mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-30 06:10:56 +00:00
Code Issues Releases Wiki Activity

ksmbd: remove ksmbd_err/info

Browse source 
Use the pr_fmt built into pr_*. and use pr_err/info after removing
wrapper ksmbd_err/info.

Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: Steve French <stfrench@microsoft.com>
This commit is contained in:
Namjae Jeon 2021-06-28 15:23:19 +09:00
parent 3fbe43c9f5
commit bde1694aec
18 changed files with 295 additions and 308 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
fs/cifsd/auth.c
View file

@ -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;
}

15
fs/cifsd/connection.c
View file

@ -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;
}
}

4
fs/cifsd/crypto_ctx.c
View file

@ -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;
}

26
fs/cifsd/glob.h
View file

@ -31,32 +31,22 @@ extern int ksmbd_debug_types;
KSMBD_DEBUG_IPC | KSMBD_DEBUG_CONN | \
KSMBD_DEBUG_RDMA)
#ifndef ksmbd_pr_fmt
#ifdef SUBMOD_NAME
#define ksmbd_pr_fmt(fmt) "ksmbd: " SUBMOD_NAME ": " fmt
#else
#define ksmbd_pr_fmt(fmt) "ksmbd: " fmt
#ifdef pr_fmt
#undef pr_fmt
#endif
#ifdef SUBMOD_NAME
#define pr_fmt(fmt) "ksmbd: " SUBMOD_NAME ": " fmt
#else
#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 */

4
fs/cifsd/mgmt/user_session.c
View file

@ -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)

2
fs/cifsd/misc.c
View file

@ -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;
}
}

14
fs/cifsd/ndr.c
View file

@ -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;
}

20
fs/cifsd/oplock.c
View file

@ -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;
}

6
fs/cifsd/server.c
View file

@ -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;
}

8
fs/cifsd/smb2misc.c
View file

@ -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;
}

204
fs/cifsd/smb2pdu.c
View file

