ksmbd: remove ksmbd_err/info

Use the pr_fmt built into pr_*. and use pr_err/info after removing
wrapper ksmbd_err/info.
Reviewed-by: NChristoph Hellwig <hch@lst.de>
Signed-off-by: NNamjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: NSteve French <stfrench@microsoft.com>

fs/cifsd/auth.c

@@ -342,7 +342,7 @@ int ksmbd_auth_ntlm(struct ksmbd_session *sess, char *pw_buf)
 	memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE);
 	rc = ksmbd_enc_p24(p21, sess->ntlmssp.cryptkey, key);
 	if (rc) {
-		ksmbd_err("password processing failed\n");
+		pr_err("password processing failed\n");
 		return rc;
 	}
 
@@ -461,7 +461,7 @@ static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess, char *client_nonce,
 				       client_nonce,
 				       (char *)sess->ntlmssp.cryptkey, 8);
 	if (rc) {
-		ksmbd_err("password processing failed\n");
+		pr_err("password processing failed\n");
 		goto out;
 	}
 
@@ -469,7 +469,7 @@ static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess, char *client_nonce,
 	memcpy(p21, user_passkey(sess->user), CIFS_NTHASH_SIZE);
 	rc = ksmbd_enc_p24(p21, sess_key, key);
 	if (rc) {
-		ksmbd_err("password processing failed\n");
+		pr_err("password processing failed\n");
 		goto out;
 	}
 
@@ -1269,7 +1269,7 @@ int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
 				      enc,
 				      key);
 	if (rc) {
-		ksmbd_err("Could not get %scryption key\n", enc ? "en" : "de");
+		pr_err("Could not get %scryption key\n", enc ? "en" : "de");
 		return rc;
 	}
 
@@ -1279,7 +1279,7 @@ int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
 	else
 		ctx = ksmbd_crypto_ctx_find_ccm();
 	if (!ctx) {
-		ksmbd_err("crypto alloc failed\n");
+		pr_err("crypto alloc failed\n");
 		return -ENOMEM;
 	}
 
@@ -1295,19 +1295,18 @@ int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
 	else
 		rc = crypto_aead_setkey(tfm, key, SMB3_GCM128_CRYPTKEY_SIZE);
 	if (rc) {
-		ksmbd_err("Failed to set aead key %d\n", rc);
+		pr_err("Failed to set aead key %d\n", rc);
 		goto free_ctx;
 	}
 
 	rc = crypto_aead_setauthsize(tfm, SMB2_SIGNATURE_SIZE);
 	if (rc) {
-		ksmbd_err("Failed to set authsize %d\n", rc);
+		pr_err("Failed to set authsize %d\n", rc);
 		goto free_ctx;
 	}
 
 	req = aead_request_alloc(tfm, GFP_KERNEL);
 	if (!req) {
-		ksmbd_err("Failed to alloc aead request\n");
 		rc = -ENOMEM;
 		goto free_ctx;
 	}
@@ -1319,7 +1318,7 @@ int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
 
 	sg = ksmbd_init_sg(iov, nvec, sign);
 	if (!sg) {
-		ksmbd_err("Failed to init sg\n");
+		pr_err("Failed to init sg\n");
 		rc = -ENOMEM;
 		goto free_req;
 	}
@@ -1327,7 +1326,6 @@ int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
 	iv_len = crypto_aead_ivsize(tfm);
 	iv = kzalloc(iv_len, GFP_KERNEL);
 	if (!iv) {
-		ksmbd_err("Failed to alloc IV\n");
 		rc = -ENOMEM;
 		goto free_sg;
 	}

fs/cifsd/connection.c

@@ -160,7 +160,7 @@ int ksmbd_conn_write(struct ksmbd_work *work)
 
 	ksmbd_conn_try_dequeue_request(work);
 	if (!rsp_hdr) {
-		ksmbd_err("NULL response header\n");
+		pr_err("NULL response header\n");
 		return -EINVAL;
 	}
 
@@ -192,7 +192,7 @@ int ksmbd_conn_write(struct ksmbd_work *work)
 	ksmbd_conn_unlock(conn);
 
 	if (sent < 0) {
-		ksmbd_err("Failed to send message: %d\n", sent);
+		pr_err("Failed to send message: %d\n", sent);
 		return sent;
 	}
 
@@ -315,24 +315,23 @@ int ksmbd_conn_handler_loop(void *p)
 		 */
 		size = t->ops->read(t, conn->request_buf + 4, pdu_size);
 		if (size < 0) {
-			ksmbd_err("sock_read failed: %d\n", size);
+			pr_err("sock_read failed: %d\n", size);
 			break;
 		}
 
 		if (size != pdu_size) {
-			ksmbd_err("PDU error. Read: %d, Expected: %d\n",
-				  size,
-				  pdu_size);
+			pr_err("PDU error. Read: %d, Expected: %d\n",
+			       size, pdu_size);
 			continue;
 		}
 
 		if (!default_conn_ops.process_fn) {
-			ksmbd_err("No connection request callback\n");
+			pr_err("No connection request callback\n");
 			break;
 		}
 
 		if (default_conn_ops.process_fn(conn)) {
-			ksmbd_err("Cannot handle request\n");
+			pr_err("Cannot handle request\n");
 			break;
 		}
 	}

fs/cifsd/crypto_ctx.c

@@ -48,12 +48,12 @@ static struct crypto_aead *alloc_aead(int id)
 		tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
 		break;
 	default:
-		ksmbd_err("Does not support encrypt ahead(id : %d)\n", id);
+		pr_err("Does not support encrypt ahead(id : %d)\n", id);
 		return NULL;
 	}
 
 	if (IS_ERR(tfm)) {
-		ksmbd_err("Failed to alloc encrypt aead : %ld\n", PTR_ERR(tfm));
+		pr_err("Failed to alloc encrypt aead : %ld\n", PTR_ERR(tfm));
 		return NULL;
 	}
 

fs/cifsd/glob.h

@@ -31,32 +31,22 @@ extern int ksmbd_debug_types;
 				KSMBD_DEBUG_IPC | KSMBD_DEBUG_CONN |	\
 				KSMBD_DEBUG_RDMA)
 
-#ifndef ksmbd_pr_fmt
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
 #ifdef SUBMOD_NAME
-#define ksmbd_pr_fmt(fmt)	"ksmbd: " SUBMOD_NAME ": " fmt
+#define pr_fmt(fmt)	"ksmbd: " SUBMOD_NAME ": " fmt
 #else
