- load_ramdisk= [RAM] [Deprecated]

-

- noinitrd [RAM] Tells the kernel not to load any configured

- initial RAM disk.

- prompt_ramdisk= [RAM] [Deprecated]

-

- ramdisk_start= [RAM] RAM disk image start address

-real-root-dev

-=============

-

-See Documentation/admin-guide/initrd.rst.

-

-

- int (*remount_fs) (struct super_block *, int *, char *);

-remount_fs: write

- struct dentry *(*mount) (struct file_system_type *, int,

- const char *, void *);

-mount yes

-->mount() returns ERR_PTR or the root dentry; its superblock should be locked

-on return.

-

- .. Note:: reconfigure is intended as a replacement for remount_fs.

-

-->get_sb() is gone. Switch to use of ->mount(). Typically it's just

-a matter of switching from calling ``get_sb_``... to ``mount_``... and changing

-the function type. If you were doing it manually, just switch from setting

-->mnt_root to some pointer to returning that pointer. On errors return

-ERR_PTR(...).

-namespace, the VFS will call the appropriate mount() method for the

-specific filesystem. New vfsmount referring to the tree returned by

-->mount() will be attached to the mountpoint, so that when pathname

-resolution reaches the mountpoint it will jump into the root of that

-vfsmount.

- struct dentry *(*mount) (struct file_system_type *, int,

- const char *, void *);

-``mount``

- the method to call when a new instance of this filesystem should

- be mounted

-

-The mount() method has the following arguments:

-

-``struct file_system_type *fs_type``

- describes the filesystem, partly initialized by the specific

- filesystem code

-

-``int flags``

- mount flags

-

-``const char *dev_name``

- the device name we are mounting.

-

-``void *data``

- arbitrary mount options, usually comes as an ASCII string (see

- "Mount Options" section)

-

-The mount() method must return the root dentry of the tree requested by

-caller. An active reference to its superblock must be grabbed and the

-superblock must be locked. On failure it should return ERR_PTR(error).

-

-The arguments match those of mount(2) and their interpretation depends

-on filesystem type. E.g. for block filesystems, dev_name is interpreted

-as block device name, that device is opened and if it contains a

-suitable filesystem image the method creates and initializes struct

-super_block accordingly, returning its root dentry to caller.

-

-->mount() may choose to return a subtree of existing filesystem - it

-doesn't have to create a new one. The main result from the caller's

-point of view is a reference to dentry at the root of (sub)tree to be

-attached; creation of new superblock is a common side effect.

-

-The most interesting member of the superblock structure that the mount()

-method fills in is the "s_op" field. This is a pointer to a "struct

-super_operations" which describes the next level of the filesystem

-implementation.

-

-For more information on mounting (and the new mount API), see

-Documentation/filesystems/mount_api.rst.

-

- int (*remount_fs) (struct super_block *, int *, char *);

-``remount_fs``

- called when the filesystem is remounted. This is called with

- the kernel lock held

-

-CONFIG_CMDLINE="console=ttySA0,38400n8 cpufreq=221200 rw root=/dev/mtdblock2 mtdparts=sa1100:512K(boot),1M(kernel),2560K(initrd),4M(root) load_ramdisk=1 prompt_ramdisk=0 mem=32M noinitrd initrd=0xc0800000,3M"

- to = min_t(unsigned, folio_size(folio) - from, count);

-static DEFINE_SPINLOCK(cdev_lock);

- unsigned int bytes_to_copy = min_t(unsigned int, len,

- thisgrp_len = min_t(unsigned int, (unsigned int)len,

- EXT4_BLOCKS_PER_GROUP(sb) - EXT4_C2B(sbi, blkoff));

- sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,

- sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,

- int copy = min_t(int, sb->s_blocksize - offset, size);

- int copy = min_t(int, sb->s_blocksize - offset, size);

- range.minlen = max_t(unsigned int, range.minlen,

- bdev_discard_granularity(sb->s_bdev));

-enum legacy_fs_param {

- LEGACY_FS_UNSET_PARAMS,

- LEGACY_FS_MONOLITHIC_PARAMS,

- LEGACY_FS_INDIVIDUAL_PARAMS,

-};

-

-struct legacy_fs_context {

- char *legacy_data; /* Data page for legacy filesystems */

- size_t data_size;

- enum legacy_fs_param param_type;

-};

-

-static int legacy_init_fs_context(struct fs_context *fc);

-

- int (*init_fs_context)(struct fs_context *);

- /* TODO: Make all filesystems support this unconditionally */

- init_fs_context = fc->fs_type->init_fs_context;

- if (!init_fs_context)

- init_fs_context = legacy_init_fs_context;

-

- ret = init_fs_context(fc);

-static void legacy_fs_context_free(struct fs_context *fc);

-

-/*

- * Free the config for a filesystem that doesn't support fs_context.

- */

-static void legacy_fs_context_free(struct fs_context *fc)

-{

- struct legacy_fs_context *ctx = fc->fs_private;

-

- if (ctx) {

- if (ctx->param_type == LEGACY_FS_INDIVIDUAL_PARAMS)

- kfree(ctx->legacy_data);

- kfree(ctx);

- }

-}

-

-/*

- * Duplicate a legacy config.

- */

-static int legacy_fs_context_dup(struct fs_context *fc, struct fs_context *src_fc)

-{

- struct legacy_fs_context *ctx;

- struct legacy_fs_context *src_ctx = src_fc->fs_private;

-

- ctx = kmemdup(src_ctx, sizeof(*src_ctx), GFP_KERNEL);

- if (!ctx)

- return -ENOMEM;

-

- if (ctx->param_type == LEGACY_FS_INDIVIDUAL_PARAMS) {

- ctx->legacy_data = kmemdup(src_ctx->legacy_data,

- src_ctx->data_size, GFP_KERNEL);

- if (!ctx->legacy_data) {

- kfree(ctx);

- return -ENOMEM;

- }

- }

-

- fc->fs_private = ctx;

- return 0;

-}

-

-/*

- * Add a parameter to a legacy config. We build up a comma-separated list of

- * options.

- */

-static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)

-{

- struct legacy_fs_context *ctx = fc->fs_private;

- unsigned int size = ctx->data_size;

- size_t len = 0;

- int ret;

-

- ret = vfs_parse_fs_param_source(fc, param);

- if (ret != -ENOPARAM)

- return ret;

-

- if (ctx->param_type == LEGACY_FS_MONOLITHIC_PARAMS)

- return invalf(fc, "VFS: Legacy: Can't mix monolithic and individual options");

-

- switch (param->type) {

- case fs_value_is_string:

- len = 1 + param->size;

- fallthrough;

- case fs_value_is_flag:

- len += strlen(param->key);

- break;

- default:

- return invalf(fc, "VFS: Legacy: Parameter type for '%s' not supported",

- param->key);

- }

-

- if (size + len + 2 > PAGE_SIZE)

- return invalf(fc, "VFS: Legacy: Cumulative options too large");

- if (strchr(param->key, ',') ||

- (param->type == fs_value_is_string &&

- memchr(param->string, ',', param->size)))

- return invalf(fc, "VFS: Legacy: Option '%s' contained comma",

- param->key);

- if (!ctx->legacy_data) {

- ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL);

- if (!ctx->legacy_data)

- return -ENOMEM;

- }

-

- if (size)

- ctx->legacy_data[size++] = ',';

- len = strlen(param->key);

- memcpy(ctx->legacy_data + size, param->key, len);

- size += len;

- if (param->type == fs_value_is_string) {

- ctx->legacy_data[size++] = '=';

- memcpy(ctx->legacy_data + size, param->string, param->size);

- size += param->size;

- }

- ctx->legacy_data[size] = '\0';

- ctx->data_size = size;

- ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS;

- return 0;

-}

-

-/*

- * Add monolithic mount data.

- */

-static int legacy_parse_monolithic(struct fs_context *fc, void *data)

-{

- struct legacy_fs_context *ctx = fc->fs_private;

-

- if (ctx->param_type != LEGACY_FS_UNSET_PARAMS) {

- pr_warn("VFS: Can't mix monolithic and individual options\n");

- return -EINVAL;

- }

-

- ctx->legacy_data = data;

- ctx->param_type = LEGACY_FS_MONOLITHIC_PARAMS;

- if (!ctx->legacy_data)

- return 0;

-

- if (fc->fs_type->fs_flags & FS_BINARY_MOUNTDATA)

- return 0;

- return security_sb_eat_lsm_opts(ctx->legacy_data, &fc->security);

-}

