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 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("retrans", Opt_retrans),
143 fsparam_u32("esize", Opt_min_enc_offload),
144 fsparam_u32("bsize", Opt_blocksize),
145 fsparam_u32("rasize", Opt_rasize),
146 fsparam_u32("rsize", Opt_rsize),
147 fsparam_u32("wsize", Opt_wsize),
148 fsparam_u32("actimeo", Opt_actimeo),
149 fsparam_u32("acdirmax", Opt_acdirmax),
150 fsparam_u32("acregmax", Opt_acregmax),
151 fsparam_u32("closetimeo", Opt_closetimeo),
152 fsparam_u32("echo_interval", Opt_echo_interval),
153 fsparam_u32("max_credits", Opt_max_credits),
154 fsparam_u32("max_cached_dirs", Opt_max_cached_dirs),
155 fsparam_u32("handletimeout", Opt_handletimeout),
156 fsparam_u64("snapshot", Opt_snapshot),
157 fsparam_u32("max_channels", Opt_max_channels),
159 /* Mount options which take string value */
160 fsparam_string("source", Opt_source),
161 fsparam_string("user", Opt_user),
162 fsparam_string("username", Opt_user),
163 fsparam_string("pass", Opt_pass),
164 fsparam_string("password", Opt_pass),
165 fsparam_string("ip", Opt_ip),
166 fsparam_string("addr", Opt_ip),
167 fsparam_string("domain", Opt_domain),
168 fsparam_string("dom", Opt_domain),
169 fsparam_string("srcaddr", Opt_srcaddr),
170 fsparam_string("iocharset", Opt_iocharset),
171 fsparam_string("netbiosname", Opt_netbiosname),
172 fsparam_string("servern", Opt_servern),
173 fsparam_string("ver", Opt_ver),
174 fsparam_string("vers", Opt_vers),
175 fsparam_string("sec", Opt_sec),
176 fsparam_string("cache", Opt_cache),
178 /* Arguments that should be ignored */
179 fsparam_flag("guest", Opt_ignore),
180 fsparam_flag("noatime", Opt_ignore),
181 fsparam_flag("relatime", Opt_ignore),
182 fsparam_flag("_netdev", Opt_ignore),
183 fsparam_flag_no("suid", Opt_ignore),
184 fsparam_flag_no("exec", Opt_ignore),
185 fsparam_flag_no("dev", Opt_ignore),
186 fsparam_flag_no("mand", Opt_ignore),
187 fsparam_flag_no("auto", Opt_ignore),
188 fsparam_string("cred", Opt_ignore),
189 fsparam_string("credentials", Opt_ignore),
191 * UNC and prefixpath is now extracted from Opt_source
192 * in the new mount API so we can just ignore them going forward.
194 fsparam_string("unc", Opt_ignore),
195 fsparam_string("prefixpath", Opt_ignore),
200 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
203 substring_t args[MAX_OPT_ARGS];
206 * With mount options, the last one should win. Reset any existing
207 * settings back to default.
209 ctx->sectype = Unspecified;
212 switch (match_token(value, cifs_secflavor_tokens, args)) {
214 cifs_errorf(fc, "sec=krb5p is not supported. Use sec=krb5,seal instead\n");
220 ctx->sectype = Kerberos;
222 case Opt_sec_ntlmsspi:
225 case Opt_sec_ntlmssp:
226 ctx->sectype = RawNTLMSSP;
228 case Opt_sec_ntlmv2i:
232 ctx->sectype = NTLMv2;
236 kfree(ctx->username);
237 ctx->username = NULL;
240 cifs_errorf(fc, "bad security option: %s\n", value);
247 static const match_table_t cifs_cacheflavor_tokens = {
248 { Opt_cache_loose, "loose" },
249 { Opt_cache_strict, "strict" },
250 { Opt_cache_none, "none" },
251 { Opt_cache_ro, "ro" },
252 { Opt_cache_rw, "singleclient" },
253 { Opt_cache_err, NULL }
257 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
259 substring_t args[MAX_OPT_ARGS];
261 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
262 case Opt_cache_loose:
263 ctx->direct_io = false;
264 ctx->strict_io = false;
265 ctx->cache_ro = false;
266 ctx->cache_rw = false;
268 case Opt_cache_strict:
269 ctx->direct_io = false;
270 ctx->strict_io = true;
271 ctx->cache_ro = false;
272 ctx->cache_rw = false;
275 ctx->direct_io = true;
276 ctx->strict_io = false;
277 ctx->cache_ro = false;
278 ctx->cache_rw = false;
281 ctx->direct_io = false;
282 ctx->strict_io = false;
283 ctx->cache_ro = true;
284 ctx->cache_rw = false;
287 ctx->direct_io = false;
288 ctx->strict_io = false;
289 ctx->cache_ro = false;
290 ctx->cache_rw = true;
293 cifs_errorf(fc, "bad cache= option: %s\n", value);
299 #define DUP_CTX_STR(field) \
302 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
303 if (new_ctx->field == NULL) { \
304 smb3_cleanup_fs_context_contents(new_ctx); \
311 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
313 memcpy(new_ctx, ctx, sizeof(*ctx));
314 new_ctx->prepath = NULL;
315 new_ctx->nodename = NULL;
316 new_ctx->username = NULL;
317 new_ctx->password = NULL;
318 new_ctx->server_hostname = NULL;
319 new_ctx->domainname = NULL;
321 new_ctx->source = NULL;
322 new_ctx->iocharset = NULL;
323 new_ctx->leaf_fullpath = NULL;
325 * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
327 DUP_CTX_STR(prepath);
328 DUP_CTX_STR(username);
329 DUP_CTX_STR(password);
330 DUP_CTX_STR(server_hostname);
333 DUP_CTX_STR(domainname);
334 DUP_CTX_STR(nodename);
335 DUP_CTX_STR(iocharset);
336 DUP_CTX_STR(leaf_fullpath);
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 * Remove duplicate path delimiters. Windows is supposed to do that
445 * but there are some bugs that prevent rename from working if there are
446 * multiple delimiters.
448 * Return a sanitized duplicate of @path or NULL for empty prefix paths.
449 * Otherwise, return ERR_PTR.
451 * @gfp indicates the GFP_* flags for kstrdup.
452 * The caller is responsible for freeing the original.
454 #define IS_DELIM(c) ((c) == '/' || (c) == '\\')
455 char *cifs_sanitize_prepath(char *prepath, gfp_t gfp)
457 char *cursor1 = prepath, *cursor2 = prepath;
460 /* skip all prepended delimiters */
461 while (IS_DELIM(*cursor1))
464 /* copy the first letter */
467 /* copy the remainder... */
468 while (*(cursor1++)) {
469 /* ... skipping all duplicated delimiters */
470 if (IS_DELIM(*cursor1) && IS_DELIM(*cursor2))
472 *(++cursor2) = *cursor1;
475 /* if the last character is a delimiter, skip it */
476 if (IS_DELIM(*(cursor2 - 1)))
482 s = kstrdup(prepath, gfp);
484 return ERR_PTR(-ENOMEM);
489 * Return full path based on the values of @ctx->{UNC,prepath}.
491 * It is assumed that both values were already parsed by smb3_parse_devname().
493 char *smb3_fs_context_fullpath(const struct smb3_fs_context *ctx, char dirsep)
498 ulen = strlen(ctx->UNC);
499 plen = ctx->prepath ? strlen(ctx->prepath) + 1 : 0;
501 s = kmalloc(ulen + plen + 1, GFP_KERNEL);
503 return ERR_PTR(-ENOMEM);
504 memcpy(s, ctx->UNC, ulen);
507 memcpy(s + ulen + 1, ctx->prepath, plen);
509 s[ulen + plen] = '\0';
510 convert_delimiter(s, dirsep);
515 * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
516 * fields with the result. Returns 0 on success and an error otherwise
517 * (e.g. ENOMEM or EINVAL)
520 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
523 const char *delims = "/\\";
527 if (unlikely(!devname || !*devname)) {
528 cifs_dbg(VFS, "Device name not specified\n");
532 /* make sure we have a valid UNC double delimiter prefix */
533 len = strspn(devname, delims);
537 /* find delimiter between host and sharename */
538 pos = strpbrk(devname + 2, delims);
542 /* record the server hostname */
543 kfree(ctx->server_hostname);
544 ctx->server_hostname = kstrndup(devname + 2, pos - devname - 2, GFP_KERNEL);
545 if (!ctx->server_hostname)
548 /* skip past delimiter */
551 /* now go until next delimiter or end of string */
552 len = strcspn(pos, delims);
556 /* move "pos" up to delimiter or NULL */
559 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
563 convert_delimiter(ctx->UNC, '\\');
565 /* skip any delimiter */
566 if (*pos == '/' || *pos == '\\')
572 /* If pos is NULL then no prepath */
576 ctx->prepath = cifs_sanitize_prepath(pos, GFP_KERNEL);
577 if (IS_ERR(ctx->prepath)) {
578 rc = PTR_ERR(ctx->prepath);
586 static void smb3_fs_context_free(struct fs_context *fc);
587 static int smb3_fs_context_parse_param(struct fs_context *fc,
588 struct fs_parameter *param);
589 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
591 static int smb3_get_tree(struct fs_context *fc);
592 static int smb3_reconfigure(struct fs_context *fc);
594 static const struct fs_context_operations smb3_fs_context_ops = {
595 .free = smb3_fs_context_free,
596 .parse_param = smb3_fs_context_parse_param,
597 .parse_monolithic = smb3_fs_context_parse_monolithic,
598 .get_tree = smb3_get_tree,
599 .reconfigure = smb3_reconfigure,
603 * Parse a monolithic block of data from sys_mount().
604 * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
605 * @ctx: The superblock configuration to fill in.
606 * @data: The data to parse
608 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
609 * called from the ->monolithic_mount_data() fs_context operation.
611 * Returns 0 on success or the error returned by the ->parse_option() fs_context
612 * operation on failure.
614 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
617 char *options = data, *key;
623 ret = security_sb_eat_lsm_opts(options, &fc->security);
627 /* BB Need to add support for sep= here TBD */
628 while ((key = strsep(&options, ",")) != NULL) {
635 /* Check if following character is the deliminator If yes,
636 * we have encountered a double deliminator reset the NULL
637 * character to the deliminator
639 while (options && options[0] == ',') {
641 strcpy(key + len, options);
642 options = strchr(options, ',');
649 value = strchr(key, '=');
657 ret = vfs_parse_fs_string(fc, key, value, len);
666 * Validate the preparsed information in the config.
668 static int smb3_fs_context_validate(struct fs_context *fc)
670 struct smb3_fs_context *ctx = smb3_fc2context(fc);
672 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
673 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
678 /* Muliuser mounts require CONFIG_KEYS support */
679 if (ctx->multiuser) {
680 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
685 if (ctx->got_version == false)
686 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");
690 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
694 /* make sure UNC has a share name */
695 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
696 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
704 /* No ip= option specified? Try to get it from UNC */
705 /* Use the address part of the UNC. */
706 slash = strchr(&ctx->UNC[2], '\\');
707 len = slash - &ctx->UNC[2];
708 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
709 &ctx->UNC[2], len)) {
710 pr_err("Unable to determine destination address\n");
711 return -EHOSTUNREACH;
715 /* set the port that we got earlier */
716 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
718 if (ctx->uid_specified && !ctx->forceuid_specified) {
719 ctx->override_uid = 1;
720 pr_notice("enabling forceuid mount option implicitly because uid= option is specified\n");
723 if (ctx->gid_specified && !ctx->forcegid_specified) {
724 ctx->override_gid = 1;
725 pr_notice("enabling forcegid mount option implicitly because gid= option is specified\n");
728 if (ctx->override_uid && !ctx->uid_specified) {
729 ctx->override_uid = 0;
730 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
733 if (ctx->override_gid && !ctx->gid_specified) {
734 ctx->override_gid = 0;
735 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
741 static int smb3_get_tree_common(struct fs_context *fc)
743 struct smb3_fs_context *ctx = smb3_fc2context(fc);
747 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
749 return PTR_ERR(root);
757 * Create an SMB3 superblock from the parameters passed.
759 static int smb3_get_tree(struct fs_context *fc)
761 int err = smb3_fs_context_validate(fc);
767 ret = smb3_get_tree_common(fc);
772 static void smb3_fs_context_free(struct fs_context *fc)
774 struct smb3_fs_context *ctx = smb3_fc2context(fc);
776 smb3_cleanup_fs_context(ctx);
780 * Compare the old and new proposed context during reconfigure
781 * and check if the changes are compatible.
783 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
784 struct smb3_fs_context *new_ctx,
785 struct smb3_fs_context *old_ctx, bool need_recon)
787 if (new_ctx->posix_paths != old_ctx->posix_paths) {
788 cifs_errorf(fc, "can not change posixpaths during remount\n");
791 if (new_ctx->sectype != old_ctx->sectype) {
792 cifs_errorf(fc, "can not change sec during remount\n");
795 if (new_ctx->multiuser != old_ctx->multiuser) {
796 cifs_errorf(fc, "can not change multiuser during remount\n");
800 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
801 cifs_errorf(fc, "can not change UNC during remount\n");
804 if (new_ctx->username &&
805 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
806 cifs_errorf(fc, "can not change username during remount\n");
809 if (new_ctx->password &&
810 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
811 if (need_recon == false) {
813 "can not change password of active session during remount\n");
815 } else if (old_ctx->sectype == Kerberos) {
817 "can not change password for Kerberos via remount\n");
821 if (new_ctx->domainname &&
822 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
823 cifs_errorf(fc, "can not change domainname during remount\n");
826 if (strcmp(new_ctx->workstation_name, old_ctx->workstation_name)) {
827 cifs_errorf(fc, "can not change workstation_name during remount\n");
830 if (new_ctx->nodename &&
831 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
832 cifs_errorf(fc, "can not change nodename during remount\n");
835 if (new_ctx->iocharset &&
836 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
837 cifs_errorf(fc, "can not change iocharset during remount\n");
844 #define STEAL_STRING(cifs_sb, ctx, field) \
847 ctx->field = cifs_sb->ctx->field; \
848 cifs_sb->ctx->field = NULL; \
851 #define STEAL_STRING_SENSITIVE(cifs_sb, ctx, field) \
853 kfree_sensitive(ctx->field); \
854 ctx->field = cifs_sb->ctx->field; \
855 cifs_sb->ctx->field = NULL; \
858 static int smb3_reconfigure(struct fs_context *fc)
860 struct smb3_fs_context *ctx = smb3_fc2context(fc);
861 struct dentry *root = fc->root;
862 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
863 struct cifs_ses *ses = cifs_sb_master_tcon(cifs_sb)->ses;
864 bool need_recon = false;
867 if (ses->expired_pwd)
870 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx, need_recon);
875 * We can not change UNC/username/password/domainname/
876 * workstation_name/nodename/iocharset
877 * during reconnect so ignore what we have in the new context and
878 * just use what we already have in cifs_sb->ctx.
880 STEAL_STRING(cifs_sb, ctx, UNC);
881 STEAL_STRING(cifs_sb, ctx, source);
882 STEAL_STRING(cifs_sb, ctx, username);
883 if (need_recon == false)
884 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password);
886 kfree_sensitive(ses->password);
887 ses->password = kstrdup(ctx->password, GFP_KERNEL);
889 STEAL_STRING(cifs_sb, ctx, domainname);
890 STEAL_STRING(cifs_sb, ctx, nodename);
891 STEAL_STRING(cifs_sb, ctx, iocharset);
893 /* if rsize or wsize not passed in on remount, use previous values */
895 ctx->rsize = cifs_sb->ctx->rsize;
897 ctx->wsize = cifs_sb->ctx->wsize;
900 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
901 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
902 smb3_update_mnt_flags(cifs_sb);
903 #ifdef CONFIG_CIFS_DFS_UPCALL
905 rc = dfs_cache_remount_fs(cifs_sb);
911 static int smb3_fs_context_parse_param(struct fs_context *fc,
912 struct fs_parameter *param)
914 struct fs_parse_result result;
915 struct smb3_fs_context *ctx = smb3_fc2context(fc);
917 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
918 bool skip_parsing = false;
922 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
925 * fs_parse can not handle string options with an empty value so
926 * we will need special handling of them.
928 if (param->type == fs_value_is_string && param->string[0] == 0) {
929 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
932 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
939 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
941 return ctx->sloppy ? 1 : opt;
946 ctx->compression = UNKNOWN_TYPE;
948 "SMB3 compression support is experimental\n");
954 if (result.negated) {
956 cifs_dbg(VFS, "conflicting hard vs. soft mount options\n");
966 cifs_dbg(VFS, "conflicting hard vs soft mount options\n");
975 ctx->sfu_remap = false; /* disable SFU mapping */
980 ctx->sfu_remap = false;
982 ctx->sfu_remap = true;
983 ctx->remap = false; /* disable SFM (mapposix) mapping */
994 ctx->override_uid = 0;
996 ctx->override_uid = 1;
997 ctx->forceuid_specified = true;
1001 ctx->override_gid = 0;
1003 ctx->override_gid = 1;
1004 ctx->forcegid_specified = true;
1024 case Opt_noblocksend:
1025 ctx->noblocksnd = 1;
1027 case Opt_noautotune:
1028 ctx->noautotune = 1;
1039 case Opt_multichannel:
1040 if (result.negated) {
1041 ctx->multichannel = false;
1042 ctx->max_channels = 1;
1044 ctx->multichannel = true;
1045 /* if number of channels not specified, default to 2 */
1046 if (ctx->max_channels < 2)
1047 ctx->max_channels = 2;
1051 uid = make_kuid(current_user_ns(), result.uint_32);
1052 if (!uid_valid(uid))
1053 goto cifs_parse_mount_err;
1054 ctx->linux_uid = uid;
1055 ctx->uid_specified = true;
1058 uid = make_kuid(current_user_ns(), result.uint_32);
1059 if (!uid_valid(uid))
1060 goto cifs_parse_mount_err;
1061 ctx->cred_uid = uid;
1062 ctx->cruid_specified = true;
1065 uid = make_kuid(current_user_ns(), result.uint_32);
1066 if (!uid_valid(uid))
1067 goto cifs_parse_mount_err;
1068 ctx->backupuid = uid;
1069 ctx->backupuid_specified = true;
1072 gid = make_kgid(current_user_ns(), result.uint_32);
1073 if (!gid_valid(gid))
1074 goto cifs_parse_mount_err;
1075 ctx->backupgid = gid;
1076 ctx->backupgid_specified = true;
1079 gid = make_kgid(current_user_ns(), result.uint_32);
1080 if (!gid_valid(gid))
1081 goto cifs_parse_mount_err;
1082 ctx->linux_gid = gid;
1083 ctx->gid_specified = true;
1086 ctx->port = result.uint_32;
1089 ctx->file_mode = result.uint_32;
1092 ctx->dir_mode = result.uint_32;
1094 case Opt_min_enc_offload:
1095 ctx->min_offload = result.uint_32;
1098 ctx->retrans = result.uint_32;
1102 * inode blocksize realistically should never need to be
1103 * less than 16K or greater than 16M and default is 1MB.
1104 * Note that small inode block sizes (e.g. 64K) can lead
1105 * to very poor performance of common tools like cp and scp
1107 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1108 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1109 cifs_errorf(fc, "%s: Invalid blocksize\n",
1111 goto cifs_parse_mount_err;
1113 ctx->bsize = result.uint_32;
1114 ctx->got_bsize = true;
1118 * readahead size realistically should never need to be
1119 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1120 * (perhaps an exception should be considered in the
1121 * for the case of a large number of channels
1122 * when multichannel is negotiated) since that would lead
1123 * to plenty of parallel I/O in flight to the server.
1124 * Note that smaller read ahead sizes would
1125 * hurt performance of common tools like cp and scp
1126 * which often trigger sequential i/o with read ahead
1128 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1129 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1130 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1131 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1132 goto cifs_parse_mount_err;
1134 ctx->rasize = result.uint_32;
1137 ctx->rsize = result.uint_32;
1138 ctx->got_rsize = true;
1141 ctx->wsize = result.uint_32;
1142 ctx->got_wsize = true;
1143 if (ctx->wsize % PAGE_SIZE != 0) {
1144 ctx->wsize = round_down(ctx->wsize, PAGE_SIZE);
1145 if (ctx->wsize == 0) {
1146 ctx->wsize = PAGE_SIZE;
1147 cifs_dbg(VFS, "wsize too small, reset to minimum %ld\n", PAGE_SIZE);
1150 "wsize rounded down to %d to multiple of PAGE_SIZE %ld\n",
1151 ctx->wsize, PAGE_SIZE);
1156 ctx->acregmax = HZ * result.uint_32;
1157 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1158 cifs_errorf(fc, "acregmax too large\n");
1159 goto cifs_parse_mount_err;
1163 ctx->acdirmax = HZ * result.uint_32;
1164 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1165 cifs_errorf(fc, "acdirmax too large\n");
1166 goto cifs_parse_mount_err;
1170 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1171 cifs_errorf(fc, "timeout too large\n");
1172 goto cifs_parse_mount_err;
1174 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1175 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1176 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1179 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1181 case Opt_closetimeo:
1182 ctx->closetimeo = HZ * result.uint_32;
1183 if (ctx->closetimeo > SMB3_MAX_DCLOSETIMEO) {
1184 cifs_errorf(fc, "closetimeo too large\n");
1185 goto cifs_parse_mount_err;
1188 case Opt_echo_interval:
1189 ctx->echo_interval = result.uint_32;
1192 ctx->snapshot_time = result.uint_64;
1194 case Opt_max_credits:
1195 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1196 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1198 goto cifs_parse_mount_err;
1200 ctx->max_credits = result.uint_32;
1202 case Opt_max_channels:
1203 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1204 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1205 __func__, CIFS_MAX_CHANNELS);
1206 goto cifs_parse_mount_err;
1208 ctx->max_channels = result.uint_32;
1209 /* If more than one channel requested ... they want multichan */
1210 if (result.uint_32 > 1)
1211 ctx->multichannel = true;
1213 case Opt_max_cached_dirs:
1214 if (result.uint_32 < 1) {
1215 cifs_errorf(fc, "%s: Invalid max_cached_dirs, needs to be 1 or more\n",
1217 goto cifs_parse_mount_err;
1219 ctx->max_cached_dirs = result.uint_32;
1221 case Opt_handletimeout:
1222 ctx->handle_timeout = result.uint_32;
1223 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1224 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1225 goto cifs_parse_mount_err;
1231 switch (smb3_parse_devname(param->string, ctx)) {
1235 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1236 goto cifs_parse_mount_err;
1238 cifs_errorf(fc, "Malformed UNC in devname\n");
1239 goto cifs_parse_mount_err;
1241 cifs_errorf(fc, "Unknown error parsing devname\n");
1242 goto cifs_parse_mount_err;
1244 ctx->source = smb3_fs_context_fullpath(ctx, '/');
1245 if (IS_ERR(ctx->source)) {
1247 cifs_errorf(fc, "OOM when copying UNC string\n");
1248 goto cifs_parse_mount_err;
1250 fc->source = kstrdup(ctx->source, GFP_KERNEL);
1251 if (fc->source == NULL) {
1252 cifs_errorf(fc, "OOM when copying UNC string\n");
1253 goto cifs_parse_mount_err;
1257 kfree(ctx->username);
1258 ctx->username = NULL;
1261 if (strlen(param->string) == 0) {
1262 /* null user, ie. anonymous authentication */
1267 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1268 CIFS_MAX_USERNAME_LEN) {
1269 pr_warn("username too long\n");
1270 goto cifs_parse_mount_err;
1272 ctx->username = kstrdup(param->string, GFP_KERNEL);
1273 if (ctx->username == NULL) {
1274 cifs_errorf(fc, "OOM when copying username string\n");
1275 goto cifs_parse_mount_err;
1279 kfree_sensitive(ctx->password);
1280 ctx->password = NULL;
1281 if (strlen(param->string) == 0)
1284 ctx->password = kstrdup(param->string, GFP_KERNEL);
1285 if (ctx->password == NULL) {
1286 cifs_errorf(fc, "OOM when copying password string\n");
1287 goto cifs_parse_mount_err;
1291 if (strlen(param->string) == 0) {
1292 ctx->got_ip = false;
1295 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1297 strlen(param->string))) {
1298 pr_err("bad ip= option (%s)\n", param->string);
1299 goto cifs_parse_mount_err;
1304 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1305 == CIFS_MAX_DOMAINNAME_LEN) {
1306 pr_warn("domain name too long\n");
1307 goto cifs_parse_mount_err;
1310 kfree(ctx->domainname);
1311 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1312 if (ctx->domainname == NULL) {
1313 cifs_errorf(fc, "OOM when copying domainname string\n");
1314 goto cifs_parse_mount_err;
1316 cifs_dbg(FYI, "Domain name set\n");
1319 if (!cifs_convert_address(
1320 (struct sockaddr *)&ctx->srcaddr,
1321 param->string, strlen(param->string))) {
1322 pr_warn("Could not parse srcaddr: %s\n",
1324 goto cifs_parse_mount_err;
1328 if (strnlen(param->string, 1024) >= 65) {
1329 pr_warn("iocharset name too long\n");
1330 goto cifs_parse_mount_err;
1333 if (strncasecmp(param->string, "default", 7) != 0) {
1334 kfree(ctx->iocharset);
1335 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1336 if (ctx->iocharset == NULL) {
1337 cifs_errorf(fc, "OOM when copying iocharset string\n");
1338 goto cifs_parse_mount_err;
1341 /* if iocharset not set then load_nls_default
1344 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1346 case Opt_netbiosname:
1347 memset(ctx->source_rfc1001_name, 0x20,
1350 * FIXME: are there cases in which a comma can
1351 * be valid in workstation netbios name (and
1352 * need special handling)?
1354 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1355 /* don't ucase netbiosname for user */
1356 if (param->string[i] == 0)
1358 ctx->source_rfc1001_name[i] = param->string[i];
1360 /* The string has 16th byte zero still from
1361 * set at top of the function
1363 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1364 pr_warn("netbiosname longer than 15 truncated\n");
1367 /* last byte, type, is 0x20 for servr type */
1368 memset(ctx->target_rfc1001_name, 0x20,
1369 RFC1001_NAME_LEN_WITH_NULL);
1371 * BB are there cases in which a comma can be valid in this
1372 * workstation netbios name (and need special handling)?
1375 /* user or mount helper must uppercase the netbios name */
1376 for (i = 0; i < 15; i++) {
1377 if (param->string[i] == 0)
1379 ctx->target_rfc1001_name[i] = param->string[i];
1382 /* The string has 16th byte zero still from set at top of function */
1383 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1384 pr_warn("server netbiosname longer than 15 truncated\n");
1387 /* version of mount userspace tools, not dialect */
1388 /* If interface changes in mount.cifs bump to new ver */
1389 if (strncasecmp(param->string, "1", 1) == 0) {
1390 if (strlen(param->string) > 1) {
1391 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1393 goto cifs_parse_mount_err;
1395 /* This is the default */
1398 /* For all other value, error */
1399 pr_warn("Invalid mount helper version specified\n");
1400 goto cifs_parse_mount_err;
1402 /* protocol version (dialect) */
1403 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1404 goto cifs_parse_mount_err;
1405 ctx->got_version = true;
1408 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1409 goto cifs_parse_mount_err;
1412 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1413 goto cifs_parse_mount_err;
1416 #ifndef CONFIG_CIFS_SWN_UPCALL
1417 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1418 goto cifs_parse_mount_err;
1420 ctx->witness = true;
1421 pr_warn_once("Witness protocol support is experimental\n");
1424 #ifndef CONFIG_CIFS_ROOT
1425 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1426 goto cifs_parse_mount_err;
1430 case Opt_posixpaths:
1432 ctx->posix_paths = 0;
1434 ctx->posix_paths = 1;
1437 if (result.negated) {
1438 if (ctx->linux_ext == 1)
1439 pr_warn_once("conflicting posix mount options specified\n");
1441 ctx->no_linux_ext = 1;
1443 if (ctx->no_linux_ext == 1)
1444 pr_warn_once("conflicting posix mount options specified\n");
1446 ctx->no_linux_ext = 0;
1453 if (result.negated) {
1455 * turn off mandatory locking in mode
1456 * if remote locking is turned off since the
1457 * local vfs will do advisory
1459 if (ctx->file_mode ==
1460 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1461 ctx->file_mode = S_IALLUGO;
1466 case Opt_handlecache:
1468 ctx->nohandlecache = 1;
1470 ctx->nohandlecache = 0;
1472 case Opt_forcemandatorylock:
1476 ctx->setuids = result.negated;
1479 ctx->intr = !result.negated;
1481 case Opt_setuidfromacl:
1482 ctx->setuidfromacl = 1;
1484 case Opt_strictsync:
1485 ctx->nostrictsync = result.negated;
1488 ctx->server_ino = !result.negated;
1490 case Opt_rwpidforward:
1491 ctx->rwpidforward = 1;
1497 ctx->cifs_acl = !result.negated;
1500 ctx->no_psx_acl = result.negated;
1502 case Opt_locallease:
1503 ctx->local_lease = 1;
1508 case Opt_ignore_signature:
1510 ctx->ignore_signature = true;
1513 /* we do not do the following in secFlags because seal
1514 * is a per tree connection (mount) not a per socket
1515 * or per-smb connection option in the protocol
1516 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1521 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1524 #ifndef CONFIG_CIFS_FSCACHE
1525 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1526 goto cifs_parse_mount_err;
1530 case Opt_mfsymlinks:
1531 ctx->mfsymlinks = true;
1534 ctx->multiuser = true;
1539 case Opt_nosharesock:
1540 ctx->nosharesock = true;
1542 case Opt_persistent:
1543 if (result.negated) {
1544 ctx->nopersistent = true;
1545 if (ctx->persistent) {
1546 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1547 goto cifs_parse_mount_err;
1550 ctx->persistent = true;
1551 if ((ctx->nopersistent) || (ctx->resilient)) {
1552 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1553 goto cifs_parse_mount_err;
1558 if (result.negated) {
1559 ctx->resilient = false; /* already the default */
1561 ctx->resilient = true;
1562 if (ctx->persistent) {
1563 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1564 goto cifs_parse_mount_err;
1568 case Opt_tcp_nodelay:
1569 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1571 ctx->sockopt_tcp_nodelay = false;
1573 ctx->sockopt_tcp_nodelay = true;
1575 case Opt_domainauto:
1576 ctx->domainauto = true;
1582 /* case Opt_ignore: - is ignored as expected ... */
1586 cifs_parse_mount_err:
1587 kfree_sensitive(ctx->password);
1588 ctx->password = NULL;
1592 int smb3_init_fs_context(struct fs_context *fc)
1594 struct smb3_fs_context *ctx;
1595 char *nodename = utsname()->nodename;
1598 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1602 strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1605 * does not have to be perfect mapping since field is
1606 * informational, only used for servers that do not support
1607 * port 445 and it can be overridden at mount time
1609 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1610 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1611 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1613 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1615 * null target name indicates to use *SMBSERVR default called name
1616 * if we end up sending RFC1001 session initialize
1618 ctx->target_rfc1001_name[0] = 0;
1619 ctx->cred_uid = current_uid();
1620 ctx->linux_uid = current_uid();
1621 ctx->linux_gid = current_gid();
1622 /* By default 4MB read ahead size, 1MB block size */
1623 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1624 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1627 * default to SFM style remapping of seven reserved characters
1628 * unless user overrides it or we negotiate CIFS POSIX where
1629 * it is unnecessary. Can not simultaneously use more than one mapping
1630 * since then readdir could list files that open could not open
1634 /* default to only allowing write access to owner of the mount */
1635 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1637 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1638 /* default is always to request posix paths. */
1639 ctx->posix_paths = 1;
1640 /* default to using server inode numbers where available */
1641 ctx->server_ino = 1;
1643 /* default is to use strict cifs caching semantics */
1644 ctx->strict_io = true;
1646 ctx->acregmax = CIFS_DEF_ACTIMEO;
1647 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1648 ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1649 ctx->max_cached_dirs = MAX_CACHED_FIDS;
1650 /* Most clients set timeout to 0, allows server to use its default */
1651 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1653 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1654 ctx->ops = &smb30_operations;
1655 ctx->vals = &smbdefault_values;
1657 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1659 /* default to no multichannel (single server connection) */
1660 ctx->multichannel = false;
1661 ctx->max_channels = 1;
1663 ctx->backupuid_specified = false; /* no backup intent for a user */
1664 ctx->backupgid_specified = false; /* no backup intent for a group */
1669 * short int override_uid = -1;
1670 * short int override_gid = -1;
1671 * char *nodename = strdup(utsname()->nodename);
1672 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1675 fc->fs_private = ctx;
1676 fc->ops = &smb3_fs_context_ops;
1681 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1687 * Make sure this stays in sync with smb3_fs_context_dup()
1689 kfree(ctx->username);
1690 ctx->username = NULL;
1691 kfree_sensitive(ctx->password);
1692 ctx->password = NULL;
1693 kfree(ctx->server_hostname);
1694 ctx->server_hostname = NULL;
1699 kfree(ctx->domainname);
1700 ctx->domainname = NULL;
1701 kfree(ctx->nodename);
1702 ctx->nodename = NULL;
1703 kfree(ctx->iocharset);
1704 ctx->iocharset = NULL;
1705 kfree(ctx->prepath);
1706 ctx->prepath = NULL;
1707 kfree(ctx->leaf_fullpath);
1708 ctx->leaf_fullpath = NULL;
1712 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1716 smb3_cleanup_fs_context_contents(ctx);
1720 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1722 struct smb3_fs_context *ctx = cifs_sb->ctx;
1725 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1727 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1730 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1732 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1735 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1737 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1739 if (ctx->setuidfromacl)
1740 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1742 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1744 if (ctx->server_ino)
1745 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1747 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1750 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1752 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1755 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1757 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1760 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1762 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1765 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1767 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1770 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1772 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1774 if (ctx->nohandlecache)
1775 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1777 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1779 if (ctx->nostrictsync)
1780 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1782 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1785 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1787 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1789 if (ctx->rwpidforward)
1790 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1792 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1795 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1797 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1800 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1802 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1804 if (ctx->backupuid_specified)
1805 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1807 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1809 if (ctx->backupgid_specified)
1810 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1812 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1814 if (ctx->override_uid)
1815 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1817 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1819 if (ctx->override_gid)
1820 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1822 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1825 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1827 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1830 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1832 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1835 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1836 CIFS_MOUNT_NO_PERM);
1838 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1842 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1844 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1847 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1849 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1851 if (ctx->mfsymlinks)
1852 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1854 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1855 if (ctx->mfsymlinks) {
1856 if (ctx->sfu_emul) {
1858 * Our SFU ("Services for Unix" emulation does not allow
1859 * creating symlinks but does allow reading existing SFU
1860 * symlinks (it does allow both creating and reading SFU
1861 * style mknod and FIFOs though). When "mfsymlinks" and
1862 * "sfu" are both enabled at the same time, it allows
1863 * reading both types of symlinks, but will only create
1864 * them with mfsymlinks format. This allows better
1865 * Apple compatibility (probably better for Samba too)
1866 * while still recognizing old Windows style symlinks.
1868 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1871 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;