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

Commit 0226f492 authored by Al Viro's avatar Al Viro
Browse files

vfs: take /proc/*/mounts and friends to fs/proc_namespace.c 



rationale: that stuff is far tighter bound to fs/namespace.c than to
the guts of procfs proper.

Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent 3a2393d7

fs/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ else 
obj-y +=	no-block.o

endif



obj-$(CONFIG_PROC_FS) += proc_namespace.o



obj-$(CONFIG_BLK_DEV_INTEGRITY) += bio-integrity.o

obj-y				+= notify/

obj-$(CONFIG_EPOLL)		+= eventpoll.o

fs/mount.h

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

#include <linux/seq_file.h>

#include <linux/poll.h>



struct mnt_namespace {

	atomic_t		count;

	struct vfsmount *	root;

	struct list_head	list;

	wait_queue_head_t poll;

	int event;

};



struct mnt_pcp {

	int mnt_count;
@@ -49,3 +59,17 @@ static inline int mnt_has_parent(struct mount *mnt) 
}



extern struct mount *__lookup_mnt(struct vfsmount *, struct dentry *, int);



static inline void get_mnt_ns(struct mnt_namespace *ns)

{

	atomic_inc(&ns->count);

}



struct proc_mounts {

	struct seq_file m; /* must be the first element */

	struct mnt_namespace *ns;

	struct path root;

	int (*show)(struct seq_file *, struct vfsmount *);

};



extern const struct seq_operations mounts_op;

fs/namespace.c

+7 −211
Original line number Diff line number Diff line
@@ -898,10 +898,10 @@ void replace_mount_options(struct super_block *sb, char *options) 
EXPORT_SYMBOL(replace_mount_options);



#ifdef CONFIG_PROC_FS

/* iterator */

