cifs: do not share tcons with DFS
Subsystems (2)
PATCH 1/3 cifs: do not share tcons with DFS
This disables tcon re-use for DFS shares.
tcon->dfs_path stores the path that the tcon should connect to when doing failing over.
If that tcon is used multiple times e.g. 2 mounts using it with different prefixpath, each will need a different dfs_path but there is only one tcon. The other solution would be to split the tcon in 2 tcons during failover but that is much harder.
--- fs/cifs/connect.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/cifs/connect.c +1 -1
@@ -3373,7 +3373,7 @@ cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)spin_lock (&cifs_tcp_ses_lock);list_for_each (tmp, &ses->tcon_list) { tcon = list_entry(tmp, struct cifs_tcon, tcon_list); -if (!match_tcon (tcon, volume_info)) +if (!match_tcon (tcon, volume_info) || tcon->dfs_path)continue ; ++tcon->tc_count;spin_unlock (&cifs_tcp_ses_lock);
Signature · 1 line
2.26.0
PATCH 2/3 cifs: ensure correct super block for DFS reconnect
We could not rely on TCP server pointer to determine which super block to update the prefix path when reconnecting tcons since it might map to different tcons that share same TCP connection.
Instead, walk through all cifs super blocks and compare their DFS full paths with the tcon being updated to.
--- fs/cifs/misc.c | 71 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 54 insertions(+), 17 deletions(-)
fs/cifs/misc.c +54 -17
@@ -1025,51 +1025,88 @@ int copy_path_name(char *dst, const char *src) }struct super_cb_data { -struct TCP_Server_Info *server; +void *data;struct super_block *sb; }; -static void super_cb (struct super_block *sb,void *arg) +static void tcp_super_cb (struct super_block *sb,void *arg) { -struct super_cb_data *d = arg; +struct super_cb_data *sd = arg; +struct TCP_Server_Info *server = sd->data;struct cifs_sb_info *cifs_sb;struct cifs_tcon *tcon; -if (d->sb) +if (sd->sb)return ; cifs_sb =CIFS_SB (sb); tcon =cifs_sb_master_tcon (cifs_sb); -if (tcon->ses->server == d->server) - d->sb = sb; +if (tcon->ses->server == server) + sd->sb = sb; } -struct super_block *cifs_get_tcp_super (struct TCP_Server_Info *server) +static struct super_block *__cifs_get_super (void (*f)(struct super_block *,void *), +void *data) { -struct super_cb_data d = { - .server = server, +struct super_cb_data sd = { + .data = data, .sb =NULL , }; -iterate_supers_type (&cifs_fs_type, super_cb, &d); +iterate_supers_type (&cifs_fs_type, f, &sd); -if (unlikely (!d.sb)) -return ERR_PTR (-ENOENT ); +if (!sd.sb) +return ERR_PTR (-EINVAL );/* * Grab an active reference in order to prevent automounts (DFS links) * of expiring and then freeing up our cifs superblock pointer while * we're doing failover. */ -cifs_sb_active (d.sb); -return d.sb; +cifs_sb_active (sd.sb); +return sd.sb; } -void cifs_put_tcp_super (struct super_block *sb) +static void __cifs_put_super (struct super_block *sb) {if (!IS_ERR_OR_NULL (sb))cifs_sb_deactive (sb); } +struct super_block *cifs_get_tcp_super (struct TCP_Server_Info *server) +{ +return __cifs_get_super (tcp_super_cb, server); +} + +void cifs_put_tcp_super (struct super_block *sb) +{ +__cifs_put_super (sb); +} + +static void tcon_super_cb (struct super_block *sb,void *arg) +{ +struct super_cb_data *sd = arg; +struct cifs_tcon *tcon = sd->data; +struct cifs_sb_info *cifs_sb; + +if (sd->sb) +return ; + + cifs_sb =CIFS_SB (sb); +if (tcon->dfs_path && cifs_sb->origin_fullpath && + !strcasecmp (tcon->dfs_path, cifs_sb->origin_fullpath)) + sd->sb = sb; +} + +static inline struct super_block *cifs_get_tcon_super (struct cifs_tcon *tcon) +{ +return __cifs_get_super (tcon_super_cb, tcon); +} + +static inline void cifs_put_tcon_super (struct super_block *sb) +{ +__cifs_put_super (sb); +} +int update_super_prepath (struct cifs_tcon *tcon,const char *prefix,size_t prefix_len) {
@@ -1077,7 +1114,7 @@ int update_super_prepath(struct cifs_tcon *tcon, const char *prefix,struct cifs_sb_info *cifs_sb;int rc =0 ; - sb =cifs_get_tcp_super (tcon->ses->server); + sb =cifs_get_tcon_super (tcon);if (IS_ERR (sb))return PTR_ERR (sb);
@@ -1099,6 +1136,6 @@ int update_super_prepath(struct cifs_tcon *tcon, const char *prefix, cifs_sb->mnt_cifs_flags |=CIFS_MOUNT_USE_PREFIX_PATH ; out: -cifs_put_tcp_super (sb); +cifs_put_tcon_super (sb);return rc; }
Signature · 1 line
2.26.0
PATCH 3/3 cifs: fix uninitialised lease_key in open_shroot()
In reply to Paulo AlcantaraSMB2_open_init() expects a pre-initialised lease_key when opening a file with a lease, so set pfid->lease_key prior to calling it in open_shroot().
This issue was observed when performing some DFS failover tests and the lease key was never randomly generated.
--- fs/cifs/smb2ops.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/cifs/smb2ops.c +5 -0
@@ -687,6 +687,11 @@ int open_shroot(unsigned int xid, struct cifs_tcon *tcon,if (smb3_encryption_required (tcon)) flags |=CIFS_TRANSFORM_REQ ; +if (!server->ops->new_lease_key) +return -EIO ; + + server->ops->new_lease_key (pfid); +memset (rqst,0 ,sizeof (rqst)); resp_buftype[0 ] = resp_buftype[1 ] =CIFS_NO_BUFFER ;memset (rsp_iov,0 ,sizeof (rsp_iov));
Signature · 1 line
2.26.0
series looks good after initial review
Quoted 33 lines · Paulo Alcantara
This disables tcon re-use for DFS shares.
tcon->dfs_pathstores the path that the tcon should connect to when doing failing over.If that tcon is used multiple times e.g. 2 mounts using it with different prefixpath, each will need a different
dfs_pathbut there is only one tcon. The other solution would be to split the tcon in 2 tcons during failover but that is much harder.Signed-off-by Paulo Alcantara (SUSE) <[email protected]>Reviewed-by Aurelien Aptel <[email protected]>--- fs/cifs/connect.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/cifs/connect.c +1
-2@@ -3373,7 +3373,7 @@ cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)spin_lock (&cifs_tcp_ses_lock);list_for_each (tmp, &ses->tcon_list) { tcon = list_entry(tmp, struct cifs_tcon, tcon_list); -if (!match_tcon (tcon, volume_info)) +if (!match_tcon (tcon, volume_info) || tcon->dfs_path)continue ; ++tcon->tc_count;spin_unlock (&cifs_tcp_ses_lock); --2.26.0