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