-#define ksmbd_pr_fmt(fmt)	"ksmbd: " fmt
-#endif
+#define pr_fmt(fmt)	"ksmbd: " fmt
 #endif
 
 #define ksmbd_debug(type, fmt, ...)				\
 	do {							\
 		if (ksmbd_debug_types & KSMBD_DEBUG_##type)	\
-			pr_info(ksmbd_pr_fmt("%s:%d: " fmt),	\
-				__func__,			\
-				__LINE__,			\
-				##__VA_ARGS__);			\
+			pr_info(fmt, ##__VA_ARGS__);		\
 	} while (0)
 
-#define ksmbd_info(fmt, ...)					\
-			pr_info(ksmbd_pr_fmt(fmt), ##__VA_ARGS__)
-
-#define ksmbd_err(fmt, ...)					\
-			pr_err(ksmbd_pr_fmt("%s:%d: " fmt),	\
-				__func__,			\
-				__LINE__,			\
-				##__VA_ARGS__)
-
 #define UNICODE_LEN(x)		((x) * 2)
 
 #endif /* __KSMBD_GLOB_H */

fs/cifsd/mgmt/user_session.c

@@ -87,7 +87,7 @@ static int __rpc_method(char *rpc_name)
 	if (!strcmp(rpc_name, "\\lsarpc") || !strcmp(rpc_name, "lsarpc"))
 		return KSMBD_RPC_LSARPC_METHOD_INVOKE;
 
-	ksmbd_err("Unsupported RPC: %s\n", rpc_name);
+	pr_err("Unsupported RPC: %s\n", rpc_name);
 	return 0;
 }
 
@@ -232,7 +232,7 @@ int get_session(struct ksmbd_session *sess)
 void put_session(struct ksmbd_session *sess)
 {
 	if (atomic_dec_and_test(&sess->refcnt))
-		ksmbd_err("get/%s seems to be mismatched.", __func__);
+		pr_err("get/%s seems to be mismatched.", __func__);
 }
 
 struct ksmbd_session *ksmbd_session_lookup_slowpath(unsigned long long id)

fs/cifsd/misc.c

@@ -107,7 +107,7 @@ static int ksmbd_validate_stream_name(char *stream_name)
 
 		stream_name++;
 		if (c == '/' || c == ':' || c == '\\') {
-			ksmbd_err("Stream name validation failed: %c\n", c);
+			pr_err("Stream name validation failed: %c\n", c);
 			return -ENOENT;
 		}
 	}

fs/cifsd/ndr.c

@@ -178,14 +178,14 @@ int ndr_decode_dos_attr(struct ndr *n, struct xattr_dos_attrib *da)
 	da->version = ndr_read_int16(n);
 
 	if (da->version != 3 && da->version != 4) {
-		ksmbd_err("v%d version is not supported\n", da->version);
+		pr_err("v%d version is not supported\n", da->version);
 		return -EINVAL;
 	}
 
 	version2 = ndr_read_int32(n);
 	if (da->version != version2) {
-		ksmbd_err("ndr version mismatched(version: %d, version2: %d)\n",
-			  da->version, version2);
+		pr_err("ndr version mismatched(version: %d, version2: %d)\n",
+		       da->version, version2);
 		return -EINVAL;
 	}
 
@@ -309,14 +309,14 @@ int ndr_decode_v4_ntacl(struct ndr *n, struct xattr_ntacl *acl)
 	n->offset = 0;
 	acl->version = ndr_read_int16(n);
 	if (acl->version != 4) {
-		ksmbd_err("v%d version is not supported\n", acl->version);
+		pr_err("v%d version is not supported\n", acl->version);
 		return -EINVAL;
 	}
 
 	version2 = ndr_read_int32(n);
 	if (acl->version != version2) {
-		ksmbd_err("ndr version mismatched(version: %d, version2: %d)\n",
-			  acl->version, version2);
+		pr_err("ndr version mismatched(version: %d, version2: %d)\n",
+		       acl->version, version2);
 		return -EINVAL;
 	}
 
@@ -329,7 +329,7 @@ int ndr_decode_v4_ntacl(struct ndr *n, struct xattr_ntacl *acl)
 
 	ndr_read_bytes(n, acl->desc, 10);
 	if (strncmp(acl->desc, "posix_acl", 9)) {
-		ksmbd_err("Invalid acl description : %s\n", acl->desc);
+		pr_err("Invalid acl description : %s\n", acl->desc);
 		return -EINVAL;
 	}
 

fs/cifsd/oplock.c

@@ -230,9 +230,9 @@ int opinfo_write_to_read(struct oplock_info *opinfo)
 
 	if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
 	      opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
-		ksmbd_err("bad oplock(0x%x)\n", opinfo->level);
+		pr_err("bad oplock(0x%x)\n", opinfo->level);
 		if (opinfo->is_lease)
-			ksmbd_err("lease state(0x%x)\n", lease->state);
+			pr_err("lease state(0x%x)\n", lease->state);
 		return -EINVAL;
 	}
 	opinfo->level = SMB2_OPLOCK_LEVEL_II;
@@ -269,9 +269,9 @@ int opinfo_write_to_none(struct oplock_info *opinfo)
 
 	if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
 	      opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
-		ksmbd_err("bad oplock(0x%x)\n", opinfo->level);
+		pr_err("bad oplock(0x%x)\n", opinfo->level);
 		if (opinfo->is_lease)
-			ksmbd_err("lease state(0x%x)\n", lease->state);
+			pr_err("lease state(0x%x)\n", lease->state);
 		return -EINVAL;
 	}
 	opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
@@ -291,9 +291,9 @@ int opinfo_read_to_none(struct oplock_info *opinfo)
 	struct lease *lease = opinfo->o_lease;
 
 	if (opinfo->level != SMB2_OPLOCK_LEVEL_II) {
-		ksmbd_err("bad oplock(0x%x)\n", opinfo->level);
+		pr_err("bad oplock(0x%x)\n", opinfo->level);
 		if (opinfo->is_lease)
-			ksmbd_err("lease state(0x%x)\n", lease->state);
+			pr_err("lease state(0x%x)\n", lease->state);
 		return -EINVAL;
 	}
 	opinfo->level = SMB2_OPLOCK_LEVEL_NONE;
@@ -622,7 +622,7 @@ static void __smb2_oplock_break_noti(struct work_struct *wk)
 	}
 
 	if (allocate_oplock_break_buf(work)) {
-		ksmbd_err("smb2_allocate_rsp_buf failed! ");
+		pr_err("smb2_allocate_rsp_buf failed! ");
 		atomic_dec(&conn->r_count);
 		ksmbd_fd_put(work, fp);
 		ksmbd_free_work_struct(work);
@@ -1680,18 +1680,18 @@ int smb2_check_durable_oplock(struct ksmbd_file *fp,
 
 	if (opinfo && opinfo->is_lease) {
 		if (!lctx) {
-			ksmbd_err("open does not include lease\n");
+			pr_err("open does not include lease\n");
 			ret = -EBADF;
 			goto out;
 		}
 		if (memcmp(opinfo->o_lease->lease_key, lctx->lease_key,
 			   SMB2_LEASE_KEY_SIZE)) {
-			ksmbd_err("invalid lease key\n");
+			pr_err("invalid lease key\n");
 			ret = -EBADF;
 			goto out;
 		}
 		if (name && strcmp(fp->filename, name)) {
-			ksmbd_err("invalid name reconnect %s\n", name);
+			pr_err("invalid name reconnect %s\n", name);
 			ret = -EINVAL;
 			goto out;
 		}

fs/cifsd/server.c

@@ -277,7 +277,7 @@ static int queue_ksmbd_work(struct ksmbd_conn *conn)
 
 	work = ksmbd_alloc_work_struct();
 	if (!work) {
-		ksmbd_err("allocation for work failed\n");
+		pr_err("allocation for work failed\n");
 		return -ENOMEM;
 	}
 
@@ -442,7 +442,7 @@ static ssize_t kill_server_store(struct class *class,
 	if (!sysfs_streq(buf, "hard"))
 		return len;
 
-	ksmbd_info("kill command received\n");
+	pr_info("kill command received\n");
 	mutex_lock(&ctrl_lock);
 	WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
 	__module_get(THIS_MODULE);
@@ -547,7 +547,7 @@ static int __init ksmbd_server_init(void)
 
 	ret = class_register(&ksmbd_control_class);
 	if (ret) {
-		ksmbd_err("Unable to register ksmbd-control class\n");
+		pr_err("Unable to register ksmbd-control class\n");
 		return ret;
 	}
 

fs/cifsd/smb2misc.c

@@ -320,12 +320,12 @@ static int smb2_validate_credit_charge(struct smb2_hdr *hdr)
 	max_len = max(req_len, expect_resp_len);
 	calc_credit_num = DIV_ROUND_UP(max_len, SMB2_MAX_BUFFER_SIZE);
 	if (!credit_charge && max_len > SMB2_MAX_BUFFER_SIZE) {
-		ksmbd_err("credit charge is zero and payload size(%d) is bigger than 64K\n",
-			  max_len);
+		pr_err("credit charge is zero and payload size(%d) is bigger than 64K\n",
+		       max_len);
 		return 1;
 	} else if (credit_charge < calc_credit_num) {
-		ksmbd_err("credit charge : %d, calc_credit_num : %d\n",
-			  credit_charge, calc_credit_num);
+		pr_err("credit charge : %d, calc_credit_num : %d\n",
+		       credit_charge, calc_credit_num);
 		return 1;
 	}
 

fs/cifsd/smb_common.c

@@ -447,7 +447,7 @@ int ksmbd_smb_negotiate_common(struct ksmbd_work *work, unsigned int command)
 		return smb_handle_negotiate(work);
 	}
 
-	ksmbd_err("Unknown SMB negotiation command: %u\n", command);
+	pr_err("Unknown SMB negotiation command: %u\n", command);
 	return -EINVAL;
 }
 

fs/cifsd/smbacl.c

@@ -264,8 +264,8 @@ static int sid_to_id(struct smb_sid *psid, uint sidtype,
 	 * Just return an error.
 	 */
 	if (unlikely(psid->num_subauth > SID_MAX_SUB_AUTHORITIES)) {
-		ksmbd_err("%s: %u subauthorities is too many!\n",
-			  __func__, psid->num_subauth);
+		pr_err("%s: %u subauthorities is too many!\n",
+		       __func__, psid->num_subauth);
 		return -EIO;
 	}
 
@@ -383,7 +383,7 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 	/* validate that we do not go past end of acl */
 	if (end_of_acl <= (char *)pdacl ||
 	    end_of_acl < (char *)pdacl + le16_to_cpu(pdacl->size)) {
-		ksmbd_err("ACL too small to parse DACL\n");
+		pr_err("ACL too small to parse DACL\n");
 		return;
 	}
 
@@ -477,8 +477,8 @@ static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl,
 			temp_fattr.cf_uid = INVALID_UID;
 			ret = sid_to_id(&ppace[i]->sid, SIDOWNER, &temp_fattr);
 			if (ret || uid_eq(temp_fattr.cf_uid, INVALID_UID)) {
-				ksmbd_err("%s: Error %d mapping Owner SID to uid\n",
-					  __func__, ret);
+				pr_err("%s: Error %d mapping Owner SID to uid\n",
+				       __func__, ret);
 				continue;
 			}
 
@@ -764,7 +764,7 @@ static int parse_sid(struct smb_sid *psid, char *end_of_acl)
 	 * bytes long (assuming no sub-auths - e.g. the null SID
 	 */
 	if (end_of_acl < (char *)psid + 8) {
-		ksmbd_err("ACL too small to parse SID %p\n", psid);
+		pr_err("ACL too small to parse SID %p\n", psid);
 		return -EINVAL;
 	}
 
@@ -808,14 +808,14 @@ int parse_sec_desc(struct smb_ntsd *pntsd, int acl_len,
 	if (pntsd->osidoffset) {
 		rc = parse_sid(owner_sid_ptr, end_of_acl);
 		if (rc) {
-			ksmbd_err("%s: Error %d parsing Owner SID\n", __func__, rc);
+			pr_err("%s: Error %d parsing Owner SID\n", __func__, rc);
 			return rc;
 		}
 
 		rc = sid_to_id(owner_sid_ptr, SIDOWNER, fattr);
 		if (rc) {
-			ksmbd_err("%s: Error %d mapping Owner SID to uid\n",
-				  __func__, rc);
+			pr_err("%s: Error %d mapping Owner SID to uid\n",
+			       __func__, rc);
 			owner_sid_ptr = NULL;
 		}
 	}
@@ -823,14 +823,14 @@ int parse_sec_desc(struct smb_ntsd *pntsd, int acl_len,
 	if (pntsd->gsidoffset) {
 		rc = parse_sid(group_sid_ptr, end_of_acl);
 		if (rc) {
-			ksmbd_err("%s: Error %d mapping Owner SID to gid\n",
-				  __func__, rc);
+			pr_err("%s: Error %d mapping Owner SID to gid\n",
+			       __func__, rc);
 			return rc;
 		}
 		rc = sid_to_id(group_sid_ptr, SIDUNIX_GROUP, fattr);
 		if (rc) {
-			ksmbd_err("%s: Error %d mapping Group SID to gid\n",
-				  __func__, rc);
+			pr_err("%s: Error %d mapping Group SID to gid\n",
+			       __func__, rc);
 			group_sid_ptr = NULL;
 		}
 	}

fs/cifsd/transport_ipc.c

@@ -43,11 +43,11 @@ static unsigned int ksmbd_tools_pid;
 static bool ksmbd_ipc_validate_version(struct genl_info *m)
 {
 	if (m->genlhdr->version != KSMBD_GENL_VERSION) {
-		ksmbd_err("%s. ksmbd: %d, kernel module: %d. %s.\n",
-			  "Daemon and kernel module version mismatch",
-			  m->genlhdr->version,
-			  KSMBD_GENL_VERSION,
-			  "User-space ksmbd should terminate");
+		pr_err("%s. ksmbd: %d, kernel module: %d. %s.\n",
+		       "Daemon and kernel module version mismatch",
+		       m->genlhdr->version,
+		       KSMBD_GENL_VERSION,
+		       "User-space ksmbd should terminate");
 		return false;
 	}
 	return true;
@@ -267,8 +267,8 @@ static int handle_response(int type, void *payload, size_t sz)
 		 * request message type + 1.
 		 */
 		if (entry->type + 1 != type) {
-			ksmbd_err("Waiting for IPC type %d, got %d. Ignore.\n",
-				  entry->type + 1, type);
+			pr_err("Waiting for IPC type %d, got %d. Ignore.\n",
+			       entry->type + 1, type);
 		}
 
 		entry->response = kvmalloc(sz, GFP_KERNEL | __GFP_ZERO);
@@ -313,9 +313,9 @@ static int ipc_server_config_on_startup(struct ksmbd_startup_request *req)
 	ret |= ksmbd_tcp_set_interfaces(KSMBD_STARTUP_CONFIG_INTERFACES(req),
 					req->ifc_list_sz);
 	if (ret) {
-		ksmbd_err("Server configuration error: %s %s %s\n",
-			  req->netbios_name, req->server_string,
-			  req->work_group);
+		pr_err("Server configuration error: %s %s %s\n",
+		       req->netbios_name, req->server_string,
+		       req->work_group);
 		return ret;
 	}
 
@@ -353,7 +353,7 @@ static int handle_startup_event(struct sk_buff *skb, struct genl_info *info)
 	mutex_lock(&startup_lock);
 	if (!ksmbd_server_configurable()) {
 		mutex_unlock(&startup_lock);
-		ksmbd_err("Server reset is in progress, can't start daemon\n");
+		pr_err("Server reset is in progress, can't start daemon\n");
 		return -EINVAL;
 	}
 
@@ -363,7 +363,7 @@ static int handle_startup_event(struct sk_buff *skb, struct genl_info *info)
 			goto out;
 		}
 
-		ksmbd_err("Reconnect to a new user space daemon\n");
+		pr_err("Reconnect to a new user space daemon\n");
 	} else {
 		struct ksmbd_startup_request *req;
 
@@ -384,7 +384,7 @@ static int handle_startup_event(struct sk_buff *skb, struct genl_info *info)
 
 static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info)
 {
-	ksmbd_err("Unknown IPC event: %d, ignore.\n", info->genlhdr->cmd);
+	pr_err("Unknown IPC event: %d, ignore.\n", info->genlhdr->cmd);
 	return -EINVAL;
 }
 
@@ -827,7 +827,7 @@ static int __ipc_heartbeat(void)
 	WRITE_ONCE(server_conf.state, SERVER_STATE_RESETTING);
 	server_conf.ipc_last_active = 0;
 	ksmbd_tools_pid = 0;
-	ksmbd_err("No IPC daemon response for %lus\n", delta / HZ);
+	pr_err("No IPC daemon response for %lus\n", delta / HZ);
 	mutex_unlock(&startup_lock);
 	return -EINVAL;
 }
@@ -871,7 +871,7 @@ int ksmbd_ipc_init(void)
 
 	ret = genl_register_family(&ksmbd_genl_family);
 	if (ret) {
-		ksmbd_err("Failed to register KSMBD netlink interface %d\n", ret);
+		pr_err("Failed to register KSMBD netlink interface %d\n", ret);
 		cancel_delayed_work_sync(&ipc_timer_work);
 	}
 

fs/cifsd/transport_rdma.c

@@ -525,9 +525,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
 		if (wc->status != IB_WC_WR_FLUSH_ERR) {
-			ksmbd_err("Recv error. status='%s (%d)' opcode=%d\n",
-				  ib_wc_status_msg(wc->status), wc->status,
-				  wc->opcode);
+			pr_err("Recv error. status='%s (%d)' opcode=%d\n",
+			       ib_wc_status_msg(wc->status), wc->status,
+			       wc->opcode);
 			smb_direct_disconnect_rdma_connection(t);
 		}
 		put_empty_recvmsg(t, recvmsg);
@@ -623,7 +623,7 @@ static int smb_direct_post_recv(struct smb_direct_transport *t,
 
 	ret = ib_post_recv(t->qp, &wr, NULL);
 	if (ret) {
-		ksmbd_err("Can't post recv: %d\n", ret);
+		pr_err("Can't post recv: %d\n", ret);
 		ib_dma_unmap_single(t->cm_id->device,
 				    recvmsg->sge.addr, recvmsg->sge.length,
 				    DMA_FROM_DEVICE);
@@ -645,7 +645,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 
 again:
 	if (st->status != SMB_DIRECT_CS_CONNECTED) {
-		ksmbd_err("disconnected\n");
+		pr_err("disconnected\n");
 		return -ENOTCONN;
 	}
 
@@ -794,7 +794,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 
 			ret = smb_direct_post_recv(t, recvmsg);
 			if (ret) {
-				ksmbd_err("Can't post recv: %d\n", ret);
+				pr_err("Can't post recv: %d\n", ret);
 				put_recvmsg(t, recvmsg);
 				break;
 			}
@@ -829,9 +829,9 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 		    wc->opcode);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_SEND) {
-		ksmbd_err("Send error. status='%s (%d)', opcode=%d\n",
-			  ib_wc_status_msg(wc->status), wc->status,
-			  wc->opcode);
+		pr_err("Send error. status='%s (%d)', opcode=%d\n",
+		       ib_wc_status_msg(wc->status), wc->status,
+		       wc->opcode);
 		smb_direct_disconnect_rdma_connection(t);
 	}
 
@@ -880,7 +880,7 @@ static int smb_direct_post_send(struct smb_direct_transport *t,
 
 	ret = ib_post_send(t->qp, wr, NULL);
 	if (ret) {
-		ksmbd_err("failed to post send: %d\n", ret);
+		pr_err("failed to post send: %d\n", ret);
 		if (wr->num_sge > 1) {
 			if (atomic_dec_and_test(&t->send_payload_pending))
 				wake_up(&t->wait_send_payload_pending);
@@ -1158,11 +1158,11 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 					    sg, SMB_DIRECT_MAX_SEND_SGES - 1,
 					    DMA_TO_DEVICE);
 		if (sg_cnt <= 0) {
-			ksmbd_err("failed to map buffer\n");
+			pr_err("failed to map buffer\n");
 			ret = -ENOMEM;
 			goto err;
 		} else if (sg_cnt + msg->num_sge > SMB_DIRECT_MAX_SEND_SGES - 1) {
-			ksmbd_err("buffer not fitted into sges\n");
+			pr_err("buffer not fitted into sges\n");
 			ret = -E2BIG;
 			ib_dma_unmap_sg(t->cm_id->device, sg, sg_cnt,
 					DMA_TO_DEVICE);
@@ -1290,8 +1290,8 @@ static void read_write_done(struct ib_cq *cq, struct ib_wc *wc,
 	struct smb_direct_transport *t = msg->t;
 
 	if (wc->status != IB_WC_SUCCESS) {
-		ksmbd_err("read/write error. opcode = %d, status = %s(%d)\n",
-			  wc->opcode, ib_wc_status_msg(wc->status), wc->status);
+		pr_err("read/write error. opcode = %d, status = %s(%d)\n",
+		       wc->opcode, ib_wc_status_msg(wc->status), wc->status);
 		smb_direct_disconnect_rdma_connection(t);
 	}
 
@@ -1348,7 +1348,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t, void *buf,
 
 	ret = get_sg_list(buf, buf_len, msg->sgt.sgl, msg->sgt.orig_nents);
 	if (ret <= 0) {
-		ksmbd_err("failed to get pages\n");
+		pr_err("failed to get pages\n");
 		goto err;
 	}
 
@@ -1357,7 +1357,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t, void *buf,
 			       0, remote_offset, remote_key,
 			       is_read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 	if (ret < 0) {
-		ksmbd_err("failed to init rdma_rw_ctx: %d\n", ret);
+		pr_err("failed to init rdma_rw_ctx: %d\n", ret);
 		goto err;
 	}
 
@@ -1369,7 +1369,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t, void *buf,
 
 	ret = ib_post_send(t->qp, first_wr, NULL);
 	if (ret) {
-		ksmbd_err("failed to post send wr: %d\n", ret);
+		pr_err("failed to post send wr: %d\n", ret);
 		goto err;
 	}
 
@@ -1445,9 +1445,9 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 		break;
 	}
 	default:
-		ksmbd_err("Unexpected RDMA CM event. cm_id=%p, event=%s (%d)\n",
-			  cm_id, rdma_event_msg(event->event),
-			  event->event);
+		pr_err("Unexpected RDMA CM event. cm_id=%p, event=%s (%d)\n",
+		       cm_id, rdma_event_msg(event->event),
+		       event->event);
 		break;
 	}
 	return 0;
@@ -1557,7 +1557,7 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 
 	ret = rdma_accept(t->cm_id, &conn_param);
 	if (ret) {
-		ksmbd_err("error at rdma_accept: %d\n", ret);
+		pr_err("error at rdma_accept: %d\n", ret);
 		return ret;
 	}
 
@@ -1581,14 +1581,14 @@ static int smb_direct_negotiate(struct smb_direct_transport *t)
 
 	ret = smb_direct_post_recv(t, recvmsg);
 	if (ret) {
-		ksmbd_err("Can't post recv: %d\n", ret);
+		pr_err("Can't post recv: %d\n", ret);
 		goto out;
 	}
 
 	t->negotiation_requested = false;
 	ret = smb_direct_accept_client(t);
 	if (ret) {
-		ksmbd_err("Can't accept client\n");
+		pr_err("Can't accept client\n");
 		goto out;
 	}
 
@@ -1635,7 +1635,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	t->max_send_size = smb_direct_max_send_size;
 	max_send_sges = DIV_ROUND_UP(t->max_send_size, PAGE_SIZE) + 2;
 	if (max_send_sges > SMB_DIRECT_MAX_SEND_SGES) {
-		ksmbd_err("max_send_size %d is too large\n", t->max_send_size);
+		pr_err("max_send_size %d is too large\n", t->max_send_size);
 		return -EINVAL;
 	}
 
@@ -1655,31 +1655,31 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	max_send_wrs = smb_direct_send_credit_target + max_rw_wrs;
 	if (max_send_wrs > device->attrs.max_cqe ||
 	    max_send_wrs > device->attrs.max_qp_wr) {
-		ksmbd_err("consider lowering send_credit_target = %d, or max_outstanding_rw_ops = %d\n",
-			  smb_direct_send_credit_target,
-			  smb_direct_max_outstanding_rw_ops);
-		ksmbd_err("Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n",
-			  device->attrs.max_cqe, device->attrs.max_qp_wr);
+		pr_err("consider lowering send_credit_target = %d, or max_outstanding_rw_ops = %d\n",
+		       smb_direct_send_credit_target,
+		       smb_direct_max_outstanding_rw_ops);
+		pr_err("Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n",
+		       device->attrs.max_cqe, device->attrs.max_qp_wr);
 		return -EINVAL;
 	}
 
 	if (smb_direct_receive_credit_max > device->attrs.max_cqe ||
 	    smb_direct_receive_credit_max > device->attrs.max_qp_wr) {
-		ksmbd_err("consider lowering receive_credit_max = %d\n",
-			  smb_direct_receive_credit_max);
-		ksmbd_err("Possible CQE overrun, device reporting max_cpe %d max_qp_wr %d\n",
-			  device->attrs.max_cqe, device->attrs.max_qp_wr);
+		pr_err("consider lowering receive_credit_max = %d\n",
+		       smb_direct_receive_credit_max);
+		pr_err("Possible CQE overrun, device reporting max_cpe %d max_qp_wr %d\n",
+		       device->attrs.max_cqe, device->attrs.max_qp_wr);
 		return -EINVAL;
 	}
 
 	if (device->attrs.max_send_sge < SMB_DIRECT_MAX_SEND_SGES) {
-		ksmbd_err("warning: device max_send_sge = %d too small\n",
-			  device->attrs.max_send_sge);
+		pr_err("warning: device max_send_sge = %d too small\n",
+		       device->attrs.max_send_sge);
 		return -EINVAL;
 	}
 	if (device->attrs.max_recv_sge < SMB_DIRECT_MAX_RECV_SGES) {
-		ksmbd_err("warning: device max_recv_sge = %d too small\n",
-			  device->attrs.max_recv_sge);
+		pr_err("warning: device max_recv_sge = %d too small\n",
+		       device->attrs.max_recv_sge);
 		return -EINVAL;
 	}
 
@@ -1788,7 +1788,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 
 	t->pd = ib_alloc_pd(t->cm_id->device, 0);
 	if (IS_ERR(t->pd)) {
-		ksmbd_err("Can't create RDMA PD\n");
+		pr_err("Can't create RDMA PD\n");
 		ret = PTR_ERR(t->pd);
 		t->pd = NULL;
 		return ret;
@@ -1797,7 +1797,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 	t->send_cq = ib_alloc_cq(t->cm_id->device, t,
 				 t->send_credit_target, 0, IB_POLL_WORKQUEUE);
 	if (IS_ERR(t->send_cq)) {
-		ksmbd_err("Can't create RDMA send CQ\n");
+		pr_err("Can't create RDMA send CQ\n");
 		ret = PTR_ERR(t->send_cq);
 		t->send_cq = NULL;
 		goto err;
@@ -1807,7 +1807,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 				 cap->max_send_wr + cap->max_rdma_ctxs,
 				 0, IB_POLL_WORKQUEUE);
 	if (IS_ERR(t->recv_cq)) {
-		ksmbd_err("Can't create RDMA recv CQ\n");
+		pr_err("Can't create RDMA recv CQ\n");
 		ret = PTR_ERR(t->recv_cq);
 		t->recv_cq = NULL;
 		goto err;
@@ -1825,7 +1825,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 
 	ret = rdma_create_qp(t->cm_id, t->pd, &qp_attr);
 	if (ret) {
-		ksmbd_err("Can't create RDMA QP: %d\n", ret);
+		pr_err("Can't create RDMA QP: %d\n", ret);
 		goto err;
 	}
 
@@ -1861,25 +1861,25 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 
 	ret = smb_direct_init_params(st, &qp_cap);
 	if (ret) {
-		ksmbd_err("Can't configure RDMA parameters\n");
+		pr_err("Can't configure RDMA parameters\n");
 		return ret;
 	}
 
 	ret = smb_direct_create_pools(st);
 	if (ret) {
-		ksmbd_err("Can't init RDMA pool: %d\n", ret);
+		pr_err("Can't init RDMA pool: %d\n", ret);
 		return ret;
 	}
 
 	ret = smb_direct_create_qpair(st, &qp_cap);
 	if (ret) {
-		ksmbd_err("Can't accept RDMA client: %d\n", ret);
+		pr_err("Can't accept RDMA client: %d\n", ret);
 		return ret;
 	}
 
 	ret = smb_direct_negotiate(st);
 	if (ret) {
-		ksmbd_err("Can't negotiate: %d\n", ret);
+		pr_err("Can't negotiate: %d\n", ret);
 		return ret;
 	}
 
@@ -1917,7 +1917,7 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id)
 	if (IS_ERR(KSMBD_TRANS(t)->handler)) {
 		int ret = PTR_ERR(KSMBD_TRANS(t)->handler);
 
-		ksmbd_err("Can't start thread\n");
+		pr_err("Can't start thread\n");
 		free_transport(t);
 		return ret;
 	}
@@ -1933,7 +1933,7 @@ static int smb_direct_listen_handler(struct rdma_cm_id *cm_id,
 		int ret = smb_direct_handle_connect_request(cm_id);
 
 		if (ret) {
-			ksmbd_err("Can't create transport: %d\n", ret);
+			pr_err("Can't create transport: %d\n", ret);
 			return ret;
 		}
 
@@ -1942,8 +1942,8 @@ static int smb_direct_listen_handler(struct rdma_cm_id *cm_id,
 		break;
 	}
 	default:
-		ksmbd_err("Unexpected listen event. cm_id=%p, event=%s (%d)\n",
-			  cm_id, rdma_event_msg(event->event), event->event);
+		pr_err("Unexpected listen event. cm_id=%p, event=%s (%d)\n",
+		       cm_id, rdma_event_msg(event->event), event->event);
 		break;
 	}
 	return 0;
@@ -1962,13 +1962,13 @@ 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));
+		pr_err("Can't create cm id: %ld\n", PTR_ERR(cm_id));
 		return PTR_ERR(cm_id);
 	}
 
 	ret = rdma_bind_addr(cm_id, (struct sockaddr *)&sin);
 	if (ret) {
-		ksmbd_err("Can't bind: %d\n", ret);
+		pr_err("Can't bind: %d\n", ret);
 		goto err;
 	}
 
@@ -1976,7 +1976,7 @@ static int smb_direct_listen(int port)
 
 	ret = rdma_listen(cm_id, 10);
 	if (ret) {
-		ksmbd_err("Can't listen: %d\n", ret);
+		pr_err("Can't listen: %d\n", ret);
 		goto err;
 	}
 	return 0;
@@ -2006,7 +2006,7 @@ int ksmbd_rdma_init(void)
 	if (ret) {
 		destroy_workqueue(smb_direct_wq);
 		smb_direct_wq = NULL;
-		ksmbd_err("Can't listen: %d\n", ret);
+		pr_err("Can't listen: %d\n", ret);
 		return ret;
 	}
 

fs/cifsd/transport_tcp.c

@@ -190,7 +190,7 @@ static int ksmbd_tcp_new_connection(struct socket *client_sk)
 
 	csin = KSMBD_TCP_PEER_SOCKADDR(KSMBD_TRANS(t)->conn);
 	if (kernel_getpeername(client_sk, csin) < 0) {
-		ksmbd_err("client ip resolution failed\n");
+		pr_err("client ip resolution failed\n");
 		rc = -EINVAL;
 		goto out_error;
 	}
@@ -200,7 +200,7 @@ static int ksmbd_tcp_new_connection(struct socket *client_sk)
 					      "ksmbd:%u",
 					      ksmbd_tcp_get_port(csin));
 	if (IS_ERR(KSMBD_TRANS(t)->handler)) {
-		ksmbd_err("cannot start conn thread\n");
+		pr_err("cannot start conn thread\n");
 		rc = PTR_ERR(KSMBD_TRANS(t)->handler);
 		free_transport(t);
 	}
@@ -380,7 +380,7 @@ static void tcp_destroy_socket(struct socket *ksmbd_socket)
 
 	ret = kernel_sock_shutdown(ksmbd_socket, SHUT_RDWR);
 	if (ret)
-		ksmbd_err("Failed to shutdown socket: %d\n", ret);
+		pr_err("Failed to shutdown socket: %d\n", ret);
 	else
 		sock_release(ksmbd_socket);
 }
@@ -400,11 +400,11 @@ static int create_socket(struct interface *iface)
 
 	ret = sock_create(PF_INET6, SOCK_STREAM, IPPROTO_TCP, &ksmbd_socket);
 	if (ret) {
-		ksmbd_err("Can't create socket for ipv6, try ipv4: %d\n", ret);
+		pr_err("Can't create socket for ipv6, try ipv4: %d\n", ret);
 		ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP,
 				  &ksmbd_socket);
 		if (ret) {
-			ksmbd_err("Can't create socket for ipv4: %d\n", ret);
+			pr_err("Can't create socket for ipv4: %d\n", ret);
 			goto out_error;
 		}
 
@@ -427,7 +427,7 @@ static int create_socket(struct interface *iface)
 			      KERNEL_SOCKPTR(iface->name),
 			      strlen(iface->name));
 	if (ret != -ENODEV && ret < 0) {
-		ksmbd_err("Failed to set SO_BINDTODEVICE: %d\n", ret);
+		pr_err("Failed to set SO_BINDTODEVICE: %d\n", ret);
 		goto out_error;
 	}
 
@@ -438,7 +438,7 @@ static int create_socket(struct interface *iface)
 		ret = kernel_bind(ksmbd_socket, (struct sockaddr *)&sin6,
 				  sizeof(sin6));
 	if (ret) {
-		ksmbd_err("Failed to bind socket: %d\n", ret);
+		pr_err("Failed to bind socket: %d\n", ret);
 		goto out_error;
 	}
 
@@ -447,14 +447,14 @@ static int create_socket(struct interface *iface)
 
 	ret = kernel_listen(ksmbd_socket, KSMBD_SOCKET_BACKLOG);
 	if (ret) {
-		ksmbd_err("Port listen() error: %d\n", ret);
+		pr_err("Port listen() error: %d\n", ret);
 		goto out_error;
 	}
 
 	iface->ksmbd_socket = ksmbd_socket;
 	ret = ksmbd_tcp_run_kthread(iface);
 	if (ret) {
-		ksmbd_err("Can't start ksmbd main kthread: %d\n", ret);
+		pr_err("Can't start ksmbd main kthread: %d\n", ret);
 		goto out_error;
 	}
 	iface->state = IFACE_STATE_CONFIGURED;
@@ -540,7 +540,7 @@ static void tcp_stop_kthread(struct task_struct *kthread)
 
 	ret = kthread_stop(kthread);
 	if (ret)
-		ksmbd_err("failed to stop forker thread\n");
+		pr_err("failed to stop forker thread\n");
 }
 
 void ksmbd_tcp_destroy(void)

