cifsd: Alignment should match open parenthesis

Fix warnings "Alignment should match open parenthesis" from
checkpatch.pl --strict.
Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Steve French <stfrench@microsoft.com>

fs/cifsd/asn1.c

@@ -106,8 +106,7 @@ static bool asn1_oid_decode(const unsigned char *value, size_t vlen,
 	return false;
 }
 
-static bool
-oid_eq(unsigned long *oid1, unsigned int oid1len,
+static bool oid_eq(unsigned long *oid1, unsigned int oid1len,
 		   unsigned long *oid2, unsigned int oid2len)
 {
 	if (oid1len != oid2len)
@@ -146,10 +145,7 @@ static int compute_asn_hdr_len_bytes(int len)
 		return 0;
 }
 
-static void encode_asn_tag(char *buf,
-			   unsigned int *ofs,
-			   char tag,
-			   char seq,
+static void encode_asn_tag(char *buf, unsigned int *ofs, char tag, char seq,
 			   int length)
 {
 	int i;
@@ -252,8 +248,8 @@ int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen,
 	return 0;
 }
 
-int gssapi_this_mech(void *context, size_t hdrlen,
-		unsigned char tag, const void *value, size_t vlen)
+int gssapi_this_mech(void *context, size_t hdrlen, unsigned char tag,
+		     const void *value, size_t vlen)
 {
 	unsigned long *oid;
 	size_t oidlen;
@@ -277,8 +273,8 @@ int gssapi_this_mech(void *context, size_t hdrlen,
 	return err;
 }
 
-int neg_token_init_mech_type(void *context, size_t hdrlen,
-		unsigned char tag, const void *value, size_t vlen)
+int neg_token_init_mech_type(void *context, size_t hdrlen, unsigned char tag,
+			     const void *value, size_t vlen)
 {
 	struct ksmbd_conn *conn = context;
 	unsigned long *oid;
@@ -314,8 +310,8 @@ int neg_token_init_mech_type(void *context, size_t hdrlen,
 	return -EBADMSG;
 }
 
-int neg_token_init_mech_token(void *context, size_t hdrlen,
-		unsigned char tag, const void *value, size_t vlen)
+int neg_token_init_mech_token(void *context, size_t hdrlen, unsigned char tag,
+			      const void *value, size_t vlen)
 {
 	struct ksmbd_conn *conn = context;
 
@@ -328,8 +324,8 @@ int neg_token_init_mech_token(void *context, size_t hdrlen,
 	return 0;
 }
 
-int neg_token_targ_resp_token(void *context, size_t hdrlen,
-		unsigned char tag, const void *value, size_t vlen)
+int neg_token_targ_resp_token(void *context, size_t hdrlen, unsigned char tag,
+			      const void *value, size_t vlen)
 {
 	struct ksmbd_conn *conn = context;
 

fs/cifsd/asn1.h

@@ -10,20 +10,12 @@
 #ifndef __ASN1_H__
 #define __ASN1_H__
 
-int ksmbd_decode_negTokenInit(unsigned char *security_blob,
-			      int length,
+int ksmbd_decode_negTokenInit(unsigned char *security_blob, int length,
 			      struct ksmbd_conn *conn);
-
-int ksmbd_decode_negTokenTarg(unsigned char *security_blob,
-			      int length,
+int ksmbd_decode_negTokenTarg(unsigned char *security_blob, int length,
 			      struct ksmbd_conn *conn);
-
-int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer,
-				  u16 *buflen,
-				  char *ntlm_blob,
-				  int ntlm_blob_len);
-
-int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer,
-				   u16 *buflen,
+int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, u16 *buflen,
+				  char *ntlm_blob, int ntlm_blob_len);
+int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen,
 				   int neg_result);
 #endif /* __ASN1_H__ */

fs/cifsd/auth.c

@@ -93,8 +93,7 @@ smbhash(unsigned char *out, const unsigned char *in, unsigned char *key)
 	struct des_ctx ctx;
 
 	if (fips_enabled) {
-		ksmbd_debug(AUTH,
-			"FIPS compliance enabled: DES not permitted\n");
+		ksmbd_debug(AUTH, "FIPS compliance enabled: DES not permitted\n");
 		return -ENOENT;
 	}
 
@@ -226,15 +225,13 @@ static int ksmbd_gen_sess_key(struct ksmbd_session *sess, char *hash,
 				 hmac,
 				 SMB2_NTLMV2_SESSKEY_SIZE);
 	if (rc) {
-		ksmbd_debug(AUTH, "Could not update with response error %d\n",
-			rc);
+		ksmbd_debug(AUTH, "Could not update with response error %d\n", rc);
 		goto out;
 	}
 
 	rc = crypto_shash_final(CRYPTO_HMACMD5(ctx), sess->sess_key);
 	if (rc) {
-		ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n",
-			rc);
+		ksmbd_debug(AUTH, "Could not generate hmacmd5 hash error %d\n", rc);
 		goto out;
 	}
 
@@ -350,8 +347,7 @@ int ksmbd_auth_ntlm(struct ksmbd_session *sess, char *pw_buf)
 		return rc;
 	}
 
-	ksmbd_enc_md4(sess->sess_key,
-			user_passkey(sess->user),
+	ksmbd_enc_md4(sess->sess_key, user_passkey(sess->user),
 		      CIFS_SMB1_SESSKEY_SIZE);
 	memcpy(sess->sess_key + CIFS_SMB1_SESSKEY_SIZE, key,
 	       CIFS_AUTH_RESP_SIZE);
@@ -539,8 +535,7 @@ int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob,
 	/* process NTLMv2 authentication */
 	ksmbd_debug(AUTH, "decode_ntlmssp_authenticate_blob dname%s\n",
 		    domain_name);
-	ret = ksmbd_auth_ntlmv2(sess,
-			(struct ntlmv2_resp *)((char *)authblob + nt_off),
+	ret = ksmbd_auth_ntlmv2(sess, (struct ntlmv2_resp *)((char *)authblob + nt_off),
 				nt_len - CIFS_ENCPWD_SIZE,
 				domain_name);
 	kfree(domain_name);

fs/cifsd/auth.h

@@ -35,55 +35,30 @@ struct ksmbd_session;
 struct ksmbd_conn;
 struct kvec;
 
-int ksmbd_crypt_message(struct ksmbd_conn *conn,
-			struct kvec *iov,
-			unsigned int nvec,
-			int enc);
-
+int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
+			unsigned int nvec, int enc);
 void ksmbd_copy_gss_neg_header(void *buf);
-
-int ksmbd_auth_ntlm(struct ksmbd_session *sess,
-		    char *pw_buf);
-
-int ksmbd_auth_ntlmv2(struct ksmbd_session *sess,
-		      struct ntlmv2_resp *ntlmv2,
-		      int blen,
-		      char *domain_name);
-
+int ksmbd_auth_ntlm(struct ksmbd_session *sess, char *pw_buf);
+int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, struct ntlmv2_resp *ntlmv2,
+		      int blen, char *domain_name);
 int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob,
-				   int blob_len,
-				   struct ksmbd_session *sess);
-
+				   int blob_len, struct ksmbd_session *sess);
 int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob,
-				  int blob_len,
-				  struct ksmbd_session *sess);
-
+				  int blob_len, struct ksmbd_session *sess);
 unsigned int
 ksmbd_build_ntlmssp_challenge_blob(struct challenge_message *chgblob,
 				   struct ksmbd_session *sess);
-
-int ksmbd_krb5_authenticate(struct ksmbd_session *sess,
-			char *in_blob, int in_len,
-			char *out_blob, int *out_len);
-
-int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn,
-			char *key,
-			struct kvec *iov,
-			int n_vec,
-			char *sig);
-int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn,
-			char *key,
-			struct kvec *iov,
-			int n_vec,
-			char *sig);
-
+int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob,
+			    int in_len,	char *out_blob, int *out_len);
+int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov,
+			int n_vec, char *sig);
+int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov,
+			int n_vec, char *sig);
 int ksmbd_gen_smb30_signingkey(struct ksmbd_session *sess);
 int ksmbd_gen_smb311_signingkey(struct ksmbd_session *sess);
 int ksmbd_gen_smb30_encryptionkey(struct ksmbd_session *sess);
 int ksmbd_gen_smb311_encryptionkey(struct ksmbd_session *sess);
-
-int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn,
-				     char *buf,
+int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, char *buf,
 				     __u8 *pi_hash);
 int ksmbd_gen_sd_hash(struct ksmbd_conn *conn, char *sd_buf, int len,
 		      __u8 *pi_hash);

fs/cifsd/buffer_pool.c

@@ -251,7 +251,8 @@ int ksmbd_init_buffer_pools(void)
 		goto out;
 
 	filp_cache = kmem_cache_create("ksmbd_file_cache",
-			sizeof(struct ksmbd_file), 0, SLAB_HWCACHE_ALIGN, NULL);
+				       sizeof(struct ksmbd_file), 0,
+				       SLAB_HWCACHE_ALIGN, NULL);
 	if (!filp_cache)
 		goto out;
 

fs/cifsd/buffer_pool.h

@@ -8,12 +8,9 @@
 
 void *ksmbd_find_buffer(size_t size);
 void ksmbd_release_buffer(void *buffer);
-
 void *ksmbd_realloc_response(void *ptr, size_t old_sz, size_t new_sz);
-
 void ksmbd_free_file_struct(void *filp);
 void *ksmbd_alloc_file_struct(void);
-
 void ksmbd_destroy_buffer_pools(void);
 int ksmbd_init_buffer_pools(void);
 

fs/cifsd/connection.c

