[linux.git] / fs / proc_namespace.c

/*
 * 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 = proc_mounts(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 };
	struct super_block *sb = mnt_path.dentry->d_sb;

	if (sb->s_op->show_devname) {
		err = sb->s_op->show_devname(m, mnt_path.dentry);
		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, sb);
	seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");
	err = show_sb_opts(m, sb);
	if (err)
		goto out;
	show_mnt_opts(m, mnt);
	if (sb->s_op->show_options)
		err = sb->s_op->show_options(m, mnt_path.dentry);
	seq_puts(m, " 0 0\n");
out:
	return err;
}

static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt)
{
	struct proc_mounts *p = proc_mounts(m);
	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->mnt_root);
	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->mnt_root);
	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->mnt_root);
	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 };
	struct super_block *sb = mnt_path.dentry->d_sb;
	int err = 0;

	/* device */
	if (sb->s_op->show_devname) {
		seq_puts(m, "device ");
		err = sb->s_op->show_devname(m, mnt_path.dentry);
	} 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, sb);

	/* optional statistics */
	if (sb->s_op->show_stats) {
		seq_putc(m, ' ');
		if (!err)
			err = sb->s_op->show_stats(m, mnt_path.dentry);
	}

	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->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 = proc_mounts(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,
};
Commit	Line	Data
0226f492 AV	1	/*
	2	* fs/proc_namespace.c - handling of /proc/<pid>/{mounts,mountinfo,mountstats}
	3	*
	4	* In fact, that's a piece of procfs; it's almost isolated from
	5	* the rest of fs/proc, but has rather close relationships with
	6	* fs/namespace.c, thus here instead of fs/proc
	7	*
	8	*/
	9	#include <linux/mnt_namespace.h>
	10	#include <linux/nsproxy.h>
	11	#include <linux/security.h>
	12	#include <linux/fs_struct.h>
	13	#include "proc/internal.h" /* only for get_proc_task() in ->open() */
	14
	15	#include "pnode.h"
	16	#include "internal.h"
	17
	18	static unsigned mounts_poll(struct file file, poll_table wait)
	19	{
6ce6e24e	20	struct proc_mounts *p = proc_mounts(file->private_data);
0226f492 AV	21	struct mnt_namespace *ns = p->ns;
	22	unsigned res = POLLIN \| POLLRDNORM;
	23
	24	poll_wait(file, &p->ns->poll, wait);
	25
962830df	26	br_read_lock(&vfsmount_lock);
0226f492 AV	27	if (p->m.poll_event != ns->event) {
	28	p->m.poll_event = ns->event;
	29	res \|= POLLERR \| POLLPRI;
	30	}
962830df	31	br_read_unlock(&vfsmount_lock);
0226f492 AV	32
	33	return res;
	34	}
	35
	36	struct proc_fs_info {
	37	int flag;
	38	const char *str;
	39	};
	40
	41	static int show_sb_opts(struct seq_file m, struct super_block sb)
	42	{
	43	static const struct proc_fs_info fs_info[] = {
	44	{ MS_SYNCHRONOUS, ",sync" },
	45	{ MS_DIRSYNC, ",dirsync" },
	46	{ MS_MANDLOCK, ",mand" },
	47	{ 0, NULL }
	48	};
	49	const struct proc_fs_info *fs_infop;
	50
	51	for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {
	52	if (sb->s_flags & fs_infop->flag)
	53	seq_puts(m, fs_infop->str);
	54	}
	55
	56	return security_sb_show_options(m, sb);
	57	}
	58
	59	static void show_mnt_opts(struct seq_file m, struct vfsmount mnt)
	60	{
	61	static const struct proc_fs_info mnt_info[] = {
	62	{ MNT_NOSUID, ",nosuid" },
	63	{ MNT_NODEV, ",nodev" },
	64	{ MNT_NOEXEC, ",noexec" },
	65	{ MNT_NOATIME, ",noatime" },
	66	{ MNT_NODIRATIME, ",nodiratime" },
	67	{ MNT_RELATIME, ",relatime" },
	68	{ 0, NULL }
	69	};
	70	const struct proc_fs_info *fs_infop;
	71
	72	for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {
	73	if (mnt->mnt_flags & fs_infop->flag)
	74	seq_puts(m, fs_infop->str);
	75	}
	76	}
	77
	78	static inline void mangle(struct seq_file m, const char s)
	79	{
	80	seq_escape(m, s, " \t\n\\");
	81	}
	82
	83	static void show_type(struct seq_file m, struct super_block sb)
	84	{
	85	mangle(m, sb->s_type->name);
	86	if (sb->s_subtype && sb->s_subtype[0]) {
	87	seq_putc(m, '.');
	88	mangle(m, sb->s_subtype);
	89	}
	90	}
	91
	92	static int show_vfsmnt(struct seq_file m, struct vfsmount mnt)
	93	{
	94	struct mount *r = real_mount(mnt);
	95	int err = 0;
96	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
d861c630	97	struct super_block *sb = mnt_path.dentry->d_sb;
0226f492	98
d861c630 AV	99	if (sb->s_op->show_devname) {
d861c630 AV	100	err = sb->s_op->show_devname(m, mnt_path.dentry);
0226f492 AV	101	if (err)
	102	goto out;
	103	} else {
	104	mangle(m, r->mnt_devname ? r->mnt_devname : "none");
	105	}
	106	seq_putc(m, ' ');
	107	seq_path(m, &mnt_path, " \t\n\\");
	108	seq_putc(m, ' ');
d861c630	109	show_type(m, sb);
0226f492	110	seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");
d861c630	111	err = show_sb_opts(m, sb);
0226f492 AV	112	if (err)
	113	goto out;
	114	show_mnt_opts(m, mnt);
d861c630	115	if (sb->s_op->show_options)
34c80b1d	116	err = sb->s_op->show_options(m, mnt_path.dentry);
0226f492 AV	117	seq_puts(m, " 0 0\n");
	118	out:
	119	return err;
	120	}
	121
	122	static int show_mountinfo(struct seq_file m, struct vfsmount mnt)
	123	{
6ce6e24e	124	struct proc_mounts *p = proc_mounts(m);
0226f492 AV	125	struct mount *r = real_mount(mnt);
	126	struct super_block *sb = mnt->mnt_sb;
	127	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
	128	struct path root = p->root;
	129	int err = 0;
	130
	131	seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id,
	132	MAJOR(sb->s_dev), MINOR(sb->s_dev));
	133	if (sb->s_op->show_path)
