1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2020, Microsoft Corporation.
5 * Author(s): Steve French <stfrench@microsoft.com>
6 * David Howells <dhowells@redhat.com>
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>
18 #include <linux/ctype.h>
19 #include <linux/fs_context.h>
20 #include <linux/fs_parser.h>
22 #include <linux/mount.h>
23 #include <linux/parser.h>
24 #include <linux/utsname.h>
28 #include "cifsproto.h"
29 #include "cifs_unicode.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
34 #include "rfc1002pdu.h"
35 #include "fs_context.h"
37 static const match_table_t cifs_smb_version_tokens = {
38 { Smb_1, SMB1_VERSION_STRING },
39 { Smb_20, SMB20_VERSION_STRING},
40 { Smb_21, SMB21_VERSION_STRING },
41 { Smb_30, SMB30_VERSION_STRING },
42 { Smb_302, SMB302_VERSION_STRING },
43 { Smb_302, ALT_SMB302_VERSION_STRING },
44 { Smb_311, SMB311_VERSION_STRING },
45 { Smb_311, ALT_SMB311_VERSION_STRING },
46 { Smb_3any, SMB3ANY_VERSION_STRING },
47 { Smb_default, SMBDEFAULT_VERSION_STRING },
48 { Smb_version_err, NULL }
51 static const match_table_t cifs_secflavor_tokens = {
52 { Opt_sec_krb5, "krb5" },
53 { Opt_sec_krb5i, "krb5i" },
54 { Opt_sec_krb5p, "krb5p" },
55 { Opt_sec_ntlmsspi, "ntlmsspi" },
56 { Opt_sec_ntlmssp, "ntlmssp" },
58 { Opt_sec_ntlmi, "ntlmi" },
59 { Opt_sec_ntlmv2, "nontlm" },
60 { Opt_sec_ntlmv2, "ntlmv2" },
61 { Opt_sec_ntlmv2i, "ntlmv2i" },
62 { Opt_sec_lanman, "lanman" },
63 { Opt_sec_none, "none" },
68 const struct fs_parameter_spec smb3_fs_parameters[] = {
69 /* Mount options that take no arguments */
70 fsparam_flag_no("user_xattr", Opt_user_xattr),
71 fsparam_flag_no("forceuid", Opt_forceuid),
72 fsparam_flag_no("multichannel", Opt_multichannel),
73 fsparam_flag_no("forcegid", Opt_forcegid),
74 fsparam_flag("noblocksend", Opt_noblocksend),
75 fsparam_flag("noautotune", Opt_noautotune),
76 fsparam_flag("nolease", Opt_nolease),
77 fsparam_flag_no("hard", Opt_hard),
78 fsparam_flag_no("soft", Opt_soft),
79 fsparam_flag_no("perm", Opt_perm),
80 fsparam_flag("nodelete", Opt_nodelete),
81 fsparam_flag_no("mapposix", Opt_mapposix),
82 fsparam_flag("mapchars", Opt_mapchars),
83 fsparam_flag("nomapchars", Opt_nomapchars),
84 fsparam_flag_no("sfu", Opt_sfu),
85 fsparam_flag("nodfs", Opt_nodfs),
86 fsparam_flag_no("posixpaths", Opt_posixpaths),
87 fsparam_flag_no("unix", Opt_unix),
88 fsparam_flag_no("linux", Opt_unix),
89 fsparam_flag_no("posix", Opt_unix),
90 fsparam_flag("nocase", Opt_nocase),
91 fsparam_flag("ignorecase", Opt_nocase),
92 fsparam_flag_no("brl", Opt_brl),
93 fsparam_flag_no("handlecache", Opt_handlecache),
94 fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
95 fsparam_flag("forcemand", Opt_forcemandatorylock),
96 fsparam_flag("setuidfromacl", Opt_setuidfromacl),
97 fsparam_flag("idsfromsid", Opt_setuidfromacl),
98 fsparam_flag_no("setuids", Opt_setuids),
99 fsparam_flag_no("dynperm", Opt_dynperm),
100 fsparam_flag_no("intr", Opt_intr),
101 fsparam_flag_no("strictsync", Opt_strictsync),
102 fsparam_flag_no("serverino", Opt_serverino),
103 fsparam_flag("rwpidforward", Opt_rwpidforward),
104 fsparam_flag("cifsacl", Opt_cifsacl),
105 fsparam_flag_no("acl", Opt_acl),
106 fsparam_flag("locallease", Opt_locallease),
107 fsparam_flag("sign", Opt_sign),
108 fsparam_flag("ignore_signature", Opt_ignore_signature),
109 fsparam_flag("signloosely", Opt_ignore_signature),
110 fsparam_flag("seal", Opt_seal),
111 fsparam_flag("noac", Opt_noac),
112 fsparam_flag("fsc", Opt_fsc),
113 fsparam_flag("mfsymlinks", Opt_mfsymlinks),
114 fsparam_flag("multiuser", Opt_multiuser),
115 fsparam_flag("sloppy", Opt_sloppy),
116 fsparam_flag("nosharesock", Opt_nosharesock),
117 fsparam_flag_no("persistenthandles", Opt_persistent),
118 fsparam_flag_no("resilienthandles", Opt_resilient),
119 fsparam_flag("domainauto", Opt_domainauto),
120 fsparam_flag("rdma", Opt_rdma),
121 fsparam_flag("modesid", Opt_modesid),
122 fsparam_flag("modefromsid", Opt_modesid),
123 fsparam_flag("rootfs", Opt_rootfs),
124 fsparam_flag("compress", Opt_compress),
125 fsparam_flag("witness", Opt_witness),
127 /* Mount options which take numeric value */
128 fsparam_u32("backupuid", Opt_backupuid),
129 fsparam_u32("backupgid", Opt_backupgid),
130 fsparam_u32("uid", Opt_uid),
131 fsparam_u32("cruid", Opt_cruid),
132 fsparam_u32("gid", Opt_gid),
133 fsparam_u32("file_mode", Opt_file_mode),
134 fsparam_u32("dirmode", Opt_dirmode),
135 fsparam_u32("dir_mode", Opt_dirmode),
136 fsparam_u32("port", Opt_port),
137 fsparam_u32("min_enc_offload", Opt_min_enc_offload),
138 fsparam_u32("esize", Opt_min_enc_offload),
139 fsparam_u32("bsize", Opt_blocksize),
140 fsparam_u32("rasize", Opt_rasize),
141 fsparam_u32("rsize", Opt_rsize),
142 fsparam_u32("wsize", Opt_wsize),
143 fsparam_u32("actimeo", Opt_actimeo),
144 fsparam_u32("acdirmax", Opt_acdirmax),
145 fsparam_u32("acregmax", Opt_acregmax),
146 fsparam_u32("echo_interval", Opt_echo_interval),
147 fsparam_u32("max_credits", Opt_max_credits),
148 fsparam_u32("handletimeout", Opt_handletimeout),
149 fsparam_u32("snapshot", Opt_snapshot),
150 fsparam_u32("max_channels", Opt_max_channels),
152 /* Mount options which take string value */
153 fsparam_string("source", Opt_source),
154 fsparam_string("user", Opt_user),
155 fsparam_string("username", Opt_user),
156 fsparam_string("pass", Opt_pass),
157 fsparam_string("password", Opt_pass),
158 fsparam_string("ip", Opt_ip),
159 fsparam_string("addr", Opt_ip),
160 fsparam_string("domain", Opt_domain),
161 fsparam_string("dom", Opt_domain),
162 fsparam_string("srcaddr", Opt_srcaddr),
163 fsparam_string("iocharset", Opt_iocharset),
164 fsparam_string("netbiosname", Opt_netbiosname),
165 fsparam_string("servern", Opt_servern),
166 fsparam_string("ver", Opt_ver),
167 fsparam_string("vers", Opt_vers),
168 fsparam_string("sec", Opt_sec),
169 fsparam_string("cache", Opt_cache),
171 /* Arguments that should be ignored */
172 fsparam_flag("guest", Opt_ignore),
173 fsparam_flag("noatime", Opt_ignore),
174 fsparam_flag("relatime", Opt_ignore),
175 fsparam_flag("_netdev", Opt_ignore),
176 fsparam_flag_no("suid", Opt_ignore),
177 fsparam_flag_no("exec", Opt_ignore),
178 fsparam_flag_no("dev", Opt_ignore),
179 fsparam_flag_no("mand", Opt_ignore),
180 fsparam_flag_no("auto", Opt_ignore),
181 fsparam_string("cred", Opt_ignore),
182 fsparam_string("credentials", Opt_ignore),
184 * UNC and prefixpath is now extracted from Opt_source
185 * in the new mount API so we can just ignore them going forward.
187 fsparam_string("unc", Opt_ignore),
188 fsparam_string("prefixpath", Opt_ignore),
193 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
196 substring_t args[MAX_OPT_ARGS];
199 * With mount options, the last one should win. Reset any existing
200 * settings back to default.
202 ctx->sectype = Unspecified;
205 switch (match_token(value, cifs_secflavor_tokens, args)) {
207 cifs_errorf(fc, "sec=krb5p is not supported!\n");
213 ctx->sectype = Kerberos;
215 case Opt_sec_ntlmsspi:
218 case Opt_sec_ntlmssp:
219 ctx->sectype = RawNTLMSSP;
227 case Opt_sec_ntlmv2i:
231 ctx->sectype = NTLMv2;
233 #ifdef CONFIG_CIFS_WEAK_PW_HASH
235 ctx->sectype = LANMAN;
242 cifs_errorf(fc, "bad security option: %s\n", value);
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 }
259 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
261 substring_t args[MAX_OPT_ARGS];
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;
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;
277 ctx->direct_io = true;
278 ctx->strict_io = false;
279 ctx->cache_ro = false;
280 ctx->cache_rw = false;
283 ctx->direct_io = false;
284 ctx->strict_io = false;
285 ctx->cache_ro = true;
286 ctx->cache_rw = false;
289 ctx->direct_io = false;
290 ctx->strict_io = false;
291 ctx->cache_ro = false;
292 ctx->cache_rw = true;
295 cifs_errorf(fc, "bad cache= option: %s\n", value);
301 #define DUP_CTX_STR(field) \
304 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
305 if (new_ctx->field == NULL) { \
306 smb3_cleanup_fs_context_contents(new_ctx); \
313 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
315 memcpy(new_ctx, ctx, sizeof(*ctx));
316 new_ctx->prepath = NULL;
317 new_ctx->mount_options = NULL;
318 new_ctx->nodename = NULL;
319 new_ctx->username = NULL;
320 new_ctx->password = NULL;
321 new_ctx->domainname = NULL;
323 new_ctx->source = NULL;
324 new_ctx->iocharset = NULL;
326 * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
328 DUP_CTX_STR(prepath);
329 DUP_CTX_STR(mount_options);
330 DUP_CTX_STR(username);
331 DUP_CTX_STR(password);
334 DUP_CTX_STR(domainname);
335 DUP_CTX_STR(nodename);
336 DUP_CTX_STR(iocharset);
342 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
344 substring_t args[MAX_OPT_ARGS];
346 switch (match_token(value, cifs_smb_version_tokens, args)) {
347 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
349 if (disable_legacy_dialects) {
350 cifs_errorf(fc, "mount with legacy dialect disabled\n");
354 cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
357 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
358 ctx->ops = &smb1_operations;
359 ctx->vals = &smb1_values;
362 if (disable_legacy_dialects) {
363 cifs_errorf(fc, "mount with legacy dialect disabled\n");
367 cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
370 ctx->ops = &smb20_operations;
371 ctx->vals = &smb20_values;
375 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
378 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
380 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
382 ctx->ops = &smb21_operations;
383 ctx->vals = &smb21_values;
386 ctx->ops = &smb30_operations;
387 ctx->vals = &smb30_values;
390 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
391 ctx->vals = &smb302_values;
394 ctx->ops = &smb311_operations;
395 ctx->vals = &smb311_values;
398 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
399 ctx->vals = &smb3any_values;
402 ctx->ops = &smb30_operations;
403 ctx->vals = &smbdefault_values;
406 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
412 int smb3_parse_opt(const char *options, const char *key, char **val)
415 char *opts, *orig, *p;
417 orig = opts = kstrdup(options, GFP_KERNEL);
421 while ((p = strsep(&opts, ","))) {
426 if (strncasecmp(p, key, strlen(key)))
428 nval = strchr(p, '=');
433 *val = kstrdup(nval, GFP_KERNEL);
434 rc = !*val ? -ENOMEM : 0;
444 * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
445 * fields with the result. Returns 0 on success and an error otherwise
446 * (e.g. ENOMEM or EINVAL)
449 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
452 const char *delims = "/\\";
455 if (unlikely(!devname || !*devname)) {
456 cifs_dbg(VFS, "Device name not specified\n");
460 /* make sure we have a valid UNC double delimiter prefix */
461 len = strspn(devname, delims);
465 /* find delimiter between host and sharename */
466 pos = strpbrk(devname + 2, delims);
470 /* skip past delimiter */
473 /* now go until next delimiter or end of string */
474 len = strcspn(pos, delims);
476 /* move "pos" up to delimiter or NULL */
479 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
483 convert_delimiter(ctx->UNC, '\\');
485 /* skip any delimiter */
486 if (*pos == '/' || *pos == '\\')
492 /* If pos is NULL then no prepath */
496 ctx->prepath = kstrdup(pos, GFP_KERNEL);
503 static void smb3_fs_context_free(struct fs_context *fc);
504 static int smb3_fs_context_parse_param(struct fs_context *fc,
505 struct fs_parameter *param);
506 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
508 static int smb3_get_tree(struct fs_context *fc);
509 static int smb3_reconfigure(struct fs_context *fc);
511 static const struct fs_context_operations smb3_fs_context_ops = {
512 .free = smb3_fs_context_free,
513 .parse_param = smb3_fs_context_parse_param,
514 .parse_monolithic = smb3_fs_context_parse_monolithic,
515 .get_tree = smb3_get_tree,
516 .reconfigure = smb3_reconfigure,
520 * Parse a monolithic block of data from sys_mount().
521 * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
522 * @ctx: The superblock configuration to fill in.
523 * @data: The data to parse
525 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
526 * called from the ->monolithic_mount_data() fs_context operation.
528 * Returns 0 on success or the error returned by the ->parse_option() fs_context
529 * operation on failure.
531 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
534 struct smb3_fs_context *ctx = smb3_fc2context(fc);
535 char *options = data, *key;
541 ctx->mount_options = kstrdup(data, GFP_KERNEL);
542 if (ctx->mount_options == NULL)
545 ret = security_sb_eat_lsm_opts(options, &fc->security);
549 /* BB Need to add support for sep= here TBD */
550 while ((key = strsep(&options, ",")) != NULL) {
557 /* Check if following character is the deliminator If yes,
558 * we have encountered a double deliminator reset the NULL
559 * character to the deliminator
561 while (options && options[0] == ',') {
563 strcpy(key + len, options);
564 options = strchr(options, ',');
571 value = strchr(key, '=');
579 ret = vfs_parse_fs_string(fc, key, value, len);
588 * Validate the preparsed information in the config.
590 static int smb3_fs_context_validate(struct fs_context *fc)
592 struct smb3_fs_context *ctx = smb3_fc2context(fc);
594 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
595 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
600 /* Muliuser mounts require CONFIG_KEYS support */
601 if (ctx->multiuser) {
602 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
607 if (ctx->got_version == false)
608 pr_warn_once("No dialect specified on mount. Default has changed to a more secure dialect, SMB2.1 or later (e.g. SMB3.1.1), from CIFS (SMB1). To use the less secure SMB1 dialect to access old servers which do not support SMB3.1.1 (or even SMB3 or SMB2.1) specify vers=1.0 on mount.\n");
612 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
616 /* make sure UNC has a share name */
617 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
618 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
626 /* No ip= option specified? Try to get it from UNC */
627 /* Use the address part of the UNC. */
628 slash = strchr(&ctx->UNC[2], '\\');
629 len = slash - &ctx->UNC[2];
630 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
631 &ctx->UNC[2], len)) {
632 pr_err("Unable to determine destination address\n");
633 return -EHOSTUNREACH;
637 /* set the port that we got earlier */
638 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
640 if (ctx->override_uid && !ctx->uid_specified) {
641 ctx->override_uid = 0;
642 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
645 if (ctx->override_gid && !ctx->gid_specified) {
646 ctx->override_gid = 0;
647 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
653 static int smb3_get_tree_common(struct fs_context *fc)
655 struct smb3_fs_context *ctx = smb3_fc2context(fc);
659 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
661 return PTR_ERR(root);
669 * Create an SMB3 superblock from the parameters passed.
671 static int smb3_get_tree(struct fs_context *fc)
673 int err = smb3_fs_context_validate(fc);
677 return smb3_get_tree_common(fc);
680 static void smb3_fs_context_free(struct fs_context *fc)
682 struct smb3_fs_context *ctx = smb3_fc2context(fc);
684 smb3_cleanup_fs_context(ctx);
688 * Compare the old and new proposed context during reconfigure
689 * and check if the changes are compatible.
691 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
692 struct smb3_fs_context *new_ctx,
693 struct smb3_fs_context *old_ctx)
695 if (new_ctx->posix_paths != old_ctx->posix_paths) {
696 cifs_errorf(fc, "can not change posixpaths during remount\n");
699 if (new_ctx->sectype != old_ctx->sectype) {
700 cifs_errorf(fc, "can not change sec during remount\n");
703 if (new_ctx->multiuser != old_ctx->multiuser) {
704 cifs_errorf(fc, "can not change multiuser during remount\n");
708 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
709 cifs_errorf(fc, "can not change UNC during remount\n");
712 if (new_ctx->username &&
713 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
714 cifs_errorf(fc, "can not change username during remount\n");
717 if (new_ctx->password &&
718 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
719 cifs_errorf(fc, "can not change password during remount\n");
722 if (new_ctx->domainname &&
723 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
724 cifs_errorf(fc, "can not change domainname during remount\n");
727 if (new_ctx->nodename &&
728 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
729 cifs_errorf(fc, "can not change nodename during remount\n");
732 if (new_ctx->iocharset &&
733 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
734 cifs_errorf(fc, "can not change iocharset during remount\n");
741 #define STEAL_STRING(cifs_sb, ctx, field) \
744 ctx->field = cifs_sb->ctx->field; \
745 cifs_sb->ctx->field = NULL; \
748 static int smb3_reconfigure(struct fs_context *fc)
750 struct smb3_fs_context *ctx = smb3_fc2context(fc);
751 struct dentry *root = fc->root;
752 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
755 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
760 * We can not change UNC/username/password/domainname/nodename/iocharset
761 * during reconnect so ignore what we have in the new context and
762 * just use what we already have in cifs_sb->ctx.
764 STEAL_STRING(cifs_sb, ctx, UNC);
765 STEAL_STRING(cifs_sb, ctx, source);
766 STEAL_STRING(cifs_sb, ctx, username);
767 STEAL_STRING(cifs_sb, ctx, password);
768 STEAL_STRING(cifs_sb, ctx, domainname);
769 STEAL_STRING(cifs_sb, ctx, nodename);
770 STEAL_STRING(cifs_sb, ctx, iocharset);
772 /* if rsize or wsize not passed in on remount, use previous values */
774 ctx->rsize = cifs_sb->ctx->rsize;
776 ctx->wsize = cifs_sb->ctx->wsize;
779 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
780 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
781 smb3_update_mnt_flags(cifs_sb);
786 static int smb3_fs_context_parse_param(struct fs_context *fc,
787 struct fs_parameter *param)
789 struct fs_parse_result result;
790 struct smb3_fs_context *ctx = smb3_fc2context(fc);
792 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
793 bool skip_parsing = false;
797 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
800 * fs_parse can not handle string options with an empty value so
801 * we will need special handling of them.
803 if (param->type == fs_value_is_string && param->string[0] == 0) {
804 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
807 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
814 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
816 return ctx->sloppy ? 1 : opt;
821 ctx->compression = UNKNOWN_TYPE;
823 "SMB3 compression support is experimental\n");
845 ctx->sfu_remap = false; /* disable SFU mapping */
856 ctx->override_uid = 0;
858 ctx->override_uid = 1;
862 ctx->override_gid = 0;
864 ctx->override_gid = 1;
884 case Opt_noblocksend:
896 case Opt_multichannel:
897 if (result.negated) {
898 ctx->multichannel = false;
899 ctx->max_channels = 1;
901 ctx->multichannel = true;
902 /* if number of channels not specified, default to 2 */
903 if (ctx->max_channels < 2)
904 ctx->max_channels = 2;
908 uid = make_kuid(current_user_ns(), result.uint_32);
910 goto cifs_parse_mount_err;
911 ctx->linux_uid = uid;
912 ctx->uid_specified = true;
915 uid = make_kuid(current_user_ns(), result.uint_32);
917 goto cifs_parse_mount_err;
919 ctx->cruid_specified = true;
922 uid = make_kuid(current_user_ns(), result.uint_32);
924 goto cifs_parse_mount_err;
925 ctx->backupuid = uid;
926 ctx->backupuid_specified = true;
929 gid = make_kgid(current_user_ns(), result.uint_32);
931 goto cifs_parse_mount_err;
932 ctx->backupgid = gid;
933 ctx->backupgid_specified = true;
936 gid = make_kgid(current_user_ns(), result.uint_32);
938 goto cifs_parse_mount_err;
939 ctx->linux_gid = gid;
940 ctx->gid_specified = true;
943 ctx->port = result.uint_32;
946 ctx->file_mode = result.uint_32;
949 ctx->dir_mode = result.uint_32;
951 case Opt_min_enc_offload:
952 ctx->min_offload = result.uint_32;
956 * inode blocksize realistically should never need to be
957 * less than 16K or greater than 16M and default is 1MB.
958 * Note that small inode block sizes (e.g. 64K) can lead
959 * to very poor performance of common tools like cp and scp
961 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
962 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
963 cifs_errorf(fc, "%s: Invalid blocksize\n",
965 goto cifs_parse_mount_err;
967 ctx->bsize = result.uint_32;
968 ctx->got_bsize = true;
972 * readahead size realistically should never need to be
973 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
974 * (perhaps an exception should be considered in the
975 * for the case of a large number of channels
976 * when multichannel is negotiated) since that would lead
977 * to plenty of parallel I/O in flight to the server.
978 * Note that smaller read ahead sizes would
979 * hurt performance of common tools like cp and scp
980 * which often trigger sequential i/o with read ahead
982 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
983 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
984 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
985 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
986 goto cifs_parse_mount_err;
988 ctx->rasize = result.uint_32;
991 ctx->rsize = result.uint_32;
992 ctx->got_rsize = true;
995 ctx->wsize = result.uint_32;
996 ctx->got_wsize = true;
999 ctx->acregmax = HZ * result.uint_32;
1000 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1001 cifs_errorf(fc, "acregmax too large\n");
1002 goto cifs_parse_mount_err;
1006 ctx->acdirmax = HZ * result.uint_32;
1007 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1008 cifs_errorf(fc, "acdirmax too large\n");
1009 goto cifs_parse_mount_err;
1013 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1014 cifs_errorf(fc, "timeout too large\n");
1015 goto cifs_parse_mount_err;
1017 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1018 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1019 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1022 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1024 case Opt_echo_interval:
1025 ctx->echo_interval = result.uint_32;
1028 ctx->snapshot_time = result.uint_32;
1030 case Opt_max_credits:
1031 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1032 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1034 goto cifs_parse_mount_err;
1036 ctx->max_credits = result.uint_32;
1038 case Opt_max_channels:
1039 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1040 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1041 __func__, CIFS_MAX_CHANNELS);
1042 goto cifs_parse_mount_err;
1044 ctx->max_channels = result.uint_32;
1045 /* If more than one channel requested ... they want multichan */
1046 if (result.uint_32 > 1)
1047 ctx->multichannel = true;
1049 case Opt_handletimeout:
1050 ctx->handle_timeout = result.uint_32;
1051 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1052 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1053 goto cifs_parse_mount_err;
1059 switch (smb3_parse_devname(param->string, ctx)) {
1063 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1064 goto cifs_parse_mount_err;
1066 cifs_errorf(fc, "Malformed UNC in devname\n");
1067 goto cifs_parse_mount_err;
1069 cifs_errorf(fc, "Unknown error parsing devname\n");
1070 goto cifs_parse_mount_err;
1072 ctx->source = kstrdup(param->string, GFP_KERNEL);
1073 if (ctx->source == NULL) {
1074 cifs_errorf(fc, "OOM when copying UNC string\n");
1075 goto cifs_parse_mount_err;
1077 fc->source = kstrdup(param->string, GFP_KERNEL);
1078 if (fc->source == NULL) {
1079 cifs_errorf(fc, "OOM when copying UNC string\n");
1080 goto cifs_parse_mount_err;
1084 kfree(ctx->username);
1085 ctx->username = NULL;
1086 if (strlen(param->string) == 0) {
1087 /* null user, ie. anonymous authentication */
1092 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1093 CIFS_MAX_USERNAME_LEN) {
1094 pr_warn("username too long\n");
1095 goto cifs_parse_mount_err;
1097 ctx->username = kstrdup(param->string, GFP_KERNEL);
1098 if (ctx->username == NULL) {
1099 cifs_errorf(fc, "OOM when copying username string\n");
1100 goto cifs_parse_mount_err;
1104 kfree(ctx->password);
1105 ctx->password = NULL;
1106 if (strlen(param->string) == 0)
1109 ctx->password = kstrdup(param->string, GFP_KERNEL);
1110 if (ctx->password == NULL) {
1111 cifs_errorf(fc, "OOM when copying password string\n");
1112 goto cifs_parse_mount_err;
1116 if (strlen(param->string) == 0) {
1117 ctx->got_ip = false;
1120 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1122 strlen(param->string))) {
1123 pr_err("bad ip= option (%s)\n", param->string);
1124 goto cifs_parse_mount_err;
1129 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1130 == CIFS_MAX_DOMAINNAME_LEN) {
1131 pr_warn("domain name too long\n");
1132 goto cifs_parse_mount_err;
1135 kfree(ctx->domainname);
1136 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1137 if (ctx->domainname == NULL) {
1138 cifs_errorf(fc, "OOM when copying domainname string\n");
1139 goto cifs_parse_mount_err;
1141 cifs_dbg(FYI, "Domain name set\n");
1144 if (!cifs_convert_address(
1145 (struct sockaddr *)&ctx->srcaddr,
1146 param->string, strlen(param->string))) {
1147 pr_warn("Could not parse srcaddr: %s\n",
1149 goto cifs_parse_mount_err;
1153 if (strnlen(param->string, 1024) >= 65) {
1154 pr_warn("iocharset name too long\n");
1155 goto cifs_parse_mount_err;
1158 if (strncasecmp(param->string, "default", 7) != 0) {
1159 kfree(ctx->iocharset);
1160 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1161 if (ctx->iocharset == NULL) {
1162 cifs_errorf(fc, "OOM when copying iocharset string\n");
1163 goto cifs_parse_mount_err;
1166 /* if iocharset not set then load_nls_default
1169 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1171 case Opt_netbiosname:
1172 memset(ctx->source_rfc1001_name, 0x20,
1175 * FIXME: are there cases in which a comma can
1176 * be valid in workstation netbios name (and
1177 * need special handling)?
1179 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1180 /* don't ucase netbiosname for user */
1181 if (param->string[i] == 0)
1183 ctx->source_rfc1001_name[i] = param->string[i];
1185 /* The string has 16th byte zero still from
1186 * set at top of the function
1188 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1189 pr_warn("netbiosname longer than 15 truncated\n");
1192 /* last byte, type, is 0x20 for servr type */
1193 memset(ctx->target_rfc1001_name, 0x20,
1194 RFC1001_NAME_LEN_WITH_NULL);
1196 * BB are there cases in which a comma can be valid in this
1197 * workstation netbios name (and need special handling)?
1200 /* user or mount helper must uppercase the netbios name */
1201 for (i = 0; i < 15; i++) {
1202 if (param->string[i] == 0)
1204 ctx->target_rfc1001_name[i] = param->string[i];
1207 /* The string has 16th byte zero still from set at top of function */
1208 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1209 pr_warn("server netbiosname longer than 15 truncated\n");
1212 /* version of mount userspace tools, not dialect */
1213 /* If interface changes in mount.cifs bump to new ver */
1214 if (strncasecmp(param->string, "1", 1) == 0) {
1215 if (strlen(param->string) > 1) {
1216 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1218 goto cifs_parse_mount_err;
1220 /* This is the default */
1223 /* For all other value, error */
1224 pr_warn("Invalid mount helper version specified\n");
1225 goto cifs_parse_mount_err;
1227 /* protocol version (dialect) */
1228 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1229 goto cifs_parse_mount_err;
1230 ctx->got_version = true;
1233 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1234 goto cifs_parse_mount_err;
1237 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1238 goto cifs_parse_mount_err;
1241 #ifndef CONFIG_CIFS_SWN_UPCALL
1242 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1243 goto cifs_parse_mount_err;
1245 ctx->witness = true;
1246 pr_warn_once("Witness protocol support is experimental\n");
1249 #ifndef CONFIG_CIFS_ROOT
1250 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1251 goto cifs_parse_mount_err;
1255 case Opt_posixpaths:
1257 ctx->posix_paths = 0;
1259 ctx->posix_paths = 1;
1265 ctx->no_linux_ext = 1;
1271 if (result.negated) {
1273 * turn off mandatory locking in mode
1274 * if remote locking is turned off since the
1275 * local vfs will do advisory
1277 if (ctx->file_mode ==
1278 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1279 ctx->file_mode = S_IALLUGO;
1284 case Opt_handlecache:
1286 ctx->nohandlecache = 1;
1288 ctx->nohandlecache = 0;
1290 case Opt_forcemandatorylock:
1294 ctx->setuids = result.negated;
1297 ctx->intr = !result.negated;
1299 case Opt_setuidfromacl:
1300 ctx->setuidfromacl = 1;
1302 case Opt_strictsync:
1303 ctx->nostrictsync = result.negated;
1306 ctx->server_ino = !result.negated;
1308 case Opt_rwpidforward:
1309 ctx->rwpidforward = 1;
1315 ctx->cifs_acl = !result.negated;
1318 ctx->no_psx_acl = result.negated;
1320 case Opt_locallease:
1321 ctx->local_lease = 1;
1326 case Opt_ignore_signature:
1328 ctx->ignore_signature = true;
1331 /* we do not do the following in secFlags because seal
1332 * is a per tree connection (mount) not a per socket
1333 * or per-smb connection option in the protocol
1334 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1339 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1342 #ifndef CONFIG_CIFS_FSCACHE
1343 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1344 goto cifs_parse_mount_err;
1348 case Opt_mfsymlinks:
1349 ctx->mfsymlinks = true;
1352 ctx->multiuser = true;
1357 case Opt_nosharesock:
1358 ctx->nosharesock = true;
1360 case Opt_persistent:
1361 if (result.negated) {
1362 ctx->nopersistent = true;
1363 if (ctx->persistent) {
1364 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1365 goto cifs_parse_mount_err;
1368 ctx->persistent = true;
1369 if ((ctx->nopersistent) || (ctx->resilient)) {
1370 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1371 goto cifs_parse_mount_err;
1376 if (result.negated) {
1377 ctx->resilient = false; /* already the default */
1379 ctx->resilient = true;
1380 if (ctx->persistent) {
1381 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1382 goto cifs_parse_mount_err;
1386 case Opt_domainauto:
1387 ctx->domainauto = true;
1393 /* case Opt_ignore: - is ignored as expected ... */
1397 cifs_parse_mount_err:
1401 int smb3_init_fs_context(struct fs_context *fc)
1403 struct smb3_fs_context *ctx;
1404 char *nodename = utsname()->nodename;
1407 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1412 * does not have to be perfect mapping since field is
1413 * informational, only used for servers that do not support
1414 * port 445 and it can be overridden at mount time
1416 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1417 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1418 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1420 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1422 * null target name indicates to use *SMBSERVR default called name
1423 * if we end up sending RFC1001 session initialize
1425 ctx->target_rfc1001_name[0] = 0;
1426 ctx->cred_uid = current_uid();
1427 ctx->linux_uid = current_uid();
1428 ctx->linux_gid = current_gid();
1429 /* By default 4MB read ahead size, 1MB block size */
1430 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1431 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1434 * default to SFM style remapping of seven reserved characters
1435 * unless user overrides it or we negotiate CIFS POSIX where
1436 * it is unnecessary. Can not simultaneously use more than one mapping
1437 * since then readdir could list files that open could not open
1441 /* default to only allowing write access to owner of the mount */
1442 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1444 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1445 /* default is always to request posix paths. */
1446 ctx->posix_paths = 1;
1447 /* default to using server inode numbers where available */
1448 ctx->server_ino = 1;
1450 /* default is to use strict cifs caching semantics */
1451 ctx->strict_io = true;
1453 ctx->acregmax = CIFS_DEF_ACTIMEO;
1454 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1456 /* Most clients set timeout to 0, allows server to use its default */
1457 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1459 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1460 ctx->ops = &smb30_operations;
1461 ctx->vals = &smbdefault_values;
1463 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1465 /* default to no multichannel (single server connection) */
1466 ctx->multichannel = false;
1467 ctx->max_channels = 1;
1469 ctx->backupuid_specified = false; /* no backup intent for a user */
1470 ctx->backupgid_specified = false; /* no backup intent for a group */
1473 * short int override_uid = -1;
1474 * short int override_gid = -1;
1475 * char *nodename = strdup(utsname()->nodename);
1476 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1479 fc->fs_private = ctx;
1480 fc->ops = &smb3_fs_context_ops;
1485 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1491 * Make sure this stays in sync with smb3_fs_context_dup()
1493 kfree(ctx->mount_options);
1494 ctx->mount_options = NULL;
1495 kfree(ctx->username);
1496 ctx->username = NULL;
1497 kfree_sensitive(ctx->password);
1498 ctx->password = NULL;
1503 kfree(ctx->domainname);
1504 ctx->domainname = NULL;
1505 kfree(ctx->nodename);
1506 ctx->nodename = NULL;
1507 kfree(ctx->iocharset);
1508 ctx->iocharset = NULL;
1509 kfree(ctx->prepath);
1510 ctx->prepath = NULL;
1514 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1518 smb3_cleanup_fs_context_contents(ctx);
1522 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1524 struct smb3_fs_context *ctx = cifs_sb->ctx;
1527 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1529 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1532 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1534 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1537 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1539 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1541 if (ctx->setuidfromacl)
1542 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1544 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1546 if (ctx->server_ino)
1547 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1549 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1552 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1554 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1557 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1559 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1562 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1564 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1567 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1569 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1572 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1574 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1576 if (ctx->nohandlecache)
1577 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1579 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1581 if (ctx->nostrictsync)
1582 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1584 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1587 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1589 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1591 if (ctx->rwpidforward)
1592 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1594 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1597 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1599 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1602 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1604 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1606 if (ctx->backupuid_specified)
1607 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1609 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1611 if (ctx->backupgid_specified)
1612 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1614 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1616 if (ctx->override_uid)
1617 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1619 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1621 if (ctx->override_gid)
1622 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1624 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1627 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1629 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1632 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1634 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1637 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1638 CIFS_MOUNT_NO_PERM);
1640 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1644 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1646 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1649 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1651 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1653 if (ctx->mfsymlinks)
1654 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1656 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1657 if (ctx->mfsymlinks) {
1658 if (ctx->sfu_emul) {
1660 * Our SFU ("Services for Unix" emulation does not allow
1661 * creating symlinks but does allow reading existing SFU
1662 * symlinks (it does allow both creating and reading SFU
1663 * style mknod and FIFOs though). When "mfsymlinks" and
1664 * "sfu" are both enabled at the same time, it allows
1665 * reading both types of symlinks, but will only create
1666 * them with mfsymlinks format. This allows better
1667 * Apple compatibility (probably better for Samba too)
1668 * while still recognizing old Windows style symlinks.
1670 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1673 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;