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