a6322de6	134	err = sb->s_op->show_path(m, mnt->mnt_root);
0226f492 AV	135	else
	136	seq_dentry(m, mnt->mnt_root, " \t\n\\");
	137	if (err)
	138	goto out;
	139	seq_putc(m, ' ');
	140
	141	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */
	142	err = seq_path_root(m, &mnt_path, &root, " \t\n\\");
	143	if (err)
	144	goto out;
	145
	146	seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
	147	show_mnt_opts(m, mnt);
	148
	149	/* Tagged fields ("foo:X" or "bar") */
	150	if (IS_MNT_SHARED(r))
	151	seq_printf(m, " shared:%i", r->mnt_group_id);
	152	if (IS_MNT_SLAVE(r)) {
	153	int master = r->mnt_master->mnt_group_id;
	154	int dom = get_dominating_id(r, &p->root);
	155	seq_printf(m, " master:%i", master);
	156	if (dom && dom != master)
	157	seq_printf(m, " propagate_from:%i", dom);
	158	}
	159	if (IS_MNT_UNBINDABLE(r))
	160	seq_puts(m, " unbindable");
	161
	162	/* Filesystem specific data */
	163	seq_puts(m, " - ");
	164	show_type(m, sb);
	165	seq_putc(m, ' ');
	166	if (sb->s_op->show_devname)
d861c630	167	err = sb->s_op->show_devname(m, mnt->mnt_root);
0226f492 AV	168	else
	169	mangle(m, r->mnt_devname ? r->mnt_devname : "none");
	170	if (err)
	171	goto out;
	172	seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw");
	173	err = show_sb_opts(m, sb);
	174	if (err)
	175	goto out;
	176	if (sb->s_op->show_options)