@@ -215,8 +215,8 @@ int ksmbd_conn_rdma_read(struct ksmbd_conn *conn, void *buf,
 }
 
 int ksmbd_conn_rdma_write(struct ksmbd_conn *conn, void *buf,
-		unsigned int buflen, u32 remote_key, u64 remote_offset,
-		u32 remote_len)
+			  unsigned int buflen, u32 remote_key,
+			  u64 remote_offset, u32 remote_len)
 {
 	int ret = -EINVAL;
 

fs/cifsd/connection.h

@@ -139,7 +139,6 @@ struct ksmbd_transport {
 
 bool ksmbd_conn_alive(struct ksmbd_conn *conn);
 void ksmbd_conn_wait_idle(struct ksmbd_conn *conn);
-
 struct ksmbd_conn *ksmbd_conn_alloc(void);
 void ksmbd_conn_free(struct ksmbd_conn *conn);
 bool ksmbd_conn_lookup_dialect(struct ksmbd_conn *c);
@@ -150,13 +149,10 @@ int ksmbd_conn_rdma_read(struct ksmbd_conn *conn, void *buf,
 int ksmbd_conn_rdma_write(struct ksmbd_conn *conn, void *buf,
 			  unsigned int buflen, u32 remote_key, u64 remote_offset,
 			  u32 remote_len);
-
 void ksmbd_conn_enqueue_request(struct ksmbd_work *work);
 int ksmbd_conn_try_dequeue_request(struct ksmbd_work *work);
 void ksmbd_conn_init_server_callbacks(struct ksmbd_conn_ops *ops);
-
 int ksmbd_conn_handler_loop(void *p);
-
 int ksmbd_conn_transport_init(void);
 void ksmbd_conn_transport_destroy(void);
 

fs/cifsd/crypto_ctx.h

@@ -59,7 +59,6 @@ struct ksmbd_crypto_ctx {
 #define CRYPTO_CCM(c)		((c)->ccmaes[CRYPTO_AEAD_AES_CCM])
 
 void ksmbd_release_crypto_ctx(struct ksmbd_crypto_ctx *ctx);
-
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacmd5(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacsha256(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_cmacaes(void);
@@ -67,10 +66,8 @@ struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha512(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha256(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_md4(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_md5(void);
-
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_gcm(void);
 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_ccm(void);
-
 void ksmbd_crypto_destroy(void);
 int ksmbd_crypto_create(void);
 

fs/cifsd/misc.c

@@ -267,7 +267,8 @@ char *convert_to_unix_name(struct ksmbd_share_config *share, char *name)
 }
 
 char *ksmbd_convert_dir_info_name(struct ksmbd_dir_info *d_info,
-		const struct nls_table *local_nls, int *conv_len)
+				  const struct nls_table *local_nls,
+				  int *conv_len)
 {
 	char *conv;
 	int  sz = min(4 * d_info->name_len, PATH_MAX);
@@ -280,11 +281,8 @@ char *ksmbd_convert_dir_info_name(struct ksmbd_dir_info *d_info,
 		return NULL;
 
 	/* XXX */
-	*conv_len = smbConvertToUTF16((__le16 *)conv,
-					d_info->name,
-					d_info->name_len,
-					local_nls,
-					0);
+	*conv_len = smbConvertToUTF16((__le16 *)conv, d_info->name,
+				      d_info->name_len, local_nls, 0);
 	*conv_len *= 2;
 
 	/* We allocate buffer twice bigger than needed. */

fs/cifsd/misc.h

@@ -12,32 +12,23 @@ struct kstat;
 struct ksmbd_file;
 
 int match_pattern(const char *str, size_t len, const char *pattern);
-
 int ksmbd_validate_filename(char *filename);
-
 int parse_stream_name(char *filename, char **stream_name, int *s_type);
-
 char *convert_to_nt_pathname(char *filename, char *sharepath);
-
 int get_nlink(struct kstat *st);
-
 void ksmbd_conv_path_to_unix(char *path);
 void ksmbd_strip_last_slash(char *path);
 void ksmbd_conv_path_to_windows(char *path);
-
 char *ksmbd_extract_sharename(char *treename);
-
 char *convert_to_unix_name(struct ksmbd_share_config *share, char *name);
 
 #define KSMBD_DIR_INFO_ALIGNMENT	8
-
 struct ksmbd_dir_info;
 char *ksmbd_convert_dir_info_name(struct ksmbd_dir_info *d_info,
 				  const struct nls_table *local_nls,
 				  int *conv_len);
 
 #define NTFS_TIME_OFFSET	((u64)(369 * 365 + 89) * 24 * 3600 * 10000000)
-
 struct timespec64 ksmbd_NTtimeToUnix(__le64 ntutc);
 u64 ksmbd_UnixTimeToNT(struct timespec64 t);
 long long ksmbd_systime(void);

fs/cifsd/ndr.c

@@ -235,7 +235,8 @@ static int ndr_encode_posix_acl_entry(struct ndr *n, struct xattr_smb_acl *acl)
 }
 
 int ndr_encode_posix_acl(struct ndr *n, struct inode *inode,
-		struct xattr_smb_acl *acl, struct xattr_smb_acl *def_acl)
+			 struct xattr_smb_acl *acl,
+			 struct xattr_smb_acl *def_acl)
 {
 	int ref_id = 0x00020000;
 

fs/cifsd/ndr.h

@@ -15,7 +15,8 @@ struct ndr {
 int ndr_encode_dos_attr(struct ndr *n, struct xattr_dos_attrib *da);
 int ndr_decode_dos_attr(struct ndr *n, struct xattr_dos_attrib *da);
 int ndr_encode_posix_acl(struct ndr *n, struct inode *inode,
-		struct xattr_smb_acl *acl, struct xattr_smb_acl *def_acl);
+			 struct xattr_smb_acl *acl,
+			 struct xattr_smb_acl *def_acl);
 int ndr_encode_v4_ntacl(struct ndr *n, struct xattr_ntacl *acl);
 int ndr_encode_v3_ntacl(struct ndr *n, struct xattr_ntacl *acl);
 int ndr_decode_v4_ntacl(struct ndr *n, struct xattr_ntacl *acl);

fs/cifsd/oplock.c

@@ -269,8 +269,7 @@ int opinfo_write_to_none(struct oplock_info *opinfo)
 	      opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
 		ksmbd_err("bad oplock(0x%x)\n", opinfo->level);
 		if (opinfo->is_lease)
-			ksmbd_err("lease state(0x%x)\n",
-					lease->state);
+			ksmbd_err("lease state(0x%x)\n", lease->state);
 		return -EINVAL;
 	}
 	opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
@@ -312,8 +311,7 @@ int lease_read_to_write(struct oplock_info *opinfo)
 	struct lease *lease = opinfo->o_lease;
 
 	if (!(lease->state & SMB2_LEASE_READ_CACHING_LE)) {
-		ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n",
-				lease->state);
+		ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n", lease->state);
 		return -EINVAL;
 	}
 
@@ -338,8 +336,7 @@ static int lease_none_upgrade(struct oplock_info *opinfo, __le32 new_state)
 	struct lease *lease = opinfo->o_lease;
 
 	if (!(lease->state == SMB2_LEASE_NONE_LE)) {
-		ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n",
-				lease->state);
+		ksmbd_debug(OPLOCK, "bad lease state(0x%x)\n", lease->state);
 		return -EINVAL;
 	}
 
@@ -410,8 +407,7 @@ static void grant_write_oplock(struct oplock_info *opinfo_new, int req_oplock,
 
 	if (lctx) {
 		lease->state = lctx->req_state;
-		memcpy(lease->lease_key, lctx->lease_key,
-				SMB2_LEASE_KEY_SIZE);
+		memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE);
 	}
 }
 
@@ -433,8 +429,7 @@ static void grant_read_oplock(struct oplock_info *opinfo_new,
 		lease->state = SMB2_LEASE_READ_CACHING_LE;
 		if (lctx->req_state & SMB2_LEASE_HANDLE_CACHING_LE)
 			lease->state |= SMB2_LEASE_HANDLE_CACHING_LE;
-		memcpy(lease->lease_key, lctx->lease_key,
-				SMB2_LEASE_KEY_SIZE);
+		memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE);
 	}
 }
 
@@ -454,8 +449,7 @@ static void grant_none_oplock(struct oplock_info *opinfo_new,
 
 	if (lctx) {
 		lease->state = 0;
-		memcpy(lease->lease_key, lctx->lease_key,
-			SMB2_LEASE_KEY_SIZE);
+		memcpy(lease->lease_key, lctx->lease_key, SMB2_LEASE_KEY_SIZE);
 	}
 }
 
@@ -483,7 +477,8 @@ static inline int compare_guid_key(struct oplock_info *opinfo,
  * Return:      oplock(lease) object on success, otherwise NULL
  */
 static struct oplock_info *same_client_has_lease(struct ksmbd_inode *ci,
-		char *client_guid, struct lease_ctx_info *lctx)
+						 char *client_guid,
+						 struct lease_ctx_info *lctx)
 {
 	int ret;
 	struct lease *lease;
@@ -843,7 +838,8 @@ static void wait_lease_breaking(struct oplock_info *opinfo)
 		int ret = 0;
 
 		ret = wait_event_interruptible_timeout(opinfo->oplock_brk,
-			atomic_read(&opinfo->breaking_cnt) == 0, HZ);
+						       atomic_read(&opinfo->breaking_cnt) == 0,
+						       HZ);
 		if (!ret)
 			atomic_set(&opinfo->breaking_cnt, 0);
 	}
@@ -978,15 +974,13 @@ int find_same_lease_key(struct ksmbd_session *sess, struct ksmbd_inode *ci,
 
 found:
 	rcu_read_lock();
-	list_for_each_entry_rcu(opinfo, &lb->lease_list,
-			lease_entry) {
+	list_for_each_entry_rcu(opinfo, &lb->lease_list, lease_entry) {
 		if (!atomic_inc_not_zero(&opinfo->refcount))
 			continue;
 		rcu_read_unlock();
 		if (opinfo->o_fp->f_ci == ci)
 			goto op_next;
-		err = compare_guid_key(opinfo,
-				sess->conn->ClientGUID,
+		err = compare_guid_key(opinfo, sess->conn->ClientGUID,
 				       lctx->lease_key);
 		if (err) {
 			err = -EINVAL;
@@ -1079,8 +1073,8 @@ static void set_oplock_level(struct oplock_info *opinfo, int level,
  * Return:      0 on success, otherwise error
  */
 int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, u64 pid,
-		struct ksmbd_file *fp, __u16 tid, struct lease_ctx_info *lctx,
-		int share_ret)
+		     struct ksmbd_file *fp, __u16 tid,
+		     struct lease_ctx_info *lctx, int share_ret)
 {
 	struct ksmbd_session *sess = work->sess;
 	int err = 0;
@@ -1267,8 +1261,8 @@ void smb_break_all_levII_oplock(struct ksmbd_work *work, struct ksmbd_file *fp,
 		}
 
 		/* Skip oplock being break to none */
-		if (brk_op->is_lease && (brk_op->o_lease->new_state ==
-				SMB2_LEASE_NONE_LE) &&
+		if (brk_op->is_lease &&
+		    (brk_op->o_lease->new_state == SMB2_LEASE_NONE_LE) &&
 		    atomic_read(&brk_op->breaking_cnt))
 			goto next;
 

fs/cifsd/oplock.h

@@ -100,7 +100,6 @@ int smb_grant_oplock(struct ksmbd_work *work, int req_op_level,
 		     struct lease_ctx_info *lctx, int share_ret);
 void smb_break_all_levII_oplock(struct ksmbd_work *work,
 				struct ksmbd_file *fp, int is_trunc);
-
 int opinfo_write_to_read(struct oplock_info *opinfo);
 int opinfo_read_handle_to_read(struct oplock_info *opinfo);
 int opinfo_write_to_none(struct oplock_info *opinfo);

fs/cifsd/server.c

@@ -222,8 +222,8 @@ static void __handle_ksmbd_work(struct ksmbd_work *work,
 			}
 		}
 
-		if (work->sess && (work->sess->sign ||
-		    smb3_11_final_sess_setup_resp(work) ||
+		if (work->sess &&
+		    (work->sess->sign || smb3_11_final_sess_setup_resp(work) ||
 		     conn->ops->is_sign_req(work, command)))
 			conn->ops->set_sign_rsp(work);
 	} while (is_chained_smb2_message(work));
@@ -430,12 +430,8 @@ static ssize_t stats_show(struct class *class, struct class_attribute *attr,
 		"shutdown"
 	};
 
-	ssize_t sz = scnprintf(buf,
-				PAGE_SIZE,
-				"%d %s %d %lu\n",
-				stats_version,
-				state[server_conf.state],
-				server_conf.tcp_port,
+	ssize_t sz = scnprintf(buf, PAGE_SIZE, "%d %s %d %lu\n", stats_version,
+			       state[server_conf.state], server_conf.tcp_port,
 			       server_conf.ipc_last_active / HZ);
 	return sz;
 }

fs/cifsd/smb_common.c

@@ -269,9 +269,12 @@ bool ksmbd_pdu_size_has_room(unsigned int pdu)
 }
 
 int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
-		struct ksmbd_file *dir, struct ksmbd_dir_info *d_info,
-		char *search_pattern, int (*fn)(struct ksmbd_conn *, int,
-			struct ksmbd_dir_info *, struct ksmbd_kstat *))
+				      struct ksmbd_file *dir,
+				      struct ksmbd_dir_info *d_info,
+				      char *search_pattern,
+				      int (*fn)(struct ksmbd_conn *, int,
+						struct ksmbd_dir_info *,
+						struct ksmbd_kstat *))
 {
 	int i, rc = 0;
 	struct ksmbd_conn *conn = work->conn;

fs/cifsd/smbacl.c

@@ -401,8 +401,7 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 	if (num_aces > ULONG_MAX / sizeof(struct smb_ace *))
 		return;
 
-	ppace = kmalloc_array(num_aces, sizeof(struct smb_ace *),
-			GFP_KERNEL);
+	ppace = kmalloc_array(num_aces, sizeof(struct smb_ace *), GFP_KERNEL);
 	if (!ppace)
 		return;
 
@@ -433,7 +432,8 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 			break;
 		} else if (!compare_sids(&ppace[i]->sid, pownersid)) {
 			acl_mode = access_flags_to_mode(fattr,
-				ppace[i]->access_req, ppace[i]->type);
+							ppace[i]->access_req,
+							ppace[i]->type);
 			acl_mode &= 0700;
 
 			if (!owner_found) {
@@ -445,7 +445,8 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 			   ppace[i]->sid.sub_auth[ppace[i]->sid.num_subauth - 1] ==
 			    DOMAIN_USER_RID_LE) {
 			acl_mode = access_flags_to_mode(fattr,
-				ppace[i]->access_req, ppace[i]->type);
+							ppace[i]->access_req,
+							ppace[i]->type);
 			acl_mode &= 0070;
 			if (!group_found) {
 				mode &= ~(0070);
@@ -454,7 +455,8 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 			group_found = true;
 		} else if (!compare_sids(&ppace[i]->sid, &sid_everyone)) {
 			acl_mode = access_flags_to_mode(fattr,
-				ppace[i]->access_req, ppace[i]->type);
+							ppace[i]->access_req,
+							ppace[i]->type);
 			acl_mode &= 0007;
 			if (!others_found) {
 				mode &= ~(0007);
@@ -553,7 +555,8 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 }
 
 static void set_posix_acl_entries_dacl(struct smb_ace *pndace,
-		struct smb_fattr *fattr, u32 *num_aces, u16 *size, u32 nt_aces_num)
+				       struct smb_fattr *fattr, u32 *num_aces,
+				       u16 *size, u32 nt_aces_num)
 {
 	struct posix_acl_entry *pace;
 	struct smb_sid *sid;
@@ -665,7 +668,8 @@ static void set_posix_acl_entries_dacl(struct smb_ace *pndace,
 }
 
 static void set_ntacl_dacl(struct smb_acl *pndacl, struct smb_acl *nt_dacl,
-		const struct smb_sid *pownersid, const struct smb_sid *pgrpsid,
+			   const struct smb_sid *pownersid,
+			   const struct smb_sid *pgrpsid,
 			   struct smb_fattr *fattr)
 {
 	struct smb_ace *ntace, *pndace;
@@ -831,8 +835,7 @@ int parse_sec_desc(struct smb_ntsd *pntsd, int acl_len,
 		}
 	}
 
-	if ((pntsd_type &
-	     (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ)) ==
+	if ((pntsd_type & (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ)) ==
 	    (DACL_AUTO_INHERITED | DACL_AUTO_INHERIT_REQ))
 		pntsd->type |= cpu_to_le16(DACL_AUTO_INHERITED);
 	if (pntsd_type & DACL_PROTECTED)
@@ -848,7 +851,8 @@ int parse_sec_desc(struct smb_ntsd *pntsd, int acl_len,
 
 /* Convert permission bits from mode to equivalent CIFS ACL */
 int build_sec_desc(struct smb_ntsd *pntsd, struct smb_ntsd *ppntsd,
-		int addition_info, __u32 *secdesclen, struct smb_fattr *fattr)
+		   int addition_info, __u32 *secdesclen,
+		   struct smb_fattr *fattr)
 {
 	int rc = 0;
 	__u32 offset;
@@ -1243,8 +1247,8 @@ int smb_check_perm_dacl(struct ksmbd_conn *conn, struct dentry *dentry,
 	}
 
 check_access_bits:
-	if (granted & ~(access_bits | FILE_READ_ATTRIBUTES |
-		READ_CONTROL | WRITE_DAC | DELETE)) {
+	if (granted &
+	    ~(access_bits | FILE_READ_ATTRIBUTES | READ_CONTROL | WRITE_DAC | DELETE)) {
 		ksmbd_debug(SMB, "Access denied with winACL, granted : %x, access_req : %x\n",
 			    granted, le32_to_cpu(ace->access_req));
 		rc = -EACCES;

fs/cifsd/transport_ipc.c

@@ -315,8 +315,7 @@ static int ipc_server_config_on_startup(struct ksmbd_startup_request *req)
 					req->ifc_list_sz);
 	if (ret) {
 		ksmbd_err("Server configuration error: %s %s %s\n",
-				req->netbios_name,
-				req->server_string,
+			  req->netbios_name, req->server_string,
 			  req->work_group);
 		return ret;
 	}

fs/cifsd/transport_ipc.h

@@ -23,23 +23,17 @@ ksmbd_ipc_tree_connect_request(struct ksmbd_session *sess,
 		struct ksmbd_share_config *share,
 		struct ksmbd_tree_connect *tree_conn,
 		struct sockaddr *peer_addr);
-
 int ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,
 				      unsigned long long connect_id);
 int ksmbd_ipc_logout_request(const char *account);
-
 struct ksmbd_share_config_response *
 ksmbd_ipc_share_config_request(const char *name);
-
 struct ksmbd_spnego_authen_response *
 ksmbd_ipc_spnego_authen_request(const char *spnego_blob, int blob_len);
-
 int ksmbd_ipc_id_alloc(void);
 void ksmbd_rpc_id_free(int handle);
-
 struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess, int handle);
 struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess, int handle);
-
 struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess, int handle,
 					  void *payload, size_t payload_sz);
 struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess, int handle);
@@ -47,7 +41,6 @@ struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess, int handle
 					  void *payload, size_t payload_sz);
 struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess, void *payload,
 					size_t payload_sz);