@ -66,7 +66,7 @@ static inline int check_session_id(struct ksmbd_conn *conn, u64 id)
sess = ksmbd_session_lookup_all(conn, id);
if (sess)
return 1;
ksmbd_err("Invalid user session id: %llu\n", id);
pr_err("Invalid user session id: %llu\n", id);
return 0;
}
@ -109,7 +109,7 @@ int smb2_get_ksmbd_tcon(struct ksmbd_work *work)
tree_id = le32_to_cpu(req_hdr->Id.SyncId.TreeId);
work->tcon = ksmbd_tree_conn_lookup(work->sess, tree_id);
if (!work->tcon) {
ksmbd_err("Invalid tid %d\n", tree_id);
pr_err("Invalid tid %d\n", tree_id);
return -1;
}
@ -329,7 +329,7 @@ int smb2_set_rsp_credits(struct ksmbd_work *work)
min_credits = conn->max_credits >> 4;
if (conn->total_credits >= conn->max_credits) {
ksmbd_err("Total credits overflow: %d\n", conn->total_credits);
pr_err("Total credits overflow: %d\n", conn->total_credits);
conn->total_credits = min_credits;
}
@ -634,7 +634,7 @@ smb2_get_name(struct ksmbd_share_config *share, const char *src,
name = smb_strndup_from_utf16(src, maxlen, 1, local_nls);
if (IS_ERR(name)) {
ksmbd_err("failed to get name %ld\n", PTR_ERR(name));
pr_err("failed to get name %ld\n", PTR_ERR(name));
return name;
}
@ -645,7 +645,7 @@ smb2_get_name(struct ksmbd_share_config *share, const char *src,
unixname = convert_to_unix_name(share, name);
kfree(name);
if (!unixname) {
ksmbd_err("can not convert absolute name\n");
pr_err("can not convert absolute name\n");
return ERR_PTR(-ENOMEM);
}
@ -664,7 +664,7 @@ int setup_async_work(struct ksmbd_work *work, void (*fn)(void **), void **arg)
id = ksmbd_acquire_async_msg_id(&conn->async_ida);
if (id < 0) {
ksmbd_err("Failed to alloc async message id\n");
pr_err("Failed to alloc async message id\n");
return id;
}
work->syncronous = false;
@ -1005,13 +1005,13 @@ int smb2_handle_negotiate(struct ksmbd_work *work)
ksmbd_debug(SMB, "Received negotiate request\n");
conn->need_neg = false;
if (ksmbd_conn_good(work)) {
ksmbd_err("conn->tcp_status is already in CifsGood State\n");
pr_err("conn->tcp_status is already in CifsGood State\n");
work->send_no_response = 1;
return rc;
}
if (req->DialectCount == 0) {
ksmbd_err("malformed packet\n");
pr_err("malformed packet\n");
rsp->hdr.Status = STATUS_INVALID_PARAMETER;
rc = -EINVAL;
goto err_out;
@ -1031,8 +1031,8 @@ int smb2_handle_negotiate(struct ksmbd_work *work)
status = deassemble_neg_contexts(conn, req);
if (status != STATUS_SUCCESS) {
ksmbd_err("deassemble_neg_contexts error(0x%x)\n",
status);
pr_err("deassemble_neg_contexts error(0x%x)\n",
status);
rsp->hdr.Status = status;
rc = -EINVAL;
goto err_out;
@ -1293,7 +1293,7 @@ static struct ksmbd_user *session_user(struct ksmbd_conn *conn,
true,
conn->local_nls);
if (IS_ERR(name)) {
ksmbd_err("cannot allocate memory\n");
pr_err("cannot allocate memory\n");
return NULL;
}
@ -1438,7 +1438,7 @@ static int ntlm_authenticate(struct ksmbd_work *work)
if (conn->dialect > SMB20_PROT_ID) {
if (!ksmbd_conn_lookup_dialect(conn)) {
ksmbd_err("fail to verify the dialect\n");
pr_err("fail to verify the dialect\n");
rsp->hdr.Status = STATUS_USER_SESSION_DELETED;
return -EPERM;
}
@ -1528,7 +1528,7 @@ static int krb5_authenticate(struct ksmbd_work *work)
if (conn->dialect > SMB20_PROT_ID) {
if (!ksmbd_conn_lookup_dialect(conn)) {
ksmbd_err("fail to verify the dialect\n");
pr_err("fail to verify the dialect\n");
rsp->hdr.Status = STATUS_USER_SESSION_DELETED;
return -EPERM;
}
@ -1688,11 +1688,11 @@ int smb2_sess_setup(struct ksmbd_work *work)
}
} else {
/* TODO: need one more negotiation */
ksmbd_err("Not support the preferred authentication\n");
pr_err("Not support the preferred authentication\n");
rc = -EINVAL;
}
} else {
ksmbd_err("Not support authentication\n");
pr_err("Not support authentication\n");
rc = -EINVAL;
}
@ -1742,7 +1742,7 @@ int smb2_tree_connect(struct ksmbd_work *work)
le16_to_cpu(req->PathLength), true,
conn->local_nls);
if (IS_ERR(treename)) {
ksmbd_err("treename is NULL\n");
pr_err("treename is NULL\n");
status.ret = KSMBD_TREE_CONN_STATUS_ERROR;
goto out_err1;
}
@ -1986,7 +1986,7 @@ static noinline int create_smb2_pipe(struct ksmbd_work *work)
id = ksmbd_session_rpc_open(work->sess, name);
if (id < 0) {
ksmbd_err("Unable to open RPC pipe: %d\n", id);
pr_err("Unable to open RPC pipe: %d\n", id);
err = id;
goto out;
}
@ -2120,7 +2120,7 @@ static inline int check_context_err(void *ctx, char *str)
ksmbd_debug(SMB, "find context %s err %d\n", str, err);
if (err == -EINVAL) {
ksmbd_err("bad name length\n");
pr_err("bad name length\n");
return err;
}
@ -2159,7 +2159,7 @@ static noinline int smb2_set_stream_name_xattr(struct path *path,
rc = ksmbd_vfs_setxattr(path->dentry, xattr_stream_name, NULL, 0, 0);
if (rc < 0)
ksmbd_err("Failed to store XATTR stream name :%d\n", rc);
pr_err("Failed to store XATTR stream name :%d\n", rc);
return 0;
}
@ -2201,7 +2201,7 @@ static int smb2_create_truncate(struct path *path)
int rc = vfs_truncate(path, 0);
if (rc) {
ksmbd_err("vfs_truncate failed, rc %d\n", rc);
pr_err("vfs_truncate failed, rc %d\n", rc);
return rc;
}
@ -2287,8 +2287,8 @@ static int smb2_creat(struct ksmbd_work *work, struct path *path, char *name,
rc = ksmbd_vfs_kern_path(name, 0, path, 0);
if (rc) {
ksmbd_err("cannot get linux path (%s), err = %d\n",
name, rc);
pr_err("cannot get linux path (%s), err = %d\n",
name, rc);
return rc;
}
return 0;
@ -2387,7 +2387,7 @@ int smb2_open(struct ksmbd_work *work)
if (req->NameLength) {
if ((req->CreateOptions & FILE_DIRECTORY_FILE_LE) &&
*(char *)req->Buffer == '\\') {
ksmbd_err("not allow directory name included leading slash\n");
pr_err("not allow directory name included leading slash\n");
rc = -EINVAL;
goto err_out1;
}
@ -2444,16 +2444,16 @@ int smb2_open(struct ksmbd_work *work)
lc = parse_lease_state(req);
if (le32_to_cpu(req->ImpersonationLevel) > le32_to_cpu(IL_DELEGATE_LE)) {
ksmbd_err("Invalid impersonationlevel : 0x%x\n",
le32_to_cpu(req->ImpersonationLevel));
pr_err("Invalid impersonationlevel : 0x%x\n",
le32_to_cpu(req->ImpersonationLevel));
rc = -EIO;
rsp->hdr.Status = STATUS_BAD_IMPERSONATION_LEVEL;
goto err_out1;
}
if (req->CreateOptions && !(req->CreateOptions & CREATE_OPTIONS_MASK)) {
ksmbd_err("Invalid create options : 0x%x\n",
le32_to_cpu(req->CreateOptions));
pr_err("Invalid create options : 0x%x\n",
le32_to_cpu(req->CreateOptions));
rc = -EINVAL;
goto err_out1;
} else {
@ -2480,22 +2480,22 @@ int smb2_open(struct ksmbd_work *work)
if (le32_to_cpu(req->CreateDisposition) >
le32_to_cpu(FILE_OVERWRITE_IF_LE)) {
ksmbd_err("Invalid create disposition : 0x%x\n",
le32_to_cpu(req->CreateDisposition));
pr_err("Invalid create disposition : 0x%x\n",
le32_to_cpu(req->CreateDisposition));
rc = -EINVAL;
goto err_out1;
}
if (!(req->DesiredAccess & DESIRED_ACCESS_MASK)) {
ksmbd_err("Invalid desired access : 0x%x\n",
le32_to_cpu(req->DesiredAccess));
pr_err("Invalid desired access : 0x%x\n",
le32_to_cpu(req->DesiredAccess));
rc = -EACCES;
goto err_out1;
}
if (req->FileAttributes && !(req->FileAttributes & ATTR_MASK_LE)) {
ksmbd_err("Invalid file attribute : 0x%x\n",
le32_to_cpu(req->FileAttributes));
pr_err("Invalid file attribute : 0x%x\n",
le32_to_cpu(req->FileAttributes));
rc = -EINVAL;
goto err_out1;
}
@ -2750,7 +2750,7 @@ int smb2_open(struct ksmbd_work *work)
filp = dentry_open(&path, open_flags, current_cred());
if (IS_ERR(filp)) {
rc = PTR_ERR(filp);
ksmbd_err("dentry open for dir failed, rc %d\n", rc);
pr_err("dentry open for dir failed, rc %d\n", rc);
goto err_out;
}
@ -2846,8 +2846,8 @@ int smb2_open(struct ksmbd_work *work)
pntsd_size);
kfree(pntsd);
if (rc)
ksmbd_err("failed to store ntacl in xattr : %d\n",
rc);
pr_err("failed to store ntacl in xattr : %d\n",
rc);
}
}
}
@ -3697,14 +3697,14 @@ int smb2_query_dir(struct ksmbd_work *work)
if (!(dir_fp->daccess & FILE_LIST_DIRECTORY_LE) ||
inode_permission(&init_user_ns, file_inode(dir_fp->filp),
MAY_READ | MAY_EXEC)) {
ksmbd_err("no right to enumerate directory (%s)\n",
FP_FILENAME(dir_fp));
pr_err("no right to enumerate directory (%s)\n",
FP_FILENAME(dir_fp));
rc = -EACCES;
goto err_out2;
}
if (!S_ISDIR(file_inode(dir_fp->filp)->i_mode)) {
ksmbd_err("can't do query dir for a file\n");
pr_err("can't do query dir for a file\n");
rc = -EINVAL;
goto err_out2;
}
@ -3805,7 +3805,7 @@ int smb2_query_dir(struct ksmbd_work *work)
return 0;
err_out:
ksmbd_err("error while processing smb2 query dir rc = %d\n", rc);
pr_err("error while processing smb2 query dir rc = %d\n", rc);
kfree(srch_ptr);
err_out2:
@ -3843,7 +3843,7 @@ static int buffer_check_err(int reqOutputBufferLength,
{
if (reqOutputBufferLength < le32_to_cpu(rsp->OutputBufferLength)) {
if (reqOutputBufferLength < infoclass_size) {
ksmbd_err("Invalid Buffer Size Requested\n");
pr_err("Invalid Buffer Size Requested\n");
rsp->hdr.Status = STATUS_INFO_LENGTH_MISMATCH;
rsp->hdr.smb2_buf_length = cpu_to_be32(sizeof(struct smb2_hdr) - 4);
return -EINVAL;
@ -3946,8 +3946,8 @@ static int smb2_get_ea(struct ksmbd_work *work, struct ksmbd_file *fp,
struct path *path;
if (!(fp->daccess & FILE_READ_EA_LE)) {
ksmbd_err("Not permitted to read ext attr : 0x%x\n",
fp->daccess);
pr_err("Not permitted to read ext attr : 0x%x\n",
fp->daccess);
return -EACCES;
}
@ -4103,8 +4103,8 @@ static int get_file_basic_info(struct smb2_query_info_rsp *rsp,
u64 time;
if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) {
ksmbd_err("no right to read the attributes : 0x%x\n",
fp->daccess);
pr_err("no right to read the attributes : 0x%x\n",
fp->daccess);
return -EACCES;
}
@ -4375,8 +4375,8 @@ static int get_file_network_open_info(struct smb2_query_info_rsp *rsp,
u64 time;
if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) {
ksmbd_err("no right to read the attributes : 0x%x\n",
fp->daccess);
pr_err("no right to read the attributes : 0x%x\n",
fp->daccess);
return -EACCES;
}
@ -4465,8 +4465,8 @@ static int get_file_attribute_tag_info(struct smb2_query_info_rsp *rsp,
struct smb2_file_attr_tag_info *file_info;
if (!(fp->daccess & FILE_READ_ATTRIBUTES_LE)) {
ksmbd_err("no right to read the attributes : 0x%x\n",
fp->daccess);
pr_err("no right to read the attributes : 0x%x\n",
fp->daccess);
return -EACCES;
}
@ -4620,7 +4620,7 @@ static int smb2_get_info_file(struct ksmbd_work *work,
break;
case SMB_FIND_FILE_POSIX_INFO:
if (!work->tcon->posix_extensions) {
ksmbd_err("client doesn't negotiate with SMB3.1.1 POSIX Extensions\n");
pr_err("client doesn't negotiate with SMB3.1.1 POSIX Extensions\n");
rc = -EOPNOTSUPP;
} else {
rc = find_file_posix_info(rsp, fp, rsp_org);
@ -4659,13 +4659,13 @@ static int smb2_get_info_filesystem(struct ksmbd_work *work,
rc = ksmbd_vfs_kern_path(share->path, lookup_flags, &path, 0);
if (rc) {
ksmbd_err("cannot create vfs path\n");
pr_err("cannot create vfs path\n");
return -EIO;
}
rc = vfs_statfs(&path, &stfs);
if (rc) {
ksmbd_err("cannot do stat of path %s\n", share->path);
pr_err("cannot do stat of path %s\n", share->path);
path_put(&path);
return -EIO;
}
@ -4846,7 +4846,7 @@ static int smb2_get_info_filesystem(struct ksmbd_work *work,
unsigned short logical_sector_size;
if (!work->tcon->posix_extensions) {
ksmbd_err("client doesn't negotiate with SMB3.1.1 POSIX Extensions\n");
pr_err("client doesn't negotiate with SMB3.1.1 POSIX Extensions\n");
rc = -EOPNOTSUPP;
} else {
info = (struct filesystem_posix_info *)(rsp->Buffer);
@ -5213,7 +5213,7 @@ static int smb2_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
len = strlen(new_name);
if (new_name[len - 1] != '/') {
ksmbd_err("not allow base filename in rename\n");
pr_err("not allow base filename in rename\n");
rc = -ESHARE;
goto out;
}
@ -5229,8 +5229,8 @@ static int smb2_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
xattr_stream_name,
NULL, 0, 0);
if (rc < 0) {
ksmbd_err("failed to store stream name in xattr: %d\n",
rc);
pr_err("failed to store stream name in xattr: %d\n",
rc);
rc = -EINVAL;
goto out;
}
@ -5389,7 +5389,7 @@ static int set_file_basic_info(struct ksmbd_file *fp, char *buf,
if (file_info->Attributes) {
if (!S_ISDIR(inode->i_mode) &&
file_info->Attributes & ATTR_DIRECTORY_LE) {
ksmbd_err("can't change a file to a directory\n");
pr_err("can't change a file to a directory\n");
return -EINVAL;
}
@ -5467,7 +5467,7 @@ static int set_file_allocation_info(struct ksmbd_work *work,
if (alloc_blks > inode->i_blocks) {
rc = ksmbd_vfs_alloc_size(work, fp, alloc_blks * 512);
if (rc && rc != -EOPNOTSUPP) {
ksmbd_err("ksmbd_vfs_alloc_size is failed : %d\n", rc);
pr_err("ksmbd_vfs_alloc_size is failed : %d\n", rc);
return rc;
}
} else if (alloc_blks < inode->i_blocks) {
@ -5483,8 +5483,8 @@ static int set_file_allocation_info(struct ksmbd_work *work,
size = i_size_read(inode);
rc = ksmbd_vfs_truncate(work, NULL, fp, alloc_blks * 512);
if (rc) {
ksmbd_err("truncate failed! filename : %s, err %d\n",
fp->filename, rc);
pr_err("truncate failed! filename : %s, err %d\n",
fp->filename, rc);
return rc;
}
if (size < alloc_blks * 512)
@ -5536,7 +5536,7 @@ static int set_rename_info(struct ksmbd_work *work, struct ksmbd_file *fp,
struct ksmbd_file *parent_fp;
if (!(fp->daccess & FILE_DELETE_LE)) {
ksmbd_err("no right to delete : 0x%x\n", fp->daccess);
pr_err("no right to delete : 0x%x\n", fp->daccess);
return -EACCES;
}
@ -5546,7 +5546,7 @@ static int set_rename_info(struct ksmbd_work *work, struct ksmbd_file *fp,
parent_fp = ksmbd_lookup_fd_inode(PARENT_INODE(fp));
if (parent_fp) {
if (parent_fp->daccess & FILE_DELETE_LE) {
ksmbd_err("parent dir is opened with delete access\n");
pr_err("parent dir is opened with delete access\n");
return -ESHARE;
}
}
@ -5562,7 +5562,7 @@ static int set_file_disposition_info(struct ksmbd_file *fp, char *buf)
struct inode *inode;
if (!(fp->daccess & FILE_DELETE_LE)) {
ksmbd_err("no right to delete : 0x%x\n", fp->daccess);
pr_err("no right to delete : 0x%x\n", fp->daccess);
return -EACCES;
}
@ -5594,8 +5594,8 @@ static int set_file_position_info(struct ksmbd_file *fp, char *buf)
if (current_byte_offset < 0 ||
(fp->coption == FILE_NO_INTERMEDIATE_BUFFERING_LE &&
current_byte_offset & (sector_size - 1))) {
ksmbd_err("CurrentByteOffset is not valid : %llu\n",
current_byte_offset);
pr_err("CurrentByteOffset is not valid : %llu\n",
current_byte_offset);
return -EINVAL;
}
@ -5614,7 +5614,7 @@ static int set_file_mode_info(struct ksmbd_file *fp, char *buf)
if ((mode & ~FILE_MODE_INFO_MASK) ||
(mode & FILE_SYNCHRONOUS_IO_ALERT_LE &&
mode & FILE_SYNCHRONOUS_IO_NONALERT_LE)) {
ksmbd_err("Mode is not valid : 0x%x\n", le32_to_cpu(mode));
pr_err("Mode is not valid : 0x%x\n", le32_to_cpu(mode));
return -EINVAL;
}
@ -5675,8 +5675,8 @@ static int smb2_set_info_file(struct ksmbd_work *work, struct ksmbd_file *fp,
case FILE_FULL_EA_INFORMATION:
{
if (!(fp->daccess & FILE_WRITE_EA_LE)) {
ksmbd_err("Not permitted to write ext attr: 0x%x\n",
fp->daccess);
pr_err("Not permitted to write ext attr: 0x%x\n",
fp->daccess);
return -EACCES;
}
@ -5691,7 +5691,7 @@ static int smb2_set_info_file(struct ksmbd_work *work, struct ksmbd_file *fp,
return set_file_mode_info(fp, buf);
}
ksmbd_err("Unimplemented Fileinfoclass :%d\n", info_class);
pr_err("Unimplemented Fileinfoclass :%d\n", info_class);
return -EOPNOTSUPP;
}
@ -5919,7 +5919,7 @@ int smb2_read(struct ksmbd_work *work)
}
if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_READ_ATTRIBUTES_LE))) {
ksmbd_err("Not permitted to read : 0x%x\n", fp->daccess);
pr_err("Not permitted to read : 0x%x\n", fp->daccess);
err = -EACCES;
goto out;
}
@ -6039,9 +6039,9 @@ static noinline int smb2_write_pipe(struct ksmbd_work *work)
} else {
if ((le16_to_cpu(req->DataOffset) > get_rfc1002_len(req)) ||
(le16_to_cpu(req->DataOffset) + length > get_rfc1002_len(req))) {
ksmbd_err("invalid write data offset %u, smb_len %u\n",
le16_to_cpu(req->DataOffset),
get_rfc1002_len(req));
pr_err("invalid write data offset %u, smb_len %u\n",
le16_to_cpu(req->DataOffset),
get_rfc1002_len(req));
err = -EINVAL;
goto out;
}
@ -6172,7 +6172,7 @@ int smb2_write(struct ksmbd_work *work)
}
if (!(fp->daccess & (FILE_WRITE_DATA_LE | FILE_READ_ATTRIBUTES_LE))) {
ksmbd_err("Not permitted to write : 0x%x\n", fp->daccess);
pr_err("Not permitted to write : 0x%x\n", fp->daccess);
err = -EACCES;
goto out;
}
@ -6198,9 +6198,9 @@ int smb2_write(struct ksmbd_work *work)
} else {
if ((le16_to_cpu(req->DataOffset) > get_rfc1002_len(req)) ||
(le16_to_cpu(req->DataOffset) + length > get_rfc1002_len(req))) {
ksmbd_err("invalid write data offset %u, smb_len %u\n",
le16_to_cpu(req->DataOffset),
get_rfc1002_len(req));
pr_err("invalid write data offset %u, smb_len %u\n",
le16_to_cpu(req->DataOffset),
get_rfc1002_len(req));
err = -EINVAL;
goto out;
}
@ -6530,7 +6530,7 @@ int smb2_lock(struct ksmbd_work *work)
lock_start = le64_to_cpu(lock_ele[i].Offset);
lock_length = le64_to_cpu(lock_ele[i].Length);
if (lock_start > U64_MAX - lock_length) {
ksmbd_err("Invalid lock range requested\n");
pr_err("Invalid lock range requested\n");
rsp->hdr.Status = STATUS_INVALID_LOCK_RANGE;
goto out;
}
@ -6560,7 +6560,7 @@ int smb2_lock(struct ksmbd_work *work)
cmp_lock->fl->fl_end >= flock->fl_end) {
if (cmp_lock->fl->fl_type != F_UNLCK &&
flock->fl_type != F_UNLCK) {
ksmbd_err("conflict two locks in one request\n");
pr_err("conflict two locks in one request\n");
rsp->hdr.Status =
STATUS_INVALID_PARAMETER;
goto out;
@ -6633,7 +6633,7 @@ int smb2_lock(struct ksmbd_work *work)
if (cmp_lock->zero_len && !smb_lock->zero_len &&
cmp_lock->start > smb_lock->start &&
cmp_lock->start < smb_lock->end) {
ksmbd_err("previous lock conflict with zero byte lock range\n");
pr_err("previous lock conflict with zero byte lock range\n");
rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
goto out;
}
@ -6641,7 +6641,7 @@ int smb2_lock(struct ksmbd_work *work)
if (smb_lock->zero_len && !cmp_lock->zero_len &&
smb_lock->start > cmp_lock->start &&
smb_lock->start < cmp_lock->end) {
ksmbd_err("current lock conflict with zero byte lock range\n");
pr_err("current lock conflict with zero byte lock range\n");
rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
goto out;
}
@ -6650,7 +6650,7 @@ int smb2_lock(struct ksmbd_work *work)
cmp_lock->end > smb_lock->start) ||
(cmp_lock->start < smb_lock->end && cmp_lock->end >= smb_lock->end)) &&
!cmp_lock->zero_len && !smb_lock->zero_len) {
ksmbd_err("Not allow lock operation on exclusive lock range\n");
pr_err("Not allow lock operation on exclusive lock range\n");
rsp->hdr.Status =
STATUS_LOCK_NOT_GRANTED;
goto out;
@ -6658,7 +6658,7 @@ int smb2_lock(struct ksmbd_work *work)
}
if (smb_lock->fl->fl_type == F_UNLCK && nolock) {
ksmbd_err("Try to unlock nolocked range\n");
pr_err("Try to unlock nolocked range\n");
rsp->hdr.Status = STATUS_RANGE_NOT_LOCKED;
goto out;
}
@ -6787,7 +6787,7 @@ int smb2_lock(struct ksmbd_work *work)
err = ksmbd_vfs_lock(filp, 0, rlock);
if (err)
ksmbd_err("rollback unlock fail : %d\n", err);
pr_err("rollback unlock fail : %d\n", err);
list_del(&smb_lock->llist);
list_del(&smb_lock->glist);
locks_free_lock(smb_lock->fl);
@ -6974,8 +6974,8 @@ static int fsctl_query_iface_info_ioctl(struct ksmbd_conn *conn,
netdev->ethtool_ops->get_link_ksettings(netdev, &cmd);
speed = cmd.base.speed;
} else {
ksmbd_err("%s %s\n", netdev->name,
"speed is unknown, defaulting to 1Gb/sec");
pr_err("%s %s\n", netdev->name,
"speed is unknown, defaulting to 1Gb/sec");
speed = SPEED_1000;
}
@ -7387,7 +7387,7 @@ int smb2_ioctl(struct ksmbd_work *work)
reparse_ptr = (struct reparse_data_buffer *)&rsp->Buffer[0];
fp = ksmbd_lookup_fd_fast(work, id);
if (!fp) {
ksmbd_err("not found fp!!\n");
pr_err("not found fp!!\n");
ret = -ENOENT;
goto out;
}
@ -7410,14 +7410,14 @@ int smb2_ioctl(struct ksmbd_work *work)
fp_in = ksmbd_lookup_fd_slow(work, dup_ext->VolatileFileHandle,
dup_ext->PersistentFileHandle);
if (!fp_in) {
ksmbd_err("not found file handle in duplicate extent to file\n");
pr_err("not found file handle in duplicate extent to file\n");
ret = -ENOENT;
goto out;
}
fp_out = ksmbd_lookup_fd_fast(work, id);
if (!fp_out) {
ksmbd_err("not found fp\n");
pr_err("not found fp\n");
ret = -ENOENT;
goto dup_ext_out;
}
@ -7514,7 +7514,7 @@ static void smb20_oplock_break_ack(struct ksmbd_work *work)
opinfo = opinfo_get(fp);
if (!opinfo) {
ksmbd_err("unexpected null oplock_info\n");
pr_err("unexpected null oplock_info\n");
rsp->hdr.Status = STATUS_INVALID_OPLOCK_PROTOCOL;
smb2_set_err_rsp(work);
ksmbd_fd_put(work, fp);
@ -7577,8 +7577,8 @@ static void smb20_oplock_break_ack(struct ksmbd_work *work)
rsp_oplevel = SMB2_OPLOCK_LEVEL_NONE;
break;
default:
ksmbd_err("unknown oplock change 0x%x -> 0x%x\n",
opinfo->level, rsp_oplevel);
pr_err("unknown oplock change 0x%x -> 0x%x\n",
opinfo->level, rsp_oplevel);
}
if (ret < 0) {
@ -7654,8 +7654,8 @@ static void smb21_lease_break_ack(struct ksmbd_work *work)
lease = opinfo->o_lease;
if (opinfo->op_state == OPLOCK_STATE_NONE) {
ksmbd_err("unexpected lease break state 0x%x\n",
opinfo->op_state);
pr_err("unexpected lease break state 0x%x\n",
opinfo->op_state);
rsp->hdr.Status = STATUS_UNSUCCESSFUL;
goto err_out;
}
@ -7868,7 +7868,7 @@ int smb2_check_sign_req(struct ksmbd_work *work)
return 0;
if (memcmp(signature, signature_req, SMB2_SIGNATURE_SIZE)) {
ksmbd_err("bad smb2 signature\n");
pr_err("bad smb2 signature\n");
return 0;
}
@ -7965,7 +7965,7 @@ int smb3_check_sign_req(struct ksmbd_work *work)
}
if (!signing_key) {
ksmbd_err("SMB3 signing key is not generated\n");
pr_err("SMB3 signing key is not generated\n");
return 0;
}
@ -7978,7 +7978,7 @@ int smb3_check_sign_req(struct ksmbd_work *work)
return 0;
if (memcmp(signature, signature_req, SMB2_SIGNATURE_SIZE)) {
ksmbd_err("bad smb2 signature\n");
pr_err("bad smb2 signature\n");
return 0;
}
@ -8175,20 +8175,20 @@ int smb3_decrypt_req(struct ksmbd_work *work)
sess = ksmbd_session_lookup_all(conn, le64_to_cpu(tr_hdr->SessionId));
if (!sess) {
ksmbd_err("invalid session id(%llx) in transform header\n",
le64_to_cpu(tr_hdr->SessionId));
pr_err("invalid session id(%llx) in transform header\n",
le64_to_cpu(tr_hdr->SessionId));
return -ECONNABORTED;
}
if (pdu_length + 4 <
sizeof(struct smb2_transform_hdr) + sizeof(struct smb2_hdr)) {
ksmbd_err("Transform message is too small (%u)\n",
pdu_length);
pr_err("Transform message is too small (%u)\n",
pdu_length);
return -ECONNABORTED;
}
if (pdu_length + 4 < orig_len + sizeof(struct smb2_transform_hdr)) {
ksmbd_err("Transform message is broken\n");
pr_err("Transform message is broken\n");
return -ECONNABORTED;
}

2
fs/cifsd/smb_common.c
View file

@ -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;
}

26
fs/cifsd/smbacl.c
View file

@ -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;
}
}

30
fs/cifsd/transport_ipc.c
View file

@ -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);
}

106
fs/cifsd/transport_rdma.c
View file

@ -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;
}

20
fs/cifsd/transport_tcp.c
View file

@ -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)

88
fs/cifsd/vfs.c
View file

@ -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;
}

10
fs/cifsd/vfs_cache.c
View file

@ -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;
}