[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 <linux/sched/task.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 seq_file *m = file->private_data;
	struct proc_mounts *p = m->private;
	struct mnt_namespace *ns = p->ns;
	unsigned res = POLLIN | POLLRDNORM;
	int event;

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

	event = ACCESS_ONCE(ns->event);
	if (m->poll_event != event) {
		m->poll_event = event;
		res |= POLLERR | POLLPRI;
	}

	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" },
		{ MS_LAZYTIME, ",lazytime" },
		{ 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 proc_mounts *p = m->private;
	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;

	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, ' ');
	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */
	err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
	if (err)
		goto out;
	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 = 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 };
	int err;

	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);
		if (err)
			goto out;
	} else {
		seq_dentry(m, mnt->mnt_root, " \t\n\\");
	}
	seq_putc(m, ' ');

	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */
	err = seq_path_root(m, &mnt_path, &p->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);
		if (err)
			goto out;
	} else {
		mangle(m, r->mnt_devname ? r->mnt_devname : "none");
	}
	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 proc_mounts *p = m->private;
	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;

	/* device */
	if (sb->s_op->show_devname) {
		seq_puts(m, "device ");
		err = sb->s_op->show_devname(m, mnt_path.dentry);
		if (err)
			goto out;
	} 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 ");
	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */
	err = seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
	if (err)
		goto out;
	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, ' ');
		err = sb->s_op->show_stats(m, mnt_path.dentry);
	}

	seq_putc(m, '\n');
out:
	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;
	struct seq_file *m;
	int ret = -EINVAL;

	if (!task)
		goto err;

	task_lock(task);
	nsp = task->nsproxy;
	if (!nsp || !nsp->mnt_ns) {
		task_unlock(task);
		put_task_struct(task);
		goto err;
	}
	ns = nsp->mnt_ns;
	get_mnt_ns(ns);
	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 = seq_open_private(file, &mounts_op, sizeof(struct proc_mounts));
	if (ret)
		goto err_put_path;

	m = file->private_data;
	m->poll_event = ns->event;

	p = m->private;
	p->ns = ns;
	p->root = root;
	p->show = show;
	p->cached_event = ~0ULL;

	return 0;

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