[linux-block.git] / fs / proc_namespace.c

// SPDX-License-Identifier: GPL-2.0
/*
 * 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 __poll_t 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;
	__poll_t res = EPOLLIN | EPOLLRDNORM;
	int event;

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

	event = READ_ONCE(ns->event);
	if (m->poll_event != event) {
		m->poll_event = event;
		res |= EPOLLERR | EPOLLPRI;
	}

	return res;
}

struct proc_fs_opts {
	int flag;
	const char *str;
};

static int show_sb_opts(struct seq_file *m, struct super_block *sb)
{
	static const struct proc_fs_opts fs_opts[] = {
		{ SB_SYNCHRONOUS, ",sync" },
		{ SB_DIRSYNC, ",dirsync" },
		{ SB_MANDLOCK, ",mand" },
		{ SB_LAZYTIME, ",lazytime" },
		{ 0, NULL }
	};
	const struct proc_fs_opts *fs_infop;

	for (fs_infop = fs_opts; 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_opts mnt_opts[] = {
		{ MNT_NOSUID, ",nosuid" },
		{ MNT_NODEV, ",nodev" },
		{ MNT_NOEXEC, ",noexec" },
		{ MNT_NOATIME, ",noatime" },
		{ MNT_NODIRATIME, ",nodiratime" },
		{ MNT_RELATIME, ",relatime" },
		{ MNT_NOSYMFOLLOW, ",nosymfollow" },
		{ 0, NULL }
	};
	const struct proc_fs_opts *fs_infop;

	for (fs_infop = mnt_opts; fs_infop->flag; fs_infop++) {
		if (mnt->mnt_flags & fs_infop->flag)
			seq_puts(m, fs_infop->str);
	}

	if (is_idmapped_mnt(mnt))
		seq_puts(m, ",idmapped");
}

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) {
		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_rdonly(sb) ? " 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;
	INIT_LIST_HEAD(&p->cursor.mnt_list);
	p->cursor.mnt.mnt_flags = MNT_CURSOR;

	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);
	mnt_cursor_del(p->ns, &p->cursor);
	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_iter	= seq_read_iter,
	.splice_read	= copy_splice_read,
	.llseek		= seq_lseek,
	.release	= mounts_release,
	.poll		= mounts_poll,
};

const struct file_operations proc_mountinfo_operations = {
	.open		= mountinfo_open,
	.read_iter	= seq_read_iter,
	.splice_read	= copy_splice_read,
	.llseek		= seq_lseek,
	.release	= mounts_release,
	.poll		= mounts_poll,
};

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