Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 707c5960 authored by Al Viro's avatar Al Viro
Browse files

Merge branch 'nsfs' into for-next

parents ba00410b 3d3d35b1

fs/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -11,7 +11,7 @@ obj-y := open.o read_write.o file_table.o super.o \ 
		attr.o bad_inode.o file.o filesystems.o namespace.o \

		seq_file.o xattr.o libfs.o fs-writeback.o \

		pnode.o splice.o sync.o utimes.o \

		stack.o fs_struct.o statfs.o fs_pin.o

		stack.o fs_struct.o statfs.o fs_pin.o nsfs.o



ifeq ($(CONFIG_BLOCK),y)

obj-y +=	buffer.o block_dev.o direct-io.o mpage.o

fs/internal.h

+5 −0
Original line number Diff line number Diff line
@@ -147,3 +147,8 @@ extern const struct file_operations pipefifo_fops; 
 */

extern void sb_pin_kill(struct super_block *sb);

extern void mnt_pin_kill(struct mount *m);



/*

 * fs/nsfs.c

 */

extern struct dentry_operations ns_dentry_operations;

fs/mount.h

+2 −1
Original line number Diff line number Diff line 
#include <linux/mount.h>

#include <linux/seq_file.h>

#include <linux/poll.h>

#include <linux/ns_common.h>



struct mnt_namespace {

	atomic_t		count;

	unsigned int		proc_inum;

	struct ns_common	ns;

	struct mount *	root;

	struct list_head	list;

	struct user_namespace	*user_ns;

fs/namespace.c

+22 −29
Original line number Diff line number Diff line
@@ -1569,17 +1569,13 @@ SYSCALL_DEFINE1(oldumount, char __user *, name) 
static bool is_mnt_ns_file(struct dentry *dentry)

{

	/* Is this a proxy for a mount namespace? */

	struct inode *inode = dentry->d_inode;

	struct proc_ns *ei;



	if (!proc_ns_inode(inode))

		return false;



	ei = get_proc_ns(inode);

	if (ei->ns_ops != &mntns_operations)

		return false;

	return dentry->d_op == &ns_dentry_operations &&

	       dentry->d_fsdata == &mntns_operations;

}



	return true;

struct mnt_namespace *to_mnt_ns(struct ns_common *ns)

{

	return container_of(ns, struct mnt_namespace, ns);

}



static bool mnt_ns_loop(struct dentry *dentry)
@@ -1591,7 +1587,7 @@ static bool mnt_ns_loop(struct dentry *dentry) 
	if (!is_mnt_ns_file(dentry))

		return false;



	mnt_ns = get_proc_ns(dentry->d_inode)->ns;

	mnt_ns = to_mnt_ns(get_proc_ns(dentry->d_inode));

	return current->nsproxy->mnt_ns->seq >= mnt_ns->seq;

}
@@ -2020,7 +2016,10 @@ static int do_loopback(struct path *path, const char *old_name, 
	if (IS_MNT_UNBINDABLE(old))

		goto out2;



	if (!check_mnt(parent) || !check_mnt(old))

	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))
@@ -2640,7 +2639,7 @@ dput_out: 


static void free_mnt_ns(struct mnt_namespace *ns)

{

	proc_free_inum(ns->proc_inum);

	ns_free_inum(&ns->ns);

	put_user_ns(ns->user_ns);

	kfree(ns);

}
@@ -2662,11 +2661,12 @@ static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *user_ns) 
	new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);

	if (!new_ns)

		return ERR_PTR(-ENOMEM);

	ret = proc_alloc_inum(&new_ns->proc_inum);

	ret = ns_alloc_inum(&new_ns->ns);

	if (ret) {

		kfree(new_ns);

		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;
@@ -3144,31 +3144,31 @@ found: 
	return visible;

}



static void *mntns_get(struct task_struct *task)

static struct ns_common *mntns_get(struct task_struct *task)

{

	struct mnt_namespace *ns = NULL;

	struct ns_common *ns = NULL;

	struct nsproxy *nsproxy;



	task_lock(task);

	nsproxy = task->nsproxy;

	if (nsproxy) {

		ns = nsproxy->mnt_ns;

		get_mnt_ns(ns);

		ns = &nsproxy->mnt_ns->ns;

		get_mnt_ns(to_mnt_ns(ns));

	}

	task_unlock(task);



	return ns;

}



static void mntns_put(void *ns)

static void mntns_put(struct ns_common *ns)

{

	put_mnt_ns(ns);

	put_mnt_ns(to_mnt_ns(ns));

}



static int mntns_install(struct nsproxy *nsproxy, void *ns)

static int mntns_install(struct nsproxy *nsproxy, struct ns_common *ns)

{

	struct fs_struct *fs = current->fs;

	struct mnt_namespace *mnt_ns = ns;

	struct mnt_namespace *mnt_ns = to_mnt_ns(ns);

	struct path root;



	if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) ||
@@ -3198,17 +3198,10 @@ static int mntns_install(struct nsproxy *nsproxy, void *ns) 
	return 0;

}



static unsigned int mntns_inum(void *ns)