-

-/*

- * Get a mountable root with the legacy mount command.

- */

-static int legacy_get_tree(struct fs_context *fc)

-{

- struct legacy_fs_context *ctx = fc->fs_private;

- struct super_block *sb;

- struct dentry *root;

-

- root = fc->fs_type->mount(fc->fs_type, fc->sb_flags,

- fc->source, ctx->legacy_data);

- if (IS_ERR(root))

- return PTR_ERR(root);

-

- sb = root->d_sb;

- BUG_ON(!sb);

-

- fc->root = root;

- return 0;

-}

-

-/*

- * Handle remount.

- */

-static int legacy_reconfigure(struct fs_context *fc)

-{

- struct legacy_fs_context *ctx = fc->fs_private;

- struct super_block *sb = fc->root->d_sb;

-

- if (!sb->s_op->remount_fs)

- return 0;

-

- return sb->s_op->remount_fs(sb, &fc->sb_flags,

- ctx ? ctx->legacy_data : NULL);

-}

-

-const struct fs_context_operations legacy_fs_context_ops = {

- .free = legacy_fs_context_free,

- .dup = legacy_fs_context_dup,

- .parse_param = legacy_parse_param,

- .parse_monolithic = legacy_parse_monolithic,

- .get_tree = legacy_get_tree,

- .reconfigure = legacy_reconfigure,

-};

-

-/*

- * Initialise a legacy context for a filesystem that doesn't support

- * fs_context.

- */

-static int legacy_init_fs_context(struct fs_context *fc)

-{

- fc->fs_private = kzalloc(sizeof(struct legacy_fs_context), GFP_KERNEL_ACCOUNT);

- if (!fc->fs_private)

- return -ENOMEM;

- fc->ops = &legacy_fs_context_ops;

- return 0;

-}

-

- if (fc->fs_type->init_fs_context)

- error = fc->fs_type->init_fs_context(fc);

- else

- error = legacy_init_fs_context(fc);

- if (fc->ops == &legacy_fs_context_ops) {

- switch (cmd) {

- case FSCONFIG_SET_BINARY:

- case FSCONFIG_SET_PATH:

- case FSCONFIG_SET_PATH_EMPTY:

- case FSCONFIG_SET_FD:

- case FSCONFIG_CMD_CREATE_EXCL:

- return -EOPNOTSUPP;

- }

- }

- nr_bytes = min_t(unsigned, num, folio_size(folio) - folio_offset);

- return min_t(unsigned int,

- ((pos + len - 1) >> PAGE_SHIFT) -

- (pos >> PAGE_SHIFT) + 1,

- max_pages);

- unsigned int len = min_t(unsigned int, ret, PAGE_SIZE - start);

-int __init init_umount(const char *name, int flags)

-{

- int lookup_flags = LOOKUP_MOUNTPOINT;

- struct path path;

- int ret;

-

- if (!(flags & UMOUNT_NOFOLLOW))

- lookup_flags |= LOOKUP_FOLLOW;

- ret = kern_path(name, lookup_flags, &path);

- if (ret)

- return ret;

- return path_umount(&path, flags);

-}

-

-extern const struct fs_context_operations legacy_fs_context_ops;

- /* paired with cmpxchg() below */

- if (cmpxchg(&inode->i_flctx, NULL, ctx)) {

-static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,

- struct inode *dir = nd->path.dentry->d_inode;

- if (nd->flags & LOOKUP_DIRECTORY)

- open_flag |= O_DIRECTORY;

-

- file->__f_path.mnt = nd->path.mnt;

- dentry = atomic_open(nd, dentry, file, open_flag, mode);

- struct mnt_namespace *ns)

- struct mount *m;

- /* Has the namespace already been emptied? */

- if (mnt_ns_id && mnt_ns_empty(ns))

- return -ENOENT;

- s->mnt = lookup_mnt_in_ns(mnt_id, ns);

- if (!s->mnt)

- return -ENOENT;

- err = grab_requested_root(ns, &s->root);

- if (err)

- return err;

- /*

- * Don't trigger audit denials. We just want to determine what

- * mounts to show users.

- */

- m = real_mount(s->mnt);

- if (!is_path_reachable(m, m->mnt.mnt_root, &s->root) &&

- !ns_capable_noaudit(ns->user_ns, CAP_SYS_ADMIN))

- return -EPERM;

- struct mnt_id_req *kreq)

- if (kreq->mnt_ns_fd != 0 && kreq->mnt_ns_id)

- return -EINVAL;

- /* The first valid unique mount id is MNT_UNIQUE_ID_OFFSET + 1. */

- if (kreq->mnt_id <= MNT_UNIQUE_ID_OFFSET)

- return -EINVAL;

- if (flags)

- ret = copy_mnt_id_req(req, &kreq);

- ns = grab_requested_mnt_ns(&kreq);

- if (IS_ERR(ns))

- return PTR_ERR(ns);

- if (kreq.mnt_ns_id && (ns != current->nsproxy->mnt_ns) &&

- !ns_capable_noaudit(ns->user_ns, CAP_SYS_ADMIN))

- return -ENOENT;

- ret = do_statmount(ks, kreq.mnt_id, kreq.mnt_ns_id, ns);

- ret = copy_mnt_id_req(req, &kreq);