/* 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;

	struct proc_mounts *p = container_of(m, struct proc_mounts, m);



	down_read(&namespace_sem);

	return seq_list_start(&p->ns->list, *pos);
@@ -909,7 +909,7 @@ static void *m_start(struct seq_file *m, loff_t *pos) 


static void *m_next(struct seq_file *m, void *v, loff_t *pos)

{

	struct proc_mounts *p = m->private;

	struct proc_mounts *p = container_of(m, struct proc_mounts, m);



	return seq_list_next(v, &p->ns->list, pos);

}
@@ -919,222 +919,18 @@ static void m_stop(struct seq_file *m, void *v) 
	up_read(&namespace_sem);

}



int mnt_had_events(struct proc_mounts *p)

{

	struct mnt_namespace *ns = p->ns;

	int res = 0;



	br_read_lock(vfsmount_lock);

	if (p->m.poll_event != ns->event) {

		p->m.poll_event = ns->event;

		res = 1;

	}

	br_read_unlock(vfsmount_lock);



	return res;

}



struct proc_fs_info {

	int flag;

	const char *str;

};



static int show_sb_opts(struct seq_file *m, struct super_block *sb)

{

	static const struct proc_fs_info fs_info[] = {

		{ MS_SYNCHRONOUS, ",sync" },

		{ MS_DIRSYNC, ",dirsync" },

		{ MS_MANDLOCK, ",mand" },

		{ 0, NULL }

	};

	const struct proc_fs_info *fs_infop;



	for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {

		if (sb->s_flags & fs_infop->flag)

			seq_puts(m, fs_infop->str);

	}



	return security_sb_show_options(m, sb);

}



static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)

{

	static const struct proc_fs_info mnt_info[] = {

		{ MNT_NOSUID, ",nosuid" },

		{ MNT_NODEV, ",nodev" },

		{ MNT_NOEXEC, ",noexec" },

		{ MNT_NOATIME, ",noatime" },

		{ MNT_NODIRATIME, ",nodiratime" },

		{ MNT_RELATIME, ",relatime" },

		{ 0, NULL }

	};

	const struct proc_fs_info *fs_infop;



	for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {

		if (mnt->mnt_flags & fs_infop->flag)

			seq_puts(m, fs_infop->str);

	}

}



static void show_type(struct seq_file *m, struct super_block *sb)

{

	mangle(m, sb->s_type->name);

	if (sb->s_subtype && sb->s_subtype[0]) {

		seq_putc(m, '.');

		mangle(m, sb->s_subtype);

	}

}



static int show_vfsmnt(struct seq_file *m, void *v)

static int m_show(struct seq_file *m, void *v)

{

	struct proc_mounts *p = container_of(m, struct proc_mounts, m);

	struct mount *r = list_entry(v, struct mount, mnt_list);

	struct vfsmount *mnt = &r->mnt;

	int err = 0;

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };



	if (mnt->mnt_sb->s_op->show_devname) {

		err = mnt->mnt_sb->s_op->show_devname(m, mnt);

		if (err)

			goto out;

	} else {

		mangle(m, r->mnt_devname ? r->mnt_devname : "none");

	}

	seq_putc(m, ' ');

	seq_path(m, &mnt_path, " \t\n\\");

	seq_putc(m, ' ');

	show_type(m, mnt->mnt_sb);

	seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");

	err = show_sb_opts(m, mnt->mnt_sb);

	if (err)

		goto out;

	show_mnt_opts(m, mnt);

	if (mnt->mnt_sb->s_op->show_options)

		err = mnt->mnt_sb->s_op->show_options(m, mnt);

	seq_puts(m, " 0 0\n");

out:

	return err;

	return p->show(m, &r->mnt);

}



const struct seq_operations mounts_op = {

	.start	= m_start,

	.next	= m_next,

	.stop	= m_stop,

	.show	= show_vfsmnt

};



static int show_mountinfo(struct seq_file *m, void *v)

{

	struct proc_mounts *p = m->private;

	struct mount *r = list_entry(v, struct mount, mnt_list);

	struct vfsmount *mnt = &r->mnt;

	struct super_block *sb = mnt->mnt_sb;

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };

	struct path root = p->root;

	int err = 0;



	seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id,

		   MAJOR(sb->s_dev), MINOR(sb->s_dev));

	if (sb->s_op->show_path)

		err = sb->s_op->show_path(m, mnt);

	else

		seq_dentry(m, mnt->mnt_root, " \t\n\\");

	if (err)

		goto out;

	seq_putc(m, ' ');



	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */

	err = seq_path_root(m, &mnt_path, &root, " \t\n\\");

	if (err)

		goto out;



	seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");

	show_mnt_opts(m, mnt);



	/* Tagged fields ("foo:X" or "bar") */

	if (IS_MNT_SHARED(r))

		seq_printf(m, " shared:%i", r->mnt_group_id);

	if (IS_MNT_SLAVE(r)) {

		int master = r->mnt_master->mnt_group_id;

		int dom = get_dominating_id(r, &p->root);

		seq_printf(m, " master:%i", master);

		if (dom && dom != master)

			seq_printf(m, " propagate_from:%i", dom);

	}

	if (IS_MNT_UNBINDABLE(r))

		seq_puts(m, " unbindable");



	/* Filesystem specific data */

	seq_puts(m, " - ");

	show_type(m, sb);

	seq_putc(m, ' ');

	if (sb->s_op->show_devname)

		err = sb->s_op->show_devname(m, mnt);

	else

		mangle(m, r->mnt_devname ? r->mnt_devname : "none");

	if (err)

		goto out;

	seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw");

	err = show_sb_opts(m, sb);

	if (err)

		goto out;

	if (sb->s_op->show_options)

		err = sb->s_op->show_options(m, mnt);

	seq_putc(m, '\n');

out:

	return err;

}



const struct seq_operations mountinfo_op = {

	.start	= m_start,

	.next	= m_next,

	.stop	= m_stop,

	.show	= show_mountinfo,

};



static int show_vfsstat(struct seq_file *m, void *v)

{

	struct mount *r = list_entry(v, struct mount, mnt_list);

	struct vfsmount *mnt = &r->mnt;

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };

	int err = 0;



	/* device */

	if (mnt->mnt_sb->s_op->show_devname) {

		seq_puts(m, "device ");

		err = mnt->mnt_sb->s_op->show_devname(m, mnt);

	} else {

		if (r->mnt_devname) {

			seq_puts(m, "device ");

			mangle(m, r->mnt_devname);

		} else

			seq_puts(m, "no device");

	}



	/* mount point */

	seq_puts(m, " mounted on ");

	seq_path(m, &mnt_path, " \t\n\\");

	seq_putc(m, ' ');



	/* file system type */

	seq_puts(m, "with fstype ");

	show_type(m, mnt->mnt_sb);



	/* optional statistics */

	if (mnt->mnt_sb->s_op->show_stats) {

		seq_putc(m, ' ');

		if (!err)

			err = mnt->mnt_sb->s_op->show_stats(m, mnt);

	}



	seq_putc(m, '\n');

	return err;

}



