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