-nfsd4_vfs_create(struct svc_fh *fhp, struct dentry *child,

- path.dentry = child;

- status = nfsd4_vfs_create(fhp, child, open);

- * dentry_create - Create and open a file

- * @path: path to create

- * @flags: O_ flags

- * @mode: mode bits for new file

- * @cred: credentials to use

- *

- * Caller must hold the parent directory's lock, and have prepared

- * a negative dentry, placed in @path->dentry, for the new file.

- *

- * Caller sets @path->mnt to the vfsmount of the filesystem where

- * the new file is to be created. The parent directory and the

- * negative dentry must reside on the same filesystem instance.

- *

- * On success, returns a "struct file *". Otherwise a ERR_PTR

- * is returned.

- */

-struct file *dentry_create(const struct path *path, int flags, umode_t mode,

- const struct cred *cred)

-{

- struct file *f;

- int error;

-

- f = alloc_empty_file(flags, cred);

- if (IS_ERR(f))

- return f;

-

- error = vfs_create(mnt_idmap(path->mnt), path->dentry, mode, NULL);

- if (!error)

- error = vfs_open(path, f);

-

- if (unlikely(error)) {

- fput(f);

- return ERR_PTR(error);

- }

- return f;

-}

-EXPORT_SYMBOL(dentry_create);

-

-/**

- int size = min_t(int, left, PAGE_SIZE - start);

- return smp_load_acquire(&inode->i_flctx);

- flctx = READ_ONCE(inode->i_flctx);

- flctx = READ_ONCE(inode->i_flctx);

- if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease)) {

- struct dentry *(*mount) (struct file_system_type *, int,

- const char *, void *);

-struct file *dentry_create(const struct path *path, int flags, umode_t mode,

- int (*remount_fs) (struct super_block *, int *, char *);

-int __init init_umount(const char *name, int flags);

-#define INITRD_MINOR 250 /* shouldn't collide with /dev/ram* too soon ... */

-

- refcount_t __ns_ref; /* do not use directly */

- __u32 mnt_ns_fd;

- KERN_REALROOTDEV=16, /* real root device to mount after initrd */

-static int __init load_ramdisk(char *str)

-{

- pr_warn("ignoring the deprecated load_ramdisk= option\n");

- return 1;

-}

-__setup("load_ramdisk=", load_ramdisk);

-

- if (initrd_load(saved_root_name))

- goto out;

-out:

-

-int __init rd_load_disk(int n);

-int __init rd_load_image(char *from);

-

-

-static inline int rd_load_disk(int n) { return 0; }

-static inline int rd_load_image(char *from) { return 0; }

-

-bool __init initrd_load(char *root_device_name);

-static inline bool initrd_load(char *root_device_name)

-{

- return false;

- }

-

-#include <linux/minix_fs.h>

-#include <linux/romfs_fs.h>

-#include <linux/sched.h>

-#include <linux/freezer.h>

-#include <linux/kmod.h>

-#include <uapi/linux/mount.h>

-static unsigned int real_root_dev; /* do_proc_dointvec cannot handle kdev_t */

-#ifdef CONFIG_SYSCTL

-static const struct ctl_table kern_do_mounts_initrd_table[] = {

- {

- .procname = "real-root-dev",

- .data = &real_root_dev,

- .maxlen = sizeof(int),

- .mode = 0644,

- .proc_handler = proc_dointvec,

- },

-};

-

-static __init int kernel_do_mounts_initrd_sysctls_init(void)

-{

- register_sysctl_init("kernel", kern_do_mounts_initrd_table);

- return 0;

-}

-late_initcall(kernel_do_mounts_initrd_sysctls_init);

-#endif /* CONFIG_SYSCTL */

-

-static int __init init_linuxrc(struct subprocess_info *info, struct cred *new)

-{

- ksys_unshare(CLONE_FS | CLONE_FILES);

- console_on_rootfs();

- /* move initrd over / and chdir/chroot in initrd root */

- init_chdir("/root");

- init_mount(".", "/", NULL, MS_MOVE, NULL);

- init_chroot(".");

- ksys_setsid();

- return 0;

-}

-

-static void __init handle_initrd(char *root_device_name)

-{

- struct subprocess_info *info;

- static char *argv[] = { "linuxrc", NULL, };

- extern char *envp_init[];

- int error;

-

- pr_warn("using deprecated initrd support, will be removed soon.\n");

-

- real_root_dev = new_encode_dev(ROOT_DEV);

- create_dev("/dev/root.old", Root_RAM0);

- /* mount initrd on rootfs' /root */

- mount_root_generic("/dev/root.old", root_device_name,

- root_mountflags & ~MS_RDONLY);

- init_mkdir("/old", 0700);

- init_chdir("/old");

-

- info = call_usermodehelper_setup("/linuxrc", argv, envp_init,

- GFP_KERNEL, init_linuxrc, NULL, NULL);

- if (!info)

- return;

- call_usermodehelper_exec(info, UMH_WAIT_PROC|UMH_FREEZABLE);

-

- /* move initrd to rootfs' /old */

- init_mount("..", ".", NULL, MS_MOVE, NULL);

- /* switch root and cwd back to / of rootfs */

- init_chroot("..");

-

- if (new_decode_dev(real_root_dev) == Root_RAM0) {

- init_chdir("/old");

- return;

- }

-

- init_chdir("/");

- ROOT_DEV = new_decode_dev(real_root_dev);

- mount_root(root_device_name);

-

- printk(KERN_NOTICE "Trying to move old root to /initrd ... ");

- error = init_mount("/old", "/root/initrd", NULL, MS_MOVE, NULL);

- if (!error)

- printk("okay\n");

- else {

- if (error == -ENOENT)

- printk("/initrd does not exist. Ignored.\n");

- else

- printk("failed\n");

- printk(KERN_NOTICE "Unmounting old root\n");

- init_umount("/old", MNT_DETACH);

- }

-}

-

-bool __init initrd_load(char *root_device_name)

- * Load the initrd data into /dev/ram0. Execute it as initrd

- * unless /dev/ram0 is supposed to be our actual root device,

- * in that case the ram disk is just set up here, and gets

- * mounted in the normal path.

- if (rd_load_image("/initrd.image") && ROOT_DEV != Root_RAM0) {

- init_unlink("/initrd.image");

- handle_initrd(root_device_name);

- return true;

- return false;

-static int __init prompt_ramdisk(char *str)

-{

- pr_warn("ignoring the deprecated prompt_ramdisk= option\n");

- return 1;

-}

-__setup("prompt_ramdisk=", prompt_ramdisk);

-

-int __init rd_load_image(char *from)

- in_file = filp_open(from, O_RDONLY, 0);

- if (strcmp(from, "/initrd.image") == 0)

- devblocks = nblocks;

- else

- devblocks = nr_blocks(in_file);

-int __init rd_load_disk(int n)

-{

- create_dev("/dev/root", ROOT_DEV);

- create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));

- return rd_load_image("/dev/root");

-}

