1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
40static const match_table_t cifs_smb_version_tokens = {
41 { Smb_1, SMB1_VERSION_STRING },
42 { Smb_20, SMB20_VERSION_STRING},
43 { Smb_21, SMB21_VERSION_STRING },
44 { Smb_30, SMB30_VERSION_STRING },
45 { Smb_302, SMB302_VERSION_STRING },
46 { Smb_302, ALT_SMB302_VERSION_STRING },
47 { Smb_311, SMB311_VERSION_STRING },
48 { Smb_311, ALT_SMB311_VERSION_STRING },
49 { Smb_3any, SMB3ANY_VERSION_STRING },
50 { Smb_default, SMBDEFAULT_VERSION_STRING },
51 { Smb_version_err, NULL }
52};
53
54static const match_table_t cifs_secflavor_tokens = {
55 { Opt_sec_krb5, "krb5" },
56 { Opt_sec_krb5i, "krb5i" },
57 { Opt_sec_krb5p, "krb5p" },
58 { Opt_sec_ntlmsspi, "ntlmsspi" },
59 { Opt_sec_ntlmssp, "ntlmssp" },
60 { Opt_ntlm, "ntlm" },
61 { Opt_sec_ntlmi, "ntlmi" },
62 { Opt_sec_ntlmv2, "nontlm" },
63 { Opt_sec_ntlmv2, "ntlmv2" },
64 { Opt_sec_ntlmv2i, "ntlmv2i" },
65 { Opt_sec_lanman, "lanman" },
66 { Opt_sec_none, "none" },
67
68 { Opt_sec_err, NULL }
69};
70
71const struct fs_parameter_spec smb3_fs_parameters[] = {
72
73 fsparam_flag_no("user_xattr", Opt_user_xattr),
74 fsparam_flag_no("forceuid", Opt_forceuid),
75 fsparam_flag_no("multichannel", Opt_multichannel),
76 fsparam_flag_no("forcegid", Opt_forcegid),
77 fsparam_flag("noblocksend", Opt_noblocksend),
78 fsparam_flag("noautotune", Opt_noautotune),
79 fsparam_flag("nolease", Opt_nolease),
80 fsparam_flag_no("hard", Opt_hard),
81 fsparam_flag_no("soft", Opt_soft),
82 fsparam_flag_no("perm", Opt_perm),
83 fsparam_flag("nodelete", Opt_nodelete),
84 fsparam_flag_no("mapposix", Opt_mapposix),
85 fsparam_flag("mapchars", Opt_mapchars),
86 fsparam_flag("nomapchars", Opt_nomapchars),
87 fsparam_flag_no("sfu", Opt_sfu),
88 fsparam_flag("nodfs", Opt_nodfs),
89 fsparam_flag_no("posixpaths", Opt_posixpaths),
90 fsparam_flag_no("unix", Opt_unix),
91 fsparam_flag_no("linux", Opt_unix),
92 fsparam_flag_no("posix", Opt_unix),
93 fsparam_flag("nocase", Opt_nocase),
94 fsparam_flag("ignorecase", Opt_nocase),
95 fsparam_flag_no("brl", Opt_brl),
96 fsparam_flag_no("handlecache", Opt_handlecache),
97 fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
98 fsparam_flag("forcemand", Opt_forcemandatorylock),
99 fsparam_flag("setuidfromacl", Opt_setuidfromacl),
100 fsparam_flag("idsfromsid", Opt_setuidfromacl),
101 fsparam_flag_no("setuids", Opt_setuids),
102 fsparam_flag_no("dynperm", Opt_dynperm),
103 fsparam_flag_no("intr", Opt_intr),
104 fsparam_flag_no("strictsync", Opt_strictsync),
105 fsparam_flag_no("serverino", Opt_serverino),
106 fsparam_flag("rwpidforward", Opt_rwpidforward),
107 fsparam_flag("cifsacl", Opt_cifsacl),
108 fsparam_flag_no("acl", Opt_acl),
109 fsparam_flag("locallease", Opt_locallease),
110 fsparam_flag("sign", Opt_sign),
111 fsparam_flag("ignore_signature", Opt_ignore_signature),
112 fsparam_flag("signloosely", Opt_ignore_signature),
113 fsparam_flag("seal", Opt_seal),
114 fsparam_flag("noac", Opt_noac),
115 fsparam_flag("fsc", Opt_fsc),
116 fsparam_flag("mfsymlinks", Opt_mfsymlinks),
117 fsparam_flag("multiuser", Opt_multiuser),
118 fsparam_flag("sloppy", Opt_sloppy),
119 fsparam_flag("nosharesock", Opt_nosharesock),
120 fsparam_flag_no("persistenthandles", Opt_persistent),
121 fsparam_flag_no("resilienthandles", Opt_resilient),
122 fsparam_flag("domainauto", Opt_domainauto),
123 fsparam_flag("rdma", Opt_rdma),
124 fsparam_flag("modesid", Opt_modesid),
125 fsparam_flag("modefromsid", Opt_modesid),
126 fsparam_flag("rootfs", Opt_rootfs),
127 fsparam_flag("compress", Opt_compress),
128 fsparam_flag("witness", Opt_witness),
129
130
131 fsparam_u32("backupuid", Opt_backupuid),
132 fsparam_u32("backupgid", Opt_backupgid),
133 fsparam_u32("uid", Opt_uid),
134 fsparam_u32("cruid", Opt_cruid),
135 fsparam_u32("gid", Opt_gid),
136 fsparam_u32("file_mode", Opt_file_mode),
137 fsparam_u32("dirmode", Opt_dirmode),
138 fsparam_u32("dir_mode", Opt_dirmode),
139 fsparam_u32("port", Opt_port),
140 fsparam_u32("min_enc_offload", Opt_min_enc_offload),
141 fsparam_u32("esize", Opt_min_enc_offload),
142 fsparam_u32("bsize", Opt_blocksize),
143 fsparam_u32("rasize", Opt_rasize),
144 fsparam_u32("rsize", Opt_rsize),
145 fsparam_u32("wsize", Opt_wsize),
146 fsparam_u32("actimeo", Opt_actimeo),
147 fsparam_u32("acdirmax", Opt_acdirmax),
148 fsparam_u32("acregmax", Opt_acregmax),
149 fsparam_u32("echo_interval", Opt_echo_interval),
150 fsparam_u32("max_credits", Opt_max_credits),
151 fsparam_u32("handletimeout", Opt_handletimeout),
152 fsparam_u32("snapshot", Opt_snapshot),
153 fsparam_u32("max_channels", Opt_max_channels),
154
155
156 fsparam_string("source", Opt_source),
157 fsparam_string("user", Opt_user),
158 fsparam_string("username", Opt_user),
159 fsparam_string("pass", Opt_pass),
160 fsparam_string("password", Opt_pass),
161 fsparam_string("ip", Opt_ip),
162 fsparam_string("addr", Opt_ip),
163 fsparam_string("domain", Opt_domain),
164 fsparam_string("dom", Opt_domain),
165 fsparam_string("srcaddr", Opt_srcaddr),
166 fsparam_string("iocharset", Opt_iocharset),
167 fsparam_string("netbiosname", Opt_netbiosname),
168 fsparam_string("servern", Opt_servern),
169 fsparam_string("ver", Opt_ver),
170 fsparam_string("vers", Opt_vers),
171 fsparam_string("sec", Opt_sec),
172 fsparam_string("cache", Opt_cache),
173
174
175 fsparam_flag("guest", Opt_ignore),
176 fsparam_flag("noatime", Opt_ignore),
177 fsparam_flag("relatime", Opt_ignore),
178 fsparam_flag("_netdev", Opt_ignore),
179 fsparam_flag_no("suid", Opt_ignore),
180 fsparam_flag_no("exec", Opt_ignore),
181 fsparam_flag_no("dev", Opt_ignore),
182 fsparam_flag_no("mand", Opt_ignore),
183 fsparam_flag_no("auto", Opt_ignore),
184 fsparam_string("cred", Opt_ignore),
185 fsparam_string("credentials", Opt_ignore),
186
187
188
189
190 fsparam_string("unc", Opt_ignore),
191 fsparam_string("prefixpath", Opt_ignore),
192 {}
193};
194
195static int
196cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
197{
198
199 substring_t args[MAX_OPT_ARGS];
200
201
202
203
204
205 ctx->sectype = Unspecified;
206 ctx->sign = false;
207
208 switch (match_token(value, cifs_secflavor_tokens, args)) {
209 case Opt_sec_krb5p:
210 cifs_errorf(fc, "sec=krb5p is not supported!\n");
211 return 1;
212 case Opt_sec_krb5i:
213 ctx->sign = true;
214 fallthrough;
215 case Opt_sec_krb5:
216 ctx->sectype = Kerberos;
217 break;
218 case Opt_sec_ntlmsspi:
219 ctx->sign = true;
220 fallthrough;
221 case Opt_sec_ntlmssp:
222 ctx->sectype = RawNTLMSSP;
223 break;
224 case Opt_sec_ntlmi:
225 ctx->sign = true;
226 fallthrough;
227 case Opt_ntlm:
228 ctx->sectype = NTLM;
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#ifdef CONFIG_CIFS_WEAK_PW_HASH
237 case Opt_sec_lanman:
238 ctx->sectype = LANMAN;
239 break;
240#endif
241 case Opt_sec_none:
242 ctx->nullauth = 1;
243 break;
244 default:
245 cifs_errorf(fc, "bad security option: %s\n", value);
246 return 1;
247 }
248
249 return 0;
250}
251
252static const match_table_t cifs_cacheflavor_tokens = {
253 { Opt_cache_loose, "loose" },
254 { Opt_cache_strict, "strict" },
255 { Opt_cache_none, "none" },
256 { Opt_cache_ro, "ro" },
257 { Opt_cache_rw, "singleclient" },
258 { Opt_cache_err, NULL }
259};
260
261static int
262cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
263{
264 substring_t args[MAX_OPT_ARGS];
265
266 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
267 case Opt_cache_loose:
268 ctx->direct_io = false;
269 ctx->strict_io = false;
270 ctx->cache_ro = false;
271 ctx->cache_rw = false;
272 break;
273 case Opt_cache_strict:
274 ctx->direct_io = false;
275 ctx->strict_io = true;
276 ctx->cache_ro = false;
277 ctx->cache_rw = false;
278 break;
279 case Opt_cache_none:
280 ctx->direct_io = true;
281 ctx->strict_io = false;
282 ctx->cache_ro = false;
283 ctx->cache_rw = false;
284 break;
285 case Opt_cache_ro:
286 ctx->direct_io = false;
287 ctx->strict_io = false;
288 ctx->cache_ro = true;
289 ctx->cache_rw = false;
290 break;
291 case Opt_cache_rw:
292 ctx->direct_io = false;
293 ctx->strict_io = false;
294 ctx->cache_ro = false;
295 ctx->cache_rw = true;
296 break;
297 default:
298 cifs_errorf(fc, "bad cache= option: %s\n", value);
299 return 1;
300 }
301 return 0;
302}
303
304#define DUP_CTX_STR(field) \
305do { \
306 if (ctx->field) { \
307 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
308 if (new_ctx->field == NULL) { \
309 smb3_cleanup_fs_context_contents(new_ctx); \
310 return -ENOMEM; \
311 } \
312 } \
313} while (0)
314
315int
316smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
317{
318 memcpy(new_ctx, ctx, sizeof(*ctx));
319 new_ctx->prepath = NULL;
320 new_ctx->mount_options = NULL;
321 new_ctx->nodename = NULL;
322 new_ctx->username = NULL;
323 new_ctx->password = NULL;
324 new_ctx->domainname = NULL;
325 new_ctx->UNC = NULL;
326 new_ctx->source = NULL;
327 new_ctx->iocharset = NULL;
328
329
330
331 DUP_CTX_STR(prepath);
332 DUP_CTX_STR(mount_options);
333 DUP_CTX_STR(username);
334 DUP_CTX_STR(password);
335 DUP_CTX_STR(UNC);
336 DUP_CTX_STR(source);
337 DUP_CTX_STR(domainname);
338 DUP_CTX_STR(nodename);
339 DUP_CTX_STR(iocharset);
340
341 return 0;
342}
343
344static int
345cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
346{
347 substring_t args[MAX_OPT_ARGS];
348
349 switch (match_token(value, cifs_smb_version_tokens, args)) {
350#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
351 case Smb_1:
352 if (disable_legacy_dialects) {
353 cifs_errorf(fc, "mount with legacy dialect disabled\n");
354 return 1;
355 }
356 if (is_smb3) {
357 cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
358 return 1;
359 }
360 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
361 ctx->ops = &smb1_operations;
362 ctx->vals = &smb1_values;
363 break;
364 case Smb_20:
365 if (disable_legacy_dialects) {
366 cifs_errorf(fc, "mount with legacy dialect disabled\n");
367 return 1;
368 }
369 if (is_smb3) {
370 cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
371 return 1;
372 }
373 ctx->ops = &smb20_operations;
374 ctx->vals = &smb20_values;
375 break;
376#else
377 case Smb_1:
378 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
379 return 1;
380 case Smb_20:
381 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
382 return 1;
383#endif
384 case Smb_21:
385 ctx->ops = &smb21_operations;
386 ctx->vals = &smb21_values;
387 break;
388 case Smb_30:
389 ctx->ops = &smb30_operations;
390 ctx->vals = &smb30_values;
391 break;
392 case Smb_302:
393 ctx->ops = &smb30_operations;
394 ctx->vals = &smb302_values;
395 break;
396 case Smb_311:
397 ctx->ops = &smb311_operations;
398 ctx->vals = &smb311_values;
399 break;
400 case Smb_3any:
401 ctx->ops = &smb30_operations;
402 ctx->vals = &smb3any_values;
403 break;
404 case Smb_default:
405 ctx->ops = &smb30_operations;
406 ctx->vals = &smbdefault_values;
407 break;
408 default:
409 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
410 return 1;
411 }
412 return 0;
413}
414
415int smb3_parse_opt(const char *options, const char *key, char **val)
416{
417 int rc = -ENOENT;
418 char *opts, *orig, *p;
419
420 orig = opts = kstrdup(options, GFP_KERNEL);
421 if (!opts)
422 return -ENOMEM;
423
424 while ((p = strsep(&opts, ","))) {
425 char *nval;
426
427 if (!*p)
428 continue;
429 if (strncasecmp(p, key, strlen(key)))
430 continue;
431 nval = strchr(p, '=');
432 if (nval) {
433 if (nval == p)
434 continue;
435 *nval++ = 0;
436 *val = kstrdup(nval, GFP_KERNEL);
437 rc = !*val ? -ENOMEM : 0;
438 goto out;
439 }
440 }
441out:
442 kfree(orig);
443 return rc;
444}
445
446
447
448
449
450
451int
452smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
453{
454 char *pos;
455 const char *delims = "/\\";
456 size_t len;
457
458 if (unlikely(!devname || !*devname)) {
459 cifs_dbg(VFS, "Device name not specified\n");
460 return -EINVAL;
461 }
462
463
464 len = strspn(devname, delims);
465 if (len != 2)
466 return -EINVAL;
467
468
469 pos = strpbrk(devname + 2, delims);
470 if (!pos)
471 return -EINVAL;
472
473
474 ++pos;
475
476
477 len = strcspn(pos, delims);
478
479
480 pos += len;
481 kfree(ctx->UNC);
482 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
483 if (!ctx->UNC)
484 return -ENOMEM;
485
486 convert_delimiter(ctx->UNC, '\\');
487
488
489 if (*pos == '/' || *pos == '\\')
490 pos++;
491
492 kfree(ctx->prepath);
493 ctx->prepath = NULL;
494
495
496 if (!*pos)
497 return 0;
498
499 ctx->prepath = kstrdup(pos, GFP_KERNEL);
500 if (!ctx->prepath)
501 return -ENOMEM;
502
503 return 0;
504}
505
506static void smb3_fs_context_free(struct fs_context *fc);
507static int smb3_fs_context_parse_param(struct fs_context *fc,
508 struct fs_parameter *param);
509static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
510 void *data);
511static int smb3_get_tree(struct fs_context *fc);
512static int smb3_reconfigure(struct fs_context *fc);
513
514static const struct fs_context_operations smb3_fs_context_ops = {
515 .free = smb3_fs_context_free,
516 .parse_param = smb3_fs_context_parse_param,
517 .parse_monolithic = smb3_fs_context_parse_monolithic,
518 .get_tree = smb3_get_tree,
519 .reconfigure = smb3_reconfigure,
520};
521
522
523
524
525
526
527
528
529
530
531
532
533
534static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
535 void *data)
536{
537 struct smb3_fs_context *ctx = smb3_fc2context(fc);
538 char *options = data, *key;
539 int ret = 0;
540
541 if (!options)
542 return 0;
543
544 ctx->mount_options = kstrdup(data, GFP_KERNEL);
545 if (ctx->mount_options == NULL)
546 return -ENOMEM;
547
548 ret = security_sb_eat_lsm_opts(options, &fc->security);
549 if (ret)
550 return ret;
551
552
553 while ((key = strsep(&options, ",")) != NULL) {
554 size_t len;
555 char *value;
556
557 if (*key == 0)
558 break;
559
560
561
562
563
564 while (options && options[0] == ',') {
565 len = strlen(key);
566 strcpy(key + len, options);
567 options = strchr(options, ',');
568 if (options)
569 *options++ = 0;
570 }
571
572
573 len = 0;
574 value = strchr(key, '=');
575 if (value) {
576 if (value == key)
577 continue;
578 *value++ = 0;
579 len = strlen(value);
580 }
581
582 ret = vfs_parse_fs_string(fc, key, value, len);
583 if (ret < 0)
584 break;
585 }
586
587 return ret;
588}
589
590
591
592
593static int smb3_fs_context_validate(struct fs_context *fc)
594{
595 struct smb3_fs_context *ctx = smb3_fc2context(fc);
596
597 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
598 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
599 return -EOPNOTSUPP;
600 }
601
602#ifndef CONFIG_KEYS
603
604 if (ctx->multiuser) {
605 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
606 return -1;
607 }
608#endif
609
610 if (ctx->got_version == false)
611 pr_warn_once("No dialect specified on mount. Default has changed to a more secure dialect, SMB2.1 or later (e.g. SMB3.1.1), from CIFS (SMB1). To use the less secure SMB1 dialect to access old servers which do not support SMB3.1.1 (or even SMB3 or SMB2.1) specify vers=1.0 on mount.\n");
612
613
614 if (!ctx->UNC) {
615 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
616 return -1;
617 }
618
619
620 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
621 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
622 return -ENOENT;
623 }
624
625 if (!ctx->got_ip) {
626 int len;
627 const char *slash;
628
629
630
631 slash = strchr(&ctx->UNC[2], '\\');
632 len = slash - &ctx->UNC[2];
633 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
634 &ctx->UNC[2], len)) {
635 pr_err("Unable to determine destination address\n");
636 return -EHOSTUNREACH;
637 }
638 }
639
640
641 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
642
643 if (ctx->override_uid && !ctx->uid_specified) {
644 ctx->override_uid = 0;
645 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
646 }
647
648 if (ctx->override_gid && !ctx->gid_specified) {
649 ctx->override_gid = 0;
650 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
651 }
652
653 return 0;
654}
655
656static int smb3_get_tree_common(struct fs_context *fc)
657{
658 struct smb3_fs_context *ctx = smb3_fc2context(fc);
659 struct dentry *root;
660 int rc = 0;
661
662 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
663 if (IS_ERR(root))
664 return PTR_ERR(root);
665
666 fc->root = root;
667
668 return rc;
669}
670
671
672
673
674static int smb3_get_tree(struct fs_context *fc)
675{
676 int err = smb3_fs_context_validate(fc);
677
678 if (err)
679 return err;
680 return smb3_get_tree_common(fc);
681}
682
683static void smb3_fs_context_free(struct fs_context *fc)
684{
685 struct smb3_fs_context *ctx = smb3_fc2context(fc);
686
687 smb3_cleanup_fs_context(ctx);
688}
689
690
691
692
693
694static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
695 struct smb3_fs_context *new_ctx,
696 struct smb3_fs_context *old_ctx)
697{
698 if (new_ctx->posix_paths != old_ctx->posix_paths) {
699 cifs_errorf(fc, "can not change posixpaths during remount\n");
700 return -EINVAL;
701 }
702 if (new_ctx->sectype != old_ctx->sectype) {
703 cifs_errorf(fc, "can not change sec during remount\n");
704 return -EINVAL;
705 }
706 if (new_ctx->multiuser != old_ctx->multiuser) {
707 cifs_errorf(fc, "can not change multiuser during remount\n");
708 return -EINVAL;
709 }
710 if (new_ctx->UNC &&
711 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
712 cifs_errorf(fc, "can not change UNC during remount\n");
713 return -EINVAL;
714 }
715 if (new_ctx->username &&
716 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
717 cifs_errorf(fc, "can not change username during remount\n");
718 return -EINVAL;
719 }
720 if (new_ctx->password &&
721 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
722 cifs_errorf(fc, "can not change password during remount\n");
723 return -EINVAL;
724 }
725 if (new_ctx->domainname &&
726 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
727 cifs_errorf(fc, "can not change domainname during remount\n");
728 return -EINVAL;
729 }
730 if (new_ctx->nodename &&
731 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
732 cifs_errorf(fc, "can not change nodename during remount\n");
733 return -EINVAL;
734 }
735 if (new_ctx->iocharset &&
736 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
737 cifs_errorf(fc, "can not change iocharset during remount\n");
738 return -EINVAL;
739 }
740
741 return 0;
742}
743
744#define STEAL_STRING(cifs_sb, ctx, field) \
745do { \
746 kfree(ctx->field); \
747 ctx->field = cifs_sb->ctx->field; \
748 cifs_sb->ctx->field = NULL; \
749} while (0)
750
751static int smb3_reconfigure(struct fs_context *fc)
752{
753 struct smb3_fs_context *ctx = smb3_fc2context(fc);
754 struct dentry *root = fc->root;
755 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
756 int rc;
757
758 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
759 if (rc)
760 return rc;
761
762
763
764
765
766
767 STEAL_STRING(cifs_sb, ctx, UNC);
768 STEAL_STRING(cifs_sb, ctx, source);
769 STEAL_STRING(cifs_sb, ctx, username);
770 STEAL_STRING(cifs_sb, ctx, password);
771 STEAL_STRING(cifs_sb, ctx, domainname);
772 STEAL_STRING(cifs_sb, ctx, nodename);
773 STEAL_STRING(cifs_sb, ctx, iocharset);
774
775
776 if (ctx->rsize == 0)
777 ctx->rsize = cifs_sb->ctx->rsize;
778 if (ctx->wsize == 0)
779 ctx->wsize = cifs_sb->ctx->wsize;
780
781
782 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
783 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
784 smb3_update_mnt_flags(cifs_sb);
785#ifdef CONFIG_CIFS_DFS_UPCALL
786 if (!rc)
787 rc = dfs_cache_remount_fs(cifs_sb);
788#endif
789
790 return rc;
791}
792
793static int smb3_fs_context_parse_param(struct fs_context *fc,
794 struct fs_parameter *param)
795{
796 struct fs_parse_result result;
797 struct smb3_fs_context *ctx = smb3_fc2context(fc);
798 int i, opt;
799 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
800 bool skip_parsing = false;
801 kuid_t uid;
802 kgid_t gid;
803
804 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
805
806
807
808
809
810 if (param->type == fs_value_is_string && param->string[0] == 0) {
811 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
812 skip_parsing = true;
813 opt = Opt_pass;
814 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
815 skip_parsing = true;
816 opt = Opt_user;
817 }
818 }
819
820 if (!skip_parsing) {
821 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
822 if (opt < 0)
823 return ctx->sloppy ? 1 : opt;
824 }
825
826 switch (opt) {
827 case Opt_compress:
828 ctx->compression = UNKNOWN_TYPE;
829 cifs_dbg(VFS,
830 "SMB3 compression support is experimental\n");
831 break;
832 case Opt_nodfs:
833 ctx->nodfs = 1;
834 break;
835 case Opt_hard:
836 if (result.negated)
837 ctx->retry = 0;
838 else
839 ctx->retry = 1;
840 break;
841 case Opt_soft:
842 if (result.negated)
843 ctx->retry = 1;
844 else
845 ctx->retry = 0;
846 break;
847 case Opt_mapposix:
848 if (result.negated)
849 ctx->remap = false;
850 else {
851 ctx->remap = true;
852 ctx->sfu_remap = false;
853 }
854 break;
855 case Opt_user_xattr:
856 if (result.negated)
857 ctx->no_xattr = 1;
858 else
859 ctx->no_xattr = 0;
860 break;
861 case Opt_forceuid:
862 if (result.negated)
863 ctx->override_uid = 0;
864 else
865 ctx->override_uid = 1;
866 break;
867 case Opt_forcegid:
868 if (result.negated)
869 ctx->override_gid = 0;
870 else
871 ctx->override_gid = 1;
872 break;
873 case Opt_perm:
874 if (result.negated)
875 ctx->noperm = 1;
876 else
877 ctx->noperm = 0;
878 break;
879 case Opt_dynperm:
880 if (result.negated)
881 ctx->dynperm = 0;
882 else
883 ctx->dynperm = 1;
884 break;
885 case Opt_sfu:
886 if (result.negated)
887 ctx->sfu_emul = 0;
888 else
889 ctx->sfu_emul = 1;
890 break;
891 case Opt_noblocksend:
892 ctx->noblocksnd = 1;
893 break;
894 case Opt_noautotune:
895 ctx->noautotune = 1;
896 break;
897 case Opt_nolease:
898 ctx->no_lease = 1;
899 break;
900 case Opt_nodelete:
901 ctx->nodelete = 1;
902 break;
903 case Opt_multichannel:
904 if (result.negated) {
905 ctx->multichannel = false;
906 ctx->max_channels = 1;
907 } else {
908 ctx->multichannel = true;
909
910 if (ctx->max_channels < 2)
911 ctx->max_channels = 2;
912 }
913 break;
914 case Opt_uid:
915 uid = make_kuid(current_user_ns(), result.uint_32);
916 if (!uid_valid(uid))
917 goto cifs_parse_mount_err;
918 ctx->linux_uid = uid;
919 ctx->uid_specified = true;
920 break;
921 case Opt_cruid:
922 uid = make_kuid(current_user_ns(), result.uint_32);
923 if (!uid_valid(uid))
924 goto cifs_parse_mount_err;
925 ctx->cred_uid = uid;
926 ctx->cruid_specified = true;
927 break;
928 case Opt_backupuid:
929 uid = make_kuid(current_user_ns(), result.uint_32);
930 if (!uid_valid(uid))
931 goto cifs_parse_mount_err;
932 ctx->backupuid = uid;
933 ctx->backupuid_specified = true;
934 break;
935 case Opt_backupgid:
936 gid = make_kgid(current_user_ns(), result.uint_32);
937 if (!gid_valid(gid))
938 goto cifs_parse_mount_err;
939 ctx->backupgid = gid;
940 ctx->backupgid_specified = true;
941 break;
942 case Opt_gid:
943 gid = make_kgid(current_user_ns(), result.uint_32);
944 if (!gid_valid(gid))
945 goto cifs_parse_mount_err;
946 ctx->linux_gid = gid;
947 ctx->gid_specified = true;
948 break;
949 case Opt_port:
950 ctx->port = result.uint_32;
951 break;
952 case Opt_file_mode:
953 ctx->file_mode = result.uint_32;
954 break;
955 case Opt_dirmode:
956 ctx->dir_mode = result.uint_32;
957 break;
958 case Opt_min_enc_offload:
959 ctx->min_offload = result.uint_32;
960 break;
961 case Opt_blocksize:
962
963
964
965
966
967
968 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
969 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
970 cifs_errorf(fc, "%s: Invalid blocksize\n",
971 __func__);
972 goto cifs_parse_mount_err;
973 }
974 ctx->bsize = result.uint_32;
975 ctx->got_bsize = true;
976 break;
977 case Opt_rasize:
978
979
980
981
982
983
984
985
986
987
988
989 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
990 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
991 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
992 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
993 goto cifs_parse_mount_err;
994 }
995 ctx->rasize = result.uint_32;
996 break;
997 case Opt_rsize:
998 ctx->rsize = result.uint_32;
999 ctx->got_rsize = true;
1000 break;
1001 case Opt_wsize:
1002 ctx->wsize = result.uint_32;
1003 ctx->got_wsize = true;
1004 break;
1005 case Opt_acregmax:
1006 ctx->acregmax = HZ * result.uint_32;
1007 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1008 cifs_errorf(fc, "acregmax too large\n");
1009 goto cifs_parse_mount_err;
1010 }
1011 break;
1012 case Opt_acdirmax:
1013 ctx->acdirmax = HZ * result.uint_32;
1014 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1015 cifs_errorf(fc, "acdirmax too large\n");
1016 goto cifs_parse_mount_err;
1017 }
1018 break;
1019 case Opt_actimeo:
1020 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1021 cifs_errorf(fc, "timeout too large\n");
1022 goto cifs_parse_mount_err;
1023 }
1024 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1025 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1026 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1027 break;
1028 }
1029 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1030 break;
1031 case Opt_echo_interval:
1032 ctx->echo_interval = result.uint_32;
1033 break;
1034 case Opt_snapshot:
1035 ctx->snapshot_time = result.uint_32;
1036 break;
1037 case Opt_max_credits:
1038 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1039 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1040 __func__);
1041 goto cifs_parse_mount_err;
1042 }
1043 ctx->max_credits = result.uint_32;
1044 break;
1045 case Opt_max_channels:
1046 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1047 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1048 __func__, CIFS_MAX_CHANNELS);
1049 goto cifs_parse_mount_err;
1050 }
1051 ctx->max_channels = result.uint_32;
1052
1053 if (result.uint_32 > 1)
1054 ctx->multichannel = true;
1055 break;
1056 case Opt_handletimeout:
1057 ctx->handle_timeout = result.uint_32;
1058 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1059 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1060 goto cifs_parse_mount_err;
1061 }
1062 break;
1063 case Opt_source:
1064 kfree(ctx->UNC);
1065 ctx->UNC = NULL;
1066 switch (smb3_parse_devname(param->string, ctx)) {
1067 case 0:
1068 break;
1069 case -ENOMEM:
1070 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1071 goto cifs_parse_mount_err;
1072 case -EINVAL:
1073 cifs_errorf(fc, "Malformed UNC in devname\n");
1074 goto cifs_parse_mount_err;
1075 default:
1076 cifs_errorf(fc, "Unknown error parsing devname\n");
1077 goto cifs_parse_mount_err;
1078 }
1079 ctx->source = kstrdup(param->string, GFP_KERNEL);
1080 if (ctx->source == NULL) {
1081 cifs_errorf(fc, "OOM when copying UNC string\n");
1082 goto cifs_parse_mount_err;
1083 }
1084 fc->source = kstrdup(param->string, GFP_KERNEL);
1085 if (fc->source == NULL) {
1086 cifs_errorf(fc, "OOM when copying UNC string\n");
1087 goto cifs_parse_mount_err;
1088 }
1089 break;
1090 case Opt_user:
1091 kfree(ctx->username);
1092 ctx->username = NULL;
1093 if (strlen(param->string) == 0) {
1094
1095 ctx->nullauth = 1;
1096 break;
1097 }
1098
1099 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1100 CIFS_MAX_USERNAME_LEN) {
1101 pr_warn("username too long\n");
1102 goto cifs_parse_mount_err;
1103 }
1104 ctx->username = kstrdup(param->string, GFP_KERNEL);
1105 if (ctx->username == NULL) {
1106 cifs_errorf(fc, "OOM when copying username string\n");
1107 goto cifs_parse_mount_err;
1108 }
1109 break;
1110 case Opt_pass:
1111 kfree(ctx->password);
1112 ctx->password = NULL;
1113 if (strlen(param->string) == 0)
1114 break;
1115
1116 ctx->password = kstrdup(param->string, GFP_KERNEL);
1117 if (ctx->password == NULL) {
1118 cifs_errorf(fc, "OOM when copying password string\n");
1119 goto cifs_parse_mount_err;
1120 }
1121 break;
1122 case Opt_ip:
1123 if (strlen(param->string) == 0) {
1124 ctx->got_ip = false;
1125 break;
1126 }
1127 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1128 param->string,
1129 strlen(param->string))) {
1130 pr_err("bad ip= option (%s)\n", param->string);
1131 goto cifs_parse_mount_err;
1132 }
1133 ctx->got_ip = true;
1134 break;
1135 case Opt_domain:
1136 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1137 == CIFS_MAX_DOMAINNAME_LEN) {
1138 pr_warn("domain name too long\n");
1139 goto cifs_parse_mount_err;
1140 }
1141
1142 kfree(ctx->domainname);
1143 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1144 if (ctx->domainname == NULL) {
1145 cifs_errorf(fc, "OOM when copying domainname string\n");
1146 goto cifs_parse_mount_err;
1147 }
1148 cifs_dbg(FYI, "Domain name set\n");
1149 break;
1150 case Opt_srcaddr:
1151 if (!cifs_convert_address(
1152 (struct sockaddr *)&ctx->srcaddr,
1153 param->string, strlen(param->string))) {
1154 pr_warn("Could not parse srcaddr: %s\n",
1155 param->string);
1156 goto cifs_parse_mount_err;
1157 }
1158 break;
1159 case Opt_iocharset:
1160 if (strnlen(param->string, 1024) >= 65) {
1161 pr_warn("iocharset name too long\n");
1162 goto cifs_parse_mount_err;
1163 }
1164
1165 if (strncasecmp(param->string, "default", 7) != 0) {
1166 kfree(ctx->iocharset);
1167 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1168 if (ctx->iocharset == NULL) {
1169 cifs_errorf(fc, "OOM when copying iocharset string\n");
1170 goto cifs_parse_mount_err;
1171 }
1172 }
1173
1174
1175
1176 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1177 break;
1178 case Opt_netbiosname:
1179 memset(ctx->source_rfc1001_name, 0x20,
1180 RFC1001_NAME_LEN);
1181
1182
1183
1184
1185
1186 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1187
1188 if (param->string[i] == 0)
1189 break;
1190 ctx->source_rfc1001_name[i] = param->string[i];
1191 }
1192
1193
1194
1195 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1196 pr_warn("netbiosname longer than 15 truncated\n");
1197 break;
1198 case Opt_servern:
1199
1200 memset(ctx->target_rfc1001_name, 0x20,
1201 RFC1001_NAME_LEN_WITH_NULL);
1202
1203
1204
1205
1206
1207
1208 for (i = 0; i < 15; i++) {
1209 if (param->string[i] == 0)
1210 break;
1211 ctx->target_rfc1001_name[i] = param->string[i];
1212 }
1213
1214
1215 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1216 pr_warn("server netbiosname longer than 15 truncated\n");
1217 break;
1218 case Opt_ver:
1219
1220
1221 if (strncasecmp(param->string, "1", 1) == 0) {
1222 if (strlen(param->string) > 1) {
1223 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1224 param->string);
1225 goto cifs_parse_mount_err;
1226 }
1227
1228 break;
1229 }
1230
1231 pr_warn("Invalid mount helper version specified\n");
1232 goto cifs_parse_mount_err;
1233 case Opt_vers:
1234
1235 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1236 goto cifs_parse_mount_err;
1237 ctx->got_version = true;
1238 break;
1239 case Opt_sec:
1240 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1241 goto cifs_parse_mount_err;
1242 break;
1243 case Opt_cache:
1244 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1245 goto cifs_parse_mount_err;
1246 break;
1247 case Opt_witness:
1248#ifndef CONFIG_CIFS_SWN_UPCALL
1249 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1250 goto cifs_parse_mount_err;
1251#endif
1252 ctx->witness = true;
1253 pr_warn_once("Witness protocol support is experimental\n");
1254 break;
1255 case Opt_rootfs:
1256#ifndef CONFIG_CIFS_ROOT
1257 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1258 goto cifs_parse_mount_err;
1259#endif
1260 ctx->rootfs = true;
1261 break;
1262 case Opt_posixpaths:
1263 if (result.negated)
1264 ctx->posix_paths = 0;
1265 else
1266 ctx->posix_paths = 1;
1267 break;
1268 case Opt_unix:
1269 if (result.negated)
1270 ctx->linux_ext = 0;
1271 else
1272 ctx->no_linux_ext = 1;
1273 break;
1274 case Opt_nocase:
1275 ctx->nocase = 1;
1276 break;
1277 case Opt_brl:
1278 if (result.negated) {
1279
1280
1281
1282
1283
1284 if (ctx->file_mode ==
1285 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1286 ctx->file_mode = S_IALLUGO;
1287 ctx->nobrl = 1;
1288 } else
1289 ctx->nobrl = 0;
1290 break;
1291 case Opt_handlecache:
1292 if (result.negated)
1293 ctx->nohandlecache = 1;
1294 else
1295 ctx->nohandlecache = 0;
1296 break;
1297 case Opt_forcemandatorylock:
1298 ctx->mand_lock = 1;
1299 break;
1300 case Opt_setuids:
1301 ctx->setuids = result.negated;
1302 break;
1303 case Opt_intr:
1304 ctx->intr = !result.negated;
1305 break;
1306 case Opt_setuidfromacl:
1307 ctx->setuidfromacl = 1;
1308 break;
1309 case Opt_strictsync:
1310 ctx->nostrictsync = result.negated;
1311 break;
1312 case Opt_serverino:
1313 ctx->server_ino = !result.negated;
1314 break;
1315 case Opt_rwpidforward:
1316 ctx->rwpidforward = 1;
1317 break;
1318 case Opt_modesid:
1319 ctx->mode_ace = 1;
1320 break;
1321 case Opt_cifsacl:
1322 ctx->cifs_acl = !result.negated;
1323 break;
1324 case Opt_acl:
1325 ctx->no_psx_acl = result.negated;
1326 break;
1327 case Opt_locallease:
1328 ctx->local_lease = 1;
1329 break;
1330 case Opt_sign:
1331 ctx->sign = true;
1332 break;
1333 case Opt_ignore_signature:
1334 ctx->sign = true;
1335 ctx->ignore_signature = true;
1336 break;
1337 case Opt_seal:
1338
1339
1340
1341
1342
1343 ctx->seal = 1;
1344 break;
1345 case Opt_noac:
1346 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1347 break;
1348 case Opt_fsc:
1349#ifndef CONFIG_CIFS_FSCACHE
1350 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1351 goto cifs_parse_mount_err;
1352#endif
1353 ctx->fsc = true;
1354 break;
1355 case Opt_mfsymlinks:
1356 ctx->mfsymlinks = true;
1357 break;
1358 case Opt_multiuser:
1359 ctx->multiuser = true;
1360 break;
1361 case Opt_sloppy:
1362 ctx->sloppy = true;
1363 break;
1364 case Opt_nosharesock:
1365 ctx->nosharesock = true;
1366 break;
1367 case Opt_persistent:
1368 if (result.negated) {
1369 ctx->nopersistent = true;
1370 if (ctx->persistent) {
1371 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1372 goto cifs_parse_mount_err;
1373 }
1374 } else {
1375 ctx->persistent = true;
1376 if ((ctx->nopersistent) || (ctx->resilient)) {
1377 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1378 goto cifs_parse_mount_err;
1379 }
1380 }
1381 break;
1382 case Opt_resilient:
1383 if (result.negated) {
1384 ctx->resilient = false;
1385 } else {
1386 ctx->resilient = true;
1387 if (ctx->persistent) {
1388 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1389 goto cifs_parse_mount_err;
1390 }
1391 }
1392 break;
1393 case Opt_domainauto:
1394 ctx->domainauto = true;
1395 break;
1396 case Opt_rdma:
1397 ctx->rdma = true;
1398 break;
1399 }
1400
1401
1402 return 0;
1403
1404 cifs_parse_mount_err:
1405 return -EINVAL;
1406}
1407
1408int smb3_init_fs_context(struct fs_context *fc)
1409{
1410 struct smb3_fs_context *ctx;
1411 char *nodename = utsname()->nodename;
1412 int i;
1413
1414 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1415 if (unlikely(!ctx))
1416 return -ENOMEM;
1417
1418
1419
1420
1421
1422
1423 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1424 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1425 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1426
1427 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1428
1429
1430
1431
1432 ctx->target_rfc1001_name[0] = 0;
1433 ctx->cred_uid = current_uid();
1434 ctx->linux_uid = current_uid();
1435 ctx->linux_gid = current_gid();
1436
1437 ctx->bsize = CIFS_DEFAULT_IOSIZE;
1438 ctx->rasize = 0;
1439
1440
1441
1442
1443
1444
1445
1446 ctx->remap = true;
1447
1448
1449 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1450
1451
1452
1453 ctx->posix_paths = 1;
1454
1455 ctx->server_ino = 1;
1456
1457
1458 ctx->strict_io = true;
1459
1460 ctx->acregmax = CIFS_DEF_ACTIMEO;
1461 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1462
1463
1464 ctx->handle_timeout = 0;
1465
1466
1467 ctx->ops = &smb30_operations;
1468 ctx->vals = &smbdefault_values;
1469
1470 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1471
1472
1473 ctx->multichannel = false;
1474 ctx->max_channels = 1;
1475
1476 ctx->backupuid_specified = false;
1477 ctx->backupgid_specified = false;
1478
1479
1480
1481
1482
1483
1484
1485
1486 fc->fs_private = ctx;
1487 fc->ops = &smb3_fs_context_ops;
1488 return 0;
1489}
1490
1491void
1492smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1493{
1494 if (ctx == NULL)
1495 return;
1496
1497
1498
1499
1500 kfree(ctx->mount_options);
1501 ctx->mount_options = NULL;
1502 kfree(ctx->username);
1503 ctx->username = NULL;
1504 kfree_sensitive(ctx->password);
1505 ctx->password = NULL;
1506 kfree(ctx->UNC);
1507 ctx->UNC = NULL;
1508 kfree(ctx->source);
1509 ctx->source = NULL;
1510 kfree(ctx->domainname);
1511 ctx->domainname = NULL;
1512 kfree(ctx->nodename);
1513 ctx->nodename = NULL;
1514 kfree(ctx->iocharset);
1515 ctx->iocharset = NULL;
1516 kfree(ctx->prepath);
1517 ctx->prepath = NULL;
1518}
1519
1520void
1521smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1522{
1523 if (!ctx)
1524 return;
1525 smb3_cleanup_fs_context_contents(ctx);
1526 kfree(ctx);
1527}
1528
1529void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1530{
1531 struct smb3_fs_context *ctx = cifs_sb->ctx;
1532
1533 if (ctx->nodfs)
1534 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1535 else
1536 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1537
1538 if (ctx->noperm)
1539 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1540 else
1541 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1542
1543 if (ctx->setuids)
1544 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1545 else
1546 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1547
1548 if (ctx->setuidfromacl)
1549 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1550 else
1551 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1552
1553 if (ctx->server_ino)
1554 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1555 else
1556 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1557
1558 if (ctx->remap)
1559 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1560 else
1561 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1562
1563 if (ctx->sfu_remap)
1564 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1565 else
1566 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1567
1568 if (ctx->no_xattr)
1569 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1570 else
1571 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1572
1573 if (ctx->sfu_emul)
1574 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1575 else
1576 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1577
1578 if (ctx->nobrl)
1579 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1580 else
1581 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1582
1583 if (ctx->nohandlecache)
1584 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1585 else
1586 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1587
1588 if (ctx->nostrictsync)
1589 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1590 else
1591 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1592
1593 if (ctx->mand_lock)
1594 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1595 else
1596 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1597
1598 if (ctx->rwpidforward)
1599 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1600 else
1601 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1602
1603 if (ctx->mode_ace)
1604 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1605 else
1606 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1607
1608 if (ctx->cifs_acl)
1609 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1610 else
1611 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1612
1613 if (ctx->backupuid_specified)
1614 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1615 else
1616 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1617
1618 if (ctx->backupgid_specified)
1619 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1620 else
1621 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1622
1623 if (ctx->override_uid)
1624 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1625 else
1626 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1627
1628 if (ctx->override_gid)
1629 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1630 else
1631 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1632
1633 if (ctx->dynperm)
1634 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1635 else
1636 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1637
1638 if (ctx->fsc)
1639 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1640 else
1641 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1642
1643 if (ctx->multiuser)
1644 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1645 CIFS_MOUNT_NO_PERM);
1646 else
1647 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1648
1649
1650 if (ctx->strict_io)
1651 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1652 else
1653 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1654
1655 if (ctx->direct_io)
1656 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1657 else
1658 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1659
1660 if (ctx->mfsymlinks)
1661 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1662 else
1663 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1664 if (ctx->mfsymlinks) {
1665 if (ctx->sfu_emul) {
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1678 }
1679 }
1680 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1681
1682 return;
1683}
1684