const struct seq_operations mountstats_op = {

	.start	= m_start,

	.next	= m_next,

	.stop	= m_stop,

	.show	= show_vfsstat,

	.show	= m_show,

};

#endif  /* CONFIG_PROC_FS */

fs/proc/base.c

+0 −114
Original line number Diff line number Diff line
@@ -631,120 +631,6 @@ static const struct inode_operations proc_def_inode_operations = { 
	.setattr	= proc_setattr,

};



static int mounts_open_common(struct inode *inode, struct file *file,

			      const struct seq_operations *op)

{

	struct task_struct *task = get_proc_task(inode);

	struct nsproxy *nsp;

	struct mnt_namespace *ns = NULL;

	struct path root;

	struct proc_mounts *p;

	int ret = -EINVAL;



	if (task) {

		rcu_read_lock();

		nsp = task_nsproxy(task);

		if (nsp) {

			ns = nsp->mnt_ns;

			if (ns)

				get_mnt_ns(ns);

		}

		rcu_read_unlock();

		if (ns && get_task_root(task, &root) == 0)

			ret = 0;

		put_task_struct(task);

	}



	if (!ns)

		goto err;

	if (ret)

		goto err_put_ns;



	ret = -ENOMEM;

	p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);

	if (!p)

		goto err_put_path;



	file->private_data = &p->m;

	ret = seq_open(file, op);

	if (ret)

		goto err_free;



	p->m.private = p;

	p->ns = ns;

	p->root = root;

	p->m.poll_event = ns->event;



	return 0;



 err_free:

	kfree(p);

 err_put_path:

	path_put(&root);

 err_put_ns:

	put_mnt_ns(ns);

 err:

	return ret;

}



static int mounts_release(struct inode *inode, struct file *file)

{

	struct proc_mounts *p = file->private_data;

	path_put(&p->root);

	put_mnt_ns(p->ns);

	return seq_release(inode, file);

}



static unsigned mounts_poll(struct file *file, poll_table *wait)

{

	struct proc_mounts *p = file->private_data;

	unsigned res = POLLIN | POLLRDNORM;



	poll_wait(file, &p->ns->poll, wait);

	if (mnt_had_events(p))

		res |= POLLERR | POLLPRI;



	return res;

}



static int mounts_open(struct inode *inode, struct file *file)

{

	return mounts_open_common(inode, file, &mounts_op);

}



static const struct file_operations proc_mounts_operations = {

	.open		= mounts_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= mounts_release,

	.poll		= mounts_poll,

};



static int mountinfo_open(struct inode *inode, struct file *file)

{

	return mounts_open_common(inode, file, &mountinfo_op);

}



static const struct file_operations proc_mountinfo_operations = {

	.open		= mountinfo_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= mounts_release,

	.poll		= mounts_poll,

};



static int mountstats_open(struct inode *inode, struct file *file)

{

	return mounts_open_common(inode, file, &mountstats_op);

}



static const struct file_operations proc_mountstats_operations = {

	.open		= mountstats_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= mounts_release,

};



#define PROC_BLOCK_SIZE	(3*1024)		/* 4K page size but our output routines use some slack for overruns */



