cifs.ko fixes
Subsystems (3)
cover cifs.ko fixes
Hi Steve,
Follow a series of bugfixes that were mostly found by doing some stress testing over the reconnect paths. I was able to find most of the issues by hard-coding the DFS cache ttl to 10 seconds which made it running several times on every reconnect test.
Please review and test.
Paulo Alcantara (7):
cifs: fix potential race when tree connecting ipc
cifs: fix potential use-after-free bugs in TCP_Server_Info::hostname
cifs: protect session status check in smb2_reconnect()
cifs: protect access of TCP_Server_Info::{origin,leaf}_fullpath
cifs: print smb3_fs_context::source when mounting
cifs: avoid potential races when handling multiple dfs tcons
cifs: fix sharing of DFS connections
fs/cifs/cifs_debug.c | 7 ++- fs/cifs/cifs_debug.h | 12 ++-- fs/cifs/cifsfs.c | 14 ++--- fs/cifs/cifsglob.h | 23 ++++--- fs/cifs/cifsproto.h | 44 ++++++++++++- fs/cifs/connect.c | 145 ++++++++++++++++++++++++------------------- fs/cifs/dfs.c | 137 ++++++++++++++++++++++++++++++---------- fs/cifs/dfs.h | 13 +++- fs/cifs/dfs_cache.c | 137 ++++++++++++++++++---------------------- fs/cifs/dfs_cache.h | 9 +++ fs/cifs/ioctl.c | 2 +- fs/cifs/sess.c | 7 ++- fs/cifs/smb2pdu.c | 19 ++++-- 13 files changed, 360 insertions(+), 209 deletions(-)
Signature · 1 line
2.40.1
PATCH 1/7 cifs: fix potential race when tree connecting ipc
Protect access of TCP_Server_Info::hostname when building the ipc tree name as it might get freed in cifsd thread and thus causing an use-after-free bug in __tree_connect_dfs_target(). Also, while at it, update status of IPC tcon on success and then avoid any extra tree connects.
--- fs/cifs/dfs.c | 57 ++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 50 insertions(+), 7 deletions(-)
fs/cifs/dfs.c +50 -7
@@ -374,6 +374,54 @@ static int target_share_matches_server(struct TCP_Server_Info *server, char *shareturn rc; } +static void __tree_connect_ipc (const unsigned int xid,char *tree, +struct cifs_sb_info *cifs_sb, +struct cifs_ses *ses) +{ +struct TCP_Server_Info *server = ses->server; +struct cifs_tcon *tcon = ses->tcon_ipc; +int rc; + +spin_lock (&ses->ses_lock); +spin_lock (&ses->chan_lock); +if (cifs_chan_needs_reconnect (ses, server) || + ses->ses_status !=SES_GOOD ) { +spin_unlock (&ses->chan_lock); +spin_unlock (&ses->ses_lock); +cifs_server_dbg (FYI ,"%s: skipping ipc reconnect due to disconnected ses\n" , + __func__); +return ; + } +spin_unlock (&ses->chan_lock); +spin_unlock (&ses->ses_lock); + +cifs_server_lock (server); +scnprintf (tree,MAX_TREE_SIZE ,"\\\\%s\\IPC$" , server->hostname); +cifs_server_unlock (server); + + rc = server->ops->tree_connect (xid, ses, tree, tcon, + cifs_sb->local_nls); +cifs_server_dbg (FYI ,"%s: tree_reconnect %s: %d\n" , __func__, tree, rc); +spin_lock (&tcon->tc_lock); +if (rc) { + tcon->status =TID_NEED_TCON ; + }else { + tcon->status =TID_GOOD ; + tcon->need_reconnect = false; + } +spin_unlock (&tcon->tc_lock); +} + +static void tree_connect_ipc (const unsigned int xid,char *tree, +struct cifs_sb_info *cifs_sb, +struct cifs_tcon *tcon) +{ +struct cifs_ses *ses = tcon->ses; + +__tree_connect_ipc (xid, tree, cifs_sb, ses); +__tree_connect_ipc (xid, tree, cifs_sb,CIFS_DFS_ROOT_SES (ses)); +} +static int __tree_connect_dfs_target (const unsigned int xid,struct cifs_tcon *tcon,struct cifs_sb_info *cifs_sb,char *tree,bool islink,struct dfs_cache_tgt_list *tl)
@@ -382,7 +430,6 @@ static int __tree_connect_dfs_target(const unsigned int xid, struct cifs_tcon *tstruct TCP_Server_Info *server = tcon->ses->server;const struct smb_version_operations *ops = server->ops;struct cifs_ses *root_ses =CIFS_DFS_ROOT_SES (tcon->ses); -struct cifs_tcon *ipc = root_ses->tcon_ipc;char *share =NULL , *prefix =NULL ;struct dfs_cache_tgt_iterator *tit;bool target_match;
@@ -418,18 +465,14 @@ static int __tree_connect_dfs_target(const unsigned int xid, struct cifs_tcon *t }dfs_cache_noreq_update_tgthint (server->current_fullpath +1 , tit); - -if (ipc->need_reconnect) { -scnprintf (tree,MAX_TREE_SIZE ,"\\\\%s\\IPC$" , server->hostname); - rc = ops->tree_connect (xid, ipc->ses, tree, ipc, cifs_sb->local_nls); -cifs_dbg (FYI ,"%s: reconnect ipc: %d\n" , __func__, rc); - } +tree_connect_ipc (xid, tree, cifs_sb, tcon);scnprintf (tree,MAX_TREE_SIZE ,"\\%s" , share);if (!islink) { rc = ops->tree_connect (xid, tcon->ses, tree, tcon, cifs_sb->local_nls);break ; } +/* * If no dfs referrals were returned from link target, then just do a TREE_CONNECT * to it. Otherwise, cache the dfs referral and then mark current tcp ses for
Signature · 1 line
2.40.1
PATCH 2/7 cifs: fix potential use-after-free bugs in TCP_Server_Info::hostname
In reply to Paulo AlcantaraTCP_Server_Info::hostname may be updated once or many times during reconnect, so protect its access outside reconnect path as well and then prevent any potential use-after-free bugs.
--- fs/cifs/cifs_debug.c | 7 ++++++- fs/cifs/cifs_debug.h | 12 ++++++------ fs/cifs/connect.c | 10 +++++++--- fs/cifs/sess.c | 7 ++++--- 4 files changed, 23 insertions(+), 13 deletions(-)
fs/cifs/cifs_debug.c +6 -1
@@ -280,8 +280,10 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)seq_printf (m,"\n%d) ConnectionId: 0x%llx " , c, server->conn_id); +spin_lock (&server->srv_lock);if (server->hostname)seq_printf (m,"Hostname: %s " , server->hostname); +spin_unlock (&server->srv_lock);#ifdef CONFIG_CIFS_SMB_DIRECT if (!server->rdma) goto skip_rdma;
@@ -623,10 +625,13 @@ static int cifs_stats_proc_show(struct seq_file *m, void *v) server->fastest_cmd[j], server->slowest_cmd[j]);for (j =0 ; j <NUMBER_OF_SMB2_COMMANDS ; j++) -if (atomic_read (&server->smb2slowcmd[j])) +if (atomic_read (&server->smb2slowcmd[j])) { +spin_lock (&server->srv_lock);seq_printf (m," %d slow responses from %s for command %d\n" ,atomic_read (&server->smb2slowcmd[j]), server->hostname, j); +spin_unlock (&server->srv_lock); + }#endif /* STATS2 */ list_for_each_entry (ses, &server->smb_ses_list, smb_ses_list) {list_for_each_entry (tcon, &ses->tcon_list, tcon_list) {
fs/cifs/cifs_debug.h +6 -6
@@ -81,19 +81,19 @@ do { \#define cifs_server_dbg_func (ratefunc, type, fmt, ...) \ do { \ - const char *sn = ""; \ - if (server && server->hostname) \ - sn = server->hostname; \ + spin_lock(&server->srv_lock); \ if ((type) & FYI && cifsFYI & CIFS_INFO) { \ pr_debug_ ## ratefunc("%s: \\\\%s " fmt, \ - __FILE__, sn, ##__VA_ARGS__); \ + __FILE__, server->hostname, \ + ##__VA_ARGS__); \ } else if ((type) & VFS) { \ pr_err_ ## ratefunc("VFS: \\\\%s " fmt, \ - sn, ##__VA_ARGS__); \ + server->hostname, ##__VA_ARGS__); \ } else if ((type) & NOISY && (NOISY != 0)) { \ pr_debug_ ## ratefunc("\\\\%s " fmt, \ - sn, ##__VA_ARGS__); \ + server->hostname, ##__VA_ARGS__); \ } \ + spin_unlock(&server->srv_lock); \ } while (0)#define cifs_server_dbg (type, fmt, ...) \
fs/cifs/connect.c +7 -3
@@ -403,8 +403,10 @@ static int __reconnect_target_unlocked(struct TCP_Server_Info *server, const chaif (server->hostname != target) { hostname =extract_hostname (target);if (!IS_ERR (hostname)) { +spin_lock (&server->srv_lock);kfree (server->hostname); server->hostname = hostname; +spin_unlock (&server->srv_lock); }else {cifs_dbg (FYI ,"%s: couldn't extract hostname or address from dfs target: %ld\n" , __func__,PTR_ERR (hostname));
@@ -561,9 +563,7 @@ cifs_echo_request(struct work_struct *work) goto requeue_echo; rc = server->ops->echo ? server->ops->echo (server) : -ENOSYS ; -if (rc) -cifs_dbg (FYI ,"Unable to send echo request to server: %s\n" , - server->hostname); +cifs_server_dbg (FYI ,"send echo request: rc = %d\n" , rc);/* Check witness registrations */ cifs_swn_check ();
@@ -1404,6 +1404,8 @@ static int match_server(struct TCP_Server_Info *server, struct smb3_fs_context * {struct sockaddr *addr = (struct sockaddr *)&ctx->dstaddr; +lockdep_assert_held (&server->srv_lock); +if (ctx->nosharesock)return 0 ;
@@ -1810,7 +1812,9 @@ cifs_setup_ipc(struct cifs_ses *ses, struct smb3_fs_context *ctx)if (tcon ==NULL )return -ENOMEM ; +spin_lock (&server->srv_lock);scnprintf (unc,sizeof (unc),"\\\\%s\\IPC$" , server->hostname); +spin_unlock (&server->srv_lock); xid =get_xid (); tcon->ses = ses;
fs/cifs/sess.c +4 -3
@@ -159,6 +159,7 @@ cifs_chan_is_iface_active(struct cifs_ses *ses,/* returns number of channels added */ int cifs_try_adding_channels (struct cifs_sb_info *cifs_sb,struct cifs_ses *ses) { +struct TCP_Server_Info *server = ses->server;int old_chan_count, new_chan_count;int left;int rc =0 ;
@@ -178,16 +179,16 @@ int cifs_try_adding_channels(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses)return 0 ; } -if (ses->server->dialect <SMB30_PROT_ID ) { +if (server->dialect <SMB30_PROT_ID ) {spin_unlock (&ses->chan_lock);cifs_dbg (VFS ,"multichannel is not supported on this protocol version, use 3.0 or above\n" );return 0 ; } -if (!(ses->server->capabilities &SMB2_GLOBAL_CAP_MULTI_CHANNEL )) { +if (!(server->capabilities &SMB2_GLOBAL_CAP_MULTI_CHANNEL )) { ses->chan_max =1 ;spin_unlock (&ses->chan_lock); -cifs_dbg (VFS ,"server %s does not support multichannel\n" , ses->server->hostname); +cifs_server_dbg (VFS ,"no multichannel support\n" );return 0 ; }spin_unlock (&ses->chan_lock);
Signature · 1 line
2.40.1
PATCH 3/7 cifs: protect session status check in smb2_reconnect()
In reply to Paulo AlcantaraUse @ses->ses_lock to protect access of @ses->ses_status.
--- fs/cifs/smb2pdu.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
fs/cifs/smb2pdu.c +11 -4
@@ -175,8 +175,17 @@ smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon, } }spin_unlock (&tcon->tc_lock); -if ((!tcon->ses) || (tcon->ses->ses_status ==SES_EXITING ) || - (!tcon->ses->server) || !server) + + ses = tcon->ses; +if (!ses) +return -EIO ; +spin_lock (&ses->ses_lock); +if (ses->ses_status ==SES_EXITING ) { +spin_unlock (&ses->ses_lock); +return -EIO ; + } +spin_unlock (&ses->ses_lock); +if (!ses->server || !server)return -EIO ;spin_lock (&server->srv_lock);
@@ -204,8 +213,6 @@ smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon,if (rc)return rc; - ses = tcon->ses; -spin_lock (&ses->chan_lock);if (!cifs_chan_needs_reconnect (ses, server) && !tcon->need_reconnect) {spin_unlock (&ses->chan_lock);
Signature · 1 line
2.40.1
PATCH 4/7 cifs: protect access of TCP_Server_Info::{origin,leaf}_fullpath
In reply to Paulo AlcantaraProtect access of TCP_Server_Info::{origin,leaf}_fullpath when matching DFS connections, and get rid of TCP_Server_Info::current_fullpath while we're at it.
--- fs/cifs/cifsglob.h | 20 +++++++++++++------- fs/cifs/connect.c | 10 ++++++---- fs/cifs/dfs.c | 14 ++++++++------ fs/cifs/dfs.h | 13 +++++++++++-- fs/cifs/dfs_cache.c | 6 +++++- 5 files changed, 43 insertions(+), 20 deletions(-)
fs/cifs/cifsglob.h +13 -7
@@ -736,17 +736,23 @@ struct TCP_Server_Info {#endif struct mutex refpath_lock;/* protects leaf_fullpath */ /* -* Canonical DFS full paths that were used to chase referrals in mount and reconnect. +* origin_fullpath: Canonical copy of smb3_fs_context::source. +* It is used for matching existing DFS tcons. * -* origin_fullpath: first or original referral path -* leaf_fullpath: last referral path (might be changed due to nested links in reconnect) +* leaf_fullpath: Canonical DFS referral path related to this +* connection. +* It is used in DFS cache refresher, reconnect and may +* change due to nested DFS links. * -* current_fullpath: pointer to either origin_fullpath or leaf_fullpath -* NOTE: cannot be accessed outside cifs_reconnect() and smb2_reconnect() +* Both protected by @refpath_lock and @srv_lock. The @refpath_lock is +* mosly used for not requiring a copy of @leaf_fullpath when getting +* cached or new DFS referrals (which might also sleep during I/O). +* While @srv_lock is held for making string and NULL comparions against +* both fields as in mount(2) and cache refresh. * -* format: \\HOST\SHARE\[OPTIONAL PATH] +* format: \\HOST\SHARE[\OPTIONAL PATH] */ -char *origin_fullpath, *leaf_fullpath, *current_fullpath; +char *origin_fullpath, *leaf_fullpath; };static inline bool is_smb1 (struct TCP_Server_Info *server)
fs/cifs/connect.c +6 -4
@@ -454,7 +454,6 @@ static int reconnect_target_unlocked(struct TCP_Server_Info *server, struct dfs_static int reconnect_dfs_server (struct TCP_Server_Info *server) {int rc =0 ; -const char *refpath = server->current_fullpath +1 ;struct dfs_cache_tgt_list tl =DFS_CACHE_TGT_LIST_INIT (tl);struct dfs_cache_tgt_iterator *target_hint =NULL ;int num_targets =0 ;
@@ -467,8 +466,10 @@ static int reconnect_dfs_server(struct TCP_Server_Info *server)* through /proc/fs/cifs/dfscache or the target list is empty due to server settings after * refreshing the referral, so, in this case, default it to 1. */ -if (!dfs_cache_noreq_find (refpath,NULL , &tl)) +mutex_lock (&server->refpath_lock); +if (!dfs_cache_noreq_find (server->leaf_fullpath +1 ,NULL , &tl)) num_targets =dfs_cache_get_nr_tgts (&tl); +mutex_unlock (&server->refpath_lock);if (!num_targets) num_targets =1 ;
@@ -512,7 +513,9 @@ static int reconnect_dfs_server(struct TCP_Server_Info *server)mod_delayed_work (cifsiod_wq, &server->reconnect,0 ); }while (server->tcpStatus == CifsNeedReconnect); -dfs_cache_noreq_update_tgthint (refpath, target_hint); +mutex_lock (&server->refpath_lock); +dfs_cache_noreq_update_tgthint (server->leaf_fullpath +1 , target_hint); +mutex_unlock (&server->refpath_lock);dfs_cache_free_tgts (&tl);/* Need to set up echo worker again once connection has been established */
@@ -1582,7 +1585,6 @@ cifs_get_tcp_session(struct smb3_fs_context *ctx, rc = -ENOMEM ; goto out_err; } - tcp_ses->current_fullpath = tcp_ses->leaf_fullpath; }if (ctx->nosharesock)
fs/cifs/dfs.c +8 -6
@@ -248,11 +248,12 @@ static int __dfs_mount_share(struct cifs_mount_ctx *mnt_ctx) tcon = mnt_ctx->tcon;mutex_lock (&server->refpath_lock); +spin_lock (&server->srv_lock);if (!server->origin_fullpath) { server->origin_fullpath = origin_fullpath; - server->current_fullpath = server->leaf_fullpath; origin_fullpath =NULL ; } +spin_unlock (&server->srv_lock);mutex_unlock (&server->refpath_lock);if (list_empty (&tcon->dfs_ses_list)) {
@@ -342,10 +343,11 @@ static int update_server_fullpath(struct TCP_Server_Info *server, struct cifs_sb rc =PTR_ERR (npath); }else {mutex_lock (&server->refpath_lock); +spin_lock (&server->srv_lock);kfree (server->leaf_fullpath); server->leaf_fullpath = npath; +spin_unlock (&server->srv_lock);mutex_unlock (&server->refpath_lock); - server->current_fullpath = server->leaf_fullpath; }return rc; }
@@ -450,7 +452,7 @@ static int __tree_connect_dfs_target(const unsigned int xid, struct cifs_tcon *t share = prefix =NULL ;/* Check if share matches with tcp ses */ - rc =dfs_cache_get_tgt_share (server->current_fullpath +1 , tit, &share, &prefix); + rc =dfs_cache_get_tgt_share (server->leaf_fullpath +1 , tit, &share, &prefix);if (rc) {cifs_dbg (VFS ,"%s: failed to parse target share: %d\n" , __func__, rc);break ;
@@ -464,7 +466,7 @@ static int __tree_connect_dfs_target(const unsigned int xid, struct cifs_tcon *tcontinue ; } -dfs_cache_noreq_update_tgthint (server->current_fullpath +1 , tit); +dfs_cache_noreq_update_tgthint (server->leaf_fullpath +1 , tit);tree_connect_ipc (xid, tree, cifs_sb, tcon);scnprintf (tree,MAX_TREE_SIZE ,"\\%s" , share);
@@ -582,8 +584,8 @@ int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const stru cifs_sb =CIFS_SB (sb);/* If it is not dfs or there was no cached dfs referral, then reconnect to same share */ -if (!server->current_fullpath || -dfs_cache_noreq_find (server->current_fullpath +1 , &ref, &tl)) { +if (!server->leaf_fullpath || +dfs_cache_noreq_find (server->leaf_fullpath +1 , &ref, &tl)) { rc = ops->tree_connect (xid, tcon->ses, tcon->tree_name, tcon, cifs_sb->local_nls); goto out; }
fs/cifs/dfs.h +11 -2
@@ -43,8 +43,12 @@ static inline char *dfs_get_automount_devname(struct dentry *dentry, void *page)size_t len;char *s; -if (unlikely (!server->origin_fullpath)) +spin_lock (&server->srv_lock); +if (unlikely (!server->origin_fullpath)) { +spin_unlock (&server->srv_lock);return ERR_PTR (-EREMOTE ); + } +spin_unlock (&server->srv_lock); s =dentry_path_raw (dentry, page,PATH_MAX );if (IS_ERR (s))
@@ -53,13 +57,18 @@ static inline char *dfs_get_automount_devname(struct dentry *dentry, void *page)if (!s[1 ]) s++; +spin_lock (&server->srv_lock); len =strlen (server->origin_fullpath); -if (s < (char *)page + len) +if (s < (char *)page + len) { +spin_unlock (&server->srv_lock);return ERR_PTR (-ENAMETOOLONG ); + } s -= len;memcpy (s, server->origin_fullpath, len); +spin_unlock (&server->srv_lock);convert_delimiter (s,'/' ); +return s; }
fs/cifs/dfs_cache.c +5 -1
@@ -1278,8 +1278,12 @@ static void refresh_cache_worker(struct work_struct *work)spin_lock (&cifs_tcp_ses_lock);list_for_each_entry (server, &cifs_tcp_ses_list, tcp_ses_list) { -if (!server->leaf_fullpath) +spin_lock (&server->srv_lock); +if (!server->leaf_fullpath) { +spin_unlock (&server->srv_lock);continue ; + } +spin_unlock (&server->srv_lock);list_for_each_entry (ses, &server->smb_ses_list, smb_ses_list) {if (ses->tcon_ipc) {
Signature · 1 line
2.40.1
PATCH 5/7 cifs: print smb3_fs_context::source when mounting
In reply to Paulo AlcantaraPrint full device name (UNC + optional prefix) from @old_ctx->source when printing info about mount.
Before patch
mount.cifs //srv/share/dir /mnt -o ...
dmesg
...
CIFS: Attempting to mount \\srv\share
After patch
mount.cifs //srv/share/dir /mnt -o ...
dmesg
...
CIFS: Attempting to mount //srv/share/dir
--- fs/cifs/cifsfs.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
fs/cifs/cifsfs.c +6 -8
@@ -874,14 +874,12 @@ cifs_smb3_do_mount(struct file_system_type *fs_type,struct cifs_mnt_data mnt_data;struct dentry *root; -/* -* Prints in Kernel / CIFS log the attempted mount operation -* If CIFS_DEBUG && cifs_FYI -*/ -if (cifsFYI) -cifs_dbg (FYI ,"Devname: %s flags: %d\n" , old_ctx->UNC, flags); -else -cifs_info ("Attempting to mount %s\n" , old_ctx->UNC); +if (cifsFYI) { +cifs_dbg (FYI ,"%s: devname=%s flags=0x%x\n" , __func__, + old_ctx->source, flags); + }else { +cifs_info ("Attempting to mount %s\n" , old_ctx->source); + } cifs_sb =kzalloc (sizeof (struct cifs_sb_info ),GFP_KERNEL );if (cifs_sb ==NULL ) {
Signature · 1 line
2.40.1
PATCH 6/7 cifs: avoid potential races when handling multiple dfs tcons
In reply to Paulo AlcantaraNow that a DFS tcon manages its own list of DFS referrals and sessions, there is no point in having a single worker to refresh referrals of all DFS tcons. Make it faster and less prone to race conditions when having several mounts by queueing a worker per DFS tcon that will take care of refreshing only the DFS referrals related to it.
--- fs/cifs/cifsglob.h | 2 +- fs/cifs/connect.c | 7 ++- fs/cifs/dfs.c | 4 ++ fs/cifs/dfs_cache.c | 141 +++++++++++++++++++------------------------- fs/cifs/dfs_cache.h | 9 +++ 5 files changed, 82 insertions(+), 81 deletions(-)
fs/cifs/cifsglob.h +1 -1
@@ -1238,8 +1238,8 @@ struct cifs_tcon {struct cached_fids *cfids;/* BB add field for back pointer to sb struct(s)? */ #ifdef CONFIG_CIFS_DFS_UPCALL -struct list_head ulist;/* cache update list */ struct list_head dfs_ses_list; +struct delayed_work dfs_cache_work;#endif struct delayed_work query_interfaces;/* query interfaces workqueue job */ };
fs/cifs/connect.c +6 -1
@@ -2336,6 +2336,9 @@ cifs_put_tcon(struct cifs_tcon *tcon)/* cancel polling of interfaces */ cancel_delayed_work_sync (&tcon->query_interfaces); +#ifdef CONFIG_CIFS_DFS_UPCALL +cancel_delayed_work_sync (&tcon->dfs_cache_work); +#endif if (tcon->use_witness) {int rc;
@@ -2583,7 +2586,9 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb3_fs_context *ctx)queue_delayed_work (cifsiod_wq, &tcon->query_interfaces, (SMB_INTERFACE_POLL_INTERVAL *HZ )); } - +#ifdef CONFIG_CIFS_DFS_UPCALL +INIT_DELAYED_WORK (&tcon->dfs_cache_work, dfs_cache_refresh); +#endif spin_lock (&cifs_tcp_ses_lock);list_add (&tcon->tcon_list, &ses->tcon_list);spin_unlock (&cifs_tcp_ses_lock);
fs/cifs/dfs.c +4 -0
@@ -157,6 +157,8 @@ static int get_dfs_conn(struct cifs_mount_ctx *mnt_ctx, const char *ref_path, co rc =cifs_is_path_remote (mnt_ctx); } +dfs_cache_noreq_update_tgthint (ref_path +1 , tit); +if (rc == -EREMOTE && is_refsrv) { rc2 =get_root_smb_session (mnt_ctx);if (rc2)
@@ -259,6 +261,8 @@ static int __dfs_mount_share(struct cifs_mount_ctx *mnt_ctx)if (list_empty (&tcon->dfs_ses_list)) {list_replace_init (&mnt_ctx->dfs_ses_list, &tcon->dfs_ses_list); +queue_delayed_work (dfscache_wq, &tcon->dfs_cache_work, +dfs_cache_get_ttl () *HZ ); }else {dfs_put_root_smb_sessions (&mnt_ctx->dfs_ses_list); }
fs/cifs/dfs_cache.c +62 -79
252 lines not on this page · raw message
fs/cifs/dfs_cache.h +9 -0
@@ -13,6 +13,9 @@#include <linux/uuid.h> #include "cifsglob.h" +extern struct workqueue_struct *dfscache_wq; +extern atomic_t dfs_cache_ttl; +#define DFS_CACHE_TGT_LIST_INIT (var) { .tl_numtgts = 0, .tl_list = LIST_HEAD_INIT((var).tl_list), }struct dfs_cache_tgt_list {
@@ -42,6 +45,7 @@ int dfs_cache_get_tgt_share(char *path, const struct dfs_cache_tgt_iterator *it, char **prefix);char *dfs_cache_canonical_path (const char *path,const struct nls_table *cp,int remap);int dfs_cache_remount_fs (struct cifs_sb_info *cifs_sb); +void dfs_cache_refresh (struct work_struct *work);static inline struct dfs_cache_tgt_iterator * dfs_cache_get_next_tgt(struct dfs_cache_tgt_list *tl,
@@ -89,4 +93,9 @@ dfs_cache_get_nr_tgts(const struct dfs_cache_tgt_list *tl) return tl ? tl->tl_numtgts : 0; } +static inline int dfs_cache_get_ttl (void ) +{ +return atomic_read (&dfs_cache_ttl); +} +#endif /* _CIFS_DFS_CACHE_H */
Signature · 1 line
2.40.1
PATCH 7/7 cifs: fix sharing of DFS connections
In reply to Paulo AlcantaraWhen matching DFS connections, we can't rely on the values set in cifs_sb_info::prepath and cifs_tcon::tree_name as they might change during DFS failover. The DFS referrals related to a specific DFS tcon are already matched earlier in match_server(), therefore we can safely skip those checks altogether as the connection is guaranteed to be unique for the DFS tcon.
Besides, when creating or finding an SMB session, make sure to also refcount any DFS root session related to it (cifs_ses::dfs_root_ses), so if a new DFS mount ends up reusing the connection from the old mount while there was an umount(2) still in progress (e.g. umount(2) -> cifs_umount() -> reconnect -> cifs_put_tcon()), the connection could potentially be put right after the umount(2) finished.
--- fs/cifs/cifsglob.h | 1 - fs/cifs/cifsproto.h | 44 ++++++++++++++++- fs/cifs/connect.c | 118 +++++++++++++++++++++++--------------------- fs/cifs/dfs.c | 62 ++++++++++++++++------- fs/cifs/ioctl.c | 2 +- fs/cifs/smb2pdu.c | 4 +- 6 files changed, 150 insertions(+), 81 deletions(-)
fs/cifs/cifsglob.h +0 -1
@@ -1756,7 +1756,6 @@ struct cifs_mount_ctx {struct TCP_Server_Info *server;struct cifs_ses *ses;struct cifs_tcon *tcon; -char *origin_fullpath, *leaf_fullpath;struct list_head dfs_ses_list; };
fs/cifs/cifsproto.h +43 -1
60 lines not on this page · raw message
fs/cifs/connect.c +61 -57
245 lines not on this page · raw message
fs/cifs/dfs.c +43 -19
102 lines not on this page · raw message
fs/cifs/ioctl.c +1 -1
@@ -239,7 +239,7 @@ static int cifs_dump_full_key(struct cifs_tcon *tcon, struct smb3_full_key_debug* section, we need to make sure it won't be released * so increment its refcount */ - ses->ses_count++; +cifs_smb_ses_inc_refcount (ses); found = true; goto search_end; }
fs/cifs/smb2pdu.c +2 -2
@@ -3856,7 +3856,7 @@ void smb2_reconnect_server(struct work_struct *work)if (ses->tcon_ipc && ses->tcon_ipc->need_reconnect) {list_add_tail (&ses->tcon_ipc->rlist, &tmp_list); tcon_selected = tcon_exist = true; - ses->ses_count++; +cifs_smb_ses_inc_refcount (ses); }/* * handle the case where channel needs to reconnect
@@ -3867,7 +3867,7 @@ void smb2_reconnect_server(struct work_struct *work)if (!tcon_selected &&cifs_chan_needs_reconnect (ses, server)) {list_add_tail (&ses->rlist, &tmp_ses_list); ses_exist = true; - ses->ses_count++; +cifs_smb_ses_inc_refcount (ses); }spin_unlock (&ses->chan_lock); }
Signature · 1 line
2.40.1
kernel test robot
build botRe: [PATCH 7/7] cifs: fix sharing of DFS connections
kernel test robot noticed the following build warnings:
Hi Paulo,
kernel test robot noticed the following build warnings:
[auto build test WARNING on v6.3]
[also build test WARNING on linus/master next-20230428] [cannot apply to cifs/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Paulo-Alcantara/cifs-fix-potential-race-when-tree-connecting-ipc/20230504-062335 base: 457391b0380335d5e9a5babdec90ac53928b23b4 patch link: https://lore.kernel.org/r/20230503222117.7609-8-pc%40manguebit.com patch subject: [PATCH 7/7] cifs: fix sharing of DFS connections config: m68k-allyesconfig (https://download.01.org/0day-ci/archive/20230504/[email protected]/config) compiler: m68k-linux-gcc (GCC) 12.1.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/5a2a7b1846bb61ee5669afdfe2238eaa80c339c2
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Paulo-Alcantara/cifs-fix-potential-race-when-tree-connecting-ipc/20230504-062335 git checkout 5a2a7b1846bb61ee5669afdfe2238eaa80c339c2
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=m68k olddefconfig COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=m68k SHELL=/bin/bash fs/
If you fix the issue, kindly add following tag where applicable
| Reported-by: kernel test robot <[email protected]>
| Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
fs/cifs/connect.c: In function 'cifs_put_tcon':
>> fs/cifs/connect.c:2310:33: warning: variable 'server' set but not used [-Wunused-but-set-variable]
2310 | struct TCP_Server_Info *server;
| ^~~~~~vim +/server +2310 fs/cifs/connect.c
2306
2307 void
2308 cifs_put_tcon(struct cifs_tcon *tcon)
2309 {
> 2310 struct TCP_Server_Info *server;
2311 struct cifs_ses *ses;
2312 unsigned int xid;
2313
2314 /*
2315 * IPC tcon share the lifetime of their session and are
2316 * destroyed in the session put function
2317 */
2318 if (tcon == NULL || tcon->ipc)
2319 return;
2320
2321 ses = tcon->ses;
2322 server = ses->server;
2323 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2324 spin_lock(&cifs_tcp_ses_lock);
2325 spin_lock(&tcon->tc_lock);
2326 if (--tcon->tc_count > 0) {
2327 spin_unlock(&tcon->tc_lock);
2328 spin_unlock(&cifs_tcp_ses_lock);
2329 return;
2330 }
2331
2332 /* tc_count can never go negative */
2333 WARN_ON(tcon->tc_count < 0);
2334
2335 list_del_init(&tcon->tcon_list);
2336 tcon->status = TID_EXITING;
2337 spin_unlock(&tcon->tc_lock);
2338 spin_unlock(&cifs_tcp_ses_lock);
2339
2340 /* cancel polling of interfaces */
2341 cancel_delayed_work_sync(&tcon->query_interfaces);
2342 #ifdef CONFIG_CIFS_DFS_UPCALL
2343 cancel_delayed_work_sync(&tcon->dfs_cache_work);
2344 #endif
2345
2346 if (tcon->use_witness) {
2347 int rc;
2348
2349 rc = cifs_swn_unregister(tcon);
2350 if (rc < 0) {
2351 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
2352 __func__, rc);
2353 }
2354 }
2355
2356 xid = get_xid();
2357 if (ses->server->ops->tree_disconnect)
2358 ses->server->ops->tree_disconnect(xid, tcon);
2359 _free_xid(xid);
2360
2361 cifs_fscache_release_super_cookie(tcon);
2362 tconInfoFree(tcon);
2363 cifs_put_smb_ses(ses);
2364 }
2365
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests
kernel test robot
build botRe: [PATCH 7/7] cifs: fix sharing of DFS connections
In reply to Paulo Alcantarakernel test robot noticed the following build warnings:
Hi Paulo,
kernel test robot noticed the following build warnings:
[auto build test WARNING on v6.3]
[also build test WARNING on linus/master next-20230428] [cannot apply to cifs/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Paulo-Alcantara/cifs-fix-potential-race-when-tree-connecting-ipc/20230504-062335 base: 457391b0380335d5e9a5babdec90ac53928b23b4 patch link: https://lore.kernel.org/r/20230503222117.7609-8-pc%40manguebit.com patch subject: [PATCH 7/7] cifs: fix sharing of DFS connections config: i386-randconfig-a011-20230501 (https://download.01.org/0day-ci/archive/20230504/[email protected]/config) compiler: clang version 14.0.6 (https://github.com/llvm/llvm-project f28c006a5895fc0e329fe15fead81e37457cb1d1)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/5a2a7b1846bb61ee5669afdfe2238eaa80c339c2
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Paulo-Alcantara/cifs-fix-potential-race-when-tree-connecting-ipc/20230504-062335 git checkout 5a2a7b1846bb61ee5669afdfe2238eaa80c339c2
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=i386 olddefconfig COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=i386 SHELL=/bin/bash fs/cifs/
If you fix the issue, kindly add following tag where applicable
| Reported-by: kernel test robot <[email protected]>
| Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
>> fs/cifs/connect.c:2310:26: warning: variable 'server' set but not used [-Wunused-but-set-variable]
struct TCP_Server_Info *server;
^1 warning generated.
vim +/server +2310 fs/cifs/connect.c
2306
2307 void
2308 cifs_put_tcon(struct cifs_tcon *tcon)
2309 {
> 2310 struct TCP_Server_Info *server;
2311 struct cifs_ses *ses;
2312 unsigned int xid;
2313
2314 /*
2315 * IPC tcon share the lifetime of their session and are
2316 * destroyed in the session put function
2317 */
2318 if (tcon == NULL || tcon->ipc)
2319 return;
2320
2321 ses = tcon->ses;
2322 server = ses->server;
2323 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2324 spin_lock(&cifs_tcp_ses_lock);
2325 spin_lock(&tcon->tc_lock);
2326 if (--tcon->tc_count > 0) {
2327 spin_unlock(&tcon->tc_lock);
2328 spin_unlock(&cifs_tcp_ses_lock);
2329 return;
2330 }
2331
2332 /* tc_count can never go negative */
2333 WARN_ON(tcon->tc_count < 0);
2334
2335 list_del_init(&tcon->tcon_list);
2336 tcon->status = TID_EXITING;
2337 spin_unlock(&tcon->tc_lock);
2338 spin_unlock(&cifs_tcp_ses_lock);
2339
2340 /* cancel polling of interfaces */
2341 cancel_delayed_work_sync(&tcon->query_interfaces);
2342 #ifdef CONFIG_CIFS_DFS_UPCALL
2343 cancel_delayed_work_sync(&tcon->dfs_cache_work);
2344 #endif
2345
2346 if (tcon->use_witness) {
2347 int rc;
2348
2349 rc = cifs_swn_unregister(tcon);
2350 if (rc < 0) {
2351 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
2352 __func__, rc);
2353 }
2354 }
2355
2356 xid = get_xid();
2357 if (ses->server->ops->tree_disconnect)
2358 ses->server->ops->tree_disconnect(xid, tcon);
2359 _free_xid(xid);
2360
2361 cifs_fscache_release_super_cookie(tcon);
2362 tconInfoFree(tcon);
2363 cifs_put_smb_ses(ses);
2364 }
2365
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests