fs_context.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2020, Microsoft Corporation.
   4  *
   5  *   Author(s): Steve French <stfrench@microsoft.com>
   6  *              David Howells <dhowells@redhat.com>
   7  */
   8
   9 /*
  10 #include <linux/module.h>
  11 #include <linux/nsproxy.h>
  12 #include <linux/slab.h>
  13 #include <linux/magic.h>
  14 #include <linux/security.h>
  15 #include <net/net_namespace.h>
  16 #ifdef CONFIG_CIFS_DFS_UPCALL
  17 #include "dfs_cache.h"
  18 #endif
  19 */
  20
  21 #include <linux/ctype.h>
  22 #include <linux/fs_context.h>
  23 #include <linux/fs_parser.h>
  24 #include <linux/fs.h>
  25 #include <linux/mount.h>
  26 #include <linux/parser.h>
  27 #include <linux/utsname.h>
  28 #include "cifsfs.h"
  29 #include "cifspdu.h"
  30 #include "cifsglob.h"
  31 #include "cifsproto.h"
  32 #include "cifs_unicode.h"
  33 #include "cifs_debug.h"
  34 #include "cifs_fs_sb.h"
  35 #include "ntlmssp.h"
  36 #include "nterr.h"
  37 #include "rfc1002pdu.h"
  38 #include "fs_context.h"
  39
  40 DEFINE_MUTEX(cifs_mount_mutex);
  41
  42 static const match_table_t cifs_smb_version_tokens = {
  43         { Smb_1, SMB1_VERSION_STRING },
  44         { Smb_20, SMB20_VERSION_STRING},
  45         { Smb_21, SMB21_VERSION_STRING },
  46         { Smb_30, SMB30_VERSION_STRING },
  47         { Smb_302, SMB302_VERSION_STRING },
  48         { Smb_302, ALT_SMB302_VERSION_STRING },
  49         { Smb_311, SMB311_VERSION_STRING },
  50         { Smb_311, ALT_SMB311_VERSION_STRING },
  51         { Smb_3any, SMB3ANY_VERSION_STRING },
  52         { Smb_default, SMBDEFAULT_VERSION_STRING },
  53         { Smb_version_err, NULL }
  54 };
  55
  56 static const match_table_t cifs_secflavor_tokens = {
  57         { Opt_sec_krb5, "krb5" },
  58         { Opt_sec_krb5i, "krb5i" },
  59         { Opt_sec_krb5p, "krb5p" },
  60         { Opt_sec_ntlmsspi, "ntlmsspi" },
  61         { Opt_sec_ntlmssp, "ntlmssp" },
  62         { Opt_sec_ntlmv2, "nontlm" },
  63         { Opt_sec_ntlmv2, "ntlmv2" },
  64         { Opt_sec_ntlmv2i, "ntlmv2i" },
  65         { Opt_sec_none, "none" },
  66
  67         { Opt_sec_err, NULL }
  68 };
  69
  70 const struct fs_parameter_spec smb3_fs_parameters[] = {
  71         /* Mount options that take no arguments */
  72         fsparam_flag_no("user_xattr", Opt_user_xattr),
  73         fsparam_flag_no("forceuid", Opt_forceuid),
  74         fsparam_flag_no("multichannel", Opt_multichannel),
  75         fsparam_flag_no("forcegid", Opt_forcegid),
  76         fsparam_flag("noblocksend", Opt_noblocksend),
  77         fsparam_flag("noautotune", Opt_noautotune),
  78         fsparam_flag("nolease", Opt_nolease),
  79         fsparam_flag_no("hard", Opt_hard),
  80         fsparam_flag_no("soft", Opt_soft),
  81         fsparam_flag_no("perm", Opt_perm),
  82         fsparam_flag("nodelete", Opt_nodelete),
  83         fsparam_flag_no("mapposix", Opt_mapposix),
  84         fsparam_flag("mapchars", Opt_mapchars),
  85         fsparam_flag("nomapchars", Opt_nomapchars),
  86         fsparam_flag_no("sfu", Opt_sfu),
  87         fsparam_flag("nodfs", Opt_nodfs),
  88         fsparam_flag_no("posixpaths", Opt_posixpaths),
  89         fsparam_flag_no("unix", Opt_unix),
  90         fsparam_flag_no("linux", Opt_unix),
  91         fsparam_flag_no("posix", Opt_unix),
  92         fsparam_flag("nocase", Opt_nocase),
  93         fsparam_flag("ignorecase", Opt_nocase),
  94         fsparam_flag_no("brl", Opt_brl),
  95         fsparam_flag_no("handlecache", Opt_handlecache),
  96         fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
  97         fsparam_flag("forcemand", Opt_forcemandatorylock),
  98         fsparam_flag("setuidfromacl", Opt_setuidfromacl),
  99         fsparam_flag("idsfromsid", Opt_setuidfromacl),
 100         fsparam_flag_no("setuids", Opt_setuids),
 101         fsparam_flag_no("dynperm", Opt_dynperm),
 102         fsparam_flag_no("intr", Opt_intr),
 103         fsparam_flag_no("strictsync", Opt_strictsync),
 104         fsparam_flag_no("serverino", Opt_serverino),
 105         fsparam_flag("rwpidforward", Opt_rwpidforward),
 106         fsparam_flag("cifsacl", Opt_cifsacl),
 107         fsparam_flag_no("acl", Opt_acl),
 108         fsparam_flag("locallease", Opt_locallease),
 109         fsparam_flag("sign", Opt_sign),
 110         fsparam_flag("ignore_signature", Opt_ignore_signature),
 111         fsparam_flag("signloosely", Opt_ignore_signature),
 112         fsparam_flag("seal", Opt_seal),
 113         fsparam_flag("noac", Opt_noac),
 114         fsparam_flag("fsc", Opt_fsc),
 115         fsparam_flag("mfsymlinks", Opt_mfsymlinks),
 116         fsparam_flag("multiuser", Opt_multiuser),
 117         fsparam_flag("sloppy", Opt_sloppy),
 118         fsparam_flag("nosharesock", Opt_nosharesock),
 119         fsparam_flag_no("persistenthandles", Opt_persistent),
 120         fsparam_flag_no("resilienthandles", Opt_resilient),
 121         fsparam_flag_no("tcpnodelay", Opt_tcp_nodelay),
 122         fsparam_flag("nosparse", Opt_nosparse),
 123         fsparam_flag("domainauto", Opt_domainauto),
 124         fsparam_flag("rdma", Opt_rdma),
 125         fsparam_flag("modesid", Opt_modesid),
 126         fsparam_flag("modefromsid", Opt_modesid),
 127         fsparam_flag("rootfs", Opt_rootfs),
 128         fsparam_flag("compress", Opt_compress),
 129         fsparam_flag("witness", Opt_witness),
 130
 131         /* Mount options which take numeric value */
 132         fsparam_u32("backupuid", Opt_backupuid),
 133         fsparam_u32("backupgid", Opt_backupgid),
 134         fsparam_u32("uid", Opt_uid),
 135         fsparam_u32("cruid", Opt_cruid),
 136         fsparam_u32("gid", Opt_gid),
 137         fsparam_u32("file_mode", Opt_file_mode),
 138         fsparam_u32("dirmode", Opt_dirmode),
 139         fsparam_u32("dir_mode", Opt_dirmode),
 140         fsparam_u32("port", Opt_port),
 141         fsparam_u32("min_enc_offload", Opt_min_enc_offload),
 142         fsparam_u32("retrans", Opt_retrans),
 143         fsparam_u32("esize", Opt_min_enc_offload),
 144         fsparam_u32("bsize", Opt_blocksize),
 145         fsparam_u32("rasize", Opt_rasize),
 146         fsparam_u32("rsize", Opt_rsize),
 147         fsparam_u32("wsize", Opt_wsize),
 148         fsparam_u32("actimeo", Opt_actimeo),
 149         fsparam_u32("acdirmax", Opt_acdirmax),
 150         fsparam_u32("acregmax", Opt_acregmax),
 151         fsparam_u32("closetimeo", Opt_closetimeo),
 152         fsparam_u32("echo_interval", Opt_echo_interval),
 153         fsparam_u32("max_credits", Opt_max_credits),
 154         fsparam_u32("max_cached_dirs", Opt_max_cached_dirs),
 155         fsparam_u32("handletimeout", Opt_handletimeout),
 156         fsparam_u64("snapshot", Opt_snapshot),
 157         fsparam_u32("max_channels", Opt_max_channels),
 158
 159         /* Mount options which take string value */
 160         fsparam_string("source", Opt_source),
 161         fsparam_string("user", Opt_user),
 162         fsparam_string("username", Opt_user),
 163         fsparam_string("pass", Opt_pass),
 164         fsparam_string("password", Opt_pass),
 165         fsparam_string("ip", Opt_ip),
 166         fsparam_string("addr", Opt_ip),
 167         fsparam_string("domain", Opt_domain),
 168         fsparam_string("dom", Opt_domain),
 169         fsparam_string("srcaddr", Opt_srcaddr),
 170         fsparam_string("iocharset", Opt_iocharset),
 171         fsparam_string("netbiosname", Opt_netbiosname),
 172         fsparam_string("servern", Opt_servern),
 173         fsparam_string("ver", Opt_ver),
 174         fsparam_string("vers", Opt_vers),
 175         fsparam_string("sec", Opt_sec),
 176         fsparam_string("cache", Opt_cache),
 177
 178         /* Arguments that should be ignored */
 179         fsparam_flag("guest", Opt_ignore),
 180         fsparam_flag("noatime", Opt_ignore),
 181         fsparam_flag("relatime", Opt_ignore),
 182         fsparam_flag("_netdev", Opt_ignore),
 183         fsparam_flag_no("suid", Opt_ignore),
 184         fsparam_flag_no("exec", Opt_ignore),
 185         fsparam_flag_no("dev", Opt_ignore),
 186         fsparam_flag_no("mand", Opt_ignore),
 187         fsparam_flag_no("auto", Opt_ignore),
 188         fsparam_string("cred", Opt_ignore),
 189         fsparam_string("credentials", Opt_ignore),
 190         /*
 191          * UNC and prefixpath is now extracted from Opt_source
 192          * in the new mount API so we can just ignore them going forward.
 193          */
 194         fsparam_string("unc", Opt_ignore),
 195         fsparam_string("prefixpath", Opt_ignore),
 196         {}
 197 };
 198
 199 static int
 200 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
 201 {
 202
 203         substring_t args[MAX_OPT_ARGS];
 204
 205         /*
 206          * With mount options, the last one should win. Reset any existing
 207          * settings back to default.
 208          */
 209         ctx->sectype = Unspecified;
 210         ctx->sign = false;
 211
 212         switch (match_token(value, cifs_secflavor_tokens, args)) {
 213         case Opt_sec_krb5p:
 214                 cifs_errorf(fc, "sec=krb5p is not supported. Use sec=krb5,seal instead\n");
 215                 return 1;
 216         case Opt_sec_krb5i:
 217                 ctx->sign = true;
 218                 fallthrough;
 219         case Opt_sec_krb5:
 220                 ctx->sectype = Kerberos;
 221                 break;
 222         case Opt_sec_ntlmsspi:
 223                 ctx->sign = true;
 224                 fallthrough;
 225         case Opt_sec_ntlmssp:
 226                 ctx->sectype = RawNTLMSSP;
 227                 break;
 228         case Opt_sec_ntlmv2i:
 229                 ctx->sign = true;
 230                 fallthrough;
 231         case Opt_sec_ntlmv2:
 232                 ctx->sectype = NTLMv2;
 233                 break;
 234         case Opt_sec_none:
 235                 ctx->nullauth = 1;
 236                 kfree(ctx->username);
 237                 ctx->username = NULL;
 238                 break;
 239         default:
 240                 cifs_errorf(fc, "bad security option: %s\n", value);
 241                 return 1;
 242         }
 243
 244         return 0;
 245 }
 246
 247 static const match_table_t cifs_cacheflavor_tokens = {
 248         { Opt_cache_loose, "loose" },
 249         { Opt_cache_strict, "strict" },
 250         { Opt_cache_none, "none" },
 251         { Opt_cache_ro, "ro" },
 252         { Opt_cache_rw, "singleclient" },
 253         { Opt_cache_err, NULL }
 254 };
 255
 256 static int
 257 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
 258 {
 259         substring_t args[MAX_OPT_ARGS];
 260
 261         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
 262         case Opt_cache_loose:
 263                 ctx->direct_io = false;
 264                 ctx->strict_io = false;
 265                 ctx->cache_ro = false;
 266                 ctx->cache_rw = false;
 267                 break;
 268         case Opt_cache_strict:
 269                 ctx->direct_io = false;
 270                 ctx->strict_io = true;
 271                 ctx->cache_ro = false;
 272                 ctx->cache_rw = false;
 273                 break;
 274         case Opt_cache_none:
 275                 ctx->direct_io = true;
 276                 ctx->strict_io = false;
 277                 ctx->cache_ro = false;
 278                 ctx->cache_rw = false;
 279                 break;
 280         case Opt_cache_ro:
 281                 ctx->direct_io = false;
 282                 ctx->strict_io = false;
 283                 ctx->cache_ro = true;
 284                 ctx->cache_rw = false;
 285                 break;
 286         case Opt_cache_rw:
 287                 ctx->direct_io = false;
 288                 ctx->strict_io = false;
 289                 ctx->cache_ro = false;
 290                 ctx->cache_rw = true;
 291                 break;
 292         default:
 293                 cifs_errorf(fc, "bad cache= option: %s\n", value);
 294                 return 1;
 295         }
 296         return 0;
 297 }
 298
 299 #define DUP_CTX_STR(field)                                              \
 300 do {                                                                    \
 301         if (ctx->field) {                                               \
 302                 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC);       \
 303                 if (new_ctx->field == NULL) {                           \
 304                         smb3_cleanup_fs_context_contents(new_ctx);      \
 305                         return -ENOMEM;                                 \
 306                 }                                                       \
 307         }                                                               \
 308 } while (0)
 309
 310 int
 311 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
 312 {
 313         memcpy(new_ctx, ctx, sizeof(*ctx));
 314         new_ctx->prepath = NULL;
 315         new_ctx->nodename = NULL;
 316         new_ctx->username = NULL;
 317         new_ctx->password = NULL;
 318         new_ctx->server_hostname = NULL;
 319         new_ctx->domainname = NULL;
 320         new_ctx->UNC = NULL;
 321         new_ctx->source = NULL;
 322         new_ctx->iocharset = NULL;
 323         new_ctx->leaf_fullpath = NULL;
 324         /*
 325          * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
 326          */
 327         DUP_CTX_STR(prepath);
 328         DUP_CTX_STR(username);
 329         DUP_CTX_STR(password);
 330         DUP_CTX_STR(server_hostname);
 331         DUP_CTX_STR(UNC);
 332         DUP_CTX_STR(source);
 333         DUP_CTX_STR(domainname);
 334         DUP_CTX_STR(nodename);
 335         DUP_CTX_STR(iocharset);
 336         DUP_CTX_STR(leaf_fullpath);
 337
 338         return 0;
 339 }
 340
 341 static int
 342 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
 343 {
 344         substring_t args[MAX_OPT_ARGS];
 345
 346         switch (match_token(value, cifs_smb_version_tokens, args)) {
 347 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 348         case Smb_1:
 349                 if (disable_legacy_dialects) {
 350                         cifs_errorf(fc, "mount with legacy dialect disabled\n");
 351                         return 1;
 352                 }
 353                 if (is_smb3) {
 354                         cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
 355                         return 1;
 356                 }
 357                 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
 358                 ctx->ops = &smb1_operations;
 359                 ctx->vals = &smb1_values;
 360                 break;
 361         case Smb_20:
 362                 if (disable_legacy_dialects) {
 363                         cifs_errorf(fc, "mount with legacy dialect disabled\n");
 364                         return 1;
 365                 }
 366                 if (is_smb3) {
 367                         cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
 368                         return 1;
 369                 }
 370                 ctx->ops = &smb20_operations;
 371                 ctx->vals = &smb20_values;
 372                 break;
 373 #else
 374         case Smb_1:
 375                 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
 376                 return 1;
 377         case Smb_20:
 378                 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
 379                 return 1;
 380 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
 381         case Smb_21:
 382                 ctx->ops = &smb21_operations;
 383                 ctx->vals = &smb21_values;
 384                 break;
 385         case Smb_30:
 386                 ctx->ops = &smb30_operations;
 387                 ctx->vals = &smb30_values;
 388                 break;
 389         case Smb_302:
 390                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 391                 ctx->vals = &smb302_values;
 392                 break;
 393         case Smb_311:
 394                 ctx->ops = &smb311_operations;
 395                 ctx->vals = &smb311_values;
 396                 break;
 397         case Smb_3any:
 398                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 399                 ctx->vals = &smb3any_values;
 400                 break;
 401         case Smb_default:
 402                 ctx->ops = &smb30_operations;
 403                 ctx->vals = &smbdefault_values;
 404                 break;
 405         default:
 406                 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
 407                 return 1;
 408         }
 409         return 0;
 410 }
 411
 412 int smb3_parse_opt(const char *options, const char *key, char **val)
 413 {
 414         int rc = -ENOENT;
 415         char *opts, *orig, *p;
 416
 417         orig = opts = kstrdup(options, GFP_KERNEL);
 418         if (!opts)
 419                 return -ENOMEM;
 420
 421         while ((p = strsep(&opts, ","))) {
 422                 char *nval;
 423
 424                 if (!*p)
 425                         continue;
 426                 if (strncasecmp(p, key, strlen(key)))
 427                         continue;
 428                 nval = strchr(p, '=');
 429                 if (nval) {
 430                         if (nval == p)
 431                                 continue;
 432                         *nval++ = 0;
 433                         *val = kstrdup(nval, GFP_KERNEL);
 434                         rc = !*val ? -ENOMEM : 0;
 435                         goto out;
 436                 }
 437         }
 438 out:
 439         kfree(orig);
 440         return rc;
 441 }
 442
 443 /*
 444  * Remove duplicate path delimiters. Windows is supposed to do that
 445  * but there are some bugs that prevent rename from working if there are
 446  * multiple delimiters.
 447  *
 448  * Return a sanitized duplicate of @path or NULL for empty prefix paths.
 449  * Otherwise, return ERR_PTR.
 450  *
 451  * @gfp indicates the GFP_* flags for kstrdup.
 452  * The caller is responsible for freeing the original.
 453  */
 454 #define IS_DELIM(c) ((c) == '/' || (c) == '\\')
 455 char *cifs_sanitize_prepath(char *prepath, gfp_t gfp)
 456 {
 457         char *cursor1 = prepath, *cursor2 = prepath;
 458         char *s;
 459
 460         /* skip all prepended delimiters */
 461         while (IS_DELIM(*cursor1))
 462                 cursor1++;
 463
 464         /* copy the first letter */
 465         *cursor2 = *cursor1;
 466
 467         /* copy the remainder... */
 468         while (*(cursor1++)) {
 469                 /* ... skipping all duplicated delimiters */
 470                 if (IS_DELIM(*cursor1) && IS_DELIM(*cursor2))
 471                         continue;
 472                 *(++cursor2) = *cursor1;
 473         }
 474
 475         /* if the last character is a delimiter, skip it */
 476         if (IS_DELIM(*(cursor2 - 1)))
 477                 cursor2--;
 478
 479         *cursor2 = '\0';
 480         if (!*prepath)
 481                 return NULL;
 482         s = kstrdup(prepath, gfp);
 483         if (!s)
 484                 return ERR_PTR(-ENOMEM);
 485         return s;
 486 }
 487
 488 /*
 489  * Return full path based on the values of @ctx->{UNC,prepath}.
 490  *
 491  * It is assumed that both values were already parsed by smb3_parse_devname().
 492  */
 493 char *smb3_fs_context_fullpath(const struct smb3_fs_context *ctx, char dirsep)
 494 {
 495         size_t ulen, plen;
 496         char *s;
 497
 498         ulen = strlen(ctx->UNC);
 499         plen = ctx->prepath ? strlen(ctx->prepath) + 1 : 0;
 500
 501         s = kmalloc(ulen + plen + 1, GFP_KERNEL);
 502         if (!s)
 503                 return ERR_PTR(-ENOMEM);
 504         memcpy(s, ctx->UNC, ulen);
 505         if (plen) {
 506                 s[ulen] = dirsep;
 507                 memcpy(s + ulen + 1, ctx->prepath, plen);
 508         }
 509         s[ulen + plen] = '\0';
 510         convert_delimiter(s, dirsep);
 511         return s;
 512 }
 513
 514 /*
 515  * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
 516  * fields with the result. Returns 0 on success and an error otherwise
 517  * (e.g. ENOMEM or EINVAL)
 518  */
 519 int
 520 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
 521 {
 522         char *pos;
 523         const char *delims = "/\\";
 524         size_t len;
 525         int rc;
 526
 527         if (unlikely(!devname || !*devname)) {
 528                 cifs_dbg(VFS, "Device name not specified\n");
 529                 return -EINVAL;
 530         }
 531
 532         /* make sure we have a valid UNC double delimiter prefix */
 533         len = strspn(devname, delims);
 534         if (len != 2)
 535                 return -EINVAL;
 536
 537         /* find delimiter between host and sharename */
 538         pos = strpbrk(devname + 2, delims);
 539         if (!pos)
 540                 return -EINVAL;
 541
 542         /* record the server hostname */
 543         kfree(ctx->server_hostname);
 544         ctx->server_hostname = kstrndup(devname + 2, pos - devname - 2, GFP_KERNEL);
 545         if (!ctx->server_hostname)
 546                 return -ENOMEM;
 547
 548         /* skip past delimiter */
 549         ++pos;
 550
 551         /* now go until next delimiter or end of string */
 552         len = strcspn(pos, delims);
 553         if (!len)
 554                 return -EINVAL;
 555
 556         /* move "pos" up to delimiter or NULL */
 557         pos += len;
 558         kfree(ctx->UNC);
 559         ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
 560         if (!ctx->UNC)
 561                 return -ENOMEM;
 562
 563         convert_delimiter(ctx->UNC, '\\');
 564
 565         /* skip any delimiter */
 566         if (*pos == '/' || *pos == '\\')
 567                 pos++;
 568
 569         kfree(ctx->prepath);
 570         ctx->prepath = NULL;
 571
 572         /* If pos is NULL then no prepath */
 573         if (!*pos)
 574                 return 0;
 575
 576         ctx->prepath = cifs_sanitize_prepath(pos, GFP_KERNEL);
 577         if (IS_ERR(ctx->prepath)) {
 578                 rc = PTR_ERR(ctx->prepath);
 579                 ctx->prepath = NULL;
 580                 return rc;
 581         }
 582
 583         return 0;
 584 }
 585
 586 static void smb3_fs_context_free(struct fs_context *fc);
 587 static int smb3_fs_context_parse_param(struct fs_context *fc,
 588                                        struct fs_parameter *param);
 589 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 590                                             void *data);
 591 static int smb3_get_tree(struct fs_context *fc);
 592 static int smb3_reconfigure(struct fs_context *fc);
 593
 594 static const struct fs_context_operations smb3_fs_context_ops = {
 595         .free                   = smb3_fs_context_free,
 596         .parse_param            = smb3_fs_context_parse_param,
 597         .parse_monolithic       = smb3_fs_context_parse_monolithic,
 598         .get_tree               = smb3_get_tree,
 599         .reconfigure            = smb3_reconfigure,
 600 };
 601
 602 /*
 603  * Parse a monolithic block of data from sys_mount().
 604  * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
 605  * @ctx: The superblock configuration to fill in.
 606  * @data: The data to parse
 607  *
 608  * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
 609  * called from the ->monolithic_mount_data() fs_context operation.
 610  *
 611  * Returns 0 on success or the error returned by the ->parse_option() fs_context
 612  * operation on failure.
 613  */
 614 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 615                                            void *data)
 616 {
 617         char *options = data, *key;
 618         int ret = 0;
 619
 620         if (!options)
 621                 return 0;
 622
 623         ret = security_sb_eat_lsm_opts(options, &fc->security);
 624         if (ret)
 625                 return ret;
 626
 627         /* BB Need to add support for sep= here TBD */
 628         while ((key = strsep(&options, ",")) != NULL) {
 629                 size_t len;
 630                 char *value;
 631
 632                 if (*key == 0)
 633                         break;
 634
 635                 /* Check if following character is the deliminator If yes,
 636                  * we have encountered a double deliminator reset the NULL
 637                  * character to the deliminator
 638                  */
 639                 while (options && options[0] == ',') {
 640                         len = strlen(key);
 641                         strcpy(key + len, options);
 642                         options = strchr(options, ',');
 643                         if (options)
 644                                 *options++ = 0;
 645                 }
 646
 647
 648                 len = 0;
 649                 value = strchr(key, '=');
 650                 if (value) {
 651                         if (value == key)
 652                                 continue;
 653                         *value++ = 0;
 654                         len = strlen(value);
 655                 }
 656
 657                 ret = vfs_parse_fs_string(fc, key, value, len);
 658                 if (ret < 0)
 659                         break;
 660         }
 661
 662         return ret;
 663 }
 664
 665 /*
 666  * Validate the preparsed information in the config.
 667  */
 668 static int smb3_fs_context_validate(struct fs_context *fc)
 669 {
 670         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 671
 672         if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
 673                 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
 674                 return -EOPNOTSUPP;
 675         }
 676
 677 #ifndef CONFIG_KEYS
 678         /* Muliuser mounts require CONFIG_KEYS support */
 679         if (ctx->multiuser) {
 680                 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
 681                 return -1;
 682         }
 683 #endif
 684
 685         if (ctx->got_version == false)
 686                 pr_warn_once("No dialect specified on mount. Default has changed to a more secure dialect, SMB2.1 or later (e.g. SMB3.1.1), from CIFS (SMB1). To use the less secure SMB1 dialect to access old servers which do not support SMB3.1.1 (or even SMB3 or SMB2.1) specify vers=1.0 on mount.\n");
 687
 688
 689         if (!ctx->UNC) {
 690                 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
 691                 return -1;
 692         }
 693
 694         /* make sure UNC has a share name */
 695         if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
 696                 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
 697                 return -ENOENT;
 698         }
 699
 700         if (!ctx->got_ip) {
 701                 int len;
 702                 const char *slash;
 703
 704                 /* No ip= option specified? Try to get it from UNC */
 705                 /* Use the address part of the UNC. */
 706                 slash = strchr(&ctx->UNC[2], '\\');
 707                 len = slash - &ctx->UNC[2];
 708                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
 709                                           &ctx->UNC[2], len)) {
 710                         pr_err("Unable to determine destination address\n");
 711                         return -EHOSTUNREACH;
 712                 }
 713         }
 714
 715         /* set the port that we got earlier */
 716         cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
 717
 718         if (ctx->uid_specified && !ctx->forceuid_specified) {
 719                 ctx->override_uid = 1;
 720                 pr_notice("enabling forceuid mount option implicitly because uid= option is specified\n");
 721         }
 722
 723         if (ctx->gid_specified && !ctx->forcegid_specified) {
 724                 ctx->override_gid = 1;
 725                 pr_notice("enabling forcegid mount option implicitly because gid= option is specified\n");
 726         }
 727
 728         if (ctx->override_uid && !ctx->uid_specified) {
 729                 ctx->override_uid = 0;
 730                 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
 731         }
 732
 733         if (ctx->override_gid && !ctx->gid_specified) {
 734                 ctx->override_gid = 0;
 735                 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
 736         }
 737
 738         return 0;
 739 }
 740
 741 static int smb3_get_tree_common(struct fs_context *fc)
 742 {
 743         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 744         struct dentry *root;
 745         int rc = 0;
 746
 747         root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
 748         if (IS_ERR(root))
 749                 return PTR_ERR(root);
 750
 751         fc->root = root;
 752
 753         return rc;
 754 }
 755
 756 /*
 757  * Create an SMB3 superblock from the parameters passed.
 758  */
 759 static int smb3_get_tree(struct fs_context *fc)
 760 {
 761         int err = smb3_fs_context_validate(fc);
 762         int ret;
 763
 764         if (err)
 765                 return err;
 766         cifs_mount_lock();
 767         ret = smb3_get_tree_common(fc);
 768         cifs_mount_unlock();
 769         return ret;
 770 }
 771
 772 static void smb3_fs_context_free(struct fs_context *fc)
 773 {
 774         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 775
 776         smb3_cleanup_fs_context(ctx);
 777 }
 778
 779 /*
 780  * Compare the old and new proposed context during reconfigure
 781  * and check if the changes are compatible.
 782  */
 783 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
 784                                        struct smb3_fs_context *new_ctx,
 785                                        struct smb3_fs_context *old_ctx, bool need_recon)
 786 {
 787         if (new_ctx->posix_paths != old_ctx->posix_paths) {
 788                 cifs_errorf(fc, "can not change posixpaths during remount\n");
 789                 return -EINVAL;
 790         }
 791         if (new_ctx->sectype != old_ctx->sectype) {
 792                 cifs_errorf(fc, "can not change sec during remount\n");
 793                 return -EINVAL;
 794         }
 795         if (new_ctx->multiuser != old_ctx->multiuser) {
 796                 cifs_errorf(fc, "can not change multiuser during remount\n");
 797                 return -EINVAL;
 798         }
 799         if (new_ctx->UNC &&
 800             (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
 801                 cifs_errorf(fc, "can not change UNC during remount\n");
 802                 return -EINVAL;
 803         }
 804         if (new_ctx->username &&
 805             (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
 806                 cifs_errorf(fc, "can not change username during remount\n");
 807                 return -EINVAL;
 808         }
 809         if (new_ctx->password &&
 810             (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
 811                 if (need_recon == false) {
 812                         cifs_errorf(fc,
 813                                     "can not change password of active session during remount\n");
 814                         return -EINVAL;
 815                 } else if (old_ctx->sectype == Kerberos) {
 816                         cifs_errorf(fc,
 817                                     "can not change password for Kerberos via remount\n");
 818                         return -EINVAL;
 819                 }
 820         }
 821         if (new_ctx->domainname &&
 822             (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
 823                 cifs_errorf(fc, "can not change domainname during remount\n");
 824                 return -EINVAL;
 825         }
 826         if (strcmp(new_ctx->workstation_name, old_ctx->workstation_name)) {
 827                 cifs_errorf(fc, "can not change workstation_name during remount\n");
 828                 return -EINVAL;
 829         }
 830         if (new_ctx->nodename &&
 831             (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
 832                 cifs_errorf(fc, "can not change nodename during remount\n");
 833                 return -EINVAL;
 834         }
 835         if (new_ctx->iocharset &&
 836             (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
 837                 cifs_errorf(fc, "can not change iocharset during remount\n");
 838                 return -EINVAL;
 839         }
 840
 841         return 0;
 842 }
 843
 844 #define STEAL_STRING(cifs_sb, ctx, field)                               \
 845 do {                                                                    \
 846         kfree(ctx->field);                                              \
 847         ctx->field = cifs_sb->ctx->field;                               \
 848         cifs_sb->ctx->field = NULL;                                     \
 849 } while (0)
 850
 851 #define STEAL_STRING_SENSITIVE(cifs_sb, ctx, field)                     \
 852 do {                                                                    \
 853         kfree_sensitive(ctx->field);                                    \
 854         ctx->field = cifs_sb->ctx->field;                               \
 855         cifs_sb->ctx->field = NULL;                                     \
 856 } while (0)
 857
 858 static int smb3_reconfigure(struct fs_context *fc)
 859 {
 860         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 861         struct dentry *root = fc->root;
 862         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 863         struct cifs_ses *ses = cifs_sb_master_tcon(cifs_sb)->ses;
 864         bool need_recon = false;
 865         int rc;
 866
 867         if (ses->expired_pwd)
 868                 need_recon = true;
 869
 870         rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx, need_recon);
 871         if (rc)
 872                 return rc;
 873
 874         /*
 875          * We can not change UNC/username/password/domainname/
 876          * workstation_name/nodename/iocharset
 877          * during reconnect so ignore what we have in the new context and
 878          * just use what we already have in cifs_sb->ctx.
 879          */
 880         STEAL_STRING(cifs_sb, ctx, UNC);
 881         STEAL_STRING(cifs_sb, ctx, source);
 882         STEAL_STRING(cifs_sb, ctx, username);
 883         if (need_recon == false)
 884                 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password);
 885         else  {
 886                 kfree_sensitive(ses->password);
 887                 ses->password = kstrdup(ctx->password, GFP_KERNEL);
 888         }
 889         STEAL_STRING(cifs_sb, ctx, domainname);
 890         STEAL_STRING(cifs_sb, ctx, nodename);
 891         STEAL_STRING(cifs_sb, ctx, iocharset);
 892
 893         /* if rsize or wsize not passed in on remount, use previous values */
 894         if (ctx->rsize == 0)
 895                 ctx->rsize = cifs_sb->ctx->rsize;
 896         if (ctx->wsize == 0)
 897                 ctx->wsize = cifs_sb->ctx->wsize;
 898
 899
 900         smb3_cleanup_fs_context_contents(cifs_sb->ctx);
 901         rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
 902         smb3_update_mnt_flags(cifs_sb);
 903 #ifdef CONFIG_CIFS_DFS_UPCALL
 904         if (!rc)
 905                 rc = dfs_cache_remount_fs(cifs_sb);
 906 #endif
 907
 908         return rc;
 909 }
 910
 911 static int smb3_fs_context_parse_param(struct fs_context *fc,
 912                                       struct fs_parameter *param)
 913 {
 914         struct fs_parse_result result;
 915         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 916         int i, opt;
 917         bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
 918         bool skip_parsing = false;
 919         kuid_t uid;
 920         kgid_t gid;
 921
 922         cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
 923
 924         /*
 925          * fs_parse can not handle string options with an empty value so
 926          * we will need special handling of them.
 927          */
 928         if (param->type == fs_value_is_string && param->string[0] == 0) {
 929                 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
 930                         skip_parsing = true;
 931                         opt = Opt_pass;
 932                 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
 933                         skip_parsing = true;
 934                         opt = Opt_user;
 935                 }
 936         }
 937
 938         if (!skip_parsing) {
 939                 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
 940                 if (opt < 0)
 941                         return ctx->sloppy ? 1 : opt;
 942         }
 943
 944         switch (opt) {
 945         case Opt_compress:
 946                 ctx->compression = UNKNOWN_TYPE;
 947                 cifs_dbg(VFS,
 948                         "SMB3 compression support is experimental\n");
 949                 break;
 950         case Opt_nodfs:
 951                 ctx->nodfs = 1;
 952                 break;
 953         case Opt_hard:
 954                 if (result.negated) {
 955                         if (ctx->retry == 1)
 956                                 cifs_dbg(VFS, "conflicting hard vs. soft mount options\n");
 957                         ctx->retry = 0;
 958                 } else
 959                         ctx->retry = 1;
 960                 break;
 961         case Opt_soft:
 962                 if (result.negated)
 963                         ctx->retry = 1;
 964                 else {
 965                         if (ctx->retry == 1)
 966                                 cifs_dbg(VFS, "conflicting hard vs soft mount options\n");
 967                         ctx->retry = 0;
 968                 }
 969                 break;
 970         case Opt_mapposix:
 971                 if (result.negated)
 972                         ctx->remap = false;
 973                 else {
 974                         ctx->remap = true;
 975                         ctx->sfu_remap = false; /* disable SFU mapping */
 976                 }
 977                 break;
 978         case Opt_mapchars:
 979                 if (result.negated)
 980                         ctx->sfu_remap = false;
 981                 else {
 982                         ctx->sfu_remap = true;
 983                         ctx->remap = false; /* disable SFM (mapposix) mapping */
 984                 }
 985                 break;
 986         case Opt_user_xattr:
 987                 if (result.negated)
 988                         ctx->no_xattr = 1;
 989                 else
 990                         ctx->no_xattr = 0;
 991                 break;
 992         case Opt_forceuid:
 993                 if (result.negated)
 994                         ctx->override_uid = 0;
 995                 else
 996                         ctx->override_uid = 1;
 997                 ctx->forceuid_specified = true;
 998                 break;
 999         case Opt_forcegid:
1000                 if (result.negated)
1001                         ctx->override_gid = 0;
1002                 else
1003                         ctx->override_gid = 1;
1004                 ctx->forcegid_specified = true;
1005                 break;
1006         case Opt_perm:
1007                 if (result.negated)
1008                         ctx->noperm = 1;
1009                 else
1010                         ctx->noperm = 0;
1011                 break;
1012         case Opt_dynperm:
1013                 if (result.negated)
1014                         ctx->dynperm = 0;
1015                 else
1016                         ctx->dynperm = 1;
1017                 break;
1018         case Opt_sfu:
1019                 if (result.negated)
1020                         ctx->sfu_emul = 0;
1021                 else
1022                         ctx->sfu_emul = 1;
1023                 break;
1024         case Opt_noblocksend:
1025                 ctx->noblocksnd = 1;
1026                 break;
1027         case Opt_noautotune:
1028                 ctx->noautotune = 1;
1029                 break;
1030         case Opt_nolease:
1031                 ctx->no_lease = 1;
1032                 break;
1033         case Opt_nosparse:
1034                 ctx->no_sparse = 1;
1035                 break;
1036         case Opt_nodelete:
1037                 ctx->nodelete = 1;
1038                 break;
1039         case Opt_multichannel:
1040                 if (result.negated) {
1041                         ctx->multichannel = false;
1042                         ctx->max_channels = 1;
1043                 } else {
1044                         ctx->multichannel = true;
1045                         /* if number of channels not specified, default to 2 */
1046                         if (ctx->max_channels < 2)
1047                                 ctx->max_channels = 2;
1048                 }
1049                 break;
1050         case Opt_uid:
1051                 uid = make_kuid(current_user_ns(), result.uint_32);
1052                 if (!uid_valid(uid))
1053                         goto cifs_parse_mount_err;
1054                 ctx->linux_uid = uid;
1055                 ctx->uid_specified = true;
1056                 break;
1057         case Opt_cruid:
1058                 uid = make_kuid(current_user_ns(), result.uint_32);
1059                 if (!uid_valid(uid))
1060                         goto cifs_parse_mount_err;
1061                 ctx->cred_uid = uid;
1062                 ctx->cruid_specified = true;
1063                 break;
1064         case Opt_backupuid:
1065                 uid = make_kuid(current_user_ns(), result.uint_32);
1066                 if (!uid_valid(uid))
1067                         goto cifs_parse_mount_err;
1068                 ctx->backupuid = uid;
1069                 ctx->backupuid_specified = true;
1070                 break;
1071         case Opt_backupgid:
1072                 gid = make_kgid(current_user_ns(), result.uint_32);
1073                 if (!gid_valid(gid))
1074                         goto cifs_parse_mount_err;
1075                 ctx->backupgid = gid;
1076                 ctx->backupgid_specified = true;
1077                 break;
1078         case Opt_gid:
1079                 gid = make_kgid(current_user_ns(), result.uint_32);
1080                 if (!gid_valid(gid))
1081                         goto cifs_parse_mount_err;
1082                 ctx->linux_gid = gid;
1083                 ctx->gid_specified = true;
1084                 break;
1085         case Opt_port:
1086                 ctx->port = result.uint_32;
1087                 break;
1088         case Opt_file_mode:
1089                 ctx->file_mode = result.uint_32;
1090                 break;
1091         case Opt_dirmode:
1092                 ctx->dir_mode = result.uint_32;
1093                 break;
1094         case Opt_min_enc_offload:
1095                 ctx->min_offload = result.uint_32;
1096                 break;
1097         case Opt_retrans:
1098                 ctx->retrans = result.uint_32;
1099                 break;
1100         case Opt_blocksize:
1101                 /*
1102                  * inode blocksize realistically should never need to be
1103                  * less than 16K or greater than 16M and default is 1MB.
1104                  * Note that small inode block sizes (e.g. 64K) can lead
1105                  * to very poor performance of common tools like cp and scp
1106                  */
1107                 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1108                    (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1109                         cifs_errorf(fc, "%s: Invalid blocksize\n",
1110                                 __func__);
1111                         goto cifs_parse_mount_err;
1112                 }
1113                 ctx->bsize = result.uint_32;
1114                 ctx->got_bsize = true;
1115                 break;
1116         case Opt_rasize:
1117                 /*
1118                  * readahead size realistically should never need to be
1119                  * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1120                  * (perhaps an exception should be considered in the
1121                  * for the case of a large number of channels
1122                  * when multichannel is negotiated) since that would lead
1123                  * to plenty of parallel I/O in flight to the server.
1124                  * Note that smaller read ahead sizes would
1125                  * hurt performance of common tools like cp and scp
1126                  * which often trigger sequential i/o with read ahead
1127                  */
1128                 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1129                     (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1130                         cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1131                                 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1132                         goto cifs_parse_mount_err;
1133                 }
1134                 ctx->rasize = result.uint_32;
1135                 break;
1136         case Opt_rsize:
1137                 ctx->rsize = result.uint_32;
1138                 ctx->got_rsize = true;
1139                 break;
1140         case Opt_wsize:
1141                 ctx->wsize = result.uint_32;
1142                 ctx->got_wsize = true;
1143                 if (ctx->wsize % PAGE_SIZE != 0) {
1144                         ctx->wsize = round_down(ctx->wsize, PAGE_SIZE);
1145                         if (ctx->wsize == 0) {
1146                                 ctx->wsize = PAGE_SIZE;
1147                                 cifs_dbg(VFS, "wsize too small, reset to minimum %ld\n", PAGE_SIZE);
1148                         } else {
1149                                 cifs_dbg(VFS,
1150                                          "wsize rounded down to %d to multiple of PAGE_SIZE %ld\n",
1151                                          ctx->wsize, PAGE_SIZE);
1152                         }
1153                 }
1154                 break;
1155         case Opt_acregmax:
1156                 ctx->acregmax = HZ * result.uint_32;
1157                 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1158                         cifs_errorf(fc, "acregmax too large\n");
1159                         goto cifs_parse_mount_err;
1160                 }
1161                 break;
1162         case Opt_acdirmax:
1163                 ctx->acdirmax = HZ * result.uint_32;
1164                 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1165                         cifs_errorf(fc, "acdirmax too large\n");
1166                         goto cifs_parse_mount_err;
1167                 }
1168                 break;
1169         case Opt_actimeo:
1170                 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1171                         cifs_errorf(fc, "timeout too large\n");
1172                         goto cifs_parse_mount_err;
1173                 }
1174                 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1175                     (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1176                         cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1177                         break;
1178                 }
1179                 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1180                 break;
1181         case Opt_closetimeo:
1182                 ctx->closetimeo = HZ * result.uint_32;
1183                 if (ctx->closetimeo > SMB3_MAX_DCLOSETIMEO) {
1184                         cifs_errorf(fc, "closetimeo too large\n");
1185                         goto cifs_parse_mount_err;
1186                 }
1187                 break;
1188         case Opt_echo_interval:
1189                 ctx->echo_interval = result.uint_32;
1190                 break;
1191         case Opt_snapshot:
1192                 ctx->snapshot_time = result.uint_64;
1193                 break;
1194         case Opt_max_credits:
1195                 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1196                         cifs_errorf(fc, "%s: Invalid max_credits value\n",
1197                                  __func__);
1198                         goto cifs_parse_mount_err;
1199                 }
1200                 ctx->max_credits = result.uint_32;
1201                 break;
1202         case Opt_max_channels:
1203                 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1204                         cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1205                                  __func__, CIFS_MAX_CHANNELS);
1206                         goto cifs_parse_mount_err;
1207                 }
1208                 ctx->max_channels = result.uint_32;
1209                 /* If more than one channel requested ... they want multichan */
1210                 if (result.uint_32 > 1)
1211                         ctx->multichannel = true;
1212                 break;
1213         case Opt_max_cached_dirs:
1214                 if (result.uint_32 < 1) {
1215                         cifs_errorf(fc, "%s: Invalid max_cached_dirs, needs to be 1 or more\n",
1216                                     __func__);
1217                         goto cifs_parse_mount_err;
1218                 }
1219                 ctx->max_cached_dirs = result.uint_32;
1220                 break;
1221         case Opt_handletimeout:
1222                 ctx->handle_timeout = result.uint_32;
1223                 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1224                         cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1225                         goto cifs_parse_mount_err;
1226                 }
1227                 break;
1228         case Opt_source:
1229                 kfree(ctx->UNC);
1230                 ctx->UNC = NULL;
1231                 switch (smb3_parse_devname(param->string, ctx)) {
1232                 case 0:
1233                         break;
1234                 case -ENOMEM:
1235                         cifs_errorf(fc, "Unable to allocate memory for devname\n");
1236                         goto cifs_parse_mount_err;
1237                 case -EINVAL:
1238                         cifs_errorf(fc, "Malformed UNC in devname\n");
1239                         goto cifs_parse_mount_err;
1240                 default:
1241                         cifs_errorf(fc, "Unknown error parsing devname\n");
1242                         goto cifs_parse_mount_err;
1243                 }
1244                 ctx->source = smb3_fs_context_fullpath(ctx, '/');
1245                 if (IS_ERR(ctx->source)) {
1246                         ctx->source = NULL;
1247                         cifs_errorf(fc, "OOM when copying UNC string\n");
1248                         goto cifs_parse_mount_err;
1249                 }
1250                 fc->source = kstrdup(ctx->source, GFP_KERNEL);
1251                 if (fc->source == NULL) {
1252                         cifs_errorf(fc, "OOM when copying UNC string\n");
1253                         goto cifs_parse_mount_err;
1254                 }
1255                 break;
1256         case Opt_user:
1257                 kfree(ctx->username);
1258                 ctx->username = NULL;
1259                 if (ctx->nullauth)
1260                         break;
1261                 if (strlen(param->string) == 0) {
1262                         /* null user, ie. anonymous authentication */
1263                         ctx->nullauth = 1;
1264                         break;
1265                 }
1266
1267                 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1268                     CIFS_MAX_USERNAME_LEN) {
1269                         pr_warn("username too long\n");
1270                         goto cifs_parse_mount_err;
1271                 }
1272                 ctx->username = kstrdup(param->string, GFP_KERNEL);
1273                 if (ctx->username == NULL) {
1274                         cifs_errorf(fc, "OOM when copying username string\n");
1275                         goto cifs_parse_mount_err;
1276                 }
1277                 break;
1278         case Opt_pass:
1279                 kfree_sensitive(ctx->password);
1280                 ctx->password = NULL;
1281                 if (strlen(param->string) == 0)
1282                         break;
1283
1284                 ctx->password = kstrdup(param->string, GFP_KERNEL);
1285                 if (ctx->password == NULL) {
1286                         cifs_errorf(fc, "OOM when copying password string\n");
1287                         goto cifs_parse_mount_err;
1288                 }
1289                 break;
1290         case Opt_ip:
1291                 if (strlen(param->string) == 0) {
1292                         ctx->got_ip = false;
1293                         break;
1294                 }
1295                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1296                                           param->string,
1297                                           strlen(param->string))) {
1298                         pr_err("bad ip= option (%s)\n", param->string);
1299                         goto cifs_parse_mount_err;
1300                 }
1301                 ctx->got_ip = true;
1302                 break;
1303         case Opt_domain:
1304                 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1305                                 == CIFS_MAX_DOMAINNAME_LEN) {
1306                         pr_warn("domain name too long\n");
1307                         goto cifs_parse_mount_err;
1308                 }
1309
1310                 kfree(ctx->domainname);
1311                 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1312                 if (ctx->domainname == NULL) {
1313                         cifs_errorf(fc, "OOM when copying domainname string\n");
1314                         goto cifs_parse_mount_err;
1315                 }
1316                 cifs_dbg(FYI, "Domain name set\n");
1317                 break;
1318         case Opt_srcaddr:
1319                 if (!cifs_convert_address(
1320                                 (struct sockaddr *)&ctx->srcaddr,
1321                                 param->string, strlen(param->string))) {
1322                         pr_warn("Could not parse srcaddr: %s\n",
1323                                 param->string);
1324                         goto cifs_parse_mount_err;
1325                 }
1326                 break;
1327         case Opt_iocharset:
1328                 if (strnlen(param->string, 1024) >= 65) {
1329                         pr_warn("iocharset name too long\n");
1330                         goto cifs_parse_mount_err;
1331                 }
1332
1333                 if (strncasecmp(param->string, "default", 7) != 0) {
1334                         kfree(ctx->iocharset);
1335                         ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1336                         if (ctx->iocharset == NULL) {
1337                                 cifs_errorf(fc, "OOM when copying iocharset string\n");
1338                                 goto cifs_parse_mount_err;
1339                         }
1340                 }
1341                 /* if iocharset not set then load_nls_default
1342                  * is used by caller
1343                  */
1344                 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1345                 break;
1346         case Opt_netbiosname:
1347                 memset(ctx->source_rfc1001_name, 0x20,
1348                         RFC1001_NAME_LEN);
1349                 /*
1350                  * FIXME: are there cases in which a comma can
1351                  * be valid in workstation netbios name (and
1352                  * need special handling)?
1353                  */
1354                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1355                         /* don't ucase netbiosname for user */
1356                         if (param->string[i] == 0)
1357                                 break;
1358                         ctx->source_rfc1001_name[i] = param->string[i];
1359                 }
1360                 /* The string has 16th byte zero still from
1361                  * set at top of the function
1362                  */
1363                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1364                         pr_warn("netbiosname longer than 15 truncated\n");
1365                 break;
1366         case Opt_servern:
1367                 /* last byte, type, is 0x20 for servr type */
1368                 memset(ctx->target_rfc1001_name, 0x20,
1369                         RFC1001_NAME_LEN_WITH_NULL);
1370                 /*
1371                  * BB are there cases in which a comma can be valid in this
1372                  * workstation netbios name (and need special handling)?
1373                  */
1374
1375                 /* user or mount helper must uppercase the netbios name */
1376                 for (i = 0; i < 15; i++) {
1377                         if (param->string[i] == 0)
1378                                 break;
1379                         ctx->target_rfc1001_name[i] = param->string[i];
1380                 }
1381
1382                 /* The string has 16th byte zero still from set at top of function */
1383                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1384                         pr_warn("server netbiosname longer than 15 truncated\n");
1385                 break;
1386         case Opt_ver:
1387                 /* version of mount userspace tools, not dialect */
1388                 /* If interface changes in mount.cifs bump to new ver */
1389                 if (strncasecmp(param->string, "1", 1) == 0) {
1390                         if (strlen(param->string) > 1) {
1391                                 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1392                                         param->string);
1393                                 goto cifs_parse_mount_err;
1394                         }
1395                         /* This is the default */
1396                         break;
1397                 }
1398                 /* For all other value, error */
1399                 pr_warn("Invalid mount helper version specified\n");
1400                 goto cifs_parse_mount_err;
1401         case Opt_vers:
1402                 /* protocol version (dialect) */
1403                 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1404                         goto cifs_parse_mount_err;
1405                 ctx->got_version = true;
1406                 break;
1407         case Opt_sec:
1408                 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1409                         goto cifs_parse_mount_err;
1410                 break;
1411         case Opt_cache:
1412                 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1413                         goto cifs_parse_mount_err;
1414                 break;
1415         case Opt_witness:
1416 #ifndef CONFIG_CIFS_SWN_UPCALL
1417                 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1418                         goto cifs_parse_mount_err;
1419 #endif
1420                 ctx->witness = true;
1421                 pr_warn_once("Witness protocol support is experimental\n");
1422                 break;
1423         case Opt_rootfs:
1424 #ifndef CONFIG_CIFS_ROOT
1425                 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1426                 goto cifs_parse_mount_err;
1427 #endif
1428                 ctx->rootfs = true;
1429                 break;
1430         case Opt_posixpaths:
1431                 if (result.negated)
1432                         ctx->posix_paths = 0;
1433                 else
1434                         ctx->posix_paths = 1;
1435                 break;
1436         case Opt_unix:
1437                 if (result.negated) {
1438                         if (ctx->linux_ext == 1)
1439                                 pr_warn_once("conflicting posix mount options specified\n");
1440                         ctx->linux_ext = 0;
1441                         ctx->no_linux_ext = 1;
1442                 } else {
1443                         if (ctx->no_linux_ext == 1)
1444                                 pr_warn_once("conflicting posix mount options specified\n");
1445                         ctx->linux_ext = 1;
1446                         ctx->no_linux_ext = 0;
1447                 }
1448                 break;
1449         case Opt_nocase:
1450                 ctx->nocase = 1;
1451                 break;
1452         case Opt_brl:
1453                 if (result.negated) {
1454                         /*
1455                          * turn off mandatory locking in mode
1456                          * if remote locking is turned off since the
1457                          * local vfs will do advisory
1458                          */
1459                         if (ctx->file_mode ==
1460                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1461                                 ctx->file_mode = S_IALLUGO;
1462                         ctx->nobrl =  1;
1463                 } else
1464                         ctx->nobrl =  0;
1465                 break;
1466         case Opt_handlecache:
1467                 if (result.negated)
1468                         ctx->nohandlecache = 1;
1469                 else
1470                         ctx->nohandlecache = 0;
1471                 break;
1472         case Opt_forcemandatorylock:
1473                 ctx->mand_lock = 1;
1474                 break;
1475         case Opt_setuids:
1476                 ctx->setuids = result.negated;
1477                 break;
1478         case Opt_intr:
1479                 ctx->intr = !result.negated;
1480                 break;
1481         case Opt_setuidfromacl:
1482                 ctx->setuidfromacl = 1;
1483                 break;
1484         case Opt_strictsync:
1485                 ctx->nostrictsync = result.negated;
1486                 break;
1487         case Opt_serverino:
1488                 ctx->server_ino = !result.negated;
1489                 break;
1490         case Opt_rwpidforward:
1491                 ctx->rwpidforward = 1;
1492                 break;
1493         case Opt_modesid:
1494                 ctx->mode_ace = 1;
1495                 break;
1496         case Opt_cifsacl:
1497                 ctx->cifs_acl = !result.negated;
1498                 break;
1499         case Opt_acl:
1500                 ctx->no_psx_acl = result.negated;
1501                 break;
1502         case Opt_locallease:
1503                 ctx->local_lease = 1;
1504                 break;
1505         case Opt_sign:
1506                 ctx->sign = true;
1507                 break;
1508         case Opt_ignore_signature:
1509                 ctx->sign = true;
1510                 ctx->ignore_signature = true;
1511                 break;
1512         case Opt_seal:
1513                 /* we do not do the following in secFlags because seal
1514                  * is a per tree connection (mount) not a per socket
1515                  * or per-smb connection option in the protocol
1516                  * vol->secFlg |= CIFSSEC_MUST_SEAL;
1517                  */
1518                 ctx->seal = 1;
1519                 break;
1520         case Opt_noac:
1521                 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1522                 break;
1523         case Opt_fsc:
1524 #ifndef CONFIG_CIFS_FSCACHE
1525                 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1526                 goto cifs_parse_mount_err;
1527 #endif
1528                 ctx->fsc = true;
1529                 break;
1530         case Opt_mfsymlinks:
1531                 ctx->mfsymlinks = true;
1532                 break;
1533         case Opt_multiuser:
1534                 ctx->multiuser = true;
1535                 break;
1536         case Opt_sloppy:
1537                 ctx->sloppy = true;
1538                 break;
1539         case Opt_nosharesock:
1540                 ctx->nosharesock = true;
1541                 break;
1542         case Opt_persistent:
1543                 if (result.negated) {
1544                         ctx->nopersistent = true;
1545                         if (ctx->persistent) {
1546                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1547                                 goto cifs_parse_mount_err;
1548                         }
1549                 } else {
1550                         ctx->persistent = true;
1551                         if ((ctx->nopersistent) || (ctx->resilient)) {
1552                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1553                                 goto cifs_parse_mount_err;
1554                         }
1555                 }
1556                 break;
1557         case Opt_resilient:
1558                 if (result.negated) {
1559                         ctx->resilient = false; /* already the default */
1560                 } else {
1561                         ctx->resilient = true;
1562                         if (ctx->persistent) {
1563                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1564                                 goto cifs_parse_mount_err;
1565                         }
1566                 }
1567                 break;
1568         case Opt_tcp_nodelay:
1569                 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1570                 if (result.negated)
1571                         ctx->sockopt_tcp_nodelay = false;
1572                 else
1573                         ctx->sockopt_tcp_nodelay = true;
1574                 break;
1575         case Opt_domainauto:
1576                 ctx->domainauto = true;
1577                 break;
1578         case Opt_rdma:
1579                 ctx->rdma = true;
1580                 break;
1581         }
1582         /* case Opt_ignore: - is ignored as expected ... */
1583
1584         return 0;
1585
1586  cifs_parse_mount_err:
1587         kfree_sensitive(ctx->password);
1588         ctx->password = NULL;
1589         return -EINVAL;
1590 }
1591
1592 int smb3_init_fs_context(struct fs_context *fc)
1593 {
1594         struct smb3_fs_context *ctx;
1595         char *nodename = utsname()->nodename;
1596         int i;
1597
1598         ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1599         if (unlikely(!ctx))
1600                 return -ENOMEM;
1601
1602         strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1603
1604         /*
1605          * does not have to be perfect mapping since field is
1606          * informational, only used for servers that do not support
1607          * port 445 and it can be overridden at mount time
1608          */
1609         memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1610         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1611                 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1612
1613         ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1614         /*
1615          * null target name indicates to use *SMBSERVR default called name
1616          *  if we end up sending RFC1001 session initialize
1617          */
1618         ctx->target_rfc1001_name[0] = 0;
1619         ctx->cred_uid = current_uid();
1620         ctx->linux_uid = current_uid();
1621         ctx->linux_gid = current_gid();
1622         /* By default 4MB read ahead size, 1MB block size */
1623         ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1624         ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1625
1626         /*
1627          * default to SFM style remapping of seven reserved characters
1628          * unless user overrides it or we negotiate CIFS POSIX where
1629          * it is unnecessary.  Can not simultaneously use more than one mapping
1630          * since then readdir could list files that open could not open
1631          */
1632         ctx->remap = true;
1633
1634         /* default to only allowing write access to owner of the mount */
1635         ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1636
1637         /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1638         /* default is always to request posix paths. */
1639         ctx->posix_paths = 1;
1640         /* default to using server inode numbers where available */
1641         ctx->server_ino = 1;
1642
1643         /* default is to use strict cifs caching semantics */
1644         ctx->strict_io = true;
1645
1646         ctx->acregmax = CIFS_DEF_ACTIMEO;
1647         ctx->acdirmax = CIFS_DEF_ACTIMEO;
1648         ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1649         ctx->max_cached_dirs = MAX_CACHED_FIDS;
1650         /* Most clients set timeout to 0, allows server to use its default */
1651         ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1652
1653         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1654         ctx->ops = &smb30_operations;
1655         ctx->vals = &smbdefault_values;
1656
1657         ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1658
1659         /* default to no multichannel (single server connection) */
1660         ctx->multichannel = false;
1661         ctx->max_channels = 1;
1662
1663         ctx->backupuid_specified = false; /* no backup intent for a user */
1664         ctx->backupgid_specified = false; /* no backup intent for a group */
1665
1666         ctx->retrans = 1;
1667
1668 /*
1669  *      short int override_uid = -1;
1670  *      short int override_gid = -1;
1671  *      char *nodename = strdup(utsname()->nodename);
1672  *      struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1673  */
1674
1675         fc->fs_private = ctx;
1676         fc->ops = &smb3_fs_context_ops;
1677         return 0;
1678 }
1679
1680 void
1681 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1682 {
1683         if (ctx == NULL)
1684                 return;
1685
1686         /*
1687          * Make sure this stays in sync with smb3_fs_context_dup()
1688          */
1689         kfree(ctx->username);
1690         ctx->username = NULL;
1691         kfree_sensitive(ctx->password);
1692         ctx->password = NULL;
1693         kfree(ctx->server_hostname);
1694         ctx->server_hostname = NULL;
1695         kfree(ctx->UNC);
1696         ctx->UNC = NULL;
1697         kfree(ctx->source);
1698         ctx->source = NULL;
1699         kfree(ctx->domainname);
1700         ctx->domainname = NULL;
1701         kfree(ctx->nodename);
1702         ctx->nodename = NULL;
1703         kfree(ctx->iocharset);
1704         ctx->iocharset = NULL;
1705         kfree(ctx->prepath);
1706         ctx->prepath = NULL;
1707         kfree(ctx->leaf_fullpath);
1708         ctx->leaf_fullpath = NULL;
1709 }
1710
1711 void
1712 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1713 {
1714         if (!ctx)
1715                 return;
1716         smb3_cleanup_fs_context_contents(ctx);
1717         kfree(ctx);
1718 }
1719
1720 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1721 {
1722         struct smb3_fs_context *ctx = cifs_sb->ctx;
1723
1724         if (ctx->nodfs)
1725                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1726         else
1727                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1728
1729         if (ctx->noperm)
1730                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1731         else
1732                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1733
1734         if (ctx->setuids)
1735                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1736         else
1737                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1738
1739         if (ctx->setuidfromacl)
1740                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1741         else
1742                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1743
1744         if (ctx->server_ino)
1745                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1746         else
1747                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1748
1749         if (ctx->remap)
1750                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1751         else
1752                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1753
1754         if (ctx->sfu_remap)
1755                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1756         else
1757                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1758
1759         if (ctx->no_xattr)
1760                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1761         else
1762                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1763
1764         if (ctx->sfu_emul)
1765                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1766         else
1767                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1768
1769         if (ctx->nobrl)
1770                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1771         else
1772                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1773
1774         if (ctx->nohandlecache)
1775                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1776         else
1777                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1778
1779         if (ctx->nostrictsync)
1780                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1781         else
1782                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1783
1784         if (ctx->mand_lock)
1785                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1786         else
1787                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1788
1789         if (ctx->rwpidforward)
1790                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1791         else
1792                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1793
1794         if (ctx->mode_ace)
1795                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1796         else
1797                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1798
1799         if (ctx->cifs_acl)
1800                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1801         else
1802                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1803
1804         if (ctx->backupuid_specified)
1805                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1806         else
1807                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1808
1809         if (ctx->backupgid_specified)
1810                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1811         else
1812                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1813
1814         if (ctx->override_uid)
1815                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1816         else
1817                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1818
1819         if (ctx->override_gid)
1820                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1821         else
1822                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1823
1824         if (ctx->dynperm)
1825                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1826         else
1827                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1828
1829         if (ctx->fsc)
1830                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1831         else
1832                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1833
1834         if (ctx->multiuser)
1835                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1836                                             CIFS_MOUNT_NO_PERM);
1837         else
1838                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1839
1840
1841         if (ctx->strict_io)
1842                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1843         else
1844                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1845
1846         if (ctx->direct_io)
1847                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1848         else
1849                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1850
1851         if (ctx->mfsymlinks)
1852                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1853         else
1854                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1855         if (ctx->mfsymlinks) {
1856                 if (ctx->sfu_emul) {
1857                         /*
1858                          * Our SFU ("Services for Unix" emulation does not allow
1859                          * creating symlinks but does allow reading existing SFU
1860                          * symlinks (it does allow both creating and reading SFU
1861                          * style mknod and FIFOs though). When "mfsymlinks" and
1862                          * "sfu" are both enabled at the same time, it allows
1863                          * reading both types of symlinks, but will only create
1864                          * them with mfsymlinks format. This allows better
1865                          * Apple compatibility (probably better for Samba too)
1866                          * while still recognizing old Windows style symlinks.
1867                          */
1868                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1869                 }
1870         }
1871         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1872
1873         return;
1874 }