-
 void ksmbd_ipc_release(void);
 void ksmbd_ipc_soft_reset(void);
 int ksmbd_ipc_init(void);

fs/cifsd/transport_rdma.c

@@ -213,7 +213,8 @@ static void smb_direct_destroy_pools(struct smb_direct_transport *transport);
 static void smb_direct_post_recv_credits(struct work_struct *work);
 static int smb_direct_post_send_data(struct smb_direct_transport *t,
 				     struct smb_direct_send_ctx *send_ctx,
-		struct kvec *iov, int niov, int remaining_data_length);
+				     struct kvec *iov, int niov,
+				     int remaining_data_length);
 
 static inline void
 *smb_direct_recvmsg_payload(struct smb_direct_recvmsg *recvmsg)
@@ -282,7 +283,8 @@ static void put_empty_recvmsg(struct smb_direct_transport *t,
 }
 
 static void enqueue_reassembly(struct smb_direct_transport *t,
-		struct smb_direct_recvmsg *recvmsg, int data_length)
+			       struct smb_direct_recvmsg *recvmsg,
+			       int data_length)
 {
 	spin_lock(&t->reassembly_queue_lock);
 	list_add_tail(&recvmsg->list, &t->reassembly_queue);
@@ -752,7 +754,8 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 
 	ksmbd_debug(RDMA, "wait_event on more data\n");
 	rc = wait_event_interruptible(st->wait_reassembly_queue,
-		st->reassembly_data_length >= size || st->status != SMB_DIRECT_CS_CONNECTED);
+				      st->reassembly_data_length >= size ||
+				       st->status != SMB_DIRECT_CS_CONNECTED);
 	if (rc)
 		return -EINTR;
 