fs/cifsd/vfs.c

@@ -45,7 +45,7 @@ static char *extract_last_component(char *path)
 		p++;
 	} else {
 		p = NULL;
-		ksmbd_err("Invalid path %s\n", path);
+		pr_err("Invalid path %s\n", path);
 	}
 	return p;
 }
@@ -170,8 +170,8 @@ int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
 	if (IS_ERR(dentry)) {
 		err = PTR_ERR(dentry);
 		if (err != -ENOENT)
-			ksmbd_err("path create failed for %s, err %d\n",
-				  name, err);
+			pr_err("path create failed for %s, err %d\n",
+			       name, err);
 		return err;
 	}
 
@@ -181,7 +181,7 @@ int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
 		ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),
 					d_inode(dentry));
 	} else {
-		ksmbd_err("File(%s): creation failed (err:%d)\n", name, err);
+		pr_err("File(%s): creation failed (err:%d)\n", name, err);
 	}
 	done_path_create(&path, dentry);
 	return err;
@@ -235,7 +235,7 @@ int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
 out:
 	done_path_create(&path, dentry);
 	if (err)
-		ksmbd_err("mkdir(%s): creation failed (err:%d)\n", name, err);
+		pr_err("mkdir(%s): creation failed (err:%d)\n", name, err);
 	return err;
 }
 
