Re: [PATCH v3 1/9] smb: client: sync runtime state into ctx on reconfigure

[Meetakshi Setiya]

Hi Rajasi,

My comments inline.

On Thu, May 21, 2026 at 7:24 PM <rajasimandalos@xxxxxxxxx> wrote:
>
> From: Rajasi Mandal <rajasimandal@xxxxxxxxxxxxx>
>
> smb3_init_fs_context() builds a fresh context with init defaults on
> every call, including reconfigure (remount).  Many fields displayed
> by cifs_show_options() are sourced from tcon/server/ses rather than
> from ctx, so the init defaults do not reflect the live mount and
> cannot be used as a baseline for comparing new vs old options on
> remount.
>
> Detect FS_CONTEXT_FOR_RECONFIGURE in smb3_init_fs_context() and
> duplicate the existing cifs_sb->ctx instead.  Before duplicating,
> sync ctx with runtime state via a new helper
> smb3_sync_ctx_from_runtime() so the baseline matches what
> cifs_show_options() displays.  Add srv_lock / tc_lock around the
> relevant runtime writers (SMB2_negotiate, SMB2_tcon,
> reset_cifs_unix_caps, cifs_swn_set_server_dstaddr) so the helper
> can read them without torn-read races.
>
> Also preserve inherited multichannel/max_channels values in
> smb3_handle_conflicting_options() during reconfigure when neither
> option is explicitly specified, since the dup'd context already
> carries them.
>
> This is preparatory plumbing for a subsequent commit that compares
> new_ctx against old_ctx in smb3_verify_reconfigure_ctx() to reject
> non-reconfigurable option changes.
>
> Signed-off-by: Rajasi Mandal <rajasimandal@xxxxxxxxxxxxx>
> ---
>  fs/smb/client/cifs_swn.h   |  14 ++++-
>  fs/smb/client/fs_context.c | 117 ++++++++++++++++++++++++++++++++++++-
>  fs/smb/client/smb1ops.c    |   7 ++-
>  fs/smb/client/smb2pdu.c    |  11 +++-
>  4 files changed, 143 insertions(+), 6 deletions(-)
>
> diff --git a/fs/smb/client/cifs_swn.h b/fs/smb/client/cifs_swn.h
> index 955d07b69450..caf0779d4d07 100644
> --- a/fs/smb/client/cifs_swn.h
> +++ b/fs/smb/client/cifs_swn.h
> @@ -26,11 +26,21 @@ void cifs_swn_check(void);
>
>  static inline bool cifs_swn_set_server_dstaddr(struct TCP_Server_Info *server)
>  {
> +       bool ret = false;
> +
> +       /*
> +        * srv_lock serializes the 128-byte sockaddr_storage write against
> +        * concurrent readers (e.g. cifs_show_address(), reconn_set_ipaddr_
> +        * from_hostname() snapshot, smb3_sync_ctx_from_runtime()) and other
> +        * writers like cifs_chan_update_iface() which already use srv_lock.
> +        */
> +       spin_lock(&server->srv_lock);
>         if (server->use_swn_dstaddr) {
>                 server->dstaddr = server->swn_dstaddr;
> -               return true;
> +               ret = true;
>         }
> -       return false;
> +       spin_unlock(&server->srv_lock);
> +       return ret;
>  }
>
>  static inline void cifs_swn_reset_server_dstaddr(struct TCP_Server_Info *server)
> diff --git a/fs/smb/client/fs_context.c b/fs/smb/client/fs_context.c
> index 2f86158f85d7..b93d6ef13463 100644
> --- a/fs/smb/client/fs_context.c
> +++ b/fs/smb/client/fs_context.c
> @@ -717,13 +717,13 @@ static int smb3_handle_conflicting_options(struct fs_context *fc)
>                                 ctx->multichannel = true;
>                         else
>                                 ctx->multichannel = false;
> -               } else {
> +               } else if (fc->purpose != FS_CONTEXT_FOR_RECONFIGURE) {
>                         ctx->multichannel = false;
>                         ctx->max_channels = 1;
>                 }
> +               /* For reconfigure with neither specified, keep inherited values */
>         }
>
> -       //resetting default values as remount doesn't initialize fs_context again
>         ctx->multichannel_specified = false;
>         ctx->max_channels_specified = false;
>
> @@ -921,6 +921,85 @@ static void smb3_fs_context_free(struct fs_context *fc)
>         smb3_cleanup_fs_context(ctx);
>  }
>
> +/*
> + * Sync cifs_sb->ctx with the runtime state visible through /proc/mounts.
> + * cifs_show_options() reads many fields from tcon/server/ses rather than
> + * from ctx.  On remount, libmount reads /proc/mounts and feeds those
> + * values back as mount options.  To avoid false mismatches between the
> + * old ctx and the newly parsed options, we must ensure ctx reflects
> + * the current runtime state before it is duplicated into the new
> + * remount context.
> + *
> + * Note: sb->s_umount is not yet held when VFS calls init_fs_context()
> + * for reconfigure, so in theory concurrent I/O paths could read
> + * cifs_sb->ctx fields (e.g. cifs_symlink_type()) while we write them.
> + * This is safe because all fields written here are word-sized
> + * (bool/int/pointer), so stores are architecturally atomic.  The same
> + * unsynchronized-read pattern already exists in cifs_show_options().
> + */

