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          * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
 327          */
 328         DUP_CTX_STR(prepath);
 329         DUP_CTX_STR(mount_options);
 330         DUP_CTX_STR(username);
 331         DUP_CTX_STR(password);
 332         DUP_CTX_STR(UNC);
 333         DUP_CTX_STR(source);
 334         DUP_CTX_STR(domainname);
 335         DUP_CTX_STR(nodename);
 336         DUP_CTX_STR(iocharset);
 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  * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
 445  * fields with the result. Returns 0 on success and an error otherwise
 446  * (e.g. ENOMEM or EINVAL)
 447  */
 448 int
 449 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
 450 {
 451         char *pos;
 452         const char *delims = "/\\";
 453         size_t len;
 454
 455         if (unlikely(!devname || !*devname)) {
 456                 cifs_dbg(VFS, "Device name not specified\n");
 457                 return -EINVAL;
 458         }
 459
 460         /* make sure we have a valid UNC double delimiter prefix */
 461         len = strspn(devname, delims);
 462         if (len != 2)
 463                 return -EINVAL;
 464
 465         /* find delimiter between host and sharename */
 466         pos = strpbrk(devname + 2, delims);
 467         if (!pos)
 468                 return -EINVAL;
 469
 470         /* skip past delimiter */
 471         ++pos;
 472
 473         /* now go until next delimiter or end of string */
 474         len = strcspn(pos, delims);
 475
 476         /* move "pos" up to delimiter or NULL */
 477         pos += len;
 478         kfree(ctx->UNC);
 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         kfree(ctx->prepath);
 490         ctx->prepath = NULL;
 491
 492         /* If pos is NULL then no prepath */
 493         if (!*pos)
 494                 return 0;
 495
 496         ctx->prepath = kstrdup(pos, GFP_KERNEL);
 497         if (!ctx->prepath)
 498                 return -ENOMEM;
 499
 500         return 0;
 501 }
 502
 503 static void smb3_fs_context_free(struct fs_context *fc);
 504 static int smb3_fs_context_parse_param(struct fs_context *fc,
 505                                        struct fs_parameter *param);
 506 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 507                                             void *data);
 508 static int smb3_get_tree(struct fs_context *fc);
 509 static int smb3_reconfigure(struct fs_context *fc);
 510
 511 static const struct fs_context_operations smb3_fs_context_ops = {
 512         .free                   = smb3_fs_context_free,
 513         .parse_param            = smb3_fs_context_parse_param,
 514         .parse_monolithic       = smb3_fs_context_parse_monolithic,
 515         .get_tree               = smb3_get_tree,
 516         .reconfigure            = smb3_reconfigure,
 517 };
 518
 519 /*
 520  * Parse a monolithic block of data from sys_mount().
 521  * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
 522  * @ctx: The superblock configuration to fill in.
 523  * @data: The data to parse
 524  *
 525  * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
 526  * called from the ->monolithic_mount_data() fs_context operation.
 527  *
 528  * Returns 0 on success or the error returned by the ->parse_option() fs_context
 529  * operation on failure.
 530  */
 531 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 532                                            void *data)
 533 {
 534         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 535         char *options = data, *key;
 536         int ret = 0;
 537
 538         if (!options)
 539                 return 0;
 540
 541         ctx->mount_options = kstrdup(data, GFP_KERNEL);
 542         if (ctx->mount_options == NULL)
 543                 return -ENOMEM;
 544
 545         ret = security_sb_eat_lsm_opts(options, &fc->security);
 546         if (ret)
 547                 return ret;
 548
 549         /* BB Need to add support for sep= here TBD */
 550         while ((key = strsep(&options, ",")) != NULL) {
 551                 size_t len;
 552                 char *value;
 553
 554                 if (*key == 0)
 555                         break;
 556
 557                 /* Check if following character is the deliminator If yes,
 558                  * we have encountered a double deliminator reset the NULL
 559                  * character to the deliminator
 560                  */
 561                 while (options && options[0] == ',') {
 562                         len = strlen(key);
 563                         strcpy(key + len, options);
 564                         options = strchr(options, ',');
 565                         if (options)
 566                                 *options++ = 0;
 567                 }
 568
 569
 570                 len = 0;
 571                 value = strchr(key, '=');
 572                 if (value) {
 573                         if (value == key)
 574                                 continue;
 575                         *value++ = 0;
 576                         len = strlen(value);
 577                 }
 578
 579                 ret = vfs_parse_fs_string(fc, key, value, len);
 580                 if (ret < 0)
 581                         break;
 582         }
 583
 584         return ret;
 585 }
 586
 587 /*
 588  * Validate the preparsed information in the config.
 589  */
 590 static int smb3_fs_context_validate(struct fs_context *fc)
 591 {
 592         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 593
 594         if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
 595                 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
 596                 return -EOPNOTSUPP;
 597         }
 598
 599 #ifndef CONFIG_KEYS
 600         /* Muliuser mounts require CONFIG_KEYS support */
 601         if (ctx->multiuser) {
 602                 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
 603                 return -1;
 604         }
 605 #endif
 606
 607         if (ctx->got_version == false)
 608                 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");
 609
 610
 611         if (!ctx->UNC) {
 612                 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
 613                 return -1;
 614         }
 615
 616         /* make sure UNC has a share name */
 617         if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
 618                 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
 619                 return -ENOENT;
 620         }
 621
 622         if (!ctx->got_ip) {
 623                 int len;
 624                 const char *slash;
 625
 626                 /* No ip= option specified? Try to get it from UNC */
 627                 /* Use the address part of the UNC. */
 628                 slash = strchr(&ctx->UNC[2], '\\');
 629                 len = slash - &ctx->UNC[2];
 630                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
 631                                           &ctx->UNC[2], len)) {
 632                         pr_err("Unable to determine destination address\n");
 633                         return -EHOSTUNREACH;
 634                 }
 635         }
 636
 637         /* set the port that we got earlier */
 638         cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
 639
 640         if (ctx->override_uid && !ctx->uid_specified) {
 641                 ctx->override_uid = 0;
 642                 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
 643         }
 644
 645         if (ctx->override_gid && !ctx->gid_specified) {
 646                 ctx->override_gid = 0;
 647                 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
 648         }
 649
 650         return 0;
 651 }
 652
 653 static int smb3_get_tree_common(struct fs_context *fc)
 654 {
 655         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 656         struct dentry *root;
 657         int rc = 0;
 658
 659         root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
 660         if (IS_ERR(root))
 661                 return PTR_ERR(root);
 662
 663         fc->root = root;
 664
 665         return rc;
 666 }
 667
 668 /*
 669  * Create an SMB3 superblock from the parameters passed.
 670  */
 671 static int smb3_get_tree(struct fs_context *fc)
 672 {
 673         int err = smb3_fs_context_validate(fc);
 674
 675         if (err)
 676                 return err;
 677         return smb3_get_tree_common(fc);
 678 }
 679
 680 static void smb3_fs_context_free(struct fs_context *fc)
 681 {
 682         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 683
 684         smb3_cleanup_fs_context(ctx);
 685 }
 686
 687 /*
 688  * Compare the old and new proposed context during reconfigure
 689  * and check if the changes are compatible.
 690  */
 691 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
 692                                        struct smb3_fs_context *new_ctx,
 693                                        struct smb3_fs_context *old_ctx)
 694 {
 695         if (new_ctx->posix_paths != old_ctx->posix_paths) {
 696                 cifs_errorf(fc, "can not change posixpaths during remount\n");
 697                 return -EINVAL;
 698         }
 699         if (new_ctx->sectype != old_ctx->sectype) {
 700                 cifs_errorf(fc, "can not change sec during remount\n");
 701                 return -EINVAL;
 702         }
 703         if (new_ctx->multiuser != old_ctx->multiuser) {
 704                 cifs_errorf(fc, "can not change multiuser during remount\n");
 705                 return -EINVAL;
 706         }
 707         if (new_ctx->UNC &&
 708             (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
 709                 cifs_errorf(fc, "can not change UNC during remount\n");
 710                 return -EINVAL;
 711         }
 712         if (new_ctx->username &&
 713             (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
 714                 cifs_errorf(fc, "can not change username during remount\n");
 715                 return -EINVAL;
 716         }
 717         if (new_ctx->password &&
 718             (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
 719                 cifs_errorf(fc, "can not change password during remount\n");
 720                 return -EINVAL;
 721         }
 722         if (new_ctx->domainname &&
 723             (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
 724                 cifs_errorf(fc, "can not change domainname during remount\n");
 725                 return -EINVAL;
 726         }
 727         if (new_ctx->nodename &&
 728             (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
 729                 cifs_errorf(fc, "can not change nodename during remount\n");
 730                 return -EINVAL;
 731         }
 732         if (new_ctx->iocharset &&
 733             (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
 734                 cifs_errorf(fc, "can not change iocharset during remount\n");
 735                 return -EINVAL;
 736         }
 737
 738         return 0;
 739 }
 740
 741 #define STEAL_STRING(cifs_sb, ctx, field)                               \
 742 do {                                                                    \
 743         kfree(ctx->field);                                              \
 744         ctx->field = cifs_sb->ctx->field;                               \
 745         cifs_sb->ctx->field = NULL;                                     \
 746 } while (0)
 747
 748 static int smb3_reconfigure(struct fs_context *fc)
 749 {
 750         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 751         struct dentry *root = fc->root;
 752         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 753         int rc;
 754
 755         rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
 756         if (rc)
 757                 return rc;
 758
 759         /*
 760          * We can not change UNC/username/password/domainname/nodename/iocharset
 761          * during reconnect so ignore what we have in the new context and
 762          * just use what we already have in cifs_sb->ctx.
 763          */
 764         STEAL_STRING(cifs_sb, ctx, UNC);
 765         STEAL_STRING(cifs_sb, ctx, source);
 766         STEAL_STRING(cifs_sb, ctx, username);
 767         STEAL_STRING(cifs_sb, ctx, password);
 768         STEAL_STRING(cifs_sb, ctx, domainname);
 769         STEAL_STRING(cifs_sb, ctx, nodename);
 770         STEAL_STRING(cifs_sb, ctx, iocharset);
 771
 772         /* if rsize or wsize not passed in on remount, use previous values */
 773         if (ctx->rsize == 0)
 774                 ctx->rsize = cifs_sb->ctx->rsize;
 775         if (ctx->wsize == 0)
 776                 ctx->wsize = cifs_sb->ctx->wsize;
 777
 778
 779         smb3_cleanup_fs_context_contents(cifs_sb->ctx);
 780         rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
 781         smb3_update_mnt_flags(cifs_sb);
 782
 783         return rc;
 784 }
 785
 786 static int smb3_fs_context_parse_param(struct fs_context *fc,
 787                                       struct fs_parameter *param)
 788 {
 789         struct fs_parse_result result;
 790         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 791         int i, opt;
 792         bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
 793         bool skip_parsing = false;
 794         kuid_t uid;
 795         kgid_t gid;
 796
 797         cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
 798
 799         /*
 800          * fs_parse can not handle string options with an empty value so
 801          * we will need special handling of them.
 802          */
 803         if (param->type == fs_value_is_string && param->string[0] == 0) {
 804                 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
 805                         skip_parsing = true;
 806                         opt = Opt_pass;
 807                 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
 808                         skip_parsing = true;
 809                         opt = Opt_user;
 810                 }
 811         }
 812
 813         if (!skip_parsing) {
 814                 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
 815                 if (opt < 0)
 816                         return ctx->sloppy ? 1 : opt;
 817         }
 818
 819         switch (opt) {
 820         case Opt_compress:
 821                 ctx->compression = UNKNOWN_TYPE;
 822                 cifs_dbg(VFS,
 823                         "SMB3 compression support is experimental\n");
 824                 break;
 825         case Opt_nodfs:
 826                 ctx->nodfs = 1;
 827                 break;
 828         case Opt_hard:
 829                 if (result.negated)
 830                         ctx->retry = 0;
 831                 else
 832                         ctx->retry = 1;
 833                 break;
 834         case Opt_soft:
 835                 if (result.negated)
 836                         ctx->retry = 1;
 837                 else
 838                         ctx->retry = 0;
 839                 break;
 840         case Opt_mapposix:
 841                 if (result.negated)
 842                         ctx->remap = false;
 843                 else {
 844                         ctx->remap = true;
 845                         ctx->sfu_remap = false; /* disable SFU mapping */
 846                 }
 847                 break;
 848         case Opt_user_xattr:
 849                 if (result.negated)
 850                         ctx->no_xattr = 1;
 851                 else
 852                         ctx->no_xattr = 0;
 853                 break;
 854         case Opt_forceuid:
 855                 if (result.negated)
 856                         ctx->override_uid = 0;
 857                 else
 858                         ctx->override_uid = 1;
 859                 break;
 860         case Opt_forcegid:
 861                 if (result.negated)
 862                         ctx->override_gid = 0;
 863                 else
 864                         ctx->override_gid = 1;
 865                 break;
 866         case Opt_perm:
 867                 if (result.negated)
 868                         ctx->noperm = 1;
 869                 else
 870                         ctx->noperm = 0;
 871                 break;
 872         case Opt_dynperm:
 873                 if (result.negated)
 874                         ctx->dynperm = 0;
 875                 else
 876                         ctx->dynperm = 1;
 877                 break;
 878         case Opt_sfu:
 879                 if (result.negated)
 880                         ctx->sfu_emul = 0;
 881                 else
 882                         ctx->sfu_emul = 1;
 883                 break;
 884         case Opt_noblocksend:
 885                 ctx->noblocksnd = 1;
 886                 break;
 887         case Opt_noautotune:
 888                 ctx->noautotune = 1;
 889                 break;
 890         case Opt_nolease:
 891                 ctx->no_lease = 1;
 892                 break;
 893         case Opt_nodelete:
 894                 ctx->nodelete = 1;
 895                 break;
 896         case Opt_multichannel:
 897                 if (result.negated) {
 898                         ctx->multichannel = false;
 899                         ctx->max_channels = 1;
 900                 } else {
 901                         ctx->multichannel = true;
 902                         /* if number of channels not specified, default to 2 */
 903                         if (ctx->max_channels < 2)
 904                                 ctx->max_channels = 2;
 905                 }
 906                 break;
 907         case Opt_uid:
 908                 uid = make_kuid(current_user_ns(), result.uint_32);
 909                 if (!uid_valid(uid))
 910                         goto cifs_parse_mount_err;
 911                 ctx->linux_uid = uid;
 912                 ctx->uid_specified = true;
 913                 break;
 914         case Opt_cruid:
 915                 uid = make_kuid(current_user_ns(), result.uint_32);
 916                 if (!uid_valid(uid))
 917                         goto cifs_parse_mount_err;
 918                 ctx->cred_uid = uid;
 919                 ctx->cruid_specified = true;
 920                 break;
 921         case Opt_backupgid:
 922                 gid = make_kgid(current_user_ns(), result.uint_32);
 923                 if (!gid_valid(gid))
 924                         goto cifs_parse_mount_err;
 925                 ctx->backupgid = gid;
 926                 ctx->backupgid_specified = true;
 927                 break;
 928         case Opt_gid:
 929                 gid = make_kgid(current_user_ns(), result.uint_32);
 930                 if (!gid_valid(gid))
 931                         goto cifs_parse_mount_err;
 932                 ctx->linux_gid = gid;
 933                 ctx->gid_specified = true;
 934                 break;
 935         case Opt_port:
 936                 ctx->port = result.uint_32;
 937                 break;
 938         case Opt_file_mode:
 939                 ctx->file_mode = result.uint_32;
 940                 break;
 941         case Opt_dirmode:
 942                 ctx->dir_mode = result.uint_32;
 943                 break;
 944         case Opt_min_enc_offload:
 945                 ctx->min_offload = result.uint_32;
 946                 break;
 947         case Opt_blocksize:
 948                 /*
 949                  * inode blocksize realistically should never need to be
 950                  * less than 16K or greater than 16M and default is 1MB.
 951                  * Note that small inode block sizes (e.g. 64K) can lead
 952                  * to very poor performance of common tools like cp and scp
 953                  */
 954                 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
 955                    (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
 956                         cifs_errorf(fc, "%s: Invalid blocksize\n",
 957                                 __func__);
 958                         goto cifs_parse_mount_err;
 959                 }
 960                 ctx->bsize = result.uint_32;
 961                 ctx->got_bsize = true;
 962                 break;
 963         case Opt_rasize:
 964                 /*
 965                  * readahead size realistically should never need to be
 966                  * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
 967                  * (perhaps an exception should be considered in the
 968                  * for the case of a large number of channels
 969                  * when multichannel is negotiated) since that would lead
 970                  * to plenty of parallel I/O in flight to the server.
 971                  * Note that smaller read ahead sizes would
 972                  * hurt performance of common tools like cp and scp
 973                  * which often trigger sequential i/o with read ahead
 974                  */
 975                 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
 976                     (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
 977                         cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
 978                                 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
 979                         goto cifs_parse_mount_err;
 980                 }
 981                 ctx->rasize = result.uint_32;
 982                 break;
 983         case Opt_rsize:
 984                 ctx->rsize = result.uint_32;
 985                 ctx->got_rsize = true;
 986                 break;
 987         case Opt_wsize:
 988                 ctx->wsize = result.uint_32;
 989                 ctx->got_wsize = true;
 990                 break;
 991         case Opt_acregmax:
 992                 ctx->acregmax = HZ * result.uint_32;
 993                 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
 994                         cifs_errorf(fc, "acregmax too large\n");
 995                         goto cifs_parse_mount_err;
 996                 }
 997                 break;
 998         case Opt_acdirmax:
 999                 ctx->acdirmax = HZ * result.uint_32;
1000                 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1001                         cifs_errorf(fc, "acdirmax too large\n");
1002                         goto cifs_parse_mount_err;
1003                 }
1004                 break;
1005         case Opt_actimeo:
1006                 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1007                         cifs_errorf(fc, "timeout too large\n");
1008                         goto cifs_parse_mount_err;
1009                 }
1010                 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1011                     (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1012                         cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1013                         break;
1014                 }
1015                 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1016                 break;
1017         case Opt_echo_interval:
1018                 ctx->echo_interval = result.uint_32;
1019                 break;
1020         case Opt_snapshot:
1021                 ctx->snapshot_time = result.uint_32;
1022                 break;
1023         case Opt_max_credits:
1024                 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1025                         cifs_errorf(fc, "%s: Invalid max_credits value\n",
1026                                  __func__);
1027                         goto cifs_parse_mount_err;
1028                 }
1029                 ctx->max_credits = result.uint_32;
1030                 break;
1031         case Opt_max_channels:
1032                 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1033                         cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1034                                  __func__, CIFS_MAX_CHANNELS);
1035                         goto cifs_parse_mount_err;
1036                 }
1037                 ctx->max_channels = result.uint_32;
1038                 /* If more than one channel requested ... they want multichan */
1039                 if (result.uint_32 > 1)
1040                         ctx->multichannel = true;
1041                 break;
1042         case Opt_handletimeout:
1043                 ctx->handle_timeout = result.uint_32;
1044                 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1045                         cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1046                         goto cifs_parse_mount_err;
1047                 }
1048                 break;
1049         case Opt_source:
1050                 kfree(ctx->UNC);
1051                 ctx->UNC = NULL;
1052                 switch (smb3_parse_devname(param->string, ctx)) {
1053                 case 0:
1054                         break;
1055                 case -ENOMEM:
1056                         cifs_errorf(fc, "Unable to allocate memory for devname\n");
1057                         goto cifs_parse_mount_err;
1058                 case -EINVAL:
1059                         cifs_errorf(fc, "Malformed UNC in devname\n");
1060                         goto cifs_parse_mount_err;
1061                 default:
1062                         cifs_errorf(fc, "Unknown error parsing devname\n");
1063                         goto cifs_parse_mount_err;
1064                 }
1065                 ctx->source = kstrdup(param->string, GFP_KERNEL);
1066                 if (ctx->source == NULL) {
1067                         cifs_errorf(fc, "OOM when copying UNC string\n");
1068                         goto cifs_parse_mount_err;
1069                 }
1070                 fc->source = kstrdup(param->string, GFP_KERNEL);
1071                 if (fc->source == NULL) {
1072                         cifs_errorf(fc, "OOM when copying UNC string\n");
1073                         goto cifs_parse_mount_err;
1074                 }
1075                 break;
1076         case Opt_user:
1077                 kfree(ctx->username);
1078                 ctx->username = NULL;
1079                 if (strlen(param->string) == 0) {
1080                         /* null user, ie. anonymous authentication */
1081                         ctx->nullauth = 1;
1082                         break;
1083                 }
1084
1085                 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1086                     CIFS_MAX_USERNAME_LEN) {
1087                         pr_warn("username too long\n");
1088                         goto cifs_parse_mount_err;
1089                 }
1090                 ctx->username = kstrdup(param->string, GFP_KERNEL);
1091                 if (ctx->username == NULL) {
1092                         cifs_errorf(fc, "OOM when copying username string\n");
1093                         goto cifs_parse_mount_err;
1094                 }
1095                 break;
1096         case Opt_pass:
1097                 kfree(ctx->password);
1098                 ctx->password = NULL;
1099                 if (strlen(param->string) == 0)
1100                         break;
1101
1102                 ctx->password = kstrdup(param->string, GFP_KERNEL);
1103                 if (ctx->password == NULL) {
1104                         cifs_errorf(fc, "OOM when copying password string\n");
1105                         goto cifs_parse_mount_err;
1106                 }
1107                 break;
1108         case Opt_ip:
1109                 if (strlen(param->string) == 0) {
1110                         ctx->got_ip = false;
1111                         break;
1112                 }
1113                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1114                                           param->string,
1115                                           strlen(param->string))) {
1116                         pr_err("bad ip= option (%s)\n", param->string);
1117                         goto cifs_parse_mount_err;
1118                 }
1119                 ctx->got_ip = true;
1120                 break;
1121         case Opt_domain:
1122                 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1123                                 == CIFS_MAX_DOMAINNAME_LEN) {
1124                         pr_warn("domain name too long\n");
1125                         goto cifs_parse_mount_err;
1126                 }
1127
1128                 kfree(ctx->domainname);
1129                 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1130                 if (ctx->domainname == NULL) {
1131                         cifs_errorf(fc, "OOM when copying domainname string\n");
1132                         goto cifs_parse_mount_err;
1133                 }
1134                 cifs_dbg(FYI, "Domain name set\n");
1135                 break;
1136         case Opt_srcaddr:
1137                 if (!cifs_convert_address(
1138                                 (struct sockaddr *)&ctx->srcaddr,
1139                                 param->string, strlen(param->string))) {
1140                         pr_warn("Could not parse srcaddr: %s\n",
1141                                 param->string);
1142                         goto cifs_parse_mount_err;
1143                 }
1144                 break;
1145         case Opt_iocharset:
1146                 if (strnlen(param->string, 1024) >= 65) {
1147                         pr_warn("iocharset name too long\n");
1148                         goto cifs_parse_mount_err;
1149                 }
1150
1151                 if (strncasecmp(param->string, "default", 7) != 0) {
1152                         kfree(ctx->iocharset);
1153                         ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1154                         if (ctx->iocharset == NULL) {
1155                                 cifs_errorf(fc, "OOM when copying iocharset string\n");
1156                                 goto cifs_parse_mount_err;
1157                         }
1158                 }
1159                 /* if iocharset not set then load_nls_default
1160                  * is used by caller
1161                  */
1162                 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1163                 break;
1164         case Opt_netbiosname:
1165                 memset(ctx->source_rfc1001_name, 0x20,
1166                         RFC1001_NAME_LEN);
1167                 /*
1168                  * FIXME: are there cases in which a comma can
1169                  * be valid in workstation netbios name (and
1170                  * need special handling)?
1171                  */
1172                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1173                         /* don't ucase netbiosname for user */
1174                         if (param->string[i] == 0)
1175                                 break;
1176                         ctx->source_rfc1001_name[i] = param->string[i];
1177                 }
1178                 /* The string has 16th byte zero still from
1179                  * set at top of the function
1180                  */
1181                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1182                         pr_warn("netbiosname longer than 15 truncated\n");
1183                 break;
1184         case Opt_servern:
1185                 /* last byte, type, is 0x20 for servr type */
1186                 memset(ctx->target_rfc1001_name, 0x20,
1187                         RFC1001_NAME_LEN_WITH_NULL);
1188                 /*
1189                  * BB are there cases in which a comma can be valid in this
1190                  * workstation netbios name (and need special handling)?
1191                  */
1192
1193                 /* user or mount helper must uppercase the netbios name */
1194                 for (i = 0; i < 15; i++) {
1195                         if (param->string[i] == 0)
1196                                 break;
1197                         ctx->target_rfc1001_name[i] = param->string[i];
1198                 }
1199
1200                 /* The string has 16th byte zero still from set at top of function */
1201                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1202                         pr_warn("server netbiosname longer than 15 truncated\n");
1203                 break;
1204         case Opt_ver:
1205                 /* version of mount userspace tools, not dialect */
1206                 /* If interface changes in mount.cifs bump to new ver */
1207                 if (strncasecmp(param->string, "1", 1) == 0) {
1208                         if (strlen(param->string) > 1) {
1209                                 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1210                                         param->string);
1211                                 goto cifs_parse_mount_err;
1212                         }
1213                         /* This is the default */
1214                         break;
1215                 }
1216                 /* For all other value, error */
1217                 pr_warn("Invalid mount helper version specified\n");
1218                 goto cifs_parse_mount_err;
1219         case Opt_vers:
1220                 /* protocol version (dialect) */
1221                 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1222                         goto cifs_parse_mount_err;
1223                 ctx->got_version = true;
1224                 break;
1225         case Opt_sec:
1226                 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1227                         goto cifs_parse_mount_err;
1228                 break;
1229         case Opt_cache:
1230                 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1231                         goto cifs_parse_mount_err;
1232                 break;
1233         case Opt_witness:
1234 #ifndef CONFIG_CIFS_SWN_UPCALL
1235                 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1236                         goto cifs_parse_mount_err;
1237 #endif
1238                 ctx->witness = true;
1239                 pr_warn_once("Witness protocol support is experimental\n");
1240                 break;
1241         case Opt_rootfs:
1242 #ifndef CONFIG_CIFS_ROOT
1243                 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1244                 goto cifs_parse_mount_err;
1245 #endif
1246                 ctx->rootfs = true;
1247                 break;
1248         case Opt_posixpaths:
1249                 if (result.negated)
1250                         ctx->posix_paths = 0;
1251                 else
1252                         ctx->posix_paths = 1;
1253                 break;
1254         case Opt_unix:
1255                 if (result.negated)
1256                         ctx->linux_ext = 0;
1257                 else
1258                         ctx->no_linux_ext = 1;
1259                 break;
1260         case Opt_nocase:
1261                 ctx->nocase = 1;
1262                 break;
1263         case Opt_brl:
1264                 if (result.negated) {
1265                         /*
1266                          * turn off mandatory locking in mode
1267                          * if remote locking is turned off since the
1268                          * local vfs will do advisory
1269                          */
1270                         if (ctx->file_mode ==
1271                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1272                                 ctx->file_mode = S_IALLUGO;
1273                         ctx->nobrl =  1;
1274                 } else
1275                         ctx->nobrl =  0;
1276                 break;
1277         case Opt_handlecache:
1278                 if (result.negated)
1279                         ctx->nohandlecache = 1;
1280                 else
1281                         ctx->nohandlecache = 0;
1282                 break;
1283         case Opt_forcemandatorylock:
1284                 ctx->mand_lock = 1;
1285                 break;
1286         case Opt_setuids:
1287                 ctx->setuids = result.negated;
1288                 break;
1289         case Opt_intr:
1290                 ctx->intr = !result.negated;
1291                 break;
1292         case Opt_setuidfromacl:
1293                 ctx->setuidfromacl = 1;
1294                 break;
1295         case Opt_strictsync:
1296                 ctx->nostrictsync = result.negated;
1297                 break;
1298         case Opt_serverino:
1299                 ctx->server_ino = !result.negated;
1300                 break;
1301         case Opt_rwpidforward:
1302                 ctx->rwpidforward = 1;
1303                 break;
1304         case Opt_modesid:
1305                 ctx->mode_ace = 1;
1306                 break;
1307         case Opt_cifsacl:
1308                 ctx->cifs_acl = !result.negated;
1309                 break;
1310         case Opt_acl:
1311                 ctx->no_psx_acl = result.negated;
1312                 break;
1313         case Opt_locallease:
1314                 ctx->local_lease = 1;
1315                 break;
1316         case Opt_sign:
1317                 ctx->sign = true;
1318                 break;
1319         case Opt_ignore_signature:
1320                 ctx->sign = true;
1321                 ctx->ignore_signature = true;
1322                 break;
1323         case Opt_seal:
1324                 /* we do not do the following in secFlags because seal
1325                  * is a per tree connection (mount) not a per socket
1326                  * or per-smb connection option in the protocol
1327                  * vol->secFlg |= CIFSSEC_MUST_SEAL;
1328                  */
1329                 ctx->seal = 1;
1330                 break;
1331         case Opt_noac:
1332                 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1333                 break;
1334         case Opt_fsc:
1335 #ifndef CONFIG_CIFS_FSCACHE
1336                 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1337                 goto cifs_parse_mount_err;
1338 #endif
1339                 ctx->fsc = true;
1340                 break;
1341         case Opt_mfsymlinks:
1342                 ctx->mfsymlinks = true;
1343                 break;
1344         case Opt_multiuser:
1345                 ctx->multiuser = true;
1346                 break;
1347         case Opt_sloppy:
1348                 ctx->sloppy = true;
1349                 break;
1350         case Opt_nosharesock:
1351                 ctx->nosharesock = true;
1352                 break;
1353         case Opt_persistent:
1354                 if (result.negated) {
1355                         ctx->nopersistent = true;
1356                         if (ctx->persistent) {
1357                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1358                                 goto cifs_parse_mount_err;
1359                         }
1360                 } else {
1361                         ctx->persistent = true;
1362                         if ((ctx->nopersistent) || (ctx->resilient)) {
1363                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1364                                 goto cifs_parse_mount_err;
1365                         }
1366                 }
1367                 break;
1368         case Opt_resilient:
1369                 if (result.negated) {
1370                         ctx->resilient = false; /* already the default */
1371                 } else {
1372                         ctx->resilient = true;
1373                         if (ctx->persistent) {
1374                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1375                                 goto cifs_parse_mount_err;
1376                         }
1377                 }
1378                 break;
1379         case Opt_domainauto:
1380                 ctx->domainauto = true;
1381                 break;
1382         case Opt_rdma:
1383                 ctx->rdma = true;
1384                 break;
1385         }
1386         /* case Opt_ignore: - is ignored as expected ... */
1387
1388         return 0;
1389
1390  cifs_parse_mount_err:
1391         return -EINVAL;
1392 }
1393
1394 int smb3_init_fs_context(struct fs_context *fc)
1395 {
1396         struct smb3_fs_context *ctx;
1397         char *nodename = utsname()->nodename;
1398         int i;
1399
1400         ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1401         if (unlikely(!ctx))
1402                 return -ENOMEM;
1403
1404         /*
1405          * does not have to be perfect mapping since field is
1406          * informational, only used for servers that do not support
1407          * port 445 and it can be overridden at mount time
1408          */
1409         memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1410         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1411                 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1412
1413         ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1414         /*
1415          * null target name indicates to use *SMBSERVR default called name
1416          *  if we end up sending RFC1001 session initialize
1417          */
1418         ctx->target_rfc1001_name[0] = 0;
1419         ctx->cred_uid = current_uid();
1420         ctx->linux_uid = current_uid();
1421         ctx->linux_gid = current_gid();
1422         /* By default 4MB read ahead size, 1MB block size */
1423         ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1424         ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1425
1426         /*
1427          * default to SFM style remapping of seven reserved characters
1428          * unless user overrides it or we negotiate CIFS POSIX where
1429          * it is unnecessary.  Can not simultaneously use more than one mapping
1430          * since then readdir could list files that open could not open
1431          */
1432         ctx->remap = true;
1433
1434         /* default to only allowing write access to owner of the mount */
1435         ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1436
1437         /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1438         /* default is always to request posix paths. */
1439         ctx->posix_paths = 1;
1440         /* default to using server inode numbers where available */
1441         ctx->server_ino = 1;
1442
1443         /* default is to use strict cifs caching semantics */
1444         ctx->strict_io = true;
1445
1446         ctx->acregmax = CIFS_DEF_ACTIMEO;
1447         ctx->acdirmax = CIFS_DEF_ACTIMEO;
1448
1449         /* Most clients set timeout to 0, allows server to use its default */
1450         ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1451
1452         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1453         ctx->ops = &smb30_operations;
1454         ctx->vals = &smbdefault_values;
1455
1456         ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1457
1458         /* default to no multichannel (single server connection) */
1459         ctx->multichannel = false;
1460         ctx->max_channels = 1;
1461
1462         ctx->backupuid_specified = false; /* no backup intent for a user */
1463         ctx->backupgid_specified = false; /* no backup intent for a group */
1464
1465 /*
1466  *      short int override_uid = -1;
1467  *      short int override_gid = -1;
1468  *      char *nodename = strdup(utsname()->nodename);
1469  *      struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1470  */
1471
1472         fc->fs_private = ctx;
1473         fc->ops = &smb3_fs_context_ops;
1474         return 0;
1475 }
1476
1477 void
1478 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1479 {
1480         if (ctx == NULL)
1481                 return;
1482
1483         /*
1484          * Make sure this stays in sync with smb3_fs_context_dup()
1485          */
1486         kfree(ctx->mount_options);
1487         ctx->mount_options = NULL;
1488         kfree(ctx->username);
1489         ctx->username = NULL;
1490         kfree_sensitive(ctx->password);
1491         ctx->password = NULL;
1492         kfree(ctx->UNC);
1493         ctx->UNC = NULL;
1494         kfree(ctx->source);
1495         ctx->source = NULL;
1496         kfree(ctx->domainname);
1497         ctx->domainname = NULL;
1498         kfree(ctx->nodename);
1499         ctx->nodename = NULL;
1500         kfree(ctx->iocharset);
1501         ctx->iocharset = NULL;
1502         kfree(ctx->prepath);
1503         ctx->prepath = NULL;
1504 }
1505
1506 void
1507 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1508 {
1509         if (!ctx)
1510                 return;
1511         smb3_cleanup_fs_context_contents(ctx);
1512         kfree(ctx);
1513 }
1514
1515 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1516 {
1517         struct smb3_fs_context *ctx = cifs_sb->ctx;
1518
1519         if (ctx->nodfs)
1520                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1521         else
1522                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1523
1524         if (ctx->noperm)
1525                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1526         else
1527                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1528
1529         if (ctx->setuids)
1530                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1531         else
1532                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1533
1534         if (ctx->setuidfromacl)
1535                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1536         else
1537                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1538
1539         if (ctx->server_ino)
1540                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1541         else
1542                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1543
1544         if (ctx->remap)
1545                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1546         else
1547                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1548
1549         if (ctx->sfu_remap)
1550                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1551         else
1552                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1553
1554         if (ctx->no_xattr)
1555                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1556         else
1557                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1558
1559         if (ctx->sfu_emul)
1560                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1561         else
1562                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1563
1564         if (ctx->nobrl)
1565                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1566         else
1567                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1568
1569         if (ctx->nohandlecache)
1570                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1571         else
1572                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1573
1574         if (ctx->nostrictsync)
1575                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1576         else
1577                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1578
1579         if (ctx->mand_lock)
1580                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1581         else
1582                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1583
1584         if (ctx->rwpidforward)
1585                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1586         else
1587                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1588
1589         if (ctx->mode_ace)
1590                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1591         else
1592                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1593
1594         if (ctx->cifs_acl)
1595                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1596         else
1597                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1598
1599         if (ctx->backupuid_specified)
1600                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1601         else
1602                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1603
1604         if (ctx->backupgid_specified)
1605                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1606         else
1607                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1608
1609         if (ctx->override_uid)
1610                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1611         else
1612                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1613
1614         if (ctx->override_gid)
1615                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1616         else
1617                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1618
1619         if (ctx->dynperm)
1620                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1621         else
1622                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1623
1624         if (ctx->fsc)
1625                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1626         else
1627                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1628
1629         if (ctx->multiuser)
1630                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1631                                             CIFS_MOUNT_NO_PERM);
1632         else
1633                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1634
1635
1636         if (ctx->strict_io)
1637                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1638         else
1639                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1640
1641         if (ctx->direct_io)
1642                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1643         else
1644                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1645
1646         if (ctx->mfsymlinks)
1647                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1648         else
1649                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1650         if (ctx->mfsymlinks) {
1651                 if (ctx->sfu_emul) {
1652                         /*
1653                          * Our SFU ("Services for Unix" emulation does not allow
1654                          * creating symlinks but does allow reading existing SFU
1655                          * symlinks (it does allow both creating and reading SFU
1656                          * style mknod and FIFOs though). When "mfsymlinks" and
1657                          * "sfu" are both enabled at the same time, it allows
1658                          * reading both types of symlinks, but will only create
1659                          * them with mfsymlinks format. This allows better
1660                          * Apple compatibility (probably better for Samba too)
1661                          * while still recognizing old Windows style symlinks.
1662                          */
1663                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1664                 }
1665         }
1666         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1667
1668         return;
1669 }