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