@@ -259,7 +259,7 @@ static ssize_t ksmbd_vfs_getcasexattr(struct dentry *dentry, char *attr_name,
 					       name,
 					       attr_value);
 		if (value_len < 0)
-			ksmbd_err("failed to get xattr in file\n");
+			pr_err("failed to get xattr in file\n");
 		break;
 	}
 
@@ -324,7 +324,7 @@ static int check_lock_range(struct file *filp, loff_t start, loff_t end,
 		if (flock->fl_end >= start && end >= flock->fl_start) {
 			if (flock->fl_type == F_RDLCK) {
 				if (type == WRITE) {
-					ksmbd_err("not allow write by shared lock\n");
+					pr_err("not allow write by shared lock\n");
 					error = 1;
 					goto out;
 				}
@@ -332,7 +332,7 @@ static int check_lock_range(struct file *filp, loff_t start, loff_t end,
 				/* check owner in lock */
 				if (flock->fl_file != filp) {
 					error = 1;
-					ksmbd_err("not allow rw access by exclusive lock from other opens\n");
+					pr_err("not allow rw access by exclusive lock from other opens\n");
 					goto out;
 				}
 			}
@@ -368,7 +368,7 @@ int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
 
 	if (work->conn->connection_type) {
 		if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
-			ksmbd_err("no right to read(%s)\n", FP_FILENAME(fp));
+			pr_err("no right to read(%s)\n", FP_FILENAME(fp));
 			return -EACCES;
 		}
 	}
@@ -381,15 +381,15 @@ int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
 
 		ret = check_lock_range(filp, *pos, *pos + count - 1, READ);
 		if (ret) {
-			ksmbd_err("unable to read due to lock\n");
+			pr_err("unable to read due to lock\n");
 			return -EAGAIN;
 		}
 	}
 
 	nbytes = kernel_read(filp, rbuf, count, pos);
 	if (nbytes < 0) {
-		ksmbd_err("smb read failed for (%s), err = %zd\n",
-			  fp->filename, nbytes);
+		pr_err("smb read failed for (%s), err = %zd\n",
+		       fp->filename, nbytes);
 		return nbytes;
 	}
 
@@ -418,7 +418,7 @@ static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos,
 				       fp->stream.size,
 				       &stream_buf);
 	if ((int)v_len < 0) {
-		ksmbd_err("not found stream in xattr : %zd\n", v_len);
+		pr_err("not found stream in xattr : %zd\n", v_len);
 		err = (int)v_len;
 		goto out;
 	}
