ksmbd: implement the command sequence window
Subsystems (2)
Namjae Jeon
maintainerPATCH 1/7 ksmbd: implement the command sequence window
ksmbd tracked only credit counts (total_credits/outstanding_credits) and never validated the MessageId of an incoming request. As a result a request carrying a MessageId outside the granted range was accepted, a MessageId could be replayed, and a 64-bit sequence wrap was not detected.
Maintain a command sequence window per connection:
- [seq_low, seq_high) is the range of granted sequence numbers and seq_bitmap records which of them have been granted but not yet consumed. The window starts as { 0 } at connection setup.
- smb2_set_rsp_credits() extends seq_high by the number of credits it grants (setting the corresponding bits), capped so the window never spans more than KSMBD_CMD_SEQ_WINDOW (== SMB2_MAX_CREDITS) sequence numbers. This implements the "limit the range of acceptable sequence numbers" allowance and keeps seq_bitmap usable as a ring.
- smb2_check_sequence_number(), run for every SMB2 request from ksmbd_smb2_check_message(), verifies that the CreditCharge consecutive sequence numbers starting at MessageId lie within the window and have not already been consumed, then removes them and slides seq_low forward. CANCEL consumes nothing. A violation (out of window, replay, or wrap) tears the connection down.
The legacy SMB1 multi-protocol negotiate occupies sequence number 0 but does not pass through ksmbd_smb2_check_message(), so it consumes that sequence number explicitly; otherwise seq_low would stay pinned at 0 after the upgrade to SMB2 and eventually stall credit grants.
For an in-order client seq_high - seq_low equals total_credits, so the window-room cap never reduces the number of credits granted. it only engages for a client that withholds low sequence numbers. init_smb2_max_credits() now clamps the configured maximum to SMB2_MAX_CREDITS so the window (and its bitmap) can always represent every outstanding sequence number.
--- fs/smb/server/connection.c | 8 ++++ fs/smb/server/connection.h | 20 ++++++++++ fs/smb/server/smb2misc.c | 79 ++++++++++++++++++++++++++++++++++++++ fs/smb/server/smb2ops.c | 7 ++++ fs/smb/server/smb2pdu.c | 16 ++++++++ fs/smb/server/smb_common.c | 17 +++++++- 6 files changed, 146 insertions(+), 1 deletion(-)
fs/smb/server/connection.c +8 -0
@@ -219,6 +219,14 @@ struct ksmbd_conn *ksmbd_conn_alloc(void) conn->total_credits =1 ; conn->outstanding_credits =0 ; +/* +* The command sequence window starts as the set { 0 } when the +* connection is established. +*/ + conn->seq_low =0 ; + conn->seq_high =1 ; +__set_bit (0 , conn->seq_bitmap); +init_waitqueue_head (&conn->req_running_q);init_waitqueue_head (&conn->r_count_q);INIT_LIST_HEAD (&conn->requests);
fs/smb/server/connection.h +20 -0
@@ -17,6 +17,7 @@#include <linux/nls.h> #include <linux/unicode.h> #include <linux/workqueue.h> +#include <linux/bitmap.h> #include "smb_common.h" #include "ksmbd_work.h"
@@ -25,6 +26,15 @@ struct smbdirect_buffer_descriptor_v1;#define KSMBD_SOCKET_BACKLOG 16 +/* +* Size of the per-connection SMB2 command sequence window. This mirrors +* SMB2_MAX_CREDITS, the maximum number of credits (and therefore the +* maximum number of outstanding sequence numbers) that can be granted on +* a connection. It must be a power of two so the window can be indexed as +* a ring. +*/ +#define KSMBD_CMD_SEQ_WINDOW 8192 +enum {KSMBD_SESS_NEW =0 ,KSMBD_SESS_GOOD ,
@@ -74,6 +84,16 @@ struct ksmbd_conn {unsigned int total_credits;unsigned int outstanding_credits;spinlock_t credits_lock; +/* +* Connection command sequence window. [seq_low, seq_high) is the +* range of granted sequence numbers (message IDs). seq_bitmap marks +* the ones in that range that have been granted but +* not yet consumed by a received request. All three are protected by +* credits_lock. +*/ +u64 seq_low; +u64 seq_high; +DECLARE_BITMAP (seq_bitmap,KSMBD_CMD_SEQ_WINDOW );wait_queue_head_t req_running_q;wait_queue_head_t r_count_q;/* Lock to protect requests list*/
fs/smb/server/smb2misc.c +79 -0
91 lines not on this page · raw message
fs/smb/server/smb2ops.c +7 -0
@@ -330,6 +330,13 @@ void init_smb2_max_trans_size(unsigned int sz)void init_smb2_max_credits (unsigned int sz) { +/* +* The command sequence window (and its backing bitmap) can track at +* most SMB2_MAX_CREDITS outstanding sequence numbers, so the number of +* credits granted on a connection must not exceed that. +*/ +if (sz >SMB2_MAX_CREDITS ) + sz =SMB2_MAX_CREDITS ; smb21_server_values.max_credits = sz; smb30_server_values.max_credits = sz; smb302_server_values.max_credits = sz;
fs/smb/server/smb2pdu.c +16 -0
@@ -388,6 +388,7 @@ int smb2_set_rsp_credits(struct ksmbd_work *work)struct ksmbd_conn *conn = work->conn;unsigned short credits_requested, aux_max;unsigned short credit_charge, credits_granted =0 ; +u64 window_room, i;if (work->send_no_response)return 0 ;
@@ -424,11 +425,26 @@ int smb2_set_rsp_credits(struct ksmbd_work *work) aux_max =1 ; else aux_max = conn->vals->max_credits - conn->total_credits; + +/* +* The command sequence window must not grow beyond +* KSMBD_CMD_SEQ_WINDOW sequence numbers ahead of the oldest one still +* outstanding. Cap the grant by the room left in the window so that +* credits are withheld until the client consumes the low end (and so +* that seq_bitmap stays usable as a ring). +*/ + window_room = conn->seq_low +KSMBD_CMD_SEQ_WINDOW - conn->seq_high; + aux_max = min_t(unsigned short, aux_max, window_room); credits_granted = min_t(unsigned short, credits_requested, aux_max); conn->total_credits += credits_granted; work->credits_granted += credits_granted; +/* Extend the sequence window to cover the newly granted credits. */ +for (i = conn->seq_high; i < conn->seq_high + credits_granted; i++) +__set_bit (i & (KSMBD_CMD_SEQ_WINDOW -1 ), conn->seq_bitmap); + conn->seq_high += credits_granted; +if (!req_hdr->NextCommand) {/* Update CreditRequest in last request */ hdr->CreditRequest =cpu_to_le16 (work->credits_granted);
fs/smb/server/smb_common.c +16 -1
@@ -164,7 +164,22 @@ int ksmbd_verify_smb_message(struct ksmbd_work *work) hdr =smb_get_msg (work->request_buf);if (*(__le32 *)hdr->Protocol ==SMB1_PROTO_NUMBER && hdr->Command ==SMB_COM_NEGOTIATE ) { - work->conn->outstanding_credits++; +struct ksmbd_conn *conn = work->conn; + + conn->outstanding_credits++; +/* +* A legacy SMB1 multi-protocol negotiate occupies sequence +* number 0 but does not pass through +* ksmbd_smb2_check_message(). Consume it here so that, after +* the connection is upgraded to SMB2, the command sequence +* window can advance instead of staying pinned at 0. +*/ +spin_lock (&conn->credits_lock); +if (conn->seq_low ==0 ) { +__clear_bit (0 , conn->seq_bitmap); + conn->seq_low =1 ; + } +spin_unlock (&conn->credits_lock);return 0 ; }
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 2/7 ksmbd: add SMB3 request replay support
SMB3 clients can replay selected requests after a channel disconnect by setting SMB2_FLAGS_REPLAY_OPERATION. The command sequence window rejects duplicate MessageIds on one connection, but it does not validate requests resent on another channel with a new MessageId.
Add the state and validation required to replay durable CREATE and file-handle operations:
- track each open ChannelSequence, outstanding request counts, and lock sequence entries;
- retain a request-owned open reference until the common response path completes ChannelSequence accounting;
- replay DurableHandleReqV2 CREATE requests by CreateGuid, validating the durable state, SecurityContext, session, lease key, and persistent flag;
- publish CreateGuid and SecurityContext before an oplock or lease break can defer CREATE, rejecting replays of that pending CREATE with STATUS_FILE_NOT_AVAILABLE;
- retain the original CREATE action and replay completed CreateGuid requests, including requests that did not receive a durable-handle grant, without modifying the existing open;
- make replayed oplock and lease break acknowledgements idempotent; and
- preserve SMB2_FLAGS_REPLAY_OPERATION in responses.
Return STATUS_FILE_NOT_AVAILABLE when ChannelSequence validation rejects a replayed WRITE, IOCTL, or SET_INFO request.
--- fs/smb/server/ksmbd_work.c | 2 + fs/smb/server/ksmbd_work.h | 9 + fs/smb/server/mgmt/user_session.c | 8 - fs/smb/server/oplock.c | 38 ++- fs/smb/server/oplock.h | 2 +- fs/smb/server/server.c | 9 +- fs/smb/server/smb2pdu.c | 525 ++++++++++++++++++++++++++++-- fs/smb/server/smb2pdu.h | 1 + fs/smb/server/vfs_cache.c | 13 +- fs/smb/server/vfs_cache.h | 18 + 10 files changed, 586 insertions(+), 39 deletions(-)
fs/smb/server/ksmbd_work.c +2 -0
@@ -11,6 +11,7 @@#include "server.h" #include "connection.h" #include "ksmbd_work.h" +#include "vfs_cache.h" #include "mgmt/ksmbd_ida.h" static struct kmem_cache *work_cache;
@@ -88,6 +89,7 @@ void ksmbd_free_work_struct(struct ksmbd_work *work)ksmbd_release_id (&work->conn->async_ida, work->async_id);if (work->owns_conn_ref)ksmbd_conn_put (work->conn); +ksmbd_fd_put (work, work->request_open);kmem_cache_free (work_cache, work); }
fs/smb/server/ksmbd_work.h +9 -0
@@ -12,6 +12,7 @@struct ksmbd_conn ;struct ksmbd_session ;struct ksmbd_tree_connect ; +struct ksmbd_file ;#define KSMBD_WORK_INLINE_IOVS 4
@@ -93,6 +94,7 @@ struct ksmbd_work {/* Work owns a reference to @conn. */ bool owns_conn_ref:1; bool need_invalidate_rkey:1; + bool request_open_chseq_tracked:1;unsigned int remote_key;/* cancel works */
@@ -100,6 +102,13 @@ struct ksmbd_work {void **cancel_argv;void (*cancel_fn)(void **argv); +/* +* Refcounted open associated with the SMB2 command currently being +* processed. +*/ +struct ksmbd_file *request_open; +__le16 request_open_chseq; +struct work_struct work;/* List head at conn->requests */ struct list_head request_entry;
fs/smb/server/mgmt/user_session.c +0 -8
@@ -478,14 +478,6 @@ void ksmbd_sessions_deregister(struct ksmbd_conn *conn)down_write (&conn->session_lock);xa_for_each (&conn->sessions, id, sess) { -unsigned long chann_id; -struct channel *chann; - -xa_for_each (&sess->ksmbd_chann_list, chann_id, chann) { -if (chann->conn != conn) -ksmbd_conn_set_exiting (chann->conn); - } -ksmbd_chann_del (conn, sess);if (xa_empty (&sess->ksmbd_chann_list)) {xa_erase (&conn->sessions, sess->id);
fs/smb/server/oplock.c +36 -2
@@ -1203,6 +1203,18 @@ static int oplock_break(struct oplock_info *brk_opinfo, int req_op_level,if (brk_opinfo->level ==SMB2_OPLOCK_LEVEL_BATCH || brk_opinfo->level ==SMB2_OPLOCK_LEVEL_EXCLUSIVE ) brk_opinfo->op_state =OPLOCK_ACK_WAIT ; + +/* +* Keep a conflicting CREATE asynchronous while waiting for an +* oplock-break acknowledgement. Besides avoiding a blocked client +* request, this lets a replay arrive while the original CREATE is +* still pending and be rejected with FILE_NOT_AVAILABLE. +*/ +if (in_work) { +setup_async_work (in_work,NULL ,NULL ); +smb2_send_interim_resp (in_work,STATUS_PENDING ); +release_async_work (in_work); + } } err =smb2_oplock_break_noti (brk_opinfo);
@@ -1450,7 +1462,7 @@ void smb_lazy_parent_lease_break_close(struct ksmbd_file *fp)*/ 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 lease_ctx_info *lctx,int share_ret,bool replay) {int err =0 ;int break_level =SMB2_OPLOCK_LEVEL_II ;
@@ -1535,6 +1547,21 @@ int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, u64 pid, prev_op_has_lease = prev_opinfo->is_lease;if (prev_op_has_lease) prev_op_state = prev_opinfo->o_lease->state; +/* +* A replay received while this open is waiting for an oplock or lease +* break must not observe an intermediate level and proceed as a new +* open. This check has to precede break_needed. an oplock may already +* have been downgraded from Batch to II while its acknowledgement is +* still pending. +*/ +if (replay && + (test_bit (0 , &prev_opinfo->pending_break) || + prev_opinfo->op_state ==OPLOCK_ACK_WAIT )) { + err = -EINPROGRESS ; +opinfo_put (prev_opinfo); + goto err_out; + } +if (share_ret <0 && prev_opinfo->level ==SMB2_OPLOCK_LEVEL_EXCLUSIVE ) { err = share_ret;
@@ -1569,7 +1596,14 @@ int smb_grant_oplock(struct ksmbd_work *work, int req_op_level, u64 pid, goto set_lev; }if (err == -ENOENT ) { -if (req_op_level !=SMB2_OPLOCK_LEVEL_NONE ) +/* +* A pending durable CREATE can lose the previous oplock when +* its holder closes the file. In that case grant the original +* request its full caching state. Other opens still need the +* normal shared-open downgrade below. +*/ +if (!prev_durable_open && + req_op_level !=SMB2_OPLOCK_LEVEL_NONE ) req_op_level =SMB2_OPLOCK_LEVEL_II ; goto set_lev; }
fs/smb/server/oplock.h +1 -1
@@ -96,7 +96,7 @@ struct oplock_break_info {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 lease_ctx_info *lctx,int share_ret,bool replay);void smb_break_all_levII_oplock (struct ksmbd_work *work,struct ksmbd_file *fp,int is_trunc);void smb_break_all_levII_oplock_rename (struct ksmbd_work *work,struct ksmbd_file *fp);
fs/smb/server/server.c +8 -1
@@ -15,6 +15,7 @@#include "server.h" #include "smb_common.h" +#include "smb2pdu.h" #include "../common/smb2status.h" #include "connection.h" #include "transport_ipc.h"
@@ -221,8 +222,10 @@ static void __handle_ksmbd_work(struct ksmbd_work *work, } rc =__process_request (work, conn, &command); -if (rc ==SERVER_HANDLER_ABORT ) +if (rc ==SERVER_HANDLER_ABORT ) { +smb2_complete_request_open (work);break ; + }/* * Call smb2_set_rsp_credits() function to set number of credits
@@ -235,10 +238,13 @@ static void __handle_ksmbd_work(struct ksmbd_work *work,if (rc <0 ) { conn->ops->set_rsp_status (work,STATUS_INVALID_PARAMETER ); +smb2_complete_request_open (work); goto send; } } +smb2_complete_request_open (work); + is_chained =is_chained_smb2_message (work); if (work->sess &&
@@ -254,6 +260,7 @@ static void __handle_ksmbd_work(struct ksmbd_work *work, }while (is_chained == true); send: +smb2_complete_request_open (work);/* * Release any credit charge still outstanding for this request. On * the normal path smb2_set_rsp_credits() already returned it, but the
fs/smb/server/smb2pdu.c +502 -23
778 lines not on this page · raw message
fs/smb/server/smb2pdu.h +1 -0
@@ -432,6 +432,7 @@ bool smb3_encryption_negotiated(struct ksmbd_conn *conn);/* smb2 misc functions */ int ksmbd_smb2_check_message (struct ksmbd_work *work); +void smb2_complete_request_open (struct ksmbd_work *work);/* smb2 command handlers */ int smb2_handle_negotiate (struct ksmbd_work *work);
fs/smb/server/vfs_cache.c +9 -4
@@ -729,6 +729,11 @@ static struct ksmbd_file *ksmbd_fp_get(struct ksmbd_file *fp)return fp; } +struct ksmbd_file *ksmbd_file_get (struct ksmbd_file *fp) +{ +return ksmbd_fp_get (fp); +} +static struct ksmbd_file *__ksmbd_lookup_fd (struct ksmbd_file_table *ft,u64 id) {
@@ -1570,7 +1575,7 @@ void ksmbd_stop_durable_scavenger(void) }/* -* ksmbd_vfs_copy_durable_owner - Copy owner info for durable reconnect +* ksmbd_vfs_set_durable_owner - Store owner info for durable replay/reconnect * @fp: ksmbd file pointer to store owner info * @user: user pointer to copy from *
@@ -1579,8 +1584,8 @@ void ksmbd_stop_durable_scavenger(void)* * Return: 0 on success, or negative error code on failure */ -static int ksmbd_vfs_copy_durable_owner (struct ksmbd_file *fp, -struct ksmbd_user *user) +int ksmbd_vfs_set_durable_owner (struct ksmbd_file *fp, +struct ksmbd_user *user) {char *name;
@@ -1651,7 +1656,7 @@ static bool session_fd_check(struct ksmbd_tree_connect *tcon,if (WARN_ON_ONCE (!fp->conn))return false; -if (ksmbd_vfs_copy_durable_owner (fp, user)) +if (ksmbd_vfs_set_durable_owner (fp, user))return false;/*
fs/smb/server/vfs_cache.h +18 -0
@@ -82,6 +82,13 @@ struct durable_owner {char *name; }; +#define KSMBD_LOCK_SEQ_ARRAY_SIZE 64 + +struct ksmbd_lock_sequence { +bool valid; +u8 sequence; +}; +struct ksmbd_file {struct file *filp;u64 persistent_id;
@@ -101,6 +108,7 @@ struct ksmbd_file {__le32 saccess;__le32 coption;__le32 cdoption; +__le32 create_file_attributes;__u64 create_time;__u64 change_time;__u64 allocation_size;
@@ -128,6 +136,8 @@ struct ksmbd_file {unsigned int durable_timeout;unsigned int durable_scavenger_timeout; +/* CREATE action returned when this durable handle was established. */ +__le32 create_action;/* if ls is happening on directory, below is valid*/ struct ksmbd_readdir_data readdir_data;
@@ -139,9 +149,14 @@ struct ksmbd_file {bool is_persistent;bool is_resilient;bool durable_reconnect_disabled; +bool durable_replay_consumed;bool is_posix_ctxt;struct durable_owner owner; +__le16 channel_sequence; +unsigned int outstanding_requests; +unsigned int outstanding_pre_requests; +struct ksmbd_lock_sequence lock_seq[KSMBD_LOCK_SEQ_ARRAY_SIZE ];/* * Pending CHANGE_NOTIFY completions for this handle, sent with
@@ -180,6 +195,9 @@ struct ksmbd_file *ksmbd_lookup_fd_fast(struct ksmbd_work *work, u64 id);struct ksmbd_file *ksmbd_lookup_foreign_fd (struct ksmbd_work *work,u64 id);struct ksmbd_file *ksmbd_lookup_fd_slow (struct ksmbd_work *work,u64 id,u64 pid); +int ksmbd_vfs_set_durable_owner (struct ksmbd_file *fp, +struct ksmbd_user *user); +struct ksmbd_file *ksmbd_file_get (struct ksmbd_file *fp);void ksmbd_fd_put (struct ksmbd_work *work,struct ksmbd_file *fp);struct ksmbd_inode *ksmbd_inode_lookup_lock (struct dentry *d);void ksmbd_inode_put (struct ksmbd_inode *ci);
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 3/7 ksmbd: fix malformed procfs status output
In reply to Namjae JeonThe ksmbd procfs monitoring files produce misleading or malformed output. The constant-name helper uses a bitwise test for enum values. This omits zero-valued constants and can print multiple names for one lease state. It also unconditionally emits a newline, splitting entries in the open-file table across two lines. Session capabilities are printed as numeric flag values even though a table of descriptive names is available.
Use exact matching for enum values. Print flag names as a comma-separated list, preserving unknown bits as hexadecimal values. Let callers control line termination so each open-file entry remains on one line. Print common session properties once, and report signing and encryption independently.
Adjust client and open-file column widths for IPv6 addresses and 64-bit file IDs, and fix the misspelled OPLOCK_EXCLUSIVE name. Also expose and maintain the total request count alongside the per-command counters.
--- fs/smb/server/connection.c | 12 ++--- fs/smb/server/mgmt/user_session.c | 75 +++++++++++++------------------ fs/smb/server/misc.h | 7 +-- fs/smb/server/proc.c | 38 ++++++++++++++++ fs/smb/server/stats.h | 4 +- fs/smb/server/vfs_cache.c | 16 ++++--- 6 files changed, 89 insertions(+), 63 deletions(-)
fs/smb/server/connection.c +6 -6
@@ -33,9 +33,9 @@ static int proc_show_clients(struct seq_file *m, void *v)struct timespec64 now, t;int i; -seq_printf (m,"#%-20s %-10s %-10s %-10s %-10s %-10s\n" , -"<name>" ,"<dialect>" ,"<credits>" ,"<open files>" , -"<requests>" ,"<last active>" ); +seq_printf (m,"#%-40s %-10s %-10s %-12s %-10s %s\n" , +"<client>" ,"<dialect>" ,"<credits>" ,"<open files>" , +"<requests>" ,"<last active>" );down_read (&conn_list_lock);hash_for_each (conn_list, i, conn, hlist) {
@@ -44,11 +44,11 @@ static int proc_show_clients(struct seq_file *m, void *v) t =timespec64_sub (now, t);#if IS_ENABLED (CONFIG_IPV6 )if (!conn->inet_addr) -seq_printf (m,"%-20pI6c" , &conn->inet6_addr); +seq_printf (m," %-40pI6c" , &conn->inet6_addr); else#endif -seq_printf (m,"%-20pI4" , &conn->inet_addr); - seq_printf(m, " 0x%-10x %-10u %-12d %-10d %ptT\n", +seq_printf (m," %-40pI4" , &conn->inet_addr); + seq_printf(m, " 0x%-8x %-10u %-12d %-10d %ptT\n", conn->dialect, conn->total_credits, atomic_read(&conn->stats.open_files_count),
fs/smb/server/mgmt/user_session.c +30 -45
103 lines not on this page · raw message
fs/smb/server/misc.h +2 -5
@@ -53,11 +53,8 @@ void ksmbd_proc_show_flag_names(struct seq_file *m,const struct ksmbd_const_name *table, int count, unsigned int flags); -void ksmbd_proc_show_const_name (struct seq_file *m, -const char *format, -const struct ksmbd_const_name *table, -int count, -unsigned int const_value); +const char *ksmbd_proc_const_name (const struct ksmbd_const_name *table, +int count,unsigned int const_value);#else static inline void ksmbd_proc_init (void ) {}static inline void ksmbd_proc_cleanup (void ) {}
fs/smb/server/proc.c +38 -0
@@ -27,6 +27,42 @@ struct proc_dir_entry *ksmbd_proc_create(const char *name, show, v); } +void ksmbd_proc_show_flag_names (struct seq_file *m, +const struct ksmbd_const_name *table, +int count,unsigned int flags) +{ +unsigned int remaining = flags; +bool separator = false; +int i; + +for (i =0 ; i < count; i++) { +unsigned int flag = table[i].const_value; + +if (!flag || (remaining & flag) != flag) +continue ; +seq_printf (m,"%s%s" , separator ?"," :"" , table[i].name); + separator = true; + remaining &= ~flag; + } + +if (remaining) +seq_printf (m,"%s0x%08x" , separator ?"," :"" , remaining); +else if (!separator) +seq_puts (m,"none" ); +} + +const char *ksmbd_proc_const_name (const struct ksmbd_const_name *table, +int count,unsigned int const_value) +{ +int i; + +for (i =0 ; i < count; i++) { +if (table[i].const_value == const_value) +return table[i].name; + } +return NULL ; +} +struct ksmbd_const_smb2_process_req {unsigned int const_value;const char *name;
@@ -71,6 +107,8 @@ static int proc_show_ksmbd_stats(struct seq_file *m, void *v) ksmbd_counter_sum(KSMBD_COUNTER_SESSIONS));seq_printf (m,"tree connects: %lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_TREE_CONNS )); +seq_printf (m,"requests: %lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_REQUESTS ));seq_printf (m,"read bytes: %lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_READ_BYTES )); seq_printf(m, "written bytes: %lld\n",
fs/smb/server/stats.h +3 -1
@@ -52,8 +52,10 @@ static inline void ksmbd_counter_sub(int type, s64 value)static inline void ksmbd_counter_inc_reqs (unsigned int cmd) { -if (cmd <KSMBD_COUNTER_MAX_REQS ) +if (cmd <KSMBD_COUNTER_MAX_REQS ) { +percpu_counter_inc (&ksmbd_counters.counters[KSMBD_COUNTER_REQUESTS ]);percpu_counter_inc (&ksmbd_counters.counters[KSMBD_COUNTER_FIRST_REQ + cmd]); + } }static inline s64 ksmbd_counter_sum (int type)
fs/smb/server/vfs_cache.c +10 -6
@@ -66,7 +66,7 @@ static const struct ksmbd_const_name ksmbd_lease_const_names[] = {static const struct ksmbd_const_name ksmbd_oplock_const_names[] = { {SMB2_OPLOCK_LEVEL_NONE ,"OPLOCK_NONE" }, {SMB2_OPLOCK_LEVEL_II ,"OPLOCK_II" }, - {SMB2_OPLOCK_LEVEL_EXCLUSIVE ,"OPLOCK_EXECL" }, + {SMB2_OPLOCK_LEVEL_EXCLUSIVE ,"OPLOCK_EXCLUSIVE" }, {SMB2_OPLOCK_LEVEL_BATCH ,"OPLOCK_BATCH" }, };
@@ -76,14 +76,14 @@ static int proc_show_files(struct seq_file *m, void *v)unsigned int id;struct oplock_info *opinfo; -seq_printf (m,"#%-10s %-10s %-10s %-10s %-15s %-10s %-10s %s\n" , +seq_printf (m,"#%-10s %-18s %-18s %-10s %-16s %-10s %-10s %s\n" ,"<tree id>" ,"<pid>" ,"<vid>" ,"<refcnt>" ,"<oplock>" ,"<daccess>" ,"<saccess>" ,"<name>" );read_lock (&global_ft.lock);idr_for_each_entry (global_ft.idr, fp, id) { - seq_printf(m, "%#-10x %#-10llx %#-10llx %#-10x", + seq_printf(m, " %#-10x %#-18llx %#-18llx %#-10x", fp->tcon ? fp->tcon->id : 0, fp->persistent_id, fp->volatile_id,
@@ -93,6 +93,7 @@ static int proc_show_files(struct seq_file *m, void *v) opinfo =rcu_dereference (fp->f_opinfo);if (opinfo) {const struct ksmbd_const_name *const_names; +const char *name;int count;unsigned int level;
@@ -106,11 +107,14 @@ static int proc_show_files(struct seq_file *m, void *v) level = opinfo->level; }rcu_read_unlock (); -ksmbd_proc_show_const_name (m," %-15s" , - const_names, count, level); + name =ksmbd_proc_const_name (const_names, count, level); +if (name) +seq_printf (m," %-16s" , name); +else +seq_printf (m," 0x%-14x" , level); }else {rcu_read_unlock (); -seq_printf (m," %-15s" ," " ); +seq_printf (m," %-16s" ," " ); } seq_printf(m, " %#010x %#010x %s\n",
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 4/7 ksmbd: expose connection runtime state in procfs
In reply to Namjae JeonThe clients proc file currently shows only a small subset of the state needed to diagnose stalled or mis-negotiated connections.
Report the transport, connection state, outstanding and total credits, session count, lifetime request count, and negotiated signing, encryption, compression, and POSIX features. Report each connection as a key/value record rather than a wide fixed-width table.
--- fs/smb/server/connection.c | 96 +++++++++++++++++++++++++++++++++----- 1 file changed, 84 insertions(+), 12 deletions(-)
fs/smb/server/connection.c +84 -12
@@ -27,33 +27,105 @@ DECLARE_RWSEM(conn_list_lock);#ifdef CONFIG_PROC_FS static struct proc_dir_entry *proc_clients; +static const char *ksmbd_conn_state_string (struct ksmbd_conn *conn) +{ +switch (READ_ONCE (conn->status)) { +case KSMBD_SESS_NEW : +return "new" ; +case KSMBD_SESS_GOOD : +return "good" ; +case KSMBD_SESS_EXITING : +return "exiting" ; +case KSMBD_SESS_NEED_RECONNECT : +return "reconnect" ; +case KSMBD_SESS_NEED_NEGOTIATE : +return "negotiate" ; +case KSMBD_SESS_NEED_SETUP : +return "setup" ; +case KSMBD_SESS_RELEASING : +return "releasing" ; +default : +return "unknown" ; + } +} + +static const char *ksmbd_conn_transport_string (struct ksmbd_conn *conn) +{ +if (conn->transport->ops->rdma_read || conn->transport->ops->rdma_write) +return "smbdirect" ; +return "tcp" ; +} + +static void proc_show_conn_feature (struct seq_file *m,bool *separator, +bool enabled,const char *name) +{ +if (!enabled) +return ; +seq_printf (m,"%s%s" , *separator ?"," :"" , name); + *separator = true; +} + +static void proc_show_conn_features (struct seq_file *m, +struct ksmbd_conn *conn) +{ +bool separator = false; + +proc_show_conn_feature (m, &separator, + conn->sign || conn->signing_negotiated,"sign" ); +proc_show_conn_feature (m, &separator, conn->cipher_type,"encrypt" ); +proc_show_conn_feature (m, &separator, + conn->compress_algorithm !=SMB3_COMPRESS_NONE , +"compress" ); +proc_show_conn_feature (m, &separator, conn->posix_ext_supported,"posix" ); +if (!separator) +seq_puts (m,"none" ); +} +static int proc_show_clients (struct seq_file *m,void *v) {struct ksmbd_conn *conn;struct timespec64 now, t;int i; -seq_printf (m,"#%-40s %-10s %-10s %-12s %-10s %s\n" , -"<client>" ,"<dialect>" ,"<credits>" ,"<open files>" , -"<requests>" ,"<last active>" ); -down_read (&conn_list_lock);hash_for_each (conn_list, i, conn, hlist) { +unsigned int outstanding_credits, total_credits; +unsigned long id; +void *entry; +unsigned int sessions =0 ; +jiffies_to_timespec64 (jiffies - conn->last_active, &t);ktime_get_real_ts64 (&now); t =timespec64_sub (now, t); + +spin_lock (&conn->credits_lock); + outstanding_credits = conn->outstanding_credits; + total_credits = conn->total_credits; +spin_unlock (&conn->credits_lock); + +rcu_read_lock (); +xa_for_each (&conn->sessions, id, entry) + sessions++; +rcu_read_unlock ();#if IS_ENABLED (CONFIG_IPV6 )if (!conn->inet_addr) -seq_printf (m," %-40pI6c" , &conn->inet6_addr); +seq_printf (m,"client:\t%pI6c\n" , &conn->inet6_addr); else#endif -seq_printf (m," %-40pI4" , &conn->inet_addr); -seq_printf (m," 0x%-8x %-10u %-12d %-10d %ptT\n" , - conn->dialect, - conn->total_credits, -atomic_read (&conn->stats.open_files_count), -atomic_read (&conn->req_running), - &t); +seq_printf (m,"client:\t%pI4\n" , &conn->inet_addr); +seq_printf (m,"transport:\t%s\n" ,ksmbd_conn_transport_string (conn)); +seq_printf (m,"state:\t%s\n" ,ksmbd_conn_state_string (conn)); +seq_printf (m,"dialect:\t0x%04x\n" , conn->dialect); +seq_printf (m,"credits:\t%u/%u\n" , outstanding_credits, + total_credits); +seq_printf (m,"sessions:\t%u\n" , sessions); +seq_printf (m,"open_files:\t%d\n" , +atomic_read (&conn->stats.open_files_count)); +seq_printf (m,"requests:\t%lld\n" , +atomic64_read (&conn->stats.request_served)); +seq_puts (m,"features:\t" ); +proc_show_conn_features (m, conn); +seq_printf (m,"\nlast_active:\t%ptT\n\n" , &t); }up_read (&conn_list_lock);return 0 ;
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 5/7 ksmbd: report session and open file details in procfs
In reply to Namjae JeonSession and file proc entries lack the state needed to correlate inactive sessions with durable or delete-pending opens.
Add the account type, dialect, idle time, open-file count, tree-connect count, and per-channel POSIX negotiation state to session entries. Extend the open-file table with the file state, durable timeout, create options, share access, and descriptive flags for durable, persistent, resilient, delete-on-close, stream, POSIX, and attribute-only opens.
--- fs/smb/server/mgmt/user_session.c | 82 ++++++++++++++++++++---------- fs/smb/server/vfs_cache.c | 84 +++++++++++++++++++++++++------ 2 files changed, 123 insertions(+), 43 deletions(-)
fs/smb/server/mgmt/user_session.c +55 -27
@@ -78,6 +78,28 @@ static const char *session_user_name(struct ksmbd_session *session)return session->user->name; } +static const char *session_account_type (struct ksmbd_session *session) +{ +if (user_guest (session->user)) +return "guest" ; +if (ksmbd_anonymous_user (session->user)) +return "anonymous" ; +return "user" ; +} + +static unsigned int session_open_file_count (struct ksmbd_session *session) +{ +struct ksmbd_file *fp; +unsigned int count =0 ; +unsigned int id; + +read_lock (&session->file_table.lock); +idr_for_each_entry (session->file_table.idr, fp, id) + count++; +read_unlock (&session->file_table.lock); +return count; +} +static int show_proc_session (struct seq_file *m,void *v) {struct ksmbd_session *sess;
@@ -90,9 +112,16 @@ static int show_proc_session(struct seq_file *m, void *v) sess = (struct ksmbd_session *)m->private;ksmbd_user_session_get (sess); -seq_printf (m,"%-20s\t%s\n" ,"user" ,session_user_name (sess)); -seq_printf (m,"%-20s\t%llu\n" ,"id" , sess->id); -seq_printf (m,"%-20s\t%s\n" ,"state" ,session_state_string (sess)); +seq_printf (m,"user:\t%s\n" ,session_user_name (sess)); +seq_printf (m,"account_type:\t%s\n" , +session_account_type (sess)); +seq_printf (m,"id:\t%llu\n" , sess->id); +seq_printf (m,"state:\t%s\n" ,session_state_string (sess)); +seq_printf (m,"dialect:\t0x%04x\n" , sess->dialect); +seq_printf (m,"last_active_seconds:\t%lu\n" , +jiffies_to_msecs (jiffies - sess->last_active) /MSEC_PER_SEC ); +seq_printf (m,"open_files:\t%u\n" , +session_open_file_count (sess)); i =0 ;down_read (&sess->chann_lock);
@@ -101,21 +130,23 @@ static int show_proc_session(struct seq_file *m, void *v)#if IS_ENABLED (CONFIG_IPV6 )if (chan->conn->inet_addr) -seq_printf (m,"%-20s\t%pI4\n" ,"client" , +seq_printf (m,"client:\t%pI4\n" , &chan->conn->inet_addr);else -seq_printf (m,"%-20s\t%pI6c\n" ,"client" , +seq_printf (m,"client:\t%pI6c\n" , &chan->conn->inet6_addr);#else -seq_printf (m,"%-20s\t%pI4\n" ,"client" , +seq_printf (m,"client:\t%pI4\n" , &chan->conn->inet_addr);#endif -seq_printf (m,"%-20s\t" ,"capabilities" ); +seq_puts (m,"capabilities:\t" );ksmbd_proc_show_flag_names (m, ksmbd_sess_cap_const_names,ARRAY_SIZE (ksmbd_sess_cap_const_names), chan->conn->vals->req_capabilities);seq_putc (m,'\n' ); +seq_printf (m,"posix_extensions:\t%s\n" , + chan->conn->posix_ext_supported ?"yes" :"no" );if (sess->sign) { unsigned int algorithm =
@@ -125,9 +156,9 @@ static int show_proc_session(struct seq_file *m, void *v)ARRAY_SIZE (ksmbd_signing_const_names), algorithm);if (name) -seq_printf (m,"%-20s\t%s\n" ,"signing" , name); +seq_printf (m,"signing:\t%s\n" , name);else -seq_printf (m,"%-20s\t0x%04x\n" ,"signing" , +seq_printf (m,"signing:\t0x%04x\n" , algorithm); }if (sess->enc) {
@@ -137,30 +168,30 @@ static int show_proc_session(struct seq_file *m, void *v)ARRAY_SIZE (ksmbd_cipher_const_names), cipher);if (name) -seq_printf (m,"%-20s\t%s\n" ,"encryption" , name); +seq_printf (m,"encryption:\t%s\n" , name);else -seq_printf (m,"%-20s\t0x%04x\n" ,"encryption" , +seq_printf (m,"encryption:\t0x%04x\n" , cipher); } i++; }up_read (&sess->chann_lock); -seq_printf (m,"%-20s\t%d\n" ,"channels" , i); +seq_printf (m,"channels:\t%d\n" , i); i =0 ;down_read (&sess->tree_conns_lock);xa_for_each (&sess->tree_conns, id, tree_conn) { share_conf = tree_conn->share_conf; -seq_printf (m,"%-20s\t%s\t%8d" ,"share" , - share_conf->name, tree_conn->id); -if (test_share_config_flag (share_conf,KSMBD_SHARE_FLAG_PIPE )) -seq_printf (m," %s " ,"pipe" ); -else -seq_printf (m," %s " ,"disk" ); -seq_putc (m,'\n' ); +seq_printf (m,"share:\t%s\n" , share_conf->name); +seq_printf (m,"tree_id:\t%d\n" , tree_conn->id); +seq_printf (m,"share_type:\t%s\n" , +test_share_config_flag (share_conf,KSMBD_SHARE_FLAG_PIPE ) ? +"pipe" :"disk" ); + i++; }up_read (&sess->tree_conns_lock); +seq_printf (m,"tree_connects:\t%d\n" , i);ksmbd_user_session_put (sess);return 0 ;
@@ -189,9 +220,6 @@ static int show_proc_sessions(struct seq_file *m, void *v)int i;unsigned long id; -seq_printf (m,"#%-40s %-15s %-10s %-10s\n" , -"<client>" ,"<user>" ,"<sess_id>" ,"<state>" ); -down_read (&sessions_table_lock);hash_for_each (sessions_table, i, session, hlist) {down_read (&session->chann_lock);
@@ -201,13 +229,13 @@ static int show_proc_sessions(struct seq_file *m, void *v)#if IS_ENABLED (CONFIG_IPV6 )if (!chan->conn->inet_addr) -seq_printf (m," %-40pI6c" , &chan->conn->inet6_addr); +seq_printf (m,"client:\t%pI6c\n" , &chan->conn->inet6_addr); else#endif -seq_printf (m," %-40pI4" , &chan->conn->inet_addr); -seq_printf (m," %-15s %-10llu %-10s\n" , -session_user_name (session), - session->id, +seq_printf (m,"client:\t%pI4\n" , &chan->conn->inet_addr); +seq_printf (m,"user:\t%s\n" ,session_user_name (session)); +seq_printf (m,"id:\t%llu\n" , session->id); +seq_printf (m,"state:\t%s\n\n" ,session_state_string (session));ksmbd_user_session_put (session);
fs/smb/server/vfs_cache.c +68 -16
109 lines not on this page · raw message
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 6/7 ksmbd: add procfs monitoring for active shares
In reply to Namjae JeonThere is no kernel-side view of the share configurations currently cached by active tree connections.
Add a shares proc entry that reports each active share name, type, tree-connection count, create masks, and descriptive configuration flags. Maintain a per-share tree-connection counter with the existing global counter so the value can be read without walking every session.
--- fs/smb/server/mgmt/share_config.c | 57 +++++++++++++++++++++++++++++++ fs/smb/server/mgmt/share_config.h | 25 ++++++++++++++ fs/smb/server/mgmt/tree_connect.c | 2 ++ fs/smb/server/server.c | 1 + 4 files changed, 85 insertions(+)
fs/smb/server/mgmt/share_config.c +57 -0
@@ -28,6 +28,62 @@ struct ksmbd_veto_pattern {struct list_head list; }; +#ifdef CONFIG_PROC_FS +static const struct ksmbd_const_name ksmbd_share_flag_names[] = { + {KSMBD_SHARE_FLAG_AVAILABLE ,"available" }, + {KSMBD_SHARE_FLAG_BROWSEABLE ,"browseable" }, + {KSMBD_SHARE_FLAG_WRITEABLE ,"writeable" }, + {KSMBD_SHARE_FLAG_READONLY ,"read-only" }, + {KSMBD_SHARE_FLAG_GUEST_OK ,"guest-ok" }, + {KSMBD_SHARE_FLAG_GUEST_ONLY ,"guest-only" }, + {KSMBD_SHARE_FLAG_STORE_DOS_ATTRS ,"store-dos-attrs" }, + {KSMBD_SHARE_FLAG_OPLOCKS ,"oplocks" }, + {KSMBD_SHARE_FLAG_PIPE ,"pipe" }, + {KSMBD_SHARE_FLAG_HIDE_DOT_FILES ,"hide-dot-files" }, + {KSMBD_SHARE_FLAG_INHERIT_OWNER ,"inherit-owner" }, + {KSMBD_SHARE_FLAG_STREAMS ,"streams" }, + {KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS ,"follow-symlinks" }, + {KSMBD_SHARE_FLAG_ACL_XATTR ,"acl-xattr" }, + {KSMBD_SHARE_FLAG_UPDATE ,"update" }, + {KSMBD_SHARE_FLAG_CROSSMNT ,"crossmnt" }, + {KSMBD_SHARE_FLAG_CONTINUOUS_AVAILABILITY ,"continuous-availability" }, +}; + +static int proc_show_shares (struct seq_file *m,void *v) +{ +struct ksmbd_share_config *share; +int i; + +down_read (&shares_table_lock); +hash_for_each (shares_table, i, share, hlist) { +seq_printf (m,"name:\t%s\n" , share->name); +seq_printf (m,"type:\t%s\n" , +test_share_config_flag (share,KSMBD_SHARE_FLAG_PIPE ) ? +"pipe" :"disk" ); +seq_printf (m,"tree_connects:\t%d\n" , +atomic_read (&share->tree_connections)); +seq_printf (m,"file_mask:\t0%07o\n" , share->create_mask); +seq_printf (m,"directory_mask:\t0%07o\n" , share->directory_mask); +seq_puts (m,"flags:\t" ); +ksmbd_proc_show_flag_names (m, ksmbd_share_flag_names, +ARRAY_SIZE (ksmbd_share_flag_names), + share->flags); +seq_puts (m,"\n\n" ); + } +up_read (&shares_table_lock); +return 0 ; +} + +int create_proc_shares (void ) +{ +if (!ksmbd_proc_create ("shares" , proc_show_shares,NULL )) +return -ENOMEM ; +return 0 ; +} +#else +int create_proc_shares (void ) {return 0 ; } +#endif +static unsigned int share_name_hash (const char *name) {return jhash (name,strlen (name),0 );
@@ -156,6 +212,7 @@ static struct ksmbd_share_config *share_config_request(struct ksmbd_work *work, share->flags = resp->flags;atomic_set (&share->refcount,1 ); +ksmbd_share_tree_conn_init (share);INIT_LIST_HEAD (&share->veto_list); share->name =kstrdup (name,KSMBD_DEFAULT_GFP );
fs/smb/server/mgmt/share_config.h +25 -0
@@ -24,6 +24,9 @@ struct ksmbd_share_config {struct path vfs_path;atomic_t refcount; +#ifdef CONFIG_PROC_FS +atomic_t tree_connections; +#endif struct hlist_node hlist;unsigned short create_mask;unsigned short directory_mask;
@@ -60,6 +63,27 @@ static inline int test_share_config_flag(struct ksmbd_share_config *share,return share->flags & flag; } +#ifdef CONFIG_PROC_FS +static inline void ksmbd_share_tree_conn_init (struct ksmbd_share_config *share) +{ +atomic_set (&share->tree_connections,0 ); +} + +static inline void ksmbd_share_tree_conn_inc (struct ksmbd_share_config *share) +{ +atomic_inc (&share->tree_connections); +} + +static inline void ksmbd_share_tree_conn_dec (struct ksmbd_share_config *share) +{ +atomic_dec (&share->tree_connections); +} +#else +static inline void ksmbd_share_tree_conn_init (struct ksmbd_share_config *share) {} +static inline void ksmbd_share_tree_conn_inc (struct ksmbd_share_config *share) {} +static inline void ksmbd_share_tree_conn_dec (struct ksmbd_share_config *share) {} +#endif +void ksmbd_share_config_del (struct ksmbd_share_config *share);void __ksmbd_share_config_put (struct ksmbd_share_config *share);
@@ -74,4 +98,5 @@ struct ksmbd_share_config *ksmbd_share_config_get(struct ksmbd_work *work, const char *name);bool ksmbd_share_veto_filename (struct ksmbd_share_config *share,const char *filename); +int create_proc_shares (void );#endif /* __SHARE_CONFIG_MANAGEMENT_H__ */
fs/smb/server/mgmt/tree_connect.c +2 -0
@@ -88,6 +88,7 @@ ksmbd_tree_conn_connect(struct ksmbd_work *work, const char *share_name) goto out_error; }ksmbd_counter_inc (KSMBD_COUNTER_TREE_CONNS ); +ksmbd_share_tree_conn_inc (sc);kvfree (resp);return status;
@@ -116,6 +117,7 @@ static int __ksmbd_tree_conn_disconnect(struct ksmbd_session *sess, ret =ksmbd_ipc_tree_disconnect_request (sess->id, tree_conn->id);ksmbd_release_tree_conn_id (sess, tree_conn->id);ksmbd_counter_dec (KSMBD_COUNTER_TREE_CONNS ); +ksmbd_share_tree_conn_dec (tree_conn->share_conf);if (atomic_dec_and_test (&tree_conn->refcount)) {ksmbd_share_config_put (tree_conn->share_conf);kfree (tree_conn);
fs/smb/server/server.c +1 -0
@@ -604,6 +604,7 @@ static int __init ksmbd_server_init(void)ksmbd_proc_init ();create_proc_sessions (); +create_proc_shares ();ksmbd_server_tcp_callbacks_init ();
Signature · 1 line
2.25.1
Namjae Jeon
maintainerPATCH 7/7 ksmbd: extend procfs server statistics
In reply to Namjae JeonThe server proc entry does not expose configured limits or enough outcome data to distinguish protocol errors from transport stalls.
Report the server state, listener and signing configuration, connection limits, timeout values, current client and open-file totals, IPC activity, and durable scavenger state. Classify processed SMB2 response statuses by NTSTATUS severity and provide counters for common error groups while retaining the per-command counters.
--- fs/smb/server/proc.c | 121 +++++++++++++++++++++++++++++++++---- fs/smb/server/server.c | 7 ++- fs/smb/server/smb_common.h | 2 +- fs/smb/server/stats.h | 53 +++++++++++++++- fs/smb/server/vfs_cache.c | 10 +++ fs/smb/server/vfs_cache.h | 1 + 6 files changed, 176 insertions(+), 18 deletions(-)
fs/smb/server/proc.c +108 -13
@@ -11,10 +11,12 @@#include <linux/seq_file.h> #include "misc.h" +#include "connection.h" #include "server.h" #include "stats.h" #include "smb_common.h" #include "smb2pdu.h" +#include "vfs_cache.h" static struct proc_dir_entry *ksmbd_proc_fs;struct ksmbd_counters ksmbd_counters;
@@ -90,34 +92,127 @@ static const struct ksmbd_const_smb2_process_req smb2_process_req[KSMBD_COUNTER_ {le16_to_cpu(SMB2_OPLOCK_BREAK), "SMB2_OPLOCK_BREAK"}, }; +static const char *ksmbd_server_state_string (void ) +{ +switch (READ_ONCE (server_conf.state)) { +case SERVER_STATE_STARTING_UP : +return "starting" ; +case SERVER_STATE_RUNNING : +return "running" ; +case SERVER_STATE_RESETTING : +return "resetting" ; +case SERVER_STATE_SHUTTING_DOWN : +return "shutdown" ; +default : +return "unknown" ; + } +} + +static const char *ksmbd_signing_mode_string (void ) +{ +switch (server_conf.signing) { +case KSMBD_CONFIG_OPT_DISABLED : +return "disabled" ; +case KSMBD_CONFIG_OPT_MANDATORY : +return "mandatory" ; +case KSMBD_CONFIG_OPT_AUTO : +return "auto" ; +default : +return "unknown" ; + } +} + +static void proc_show_runtime_totals (struct seq_file *m) +{ +struct ksmbd_conn *conn; +unsigned int clients =0 ; +unsigned int open_files =0 ; +int i; + +down_read (&conn_list_lock); +hash_for_each (conn_list, i, conn, hlist) { + clients++; + open_files +=atomic_read (&conn->stats.open_files_count); + } +up_read (&conn_list_lock); + +seq_printf (m,"clients:\t%u\n" , clients); +seq_printf (m,"open_files:\t%u\n" , open_files); +} +static int proc_show_ksmbd_stats (struct seq_file *m,void *v) {int i;seq_puts (m,"Server\n" ); -seq_printf (m,"name: %s\n" ,ksmbd_server_string ()); -seq_printf (m,"netbios: %s\n" ,ksmbd_netbios_name ()); -seq_printf (m,"work group: %s\n" ,ksmbd_work_group ()); -seq_printf (m,"min protocol: %s\n" ,ksmbd_get_protocol_string (server_conf.min_protocol)); -seq_printf (m,"max protocol: %s\n" ,ksmbd_get_protocol_string (server_conf.max_protocol)); -seq_printf (m,"flags: 0x%08x\n" , server_conf.flags); -seq_printf (m,"share_fake_fscaps: 0x%08x\n" , +seq_printf (m,"state:\t%s\n" ,ksmbd_server_state_string ()); +seq_printf (m,"name:\t%s\n" ,ksmbd_server_string ()); +seq_printf (m,"netbios:\t%s\n" ,ksmbd_netbios_name ()); +seq_printf (m,"work_group:\t%s\n" ,ksmbd_work_group ()); +seq_printf (m,"min_protocol:\t%s\n" ,ksmbd_get_protocol_string (server_conf.min_protocol)); +seq_printf (m,"max_protocol:\t%s\n" ,ksmbd_get_protocol_string (server_conf.max_protocol)); +seq_printf (m,"flags:\t0x%08x\n" , server_conf.flags); +seq_printf (m,"tcp_port:\t%u\n" , server_conf.tcp_port); +seq_printf (m,"signing:\t%s\n" ,ksmbd_signing_mode_string ()); +seq_printf (m,"signing_enforced:\t%s\n" , + server_conf.enforced_signing ?"yes" :"no" ); +seq_printf (m,"bind_interfaces_only:\t%s\n" , + server_conf.bind_interfaces_only ?"yes" :"no" ); +seq_printf (m,"max_connections:\t%u\n" , server_conf.max_connections); +seq_printf (m,"max_connections_per_ip:\t%u\n" , + server_conf.max_ip_connections); +seq_printf (m,"max_inflight_requests:\t%u\n" , + server_conf.max_inflight_req); +seq_printf (m,"deadtime_seconds:\t%lu\n" , server_conf.deadtime /HZ ); +seq_printf (m,"ipc_timeout_seconds:\t%u\n" , server_conf.ipc_timeout /HZ ); +if (server_conf.ipc_last_active) +seq_printf (m,"ipc_last_active_seconds:\t%lu\n" , +jiffies_to_msecs (jiffies - server_conf.ipc_last_active) / +MSEC_PER_SEC ); +else +seq_puts (m,"ipc_last_active_seconds:\tnever\n" ); +seq_printf (m,"durable_scavenger:\t%s\n" , +ksmbd_durable_scavenger_active () ?"running" :"stopped" ); +seq_printf (m,"share_fake_fscaps:\t0x%08x\n" , server_conf.share_fake_fscaps); -seq_printf (m,"sessions: %lld\n" , +proc_show_runtime_totals (m); +seq_printf (m,"sessions:\t%lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_SESSIONS )); -seq_printf (m,"tree connects: %lld\n" , +seq_printf (m,"tree_connects:\t%lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_TREE_CONNS )); -seq_printf (m,"requests: %lld\n" , +seq_printf (m,"requests:\t%lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_REQUESTS )); -seq_printf (m,"read bytes: %lld\n" , +seq_printf (m,"read_bytes:\t%lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_READ_BYTES )); -seq_printf (m,"written bytes: %lld\n" , +seq_printf (m,"written_bytes:\t%lld\n" ,ksmbd_counter_sum (KSMBD_COUNTER_WRITE_BYTES ));seq_puts (m,"\nSMB2\n" );for (i =0 ; i <KSMBD_COUNTER_MAX_REQS ; i++) -seq_printf (m,"%-20s:\t%lld\n" , smb2_process_req[i].name, +seq_printf (m,"%s:\t%lld\n" , smb2_process_req[i].name,ksmbd_counter_sum (KSMBD_COUNTER_FIRST_REQ + i)); + +seq_puts (m,"\nSMB2 status\n" ); +seq_printf (m,"success:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_STATUS_SUCCESS )); +seq_printf (m,"informational:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_STATUS_INFORMATIONAL )); +seq_printf (m,"warning:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_STATUS_WARNING )); +seq_printf (m,"error:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_STATUS_ERROR )); +seq_printf (m,"access_denied:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_ERROR_ACCESS_DENIED )); +seq_printf (m,"not_found:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_ERROR_NOT_FOUND )); +seq_printf (m,"invalid_parameter:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_ERROR_INVALID_PARAMETER )); +seq_printf (m,"sharing_violation:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_ERROR_SHARING_VIOLATION )); +seq_printf (m,"not_supported:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_ERROR_NOT_SUPPORTED )); +seq_printf (m,"other:\t%lld\n" , +ksmbd_counter_sum (KSMBD_COUNTER_ERROR_OTHER ));return 0 ; }
fs/smb/server/server.c +5 -2
@@ -148,8 +148,11 @@ static int __process_request(struct ksmbd_work *work, struct ksmbd_conn *conn, } ret = cmds->proc (work); -if (conn->ops->inc_reqs) - conn->ops->inc_reqs (command); +if (conn->ops->inc_reqs) { +struct smb2_hdr *rsp =ksmbd_resp_buf_curr (work); + + conn->ops->inc_reqs (command, rsp->Status); + }if (ret <0 )ksmbd_debug (CONN ,"Failed to process %u [%d]\n" , command, ret);
fs/smb/server/smb_common.h +1 -1
@@ -135,7 +135,7 @@ struct file_id_both_directory_info {struct smb_version_ops {u16 (*get_cmd_val)(struct ksmbd_work *swork); -void (*inc_reqs)(unsigned int cmd); +void (*inc_reqs)(unsigned int cmd,__le32 status);int (*init_rsp_hdr)(struct ksmbd_work *swork);void (*set_rsp_status)(struct ksmbd_work *swork,__le32 err);int (*allocate_rsp_buf)(struct ksmbd_work *work);
fs/smb/server/stats.h +51 -2
78 lines not on this page · raw message
fs/smb/server/vfs_cache.c +10 -0
@@ -191,6 +191,16 @@ static bool durable_scavenger_running;static DEFINE_MUTEX (durable_scavenger_lock);static wait_queue_head_t dh_wq; +bool ksmbd_durable_scavenger_active (void ) +{ +bool active; + +mutex_lock (&durable_scavenger_lock); + active = durable_scavenger_running; +mutex_unlock (&durable_scavenger_lock); +return active; +} +void ksmbd_set_fd_limit (unsigned long limit) { limit =min (limit,get_max_files ());
fs/smb/server/vfs_cache.h +1 -0
@@ -216,6 +216,7 @@ unsigned int ksmbd_open_durable_fd(struct ksmbd_file *fp);struct ksmbd_file *ksmbd_open_fd (struct ksmbd_work *work,struct file *filp);void ksmbd_launch_ksmbd_durable_scavenger (void );void ksmbd_stop_durable_scavenger (void ); +bool ksmbd_durable_scavenger_active (void );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);
Signature · 1 line
2.25.1