{

	struct mnt_namespace *mnt_ns = ns;

	return mnt_ns->proc_inum;

}



const struct proc_ns_operations mntns_operations = {

	.name		= "mnt",

	.type		= CLONE_NEWNS,

	.get		= mntns_get,

	.put		= mntns_put,

	.install	= mntns_install,

	.inum		= mntns_inum,

};

fs/nsfs.c

0 → 100644
+161 −0
Original line number Diff line number Diff line 
#include <linux/mount.h>

#include <linux/file.h>

#include <linux/fs.h>

#include <linux/proc_ns.h>

#include <linux/magic.h>

#include <linux/ktime.h>



static struct vfsmount *nsfs_mnt;



static const struct file_operations ns_file_operations = {

	.llseek		= no_llseek,

};



static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)

{

	struct inode *inode = dentry->d_inode;

	const struct proc_ns_operations *ns_ops = dentry->d_fsdata;



	return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]",

		ns_ops->name, inode->i_ino);

}



static void ns_prune_dentry(struct dentry *dentry)

{

	struct inode *inode = dentry->d_inode;

	if (inode) {

		struct ns_common *ns = inode->i_private;

		atomic_long_set(&ns->stashed, 0);

	}

}



const struct dentry_operations ns_dentry_operations =

{

	.d_prune	= ns_prune_dentry,

	.d_delete	= always_delete_dentry,

	.d_dname	= ns_dname,

};



static void nsfs_evict(struct inode *inode)

{

	struct ns_common *ns = inode->i_private;

	clear_inode(inode);

	ns->ops->put(ns);

}



void *ns_get_path(struct path *path, struct task_struct *task,

			const struct proc_ns_operations *ns_ops)

{

	struct vfsmount *mnt = mntget(nsfs_mnt);

	struct qstr qname = { .name = "", };

	struct dentry *dentry;

	struct inode *inode;

	struct ns_common *ns;

	unsigned long d;



again:

	ns = ns_ops->get(task);

	if (!ns) {

		mntput(mnt);

		return ERR_PTR(-ENOENT);

	}

	rcu_read_lock();

	d = atomic_long_read(&ns->stashed);

	if (!d)

		goto slow;

	dentry = (struct dentry *)d;

	if (!lockref_get_not_dead(&dentry->d_lockref))

		goto slow;

	rcu_read_unlock();

	ns_ops->put(ns);

got_it:

	path->mnt = mnt;

	path->dentry = dentry;

	return NULL;

slow:

	rcu_read_unlock();

	inode = new_inode_pseudo(mnt->mnt_sb);

	if (!inode) {

		ns_ops->put(ns);

		mntput(mnt);

		return ERR_PTR(-ENOMEM);

	}

	inode->i_ino = ns->inum;

	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;

	inode->i_flags |= S_IMMUTABLE;

	inode->i_mode = S_IFREG | S_IRUGO;

	inode->i_fop = &ns_file_operations;

	inode->i_private = ns;



	dentry = d_alloc_pseudo(mnt->mnt_sb, &qname);

	if (!dentry) {

		iput(inode);

		mntput(mnt);

		return ERR_PTR(-ENOMEM);

	}

	d_instantiate(dentry, inode);

	dentry->d_fsdata = (void *)ns_ops;

	d = atomic_long_cmpxchg(&ns->stashed, 0, (unsigned long)dentry);

	if (d) {

		d_delete(dentry);	/* make sure ->d_prune() does nothing */

		dput(dentry);

		cpu_relax();

		goto again;

	}

	goto got_it;

}



int ns_get_name(char *buf, size_t size, struct task_struct *task,

			const struct proc_ns_operations *ns_ops)

{

	struct ns_common *ns;

	int res = -ENOENT;

	ns = ns_ops->get(task);

	if (ns) {

		res = snprintf(buf, size, "%s:[%u]", ns_ops->name, ns->inum);

		ns_ops->put(ns);

	}

	return res;

}



struct file *proc_ns_fget(int fd)

{

	struct file *file;



	file = fget(fd);

	if (!file)

		return ERR_PTR(-EBADF);



	if (file->f_op != &ns_file_operations)

		goto out_invalid;



	return file;



out_invalid:

	fput(file);

	return ERR_PTR(-EINVAL);

}



static const struct super_operations nsfs_ops = {

	.statfs = simple_statfs,

	.evict_inode = nsfs_evict,

};

static struct dentry *nsfs_mount(struct file_system_type *fs_type,

			int flags, const char *dev_name, void *data)

{

	return mount_pseudo(fs_type, "nsfs:", &nsfs_ops,

			&ns_dentry_operations, NSFS_MAGIC);

}

static struct file_system_type nsfs = {

	.name = "nsfs",

	.mount = nsfs_mount,

	.kill_sb = kill_anon_super,

};



void __init nsfs_init(void)

{

	nsfs_mnt = kern_mount(&nsfs);

	if (IS_ERR(nsfs_mnt))

		panic("can't set nsfs up\n");

	nsfs_mnt->mnt_sb->s_flags &= ~MS_NOUSER;

}