@@ -476,7 +476,7 @@ int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
 
 	if (sess->conn->connection_type) {
 		if (!(fp->daccess & FILE_WRITE_DATA_LE)) {
-			ksmbd_err("no right to write(%s)\n", FP_FILENAME(fp));
+			pr_err("no right to write(%s)\n", FP_FILENAME(fp));
 			err = -EACCES;
 			goto out;
 		}
@@ -494,7 +494,7 @@ int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
 	if (!work->tcon->posix_extensions) {
 		err = check_lock_range(filp, *pos, *pos + count - 1, WRITE);
 		if (err) {
-			ksmbd_err("unable to write due to lock\n");
+			pr_err("unable to write due to lock\n");
 			err = -EAGAIN;
 			goto out;
 		}
@@ -515,8 +515,8 @@ int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
 	if (sync) {
 		err = vfs_fsync_range(filp, offset, offset + *written, 0);
 		if (err < 0)
-			ksmbd_err("fsync failed for filename = %s, err = %d\n",
-				  FP_FILENAME(fp), err);
+			pr_err("fsync failed for filename = %s, err = %d\n",
+			       FP_FILENAME(fp), err);
 	}
 
 out:
@@ -537,7 +537,7 @@ int ksmbd_vfs_getattr(struct path *path, struct kstat *stat)
 
 	err = vfs_getattr(path, stat, STATX_BTIME, AT_STATX_SYNC_AS_STAT);
 	if (err)
-		ksmbd_err("getattr failed, err %d\n", err);
+		pr_err("getattr failed, err %d\n", err);
 	return err;
 }
 
@@ -555,12 +555,12 @@ int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id)
 
 	fp = ksmbd_lookup_fd_slow(work, fid, p_id);
 	if (!fp) {
-		ksmbd_err("failed to get filp for fid %llu\n", fid);
+		pr_err("failed to get filp for fid %llu\n", fid);
 		return -ENOENT;
 	}
 	err = vfs_fsync(fp->filp, 0);
 	if (err < 0)
