Release 4.17 fs/namespace.c

Directory: fs
/*
 *  linux/fs/namespace.c
 *
 * (C) Copyright Al Viro 2000, 2001
 *      Released under GPL v2.
 *
 * Based on code from fs/super.c, copyright Linus Torvalds and others.
 * Heavily rewritten.
 */

#include <linux/syscalls.h>
#include <linux/export.h>
#include <linux/capability.h>
#include <linux/mnt_namespace.h>
#include <linux/user_namespace.h>
#include <linux/namei.h>
#include <linux/security.h>
#include <linux/cred.h>
#include <linux/idr.h>
#include <linux/init.h>		/* init_rootfs */
#include <linux/fs_struct.h>	/* get_fs_root et.al. */
#include <linux/fsnotify.h>	/* fsnotify_vfsmount_delete */
#include <linux/uaccess.h>
#include <linux/proc_ns.h>
#include <linux/magic.h>
#include <linux/bootmem.h>
#include <linux/task_work.h>
#include <linux/sched/task.h>

#include "pnode.h"
#include "internal.h"

/* Maximum number of mounts in a mount namespace */

unsigned int sysctl_mount_max __read_mostly = 100000;


static unsigned int m_hash_mask __read_mostly;

static unsigned int m_hash_shift __read_mostly;

static unsigned int mp_hash_mask __read_mostly;

static unsigned int mp_hash_shift __read_mostly;


static __initdata unsigned long mhash_entries;


