#endif
};
-
void ksmbd_copy_gss_neg_header(void *buf)
{
memcpy(buf, NEGOTIATE_GSS_HEADER, AUTH_GSS_LENGTH);
return 0;
}
-static int ksmbd_enc_p24(unsigned char *p21,
- const unsigned char *c8,
- unsigned char *p24)
+static int ksmbd_enc_p24(unsigned char *p21, const unsigned char *c8, unsigned char *p24)
{
int rc;
}
/* produce a md4 message digest from data of length n bytes */
-static int ksmbd_enc_md4(unsigned char *md4_hash,
- unsigned char *link_str,
- int link_len)
+static int ksmbd_enc_md4(unsigned char *md4_hash, unsigned char *link_str,
+ int link_len)
{
int rc;
struct ksmbd_crypto_ctx *ctx;
return rc;
}
-static int ksmbd_enc_update_sess_key(unsigned char *md5_hash,
- char *nonce,
- char *server_challenge,
- int len)
+static int ksmbd_enc_update_sess_key(unsigned char *md5_hash, char *nonce,
+ char *server_challenge, int len)
{
int rc;
struct ksmbd_crypto_ctx *ctx;
* @hmac: source hmac value to be used for finding session key
*
*/
-static int ksmbd_gen_sess_key(struct ksmbd_session *sess,
- char *hash,
- char *hmac)
+static int ksmbd_gen_sess_key(struct ksmbd_session *sess, char *hash,
+ char *hmac)
{
struct ksmbd_crypto_ctx *ctx;
int rc = -EINVAL;
}
static int calc_ntlmv2_hash(struct ksmbd_session *sess, char *ntlmv2_hash,
- char *dname)
+ char *dname)
{
int ret = -EINVAL, len;
wchar_t *domain = NULL;
if (strncmp(pw_buf, key, CIFS_AUTH_RESP_SIZE) != 0) {
ksmbd_debug(AUTH, "ntlmv1 authentication failed\n");
rc = -EINVAL;
- } else
+ } else {
ksmbd_debug(AUTH, "ntlmv1 authentication pass\n");
+ }
return rc;
}
*
* Return: 0 on success, error number on error
*/
-int ksmbd_auth_ntlmv2(struct ksmbd_session *sess,
- struct ntlmv2_resp *ntlmv2,
- int blen,
- char *domain_name)
+int ksmbd_auth_ntlmv2(struct ksmbd_session *sess, struct ntlmv2_resp *ntlmv2,
+ int blen, char *domain_name)
{
char ntlmv2_hash[CIFS_ENCPWD_SIZE];
char ntlmv2_rsp[CIFS_HMAC_MD5_HASH_SIZE];
*
* Return: 0 on success, error number on error
*/
-static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess,
- char *client_nonce,
- char *ntlm_resp)
+static int __ksmbd_auth_ntlmv2(struct ksmbd_session *sess, char *client_nonce,
+ char *ntlm_resp)
{
char sess_key[CIFS_SMB1_SESSKEY_SIZE] = {0};
int rc;
* Return: 0 on success, error number on error
*/
int ksmbd_decode_ntlmssp_auth_blob(struct authenticate_message *authblob,
- int blob_len,
- struct ksmbd_session *sess)
+ int blob_len, struct ksmbd_session *sess)
{
char *domain_name;
unsigned int lm_off, nt_off;
/* process NTLM authentication */
if (nt_len == CIFS_AUTH_RESP_SIZE) {
- if (le32_to_cpu(authblob->NegotiateFlags)
- & NTLMSSP_NEGOTIATE_EXTENDED_SEC)
+ if (le32_to_cpu(authblob->NegotiateFlags) &
+ NTLMSSP_NEGOTIATE_EXTENDED_SEC)
return __ksmbd_auth_ntlmv2(sess, (char *)authblob +
lm_off, (char *)authblob + nt_off);
else
}
/* TODO : use domain name that imported from configuration file */
- domain_name = smb_strndup_from_utf16(
- (const char *)authblob +
+ domain_name = smb_strndup_from_utf16((const char *)authblob +
le32_to_cpu(authblob->DomainName.BufferOffset),
le16_to_cpu(authblob->DomainName.Length), true,
sess->conn->local_nls);
*
*/
int ksmbd_decode_ntlmssp_neg_blob(struct negotiate_message *negblob,
- int blob_len,
- struct ksmbd_session *sess)
+ int blob_len, struct ksmbd_session *sess)
{
if (blob_len < sizeof(struct negotiate_message)) {
ksmbd_debug(AUTH, "negotiate blob len %d too small\n",
flags |= NTLMSSP_REQUEST_TARGET;
if (sess->conn->use_spnego &&
- (cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
+ (cflags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
flags |= NTLMSSP_NEGOTIATE_EXTENDED_SEC;
chgblob->NegotiateFlags = cpu_to_le32(flags);
}
#ifdef CONFIG_SMB_SERVER_KERBEROS5
-int ksmbd_krb5_authenticate(struct ksmbd_session *sess,
- char *in_blob, int in_len,
- char *out_blob, int *out_len)
+int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob,
+ int in_len, char *out_blob, int *out_len)
{
struct ksmbd_spnego_authen_response *resp;
struct ksmbd_user *user = NULL;
return retval;
}
#else
-int ksmbd_krb5_authenticate(struct ksmbd_session *sess,
- char *in_blob, int in_len,
- char *out_blob, int *out_len)
+int ksmbd_krb5_authenticate(struct ksmbd_session *sess, char *in_blob,
+ int in_len, char *out_blob, int *out_len)
{
return -EOPNOTSUPP;
}
* @sig: signature value generated for client request packet
*
*/
-int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn,
- char *key,
- struct kvec *iov,
- int n_vec,
- char *sig)
+int ksmbd_sign_smb2_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov,
+ int n_vec, char *sig)
{
struct ksmbd_crypto_ctx *ctx;
int rc = -EINVAL;
* @sig: signature value generated for client request packet
*
*/
-int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn,
- char *key,
- struct kvec *iov,
- int n_vec,
- char *sig)
+int ksmbd_sign_smb3_pdu(struct ksmbd_conn *conn, char *key, struct kvec *iov,
+ int n_vec, char *sig)
{
struct ksmbd_crypto_ctx *ctx;
int rc = -EINVAL;
};
static int generate_key(struct ksmbd_session *sess, struct kvec label,
- struct kvec context, __u8 *key, unsigned int key_size)
+ struct kvec context, __u8 *key, unsigned int key_size)
{
unsigned char zero = 0x0;
__u8 i[4] = {0, 0, 0, 1};
}
static int generate_smb3signingkey(struct ksmbd_session *sess,
- const struct derivation *signing)
+ const struct derivation *signing)
{
int rc;
struct channel *chann;
};
static int generate_smb3encryptionkey(struct ksmbd_session *sess,
- const struct derivation_twin *ptwin)
+ const struct derivation_twin *ptwin)
{
int rc;
return generate_smb3encryptionkey(sess, &twin);
}
-int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn,
- char *buf,
- __u8 *pi_hash)
+int ksmbd_gen_preauth_integrity_hash(struct ksmbd_conn *conn, char *buf,
+ __u8 *pi_hash)
{
int rc = -1;
struct smb2_hdr *rcv_hdr = (struct smb2_hdr *)buf;
struct ksmbd_crypto_ctx *ctx = NULL;
if (conn->preauth_info->Preauth_HashId ==
- SMB2_PREAUTH_INTEGRITY_SHA512) {
+ SMB2_PREAUTH_INTEGRITY_SHA512) {
ctx = ksmbd_crypto_ctx_find_sha512();
if (!ctx) {
ksmbd_debug(AUTH, "could not alloc sha512 rc %d\n", rc);
goto out;
}
- } else
+ } else {
goto out;
+ }
rc = crypto_shash_init(CRYPTO_SHA512(ctx));
if (rc) {
return rc;
}
-static int ksmbd_get_encryption_key(struct ksmbd_conn *conn,
- __u64 ses_id,
- int enc,
- u8 *key)
+static int ksmbd_get_encryption_key(struct ksmbd_conn *conn, __u64 ses_id,
+ int enc, u8 *key)
{
struct ksmbd_session *sess;
u8 *ses_enc_key;
sg_set_page(sg, addr, buflen, offset_in_page(buf));
}
-static struct scatterlist *ksmbd_init_sg(struct kvec *iov,
- unsigned int nvec,
- u8 *sign)
+static struct scatterlist *ksmbd_init_sg(struct kvec *iov, unsigned int nvec,
+ u8 *sign)
{
struct scatterlist *sg;
unsigned int assoc_data_len = sizeof(struct smb2_transform_hdr) - 24;
nr_entries[i] = ((kaddr + iov[i + 1].iov_len +
PAGE_SIZE - 1) >> PAGE_SHIFT) -
(kaddr >> PAGE_SHIFT);
- } else
+ } else {
nr_entries[i]++;
+ }
total_entries += nr_entries[i];
}
sg_set_page(&sg[sg_idx++], virt_to_page(data), len,
offset_in_page(data));
}
-
}
smb2_sg_set_buf(&sg[sg_idx], sign, SMB2_SIGNATURE_SIZE);
return sg;
}
-int ksmbd_crypt_message(struct ksmbd_conn *conn,
- struct kvec *iov,
- unsigned int nvec,
- int enc)
+int ksmbd_crypt_message(struct ksmbd_conn *conn, struct kvec *iov,
+ unsigned int nvec, int enc)
{
struct smb2_transform_hdr *tr_hdr =
(struct smb2_transform_hdr *)iov[0].iov_base;
goto free_sg;
}
- if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM)
+ if (conn->cipher_type == SMB2_ENCRYPTION_AES128_GCM) {
memcpy(iv, (char *)tr_hdr->Nonce, SMB3_AES128GCM_NONCE);
- else {
+ } else {
iv[0] = 3;
memcpy(iv + 1, (char *)tr_hdr->Nonce, SMB3_AES128CCM_NONCE);
}
goto out;
filp_cache = kmem_cache_create("ksmbd_file_cache",
- sizeof(struct ksmbd_file), 0,
- SLAB_HWCACHE_ALIGN, NULL);
+ sizeof(struct ksmbd_file), 0, SLAB_HWCACHE_ALIGN, NULL);
if (!filp_cache)
goto out;
int ret = 1;
if (list_empty(&work->request_entry) &&
- list_empty(&work->async_request_entry))
+ list_empty(&work->async_request_entry))
return 0;
atomic_dec(&conn->req_running);
return 0;
}
-int ksmbd_conn_rdma_read(struct ksmbd_conn *conn,
- void *buf, unsigned int buflen,
- u32 remote_key, u64 remote_offset,
- u32 remote_len)
+int ksmbd_conn_rdma_read(struct ksmbd_conn *conn, void *buf,
+ unsigned int buflen, u32 remote_key, u64 remote_offset,
+ u32 remote_len)
{
int ret = -EINVAL;
return ret;
}
-int ksmbd_conn_rdma_write(struct ksmbd_conn *conn,
- void *buf, unsigned int buflen,
- u32 remote_key, u64 remote_offset,
- u32 remote_len)
+int ksmbd_conn_rdma_write(struct ksmbd_conn *conn, void *buf,
+ unsigned int buflen, u32 remote_key, u64 remote_offset,
+ u32 remote_len)
{
int ret = -EINVAL;
* zero.
*/
if (server_conf.deadtime > 0 &&
- time_after(jiffies, conn->last_active + server_conf.deadtime)) {
+ time_after(jiffies, conn->last_active + server_conf.deadtime)) {
ksmbd_debug(CONN, "No response from client in %lu minutes\n",
server_conf.deadtime / SMB_ECHO_INTERVAL);
return false;
task = conn->transport->handler;
if (task)
ksmbd_debug(CONN, "Stop session handler %s/%d\n",
- task->comm,
- task_pid_nr(task));
+ task->comm, task_pid_nr(task));
conn->status = KSMBD_SESS_EXITING;
}
read_unlock(&conn_list_lock);
if (!list_empty(&conn_list)) {
- schedule_timeout_interruptible(HZ/10); /* 100ms */
+ schedule_timeout_interruptible(HZ / 10); /* 100ms */
goto again;
}
}
struct ksmbd_transport_ops {
int (*prepare)(struct ksmbd_transport *t);
void (*disconnect)(struct ksmbd_transport *t);
- int (*read)(struct ksmbd_transport *t,
- char *buf, unsigned int size);
- int (*writev)(struct ksmbd_transport *t,
- struct kvec *iovs, int niov, int size,
- bool need_invalidate_rkey, unsigned int remote_key);
- int (*rdma_read)(struct ksmbd_transport *t,
- void *buf, unsigned int len, u32 remote_key,
- u64 remote_offset, u32 remote_len);
- int (*rdma_write)(struct ksmbd_transport *t,
- void *buf, unsigned int len, u32 remote_key,
- u64 remote_offset, u32 remote_len);
+ int (*read)(struct ksmbd_transport *t, char *buf, unsigned int size);
+ int (*writev)(struct ksmbd_transport *t, struct kvec *iovs, int niov,
+ int size, bool need_invalidate_rkey,
+ unsigned int remote_key);
+ int (*rdma_read)(struct ksmbd_transport *t, void *buf, unsigned int len,
+ u32 remote_key, u64 remote_offset, u32 remote_len);
+ int (*rdma_write)(struct ksmbd_transport *t, void *buf,
+ unsigned int len, u32 remote_key, u64 remote_offset,
+ u32 remote_len);
};
struct ksmbd_transport {
void ksmbd_conn_free(struct ksmbd_conn *conn);
bool ksmbd_conn_lookup_dialect(struct ksmbd_conn *c);
int ksmbd_conn_write(struct ksmbd_work *work);
-int ksmbd_conn_rdma_read(struct ksmbd_conn *conn,
- void *buf, unsigned int buflen,
- u32 remote_key, u64 remote_offset,
- u32 remote_len);
-int ksmbd_conn_rdma_write(struct ksmbd_conn *conn,
- void *buf, unsigned int buflen,
- u32 remote_key, u64 remote_offset,
- u32 remote_len);
+int ksmbd_conn_rdma_read(struct ksmbd_conn *conn, void *buf,
+ unsigned int buflen, u32 remote_key, u64 remote_offset,
+ u32 remote_len);
+int ksmbd_conn_rdma_write(struct ksmbd_conn *conn, void *buf,
+ unsigned int buflen, u32 remote_key, u64 remote_offset,
+ u32 remote_len);
void ksmbd_conn_enqueue_request(struct ksmbd_work *work);
int ksmbd_conn_try_dequeue_request(struct ksmbd_work *work);
#define DATA_STREAM 1
#define DIR_STREAM 2
-#define KSMBD_DEBUG_SMB (1 << 0)
-#define KSMBD_DEBUG_AUTH (1 << 1)
-#define KSMBD_DEBUG_VFS (1 << 2)
-#define KSMBD_DEBUG_OPLOCK (1 << 3)
-#define KSMBD_DEBUG_IPC (1 << 4)
-#define KSMBD_DEBUG_CONN (1 << 5)
-#define KSMBD_DEBUG_RDMA (1 << 6)
+#define KSMBD_DEBUG_SMB BIT(0)
+#define KSMBD_DEBUG_AUTH BIT(1)
+#define KSMBD_DEBUG_VFS BIT(2)
+#define KSMBD_DEBUG_OPLOCK BIT(3)
+#define KSMBD_DEBUG_IPC BIT(4)
+#define KSMBD_DEBUG_CONN BIT(5)
+#define KSMBD_DEBUG_RDMA BIT(6)
#define KSMBD_DEBUG_ALL (KSMBD_DEBUG_SMB | KSMBD_DEBUG_AUTH | \
KSMBD_DEBUG_VFS | KSMBD_DEBUG_OPLOCK | \
KSMBD_DEBUG_IPC | KSMBD_DEBUG_CONN | \
* Global config flags.
*/
#define KSMBD_GLOBAL_FLAG_INVALID (0)
-#define KSMBD_GLOBAL_FLAG_SMB2_LEASES (1 << 0)
-#define KSMBD_GLOBAL_FLAG_CACHE_TBUF (1 << 1)
-#define KSMBD_GLOBAL_FLAG_CACHE_RBUF (1 << 2)
-#define KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION (1 << 3)
-#define KSMBD_GLOBAL_FLAG_DURABLE_HANDLE (1 << 4)
+#define KSMBD_GLOBAL_FLAG_SMB2_LEASES BIT(0)
+#define KSMBD_GLOBAL_FLAG_CACHE_TBUF BIT(1)
+#define KSMBD_GLOBAL_FLAG_CACHE_RBUF BIT(2)
+#define KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION BIT(3)
+#define KSMBD_GLOBAL_FLAG_DURABLE_HANDLE BIT(4)
struct ksmbd_startup_request {
__u32 flags;
* User config flags.
*/
#define KSMBD_USER_FLAG_INVALID (0)
-#define KSMBD_USER_FLAG_OK (1 << 0)
-#define KSMBD_USER_FLAG_BAD_PASSWORD (1 << 1)
-#define KSMBD_USER_FLAG_BAD_UID (1 << 2)
-#define KSMBD_USER_FLAG_BAD_USER (1 << 3)
-#define KSMBD_USER_FLAG_GUEST_ACCOUNT (1 << 4)
+#define KSMBD_USER_FLAG_OK BIT(0)
+#define KSMBD_USER_FLAG_BAD_PASSWORD BIT(1)
+#define KSMBD_USER_FLAG_BAD_UID BIT(2)
+#define KSMBD_USER_FLAG_BAD_USER BIT(3)
+#define KSMBD_USER_FLAG_GUEST_ACCOUNT BIT(4)
/*
* Share config flags.
*/
#define KSMBD_SHARE_FLAG_INVALID (0)
-#define KSMBD_SHARE_FLAG_AVAILABLE (1 << 0)
-#define KSMBD_SHARE_FLAG_BROWSEABLE (1 << 1)
-#define KSMBD_SHARE_FLAG_WRITEABLE (1 << 2)
-#define KSMBD_SHARE_FLAG_READONLY (1 << 3)
-#define KSMBD_SHARE_FLAG_GUEST_OK (1 << 4)
-#define KSMBD_SHARE_FLAG_GUEST_ONLY (1 << 5)
-#define KSMBD_SHARE_FLAG_STORE_DOS_ATTRS (1 << 6)
-#define KSMBD_SHARE_FLAG_OPLOCKS (1 << 7)
-#define KSMBD_SHARE_FLAG_PIPE (1 << 8)
-#define KSMBD_SHARE_FLAG_HIDE_DOT_FILES (1 << 9)
-#define KSMBD_SHARE_FLAG_INHERIT_SMACK (1 << 10)
-#define KSMBD_SHARE_FLAG_INHERIT_OWNER (1 << 11)
-#define KSMBD_SHARE_FLAG_STREAMS (1 << 12)
-#define KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS (1 << 13)
-#define KSMBD_SHARE_FLAG_ACL_XATTR (1 << 14)
+#define KSMBD_SHARE_FLAG_AVAILABLE BIT(0)
+#define KSMBD_SHARE_FLAG_BROWSEABLE BIT(1)
+#define KSMBD_SHARE_FLAG_WRITEABLE BIT(2)
+#define KSMBD_SHARE_FLAG_READONLY BIT(3)
+#define KSMBD_SHARE_FLAG_GUEST_OK BIT(4)
+#define KSMBD_SHARE_FLAG_GUEST_ONLY BIT(5)
+#define KSMBD_SHARE_FLAG_STORE_DOS_ATTRS BIT(6)
+#define KSMBD_SHARE_FLAG_OPLOCKS BIT(7)
+#define KSMBD_SHARE_FLAG_PIPE BIT(8)
+#define KSMBD_SHARE_FLAG_HIDE_DOT_FILES BIT(9)
+#define KSMBD_SHARE_FLAG_INHERIT_SMACK BIT(10)
+#define KSMBD_SHARE_FLAG_INHERIT_OWNER BIT(11)
+#define KSMBD_SHARE_FLAG_STREAMS BIT(12)
+#define KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS BIT(13)
+#define KSMBD_SHARE_FLAG_ACL_XATTR BIT(14)
/*
* Tree connect request flags.
*/
#define KSMBD_TREE_CONN_FLAG_REQUEST_SMB1 (0)
-#define KSMBD_TREE_CONN_FLAG_REQUEST_IPV6 (1 << 0)
-#define KSMBD_TREE_CONN_FLAG_REQUEST_SMB2 (1 << 1)
+#define KSMBD_TREE_CONN_FLAG_REQUEST_IPV6 BIT(0)
+#define KSMBD_TREE_CONN_FLAG_REQUEST_SMB2 BIT(1)
/*
* Tree connect flags.
*/
-#define KSMBD_TREE_CONN_FLAG_GUEST_ACCOUNT (1 << 0)
-#define KSMBD_TREE_CONN_FLAG_READ_ONLY (1 << 1)
-#define KSMBD_TREE_CONN_FLAG_WRITABLE (1 << 2)
-#define KSMBD_TREE_CONN_FLAG_ADMIN_ACCOUNT (1 << 3)
+#define KSMBD_TREE_CONN_FLAG_GUEST_ACCOUNT BIT(0)
+#define KSMBD_TREE_CONN_FLAG_READ_ONLY BIT(1)
+#define KSMBD_TREE_CONN_FLAG_WRITABLE BIT(2)
+#define KSMBD_TREE_CONN_FLAG_ADMIN_ACCOUNT BIT(3)
/*
* RPC over IPC.
*/
-#define KSMBD_RPC_METHOD_RETURN (1 << 0)
-#define KSMBD_RPC_SRVSVC_METHOD_INVOKE (1 << 1)
-#define KSMBD_RPC_SRVSVC_METHOD_RETURN ((1 << 1) | KSMBD_RPC_METHOD_RETURN)
-#define KSMBD_RPC_WKSSVC_METHOD_INVOKE (1 << 2)
-#define KSMBD_RPC_WKSSVC_METHOD_RETURN ((1 << 2) | KSMBD_RPC_METHOD_RETURN)
-#define KSMBD_RPC_IOCTL_METHOD ((1 << 3) | KSMBD_RPC_METHOD_RETURN)
-#define KSMBD_RPC_OPEN_METHOD (1 << 4)
-#define KSMBD_RPC_WRITE_METHOD (1 << 5)
-#define KSMBD_RPC_READ_METHOD ((1 << 6) | KSMBD_RPC_METHOD_RETURN)
-#define KSMBD_RPC_CLOSE_METHOD (1 << 7)
-#define KSMBD_RPC_RAP_METHOD ((1 << 8) | KSMBD_RPC_METHOD_RETURN)
-#define KSMBD_RPC_RESTRICTED_CONTEXT (1 << 9)
-#define KSMBD_RPC_SAMR_METHOD_INVOKE (1 << 10)
-#define KSMBD_RPC_SAMR_METHOD_RETURN ((1 << 10) | KSMBD_RPC_METHOD_RETURN)
-#define KSMBD_RPC_LSARPC_METHOD_INVOKE (1 << 11)
-#define KSMBD_RPC_LSARPC_METHOD_RETURN ((1 << 11) | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_METHOD_RETURN BIT(0)
+#define KSMBD_RPC_SRVSVC_METHOD_INVOKE BIT(1)
+#define KSMBD_RPC_SRVSVC_METHOD_RETURN (KSMBD_RPC_SRVSVC_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_WKSSVC_METHOD_INVOKE BIT(2)
+#define KSMBD_RPC_WKSSVC_METHOD_RETURN (KSMBD_RPC_WKSSVC_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_IOCTL_METHOD (BIT(3) | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_OPEN_METHOD BIT(4)
+#define KSMBD_RPC_WRITE_METHOD BIT(5)
+#define KSMBD_RPC_READ_METHOD (BIT(6) | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_CLOSE_METHOD BIT(7)
+#define KSMBD_RPC_RAP_METHOD (BIT(8) | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_RESTRICTED_CONTEXT BIT(9)
+#define KSMBD_RPC_SAMR_METHOD_INVOKE BIT(10)
+#define KSMBD_RPC_SAMR_METHOD_RETURN (KSMBD_RPC_SAMR_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN)
+#define KSMBD_RPC_LSARPC_METHOD_INVOKE BIT(11)
+#define KSMBD_RPC_LSARPC_METHOD_RETURN (KSMBD_RPC_LSARPC_METHOD_INVOKE | KSMBD_RPC_METHOD_RETURN)
#define KSMBD_RPC_OK 0
#define KSMBD_RPC_EBAD_FUNC 0x00000001
struct preauth_session {
__u8 Preauth_HashValue[PREAUTH_HASHVALUE_SIZE];
- uint64_t sess_id;
+ u64 sess_id;
struct list_head list_entry;
};
struct ksmbd_session {
- uint64_t id;
+ u64 id;
struct ksmbd_user *user;
struct ksmbd_conn *conn;
{
/* check for control chars, wildcards etc. */
if (!(ch & 0x80) &&
- (ch <= 0x1f ||
- ch == '?' || ch == '"' || ch == '<' ||
- ch == '>' || ch == '|' || ch == '*'))
+ (ch <= 0x1f ||
+ ch == '?' || ch == '"' || ch == '<' ||
+ ch == '>' || ch == '|' || ch == '*'))
return 0;
return 1;
}
char *ksmbd_convert_dir_info_name(struct ksmbd_dir_info *d_info,
- const struct nls_table *local_nls,
- int *conv_len)
+ const struct nls_table *local_nls, int *conv_len)
{
char *conv;
int sz = min(4 * d_info->name_len, PATH_MAX);
ndr_write_int32(n, da->ea_size);
ndr_write_int64(n, da->size);
ndr_write_int64(n, da->alloc_size);
- } else
+ } else {
ndr_write_int64(n, da->itime);
+ }
ndr_write_int64(n, da->create_time);
if (da->version == 3)
ndr_write_int64(n, da->change_time);
/* ACL ACCESS */
ndr_write_int32(n, ref_id);
ref_id += 4;
- } else
+ } else {
ndr_write_int32(n, 0);
+ }
if (def_acl) {
/* DEFAULT ACL ACCESS */
ndr_write_int32(n, ref_id);
ref_id += 4;
- } else
+ } else {
ndr_write_int32(n, 0);
+ }
ndr_write_int64(n, from_kuid(&init_user_ns, inode->i_uid));
ndr_write_int64(n, from_kgid(&init_user_ns, inode->i_gid));
// SPDX-License-Identifier: GPL-2.0-or-later
/*
- * fs/ksmbd/netmisc.c
- *
* Copyright (c) International Business Machines Corp., 2002,2008
* Author(s): Steve French (sfrench@us.ibm.com)
*
* Return: allocated opinfo object on success, otherwise NULL
*/
static struct oplock_info *alloc_opinfo(struct ksmbd_work *work,
- uint64_t id, __u16 Tid)
+ u64 id, __u16 Tid)
{
struct ksmbd_session *sess = work->sess;
struct oplock_info *opinfo;
write_unlock(&lease_list_lock);
}
-static int alloc_lease(struct oplock_info *opinfo,
- struct lease_ctx_info *lctx)
+static int alloc_lease(struct oplock_info *opinfo, struct lease_ctx_info *lctx)
{
struct lease *lease;
{
struct lease *lease = opinfo->o_lease;
- if (!((opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) ||
- (opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))) {
+ if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
+ opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
ksmbd_err("bad oplock(0x%x)\n", opinfo->level);
if (opinfo->is_lease)
ksmbd_err("lease state(0x%x)\n", lease->state);
{
struct lease *lease = opinfo->o_lease;
- if (!((opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) ||
- (opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))) {
+ if (!(opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
+ opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
ksmbd_err("bad oplock(0x%x)\n", opinfo->level);
if (opinfo->is_lease)
ksmbd_err("lease state(0x%x)\n",
*
* Return: 0 on success, otherwise -EINVAL
*/
-static int lease_none_upgrade(struct oplock_info *opinfo,
- __le32 new_state)
+static int lease_none_upgrade(struct oplock_info *opinfo, __le32 new_state)
{
struct lease *lease = opinfo->o_lease;
* Return: 0
*/
static void grant_write_oplock(struct oplock_info *opinfo_new, int req_oplock,
- struct lease_ctx_info *lctx)
+ struct lease_ctx_info *lctx)
{
struct lease *lease = opinfo_new->o_lease;
* Return: 0
*/
static void grant_read_oplock(struct oplock_info *opinfo_new,
- struct lease_ctx_info *lctx)
+ struct lease_ctx_info *lctx)
{
struct lease *lease = opinfo_new->o_lease;
* Return: 0
*/
static void grant_none_oplock(struct oplock_info *opinfo_new,
- struct lease_ctx_info *lctx)
+ struct lease_ctx_info *lctx)
{
struct lease *lease = opinfo_new->o_lease;
guid2 = opinfo->conn->ClientGUID;
key2 = opinfo->o_lease->lease_key;
if (!memcmp(guid1, guid2, SMB2_CLIENT_GUID_SIZE) &&
- !memcmp(key1, key2, SMB2_LEASE_KEY_SIZE))
+ !memcmp(key1, key2, SMB2_LEASE_KEY_SIZE))
return 1;
return 0;
* Return: oplock(lease) object on success, otherwise NULL
*/
static struct oplock_info *same_client_has_lease(struct ksmbd_inode *ci,
- char *client_guid, struct lease_ctx_info *lctx)
+ char *client_guid, struct lease_ctx_info *lctx)
{
int ret;
struct lease *lease;
rsp_hdr->SessionId = 0;
memset(rsp_hdr->Signature, 0, 16);
-
rsp = work->response_buf;
rsp->StructureSize = cpu_to_le16(24);
if (!br_info->open_trunc &&
- (br_info->level == SMB2_OPLOCK_LEVEL_BATCH ||
- br_info->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))
+ (br_info->level == SMB2_OPLOCK_LEVEL_BATCH ||
+ br_info->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))
rsp->OplockLevel = SMB2_OPLOCK_LEVEL_II;
else
rsp->OplockLevel = SMB2_OPLOCK_LEVEL_NONE;
if (atomic_read(&opinfo->breaking_cnt)) {
int ret = 0;
- ret = wait_event_interruptible_timeout(
- opinfo->oplock_brk,
- atomic_read(&opinfo->breaking_cnt) == 0,
- HZ);
+ ret = wait_event_interruptible_timeout(opinfo->oplock_brk,
+ atomic_read(&opinfo->breaking_cnt) == 0, HZ);
if (!ret)
atomic_set(&opinfo->breaking_cnt, 0);
}
return err < 0 ? err : 0;
if (brk_opinfo->level == SMB2_OPLOCK_LEVEL_BATCH ||
- brk_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
+ brk_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
brk_opinfo->op_state = OPLOCK_ACK_WAIT;
}
list_for_each_entry_safe(lb, lbtmp, &lease_table_list, l_entry) {
if (conn && memcmp(lb->client_guid, conn->ClientGUID,
- SMB2_CLIENT_GUID_SIZE))
+ SMB2_CLIENT_GUID_SIZE))
continue;
again:
rcu_read_lock();
list_for_each_entry(lb, &lease_table_list, l_entry) {
if (!memcmp(lb->client_guid, sess->conn->ClientGUID,
- SMB2_CLIENT_GUID_SIZE))
+ SMB2_CLIENT_GUID_SIZE))
goto found;
}
read_unlock(&lease_list_lock);
read_lock(&lease_list_lock);
list_for_each_entry(lb, &lease_table_list, l_entry) {
if (!memcmp(lb->client_guid, opinfo->conn->ClientGUID,
- SMB2_CLIENT_GUID_SIZE)) {
+ SMB2_CLIENT_GUID_SIZE)) {
opinfo->o_lease->l_lb = lb;
lease_add_list(opinfo);
read_unlock(&lease_list_lock);
}
static void set_oplock_level(struct oplock_info *opinfo, int level,
- struct lease_ctx_info *lctx)
+ struct lease_ctx_info *lctx)
{
switch (level) {
case SMB2_OPLOCK_LEVEL_BATCH:
case SMB2_OPLOCK_LEVEL_EXCLUSIVE:
- grant_write_oplock(opinfo,
- level, lctx);
+ grant_write_oplock(opinfo, level, lctx);
break;
case SMB2_OPLOCK_LEVEL_II:
grant_read_oplock(opinfo, lctx);
*
* Return: 0 on success, otherwise error
*/
-int smb_grant_oplock(struct ksmbd_work *work,
- int req_op_level,
- uint64_t pid,
- struct ksmbd_file *fp,
- __u16 tid,
- struct lease_ctx_info *lctx,
- int share_ret)
+int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, u64 pid,
+ struct ksmbd_file *fp, __u16 tid, struct lease_ctx_info *lctx,
+ int share_ret)
{
struct ksmbd_session *sess = work->sess;
int err = 0;
prev_op_state = prev_opinfo->o_lease->state;
if (share_ret < 0 &&
- (prev_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
+ prev_opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
err = share_ret;
opinfo_put(prev_opinfo);
goto err_out;
}
- if ((prev_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH) &&
- (prev_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE)) {
+ if (prev_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH &&
+ prev_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
opinfo_put(prev_opinfo);
goto op_break_not_needed;
}
* @is_trunc: truncate on open
*/
static void smb_break_all_write_oplock(struct ksmbd_work *work,
- struct ksmbd_file *fp, int is_trunc)
+ struct ksmbd_file *fp, int is_trunc)
{
struct oplock_info *brk_opinfo;
if (!brk_opinfo)
return;
if (brk_opinfo->level != SMB2_OPLOCK_LEVEL_BATCH &&
- brk_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
+ brk_opinfo->level != SMB2_OPLOCK_LEVEL_EXCLUSIVE) {
opinfo_put(brk_opinfo);
return;
}
* @fp: ksmbd file pointer
* @is_trunc: truncate on open
*/
-void smb_break_all_levII_oplock(struct ksmbd_work *work,
- struct ksmbd_file *fp, int is_trunc)
+void smb_break_all_levII_oplock(struct ksmbd_work *work, struct ksmbd_file *fp,
+ int is_trunc)
{
struct oplock_info *op, *brk_op;
struct ksmbd_inode *ci;
struct ksmbd_conn *conn = work->sess->conn;
if (!test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_OPLOCKS)) {
+ KSMBD_SHARE_FLAG_OPLOCKS))
return;
- }
ci = fp->f_ci;
op = opinfo_get(fp);
atomic_read(&brk_op->breaking_cnt))
goto next;
- if (op && op->is_lease &&
- brk_op->is_lease &&
- !memcmp(conn->ClientGUID, brk_op->conn->ClientGUID,
- SMB2_CLIENT_GUID_SIZE) &&
- !memcmp(op->o_lease->lease_key,
- brk_op->o_lease->lease_key,
- SMB2_LEASE_KEY_SIZE))
+ if (op && op->is_lease && brk_op->is_lease &&
+ !memcmp(conn->ClientGUID, brk_op->conn->ClientGUID,
+ SMB2_CLIENT_GUID_SIZE) &&
+ !memcmp(op->o_lease->lease_key, brk_op->o_lease->lease_key,
+ SMB2_LEASE_KEY_SIZE))
goto next;
brk_op->open_trunc = is_trunc;
oplock_break(brk_op, SMB2_OPLOCK_LEVEL_NONE);
void smb_break_all_oplock(struct ksmbd_work *work, struct ksmbd_file *fp)
{
if (!test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_OPLOCKS))
+ KSMBD_SHARE_FLAG_OPLOCKS))
return;
smb_break_all_write_oplock(work, fp, 1);
__u8 smb2_map_lease_to_oplock(__le32 lease_state)
{
if (lease_state == (SMB2_LEASE_HANDLE_CACHING_LE |
- SMB2_LEASE_READ_CACHING_LE | SMB2_LEASE_WRITE_CACHING_LE))
+ SMB2_LEASE_READ_CACHING_LE |
+ SMB2_LEASE_WRITE_CACHING_LE)) {
return SMB2_OPLOCK_LEVEL_BATCH;
- else if (lease_state != SMB2_LEASE_WRITE_CACHING_LE &&
- lease_state & SMB2_LEASE_WRITE_CACHING_LE) {
+ } else if (lease_state != SMB2_LEASE_WRITE_CACHING_LE &&
+ lease_state & SMB2_LEASE_WRITE_CACHING_LE) {
if (!(lease_state & SMB2_LEASE_HANDLE_CACHING_LE))
return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
- } else if (lease_state & SMB2_LEASE_READ_CACHING_LE)
+ } else if (lease_state & SMB2_LEASE_READ_CACHING_LE) {
return SMB2_OPLOCK_LEVEL_II;
+ }
return 0;
}
cc = (struct create_context *)((char *)cc + next);
name = le16_to_cpu(cc->NameOffset) + (char *)cc;
if (le16_to_cpu(cc->NameLength) != 4 ||
- strncmp(name, SMB2_CREATE_REQUEST_LEASE, 4)) {
+ strncmp(name, SMB2_CREATE_REQUEST_LEASE, 4)) {
next = le32_to_cpu(cc->Next);
continue;
}
* Return: opinfo if found matching opinfo, otherwise NULL
*/
struct oplock_info *lookup_lease_in_table(struct ksmbd_conn *conn,
- char *lease_key)
+ char *lease_key)
{
struct oplock_info *opinfo = NULL, *ret_op = NULL;
struct lease_table *lt;
read_lock(&lease_list_lock);
list_for_each_entry(lt, &lease_table_list, l_entry) {
if (!memcmp(lt->client_guid, conn->ClientGUID,
- SMB2_CLIENT_GUID_SIZE))
+ SMB2_CLIENT_GUID_SIZE))
goto found;
}
if (!atomic_inc_not_zero(&opinfo->refcount))
continue;
rcu_read_unlock();
- if (!opinfo->op_state ||
- opinfo->op_state == OPLOCK_CLOSING)
+ if (!opinfo->op_state || opinfo->op_state == OPLOCK_CLOSING)
goto op_next;
if (!(opinfo->o_lease->state &
- (SMB2_LEASE_HANDLE_CACHING_LE |
- SMB2_LEASE_WRITE_CACHING_LE)))
+ (SMB2_LEASE_HANDLE_CACHING_LE |
+ SMB2_LEASE_WRITE_CACHING_LE)))
goto op_next;
ret = compare_guid_key(opinfo, conn->ClientGUID,
lease_key);
}
int smb2_check_durable_oplock(struct ksmbd_file *fp,
- struct lease_ctx_info *lctx, char *name)
+ struct lease_ctx_info *lctx, char *name)
{
struct oplock_info *opinfo = opinfo_get(fp);
int ret = 0;
goto out;
}
if (memcmp(opinfo->o_lease->lease_key, lctx->lease_key,
- SMB2_LEASE_KEY_SIZE)) {
+ SMB2_LEASE_KEY_SIZE)) {
ksmbd_err("invalid lease key\n");
ret = -EBADF;
goto out;
#include "smb_common.h"
-#define OPLOCK_WAIT_TIME (35*HZ)
+#define OPLOCK_WAIT_TIME (35 * HZ)
/* SMB Oplock levels */
#define OPLOCK_NONE 0
int level;
int op_state;
unsigned long pending_break;
- uint64_t fid;
+ u64 fid;
atomic_t breaking_cnt;
atomic_t refcount;
__u16 Tid;
int fid;
};
-extern int smb_grant_oplock(struct ksmbd_work *work, int req_op_level,
- uint64_t pid, struct ksmbd_file *fp, __u16 tid,
+int smb_grant_oplock(struct ksmbd_work *work, int req_op_level,
+ u64 pid, struct ksmbd_file *fp, __u16 tid,
struct lease_ctx_info *lctx, int share_ret);
-extern void smb_break_all_levII_oplock(struct ksmbd_work *work,
- struct ksmbd_file *fp, int is_trunc);
+void smb_break_all_levII_oplock(struct ksmbd_work *work,
+ struct ksmbd_file *fp, int is_trunc);
int opinfo_write_to_read(struct oplock_info *opinfo);
int opinfo_read_handle_to_read(struct oplock_info *opinfo);
void create_posix_rsp_buf(char *cc, struct ksmbd_file *fp);
struct create_context *smb2_find_context_vals(void *open_req, const char *str);
int ksmbd_durable_verify_and_del_oplock(struct ksmbd_session *curr_sess,
- struct ksmbd_session *prev_sess,
- int fid, struct file **filp,
- uint64_t sess_id);
+ struct ksmbd_session *prev_sess, int fid, struct file **filp,
+ u64 sess_id);
struct oplock_info *lookup_lease_in_table(struct ksmbd_conn *conn,
- char *lease_key);
+ char *lease_key);
int find_same_lease_key(struct ksmbd_session *sess, struct ksmbd_inode *ci,
- struct lease_ctx_info *lctx);
+ struct lease_ctx_info *lctx);
void destroy_lease_table(struct ksmbd_conn *conn);
int smb2_check_durable_oplock(struct ksmbd_file *fp,
- struct lease_ctx_info *lctx, char *name);
-
+ struct lease_ctx_info *lctx, char *name);
#endif /* __KSMBD_OPLOCK_H */
#define TCP_HANDLER_CONTINUE 0
#define TCP_HANDLER_ABORT 1
-static int __process_request(struct ksmbd_work *work,
- struct ksmbd_conn *conn,
- uint16_t *cmd)
+static int __process_request(struct ksmbd_work *work, struct ksmbd_conn *conn,
+ uint16_t *cmd)
{
struct smb_version_cmds *cmds;
uint16_t command;
}
static void __handle_ksmbd_work(struct ksmbd_work *work,
- struct ksmbd_conn *conn)
+ struct ksmbd_conn *conn)
{
- uint16_t command = 0;
+ u16 command = 0;
int rc;
if (conn->ops->allocate_rsp_buf(work))
return;
if (conn->ops->is_transform_hdr &&
- conn->ops->is_transform_hdr(work->request_buf)) {
+ conn->ops->is_transform_hdr(work->request_buf)) {
rc = conn->ops->decrypt_req(work);
if (rc < 0) {
conn->ops->set_rsp_status(work, STATUS_DATA_ERROR);
}
if (work->sess && (work->sess->sign ||
- smb3_11_final_sess_setup_resp(work) ||
+ smb3_11_final_sess_setup_resp(work) ||
conn->ops->is_sign_req(work, command)))
conn->ops->set_sign_rsp(work);
} while (is_chained_smb2_message(work));
send:
smb3_preauth_hash_rsp(work);
if (work->sess && work->sess->enc && work->encrypted &&
- conn->ops->encrypt_resp) {
+ conn->ops->encrypt_resp) {
rc = conn->ops->encrypt_resp(work);
if (rc < 0) {
conn->ops->set_rsp_status(work, STATUS_DATA_ERROR);
return __queue_ctrl_work(SERVER_CTRL_TYPE_RESET);
}
-static ssize_t stats_show(struct class *class,
- struct class_attribute *attr,
- char *buf)
+static ssize_t stats_show(struct class *class, struct class_attribute *attr,
+ char *buf)
{
/*
* Inc this each time you change stats output format,
}
static ssize_t kill_server_store(struct class *class,
- struct class_attribute *attr,
- const char *buf,
- size_t len)
+ struct class_attribute *attr, const char *buf,
+ size_t len)
{
if (!sysfs_streq(buf, "hard"))
return len;
"oplock", "ipc", "conn",
"rdma"};
-static ssize_t debug_show(struct class *class,
- struct class_attribute *attr,
+static ssize_t debug_show(struct class *class, struct class_attribute *attr,
char *buf)
{
ssize_t sz = 0;
debug_type_strings[i]);
}
sz += pos;
-
}
sz += scnprintf(buf + sz, PAGE_SIZE - sz, "\n");
return sz;
}
-static ssize_t debug_store(struct class *class,
- struct class_attribute *attr,
- const char *buf,
- size_t len)
+static ssize_t debug_store(struct class *class, struct class_attribute *attr,
+ const char *buf, size_t len)
{
int i;
/* error reqeusts do not have data area */
if (hdr->Status && hdr->Status != STATUS_MORE_PROCESSING_REQUIRED &&
- (((struct smb2_err_rsp *)hdr)->StructureSize) ==
- SMB2_ERROR_STRUCTURE_SIZE2_LE)
+ (((struct smb2_err_rsp *)hdr)->StructureSize) == SMB2_ERROR_STRUCTURE_SIZE2_LE)
return NULL;
/*
*/
switch (hdr->Command) {
case SMB2_SESSION_SETUP:
- *off = le16_to_cpu(
- ((struct smb2_sess_setup_req *)hdr)->SecurityBufferOffset);
- *len = le16_to_cpu(
- ((struct smb2_sess_setup_req *)hdr)->SecurityBufferLength);
+ *off = le16_to_cpu(((struct smb2_sess_setup_req *)hdr)->SecurityBufferOffset);
+ *len = le16_to_cpu(((struct smb2_sess_setup_req *)hdr)->SecurityBufferLength);
break;
case SMB2_TREE_CONNECT:
- *off = le16_to_cpu(
- ((struct smb2_tree_connect_req *)hdr)->PathOffset);
- *len = le16_to_cpu(
- ((struct smb2_tree_connect_req *)hdr)->PathLength);
+ *off = le16_to_cpu(((struct smb2_tree_connect_req *)hdr)->PathOffset);
+ *len = le16_to_cpu(((struct smb2_tree_connect_req *)hdr)->PathLength);
break;
case SMB2_CREATE:
{
break;
}
- *off = le16_to_cpu(
- ((struct smb2_create_req *)hdr)->NameOffset);
- *len = le16_to_cpu(
- ((struct smb2_create_req *)hdr)->NameLength);
+ *off = le16_to_cpu(((struct smb2_create_req *)hdr)->NameOffset);
+ *len = le16_to_cpu(((struct smb2_create_req *)hdr)->NameLength);
break;
}
case SMB2_QUERY_INFO:
- *off = le16_to_cpu(
- ((struct smb2_query_info_req *)hdr)->InputBufferOffset);
- *len = le32_to_cpu(
- ((struct smb2_query_info_req *)hdr)->InputBufferLength);
+ *off = le16_to_cpu(((struct smb2_query_info_req *)hdr)->InputBufferOffset);
+ *len = le32_to_cpu(((struct smb2_query_info_req *)hdr)->InputBufferLength);
break;
case SMB2_SET_INFO:
- *off = le16_to_cpu(
- ((struct smb2_set_info_req *)hdr)->BufferOffset);
- *len = le32_to_cpu(
- ((struct smb2_set_info_req *)hdr)->BufferLength);
+ *off = le16_to_cpu(((struct smb2_set_info_req *)hdr)->BufferOffset);
+ *len = le32_to_cpu(((struct smb2_set_info_req *)hdr)->BufferLength);
break;
case SMB2_READ:
- *off = le16_to_cpu(
- ((struct smb2_read_req *)hdr)->ReadChannelInfoOffset);
- *len = le16_to_cpu(
- ((struct smb2_read_req *)hdr)->ReadChannelInfoLength);
+ *off = le16_to_cpu(((struct smb2_read_req *)hdr)->ReadChannelInfoOffset);
+ *len = le16_to_cpu(((struct smb2_read_req *)hdr)->ReadChannelInfoLength);
break;
case SMB2_WRITE:
if (((struct smb2_write_req *)hdr)->DataOffset) {
- *off = le16_to_cpu(
- ((struct smb2_write_req *)hdr)->DataOffset);
- *len = le32_to_cpu(
- ((struct smb2_write_req *)hdr)->Length);
+ *off = le16_to_cpu(((struct smb2_write_req *)hdr)->DataOffset);
+ *len = le32_to_cpu(((struct smb2_write_req *)hdr)->Length);
break;
}
- *off = le16_to_cpu(
- ((struct smb2_write_req *)hdr)->WriteChannelInfoOffset);
- *len = le16_to_cpu(
- ((struct smb2_write_req *)hdr)->WriteChannelInfoLength);
+ *off = le16_to_cpu(((struct smb2_write_req *)hdr)->WriteChannelInfoOffset);
+ *len = le16_to_cpu(((struct smb2_write_req *)hdr)->WriteChannelInfoLength);
break;
case SMB2_QUERY_DIRECTORY:
- *off = le16_to_cpu(
- ((struct smb2_query_directory_req *)hdr)->FileNameOffset);
- *len = le16_to_cpu(
- ((struct smb2_query_directory_req *)hdr)->FileNameLength);
+ *off = le16_to_cpu(((struct smb2_query_directory_req *)hdr)->FileNameOffset);
+ *len = le16_to_cpu(((struct smb2_query_directory_req *)hdr)->FileNameLength);
break;
case SMB2_LOCK:
{
* smb2_lock request size is 48 included single
* smb2_lock_element structure size.
*/
- lock_count = le16_to_cpu(
- ((struct smb2_lock_req *)hdr)->LockCount) - 1;
+ lock_count = le16_to_cpu(((struct smb2_lock_req *)hdr)->LockCount) - 1;
if (lock_count > 0) {
*off = __SMB2_HEADER_STRUCTURE_SIZE + 48;
*len = sizeof(struct smb2_lock_element) * lock_count;
break;
}
case SMB2_IOCTL:
- *off = le32_to_cpu(
- ((struct smb2_ioctl_req *)hdr)->InputOffset);
+ *off = le32_to_cpu(((struct smb2_ioctl_req *)hdr)->InputOffset);
*len = le32_to_cpu(((struct smb2_ioctl_req *)hdr)->InputCount);
break;
hdr = &pdu->hdr;
}
- if (le32_to_cpu(hdr->NextCommand) > 0)
+ if (le32_to_cpu(hdr->NextCommand) > 0) {
len = le32_to_cpu(hdr->NextCommand);
- else if (work->next_smb2_rcv_hdr_off) {
+ } else if (work->next_smb2_rcv_hdr_off) {
len -= work->next_smb2_rcv_hdr_off;
len = round_up(len, 8);
}
}
if (smb2_req_struct_sizes[command] != pdu->StructureSize2) {
- if (command != SMB2_OPLOCK_BREAK_HE && (hdr->Status == 0 ||
- pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2_LE)) {
+ if (command != SMB2_OPLOCK_BREAK_HE &&
+ (hdr->Status == 0 || pdu->StructureSize2 != SMB2_ERROR_STRUCTURE_SIZE2_LE)) {
/* error packets have 9 byte structure size */
ksmbd_debug(SMB,
"Illegal request size %u for command %d\n",
le16_to_cpu(pdu->StructureSize2), command);
return 1;
- } else if (command == SMB2_OPLOCK_BREAK_HE
- && (hdr->Status == 0)
- && (le16_to_cpu(pdu->StructureSize2) !=
- OP_BREAK_STRUCT_SIZE_20)
- && (le16_to_cpu(pdu->StructureSize2) !=
- OP_BREAK_STRUCT_SIZE_21)) {
+ } else if (command == SMB2_OPLOCK_BREAK_HE &&
+ hdr->Status == 0 &&
+ le16_to_cpu(pdu->StructureSize2) != OP_BREAK_STRUCT_SIZE_20 &&
+ le16_to_cpu(pdu->StructureSize2) != OP_BREAK_STRUCT_SIZE_21) {
/* special case for SMB2.1 lease break message */
ksmbd_debug(SMB,
"Illegal request size %d for oplock break\n",
conn->vals->capabilities |= SMB2_GLOBAL_CAP_LEASING;
if (server_conf.flags & KSMBD_GLOBAL_FLAG_SMB2_ENCRYPTION &&
- conn->cli_cap & SMB2_GLOBAL_CAP_ENCRYPTION)
+ conn->cli_cap & SMB2_GLOBAL_CAP_ENCRYPTION)
conn->vals->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION;
}
*
* Return: 1 if valid session id, otherwise 0
*/
-static inline int check_session_id(struct ksmbd_conn *conn, uint64_t id)
+static inline int check_session_id(struct ksmbd_conn *conn, u64 id)
{
struct ksmbd_session *sess;
int tree_id;
work->tcon = NULL;
- if ((work->conn->ops->get_cmd_val(work) == SMB2_TREE_CONNECT_HE) ||
- (work->conn->ops->get_cmd_val(work) == SMB2_CANCEL_HE) ||
- (work->conn->ops->get_cmd_val(work) == SMB2_LOGOFF_HE)) {
+ if (work->conn->ops->get_cmd_val(work) == SMB2_TREE_CONNECT_HE ||
+ work->conn->ops->get_cmd_val(work) == SMB2_CANCEL_HE ||
+ work->conn->ops->get_cmd_val(work) == SMB2_LOGOFF_HE) {
ksmbd_debug(SMB, "skip to check tree connect request\n");
return 0;
}
if (conn->need_neg == false)
return -EINVAL;
if (!(conn->dialect >= SMB20_PROT_ID &&
- conn->dialect <= SMB311_PROT_ID))
+ conn->dialect <= SMB311_PROT_ID))
return -EINVAL;
rsp_hdr = work->response_buf;
req = work->request_buf;
if (req->InfoType == SMB2_O_INFO_FILE &&
- (req->FileInfoClass == FILE_FULL_EA_INFORMATION ||
- req->FileInfoClass == FILE_ALL_INFORMATION)) {
+ (req->FileInfoClass == FILE_FULL_EA_INFORMATION ||
+ req->FileInfoClass == FILE_ALL_INFORMATION)) {
sz = large_sz;
work->set_trans_buf = true;
}
* these commands.
*/
if (cmd == SMB2_ECHO_HE || cmd == SMB2_NEGOTIATE_HE ||
- cmd == SMB2_SESSION_SETUP_HE)
+ cmd == SMB2_SESSION_SETUP_HE)
return 0;
if (!ksmbd_conn_good(work))
return -EINVAL;
}
-static void destroy_previous_session(struct ksmbd_user *user, uint64_t id)
+static void destroy_previous_session(struct ksmbd_user *user, u64 id)
{
struct ksmbd_session *prev_sess = ksmbd_session_lookup_slowpath(id);
struct ksmbd_user *prev_user;
* Return: matching converted filename on success, otherwise error ptr
*/
static char *
-smb2_get_name(struct ksmbd_share_config *share,
- const char *src,
- const int maxlen,
- struct nls_table *local_nls)
+smb2_get_name(struct ksmbd_share_config *share, const char *src,
+ const int maxlen, struct nls_table *local_nls)
{
char *name, *unixname;
- name = smb_strndup_from_utf16(src, maxlen, 1,
- local_nls);
+ 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));
return name;
{
int attr = 0;
- if (S_ISDIR(stat->mode))
+ if (S_ISDIR(stat->mode)) {
attr = ATTR_DIRECTORY |
(attribute & (ATTR_HIDDEN | ATTR_SYSTEM));
- else {
+ } else {
attr = (attribute & 0x00005137) | ATTR_ARCHIVE;
attr &= ~(ATTR_DIRECTORY);
if (S_ISREG(stat->mode) && (server_conf.share_fake_fscaps &
}
static void build_preauth_ctxt(struct smb2_preauth_neg_context *pneg_ctxt,
- __le16 hash_id)
+ __le16 hash_id)
{
pneg_ctxt->ContextType = SMB2_PREAUTH_INTEGRITY_CAPABILITIES;
pneg_ctxt->DataLength = cpu_to_le16(38);
}
static void build_encrypt_ctxt(struct smb2_encryption_neg_context *pneg_ctxt,
- __le16 cipher_type)
+ __le16 cipher_type)
{
pneg_ctxt->ContextType = SMB2_ENCRYPTION_CAPABILITIES;
pneg_ctxt->DataLength = cpu_to_le16(4);
}
static void build_compression_ctxt(struct smb2_compression_ctx *pneg_ctxt,
- __le16 comp_algo)
+ __le16 comp_algo)
{
pneg_ctxt->ContextType = SMB2_COMPRESSION_CAPABILITIES;
pneg_ctxt->DataLength =
pneg_ctxt->CompressionAlgorithms[0] = comp_algo;
}
-static void
-build_posix_ctxt(struct smb2_posix_neg_context *pneg_ctxt)
+static void build_posix_ctxt(struct smb2_posix_neg_context *pneg_ctxt)
{
pneg_ctxt->ContextType = SMB2_POSIX_EXTENSIONS_AVAILABLE;
pneg_ctxt->DataLength = cpu_to_le16(POSIX_CTXT_DATA_LEN);
pneg_ctxt->Name[15] = 0x7C;
}
-static void
-assemble_neg_contexts(struct ksmbd_conn *conn,
- struct smb2_negotiate_rsp *rsp)
+static void assemble_neg_contexts(struct ksmbd_conn *conn,
+ struct smb2_negotiate_rsp *rsp)
{
/* +4 is to account for the RFC1001 len field */
char *pneg_ctxt = (char *)rsp +
ctxt_size = round_up(ctxt_size, 8);
ksmbd_debug(SMB,
"assemble SMB2_ENCRYPTION_CAPABILITIES context\n");
- build_encrypt_ctxt(
- (struct smb2_encryption_neg_context *)pneg_ctxt,
+ build_encrypt_ctxt((struct smb2_encryption_neg_context *)pneg_ctxt,
conn->cipher_type);
rsp->NegotiateContextCount = cpu_to_le16(++neg_ctxt_cnt);
ctxt_size += sizeof(struct smb2_encryption_neg_context);
inc_rfc1001_len(rsp, ctxt_size);
}
-static __le32
-decode_preauth_ctxt(struct ksmbd_conn *conn,
- struct smb2_preauth_neg_context *pneg_ctxt)
+static __le32 decode_preauth_ctxt(struct ksmbd_conn *conn,
+ struct smb2_preauth_neg_context *pneg_ctxt)
{
__le32 err = STATUS_NO_PREAUTH_INTEGRITY_HASH_OVERLAP;
}
static int decode_encrypt_ctxt(struct ksmbd_conn *conn,
- struct smb2_encryption_neg_context *pneg_ctxt)
+ struct smb2_encryption_neg_context *pneg_ctxt)
{
int i;
int cph_cnt = le16_to_cpu(pneg_ctxt->CipherCount);
for (i = 0; i < cph_cnt; i++) {
if (pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES128_GCM ||
- pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES128_CCM) {
+ pneg_ctxt->Ciphers[i] == SMB2_ENCRYPTION_AES128_CCM) {
ksmbd_debug(SMB, "Cipher ID = 0x%x\n",
pneg_ctxt->Ciphers[i]);
conn->cipher_type = pneg_ctxt->Ciphers[i];
}
static int decode_compress_ctxt(struct ksmbd_conn *conn,
- struct smb2_compression_ctx *pneg_ctxt)
+ struct smb2_compression_ctx *pneg_ctxt)
{
int algo_cnt = le16_to_cpu(pneg_ctxt->CompressionAlgorithmCount);
}
static __le32 deassemble_neg_contexts(struct ksmbd_conn *conn,
- struct smb2_negotiate_req *req)
+ struct smb2_negotiate_req *req)
{
int i = 0;
__le32 status = 0;
status = decode_preauth_ctxt(conn,
(struct smb2_preauth_neg_context *)pneg_ctxt);
- pneg_ctxt += DIV_ROUND_UP(
- sizeof(struct smb2_preauth_neg_context), 8) * 8;
+ pneg_ctxt += DIV_ROUND_UP(sizeof(struct smb2_preauth_neg_context), 8) * 8;
} else if (*ContextType == SMB2_ENCRYPTION_CAPABILITIES) {
ksmbd_debug(SMB,
"deassemble SMB2_ENCRYPTION_CAPABILITIES context\n");
break;
ctxt_size = decode_encrypt_ctxt(conn,
- (struct smb2_encryption_neg_context *)
- pneg_ctxt);
+ (struct smb2_encryption_neg_context *)pneg_ctxt);
pneg_ctxt += DIV_ROUND_UP(ctxt_size, 8) * 8;
} else if (*ContextType == SMB2_COMPRESSION_CAPABILITIES) {
ksmbd_debug(SMB,
break;
ctxt_size = decode_compress_ctxt(conn,
- (struct smb2_compression_ctx *)
- pneg_ctxt);
+ (struct smb2_compression_ctx *) pneg_ctxt);
pneg_ctxt += DIV_ROUND_UP(ctxt_size, 8) * 8;
} else if (*ContextType == SMB2_NETNAME_NEGOTIATE_CONTEXT_ID) {
ksmbd_debug(SMB,
"deassemble SMB2_NETNAME_NEGOTIATE_CONTEXT_ID context\n");
ctxt_size = sizeof(struct smb2_netname_neg_context);
- ctxt_size += DIV_ROUND_UP(
- le16_to_cpu(((struct smb2_netname_neg_context *)
+ ctxt_size += DIV_ROUND_UP(le16_to_cpu(((struct smb2_netname_neg_context *)
pneg_ctxt)->DataLength), 8) * 8;
pneg_ctxt += ctxt_size;
} else if (*ContextType == SMB2_POSIX_EXTENSIONS_AVAILABLE) {
ksmbd_debug(SMB,
"deassemble SMB2_POSIX_EXTENSIONS_AVAILABLE context\n");
conn->posix_ext_supported = true;
- pneg_ctxt += DIV_ROUND_UP(
- sizeof(struct smb2_posix_neg_context), 8) * 8;
+ pneg_ctxt += DIV_ROUND_UP(sizeof(struct smb2_posix_neg_context), 8) * 8;
}
ContextType = (__le16 *)pneg_ctxt;
conn->use_spnego = true;
if ((server_conf.signing == KSMBD_CONFIG_OPT_AUTO ||
- server_conf.signing == KSMBD_CONFIG_OPT_DISABLED) &&
- req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED_LE)
+ server_conf.signing == KSMBD_CONFIG_OPT_DISABLED) &&
+ req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED_LE)
conn->sign = true;
else if (server_conf.signing == KSMBD_CONFIG_OPT_MANDATORY) {
server_conf.enforced_signing = true;
}
static int alloc_preauth_hash(struct ksmbd_session *sess,
- struct ksmbd_conn *conn)
+ struct ksmbd_conn *conn)
{
if (sess->Preauth_HashValue)
return 0;
}
static int decode_negotiation_token(struct ksmbd_work *work,
- struct negotiate_message *negblob)
+ struct negotiate_message *negblob)
{
struct ksmbd_conn *conn = work->conn;
struct smb2_sess_setup_req *req;
}
static int ntlm_negotiate(struct ksmbd_work *work,
- struct negotiate_message *negblob)
+ struct negotiate_message *negblob)
{
struct smb2_sess_setup_req *req = work->request_buf;
struct smb2_sess_setup_rsp *rsp = work->response_buf;
}
static struct authenticate_message *user_authblob(struct ksmbd_conn *conn,
- struct smb2_sess_setup_req *req)
+ struct smb2_sess_setup_req *req)
{
int sz;
}
static struct ksmbd_user *session_user(struct ksmbd_conn *conn,
- struct smb2_sess_setup_req *req)
+ struct smb2_sess_setup_req *req)
{
struct authenticate_message *authblob;
struct ksmbd_user *user;
struct ksmbd_session *sess = work->sess;
struct channel *chann = NULL;
struct ksmbd_user *user;
- uint64_t prev_id;
+ u64 prev_id;
int sz, rc;
ksmbd_debug(SMB, "authenticate phase\n");
return -ENOMEM;
sz = le16_to_cpu(rsp->SecurityBufferOffset);
- memcpy((char *)&rsp->hdr.ProtocolId + sz,
- spnego_blob,
- spnego_blob_len);
+ memcpy((char *)&rsp->hdr.ProtocolId + sz, spnego_blob, spnego_blob_len);
rsp->SecurityBufferLength = cpu_to_le16(spnego_blob_len);
kfree(spnego_blob);
inc_rfc1001_len(rsp, spnego_blob_len - 1);
sess->user = user;
if (user_guest(sess->user)) {
if (conn->sign) {
- ksmbd_debug(SMB,
- "Guest login not allowed when signing enabled\n");
+ ksmbd_debug(SMB, "Guest login not allowed when signing enabled\n");
rsp->hdr.Status = STATUS_LOGON_FAILURE;
return -EACCES;
}
return 0;
if ((conn->sign || server_conf.enforced_signing) ||
- (req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED))
+ (req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED))
sess->sign = true;
if (conn->vals->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION &&
- conn->ops->generate_encryptionkey) {
+ conn->ops->generate_encryptionkey) {
rc = conn->ops->generate_encryptionkey(sess);
if (rc) {
ksmbd_debug(SMB,
if (conn->ops->generate_signingkey) {
rc = conn->ops->generate_signingkey(sess);
if (rc) {
- ksmbd_debug(SMB,
- "SMB3 signing key generation failed\n");
+ ksmbd_debug(SMB, "SMB3 signing key generation failed\n");
rsp->hdr.Status = STATUS_LOGON_FAILURE;
return rc;
}
struct ksmbd_session *sess = work->sess;
char *in_blob, *out_blob;
struct channel *chann = NULL;
- uint64_t prev_sess_id;
+ u64 prev_sess_id;
int in_len, out_len;
int retval;
inc_rfc1001_len(rsp, out_len - 1);
if ((conn->sign || server_conf.enforced_signing) ||
- (req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED))
+ (req->SecurityMode & SMB2_NEGOTIATE_SIGNING_REQUIRED))
sess->sign = true;
if ((conn->vals->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION) &&
- conn->ops->generate_encryptionkey) {
+ conn->ops->generate_encryptionkey) {
retval = conn->ops->generate_encryptionkey(sess);
if (retval) {
ksmbd_debug(SMB,
if (conn->ops->generate_signingkey) {
retval = conn->ops->generate_signingkey(sess);
if (retval) {
- ksmbd_debug(SMB,
- "SMB3 signing key generation failed\n");
+ ksmbd_debug(SMB, "SMB3 signing key generation failed\n");
rsp->hdr.Status = STATUS_LOGON_FAILURE;
return retval;
}
* Note: here total size -1 is done as an
* adjustment for 0 size blob
*/
- inc_rfc1001_len(rsp,
- le16_to_cpu(rsp->SecurityBufferLength)
- - 1);
+ inc_rfc1001_len(rsp, le16_to_cpu(rsp->SecurityBufferLength) - 1);
} else if (negblob->MessageType == NtLmAuthenticate) {
rc = ntlm_authenticate(work);
int rc = -EINVAL;
treename = smb_strndup_from_utf16(req->Buffer,
- le16_to_cpu(req->PathLength), true, conn->local_nls);
+ le16_to_cpu(req->PathLength), true, conn->local_nls);
if (IS_ERR(treename)) {
ksmbd_err("treename is NULL\n");
status.ret = KSMBD_TREE_CONN_STATUS_ERROR;
int oflags = O_NONBLOCK | O_LARGEFILE;
if (access & FILE_READ_DESIRED_ACCESS_LE &&
- access & FILE_WRITE_DESIRE_ACCESS_LE)
+ access & FILE_WRITE_DESIRE_ACCESS_LE)
oflags |= O_RDWR;
else if (access & FILE_WRITE_DESIRE_ACCESS_LE)
oflags |= O_WRONLY;
};
static int parse_durable_handle_context(struct ksmbd_work *work,
- struct smb2_create_req *req, struct lease_ctx_info *lc,
- struct durable_info *d_info)
+ struct smb2_create_req *req, struct lease_ctx_info *lc,
+ struct durable_info *d_info)
{
struct ksmbd_conn *conn = work->conn;
struct create_context *context;
int i, err = 0;
- uint64_t persistent_id = 0;
+ u64 persistent_id = 0;
int req_op_level;
static const char * const durable_arr[] = {"DH2C", "DHnC", "DH2Q",
"DHnQ", SMB2_CREATE_APP_INSTANCE_ID};
recon_v2 =
(struct create_durable_reconn_v2_req *)context;
- persistent_id = le64_to_cpu(
- recon_v2->Fid.PersistentFileId);
+ persistent_id = le64_to_cpu(recon_v2->Fid.PersistentFileId);
d_info->fp = ksmbd_lookup_durable_fd(persistent_id);
if (!d_info->fp) {
ksmbd_err("Failed to get Durable handle state\n");
goto out;
}
- if (memcmp(d_info->fp->create_guid,
- recon_v2->CreateGuid,
- SMB2_CREATE_GUID_SIZE)) {
+ if (memcmp(d_info->fp->create_guid, recon_v2->CreateGuid,
+ SMB2_CREATE_GUID_SIZE)) {
err = -EBADF;
goto out;
}
struct create_durable_reconn_req *recon;
if (d_info->type == DURABLE_RECONN_V2 ||
- d_info->type == DURABLE_REQ_V2) {
+ d_info->type == DURABLE_REQ_V2) {
err = -EINVAL;
goto out;
}
recon =
(struct create_durable_reconn_req *)context;
- persistent_id = le64_to_cpu(
- recon->Data.Fid.PersistentFileId);
+ persistent_id = le64_to_cpu(recon->Data.Fid.PersistentFileId);
d_info->fp = ksmbd_lookup_durable_fd(persistent_id);
if (!d_info->fp) {
ksmbd_err("Failed to get Durable handle state\n");
struct create_durable_req_v2 *durable_v2_blob;
if (d_info->type == DURABLE_RECONN ||
- d_info->type == DURABLE_RECONN_V2) {
+ d_info->type == DURABLE_RECONN_V2) {
err = -EINVAL;
goto out;
}
durable_v2_blob =
(struct create_durable_req_v2 *)context;
ksmbd_debug(SMB, "Request for durable v2 open\n");
- d_info->fp = ksmbd_lookup_fd_cguid(
- durable_v2_blob->CreateGuid);
+ d_info->fp = ksmbd_lookup_fd_cguid(durable_v2_blob->CreateGuid);
if (d_info->fp) {
- if (!memcmp(conn->ClientGUID,
- d_info->fp->client_guid,
- SMB2_CLIENT_GUID_SIZE)) {
- if (!(req->hdr.Flags &
- SMB2_FLAGS_REPLAY_OPERATIONS)) {
+ if (!memcmp(conn->ClientGUID, d_info->fp->client_guid,
+ SMB2_CLIENT_GUID_SIZE)) {
+ if (!(req->hdr.Flags & SMB2_FLAGS_REPLAY_OPERATIONS)) {
err = -ENOEXEC;
goto out;
}
goto out;
}
}
- if (((lc &&
- (lc->req_state &
- SMB2_LEASE_HANDLE_CACHING_LE)) ||
- (req_op_level == SMB2_OPLOCK_LEVEL_BATCH))) {
+ if (((lc && (lc->req_state & SMB2_LEASE_HANDLE_CACHING_LE)) ||
+ req_op_level == SMB2_OPLOCK_LEVEL_BATCH)) {
d_info->CreateGuid =
durable_v2_blob->CreateGuid;
d_info->persistent =
if (d_info->type == DURABLE_RECONN)
goto out;
if (d_info->type == DURABLE_RECONN_V2 ||
- d_info->type == DURABLE_REQ_V2) {
+ d_info->type == DURABLE_REQ_V2) {
err = -EINVAL;
goto out;
}
- if (((lc &&
- (lc->req_state &
- SMB2_LEASE_HANDLE_CACHING_LE)) ||
- (req_op_level == SMB2_OPLOCK_LEVEL_BATCH))) {
+ if (((lc && (lc->req_state & SMB2_LEASE_HANDLE_CACHING_LE)) ||
+ req_op_level == SMB2_OPLOCK_LEVEL_BATCH)) {
ksmbd_debug(SMB, "Request for durable open\n");
d_info->type = i;
}
}
static noinline int smb2_set_stream_name_xattr(struct path *path,
- struct ksmbd_file *fp,
- char *stream_name,
- int s_type)
+ struct ksmbd_file *fp, char *stream_name, int s_type)
{
size_t xattr_stream_size;
char *xattr_stream_name;
ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
if (strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
- strncmp(&name[XATTR_USER_PREFIX_LEN],
- DOS_ATTRIBUTE_PREFIX,
- DOS_ATTRIBUTE_PREFIX_LEN) &&
- strncmp(&name[XATTR_USER_PREFIX_LEN],
- STREAM_PREFIX,
- STREAM_PREFIX_LEN))
+ strncmp(&name[XATTR_USER_PREFIX_LEN], DOS_ATTRIBUTE_PREFIX,
+ DOS_ATTRIBUTE_PREFIX_LEN) &&
+ strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX, STREAM_PREFIX_LEN))
continue;
err = ksmbd_vfs_remove_xattr(dentry, name);
return rc;
}
-static void smb2_new_xattrs(struct ksmbd_tree_connect *tcon,
- struct path *path,
- struct ksmbd_file *fp)
+static void smb2_new_xattrs(struct ksmbd_tree_connect *tcon, struct path *path,
+ struct ksmbd_file *fp)
{
struct xattr_dos_attrib da = {0};
int rc;
}
static void smb2_update_xattrs(struct ksmbd_tree_connect *tcon,
- struct path *path,
- struct ksmbd_file *fp)
+ struct path *path, struct ksmbd_file *fp)
{
struct xattr_dos_attrib da;
int rc;
/* get FileAttributes from XATTR_NAME_DOS_ATTRIBUTE */
if (!test_share_config_flag(tcon->share_conf,
- KSMBD_SHARE_FLAG_STORE_DOS_ATTRS))
+ KSMBD_SHARE_FLAG_STORE_DOS_ATTRS))
return;
rc = ksmbd_vfs_get_dos_attrib_xattr(path->dentry, &da);
}
}
-static int smb2_creat(struct ksmbd_work *work,
- struct path *path,
- char *name,
- int open_flags,
- umode_t posix_mode,
- bool is_dir)
+static int smb2_creat(struct ksmbd_work *work, struct path *path, char *name,
+ int open_flags, umode_t posix_mode, bool is_dir)
{
struct ksmbd_tree_connect *tcon = work->tcon;
struct ksmbd_share_config *share = tcon->share_conf;
WORK_BUFFERS(work, req, rsp);
if (req->hdr.NextCommand && !work->next_smb2_rcv_hdr_off &&
- (req->hdr.Flags & SMB2_FLAGS_RELATED_OPERATIONS)) {
+ (req->hdr.Flags & SMB2_FLAGS_RELATED_OPERATIONS)) {
ksmbd_debug(SMB, "invalid flag in chained command\n");
rsp->hdr.Status = STATUS_INVALID_PARAMETER;
smb2_set_err_rsp(work);
if (req->NameLength) {
if ((req->CreateOptions & FILE_DIRECTORY_FILE_LE) &&
- *(char *)req->Buffer == '\\') {
+ *(char *)req->Buffer == '\\') {
ksmbd_err("not allow directory name included leading slash\n");
rc = -EINVAL;
goto err_out1;
ksmbd_debug(SMB, "converted name = %s\n", name);
if (strchr(name, ':')) {
if (!test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_STREAMS)) {
+ KSMBD_SHARE_FLAG_STREAMS)) {
rc = -EBADF;
goto err_out1;
}
req_op_level = req->RequestedOplockLevel;
memset(&d_info, 0, sizeof(struct durable_info));
if (server_conf.flags & KSMBD_GLOBAL_FLAG_DURABLE_HANDLE &&
- req->CreateContextsOffset) {
+ req->CreateContextsOffset) {
lc = parse_lease_state(req);
rc = parse_durable_handle_context(work, req, lc, &d_info);
if (rc) {
lc = parse_lease_state(req);
}
- if (le32_to_cpu(req->ImpersonationLevel) >
- le32_to_cpu(IL_DELEGATE_LE)) {
+ if (le32_to_cpu(req->ImpersonationLevel) > le32_to_cpu(IL_DELEGATE_LE)) {
ksmbd_err("Invalid impersonationlevel : 0x%x\n",
le32_to_cpu(req->ImpersonationLevel));
rc = -EIO;
} else {
if (req->CreateOptions & FILE_SEQUENTIAL_ONLY_LE &&
- req->CreateOptions & FILE_RANDOM_ACCESS_LE)
+ req->CreateOptions & FILE_RANDOM_ACCESS_LE)
req->CreateOptions = ~(FILE_SEQUENTIAL_ONLY_LE);
if (req->CreateOptions & (FILE_OPEN_BY_FILE_ID_LE |
if (req->CreateOptions & FILE_NON_DIRECTORY_FILE_LE) {
rc = -EINVAL;
goto err_out1;
- } else if (req->CreateOptions & FILE_NO_COMPRESSION_LE)
+ } else if (req->CreateOptions & FILE_NO_COMPRESSION_LE) {
req->CreateOptions = ~(FILE_NO_COMPRESSION_LE);
+ }
}
}
goto err_out1;
}
- if (req->FileAttributes &&
- !(req->FileAttributes & ATTR_MASK_LE)) {
+ if (req->FileAttributes && !(req->FileAttributes & ATTR_MASK_LE)) {
ksmbd_err("Invalid file attribute : 0x%x\n",
le32_to_cpu(req->FileAttributes));
rc = -EINVAL;
* denied error.
*/
if (req->CreateDisposition == FILE_OVERWRITE_IF_LE ||
- req->CreateDisposition == FILE_OPEN_IF_LE) {
+ req->CreateDisposition == FILE_OPEN_IF_LE) {
rc = -EACCES;
path_put(&path);
goto err_out;
}
- if (!test_tree_conn_flag(tcon,
- KSMBD_TREE_CONN_FLAG_WRITABLE)) {
+ if (!test_tree_conn_flag(tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) {
ksmbd_debug(SMB,
"User does not have write permission\n");
rc = -EACCES;
}
} else {
if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS)) {
+ KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS)) {
/*
* Use LOOKUP_FOLLOW to follow the path of
* symlink in path buildup
}
if (req->CreateOptions & FILE_DIRECTORY_FILE_LE &&
- req->FileAttributes & ATTR_NORMAL_LE) {
+ req->FileAttributes & ATTR_NORMAL_LE) {
rsp->hdr.Status = STATUS_NOT_A_DIRECTORY;
rc = -EIO;
}
goto err_out;
}
- if (file_present && req->CreateOptions & FILE_NON_DIRECTORY_FILE_LE
- && S_ISDIR(stat.mode) &&
- !(req->CreateOptions & FILE_DELETE_ON_CLOSE_LE)) {
+ if (file_present && req->CreateOptions & FILE_NON_DIRECTORY_FILE_LE &&
+ S_ISDIR(stat.mode) && !(req->CreateOptions & FILE_DELETE_ON_CLOSE_LE)) {
ksmbd_debug(SMB, "open() argument is a directory: %s, %x\n",
name, req->CreateOptions);
rsp->hdr.Status = STATUS_FILE_IS_A_DIRECTORY;
}
if (file_present && (req->CreateOptions & FILE_DIRECTORY_FILE_LE) &&
- !(req->CreateDisposition == FILE_CREATE_LE) &&
- !S_ISDIR(stat.mode)) {
+ !(req->CreateDisposition == FILE_CREATE_LE) &&
+ !S_ISDIR(stat.mode)) {
rsp->hdr.Status = STATUS_NOT_A_DIRECTORY;
rc = -EIO;
goto err_out;
}
if (!stream_name && file_present &&
- (req->CreateDisposition == FILE_CREATE_LE)) {
+ req->CreateDisposition == FILE_CREATE_LE) {
rc = -EEXIST;
goto err_out;
}
if (server_conf.flags & KSMBD_GLOBAL_FLAG_DURABLE_HANDLE &&
- file_present)
+ file_present)
file_present = ksmbd_close_inode_fds(work,
d_inode(path.dentry));
* because execute(search) permission on a parent directory,
* is already granted.
*/
- if (daccess & ~(FILE_READ_ATTRIBUTES_LE |
- FILE_READ_CONTROL_LE)) {
+ if (daccess & ~(FILE_READ_ATTRIBUTES_LE | FILE_READ_CONTROL_LE)) {
if (ksmbd_vfs_inode_permission(path.dentry,
- open_flags & O_ACCMODE, may_delete)) {
+ open_flags & O_ACCMODE,
+ may_delete)) {
rc = -EACCES;
goto err_out;
}
if ((req->CreateDisposition & FILE_CREATE_MASK_LE)
== FILE_SUPERSEDE_LE)
file_info = FILE_SUPERSEDED;
- } else if (open_flags & O_CREAT)
+ } else if (open_flags & O_CREAT) {
file_info = FILE_CREATED;
+ }
ksmbd_vfs_set_fadvise(filp, req->CreateOptions);
ksmbd_debug(SMB, "inherit posix acl failed : %d\n", posix_acl_rc);
if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_ACL_XATTR)) {
+ KSMBD_SHARE_FLAG_ACL_XATTR)) {
rc = smb_inherit_dacl(conn, path.dentry, sess->user->uid,
sess->user->gid);
}
ksmbd_vfs_set_init_posix_acl(inode);
if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_ACL_XATTR)) {
+ KSMBD_SHARE_FLAG_ACL_XATTR)) {
struct smb_fattr fattr;
struct smb_ntsd *pntsd;
int pntsd_size, ace_num;
}
pntsd = kmalloc(sizeof(struct smb_ntsd) +
- sizeof(struct smb_sid)*3 +
+ sizeof(struct smb_sid) * 3 +
sizeof(struct smb_acl) +
- sizeof(struct smb_ace)*ace_num*2,
+ sizeof(struct smb_ace) * ace_num * 2,
GFP_KERNEL);
if (!pntsd)
goto err_out;
fp->attrib_only = !(req->DesiredAccess & ~(FILE_READ_ATTRIBUTES_LE |
FILE_WRITE_ATTRIBUTES_LE | FILE_SYNCHRONIZE_LE));
- if (!S_ISDIR(file_inode(filp)->i_mode) && open_flags & O_TRUNC
- && !fp->attrib_only && !stream_name) {
+ if (!S_ISDIR(file_inode(filp)->i_mode) && open_flags & O_TRUNC &&
+ !fp->attrib_only && !stream_name) {
smb_break_all_oplock(work, fp);
need_truncate = 1;
}
}
share_ret = ksmbd_smb_check_shared_mode(fp->filp, fp);
- if (!test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_OPLOCKS) ||
- (req_op_level == SMB2_OPLOCK_LEVEL_LEASE &&
- !(conn->vals->capabilities & SMB2_GLOBAL_CAP_LEASING))) {
+ if (!test_share_config_flag(work->tcon->share_conf, KSMBD_SHARE_FLAG_OPLOCKS) ||
+ (req_op_level == SMB2_OPLOCK_LEVEL_LEASE &&
+ !(conn->vals->capabilities & SMB2_GLOBAL_CAP_LEASING))) {
if (share_ret < 0 && !S_ISDIR(FP_INODE(fp)->i_mode)) {
rc = share_ret;
goto err_out;
if (rc)
goto err_out;
} else if (open_flags == O_RDONLY &&
- (req_op_level == SMB2_OPLOCK_LEVEL_BATCH ||
- req_op_level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))
+ (req_op_level == SMB2_OPLOCK_LEVEL_BATCH ||
+ req_op_level == SMB2_OPLOCK_LEVEL_EXCLUSIVE))
req_op_level = SMB2_OPLOCK_LEVEL_II;
rc = smb_grant_oplock(work, req_op_level,
err);
}
- context = smb2_find_context_vals(req,
- SMB2_CREATE_QUERY_ON_DISK_ID);
+ context = smb2_find_context_vals(req, SMB2_CREATE_QUERY_ON_DISK_ID);
if (IS_ERR(context)) {
- rc = check_context_err(context,
- SMB2_CREATE_QUERY_ON_DISK_ID);
+ rc = check_context_err(context, SMB2_CREATE_QUERY_ON_DISK_ID);
if (rc < 0)
goto err_out;
} else {
memcpy(fp->client_guid, conn->ClientGUID, SMB2_CLIENT_GUID_SIZE);
if (d_info.type) {
- if (d_info.type == DURABLE_REQ_V2 &&
- d_info.persistent)
+ if (d_info.type == DURABLE_REQ_V2 && d_info.persistent)
fp->is_persistent = 1;
else
fp->is_durable = 1;
else
fp->durable_timeout = 1600;
if (d_info.app_id)
- memcpy(fp->app_instance_id,
- d_info.app_id, 16);
+ memcpy(fp->app_instance_id, d_info.app_id, 16);
}
}
*
* Return: 0 on success, otherwise error
*/
-static int smb2_populate_readdir_entry(struct ksmbd_conn *conn,
- int info_level,
- struct ksmbd_dir_info *d_info,
- struct ksmbd_kstat *ksmbd_kstat)
+static int smb2_populate_readdir_entry(struct ksmbd_conn *conn, int info_level,
+ struct ksmbd_dir_info *d_info, struct ksmbd_kstat *ksmbd_kstat)
{
int next_entry_offset = 0;
char *conv_name;
}
static int reserve_populate_dentry(struct ksmbd_dir_info *d_info,
- int info_level)
+ int info_level)
{
int struct_sz;
int conv_len;
return 0;
}
-static int __query_dir(struct dir_context *ctx,
- const char *name,
- int namlen,
- loff_t offset,
- u64 ino,
- unsigned int d_type)
+static int __query_dir(struct dir_context *ctx, const char *name, int namlen,
+ loff_t offset, u64 ino, unsigned int d_type)
{
struct ksmbd_readdir_data *buf;
struct smb2_query_dir_private *priv;
}
if (!(dir_fp->daccess & FILE_LIST_DIRECTORY_LE) ||
- inode_permission(&init_user_ns, file_inode(dir_fp->filp),
- MAY_READ | MAY_EXEC)) {
+ 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));
rc = -EACCES;
ksmbd_debug(SMB, "Search Pattern not found\n");
rc = -EINVAL;
goto err_out2;
- } else
+ } else {
ksmbd_debug(SMB, "Search pattern is %s\n", srch_ptr);
+ }
ksmbd_debug(SMB, "Directory name is %s\n", dir_fp->filename);
memset(&d_info, 0, sizeof(struct ksmbd_dir_info));
d_info.wptr = (char *)rsp->Buffer;
d_info.rptr = (char *)rsp->Buffer;
- d_info.out_buf_len = (work->response_sz -
- (get_rfc1002_len(rsp_org) + 4));
+ d_info.out_buf_len = (work->response_sz - (get_rfc1002_len(rsp_org) + 4));
d_info.out_buf_len = min_t(int, d_info.out_buf_len,
- le32_to_cpu(req->OutputBufferLength)) -
- sizeof(struct smb2_query_directory_rsp);
+ le32_to_cpu(req->OutputBufferLength)) - sizeof(struct smb2_query_directory_rsp);
d_info.flags = srch_flag;
/*
goto err_out;
if (!d_info.data_count && d_info.out_buf_len >= 0) {
- if (srch_flag & SMB2_RETURN_SINGLE_ENTRY && !is_asterisk(srch_ptr))
+ if (srch_flag & SMB2_RETURN_SINGLE_ENTRY && !is_asterisk(srch_ptr)) {
rsp->hdr.Status = STATUS_NO_SUCH_FILE;
- else {
+ } else {
dir_fp->dot_dotdot[0] = dir_fp->dot_dotdot[1] = 0;
rsp->hdr.Status = STATUS_NO_MORE_FILES;
}
* Return: 0 on success, otherwise error
*/
static int buffer_check_err(int reqOutputBufferLength,
- struct smb2_query_info_rsp *rsp, int infoclass_size)
+ struct smb2_query_info_rsp *rsp, int infoclass_size)
{
if (reqOutputBufferLength < le32_to_cpu(rsp->OutputBufferLength)) {
if (reqOutputBufferLength < infoclass_size) {
ksmbd_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);
+ rsp->hdr.smb2_buf_length = cpu_to_be32(sizeof(struct smb2_hdr) - 4);
return -EINVAL;
}
ksmbd_debug(SMB, "Buffer Overflow\n");
rsp->hdr.Status = STATUS_BUFFER_OVERFLOW;
- rsp->hdr.smb2_buf_length = cpu_to_be32(
- sizeof(struct smb2_hdr) - 4
- + reqOutputBufferLength);
- rsp->OutputBufferLength = cpu_to_le32(
- reqOutputBufferLength);
+ rsp->hdr.smb2_buf_length = cpu_to_be32(sizeof(struct smb2_hdr) - 4 +
+ reqOutputBufferLength);
+ rsp->OutputBufferLength = cpu_to_le32(reqOutputBufferLength);
}
return 0;
}
}
static void get_internal_info_pipe(struct smb2_query_info_rsp *rsp,
- uint64_t num)
+ u64 num)
{
struct smb2_file_internal_info *file_info;
}
static int smb2_get_info_file_pipe(struct ksmbd_session *sess,
- struct smb2_query_info_req *req, struct smb2_query_info_rsp *rsp)
+ struct smb2_query_info_req *req,
+ struct smb2_query_info_rsp *rsp)
{
- uint64_t id;
+ u64 id;
int rc;
/*
*
* Return: 0 on success, otherwise error
*/
-static int smb2_get_ea(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- struct smb2_query_info_req *req,
- struct smb2_query_info_rsp *rsp,
- void *rsp_org)
+static int smb2_get_ea(struct ksmbd_work *work, struct ksmbd_file *fp,
+ struct smb2_query_info_req *req,
+ struct smb2_query_info_rsp *rsp, void *rsp_org)
{
struct smb2_ea_info *eainfo, *prev_eainfo;
char *name, *ptr, *xattr_list = NULL, *buf;
path = &fp->filp->f_path;
/* single EA entry is requested with given user.* name */
- if (req->InputBufferLength)
+ if (req->InputBufferLength) {
ea_req = (struct smb2_ea_info_req *)req->Buffer;
- else {
+ } else {
/* need to send all EAs, if no specific EA is requested*/
if (le32_to_cpu(req->Flags) & SL_RETURN_SINGLE_ENTRY)
ksmbd_debug(SMB,
continue;
if (!strncmp(&name[XATTR_USER_PREFIX_LEN], STREAM_PREFIX,
- STREAM_PREFIX_LEN))
+ STREAM_PREFIX_LEN))
continue;
if (req->InputBufferLength &&
- (strncmp(&name[XATTR_USER_PREFIX_LEN],
- ea_req->name, ea_req->EaNameLength)))
+ strncmp(&name[XATTR_USER_PREFIX_LEN], ea_req->name,
+ ea_req->EaNameLength))
continue;
if (!strncmp(&name[XATTR_USER_PREFIX_LEN],
- DOS_ATTRIBUTE_PREFIX, DOS_ATTRIBUTE_PREFIX_LEN))
+ DOS_ATTRIBUTE_PREFIX, DOS_ATTRIBUTE_PREFIX_LEN))
continue;
if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
eainfo->Flags = 0;
eainfo->EaNameLength = name_len;
- if (!strncmp(name, XATTR_USER_PREFIX,
- XATTR_USER_PREFIX_LEN))
+ if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
memcpy(eainfo->name, &name[XATTR_USER_PREFIX_LEN],
name_len);
else
}
static void get_file_access_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_access_info *file_info;
}
static int get_file_basic_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_all_info *basic_info;
struct kstat stat;
basic_info->Attributes = fp->f_ci->m_fattr;
basic_info->Pad1 = 0;
rsp->OutputBufferLength =
- cpu_to_le32(offsetof(struct smb2_file_all_info,
- AllocationSize));
+ cpu_to_le32(offsetof(struct smb2_file_all_info, AllocationSize));
inc_rfc1001_len(rsp_org, offsetof(struct smb2_file_all_info,
AllocationSize));
return 0;
alloc_size = stat->size;
else
alloc_size = inode->i_blocks << 9;
-
}
return alloc_size;
}
static void get_file_standard_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_standard_info *sinfo;
unsigned int delete_pending;
}
static void get_file_alignment_info(struct smb2_query_info_rsp *rsp,
- void *rsp_org)
+ void *rsp_org)
{
struct smb2_file_alignment_info *file_info;
}
static int get_file_all_info(struct ksmbd_work *work,
- struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct smb2_query_info_rsp *rsp, struct ksmbd_file *fp,
+ void *rsp_org)
{
struct ksmbd_conn *conn = work->conn;
struct smb2_file_all_info *file_info;
}
static void get_file_alternate_info(struct ksmbd_work *work,
- struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct smb2_query_info_rsp *rsp, struct ksmbd_file *fp,
+ void *rsp_org)
{
struct ksmbd_conn *conn = work->conn;
struct smb2_file_alt_name_info *file_info;
}
static void get_file_stream_info(struct ksmbd_work *work,
- struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct smb2_query_info_rsp *rsp, struct ksmbd_file *fp,
+ void *rsp_org)
{
struct ksmbd_conn *conn = work->conn;
struct smb2_file_stream_info *file_info;
ksmbd_debug(SMB, "%s, len %d\n", stream_name, streamlen);
if (strncmp(&stream_name[XATTR_USER_PREFIX_LEN],
- STREAM_PREFIX, STREAM_PREFIX_LEN))
+ STREAM_PREFIX, STREAM_PREFIX_LEN))
continue;
stream_name_len = streamlen - (XATTR_USER_PREFIX_LEN +
}
static void get_file_internal_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_internal_info *file_info;
struct kstat stat;
}
static int get_file_network_open_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_ntwrk_info *file_info;
struct inode *inode;
return 0;
}
-static void get_file_ea_info(struct smb2_query_info_rsp *rsp,
- void *rsp_org)
+static void get_file_ea_info(struct smb2_query_info_rsp *rsp, void *rsp_org)
{
struct smb2_file_ea_info *file_info;
}
static void get_file_position_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_pos_info *file_info;
}
static void get_file_mode_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_mode_info *file_info;
}
static void get_file_compression_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_comp_info *file_info;
struct kstat stat;
}
static int get_file_attribute_tag_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb2_file_attr_tag_info *file_info;
}
static int find_file_posix_info(struct smb2_query_info_rsp *rsp,
- struct ksmbd_file *fp,
- void *rsp_org)
+ struct ksmbd_file *fp, void *rsp_org)
{
struct smb311_posix_qinfo *file_info;
struct inode *inode = FP_INODE(fp);
file_info->DeviceId = cpu_to_le32(inode->i_rdev);
rsp->OutputBufferLength =
cpu_to_le32(sizeof(struct smb311_posix_qinfo));
- inc_rfc1001_len(rsp_org,
- sizeof(struct smb311_posix_qinfo));
+ inc_rfc1001_len(rsp_org, sizeof(struct smb311_posix_qinfo));
return 0;
}
static int smb2_get_info_file(struct ksmbd_work *work,
- struct smb2_query_info_req *req,
- struct smb2_query_info_rsp *rsp,
- void *rsp_org)
+ struct smb2_query_info_req *req,
+ struct smb2_query_info_rsp *rsp, void *rsp_org)
{
struct ksmbd_file *fp;
int fileinfoclass = 0;
unsigned int id = KSMBD_NO_FID, pid = KSMBD_NO_FID;
if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_PIPE)) {
+ KSMBD_SHARE_FLAG_PIPE)) {
/* smb2 info file called for pipe */
return smb2_get_info_file_pipe(work->sess, req, rsp);
}
}
static int smb2_get_info_filesystem(struct ksmbd_work *work,
- struct smb2_query_info_req *req,
- struct smb2_query_info_rsp *rsp,
- void *rsp_org)
+ struct smb2_query_info_req *req,
+ struct smb2_query_info_rsp *rsp, void *rsp_org)
{
struct ksmbd_session *sess = work->sess;
struct ksmbd_conn *conn = sess->conn;
info->extended_info.version = cpu_to_le32(1);
info->extended_info.release = cpu_to_le32(1);
info->extended_info.rel_date = 0;
- memcpy(info->extended_info.version_string,
- "1.1.0",
- strlen("1.1.0"));
+ memcpy(info->extended_info.version_string, "1.1.0", strlen("1.1.0"));
rsp->OutputBufferLength = cpu_to_le32(64);
inc_rfc1001_len(rsp_org, 64);
fs_infoclass_size = FS_OBJECT_ID_INFORMATION_SIZE;
}
static int smb2_get_info_sec(struct ksmbd_work *work,
- struct smb2_query_info_req *req, struct smb2_query_info_rsp *rsp,
- void *rsp_org)
+ struct smb2_query_info_req *req,
+ struct smb2_query_info_rsp *rsp, void *rsp_org)
{
struct ksmbd_file *fp;
struct smb_ntsd *pntsd = (struct smb_ntsd *)rsp->Buffer, *ppntsd = NULL;
fattr.cf_dacls = ksmbd_vfs_get_acl(inode, ACL_TYPE_DEFAULT);
if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_ACL_XATTR))
+ KSMBD_SHARE_FLAG_ACL_XATTR))
ksmbd_vfs_get_sd_xattr(work->conn, fp->filp->f_path.dentry, &ppntsd);
rc = build_sec_desc(pntsd, ppntsd, addition_info, &secdesclen, &fattr);
*/
static noinline int smb2_close_pipe(struct ksmbd_work *work)
{
- uint64_t id;
+ u64 id;
struct smb2_close_req *req = work->request_buf;
struct smb2_close_rsp *rsp = work->response_buf;
int smb2_close(struct ksmbd_work *work)
{
unsigned int volatile_id = KSMBD_NO_FID;
- uint64_t sess_id;
+ u64 sess_id;
struct smb2_close_req *req;
struct smb2_close_rsp *rsp;
struct smb2_close_rsp *rsp_org;
sess_id = work->compound_sid;
work->compound_sid = 0;
- if (check_session_id(conn, sess_id))
+ if (check_session_id(conn, sess_id)) {
work->compound_sid = sess_id;
- else {
+ } else {
rsp->hdr.Status = STATUS_USER_SESSION_DELETED;
if (req->hdr.Flags & SMB2_FLAGS_RELATED_OPERATIONS)
rsp->hdr.Status = STATUS_INVALID_PARAMETER;
}
if (work->next_smb2_rcv_hdr_off &&
- !HAS_FILE_ID(le64_to_cpu(req->VolatileFileId))) {
+ !HAS_FILE_ID(le64_to_cpu(req->VolatileFileId))) {
if (!HAS_FILE_ID(work->compound_fid)) {
/* file already closed, return FILE_CLOSED */
ksmbd_debug(SMB, "file already closed\n");
}
static int smb2_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
- struct smb2_file_rename_info *file_info,
- struct nls_table *local_nls)
+ struct smb2_file_rename_info *file_info,
+ struct nls_table *local_nls)
{
struct ksmbd_share_config *share = fp->tcon->share_conf;
char *new_name = NULL, *abs_oldname = NULL, *old_name = NULL;
goto out;
}
old_name = strrchr(abs_oldname, '/');
- if (old_name && old_name[1] != '\0')
+ if (old_name && old_name[1] != '\0') {
old_name++;
- else {
+ } else {
ksmbd_debug(SMB, "can't get last component in path %s\n",
abs_oldname);
rc = -ENOENT;
}
} else {
if (file_present &&
- strncmp(old_name, path.dentry->d_name.name,
- strlen(old_name))) {
+ strncmp(old_name, path.dentry->d_name.name, strlen(old_name))) {
rc = -EEXIST;
ksmbd_debug(SMB,
"cannot rename already existing file\n");
}
static int smb2_create_link(struct ksmbd_work *work,
- struct ksmbd_share_config *share,
- struct smb2_file_link_info *file_info,
- struct file *filp,
- struct nls_table *local_nls)
+ struct ksmbd_share_config *share,
+ struct smb2_file_link_info *file_info, struct file *filp,
+ struct nls_table *local_nls)
{
char *link_name = NULL, *target_name = NULL, *pathname = NULL;
struct path path;
return fp->daccess & FILE_WRITE_ATTRIBUTES_LE;
}
-static int set_file_basic_info(struct ksmbd_file *fp,
- char *buf,
- struct ksmbd_share_config *share)
+static int set_file_basic_info(struct ksmbd_file *fp, char *buf,
+ struct ksmbd_share_config *share)
{
struct smb2_file_all_info *file_info;
struct iattr attrs;
temp_attrs.ia_ctime = ksmbd_NTtimeToUnix(file_info->ChangeTime);
attrs.ia_ctime = temp_attrs.ia_ctime;
attrs.ia_valid |= ATTR_CTIME;
- } else
+ } else {
temp_attrs.ia_ctime = inode->i_ctime;
+ }
if (file_info->LastWriteTime) {
attrs.ia_mtime = ksmbd_NTtimeToUnix(file_info->LastWriteTime);
if (file_info->Attributes) {
if (!S_ISDIR(inode->i_mode) &&
- file_info->Attributes & ATTR_DIRECTORY_LE) {
+ file_info->Attributes & ATTR_DIRECTORY_LE) {
ksmbd_err("can't change a file to a directory\n");
return -EINVAL;
}
}
static int set_file_allocation_info(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- char *buf)
+ struct ksmbd_file *fp, char *buf)
{
/*
* TODO : It's working fine only when store dos attributes
return 0;
}
-static int set_end_of_file_info(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- char *buf)
+static int set_end_of_file_info(struct ksmbd_work *work, struct ksmbd_file *fp,
+ char *buf)
{
struct smb2_file_eof_info *file_eof_info;
loff_t newsize;
fp->filename, newsize);
rc = ksmbd_vfs_truncate(work, NULL, fp, newsize);
if (rc) {
- ksmbd_debug(SMB,
- "truncate failed! filename : %s err %d\n",
+ ksmbd_debug(SMB, "truncate failed! filename : %s err %d\n",
fp->filename, rc);
if (rc != -EAGAIN)
rc = -EBADF;
return 0;
}
-static int set_rename_info(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- char *buf)
+static int set_rename_info(struct ksmbd_work *work, struct ksmbd_file *fp,
+ char *buf)
{
struct ksmbd_file *parent_fp;
work->sess->conn->local_nls);
}
-static int set_file_disposition_info(struct ksmbd_file *fp,
- char *buf)
+static int set_file_disposition_info(struct ksmbd_file *fp, char *buf)
{
struct smb2_file_disposition_info *file_info;
struct inode *inode;
file_info = (struct smb2_file_disposition_info *)buf;
if (file_info->DeletePending) {
if (S_ISDIR(inode->i_mode) &&
- ksmbd_vfs_empty_dir(fp) == -ENOTEMPTY)
+ ksmbd_vfs_empty_dir(fp) == -ENOTEMPTY)
return -EBUSY;
ksmbd_set_inode_pending_delete(fp);
} else {
return 0;
}
-static int set_file_position_info(struct ksmbd_file *fp,
- char *buf)
+static int set_file_position_info(struct ksmbd_file *fp, char *buf)
{
struct smb2_file_pos_info *file_info;
loff_t current_byte_offset;
sector_size = ksmbd_vfs_logical_sector_size(inode);
if (current_byte_offset < 0 ||
- (fp->coption == FILE_NO_INTERMEDIATE_BUFFERING_LE &&
- current_byte_offset & (sector_size-1))) {
+ (fp->coption == FILE_NO_INTERMEDIATE_BUFFERING_LE &&
+ current_byte_offset & (sector_size - 1))) {
ksmbd_err("CurrentByteOffset is not valid : %llu\n",
current_byte_offset);
return -EINVAL;
return 0;
}
-static int set_file_mode_info(struct ksmbd_file *fp,
- char *buf)
+static int set_file_mode_info(struct ksmbd_file *fp, char *buf)
{
struct smb2_file_mode_info *file_info;
__le32 mode;
file_info = (struct smb2_file_mode_info *)buf;
mode = file_info->Mode;
- if ((mode & (~FILE_MODE_INFO_MASK)) ||
- (mode & FILE_SYNCHRONOUS_IO_ALERT_LE &&
- mode & FILE_SYNCHRONOUS_IO_NONALERT_LE)) {
+ 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));
return -EINVAL;
}
* Return: 0 on success, otherwise error
* TODO: need to implement an error handling for STATUS_INFO_LENGTH_MISMATCH
*/
-static int smb2_set_info_file(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- int info_class,
- char *buf,
- struct ksmbd_share_config *share)
+static int smb2_set_info_file(struct ksmbd_work *work, struct ksmbd_file *fp,
+ int info_class, char *buf, struct ksmbd_share_config *share)
{
switch (info_class) {
case FILE_BASIC_INFORMATION:
return set_end_of_file_info(work, fp, buf);
case FILE_RENAME_INFORMATION:
- if (!test_tree_conn_flag(work->tcon,
- KSMBD_TREE_CONN_FLAG_WRITABLE)) {
+ if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) {
ksmbd_debug(SMB,
"User does not have write permission\n");
return -EACCES;
work->sess->conn->local_nls);
case FILE_DISPOSITION_INFORMATION:
- if (!test_tree_conn_flag(work->tcon,
- KSMBD_TREE_CONN_FLAG_WRITABLE)) {
+ if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) {
ksmbd_debug(SMB,
"User does not have write permission\n");
return -EACCES;
return -EOPNOTSUPP;
}
-static int smb2_set_info_sec(struct ksmbd_file *fp,
- int addition_info,
- char *buffer,
- int buf_len)
+static int smb2_set_info_sec(struct ksmbd_file *fp, int addition_info,
+ char *buffer, int buf_len)
{
struct smb_ntsd *pntsd = (struct smb_ntsd *)buffer;
static noinline int smb2_read_pipe(struct ksmbd_work *work)
{
int nbytes = 0, err;
- uint64_t id;
+ u64 id;
struct ksmbd_rpc_command *rpc_resp;
struct smb2_read_req *req = work->request_buf;
struct smb2_read_rsp *rsp = work->response_buf;
}
static ssize_t smb2_read_rdma_channel(struct ksmbd_work *work,
- struct smb2_read_req *req,
- void *data_buf, size_t length)
+ struct smb2_read_req *req, void *data_buf, size_t length)
{
struct smb2_buffer_desc_v1 *desc =
(struct smb2_buffer_desc_v1 *)&req->Buffer[0];
int err;
- if (work->conn->dialect == SMB30_PROT_ID
- && req->Channel != SMB2_CHANNEL_RDMA_V1)
+ if (work->conn->dialect == SMB30_PROT_ID &&
+ req->Channel != SMB2_CHANNEL_RDMA_V1)
return -EINVAL;
- if (req->ReadChannelInfoOffset == 0
- || le16_to_cpu(req->ReadChannelInfoLength) < sizeof(*desc))
+ if (req->ReadChannelInfoOffset == 0 ||
+ le16_to_cpu(req->ReadChannelInfoLength) < sizeof(*desc))
return -EINVAL;
work->need_invalidate_rkey =
(req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE);
work->remote_key = le32_to_cpu(desc->token);
- err = ksmbd_conn_rdma_write(work->conn,
- data_buf, length,
- le32_to_cpu(desc->token),
- le64_to_cpu(desc->offset),
- le32_to_cpu(desc->length));
+ err = ksmbd_conn_rdma_write(work->conn, data_buf, length,
+ le32_to_cpu(desc->token), le64_to_cpu(desc->offset),
+ le32_to_cpu(desc->length));
if (err)
return err;
nbytes, offset, mincount);
if (req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE ||
- req->Channel == SMB2_CHANNEL_RDMA_V1) {
+ req->Channel == SMB2_CHANNEL_RDMA_V1) {
/* write data to the client using rdma channel */
remain_bytes = smb2_read_rdma_channel(work, req,
work->aux_payload_buf, nbytes);
struct smb2_write_req *req = work->request_buf;
struct smb2_write_rsp *rsp = work->response_buf;
struct ksmbd_rpc_command *rpc_resp;
- uint64_t id = 0;
+ u64 id = 0;
int err = 0, ret = 0;
char *data_buf;
size_t length;
id = le64_to_cpu(req->VolatileFileId);
if (le16_to_cpu(req->DataOffset) ==
- (offsetof(struct smb2_write_req, Buffer) - 4)) {
+ (offsetof(struct smb2_write_req, Buffer) - 4)) {
data_buf = (char *)&req->Buffer[0];
} else {
if ((le16_to_cpu(req->DataOffset) > get_rfc1002_len(req)) ||
- (le16_to_cpu(req->DataOffset) +
- length > 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));
+ le16_to_cpu(req->DataOffset), get_rfc1002_len(req));
err = -EINVAL;
goto out;
}
}
static ssize_t smb2_write_rdma_channel(struct ksmbd_work *work,
- struct smb2_write_req *req, struct ksmbd_file *fp,
- loff_t offset, size_t length, bool sync)
+ struct smb2_write_req *req, struct ksmbd_file *fp,
+ loff_t offset, size_t length, bool sync)
{
struct smb2_buffer_desc_v1 *desc;
char *data_buf;
desc = (struct smb2_buffer_desc_v1 *)&req->Buffer[0];
if (work->conn->dialect == SMB30_PROT_ID &&
- req->Channel != SMB2_CHANNEL_RDMA_V1)
+ req->Channel != SMB2_CHANNEL_RDMA_V1)
return -EINVAL;
if (req->Length != 0 || req->DataOffset != 0)
return -EINVAL;
- if (req->WriteChannelInfoOffset == 0
- || le16_to_cpu(req->WriteChannelInfoLength) < sizeof(*desc))
+ if (req->WriteChannelInfoOffset == 0 ||
+ le16_to_cpu(req->WriteChannelInfoLength) < sizeof(*desc))
return -EINVAL;
work->need_invalidate_rkey =
le32_to_cpu(desc->token),
le64_to_cpu(desc->offset),
le32_to_cpu(desc->length));
-
if (ret < 0) {
ksmbd_free_response(data_buf);
return ret;
}
- ret = ksmbd_vfs_write(work, fp, data_buf, length, &offset,
- sync, &nbytes);
-
+ ret = ksmbd_vfs_write(work, fp, data_buf, length, &offset, sync, &nbytes);
ksmbd_free_response(data_buf);
if (ret < 0)
return ret;
rsp_org = work->response_buf;
WORK_BUFFERS(work, req, rsp);
- if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_PIPE)) {
+ if (test_share_config_flag(work->tcon->share_conf, KSMBD_SHARE_FLAG_PIPE)) {
ksmbd_debug(SMB, "IPC pipe write request\n");
return smb2_write_pipe(work);
}
goto out;
}
- fp = ksmbd_lookup_fd_slow(work,
- le64_to_cpu(req->VolatileFileId),
- le64_to_cpu(req->PersistentFileId));
+ fp = ksmbd_lookup_fd_slow(work, le64_to_cpu(req->VolatileFileId),
+ le64_to_cpu(req->PersistentFileId));
if (!fp) {
rsp->hdr.Status = STATUS_FILE_CLOSED;
return -ENOENT;
writethrough = true;
if (req->Channel != SMB2_CHANNEL_RDMA_V1 &&
- req->Channel != SMB2_CHANNEL_RDMA_V1_INVALIDATE) {
-
+ req->Channel != SMB2_CHANNEL_RDMA_V1_INVALIDATE) {
if (le16_to_cpu(req->DataOffset) ==
(offsetof(struct smb2_write_req, Buffer) - 4)) {
data_buf = (char *)&req->Buffer[0];
} else {
- if ((le16_to_cpu(req->DataOffset) >
- get_rfc1002_len(req)) ||
- (le16_to_cpu(req->DataOffset) +
- length > get_rfc1002_len(req))) {
+ 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));
chdr = cancel_work->request_buf;
if (cancel_work->async_id !=
- le64_to_cpu(hdr->Id.AsyncId))
+ le64_to_cpu(hdr->Id.AsyncId))
continue;
ksmbd_debug(SMB,
chdr = cancel_work->request_buf;
if (chdr->MessageId != hdr->MessageId ||
- cancel_work == work)
+ cancel_work == work)
continue;
ksmbd_debug(SMB,
flock->fl_type = F_WRLCK;
flock->fl_flags |= FL_SLEEP;
break;
- case SMB2_LOCKFLAG_SHARED|SMB2_LOCKFLAG_FAIL_IMMEDIATELY:
+ case SMB2_LOCKFLAG_SHARED | SMB2_LOCKFLAG_FAIL_IMMEDIATELY:
ksmbd_debug(SMB,
"received shared & fail immediately request\n");
cmd = F_SETLK;
flock->fl_type = F_RDLCK;
break;
- case SMB2_LOCKFLAG_EXCLUSIVE|SMB2_LOCKFLAG_FAIL_IMMEDIATELY:
+ case SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_FAIL_IMMEDIATELY:
ksmbd_debug(SMB,
"received exclusive & fail immediately request\n");
cmd = F_SETLK;
}
static struct ksmbd_lock *smb2_lock_init(struct file_lock *flock,
- unsigned int cmd, int flags, struct list_head *lock_list)
+ unsigned int cmd, int flags, struct list_head *lock_list)
{
struct ksmbd_lock *lock;
int flags = 0;
int cmd = 0;
int err = 0, i;
- uint64_t lock_length;
+ u64 lock_length;
struct ksmbd_lock *smb_lock = NULL, *cmp_lock, *tmp;
int nolock = 0;
LIST_HEAD(lock_list);
ksmbd_debug(SMB, "Received lock request\n");
fp = ksmbd_lookup_fd_slow(work,
- le64_to_cpu(req->VolatileFileId),
- le64_to_cpu(req->PersistentFileId));
+ le64_to_cpu(req->VolatileFileId),
+ le64_to_cpu(req->PersistentFileId));
if (!fp) {
ksmbd_debug(SMB, "Invalid file id for lock : %llu\n",
le64_to_cpu(req->VolatileFileId));
lock_length = le64_to_cpu(lock_ele[i].Length);
if (lock_length > 0) {
- if (lock_length >
- OFFSET_MAX - flock->fl_start) {
+ if (lock_length > OFFSET_MAX - flock->fl_start) {
ksmbd_debug(SMB,
"Invalid lock range requested\n");
lock_length = OFFSET_MAX - flock->fl_start;
rsp->hdr.Status = STATUS_INVALID_LOCK_RANGE;
goto out;
}
- } else
+ } else {
lock_length = 0;
+ }
flock->fl_end = flock->fl_start + lock_length;
/* Check conflict locks in one request */
list_for_each_entry(cmp_lock, &lock_list, llist) {
if (cmp_lock->fl->fl_start <= flock->fl_start &&
- cmp_lock->fl->fl_end >= flock->fl_end) {
+ cmp_lock->fl->fl_end >= flock->fl_end) {
if (cmp_lock->fl->fl_type != F_UNLCK &&
- flock->fl_type != F_UNLCK) {
+ flock->fl_type != F_UNLCK) {
ksmbd_err("conflict two locks in one request\n");
rsp->hdr.Status =
STATUS_INVALID_PARAMETER;
goto out;
}
- if ((prior_lock & (SMB2_LOCKFLAG_EXCLUSIVE |
- SMB2_LOCKFLAG_SHARED) &&
- smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) ||
- (prior_lock == SMB2_LOCKFLAG_UNLOCK &&
- !(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK))) {
+ if ((prior_lock & (SMB2_LOCKFLAG_EXCLUSIVE | SMB2_LOCKFLAG_SHARED) &&
+ smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) ||
+ (prior_lock == SMB2_LOCKFLAG_UNLOCK &&
+ !(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK))) {
rsp->hdr.Status = STATUS_INVALID_PARAMETER;
goto out;
}
prior_lock = smb_lock->flags;
if (!(smb_lock->flags & SMB2_LOCKFLAG_UNLOCK) &&
- !(smb_lock->flags & SMB2_LOCKFLAG_FAIL_IMMEDIATELY))
+ !(smb_lock->flags & SMB2_LOCKFLAG_FAIL_IMMEDIATELY))
goto no_check_gl;
nolock = 1;
/* check locks in global list */
list_for_each_entry(cmp_lock, &global_lock_list, glist) {
if (file_inode(cmp_lock->fl->fl_file) !=
- file_inode(smb_lock->fl->fl_file))
+ file_inode(smb_lock->fl->fl_file))
continue;
if (smb_lock->fl->fl_type == F_UNLCK) {
- if (cmp_lock->fl->fl_file ==
- smb_lock->fl->fl_file &&
- cmp_lock->start == smb_lock->start &&
- cmp_lock->end == smb_lock->end &&
- !lock_defer_pending(cmp_lock->fl)) {
+ if (cmp_lock->fl->fl_file == smb_lock->fl->fl_file &&
+ cmp_lock->start == smb_lock->start &&
+ cmp_lock->end == smb_lock->end &&
+ !lock_defer_pending(cmp_lock->fl)) {
nolock = 0;
locks_free_lock(cmp_lock->fl);
list_del(&cmp_lock->glist);
/* check zero byte lock range */
if (cmp_lock->zero_len && !smb_lock->zero_len &&
- cmp_lock->start > smb_lock->start &&
- cmp_lock->start < smb_lock->end) {
+ cmp_lock->start > smb_lock->start &&
+ cmp_lock->start < smb_lock->end) {
ksmbd_err("previous lock conflict with zero byte lock range\n");
rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
goto out;
}
if (smb_lock->zero_len && !cmp_lock->zero_len &&
- smb_lock->start > cmp_lock->start &&
- smb_lock->start < cmp_lock->end) {
+ smb_lock->start > cmp_lock->start &&
+ smb_lock->start < cmp_lock->end) {
ksmbd_err("current lock conflict with zero byte lock range\n");
rsp->hdr.Status = STATUS_LOCK_NOT_GRANTED;
goto out;
}
if (((cmp_lock->start <= smb_lock->start &&
- 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) {
+ 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");
rsp->hdr.Status =
STATUS_LOCK_NOT_GRANTED;
err = ksmbd_vfs_lock(filp, smb_lock->cmd, flock);
skip:
if (flags & SMB2_LOCKFLAG_UNLOCK) {
- if (!err)
+ if (!err) {
ksmbd_debug(SMB, "File unlocked\n");
- else if (err == -ENOENT) {
+ } else if (err == -ENOENT) {
rsp->hdr.Status = STATUS_NOT_LOCKED;
goto out;
}
return 0;
}
-static int fsctl_copychunk(struct ksmbd_work *work,
- struct smb2_ioctl_req *req,
- struct smb2_ioctl_rsp *rsp)
+static int fsctl_copychunk(struct ksmbd_work *work, struct smb2_ioctl_req *req,
+ struct smb2_ioctl_rsp *rsp)
{
struct copychunk_ioctl_req *ci_req;
struct copychunk_ioctl_rsp *ci_rsp;
rsp->VolatileFileId = req->VolatileFileId;
rsp->PersistentFileId = req->PersistentFileId;
- ci_rsp->ChunksWritten = cpu_to_le32(
- ksmbd_server_side_copy_max_chunk_count());
- ci_rsp->ChunkBytesWritten = cpu_to_le32(
- ksmbd_server_side_copy_max_chunk_size());
- ci_rsp->TotalBytesWritten = cpu_to_le32(
- ksmbd_server_side_copy_max_total_size());
+ ci_rsp->ChunksWritten =
+ cpu_to_le32(ksmbd_server_side_copy_max_chunk_count());
+ ci_rsp->ChunkBytesWritten =
+ cpu_to_le32(ksmbd_server_side_copy_max_chunk_size());
+ ci_rsp->TotalBytesWritten =
+ cpu_to_le32(ksmbd_server_side_copy_max_total_size());
chunks = (struct srv_copychunk *)&ci_req->Chunks[0];
chunk_count = le32_to_cpu(ci_req->ChunkCount);
/* verify the SRV_COPYCHUNK_COPY packet */
if (chunk_count > ksmbd_server_side_copy_max_chunk_count() ||
- le32_to_cpu(req->InputCount) <
- offsetof(struct copychunk_ioctl_req, Chunks) +
- chunk_count * sizeof(struct srv_copychunk)) {
+ le32_to_cpu(req->InputCount) <
+ offsetof(struct copychunk_ioctl_req, Chunks) +
+ chunk_count * sizeof(struct srv_copychunk)) {
rsp->hdr.Status = STATUS_INVALID_PARAMETER;
return -EINVAL;
}
for (i = 0; i < chunk_count; i++) {
if (le32_to_cpu(chunks[i].Length) == 0 ||
- le32_to_cpu(chunks[i].Length) >
- ksmbd_server_side_copy_max_chunk_size())
+ le32_to_cpu(chunks[i].Length) > ksmbd_server_side_copy_max_chunk_size())
break;
total_size_written += le32_to_cpu(chunks[i].Length);
}
- if (i < chunk_count || total_size_written >
- ksmbd_server_side_copy_max_total_size()) {
+
+ if (i < chunk_count ||
+ total_size_written > ksmbd_server_side_copy_max_total_size()) {
rsp->hdr.Status = STATUS_INVALID_PARAMETER;
return -EINVAL;
}
dst_fp = ksmbd_lookup_fd_slow(work,
le64_to_cpu(req->VolatileFileId),
le64_to_cpu(req->PersistentFileId));
-
ret = -EINVAL;
- if (!src_fp || src_fp->persistent_id !=
- le64_to_cpu(ci_req->ResumeKey[1])) {
+ if (!src_fp ||
+ src_fp->persistent_id != le64_to_cpu(ci_req->ResumeKey[1])) {
rsp->hdr.Status = STATUS_OBJECT_NAME_NOT_FOUND;
goto out;
}
+
if (!dst_fp) {
rsp->hdr.Status = STATUS_FILE_CLOSED;
goto out;
}
static int fsctl_query_iface_info_ioctl(struct ksmbd_conn *conn,
- struct smb2_ioctl_req *req,
- struct smb2_ioctl_rsp *rsp)
+ struct smb2_ioctl_req *req, struct smb2_ioctl_rsp *rsp)
{
struct network_interface_info_ioctl_rsp *nii_rsp = NULL;
int nbytes = 0;
netdev->ethtool_ops->get_link_ksettings(netdev, &cmd);
speed = cmd.base.speed;
} else {
- ksmbd_err("%s %s %s\n",
- netdev->name,
- "speed is unknown,",
- "defaulting to 1Gb/sec");
+ ksmbd_err("%s %s\n", netdev->name,
+ "speed is unknown, defaulting to 1Gb/sec");
speed = SPEED_1000;
}
return nbytes;
}
-
static int fsctl_validate_negotiate_info(struct ksmbd_conn *conn,
- struct validate_negotiate_info_req *neg_req,
- struct validate_negotiate_info_rsp *neg_rsp)
+ struct validate_negotiate_info_req *neg_req,
+ struct validate_negotiate_info_rsp *neg_rsp)
{
int ret = 0;
int dialect;
return ret;
}
-static int fsctl_query_allocated_ranges(struct ksmbd_work *work, uint64_t id,
- struct file_allocated_range_buffer *qar_req,
- struct file_allocated_range_buffer *qar_rsp,
- int in_count, int *out_count)
+static int fsctl_query_allocated_ranges(struct ksmbd_work *work, u64 id,
+ struct file_allocated_range_buffer *qar_req,
+ struct file_allocated_range_buffer *qar_rsp,
+ int in_count, int *out_count)
{
struct ksmbd_file *fp;
loff_t start, length;
return ret;
}
-static int fsctl_pipe_transceive(struct ksmbd_work *work, uint64_t id,
- int out_buf_len, struct smb2_ioctl_req *req, struct smb2_ioctl_rsp *rsp)
+static int fsctl_pipe_transceive(struct ksmbd_work *work, u64 id,
+ int out_buf_len, struct smb2_ioctl_req *req,
+ struct smb2_ioctl_rsp *rsp)
{
struct ksmbd_rpc_command *rpc_resp;
char *data_buf = (char *)&req->Buffer[0];
int nbytes = 0;
- rpc_resp = ksmbd_rpc_ioctl(work->sess, id,
- data_buf,
+ rpc_resp = ksmbd_rpc_ioctl(work->sess, id, data_buf,
le32_to_cpu(req->InputCount));
if (rpc_resp) {
if (rpc_resp->flags == KSMBD_RPC_SOME_NOT_MAPPED) {
return nbytes;
}
-static inline int fsctl_set_sparse(struct ksmbd_work *work, uint64_t id,
- struct file_sparse *sparse)
+static inline int fsctl_set_sparse(struct ksmbd_work *work, u64 id,
+ struct file_sparse *sparse)
{
struct ksmbd_file *fp;
int ret = 0;
fp->f_ci->m_fattr &= ~ATTR_SPARSE_FILE_LE;
if (fp->f_ci->m_fattr != old_fattr &&
- test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
+ test_share_config_flag(work->tcon->share_conf,
+ KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
struct xattr_dos_attrib da;
ret = ksmbd_vfs_get_dos_attrib_xattr(fp->filp->f_path.dentry, &da);
}
static int fsctl_request_resume_key(struct ksmbd_work *work,
- struct smb2_ioctl_req *req, struct resume_key_ioctl_rsp *key_rsp)
+ struct smb2_ioctl_req *req,
+ struct resume_key_ioctl_rsp *key_rsp)
{
struct ksmbd_file *fp;
struct smb2_ioctl_rsp *rsp, *rsp_org;
int cnt_code, nbytes = 0;
int out_buf_len;
- uint64_t id = KSMBD_NO_FID;
+ u64 id = KSMBD_NO_FID;
struct ksmbd_conn *conn = work->conn;
int ret = 0;
break;
case FSCTL_COPYCHUNK:
case FSCTL_COPYCHUNK_WRITE:
- if (!test_tree_conn_flag(work->tcon,
- KSMBD_TREE_CONN_FLAG_WRITABLE)) {
+ if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) {
ksmbd_debug(SMB,
"User does not have write permission\n");
ret = -EACCES;
struct ksmbd_file *fp;
loff_t off, len;
- if (!test_tree_conn_flag(work->tcon,
- KSMBD_TREE_CONN_FLAG_WRITABLE)) {
+ if (!test_tree_conn_flag(work->tcon, KSMBD_TREE_CONN_FLAG_WRITABLE)) {
ksmbd_debug(SMB,
"User does not have write permission\n");
ret = -EACCES;
struct oplock_info *opinfo = NULL;
__le32 err = 0;
int ret = 0;
- uint64_t volatile_id, persistent_id;
+ u64 volatile_id, persistent_id;
char req_oplevel = 0, rsp_oplevel = 0;
unsigned int oplock_change_type;
goto err_out;
}
- if (((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE) ||
- (opinfo->level == SMB2_OPLOCK_LEVEL_BATCH)) &&
- ((req_oplevel != SMB2_OPLOCK_LEVEL_II) &&
- (req_oplevel != SMB2_OPLOCK_LEVEL_NONE))) {
+ if ((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE ||
+ opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) &&
+ (req_oplevel != SMB2_OPLOCK_LEVEL_II &&
+ req_oplevel != SMB2_OPLOCK_LEVEL_NONE)) {
err = STATUS_INVALID_OPLOCK_PROTOCOL;
oplock_change_type = OPLOCK_WRITE_TO_NONE;
- } else if ((opinfo->level == SMB2_OPLOCK_LEVEL_II) &&
- (req_oplevel != SMB2_OPLOCK_LEVEL_NONE)) {
+ } else if (opinfo->level == SMB2_OPLOCK_LEVEL_II &&
+ req_oplevel != SMB2_OPLOCK_LEVEL_NONE) {
err = STATUS_INVALID_OPLOCK_PROTOCOL;
oplock_change_type = OPLOCK_READ_TO_NONE;
- } else if ((req_oplevel == SMB2_OPLOCK_LEVEL_II) ||
- (req_oplevel == SMB2_OPLOCK_LEVEL_NONE)) {
+ } else if (req_oplevel == SMB2_OPLOCK_LEVEL_II ||
+ req_oplevel == SMB2_OPLOCK_LEVEL_NONE) {
err = STATUS_INVALID_DEVICE_STATE;
- if (((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE) ||
- (opinfo->level == SMB2_OPLOCK_LEVEL_BATCH)) &&
- (req_oplevel == SMB2_OPLOCK_LEVEL_II)) {
+ if ((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE ||
+ opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) &&
+ req_oplevel == SMB2_OPLOCK_LEVEL_II) {
oplock_change_type = OPLOCK_WRITE_TO_READ;
- } else if (((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE)
- || (opinfo->level == SMB2_OPLOCK_LEVEL_BATCH)) &&
- (req_oplevel == SMB2_OPLOCK_LEVEL_NONE)) {
+ } else if ((opinfo->level == SMB2_OPLOCK_LEVEL_EXCLUSIVE ||
+ opinfo->level == SMB2_OPLOCK_LEVEL_BATCH) &&
+ req_oplevel == SMB2_OPLOCK_LEVEL_NONE) {
oplock_change_type = OPLOCK_WRITE_TO_NONE;
- } else if ((opinfo->level == SMB2_OPLOCK_LEVEL_II) &&
- (req_oplevel == SMB2_OPLOCK_LEVEL_NONE)) {
+ } else if (opinfo->level == SMB2_OPLOCK_LEVEL_II &&
+ req_oplevel == SMB2_OPLOCK_LEVEL_NONE) {
oplock_change_type = OPLOCK_READ_TO_NONE;
- } else
+ } else {
oplock_change_type = 0;
- } else
+ }
+ } else {
oplock_change_type = 0;
+ }
switch (oplock_change_type) {
case OPLOCK_WRITE_TO_READ:
static int check_lease_state(struct lease *lease, __le32 req_state)
{
if ((lease->new_state ==
- (SMB2_LEASE_READ_CACHING_LE | SMB2_LEASE_HANDLE_CACHING_LE))
- && !(req_state & SMB2_LEASE_WRITE_CACHING_LE)) {
+ (SMB2_LEASE_READ_CACHING_LE | SMB2_LEASE_HANDLE_CACHING_LE)) &&
+ !(req_state & SMB2_LEASE_WRITE_CACHING_LE)) {
lease->new_state = req_state;
return 0;
}
/* check for bad lease state */
if (req->LeaseState & (~(SMB2_LEASE_READ_CACHING_LE |
- SMB2_LEASE_HANDLE_CACHING_LE))) {
+ SMB2_LEASE_HANDLE_CACHING_LE))) {
err = STATUS_INVALID_OPLOCK_PROTOCOL;
if (lease->state & SMB2_LEASE_WRITE_CACHING_LE)
lease_change_type = OPLOCK_WRITE_TO_NONE;
ksmbd_debug(OPLOCK, "handle bad lease state 0x%x -> 0x%x\n",
le32_to_cpu(lease->state),
le32_to_cpu(req->LeaseState));
- } else if ((lease->state == SMB2_LEASE_READ_CACHING_LE) &&
- (req->LeaseState != SMB2_LEASE_NONE_LE)) {
+ } else if (lease->state == SMB2_LEASE_READ_CACHING_LE &&
+ req->LeaseState != SMB2_LEASE_NONE_LE) {
err = STATUS_INVALID_OPLOCK_PROTOCOL;
lease_change_type = OPLOCK_READ_TO_NONE;
ksmbd_debug(OPLOCK, "handle bad lease state 0x%x -> 0x%x\n",
lease_change_type = OPLOCK_WRITE_TO_READ;
else
lease_change_type = OPLOCK_READ_HANDLE_TO_READ;
- } else
+ } else {
lease_change_type = 0;
+ }
}
switch (lease_change_type) {
struct smb2_hdr *rcv_hdr2 = work->request_buf;
if ((rcv_hdr2->Flags & SMB2_FLAGS_SIGNED) &&
- command != SMB2_NEGOTIATE_HE &&
- command != SMB2_SESSION_SETUP_HE &&
- command != SMB2_OPLOCK_BREAK_HE)
+ command != SMB2_NEGOTIATE_HE &&
+ command != SMB2_SESSION_SETUP_HE &&
+ command != SMB2_OPLOCK_BREAK_HE)
return true;
return 0;
iov[0].iov_len = len;
if (ksmbd_sign_smb2_pdu(work->conn, work->sess->sess_key, iov, 1,
- signature))
+ signature))
return 0;
if (memcmp(signature, signature_req, SMB2_SIGNATURE_SIZE)) {
}
if (!ksmbd_sign_smb2_pdu(work->conn, work->sess->sess_key, iov, n_vec,
- signature))
+ signature))
memcpy(hdr->Signature, signature, SMB2_SIGNATURE_SIZE);
}
conn->preauth_info->Preauth_HashValue);
if (le16_to_cpu(rsp->Command) == SMB2_SESSION_SETUP_HE &&
- sess && sess->state == SMB2_SESSION_IN_PROGRESS) {
+ sess && sess->state == SMB2_SESSION_IN_PROGRESS) {
__u8 *hash_value;
hash_value = sess->Preauth_HashValue;
}
}
-static void fill_transform_hdr(struct smb2_transform_hdr *tr_hdr,
- char *old_buf,
- __le16 cipher_type)
+static void fill_transform_hdr(struct smb2_transform_hdr *tr_hdr, char *old_buf,
+ __le16 cipher_type)
{
struct smb2_hdr *hdr = (struct smb2_hdr *)old_buf;
unsigned int orig_len = get_rfc1002_len(old_buf);
sess = ksmbd_session_lookup(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));
+ le64_to_cpu(tr_hdr->SessionId));
return -ECONNABORTED;
}
rsp = RESPONSE_BUF_NEXT(work);
if (le16_to_cpu(rsp->Command) == SMB2_SESSION_SETUP_HE &&
- rsp->Status == STATUS_SUCCESS)
+ rsp->Status == STATUS_SUCCESS)
return true;
return false;
}
#define SMB2_SESSION_REQ_FLAG_ENCRYPT_DATA 0x04
#define SMB2_SESSION_EXPIRED (0)
-#define SMB2_SESSION_IN_PROGRESS (1 << 0)
-#define SMB2_SESSION_VALID (1 << 1)
+#define SMB2_SESSION_IN_PROGRESS BIT(0)
+#define SMB2_SESSION_VALID BIT(1)
/* Flags */
#define SMB2_SESSION_REQ_FLAG_BINDING 0x01
__le16 StructureSize; /* Must be 2 */
} __packed;
-
/* FILE Info response size */
#define FILE_DIRECTORY_INFORMATION_SIZE 1
#define FILE_FULL_DIRECTORY_INFORMATION_SIZE 2
#define FILE_NETWORK_OPEN_INFORMATION_SIZE 56
#define FILE_ATTRIBUTE_TAG_INFORMATION_SIZE 8
-
/* FS Info response size */
#define FS_DEVICE_INFORMATION_SIZE 8
#define FS_ATTRIBUTE_INFORMATION_SIZE 16
} __packed;
/* functions */
-
-extern int init_smb2_0_server(struct ksmbd_conn *conn);
-extern void init_smb2_1_server(struct ksmbd_conn *conn);
-extern void init_smb3_0_server(struct ksmbd_conn *conn);
-extern void init_smb3_02_server(struct ksmbd_conn *conn);
-extern int init_smb3_11_server(struct ksmbd_conn *conn);
-
-extern void init_smb2_max_read_size(unsigned int sz);
-extern void init_smb2_max_write_size(unsigned int sz);
-extern void init_smb2_max_trans_size(unsigned int sz);
-
-extern int is_smb2_neg_cmd(struct ksmbd_work *work);
-extern int is_smb2_rsp(struct ksmbd_work *work);
-
-extern uint16_t get_smb2_cmd_val(struct ksmbd_work *work);
-extern void set_smb2_rsp_status(struct ksmbd_work *work, __le32 err);
-extern int init_smb2_rsp_hdr(struct ksmbd_work *work);
-extern int smb2_allocate_rsp_buf(struct ksmbd_work *work);
-extern bool is_chained_smb2_message(struct ksmbd_work *work);
-extern int init_smb2_neg_rsp(struct ksmbd_work *work);
-extern void smb2_set_err_rsp(struct ksmbd_work *work);
-extern int smb2_check_user_session(struct ksmbd_work *work);
-extern int smb2_get_ksmbd_tcon(struct ksmbd_work *work);
-extern bool smb2_is_sign_req(struct ksmbd_work *work, unsigned int command);
-extern int smb2_check_sign_req(struct ksmbd_work *work);
-extern void smb2_set_sign_rsp(struct ksmbd_work *work);
-extern int smb3_check_sign_req(struct ksmbd_work *work);
-extern void smb3_set_sign_rsp(struct ksmbd_work *work);
-extern int find_matching_smb2_dialect(int start_index, __le16 *cli_dialects,
- __le16 dialects_count);
-extern struct file_lock *smb_flock_init(struct file *f);
-extern int setup_async_work(struct ksmbd_work *work, void (*fn)(void **),
- void **arg);
-extern void smb2_send_interim_resp(struct ksmbd_work *work, __le32 status);
-extern struct channel *lookup_chann_list(struct ksmbd_session *sess);
-extern void smb3_preauth_hash_rsp(struct ksmbd_work *work);
-extern int smb3_is_transform_hdr(void *buf);
-extern int smb3_decrypt_req(struct ksmbd_work *work);
-extern int smb3_encrypt_resp(struct ksmbd_work *work);
-extern bool smb3_11_final_sess_setup_resp(struct ksmbd_work *work);
-extern int smb2_set_rsp_credits(struct ksmbd_work *work);
+int init_smb2_0_server(struct ksmbd_conn *conn);
+void init_smb2_1_server(struct ksmbd_conn *conn);
+void init_smb3_0_server(struct ksmbd_conn *conn);
+void init_smb3_02_server(struct ksmbd_conn *conn);
+int init_smb3_11_server(struct ksmbd_conn *conn);
+
+void init_smb2_max_read_size(unsigned int sz);
+void init_smb2_max_write_size(unsigned int sz);
+void init_smb2_max_trans_size(unsigned int sz);
+
+int is_smb2_neg_cmd(struct ksmbd_work *work);
+int is_smb2_rsp(struct ksmbd_work *work);
+
+u16 get_smb2_cmd_val(struct ksmbd_work *work);
+void set_smb2_rsp_status(struct ksmbd_work *work, __le32 err);
+int init_smb2_rsp_hdr(struct ksmbd_work *work);
+int smb2_allocate_rsp_buf(struct ksmbd_work *work);
+bool is_chained_smb2_message(struct ksmbd_work *work);
+int init_smb2_neg_rsp(struct ksmbd_work *work);
+void smb2_set_err_rsp(struct ksmbd_work *work);
+int smb2_check_user_session(struct ksmbd_work *work);
+int smb2_get_ksmbd_tcon(struct ksmbd_work *work);
+bool smb2_is_sign_req(struct ksmbd_work *work, unsigned int command);
+int smb2_check_sign_req(struct ksmbd_work *work);
+void smb2_set_sign_rsp(struct ksmbd_work *work);
+int smb3_check_sign_req(struct ksmbd_work *work);
+void smb3_set_sign_rsp(struct ksmbd_work *work);
+int find_matching_smb2_dialect(int start_index, __le16 *cli_dialects,
+ __le16 dialects_count);
+struct file_lock *smb_flock_init(struct file *f);
+int setup_async_work(struct ksmbd_work *work, void (*fn)(void **),
+ void **arg);
+void smb2_send_interim_resp(struct ksmbd_work *work, __le32 status);
+struct channel *lookup_chann_list(struct ksmbd_session *sess);
+void smb3_preauth_hash_rsp(struct ksmbd_work *work);
+int smb3_is_transform_hdr(void *buf);
+int smb3_decrypt_req(struct ksmbd_work *work);
+int smb3_encrypt_resp(struct ksmbd_work *work);
+bool smb3_11_final_sess_setup_resp(struct ksmbd_work *work);
+int smb2_set_rsp_credits(struct ksmbd_work *work);
/* smb2 misc functions */
-extern int ksmbd_smb2_check_message(struct ksmbd_work *work);
+int ksmbd_smb2_check_message(struct ksmbd_work *work);
/* smb2 command handlers */
-extern int smb2_handle_negotiate(struct ksmbd_work *work);
-extern int smb2_negotiate_request(struct ksmbd_work *work);
-extern int smb2_sess_setup(struct ksmbd_work *work);
-extern int smb2_tree_connect(struct ksmbd_work *work);
-extern int smb2_tree_disconnect(struct ksmbd_work *work);
-extern int smb2_session_logoff(struct ksmbd_work *work);
-extern int smb2_open(struct ksmbd_work *work);
-extern int smb2_query_info(struct ksmbd_work *work);
-extern int smb2_query_dir(struct ksmbd_work *work);
-extern int smb2_close(struct ksmbd_work *work);
-extern int smb2_echo(struct ksmbd_work *work);
-extern int smb2_set_info(struct ksmbd_work *work);
-extern int smb2_read(struct ksmbd_work *work);
-extern int smb2_write(struct ksmbd_work *work);
-extern int smb2_flush(struct ksmbd_work *work);
-extern int smb2_cancel(struct ksmbd_work *work);
-extern int smb2_lock(struct ksmbd_work *work);
-extern int smb2_ioctl(struct ksmbd_work *work);
-extern int smb2_oplock_break(struct ksmbd_work *work);
-extern int smb2_notify(struct ksmbd_work *ksmbd_work);
+int smb2_handle_negotiate(struct ksmbd_work *work);
+int smb2_negotiate_request(struct ksmbd_work *work);
+int smb2_sess_setup(struct ksmbd_work *work);
+int smb2_tree_connect(struct ksmbd_work *work);
+int smb2_tree_disconnect(struct ksmbd_work *work);
+int smb2_session_logoff(struct ksmbd_work *work);
+int smb2_open(struct ksmbd_work *work);
+int smb2_query_info(struct ksmbd_work *work);
+int smb2_query_dir(struct ksmbd_work *work);
+int smb2_close(struct ksmbd_work *work);
+int smb2_echo(struct ksmbd_work *work);
+int smb2_set_info(struct ksmbd_work *work);
+int smb2_read(struct ksmbd_work *work);
+int smb2_write(struct ksmbd_work *work);
+int smb2_flush(struct ksmbd_work *work);
+int smb2_cancel(struct ksmbd_work *work);
+int smb2_lock(struct ksmbd_work *work);
+int smb2_ioctl(struct ksmbd_work *work);
+int smb2_oplock_break(struct ksmbd_work *work);
+int smb2_notify(struct ksmbd_work *ksmbd_work);
#endif /* _SMB2PDU_H */
/*for shortname implementation */
static const char basechars[43] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-!@#$%";
-#define MANGLE_BASE (sizeof(basechars)/sizeof(char)-1)
+#define MANGLE_BASE (sizeof(basechars) / sizeof(char) - 1)
#define MAGIC_CHAR '~'
#define PERIOD '.'
#define mangle(V) ((char)(basechars[(V) % MANGLE_BASE]))
return (pdu >= KSMBD_MIN_SUPPORTED_HEADER_SIZE - 4);
}
-int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work,
- int info_level,
- struct ksmbd_file *dir,
- struct ksmbd_dir_info *d_info,
- char *search_pattern,
- int (*fn)(struct ksmbd_conn *,
- int,
- struct ksmbd_dir_info *,
- struct ksmbd_kstat *))
+int ksmbd_populate_dot_dotdot_entries(struct ksmbd_work *work, int info_level,
+ struct ksmbd_file *dir, struct ksmbd_dir_info *d_info,
+ char *search_pattern, int (*fn)(struct ksmbd_conn *, int,
+ struct ksmbd_dir_info *, struct ksmbd_kstat *))
{
int i, rc = 0;
struct ksmbd_conn *conn = work->conn;
}
if (!match_pattern(d_info->name, d_info->name_len,
- search_pattern)) {
+ search_pattern)) {
dir->dot_dotdot[i] = 1;
continue;
}
* TODO: Though this function comforms the restriction of 8.3 Filename spec,
* but the result is different with Windows 7's one. need to check.
*/
-int ksmbd_extract_shortname(struct ksmbd_conn *conn,
- const char *longname,
- char *shortname)
+int ksmbd_extract_shortname(struct ksmbd_conn *conn, const char *longname,
+ char *shortname)
{
const char *p;
char base[9], extension[4];
if (p == longname) { /*name starts with a dot*/
strscpy(extension, "___", strlen("___"));
} else {
- if (p != NULL) {
+ if (p) {
p++;
while (*p && extlen < 3) {
if (*p != '.')
p++;
}
extension[extlen] = '\0';
- } else
+ } else {
dot_present = false;
+ }
}
p = longname;
}
base[baselen] = MAGIC_CHAR;
- memcpy(out, base, baselen+1);
+ memcpy(out, base, baselen + 1);
ptr = longname;
len = strlen(longname);
csum += *ptr;
csum = csum % (MANGLE_BASE * MANGLE_BASE);
- out[baselen+1] = mangle(csum/MANGLE_BASE);
- out[baselen+2] = mangle(csum);
- out[baselen+3] = PERIOD;
+ out[baselen + 1] = mangle(csum / MANGLE_BASE);
+ out[baselen + 2] = mangle(csum);
+ out[baselen + 3] = PERIOD;
if (dot_present)
- memcpy(&out[baselen+4], extension, 4);
+ memcpy(&out[baselen + 4], extension, 4);
else
- out[baselen+4] = '\0';
+ out[baselen + 4] = '\0';
smbConvertToUTF16((__le16 *)shortname, out, PATH_MAX,
conn->local_nls, 0);
len = strlen(out) * 2;
"Desired access mode does not permit FILE_DELETE",
};
-static void smb_shared_mode_error(int error,
- struct ksmbd_file *prev_fp,
- struct ksmbd_file *curr_fp)
+static void smb_shared_mode_error(int error, struct ksmbd_file *prev_fp,
+ struct ksmbd_file *curr_fp)
{
ksmbd_debug(SMB, "%s\n", shared_mode_errors[error]);
ksmbd_debug(SMB, "Current mode: 0x%x Desired mode: 0x%x\n",
continue;
if (!(prev_fp->saccess & FILE_SHARE_DELETE_LE) &&
- curr_fp->daccess & FILE_DELETE_LE) {
+ curr_fp->daccess & FILE_DELETE_LE) {
smb_shared_mode_error(SHARE_DELETE_ERROR,
prev_fp,
curr_fp);
continue;
if (!(prev_fp->saccess & FILE_SHARE_READ_LE) &&
- curr_fp->daccess & (FILE_EXECUTE_LE |
- FILE_READ_DATA_LE)) {
+ curr_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE)) {
smb_shared_mode_error(SHARE_READ_ERROR,
prev_fp,
curr_fp);
}
if (!(prev_fp->saccess & FILE_SHARE_WRITE_LE) &&
- curr_fp->daccess & (FILE_WRITE_DATA_LE |
- FILE_APPEND_DATA_LE)) {
+ curr_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) {
smb_shared_mode_error(SHARE_WRITE_ERROR,
prev_fp,
curr_fp);
break;
}
- if (prev_fp->daccess & (FILE_EXECUTE_LE |
- FILE_READ_DATA_LE) &&
- !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
+ if (prev_fp->daccess & (FILE_EXECUTE_LE | FILE_READ_DATA_LE) &&
+ !(curr_fp->saccess & FILE_SHARE_READ_LE)) {
smb_shared_mode_error(FILE_READ_ERROR,
prev_fp,
curr_fp);
break;
}
- if (prev_fp->daccess & (FILE_WRITE_DATA_LE |
- FILE_APPEND_DATA_LE) &&
- !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
+ if (prev_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE) &&
+ !(curr_fp->saccess & FILE_SHARE_WRITE_LE)) {
smb_shared_mode_error(FILE_WRITE_ERROR,
prev_fp,
curr_fp);
}
if (prev_fp->daccess & FILE_DELETE_LE &&
- !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
+ !(curr_fp->saccess & FILE_SHARE_DELETE_LE)) {
smb_shared_mode_error(FILE_DELETE_ERROR,
prev_fp,
curr_fp);
if (!uid_eq(cred->fsuid, GLOBAL_ROOT_UID))
cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
- WARN_ON(work->saved_cred != NULL);
+ WARN_ON(work->saved_cred);
work->saved_cred = override_creds(cred);
if (!work->saved_cred) {
abort_creds(cred);
{
const struct cred *cred;
- WARN_ON(work->saved_cred == NULL);
+ WARN_ON(!work->saved_cred);
cred = current_cred();
revert_creds(work->saved_cred);
#define SMB311_PROT_ID 0x0311
#define BAD_PROT_ID 0xFFFF
-#define SMB_ECHO_INTERVAL (60*HZ)
+#define SMB_ECHO_INTERVAL (60 * HZ)
#define CIFS_DEFAULT_IOSIZE (64 * 1024)
#define MAX_CIFS_SMALL_BUFFER_SIZE 448 /* big enough for most */
int (*proc)(struct ksmbd_work *swork);
};
-
-
int ksmbd_min_protocol(void);
int ksmbd_max_protocol(void);
* if the two SIDs (roughly equivalent to a UUID for a user or group) are
* the same returns zero, if they do not match returns non-zero.
*/
-int
-compare_sids(const struct smb_sid *ctsid, const struct smb_sid *cwsid)
+int compare_sids(const struct smb_sid *ctsid, const struct smb_sid *cwsid)
{
int i;
int num_subauth, num_sat, num_saw;
- if ((!ctsid) || (!cwsid))
+ if (!ctsid || !cwsid)
return 1;
/* compare the revision */
for (i = 0; i < num_subauth; ++i) {
if (ctsid->sub_auth[i] != cwsid->sub_auth[i]) {
if (le32_to_cpu(ctsid->sub_auth[i]) >
- le32_to_cpu(cwsid->sub_auth[i]))
+ le32_to_cpu(cwsid->sub_auth[i]))
return 1;
else
return -1;
return 0; /* sids compare/match */
}
-static void
-smb_copy_sid(struct smb_sid *dst, const struct smb_sid *src)
+static void smb_copy_sid(struct smb_sid *dst, const struct smb_sid *src)
{
int i;
return mode;
}
- if ((flags & GENERIC_READ) ||
- (flags & FILE_READ_RIGHTS))
+ if ((flags & GENERIC_READ) || (flags & FILE_READ_RIGHTS))
mode = 0444;
- if ((flags & GENERIC_WRITE) ||
- (flags & FILE_WRITE_RIGHTS)) {
+ if ((flags & GENERIC_WRITE) || (flags & FILE_WRITE_RIGHTS)) {
mode |= 0222;
if (S_ISDIR(fattr->cf_mode))
mode |= 0111;
}
- if ((flags & GENERIC_EXECUTE) ||
- (flags & FILE_EXEC_RIGHTS))
+ if ((flags & GENERIC_EXECUTE) || (flags & FILE_EXEC_RIGHTS))
mode |= 0111;
- if (type == ACCESS_DENIED_ACE_TYPE ||
- type == ACCESS_DENIED_OBJECT_ACE_TYPE)
+ if (type == ACCESS_DENIED_ACE_TYPE || type == ACCESS_DENIED_OBJECT_ACE_TYPE)
mode = ~mode;
ksmbd_debug(SMB, "access flags 0x%x mode now %04o\n", flags, mode);
id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]);
if (id > 0) {
uid = make_kuid(&init_user_ns, id);
- if (uid_valid(uid) &&
- kuid_has_mapping(&init_user_ns, uid)) {
+ if (uid_valid(uid) && kuid_has_mapping(&init_user_ns, uid)) {
fattr->cf_uid = uid;
rc = 0;
}
id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]);
if (id > 0) {
gid = make_kgid(&init_user_ns, id);
- if (gid_valid(gid) &&
- kgid_has_mapping(&init_user_ns, gid)) {
+ if (gid_valid(gid) && kgid_has_mapping(&init_user_ns, gid)) {
fattr->cf_gid = gid;
rc = 0;
}
* enough space for either:
*/
alloc = sizeof(struct posix_ace_state_array)
- + cnt*sizeof(struct posix_user_ace_state);
+ + cnt * sizeof(struct posix_user_ace_state);
state->users = kzalloc(alloc, GFP_KERNEL);
if (!state->users)
return -ENOMEM;
* user/group/other have no permissions
*/
for (i = 0; i < num_aces; ++i) {
- ppace[i] = (struct smb_ace *) (acl_base + acl_size);
+ ppace[i] = (struct smb_ace *)(acl_base + acl_size);
acl_base = (char *)ppace[i];
acl_size = le16_to_cpu(ppace[i]->size);
ppace[i]->access_req =
smb_map_generic_desired_access(ppace[i]->access_req);
- if (!(compare_sids(&(ppace[i]->sid), &sid_unix_NFS_mode))) {
+ if (!(compare_sids(&ppace[i]->sid, &sid_unix_NFS_mode))) {
fattr->cf_mode =
le32_to_cpu(ppace[i]->sid.sub_auth[2]);
break;
- } else if (!compare_sids(&(ppace[i]->sid), pownersid)) {
+ } else if (!compare_sids(&ppace[i]->sid, pownersid)) {
acl_mode = access_flags_to_mode(fattr,
ppace[i]->access_req, ppace[i]->type);
acl_mode &= 0700;
mode |= acl_mode;
}
owner_found = true;
- } else if (!compare_sids(&(ppace[i]->sid), pgrpsid) ||
- ppace[i]->sid.sub_auth[ppace[i]->sid.num_subauth - 1] ==
- DOMAIN_USER_RID_LE) {
+ } else if (!compare_sids(&ppace[i]->sid, pgrpsid) ||
+ ppace[i]->sid.sub_auth[ppace[i]->sid.num_subauth - 1] ==
+ DOMAIN_USER_RID_LE) {
acl_mode = access_flags_to_mode(fattr,
ppace[i]->access_req, ppace[i]->type);
acl_mode &= 0070;
mode |= acl_mode;
}
group_found = true;
- } else if (!compare_sids(&(ppace[i]->sid), &sid_everyone)) {
+ } else if (!compare_sids(&ppace[i]->sid, &sid_everyone)) {
acl_mode = access_flags_to_mode(fattr,
ppace[i]->access_req, ppace[i]->type);
acl_mode &= 0007;
mode |= acl_mode;
}
others_found = true;
- } else if (!compare_sids(&(ppace[i]->sid), &creator_owner))
+ } else if (!compare_sids(&ppace[i]->sid, &creator_owner)) {
continue;
- else if (!compare_sids(&(ppace[i]->sid), &creator_group))
+ } else if (!compare_sids(&ppace[i]->sid, &creator_group)) {
continue;
- else if (!compare_sids(&(ppace[i]->sid), &sid_authusers))
+ } else if (!compare_sids(&ppace[i]->sid, &sid_authusers)) {
continue;
- else {
+ } else {
struct smb_fattr temp_fattr;
acl_mode = access_flags_to_mode(fattr, ppace[i]->access_req,
if (S_ISDIR(fattr->cf_mode) && pace->e_tag == ACL_OTHER)
flags = 0x03;
- ntace = (struct smb_ace *) ((char *)pndace + *size);
+ ntace = (struct smb_ace *)((char *)pndace + *size);
*size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, flags,
pace->e_perm, 0777);
(*num_aces)++;
FILE_DELETE_LE | FILE_DELETE_CHILD_LE;
if (S_ISDIR(fattr->cf_mode) &&
- (pace->e_tag == ACL_USER || pace->e_tag == ACL_GROUP)) {
- ntace = (struct smb_ace *) ((char *)pndace + *size);
+ (pace->e_tag == ACL_USER || pace->e_tag == ACL_GROUP)) {
+ ntace = (struct smb_ace *)((char *)pndace + *size);
*size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED,
0x03, pace->e_perm, 0777);
(*num_aces)++;
continue;
}
- ntace = (struct smb_ace *) ((char *)pndace + *size);
+ ntace = (struct smb_ace *)((char *)pndace + *size);
*size += fill_ace_for_sid(ntace, sid, ACCESS_ALLOWED, 0x0b,
pace->e_perm, 0777);
(*num_aces)++;
__u32 dacloffset;
int pntsd_type;
- if (pntsd == NULL)
+ if (!pntsd)
return -EIO;
owner_sid_ptr = (struct smb_sid *)((char *)pntsd +
dacl_ptr->size = cpu_to_le16(sizeof(struct smb_acl));
dacl_ptr->num_aces = 0;
- if (!ppntsd)
+ if (!ppntsd) {
set_mode_dacl(dacl_ptr, fattr);
- else if (!ppntsd->dacloffset)
+ } else if (!ppntsd->dacloffset) {
goto out;
- else {
+ } else {
struct smb_acl *ppdacl_ptr;
ppdacl_ptr = (struct smb_acl *)((char *)ppntsd +
flags |= INHERIT_ONLY_ACE;
if (flags & NO_PROPAGATE_INHERIT_ACE)
flags = 0;
- } else
+ } else {
flags = 0;
+ }
if (!compare_sids(&creator_owner, &parent_aces->sid)) {
creator = &creator_owner;
aces = (struct smb_ace *)((char *)aces + le16_to_cpu(aces->size));
flags |= INHERIT_ONLY_ACE;
psid = creator;
- } else if (is_dir && !(parent_aces->flags & NO_PROPAGATE_INHERIT_ACE))
+ } else if (is_dir && !(parent_aces->flags & NO_PROPAGATE_INHERIT_ACE)) {
psid = &parent_aces->sid;
+ }
smb_set_ace(aces, psid, parent_aces->type, flags | inherited_flags,
parent_aces->access_req);
ace = (struct smb_ace *)((char *)pdacl + sizeof(struct smb_acl));
for (i = 0; i < le32_to_cpu(pdacl->num_aces); i++) {
granted |= le32_to_cpu(ace->access_req);
- ace = (struct smb_ace *) ((char *)ace + le16_to_cpu(ace->size));
+ ace = (struct smb_ace *)((char *)ace + le16_to_cpu(ace->size));
if (end_of_acl < (char *)ace)
goto err_out;
}
if (!compare_sids(&sid_everyone, &ace->sid))
others_ace = ace;
- ace = (struct smb_ace *) ((char *)ace + le16_to_cpu(ace->size));
+ ace = (struct smb_ace *)((char *)ace + le16_to_cpu(ace->size));
if (end_of_acl < (char *)ace)
goto err_out;
}
posix_acl_release(posix_acls);
if (!found) {
- if (others_ace)
+ if (others_ace) {
ace = others_ace;
- else {
+ } else {
ksmbd_debug(SMB, "Can't find corresponding sid\n");
rc = -EACCES;
goto err_out;
if (type_check && !(le16_to_cpu(pntsd->type) & DACL_PRESENT))
goto out;
- if (test_share_config_flag(tcon->share_conf,
- KSMBD_SHARE_FLAG_ACL_XATTR)) {
+ if (test_share_config_flag(tcon->share_conf, KSMBD_SHARE_FLAG_ACL_XATTR)) {
/* Update WinACL in xattr */
ksmbd_vfs_remove_sd_xattrs(dentry);
ksmbd_vfs_set_sd_xattr(conn, dentry, pntsd, ntsd_len);
* between different kernel versions.
*/
-#define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
+#define NTFS_TIME_OFFSET ((u64)(369 * 365 + 89) * 24 * 3600 * 10000000)
/* Convert the Unix UTC into NT UTC. */
static inline u64 ksmbd_UnixTimeToNT(struct timespec64 t)
{
/* Convert to 100ns intervals and then add the NTFS time offset. */
- return (u64) t.tv_sec * 10000000 + t.tv_nsec / 100 + NTFS_TIME_OFFSET;
+ return (u64)t.tv_sec * 10000000 + t.tv_nsec / 100 + NTFS_TIME_OFFSET;
}
struct timespec64 ksmbd_NTtimeToUnix(__le64 ntutc);
static struct delayed_work ipc_timer_work;
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);
+static int handle_unsupported_event(struct sk_buff *skb, struct genl_info *info);
static int handle_generic_event(struct sk_buff *skb, struct genl_info *info);
static int ksmbd_ipc_heartbeat_request(void);
return ret;
}
-static int handle_unsupported_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);
return -EINVAL;
return ret;
}
-static void *ipc_msg_send_request(struct ksmbd_ipc_msg *msg,
- unsigned int handle)
+static void *ipc_msg_send_request(struct ksmbd_ipc_msg *msg, unsigned int handle)
{
struct ipc_msg_table_entry entry;
int ret;
struct ksmbd_tree_connect_response *
ksmbd_ipc_tree_connect_request(struct ksmbd_session *sess,
- struct ksmbd_share_config *share,
- struct ksmbd_tree_connect *tree_conn,
- struct sockaddr *peer_addr)
+ struct ksmbd_share_config *share,
+ struct ksmbd_tree_connect *tree_conn,
+ struct sockaddr *peer_addr)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_tree_connect_request *req;
}
int ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,
- unsigned long long connect_id)
+ unsigned long long connect_id)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_tree_disconnect_request *req;
return resp;
}
-struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess,
- int handle)
+struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess, int handle)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_rpc_command *req;
return resp;
}
-struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess,
- int handle)
+struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess, int handle)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_rpc_command *req;
return resp;
}
-struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess,
- int handle,
- void *payload,
- size_t payload_sz)
+struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess, int handle,
+ void *payload, size_t payload_sz)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_rpc_command *req;
return resp;
}
-struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess,
- int handle)
+struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess, int handle)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_rpc_command *req;
return resp;
}
-struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess,
- int handle,
- void *payload,
- size_t payload_sz)
+struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess, int handle,
+ void *payload, size_t payload_sz)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_rpc_command *req;
return resp;
}
-struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess,
- void *payload,
- size_t payload_sz)
+struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess, void *payload,
+ size_t payload_sz)
{
struct ksmbd_ipc_msg *msg;
struct ksmbd_rpc_command *req;
ret = genl_register_family(&ksmbd_genl_family);
if (ret) {
- ksmbd_err("Failed to register KSMBD netlink interface %d\n",
- ret);
+ ksmbd_err("Failed to register KSMBD netlink interface %d\n", ret);
goto cancel_work;
}
struct ksmbd_tree_connect_response *
ksmbd_ipc_tree_connect_request(struct ksmbd_session *sess,
- struct ksmbd_share_config *share,
- struct ksmbd_tree_connect *tree_conn,
- struct sockaddr *peer_addr);
+ struct ksmbd_share_config *share,
+ struct ksmbd_tree_connect *tree_conn,
+ struct sockaddr *peer_addr);
int ksmbd_ipc_tree_disconnect_request(unsigned long long session_id,
unsigned long long connect_id);
int ksmbd_ipc_id_alloc(void);
void ksmbd_rpc_id_free(int handle);
-struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess,
- int handle);
-struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess,
- int handle);
-
-struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess,
- int handle,
- void *payload,
- size_t payload_sz);
-struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess,
- int handle);
-struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess,
- int handle,
- void *payload,
- size_t payload_sz);
-struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess,
- void *payload,
- size_t payload_sz);
+struct ksmbd_rpc_command *ksmbd_rpc_open(struct ksmbd_session *sess, int handle);
+struct ksmbd_rpc_command *ksmbd_rpc_close(struct ksmbd_session *sess, int handle);
+
+struct ksmbd_rpc_command *ksmbd_rpc_write(struct ksmbd_session *sess, int handle,
+ void *payload, size_t payload_sz);
+struct ksmbd_rpc_command *ksmbd_rpc_read(struct ksmbd_session *sess, int handle);
+struct ksmbd_rpc_command *ksmbd_rpc_ioctl(struct ksmbd_session *sess, int handle,
+ void *payload, size_t payload_sz);
+struct ksmbd_rpc_command *ksmbd_rpc_rap(struct ksmbd_session *sess, void *payload,
+ size_t payload_sz);
void ksmbd_ipc_release(void);
void ksmbd_ipc_soft_reset(void);
struct rdma_cm_id *cm_id;
} smb_direct_listener;
-
static struct workqueue_struct *smb_direct_wq;
enum smb_direct_status {
static void smb_direct_destroy_pools(struct smb_direct_transport *transport);
static void smb_direct_post_recv_credits(struct work_struct *work);
static int smb_direct_post_send_data(struct smb_direct_transport *t,
- struct smb_direct_send_ctx *send_ctx,
- struct kvec *iov, int niov, int remaining_data_length);
+ struct smb_direct_send_ctx *send_ctx,
+ struct kvec *iov, int niov, int remaining_data_length);
static inline void
*smb_direct_recvmsg_payload(struct smb_direct_recvmsg *recvmsg)
}
static inline bool is_receive_credit_post_required(int receive_credits,
- int avail_recvmsg_count)
+ int avail_recvmsg_count)
{
return receive_credits <= (smb_direct_receive_credit_max >> 3) &&
avail_recvmsg_count >= (receive_credits >> 2);
}
static void put_recvmsg(struct smb_direct_transport *t,
- struct smb_direct_recvmsg *recvmsg)
+ struct smb_direct_recvmsg *recvmsg)
{
ib_dma_unmap_single(t->cm_id->device, recvmsg->sge.addr,
recvmsg->sge.length, DMA_FROM_DEVICE);
spin_lock(&t->recvmsg_queue_lock);
list_add(&recvmsg->list, &t->recvmsg_queue);
spin_unlock(&t->recvmsg_queue_lock);
-
}
static struct
spin_lock(&t->empty_recvmsg_queue_lock);
if (!list_empty(&t->empty_recvmsg_queue)) {
- recvmsg = list_first_entry(
- &t->empty_recvmsg_queue,
+ recvmsg = list_first_entry(&t->empty_recvmsg_queue,
struct smb_direct_recvmsg, list);
list_del(&recvmsg->list);
}
}
static void put_empty_recvmsg(struct smb_direct_transport *t,
- struct smb_direct_recvmsg *recvmsg)
+ struct smb_direct_recvmsg *recvmsg)
{
ib_dma_unmap_single(t->cm_id->device, recvmsg->sge.addr,
recvmsg->sge.length, DMA_FROM_DEVICE);
}
static void enqueue_reassembly(struct smb_direct_transport *t,
- struct smb_direct_recvmsg *recvmsg,
- int data_length)
+ struct smb_direct_recvmsg *recvmsg, int data_length)
{
spin_lock(&t->reassembly_queue_lock);
list_add_tail(&recvmsg->list, &t->reassembly_queue);
virt_wmb();
t->reassembly_data_length += data_length;
spin_unlock(&t->reassembly_queue_lock);
-
}
-static struct smb_direct_recvmsg *get_first_reassembly(
- struct smb_direct_transport *t)
+static struct smb_direct_recvmsg *get_first_reassembly(struct smb_direct_transport *t)
{
if (!list_empty(&t->reassembly_queue))
return list_first_entry(&t->reassembly_queue,
recvmsg = get_first_reassembly(t);
if (recvmsg) {
list_del(&recvmsg->list);
- spin_unlock(
- &t->reassembly_queue_lock);
+ spin_unlock(&t->reassembly_queue_lock);
put_recvmsg(t, recvmsg);
- } else
+ } else {
spin_unlock(&t->reassembly_queue_lock);
+ }
} while (recvmsg);
t->reassembly_data_length = 0;
}
static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
- struct smb_direct_sendmsg *msg)
+ struct smb_direct_sendmsg *msg)
{
int i;
switch (recvmsg->type) {
case SMB_DIRECT_MSG_DATA_TRANSFER: {
struct smb_direct_data_transfer *req =
- (struct smb_direct_data_transfer *) recvmsg->packet;
- struct smb2_hdr *hdr = (struct smb2_hdr *) (recvmsg->packet
+ (struct smb_direct_data_transfer *)recvmsg->packet;
+ struct smb2_hdr *hdr = (struct smb2_hdr *)(recvmsg->packet
+ le32_to_cpu(req->data_offset) - 4);
ksmbd_debug(RDMA,
"CreditGranted: %u, CreditRequested: %u, DataLength: %u, RemainingDataLength: %u, SMB: %x, Command: %u\n",
le32_to_cpu(req->max_receive_size),
le32_to_cpu(req->max_fragmented_size));
if (le16_to_cpu(req->min_version) > 0x0100 ||
- le16_to_cpu(req->max_version) < 0x0100)
+ le16_to_cpu(req->max_version) < 0x0100)
return -EOPNOTSUPP;
if (le16_to_cpu(req->credits_requested) <= 0 ||
- le32_to_cpu(req->max_receive_size) <= 128 ||
- le32_to_cpu(req->max_fragmented_size) <=
- 128*1024)
+ le32_to_cpu(req->max_receive_size) <= 128 ||
+ le32_to_cpu(req->max_fragmented_size) <=
+ 128 * 1024)
return -ECONNABORTED;
break;
if (atomic_read(&t->send_credits) > 0)
wake_up_interruptible(&t->wait_send_credits);
- if (is_receive_credit_post_required(receive_credits,
- avail_recvmsg_count))
+ if (is_receive_credit_post_required(receive_credits, avail_recvmsg_count))
mod_delayed_work(smb_direct_wq,
&t->post_recv_credits_work, 0);
break;
}
static int smb_direct_post_recv(struct smb_direct_transport *t,
- struct smb_direct_recvmsg *recvmsg)
+ struct smb_direct_recvmsg *recvmsg)
{
struct ib_recv_wr wr;
int ret;
data_transfer = smb_direct_recvmsg_payload(recvmsg);
data_length = le32_to_cpu(data_transfer->data_length);
remaining_data_length =
- le32_to_cpu(
- data_transfer->remaining_data_length);
+ le32_to_cpu(data_transfer->remaining_data_length);
data_offset = le32_to_cpu(data_transfer->data_offset);
/*
}
to_copy = min_t(int, data_length - offset, to_read);
- memcpy(
- buf + data_read,
- (char *)data_transfer + data_offset + offset,
+ memcpy(buf + data_read, (char *)data_transfer + data_offset + offset,
to_copy);
/* move on to the next buffer? */
* No need to lock if we are not at the
* end of the queue
*/
- if (queue_length)
+ if (queue_length) {
list_del(&recvmsg->list);
- else {
- spin_lock_irq(
- &st->reassembly_queue_lock);
+ } else {
+ spin_lock_irq(&st->reassembly_queue_lock);
list_del(&recvmsg->list);
- spin_unlock_irq(
- &st->reassembly_queue_lock);
+ spin_unlock_irq(&st->reassembly_queue_lock);
}
queue_removed++;
put_recvmsg(st, recvmsg);
offset = 0;
- } else
+ } else {
offset += to_copy;
+ }
to_read -= to_copy;
data_read += to_copy;
spin_lock(&st->receive_credit_lock);
st->count_avail_recvmsg += queue_removed;
- if (is_receive_credit_post_required(st->recv_credits,
- st->count_avail_recvmsg)) {
+ if (is_receive_credit_post_required(st->recv_credits, st->count_avail_recvmsg)) {
spin_unlock(&st->receive_credit_lock);
mod_delayed_work(smb_direct_wq,
&st->post_recv_credits_work, 0);
- } else
+ } else {
spin_unlock(&st->receive_credit_lock);
+ }
st->first_entry_offset = offset;
ksmbd_debug(RDMA,
}
ksmbd_debug(RDMA, "wait_event on more data\n");
- rc = wait_event_interruptible(
- st->wait_reassembly_queue,
- st->reassembly_data_length >= size ||
- st->status != SMB_DIRECT_CS_CONNECTED);
+ rc = wait_event_interruptible(st->wait_reassembly_queue,
+ st->reassembly_data_length >= size || st->status != SMB_DIRECT_CS_CONNECTED);
if (rc)
return -EINTR;
if (use_free) {
use_free = 0;
continue;
- } else
+ } else {
break;
+ }
}
recvmsg->type = SMB_DIRECT_MSG_DATA_TRANSFER;
}
static void smb_direct_send_ctx_init(struct smb_direct_transport *t,
- struct smb_direct_send_ctx *send_ctx,
- bool need_invalidate_rkey, unsigned int remote_key)
+ struct smb_direct_send_ctx *send_ctx,
+ bool need_invalidate_rkey, unsigned int remote_key)
{
INIT_LIST_HEAD(&send_ctx->msg_list);
send_ctx->wr_cnt = 0;
}
static int smb_direct_flush_send_list(struct smb_direct_transport *t,
- struct smb_direct_send_ctx *send_ctx, bool is_last)
+ struct smb_direct_send_ctx *send_ctx, bool is_last)
{
struct smb_direct_sendmsg *first, *last;
int ret;
}
static int wait_for_send_credits(struct smb_direct_transport *t,
- struct smb_direct_send_ctx *send_ctx)
+ struct smb_direct_send_ctx *send_ctx)
{
int ret;
if (send_ctx && (send_ctx->wr_cnt >= 16 ||
- atomic_read(&t->send_credits) <= 1)) {
+ atomic_read(&t->send_credits) <= 1)) {
ret = smb_direct_flush_send_list(t, send_ctx, false);
if (ret)
return ret;
return 0;
}
-static int get_sg_list(void *buf, int size,
- struct scatterlist *sg_list, int nentries)
+static int get_sg_list(void *buf, int size, struct scatterlist *sg_list, int nentries)
{
bool high = is_vmalloc_addr(buf);
struct page *page;
}
static int get_mapped_sg_list(struct ib_device *device, void *buf, int size,
- struct scatterlist *sg_list, int nentries,
- enum dma_data_direction dir)
+ struct scatterlist *sg_list, int nentries,
+ enum dma_data_direction dir)
{
int npages;
}
static int post_sendmsg(struct smb_direct_transport *t,
- struct smb_direct_send_ctx *send_ctx,
- struct smb_direct_sendmsg *msg)
+ struct smb_direct_send_ctx *send_ctx,
+ struct smb_direct_sendmsg *msg)
{
int i;
}
static int smb_direct_post_send_data(struct smb_direct_transport *t,
- struct smb_direct_send_ctx *send_ctx,
- struct kvec *iov, int niov, int remaining_data_length)
+ struct smb_direct_send_ctx *send_ctx,
+ struct kvec *iov, int niov, int remaining_data_length)
{
int i, j, ret;
struct smb_direct_sendmsg *msg;
int data_length;
- struct scatterlist sg[SMB_DIRECT_MAX_SEND_SGES-1];
+ struct scatterlist sg[SMB_DIRECT_MAX_SEND_SGES - 1];
ret = wait_for_send_credits(t, send_ctx);
if (ret)
struct ib_sge *sge;
int sg_cnt;
- sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES-1);
+ sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES - 1);
sg_cnt = get_mapped_sg_list(t->cm_id->device,
iov[i].iov_base, iov[i].iov_len,
- sg, SMB_DIRECT_MAX_SEND_SGES-1, DMA_TO_DEVICE);
+ sg, SMB_DIRECT_MAX_SEND_SGES - 1, DMA_TO_DEVICE);
if (sg_cnt <= 0) {
ksmbd_err("failed to map buffer\n");
ret = -ENOMEM;
goto err;
- } else if (sg_cnt + msg->num_sge > SMB_DIRECT_MAX_SEND_SGES-1) {
+ } else if (sg_cnt + msg->num_sge > SMB_DIRECT_MAX_SEND_SGES - 1) {
ksmbd_err("buffer not fitted into sges\n");
ret = -E2BIG;
ib_dma_unmap_sg(t->cm_id->device, sg, sg_cnt,
}
static int smb_direct_writev(struct ksmbd_transport *t,
- struct kvec *iov, int niovs, int buflen,
- bool need_invalidate, unsigned int remote_key)
+ struct kvec *iov, int niovs, int buflen,
+ bool need_invalidate, unsigned int remote_key)
{
struct smb_direct_transport *st = SMB_DIRECT_TRANS(t);
int remaining_data_length;
if (buflen > max_iov_size) {
if (i > start) {
remaining_data_length -=
- (buflen-iov[i].iov_len);
+ (buflen - iov[i].iov_len);
ret = smb_direct_post_send_data(st, &send_ctx,
- &iov[start], i-start,
+ &iov[start], i - start,
remaining_data_length);
if (ret)
goto done;
} else {
/* iov[start] is too big, break it */
- int nvec = (buflen+max_iov_size-1) /
+ int nvec = (buflen + max_iov_size - 1) /
max_iov_size;
for (j = 0; j < nvec; j++) {
vec.iov_base =
(char *)iov[start].iov_base +
- j*max_iov_size;
+ j * max_iov_size;
vec.iov_len =
min_t(int, max_iov_size,
- buflen - max_iov_size*j);
+ buflen - max_iov_size * j);
remaining_data_length -= vec.iov_len;
ret = smb_direct_post_send_data(st,
&send_ctx, &vec, 1,
/* send out all remaining vecs */
remaining_data_length -= buflen;
ret = smb_direct_post_send_data(st, &send_ctx,
- &iov[start], i-start,
+ &iov[start], i - start,
remaining_data_length);
if (ret)
goto done;
}
static void read_write_done(struct ib_cq *cq, struct ib_wc *wc,
- enum dma_data_direction dir)
+ enum dma_data_direction dir)
{
struct smb_direct_rdma_rw_msg *msg = container_of(wc->wr_cqe,
struct smb_direct_rdma_rw_msg, cqe);
}
static int smb_direct_rdma_xmit(struct smb_direct_transport *t, void *buf,
- int buf_len, u32 remote_key, u64 remote_offset, u32 remote_len,
- bool is_read)
+ int buf_len, u32 remote_key, u64 remote_offset, u32 remote_len,
+ bool is_read)
{
struct smb_direct_rdma_rw_msg *msg;
int ret;
sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE);
kfree(msg);
return ret;
-
}
-static int smb_direct_rdma_write(struct ksmbd_transport *t,
- void *buf, unsigned int buflen,
- u32 remote_key, u64 remote_offset,
- u32 remote_len)
+static int smb_direct_rdma_write(struct ksmbd_transport *t, void *buf,
+ unsigned int buflen, u32 remote_key, u64 remote_offset,
+ u32 remote_len)
{
return smb_direct_rdma_xmit(SMB_DIRECT_TRANS(t), buf, buflen,
remote_key, remote_offset,
remote_len, false);
}
-static int smb_direct_rdma_read(struct ksmbd_transport *t,
- void *buf, unsigned int buflen,
- u32 remote_key, u64 remote_offset,
- u32 remote_len)
+static int smb_direct_rdma_read(struct ksmbd_transport *t, void *buf,
+ unsigned int buflen, u32 remote_key, u64 remote_offset,
+ u32 remote_len)
{
return smb_direct_rdma_xmit(SMB_DIRECT_TRANS(t), buf, buflen,
remote_key, remote_offset,
}
static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
- struct rdma_cm_event *event)
+ struct rdma_cm_event *event)
{
struct smb_direct_transport *t = cm_id->context;
resp->reserved = 0;
resp->credits_requested =
cpu_to_le16(t->send_credit_target);
- resp->credits_granted = cpu_to_le16(
- manage_credits_prior_sending(t));
+ resp->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
resp->max_readwrite_size = cpu_to_le32(t->max_rdma_rw_size);
resp->preferred_send_size = cpu_to_le32(t->max_send_size);
resp->max_receive_size = cpu_to_le32(t->max_recv_size);
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) {
+ 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);
}
static int smb_direct_listen_handler(struct rdma_cm_id *cm_id,
- struct rdma_cm_event *event)
+ struct rdma_cm_event *event)
{
switch (event->event) {
case RDMA_CM_EVENT_CONNECT_REQUEST: {
* for lack of credits
*/
smb_direct_wq = alloc_workqueue("ksmbd-smb_direct-wq",
- WQ_HIGHPRI|WQ_MEM_RECLAIM, 0);
+ WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
if (!smb_direct_wq)
return -ENOMEM;
#include "connection.h"
#include "transport_tcp.h"
-#define IFACE_STATE_DOWN (1 << 0)
-#define IFACE_STATE_CONFIGURED (1 << 1)
+#define IFACE_STATE_DOWN BIT(0)
+#define IFACE_STATE_CONFIGURED BIT(1)
struct interface {
struct task_struct *ksmbd_kthread;
* Return: Number of IO segments
*/
static unsigned int kvec_array_init(struct kvec *new, struct kvec *iov,
- unsigned int nr_segs, size_t bytes)
+ unsigned int nr_segs, size_t bytes)
{
size_t base = 0;
*
* Return: return existing or newly allocate iovec
*/
-static struct kvec *get_conn_iovec(struct tcp_transport *t,
- unsigned int nr_segs)
+static struct kvec *get_conn_iovec(struct tcp_transport *t, unsigned int nr_segs)
{
struct kvec *new_iov;
* Return: on success return number of bytes read from socket,
* otherwise return error number
*/
-static int ksmbd_tcp_readv(struct tcp_transport *t,
- struct kvec *iov_orig,
- unsigned int nr_segs,
- unsigned int to_read)
+static int ksmbd_tcp_readv(struct tcp_transport *t, struct kvec *iov_orig,
+ unsigned int nr_segs, unsigned int to_read)
{
int length = 0;
int total_read;
* Return: on success return number of bytes read from socket,
* otherwise return error number
*/
-static int ksmbd_tcp_read(struct ksmbd_transport *t,
- char *buf,
- unsigned int to_read)
+static int ksmbd_tcp_read(struct ksmbd_transport *t, char *buf, unsigned int to_read)
{
struct kvec iov;
return ksmbd_tcp_readv(TCP_TRANS(t), &iov, 1, to_read);
}
-static int ksmbd_tcp_writev(struct ksmbd_transport *t,
- struct kvec *iov, int nvecs, int size,
- bool need_invalidate, unsigned int remote_key)
+static int ksmbd_tcp_writev(struct ksmbd_transport *t, struct kvec *iov,
+ int nvecs, int size, bool need_invalidate, unsigned int remote_key)
{
struct msghdr smb_msg = {.msg_flags = MSG_NOSIGNAL};
}
static int ksmbd_netdev_event(struct notifier_block *nb, unsigned long event,
- void *ptr)
+ void *ptr)
{
struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
struct interface *iface;
}
return NOTIFY_DONE;
-
}
static struct notifier_block ksmbd_netdev_notifier = {
*
* Return: string length after conversion
*/
-static int smb_utf16_bytes(const __le16 *from,
- int maxbytes,
- const struct nls_table *codepage)
+static int smb_utf16_bytes(const __le16 *from, int maxbytes,
+ const struct nls_table *codepage)
{
int i;
int charlen, outlen = 0;
*/
static int
cifs_mapchar(char *target, const __u16 src_char, const struct nls_table *cp,
- bool mapchar)
+ bool mapchar)
{
int len = 1;
{
/* check for control chars, wildcards etc. */
if (!(*ch & 0x80) &&
- (*ch <= 0x1f ||
- *ch == '?' || *ch == '"' || *ch == '<' ||
- *ch == '>' || *ch == '|'))
+ (*ch <= 0x1f ||
+ *ch == '?' || *ch == '"' || *ch == '<' ||
+ *ch == '>' || *ch == '|'))
return 0;
return 1;
*
* Return: string length after conversion
*/
-static int smb_from_utf16(char *to,
- const __le16 *from,
- int tolen,
- int fromlen,
- const struct nls_table *codepage,
- bool mapchar)
+static int smb_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
+ const struct nls_table *codepage, bool mapchar)
{
int i, charlen, safelen;
int outlen = 0;
*
* Return: string length after conversion
*/
-int
-smb_strtoUTF16(__le16 *to, const char *from, int len,
+int smb_strtoUTF16(__le16 *to, const char *from, int len,
const struct nls_table *codepage)
{
int charlen;
* in destination len is length in wchar_t units (16bits)
*/
i = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN,
- (wchar_t *) to, len);
+ (wchar_t *)to, len);
/* if success terminate and exit */
if (i >= 0)
*
* Return: destination string buffer or error ptr
*/
-char *
-smb_strndup_from_utf16(const char *src, const int maxlen,
- const bool is_unicode, const struct nls_table *codepage)
+char *smb_strndup_from_utf16(const char *src, const int maxlen,
+ const bool is_unicode, const struct nls_table *codepage)
{
int len, ret;
char *dst;
if (is_unicode) {
- len = smb_utf16_bytes((__le16 *) src, maxlen, codepage);
+ len = smb_utf16_bytes((__le16 *)src, maxlen, codepage);
len += nls_nullsize(codepage);
dst = kmalloc(len, GFP_KERNEL);
if (!dst)
return ERR_PTR(-ENOMEM);
- ret = smb_from_utf16(dst, (__le16 *) src, len, maxlen, codepage,
+ ret = smb_from_utf16(dst, (__le16 *)src, len, maxlen, codepage,
false);
if (ret < 0) {
kfree(dst);
*
* Return: char length after conversion
*/
-int
-smbConvertToUTF16(__le16 *target, const char *source, int srclen,
- const struct nls_table *cp, int mapchars)
+int smbConvertToUTF16(__le16 *target, const char *source, int srclen,
+ const struct nls_table *cp, int mapchars)
{
int i, j, charlen;
char src_char;
* reserved symbols (along with \ and /), otherwise illegal to store
* in filenames in NTFS
*/
-#define UNI_ASTERISK ((__u16) ('*' + 0xF000))
-#define UNI_QUESTION ((__u16) ('?' + 0xF000))
-#define UNI_COLON ((__u16) (':' + 0xF000))
-#define UNI_GRTRTHAN ((__u16) ('>' + 0xF000))
-#define UNI_LESSTHAN ((__u16) ('<' + 0xF000))
-#define UNI_PIPE ((__u16) ('|' + 0xF000))
-#define UNI_SLASH ((__u16) ('\\' + 0xF000))
+#define UNI_ASTERISK ((__u16)('*' + 0xF000))
+#define UNI_QUESTION ((__u16)('?' + 0xF000))
+#define UNI_COLON ((__u16)(':' + 0xF000))
+#define UNI_GRTRTHAN ((__u16)('>' + 0xF000))
+#define UNI_LESSTHAN ((__u16)('<' + 0xF000))
+#define UNI_PIPE ((__u16)('|' + 0xF000))
+#define UNI_SLASH ((__u16)('\\' + 0xF000))
/* Just define what we want from uniupr.h. We don't want to define the tables
* in each source file.
#ifdef __KERNEL__
int smb_strtoUTF16(__le16 *to, const char *from, int len,
- const struct nls_table *codepage);
-char *smb_strndup_from_utf16(const char *src, const int maxlen,
- const bool is_unicode,
const struct nls_table *codepage);
-extern int smbConvertToUTF16(__le16 *target, const char *source, int srclen,
+char *smb_strndup_from_utf16(const char *src, const int maxlen,
+ const bool is_unicode, const struct nls_table *codepage);
+int smbConvertToUTF16(__le16 *target, const char *source, int srclen,
const struct nls_table *cp, int mapchars);
-extern char *ksmbd_extract_sharename(char *treename);
+char *ksmbd_extract_sharename(char *treename);
#endif
wchar_t cifs_toupper(wchar_t in);
* Returns:
* Address of the first string
*/
- static inline wchar_t *
-UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
+static inline wchar_t *UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
{
wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
* Address of first occurrence of character in string
* or NULL if the character is not in the string
*/
- static inline wchar_t *
-UniStrchr(const wchar_t *ucs, wchar_t uc)
+static inline wchar_t *UniStrchr(const wchar_t *ucs, wchar_t uc)
{
while ((*ucs != uc) && *ucs)
ucs++;
if (*ucs == uc)
- return (wchar_t *) ucs;
+ return (wchar_t *)ucs;
return NULL;
}
* = 0: Strings are equal
* > 0: First string is greater than second
*/
- static inline int
-UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
+static inline int UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
{
while ((*ucs1 == *ucs2) && *ucs1) {
ucs1++;
ucs2++;
}
- return (int) *ucs1 - (int) *ucs2;
+ return (int)*ucs1 - (int)*ucs2;
}
/*
* UniStrcpy: Copy a string
*/
- static inline wchar_t *
-UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
+static inline wchar_t *UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
{
wchar_t *anchor = ucs1; /* save the start of result string */
/*
* UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes)
*/
- static inline size_t
-UniStrlen(const wchar_t *ucs1)
+static inline size_t UniStrlen(const wchar_t *ucs1)
{
int i = 0;
* UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a
* string (length limited)
*/
- static inline size_t
-UniStrnlen(const wchar_t *ucs1, int maxlen)
+static inline size_t UniStrnlen(const wchar_t *ucs1, int maxlen)
{
int i = 0;
/*
* UniStrncat: Concatenate length limited string
*/
- static inline wchar_t *
-UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
+static inline wchar_t *UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
{
wchar_t *anchor = ucs1; /* save pointer to string 1 */
/*
* UniStrncmp: Compare length limited string
*/
- static inline int
-UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
+static inline int UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
{
if (!n)
return 0; /* Null strings are equal */
ucs1++;
ucs2++;
}
- return (int) *ucs1 - (int) *ucs2;
+ return (int)*ucs1 - (int)*ucs2;
}
/*
ucs1++;
ucs2++;
}
- return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
+ return (int)*ucs1 - (int)__le16_to_cpu(*ucs2);
}
/*
* UniStrncpy: Copy length limited string with pad
*/
- static inline wchar_t *
-UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
+static inline wchar_t *UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
{
wchar_t *anchor = ucs1;
/*
* UniStrncpy_le: Copy length limited string with pad to little-endian
*/
- static inline wchar_t *
-UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
+static inline wchar_t *UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
{
wchar_t *anchor = ucs1;
* Address of first match found
* NULL if no matching string is found
*/
- static inline wchar_t *
-UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
+static inline wchar_t *UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
{
const wchar_t *anchor1 = ucs1;
const wchar_t *anchor2 = ucs2;
ucs2++;
} else {
if (!*ucs2) /* Match found */
- return (wchar_t *) anchor1;
+ return (wchar_t *)anchor1;
ucs1 = ++anchor1; /* No match */
ucs2 = anchor2;
}
}
if (!*ucs2) /* Both end together */
- return (wchar_t *) anchor1; /* Match found */
+ return (wchar_t *)anchor1; /* Match found */
return NULL; /* No match */
}
/*
* UniToupper: Convert a unicode character to upper case
*/
- static inline wchar_t
-UniToupper(register wchar_t uc)
+static inline wchar_t UniToupper(register wchar_t uc)
{
register const struct UniCaseRange *rp;
/*
* UniStrupr: Upper case a unicode string
*/
- static inline __le16 *
-UniStrupr(register __le16 *upin)
+static inline __le16 *UniStrupr(register __le16 *upin)
{
register __le16 *up;
/*
* UniTolower: Convert a unicode character to lower case
*/
- static inline wchar_t
-UniTolower(register wchar_t uc)
+static inline wchar_t UniTolower(register wchar_t uc)
{
register const struct UniCaseRange *rp;
/*
* UniStrlwr: Lower case a unicode string
*/
- static inline wchar_t *
-UniStrlwr(register wchar_t *upin)
+static inline wchar_t *UniStrlwr(register wchar_t *upin)
{
register wchar_t *up;
}
static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work,
- struct inode *parent_inode,
- struct inode *inode)
+ struct inode *parent_inode, struct inode *inode)
{
if (!test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_INHERIT_OWNER))
+ KSMBD_SHARE_FLAG_INHERIT_OWNER))
return;
i_uid_write(inode, i_uid_read(parent_inode));
}
static void ksmbd_vfs_inherit_smack(struct ksmbd_work *work,
- struct dentry *dir_dentry,
- struct dentry *dentry)
+ struct dentry *dir_dentry, struct dentry *dentry)
{
char *name, *xattr_list = NULL, *smack_buf;
int value_len, xattr_list_len;
return 0;
}
-
/**
* ksmbd_vfs_create() - vfs helper for smb create file
* @work: work
*
* Return: 0 on success, otherwise error
*/
-int ksmbd_vfs_create(struct ksmbd_work *work,
- const char *name,
- umode_t mode)
+int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
{
struct path path;
struct dentry *dentry;
*
* Return: 0 on success, otherwise error
*/
-int ksmbd_vfs_mkdir(struct ksmbd_work *work,
- const char *name,
- umode_t mode)
+int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
{
struct path path;
struct dentry *dentry;
ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),
d_inode(dentry));
ksmbd_vfs_inherit_smack(work, path.dentry, dentry);
- } else
+ } else {
ksmbd_err("mkdir(%s): creation failed (err:%d)\n", name, err);
+ }
done_path_create(&path, dentry);
return err;
}
-static ssize_t ksmbd_vfs_getcasexattr(struct dentry *dentry,
- char *attr_name,
- int attr_name_len,
- char **attr_value)
+static ssize_t ksmbd_vfs_getcasexattr(struct dentry *dentry, char *attr_name,
+ int attr_name_len, char **attr_value)
{
char *name, *xattr_list = NULL;
ssize_t value_len = -ENOENT, xattr_list_len;
}
static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos,
- size_t count)
+ size_t count)
{
ssize_t v_len;
char *stream_buf = NULL;
*
* Return: 0 on success, otherwise error
*/
-static int check_lock_range(struct file *filp,
- loff_t start,
- loff_t end,
- unsigned char type)
+static int check_lock_range(struct file *filp, loff_t start, loff_t end,
+ unsigned char type)
{
struct file_lock *flock;
struct file_lock_context *ctx = file_inode(filp)->i_flctx;
*
* Return: number of read bytes on success, otherwise error
*/
-int ksmbd_vfs_read(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- size_t count,
+int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
loff_t *pos)
{
struct file *filp;
}
static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos,
- size_t count)
+ size_t count)
{
char *stream_buf = NULL, *wbuf;
size_t size, v_len;
* Return: 0 on success, otherwise error
*/
int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
- char *buf, size_t count, loff_t *pos, bool sync, ssize_t *written)
+ char *buf, size_t count, loff_t *pos, bool sync,
+ ssize_t *written)
{
struct ksmbd_session *sess = work->sess;
struct file *filp;
*
* Return: 0 on success, otherwise error
*/
-int ksmbd_vfs_fsync(struct ksmbd_work *work, uint64_t fid, uint64_t p_id)
+int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id)
{
struct ksmbd_file *fp;
int err;
*
* Return: 0 on success, otherwise error
*/
-int ksmbd_vfs_link(struct ksmbd_work *work,
- const char *oldname, const char *newname)
+int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
+ const char *newname)
{
struct path oldpath, newpath;
struct dentry *dentry;
}
static int __ksmbd_vfs_rename(struct ksmbd_work *work,
- struct dentry *src_dent_parent,
- struct dentry *src_dent,
- struct dentry *dst_dent_parent,
- struct dentry *trap_dent,
- char *dst_name)
+ struct dentry *src_dent_parent, struct dentry *src_dent,
+ struct dentry *dst_dent_parent, struct dentry *trap_dent,
+ char *dst_name)
{
struct dentry *dst_dent;
int err;
* Return: 0 on success, otherwise error
*/
int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name,
- struct ksmbd_file *fp, loff_t size)
+ struct ksmbd_file *fp, loff_t size)
{
struct path path;
int err = 0;
return size;
}
-static ssize_t ksmbd_vfs_xattr_len(struct dentry *dentry,
- char *xattr_name)
+static ssize_t ksmbd_vfs_xattr_len(struct dentry *dentry, char *xattr_name)
{
return vfs_getxattr(&init_user_ns, dentry, xattr_name, NULL, 0);
}
*
* Return: read xattr value length on success, otherwise error
*/
-ssize_t ksmbd_vfs_getxattr(struct dentry *dentry,
- char *xattr_name,
- char **xattr_buf)
+ssize_t ksmbd_vfs_getxattr(struct dentry *dentry, char *xattr_name,
+ char **xattr_buf)
{
ssize_t xattr_len;
char *buf;
*
* Return: 0 on success, otherwise error
*/
-int ksmbd_vfs_setxattr(struct dentry *dentry,
- const char *attr_name,
- const void *attr_value,
- size_t attr_size,
- int flags)
+int ksmbd_vfs_setxattr(struct dentry *dentry, const char *attr_name,
+ const void *attr_value, size_t attr_size, int flags)
{
int err;
if (!option || !mapping)
return;
- if (option & FILE_WRITE_THROUGH_LE)
+ if (option & FILE_WRITE_THROUGH_LE) {
filp->f_flags |= O_SYNC;
- else if (option & FILE_SEQUENTIAL_ONLY_LE) {
+ } else if (option & FILE_SEQUENTIAL_ONLY_LE) {
filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2;
spin_lock(&filp->f_lock);
filp->f_mode &= ~FMODE_RANDOM;
return iterate_dir(file, &rdata->ctx);
}
-int ksmbd_vfs_alloc_size(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- loff_t len)
+int ksmbd_vfs_alloc_size(struct ksmbd_work *work, struct ksmbd_file *fp,
+ loff_t len)
{
smb_break_all_levII_oplock(work, fp, 1);
return vfs_fallocate(fp->filp, FALLOC_FL_KEEP_SIZE, 0, len);
}
-int ksmbd_vfs_zero_data(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- loff_t off,
- loff_t len)
+int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp,
+ loff_t off, loff_t len)
{
smb_break_all_levII_oplock(work, fp, 1);
if (fp->f_ci->m_fattr & ATTR_SPARSE_FILE_LE)
if (extent_end != -ENXIO)
ret = (int)extent_end;
break;
- } else if (extent_start >= extent_end)
+ } else if (extent_start >= extent_end) {
break;
+ }
ranges[*out_count].file_offset = cpu_to_le64(extent_start);
ranges[(*out_count)++].length =
* @fs_ss: fs sector size struct
*/
void ksmbd_vfs_smb2_sector_size(struct inode *inode,
- struct ksmbd_fs_sector_size *fs_ss)
+ struct ksmbd_fs_sector_size *fs_ss)
{
struct request_queue *q;
}
}
-static int __dir_empty(struct dir_context *ctx,
- const char *name,
- int namlen,
- loff_t offset,
- u64 ino,
- unsigned int d_type)
+static int __dir_empty(struct dir_context *ctx, const char *name, int namlen,
+ loff_t offset, u64 ino, unsigned int d_type)
{
struct ksmbd_readdir_data *buf;
return err;
}
-static int __caseless_lookup(struct dir_context *ctx,
- const char *name,
- int namlen,
- loff_t offset,
- u64 ino,
- unsigned int d_type)
+static int __caseless_lookup(struct dir_context *ctx, const char *name,
+ int namlen, loff_t offset, u64 ino, unsigned int d_type)
{
struct ksmbd_readdir_data *buf;
struct path dir_path;
int ret;
struct file *dfilp;
- int flags = O_RDONLY|O_LARGEFILE;
+ int flags = O_RDONLY | O_LARGEFILE;
int dirnamelen = strlen(dirname);
struct ksmbd_readdir_data readdir_data = {
.ctx.actor = __caseless_lookup,
ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
- sizeof(XATTR_NAME_POSIX_ACL_ACCESS)-1) ||
+ sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) ||
!strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
- sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)-1)) {
+ sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) {
err = ksmbd_vfs_remove_xattr(dentry, name);
if (err)
ksmbd_debug(SMB,
if (ndr_decode_dos_attr(&n, da))
err = -EINVAL;
ksmbd_free(n.data);
- } else
+ } else {
ksmbd_debug(SMB, "failed to load dos attribute in xattr\n");
+ }
return err;
}
return info;
}
-int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work,
- struct dentry *dentry,
- struct ksmbd_kstat *ksmbd_kstat)
+int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, struct dentry *dentry,
+ struct ksmbd_kstat *ksmbd_kstat)
{
u64 time;
int rc;
ksmbd_kstat->file_attributes = ATTR_ARCHIVE_LE;
if (test_share_config_flag(work->tcon->share_conf,
- KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
+ KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
struct xattr_dos_attrib da;
rc = ksmbd_vfs_get_dos_attrib_xattr(dentry, &da);
if (rc > 0) {
ksmbd_kstat->file_attributes = cpu_to_le32(da.attr);
ksmbd_kstat->create_time = da.create_time;
- } else
+ } else {
ksmbd_debug(VFS, "fail to load dos attribute.\n");
+ }
}
return 0;
}
-ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry,
- char *attr_name,
- int attr_name_len)
+ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry, char *attr_name,
+ int attr_name_len)
{
char *name, *xattr_list = NULL;
ssize_t value_len = -ENOENT, xattr_list_len;
return value_len;
}
-int ksmbd_vfs_xattr_stream_name(char *stream_name,
- char **xattr_stream_name,
- size_t *xattr_stream_name_size,
- int s_type)
+int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
+ size_t *xattr_stream_name_size, int s_type)
{
int stream_name_size;
char *xattr_stream_name_buf;
}
static int ksmbd_vfs_copy_file_range(struct file *file_in, loff_t pos_in,
- struct file *file_out, loff_t pos_out,
- size_t len)
+ struct file *file_out, loff_t pos_out, size_t len)
{
struct inode *inode_in = file_inode(file_in);
struct inode *inode_out = file_inode(file_out);
}
int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
- struct ksmbd_file *src_fp,
- struct ksmbd_file *dst_fp,
- struct srv_copychunk *chunks,
- unsigned int chunk_count,
- unsigned int *chunk_count_written,
- unsigned int *chunk_size_written,
- loff_t *total_size_written)
+ struct ksmbd_file *src_fp, struct ksmbd_file *dst_fp,
+ struct srv_copychunk *chunks, unsigned int chunk_count,
+ unsigned int *chunk_count_written,
+ unsigned int *chunk_size_written, loff_t *total_size_written)
{
unsigned int i;
loff_t src_off, dst_off, src_file_size;
len = le32_to_cpu(chunks[i].Length);
if (check_lock_range(src_fp->filp, src_off,
- src_off + len - 1, READ))
+ src_off + len - 1, READ))
return -EAGAIN;
if (check_lock_range(dst_fp->filp, dst_off,
- dst_off + len - 1, WRITE))
+ dst_off + len - 1, WRITE))
return -EAGAIN;
}
}
#define XATTR_NAME_SD_LEN \
(sizeof(XATTR_SECURITY_PREFIX SD_PREFIX) - 1)
-
/* CreateOptions */
/* Flag is set, it must not be a file , valid for directory only */
#define FILE_DIRECTORY_FILE_LE cpu_to_le32(0x00000001)
int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode);
int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode);
int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp,
- size_t count, loff_t *pos);
+ size_t count, loff_t *pos);
int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
- char *buf, size_t count, loff_t *pos, bool sync, ssize_t *written);
-int ksmbd_vfs_fsync(struct ksmbd_work *work, uint64_t fid, uint64_t p_id);
+ char *buf, size_t count, loff_t *pos, bool sync,
+ ssize_t *written);
+int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id);
int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name);
int ksmbd_vfs_link(struct ksmbd_work *work,
const char *oldname, const char *newname);
int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
char *newname);
-int ksmbd_vfs_rename_slowpath(struct ksmbd_work *work,
- char *oldname, char *newname);
int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name,
- struct ksmbd_file *fp, loff_t size);
+ struct ksmbd_file *fp, loff_t size);
struct srv_copychunk;
int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
- struct ksmbd_file *src_fp,
- struct ksmbd_file *dst_fp,
- struct srv_copychunk *chunks,
- unsigned int chunk_count,
- unsigned int *chunk_count_written,
- unsigned int *chunk_size_written,
- loff_t *total_size_written);
-
-struct ksmbd_file *ksmbd_vfs_dentry_open(struct ksmbd_work *work,
- const struct path *path,
- int flags,
- __le32 option,
- int fexist);
+ struct ksmbd_file *src_fp, struct ksmbd_file *dst_fp,
+ struct srv_copychunk *chunks, unsigned int chunk_count,
+ unsigned int *chunk_count_written,
+ unsigned int *chunk_size_written, loff_t *total_size_written);
ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list);
-ssize_t ksmbd_vfs_getxattr(struct dentry *dentry,
- char *xattr_name,
- char **xattr_buf);
-
-ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry,
- char *attr_name,
- int attr_name_len);
-
-int ksmbd_vfs_setxattr(struct dentry *dentry,
- const char *attr_name,
- const void *attr_value,
- size_t attr_size,
- int flags);
-
-int ksmbd_vfs_fsetxattr(const char *filename,
- const char *attr_name,
- const void *attr_value,
- size_t attr_size,
- int flags);
-
-int ksmbd_vfs_xattr_stream_name(char *stream_name,
- char **xattr_stream_name,
- size_t *xattr_stream_name_size,
- int s_type);
-
+ssize_t ksmbd_vfs_getxattr(struct dentry *dentry, char *xattr_name,
+ char **xattr_buf);
+ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry, char *attr_name,
+ int attr_name_len);
+int ksmbd_vfs_setxattr(struct dentry *dentry, const char *attr_name,
+ const void *attr_value, size_t attr_size, int flags);
+int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
+ size_t *xattr_stream_name_size, int s_type);
int ksmbd_vfs_truncate_xattr(struct dentry *dentry, int wo_streams);
int ksmbd_vfs_remove_xattr(struct dentry *dentry, char *attr_name);
void ksmbd_vfs_xattr_free(char *xattr);
-
int ksmbd_vfs_kern_path(char *name, unsigned int flags, struct path *path,
bool caseless);
int ksmbd_vfs_empty_dir(struct ksmbd_file *fp);
void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option);
int ksmbd_vfs_lock(struct file *filp, int cmd, struct file_lock *flock);
int ksmbd_vfs_readdir(struct file *file, struct ksmbd_readdir_data *rdata);
-int ksmbd_vfs_alloc_size(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- loff_t len);
-int ksmbd_vfs_zero_data(struct ksmbd_work *work,
- struct ksmbd_file *fp,
- loff_t off,
- loff_t len);
-
+int ksmbd_vfs_alloc_size(struct ksmbd_work *work, struct ksmbd_file *fp,
+ loff_t len);
+int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp,
+ loff_t off, loff_t len);
struct file_allocated_range_buffer;
int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length,
- struct file_allocated_range_buffer *ranges,
- int in_count, int *out_count);
+ struct file_allocated_range_buffer *ranges,
+ int in_count, int *out_count);
int ksmbd_vfs_unlink(struct dentry *dir, struct dentry *dentry);
unsigned short ksmbd_vfs_logical_sector_size(struct inode *inode);
void ksmbd_vfs_smb2_sector_size(struct inode *inode,
- struct ksmbd_fs_sector_size *fs_ss);
+ struct ksmbd_fs_sector_size *fs_ss);
void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat);
-
-int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work,
- struct dentry *dentry,
- struct ksmbd_kstat *ksmbd_kstat);
-
+int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, struct dentry *dentry,
+ struct ksmbd_kstat *ksmbd_kstat);
int ksmbd_vfs_posix_lock_wait(struct file_lock *flock);
int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout);
void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock);
-
int ksmbd_vfs_remove_acl_xattrs(struct dentry *dentry);
int ksmbd_vfs_remove_sd_xattrs(struct dentry *dentry);
int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry,
write_unlock(&global_ft.lock);
}
-static void __ksmbd_remove_fd(struct ksmbd_file_table *ft,
- struct ksmbd_file *fp)
+static void __ksmbd_remove_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp)
{
if (!HAS_FILE_ID(fp->volatile_id))
return;
write_unlock(&ft->lock);
}
-static void __ksmbd_close_fd(struct ksmbd_file_table *ft,
- struct ksmbd_file *fp)
+static void __ksmbd_close_fd(struct ksmbd_file_table *ft, struct ksmbd_file *fp)
{
struct file *filp;
}
static struct ksmbd_file *__ksmbd_lookup_fd(struct ksmbd_file_table *ft,
- unsigned int id)
+ unsigned int id)
{
bool unclaimed = true;
struct ksmbd_file *fp;
return fp;
}
-static void __put_fd_final(struct ksmbd_work *work,
- struct ksmbd_file *fp)
+static void __put_fd_final(struct ksmbd_work *work, struct ksmbd_file *fp)
{
__ksmbd_close_fd(&work->sess->file_table, fp);
atomic_dec(&work->conn->stats.open_files_count);
return 0;
}
-void ksmbd_fd_put(struct ksmbd_work *work,
- struct ksmbd_file *fp)
+void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp)
{
if (!fp)
return;
__put_fd_final(work, fp);
}
-static bool __sanity_check(struct ksmbd_tree_connect *tcon,
- struct ksmbd_file *fp)
+static bool __sanity_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
{
if (!fp)
return false;
return true;
}
-struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work,
- unsigned int id)
+struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, unsigned int id)
{
return __ksmbd_lookup_fd(&work->sess->file_table, id);
}
-struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work,
- unsigned int id)
+struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, unsigned int id)
{
struct ksmbd_file *fp = __ksmbd_lookup_fd(&work->sess->file_table, id);
return NULL;
}
-struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work,
- unsigned int id,
- unsigned int pid)
+struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, unsigned int id,
+ unsigned int pid)
{
struct ksmbd_file *fp;
return __ksmbd_lookup_fd(&global_ft, id);
}
-int ksmbd_close_fd_app_id(struct ksmbd_work *work,
- char *app_id)
+int ksmbd_close_fd_app_id(struct ksmbd_work *work, char *app_id)
{
struct ksmbd_file *fp = NULL;
unsigned int id;
return fp;
}
-struct ksmbd_file *ksmbd_lookup_fd_filename(struct ksmbd_work *work,
- char *filename)
+struct ksmbd_file *ksmbd_lookup_fd_filename(struct ksmbd_work *work, char *filename)
{
struct ksmbd_file *fp = NULL;
unsigned int id;
fp->persistent_id = id;
}
-static int __open_id(struct ksmbd_file_table *ft,
- struct ksmbd_file *fp,
+static int __open_id(struct ksmbd_file_table *ft, struct ksmbd_file *fp,
int type)
{
unsigned int id = 0;
return fp->persistent_id;
}
-struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work,
- struct file *filp)
+struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp)
{
struct ksmbd_file *fp;
int ret;
if (fp->is_resilient || fp->is_persistent)
reconn = true;
else if (fp->is_durable && opinfo->is_lease &&
- opinfo->o_lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
+ opinfo->o_lease->state & SMB2_LEASE_HANDLE_CACHING_LE)
reconn = true;
else if (fp->is_durable && opinfo->level == SMB2_OPLOCK_LEVEL_BATCH)
}
static int
-__close_file_table_ids(struct ksmbd_file_table *ft,
- struct ksmbd_tree_connect *tcon,
- bool (*skip)(struct ksmbd_tree_connect *tcon,
- struct ksmbd_file *fp))
+__close_file_table_ids(struct ksmbd_file_table *ft, struct ksmbd_tree_connect *tcon,
+ bool (*skip)(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp))
{
unsigned int id;
struct ksmbd_file *fp;
return num;
}
-static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon,
- struct ksmbd_file *fp)
+static bool tree_conn_fd_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
{
return fp->tcon != tcon;
}
-static bool session_fd_check(struct ksmbd_tree_connect *tcon,
- struct ksmbd_file *fp)
+static bool session_fd_check(struct ksmbd_tree_connect *tcon, struct ksmbd_file *fp)
{
if (!is_reconnectable(fp))
return false;
ksmbd_destroy_file_table(&global_ft);
}
-int ksmbd_reopen_durable_fd(struct ksmbd_work *work,
- struct ksmbd_file *fp)
+int ksmbd_reopen_durable_fd(struct ksmbd_work *work, struct ksmbd_file *fp)
{
if (!fp->is_durable || fp->conn || fp->tcon) {
ksmbd_err("Invalid durable fd [%p:%p]\n",
int ksmbd_init_file_table(struct ksmbd_file_table *ft);
void ksmbd_destroy_file_table(struct ksmbd_file_table *ft);
-
int ksmbd_close_fd(struct ksmbd_work *work, unsigned int id);
-
-struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work,
- unsigned int id);
-struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work,
- unsigned int id);
-struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work,
- unsigned int id,
- unsigned int pid);
-
+struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, unsigned int id);
+struct ksmbd_file *ksmbd_lookup_foreign_fd(struct ksmbd_work *work, unsigned int id);
+struct ksmbd_file *ksmbd_lookup_fd_slow(struct ksmbd_work *work, unsigned int id,
+ unsigned int pid);
void ksmbd_fd_put(struct ksmbd_work *work, struct ksmbd_file *fp);
-
int ksmbd_close_fd_app_id(struct ksmbd_work *work, char *app_id);
struct ksmbd_file *ksmbd_lookup_durable_fd(unsigned long long id);
struct ksmbd_file *ksmbd_lookup_fd_cguid(char *cguid);
-struct ksmbd_file *ksmbd_lookup_fd_filename(struct ksmbd_work *work,
- char *filename);
+struct ksmbd_file *ksmbd_lookup_fd_filename(struct ksmbd_work *work, char *filename);
struct ksmbd_file *ksmbd_lookup_fd_inode(struct inode *inode);
-
unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp);
-
-struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work,
- struct file *filp);
-
+struct ksmbd_file *ksmbd_open_fd(struct ksmbd_work *work, struct file *filp);
void ksmbd_close_tree_conn_fds(struct ksmbd_work *work);
void ksmbd_close_session_fds(struct ksmbd_work *work);
-
int ksmbd_close_inode_fds(struct ksmbd_work *work, struct inode *inode);
-
-int ksmbd_reopen_durable_fd(struct ksmbd_work *work,
- struct ksmbd_file *fp);
-
+int ksmbd_reopen_durable_fd(struct ksmbd_work *work, struct ksmbd_file *fp);
int ksmbd_init_global_file_table(void);
void ksmbd_free_global_file_table(void);
-
int ksmbd_file_table_flush(struct ksmbd_work *work);
-
void ksmbd_set_fd_limit(unsigned long limit);
/*
* INODE hash
*/
-
int __init ksmbd_inode_hash_init(void);
void ksmbd_release_inode_hash(void);
};
int ksmbd_query_inode_status(struct inode *inode);
-
bool ksmbd_inode_pending_delete(struct ksmbd_file *fp);
void ksmbd_set_inode_pending_delete(struct ksmbd_file *fp);
void ksmbd_clear_inode_pending_delete(struct ksmbd_file *fp);
-
void ksmbd_fd_set_delete_on_close(struct ksmbd_file *fp,
int file_info);
#endif /* __VFS_CACHE_H__ */
projects / platform / kernel / linux-starfive.git / commitdiff