-		ksmbd_err("smb fsync failed, err = %d\n", err);
+		pr_err("smb fsync failed, err = %d\n", err);
 	ksmbd_fd_put(work, fp);
 	return err;
 }
@@ -654,8 +654,8 @@ int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
 
 	err = kern_path(oldname, flags, &oldpath);
 	if (err) {
-		ksmbd_err("cannot get linux path for %s, err = %d\n",
-			  oldname, err);
+		pr_err("cannot get linux path for %s, err = %d\n",
+		       oldname, err);
 		goto out1;
 	}
 
@@ -663,13 +663,13 @@ int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
 				  flags | LOOKUP_REVAL);
 	if (IS_ERR(dentry)) {
 		err = PTR_ERR(dentry);
-		ksmbd_err("path create err for %s, err %d\n", newname, err);
+		pr_err("path create err for %s, err %d\n", newname, err);
 		goto out2;
 	}
 
 	err = -EXDEV;
 	if (oldpath.mnt != newpath.mnt) {
-		ksmbd_err("vfs_link failed err %d\n", err);
+		pr_err("vfs_link failed err %d\n", err);
 		goto out3;
 	}
 
@@ -730,7 +730,7 @@ static int __ksmbd_vfs_rename(struct ksmbd_work *work,
 	dst_dent = lookup_one_len(dst_name, dst_dent_parent, strlen(dst_name));
 	err = PTR_ERR(dst_dent);
 	if (IS_ERR(dst_dent)) {
-		ksmbd_err("lookup failed %s [%d]\n", dst_name, err);
+		pr_err("lookup failed %s [%d]\n", dst_name, err);
 		goto out;
 	}
 
@@ -747,7 +747,7 @@ static int __ksmbd_vfs_rename(struct ksmbd_work *work,
 		err = vfs_rename(&rd);
 	}
 	if (err)
-		ksmbd_err("vfs_rename failed err %d\n", err);
+		pr_err("vfs_rename failed err %d\n", err);
 	if (dst_dent)
 		dput(dst_dent);
 out:
@@ -835,14 +835,14 @@ int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name,
 	if (name) {
 		err = kern_path(name, 0, &path);
 		if (err) {
-			ksmbd_err("cannot get linux path for %s, err %d\n",
-				  name, err);
+			pr_err("cannot get linux path for %s, err %d\n",
+			       name, err);
 			return err;
 		}
 		err = vfs_truncate(&path, size);
 		if (err)
-			ksmbd_err("truncate failed for %s err %d\n",
-				  name, err);
+			pr_err("truncate failed for %s err %d\n",
+			       name, err);
 		path_put(&path);
 	} else {
 		struct file *filp;
@@ -864,15 +864,15 @@ int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name,
 			}
 
 			if (err) {
-				ksmbd_err("failed due to lock\n");
+				pr_err("failed due to lock\n");
 				return -EAGAIN;
 			}
 		}
 
 		err = vfs_truncate(&filp->f_path, size);
 		if (err)