Nitpick about the comment - dstaddr for example is not word-sized and
not atomic. You should rework this comment.

> +static void smb3_sync_ctx_from_runtime(struct cifs_sb_info *cifs_sb)
> +{
> +       struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
> +       struct TCP_Server_Info *server = tcon->ses->server;
> +       struct cifs_ses *ses = tcon->ses;
> +       struct smb3_fs_context *ctx = cifs_sb->ctx;
> +       const char *domain;
> +       int unicode;
> +
> +       /*
> +        * Server fields that can drift from ctx after mount:
> +        *  - ops/vals: dialect renegotiation during reconnect (paired,
> +        *    so read under srv_lock to match the writer in SMB2_negotiate)
> +        *  - dstaddr: SWN witness failover updates server->dstaddr; the
> +        *    128-byte sockaddr_storage is not atomic, so srv_lock is
> +        *    required against torn reads
> +        *  - nosharesock: can be flipped to true post-mount by SMB2_tcon
> +        *    on STATUS_BAD_NETWORK_NAME with ISOLATED_TRANSPORT, so read
> +        *    under srv_lock to pair with that writer
> +        */
> +       spin_lock(&server->srv_lock);
> +       ctx->ops = server->ops;
> +       ctx->vals = server->vals;
> +       ctx->dstaddr = server->dstaddr;
> +       ctx->nosharesock = server->nosharesock;
> +       spin_unlock(&server->srv_lock);
> +
> +       /*
> +        * tcon->unix_ext can be flipped post-mount by reset_cifs_unix_caps()
> +        * on SMB1 reconnect (smb1_reconnect path). Read under tc_lock to pair
> +        * with that writer. tcon->posix_extensions is only ever set at
> +        * mount-time pre-publish, but read it under the same lock so the
> +        * derived linux_ext/no_linux_ext pair is consistent.
> +        */
> +       spin_lock(&tcon->tc_lock);
> +       if (tcon->posix_extensions || tcon->unix_ext) {
> +               ctx->linux_ext = 1;
> +               ctx->no_linux_ext = 0;
> +       } else {
> +               ctx->linux_ext = 0;
> +               ctx->no_linux_ext = 1;
> +       }
> +       spin_unlock(&tcon->tc_lock);
> +       ctx->seal         = tcon->seal;
> +       ctx->persistent   = tcon->use_persistent;
> +       ctx->nopersistent = !tcon->use_persistent;
> +       ctx->resilient    = tcon->use_resilient;
> +       ctx->witness      = tcon->use_witness;
> +
> +       /*
> +        * Session fields: domainName and unicode are effectively
> +        * write-once (set during session setup, never freed/replaced
> +        * while the session exists), so plain reads are safe.
> +        */
> +       domain = ses->domainName;
> +       unicode = ses->unicode;
> +
> +       if (domain && !ctx->domainname)
> +               ctx->domainname = kstrdup(domain, GFP_KERNEL);

Can you handle the ENOMEM error here?

> +       if (unicode >= 0)
> +               ctx->unicode = unicode;
> +}
> +
>  /*
>   * Compare the old and new proposed context during reconfigure
>   * and check if the changes are compatible.
> @@ -1958,6 +2037,40 @@ int smb3_init_fs_context(struct fs_context *fc)
>         char *nodename = utsname()->nodename;
>         int i;
>
> +       /*
> +        * For reconfigure (remount), duplicate the existing mount context
> +        * instead of building one from scratch with init defaults.
> +        *
> +        * VFS sets fc->root before calling init_fs_context for reconfigure,
> +        * so we can access the existing superblock's context.  We first sync
> +        * cifs_sb->ctx with runtime state (tcon/server/ses) so that ctx
> +        * matches what cifs_show_options() displays.  Then we dup old_ctx
> +        * into new_ctx.  The parser will overwrite only the options
> +        * explicitly passed on remount, so any difference between new_ctx
> +        * and old_ctx in smb3_verify_reconfigure_ctx() represents a real,
> +        * intentional change by the user.
> +        */
> +       if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
> +               struct cifs_sb_info *cifs_sb = CIFS_SB(fc->root->d_sb);
> +               int rc;
> +
> +               smb3_sync_ctx_from_runtime(cifs_sb);
> +
> +               ctx = kzalloc_obj(struct smb3_fs_context);
> +               if (!ctx)
> +                       return -ENOMEM;
> +
> +               rc = smb3_fs_context_dup(ctx, cifs_sb->ctx);
> +               if (rc) {
> +                       kfree(ctx);
> +                       return rc;
> +               }
> +
> +               fc->fs_private = ctx;
> +               fc->ops = &smb3_fs_context_ops;
> +               return 0;
> +       }
> +
>         ctx = kzalloc_obj(struct smb3_fs_context);
>         if (unlikely(!ctx))
>                 return -ENOMEM;
> diff --git a/fs/smb/client/smb1ops.c b/fs/smb/client/smb1ops.c
> index e198e3dda917..a91539d7f0ba 100644
> --- a/fs/smb/client/smb1ops.c
> +++ b/fs/smb/client/smb1ops.c
> @@ -36,11 +36,16 @@ void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
>
>         if (ctx && ctx->no_linux_ext) {
>                 tcon->fsUnixInfo.Capability = 0;
> +               spin_lock(&tcon->tc_lock);
>                 tcon->unix_ext = 0; /* Unix Extensions disabled */
> +               spin_unlock(&tcon->tc_lock);
>                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
>                 return;
> -       } else if (ctx)
> +       } else if (ctx) {
> +               spin_lock(&tcon->tc_lock);
>                 tcon->unix_ext = 1; /* Unix Extensions supported */
> +               spin_unlock(&tcon->tc_lock);
> +       }
>
>         if (!tcon->unix_ext) {
>                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
> diff --git a/fs/smb/client/smb2pdu.c b/fs/smb/client/smb2pdu.c
> index 995fcdd30681..9e07c1a99981 100644
> --- a/fs/smb/client/smb2pdu.c
> +++ b/fs/smb/client/smb2pdu.c
> @@ -1189,8 +1189,10 @@ SMB2_negotiate(const unsigned int xid,
>                         goto neg_exit;
>                 case SMB311_PROT_ID:
>                         /* ops set to 3.0 by default for default so update */
> +                       spin_lock(&server->srv_lock);
>                         server->ops = &smb311_operations;
>                         server->vals = &smb311_values;
> +                       spin_unlock(&server->srv_lock);
>                         break;
>                 default:
>                         break;
> @@ -1205,12 +1207,16 @@ SMB2_negotiate(const unsigned int xid,
>                         goto neg_exit;
>                 case SMB21_PROT_ID:
>                         /* ops set to 3.0 by default for default so update */
> +                       spin_lock(&server->srv_lock);
>                         server->ops = &smb21_operations;
>                         server->vals = &smb21_values;
> +                       spin_unlock(&server->srv_lock);
>                         break;
>                 case SMB311_PROT_ID:
> +                       spin_lock(&server->srv_lock);
>                         server->ops = &smb311_operations;
>                         server->vals = &smb311_values;
> +                       spin_unlock(&server->srv_lock);
>                         break;
>                 default:
>                         break;
> @@ -2228,8 +2234,11 @@ SMB2_tcon(const unsigned int xid, struct cifs_ses *ses, const char *tree,
>         if (server->ops->validate_negotiate)
>                 rc = server->ops->validate_negotiate(xid, tcon);
>         if (rc == 0) /* See MS-SMB2 2.2.10 and 3.2.5.5 */
> -               if (tcon->share_flags & SMB2_SHAREFLAG_ISOLATED_TRANSPORT)
> +               if (tcon->share_flags & SMB2_SHAREFLAG_ISOLATED_TRANSPORT) {
> +                       spin_lock(&server->srv_lock);
>                         server->nosharesock = true;
> +                       spin_unlock(&server->srv_lock);
> +               }
>  tcon_exit:
>
>         free_rsp_buf(resp_buftype, rsp);
> --
> 2.43.0
>

Other than these issues, the patch looks good to me.

Thanks
Meetakshi