static ssize_t proc_info_read(struct file * file, char __user * buf,

fs/proc_namespace.c

0 → 100644
+331 −0
Original line number Diff line number Diff line 
/*

 * fs/proc_namespace.c - handling of /proc/<pid>/{mounts,mountinfo,mountstats}

 *

 * In fact, that's a piece of procfs; it's *almost* isolated from

 * the rest of fs/proc, but has rather close relationships with

 * fs/namespace.c, thus here instead of fs/proc

 *

 */

#include <linux/mnt_namespace.h>

#include <linux/nsproxy.h>

#include <linux/security.h>

#include <linux/fs_struct.h>

#include "proc/internal.h" /* only for get_proc_task() in ->open() */



#include "pnode.h"

#include "internal.h"



static unsigned mounts_poll(struct file *file, poll_table *wait)

{

	struct proc_mounts *p = file->private_data;

	struct mnt_namespace *ns = p->ns;

	unsigned res = POLLIN | POLLRDNORM;



	poll_wait(file, &p->ns->poll, wait);



	br_read_lock(vfsmount_lock);

	if (p->m.poll_event != ns->event) {

		p->m.poll_event = ns->event;

		res |= POLLERR | POLLPRI;

	}

	br_read_unlock(vfsmount_lock);



	return res;

}



struct proc_fs_info {

	int flag;

	const char *str;

};



static int show_sb_opts(struct seq_file *m, struct super_block *sb)

{

	static const struct proc_fs_info fs_info[] = {

		{ MS_SYNCHRONOUS, ",sync" },

		{ MS_DIRSYNC, ",dirsync" },

		{ MS_MANDLOCK, ",mand" },

		{ 0, NULL }

	};

	const struct proc_fs_info *fs_infop;



	for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {

		if (sb->s_flags & fs_infop->flag)

			seq_puts(m, fs_infop->str);

	}



	return security_sb_show_options(m, sb);

}



static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)

{

	static const struct proc_fs_info mnt_info[] = {

		{ MNT_NOSUID, ",nosuid" },

		{ MNT_NODEV, ",nodev" },

		{ MNT_NOEXEC, ",noexec" },

		{ MNT_NOATIME, ",noatime" },

		{ MNT_NODIRATIME, ",nodiratime" },

		{ MNT_RELATIME, ",relatime" },

		{ 0, NULL }

	};

	const struct proc_fs_info *fs_infop;



	for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {

		if (mnt->mnt_flags & fs_infop->flag)

			seq_puts(m, fs_infop->str);

	}

}



static inline void mangle(struct seq_file *m, const char *s)

{

	seq_escape(m, s, " \t\n\\");

}



static void show_type(struct seq_file *m, struct super_block *sb)

{

	mangle(m, sb->s_type->name);

	if (sb->s_subtype && sb->s_subtype[0]) {

		seq_putc(m, '.');

		mangle(m, sb->s_subtype);

	}

}



static int show_vfsmnt(struct seq_file *m, struct vfsmount *mnt)

{

	struct mount *r = real_mount(mnt);

	int err = 0;

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };



	if (mnt->mnt_sb->s_op->show_devname) {

		err = mnt->mnt_sb->s_op->show_devname(m, mnt);

		if (err)

			goto out;

	} else {

		mangle(m, r->mnt_devname ? r->mnt_devname : "none");

	}

	seq_putc(m, ' ');

	seq_path(m, &mnt_path, " \t\n\\");

	seq_putc(m, ' ');

	show_type(m, mnt->mnt_sb);

	seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");

	err = show_sb_opts(m, mnt->mnt_sb);

	if (err)

		goto out;

	show_mnt_opts(m, mnt);

	if (mnt->mnt_sb->s_op->show_options)

		err = mnt->mnt_sb->s_op->show_options(m, mnt);

	seq_puts(m, " 0 0\n");

out:

	return err;

}



static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt)

{

	struct proc_mounts *p = m->private;

	struct mount *r = real_mount(mnt);

	struct super_block *sb = mnt->mnt_sb;

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };

	struct path root = p->root;

	int err = 0;



	seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id,

		   MAJOR(sb->s_dev), MINOR(sb->s_dev));

	if (sb->s_op->show_path)

		err = sb->s_op->show_path(m, mnt);

	else

		seq_dentry(m, mnt->mnt_root, " \t\n\\");

	if (err)

		goto out;

	seq_putc(m, ' ');



	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */

	err = seq_path_root(m, &mnt_path, &root, " \t\n\\");

	if (err)

		goto out;



	seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");

	show_mnt_opts(m, mnt);



	/* Tagged fields ("foo:X" or "bar") */

	if (IS_MNT_SHARED(r))

		seq_printf(m, " shared:%i", r->mnt_group_id);

	if (IS_MNT_SLAVE(r)) {

		int master = r->mnt_master->mnt_group_id;

		int dom = get_dominating_id(r, &p->root);

		seq_printf(m, " master:%i", master);

		if (dom && dom != master)

			seq_printf(m, " propagate_from:%i", dom);

	}

	if (IS_MNT_UNBINDABLE(r))

		seq_puts(m, " unbindable");



	/* Filesystem specific data */

	seq_puts(m, " - ");

	show_type(m, sb);

	seq_putc(m, ' ');

	if (sb->s_op->show_devname)

		err = sb->s_op->show_devname(m, mnt);

	else

		mangle(m, r->mnt_devname ? r->mnt_devname : "none");

	if (err)

		goto out;

	seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw");

	err = show_sb_opts(m, sb);

	if (err)

		goto out;

	if (sb->s_op->show_options)

		err = sb->s_op->show_options(m, mnt);

	seq_putc(m, '\n');