-			ksmbd_err("truncate failed for filename : %s err %d\n",
-				  fp->filename, err);
+			pr_err("truncate failed for filename : %s err %d\n",
+			       fp->filename, err);
 	}
 
 	return err;
@@ -1458,7 +1458,7 @@ static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct inode *inode,
 			xa_entry->type = SMB_ACL_MASK;
 			break;
 		default:
-			ksmbd_err("unknown type : 0x%x\n", pa_entry->e_tag);
+			pr_err("unknown type : 0x%x\n", pa_entry->e_tag);
 			goto out;
 		}
 
@@ -1502,7 +1502,7 @@ int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry,
 
 	rc = ksmbd_gen_sd_hash(conn, acl.sd_buf, acl.sd_size, acl.hash);
 	if (rc) {
-		ksmbd_err("failed to generate hash for ndr acl\n");
+		pr_err("failed to generate hash for ndr acl\n");
 		return rc;
 	}
 
@@ -1513,27 +1513,27 @@ int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry,
 
 	rc = ndr_encode_posix_acl(&acl_ndr, inode, smb_acl, def_smb_acl);
 	if (rc) {
-		ksmbd_err("failed to encode ndr to posix acl\n");
+		pr_err("failed to encode ndr to posix acl\n");
 		goto out;
 	}
 
 	rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
 			       acl.posix_acl_hash);
 	if (rc) {
-		ksmbd_err("failed to generate hash for ndr acl\n");
+		pr_err("failed to generate hash for ndr acl\n");
 		goto out;
 	}
 
 	rc = ndr_encode_v4_ntacl(&sd_ndr, &acl);
 	if (rc) {
-		ksmbd_err("failed to encode ndr to posix acl\n");
+		pr_err("failed to encode ndr to posix acl\n");
 		goto out;
 	}
 
 	rc = ksmbd_vfs_setxattr(dentry, XATTR_NAME_SD, sd_ndr.data,
 				sd_ndr.offset, 0);
 	if (rc < 0)