-

-struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid,

- size_t set_tid_size)

- * set_tid_size contains the size of the set_tid array. Starting at

- * up to set_tid_size PID namespaces. It does not have to set the PID

- * for a process in all nested PID namespaces but set_tid_size must

- if (set_tid_size > ns->level + 1)

- tmp = ns;

- for (i = ns->level; i >= 0; i--) {

- int tid = 0;

- int pid_max = READ_ONCE(tmp->pid_max);

- if (set_tid_size) {

- tid = set_tid[ns->level - i];

- if (tid < 1 || tid >= pid_max)

- goto out_free;

- goto out_free;

- goto out_free;

- set_tid_size--;

- idr_preload(GFP_KERNEL);

- spin_lock(&pidmap_lock);

- pid_max, GFP_ATOMIC);

- spin_unlock(&pidmap_lock);

- idr_preload_end();

- if (nr < 0) {

- retval = (nr == -ENOSPC) ? -EAGAIN : nr;

-

- get_pid_ns(ns);

- refcount_set(&pid->count, 1);

- spin_lock_init(&pid->lock);

- for (type = 0; type < PIDTYPE_MAX; ++type)

- INIT_HLIST_HEAD(&pid->tasks[type]);

-

- init_waitqueue_head(&pid->wait_pidfd);

- INIT_HLIST_HEAD(&pid->inodes);

-

- upid = pid->numbers + ns->level;

- idr_preload(GFP_KERNEL);

- spin_lock(&pidmap_lock);

- if (!(ns->pid_allocated & PIDNS_ADDING))

- goto out_unlock;

- for ( ; upid >= pid->numbers; --upid) {

-out_unlock:

- spin_unlock(&pidmap_lock);

- idr_preload_end();

- put_pid_ns(ns);

-

- spin_lock(&pidmap_lock);

-struct file *rust_helper_get_file(struct file *f)

-struct pid_namespace *rust_helper_get_pid_ns(struct pid_namespace *ns)

-void rust_helper_put_pid_ns(struct pid_namespace *ns)

-struct pid_namespace *rust_helper_task_get_pid_ns(struct task_struct *task)

-void rust_helper_poll_wait(struct file *filp, wait_queue_head_t *wait_address,

- poll_table *p)

-static inline int statmount(uint64_t mnt_id, uint64_t mnt_ns_id, uint64_t mask,

- struct statmount *buf, size_t bufsize,

- .mnt_id = mnt_id,

- if (mnt_ns_id) {

- req.mnt_ns_id = mnt_ns_id;

-static struct statmount *statmount_alloc(uint64_t mnt_id, uint64_t mask, unsigned int flags)

- struct statmount *buf = NULL, *tmp = alloca(bufsize);

- ret = statmount(mnt_id, 0, mask, tmp, bufsize, flags);

- ret = statmount(root_id, 0, 0, &sm, sizeof(sm), 0);

- ret = statmount(root_id, 0, mask, &sm, sizeof(sm), 0);

- ret = statmount(root_id, 0, mask, &sm, sizeof(sm), 0);

- sm = statmount_alloc(root_id, STATMOUNT_MNT_POINT, 0);

- sm = statmount_alloc(root_id, STATMOUNT_MNT_ROOT, 0);

- sm = statmount_alloc(root_id, STATMOUNT_FS_TYPE, 0);

- sm = statmount_alloc(root_id, STATMOUNT_MNT_BASIC | STATMOUNT_MNT_OPTS,

- sm = statmount_alloc(root_id, mask, 0);

- ret = statmount(root_id, 0, mask, sm, exactsize, 0);

- ret = statmount(root_id, 0, mask, sm, shortsize, 0);

- ret = statmount(0, 0, 0, NULL, 0, 0);

- ksft_set_plan(15);

- ret = statmount(root_id, 0, STATMOUNT_MNT_NS_ID, &sm, sizeof(sm), 0);

- ret = statmount(list[i], mnt_ns_id, STATMOUNT_MNT_NS_ID, &sm,

- ret = statmount(0, 0, 0, NULL, 0, 0);