@@ -893,7 +896,8 @@ static int smb_direct_post_send(struct smb_direct_transport *t,
 
 static void smb_direct_send_ctx_init(struct smb_direct_transport *t,
 				     struct smb_direct_send_ctx *send_ctx,
-		bool need_invalidate_rkey, unsigned int remote_key)
+				     bool need_invalidate_rkey,
+				     unsigned int remote_key)
 {
 	INIT_LIST_HEAD(&send_ctx->msg_list);
 	send_ctx->wr_cnt = 0;
@@ -902,7 +906,8 @@ static void smb_direct_send_ctx_init(struct smb_direct_transport *t,
 }
 
 static int smb_direct_flush_send_list(struct smb_direct_transport *t,
-		struct smb_direct_send_ctx *send_ctx, bool is_last)
+				      struct smb_direct_send_ctx *send_ctx,
+				      bool is_last)
 {
 	struct smb_direct_sendmsg *first, *last;
 	int ret;
@@ -927,7 +932,8 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 	ret = smb_direct_post_send(t, &first->wr);
 	if (!ret) {
 		smb_direct_send_ctx_init(t, send_ctx,
-			send_ctx->need_invalidate_rkey, send_ctx->remote_key);
+					 send_ctx->need_invalidate_rkey,
+					 send_ctx->remote_key);
 	} else {
 		atomic_add(send_ctx->wr_cnt, &t->send_credits);
 		wake_up(&t->wait_send_credits);
@@ -965,8 +971,8 @@ static int wait_for_send_credits(struct smb_direct_transport *t,
 {
 	int ret;
 
-	if (send_ctx && (send_ctx->wr_cnt >= 16 ||
-			 atomic_read(&t->send_credits) <= 1)) {
+	if (send_ctx &&
+	    (send_ctx->wr_cnt >= 16 || atomic_read(&t->send_credits) <= 1)) {
 		ret = smb_direct_flush_send_list(t, send_ctx, false);
 		if (ret)
 			return ret;
@@ -1120,7 +1126,8 @@ static int post_sendmsg(struct smb_direct_transport *t,
 
 static int smb_direct_post_send_data(struct smb_direct_transport *t,
 				     struct smb_direct_send_ctx *send_ctx,
-		struct kvec *iov, int niov, int remaining_data_length)
+				     struct kvec *iov, int niov,
+				     int remaining_data_length)
 {
 	int i, j, ret;
 	struct smb_direct_sendmsg *msg;
@@ -1149,7 +1156,8 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 		sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES - 1);
 		sg_cnt = get_mapped_sg_list(t->cm_id->device,
 					    iov[i].iov_base, iov[i].iov_len,
-				sg, SMB_DIRECT_MAX_SEND_SGES - 1, DMA_TO_DEVICE);
+					    sg, SMB_DIRECT_MAX_SEND_SGES - 1,
+					    DMA_TO_DEVICE);
 		if (sg_cnt <= 0) {
 			ksmbd_err("failed to map buffer\n");
 			ret = -ENOMEM;
@@ -1234,8 +1242,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 						min_t(int, max_iov_size,
 						      buflen - max_iov_size * j);
 					remaining_data_length -= vec.iov_len;
-					ret = smb_direct_post_send_data(st,
-						&send_ctx, &vec, 1,
+					ret = smb_direct_post_send_data(st, &send_ctx, &vec, 1,
 									remaining_data_length);
 					if (ret)
 						goto done;
@@ -1310,8 +1317,8 @@ static void write_done(struct ib_cq *cq, struct ib_wc *wc)
 }
 
 static int smb_direct_rdma_xmit(struct smb_direct_transport *t, void *buf,
-		int buf_len, u32 remote_key, u64 remote_offset, u32 remote_len,
-		bool is_read)
+				int buf_len, u32 remote_key, u64 remote_offset,
+				u32 remote_len, bool is_read)
 {
 	struct smb_direct_rdma_rw_msg *msg;
 	int ret;
@@ -1382,8 +1389,8 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t, void *buf,
 }
 
 static int smb_direct_rdma_write(struct ksmbd_transport *t, void *buf,
-		unsigned int buflen, u32 remote_key, u64 remote_offset,
-		u32 remote_len)
+				 unsigned int buflen, u32 remote_key,
+				 u64 remote_offset, u32 remote_len)
 {
 	return smb_direct_rdma_xmit(SMB_DIRECT_TRANS(t), buf, buflen,
 				    remote_key, remote_offset,
@@ -1391,8 +1398,8 @@ static int smb_direct_rdma_write(struct ksmbd_transport *t, void *buf,
 }
 
 static int smb_direct_rdma_read(struct ksmbd_transport *t, void *buf,
-		unsigned int buflen, u32 remote_key, u64 remote_offset,
-		u32 remote_len)
+				unsigned int buflen, u32 remote_key,
+				u64 remote_offset, u32 remote_len)
 {
 	return smb_direct_rdma_xmit(SMB_DIRECT_TRANS(t), buf, buflen,
 				    remote_key, remote_offset,
@@ -1498,9 +1505,9 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 	}
 
 	sendmsg->sge[0].addr = ib_dma_map_single(t->cm_id->device,
-				(void *)resp, sizeof(*resp), DMA_TO_DEVICE);
-	ret = ib_dma_mapping_error(t->cm_id->device,
-				sendmsg->sge[0].addr);
+						 (void *)resp, sizeof(*resp),
+						 DMA_TO_DEVICE);
+	ret = ib_dma_mapping_error(t->cm_id->device, sendmsg->sge[0].addr);
 	if (ret) {
 		smb_direct_free_sendmsg(t, sendmsg);
 		return ret;
@@ -1529,13 +1536,13 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 	int ret;
 
 	memset(&conn_param, 0, sizeof(conn_param));
-	conn_param.initiator_depth = min_t(u8,
-				t->cm_id->device->attrs.max_qp_rd_atom,
+	conn_param.initiator_depth = min_t(u8, t->cm_id->device->attrs.max_qp_rd_atom,
 					   SMB_DIRECT_CM_INITIATOR_DEPTH);
 	conn_param.responder_resources = 0;
 
 	t->cm_id->device->ops.get_port_immutable(t->cm_id->device,
-			t->cm_id->port_num, &port_immutable);
+						 t->cm_id->port_num,
+						 &port_immutable);
 	if (port_immutable.core_cap_flags & RDMA_CORE_PORT_IWARP) {
 		ird_ord_hdr[0] = conn_param.responder_resources;
 		ird_ord_hdr[1] = 1;
@@ -1906,7 +1913,8 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id)
 		return -ENOMEM;
 
 	KSMBD_TRANS(t)->handler = kthread_run(ksmbd_conn_handler_loop,
-			KSMBD_TRANS(t)->conn, "ksmbd:r%u", SMB_DIRECT_PORT);
+					      KSMBD_TRANS(t)->conn, "ksmbd:r%u",
+					      SMB_DIRECT_PORT);
 	if (IS_ERR(KSMBD_TRANS(t)->handler)) {
 		int ret = PTR_ERR(KSMBD_TRANS(t)->handler);
 
@@ -1936,8 +1944,7 @@ static int smb_direct_listen_handler(struct rdma_cm_id *cm_id,
 	}
 	default:
 		ksmbd_err("Unexpected listen event. cm_id=%p, event=%s (%d)\n",
-				cm_id,
-				rdma_event_msg(event->event), event->event);
+			  cm_id, rdma_event_msg(event->event), event->event);
 		break;
 	}
 	return 0;
@@ -1956,8 +1963,7 @@ static int smb_direct_listen(int port)
 	cm_id = rdma_create_id(&init_net, smb_direct_listen_handler,
 			       &smb_direct_listener, RDMA_PS_TCP, IB_QPT_RC);
 	if (IS_ERR(cm_id)) {
-		ksmbd_err("Can't create cm id: %ld\n",
-				PTR_ERR(cm_id));
+		ksmbd_err("Can't create cm id: %ld\n", PTR_ERR(cm_id));
 		return PTR_ERR(cm_id);
 	}
 

fs/cifsd/transport_tcp.c

@@ -198,7 +198,8 @@ static int ksmbd_tcp_new_connection(struct socket *client_sk)
 
 	KSMBD_TRANS(t)->handler = kthread_run(ksmbd_conn_handler_loop,
 					      KSMBD_TRANS(t)->conn,
-					"ksmbd:%u", ksmbd_tcp_get_port(csin));
+					      "ksmbd:%u",
+					      ksmbd_tcp_get_port(csin));
 	if (IS_ERR(KSMBD_TRANS(t)->handler)) {
 		ksmbd_err("cannot start conn thread\n");
 		rc = PTR_ERR(KSMBD_TRANS(t)->handler);
@@ -265,8 +266,8 @@ static int ksmbd_tcp_run_kthread(struct interface *iface)
 	int rc;
 	struct task_struct *kthread;
 
-	kthread = kthread_run(ksmbd_kthread_fn, (void *)iface,
-		"ksmbd-%s", iface->name);
+	kthread = kthread_run(ksmbd_kthread_fn, (void *)iface, "ksmbd-%s",
+			      iface->name);
 	if (IS_ERR(kthread)) {
 		rc = PTR_ERR(kthread);
 		return rc;
@@ -353,7 +354,8 @@ static int ksmbd_tcp_read(struct ksmbd_transport *t, char *buf, unsigned int to_
 }
 
 static int ksmbd_tcp_writev(struct ksmbd_transport *t, struct kvec *iov,
-		int nvecs, int size, bool need_invalidate, unsigned int remote_key)
+			    int nvecs, int size, bool need_invalidate,
+			    unsigned int remote_key)
 
 {
 	struct msghdr smb_msg = {.msg_flags = MSG_NOSIGNAL};

fs/cifsd/unicode.c

@@ -267,7 +267,8 @@ int smb_strtoUTF16(__le16 *to, const char *from, int len,
  * Return:	destination string buffer or error ptr
  */
 char *smb_strndup_from_utf16(const char *src, const int maxlen,
-		const bool is_unicode, const struct nls_table *codepage)
+			     const bool is_unicode,
+			     const struct nls_table *codepage)
 {
 	int len, ret;
 	char *dst;

fs/cifsd/unicode.h

@@ -65,7 +65,8 @@ extern const struct UniCaseRange CifsUniLowerRange[];
 int smb_strtoUTF16(__le16 *to, const char *from, int len,
 		   const struct nls_table *codepage);
 char *smb_strndup_from_utf16(const char *src, const int maxlen,
-		const bool is_unicode, const struct nls_table *codepage);
+			     const bool is_unicode,
+			     const struct nls_table *codepage);
 int smbConvertToUTF16(__le16 *target, const char *source, int srclen,
 		      const struct nls_table *cp, int mapchars);
 char *ksmbd_extract_sharename(char *treename);
@@ -198,7 +199,7 @@ static inline int UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
 /*
  * UniStrncmp_le:  Compare length limited string - native to little-endian
  */
-	static inline int
+static inline int
 UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
 {
 	if (!n)

fs/cifsd/vfs.c

@@ -52,7 +52,8 @@ static char *extract_last_component(char *path)
 }
 
 static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work,
-		struct inode *parent_inode, struct inode *inode)
+				    struct inode *parent_inode,
+				    struct inode *inode)
 {
 	if (!test_share_config_flag(work->tcon->share_conf,
 				    KSMBD_SHARE_FLAG_INHERIT_OWNER))
@@ -217,8 +218,7 @@ int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
 	} else if (d_unhashed(dentry)) {
 		struct dentry *d;
 
-		d = lookup_one_len(dentry->d_name.name,
-			       dentry->d_parent,
+		d = lookup_one_len(dentry->d_name.name, dentry->d_parent,
 				   dentry->d_name.len);
 		if (IS_ERR(d)) {
 			err = PTR_ERR(d);
@@ -230,8 +230,7 @@ int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
 			goto out;
 		}
 
-		ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),
-			d_inode(d));
+		ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(d));
 		dput(d);
 	}
 out:
@@ -377,8 +376,7 @@ int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
 	if (!work->tcon->posix_extensions) {
 		int ret;
 
-		ret = check_lock_range(filp, *pos, *pos + count - 1,
-				READ);
+		ret = check_lock_range(filp, *pos, *pos + count - 1, READ);
 		if (ret) {
 			ksmbd_err("unable to read due to lock\n");
 			return -EAGAIN;
@@ -676,8 +674,10 @@ int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
 }
 
 static int __ksmbd_vfs_rename(struct ksmbd_work *work,
-		struct dentry *src_dent_parent, struct dentry *src_dent,
-		struct dentry *dst_dent_parent, struct dentry *trap_dent,
+			      struct dentry *src_dent_parent,
+			      struct dentry *src_dent,
+			      struct dentry *dst_dent_parent,
+			      struct dentry *trap_dent,
 			      char *dst_name)
 {
 	struct dentry *dst_dent;
@@ -988,8 +988,7 @@ void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option)
  *
  * Return:	0 on success, otherwise error
  */
-int ksmbd_vfs_lock(struct file *filp, int cmd,
-			struct file_lock *flock)
+int ksmbd_vfs_lock(struct file *filp, int cmd, struct file_lock *flock)
 {
 	ksmbd_debug(VFS, "calling vfs_lock_file\n");
 	return vfs_lock_file(filp, cmd, flock, NULL);
@@ -1013,7 +1012,8 @@ int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp,
 	smb_break_all_levII_oplock(work, fp, 1);
 	if (fp->f_ci->m_fattr & ATTR_SPARSE_FILE_LE)
 		return vfs_fallocate(fp->filp,
-			FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, off, len);
+				     FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
+				     off, len);
 
 	return vfs_fallocate(fp->filp, FALLOC_FL_ZERO_RANGE, off, len);
 }