static int __init set_mhash_entries(char *str)
{
	if (!str)
		return 0;
	mhash_entries = simple_strtoul(str, &str, 0);
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%

__setup("mhash_entries=", set_mhash_entries);


static __initdata unsigned long mphash_entries;


static int __init set_mphash_entries(char *str)
{
	if (!str)
		return 0;
	mphash_entries = simple_strtoul(str, &str, 0);
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%

__setup("mphash_entries=", set_mphash_entries);


static u64 event;
static DEFINE_IDA(mnt_id_ida);
static DEFINE_IDA(mnt_group_ida);
static DEFINE_SPINLOCK(mnt_id_lock);

static int mnt_id_start = 0;

static int mnt_group_start = 1;


static struct hlist_head *mount_hashtable __read_mostly;

static struct hlist_head *mountpoint_hashtable __read_mostly;

static struct kmem_cache *mnt_cache __read_mostly;
static DECLARE_RWSEM(namespace_sem);

/* /sys/fs */

struct kobject *fs_kobj;
EXPORT_SYMBOL_GPL(fs_kobj);

/*
 * vfsmount lock may be taken for read to prevent changes to the
 * vfsmount hash, ie. during mountpoint lookups or walking back
 * up the tree.
 *
 * It should be taken for write in all cases where the vfsmount
 * tree or hash is modified or when a vfsmount structure is modified.
 */
__cacheline_aligned_in_smp DEFINE_SEQLOCK(mount_lock);



static inline struct hlist_head *m_hash(struct vfsmount *mnt, struct dentry *dentry)
{
	unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES);
	tmp += ((unsigned long)dentry / L1_CACHE_BYTES);
	tmp = tmp + (tmp >> m_hash_shift);
	return &mount_hashtable[tmp & m_hash_mask];
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 52 81.25% 1 33.33%
Al Viro 12 18.75% 2 66.67%
Total 64 100.00% 3 100.00%



static inline struct hlist_head *mp_hash(struct dentry *dentry)
{
	unsigned long tmp = ((unsigned long)dentry / L1_CACHE_BYTES);
	tmp = tmp + (tmp >> mp_hash_shift);
	return &mountpoint_hashtable[tmp & mp_hash_mask];
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 43 91.49% 1 33.33%
Linus Torvalds 2 4.26% 1 33.33%
Eric Dumazet 2 4.26% 1 33.33%
Total 47 100.00% 3 100.00%



static int mnt_alloc_id(struct mount *mnt)
{
	int res;

retry:
	ida_pre_get(&mnt_id_ida, GFP_KERNEL);
	spin_lock(&mnt_id_lock);
	res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id);
	if (!res)
		mnt_id_start = mnt->mnt_id + 1;
	spin_unlock(&mnt_id_lock);
	if (res == -EAGAIN)
		goto retry;

	return res;
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 58 75.32% 1 25.00%
Al Viro 17 22.08% 2 50.00%
Nicholas Piggin 2 2.60% 1 25.00%
Total 77 100.00% 4 100.00%



static void mnt_free_id(struct mount *mnt)
{
	int id = mnt->mnt_id;
	spin_lock(&mnt_id_lock);
	ida_remove(&mnt_id_ida, id);
	if (mnt_id_start > id)
		mnt_id_start = id;
	spin_unlock(&mnt_id_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 27 56.25% 1 25.00%
Al Viro 19 39.58% 2 50.00%
Nicholas Piggin 2 4.17% 1 25.00%
Total 48 100.00% 4 100.00%

/*
 * Allocate a new peer group ID
 *
 * mnt_group_ida is protected by namespace_sem
 */


static int mnt_alloc_group_id(struct mount *mnt)
{
	int res;

	if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL))
		return -ENOMEM;

	res = ida_get_new_above(&mnt_group_ida,
				mnt_group_start,
				&mnt->mnt_group_id);
	if (!res)
		mnt_group_start = mnt->mnt_group_id + 1;

	return res;
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 37 61.67% 1 33.33%
Al Viro 23 38.33% 2 66.67%
Total 60 100.00% 3 100.00%

/*
 * Release a peer group ID
 */


void mnt_release_group_id(struct mount *mnt)
{
	int id = mnt->mnt_group_id;
	ida_remove(&mnt_group_ida, id);
	if (mnt_group_start > id)
		mnt_group_start = id;
	mnt->mnt_group_id = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 22 53.66% 1 33.33%
Al Viro 19 46.34% 2 66.67%
Total 41 100.00% 3 100.00%

/*
 * vfsmount lock must be held for read
 */


static inline void mnt_add_count(struct mount *mnt, int n)
{
#ifdef CONFIG_SMP
	this_cpu_add(mnt->mnt_pcp->mnt_count, n);
#else
	preempt_disable();
	mnt->mnt_count += n;
	preempt_enable();
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 44 97.78% 1 50.00%
Al Viro 1 2.22% 1 50.00%
Total 45 100.00% 2 100.00%

/*
 * vfsmount lock must be held for write
 */


unsigned int mnt_get_count(struct mount *mnt)
{
#ifdef CONFIG_SMP
	unsigned int count = 0;
	int cpu;

	for_each_possible_cpu(cpu) {
		count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count;
	}

	return count;
#else
	return mnt->mnt_count;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 52 96.30% 1 33.33%
Al Viro 2 3.70% 2 66.67%
Total 54 100.00% 3 100.00%



static void drop_mountpoint(struct fs_pin *p)
{
	struct mount *m = container_of(p, struct mount, mnt_umount);
	dput(m->mnt_ex_mountpoint);
	pin_remove(p);
	mntput(&m->mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%



static struct mount *alloc_vfsmnt(const char *name)
{
	struct mount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
	if (mnt) {
		int err;

		err = mnt_alloc_id(mnt);
		if (err)
			goto out_free_cache;

		if (name) {
			mnt->mnt_devname = kstrdup_const(name, GFP_KERNEL);
			if (!mnt->mnt_devname)
				goto out_free_id;
		}

#ifdef CONFIG_SMP
		mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
		if (!mnt->mnt_pcp)
			goto out_free_devname;

		this_cpu_add(mnt->mnt_pcp->mnt_count, 1);
#else
		mnt->mnt_count = 1;
		mnt->mnt_writers = 0;
#endif

		INIT_HLIST_NODE(&mnt->mnt_hash);
		INIT_LIST_HEAD(&mnt->mnt_child);
		INIT_LIST_HEAD(&mnt->mnt_mounts);
		INIT_LIST_HEAD(&mnt->mnt_list);
		INIT_LIST_HEAD(&mnt->mnt_expire);
		INIT_LIST_HEAD(&mnt->mnt_share);
		INIT_LIST_HEAD(&mnt->mnt_slave_list);
		INIT_LIST_HEAD(&mnt->mnt_slave);
		INIT_HLIST_NODE(&mnt->mnt_mp_list);
		INIT_LIST_HEAD(&mnt->mnt_umounting);
		init_fs_pin(&mnt->mnt_umount, drop_mountpoint);
	}
	return mnt;

#ifdef CONFIG_SMP
out_free_devname:
	kfree_const(mnt->mnt_devname);
#endif
out_free_id:
	mnt_free_id(mnt);
out_free_cache:
	kmem_cache_free(mnt_cache, mnt);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 58 23.11% 3 11.54%
Nicholas Piggin 51 20.32% 2 7.69%
Al Viro 40 15.94% 7 26.92%
Li Zefan 28 11.16% 1 3.85%
Ram Pai 21 8.37% 2 7.69%
Miklos Szeredi 20 7.97% 2 7.69%
Eric W. Biedermann 16 6.37% 3 11.54%
David Howells 6 2.39% 1 3.85%
Dave Hansen 5 1.99% 1 3.85%
Andreas Gruenbacher 2 0.80% 1 3.85%
Andrzej Hajda 2 0.80% 1 3.85%
Andries E. Brouwer 1 0.40% 1 3.85%
Robert P. J. Day 1 0.40% 1 3.85%
Total 251 100.00% 26 100.00%

/*
 * Most r/o checks on a fs are for operations that take
 * discrete amounts of time, like a write() or unlink().
 * We must keep track of when those operations start
 * (for permission checks) and when they end, so that
 * we can determine when writes are able to occur to
 * a filesystem.
 */
/*
 * __mnt_is_readonly: check whether a mount is read-only
 * @mnt: the mount to check for its write status
 *
 * This shouldn't be used directly ouside of the VFS.
 * It does not guarantee that the filesystem will stay
 * r/w, just that it is right *now*.  This can not and
 * should not be used in place of IS_RDONLY(inode).
 * mnt_want/drop_write() will _keep_ the filesystem
 * r/w.
 */


int __mnt_is_readonly(struct vfsmount *mnt)
{
	if (mnt->mnt_flags & MNT_READONLY)
		return 1;
	if (sb_rdonly(mnt->mnt_sb))
		return 1;
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Dave Hansen 33 91.67% 2 66.67%
David Howells 3 8.33% 1 33.33%
Total 36 100.00% 3 100.00%

EXPORT_SYMBOL_GPL(__mnt_is_readonly);



static inline void mnt_inc_writers(struct mount *mnt)
{
#ifdef CONFIG_SMP
	this_cpu_inc(mnt->mnt_pcp->mnt_writers);
#else
	mnt->mnt_writers++;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Dave Hansen 16 48.48% 1 20.00%
Nicholas Piggin 16 48.48% 3 60.00%
Al Viro 1 3.03% 1 20.00%
Total 33 100.00% 5 100.00%



static inline void mnt_dec_writers(struct mount *mnt)
{
#ifdef CONFIG_SMP
	this_cpu_dec(mnt->mnt_pcp->mnt_writers);
#else
	mnt->mnt_writers--;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 17 51.52% 3 60.00%
Dave Hansen 15 45.45% 1 20.00%
Al Viro 1 3.03% 1 20.00%
Total 33 100.00% 5 100.00%



static unsigned int mnt_get_writers(struct mount *mnt)
{
#ifdef CONFIG_SMP
	unsigned int count = 0;
	int cpu;

	for_each_possible_cpu(cpu) {
		count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers;
	}

	return count;
#else
	return mnt->mnt_writers;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 32 58.18% 3 60.00%
Dave Hansen 22 40.00% 1 20.00%
Al Viro 1 1.82% 1 20.00%
Total 55 100.00% 5 100.00%



static int mnt_is_readonly(struct vfsmount *mnt)
{
	if (mnt->mnt_sb->s_readonly_remount)
		return 1;
	/* Order wrt setting s_flags/s_readonly_remount in do_remount() */
	smp_rmb();
	return __mnt_is_readonly(mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%

/*
 * Most r/o & frozen checks on a fs are for operations that take discrete
 * amounts of time, like a write() or unlink().  We must keep track of when
 * those operations start (for permission checks) and when they end, so that we
 * can determine when writes are able to occur to a filesystem.
 */
/**
 * __mnt_want_write - get write access to a mount without freeze protection
 * @m: the mount on which to take a write
 *
 * This tells the low-level filesystem that a write is about to be performed to
 * it, and makes sure that writes are allowed (mnt it read-write) before
 * returning success. This operation does not protect against filesystem being
 * frozen. When the write operation is finished, __mnt_drop_write() must be
 * called. This is effectively a refcount.
 */


int __mnt_want_write(struct vfsmount *m)
{
	struct mount *mnt = real_mount(m);
	int ret = 0;

	preempt_disable();
	mnt_inc_writers(mnt);
	/*
         * The store to mnt_inc_writers must be visible before we pass
         * MNT_WRITE_HOLD loop below, so that the slowpath can see our
         * incremented count after it has set MNT_WRITE_HOLD.
         */
	smp_mb();
	while (READ_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD)
		cpu_relax();
	/*
         * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
         * be set to match its requirements. So we must not load that until
         * MNT_WRITE_HOLD is cleared.
         */
	smp_rmb();
	if (mnt_is_readonly(m)) {
		mnt_dec_writers(mnt);
		ret = -EROFS;
	}
	preempt_enable();

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 38 46.34% 2 22.22%
Dave Hansen 25 30.49% 2 22.22%
Al Viro 14 17.07% 1 11.11%
Miao Xie 2 2.44% 1 11.11%
Mark Rutland 1 1.22% 1 11.11%
Miklos Szeredi 1 1.22% 1 11.11%
Jan Kara 1 1.22% 1 11.11%
Total 82 100.00% 9 100.00%

/**
 * mnt_want_write - get write access to a mount
 * @m: the mount on which to take a write
 *
 * This tells the low-level filesystem that a write is about to be performed to
 * it, and makes sure that writes are allowed (mount is read-write, filesystem
 * is not frozen) before returning success.  When the write operation is
 * finished, mnt_drop_write() must be called.  This is effectively a refcount.
 */


int mnt_want_write(struct vfsmount *m)
{
	int ret;

	sb_start_write(m->mnt_sb);
	ret = __mnt_want_write(m);
	if (ret)
		sb_end_write(m->mnt_sb);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Jan Kara 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(mnt_want_write);

/**
 * mnt_clone_write - get write access to a mount
 * @mnt: the mount on which to take a write
 *
 * This is effectively like mnt_want_write, except
 * it must only be used to take an extra write reference
 * on a mountpoint that we already know has a write reference
 * on it. This allows some optimisation.
 *
 * After finished, mnt_drop_write must be called as usual to
 * drop the reference.
 */


int mnt_clone_write(struct vfsmount *mnt)
{
	/* superblock may be r/o */
	if (__mnt_is_readonly(mnt))
		return -EROFS;
	preempt_disable();
	mnt_inc_writers(real_mount(mnt));
	preempt_enable();
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 36 92.31% 2 66.67%
Al Viro 3 7.69% 1 33.33%
Total 39 100.00% 3 100.00%

EXPORT_SYMBOL_GPL(mnt_clone_write);

/**
 * __mnt_want_write_file - get write access to a file's mount
 * @file: the file who's mount on which to take a write
 *
 * This is like __mnt_want_write, but it takes a file and can
 * do some optimisations if the file is open for write already
 */


int __mnt_want_write_file(struct file *file)
{
	if (!(file->f_mode & FMODE_WRITER))
		return __mnt_want_write(file->f_path.mnt);
	else
		return mnt_clone_write(file->f_path.mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 39 92.86% 1 33.33%
Jan Kara 2 4.76% 1 33.33%
Al Viro 1 2.38% 1 33.33%
Total 42 100.00% 3 100.00%

/**
 * mnt_want_write_file_path - get write access to a file's mount
 * @file: the file who's mount on which to take a write
 *
 * This is like mnt_want_write, but it takes a file and can
 * do some optimisations if the file is open for write already
 *
 * Called by the vfs for cases when we have an open file at hand, but will do an
 * inode operation on it (important distinction for files opened on overlayfs,
 * since the file operations will come from the real underlying file, while
 * inode operations come from the overlay).
 */


int mnt_want_write_file_path(struct file *file)
{
	int ret;

	sb_start_write(file->f_path.mnt->mnt_sb);
	ret = __mnt_want_write_file(file);
	if (ret)
		sb_end_write(file->f_path.mnt->mnt_sb);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Jan Kara 48 97.96% 1 50.00%
Miklos Szeredi 1 2.04% 1 50.00%
Total 49 100.00% 2 100.00%



static inline int may_write_real(struct file *file)
{
	struct dentry *dentry = file->f_path.dentry;
	struct dentry *upperdentry;

	/* Writable file? */
	if (file->f_mode & FMODE_WRITER)
		return 0;

	/* Not overlayfs? */
	if (likely(!(dentry->d_flags & DCACHE_OP_REAL)))
		return 0;

	/* File refers to upper, writable layer? */
	upperdentry = d_real(dentry, NULL, 0, D_REAL_UPPER);
	if (upperdentry &&
	    (file_inode(file) == d_inode(upperdentry) ||
	     file_inode(file) == d_inode(dentry)))
		return 0;

	/* Lower layer: can't write to real file, sorry... */
	return -EPERM;
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 94 88.68% 1 50.00%
Amir Goldstein 12 11.32% 1 50.00%
Total 106 100.00% 2 100.00%

/**
 * mnt_want_write_file - get write access to a file's mount
 * @file: the file who's mount on which to take a write
 *
 * This is like mnt_want_write, but it takes a file and can
 * do some optimisations if the file is open for write already
 *
 * Mostly called by filesystems from their ioctl operation before performing
 * modification.  On overlayfs this needs to check if the file is on a read-only
 * lower layer and deny access in that case.
 */


int mnt_want_write_file(struct file *file)
{
	int ret;

	ret = may_write_real(file);
	if (!ret) {
		sb_start_write(file_inode(file)->i_sb);
		ret = __mnt_want_write_file(file);
		if (ret)
			sb_end_write(file_inode(file)->i_sb);
	}
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 61 100.00% 1 100.00%
Total 61 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(mnt_want_write_file);

/**
 * __mnt_drop_write - give up write access to a mount
 * @mnt: the mount on which to give up write access
 *
 * Tells the low-level filesystem that we are done
 * performing writes to it.  Must be matched with
 * __mnt_want_write() call above.
 */


void __mnt_drop_write(struct vfsmount *mnt)
{
	preempt_disable();
	mnt_dec_writers(real_mount(mnt));
	preempt_enable();
}

Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 14 58.33% 2 40.00%
Dave Hansen 6 25.00% 1 20.00%
Al Viro 3 12.50% 1 20.00%
Jan Kara 1 4.17% 1 20.00%
Total 24 100.00% 5 100.00%

/**
 * mnt_drop_write - give up write access to a mount
 * @mnt: the mount on which to give up write access
 *
 * Tells the low-level filesystem that we are done performing writes to it and
 * also allows filesystem to be frozen again.  Must be matched with
 * mnt_want_write() call above.
 */


void mnt_drop_write(struct vfsmount *mnt)
{
	__mnt_drop_write(mnt);
	sb_end_write(mnt->mnt_sb);
}
Contributors
Person Tokens Prop Commits CommitProp
Jan Kara 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%

EXPORT_SYMBOL_GPL(mnt_drop_write);



void __mnt_drop_write_file(struct file *file)
{
	__mnt_drop_write(file->f_path.mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Jan Kara 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



void mnt_drop_write_file_path(struct file *file)
{
	mnt_drop_write(file->f_path.mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



void mnt_drop_write_file(struct file *file)
{
	__mnt_drop_write(file->f_path.mnt);
	sb_end_write(file_inode(file)->i_sb);
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 18 62.07% 1 50.00%
Miklos Szeredi 11 37.93% 1 50.00%
Total 29 100.00% 2 100.00%

EXPORT_SYMBOL(mnt_drop_write_file);



static int mnt_make_readonly(struct mount *mnt)
{
	int ret = 0;

	lock_mount_hash();
	mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
	/*
         * After storing MNT_WRITE_HOLD, we'll read the counters. This store
         * should be visible before we do.
         */
	smp_mb();

	/*
         * With writers on hold, if this value is zero, then there are
         * definitely no active writers (although held writers may subsequently
         * increment the count, they'll have to wait, and decrement it after
         * seeing MNT_READONLY).
         *
         * It is OK to have counter incremented on one CPU and decremented on
         * another: the sum will add up correctly. The danger would be when we
         * sum up each counter, if we read a counter before it is incremented,
         * but then read another CPU's count which it has been subsequently
         * decremented from -- we would see more decrements than we should.
         * MNT_WRITE_HOLD protects against this scenario, because
         * mnt_want_write first increments count, then smp_mb, then spins on
         * MNT_WRITE_HOLD, so it can't be decremented by another CPU while
         * we're counting up here.
         */
	if (mnt_get_writers(mnt) > 0)
		ret = -EBUSY;
	else
		mnt->mnt.mnt_flags |= MNT_READONLY;
	/*
         * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
         * that become unheld will see MNT_READONLY.
         */
	smp_wmb();
	mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
	unlock_mount_hash();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Dave Hansen 40 54.05% 3 42.86%
Nicholas Piggin 23 31.08% 2 28.57%
Al Viro 11 14.86% 2 28.57%
Total 74 100.00% 7 100.00%



static void __mnt_unmake_readonly(struct mount *mnt)
{
	lock_mount_hash();
	mnt->mnt.mnt_flags &= ~MNT_READONLY;
	unlock_mount_hash();
}

Contributors
Person Tokens Prop Commits CommitProp
Dave Hansen 19 73.08% 1 33.33%
Al Viro 7 26.92% 2 66.67%
Total 26 100.00% 3 100.00%



int sb_prepare_remount_readonly(struct super_block *sb)
{
	struct mount *mnt;
	int err = 0;

	/* Racy optimization.  Recheck the counter under MNT_WRITE_HOLD */
	if (atomic_long_read(&sb->s_remove_count))
		return -EBUSY;

	lock_mount_hash();
	list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
		if (!(mnt->mnt.mnt_flags & MNT_READONLY)) {
			mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
			smp_mb();
			if (mnt_get_writers(mnt) > 0) {
				err = -EBUSY;
				break;
			}
		}
	}
	if (!err && atomic_long_read(&sb->s_remove_count))
		err = -EBUSY;

	if (!err) {
		sb->s_readonly_remount = 1;
		smp_wmb();
	}
	list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
		if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD)
			mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
	}
	unlock_mount_hash();

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 156 97.50% 2 66.67%
Al Viro 4 2.50% 1 33.33%
Total 160 100.00% 3 100.00%



static void free_vfsmnt(struct mount *mnt)
{
	kfree_const(mnt->mnt_devname);
#ifdef CONFIG_SMP
	free_percpu(mnt->mnt_pcp);
#endif
	kmem_cache_free(mnt_cache, mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 21 56.76% 1 16.67%
Nicholas Piggin 12 32.43% 2 33.33%
Al Viro 3 8.11% 2 33.33%
Andrzej Hajda 1 2.70% 1 16.67%
Total 37 100.00% 6 100.00%



static void delayed_free_vfsmnt(struct rcu_head *head)
{
	free_vfsmnt(container_of(head, struct mount, mnt_rcu));
}

Contributors
Person Tokens Prop Commits CommitProp
David Howells 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%

/* call under rcu_read_lock */


int __legitimize_mnt(struct vfsmount *bastard, unsigned seq)
{
	struct mount *mnt;
	if (read_seqretry(&mount_lock, seq))
		return 1;
	if (bastard == NULL)
		return 0;
	mnt = real_mount(bastard);
	mnt_add_count(mnt, 1);
	if (likely(!read_seqretry(&mount_lock, seq)))
		return 0;
	if (bastard->mnt_flags & MNT_SYNC_UMOUNT) {
		mnt_add_count(mnt, -1);
		return 1;
	}
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 96 100.00% 2 100.00%
Total 96 100.00% 2 100.00%

/* call under rcu_read_lock */


bool legitimize_mnt(struct vfsmount *bastard, unsigned seq)
{
	int res = __legitimize_mnt(bastard, seq);
	if (likely(!res))
		return true;
	if (unlikely(res < 0)) {
		rcu_read_unlock();
		mntput(bastard);
		rcu_read_lock();
	}
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 59 100.00% 2 100.00%
Total 59 100.00% 2 100.00%

/*
 * find the first mount at @dentry on vfsmount @mnt.
 * call under rcu_read_lock()
 */


struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
{
	struct hlist_head *head = m_hash(mnt, dentry);
	struct mount *p;

	hlist_for_each_entry_rcu(p, head, mnt_hash)
		if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry)
			return p;
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 33 50.77% 1 16.67%
Al Viro 30 46.15% 4 66.67%
Ram Pai 2 3.08% 1 16.67%
Total 65 100.00% 6 100.00%

/*
 * lookup_mnt - Return the first child mount mounted at path
 *
 * "First" means first mounted chronologically.  If you create the
 * following mounts:
 *
 * mount /dev/sda1 /mnt
 * mount /dev/sda2 /mnt
 * mount /dev/sda3 /mnt
 *
 * Then lookup_mnt() on the base /mnt dentry in the root mount will
 * return successively the root dentry and vfsmount of /dev/sda1, then
 * /dev/sda2, then /dev/sda3, then NULL.
 *
 * lookup_mnt takes a reference to the found vfsmount.
 */


struct vfsmount *lookup_mnt(const struct path *path)
{
	struct mount *child_mnt;
	struct vfsmount *m;
	unsigned seq;

	rcu_read_lock();
	do {
		seq = read_seqbegin(&mount_lock);
		child_mnt = __lookup_mnt(path->mnt, path->dentry);
		m = child_mnt ? &child_mnt->mnt : NULL;
	} while (!legitimize_mnt(m, seq));
	rcu_read_unlock();
	return m;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 52 64.20% 4 57.14%
Ram Pai 26 32.10% 1 14.29%
Linus Torvalds 2 2.47% 1 14.29%
Andi Kleen 1 1.23% 1 14.29%
Total 81 100.00% 7 100.00%

/*
 * __is_local_mountpoint - Test to see if dentry is a mountpoint in the
 *                         current mount namespace.
 *
 * The common case is dentries are not mountpoints at all and that
 * test is handled inline.  For the slow case when we are actually
 * dealing with a mountpoint of some kind, walk through all of the
 * mounts in the current mount namespace and test to see if the dentry
 * is a mountpoint.
 *
 * The mount_hashtable is not usable in the context because we
 * need to identify all mounts that may be in the current mount
 * namespace not just a mount that happens to have some specified
 * parent mount.
 */


bool __is_local_mountpoint(struct dentry *dentry)
{
	struct mnt_namespace *ns = current->nsproxy->mnt_ns;
	struct mount *mnt;
	bool is_covered = false;

	if (!d_mountpoint(dentry))
		goto out;

	down_read(&namespace_sem);
	list_for_each_entry(mnt, &ns->list, mnt_list) {
		is_covered = (mnt->mnt_mountpoint == dentry);
		if (is_covered)
			break;
	}
	up_read(&namespace_sem);
out:
	return is_covered;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 84 100.00% 1 100.00%
Total 84 100.00% 1 100.00%



static struct mountpoint *lookup_mountpoint(struct dentry *dentry)
{
	struct hlist_head *chain = mp_hash(dentry);
	struct mountpoint *mp;

	hlist_for_each_entry(mp, chain, m_hash) {
		if (mp->m_dentry == dentry) {
			/* might be worth a WARN_ON() */
			if (d_unlinked(dentry))
				return ERR_PTR(-ENOENT);
			mp->m_count++;
			return mp;
		}
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 69 93.24% 2 66.67%
Eric W. Biedermann 5 6.76% 1 33.33%
Total 74 100.00% 3 100.00%



static struct mountpoint *get_mountpoint(struct dentry *dentry)
{
	struct mountpoint *mp, *new = NULL;
	int ret;

	if (d_mountpoint(dentry)) {
mountpoint:
		read_seqlock_excl(&mount_lock);
		mp = lookup_mountpoint(dentry);
		read_sequnlock_excl(&mount_lock);
		if (mp)
			goto done;
	}

	if (!new)
		new = kmalloc(sizeof(struct mountpoint), GFP_KERNEL);
	if (!new)
		return ERR_PTR(-ENOMEM);


	/* Exactly one processes may set d_mounted */
	ret = d_set_mounted(dentry);

	/* Someone else set d_mounted? */
	if (ret == -EBUSY)
		goto mountpoint;

	/* The dentry is not available as a mountpoint? */
	mp = ERR_PTR(ret);
	if (ret)
		goto done;

	/* Add the new mountpoint to the hash table */
	read_seqlock_excl(&mount_lock);
	new->m_dentry = dentry;
	new->m_count = 1;
	hlist_add_head(&new->m_hash, mp_hash(dentry));
	INIT_HLIST_HEAD(&new->m_list);
	read_sequnlock_excl(&mount_lock);

	mp = new;
	new = NULL;
done:
	kfree(new);
	return mp;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 129 67.54% 3 50.00%
Al Viro 57 29.84% 2 33.33%
Miklos Szeredi 5 2.62% 1 16.67%
Total 191 100.00% 6 100.00%



static void put_mountpoint(struct mountpoint *mp)
{
	if (!--mp->m_count) {
		struct dentry *dentry = mp->m_dentry;
		BUG_ON(!hlist_empty(&mp->m_list));
		spin_lock(&dentry->d_lock);
		dentry->d_flags &= ~DCACHE_MOUNTED;
		spin_unlock(&dentry->d_lock);
		hlist_del(&mp->m_hash);
		kfree(mp);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 66 84.62% 2 66.67%
Eric W. Biedermann 12 15.38% 1 33.33%
Total 78 100.00% 3 100.00%



static inline int check_mnt(struct mount *mnt)
{
	return mnt->mnt_ns == current->nsproxy->mnt_ns;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 16 69.57% 2 33.33%
Serge E. Hallyn 2 8.70% 1 16.67%
Kirill Korotaev 2 8.70% 1 16.67%
David Howells 2 8.70% 1 16.67%
Al Viro 1 4.35% 1 16.67%
Total 23 100.00% 6 100.00%

/*
 * vfsmount lock must be held for write
 */


static void touch_mnt_namespace(struct mnt_namespace *ns)
{
	if (ns) {
		ns->event = ++event;
		wake_up_interruptible(&ns->poll);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 30 93.75% 1 50.00%
Kirill Korotaev 2 6.25% 1 50.00%
Total 32 100.00% 2 100.00%

/*
 * vfsmount lock must be held for write
 */


static void __touch_mnt_namespace(struct mnt_namespace *ns)
{
	if (ns && ns->event != event) {
		ns->event = event;
		wake_up_interruptible(&ns->poll);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 35 94.59% 1 50.00%
Kirill Korotaev 2 5.41% 1 50.00%
Total 37 100.00% 2 100.00%

/*
 * vfsmount lock must be held for write
 */


static void unhash_mnt(struct mount *mnt)
{
	mnt->mnt_parent = mnt;
	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
	list_del_init(&mnt->mnt_child);
	hlist_del_init_rcu(&mnt->mnt_hash);
	hlist_del_init(&mnt->mnt_mp_list);
	put_mountpoint(mnt->mnt_mp);
	mnt->mnt_mp = NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 33 51.56% 1 14.29%
Al Viro 13 20.31% 3 42.86%
Eric W. Biedermann 9 14.06% 2 28.57%
Nicholas Piggin 9 14.06% 1 14.29%
Total 64 100.00% 7 100.00%

/*
 * vfsmount lock must be held for write
 */


static void detach_mnt(struct mount *mnt, struct path *old_path)
{
	old_path->dentry = mnt->mnt_mountpoint;
	old_path->mnt = &mnt->mnt_parent->mnt;
	unhash_mnt(mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%

/*
 * vfsmount lock must be held for write
 */


static void umount_mnt(struct mount *mnt)
{
	/* old mountpoint will be dropped when we can do that */
	mnt->mnt_ex_mountpoint = mnt->mnt_mountpoint;
	unhash_mnt(mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

/*
 * vfsmount lock must be held for write
 */


void mnt_set_mountpoint(struct mount *mnt,
			struct mountpoint *mp,
			struct mount *child_mnt)
{
	mp->m_count++;
	mnt_add_count(mnt, 1);	/* essentially, that's mntget */
	child_mnt->mnt_mountpoint = dget(mp->m_dentry);
	child_mnt->mnt_parent = mnt;
	child_mnt->mnt_mp = mp;
	hlist_add_head(&child_mnt->mnt_mp_list, &mp->m_list);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 27 39.13% 5 55.56%
Linus Torvalds 18 26.09% 1 11.11%
Eric W. Biedermann 13 18.84% 1 11.11%
Ram Pai 10 14.49% 1 11.11%
Nicholas Piggin 1 1.45% 1 11.11%
Total 69 100.00% 9 100.00%



static void __attach_mnt(struct mount *mnt, struct mount *parent)
{
	hlist_add_head_rcu(&mnt->mnt_hash,
			   m_hash(&parent->mnt, mnt->mnt_mountpoint));
	list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 23 46.94% 1 11.11%
Ram Pai 12 24.49% 1 11.11%
Al Viro 11 22.45% 6 66.67%
Eric W. Biedermann 3 6.12% 1 11.11%
Total 49 100.00% 9 100.00%

/*
 * vfsmount lock must be held for write
 */


static void attach_mnt(struct mount *mnt,
			struct mount *parent,
			struct mountpoint *mp)
{
	mnt_set_mountpoint(parent, mp, mnt);
	__attach_mnt(mnt, parent);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 21 56.76% 1 33.33%
Eric W. Biedermann 15 40.54% 1 33.33%
Linus Torvalds 1 2.70% 1 33.33%
Total 37 100.00% 3 100.00%



void mnt_change_mountpoint(struct mount *parent, struct mountpoint *mp, struct mount *mnt)
{
	struct mountpoint *old_mp = mnt->mnt_mp;
	struct dentry *old_mountpoint = mnt->mnt_mountpoint;
	struct mount *old_parent = mnt->mnt_parent;

	list_del_init(&mnt->mnt_child);
	hlist_del_init(&mnt->mnt_mp_list);
	hlist_del_init_rcu(&mnt->mnt_hash);

	attach_mnt(mnt, parent, mp);

	put_mountpoint(old_mp);

	/*
         * Safely avoid even the suggestion this code might sleep or
         * lock the mount hash by taking advantage of the knowledge that
         * mnt_change_mountpoint will not release the final reference
         * to a mountpoint.
         *
         * During mounting, the mount passed in as the parent mount will
         * continue to use the old mountpoint and during unmounting, the
         * old mountpoint will continue to exist until namespace_unlock,
         * which happens well after mnt_change_mountpoint.
         */
	spin_lock(&old_mountpoint->d_lock);
	old_mountpoint->d_lockref.count--;
	spin_unlock(&old_mountpoint->d_lock);

	mnt_add_count(old_parent, -1);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 89 76.07% 1 50.00%
Al Viro 28 23.93% 1 50.00%
Total 117 100.00% 2 100.00%

/*
 * vfsmount lock must be held for write
 */


static void commit_tree(struct mount *mnt)
{
	struct mount *parent = mnt->mnt_parent;
	struct mount *m;
	LIST_HEAD(head);
	struct mnt_namespace *n = parent->mnt_ns;

	BUG_ON(parent == mnt);

	list_add_tail(&head, &mnt->mnt_list);
	list_for_each_entry(m, &head, mnt_list)
		m->mnt_ns = n;

	list_splice(&head, n->list.prev);

	n->mounts += n->pending_mounts;
	n->pending_mounts = 0;

	__attach_mnt(mnt, parent);
	touch_mnt_namespace(n);
}

Contributors
Person Tokens Prop Commits CommitProp
Ram Pai 82 75.23% 1 11.11%
Eric W. Biedermann 15 13.76% 2 22.22%
Linus Torvalds 4 3.67% 1 11.11%
Kirill Korotaev 4 3.67% 1 11.11%
Al Viro 4 3.67% 4 44.44%
Total 109 100.00% 9 100.00%



static struct mount *next_mnt(struct mount *p, struct mount *root)
{
	struct list_head *next = p->mnt_mounts.next;
	if (next == &p->mnt_mounts) {
		while (1) {
			if (p == root)
				return NULL;
			next = p->mnt_child.next;
			if (next != &p->mnt_parent->mnt_mounts)
				break;
			p = p->mnt_parent;
		}
	}
	return list_entry(next, struct mount, mnt_child);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 88 95.65% 1 33.33%
Al Viro 4 4.35% 2 66.67%
Total 92 100.00% 3 100.00%



static struct mount *skip_mnt_tree(struct mount *p)
{
	struct list_head *prev = p->mnt_mounts.prev;
	while (prev != &p->mnt_mounts) {
		p = list_entry(prev, struct mount, mnt_child);
		prev = p->mnt_mounts.prev;
	}
	return p;
}

Contributors
Person Tokens Prop Commits CommitProp
Ram Pai 55 94.83% 1 50.00%
Al Viro 3 5.17% 1 50.00%
Total 58 100.00% 2 100.00%


struct vfsmount *

vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
	struct mount *mnt;
	struct dentry *root;

	if (!type)
		return ERR_PTR(-ENODEV);

	mnt = alloc_vfsmnt(name);
	if (!mnt)
		return ERR_PTR(-ENOMEM);

	if (flags & SB_KERNMOUNT)
		mnt->mnt.mnt_flags = MNT_INTERNAL;

	root = mount_fs(type, flags, name, data);
	if (IS_ERR(root)) {
		mnt_free_id(mnt);
		free_vfsmnt(mnt);
		return ERR_CAST(root);
	}

	mnt->mnt.mnt_root = root;
	mnt->mnt.mnt_sb = root->d_sb;
	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
	mnt->mnt_parent = mnt;
	lock_mount_hash();
	list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
	unlock_mount_hash();
	return &mnt->mnt;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 155 87.08% 3 50.00%
Miklos Szeredi 17 9.55% 1 16.67%
David Howells 6 3.37% 2 33.33%
Total 178 100.00% 6 100.00%

EXPORT_SYMBOL_GPL(vfs_kern_mount);


struct vfsmount *

vfs_submount(const struct dentry *mountpoint, struct file_system_type *type,
	     const char *name, void *data)
{
	/* Until it is worked out how to pass the user namespace
         * through from the parent mount to the submount don't support
         * unprivileged mounts with submounts.
         */
	if (mountpoint->d_sb->s_user_ns != &init_user_ns)
		return ERR_PTR(-EPERM);

	return vfs_kern_mount(type, SB_SUBMOUNT, name, data);
}
Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 57 98.28% 1 50.00%
David Howells 1 1.72% 1 50.00%
Total 58 100.00% 2 100.00%

EXPORT_SYMBOL_GPL(vfs_submount);



static struct mount *clone_mnt(struct mount *old, struct dentry *root,
					int flag)
{
	struct super_block *sb = old->mnt.mnt_sb;
	struct mount *mnt;
	int err;

	mnt = alloc_vfsmnt(old->mnt_devname);
	if (!mnt)
		return ERR_PTR(-ENOMEM);

	if (flag & (CL_SLAVE | CL_PRIVATE | CL_SHARED_TO_SLAVE))
		mnt->mnt_group_id = 0; /* not a peer of original */
	else
		mnt->mnt_group_id = old->mnt_group_id;

	if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
		err = mnt_alloc_group_id(mnt);
		if (err)
			goto out_free;
	}

	mnt->mnt.mnt_flags = old->mnt.mnt_flags;
	mnt->mnt.mnt_flags &= ~(MNT_WRITE_HOLD|MNT_MARKED|MNT_INTERNAL);
	/* Don't allow unprivileged users to change mount flags */
	if (flag & CL_UNPRIVILEGED) {
		mnt->mnt.mnt_flags |= MNT_LOCK_ATIME;

		if (mnt->mnt.mnt_flags & MNT_READONLY)
			mnt->mnt.mnt_flags |= MNT_LOCK_READONLY;

		if (mnt->mnt.mnt_flags & MNT_NODEV)
			mnt->mnt.mnt_flags |= MNT_LOCK_NODEV;

		if (mnt->mnt.mnt_flags & MNT_NOSUID)
			mnt->mnt.mnt_flags |= MNT_LOCK_NOSUID;

		if (mnt->mnt.mnt_flags & MNT_NOEXEC)
			mnt->mnt.mnt_flags |= MNT_LOCK_NOEXEC;
	}

	/* Don't allow unprivileged users to reveal what is under a mount */
	if ((flag & CL_UNPRIVILEGED) &&
	    (!(flag & CL_EXPIRE) || list_empty(&old->mnt_expire)))
		mnt->mnt.mnt_flags |= MNT_LOCKED;

	atomic_inc(&sb->s_active);
	mnt->mnt.mnt_sb = sb;
	mnt->mnt.mnt_root = dget(root);
	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
	mnt->mnt_parent = mnt;
	lock_mount_hash();
	list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
	unlock_mount_hash();

	if ((flag & CL_SLAVE) ||
	    ((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) {
		list_add(&mnt->mnt_slave, &old->mnt_slave_list);
		mnt->mnt_master = old;
		CLEAR_MNT_SHARED(mnt);
	} else if (!(flag & CL_PRIVATE)) {
		if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
			list_add(&mnt->mnt_share, &old->mnt_share);
		if (IS_MNT_SLAVE(old))
			list_add(&mnt->mnt_slave, &old->mnt_slave);
		mnt->mnt_master = old->mnt_master;
	} else {
		CLEAR_MNT_SHARED(mnt);
	}
	if (flag & CL_MAKE_SHARED)
		set_mnt_shared(mnt);

	/* stick the duplicate mount on the same expiry list
         * as the original if that was on one */
	if (flag & CL_EXPIRE) {
		if (!list_empty(&old->mnt_expire))
			list_add(&mnt->mnt_expire, &old->mnt_expire);
	}

	return mnt;

 out_free:
	mnt_free_id(mnt);
	free_vfsmnt(mnt);
	return ERR_PTR(err);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 140 27.13% 5 17.86%
Ram Pai 104 20.16% 3 10.71%
Linus Torvalds 85 16.47% 3 10.71%
Miklos Szeredi 73 14.15% 4 14.29%
David Howells 52 10.08% 3 10.71%
Al Viro 51 9.88% 9 32.14%
Nicholas Piggin 11 2.13% 1 3.57%
Total 516 100.00% 28 100.00%



static void cleanup_mnt(struct mount *mnt)
{
	/*
         * This probably indicates that somebody messed
         * up a mnt_want/drop_write() pair.  If this
         * happens, the filesystem was probably unable
         * to make r/w->r/o transitions.
         */
	/*
         * The locking used to deal with mnt_count decrement provides barriers,
         * so mnt_get_writers() below is safe.
         */
	WARN_ON(mnt_get_writers(mnt));
	if (unlikely(mnt->mnt_pins.first))
		mnt_pin_kill(mnt);
	fsnotify_vfsmount_delete(&mnt->mnt);
	dput(mnt->mnt.mnt_root);
	deactivate_super(mnt->mnt.mnt_sb);
	mnt_free_id(mnt);
	call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 78 100.00% 1 100.00%
Total 78 100.00% 1 100.00%



static void __cleanup_mnt(struct rcu_head *head)
{
	cleanup_mnt(container_of(head, struct mount, mnt_rcu));
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%

static LLIST_HEAD(delayed_mntput_list);


static void delayed_mntput(struct work_struct *unused)
{
	struct llist_node *node = llist_del_all(&delayed_mntput_list);
	struct mount *m, *t;

	llist_for_each_entry_safe(m, t, node, mnt_llist)
		cleanup_mnt(m);
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 31 68.89% 1 50.00%
Byungchul Park 14 31.11% 1 50.00%
Total 45 100.00% 2 100.00%

static DECLARE_DELAYED_WORK(delayed_mntput_work, delayed_mntput);



static void mntput_no_expire(struct mount *mnt)
{
	rcu_read_lock();
	mnt_add_count(mnt, -1);
	if (likely(mnt->mnt_ns)) { /* shouldn't be the last one */
		rcu_read_unlock();
		return;
	}
	lock_mount_hash();
	if (mnt_get_count(mnt)) {
		rcu_read_unlock();
		unlock_mount_hash();
		return;
	}
	if (unlikely(mnt->mnt.mnt_flags & MNT_DOOMED)) {
		rcu_read_unlock();
		unlock_mount_hash();
		return;
	}
	mnt->mnt.mnt_flags |= MNT_DOOMED;
	rcu_read_unlock();

	list_del(&mnt->mnt_instance);

	if (unlikely(!list_empty(&mnt->mnt_mounts))) {
		struct mount *p, *tmp;
		list_for_each_entry_safe(p, tmp, &mnt->mnt_mounts,  mnt_child) {
			umount_mnt(p);
		}
	}
	unlock_mount_hash();

	if (likely(!(mnt->mnt.mnt_flags & MNT_INTERNAL))) {
		struct task_struct *task = current;
		if (likely(!(task->flags & PF_KTHREAD))) {
			init_task_work(&mnt->mnt_rcu, __cleanup_mnt);
			if (!task_work_add(task, &mnt->mnt_rcu, true))
				return;
		}
		if (llist_add(&mnt->mnt_llist, &delayed_mntput_list))
			schedule_delayed_work(&delayed_mntput_work, 1);
		return;
	}
	cleanup_mnt(mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 151 63.98% 6 66.67%
Eric W. Biedermann 41 17.37% 1 11.11%
Nicholas Piggin 36 15.25% 1 11.11%
Miklos Szeredi 8 3.39% 1 11.11%
Total 236 100.00% 9 100.00%



void mntput(struct vfsmount *mnt)
{
	if (mnt) {
		struct mount *m = real_mount(mnt);
		/* avoid cacheline pingpong, hope gcc doesn't get "smart" */
		if (unlikely(m->mnt_expiry_mark))
			m->mnt_expiry_mark = 0;
		mntput_no_expire(m);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
Nicholas Piggin 17 36.17% 1 14.29%
Al Viro 15 31.91% 3 42.86%
Linus Torvalds 12 25.53% 1 14.29%
Andreas Gruenbacher 2 4.26% 1 14.29%
Dave Hansen 1 2.13% 1 14.29%
Total 47 100.00% 7 100.00%

EXPORT_SYMBOL(mntput);



struct vfsmount *mntget(struct vfsmount *mnt)
{
	if (mnt)
		mnt_add_count(real_mount(mnt), 1);
	return mnt;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 17 58.62% 3 60.00%
Nicholas Piggin 12 41.38% 2 40.00%
Total 29 100.00% 5 100.00%

EXPORT_SYMBOL(mntget);

/* path_is_mountpoint() - Check if path is a mount in the current
 *                          namespace.
 *
 *  d_mountpoint() can only be used reliably to establish if a dentry is
 *  not mounted in any namespace and that common case is handled inline.
 *  d_mountpoint() isn't aware of the possibility there may be multiple
 *  mounts using a given dentry in a different namespace. This function
 *  checks if the passed in path is a mountpoint rather than the dentry
 *  alone.
 */


bool path_is_mountpoint(const struct path *path)
{
	unsigned seq;
	bool res;

	if (!d_mountpoint(path->dentry))
		return false;

	rcu_read_lock();
	do {
		seq = read_seqbegin(&mount_lock);
		res = __path_is_mountpoint(path);
	} while (read_seqretry(&mount_lock, seq));
	rcu_read_unlock();

	return res;
}
Contributors
Person Tokens Prop Commits CommitProp
Ian Kent 68 100.00% 1 100.00%
Total 68 100.00% 1 100.00%

EXPORT_SYMBOL(path_is_mountpoint);



struct vfsmount *mnt_clone_internal(const struct path *path)
{
	struct mount *p;
	p = clone_mnt(real_mount(path->mnt), path->dentry, CL_PRIVATE);
	if (IS_ERR(p))
		return ERR_CAST(p);
	p->mnt.mnt_flags |= MNT_INTERNAL;
	return &p->mnt;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 63 100.00% 4 100.00%
Total 63 100.00% 4 100.00%

#ifdef CONFIG_PROC_FS
/* iterator; we want it to have access to namespace_sem, thus here... */


static void *m_start(struct seq_file *m, loff_t *pos)
{
	struct proc_mounts *p = m->private;

	down_read(&namespace_sem);
	if (p->cached_event == p->ns->event) {
		void *v = p->cached_mount;
		if (*pos == p->cached_index)
			return v;
		if (*pos == p->cached_index + 1) {
			v = seq_list_next(v, &p->ns->list, &p->cached_index);
			return p->cached_mount = v;
		}
	}

	p->cached_event = p->ns->event;
	p->cached_mount = seq_list_start(&p->ns->list, *pos);
	p->cached_index = *pos;
	return p->cached_mount;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 99 69.23% 2 22.22%
Linus Torvalds 30 20.98% 3 33.33%
Pavel Emelyanov 6 4.20% 1 11.11%
Miklos Szeredi 5 3.50% 1 11.11%
Yann Droneaud 2 1.40% 1 11.11%
Ram Pai 1 0.70% 1 11.11%
Total 143 100.00% 9 100.00%



static void *m_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct proc_mounts *p = m->private;

	p->cached_mount = seq_list_next(v, &p->ns->list, pos);
	p->cached_index = *pos;
	return p->cached_mount;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 30 50.85% 3 37.50%
Al Viro 17 28.81% 2 25.00%
Miklos Szeredi 5 8.47% 1 12.50%
Pavel Emelyanov 5 8.47% 1 12.50%
Yann Droneaud 2 3.39% 1 12.50%
Total 59 100.00% 8 100.00%



static void m_stop(struct seq_file *m, void *v)
{
	up_read(&namespace_sem);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 20 95.24% 3 75.00%
Ram Pai 1 4.76% 1 25.00%
Total 21 100.00% 4 100.00%



static int m_show(struct seq_file *m, void *v)
{
	struct proc_mounts *p = m->private;
	struct mount *r = list_entry(v, struct mount, mnt_list);
	return p->show(m, &r->mnt);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 33 63.46% 2 28.57%
Ram Pai 11 21.15% 1 14.29%
Linus Torvalds 3 5.77% 1 14.29%
Eric Paris 2 3.85% 1 14.29%
Yann Droneaud 2 3.85% 1 14.29%
Kay Sievers 1 1.92% 1 14.29%
Total 52 100.00% 7 100.00%


const struct seq_operations mounts_op = {
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= m_show,
};
#endif  /* CONFIG_PROC_FS */

/**
 * may_umount_tree - check if a mount tree is busy
 * @mnt: root of mount tree
 *
 * This is called to check if a tree of mounts has any
 * open files, pwds, chroots or sub mounts that are
 * busy.
 */


int may_umount_tree(struct vfsmount *m)
{
	struct mount *mnt = real_mount(m);
	int actual_refs = 0;
	int minimum_refs = 0;
	struct mount *p;
	BUG_ON(!m);

	/* write lock needed for mnt_get_count */
	lock_mount_hash();
	for (p = mnt; p; p = next_mnt(p, mnt)) {
		actual_refs += mnt_get_count(p);
		minimum_refs += 2;
	}
	unlock_mount_hash();

	if (actual_refs > minimum_refs)
		return 0;

	return 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 29 32.22% 2 22.22%
Al Viro 22 24.44% 3 33.33%
Ram Pai 20 22.22% 1 11.11%
Linus Torvalds 15 16.67% 1 11.11%
Nicholas Piggin 2 2.22% 1 11.11%
Ian Kent 2 2.22% 1 11.11%
Total 90 100.00% 9 100.00%

EXPORT_SYMBOL(may_umount_tree);

/**
 * may_umount - check if a mount point is busy
 * @mnt: root of mount
 *
 * This is called to check if a mount point has any
 * open files, pwds, chroots or sub mounts. If the
 * mount has sub mounts this will return busy
 * regardless of whether the sub mounts are busy.
 *
 * Doesn't take quota and stuff into account. IOW, in some cases it will
 * give false negatives. The main reason why it's here is that we need
 * a non-destructive way to look for easily umountable filesystems.
 */


int may_umount(struct vfsmount *mnt)
{
	int ret = 1;
	down_read(&namespace_sem);
	lock_mount_hash();
	if (propagate_mount_busy(real_mount(mnt), 2))
		ret = 0;
	unlock_mount_hash();
	up_read(&namespace_sem);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 19 36.54% 3 42.86%
Andrew Morton 18 34.62% 2 28.57%
Ram Pai 13 25.00% 1 14.29%
Ian Kent 2 3.85% 1 14.29%
Total 52 100.00% 7 100.00%

EXPORT_SYMBOL(may_umount);

static HLIST_HEAD(unmounted);	/* protected by namespace_sem */



static void namespace_unlock(void)
{
	struct hlist_head head;

	hlist_move_list(&unmounted, &head);

	up_write(&namespace_sem);

	if (likely(hlist_empty(&head)))
		return;

	synchronize_rcu();

	group_pin_kill(&head);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 25 52.08% 5 62.50%
Eric W. Biedermann 13 27.08% 1 12.50%
Linus Torvalds 7 14.58% 1 12.50%
Ram Pai 3 6.25% 1 12.50%
Total 48 100.00% 8 100.00%



static inline void namespace_lock(void)
{
	down_write(&namespace_sem);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 15 100.00% 2 100.00%
Total 15 100.00% 2 100.00%


enum umount_tree_flags {
	
UMOUNT_SYNC = 1,
	
UMOUNT_PROPAGATE = 2,
	
UMOUNT_CONNECTED = 4,
};



static bool disconnect_mount(struct mount *mnt, enum umount_tree_flags how)
{
	/* Leaving mounts connected is only valid for lazy umounts */
	if (how & UMOUNT_SYNC)
		return true;

	/* A mount without a parent has nothing to be connected to */
	if (!mnt_has_parent(mnt))
		return true;

	/* Because the reference counting rules change when mounts are
         * unmounted and connected, umounted mounts may not be
         * connected to mounted mounts.
         */
	if (!(mnt->mnt_parent->mnt.mnt_flags & MNT_UMOUNT))
		return true;

	/* Has it been requested that the mount remain connected? */
	if (how & UMOUNT_CONNECTED)
		return false;

	/* Is the mount locked such that it needs to remain connected? */
	if (IS_MNT_LOCKED(mnt))
		return false;

	/* By default disconnect the mount */
	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 81 100.00% 1 100.00%
Total 81 100.00% 1 100.00%

/*
 * mount_lock must be held
 * namespace_sem must be held for write
 */


static void umount_tree(struct mount *mnt, enum umount_tree_flags how)
{
	LIST_HEAD(tmp_list);
	struct mount *p;

	if (how & UMOUNT_PROPAGATE)
		propagate_mount_unlock(mnt);

	/* Gather the mounts to umount */
	for (p = mnt; p; p = next_mnt(p, mnt)) {
		p->mnt.mnt_flags |= MNT_UMOUNT;
		list_move(&p->mnt_list, &tmp_list);
	}

	/* Hide the mounts from mnt_mounts */
	list_for_each_entry(p, &tmp_list, mnt_list) {
		list_del_init(&p->mnt_child);
	}

	/* Add propogated mounts to the tmp_list */
	if (how & UMOUNT_PROPAGATE)
		propagate_umount(&tmp_list);

	while (!list_empty(&tmp_list)) {
		struct mnt_namespace *ns;
		bool disconnect;
		p = list_first_entry(&tmp_list, struct mount, mnt_list);
		list_del_init(&p->mnt_expire);
		list_del_init(&p->mnt_list);
		ns = p->mnt_ns;
		if (ns) {
			ns->mounts--;
			__touch_mnt_namespace(ns);
		}
		p->mnt_ns = NULL;
		if (how & UMOUNT_SYNC)
			p->mnt.mnt_flags |= MNT_SYNC_UMOUNT;

		disconnect = disconnect_mount(p, how);

		pin_insert_group(&p->mnt_umount, &p->mnt_parent->mnt,
				 disconnect ? &unmounted : NULL);
		if (mnt_has_parent(p)) {
			mnt_add_count(p->mnt_parent, -1);
			if (!disconnect) {
				/* Don't forget about p */
				list_add_tail(&p->mnt_child, &p->mnt_parent->mnt_mounts);
			} else {
				umount_mnt(p);
			}
		}
		change_mnt_propagation(p, MS_PRIVATE);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 112 39.30% 9 37.50%
Al Viro 93 32.63% 11 45.83%
Ram Pai 62 21.75% 2 8.33%
Linus Torvalds 17 5.96% 1 4.17%
Kirill Korotaev 1 0.35% 1 4.17%
Total 285 100.00% 24 100.00%

static void shrink_submounts(struct mount *mnt);



static int do_umount(struct mount *mnt, int flags)
{
	struct super_block *sb = mnt->mnt.mnt_sb;
	int retval;

	retval = security_sb_umount(&mnt->mnt, flags);
	if (retval)
		return retval;

	/*
         * Allow userspace to request a mountpoint be expired rather than
         * unmounting unconditionally. Unmount only happens if:
         *  (1) the mark is already set (the mark is cleared by mntput())
         *  (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
         */
	if (flags & MNT_EXPIRE) {
		if (&mnt->mnt == current->fs->root.mnt ||
		    flags & (MNT_FORCE | MNT_DETACH))
			return -EINVAL;

		/*
                 * probably don't strictly need the lock here if we examined
                 * all race cases, but it's a slowpath.
                 */
		lock_mount_hash();
		if (mnt_get_count(mnt) != 2) {
			unlock_mount_hash();
			return -EBUSY;
		}
		unlock_mount_hash();

		if (!xchg(&mnt->mnt_expiry_mark, 1))
			return -EAGAIN;
	}

	/*
         * If we may have to abort operations to get out of this
         * mount, and they will themselves hold resources we must
         * allow the fs to do things. In the Unix tradition of
         * 'Gee thats tricky lets do it in userspace' the umount_begin
         * might fail to complete on the first run through as other tasks
         * must return, and the like. Thats for the mount program to worry
         * about for the moment.
         */

	if (flags & MNT_FORCE && sb->s_op->umount_begin) {
		sb->s_op->umount_begin(sb);
	}

	/*
         * No sense to grab the lock for this test, but test itself looks
         * somewhat bogus. Suggestions for better replacement?
         * Ho-hum... In principle, we might treat that as umount + switch
         * to rootfs. GC would eventually take care of the old vfsmount.
         * Actually it makes sense, especially if rootfs would contain a
         * /reboot - static binary that would close all descriptors and
         * call reboot(9). Then init(8) could umount root and exec /reboot.
         */
	if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
		/*
                 * Special case for "unmounting" root ...
                 * we just try to remount it readonly.
                 */
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;
		down_write(&sb->s_umount);
		if (!sb_rdonly(sb))
			retval = do_remount_sb(sb, SB_RDONLY, NULL, 0);
		up_write(&sb->s_umount);
		return retval;
	}

	namespace_lock();
	lock_mount_hash();
	event++;

	if (flags & MNT_DETACH) {
		if (!list_empty(&mnt->mnt_list))
			umount_tree(mnt, UMOUNT_PROPAGATE);
		retval = 0;
	} else {
		shrink_submounts(mnt);
		retval = -EBUSY;
		if (!propagate_mount_busy(mnt, 2)) {
			if (!list_empty(&mnt->mnt_list))
				umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
			retval = 0;
		}
	}
	unlock_mount_hash();
	namespace_unlock();
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 132 40.74% 4 16.00%
Al Viro 73 22.53% 8 32.00%
David Howells 63 19.44% 3 12.00%
Andrew Lutomirski 12 3.70% 1 4.00%
Stephen D. Smalley 11 3.40% 1 4.00%
Ram Pai 9 2.78% 2 8.00%
Nicholas Piggin 7 2.16% 1 4.00%
Jan Blunck 6 1.85% 1 4.00%
Greg Kroah-Hartman 5 1.54% 2 8.00%
Eric W. Biedermann 4 1.23% 1 4.00%
Andrew Morton 2 0.62% 1 4.00%
Total 324 100.00% 25 100.00%

/*
 * __detach_mounts - lazily unmount all mounts on the specified dentry
 *
 * During unlink, rmdir, and d_drop it is possible to loose the path
 * to an existing mountpoint, and wind up leaking the mount.
 * detach_mounts allows lazily unmounting those mounts instead of
 * leaking them.
 *
 * The caller may hold dentry->d_inode->i_mutex.
 */


void __detach_mounts(struct dentry *dentry)
{
	struct mountpoint *mp;
	struct mount *mnt;

	namespace_lock();
	lock_mount_hash();
	mp = lookup_mountpoint(dentry);
	if (IS_ERR_OR_NULL(mp))
		goto out_unlock;

	event++;
	while (!hlist_empty(&mp->m_list)) {
		mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);
		if (mnt->mnt.mnt_flags & MNT_UMOUNT) {
			hlist_add_head(&mnt->mnt_umount.s_list, &unmounted);
			umount_mnt(mnt);
		}
		else umount_tree(mnt, UMOUNT_CONNECTED);
	}
	put_mountpoint(mp);
out_unlock:
	unlock_mount_hash();
	namespace_unlock();
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 123 97.62% 6 85.71%
Andrey Ulanov 3 2.38% 1 14.29%
Total 126 100.00% 7 100.00%

/*
 * Is the caller allowed to modify his namespace?
 */


static inline bool may_mount(void)
{
	return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



static inline bool may_mandlock(void)
{
#ifndef	CONFIG_MANDATORY_FILE_LOCKING
	return false;
#endif
	return capable(CAP_SYS_ADMIN);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Layton 19 82.61% 1 50.00%
Eric W. Biedermann 4 17.39% 1 50.00%
Total 23 100.00% 2 100.00%

/*
 * Now umount can handle mount points as well as block devices.
 * This is important for filesystems which use unnamed block devices.
 *
 * We now support a flag for forced unmount like the other 'big iron'
 * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
 */



int ksys_umount(char __user *name, int flags)
{
	struct path path;
	struct mount *mnt;
	int retval;
	int lookup_flags = 0;

	if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW))
		return -EINVAL;

	if (!may_mount())
		return -EPERM;

	if (!(flags & UMOUNT_NOFOLLOW))
		lookup_flags |= LOOKUP_FOLLOW;

	retval = user_path_mountpoint_at(AT_FDCWD, name, lookup_flags, &path);
	if (retval)
		goto out;
	mnt = real_mount(path.mnt);
	retval = -EINVAL;
	if (path.dentry != path.mnt->mnt_root)
		goto dput_and_out;
	if (!check_mnt(mnt))
		goto dput_and_out;
	if (mnt->mnt.mnt_flags & MNT_LOCKED)
		goto dput_and_out;
	retval = -EPERM;
	if (flags & MNT_FORCE && !capable(CAP_SYS_ADMIN))
		goto dput_and_out;

	retval = do_umount(mnt, flags);
dput_and_out:
	/* we mustn't call path_put() as that would clear mnt_expiry_mark */
	dput(path.dentry);
	mntput_no_expire(mnt);
out:
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 67 34.36% 1 8.33%
Miklos Szeredi 41 21.03% 1 8.33%
Eric W. Biedermann 33 16.92% 2 16.67%
Al Viro 29 14.87% 5 41.67%
Jan Blunck 14 7.18% 2 16.67%
Dominik Brodowski 11 5.64% 1 8.33%
Total 195 100.00% 12 100.00%


SYSCALL_DEFINE2(umount, char __user *, name, int, flags)
{
	return ksys_umount(name, flags);
}

#ifdef __ARCH_WANT_SYS_OLDUMOUNT

/*
 *      The 2.0 compatible umount. No flags.
 */

SYSCALL_DEFINE1(oldumount, char __user *, name)
{
	return ksys_umount(name, 0);
}

#endif



static bool is_mnt_ns_file(struct dentry *dentry)
{
	/* Is this a proxy for a mount namespace? */
	return dentry->d_op == &ns_dentry_operations &&
	       dentry->d_fsdata == &mntns_operations;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 18 66.67% 2 50.00%
Al Viro 9 33.33% 2 50.00%
Total 27 100.00% 4 100.00%



struct mnt_namespace *to_mnt_ns(struct ns_common *ns)
{
	return container_of(ns, struct mnt_namespace, ns);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%



static bool mnt_ns_loop(struct dentry *dentry)
{
	/* Could bind mounting the mount namespace inode cause a
         * mount namespace loop?
         */
	struct mnt_namespace *mnt_ns;
	if (!is_mnt_ns_file(dentry))
		return false;

	mnt_ns = to_mnt_ns(get_proc_ns(dentry->d_inode));
	return current->nsproxy->mnt_ns->seq >= mnt_ns->seq;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 50 94.34% 2 66.67%
Al Viro 3 5.66% 1 33.33%
Total 53 100.00% 3 100.00%



struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
					int flag)
{
	struct mount *res, *p, *q, *r, *parent;

	if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(mnt))
		return ERR_PTR(-EINVAL);

	if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(dentry))
		return ERR_PTR(-EINVAL);

	res = q = clone_mnt(mnt, dentry, flag);
	if (IS_ERR(q))
		return q;

	q->mnt_mountpoint = mnt->mnt_mountpoint;

	p = mnt;
	list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
		struct mount *s;
		if (!is_subdir(r->mnt_mountpoint, dentry))
			continue;

		for (s = r; s; s = next_mnt(s, r)) {
			if (!(flag & CL_COPY_UNBINDABLE) &&
			    IS_MNT_UNBINDABLE(s)) {
				s = skip_mnt_tree(s);
				continue;
			}
			if (!(flag & CL_COPY_MNT_NS_FILE) &&
			    is_mnt_ns_file(s->mnt.mnt_root)) {
				s = skip_mnt_tree(s);
				continue;
			}
			while (p != s->mnt_parent) {
				p = p->mnt_parent;
				q = q->mnt_parent;
			}
			p = s;
			parent = q;
			q = clone_mnt(p, p->mnt.mnt_root, flag);
			if (IS_ERR(q))
				goto out;
			lock_mount_hash();
			list_add_tail(&q->mnt_list, &res->mnt_list);
			attach_mnt(q, parent, p->mnt_mp);
			unlock_mount_hash();
		}
	}
	return res;
out:
	if (res) {
		lock_mount_hash();
		umount_tree(res, UMOUNT_SYNC);
		unlock_mount_hash();
	}
	return q;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 130 40.00% 1 5.26%
Eric W. Biedermann 54 16.62% 3 15.79%
Ram Pai 46 14.15% 3 15.79%
Andries E. Brouwer 39 12.00% 1 5.26%
Al Viro 35 10.77% 8 42.11%
David Howells 17 5.23% 1 5.26%
Domen Puncer 3 0.92% 1 5.26%
Jan Blunck 1 0.31% 1 5.26%
Total 325 100.00% 19 100.00%

/* Caller should check returned pointer for errors */



struct vfsmount *collect_mounts(const struct path *path)
{
	struct mount *tree;
	namespace_lock();
	if (!check_mnt(real_mount(path->mnt)))
		tree = ERR_PTR(-EINVAL);
	else
		tree = copy_tree(real_mount(path->mnt), path->dentry,
				 CL_COPY_ALL | CL_PRIVATE);
	namespace_unlock();
	if (IS_ERR(tree))
		return ERR_CAST(tree);
	return &tree->mnt;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 50 58.82% 7 70.00%
Eric W. Biedermann 22 25.88% 1 10.00%
David Howells 9 10.59% 1 10.00%
Dan Carpenter 4 4.71% 1 10.00%
Total 85 100.00% 10 100.00%



void drop_collected_mounts(struct vfsmount *mnt)
{
	namespace_lock();
	lock_mount_hash();
	umount_tree(real_mount(mnt), UMOUNT_SYNC);
	unlock_mount_hash();
	namespace_unlock();
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 31 96.88% 5 83.33%
Eric W. Biedermann 1 3.12% 1 16.67%
Total 32 100.00% 6 100.00%

/**
 * clone_private_mount - create a private clone of a path
 *
 * This creates a new vfsmount, which will be the clone of @path.  The new will
 * not be attached anywhere in the namespace and will be private (i.e. changes
 * to the originating mount won't be propagated into this).
 *
 * Release with mntput().
 */


struct vfsmount *clone_private_mount(const struct path *path)
{
	struct mount *old_mnt = real_mount(path->mnt);
	struct mount *new_mnt;

	if (IS_MNT_UNBINDABLE(old_mnt))
		return ERR_PTR(-EINVAL);

	new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
	if (IS_ERR(new_mnt))
		return ERR_CAST(new_mnt);

	return &new_mnt->mnt;
}
Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 75 98.68% 1 50.00%
Al Viro 1 1.32% 1 50.00%
Total 76 100.00% 2 100.00%

EXPORT_SYMBOL_GPL(clone_private_mount);



int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
		   struct vfsmount *root)
{
	struct mount *mnt;
	int res = f(root, arg);
	if (res)
		return res;
	list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) {
		res = f(&mnt->mnt, arg);
		if (res)
			return res;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 82 100.00% 2 100.00%
Total 82 100.00% 2 100.00%



static void cleanup_group_ids(struct mount *mnt, struct mount *end)
{
	struct mount *p;

	for (p = mnt; p != end; p = next_mnt(p, mnt)) {
		if (p->mnt_group_id && !IS_MNT_SHARED(p))
			mnt_release_group_id(p);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 56 94.92% 1 33.33%
Al Viro 3 5.08% 2 66.67%
Total 59 100.00% 3 100.00%



static int invent_group_ids(struct mount *mnt, bool recurse)
{
	struct mount *p;

	for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) {
		if (!p->mnt_group_id && !IS_MNT_SHARED(p)) {
			int err = mnt_alloc_group_id(p);
			if (err) {
				cleanup_group_ids(mnt, p);
				return err;
			}
		}
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Miklos Szeredi 82 97.62% 1 33.33%
Al Viro 2 2.38% 2 66.67%
Total 84 100.00% 3 100.00%



int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
{
	unsigned int max = READ_ONCE(sysctl_mount_max);
	unsigned int mounts = 0, old, pending, sum;
	struct mount *p;

	for (p = mnt; p; p = next_mnt(p, mnt))
		mounts++;

	old = ns->mounts;
	pending = ns->pending_mounts;
	sum = old + pending;
	if ((old > sum) ||
	    (pending > sum) ||
	    (max < sum) ||
	    (mounts > (max - sum)))
		return -ENOSPC;

	ns->pending_mounts = pending + mounts;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 124 100.00% 1 100.00%
Total 124 100.00% 1 100.00%

/*
 *  @source_mnt : mount tree to be attached
 *  @nd         : place the mount tree @source_mnt is attached
 *  @parent_nd  : if non-null, detach the source_mnt from its parent and
 *                 store the parent mount and mountpoint dentry.
 *                 (done when source_mnt is moved)
 *
 *  NOTE: in the table below explains the semantics when a source mount
 *  of a given type is attached to a destination mount of a given type.
 * ---------------------------------------------------------------------------
 * |         BIND MOUNT OPERATION                                            |
 * |**************************************************************************
 * | source-->| shared        |       private  |       slave    | unbindable |
 * | dest     |               |                |                |            |
 * |   |      |               |                |                |            |
 * |   v      |               |                |                |            |
 * |**************************************************************************
 * |  shared  | shared (++)   |     shared (+) |     shared(+++)|  invalid   |
 * |          |               |                |                |            |
 * |non-shared| shared (+)    |      private   |      slave (*) |  invalid   |
 * ***************************************************************************
 * A bind operation clones the source mount and mounts the clone on the
 * destination mount.
 *
 * (++)  the cloned mount is propagated to all the mounts in the propagation
 *       tree of the destination mount and the cloned mount is added to
 *       the peer group of the source mount.
 * (+)   the cloned mount is created under the destination mount and is marked
 *       as shared. The cloned mount is added to the peer group of the source
 *       mount.
 * (+++) the mount is propagated to all the mounts in the propagation tree
 *       of the destination mount and the cloned mount is made slave
 *       of the same master as that of the source mount. The cloned mount
 *       is marked as 'shared and slave'.
 * (*)   the cloned mount is made a slave of the same master as that of the
 *       source mount.
 *
 * ---------------------------------------------------------------------------
 * |                    MOVE MOUNT OPERATION                                 |
 * |**************************************************************************
 * | source-->| shared        |       private  |       slave    | unbindable |
 * | dest     |               |                |                |            |
 * |   |      |               |                |                |            |
 * |   v      |               |                |                |            |
 * |**************************************************************************
 * |  shared  | shared (+)    |     shared (+) |    shared(+++) |  invalid   |
 * |          |               |                |                |            |
 * |non-shared| shared (+*)   |      private   |    slave (*)   | unbindable |
 * ***************************************************************************
 *
 * (+)  the mount is moved to the destination. And is then propagated to
 *      all the mounts in the propagation tree of the destination mount.
 * (+*)  the mount is moved to the destination.
 * (+++)  the mount is moved to the destination and is then propagated to
 *      all the mounts belonging to the destination mount's propagation tree.
 *      the mount is marked as 'shared and slave'.
 * (*)  the mount continues to be a slave at the new location.
 *
 * if the source mount is a tree, the operations explained above is
 * applied to each mount in the tree.
 * Must be called without spinlocks held, since this function can sleep
 * in allocations.
 */


static int attach_recursive_mnt(struct mount *source_mnt,
			struct mount *dest_mnt,
			struct mountpoint *dest_mp,
			struct path *parent_path)
{
	HLIST_HEAD(tree_list);
	struct mnt_namespace *ns = dest_mnt->mnt_ns;
	struct mountpoint *smp;
	struct mount *child, *p;
	struct hlist_node *n;
	int err;

	/* Preallocate a mountpoint in case the new mounts need
         * to be tucked under other mounts.
         */
	smp = get_mountpoint(source_mnt->mnt.mnt_root);
	if (IS_ERR(smp))
		return PTR_ERR(smp);

	/* Is there space to add these mounts to the mount namespace? */
	if (!parent_path) {
		err = count_mounts(ns, source_mnt);
		if (err)
			goto out;
	}

	if (IS_MNT_SHARED(dest_mnt)) {
		err = invent_group_ids(source_mnt, true);
		if (err)
			goto out;
		err = propagate_mnt(dest_mnt, dest_mp, source_mnt, &tree_list);
		lock_mount_hash();
		if (err)
			goto out_cleanup_ids;
		for (p = source_mnt; p; p = next_mnt(p, source_mnt))
			set_mnt_shared(p);
	} else {
		lock_mount_hash();
	}
	if (parent_path) {
		detach_mnt(source_mnt, parent_path);
		attach_mnt(source_mnt, dest_mnt, dest_mp);
		touch_mnt_namespace(source_mnt->mnt_ns);
	} else {
		mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt);
		commit_tree(source_mnt);
	}

	hlist_for_each_entry_safe(child, n, &tree_list, mnt_hash) {
		struct mount *q;
		hlist_del_init(&child->mnt_hash);
		q = __lookup_mnt(&child->mnt_parent->mnt,
				 child->mnt_mountpoint);
		if (q)
			mnt_change_mountpoint(child, smp, q);
		commit_tree(child);
	}
	put_mountpoint(smp);
	unlock_mount_hash();

	return 0;

 out_cleanup_ids:
	while (!hlist_empty(&tree_list)) {
		child = hlist_entry(tree_list.first, struct mount, mnt_hash);
		child->mnt_parent->mnt_ns->pending_mounts = 0;
		umount_tree(child, UMOUNT_SYNC);
	}
	unlock_mount_hash();
	cleanup_group_ids(source_mnt, NULL);
 out:
	ns->pending_mounts = 0;

	read_seqlock_excl(&mount_lock);
	put_mountpoint(smp);
	read_sequnlock_excl(&mount_lock);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Ram Pai 123 31.95% 2 10.53%
Eric W. Biedermann 115 29.87% 3 15.79%
Al Viro 96 24.94% 11 57.89%
Miklos Szeredi 48 12.47% 1 5.26%
Kirill Korotaev 2 0.52% 1 5.26%
Serge E. Hallyn 1 0.26% 1 5.26%
Total 385 100.00% 19 100.00%



static struct mountpoint *lock_mount(struct path *path)
{
	struct vfsmount *mnt;
	struct dentry *dentry = path->dentry;
retry:
	inode_lock(dentry->d_inode);
	if (unlikely(cant_mount(dentry))) {
		inode_unlock(dentry->d_inode);
		return ERR_PTR(-ENOENT);
	}
	namespace_lock();
	mnt = lookup_mnt(path);
	if (likely(!mnt)) {
		struct mountpoint *mp = get_mountpoint(dentry);
		if (IS_ERR(mp)) {
			namespace_unlock();
			inode_unlock(dentry->d_inode);
			return mp;
		}
		return mp;
	}
	namespace_unlock();
	inode_unlock(path->dentry->d_inode);
	path_put(path);
	path->mnt = mnt;
	dentry = path->dentry = dget(mnt->mnt_root);
	goto retry;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 155 99.36% 4 80.00%
Eric W. Biedermann 1 0.64% 1 20.00%
Total 156 100.00% 5 100.00%



static void unlock_mount(struct mountpoint *where)
{
	struct dentry *dentry = where->m_dentry;

	read_seqlock_excl(&mount_lock);
	put_mountpoint(where);
	read_sequnlock_excl(&mount_lock);

	namespace_unlock();
	inode_unlock(dentry->d_inode);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 35 74.47% 4 80.00%
Eric W. Biedermann 12 25.53% 1 20.00%
Total 47 100.00% 5 100.00%



static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
{
	if (mnt->mnt.mnt_sb->s_flags & SB_NOUSER)
		return -EINVAL;

	if (d_is_dir(mp->m_dentry) !=
	      d_is_dir(mnt->mnt.mnt_root))
		return -ENOTDIR;

	return attach_recursive_mnt(mnt, p, mp, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 49 69.01% 2 20.00%
Al Viro 16 22.54% 4 40.00%
Ram Pai 3 4.23% 2 20.00%
David Howells 3 4.23% 2 20.00%
Total 71 100.00% 10 100.00%

/*
 * Sanity check the flags to change_mnt_propagation.
 */



static int flags_to_propagation_type(int ms_flags)
{
	int type = ms_flags & ~(MS_REC | MS_SILENT);

	/* Fail if any non-propagation flags are set */
	if (type & ~(MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
		return 0;
	/* Only one propagation flag should be set */
	if (!is_power_of_2(type))
		return 0;
	return type;
}

Contributors
Person Tokens Prop Commits CommitProp
Valerie Aurora 49 89.09% 1 33.33%
Roman Borisov 4 7.27% 1 33.33%
David Howells 2 3.64% 1 33.33%
Total 55 100.00% 3 100.00%

/*
 * recursively change the type of the mountpoint.
 */


static int do_change_type(struct path *path, int ms_flags)
{
	struct mount *m;
	struct mount *mnt = real_mount(path->mnt);
	int recurse = ms_flags & MS_REC;
	int type;
	int err = 0;

	if (path->dentry != path->mnt->mnt_root)
		return -EINVAL;

	type = flags_to_propagation_type(ms_flags);
	if (!type)
		return -EINVAL;

	namespace_lock();
	if (type == MS_SHARED) {
		err = invent_group_ids(mnt, recurse);
		if (err)
			goto out_unlock;
	}

	lock_mount_hash();
	for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))
		change_mnt_propagation(m, type);
	unlock_mount_hash();

 out_unlock:
	namespace_unlock();
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Ram Pai 76 51.01% 1 10.00%
Miklos Szeredi 32 21.48% 1 10.00%
Al Viro 20 13.42% 5 50.00%
Valerie Aurora 15 10.07% 1 10.00%
David Howells 3 2.01% 1 10.00%
Jan Blunck 3 2.01% 1 10.00%
Total 149 100.00% 10 100.00%



static bool has_locked_children(struct mount *mnt, struct dentry *dentry)
{
	struct mount *child;
	list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
		if (!is_subdir(child->mnt_mountpoint, dentry))
			continue;

		if (child->mnt.mnt_flags & MNT_LOCKED)
			return true;
	}
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 60 100.00% 1 100.00%
Total 60 100.00% 1 100.00%

/*
 * do loopback mount.
 */


static int do_loopback(struct path *path, const char *old_name,
				int recurse)
{
	struct path old_path;
	struct mount *mnt = NULL, *old, *parent;
	struct mountpoint *mp;
	int err;
	if (!old_name || !*old_name)
		return -EINVAL;
	err = kern_path(old_name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &old_path);
	if (err)
		return err;

	err = -EINVAL;
	if (mnt_ns_loop(old_path.dentry))
		goto out;

	mp = lock_mount(path);
	err = PTR_ERR(mp);
	if (IS_ERR(mp))
		goto out;

	old = real_mount(old_path.mnt);
	parent = real_mount(path->mnt);

	err = -EINVAL;
	if (IS_MNT_UNBINDABLE(old))
		goto out2;

	if (!check_mnt(parent))
		goto out2;

	if (!check_mnt(old) && old_path.dentry->d_op != &ns_dentry_operations)
		goto out2;

	if (!recurse && has_locked_children(old, old_path.dentry))
		goto out2;

	if (recurse)
		mnt = copy_tree(old, old_path.dentry, CL_COPY_MNT_NS_FILE);
	else
		mnt = clone_mnt(old, old_path.dentry, 0);

	if (IS_ERR(mnt)) {
		err = PTR_ERR(mnt);
		goto out2;
	}

	mnt->mnt.mnt_flags &= ~MNT_LOCKED;

	err = graft_tree(mnt, parent, mp);
	if (err) {
		lock_mount_hash();
		umount_tree(mnt, UMOUNT_SYNC);
		unlock_mount_hash();
	}
out2:
	unlock_mount(mp);
out:
	path_put(&old_path);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 122 39.74% 3 10.71%
Al Viro 108 35.18% 12 42.86%
Eric W. Biedermann 44 14.33% 4 14.29%
Ram Pai 14 4.56% 3 10.71%
David Howells 12 3.91% 1 3.57%
Jan Blunck 3 0.98% 2 7.14%
Trond Myklebust 2 0.65% 1 3.57%
Andrey Vagin 1 0.33% 1 3.57%
Andrew Morton 1 0.33% 1 3.57%
Total 307 100.00% 28 100.00%



static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
{
	int error = 0;
	int readonly_request = 0;

	if (ms_flags & MS_RDONLY)
		readonly_request = 1;
	if (readonly_request == __mnt_is_readonly(mnt))
		return 0;

	if (readonly_request)
		error = mnt_make_readonly(real_mount(mnt));
	else
		__mnt_unmake_readonly(real_mount(mnt));
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
Dave Hansen 66 91.67% 1 50.00%
Al Viro 6 8.33% 1 50.00%
Total 72 100.00% 2 100.00%

/*
 * change filesystem flags. dir should be a physical root of filesystem.
 * If you've mounted a non-root directory somewhere and want to do remount
 * on it - tough luck.
 */


static int do_remount(struct path *path, int ms_flags, int sb_flags,
		      int mnt_flags, void *data)
{
	int err;
	struct super_block *sb = path->mnt->mnt_sb;
	struct mount *mnt = real_mount(path->mnt);

	if (!check_mnt(mnt))
		return -EINVAL;

	if (path->dentry != path->mnt->mnt_root)
		return -EINVAL;

	/* Don't allow changing of locked mnt flags.
         *
         * No locks need to be held here while testing the various
         * MNT_LOCK flags because those flags can never be cleared
         * once they are set.
         */
	if ((mnt->mnt.mnt_flags & MNT_LOCK_READONLY) &&
	    !(mnt_flags & MNT_READONLY)) {
		return -EPERM;
	}
	if ((mnt->mnt.mnt_flags & MNT_LOCK_NODEV) &&
	    !(mnt_flags & MNT_NODEV)) {
		return -EPERM;
	}
	if ((mnt->mnt.mnt_flags & MNT_LOCK_NOSUID) &&
	    !(mnt_flags & MNT_NOSUID)) {
		return -EPERM;
	}
	if ((mnt->mnt.mnt_flags & MNT_LOCK_NOEXEC) &&
	    !(mnt_flags & MNT_NOEXEC)) {
		return -EPERM;
	}
	if ((mnt->mnt.mnt_flags & MNT_LOCK_ATIME) &&
	    ((mnt->mnt.mnt_flags & MNT_ATIME_MASK) != (mnt_flags & MNT_ATIME_MASK))) {
		return -EPERM;
	}

	err = security_sb_remount(sb, data);
	if (err)
		return err;

	down_write(&sb->s_umount);
	if (ms_flags & MS_BIND)
		err = change_mount_flags(path->mnt, ms_flags);
	else if (!capable(CAP_SYS_ADMIN))
		err = -EPERM;
	else
		err = do_remount_sb(sb, sb_flags, data, 0);
	if (!err) {
		lock_mount_hash();
		mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
		mnt->mnt.mnt_flags = mnt_flags;
		touch_mnt_namespace(mnt->mnt_ns);
		unlock_mount_hash();
	}
	up_write(&sb->s_umount);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 139 41.62% 3 18.75%
Linus Torvalds 94 28.14% 2 12.50%
Al Viro 58 17.37% 6 37.50%
Eric Paris 16 4.79% 1 6.25%
Dave Hansen 15 4.49% 1 6.25%
David Howells 7 2.10% 1 6.25%
Jan Blunck 3 0.90% 1 6.25%
Andrew Morton 2 0.60% 1 6.25%
Total 334 100.00% 16 100.00%



static inline int tree_contains_unbindable(struct mount *mnt)
{
	struct mount *p;
	for (p = mnt; p; p = next_mnt(p, mnt)) {
		if (IS_MNT_UNBINDABLE(p))
			return 1;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Ram Pai 47 95.92% 1 33.33%
Al Viro 2 4.08% 2 66.67%
Total 49 100.00% 3 100.00%



static int do_move_mount(struct path *path, const char *old_name)
{
	struct path old_path, parent_path;
	struct mount *p;
	struct mount *old;
	struct mountpoint *mp;
	int err;
	if (!old_name || !*old_name)
		return -EINVAL;
	err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
	if (err)
		return err;

	mp = lock_mount(path);
	err = PTR_ERR(mp);
	if (IS_ERR(mp))
		goto out;

	old = real_mount(old_path.mnt);
	p = real_mount(path->mnt);

	err = -EINVAL;
	if (!check_mnt(p) || !check_mnt(old))
		goto out1;

	if (old->mnt.mnt_flags & MNT_LOCKED)
		goto out1;

	err = -EINVAL;
	if (old_path.dentry != old_path.mnt->mnt_root)
		goto out1;

	if (!mnt_has_parent(old))
		goto out1;

	if (d_is_dir(path->dentry) !=
	      d_is_dir(old_path.dentry))
		goto out1;
	/*
         * Don't move a mount residing in a shared parent.
         */
	if (IS_MNT_SHARED(old->mnt_parent))
		goto out1;
	/*
         * Don't move a mount tree containing unbindable mounts to a destination
         * mount which is shared.
         */
	if (IS_MNT_SHARED(p) && tree_contains_unbindable(old))
		goto out1;
	err = -ELOOP;
	for (; mnt_has_parent(p); p = p->mnt_parent)
		if (p == old)
			goto out1;

	err = attach_recursive_mnt(old, real_mount(path->mnt), mp, &parent_path);
	if (err)
		goto out1;

	/* if the mount is moved, it should no longer be expire
         * automatically */
	list_del_init(&old->mnt_expire);
out1:
	unlock_mount(mp);
out:
	if (!err)
		path_put(&parent_path);
	path_put(&old_path);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 156 48.75% 1 4.17%
Al Viro 87 27.19% 14 58.33%
Ram Pai 36 11.25% 2 8.33%
David Howells 16 5.00% 3 12.50%
Eric W. Biedermann 13 4.06% 1 4.17%
Jan Blunck 11 3.44% 2 8.33%
Miklos Szeredi 1 0.31% 1 4.17%
Total 320 100.00% 24 100.00%



static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
{
	int err;
	const char *subtype = strchr(fstype, '.');
	if (subtype) {
		subtype++;
		err = -EINVAL;
		if (!subtype[0])
			goto err;
	} else
		subtype = "";

	mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
	err = -ENOMEM;
	if (!mnt->mnt_sb->s_subtype)
		goto err;
	return mnt;

 err:
	mntput(mnt);
	return ERR_PTR(err);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 77 70.64% 3 50.00%
Linus Torvalds 27 24.77% 2 33.33%
David Howells 5 4.59% 1 16.67%
Total 109 100.00% 6 100.00%

/*
 * add a mount into a namespace's mount tree
 */


static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
{
	struct mountpoint *mp;
	struct mount *parent;
	int err;

	mnt_flags &= ~MNT_INTERNAL_FLAGS;

	mp = lock_mount(path);
	if (IS_ERR(mp))
		return PTR_ERR(mp);

	parent = real_mount(path->mnt);
	err = -EINVAL;
	if (unlikely(!check_mnt(parent))) {
		/* that's acceptable only for automounts done in private ns */
		if (!(mnt_flags & MNT_SHRINKABLE))
			goto unlock;
		/* ... and for those we'd better have mountpoint still alive */
		if (!parent->mnt_ns)
			goto unlock;
	}

	/* Refuse the same filesystem on the same mount point */
	err = -EBUSY;
	if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&
	    path->mnt->mnt_root == path->dentry)
		goto unlock;

	err = -EINVAL;
	if (d_is_symlink(newmnt->mnt.mnt_root))
		goto unlock;

	newmnt->mnt.mnt_flags = mnt_flags;
	err = graft_tree(newmnt, parent, mp);

unlock:
	unlock_mount(mp);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 99 52.38% 10 62.50%
Linus Torvalds 56 29.63% 1 6.25%
David Howells 29 15.34% 3 18.75%
Jan Blunck 4 2.12% 1 6.25%
Ram Pai 1 0.53% 1 6.25%
Total 189 100.00% 16 100.00%

static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags);

/*
 * create a new mount for userspace and request it to be added into the
 * namespace's tree
 */


static int do_new_mount(struct path *path, const char *fstype, int sb_flags,
			int mnt_flags, const char *name, void *data)
{
	struct file_system_type *type;
	struct vfsmount *mnt;
	int err;

	if (!fstype)
		return -EINVAL;

	type = get_fs_type(fstype);
	if (!type)
		return -ENODEV;

	mnt = vfs_kern_mount(type, sb_flags, name, data);
	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
	    !mnt->mnt_sb->s_subtype)
		mnt = fs_set_subtype(mnt, fstype);

	put_filesystem(type);
	if (IS_ERR(mnt))
		return PTR_ERR(mnt);

	if (mount_too_revealing(mnt, &mnt_flags)) {
		mntput(mnt);
		return -EPERM;
	}

	err = do_add_mount(real_mount(mnt), path, mnt_flags);
	if (err)
		mntput(mnt);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 95 53.07% 3 50.00%
Eric W. Biedermann 82 45.81% 2 33.33%
David Howells 2 1.12% 1 16.67%
Total 179 100.00% 6 100.00%



int finish_automount(struct vfsmount *m, struct path *path)
{
	struct mount *mnt = real_mount(m);
	int err;
	/* The new mount record should have at least 2 refs to prevent it being
         * expired before we get a chance to add it
         */
	BUG_ON(mnt_get_count(mnt) < 2);

	if (m->mnt_sb == path->mnt->mnt_sb &&
	    m->mnt_root == path->dentry) {
		err = -ELOOP;
		goto fail;
	}

	err = do_add_mount(mnt, path, path->mnt->mnt_flags | MNT_SHRINKABLE);
	if (!err)
		return 0;
fail:
	/* remove m from any expiration list it may be on */
	if (!list_empty(&mnt->mnt_expire)) {
		namespace_lock();
		list_del_init(&mnt->mnt_expire);
		namespace_unlock();
	}
	mntput(m);
	mntput(m);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 137 100.00% 5 100.00%
Total 137 100.00% 5 100.00%

/**
 * mnt_set_expiry - Put a mount on an expiration list
 * @mnt: The mount to list.
 * @expiry_list: The list to add the mount to.
 */


void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list)
{
	namespace_lock();

	list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list);

	namespace_unlock();
}
Contributors
Person Tokens Prop Commits CommitProp
David Howells 27 79.41% 1 33.33%
Al Viro 7 20.59% 2 66.67%
Total 34 100.00% 3 100.00%

EXPORT_SYMBOL(mnt_set_expiry);

/*
 * process a list of expirable mountpoints with the intent of discarding any
 * mountpoints that aren't in use and haven't been touched since last we came
 * here
 */


void mark_mounts_for_expiry(struct list_head *mounts)
{
	struct mount *mnt, *next;
	LIST_HEAD(graveyard);

	if (list_empty(mounts))
		return;

	namespace_lock();
	lock_mount_hash();

	/* extract from the expiration list every vfsmount that matches the
         * following criteria:
         * - only referenced by its parent vfsmount
         * - still marked for expiry (marked on the last call here; marks are
         *   cleared by mntput())
         */
	list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
		if (!xchg(&mnt->mnt_expiry_mark, 1) ||
			propagate_mount_busy(mnt, 1))
			continue;
		list_move(&mnt->mnt_expire, &graveyard);
	}
	while (!list_empty(&graveyard)) {
		mnt = list_first_entry(&graveyard, struct mount, mnt_expire);
		touch_mnt_namespace(mnt->mnt_ns);
		umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
	}
	unlock_mount_hash();
	namespace_unlock();
}

Contributors
Person Tokens Prop Commits CommitProp
David Howells 50 39.06% 1 8.33%
Al Viro 46 35.94% 6 50.00%
Trond Myklebust 15 11.72% 1 8.33%
Christoph Hellwig 12 9.38% 1 8.33%
Eric W. Biedermann 3 2.34% 1 8.33%
Ram Pai 1 0.78% 1 8.33%
Miklos Szeredi 1 0.78% 1 8.33%
Total 128 100.00% 12 100.00%

EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);

/*
 * Ripoff of 'select_parent()'
 *
 * search the list of submounts for a given mountpoint, and move any
 * shrinkable submounts to the 'graveyard' list.
 */


static int select_submounts(struct mount *parent, struct list_head *graveyard)
{
	struct mount *this_parent = parent;
	struct list_head *next;
	int found = 0;

repeat:
	next = this_parent->mnt_mounts.next;
resume:
	while (next != &this_parent->mnt_mounts) {
		struct list_head *tmp = next;
		struct mount *mnt = list_entry(tmp, struct mount, mnt_child);

		next = tmp->next;
		if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE))
			continue;
		/*
                 * Descend a level if the d_mounts list is non-empty.
                 */
		if (!list_empty(&mnt->mnt_mounts)) {
			this_parent = mnt;
			goto repeat;
		}

		if (!propagate_mount_busy(mnt, 1)) {
			list_move_tail(&mnt->mnt_expire, graveyard);
			found++;
		}
	}
	/*
         * All done at this level ... ascend and resume the search
         */
	if (this_parent != parent) {
		next = this_parent->mnt_child.next;
		this_parent = this_parent->mnt_parent;
		goto resume;
	}
	return found;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 139 80.35% 1 33.33%
David Howells 28 16.18% 1 33.33%
Al Viro 6 3.47% 1 33.33%
Total 173 100.00% 3 100.00%

/*
 * process a list of expirable mountpoints with the intent of discarding any
 * submounts of a specific parent mountpoint
 *
 * mount_lock must be held for write
 */


static void shrink_submounts(struct mount *mnt)
{
	LIST_HEAD(graveyard);
	struct mount *m;

	/* extract submounts of 'mountpoint' from the expiration list */
	while (select_submounts(mnt, &graveyard)) {
		while (!list_empty(&graveyard)) {
			m = list_first_entry(&graveyard, struct mount,
						mnt_expire);
			touch_mnt_namespace(m->mnt_ns);
			umount_tree(m, UMOUNT_PROPAGATE|UMOUNT_SYNC);
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 39 52.70% 4 44.44%
Trond Myklebust 20 27.03% 1 11.11%
David Howells 7 9.46% 1 11.11%
Eric W. Biedermann 5 6.76% 2 22.22%
Ram Pai 3 4.05% 1 11.11%
Total 74 100.00% 9 100.00%

/*
 * Some copy_from_user() implementations do not return the exact number of
 * bytes remaining to copy on a fault.  But copy_mount_options() requires that.
 * Note that this function differs from copy_from_user() in that it will oops
 * on bad values of `to', rather than returning a short copy.
 */


static long exact_copy_from_user(void *to, const void __user * from,
				 unsigned long n)
{
	char *t = to;
	const char __user *f = from;
	char c;

	if (!access_ok(VERIFY_READ, from, n))
		return n;

	while (n) {
		if (__get_user(c, f)) {
			memset(t, 0, n);
			break;
		}
		*t++ = c;
		f++;
		n--;
	}
	return n;
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 94 100.00% 1 100.00%
Total 94 100.00% 1 100.00%



void *copy_mount_options(const void __user * data)
{
	int i;
	unsigned long size;
	char *copy;

	if (!data)
		return NULL;

	copy = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (!copy)
		return ERR_PTR(-ENOMEM);

	/* We only care that *some* data at the address the user
         * gave us is valid.  Just in case, we'll zero
         * the remainder of the page.
         */
	/* copy_from_user cannot cross TASK_SIZE ! */
	size = TASK_SIZE - (unsigned long)data;
	if (size > PAGE_SIZE)
		size = PAGE_SIZE;

	i = size - exact_copy_from_user(copy, data, size);
	if (!i) {
		kfree(copy);
		return ERR_PTR(-EFAULT);
	}
	if (i != PAGE_SIZE)
		memset(copy + i, 0, PAGE_SIZE - i);
	return copy;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 100 78.12% 2 50.00%
Al Viro 27 21.09% 1 25.00%
Andrew Morton 1 0.78% 1 25.00%
Total 128 100.00% 4 100.00%



char *copy_mount_string(const void __user *data)
{
	return data ? strndup_user(data, PAGE_SIZE) : NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Vegard Nossum 18 75.00% 1 50.00%
Tim Gardner 6 25.00% 1 50.00%
Total 24 100.00% 2 100.00%

/*
 * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
 * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
 *
 * data is a (void *) that can point to any structure up to
 * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
 * information (or be NULL).
 *
 * Pre-0.97 versions of mount() didn't have a flags word.
 * When the flags word was introduced its top half was required
 * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
 * Therefore, if this magic number is present, it carries no information
 * and must be discarded.
 */


long do_mount(const char *dev_name, const char __user *dir_name,
		const char *type_page, unsigned long flags, void *data_page)
{
	struct path path;
	unsigned int mnt_flags = 0, sb_flags;
	int retval = 0;

	/* Discard magic */
	if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
		flags &= ~MS_MGC_MSK;

	/* Basic sanity checks */
	if (data_page)
		((char *)data_page)[PAGE_SIZE - 1] = 0;

	if (flags & MS_NOUSER)
		return -EINVAL;

	/* ... and get the mountpoint */
	retval = user_path(dir_name, &path);
	if (retval)
		return retval;

	retval = security_sb_mount(dev_name, &path,
				   type_page, flags, data_page);
	if (!retval && !may_mount())
		retval = -EPERM;
	if (!retval && (flags & SB_MANDLOCK) && !may_mandlock())
		retval = -EPERM;
	if (retval)
		goto dput_out;

	/* Default to relatime unless overriden */
	if (!(flags & MS_NOATIME))
		mnt_flags |= MNT_RELATIME;

	/* Separate the per-mountpoint flags */
	if (flags & MS_NOSUID)
		mnt_flags |= MNT_NOSUID;
	if (flags & MS_NODEV)
		mnt_flags |= MNT_NODEV;
	if (flags & MS_NOEXEC)
		mnt_flags |= MNT_NOEXEC;
	if (flags & MS_NOATIME)
		mnt_flags |= MNT_NOATIME;
	if (flags & MS_NODIRATIME)
		mnt_flags |= MNT_NODIRATIME;
	if (flags & MS_STRICTATIME)
		mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
	if (flags & MS_RDONLY)
		mnt_flags |= MNT_READONLY;

	/* The default atime for remount is preservation */
	if ((flags & MS_REMOUNT) &&
	    ((flags & (MS_NOATIME | MS_NODIRATIME | MS_RELATIME |
		       MS_STRICTATIME)) == 0)) {
		mnt_flags &= ~MNT_ATIME_MASK;
		mnt_flags |= path.mnt->mnt_flags & MNT_ATIME_MASK;
	}

	sb_flags = flags & (SB_RDONLY |
			    SB_SYNCHRONOUS |
			    SB_MANDLOCK |
			    SB_DIRSYNC |
			    SB_SILENT |
			    SB_POSIXACL |
			    SB_LAZYTIME |
			    SB_I_VERSION);

	if (flags & MS_REMOUNT)
		retval = do_remount(&path, flags, sb_flags, mnt_flags,
				    data_page);
	else if (flags & MS_BIND)
		retval = do_loopback(&path, dev_name, flags & MS_REC);
	else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
		retval = do_change_type(&path, flags);
	else if (flags & MS_MOVE)
		retval = do_move_mount(&path, dev_name);
	else
		retval = do_new_mount(&path, type_page, sb_flags, mnt_flags,
				      dev_name, data_page);
dput_out:
	path_put(&path);
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 167 38.13% 3 9.38%
Eric W. Biedermann 44 10.05% 1 3.12%
Tetsuo Handa 36 8.22% 1 3.12%
Al Viro 30 6.85% 6 18.75%
David Howells 30 6.85% 3 9.38%
Ram Pai 24 5.48% 4 12.50%
Christoph Hellwig 21 4.79% 1 3.12%
Jeff Layton 19 4.34% 1 3.12%
Andrew Morton 19 4.34% 2 6.25%
Matthew Garrett 19 4.34% 2 6.25%
Andi Kleen 10 2.28% 1 3.12%
Dave Hansen 5 1.14% 1 3.12%
Valerie Henson 4 0.91% 1 3.12%
SeungHun Lee 2 0.46% 1 3.12%
Markus Trippelsdorf 2 0.46% 1 3.12%
Mimi Zohar 2 0.46% 1 3.12%
Stephen D. Smalley 2 0.46% 1 3.12%
Jan Blunck 2 0.46% 1 3.12%
Total 438 100.00% 32 100.00%



static struct ucounts *inc_mnt_namespaces(struct user_namespace *ns)
{
	return inc_ucount(ns, current_euid(), UCOUNT_MNT_NAMESPACES);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static void dec_mnt_namespaces(struct ucounts *ucounts)
{
	dec_ucount(ucounts, UCOUNT_MNT_NAMESPACES);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static void free_mnt_ns(struct mnt_namespace *ns)
{
	ns_free_inum(&ns->ns);
	dec_mnt_namespaces(ns->ucounts);
	put_user_ns(ns->user_ns);
	kfree(ns);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 35 92.11% 3 60.00%
Al Viro 3 7.89% 2 40.00%
Total 38 100.00% 5 100.00%

/*
 * Assign a sequence number so we can detect when we attempt to bind
 * mount a reference to an older mount namespace into the current
 * mount namespace, preventing reference counting loops.  A 64bit
 * number incrementing at 10Ghz will take 12,427 years to wrap which
 * is effectively never, so we can ignore the possibility.
 */

static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1);



static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *user_ns)
{
	struct mnt_namespace *new_ns;
	struct ucounts *ucounts;
	int ret;

	ucounts = inc_mnt_namespaces(user_ns);
	if (!ucounts)
		return ERR_PTR(-ENOSPC);

	new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
	if (!new_ns) {
		dec_mnt_namespaces(ucounts);
		return ERR_PTR(-ENOMEM);
	}
	ret = ns_alloc_inum(&new_ns->ns);
	if (ret) {
		kfree(new_ns);
		dec_mnt_namespaces(ucounts);
		return ERR_PTR(ret);
	}
	new_ns->ns.ops = &mntns_operations;
	new_ns->seq = atomic64_add_return(1, &mnt_ns_seq);
	atomic_set(&new_ns->count, 1);
	new_ns->root = NULL;
	INIT_LIST_HEAD(&new_ns->list);
	init_waitqueue_head(&new_ns->poll);
	new_ns->event = 0;
	new_ns->user_ns = get_user_ns(user_ns);
	new_ns->ucounts = ucounts;
	new_ns->mounts = 0;
	new_ns->pending_mounts = 0;
	return new_ns;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 107 54.04% 6 33.33%
Linus Torvalds 42 21.21% 2 11.11%
Al Viro 25 12.63% 4 22.22%
Trond Myklebust 11 5.56% 1 5.56%
Cédric Le Goater 5 2.53% 1 5.56%
Kirill Korotaev 3 1.52% 1 5.56%
Janak Desai 2 1.01% 1 5.56%
Adrian Bunk 2 1.01% 1 5.56%
Badari Pulavarty 1 0.51% 1 5.56%
Total 198 100.00% 18 100.00%


__latent_entropy

struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,
		struct user_namespace *user_ns, struct fs_struct *new_fs)
{
	struct mnt_namespace *new_ns;
	struct vfsmount *rootmnt = NULL, *pwdmnt = NULL;
	struct mount *p, *q;
	struct mount *old;
	struct mount *new;
	int copy_flags;

	BUG_ON(!ns);

	if (likely(!(flags & CLONE_NEWNS))) {
		get_mnt_ns(ns);
		return ns;
	}

	old = ns->root;

	new_ns = alloc_mnt_ns(user_ns);
	if (IS_ERR(new_ns))
		return new_ns;

	namespace_lock();
	/* First pass: copy the tree topology */
	copy_flags = CL_COPY_UNBINDABLE | CL_EXPIRE;
	if (user_ns != ns->user_ns)
		copy_flags |= CL_SHARED_TO_SLAVE | CL_UNPRIVILEGED;
	new = copy_tree(old, old->mnt.mnt_root, copy_flags);
	if (IS_ERR(new)) {
		namespace_unlock();
		free_mnt_ns(new_ns);
		return ERR_CAST(new);
	}
	new_ns->root = new;
	list_add_tail(&new_ns->list, &new->mnt_list);

	/*
         * Second pass: switch the tsk->fs->* elements and mark new vfsmounts
         * as belonging to new namespace.  We have already acquired a private
         * fs_struct, so tsk->fs->lock is not needed.
         */
	p = old;
	q = new;
	while (p) {
		q->mnt_ns = new_ns;
		new_ns->mounts++;
		if (new_fs) {
			if (&p->mnt == new_fs->root.mnt) {
				new_fs->root.mnt = mntget(&q->mnt);
				rootmnt = &p->mnt;
			}
			if (&p->mnt == new_fs->pwd.mnt) {
				new_fs->pwd.mnt = mntget(&q->mnt);
				pwdmnt = &p->mnt;
			}
		}
		p = next_mnt(p, old);
		q = next_mnt(q, new);
		if (!q)
			break;
		while (p->mnt.mnt_root != q->mnt.mnt_root)
			p = next_mnt(p, old);
	}
	namespace_unlock();

	if (rootmnt)
		mntput(rootmnt);
	if (pwdmnt)
		mntput(pwdmnt);

	return new_ns;
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 126 33.87% 9 36.00%
Linus Torvalds 91 24.46% 1 4.00%
Eric W. Biedermann 66 17.74% 5 20.00%
Trond Myklebust 51 13.71% 1 4.00%
Jan Blunck 12 3.23% 1 4.00%
Andrew Morton 10 2.69% 1 4.00%
David Howells 5 1.34% 1 4.00%
Janak Desai 4 1.08% 1 4.00%
Cédric Le Goater 2 0.54% 1 4.00%
Adrian Bunk 2 0.54% 1 4.00%
Kirill Korotaev 1 0.27% 1 4.00%
Ram Pai 1 0.27% 1 4.00%
Emese Revfy 1 0.27% 1 4.00%
Total 372 100.00% 25 100.00%

/**
 * create_mnt_ns - creates a private namespace and adds a root filesystem
 * @mnt: pointer to the new root filesystem mountpoint
 */


static struct mnt_namespace *create_mnt_ns(struct vfsmount *m)
{
	struct mnt_namespace *new_ns = alloc_mnt_ns(&init_user_ns);
	if (!IS_ERR(new_ns)) {
		struct mount *mnt = real_mount(m);
		mnt->mnt_ns = new_ns;
		new_ns->root = mnt;
		new_ns->mounts++;
		list_add(&mnt->mnt_list, &new_ns->list);
	} else {
		mntput(m);
	}
	return new_ns;
}

Contributors
Person Tokens Prop Commits CommitProp
Trond Myklebust 48 56.47% 1 11.11%
Al Viro 28 32.94% 6 66.67%
Eric W. Biedermann 9 10.59% 2 22.22%
Total 85 100.00% 9 100.00%



struct dentry *mount_subtree(struct vfsmount *mnt, const char *name)
{
	struct mnt_namespace *ns;
	struct super_block *s;
	struct path path;
	int err;

	ns = create_mnt_ns(mnt);
	if (IS_ERR(ns))
		return ERR_CAST(ns);

	err = vfs_path_lookup(mnt->mnt_root, mnt,
			name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);

	put_mnt_ns(ns);

	if (err)
		return ERR_PTR(err);

	/* trade a vfsmount reference for active sb one */
	s = path.mnt->mnt_sb;
	atomic_inc(&s->s_active);
	mntput(path.mnt);
	/* lock the sucker */
	down_write(&s->s_umount);
	/* ... and return the root of (sub)tree on it */
	return path.dentry;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 128 100.00% 2 100.00%
Total 128 100.00% 2 100.00%

EXPORT_SYMBOL(mount_subtree);



int ksys_mount(char __user *dev_name, char __user *dir_name, char __user *type,
	       unsigned long flags, void __user *data)
{
	int ret;
	char *kernel_type;
	char *kernel_dev;
	void *options;

	kernel_type = copy_mount_string(type);
	ret = PTR_ERR(kernel_type);
	if (IS_ERR(kernel_type))
		goto out_type;

	kernel_dev = copy_mount_string(dev_name);
	ret = PTR_ERR(kernel_dev);
	if (IS_ERR(kernel_dev))
		goto out_dev;

	options = copy_mount_options(data);
	ret = PTR_ERR(options);
	if (IS_ERR(options))
		goto out_data;

	ret = do_mount(kernel_dev, dir_name, kernel_type, flags, options);

	kfree(options);
out_data:
	kfree(kernel_dev);
out_dev:
	kfree(kernel_type);
out_type:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 60 38.71% 2 28.57%
Vegard Nossum 27 17.42% 1 14.29%
Dominik Brodowski 27 17.42% 1 14.29%
Tim Gardner 22 14.19% 1 14.29%
Al Viro 18 11.61% 1 14.29%
SeungHun Lee 1 0.65% 1 14.29%
Total 155 100.00% 7 100.00%


SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
		char __user *, type, unsigned long, flags, void __user *, data)
{
	return ksys_mount(dev_name, dir_name, type, flags, data);
}

/*
 * Return true if path is reachable from root
 *
 * namespace_sem or mount_lock is held
 */


bool is_path_reachable(struct mount *mnt, struct dentry *dentry,
			 const struct path *root)
{
	while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) {
		dentry = mnt->mnt_mountpoint;
		mnt = mnt->mnt_parent;
	}
	return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry);
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 70 100.00% 2 100.00%
Total 70 100.00% 2 100.00%



bool path_is_under(const struct path *path1, const struct path *path2)
{
	bool res;
	read_seqlock_excl(&mount_lock);
	res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2);
	read_sequnlock_excl(&mount_lock);
	return res;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 47 88.68% 3 50.00%
Mickaël Salaün 2 3.77% 1 16.67%
Andi Kleen 2 3.77% 1 16.67%
Yaowei Bai 2 3.77% 1 16.67%
Total 53 100.00% 6 100.00%

EXPORT_SYMBOL(path_is_under);

/*
 * pivot_root Semantics:
 * Moves the root file system of the current process to the directory put_old,
 * makes new_root as the new root file system of the current process, and sets
 * root/cwd of all processes which had them on the current root to new_root.
 *
 * Restrictions:
 * The new_root and put_old must be directories, and  must not be on the
 * same file  system as the current process root. The put_old  must  be
 * underneath new_root,  i.e. adding a non-zero number of /.. to the string
 * pointed to by put_old must yield the same directory as new_root. No other
 * file system may be mounted on put_old. After all, new_root is a mountpoint.
 *
 * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
 * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives
 * in this situation.
 *
 * Notes:
 *  - we don't move root/cwd if they are not at the root (reason: if something
 *    cared enough to change them, it's probably wrong to force them elsewhere)
 *  - it's okay to pick a root that isn't the root of a file system, e.g.
 *    /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
 *    though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
 *    first.
 */

SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
		const char __user *, put_old)
{
	struct path new, old, parent_path, root_parent, root;
	struct mount *new_mnt, *root_mnt, *old_mnt;
	struct mountpoint *old_mp, *root_mp;
	int error;

	if (!may_mount())
		return -EPERM;

	error = user_path_dir(new_root, &new);
	if (error)
		goto out0;

	error = user_path_dir(put_old, &old);
	if (error)
		goto out1;

	error = security_sb_pivotroot(&old, &new);
	if (error)
		goto out2;

	get_fs_root(current->fs, &root);
	old_mp = lock_mount(&old);
	error = PTR_ERR(old_mp);
	if (IS_ERR(old_mp))
		goto out3;

	error = -EINVAL;
	new_mnt = real_mount(new.mnt);
	root_mnt = real_mount(root.mnt);
	old_mnt = real_mount(old.mnt);
	if (IS_MNT_SHARED(old_mnt) ||
		IS_MNT_SHARED(new_mnt->mnt_parent) ||
		IS_MNT_SHARED(root_mnt->mnt_parent))
		goto out4;
	if (!check_mnt(root_mnt) || !check_mnt(new_mnt))
		goto out4;
	if (new_mnt->mnt.mnt_flags & MNT_LOCKED)
		goto out4;
	error = -ENOENT;
	if (d_unlinked(new.dentry))
		goto out4;
	error = -EBUSY;
	if (new_mnt == root_mnt || old_mnt == root_mnt)
		goto out4; /* loop, on the same file system  */
	error = -EINVAL;
	if (root.mnt->mnt_root != root.dentry)
		goto out4; /* not a mountpoint */
	if (!mnt_has_parent(root_mnt))
		goto out4; /* not attached */
	root_mp = root_mnt->mnt_mp;
	if (new.mnt->mnt_root != new.dentry)
		goto out4; /* not a mountpoint */
	if (!mnt_has_parent(new_mnt))
		goto out4; /* not attached */
	/* make sure we can reach put_old from new_root */
	if (!is_path_reachable(old_mnt, old.dentry, &new))
		goto out4;
	/* make certain new is below the root */
	if (!is_path_reachable(new_mnt, new.dentry, &root))
		goto out4;
	root_mp->m_count++; /* pin it so it won't go away */
	lock_mount_hash();
	detach_mnt(new_mnt, &parent_path);
	detach_mnt(root_mnt, &root_parent);
	if (root_mnt->mnt.mnt_flags & MNT_LOCKED) {
		new_mnt->mnt.mnt_flags |= MNT_LOCKED;
		root_mnt->mnt.mnt_flags &= ~MNT_LOCKED;
	}
	/* mount old root on put_old */
	attach_mnt(root_mnt, old_mnt, old_mp);
	/* mount new_root on / */
	attach_mnt(new_mnt, real_mount(root_parent.mnt), root_mp);
	touch_mnt_namespace(current->nsproxy->mnt_ns);
	/* A moved mount should not expire automatically */
	list_del_init(&new_mnt->mnt_expire);
	put_mountpoint(root_mp);
	unlock_mount_hash();
	chroot_fs_refs(&root, &new);
	error = 0;
out4:
	unlock_mount(old_mp);
	if (!error) {
		path_put(&root_parent);
		path_put(&parent_path);
	}
out3:
	path_put(&root);
out2:
	path_put(&old);
out1:
	path_put(&new);
out0:
	return error;
}



static void __init init_mount_tree(void)
{
	struct vfsmount *mnt;
	struct mnt_namespace *ns;
	struct path root;
	struct file_system_type *type;

	type = get_fs_type("rootfs");
	if (!type)
		panic("Can't find rootfs type");
	mnt = vfs_kern_mount(type, 0, "rootfs", NULL);
	put_filesystem(type);
	if (IS_ERR(mnt))
		panic("Can't create rootfs");

	ns = create_mnt_ns(mnt);
	if (IS_ERR(ns))
		panic("Can't allocate initial namespace");

	init_task.nsproxy->mnt_ns = ns;
	get_mnt_ns(ns);

	root.mnt = mnt;
	root.dentry = mnt->mnt_root;
	mnt->mnt_flags |= MNT_LOCKED;

	set_fs_pwd(current->fs, &root);
	set_fs_root(current->fs, &root);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 72 48.98% 3 30.00%
Eric W. Biedermann 35 23.81% 2 20.00%
Jan Blunck 23 15.65% 1 10.00%
Kirill Korotaev 8 5.44% 1 10.00%
Trond Myklebust 5 3.40% 1 10.00%
Al Viro 2 1.36% 1 10.00%
Serge E. Hallyn 2 1.36% 1 10.00%
Total 147 100.00% 10 100.00%



void __init mnt_init(void)
{
	int err;

	mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount),
			0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);

	mount_hashtable = alloc_large_system_hash("Mount-cache",
				sizeof(struct hlist_head),
				mhash_entries, 19,
				HASH_ZERO,
				&m_hash_shift, &m_hash_mask, 0, 0);
	mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache",
				sizeof(struct hlist_head),
				mphash_entries, 19,
				HASH_ZERO,
				&mp_hash_shift, &mp_hash_mask, 0, 0);

	if (!mount_hashtable || !mountpoint_hashtable)
		panic("Failed to allocate mount hash table\n");

	kernfs_init();

	err = sysfs_init();
	if (err)
		printk(KERN_WARNING "%s: sysfs_init error: %d\n",
			__func__, err);
	fs_kobj = kobject_create_and_add("fs", NULL);
	if (!fs_kobj)
		printk(KERN_WARNING "%s: kobj create error\n", __func__);
	init_rootfs();
	init_mount_tree();
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 55 35.95% 4 25.00%
Linus Torvalds 46 30.07% 2 12.50%
Randy Dunlap 28 18.30% 1 6.25%
Greg Kroah-Hartman 8 5.23% 1 6.25%
Tejun Heo 3 1.96% 1 6.25%
Miklos Szeredi 3 1.96% 1 6.25%
Patrick Mochel 3 1.96% 2 12.50%
Harvey Harrison 2 1.31% 1 6.25%
Andrew Morton 2 1.31% 1 6.25%
Pavel Tatashin 2 1.31% 1 6.25%
Cheng Renquan 1 0.65% 1 6.25%
Total 153 100.00% 16 100.00%



void put_mnt_ns(struct mnt_namespace *ns)
{
	if (!atomic_dec_and_test(&ns->count))
		return;
	drop_collected_mounts(&ns->root->mnt);
	free_mnt_ns(ns);
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 14 37.84% 1 14.29%
Trond Myklebust 12 32.43% 1 14.29%
Al Viro 6 16.22% 2 28.57%
Kirill Korotaev 3 8.11% 1 14.29%
Eric W. Biedermann 1 2.70% 1 14.29%
Andi Kleen 1 2.70% 1 14.29%
Total 37 100.00% 7 100.00%



struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
{
	struct vfsmount *mnt;
	mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, data);
	if (!IS_ERR(mnt)) {
		/*
                 * it is a longterm mount, don't release mnt until
                 * we unmount before file sys is unregistered
                */
		real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
	}
	return mnt;
}
Contributors
Person Tokens Prop Commits CommitProp
Al Viro 33 55.93% 2 50.00%
Tim Chen 25 42.37% 1 25.00%
David Howells 1 1.69% 1 25.00%
Total 59 100.00% 4 100.00%

EXPORT_SYMBOL_GPL(kern_mount_data);



void kern_unmount(struct vfsmount *mnt)
{
	/* release long term mount so mount point can be released */
	if (!IS_ERR_OR_NULL(mnt)) {
		real_mount(mnt)->mnt_ns = NULL;
		synchronize_rcu();	/* yecchhh... */
		mntput(mnt);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
Tim Chen 30 76.92% 1 25.00%
Al Viro 9 23.08% 3 75.00%
Total 39 100.00% 4 100.00%

EXPORT_SYMBOL(kern_unmount);



bool our_mnt(struct vfsmount *mnt)
{
	return check_mnt(real_mount(mnt));
}

Contributors
Person Tokens Prop Commits CommitProp
Al Viro 19 100.00% 2 100.00%
Total 19 100.00% 2 100.00%



bool current_chrooted(void)
{
	/* Does the current process have a non-standard root */
	struct path ns_root;
	struct path fs_root;
	bool chrooted;

	/* Find the namespace root */
	ns_root.mnt = &current->nsproxy->mnt_ns->root->mnt;
	ns_root.dentry = ns_root.mnt->mnt_root;
	path_get(&ns_root);
	while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root))
		;

	get_fs_root(current->fs, &fs_root);

	chrooted = !path_equal(&fs_root, &ns_root);

	path_put(&fs_root);
	path_put(&ns_root);

	return chrooted;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 104 100.00% 1 100.00%
Total 104 100.00% 1 100.00%



static bool mnt_already_visible(struct mnt_namespace *ns, struct vfsmount *new,
				int *new_mnt_flags)
{
	int new_flags = *new_mnt_flags;
	struct mount *mnt;
	bool visible = false;

	down_read(&namespace_sem);
	list_for_each_entry(mnt, &ns->list, mnt_list) {
		struct mount *child;
		int mnt_flags;

		if (mnt->mnt.mnt_sb->s_type != new->mnt_sb->s_type)
			continue;

		/* This mount is not fully visible if it's root directory
                 * is not the root directory of the filesystem.
                 */
		if (mnt->mnt.mnt_root != mnt->mnt.mnt_sb->s_root)
			continue;

		/* A local view of the mount flags */
		mnt_flags = mnt->mnt.mnt_flags;

		/* Don't miss readonly hidden in the superblock flags */
		if (sb_rdonly(mnt->mnt.mnt_sb))
			mnt_flags |= MNT_LOCK_READONLY;

		/* Verify the mount flags are equal to or more permissive
                 * than the proposed new mount.
                 */
		if ((mnt_flags & MNT_LOCK_READONLY) &&
		    !(new_flags & MNT_READONLY))
			continue;
		if ((mnt_flags & MNT_LOCK_ATIME) &&
		    ((mnt_flags & MNT_ATIME_MASK) != (new_flags & MNT_ATIME_MASK)))
			continue;

		/* This mount is not fully visible if there are any
                 * locked child mounts that cover anything except for
                 * empty directories.
                 */
		list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
			struct inode *inode = child->mnt_mountpoint->d_inode;
			/* Only worry about locked mounts */
			if (!(child->mnt.mnt_flags & MNT_LOCKED))
				continue;
			/* Is the directory permanetly empty? */
			if (!is_empty_dir_inode(inode))
				goto next;
		}
		/* Preserve the locked attributes */
		*new_mnt_flags |= mnt_flags & (MNT_LOCK_READONLY | \
					       MNT_LOCK_ATIME);
		visible = true;
		goto found;
	next:	;
	}
found:
	up_read(&namespace_sem);
	return visible;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 230 94.65% 12 85.71%
Al Viro 10 4.12% 1 7.14%
David Howells 3 1.23% 1 7.14%
Total 243 100.00% 14 100.00%



static bool mount_too_revealing(struct vfsmount *mnt, int *new_mnt_flags)
{
	const unsigned long required_iflags = SB_I_NOEXEC | SB_I_NODEV;
	struct mnt_namespace *ns = current->nsproxy->mnt_ns;
	unsigned long s_iflags;

	if (ns->user_ns == &init_user_ns)
		return false;

	/* Can this filesystem be too revealing? */
	s_iflags = mnt->mnt_sb->s_iflags;
	if (!(s_iflags & SB_I_USERNS_VISIBLE))
		return false;

	if ((s_iflags & required_iflags) != required_iflags) {
		WARN_ONCE(1, "Expected s_iflags to contain 0x%lx\n",
			  required_iflags);
		return true;
	}

	return !mnt_already_visible(ns, mnt, new_mnt_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 107 100.00% 2 100.00%
Total 107 100.00% 2 100.00%



bool mnt_may_suid(struct vfsmount *mnt)
{
	/*
         * Foreign mounts (accessed via fchdir or through /proc
         * symlinks) are always treated as if they are nosuid.  This
         * prevents namespaces from trusting potentially unsafe
         * suid/sgid bits, file caps, or security labels that originate
         * in other namespaces.
         */
	return !(mnt->mnt_flags & MNT_NOSUID) && check_mnt(real_mount(mnt)) &&
	       current_in_userns(mnt->mnt_sb->s_user_ns);
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Lutomirski 38 100.00% 1 100.00%
Total 38 100.00% 1 100.00%



static struct ns_common *mntns_get(struct task_struct *task)
{
	struct ns_common *ns = NULL;
	struct nsproxy *nsproxy;

	task_lock(task);
	nsproxy = task->nsproxy;
	if (nsproxy) {
		ns = &nsproxy->mnt_ns->ns;
		get_mnt_ns(to_mnt_ns(ns));
	}
	task_unlock(task);

	return ns;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 58 86.57% 2 50.00%
Al Viro 9 13.43% 2 50.00%
Total 67 100.00% 4 100.00%



static void mntns_put(struct ns_common *ns)
{
	put_mnt_ns(to_mnt_ns(ns));
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 14 73.68% 1 33.33%
Al Viro 5 26.32% 2 66.67%
Total 19 100.00% 3 100.00%



static int mntns_install(struct nsproxy *nsproxy, struct ns_common *ns)
{
	struct fs_struct *fs = current->fs;
	struct mnt_namespace *mnt_ns = to_mnt_ns(ns), *old_mnt_ns;
	struct path root;
	int err;

	if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) ||
	    !ns_capable(current_user_ns(), CAP_SYS_CHROOT) ||
	    !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
		return -EPERM;

	if (fs->users != 1)
		return -EINVAL;

	get_mnt_ns(mnt_ns);
	old_mnt_ns = nsproxy->mnt_ns;
	nsproxy->mnt_ns = mnt_ns;

	/* Find the root */
	err = vfs_path_lookup(mnt_ns->root->mnt.mnt_root, &mnt_ns->root->mnt,
				"/", LOOKUP_DOWN, &root);
	if (err) {
		/* revert to old namespace */
		nsproxy->mnt_ns = old_mnt_ns;
		put_mnt_ns(mnt_ns);
		return err;
	}

	put_mnt_ns(old_mnt_ns);

	/* Update the pwd and root */
	set_fs_pwd(fs, &root);
	set_fs_root(fs, &root);

	path_put(&root);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 140 74.47% 4 44.44%
Al Viro 42 22.34% 3 33.33%
Andrey Vagin 5 2.66% 1 11.11%
Zhao Hongjiang 1 0.53% 1 11.11%
Total 188 100.00% 9 100.00%



static struct user_namespace *mntns_owner(struct ns_common *ns)
{
	return to_mnt_ns(ns)->user_ns;
}

Contributors
Person Tokens Prop Commits CommitProp
Andrey Vagin 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%


const struct proc_ns_operations mntns_operations = {
	.name		= "mnt",
	.type		= CLONE_NEWNS,
	.get		= mntns_get,
	.put		= mntns_put,
	.install	= mntns_install,
	.owner		= mntns_owner,
};
Overall Contributors
Person Tokens Prop Commits CommitProp
Al Viro 4378 30.42% 136 36.86%
Eric W. Biedermann 2971 20.64% 61 16.53%
Linus Torvalds 2207 15.33% 15 4.07%
Miklos Szeredi 1040 7.23% 15 4.07%
Ram Pai 856 5.95% 14 3.79%
Nicholas Piggin 506 3.52% 6 1.63%
David Howells 424 2.95% 12 3.25%
Trond Myklebust 310 2.15% 5 1.36%
Dave Hansen 283 1.97% 3 0.81%
Andrew Morton 207 1.44% 10 2.71%
Jan Kara 140 0.97% 1 0.27%
Dominik Brodowski 101 0.70% 2 0.54%
Jan Blunck 97 0.67% 6 1.63%
Ian Kent 78 0.54% 2 0.54%
Valerie Aurora 65 0.45% 1 0.27%
Tim Chen 60 0.42% 1 0.27%
Andrew Lutomirski 50 0.35% 2 0.54%
Vegard Nossum 45 0.31% 1 0.27%
Andries E. Brouwer 40 0.28% 2 0.54%
Christoph Hellwig 38 0.26% 4 1.08%
Jeff Layton 38 0.26% 1 0.27%
Tetsuo Handa 36 0.25% 1 0.27%
Andrey Vagin 32 0.22% 3 0.81%
Randy Dunlap 31 0.22% 2 0.54%
Kirill Korotaev 31 0.22% 1 0.27%
Tim Gardner 28 0.19% 1 0.27%
Li Zefan 28 0.19% 1 0.27%
Greg Kroah-Hartman 27 0.19% 4 1.08%
Stephen D. Smalley 23 0.16% 1 0.27%
Heiko Carstens 20 0.14% 2 0.54%
Matthew Garrett 19 0.13% 2 0.54%
Eric Paris 18 0.13% 2 0.54%
Andi Kleen 14 0.10% 2 0.54%
Byungchul Park 14 0.10% 1 0.27%
Amir Goldstein 12 0.08% 1 0.27%
Pavel Emelyanov 11 0.08% 1 0.27%
Serge E. Hallyn 7 0.05% 1 0.27%
Cédric Le Goater 7 0.05% 1 0.27%
Adrian Bunk 7 0.05% 2 0.54%
Janak Desai 6 0.04% 1 0.27%
Ingo Molnar 6 0.04% 2 0.54%
Yann Droneaud 6 0.04% 1 0.27%
Andreas Gruenbacher 5 0.03% 2 0.54%
Arnaldo Carvalho de Melo 5 0.03% 1 0.27%
Roman Borisov 4 0.03% 1 0.27%
Valerie Henson 4 0.03% 1 0.27%
Eric Dumazet 4 0.03% 2 0.54%
Dan Carpenter 4 0.03% 1 0.27%
Domen Puncer 3 0.02% 1 0.27%
SeungHun Lee 3 0.02% 1 0.27%
Arnd Bergmann 3 0.02% 1 0.27%
Tejun Heo 3 0.02% 1 0.27%
Andrzej Hajda 3 0.02% 1 0.27%
Patrick Mochel 3 0.02% 2 0.54%
Andrey Ulanov 3 0.02% 1 0.27%
Markus Trippelsdorf 2 0.01% 1 0.27%
Miao Xie 2 0.01% 1 0.27%
Mimi Zohar 2 0.01% 1 0.27%
Prasanna Meda 2 0.01% 1 0.27%
Yaowei Bai 2 0.01% 1 0.27%
Chuck Lever 2 0.01% 1 0.27%
Harvey Harrison 2 0.01% 1 0.27%
Christoph Lameter 2 0.01% 1 0.27%
Pavel Tatashin 2 0.01% 1 0.27%
Mickaël Salaün 2 0.01% 1 0.27%
Mark Rutland 1 0.01% 1 0.27%
Cheng Renquan 1 0.01% 1 0.27%
Rob Landley 1 0.01% 1 0.27%
Robert P. J. Day 1 0.01% 1 0.27%
Alexey Dobriyan 1 0.01% 1 0.27%
Kay Sievers 1 0.01% 1 0.27%
Neil Brown 1 0.01% 1 0.27%
Zhao Hongjiang 1 0.01% 1 0.27%
Emese Revfy 1 0.01% 1 0.27%
Badari Pulavarty 1 0.01% 1 0.27%
Ravikiran G. Thirumalai 0.00% 0 0.00%
Total 14394 100.00% 369 100.00%
Directory: fs

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Al Viro	34	100.00%	1	100.00%
Total	34	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.17 fs/namespace.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
