1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2020, Microsoft Corporation.
5 * Author(s): Steve French <stfrench@microsoft.com>
6 * David Howells <dhowells@redhat.com>
10 #include <linux/module.h>
11 #include <linux/nsproxy.h>
12 #include <linux/slab.h>
13 #include <linux/magic.h>
14 #include <linux/security.h>
15 #include <net/net_namespace.h>
18 #include <linux/ctype.h>
19 #include <linux/fs_context.h>
20 #include <linux/fs_parser.h>
22 #include <linux/mount.h>
23 #include <linux/parser.h>
24 #include <linux/utsname.h>
28 #include "cifsproto.h"
29 #include "cifs_unicode.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
34 #include "rfc1002pdu.h"
35 #include "fs_context.h"
37 static const match_table_t cifs_smb_version_tokens = {
38 { Smb_1, SMB1_VERSION_STRING },
39 { Smb_20, SMB20_VERSION_STRING},
40 { Smb_21, SMB21_VERSION_STRING },
41 { Smb_30, SMB30_VERSION_STRING },
42 { Smb_302, SMB302_VERSION_STRING },
43 { Smb_302, ALT_SMB302_VERSION_STRING },
44 { Smb_311, SMB311_VERSION_STRING },
45 { Smb_311, ALT_SMB311_VERSION_STRING },
46 { Smb_3any, SMB3ANY_VERSION_STRING },
47 { Smb_default, SMBDEFAULT_VERSION_STRING },
48 { Smb_version_err, NULL }
51 static const match_table_t cifs_secflavor_tokens = {
52 { Opt_sec_krb5, "krb5" },
53 { Opt_sec_krb5i, "krb5i" },
54 { Opt_sec_krb5p, "krb5p" },
55 { Opt_sec_ntlmsspi, "ntlmsspi" },
56 { Opt_sec_ntlmssp, "ntlmssp" },
58 { Opt_sec_ntlmi, "ntlmi" },
59 { Opt_sec_ntlmv2, "nontlm" },
60 { Opt_sec_ntlmv2, "ntlmv2" },
61 { Opt_sec_ntlmv2i, "ntlmv2i" },
62 { Opt_sec_lanman, "lanman" },
63 { Opt_sec_none, "none" },
68 const struct fs_parameter_spec smb3_fs_parameters[] = {
69 /* Mount options that take no arguments */
70 fsparam_flag_no("user_xattr", Opt_user_xattr),
71 fsparam_flag_no("forceuid", Opt_forceuid),
72 fsparam_flag_no("multichannel", Opt_multichannel),
73 fsparam_flag_no("forcegid", Opt_forcegid),
74 fsparam_flag("noblocksend", Opt_noblocksend),
75 fsparam_flag("noautotune", Opt_noautotune),
76 fsparam_flag("nolease", Opt_nolease),
77 fsparam_flag_no("hard", Opt_hard),
78 fsparam_flag_no("soft", Opt_soft),
79 fsparam_flag_no("perm", Opt_perm),
80 fsparam_flag("nodelete", Opt_nodelete),
81 fsparam_flag_no("mapposix", Opt_mapposix),
82 fsparam_flag("mapchars", Opt_mapchars),
83 fsparam_flag("nomapchars", Opt_nomapchars),
84 fsparam_flag_no("sfu", Opt_sfu),
85 fsparam_flag("nodfs", Opt_nodfs),
86 fsparam_flag_no("posixpaths", Opt_posixpaths),
87 fsparam_flag_no("unix", Opt_unix),
88 fsparam_flag_no("linux", Opt_unix),
89 fsparam_flag_no("posix", Opt_unix),
90 fsparam_flag("nocase", Opt_nocase),
91 fsparam_flag("ignorecase", Opt_nocase),
92 fsparam_flag_no("brl", Opt_brl),
93 fsparam_flag_no("handlecache", Opt_handlecache),
94 fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
95 fsparam_flag("forcemand", Opt_forcemandatorylock),
96 fsparam_flag("setuidfromacl", Opt_setuidfromacl),
97 fsparam_flag("idsfromsid", Opt_setuidfromacl),
98 fsparam_flag_no("setuids", Opt_setuids),
99 fsparam_flag_no("dynperm", Opt_dynperm),
100 fsparam_flag_no("intr", Opt_intr),
101 fsparam_flag_no("strictsync", Opt_strictsync),
102 fsparam_flag_no("serverino", Opt_serverino),
103 fsparam_flag("rwpidforward", Opt_rwpidforward),
104 fsparam_flag("cifsacl", Opt_cifsacl),
105 fsparam_flag_no("acl", Opt_acl),
106 fsparam_flag("locallease", Opt_locallease),
107 fsparam_flag("sign", Opt_sign),
108 fsparam_flag("ignore_signature", Opt_ignore_signature),
109 fsparam_flag("signloosely", Opt_ignore_signature),
110 fsparam_flag("seal", Opt_seal),
111 fsparam_flag("noac", Opt_noac),
112 fsparam_flag("fsc", Opt_fsc),
113 fsparam_flag("mfsymlinks", Opt_mfsymlinks),
114 fsparam_flag("multiuser", Opt_multiuser),
115 fsparam_flag("sloppy", Opt_sloppy),
116 fsparam_flag("nosharesock", Opt_nosharesock),
117 fsparam_flag_no("persistenthandles", Opt_persistent),
118 fsparam_flag_no("resilienthandles", Opt_resilient),
119 fsparam_flag("domainauto", Opt_domainauto),
120 fsparam_flag("rdma", Opt_rdma),
121 fsparam_flag("modesid", Opt_modesid),
122 fsparam_flag("modefromsid", Opt_modesid),
123 fsparam_flag("rootfs", Opt_rootfs),
124 fsparam_flag("compress", Opt_compress),
125 fsparam_flag("witness", Opt_witness),
127 /* Mount options which take numeric value */
128 fsparam_u32("backupuid", Opt_backupuid),
129 fsparam_u32("backupgid", Opt_backupgid),
130 fsparam_u32("uid", Opt_uid),
131 fsparam_u32("cruid", Opt_cruid),
132 fsparam_u32("gid", Opt_gid),
133 fsparam_u32("file_mode", Opt_file_mode),
134 fsparam_u32("dirmode", Opt_dirmode),
135 fsparam_u32("dir_mode", Opt_dirmode),
136 fsparam_u32("port", Opt_port),
137 fsparam_u32("min_enc_offload", Opt_min_enc_offload),
138 fsparam_u32("esize", Opt_min_enc_offload),
139 fsparam_u32("bsize", Opt_blocksize),
140 fsparam_u32("rasize", Opt_rasize),
141 fsparam_u32("rsize", Opt_rsize),
142 fsparam_u32("wsize", Opt_wsize),
143 fsparam_u32("actimeo", Opt_actimeo),
144 fsparam_u32("acdirmax", Opt_acdirmax),
145 fsparam_u32("acregmax", Opt_acregmax),
146 fsparam_u32("echo_interval", Opt_echo_interval),
147 fsparam_u32("max_credits", Opt_max_credits),
148 fsparam_u32("handletimeout", Opt_handletimeout),
149 fsparam_u32("snapshot", Opt_snapshot),
150 fsparam_u32("max_channels", Opt_max_channels),
152 /* Mount options which take string value */
153 fsparam_string("source", Opt_source),
154 fsparam_string("user", Opt_user),
155 fsparam_string("username", Opt_user),
156 fsparam_string("pass", Opt_pass),
157 fsparam_string("password", Opt_pass),
158 fsparam_string("ip", Opt_ip),
159 fsparam_string("addr", Opt_ip),
160 fsparam_string("domain", Opt_domain),
161 fsparam_string("dom", Opt_domain),
162 fsparam_string("srcaddr", Opt_srcaddr),
163 fsparam_string("iocharset", Opt_iocharset),
164 fsparam_string("netbiosname", Opt_netbiosname),
165 fsparam_string("servern", Opt_servern),
166 fsparam_string("ver", Opt_ver),
167 fsparam_string("vers", Opt_vers),
168 fsparam_string("sec", Opt_sec),
169 fsparam_string("cache", Opt_cache),
171 /* Arguments that should be ignored */
172 fsparam_flag("guest", Opt_ignore),
173 fsparam_flag("noatime", Opt_ignore),
174 fsparam_flag("relatime", Opt_ignore),
175 fsparam_flag("_netdev", Opt_ignore),
176 fsparam_flag_no("suid", Opt_ignore),
177 fsparam_flag_no("exec", Opt_ignore),
178 fsparam_flag_no("dev", Opt_ignore),
179 fsparam_flag_no("mand", Opt_ignore),
180 fsparam_flag_no("auto", Opt_ignore),
181 fsparam_string("cred", Opt_ignore),
182 fsparam_string("credentials", Opt_ignore),
184 * UNC and prefixpath is now extracted from Opt_source
185 * in the new mount API so we can just ignore them going forward.
187 fsparam_string("unc", Opt_ignore),
188 fsparam_string("prefixpath", Opt_ignore),
193 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
196 substring_t args[MAX_OPT_ARGS];
199 * With mount options, the last one should win. Reset any existing
200 * settings back to default.
202 ctx->sectype = Unspecified;
205 switch (match_token(value, cifs_secflavor_tokens, args)) {
207 cifs_errorf(fc, "sec=krb5p is not supported!\n");
213 ctx->sectype = Kerberos;
215 case Opt_sec_ntlmsspi:
218 case Opt_sec_ntlmssp:
219 ctx->sectype = RawNTLMSSP;
227 case Opt_sec_ntlmv2i:
231 ctx->sectype = NTLMv2;
233 #ifdef CONFIG_CIFS_WEAK_PW_HASH
235 ctx->sectype = LANMAN;
242 cifs_errorf(fc, "bad security option: %s\n", value);
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 }
259 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
261 substring_t args[MAX_OPT_ARGS];
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;
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;
277 ctx->direct_io = true;
278 ctx->strict_io = false;
279 ctx->cache_ro = false;
280 ctx->cache_rw = false;
283 ctx->direct_io = false;
284 ctx->strict_io = false;
285 ctx->cache_ro = true;
286 ctx->cache_rw = false;
289 ctx->direct_io = false;
290 ctx->strict_io = false;
291 ctx->cache_ro = false;
292 ctx->cache_rw = true;
295 cifs_errorf(fc, "bad cache= option: %s\n", value);
301 #define DUP_CTX_STR(field) \
304 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
305 if (new_ctx->field == NULL) { \
306 smb3_cleanup_fs_context_contents(new_ctx); \
313 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
315 memcpy(new_ctx, ctx, sizeof(*ctx));
316 new_ctx->prepath = NULL;
317 new_ctx->mount_options = NULL;
318 new_ctx->nodename = NULL;
319 new_ctx->username = NULL;
320 new_ctx->password = NULL;
321 new_ctx->domainname = NULL;
323 new_ctx->source = NULL;
324 new_ctx->iocharset = NULL;
327 * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
329 DUP_CTX_STR(prepath);
330 DUP_CTX_STR(mount_options);
331 DUP_CTX_STR(username);
332 DUP_CTX_STR(password);
335 DUP_CTX_STR(domainname);
336 DUP_CTX_STR(nodename);
337 DUP_CTX_STR(iocharset);
343 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
345 substring_t args[MAX_OPT_ARGS];
347 switch (match_token(value, cifs_smb_version_tokens, args)) {
348 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
350 if (disable_legacy_dialects) {
351 cifs_errorf(fc, "mount with legacy dialect disabled\n");
355 cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
358 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
359 ctx->ops = &smb1_operations;
360 ctx->vals = &smb1_values;
363 if (disable_legacy_dialects) {
364 cifs_errorf(fc, "mount with legacy dialect disabled\n");
368 cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
371 ctx->ops = &smb20_operations;
372 ctx->vals = &smb20_values;
376 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
379 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
381 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
383 ctx->ops = &smb21_operations;
384 ctx->vals = &smb21_values;
387 ctx->ops = &smb30_operations;
388 ctx->vals = &smb30_values;
391 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
392 ctx->vals = &smb302_values;
395 ctx->ops = &smb311_operations;
396 ctx->vals = &smb311_values;
399 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
400 ctx->vals = &smb3any_values;
403 ctx->ops = &smb30_operations;
404 ctx->vals = &smbdefault_values;
407 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
413 int smb3_parse_opt(const char *options, const char *key, char **val)
416 char *opts, *orig, *p;
418 orig = opts = kstrdup(options, GFP_KERNEL);
422 while ((p = strsep(&opts, ","))) {
427 if (strncasecmp(p, key, strlen(key)))
429 nval = strchr(p, '=');
434 *val = kstrdup(nval, GFP_KERNEL);
435 rc = !*val ? -ENOMEM : 0;
445 * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
446 * fields with the result. Returns 0 on success and an error otherwise
447 * (e.g. ENOMEM or EINVAL)
450 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
453 const char *delims = "/\\";
456 if (unlikely(!devname || !*devname)) {
457 cifs_dbg(VFS, "Device name not specified\n");
461 /* make sure we have a valid UNC double delimiter prefix */
462 len = strspn(devname, delims);
466 /* find delimiter between host and sharename */
467 pos = strpbrk(devname + 2, delims);
471 /* skip past delimiter */
474 /* now go until next delimiter or end of string */
475 len = strcspn(pos, delims);
477 /* move "pos" up to delimiter or NULL */
479 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
483 convert_delimiter(ctx->UNC, '\\');
485 /* skip any delimiter */
486 if (*pos == '/' || *pos == '\\')
489 /* If pos is NULL then no prepath */
493 ctx->prepath = kstrdup(pos, GFP_KERNEL);
500 static void smb3_fs_context_free(struct fs_context *fc);
501 static int smb3_fs_context_parse_param(struct fs_context *fc,
502 struct fs_parameter *param);
503 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
505 static int smb3_get_tree(struct fs_context *fc);
506 static int smb3_reconfigure(struct fs_context *fc);
508 static const struct fs_context_operations smb3_fs_context_ops = {
509 .free = smb3_fs_context_free,
510 .parse_param = smb3_fs_context_parse_param,
511 .parse_monolithic = smb3_fs_context_parse_monolithic,
512 .get_tree = smb3_get_tree,
513 .reconfigure = smb3_reconfigure,
517 * Parse a monolithic block of data from sys_mount().
518 * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
519 * @ctx: The superblock configuration to fill in.
520 * @data: The data to parse
522 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
523 * called from the ->monolithic_mount_data() fs_context operation.
525 * Returns 0 on success or the error returned by the ->parse_option() fs_context
526 * operation on failure.
528 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
531 struct smb3_fs_context *ctx = smb3_fc2context(fc);
532 char *options = data, *key;
538 ctx->mount_options = kstrdup(data, GFP_KERNEL);
539 if (ctx->mount_options == NULL)
542 ret = security_sb_eat_lsm_opts(options, &fc->security);
546 /* BB Need to add support for sep= here TBD */
547 while ((key = strsep(&options, ",")) != NULL) {
554 /* Check if following character is the deliminator If yes,
555 * we have encountered a double deliminator reset the NULL
556 * character to the deliminator
558 while (options && options[0] == ',') {
560 strcpy(key + len, options);
561 options = strchr(options, ',');
568 value = strchr(key, '=');
576 ret = vfs_parse_fs_string(fc, key, value, len);
585 * Validate the preparsed information in the config.
587 static int smb3_fs_context_validate(struct fs_context *fc)
589 struct smb3_fs_context *ctx = smb3_fc2context(fc);
591 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
592 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
597 /* Muliuser mounts require CONFIG_KEYS support */
598 if (ctx->multiuser) {
599 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
604 if (ctx->got_version == false)
605 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");
609 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
613 /* make sure UNC has a share name */
614 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
615 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
623 /* No ip= option specified? Try to get it from UNC */
624 /* Use the address part of the UNC. */
625 slash = strchr(&ctx->UNC[2], '\\');
626 len = slash - &ctx->UNC[2];
627 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
628 &ctx->UNC[2], len)) {
629 pr_err("Unable to determine destination address\n");
630 return -EHOSTUNREACH;
634 /* set the port that we got earlier */
635 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
637 if (ctx->override_uid && !ctx->uid_specified) {
638 ctx->override_uid = 0;
639 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
642 if (ctx->override_gid && !ctx->gid_specified) {
643 ctx->override_gid = 0;
644 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
650 static int smb3_get_tree_common(struct fs_context *fc)
652 struct smb3_fs_context *ctx = smb3_fc2context(fc);
656 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
658 return PTR_ERR(root);
666 * Create an SMB3 superblock from the parameters passed.
668 static int smb3_get_tree(struct fs_context *fc)
670 int err = smb3_fs_context_validate(fc);
674 return smb3_get_tree_common(fc);
677 static void smb3_fs_context_free(struct fs_context *fc)
679 struct smb3_fs_context *ctx = smb3_fc2context(fc);
681 smb3_cleanup_fs_context(ctx);
685 * Compare the old and new proposed context during reconfigure
686 * and check if the changes are compatible.
688 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
689 struct smb3_fs_context *new_ctx,
690 struct smb3_fs_context *old_ctx)
692 if (new_ctx->posix_paths != old_ctx->posix_paths) {
693 cifs_errorf(fc, "can not change posixpaths during remount\n");
696 if (new_ctx->sectype != old_ctx->sectype) {
697 cifs_errorf(fc, "can not change sec during remount\n");
700 if (new_ctx->multiuser != old_ctx->multiuser) {
701 cifs_errorf(fc, "can not change multiuser during remount\n");
705 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
706 cifs_errorf(fc, "can not change UNC during remount\n");
709 if (new_ctx->username &&
710 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
711 cifs_errorf(fc, "can not change username during remount\n");
714 if (new_ctx->password &&
715 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
716 cifs_errorf(fc, "can not change password during remount\n");
719 if (new_ctx->domainname &&
720 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
721 cifs_errorf(fc, "can not change domainname during remount\n");
724 if (new_ctx->nodename &&
725 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
726 cifs_errorf(fc, "can not change nodename during remount\n");
729 if (new_ctx->iocharset &&
730 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
731 cifs_errorf(fc, "can not change iocharset during remount\n");
738 #define STEAL_STRING(cifs_sb, ctx, field) \
741 ctx->field = cifs_sb->ctx->field; \
742 cifs_sb->ctx->field = NULL; \
745 static int smb3_reconfigure(struct fs_context *fc)
747 struct smb3_fs_context *ctx = smb3_fc2context(fc);
748 struct dentry *root = fc->root;
749 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
752 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
757 * We can not change UNC/username/password/domainname/nodename/iocharset
758 * during reconnect so ignore what we have in the new context and
759 * just use what we already have in cifs_sb->ctx.
761 STEAL_STRING(cifs_sb, ctx, UNC);
762 STEAL_STRING(cifs_sb, ctx, source);
763 STEAL_STRING(cifs_sb, ctx, username);
764 STEAL_STRING(cifs_sb, ctx, password);
765 STEAL_STRING(cifs_sb, ctx, domainname);
766 STEAL_STRING(cifs_sb, ctx, nodename);
767 STEAL_STRING(cifs_sb, ctx, iocharset);
769 /* if rsize or wsize not passed in on remount, use previous values */
771 ctx->rsize = cifs_sb->ctx->rsize;
773 ctx->wsize = cifs_sb->ctx->wsize;
776 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
777 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
778 smb3_update_mnt_flags(cifs_sb);
783 static int smb3_fs_context_parse_param(struct fs_context *fc,
784 struct fs_parameter *param)
786 struct fs_parse_result result;
787 struct smb3_fs_context *ctx = smb3_fc2context(fc);
789 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
790 bool skip_parsing = false;
792 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
795 * fs_parse can not handle string options with an empty value so
796 * we will need special handling of them.
798 if (param->type == fs_value_is_string && param->string[0] == 0) {
799 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
802 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
809 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
811 return ctx->sloppy ? 1 : opt;
816 ctx->compression = UNKNOWN_TYPE;
818 "SMB3 compression support is experimental\n");
840 ctx->sfu_remap = false; /* disable SFU mapping */
851 ctx->override_uid = 0;
853 ctx->override_uid = 1;
857 ctx->override_gid = 0;
859 ctx->override_gid = 1;
879 case Opt_noblocksend:
891 case Opt_multichannel:
892 if (result.negated) {
893 ctx->multichannel = false;
894 ctx->max_channels = 1;
896 ctx->multichannel = true;
897 /* if number of channels not specified, default to 2 */
898 if (ctx->max_channels < 2)
899 ctx->max_channels = 2;
903 ctx->linux_uid.val = result.uint_32;
904 ctx->uid_specified = true;
907 ctx->cred_uid.val = result.uint_32;
910 ctx->backupgid.val = result.uint_32;
911 ctx->backupgid_specified = true;
914 ctx->linux_gid.val = result.uint_32;
915 ctx->gid_specified = true;
918 ctx->port = result.uint_32;
921 ctx->file_mode = result.uint_32;
924 ctx->dir_mode = result.uint_32;
926 case Opt_min_enc_offload:
927 ctx->min_offload = result.uint_32;
931 * inode blocksize realistically should never need to be
932 * less than 16K or greater than 16M and default is 1MB.
933 * Note that small inode block sizes (e.g. 64K) can lead
934 * to very poor performance of common tools like cp and scp
936 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
937 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
938 cifs_errorf(fc, "%s: Invalid blocksize\n",
940 goto cifs_parse_mount_err;
942 ctx->bsize = result.uint_32;
943 ctx->got_bsize = true;
947 * readahead size realistically should never need to be
948 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
949 * (perhaps an exception should be considered in the
950 * for the case of a large number of channels
951 * when multichannel is negotiated) since that would lead
952 * to plenty of parallel I/O in flight to the server.
953 * Note that smaller read ahead sizes would
954 * hurt performance of common tools like cp and scp
955 * which often trigger sequential i/o with read ahead
957 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
958 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
959 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
960 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
961 goto cifs_parse_mount_err;
963 ctx->rasize = result.uint_32;
966 ctx->rsize = result.uint_32;
967 ctx->got_rsize = true;
970 ctx->wsize = result.uint_32;
971 ctx->got_wsize = true;
974 ctx->acregmax = HZ * result.uint_32;
975 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
976 cifs_errorf(fc, "acregmax too large\n");
977 goto cifs_parse_mount_err;
981 ctx->acdirmax = HZ * result.uint_32;
982 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
983 cifs_errorf(fc, "acdirmax too large\n");
984 goto cifs_parse_mount_err;
988 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
989 cifs_errorf(fc, "timeout too large\n");
990 goto cifs_parse_mount_err;
992 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
993 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
994 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
997 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
999 case Opt_echo_interval:
1000 ctx->echo_interval = result.uint_32;
1003 ctx->snapshot_time = result.uint_32;
1005 case Opt_max_credits:
1006 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1007 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1009 goto cifs_parse_mount_err;
1011 ctx->max_credits = result.uint_32;
1013 case Opt_max_channels:
1014 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1015 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1016 __func__, CIFS_MAX_CHANNELS);
1017 goto cifs_parse_mount_err;
1019 ctx->max_channels = result.uint_32;
1021 case Opt_handletimeout:
1022 ctx->handle_timeout = result.uint_32;
1023 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1024 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1025 goto cifs_parse_mount_err;
1031 switch (smb3_parse_devname(param->string, ctx)) {
1035 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1036 goto cifs_parse_mount_err;
1038 cifs_errorf(fc, "Malformed UNC in devname\n");
1039 goto cifs_parse_mount_err;
1041 cifs_errorf(fc, "Unknown error parsing devname\n");
1042 goto cifs_parse_mount_err;
1044 ctx->source = kstrdup(param->string, GFP_KERNEL);
1045 if (ctx->source == NULL) {
1046 cifs_errorf(fc, "OOM when copying UNC string\n");
1047 goto cifs_parse_mount_err;
1049 fc->source = kstrdup(param->string, GFP_KERNEL);
1050 if (fc->source == NULL) {
1051 cifs_errorf(fc, "OOM when copying UNC string\n");
1052 goto cifs_parse_mount_err;
1056 kfree(ctx->username);
1057 ctx->username = NULL;
1058 if (strlen(param->string) == 0) {
1059 /* null user, ie. anonymous authentication */
1064 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1065 CIFS_MAX_USERNAME_LEN) {
1066 pr_warn("username too long\n");
1067 goto cifs_parse_mount_err;
1069 ctx->username = kstrdup(param->string, GFP_KERNEL);
1070 if (ctx->username == NULL) {
1071 cifs_errorf(fc, "OOM when copying username string\n");
1072 goto cifs_parse_mount_err;
1076 kfree(ctx->password);
1077 ctx->password = NULL;
1078 if (strlen(param->string) == 0)
1081 ctx->password = kstrdup(param->string, GFP_KERNEL);
1082 if (ctx->password == NULL) {
1083 cifs_errorf(fc, "OOM when copying password string\n");
1084 goto cifs_parse_mount_err;
1088 if (strlen(param->string) == 0) {
1089 ctx->got_ip = false;
1092 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1094 strlen(param->string))) {
1095 pr_err("bad ip= option (%s)\n", param->string);
1096 goto cifs_parse_mount_err;
1101 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1102 == CIFS_MAX_DOMAINNAME_LEN) {
1103 pr_warn("domain name too long\n");
1104 goto cifs_parse_mount_err;
1107 kfree(ctx->domainname);
1108 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1109 if (ctx->domainname == NULL) {
1110 cifs_errorf(fc, "OOM when copying domainname string\n");
1111 goto cifs_parse_mount_err;
1113 cifs_dbg(FYI, "Domain name set\n");
1116 if (!cifs_convert_address(
1117 (struct sockaddr *)&ctx->srcaddr,
1118 param->string, strlen(param->string))) {
1119 pr_warn("Could not parse srcaddr: %s\n",
1121 goto cifs_parse_mount_err;
1125 if (strnlen(param->string, 1024) >= 65) {
1126 pr_warn("iocharset name too long\n");
1127 goto cifs_parse_mount_err;
1130 if (strncasecmp(param->string, "default", 7) != 0) {
1131 kfree(ctx->iocharset);
1132 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1133 if (ctx->iocharset == NULL) {
1134 cifs_errorf(fc, "OOM when copying iocharset string\n");
1135 goto cifs_parse_mount_err;
1138 /* if iocharset not set then load_nls_default
1141 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1143 case Opt_netbiosname:
1144 memset(ctx->source_rfc1001_name, 0x20,
1147 * FIXME: are there cases in which a comma can
1148 * be valid in workstation netbios name (and
1149 * need special handling)?
1151 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1152 /* don't ucase netbiosname for user */
1153 if (param->string[i] == 0)
1155 ctx->source_rfc1001_name[i] = param->string[i];
1157 /* The string has 16th byte zero still from
1158 * set at top of the function
1160 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1161 pr_warn("netbiosname longer than 15 truncated\n");
1164 /* last byte, type, is 0x20 for servr type */
1165 memset(ctx->target_rfc1001_name, 0x20,
1166 RFC1001_NAME_LEN_WITH_NULL);
1168 * BB are there cases in which a comma can be valid in this
1169 * workstation netbios name (and need special handling)?
1172 /* user or mount helper must uppercase the netbios name */
1173 for (i = 0; i < 15; i++) {
1174 if (param->string[i] == 0)
1176 ctx->target_rfc1001_name[i] = param->string[i];
1179 /* The string has 16th byte zero still from set at top of function */
1180 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1181 pr_warn("server netbiosname longer than 15 truncated\n");
1184 /* version of mount userspace tools, not dialect */
1185 /* If interface changes in mount.cifs bump to new ver */
1186 if (strncasecmp(param->string, "1", 1) == 0) {
1187 if (strlen(param->string) > 1) {
1188 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1190 goto cifs_parse_mount_err;
1192 /* This is the default */
1195 /* For all other value, error */
1196 pr_warn("Invalid mount helper version specified\n");
1197 goto cifs_parse_mount_err;
1199 /* protocol version (dialect) */
1200 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1201 goto cifs_parse_mount_err;
1202 ctx->got_version = true;
1205 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1206 goto cifs_parse_mount_err;
1209 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1210 goto cifs_parse_mount_err;
1213 #ifndef CONFIG_CIFS_SWN_UPCALL
1214 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1215 goto cifs_parse_mount_err;
1217 ctx->witness = true;
1218 pr_warn_once("Witness protocol support is experimental\n");
1221 #ifndef CONFIG_CIFS_ROOT
1222 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1223 goto cifs_parse_mount_err;
1227 case Opt_posixpaths:
1229 ctx->posix_paths = 0;
1231 ctx->posix_paths = 1;
1237 ctx->no_linux_ext = 1;
1243 if (result.negated) {
1245 * turn off mandatory locking in mode
1246 * if remote locking is turned off since the
1247 * local vfs will do advisory
1249 if (ctx->file_mode ==
1250 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1251 ctx->file_mode = S_IALLUGO;
1256 case Opt_handlecache:
1258 ctx->nohandlecache = 1;
1260 ctx->nohandlecache = 0;
1262 case Opt_forcemandatorylock:
1266 ctx->setuids = result.negated;
1269 ctx->intr = !result.negated;
1271 case Opt_setuidfromacl:
1272 ctx->setuidfromacl = 1;
1274 case Opt_strictsync:
1275 ctx->nostrictsync = result.negated;
1278 ctx->server_ino = !result.negated;
1280 case Opt_rwpidforward:
1281 ctx->rwpidforward = 1;
1287 ctx->cifs_acl = !result.negated;
1290 ctx->no_psx_acl = result.negated;
1292 case Opt_locallease:
1293 ctx->local_lease = 1;
1298 case Opt_ignore_signature:
1300 ctx->ignore_signature = true;
1303 /* we do not do the following in secFlags because seal
1304 * is a per tree connection (mount) not a per socket
1305 * or per-smb connection option in the protocol
1306 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1311 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1314 #ifndef CONFIG_CIFS_FSCACHE
1315 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1316 goto cifs_parse_mount_err;
1320 case Opt_mfsymlinks:
1321 ctx->mfsymlinks = true;
1324 ctx->multiuser = true;
1329 case Opt_nosharesock:
1330 ctx->nosharesock = true;
1332 case Opt_persistent:
1333 if (result.negated) {
1334 ctx->nopersistent = true;
1335 if (ctx->persistent) {
1336 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1337 goto cifs_parse_mount_err;
1340 ctx->persistent = true;
1341 if ((ctx->nopersistent) || (ctx->resilient)) {
1342 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1343 goto cifs_parse_mount_err;
1348 if (result.negated) {
1349 ctx->resilient = false; /* already the default */
1351 ctx->resilient = true;
1352 if (ctx->persistent) {
1353 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1354 goto cifs_parse_mount_err;
1358 case Opt_domainauto:
1359 ctx->domainauto = true;
1365 /* case Opt_ignore: - is ignored as expected ... */
1369 cifs_parse_mount_err:
1373 int smb3_init_fs_context(struct fs_context *fc)
1375 struct smb3_fs_context *ctx;
1376 char *nodename = utsname()->nodename;
1379 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1384 * does not have to be perfect mapping since field is
1385 * informational, only used for servers that do not support
1386 * port 445 and it can be overridden at mount time
1388 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1389 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1390 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1392 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1394 * null target name indicates to use *SMBSERVR default called name
1395 * if we end up sending RFC1001 session initialize
1397 ctx->target_rfc1001_name[0] = 0;
1398 ctx->cred_uid = current_uid();
1399 ctx->linux_uid = current_uid();
1400 ctx->linux_gid = current_gid();
1401 /* By default 4MB read ahead size, 1MB block size */
1402 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1403 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1406 * default to SFM style remapping of seven reserved characters
1407 * unless user overrides it or we negotiate CIFS POSIX where
1408 * it is unnecessary. Can not simultaneously use more than one mapping
1409 * since then readdir could list files that open could not open
1413 /* default to only allowing write access to owner of the mount */
1414 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1416 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1417 /* default is always to request posix paths. */
1418 ctx->posix_paths = 1;
1419 /* default to using server inode numbers where available */
1420 ctx->server_ino = 1;
1422 /* default is to use strict cifs caching semantics */
1423 ctx->strict_io = true;
1425 ctx->acregmax = CIFS_DEF_ACTIMEO;
1426 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1428 /* Most clients set timeout to 0, allows server to use its default */
1429 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1431 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1432 ctx->ops = &smb30_operations;
1433 ctx->vals = &smbdefault_values;
1435 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1437 /* default to no multichannel (single server connection) */
1438 ctx->multichannel = false;
1439 ctx->max_channels = 1;
1441 ctx->backupuid_specified = false; /* no backup intent for a user */
1442 ctx->backupgid_specified = false; /* no backup intent for a group */
1445 * short int override_uid = -1;
1446 * short int override_gid = -1;
1447 * char *nodename = strdup(utsname()->nodename);
1448 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1451 fc->fs_private = ctx;
1452 fc->ops = &smb3_fs_context_ops;
1457 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1463 * Make sure this stays in sync with smb3_fs_context_dup()
1465 kfree(ctx->mount_options);
1466 ctx->mount_options = NULL;
1467 kfree(ctx->username);
1468 ctx->username = NULL;
1469 kfree_sensitive(ctx->password);
1470 ctx->password = NULL;
1475 kfree(ctx->domainname);
1476 ctx->domainname = NULL;
1477 kfree(ctx->nodename);
1478 ctx->nodename = NULL;
1479 kfree(ctx->iocharset);
1480 ctx->iocharset = NULL;
1481 kfree(ctx->prepath);
1482 ctx->prepath = NULL;
1486 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1490 smb3_cleanup_fs_context_contents(ctx);
1494 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1496 struct smb3_fs_context *ctx = cifs_sb->ctx;
1499 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1501 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1504 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1506 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1509 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1511 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1513 if (ctx->setuidfromacl)
1514 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1516 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1518 if (ctx->server_ino)
1519 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1521 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1524 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1526 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1529 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1531 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1534 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1536 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1539 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1541 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1544 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1546 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1548 if (ctx->nohandlecache)
1549 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1551 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1553 if (ctx->nostrictsync)
1554 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1556 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1559 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1561 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1563 if (ctx->rwpidforward)
1564 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1566 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1569 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1571 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1574 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1576 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1578 if (ctx->backupuid_specified)
1579 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1581 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1583 if (ctx->backupgid_specified)
1584 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1586 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1588 if (ctx->override_uid)
1589 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1591 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1593 if (ctx->override_gid)
1594 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1596 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1599 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1601 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1604 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1606 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1609 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1610 CIFS_MOUNT_NO_PERM);
1612 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1616 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1618 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1621 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1623 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1625 if (ctx->mfsymlinks)
1626 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1628 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1629 if (ctx->mfsymlinks) {
1630 if (ctx->sfu_emul) {
1632 * Our SFU ("Services for Unix" emulation does not allow
1633 * creating symlinks but does allow reading existing SFU
1634 * symlinks (it does allow both creating and reading SFU
1635 * style mknod and FIFOs though). When "mfsymlinks" and
1636 * "sfu" are both enabled at the same time, it allows
1637 * reading both types of symlinks, but will only create
1638 * them with mfsymlinks format. This allows better
1639 * Apple compatibility (probably better for Samba too)
1640 * while still recognizing old Windows style symlinks.
1642 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");