@@ -1087,8 +1087,7 @@ int ksmbd_vfs_unlink(struct dentry *dir, struct dentry *dentry)
 
 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
 	dget(dentry);
-	child = lookup_one_len(dentry->d_name.name, dir,
-			dentry->d_name.len);
+	child = lookup_one_len(dentry->d_name.name, dir, dentry->d_name.len);
 	if (IS_ERR(child)) {
 		err = PTR_ERR(child);
 		goto out;
@@ -1206,7 +1205,8 @@ int ksmbd_vfs_empty_dir(struct ksmbd_file *fp)
 }
 
 static int __caseless_lookup(struct dir_context *ctx, const char *name,
-		int namlen, loff_t offset, u64 ino, unsigned int d_type)
+			     int namlen, loff_t offset, u64 ino,
+			     unsigned int d_type)
 {
 	struct ksmbd_readdir_data *buf;
 
@@ -1596,11 +1596,8 @@ int ksmbd_vfs_set_dos_attrib_xattr(struct dentry *dentry,
 	if (err)
 		return err;
 
-	err = ksmbd_vfs_setxattr(dentry,
-			XATTR_NAME_DOS_ATTRIBUTE,
-			(void *)n.data,
-			n.offset,
-			0);
+	err = ksmbd_vfs_setxattr(dentry, XATTR_NAME_DOS_ATTRIBUTE,
+				 (void *)n.data, n.offset, 0);
 	if (err)
 		ksmbd_debug(SMB, "failed to store dos attribute in xattr\n");
 	kfree(n.data);
@@ -1614,8 +1611,7 @@ int ksmbd_vfs_get_dos_attrib_xattr(struct dentry *dentry,
 	struct ndr n;
 	int err;
 
-	err = ksmbd_vfs_getxattr(dentry,
-			XATTR_NAME_DOS_ATTRIBUTE,
+	err = ksmbd_vfs_getxattr(dentry, XATTR_NAME_DOS_ATTRIBUTE,
 				 (char **)&n.data);
 	if (err > 0) {
 		n.length = err;
@@ -1771,14 +1767,11 @@ int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
 	if (!xattr_stream_name_buf)
 		return -ENOMEM;
 
-	memcpy(xattr_stream_name_buf,
-		XATTR_NAME_STREAM,
-		XATTR_NAME_STREAM_LEN);
+	memcpy(xattr_stream_name_buf, XATTR_NAME_STREAM, XATTR_NAME_STREAM_LEN);
 
 	if (stream_name_size) {
 		memcpy(&xattr_stream_name_buf[XATTR_NAME_STREAM_LEN],
-			stream_name,
-			stream_name_size);
+		       stream_name, stream_name_size);
 	}
 	memcpy(&xattr_stream_name_buf[*xattr_stream_name_size - 1], type, type_len);
 		*xattr_stream_name_size += type_len;
@@ -1836,10 +1829,13 @@ int ksmbd_vfs_copy_file_range(struct file *file_in, loff_t pos_in,
 }
 
 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
-		struct ksmbd_file *src_fp, struct ksmbd_file *dst_fp,
-		struct srv_copychunk *chunks, unsigned int chunk_count,
+			       struct ksmbd_file *src_fp,
+			       struct ksmbd_file *dst_fp,
+			       struct srv_copychunk *chunks,
+			       unsigned int chunk_count,
 			       unsigned int *chunk_count_written,
-		unsigned int *chunk_size_written, loff_t *total_size_written)
+			       unsigned int *chunk_size_written,
+			       loff_t *total_size_written)
 {
 	unsigned int i;
 	loff_t src_off, dst_off, src_file_size;

fs/cifsd/vfs.h

@@ -205,21 +205,22 @@ int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name);
 int ksmbd_vfs_link(struct ksmbd_work *work,
 		   const char *oldname, const char *newname);
 int ksmbd_vfs_getattr(struct path *path, struct kstat *stat);
-
 int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
 			char *newname);
-
 int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name,
 		       struct ksmbd_file *fp, loff_t size);
