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 DEFINE_MUTEX(cifs_mount_mutex);
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 }
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" },
70 const struct fs_parameter_spec smb3_fs_parameters[] = {
71 /* Mount options that take no arguments */
72 fsparam_flag_no("user_xattr", Opt_user_xattr),
73 fsparam_flag_no("forceuid", Opt_forceuid),
74 fsparam_flag_no("multichannel", Opt_multichannel),
75 fsparam_flag_no("forcegid", Opt_forcegid),
76 fsparam_flag("noblocksend", Opt_noblocksend),
77 fsparam_flag("noautotune", Opt_noautotune),
78 fsparam_flag("nolease", Opt_nolease),
79 fsparam_flag_no("hard", Opt_hard),
80 fsparam_flag_no("soft", Opt_soft),
81 fsparam_flag_no("perm", Opt_perm),
82 fsparam_flag("nodelete", Opt_nodelete),
83 fsparam_flag_no("mapposix", Opt_mapposix),
84 fsparam_flag("mapchars", Opt_mapchars),
85 fsparam_flag("nomapchars", Opt_nomapchars),
86 fsparam_flag_no("sfu", Opt_sfu),
87 fsparam_flag("nodfs", Opt_nodfs),
88 fsparam_flag_no("posixpaths", Opt_posixpaths),
89 fsparam_flag_no("unix", Opt_unix),
90 fsparam_flag_no("linux", Opt_unix),
91 fsparam_flag_no("posix", Opt_unix),
92 fsparam_flag("nocase", Opt_nocase),
93 fsparam_flag("ignorecase", Opt_nocase),
94 fsparam_flag_no("brl", Opt_brl),
95 fsparam_flag_no("handlecache", Opt_handlecache),
96 fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
97 fsparam_flag("forcemand", Opt_forcemandatorylock),
98 fsparam_flag("setuidfromacl", Opt_setuidfromacl),
99 fsparam_flag("idsfromsid", Opt_setuidfromacl),
100 fsparam_flag_no("setuids", Opt_setuids),
101 fsparam_flag_no("dynperm", Opt_dynperm),
102 fsparam_flag_no("intr", Opt_intr),
103 fsparam_flag_no("strictsync", Opt_strictsync),
104 fsparam_flag_no("serverino", Opt_serverino),
105 fsparam_flag("rwpidforward", Opt_rwpidforward),
106 fsparam_flag("cifsacl", Opt_cifsacl),
107 fsparam_flag_no("acl", Opt_acl),
108 fsparam_flag("locallease", Opt_locallease),
109 fsparam_flag("sign", Opt_sign),
110 fsparam_flag("ignore_signature", Opt_ignore_signature),
111 fsparam_flag("signloosely", Opt_ignore_signature),
112 fsparam_flag("seal", Opt_seal),
113 fsparam_flag("noac", Opt_noac),
114 fsparam_flag("fsc", Opt_fsc),
115 fsparam_flag("mfsymlinks", Opt_mfsymlinks),
116 fsparam_flag("multiuser", Opt_multiuser),
117 fsparam_flag("sloppy", Opt_sloppy),
118 fsparam_flag("nosharesock", Opt_nosharesock),
119 fsparam_flag_no("persistenthandles", Opt_persistent),
120 fsparam_flag_no("resilienthandles", Opt_resilient),
121 fsparam_flag_no("tcpnodelay", Opt_tcp_nodelay),
122 fsparam_flag("nosparse", Opt_nosparse),
123 fsparam_flag("domainauto", Opt_domainauto),
124 fsparam_flag("rdma", Opt_rdma),
125 fsparam_flag("modesid", Opt_modesid),
126 fsparam_flag("modefromsid", Opt_modesid),
127 fsparam_flag("rootfs", Opt_rootfs),
128 fsparam_flag("compress", Opt_compress),
129 fsparam_flag("witness", Opt_witness),
131 /* Mount options which take numeric value */
132 fsparam_u32("backupuid", Opt_backupuid),
133 fsparam_u32("backupgid", Opt_backupgid),
134 fsparam_u32("uid", Opt_uid),
135 fsparam_u32("cruid", Opt_cruid),
136 fsparam_u32("gid", Opt_gid),
137 fsparam_u32("file_mode", Opt_file_mode),
138 fsparam_u32("dirmode", Opt_dirmode),
139 fsparam_u32("dir_mode", Opt_dirmode),
140 fsparam_u32("port", Opt_port),
141 fsparam_u32("min_enc_offload", Opt_min_enc_offload),
142 fsparam_u32("esize", Opt_min_enc_offload),
143 fsparam_u32("bsize", Opt_blocksize),
144 fsparam_u32("rasize", Opt_rasize),
145 fsparam_u32("rsize", Opt_rsize),
146 fsparam_u32("wsize", Opt_wsize),
147 fsparam_u32("actimeo", Opt_actimeo),
148 fsparam_u32("acdirmax", Opt_acdirmax),
149 fsparam_u32("acregmax", Opt_acregmax),
150 fsparam_u32("closetimeo", Opt_closetimeo),
151 fsparam_u32("echo_interval", Opt_echo_interval),
152 fsparam_u32("max_credits", Opt_max_credits),
153 fsparam_u32("handletimeout", Opt_handletimeout),
154 fsparam_u64("snapshot", Opt_snapshot),
155 fsparam_u32("max_channels", Opt_max_channels),
157 /* Mount options which take string value */
158 fsparam_string("source", Opt_source),
159 fsparam_string("user", Opt_user),
160 fsparam_string("username", Opt_user),
161 fsparam_string("pass", Opt_pass),
162 fsparam_string("password", Opt_pass),
163 fsparam_string("ip", Opt_ip),
164 fsparam_string("addr", Opt_ip),
165 fsparam_string("domain", Opt_domain),
166 fsparam_string("dom", Opt_domain),
167 fsparam_string("srcaddr", Opt_srcaddr),
168 fsparam_string("iocharset", Opt_iocharset),
169 fsparam_string("netbiosname", Opt_netbiosname),
170 fsparam_string("servern", Opt_servern),
171 fsparam_string("ver", Opt_ver),
172 fsparam_string("vers", Opt_vers),
173 fsparam_string("sec", Opt_sec),
174 fsparam_string("cache", Opt_cache),
176 /* Arguments that should be ignored */
177 fsparam_flag("guest", Opt_ignore),
178 fsparam_flag("noatime", Opt_ignore),
179 fsparam_flag("relatime", Opt_ignore),
180 fsparam_flag("_netdev", Opt_ignore),
181 fsparam_flag_no("suid", Opt_ignore),
182 fsparam_flag_no("exec", Opt_ignore),
183 fsparam_flag_no("dev", Opt_ignore),
184 fsparam_flag_no("mand", Opt_ignore),
185 fsparam_flag_no("auto", Opt_ignore),
186 fsparam_string("cred", Opt_ignore),
187 fsparam_string("credentials", Opt_ignore),
189 * UNC and prefixpath is now extracted from Opt_source
190 * in the new mount API so we can just ignore them going forward.
192 fsparam_string("unc", Opt_ignore),
193 fsparam_string("prefixpath", Opt_ignore),
198 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
201 substring_t args[MAX_OPT_ARGS];
204 * With mount options, the last one should win. Reset any existing
205 * settings back to default.
207 ctx->sectype = Unspecified;
210 switch (match_token(value, cifs_secflavor_tokens, args)) {
212 cifs_errorf(fc, "sec=krb5p is not supported. Use sec=krb5,seal instead\n");
218 ctx->sectype = Kerberos;
220 case Opt_sec_ntlmsspi:
223 case Opt_sec_ntlmssp:
224 ctx->sectype = RawNTLMSSP;
226 case Opt_sec_ntlmv2i:
230 ctx->sectype = NTLMv2;
236 cifs_errorf(fc, "bad security option: %s\n", value);
243 static const match_table_t cifs_cacheflavor_tokens = {
244 { Opt_cache_loose, "loose" },
245 { Opt_cache_strict, "strict" },
246 { Opt_cache_none, "none" },
247 { Opt_cache_ro, "ro" },
248 { Opt_cache_rw, "singleclient" },
249 { Opt_cache_err, NULL }
253 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
255 substring_t args[MAX_OPT_ARGS];
257 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
258 case Opt_cache_loose:
259 ctx->direct_io = false;
260 ctx->strict_io = false;
261 ctx->cache_ro = false;
262 ctx->cache_rw = false;
264 case Opt_cache_strict:
265 ctx->direct_io = false;
266 ctx->strict_io = true;
267 ctx->cache_ro = false;
268 ctx->cache_rw = false;
271 ctx->direct_io = true;
272 ctx->strict_io = false;
273 ctx->cache_ro = false;
274 ctx->cache_rw = false;
277 ctx->direct_io = false;
278 ctx->strict_io = false;
279 ctx->cache_ro = true;
280 ctx->cache_rw = false;
283 ctx->direct_io = false;
284 ctx->strict_io = false;
285 ctx->cache_ro = false;
286 ctx->cache_rw = true;
289 cifs_errorf(fc, "bad cache= option: %s\n", value);
295 #define DUP_CTX_STR(field) \
298 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
299 if (new_ctx->field == NULL) { \
300 smb3_cleanup_fs_context_contents(new_ctx); \
307 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
309 memcpy(new_ctx, ctx, sizeof(*ctx));
310 new_ctx->prepath = NULL;
311 new_ctx->mount_options = NULL;
312 new_ctx->nodename = NULL;
313 new_ctx->username = NULL;
314 new_ctx->password = NULL;
315 new_ctx->server_hostname = NULL;
316 new_ctx->domainname = NULL;
318 new_ctx->source = NULL;
319 new_ctx->iocharset = NULL;
321 * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
323 DUP_CTX_STR(prepath);
324 DUP_CTX_STR(mount_options);
325 DUP_CTX_STR(username);
326 DUP_CTX_STR(password);
327 DUP_CTX_STR(server_hostname);
330 DUP_CTX_STR(domainname);
331 DUP_CTX_STR(nodename);
332 DUP_CTX_STR(iocharset);
338 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
340 substring_t args[MAX_OPT_ARGS];
342 switch (match_token(value, cifs_smb_version_tokens, args)) {
343 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
345 if (disable_legacy_dialects) {
346 cifs_errorf(fc, "mount with legacy dialect disabled\n");
350 cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
353 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
354 ctx->ops = &smb1_operations;
355 ctx->vals = &smb1_values;
358 if (disable_legacy_dialects) {
359 cifs_errorf(fc, "mount with legacy dialect disabled\n");
363 cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
366 ctx->ops = &smb20_operations;
367 ctx->vals = &smb20_values;
371 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
374 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
376 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
378 ctx->ops = &smb21_operations;
379 ctx->vals = &smb21_values;
382 ctx->ops = &smb30_operations;
383 ctx->vals = &smb30_values;
386 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
387 ctx->vals = &smb302_values;
390 ctx->ops = &smb311_operations;
391 ctx->vals = &smb311_values;
394 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
395 ctx->vals = &smb3any_values;
398 ctx->ops = &smb30_operations;
399 ctx->vals = &smbdefault_values;
402 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
408 int smb3_parse_opt(const char *options, const char *key, char **val)
411 char *opts, *orig, *p;
413 orig = opts = kstrdup(options, GFP_KERNEL);
417 while ((p = strsep(&opts, ","))) {
422 if (strncasecmp(p, key, strlen(key)))
424 nval = strchr(p, '=');
429 *val = kstrdup(nval, GFP_KERNEL);
430 rc = !*val ? -ENOMEM : 0;
440 * Remove duplicate path delimiters. Windows is supposed to do that
441 * but there are some bugs that prevent rename from working if there are
442 * multiple delimiters.
444 * Returns a sanitized duplicate of @path. @gfp indicates the GFP_* flags
446 * The caller is responsible for freeing the original.
448 #define IS_DELIM(c) ((c) == '/' || (c) == '\\')
449 char *cifs_sanitize_prepath(char *prepath, gfp_t gfp)
451 char *cursor1 = prepath, *cursor2 = prepath;
453 /* skip all prepended delimiters */
454 while (IS_DELIM(*cursor1))
457 /* copy the first letter */
460 /* copy the remainder... */
461 while (*(cursor1++)) {
462 /* ... skipping all duplicated delimiters */
463 if (IS_DELIM(*cursor1) && IS_DELIM(*cursor2))
465 *(++cursor2) = *cursor1;
468 /* if the last character is a delimiter, skip it */
469 if (IS_DELIM(*(cursor2 - 1)))
473 return kstrdup(prepath, gfp);
477 * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
478 * fields with the result. Returns 0 on success and an error otherwise
479 * (e.g. ENOMEM or EINVAL)
482 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
485 const char *delims = "/\\";
488 if (unlikely(!devname || !*devname)) {
489 cifs_dbg(VFS, "Device name not specified\n");
493 /* make sure we have a valid UNC double delimiter prefix */
494 len = strspn(devname, delims);
498 /* find delimiter between host and sharename */
499 pos = strpbrk(devname + 2, delims);
503 /* record the server hostname */
504 kfree(ctx->server_hostname);
505 ctx->server_hostname = kstrndup(devname + 2, pos - devname - 2, GFP_KERNEL);
506 if (!ctx->server_hostname)
509 /* skip past delimiter */
512 /* now go until next delimiter or end of string */
513 len = strcspn(pos, delims);
515 /* move "pos" up to delimiter or NULL */
518 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
522 convert_delimiter(ctx->UNC, '\\');
524 /* skip any delimiter */
525 if (*pos == '/' || *pos == '\\')
531 /* If pos is NULL then no prepath */
535 ctx->prepath = cifs_sanitize_prepath(pos, GFP_KERNEL);
542 static void smb3_fs_context_free(struct fs_context *fc);
543 static int smb3_fs_context_parse_param(struct fs_context *fc,
544 struct fs_parameter *param);
545 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
547 static int smb3_get_tree(struct fs_context *fc);
548 static int smb3_reconfigure(struct fs_context *fc);
550 static const struct fs_context_operations smb3_fs_context_ops = {
551 .free = smb3_fs_context_free,
552 .parse_param = smb3_fs_context_parse_param,
553 .parse_monolithic = smb3_fs_context_parse_monolithic,
554 .get_tree = smb3_get_tree,
555 .reconfigure = smb3_reconfigure,
559 * Parse a monolithic block of data from sys_mount().
560 * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
561 * @ctx: The superblock configuration to fill in.
562 * @data: The data to parse
564 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
565 * called from the ->monolithic_mount_data() fs_context operation.
567 * Returns 0 on success or the error returned by the ->parse_option() fs_context
568 * operation on failure.
570 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
573 struct smb3_fs_context *ctx = smb3_fc2context(fc);
574 char *options = data, *key;
580 ctx->mount_options = kstrdup(data, GFP_KERNEL);
581 if (ctx->mount_options == NULL)
584 ret = security_sb_eat_lsm_opts(options, &fc->security);
588 /* BB Need to add support for sep= here TBD */
589 while ((key = strsep(&options, ",")) != NULL) {
596 /* Check if following character is the deliminator If yes,
597 * we have encountered a double deliminator reset the NULL
598 * character to the deliminator
600 while (options && options[0] == ',') {
602 strcpy(key + len, options);
603 options = strchr(options, ',');
610 value = strchr(key, '=');
618 ret = vfs_parse_fs_string(fc, key, value, len);
627 * Validate the preparsed information in the config.
629 static int smb3_fs_context_validate(struct fs_context *fc)
631 struct smb3_fs_context *ctx = smb3_fc2context(fc);
633 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
634 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
639 /* Muliuser mounts require CONFIG_KEYS support */
640 if (ctx->multiuser) {
641 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
646 if (ctx->got_version == false)
647 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");
651 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
655 /* make sure UNC has a share name */
656 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
657 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
665 /* No ip= option specified? Try to get it from UNC */
666 /* Use the address part of the UNC. */
667 slash = strchr(&ctx->UNC[2], '\\');
668 len = slash - &ctx->UNC[2];
669 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
670 &ctx->UNC[2], len)) {
671 pr_err("Unable to determine destination address\n");
672 return -EHOSTUNREACH;
676 /* set the port that we got earlier */
677 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
679 if (ctx->override_uid && !ctx->uid_specified) {
680 ctx->override_uid = 0;
681 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
684 if (ctx->override_gid && !ctx->gid_specified) {
685 ctx->override_gid = 0;
686 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
692 static int smb3_get_tree_common(struct fs_context *fc)
694 struct smb3_fs_context *ctx = smb3_fc2context(fc);
698 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
700 return PTR_ERR(root);
708 * Create an SMB3 superblock from the parameters passed.
710 static int smb3_get_tree(struct fs_context *fc)
712 int err = smb3_fs_context_validate(fc);
717 mutex_lock(&cifs_mount_mutex);
718 ret = smb3_get_tree_common(fc);
719 mutex_unlock(&cifs_mount_mutex);
723 static void smb3_fs_context_free(struct fs_context *fc)
725 struct smb3_fs_context *ctx = smb3_fc2context(fc);
727 smb3_cleanup_fs_context(ctx);
731 * Compare the old and new proposed context during reconfigure
732 * and check if the changes are compatible.
734 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
735 struct smb3_fs_context *new_ctx,
736 struct smb3_fs_context *old_ctx)
738 if (new_ctx->posix_paths != old_ctx->posix_paths) {
739 cifs_errorf(fc, "can not change posixpaths during remount\n");
742 if (new_ctx->sectype != old_ctx->sectype) {
743 cifs_errorf(fc, "can not change sec during remount\n");
746 if (new_ctx->multiuser != old_ctx->multiuser) {
747 cifs_errorf(fc, "can not change multiuser during remount\n");
751 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
752 cifs_errorf(fc, "can not change UNC during remount\n");
755 if (new_ctx->username &&
756 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
757 cifs_errorf(fc, "can not change username during remount\n");
760 if (new_ctx->password &&
761 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
762 cifs_errorf(fc, "can not change password during remount\n");
765 if (new_ctx->domainname &&
766 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
767 cifs_errorf(fc, "can not change domainname during remount\n");
770 if (strcmp(new_ctx->workstation_name, old_ctx->workstation_name)) {
771 cifs_errorf(fc, "can not change workstation_name during remount\n");
774 if (new_ctx->nodename &&
775 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
776 cifs_errorf(fc, "can not change nodename during remount\n");
779 if (new_ctx->iocharset &&
780 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
781 cifs_errorf(fc, "can not change iocharset during remount\n");
788 #define STEAL_STRING(cifs_sb, ctx, field) \
791 ctx->field = cifs_sb->ctx->field; \
792 cifs_sb->ctx->field = NULL; \
795 #define STEAL_STRING_SENSITIVE(cifs_sb, ctx, field) \
797 kfree_sensitive(ctx->field); \
798 ctx->field = cifs_sb->ctx->field; \
799 cifs_sb->ctx->field = NULL; \
802 static int smb3_reconfigure(struct fs_context *fc)
804 struct smb3_fs_context *ctx = smb3_fc2context(fc);
805 struct dentry *root = fc->root;
806 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
809 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
814 * We can not change UNC/username/password/domainname/
815 * workstation_name/nodename/iocharset
816 * during reconnect so ignore what we have in the new context and
817 * just use what we already have in cifs_sb->ctx.
819 STEAL_STRING(cifs_sb, ctx, UNC);
820 STEAL_STRING(cifs_sb, ctx, source);
821 STEAL_STRING(cifs_sb, ctx, username);
822 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password);
823 STEAL_STRING(cifs_sb, ctx, domainname);
824 STEAL_STRING(cifs_sb, ctx, nodename);
825 STEAL_STRING(cifs_sb, ctx, iocharset);
827 /* if rsize or wsize not passed in on remount, use previous values */
829 ctx->rsize = cifs_sb->ctx->rsize;
831 ctx->wsize = cifs_sb->ctx->wsize;
834 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
835 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
836 smb3_update_mnt_flags(cifs_sb);
837 #ifdef CONFIG_CIFS_DFS_UPCALL
839 rc = dfs_cache_remount_fs(cifs_sb);
845 static int smb3_fs_context_parse_param(struct fs_context *fc,
846 struct fs_parameter *param)
848 struct fs_parse_result result;
849 struct smb3_fs_context *ctx = smb3_fc2context(fc);
851 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
852 bool skip_parsing = false;
856 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
859 * fs_parse can not handle string options with an empty value so
860 * we will need special handling of them.
862 if (param->type == fs_value_is_string && param->string[0] == 0) {
863 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
866 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
873 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
875 return ctx->sloppy ? 1 : opt;
880 ctx->compression = UNKNOWN_TYPE;
882 "SMB3 compression support is experimental\n");
904 ctx->sfu_remap = false; /* disable SFU mapping */
909 ctx->sfu_remap = false;
911 ctx->sfu_remap = true;
912 ctx->remap = false; /* disable SFM (mapposix) mapping */
923 ctx->override_uid = 0;
925 ctx->override_uid = 1;
929 ctx->override_gid = 0;
931 ctx->override_gid = 1;
951 case Opt_noblocksend:
966 case Opt_multichannel:
967 if (result.negated) {
968 ctx->multichannel = false;
969 ctx->max_channels = 1;
971 ctx->multichannel = true;
972 /* if number of channels not specified, default to 2 */
973 if (ctx->max_channels < 2)
974 ctx->max_channels = 2;
978 uid = make_kuid(current_user_ns(), result.uint_32);
980 goto cifs_parse_mount_err;
981 ctx->linux_uid = uid;
982 ctx->uid_specified = true;
985 uid = make_kuid(current_user_ns(), result.uint_32);
987 goto cifs_parse_mount_err;
989 ctx->cruid_specified = true;
992 uid = make_kuid(current_user_ns(), result.uint_32);
994 goto cifs_parse_mount_err;
995 ctx->backupuid = uid;
996 ctx->backupuid_specified = true;
999 gid = make_kgid(current_user_ns(), result.uint_32);
1000 if (!gid_valid(gid))
1001 goto cifs_parse_mount_err;
1002 ctx->backupgid = gid;
1003 ctx->backupgid_specified = true;
1006 gid = make_kgid(current_user_ns(), result.uint_32);
1007 if (!gid_valid(gid))
1008 goto cifs_parse_mount_err;
1009 ctx->linux_gid = gid;
1010 ctx->gid_specified = true;
1013 ctx->port = result.uint_32;
1016 ctx->file_mode = result.uint_32;
1019 ctx->dir_mode = result.uint_32;
1021 case Opt_min_enc_offload:
1022 ctx->min_offload = result.uint_32;
1026 * inode blocksize realistically should never need to be
1027 * less than 16K or greater than 16M and default is 1MB.
1028 * Note that small inode block sizes (e.g. 64K) can lead
1029 * to very poor performance of common tools like cp and scp
1031 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1032 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1033 cifs_errorf(fc, "%s: Invalid blocksize\n",
1035 goto cifs_parse_mount_err;
1037 ctx->bsize = result.uint_32;
1038 ctx->got_bsize = true;
1042 * readahead size realistically should never need to be
1043 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1044 * (perhaps an exception should be considered in the
1045 * for the case of a large number of channels
1046 * when multichannel is negotiated) since that would lead
1047 * to plenty of parallel I/O in flight to the server.
1048 * Note that smaller read ahead sizes would
1049 * hurt performance of common tools like cp and scp
1050 * which often trigger sequential i/o with read ahead
1052 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1053 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1054 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1055 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1056 goto cifs_parse_mount_err;
1058 ctx->rasize = result.uint_32;
1061 ctx->rsize = result.uint_32;
1062 ctx->got_rsize = true;
1065 ctx->wsize = result.uint_32;
1066 ctx->got_wsize = true;
1069 ctx->acregmax = HZ * result.uint_32;
1070 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1071 cifs_errorf(fc, "acregmax too large\n");
1072 goto cifs_parse_mount_err;
1076 ctx->acdirmax = HZ * result.uint_32;
1077 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1078 cifs_errorf(fc, "acdirmax too large\n");
1079 goto cifs_parse_mount_err;
1083 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1084 cifs_errorf(fc, "timeout too large\n");
1085 goto cifs_parse_mount_err;
1087 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1088 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1089 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1092 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1094 case Opt_closetimeo:
1095 ctx->closetimeo = HZ * result.uint_32;
1096 if (ctx->closetimeo > SMB3_MAX_DCLOSETIMEO) {
1097 cifs_errorf(fc, "closetimeo too large\n");
1098 goto cifs_parse_mount_err;
1101 case Opt_echo_interval:
1102 ctx->echo_interval = result.uint_32;
1105 ctx->snapshot_time = result.uint_64;
1107 case Opt_max_credits:
1108 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1109 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1111 goto cifs_parse_mount_err;
1113 ctx->max_credits = result.uint_32;
1115 case Opt_max_channels:
1116 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1117 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1118 __func__, CIFS_MAX_CHANNELS);
1119 goto cifs_parse_mount_err;
1121 ctx->max_channels = result.uint_32;
1122 /* If more than one channel requested ... they want multichan */
1123 if (result.uint_32 > 1)
1124 ctx->multichannel = true;
1126 case Opt_handletimeout:
1127 ctx->handle_timeout = result.uint_32;
1128 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1129 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1130 goto cifs_parse_mount_err;
1136 switch (smb3_parse_devname(param->string, ctx)) {
1140 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1141 goto cifs_parse_mount_err;
1143 cifs_errorf(fc, "Malformed UNC in devname\n");
1144 goto cifs_parse_mount_err;
1146 cifs_errorf(fc, "Unknown error parsing devname\n");
1147 goto cifs_parse_mount_err;
1149 ctx->source = kstrdup(param->string, GFP_KERNEL);
1150 if (ctx->source == NULL) {
1151 cifs_errorf(fc, "OOM when copying UNC string\n");
1152 goto cifs_parse_mount_err;
1154 fc->source = kstrdup(param->string, GFP_KERNEL);
1155 if (fc->source == NULL) {
1156 cifs_errorf(fc, "OOM when copying UNC string\n");
1157 goto cifs_parse_mount_err;
1161 kfree(ctx->username);
1162 ctx->username = NULL;
1163 if (strlen(param->string) == 0) {
1164 /* null user, ie. anonymous authentication */
1169 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1170 CIFS_MAX_USERNAME_LEN) {
1171 pr_warn("username too long\n");
1172 goto cifs_parse_mount_err;
1174 ctx->username = kstrdup(param->string, GFP_KERNEL);
1175 if (ctx->username == NULL) {
1176 cifs_errorf(fc, "OOM when copying username string\n");
1177 goto cifs_parse_mount_err;
1181 kfree_sensitive(ctx->password);
1182 ctx->password = NULL;
1183 if (strlen(param->string) == 0)
1186 ctx->password = kstrdup(param->string, GFP_KERNEL);
1187 if (ctx->password == NULL) {
1188 cifs_errorf(fc, "OOM when copying password string\n");
1189 goto cifs_parse_mount_err;
1193 if (strlen(param->string) == 0) {
1194 ctx->got_ip = false;
1197 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1199 strlen(param->string))) {
1200 pr_err("bad ip= option (%s)\n", param->string);
1201 goto cifs_parse_mount_err;
1206 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1207 == CIFS_MAX_DOMAINNAME_LEN) {
1208 pr_warn("domain name too long\n");
1209 goto cifs_parse_mount_err;
1212 kfree(ctx->domainname);
1213 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1214 if (ctx->domainname == NULL) {
1215 cifs_errorf(fc, "OOM when copying domainname string\n");
1216 goto cifs_parse_mount_err;
1218 cifs_dbg(FYI, "Domain name set\n");
1221 if (!cifs_convert_address(
1222 (struct sockaddr *)&ctx->srcaddr,
1223 param->string, strlen(param->string))) {
1224 pr_warn("Could not parse srcaddr: %s\n",
1226 goto cifs_parse_mount_err;
1230 if (strnlen(param->string, 1024) >= 65) {
1231 pr_warn("iocharset name too long\n");
1232 goto cifs_parse_mount_err;
1235 if (strncasecmp(param->string, "default", 7) != 0) {
1236 kfree(ctx->iocharset);
1237 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1238 if (ctx->iocharset == NULL) {
1239 cifs_errorf(fc, "OOM when copying iocharset string\n");
1240 goto cifs_parse_mount_err;
1243 /* if iocharset not set then load_nls_default
1246 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1248 case Opt_netbiosname:
1249 memset(ctx->source_rfc1001_name, 0x20,
1252 * FIXME: are there cases in which a comma can
1253 * be valid in workstation netbios name (and
1254 * need special handling)?
1256 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1257 /* don't ucase netbiosname for user */
1258 if (param->string[i] == 0)
1260 ctx->source_rfc1001_name[i] = param->string[i];
1262 /* The string has 16th byte zero still from
1263 * set at top of the function
1265 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1266 pr_warn("netbiosname longer than 15 truncated\n");
1269 /* last byte, type, is 0x20 for servr type */
1270 memset(ctx->target_rfc1001_name, 0x20,
1271 RFC1001_NAME_LEN_WITH_NULL);
1273 * BB are there cases in which a comma can be valid in this
1274 * workstation netbios name (and need special handling)?
1277 /* user or mount helper must uppercase the netbios name */
1278 for (i = 0; i < 15; i++) {
1279 if (param->string[i] == 0)
1281 ctx->target_rfc1001_name[i] = param->string[i];
1284 /* The string has 16th byte zero still from set at top of function */
1285 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1286 pr_warn("server netbiosname longer than 15 truncated\n");
1289 /* version of mount userspace tools, not dialect */
1290 /* If interface changes in mount.cifs bump to new ver */
1291 if (strncasecmp(param->string, "1", 1) == 0) {
1292 if (strlen(param->string) > 1) {
1293 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1295 goto cifs_parse_mount_err;
1297 /* This is the default */
1300 /* For all other value, error */
1301 pr_warn("Invalid mount helper version specified\n");
1302 goto cifs_parse_mount_err;
1304 /* protocol version (dialect) */
1305 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1306 goto cifs_parse_mount_err;
1307 ctx->got_version = true;
1310 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1311 goto cifs_parse_mount_err;
1314 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1315 goto cifs_parse_mount_err;
1318 #ifndef CONFIG_CIFS_SWN_UPCALL
1319 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1320 goto cifs_parse_mount_err;
1322 ctx->witness = true;
1323 pr_warn_once("Witness protocol support is experimental\n");
1326 #ifndef CONFIG_CIFS_ROOT
1327 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1328 goto cifs_parse_mount_err;
1332 case Opt_posixpaths:
1334 ctx->posix_paths = 0;
1336 ctx->posix_paths = 1;
1339 if (result.negated) {
1340 if (ctx->linux_ext == 1)
1341 pr_warn_once("conflicting posix mount options specified\n");
1343 ctx->no_linux_ext = 1;
1345 if (ctx->no_linux_ext == 1)
1346 pr_warn_once("conflicting posix mount options specified\n");
1348 ctx->no_linux_ext = 0;
1355 if (result.negated) {
1357 * turn off mandatory locking in mode
1358 * if remote locking is turned off since the
1359 * local vfs will do advisory
1361 if (ctx->file_mode ==
1362 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1363 ctx->file_mode = S_IALLUGO;
1368 case Opt_handlecache:
1370 ctx->nohandlecache = 1;
1372 ctx->nohandlecache = 0;
1374 case Opt_forcemandatorylock:
1378 ctx->setuids = result.negated;
1381 ctx->intr = !result.negated;
1383 case Opt_setuidfromacl:
1384 ctx->setuidfromacl = 1;
1386 case Opt_strictsync:
1387 ctx->nostrictsync = result.negated;
1390 ctx->server_ino = !result.negated;
1392 case Opt_rwpidforward:
1393 ctx->rwpidforward = 1;
1399 ctx->cifs_acl = !result.negated;
1402 ctx->no_psx_acl = result.negated;
1404 case Opt_locallease:
1405 ctx->local_lease = 1;
1410 case Opt_ignore_signature:
1412 ctx->ignore_signature = true;
1415 /* we do not do the following in secFlags because seal
1416 * is a per tree connection (mount) not a per socket
1417 * or per-smb connection option in the protocol
1418 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1423 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1426 #ifndef CONFIG_CIFS_FSCACHE
1427 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1428 goto cifs_parse_mount_err;
1432 case Opt_mfsymlinks:
1433 ctx->mfsymlinks = true;
1436 ctx->multiuser = true;
1441 case Opt_nosharesock:
1442 ctx->nosharesock = true;
1444 case Opt_persistent:
1445 if (result.negated) {
1446 ctx->nopersistent = true;
1447 if (ctx->persistent) {
1448 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1449 goto cifs_parse_mount_err;
1452 ctx->persistent = true;
1453 if ((ctx->nopersistent) || (ctx->resilient)) {
1454 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1455 goto cifs_parse_mount_err;
1460 if (result.negated) {
1461 ctx->resilient = false; /* already the default */
1463 ctx->resilient = true;
1464 if (ctx->persistent) {
1465 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1466 goto cifs_parse_mount_err;
1470 case Opt_tcp_nodelay:
1471 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1473 ctx->sockopt_tcp_nodelay = false;
1475 ctx->sockopt_tcp_nodelay = true;
1477 case Opt_domainauto:
1478 ctx->domainauto = true;
1484 /* case Opt_ignore: - is ignored as expected ... */
1488 cifs_parse_mount_err:
1489 kfree_sensitive(ctx->password);
1490 ctx->password = NULL;
1494 int smb3_init_fs_context(struct fs_context *fc)
1496 struct smb3_fs_context *ctx;
1497 char *nodename = utsname()->nodename;
1500 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1504 strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1507 * does not have to be perfect mapping since field is
1508 * informational, only used for servers that do not support
1509 * port 445 and it can be overridden at mount time
1511 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1512 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1513 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1515 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1517 * null target name indicates to use *SMBSERVR default called name
1518 * if we end up sending RFC1001 session initialize
1520 ctx->target_rfc1001_name[0] = 0;
1521 ctx->cred_uid = current_uid();
1522 ctx->linux_uid = current_uid();
1523 ctx->linux_gid = current_gid();
1524 /* By default 4MB read ahead size, 1MB block size */
1525 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1526 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1529 * default to SFM style remapping of seven reserved characters
1530 * unless user overrides it or we negotiate CIFS POSIX where
1531 * it is unnecessary. Can not simultaneously use more than one mapping
1532 * since then readdir could list files that open could not open
1536 /* default to only allowing write access to owner of the mount */
1537 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1539 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1540 /* default is always to request posix paths. */
1541 ctx->posix_paths = 1;
1542 /* default to using server inode numbers where available */
1543 ctx->server_ino = 1;
1545 /* default is to use strict cifs caching semantics */
1546 ctx->strict_io = true;
1548 ctx->acregmax = CIFS_DEF_ACTIMEO;
1549 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1550 ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1552 /* Most clients set timeout to 0, allows server to use its default */
1553 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1555 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1556 ctx->ops = &smb30_operations;
1557 ctx->vals = &smbdefault_values;
1559 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1561 /* default to no multichannel (single server connection) */
1562 ctx->multichannel = false;
1563 ctx->max_channels = 1;
1565 ctx->backupuid_specified = false; /* no backup intent for a user */
1566 ctx->backupgid_specified = false; /* no backup intent for a group */
1569 * short int override_uid = -1;
1570 * short int override_gid = -1;
1571 * char *nodename = strdup(utsname()->nodename);
1572 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1575 fc->fs_private = ctx;
1576 fc->ops = &smb3_fs_context_ops;
1581 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1587 * Make sure this stays in sync with smb3_fs_context_dup()
1589 kfree(ctx->mount_options);
1590 ctx->mount_options = NULL;
1591 kfree(ctx->username);
1592 ctx->username = NULL;
1593 kfree_sensitive(ctx->password);
1594 ctx->password = NULL;
1595 kfree(ctx->server_hostname);
1596 ctx->server_hostname = NULL;
1601 kfree(ctx->domainname);
1602 ctx->domainname = NULL;
1603 kfree(ctx->nodename);
1604 ctx->nodename = NULL;
1605 kfree(ctx->iocharset);
1606 ctx->iocharset = NULL;
1607 kfree(ctx->prepath);
1608 ctx->prepath = NULL;
1612 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1616 smb3_cleanup_fs_context_contents(ctx);
1620 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1622 struct smb3_fs_context *ctx = cifs_sb->ctx;
1625 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1627 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1630 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1632 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1635 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1637 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1639 if (ctx->setuidfromacl)
1640 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1642 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1644 if (ctx->server_ino)
1645 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1647 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1650 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1652 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1655 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1657 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1660 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1662 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1665 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1667 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1670 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1672 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1674 if (ctx->nohandlecache)
1675 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1677 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1679 if (ctx->nostrictsync)
1680 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1682 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1685 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1687 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1689 if (ctx->rwpidforward)
1690 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1692 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1695 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1697 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1700 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1702 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1704 if (ctx->backupuid_specified)
1705 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1707 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1709 if (ctx->backupgid_specified)
1710 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1712 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1714 if (ctx->override_uid)
1715 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1717 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1719 if (ctx->override_gid)
1720 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1722 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1725 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1727 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1730 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1732 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1735 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1736 CIFS_MOUNT_NO_PERM);
1738 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1742 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1744 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1747 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1749 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1751 if (ctx->mfsymlinks)
1752 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1754 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1755 if (ctx->mfsymlinks) {
1756 if (ctx->sfu_emul) {
1758 * Our SFU ("Services for Unix" emulation does not allow
1759 * creating symlinks but does allow reading existing SFU
1760 * symlinks (it does allow both creating and reading SFU
1761 * style mknod and FIFOs though). When "mfsymlinks" and
1762 * "sfu" are both enabled at the same time, it allows
1763 * reading both types of symlinks, but will only create
1764 * them with mfsymlinks format. This allows better
1765 * Apple compatibility (probably better for Samba too)
1766 * while still recognizing old Windows style symlinks.
1768 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1771 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;