34c80b1d	177	err = sb->s_op->show_options(m, mnt->mnt_root);
0226f492 AV	178	seq_putc(m, '\n');
	179	out:
	180	return err;
	181	}
	182
	183	static int show_vfsstat(struct seq_file m, struct vfsmount mnt)
	184	{
	185	struct mount *r = real_mount(mnt);
	186	struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
64132379	187	struct super_block *sb = mnt_path.dentry->d_sb;
0226f492 AV	188	int err = 0;
	189
	190	/* device */
64132379	191	if (sb->s_op->show_devname) {
0226f492	192	seq_puts(m, "device ");
d861c630	193	err = sb->s_op->show_devname(m, mnt_path.dentry);
0226f492 AV	194	} else {
	195	if (r->mnt_devname) {
	196	seq_puts(m, "device ");
	197	mangle(m, r->mnt_devname);
	198	} else
	199	seq_puts(m, "no device");
	200	}
	201
	202	/* mount point */
	203	seq_puts(m, " mounted on ");
	204	seq_path(m, &mnt_path, " \t\n\\");
	205	seq_putc(m, ' ');
	206
	207	/* file system type */
	208	seq_puts(m, "with fstype ");
64132379	209	show_type(m, sb);
0226f492 AV	210
0226f492 AV	211	/* optional statistics */
64132379	212	if (sb->s_op->show_stats) {
0226f492 AV	213	seq_putc(m, ' ');
0226f492 AV	214	if (!err)
64132379	215	err = sb->s_op->show_stats(m, mnt_path.dentry);
0226f492 AV	216	}
	217
	218	seq_putc(m, '\n');
	219	return err;
	220	}
	221
	222	static int mounts_open_common(struct inode inode, struct file file,
	223	int (show)(struct seq_file , struct vfsmount *))
	224	{
	225	struct task_struct *task = get_proc_task(inode);
	226	struct nsproxy *nsp;
	227	struct mnt_namespace *ns = NULL;
	228	struct path root;
	229	struct proc_mounts *p;
	230	int ret = -EINVAL;
	231
	232	if (!task)
	233	goto err;
	234
	235	rcu_read_lock();
	236	nsp = task_nsproxy(task);
	237	if (!nsp) {
	238	rcu_read_unlock();
	239	put_task_struct(task);
	240	goto err;
	241	}
	242	ns = nsp->mnt_ns;
	243	if (!ns) {
	244	rcu_read_unlock();
	245	put_task_struct(task);
	246	goto err;
	247	}
	248	get_mnt_ns(ns);
	249	rcu_read_unlock();
	250	task_lock(task);
	251	if (!task->fs) {
	252	task_unlock(task);
	253	put_task_struct(task);
	254	ret = -ENOENT;
	255	goto err_put_ns;
	256	}
	257	get_fs_root(task->fs, &root);
	258	task_unlock(task);
	259	put_task_struct(task);
	260
	261	ret = -ENOMEM;
	262	p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
	263	if (!p)
	264	goto err_put_path;
	265
	266	file->private_data = &p->m;
	267	ret = seq_open(file, &mounts_op);
	268	if (ret)
	269	goto err_free;
	270
0226f492 AV	271	p->ns = ns;
	272	p->root = root;
	273	p->m.poll_event = ns->event;
	274	p->show = show;
	275
	276	return 0;
	277
	278	err_free:
	279	kfree(p);
	280	err_put_path:
	281	path_put(&root);
	282	err_put_ns:
	283	put_mnt_ns(ns);
	284	err:
	285	return ret;
	286	}
	287
	288	static int mounts_release(struct inode inode, struct file file)
	289	{
6ce6e24e	290	struct proc_mounts *p = proc_mounts(file->private_data);
0226f492 AV	291	path_put(&p->root);
	292	put_mnt_ns(p->ns);
	293	return seq_release(inode, file);
	294	}
	295
	296	static int mounts_open(struct inode inode, struct file file)
	297	{
	298	return mounts_open_common(inode, file, show_vfsmnt);
	299	}
	300
	301	static int mountinfo_open(struct inode inode, struct file file)
	302	{
	303	return mounts_open_common(inode, file, show_mountinfo);
	304	}
	305
	306	static int mountstats_open(struct inode inode, struct file file)
	307	{
	308	return mounts_open_common(inode, file, show_vfsstat);
	309	}
	310
	311	const struct file_operations proc_mounts_operations = {
	312	.open = mounts_open,
	313	.read = seq_read,
	314	.llseek = seq_lseek,
	315	.release = mounts_release,
	316	.poll = mounts_poll,
	317	};
	318
	319	const struct file_operations proc_mountinfo_operations = {
	320	.open = mountinfo_open,
	321	.read = seq_read,
	322	.llseek = seq_lseek,
	323	.release = mounts_release,
	324	.poll = mounts_poll,
	325	};
	326
	327	const struct file_operations proc_mountstats_operations = {
	328	.open = mountstats_open,
	329	.read = seq_read,
	330	.llseek = seq_lseek,
	331	.release = mounts_release,
	332	};