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
40 DEFINE_MUTEX(cifs_mount_mutex);
41
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 }
54 };
55
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" },
66
67 { Opt_sec_err, NULL }
68 };
69
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),
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
201 static int
cifs_parse_security_flavors(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)202 cifs_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
249 static const match_table_t cifs_cacheflavor_tokens = {
250 { Opt_cache_loose, "loose" },
251 { Opt_cache_strict, "strict" },
252 { Opt_cache_none, "none" },
253 { Opt_cache_ro, "ro" },
254 { Opt_cache_rw, "singleclient" },
255 { Opt_cache_err, NULL }
256 };
257
258 static int
cifs_parse_cache_flavor(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)259 cifs_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
301 static 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
parse_reparse_flavor(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)308 static 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) \
331 do { \
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
341 int
smb3_fs_context_dup(struct smb3_fs_context * new_ctx,struct smb3_fs_context * ctx)342 smb3_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
374 static int
cifs_parse_smb_version(struct fs_context * fc,char * value,struct smb3_fs_context * ctx,bool is_smb3)375 cifs_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
smb3_parse_opt(const char * options,const char * key,char ** val)445 int 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 }
471 out:
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) == '\\')
cifs_sanitize_prepath(char * prepath,gfp_t gfp)488 char *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 */
smb3_fs_context_fullpath(const struct smb3_fs_context * ctx,char dirsep)526 char *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 */
552 int
smb3_parse_devname(const char * devname,struct smb3_fs_context * ctx)553 smb3_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
619 static void smb3_fs_context_free(struct fs_context *fc);
620 static int smb3_fs_context_parse_param(struct fs_context *fc,
621 struct fs_parameter *param);
622 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
623 void *data);
624 static int smb3_get_tree(struct fs_context *fc);
625 static int smb3_reconfigure(struct fs_context *fc);
626
627 static 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 */
smb3_fs_context_parse_monolithic(struct fs_context * fc,void * data)647 static 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 */
smb3_fs_context_validate(struct fs_context * fc)701 static 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
smb3_get_tree_common(struct fs_context * fc)774 static 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 */
smb3_get_tree(struct fs_context * fc)792 static 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
smb3_fs_context_free(struct fs_context * fc)805 static 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 */
smb3_verify_reconfigure_ctx(struct fs_context * fc,struct smb3_fs_context * new_ctx,struct smb3_fs_context * old_ctx,bool need_recon)816 static 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) \
878 do { \
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) \
885 do { \
886 kfree_sensitive(ctx->field); \
887 ctx->field = cifs_sb->ctx->field; \
888 cifs_sb->ctx->field = NULL; \
889 } while (0)
890
smb3_reconfigure(struct fs_context * fc)891 static 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 if (!ses->password)
922 return -ENOMEM;
923 kfree_sensitive(ses->password2);
924 ses->password2 = kstrdup(ctx->password2, GFP_KERNEL);
925 if (!ses->password2) {
926 kfree_sensitive(ses->password);
927 ses->password = NULL;
928 return -ENOMEM;
929 }
930 }
931 STEAL_STRING(cifs_sb, ctx, domainname);
932 STEAL_STRING(cifs_sb, ctx, nodename);
933 STEAL_STRING(cifs_sb, ctx, iocharset);
934
935 /* if rsize or wsize not passed in on remount, use previous values */
936 if (ctx->rsize == 0)
937 ctx->rsize = cifs_sb->ctx->rsize;
938 if (ctx->wsize == 0)
939 ctx->wsize = cifs_sb->ctx->wsize;
940
941
942 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
943 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
944 smb3_update_mnt_flags(cifs_sb);
945 #ifdef CONFIG_CIFS_DFS_UPCALL
946 if (!rc)
947 rc = dfs_cache_remount_fs(cifs_sb);
948 #endif
949
950 return rc;
951 }
952
smb3_fs_context_parse_param(struct fs_context * fc,struct fs_parameter * param)953 static int smb3_fs_context_parse_param(struct fs_context *fc,
954 struct fs_parameter *param)
955 {
956 struct fs_parse_result result;
957 struct smb3_fs_context *ctx = smb3_fc2context(fc);
958 int i, opt;
959 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
960 bool skip_parsing = false;
961 kuid_t uid;
962 kgid_t gid;
963
964 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
965
966 /*
967 * fs_parse can not handle string options with an empty value so
968 * we will need special handling of them.
969 */
970 if (param->type == fs_value_is_string && param->string[0] == 0) {
971 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
972 skip_parsing = true;
973 opt = Opt_pass;
974 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
975 skip_parsing = true;
976 opt = Opt_user;
977 }
978 }
979
980 if (!skip_parsing) {
981 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
982 if (opt < 0)
983 return ctx->sloppy ? 1 : opt;
984 }
985
986 switch (opt) {
987 case Opt_compress:
988 ctx->compress = true;
989 cifs_dbg(VFS,
990 "SMB3 compression support is experimental\n");
991 break;
992 case Opt_nodfs:
993 ctx->nodfs = 1;
994 break;
995 case Opt_hard:
996 if (result.negated) {
997 if (ctx->retry == 1)
998 cifs_dbg(VFS, "conflicting hard vs. soft mount options\n");
999 ctx->retry = 0;
1000 } else
1001 ctx->retry = 1;
1002 break;
1003 case Opt_soft:
1004 if (result.negated)
1005 ctx->retry = 1;
1006 else {
1007 if (ctx->retry == 1)
1008 cifs_dbg(VFS, "conflicting hard vs soft mount options\n");
1009 ctx->retry = 0;
1010 }
1011 break;
1012 case Opt_mapposix:
1013 if (result.negated)
1014 ctx->remap = false;
1015 else {
1016 ctx->remap = true;
1017 ctx->sfu_remap = false; /* disable SFU mapping */
1018 }
1019 break;
1020 case Opt_mapchars:
1021 if (result.negated)
1022 ctx->sfu_remap = false;
1023 else {
1024 ctx->sfu_remap = true;
1025 ctx->remap = false; /* disable SFM (mapposix) mapping */
1026 }
1027 break;
1028 case Opt_user_xattr:
1029 if (result.negated)
1030 ctx->no_xattr = 1;
1031 else
1032 ctx->no_xattr = 0;
1033 break;
1034 case Opt_forceuid:
1035 if (result.negated)
1036 ctx->override_uid = 0;
1037 else
1038 ctx->override_uid = 1;
1039 ctx->forceuid_specified = true;
1040 break;
1041 case Opt_forcegid:
1042 if (result.negated)
1043 ctx->override_gid = 0;
1044 else
1045 ctx->override_gid = 1;
1046 ctx->forcegid_specified = true;
1047 break;
1048 case Opt_perm:
1049 if (result.negated)
1050 ctx->noperm = 1;
1051 else
1052 ctx->noperm = 0;
1053 break;
1054 case Opt_dynperm:
1055 if (result.negated)
1056 ctx->dynperm = 0;
1057 else
1058 ctx->dynperm = 1;
1059 break;
1060 case Opt_sfu:
1061 if (result.negated)
1062 ctx->sfu_emul = 0;
1063 else
1064 ctx->sfu_emul = 1;
1065 break;
1066 case Opt_noblocksend:
1067 ctx->noblocksnd = 1;
1068 break;
1069 case Opt_noautotune:
1070 ctx->noautotune = 1;
1071 break;
1072 case Opt_nolease:
1073 ctx->no_lease = 1;
1074 break;
1075 case Opt_nosparse:
1076 ctx->no_sparse = 1;
1077 break;
1078 case Opt_nodelete:
1079 ctx->nodelete = 1;
1080 break;
1081 case Opt_multichannel:
1082 if (result.negated) {
1083 ctx->multichannel = false;
1084 ctx->max_channels = 1;
1085 } else {
1086 ctx->multichannel = true;
1087 /* if number of channels not specified, default to 2 */
1088 if (ctx->max_channels < 2)
1089 ctx->max_channels = 2;
1090 }
1091 break;
1092 case Opt_uid:
1093 uid = make_kuid(current_user_ns(), result.uint_32);
1094 if (!uid_valid(uid))
1095 goto cifs_parse_mount_err;
1096 ctx->linux_uid = uid;
1097 ctx->uid_specified = true;
1098 break;
1099 case Opt_cruid:
1100 uid = make_kuid(current_user_ns(), result.uint_32);
1101 if (!uid_valid(uid))
1102 goto cifs_parse_mount_err;
1103 ctx->cred_uid = uid;
1104 ctx->cruid_specified = true;
1105 break;
1106 case Opt_backupuid:
1107 uid = make_kuid(current_user_ns(), result.uint_32);
1108 if (!uid_valid(uid))
1109 goto cifs_parse_mount_err;
1110 ctx->backupuid = uid;
1111 ctx->backupuid_specified = true;
1112 break;
1113 case Opt_backupgid:
1114 gid = make_kgid(current_user_ns(), result.uint_32);
1115 if (!gid_valid(gid))
1116 goto cifs_parse_mount_err;
1117 ctx->backupgid = gid;
1118 ctx->backupgid_specified = true;
1119 break;
1120 case Opt_gid:
1121 gid = make_kgid(current_user_ns(), result.uint_32);
1122 if (!gid_valid(gid))
1123 goto cifs_parse_mount_err;
1124 ctx->linux_gid = gid;
1125 ctx->gid_specified = true;
1126 break;
1127 case Opt_port:
1128 ctx->port = result.uint_32;
1129 break;
1130 case Opt_file_mode:
1131 ctx->file_mode = result.uint_32;
1132 break;
1133 case Opt_dirmode:
1134 ctx->dir_mode = result.uint_32;
1135 break;
1136 case Opt_min_enc_offload:
1137 ctx->min_offload = result.uint_32;
1138 break;
1139 case Opt_retrans:
1140 ctx->retrans = result.uint_32;
1141 break;
1142 case Opt_blocksize:
1143 /*
1144 * inode blocksize realistically should never need to be
1145 * less than 16K or greater than 16M and default is 1MB.
1146 * Note that small inode block sizes (e.g. 64K) can lead
1147 * to very poor performance of common tools like cp and scp
1148 */
1149 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1150 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1151 cifs_errorf(fc, "%s: Invalid blocksize\n",
1152 __func__);
1153 goto cifs_parse_mount_err;
1154 }
1155 ctx->bsize = result.uint_32;
1156 ctx->got_bsize = true;
1157 break;
1158 case Opt_rasize:
1159 /*
1160 * readahead size realistically should never need to be
1161 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1162 * (perhaps an exception should be considered in the
1163 * for the case of a large number of channels
1164 * when multichannel is negotiated) since that would lead
1165 * to plenty of parallel I/O in flight to the server.
1166 * Note that smaller read ahead sizes would
1167 * hurt performance of common tools like cp and scp
1168 * which often trigger sequential i/o with read ahead
1169 */
1170 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1171 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1172 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1173 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1174 goto cifs_parse_mount_err;
1175 }
1176 ctx->rasize = result.uint_32;
1177 break;
1178 case Opt_rsize:
1179 ctx->rsize = result.uint_32;
1180 ctx->got_rsize = true;
1181 break;
1182 case Opt_wsize:
1183 ctx->wsize = result.uint_32;
1184 ctx->got_wsize = true;
1185 if (ctx->wsize % PAGE_SIZE != 0) {
1186 ctx->wsize = round_down(ctx->wsize, PAGE_SIZE);
1187 if (ctx->wsize == 0) {
1188 ctx->wsize = PAGE_SIZE;
1189 cifs_dbg(VFS, "wsize too small, reset to minimum %ld\n", PAGE_SIZE);
1190 } else {
1191 cifs_dbg(VFS,
1192 "wsize rounded down to %d to multiple of PAGE_SIZE %ld\n",
1193 ctx->wsize, PAGE_SIZE);
1194 }
1195 }
1196 break;
1197 case Opt_acregmax:
1198 ctx->acregmax = HZ * result.uint_32;
1199 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1200 cifs_errorf(fc, "acregmax too large\n");
1201 goto cifs_parse_mount_err;
1202 }
1203 break;
1204 case Opt_acdirmax:
1205 ctx->acdirmax = HZ * result.uint_32;
1206 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1207 cifs_errorf(fc, "acdirmax too large\n");
1208 goto cifs_parse_mount_err;
1209 }
1210 break;
1211 case Opt_actimeo:
1212 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1213 cifs_errorf(fc, "timeout too large\n");
1214 goto cifs_parse_mount_err;
1215 }
1216 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1217 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1218 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1219 break;
1220 }
1221 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1222 break;
1223 case Opt_closetimeo:
1224 ctx->closetimeo = HZ * result.uint_32;
1225 if (ctx->closetimeo > SMB3_MAX_DCLOSETIMEO) {
1226 cifs_errorf(fc, "closetimeo too large\n");
1227 goto cifs_parse_mount_err;
1228 }
1229 break;
1230 case Opt_echo_interval:
1231 ctx->echo_interval = result.uint_32;
1232 break;
1233 case Opt_snapshot:
1234 ctx->snapshot_time = result.uint_64;
1235 break;
1236 case Opt_max_credits:
1237 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1238 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1239 __func__);
1240 goto cifs_parse_mount_err;
1241 }
1242 ctx->max_credits = result.uint_32;
1243 break;
1244 case Opt_max_channels:
1245 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1246 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1247 __func__, CIFS_MAX_CHANNELS);
1248 goto cifs_parse_mount_err;
1249 }
1250 ctx->max_channels = result.uint_32;
1251 /* If more than one channel requested ... they want multichan */
1252 if (result.uint_32 > 1)
1253 ctx->multichannel = true;
1254 break;
1255 case Opt_max_cached_dirs:
1256 if (result.uint_32 < 1) {
1257 cifs_errorf(fc, "%s: Invalid max_cached_dirs, needs to be 1 or more\n",
1258 __func__);
1259 goto cifs_parse_mount_err;
1260 }
1261 ctx->max_cached_dirs = result.uint_32;
1262 break;
1263 case Opt_handletimeout:
1264 ctx->handle_timeout = result.uint_32;
1265 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1266 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1267 goto cifs_parse_mount_err;
1268 }
1269 break;
1270 case Opt_source:
1271 kfree(ctx->UNC);
1272 ctx->UNC = NULL;
1273 switch (smb3_parse_devname(param->string, ctx)) {
1274 case 0:
1275 break;
1276 case -ENOMEM:
1277 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1278 goto cifs_parse_mount_err;
1279 case -EINVAL:
1280 cifs_errorf(fc, "Malformed UNC in devname\n");
1281 goto cifs_parse_mount_err;
1282 default:
1283 cifs_errorf(fc, "Unknown error parsing devname\n");
1284 goto cifs_parse_mount_err;
1285 }
1286 ctx->source = smb3_fs_context_fullpath(ctx, '/');
1287 if (IS_ERR(ctx->source)) {
1288 ctx->source = NULL;
1289 cifs_errorf(fc, "OOM when copying UNC string\n");
1290 goto cifs_parse_mount_err;
1291 }
1292 fc->source = kstrdup(ctx->source, GFP_KERNEL);
1293 if (fc->source == NULL) {
1294 cifs_errorf(fc, "OOM when copying UNC string\n");
1295 goto cifs_parse_mount_err;
1296 }
1297 break;
1298 case Opt_user:
1299 kfree(ctx->username);
1300 ctx->username = NULL;
1301 if (ctx->nullauth)
1302 break;
1303 if (strlen(param->string) == 0) {
1304 /* null user, ie. anonymous authentication */
1305 ctx->nullauth = 1;
1306 break;
1307 }
1308
1309 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1310 CIFS_MAX_USERNAME_LEN) {
1311 pr_warn("username too long\n");
1312 goto cifs_parse_mount_err;
1313 }
1314 ctx->username = kstrdup(param->string, GFP_KERNEL);
1315 if (ctx->username == NULL) {
1316 cifs_errorf(fc, "OOM when copying username string\n");
1317 goto cifs_parse_mount_err;
1318 }
1319 break;
1320 case Opt_pass:
1321 kfree_sensitive(ctx->password);
1322 ctx->password = NULL;
1323 if (strlen(param->string) == 0)
1324 break;
1325
1326 ctx->password = kstrdup(param->string, GFP_KERNEL);
1327 if (ctx->password == NULL) {
1328 cifs_errorf(fc, "OOM when copying password string\n");
1329 goto cifs_parse_mount_err;
1330 }
1331 break;
1332 case Opt_pass2:
1333 kfree_sensitive(ctx->password2);
1334 ctx->password2 = NULL;
1335 if (strlen(param->string) == 0)
1336 break;
1337
1338 ctx->password2 = kstrdup(param->string, GFP_KERNEL);
1339 if (ctx->password2 == NULL) {
1340 cifs_errorf(fc, "OOM when copying password2 string\n");
1341 goto cifs_parse_mount_err;
1342 }
1343 break;
1344 case Opt_ip:
1345 if (strlen(param->string) == 0) {
1346 ctx->got_ip = false;
1347 break;
1348 }
1349 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1350 param->string,
1351 strlen(param->string))) {
1352 pr_err("bad ip= option (%s)\n", param->string);
1353 goto cifs_parse_mount_err;
1354 }
1355 ctx->got_ip = true;
1356 break;
1357 case Opt_domain:
1358 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1359 == CIFS_MAX_DOMAINNAME_LEN) {
1360 pr_warn("domain name too long\n");
1361 goto cifs_parse_mount_err;
1362 }
1363
1364 kfree(ctx->domainname);
1365 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1366 if (ctx->domainname == NULL) {
1367 cifs_errorf(fc, "OOM when copying domainname string\n");
1368 goto cifs_parse_mount_err;
1369 }
1370 cifs_dbg(FYI, "Domain name set\n");
1371 break;
1372 case Opt_srcaddr:
1373 if (!cifs_convert_address(
1374 (struct sockaddr *)&ctx->srcaddr,
1375 param->string, strlen(param->string))) {
1376 pr_warn("Could not parse srcaddr: %s\n",
1377 param->string);
1378 goto cifs_parse_mount_err;
1379 }
1380 break;
1381 case Opt_iocharset:
1382 if (strnlen(param->string, 1024) >= 65) {
1383 pr_warn("iocharset name too long\n");
1384 goto cifs_parse_mount_err;
1385 }
1386
1387 if (strncasecmp(param->string, "default", 7) != 0) {
1388 kfree(ctx->iocharset);
1389 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1390 if (ctx->iocharset == NULL) {
1391 cifs_errorf(fc, "OOM when copying iocharset string\n");
1392 goto cifs_parse_mount_err;
1393 }
1394 }
1395 /* if iocharset not set then load_nls_default
1396 * is used by caller
1397 */
1398 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1399 break;
1400 case Opt_netbiosname:
1401 memset(ctx->source_rfc1001_name, 0x20,
1402 RFC1001_NAME_LEN);
1403 /*
1404 * FIXME: are there cases in which a comma can
1405 * be valid in workstation netbios name (and
1406 * need special handling)?
1407 */
1408 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1409 /* don't ucase netbiosname for user */
1410 if (param->string[i] == 0)
1411 break;
1412 ctx->source_rfc1001_name[i] = param->string[i];
1413 }
1414 /* The string has 16th byte zero still from
1415 * set at top of the function
1416 */
1417 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1418 pr_warn("netbiosname longer than 15 truncated\n");
1419 break;
1420 case Opt_servern:
1421 /* last byte, type, is 0x20 for servr type */
1422 memset(ctx->target_rfc1001_name, 0x20,
1423 RFC1001_NAME_LEN_WITH_NULL);
1424 /*
1425 * BB are there cases in which a comma can be valid in this
1426 * workstation netbios name (and need special handling)?
1427 */
1428
1429 /* user or mount helper must uppercase the netbios name */
1430 for (i = 0; i < 15; i++) {
1431 if (param->string[i] == 0)
1432 break;
1433 ctx->target_rfc1001_name[i] = param->string[i];
1434 }
1435
1436 /* The string has 16th byte zero still from set at top of function */
1437 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1438 pr_warn("server netbiosname longer than 15 truncated\n");
1439 break;
1440 case Opt_ver:
1441 /* version of mount userspace tools, not dialect */
1442 /* If interface changes in mount.cifs bump to new ver */
1443 if (strncasecmp(param->string, "1", 1) == 0) {
1444 if (strlen(param->string) > 1) {
1445 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1446 param->string);
1447 goto cifs_parse_mount_err;
1448 }
1449 /* This is the default */
1450 break;
1451 }
1452 /* For all other value, error */
1453 pr_warn("Invalid mount helper version specified\n");
1454 goto cifs_parse_mount_err;
1455 case Opt_vers:
1456 /* protocol version (dialect) */
1457 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1458 goto cifs_parse_mount_err;
1459 ctx->got_version = true;
1460 break;
1461 case Opt_sec:
1462 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1463 goto cifs_parse_mount_err;
1464 break;
1465 case Opt_cache:
1466 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1467 goto cifs_parse_mount_err;
1468 break;
1469 case Opt_witness:
1470 #ifndef CONFIG_CIFS_SWN_UPCALL
1471 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1472 goto cifs_parse_mount_err;
1473 #endif
1474 ctx->witness = true;
1475 pr_warn_once("Witness protocol support is experimental\n");
1476 break;
1477 case Opt_rootfs:
1478 #ifndef CONFIG_CIFS_ROOT
1479 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1480 goto cifs_parse_mount_err;
1481 #endif
1482 ctx->rootfs = true;
1483 break;
1484 case Opt_posixpaths:
1485 if (result.negated)
1486 ctx->posix_paths = 0;
1487 else
1488 ctx->posix_paths = 1;
1489 break;
1490 case Opt_unix:
1491 if (result.negated) {
1492 if (ctx->linux_ext == 1)
1493 pr_warn_once("conflicting posix mount options specified\n");
1494 ctx->linux_ext = 0;
1495 ctx->no_linux_ext = 1;
1496 } else {
1497 if (ctx->no_linux_ext == 1)
1498 pr_warn_once("conflicting posix mount options specified\n");
1499 ctx->linux_ext = 1;
1500 ctx->no_linux_ext = 0;
1501 }
1502 break;
1503 case Opt_nocase:
1504 ctx->nocase = 1;
1505 break;
1506 case Opt_brl:
1507 if (result.negated) {
1508 /*
1509 * turn off mandatory locking in mode
1510 * if remote locking is turned off since the
1511 * local vfs will do advisory
1512 */
1513 if (ctx->file_mode ==
1514 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1515 ctx->file_mode = S_IALLUGO;
1516 ctx->nobrl = 1;
1517 } else
1518 ctx->nobrl = 0;
1519 break;
1520 case Opt_handlecache:
1521 if (result.negated)
1522 ctx->nohandlecache = 1;
1523 else
1524 ctx->nohandlecache = 0;
1525 break;
1526 case Opt_forcemandatorylock:
1527 ctx->mand_lock = 1;
1528 break;
1529 case Opt_setuids:
1530 ctx->setuids = result.negated;
1531 break;
1532 case Opt_intr:
1533 ctx->intr = !result.negated;
1534 break;
1535 case Opt_setuidfromacl:
1536 ctx->setuidfromacl = 1;
1537 break;
1538 case Opt_strictsync:
1539 ctx->nostrictsync = result.negated;
1540 break;
1541 case Opt_serverino:
1542 ctx->server_ino = !result.negated;
1543 break;
1544 case Opt_rwpidforward:
1545 ctx->rwpidforward = 1;
1546 break;
1547 case Opt_modesid:
1548 ctx->mode_ace = 1;
1549 break;
1550 case Opt_cifsacl:
1551 ctx->cifs_acl = !result.negated;
1552 break;
1553 case Opt_acl:
1554 ctx->no_psx_acl = result.negated;
1555 break;
1556 case Opt_locallease:
1557 ctx->local_lease = 1;
1558 break;
1559 case Opt_sign:
1560 ctx->sign = true;
1561 break;
1562 case Opt_ignore_signature:
1563 ctx->sign = true;
1564 ctx->ignore_signature = true;
1565 break;
1566 case Opt_seal:
1567 /* we do not do the following in secFlags because seal
1568 * is a per tree connection (mount) not a per socket
1569 * or per-smb connection option in the protocol
1570 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1571 */
1572 ctx->seal = 1;
1573 break;
1574 case Opt_noac:
1575 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1576 break;
1577 case Opt_fsc:
1578 #ifndef CONFIG_CIFS_FSCACHE
1579 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1580 goto cifs_parse_mount_err;
1581 #endif
1582 ctx->fsc = true;
1583 break;
1584 case Opt_mfsymlinks:
1585 ctx->mfsymlinks = true;
1586 break;
1587 case Opt_multiuser:
1588 ctx->multiuser = true;
1589 break;
1590 case Opt_sloppy:
1591 ctx->sloppy = true;
1592 break;
1593 case Opt_nosharesock:
1594 ctx->nosharesock = true;
1595 break;
1596 case Opt_persistent:
1597 if (result.negated) {
1598 ctx->nopersistent = true;
1599 if (ctx->persistent) {
1600 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1601 goto cifs_parse_mount_err;
1602 }
1603 } else {
1604 ctx->persistent = true;
1605 if ((ctx->nopersistent) || (ctx->resilient)) {
1606 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1607 goto cifs_parse_mount_err;
1608 }
1609 }
1610 break;
1611 case Opt_resilient:
1612 if (result.negated) {
1613 ctx->resilient = false; /* already the default */
1614 } else {
1615 ctx->resilient = true;
1616 if (ctx->persistent) {
1617 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1618 goto cifs_parse_mount_err;
1619 }
1620 }
1621 break;
1622 case Opt_tcp_nodelay:
1623 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1624 if (result.negated)
1625 ctx->sockopt_tcp_nodelay = false;
1626 else
1627 ctx->sockopt_tcp_nodelay = true;
1628 break;
1629 case Opt_domainauto:
1630 ctx->domainauto = true;
1631 break;
1632 case Opt_rdma:
1633 ctx->rdma = true;
1634 break;
1635 case Opt_reparse:
1636 if (parse_reparse_flavor(fc, param->string, ctx))
1637 goto cifs_parse_mount_err;
1638 break;
1639 }
1640 /* case Opt_ignore: - is ignored as expected ... */
1641
1642 return 0;
1643
1644 cifs_parse_mount_err:
1645 kfree_sensitive(ctx->password);
1646 ctx->password = NULL;
1647 kfree_sensitive(ctx->password2);
1648 ctx->password2 = NULL;
1649 return -EINVAL;
1650 }
1651
smb3_init_fs_context(struct fs_context * fc)1652 int smb3_init_fs_context(struct fs_context *fc)
1653 {
1654 struct smb3_fs_context *ctx;
1655 char *nodename = utsname()->nodename;
1656 int i;
1657
1658 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1659 if (unlikely(!ctx))
1660 return -ENOMEM;
1661
1662 strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1663
1664 /*
1665 * does not have to be perfect mapping since field is
1666 * informational, only used for servers that do not support
1667 * port 445 and it can be overridden at mount time
1668 */
1669 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1670 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1671 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1672
1673 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1674 /*
1675 * null target name indicates to use *SMBSERVR default called name
1676 * if we end up sending RFC1001 session initialize
1677 */
1678 ctx->target_rfc1001_name[0] = 0;
1679 ctx->cred_uid = current_uid();
1680 ctx->linux_uid = current_uid();
1681 ctx->linux_gid = current_gid();
1682 /* By default 4MB read ahead size, 1MB block size */
1683 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1684 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1685
1686 /*
1687 * default to SFM style remapping of seven reserved characters
1688 * unless user overrides it or we negotiate CIFS POSIX where
1689 * it is unnecessary. Can not simultaneously use more than one mapping
1690 * since then readdir could list files that open could not open
1691 */
1692 ctx->remap = true;
1693
1694 /* default to only allowing write access to owner of the mount */
1695 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1696
1697 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1698 /* default is always to request posix paths. */
1699 ctx->posix_paths = 1;
1700 /* default to using server inode numbers where available */
1701 ctx->server_ino = 1;
1702
1703 /* default is to use strict cifs caching semantics */
1704 ctx->strict_io = true;
1705
1706 ctx->acregmax = CIFS_DEF_ACTIMEO;
1707 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1708 ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1709 ctx->max_cached_dirs = MAX_CACHED_FIDS;
1710 /* Most clients set timeout to 0, allows server to use its default */
1711 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1712
1713 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1714 ctx->ops = &smb30_operations;
1715 ctx->vals = &smbdefault_values;
1716
1717 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1718
1719 /* default to no multichannel (single server connection) */
1720 ctx->multichannel = false;
1721 ctx->max_channels = 1;
1722
1723 ctx->backupuid_specified = false; /* no backup intent for a user */
1724 ctx->backupgid_specified = false; /* no backup intent for a group */
1725
1726 ctx->retrans = 1;
1727 ctx->reparse_type = CIFS_REPARSE_TYPE_DEFAULT;
1728
1729 /*
1730 * short int override_uid = -1;
1731 * short int override_gid = -1;
1732 * char *nodename = strdup(utsname()->nodename);
1733 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1734 */
1735
1736 fc->fs_private = ctx;
1737 fc->ops = &smb3_fs_context_ops;
1738 return 0;
1739 }
1740
1741 void
smb3_cleanup_fs_context_contents(struct smb3_fs_context * ctx)1742 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1743 {
1744 if (ctx == NULL)
1745 return;
1746
1747 /*
1748 * Make sure this stays in sync with smb3_fs_context_dup()
1749 */
1750 kfree(ctx->username);
1751 ctx->username = NULL;
1752 kfree_sensitive(ctx->password);
1753 ctx->password = NULL;
1754 kfree_sensitive(ctx->password2);
1755 ctx->password2 = NULL;
1756 kfree(ctx->server_hostname);
1757 ctx->server_hostname = NULL;
1758 kfree(ctx->UNC);
1759 ctx->UNC = NULL;
1760 kfree(ctx->source);
1761 ctx->source = NULL;
1762 kfree(ctx->domainname);
1763 ctx->domainname = NULL;
1764 kfree(ctx->nodename);
1765 ctx->nodename = NULL;
1766 kfree(ctx->iocharset);
1767 ctx->iocharset = NULL;
1768 kfree(ctx->prepath);
1769 ctx->prepath = NULL;
1770 kfree(ctx->leaf_fullpath);
1771 ctx->leaf_fullpath = NULL;
1772 }
1773
1774 void
smb3_cleanup_fs_context(struct smb3_fs_context * ctx)1775 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1776 {
1777 if (!ctx)
1778 return;
1779 smb3_cleanup_fs_context_contents(ctx);
1780 kfree(ctx);
1781 }
1782
smb3_update_mnt_flags(struct cifs_sb_info * cifs_sb)1783 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1784 {
1785 struct smb3_fs_context *ctx = cifs_sb->ctx;
1786
1787 if (ctx->nodfs)
1788 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1789 else
1790 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1791
1792 if (ctx->noperm)
1793 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1794 else
1795 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1796
1797 if (ctx->setuids)
1798 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1799 else
1800 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1801
1802 if (ctx->setuidfromacl)
1803 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1804 else
1805 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1806
1807 if (ctx->server_ino)
1808 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1809 else
1810 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1811
1812 if (ctx->remap)
1813 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1814 else
1815 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1816
1817 if (ctx->sfu_remap)
1818 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1819 else
1820 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1821
1822 if (ctx->no_xattr)
1823 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1824 else
1825 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1826
1827 if (ctx->sfu_emul)
1828 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1829 else
1830 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1831
1832 if (ctx->nobrl)
1833 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1834 else
1835 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1836
1837 if (ctx->nohandlecache)
1838 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1839 else
1840 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1841
1842 if (ctx->nostrictsync)
1843 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1844 else
1845 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1846
1847 if (ctx->mand_lock)
1848 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1849 else
1850 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1851
1852 if (ctx->rwpidforward)
1853 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1854 else
1855 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1856
1857 if (ctx->mode_ace)
1858 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1859 else
1860 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1861
1862 if (ctx->cifs_acl)
1863 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1864 else
1865 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1866
1867 if (ctx->backupuid_specified)
1868 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1869 else
1870 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1871
1872 if (ctx->backupgid_specified)
1873 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1874 else
1875 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1876
1877 if (ctx->override_uid)
1878 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1879 else
1880 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1881
1882 if (ctx->override_gid)
1883 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1884 else
1885 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1886
1887 if (ctx->dynperm)
1888 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1889 else
1890 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1891
1892 if (ctx->fsc)
1893 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1894 else
1895 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1896
1897 if (ctx->multiuser)
1898 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1899 CIFS_MOUNT_NO_PERM);
1900 else
1901 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1902
1903
1904 if (ctx->strict_io)
1905 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1906 else
1907 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1908
1909 if (ctx->direct_io)
1910 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1911 else
1912 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1913
1914 if (ctx->mfsymlinks)
1915 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1916 else
1917 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1918 if (ctx->mfsymlinks) {
1919 if (ctx->sfu_emul) {
1920 /*
1921 * Our SFU ("Services for Unix" emulation does not allow
1922 * creating symlinks but does allow reading existing SFU
1923 * symlinks (it does allow both creating and reading SFU
1924 * style mknod and FIFOs though). When "mfsymlinks" and
1925 * "sfu" are both enabled at the same time, it allows
1926 * reading both types of symlinks, but will only create
1927 * them with mfsymlinks format. This allows better
1928 * Apple compatibility (probably better for Samba too)
1929 * while still recognizing old Windows style symlinks.
1930 */
1931 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1932 }
1933 }
1934 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1935
1936 return;
1937 }
1938