1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Provide a way to create a superblock configuration context within the kernel
3 * that allows a superblock to be set up prior to mounting.
5 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
6 * Written by David Howells (dhowells@redhat.com)
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/module.h>
11 #include <linux/fs_context.h>
12 #include <linux/fs_parser.h>
14 #include <linux/mount.h>
15 #include <linux/nsproxy.h>
16 #include <linux/slab.h>
17 #include <linux/magic.h>
18 #include <linux/security.h>
19 #include <linux/mnt_namespace.h>
20 #include <linux/pid_namespace.h>
21 #include <linux/user_namespace.h>
22 #include <net/net_namespace.h>
23 #include <asm/sections.h>
27 enum legacy_fs_param
{
28 LEGACY_FS_UNSET_PARAMS
,
29 LEGACY_FS_MONOLITHIC_PARAMS
,
30 LEGACY_FS_INDIVIDUAL_PARAMS
,
33 struct legacy_fs_context
{
34 char *legacy_data
; /* Data page for legacy filesystems */
36 enum legacy_fs_param param_type
;
39 static int legacy_init_fs_context(struct fs_context
*fc
);
41 static const struct constant_table common_set_sb_flag
[] = {
42 { "dirsync", SB_DIRSYNC
},
43 { "lazytime", SB_LAZYTIME
},
44 { "mand", SB_MANDLOCK
},
46 { "sync", SB_SYNCHRONOUS
},
50 static const struct constant_table common_clear_sb_flag
[] = {
51 { "async", SB_SYNCHRONOUS
},
52 { "nolazytime", SB_LAZYTIME
},
53 { "nomand", SB_MANDLOCK
},
59 * Check for a common mount option that manipulates s_flags.
61 static int vfs_parse_sb_flag(struct fs_context
*fc
, const char *key
)
65 token
= lookup_constant(common_set_sb_flag
, key
, 0);
67 fc
->sb_flags
|= token
;
68 fc
->sb_flags_mask
|= token
;
72 token
= lookup_constant(common_clear_sb_flag
, key
, 0);
74 fc
->sb_flags
&= ~token
;
75 fc
->sb_flags_mask
|= token
;
83 * vfs_parse_fs_param_source - Handle setting "source" via parameter
84 * @fc: The filesystem context to modify
85 * @param: The parameter
87 * This is a simple helper for filesystems to verify that the "source" they
90 * Returns 0 on success, -ENOPARAM if this is not "source" parameter, and
91 * -EINVAL otherwise. In the event of failure, supplementary error information
94 int vfs_parse_fs_param_source(struct fs_context
*fc
, struct fs_parameter
*param
)
96 if (strcmp(param
->key
, "source") != 0)
99 if (param
->type
!= fs_value_is_string
)
100 return invalf(fc
, "Non-string source");
103 return invalf(fc
, "Multiple sources");
105 fc
->source
= param
->string
;
106 param
->string
= NULL
;
109 EXPORT_SYMBOL(vfs_parse_fs_param_source
);
112 * vfs_parse_fs_param - Add a single parameter to a superblock config
113 * @fc: The filesystem context to modify
114 * @param: The parameter
116 * A single mount option in string form is applied to the filesystem context
117 * being set up. Certain standard options (for example "ro") are translated
118 * into flag bits without going to the filesystem. The active security module
119 * is allowed to observe and poach options. Any other options are passed over
120 * to the filesystem to parse.
122 * This may be called multiple times for a context.
124 * Returns 0 on success and a negative error code on failure. In the event of
125 * failure, supplementary error information may have been set.
127 int vfs_parse_fs_param(struct fs_context
*fc
, struct fs_parameter
*param
)
132 return invalf(fc
, "Unnamed parameter\n");
134 ret
= vfs_parse_sb_flag(fc
, param
->key
);
135 if (ret
!= -ENOPARAM
)
138 ret
= security_fs_context_parse_param(fc
, param
);
139 if (ret
!= -ENOPARAM
)
140 /* Param belongs to the LSM or is disallowed by the LSM; so
141 * don't pass to the FS.
145 if (fc
->ops
->parse_param
) {
146 ret
= fc
->ops
->parse_param(fc
, param
);
147 if (ret
!= -ENOPARAM
)
151 /* If the filesystem doesn't take any arguments, give it the
152 * default handling of source.
154 ret
= vfs_parse_fs_param_source(fc
, param
);
155 if (ret
!= -ENOPARAM
)
158 return invalf(fc
, "%s: Unknown parameter '%s'",
159 fc
->fs_type
->name
, param
->key
);
161 EXPORT_SYMBOL(vfs_parse_fs_param
);
164 * vfs_parse_fs_string - Convenience function to just parse a string.
166 int vfs_parse_fs_string(struct fs_context
*fc
, const char *key
,
167 const char *value
, size_t v_size
)
171 struct fs_parameter param
= {
173 .type
= fs_value_is_flag
,
178 param
.string
= kmemdup_nul(value
, v_size
, GFP_KERNEL
);
181 param
.type
= fs_value_is_string
;
184 ret
= vfs_parse_fs_param(fc
, ¶m
);
188 EXPORT_SYMBOL(vfs_parse_fs_string
);
191 * generic_parse_monolithic - Parse key[=val][,key[=val]]* mount data
192 * @ctx: The superblock configuration to fill in.
193 * @data: The data to parse
195 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
196 * called from the ->monolithic_mount_data() fs_context operation.
198 * Returns 0 on success or the error returned by the ->parse_option() fs_context
199 * operation on failure.
201 int generic_parse_monolithic(struct fs_context
*fc
, void *data
)
203 char *options
= data
, *key
;
209 ret
= security_sb_eat_lsm_opts(options
, &fc
->security
);
213 while ((key
= strsep(&options
, ",")) != NULL
) {
216 char *value
= strchr(key
, '=');
222 v_len
= strlen(value
);
224 ret
= vfs_parse_fs_string(fc
, key
, value
, v_len
);
232 EXPORT_SYMBOL(generic_parse_monolithic
);
235 * alloc_fs_context - Create a filesystem context.
236 * @fs_type: The filesystem type.
237 * @reference: The dentry from which this one derives (or NULL)
238 * @sb_flags: Filesystem/superblock flags (SB_*)
239 * @sb_flags_mask: Applicable members of @sb_flags
240 * @purpose: The purpose that this configuration shall be used for.
242 * Open a filesystem and create a mount context. The mount context is
243 * initialised with the supplied flags and, if a submount/automount from
244 * another superblock (referred to by @reference) is supplied, may have
245 * parameters such as namespaces copied across from that superblock.
247 static struct fs_context
*alloc_fs_context(struct file_system_type
*fs_type
,
248 struct dentry
*reference
,
249 unsigned int sb_flags
,
250 unsigned int sb_flags_mask
,
251 enum fs_context_purpose purpose
)
253 int (*init_fs_context
)(struct fs_context
*);
254 struct fs_context
*fc
;
257 fc
= kzalloc(sizeof(struct fs_context
), GFP_KERNEL
);
259 return ERR_PTR(-ENOMEM
);
261 fc
->purpose
= purpose
;
262 fc
->sb_flags
= sb_flags
;
263 fc
->sb_flags_mask
= sb_flags_mask
;
264 fc
->fs_type
= get_filesystem(fs_type
);
265 fc
->cred
= get_current_cred();
266 fc
->net_ns
= get_net(current
->nsproxy
->net_ns
);
267 fc
->log
.prefix
= fs_type
->name
;
269 mutex_init(&fc
->uapi_mutex
);
272 case FS_CONTEXT_FOR_MOUNT
:
273 fc
->user_ns
= get_user_ns(fc
->cred
->user_ns
);
275 case FS_CONTEXT_FOR_SUBMOUNT
:
276 fc
->user_ns
= get_user_ns(reference
->d_sb
->s_user_ns
);
278 case FS_CONTEXT_FOR_RECONFIGURE
:
279 atomic_inc(&reference
->d_sb
->s_active
);
280 fc
->user_ns
= get_user_ns(reference
->d_sb
->s_user_ns
);
281 fc
->root
= dget(reference
);
285 /* TODO: Make all filesystems support this unconditionally */
286 init_fs_context
= fc
->fs_type
->init_fs_context
;
287 if (!init_fs_context
)
288 init_fs_context
= legacy_init_fs_context
;
290 ret
= init_fs_context(fc
);
293 fc
->need_free
= true;
301 struct fs_context
*fs_context_for_mount(struct file_system_type
*fs_type
,
302 unsigned int sb_flags
)
304 return alloc_fs_context(fs_type
, NULL
, sb_flags
, 0,
305 FS_CONTEXT_FOR_MOUNT
);
307 EXPORT_SYMBOL(fs_context_for_mount
);
309 struct fs_context
*fs_context_for_reconfigure(struct dentry
*dentry
,
310 unsigned int sb_flags
,
311 unsigned int sb_flags_mask
)
313 return alloc_fs_context(dentry
->d_sb
->s_type
, dentry
, sb_flags
,
314 sb_flags_mask
, FS_CONTEXT_FOR_RECONFIGURE
);
316 EXPORT_SYMBOL(fs_context_for_reconfigure
);
318 struct fs_context
*fs_context_for_submount(struct file_system_type
*type
,
319 struct dentry
*reference
)
321 return alloc_fs_context(type
, reference
, 0, 0, FS_CONTEXT_FOR_SUBMOUNT
);
323 EXPORT_SYMBOL(fs_context_for_submount
);
325 void fc_drop_locked(struct fs_context
*fc
)
327 struct super_block
*sb
= fc
->root
->d_sb
;
330 deactivate_locked_super(sb
);
333 static void legacy_fs_context_free(struct fs_context
*fc
);
336 * vfs_dup_fc_config: Duplicate a filesystem context.
337 * @src_fc: The context to copy.
339 struct fs_context
*vfs_dup_fs_context(struct fs_context
*src_fc
)
341 struct fs_context
*fc
;
344 if (!src_fc
->ops
->dup
)
345 return ERR_PTR(-EOPNOTSUPP
);
347 fc
= kmemdup(src_fc
, sizeof(struct fs_context
), GFP_KERNEL
);
349 return ERR_PTR(-ENOMEM
);
351 mutex_init(&fc
->uapi_mutex
);
353 fc
->fs_private
= NULL
;
354 fc
->s_fs_info
= NULL
;
357 get_filesystem(fc
->fs_type
);
359 get_user_ns(fc
->user_ns
);
362 refcount_inc(&fc
->log
.log
->usage
);
364 /* Can't call put until we've called ->dup */
365 ret
= fc
->ops
->dup(fc
, src_fc
);
369 ret
= security_fs_context_dup(fc
, src_fc
);
378 EXPORT_SYMBOL(vfs_dup_fs_context
);
381 * logfc - Log a message to a filesystem context
382 * @fc: The filesystem context to log to.
383 * @fmt: The format of the buffer.
385 void logfc(struct fc_log
*log
, const char *prefix
, char level
, const char *fmt
, ...)
388 struct va_format vaf
= {.fmt
= fmt
, .va
= &va
};
394 printk(KERN_WARNING
"%s%s%pV\n", prefix
? prefix
: "",
395 prefix
? ": " : "", &vaf
);
398 printk(KERN_ERR
"%s%s%pV\n", prefix
? prefix
: "",
399 prefix
? ": " : "", &vaf
);
402 printk(KERN_NOTICE
"%s%s%pV\n", prefix
? prefix
: "",
403 prefix
? ": " : "", &vaf
);
407 unsigned int logsize
= ARRAY_SIZE(log
->buffer
);
409 char *q
= kasprintf(GFP_KERNEL
, "%c %s%s%pV\n", level
,
410 prefix
? prefix
: "",
411 prefix
? ": " : "", &vaf
);
413 index
= log
->head
& (logsize
- 1);
414 BUILD_BUG_ON(sizeof(log
->head
) != sizeof(u8
) ||
415 sizeof(log
->tail
) != sizeof(u8
));
416 if ((u8
)(log
->head
- log
->tail
) == logsize
) {
417 /* The buffer is full, discard the oldest message */
418 if (log
->need_free
& (1 << index
))
419 kfree(log
->buffer
[index
]);
423 log
->buffer
[index
] = q
? q
: "OOM: Can't store error string";
425 log
->need_free
|= 1 << index
;
427 log
->need_free
&= ~(1 << index
);
432 EXPORT_SYMBOL(logfc
);
435 * Free a logging structure.
437 static void put_fc_log(struct fs_context
*fc
)
439 struct fc_log
*log
= fc
->log
.log
;
443 if (refcount_dec_and_test(&log
->usage
)) {
445 for (i
= 0; i
<= 7; i
++)
446 if (log
->need_free
& (1 << i
))
447 kfree(log
->buffer
[i
]);
454 * put_fs_context - Dispose of a superblock configuration context.
455 * @fc: The context to dispose of.
457 void put_fs_context(struct fs_context
*fc
)
459 struct super_block
*sb
;
465 deactivate_super(sb
);
468 if (fc
->need_free
&& fc
->ops
&& fc
->ops
->free
)
471 security_free_mnt_opts(&fc
->security
);
473 put_user_ns(fc
->user_ns
);
476 put_filesystem(fc
->fs_type
);
480 EXPORT_SYMBOL(put_fs_context
);
483 * Free the config for a filesystem that doesn't support fs_context.
485 static void legacy_fs_context_free(struct fs_context
*fc
)
487 struct legacy_fs_context
*ctx
= fc
->fs_private
;
490 if (ctx
->param_type
== LEGACY_FS_INDIVIDUAL_PARAMS
)
491 kfree(ctx
->legacy_data
);
497 * Duplicate a legacy config.
499 static int legacy_fs_context_dup(struct fs_context
*fc
, struct fs_context
*src_fc
)
501 struct legacy_fs_context
*ctx
;
502 struct legacy_fs_context
*src_ctx
= src_fc
->fs_private
;
504 ctx
= kmemdup(src_ctx
, sizeof(*src_ctx
), GFP_KERNEL
);
508 if (ctx
->param_type
== LEGACY_FS_INDIVIDUAL_PARAMS
) {
509 ctx
->legacy_data
= kmemdup(src_ctx
->legacy_data
,
510 src_ctx
->data_size
, GFP_KERNEL
);
511 if (!ctx
->legacy_data
) {
517 fc
->fs_private
= ctx
;
522 * Add a parameter to a legacy config. We build up a comma-separated list of
525 static int legacy_parse_param(struct fs_context
*fc
, struct fs_parameter
*param
)
527 struct legacy_fs_context
*ctx
= fc
->fs_private
;
528 unsigned int size
= ctx
->data_size
;
532 ret
= vfs_parse_fs_param_source(fc
, param
);
533 if (ret
!= -ENOPARAM
)
536 if (ctx
->param_type
== LEGACY_FS_MONOLITHIC_PARAMS
)
537 return invalf(fc
, "VFS: Legacy: Can't mix monolithic and individual options");
539 switch (param
->type
) {
540 case fs_value_is_string
:
541 len
= 1 + param
->size
;
543 case fs_value_is_flag
:
544 len
+= strlen(param
->key
);
547 return invalf(fc
, "VFS: Legacy: Parameter type for '%s' not supported",
551 if (len
> PAGE_SIZE
- 2 - size
)
552 return invalf(fc
, "VFS: Legacy: Cumulative options too large");
553 if (strchr(param
->key
, ',') ||
554 (param
->type
== fs_value_is_string
&&
555 memchr(param
->string
, ',', param
->size
)))
556 return invalf(fc
, "VFS: Legacy: Option '%s' contained comma",
558 if (!ctx
->legacy_data
) {
559 ctx
->legacy_data
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
560 if (!ctx
->legacy_data
)
564 ctx
->legacy_data
[size
++] = ',';
565 len
= strlen(param
->key
);
566 memcpy(ctx
->legacy_data
+ size
, param
->key
, len
);
568 if (param
->type
== fs_value_is_string
) {
569 ctx
->legacy_data
[size
++] = '=';
570 memcpy(ctx
->legacy_data
+ size
, param
->string
, param
->size
);
573 ctx
->legacy_data
[size
] = '\0';
574 ctx
->data_size
= size
;
575 ctx
->param_type
= LEGACY_FS_INDIVIDUAL_PARAMS
;
580 * Add monolithic mount data.
582 static int legacy_parse_monolithic(struct fs_context
*fc
, void *data
)
584 struct legacy_fs_context
*ctx
= fc
->fs_private
;
586 if (ctx
->param_type
!= LEGACY_FS_UNSET_PARAMS
) {
587 pr_warn("VFS: Can't mix monolithic and individual options\n");
591 ctx
->legacy_data
= data
;
592 ctx
->param_type
= LEGACY_FS_MONOLITHIC_PARAMS
;
593 if (!ctx
->legacy_data
)
596 if (fc
->fs_type
->fs_flags
& FS_BINARY_MOUNTDATA
)
598 return security_sb_eat_lsm_opts(ctx
->legacy_data
, &fc
->security
);
602 * Get a mountable root with the legacy mount command.
604 static int legacy_get_tree(struct fs_context
*fc
)
606 struct legacy_fs_context
*ctx
= fc
->fs_private
;
607 struct super_block
*sb
;
610 root
= fc
->fs_type
->mount(fc
->fs_type
, fc
->sb_flags
,
611 fc
->source
, ctx
->legacy_data
);
613 return PTR_ERR(root
);
625 static int legacy_reconfigure(struct fs_context
*fc
)
627 struct legacy_fs_context
*ctx
= fc
->fs_private
;
628 struct super_block
*sb
= fc
->root
->d_sb
;
630 if (!sb
->s_op
->remount_fs
)
633 return sb
->s_op
->remount_fs(sb
, &fc
->sb_flags
,
634 ctx
? ctx
->legacy_data
: NULL
);
637 const struct fs_context_operations legacy_fs_context_ops
= {
638 .free
= legacy_fs_context_free
,
639 .dup
= legacy_fs_context_dup
,
640 .parse_param
= legacy_parse_param
,
641 .parse_monolithic
= legacy_parse_monolithic
,
642 .get_tree
= legacy_get_tree
,
643 .reconfigure
= legacy_reconfigure
,
647 * Initialise a legacy context for a filesystem that doesn't support
650 static int legacy_init_fs_context(struct fs_context
*fc
)
652 fc
->fs_private
= kzalloc(sizeof(struct legacy_fs_context
), GFP_KERNEL
);
655 fc
->ops
= &legacy_fs_context_ops
;
659 int parse_monolithic_mount_data(struct fs_context
*fc
, void *data
)
661 int (*monolithic_mount_data
)(struct fs_context
*, void *);
663 monolithic_mount_data
= fc
->ops
->parse_monolithic
;
664 if (!monolithic_mount_data
)
665 monolithic_mount_data
= generic_parse_monolithic
;
667 return monolithic_mount_data(fc
, data
);
671 * Clean up a context after performing an action on it and put it into a state
672 * from where it can be used to reconfigure a superblock.
674 * Note that here we do only the parts that can't fail; the rest is in
675 * finish_clean_context() below and in between those fs_context is marked
676 * FS_CONTEXT_AWAITING_RECONF. The reason for splitup is that after
677 * successful mount or remount we need to report success to userland.
678 * Trying to do full reinit (for the sake of possible subsequent remount)
679 * and failing to allocate memory would've put us into a nasty situation.
680 * So here we only discard the old state and reinitialization is left
681 * until we actually try to reconfigure.
683 void vfs_clean_context(struct fs_context
*fc
)
685 if (fc
->need_free
&& fc
->ops
&& fc
->ops
->free
)
687 fc
->need_free
= false;
688 fc
->fs_private
= NULL
;
689 fc
->s_fs_info
= NULL
;
691 security_free_mnt_opts(&fc
->security
);
695 fc
->purpose
= FS_CONTEXT_FOR_RECONFIGURE
;
696 fc
->phase
= FS_CONTEXT_AWAITING_RECONF
;
699 int finish_clean_context(struct fs_context
*fc
)
703 if (fc
->phase
!= FS_CONTEXT_AWAITING_RECONF
)
706 if (fc
->fs_type
->init_fs_context
)
707 error
= fc
->fs_type
->init_fs_context(fc
);
709 error
= legacy_init_fs_context(fc
);
710 if (unlikely(error
)) {
711 fc
->phase
= FS_CONTEXT_FAILED
;
714 fc
->need_free
= true;
715 fc
->phase
= FS_CONTEXT_RECONF_PARAMS
;