out:

	return err;

}



static int show_vfsstat(struct seq_file *m, struct vfsmount *mnt)

{

	struct mount *r = real_mount(mnt);

	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };

	int err = 0;



	/* device */

	if (mnt->mnt_sb->s_op->show_devname) {

		seq_puts(m, "device ");

		err = mnt->mnt_sb->s_op->show_devname(m, mnt);

	} else {

		if (r->mnt_devname) {

			seq_puts(m, "device ");

			mangle(m, r->mnt_devname);

		} else

			seq_puts(m, "no device");

	}



	/* mount point */

	seq_puts(m, " mounted on ");

	seq_path(m, &mnt_path, " \t\n\\");

	seq_putc(m, ' ');



	/* file system type */

	seq_puts(m, "with fstype ");

	show_type(m, mnt->mnt_sb);



	/* optional statistics */

	if (mnt->mnt_sb->s_op->show_stats) {

		seq_putc(m, ' ');

		if (!err)

			err = mnt->mnt_sb->s_op->show_stats(m, mnt);

	}



	seq_putc(m, '\n');

	return err;

}



static int mounts_open_common(struct inode *inode, struct file *file,

			      int (*show)(struct seq_file *, struct vfsmount *))

{

	struct task_struct *task = get_proc_task(inode);

	struct nsproxy *nsp;

	struct mnt_namespace *ns = NULL;

	struct path root;

	struct proc_mounts *p;

	int ret = -EINVAL;



	if (!task)

		goto err;



	rcu_read_lock();

	nsp = task_nsproxy(task);

	if (!nsp) {

		rcu_read_unlock();

		put_task_struct(task);

		goto err;

	}

	ns = nsp->mnt_ns;

	if (!ns) {

		rcu_read_unlock();

		put_task_struct(task);

		goto err;

	}

	get_mnt_ns(ns);

	rcu_read_unlock();

	task_lock(task);

	if (!task->fs) {

		task_unlock(task);

		put_task_struct(task);

		ret = -ENOENT;

		goto err_put_ns;

	}

	get_fs_root(task->fs, &root);

	task_unlock(task);

	put_task_struct(task);



	ret = -ENOMEM;

	p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);

	if (!p)

		goto err_put_path;



	file->private_data = &p->m;

	ret = seq_open(file, &mounts_op);

	if (ret)

		goto err_free;



	p->m.private = p;

	p->ns = ns;

	p->root = root;

	p->m.poll_event = ns->event;

	p->show = show;



	return 0;



 err_free:

	kfree(p);

 err_put_path:

	path_put(&root);

 err_put_ns:

	put_mnt_ns(ns);

 err:

	return ret;

}



static int mounts_release(struct inode *inode, struct file *file)

{

	struct proc_mounts *p = file->private_data;

	path_put(&p->root);

	put_mnt_ns(p->ns);

	return seq_release(inode, file);

}



static int mounts_open(struct inode *inode, struct file *file)

{

	return mounts_open_common(inode, file, show_vfsmnt);

}



static int mountinfo_open(struct inode *inode, struct file *file)

{

	return mounts_open_common(inode, file, show_mountinfo);

}



static int mountstats_open(struct inode *inode, struct file *file)

{

	return mounts_open_common(inode, file, show_vfsstat);

}



const struct file_operations proc_mounts_operations = {

	.open		= mounts_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= mounts_release,

	.poll		= mounts_poll,

};



const struct file_operations proc_mountinfo_operations = {

	.open		= mountinfo_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= mounts_release,

	.poll		= mounts_poll,

};



const struct file_operations proc_mountstats_operations = {

	.open		= mountstats_open,

	.read		= seq_read,

	.llseek		= seq_lseek,

	.release	= mounts_release,

};