-
 struct srv_copychunk;
 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
-		struct ksmbd_file *src_fp, struct ksmbd_file *dst_fp,
-		struct srv_copychunk *chunks, unsigned int chunk_count,
+			       struct ksmbd_file *src_fp,
+			       struct ksmbd_file *dst_fp,
+			       struct srv_copychunk *chunks,
+			       unsigned int chunk_count,
 			       unsigned int *chunk_count_written,
-		unsigned int *chunk_size_written, loff_t  *total_size_written);
+			       unsigned int *chunk_size_written,
+			       loff_t  *total_size_written);
 int ksmbd_vfs_copy_file_range(struct file *file_in, loff_t pos_in,
-		struct file *file_out, loff_t pos_out, size_t len);
+			      struct file *file_out, loff_t pos_out,
+			      size_t len);
 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list);
 ssize_t ksmbd_vfs_getxattr(struct dentry *dentry, char *xattr_name,
 			   char **xattr_buf);

fs/cifsd/vfs_cache.c

@@ -577,8 +577,10 @@ struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp)
 }
 
 static int
-__close_file_table_ids(struct ksmbd_file_table *ft, struct ksmbd_tree_connect *tcon,
-		bool (*skip)(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp))
+__close_file_table_ids(struct ksmbd_file_table *ft,
+		       struct ksmbd_tree_connect *tcon,
+		       bool (*skip)(struct ksmbd_tree_connect *tcon,
+				    struct ksmbd_file *fp))
 {
 	unsigned int			id;
 	struct ksmbd_file		*fp;