-		ksmbd_err("Failed to store XATTR ntacl :%d\n", rc);
+		pr_err("Failed to store XATTR ntacl :%d\n", rc);
 
 	kfree(sd_ndr.data);
 out:
@@ -1570,19 +1570,19 @@ int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry,
 
 		rc = ndr_encode_posix_acl(&acl_ndr, inode, smb_acl, def_smb_acl);
 		if (rc) {
-			ksmbd_err("failed to encode ndr to posix acl\n");
+			pr_err("failed to encode ndr to posix acl\n");
 			goto out;
 		}
 
 		rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
 				       cmp_hash);
 		if (rc) {
-			ksmbd_err("failed to generate hash for ndr acl\n");
+			pr_err("failed to generate hash for ndr acl\n");
 			goto out;
 		}
 
 		if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) {
-			ksmbd_err("hash value diff\n");
+			pr_err("hash value diff\n");
 			rc = -EINVAL;
 			goto out;
 		}
@@ -1821,11 +1821,11 @@ int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
 	*total_size_written = 0;
 
 	if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
-		ksmbd_err("no right to read(%s)\n", FP_FILENAME(src_fp));
+		pr_err("no right to read(%s)\n", FP_FILENAME(src_fp));
 		return -EACCES;
 	}
 	if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) {
-		ksmbd_err("no right to write(%s)\n", FP_FILENAME(dst_fp));
+		pr_err("no right to write(%s)\n", FP_FILENAME(dst_fp));
 		return -EACCES;
 	}
 

fs/cifsd/vfs_cache.c

@@ -185,7 +185,7 @@ static struct ksmbd_inode *ksmbd_inode_get(struct ksmbd_file *fp)
 
 	rc = ksmbd_inode_init(ci, fp);
 	if (rc) {
-		ksmbd_err("inode initialized failed\n");
+		pr_err("inode initialized failed\n");
 		kfree(ci);
 		return NULL;
 	}
@@ -254,8 +254,8 @@ static void __ksmbd_inode_close(struct ksmbd_file *fp)
 		err = ksmbd_vfs_remove_xattr(filp->f_path.dentry,
 					     fp->stream.name);
 		if (err)
-			ksmbd_err("remove xattr failed : %s\n",
-				  fp->stream.name);
+			pr_err("remove xattr failed : %s\n",
+			       fp->stream.name);
 	}
 
 	if (atomic_dec_and_test(&ci->m_count)) {
@@ -542,7 +542,7 @@ struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp)
 
 	fp = kmem_cache_zalloc(filp_cache, GFP_KERNEL);
 	if (!fp) {
-		ksmbd_err("Failed to allocate memory\n");
+		pr_err("Failed to allocate memory\n");
 		return ERR_PTR(-ENOMEM);
 	}
 
@@ -698,7 +698,7 @@ int ksmbd_init_file_cache(void)
 	return 0;
 
 out:
-	ksmbd_err("failed to allocate file cache\n");
+	pr_err("failed to allocate file cache\n");
 	return -ENOMEM;
 }