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>
16 #ifdef CONFIG_CIFS_DFS_UPCALL
17 #include "dfs_cache.h"
21 #include <linux/ctype.h>
22 #include <linux/fs_context.h>
23 #include <linux/fs_parser.h>
25 #include <linux/mount.h>
26 #include <linux/parser.h>
27 #include <linux/utsname.h>
31 #include "cifsproto.h"
32 #include "cifs_unicode.h"
33 #include "cifs_debug.h"
34 #include "cifs_fs_sb.h"
37 #include "rfc1002pdu.h"
38 #include "fs_context.h"
40 static const match_table_t cifs_smb_version_tokens = {
41 { Smb_1, SMB1_VERSION_STRING },
42 { Smb_20, SMB20_VERSION_STRING},
43 { Smb_21, SMB21_VERSION_STRING },
44 { Smb_30, SMB30_VERSION_STRING },
45 { Smb_302, SMB302_VERSION_STRING },
46 { Smb_302, ALT_SMB302_VERSION_STRING },
47 { Smb_311, SMB311_VERSION_STRING },
48 { Smb_311, ALT_SMB311_VERSION_STRING },
49 { Smb_3any, SMB3ANY_VERSION_STRING },
50 { Smb_default, SMBDEFAULT_VERSION_STRING },
51 { Smb_version_err, NULL }
54 static const match_table_t cifs_secflavor_tokens = {
55 { Opt_sec_krb5, "krb5" },
56 { Opt_sec_krb5i, "krb5i" },
57 { Opt_sec_krb5p, "krb5p" },
58 { Opt_sec_ntlmsspi, "ntlmsspi" },
59 { Opt_sec_ntlmssp, "ntlmssp" },
61 { Opt_sec_ntlmi, "ntlmi" },
62 { Opt_sec_ntlmv2, "nontlm" },
63 { Opt_sec_ntlmv2, "ntlmv2" },
64 { Opt_sec_ntlmv2i, "ntlmv2i" },
65 { Opt_sec_lanman, "lanman" },
66 { Opt_sec_none, "none" },
71 const struct fs_parameter_spec smb3_fs_parameters[] = {
72 /* Mount options that take no arguments */
73 fsparam_flag_no("user_xattr", Opt_user_xattr),
74 fsparam_flag_no("forceuid", Opt_forceuid),
75 fsparam_flag_no("multichannel", Opt_multichannel),
76 fsparam_flag_no("forcegid", Opt_forcegid),
77 fsparam_flag("noblocksend", Opt_noblocksend),
78 fsparam_flag("noautotune", Opt_noautotune),
79 fsparam_flag("nolease", Opt_nolease),
80 fsparam_flag_no("hard", Opt_hard),
81 fsparam_flag_no("soft", Opt_soft),
82 fsparam_flag_no("perm", Opt_perm),
83 fsparam_flag("nodelete", Opt_nodelete),
84 fsparam_flag_no("mapposix", Opt_mapposix),
85 fsparam_flag("mapchars", Opt_mapchars),
86 fsparam_flag("nomapchars", Opt_nomapchars),
87 fsparam_flag_no("sfu", Opt_sfu),
88 fsparam_flag("nodfs", Opt_nodfs),
89 fsparam_flag_no("posixpaths", Opt_posixpaths),
90 fsparam_flag_no("unix", Opt_unix),
91 fsparam_flag_no("linux", Opt_unix),
92 fsparam_flag_no("posix", Opt_unix),
93 fsparam_flag("nocase", Opt_nocase),
94 fsparam_flag("ignorecase", Opt_nocase),
95 fsparam_flag_no("brl", Opt_brl),
96 fsparam_flag_no("handlecache", Opt_handlecache),
97 fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
98 fsparam_flag("forcemand", Opt_forcemandatorylock),
99 fsparam_flag("setuidfromacl", Opt_setuidfromacl),
100 fsparam_flag("idsfromsid", Opt_setuidfromacl),
101 fsparam_flag_no("setuids", Opt_setuids),
102 fsparam_flag_no("dynperm", Opt_dynperm),
103 fsparam_flag_no("intr", Opt_intr),
104 fsparam_flag_no("strictsync", Opt_strictsync),
105 fsparam_flag_no("serverino", Opt_serverino),
106 fsparam_flag("rwpidforward", Opt_rwpidforward),
107 fsparam_flag("cifsacl", Opt_cifsacl),
108 fsparam_flag_no("acl", Opt_acl),
109 fsparam_flag("locallease", Opt_locallease),
110 fsparam_flag("sign", Opt_sign),
111 fsparam_flag("ignore_signature", Opt_ignore_signature),
112 fsparam_flag("signloosely", Opt_ignore_signature),
113 fsparam_flag("seal", Opt_seal),
114 fsparam_flag("noac", Opt_noac),
115 fsparam_flag("fsc", Opt_fsc),
116 fsparam_flag("mfsymlinks", Opt_mfsymlinks),
117 fsparam_flag("multiuser", Opt_multiuser),
118 fsparam_flag("sloppy", Opt_sloppy),
119 fsparam_flag("nosharesock", Opt_nosharesock),
120 fsparam_flag_no("persistenthandles", Opt_persistent),
121 fsparam_flag_no("resilienthandles", Opt_resilient),
122 fsparam_flag("domainauto", Opt_domainauto),
123 fsparam_flag("rdma", Opt_rdma),
124 fsparam_flag("modesid", Opt_modesid),
125 fsparam_flag("modefromsid", Opt_modesid),
126 fsparam_flag("rootfs", Opt_rootfs),
127 fsparam_flag("compress", Opt_compress),
128 fsparam_flag("witness", Opt_witness),
130 /* Mount options which take numeric value */
131 fsparam_u32("backupuid", Opt_backupuid),
132 fsparam_u32("backupgid", Opt_backupgid),
133 fsparam_u32("uid", Opt_uid),
134 fsparam_u32("cruid", Opt_cruid),
135 fsparam_u32("gid", Opt_gid),
136 fsparam_u32("file_mode", Opt_file_mode),
137 fsparam_u32("dirmode", Opt_dirmode),
138 fsparam_u32("dir_mode", Opt_dirmode),
139 fsparam_u32("port", Opt_port),
140 fsparam_u32("min_enc_offload", Opt_min_enc_offload),
141 fsparam_u32("esize", Opt_min_enc_offload),
142 fsparam_u32("bsize", Opt_blocksize),
143 fsparam_u32("rasize", Opt_rasize),
144 fsparam_u32("rsize", Opt_rsize),
145 fsparam_u32("wsize", Opt_wsize),
146 fsparam_u32("actimeo", Opt_actimeo),
147 fsparam_u32("acdirmax", Opt_acdirmax),
148 fsparam_u32("acregmax", Opt_acregmax),
149 fsparam_u32("echo_interval", Opt_echo_interval),
150 fsparam_u32("max_credits", Opt_max_credits),
151 fsparam_u32("handletimeout", Opt_handletimeout),
152 fsparam_u32("snapshot", Opt_snapshot),
153 fsparam_u32("max_channels", Opt_max_channels),
155 /* Mount options which take string value */
156 fsparam_string("source", Opt_source),
157 fsparam_string("user", Opt_user),
158 fsparam_string("username", Opt_user),
159 fsparam_string("pass", Opt_pass),
160 fsparam_string("password", Opt_pass),
161 fsparam_string("ip", Opt_ip),
162 fsparam_string("addr", Opt_ip),
163 fsparam_string("domain", Opt_domain),
164 fsparam_string("dom", Opt_domain),
165 fsparam_string("srcaddr", Opt_srcaddr),
166 fsparam_string("iocharset", Opt_iocharset),
167 fsparam_string("netbiosname", Opt_netbiosname),
168 fsparam_string("servern", Opt_servern),
169 fsparam_string("ver", Opt_ver),
170 fsparam_string("vers", Opt_vers),
171 fsparam_string("sec", Opt_sec),
172 fsparam_string("cache", Opt_cache),
174 /* Arguments that should be ignored */
175 fsparam_flag("guest", Opt_ignore),
176 fsparam_flag("noatime", Opt_ignore),
177 fsparam_flag("relatime", Opt_ignore),
178 fsparam_flag("_netdev", Opt_ignore),
179 fsparam_flag_no("suid", Opt_ignore),
180 fsparam_flag_no("exec", Opt_ignore),
181 fsparam_flag_no("dev", Opt_ignore),
182 fsparam_flag_no("mand", Opt_ignore),
183 fsparam_flag_no("auto", Opt_ignore),
184 fsparam_string("cred", Opt_ignore),
185 fsparam_string("credentials", Opt_ignore),
187 * UNC and prefixpath is now extracted from Opt_source
188 * in the new mount API so we can just ignore them going forward.
190 fsparam_string("unc", Opt_ignore),
191 fsparam_string("prefixpath", Opt_ignore),
196 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
199 substring_t args[MAX_OPT_ARGS];
202 * With mount options, the last one should win. Reset any existing
203 * settings back to default.
205 ctx->sectype = Unspecified;
208 switch (match_token(value, cifs_secflavor_tokens, args)) {
210 cifs_errorf(fc, "sec=krb5p is not supported!\n");
216 ctx->sectype = Kerberos;
218 case Opt_sec_ntlmsspi:
221 case Opt_sec_ntlmssp:
222 ctx->sectype = RawNTLMSSP;
230 case Opt_sec_ntlmv2i:
234 ctx->sectype = NTLMv2;
236 #ifdef CONFIG_CIFS_WEAK_PW_HASH
238 ctx->sectype = LANMAN;
245 cifs_errorf(fc, "bad security option: %s\n", value);
252 static const match_table_t cifs_cacheflavor_tokens = {
253 { Opt_cache_loose, "loose" },
254 { Opt_cache_strict, "strict" },
255 { Opt_cache_none, "none" },
256 { Opt_cache_ro, "ro" },
257 { Opt_cache_rw, "singleclient" },
258 { Opt_cache_err, NULL }
262 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
264 substring_t args[MAX_OPT_ARGS];
266 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
267 case Opt_cache_loose:
268 ctx->direct_io = false;
269 ctx->strict_io = false;
270 ctx->cache_ro = false;
271 ctx->cache_rw = false;
273 case Opt_cache_strict:
274 ctx->direct_io = false;
275 ctx->strict_io = true;
276 ctx->cache_ro = false;
277 ctx->cache_rw = false;
280 ctx->direct_io = true;
281 ctx->strict_io = false;
282 ctx->cache_ro = false;
283 ctx->cache_rw = false;
286 ctx->direct_io = false;
287 ctx->strict_io = false;
288 ctx->cache_ro = true;
289 ctx->cache_rw = false;
292 ctx->direct_io = false;
293 ctx->strict_io = false;
294 ctx->cache_ro = false;
295 ctx->cache_rw = true;
298 cifs_errorf(fc, "bad cache= option: %s\n", value);
304 #define DUP_CTX_STR(field) \
307 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
308 if (new_ctx->field == NULL) { \
309 smb3_cleanup_fs_context_contents(new_ctx); \
316 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
318 memcpy(new_ctx, ctx, sizeof(*ctx));
319 new_ctx->prepath = NULL;
320 new_ctx->mount_options = NULL;
321 new_ctx->nodename = NULL;
322 new_ctx->username = NULL;
323 new_ctx->password = NULL;
324 new_ctx->domainname = NULL;
326 new_ctx->source = NULL;
327 new_ctx->iocharset = NULL;
329 * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
331 DUP_CTX_STR(prepath);
332 DUP_CTX_STR(mount_options);
333 DUP_CTX_STR(username);
334 DUP_CTX_STR(password);
337 DUP_CTX_STR(domainname);
338 DUP_CTX_STR(nodename);
339 DUP_CTX_STR(iocharset);
345 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
347 substring_t args[MAX_OPT_ARGS];
349 switch (match_token(value, cifs_smb_version_tokens, args)) {
350 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
352 if (disable_legacy_dialects) {
353 cifs_errorf(fc, "mount with legacy dialect disabled\n");
357 cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
360 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
361 ctx->ops = &smb1_operations;
362 ctx->vals = &smb1_values;
365 if (disable_legacy_dialects) {
366 cifs_errorf(fc, "mount with legacy dialect disabled\n");
370 cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
373 ctx->ops = &smb20_operations;
374 ctx->vals = &smb20_values;
378 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
381 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
383 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
385 ctx->ops = &smb21_operations;
386 ctx->vals = &smb21_values;
389 ctx->ops = &smb30_operations;
390 ctx->vals = &smb30_values;
393 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
394 ctx->vals = &smb302_values;
397 ctx->ops = &smb311_operations;
398 ctx->vals = &smb311_values;
401 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
402 ctx->vals = &smb3any_values;
405 ctx->ops = &smb30_operations;
406 ctx->vals = &smbdefault_values;
409 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
415 int smb3_parse_opt(const char *options, const char *key, char **val)
418 char *opts, *orig, *p;
420 orig = opts = kstrdup(options, GFP_KERNEL);
424 while ((p = strsep(&opts, ","))) {
429 if (strncasecmp(p, key, strlen(key)))
431 nval = strchr(p, '=');
436 *val = kstrdup(nval, GFP_KERNEL);
437 rc = !*val ? -ENOMEM : 0;
447 * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
448 * fields with the result. Returns 0 on success and an error otherwise
449 * (e.g. ENOMEM or EINVAL)
452 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
455 const char *delims = "/\\";
458 if (unlikely(!devname || !*devname)) {
459 cifs_dbg(VFS, "Device name not specified\n");
463 /* make sure we have a valid UNC double delimiter prefix */
464 len = strspn(devname, delims);
468 /* find delimiter between host and sharename */
469 pos = strpbrk(devname + 2, delims);
473 /* skip past delimiter */
476 /* now go until next delimiter or end of string */
477 len = strcspn(pos, delims);
479 /* move "pos" up to delimiter or NULL */
482 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
486 convert_delimiter(ctx->UNC, '\\');
488 /* skip any delimiter */
489 if (*pos == '/' || *pos == '\\')
495 /* If pos is NULL then no prepath */
499 ctx->prepath = kstrdup(pos, GFP_KERNEL);
506 static void smb3_fs_context_free(struct fs_context *fc);
507 static int smb3_fs_context_parse_param(struct fs_context *fc,
508 struct fs_parameter *param);
509 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
511 static int smb3_get_tree(struct fs_context *fc);
512 static int smb3_reconfigure(struct fs_context *fc);
514 static const struct fs_context_operations smb3_fs_context_ops = {
515 .free = smb3_fs_context_free,
516 .parse_param = smb3_fs_context_parse_param,
517 .parse_monolithic = smb3_fs_context_parse_monolithic,
518 .get_tree = smb3_get_tree,
519 .reconfigure = smb3_reconfigure,
523 * Parse a monolithic block of data from sys_mount().
524 * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
525 * @ctx: The superblock configuration to fill in.
526 * @data: The data to parse
528 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
529 * called from the ->monolithic_mount_data() fs_context operation.
531 * Returns 0 on success or the error returned by the ->parse_option() fs_context
532 * operation on failure.
534 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
537 struct smb3_fs_context *ctx = smb3_fc2context(fc);
538 char *options = data, *key;
544 ctx->mount_options = kstrdup(data, GFP_KERNEL);
545 if (ctx->mount_options == NULL)
548 ret = security_sb_eat_lsm_opts(options, &fc->security);
552 /* BB Need to add support for sep= here TBD */
553 while ((key = strsep(&options, ",")) != NULL) {
560 /* Check if following character is the deliminator If yes,
561 * we have encountered a double deliminator reset the NULL
562 * character to the deliminator
564 while (options && options[0] == ',') {
566 strcpy(key + len, options);
567 options = strchr(options, ',');
574 value = strchr(key, '=');
582 ret = vfs_parse_fs_string(fc, key, value, len);
591 * Validate the preparsed information in the config.
593 static int smb3_fs_context_validate(struct fs_context *fc)
595 struct smb3_fs_context *ctx = smb3_fc2context(fc);
597 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
598 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
603 /* Muliuser mounts require CONFIG_KEYS support */
604 if (ctx->multiuser) {
605 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
610 if (ctx->got_version == false)
611 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");
615 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
619 /* make sure UNC has a share name */
620 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
621 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
629 /* No ip= option specified? Try to get it from UNC */
630 /* Use the address part of the UNC. */
631 slash = strchr(&ctx->UNC[2], '\\');
632 len = slash - &ctx->UNC[2];
633 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
634 &ctx->UNC[2], len)) {
635 pr_err("Unable to determine destination address\n");
636 return -EHOSTUNREACH;
640 /* set the port that we got earlier */
641 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
643 if (ctx->override_uid && !ctx->uid_specified) {
644 ctx->override_uid = 0;
645 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
648 if (ctx->override_gid && !ctx->gid_specified) {
649 ctx->override_gid = 0;
650 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
656 static int smb3_get_tree_common(struct fs_context *fc)
658 struct smb3_fs_context *ctx = smb3_fc2context(fc);
662 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
664 return PTR_ERR(root);
672 * Create an SMB3 superblock from the parameters passed.
674 static int smb3_get_tree(struct fs_context *fc)
676 int err = smb3_fs_context_validate(fc);
680 return smb3_get_tree_common(fc);
683 static void smb3_fs_context_free(struct fs_context *fc)
685 struct smb3_fs_context *ctx = smb3_fc2context(fc);
687 smb3_cleanup_fs_context(ctx);
691 * Compare the old and new proposed context during reconfigure
692 * and check if the changes are compatible.
694 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
695 struct smb3_fs_context *new_ctx,
696 struct smb3_fs_context *old_ctx)
698 if (new_ctx->posix_paths != old_ctx->posix_paths) {
699 cifs_errorf(fc, "can not change posixpaths during remount\n");
702 if (new_ctx->sectype != old_ctx->sectype) {
703 cifs_errorf(fc, "can not change sec during remount\n");
706 if (new_ctx->multiuser != old_ctx->multiuser) {
707 cifs_errorf(fc, "can not change multiuser during remount\n");
711 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
712 cifs_errorf(fc, "can not change UNC during remount\n");
715 if (new_ctx->username &&
716 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
717 cifs_errorf(fc, "can not change username during remount\n");
720 if (new_ctx->password &&
721 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
722 cifs_errorf(fc, "can not change password during remount\n");
725 if (new_ctx->domainname &&
726 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
727 cifs_errorf(fc, "can not change domainname during remount\n");
730 if (new_ctx->nodename &&
731 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
732 cifs_errorf(fc, "can not change nodename during remount\n");
735 if (new_ctx->iocharset &&
736 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
737 cifs_errorf(fc, "can not change iocharset during remount\n");
744 #define STEAL_STRING(cifs_sb, ctx, field) \
747 ctx->field = cifs_sb->ctx->field; \
748 cifs_sb->ctx->field = NULL; \
751 static int smb3_reconfigure(struct fs_context *fc)
753 struct smb3_fs_context *ctx = smb3_fc2context(fc);
754 struct dentry *root = fc->root;
755 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
758 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
763 * We can not change UNC/username/password/domainname/nodename/iocharset
764 * during reconnect so ignore what we have in the new context and
765 * just use what we already have in cifs_sb->ctx.
767 STEAL_STRING(cifs_sb, ctx, UNC);
768 STEAL_STRING(cifs_sb, ctx, source);
769 STEAL_STRING(cifs_sb, ctx, username);
770 STEAL_STRING(cifs_sb, ctx, password);
771 STEAL_STRING(cifs_sb, ctx, domainname);
772 STEAL_STRING(cifs_sb, ctx, nodename);
773 STEAL_STRING(cifs_sb, ctx, iocharset);
775 /* if rsize or wsize not passed in on remount, use previous values */
777 ctx->rsize = cifs_sb->ctx->rsize;
779 ctx->wsize = cifs_sb->ctx->wsize;
782 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
783 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
784 smb3_update_mnt_flags(cifs_sb);
785 #ifdef CONFIG_CIFS_DFS_UPCALL
787 rc = dfs_cache_remount_fs(cifs_sb);
793 static int smb3_fs_context_parse_param(struct fs_context *fc,
794 struct fs_parameter *param)
796 struct fs_parse_result result;
797 struct smb3_fs_context *ctx = smb3_fc2context(fc);
799 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
800 bool skip_parsing = false;
804 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
807 * fs_parse can not handle string options with an empty value so
808 * we will need special handling of them.
810 if (param->type == fs_value_is_string && param->string[0] == 0) {
811 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
814 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
821 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
823 return ctx->sloppy ? 1 : opt;
828 ctx->compression = UNKNOWN_TYPE;
830 "SMB3 compression support is experimental\n");
852 ctx->sfu_remap = false; /* disable SFU mapping */
863 ctx->override_uid = 0;
865 ctx->override_uid = 1;
869 ctx->override_gid = 0;
871 ctx->override_gid = 1;
891 case Opt_noblocksend:
903 case Opt_multichannel:
904 if (result.negated) {
905 ctx->multichannel = false;
906 ctx->max_channels = 1;
908 ctx->multichannel = true;
909 /* if number of channels not specified, default to 2 */
910 if (ctx->max_channels < 2)
911 ctx->max_channels = 2;
915 uid = make_kuid(current_user_ns(), result.uint_32);
917 goto cifs_parse_mount_err;
918 ctx->linux_uid = uid;
919 ctx->uid_specified = true;
922 uid = make_kuid(current_user_ns(), result.uint_32);
924 goto cifs_parse_mount_err;
926 ctx->cruid_specified = true;
929 uid = make_kuid(current_user_ns(), result.uint_32);
931 goto cifs_parse_mount_err;
932 ctx->backupuid = uid;
933 ctx->backupuid_specified = true;
936 gid = make_kgid(current_user_ns(), result.uint_32);
938 goto cifs_parse_mount_err;
939 ctx->backupgid = gid;
940 ctx->backupgid_specified = true;
943 gid = make_kgid(current_user_ns(), result.uint_32);
945 goto cifs_parse_mount_err;
946 ctx->linux_gid = gid;
947 ctx->gid_specified = true;
950 ctx->port = result.uint_32;
953 ctx->file_mode = result.uint_32;
956 ctx->dir_mode = result.uint_32;
958 case Opt_min_enc_offload:
959 ctx->min_offload = result.uint_32;
963 * inode blocksize realistically should never need to be
964 * less than 16K or greater than 16M and default is 1MB.
965 * Note that small inode block sizes (e.g. 64K) can lead
966 * to very poor performance of common tools like cp and scp
968 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
969 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
970 cifs_errorf(fc, "%s: Invalid blocksize\n",
972 goto cifs_parse_mount_err;
974 ctx->bsize = result.uint_32;
975 ctx->got_bsize = true;
979 * readahead size realistically should never need to be
980 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
981 * (perhaps an exception should be considered in the
982 * for the case of a large number of channels
983 * when multichannel is negotiated) since that would lead
984 * to plenty of parallel I/O in flight to the server.
985 * Note that smaller read ahead sizes would
986 * hurt performance of common tools like cp and scp
987 * which often trigger sequential i/o with read ahead
989 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
990 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
991 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
992 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
993 goto cifs_parse_mount_err;
995 ctx->rasize = result.uint_32;
998 ctx->rsize = result.uint_32;
999 ctx->got_rsize = true;
1002 ctx->wsize = result.uint_32;
1003 ctx->got_wsize = true;
1006 ctx->acregmax = HZ * result.uint_32;
1007 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1008 cifs_errorf(fc, "acregmax too large\n");
1009 goto cifs_parse_mount_err;
1013 ctx->acdirmax = HZ * result.uint_32;
1014 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1015 cifs_errorf(fc, "acdirmax too large\n");
1016 goto cifs_parse_mount_err;
1020 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1021 cifs_errorf(fc, "timeout too large\n");
1022 goto cifs_parse_mount_err;
1024 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1025 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1026 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1029 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1031 case Opt_echo_interval:
1032 ctx->echo_interval = result.uint_32;
1035 ctx->snapshot_time = result.uint_32;
1037 case Opt_max_credits:
1038 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1039 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1041 goto cifs_parse_mount_err;
1043 ctx->max_credits = result.uint_32;
1045 case Opt_max_channels:
1046 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1047 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1048 __func__, CIFS_MAX_CHANNELS);
1049 goto cifs_parse_mount_err;
1051 ctx->max_channels = result.uint_32;
1052 /* If more than one channel requested ... they want multichan */
1053 if (result.uint_32 > 1)
1054 ctx->multichannel = true;
1056 case Opt_handletimeout:
1057 ctx->handle_timeout = result.uint_32;
1058 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1059 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1060 goto cifs_parse_mount_err;
1066 switch (smb3_parse_devname(param->string, ctx)) {
1070 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1071 goto cifs_parse_mount_err;
1073 cifs_errorf(fc, "Malformed UNC in devname\n");
1074 goto cifs_parse_mount_err;
1076 cifs_errorf(fc, "Unknown error parsing devname\n");
1077 goto cifs_parse_mount_err;
1079 ctx->source = kstrdup(param->string, GFP_KERNEL);
1080 if (ctx->source == NULL) {
1081 cifs_errorf(fc, "OOM when copying UNC string\n");
1082 goto cifs_parse_mount_err;
1084 fc->source = kstrdup(param->string, GFP_KERNEL);
1085 if (fc->source == NULL) {
1086 cifs_errorf(fc, "OOM when copying UNC string\n");
1087 goto cifs_parse_mount_err;
1091 kfree(ctx->username);
1092 ctx->username = NULL;
1093 if (strlen(param->string) == 0) {
1094 /* null user, ie. anonymous authentication */
1099 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1100 CIFS_MAX_USERNAME_LEN) {
1101 pr_warn("username too long\n");
1102 goto cifs_parse_mount_err;
1104 ctx->username = kstrdup(param->string, GFP_KERNEL);
1105 if (ctx->username == NULL) {
1106 cifs_errorf(fc, "OOM when copying username string\n");
1107 goto cifs_parse_mount_err;
1111 kfree(ctx->password);
1112 ctx->password = NULL;
1113 if (strlen(param->string) == 0)
1116 ctx->password = kstrdup(param->string, GFP_KERNEL);
1117 if (ctx->password == NULL) {
1118 cifs_errorf(fc, "OOM when copying password string\n");
1119 goto cifs_parse_mount_err;
1123 if (strlen(param->string) == 0) {
1124 ctx->got_ip = false;
1127 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1129 strlen(param->string))) {
1130 pr_err("bad ip= option (%s)\n", param->string);
1131 goto cifs_parse_mount_err;
1136 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1137 == CIFS_MAX_DOMAINNAME_LEN) {
1138 pr_warn("domain name too long\n");
1139 goto cifs_parse_mount_err;
1142 kfree(ctx->domainname);
1143 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1144 if (ctx->domainname == NULL) {
1145 cifs_errorf(fc, "OOM when copying domainname string\n");
1146 goto cifs_parse_mount_err;
1148 cifs_dbg(FYI, "Domain name set\n");
1151 if (!cifs_convert_address(
1152 (struct sockaddr *)&ctx->srcaddr,
1153 param->string, strlen(param->string))) {
1154 pr_warn("Could not parse srcaddr: %s\n",
1156 goto cifs_parse_mount_err;
1160 if (strnlen(param->string, 1024) >= 65) {
1161 pr_warn("iocharset name too long\n");
1162 goto cifs_parse_mount_err;
1165 if (strncasecmp(param->string, "default", 7) != 0) {
1166 kfree(ctx->iocharset);
1167 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1168 if (ctx->iocharset == NULL) {
1169 cifs_errorf(fc, "OOM when copying iocharset string\n");
1170 goto cifs_parse_mount_err;
1173 /* if iocharset not set then load_nls_default
1176 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1178 case Opt_netbiosname:
1179 memset(ctx->source_rfc1001_name, 0x20,
1182 * FIXME: are there cases in which a comma can
1183 * be valid in workstation netbios name (and
1184 * need special handling)?
1186 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1187 /* don't ucase netbiosname for user */
1188 if (param->string[i] == 0)
1190 ctx->source_rfc1001_name[i] = param->string[i];
1192 /* The string has 16th byte zero still from
1193 * set at top of the function
1195 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1196 pr_warn("netbiosname longer than 15 truncated\n");
1199 /* last byte, type, is 0x20 for servr type */
1200 memset(ctx->target_rfc1001_name, 0x20,
1201 RFC1001_NAME_LEN_WITH_NULL);
1203 * BB are there cases in which a comma can be valid in this
1204 * workstation netbios name (and need special handling)?
1207 /* user or mount helper must uppercase the netbios name */
1208 for (i = 0; i < 15; i++) {
1209 if (param->string[i] == 0)
1211 ctx->target_rfc1001_name[i] = param->string[i];
1214 /* The string has 16th byte zero still from set at top of function */
1215 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1216 pr_warn("server netbiosname longer than 15 truncated\n");
1219 /* version of mount userspace tools, not dialect */
1220 /* If interface changes in mount.cifs bump to new ver */
1221 if (strncasecmp(param->string, "1", 1) == 0) {
1222 if (strlen(param->string) > 1) {
1223 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1225 goto cifs_parse_mount_err;
1227 /* This is the default */
1230 /* For all other value, error */
1231 pr_warn("Invalid mount helper version specified\n");
1232 goto cifs_parse_mount_err;
1234 /* protocol version (dialect) */
1235 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1236 goto cifs_parse_mount_err;
1237 ctx->got_version = true;
1240 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1241 goto cifs_parse_mount_err;
1244 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1245 goto cifs_parse_mount_err;
1248 #ifndef CONFIG_CIFS_SWN_UPCALL
1249 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1250 goto cifs_parse_mount_err;
1252 ctx->witness = true;
1253 pr_warn_once("Witness protocol support is experimental\n");
1256 #ifndef CONFIG_CIFS_ROOT
1257 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1258 goto cifs_parse_mount_err;
1262 case Opt_posixpaths:
1264 ctx->posix_paths = 0;
1266 ctx->posix_paths = 1;
1272 ctx->no_linux_ext = 1;
1278 if (result.negated) {
1280 * turn off mandatory locking in mode
1281 * if remote locking is turned off since the
1282 * local vfs will do advisory
1284 if (ctx->file_mode ==
1285 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1286 ctx->file_mode = S_IALLUGO;
1291 case Opt_handlecache:
1293 ctx->nohandlecache = 1;
1295 ctx->nohandlecache = 0;
1297 case Opt_forcemandatorylock:
1301 ctx->setuids = result.negated;
1304 ctx->intr = !result.negated;
1306 case Opt_setuidfromacl:
1307 ctx->setuidfromacl = 1;
1309 case Opt_strictsync:
1310 ctx->nostrictsync = result.negated;
1313 ctx->server_ino = !result.negated;
1315 case Opt_rwpidforward:
1316 ctx->rwpidforward = 1;
1322 ctx->cifs_acl = !result.negated;
1325 ctx->no_psx_acl = result.negated;
1327 case Opt_locallease:
1328 ctx->local_lease = 1;
1333 case Opt_ignore_signature:
1335 ctx->ignore_signature = true;
1338 /* we do not do the following in secFlags because seal
1339 * is a per tree connection (mount) not a per socket
1340 * or per-smb connection option in the protocol
1341 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1346 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1349 #ifndef CONFIG_CIFS_FSCACHE
1350 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1351 goto cifs_parse_mount_err;
1355 case Opt_mfsymlinks:
1356 ctx->mfsymlinks = true;
1359 ctx->multiuser = true;
1364 case Opt_nosharesock:
1365 ctx->nosharesock = true;
1367 case Opt_persistent:
1368 if (result.negated) {
1369 ctx->nopersistent = true;
1370 if (ctx->persistent) {
1371 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1372 goto cifs_parse_mount_err;
1375 ctx->persistent = true;
1376 if ((ctx->nopersistent) || (ctx->resilient)) {
1377 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1378 goto cifs_parse_mount_err;
1383 if (result.negated) {
1384 ctx->resilient = false; /* already the default */
1386 ctx->resilient = true;
1387 if (ctx->persistent) {
1388 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1389 goto cifs_parse_mount_err;
1393 case Opt_domainauto:
1394 ctx->domainauto = true;
1400 /* case Opt_ignore: - is ignored as expected ... */
1404 cifs_parse_mount_err:
1408 int smb3_init_fs_context(struct fs_context *fc)
1410 struct smb3_fs_context *ctx;
1411 char *nodename = utsname()->nodename;
1414 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1419 * does not have to be perfect mapping since field is
1420 * informational, only used for servers that do not support
1421 * port 445 and it can be overridden at mount time
1423 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1424 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1425 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1427 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1429 * null target name indicates to use *SMBSERVR default called name
1430 * if we end up sending RFC1001 session initialize
1432 ctx->target_rfc1001_name[0] = 0;
1433 ctx->cred_uid = current_uid();
1434 ctx->linux_uid = current_uid();
1435 ctx->linux_gid = current_gid();
1436 /* By default 4MB read ahead size, 1MB block size */
1437 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1438 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1441 * default to SFM style remapping of seven reserved characters
1442 * unless user overrides it or we negotiate CIFS POSIX where
1443 * it is unnecessary. Can not simultaneously use more than one mapping
1444 * since then readdir could list files that open could not open
1448 /* default to only allowing write access to owner of the mount */
1449 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1451 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1452 /* default is always to request posix paths. */
1453 ctx->posix_paths = 1;
1454 /* default to using server inode numbers where available */
1455 ctx->server_ino = 1;
1457 /* default is to use strict cifs caching semantics */
1458 ctx->strict_io = true;
1460 ctx->acregmax = CIFS_DEF_ACTIMEO;
1461 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1463 /* Most clients set timeout to 0, allows server to use its default */
1464 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1466 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1467 ctx->ops = &smb30_operations;
1468 ctx->vals = &smbdefault_values;
1470 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1472 /* default to no multichannel (single server connection) */
1473 ctx->multichannel = false;
1474 ctx->max_channels = 1;
1476 ctx->backupuid_specified = false; /* no backup intent for a user */
1477 ctx->backupgid_specified = false; /* no backup intent for a group */
1480 * short int override_uid = -1;
1481 * short int override_gid = -1;
1482 * char *nodename = strdup(utsname()->nodename);
1483 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1486 fc->fs_private = ctx;
1487 fc->ops = &smb3_fs_context_ops;
1492 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1498 * Make sure this stays in sync with smb3_fs_context_dup()
1500 kfree(ctx->mount_options);
1501 ctx->mount_options = NULL;
1502 kfree(ctx->username);
1503 ctx->username = NULL;
1504 kfree_sensitive(ctx->password);
1505 ctx->password = NULL;
1510 kfree(ctx->domainname);
1511 ctx->domainname = NULL;
1512 kfree(ctx->nodename);
1513 ctx->nodename = NULL;
1514 kfree(ctx->iocharset);
1515 ctx->iocharset = NULL;
1516 kfree(ctx->prepath);
1517 ctx->prepath = NULL;
1521 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1525 smb3_cleanup_fs_context_contents(ctx);
1529 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1531 struct smb3_fs_context *ctx = cifs_sb->ctx;
1534 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1536 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1539 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1541 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1544 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1546 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1548 if (ctx->setuidfromacl)
1549 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1551 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1553 if (ctx->server_ino)
1554 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1556 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1559 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1561 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1564 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1566 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1569 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1571 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1574 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1576 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1579 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1581 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1583 if (ctx->nohandlecache)
1584 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1586 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1588 if (ctx->nostrictsync)
1589 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1591 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1594 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1596 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1598 if (ctx->rwpidforward)
1599 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1601 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1604 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1606 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1609 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1611 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1613 if (ctx->backupuid_specified)
1614 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1616 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1618 if (ctx->backupgid_specified)
1619 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1621 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1623 if (ctx->override_uid)
1624 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1626 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1628 if (ctx->override_gid)
1629 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1631 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1634 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1636 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1639 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1641 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1644 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1645 CIFS_MOUNT_NO_PERM);
1647 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1651 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1653 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1656 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1658 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1660 if (ctx->mfsymlinks)
1661 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1663 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1664 if (ctx->mfsymlinks) {
1665 if (ctx->sfu_emul) {
1667 * Our SFU ("Services for Unix" emulation does not allow
1668 * creating symlinks but does allow reading existing SFU
1669 * symlinks (it does allow both creating and reading SFU
1670 * style mknod and FIFOs though). When "mfsymlinks" and
1671 * "sfu" are both enabled at the same time, it allows
1672 * reading both types of symlinks, but will only create
1673 * them with mfsymlinks format. This allows better
1674 * Apple compatibility (probably better for Samba too)
1675 * while still recognizing old Windows style symlinks.
1677 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1680 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;