On Tue, 2008-03-11 at 17:17 +0100, Miklos Szeredi wrote:
> [One more RFC for mountinfo, and then I'll really send them to
> Andrew.]
>
> Two changes:
>
> 1. Only show reachable mounts in /proc/<pid>/mountinfo, this makes
> mountpoints unambiguous for chrooted processes.
>
> 2. Instead of showing mountpoints relative to the current root, always
> show them relative to the queried task's root.
>
> This means, that a particular mountinfo file will always have the same
> contents, regardless of which process is reading the file. Which is a
> lot more consistent, than the current behavior of /proc/<pid>/mounts.
What about the propagation aspect? Won't you have to show only those
master mount pgid's that have a mounts within the same chrooted tree?
RP
>
> Comments?
>
> Thanks,
> Miklos
>
> Index: linux/fs/dcache.c
> ===================================================================
> --- linux.orig/fs/dcache.c 2008-03-11 12:40:55.000000000 +0100
> +++ linux/fs/dcache.c 2008-03-11 16:22:08.000000000 +0100
> @@ -1774,9 +1774,10 @@ static int prepend(char **buffer, int *b
> *
> * "buflen" should be positive. Caller holds the dcache_lock.
> */
> -static char *__d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
> - struct path *root, char *buffer, int buflen)
> +char *__d_path(struct path *path, struct path *root, char *buffer, int buflen)
> {
> + struct dentry *dentry = path->dentry;
> + struct vfsmount *vfsmnt = path->mnt;
> char * end = buffer+buflen;
> char * retval;
>
> @@ -1863,7 +1864,7 @@ char *d_path(struct path *path, char *bu
> path_get(¤t->fs->root);
> read_unlock(¤t->fs->lock);
> spin_lock(&dcache_lock);
> - res = __d_path(path->dentry, path->mnt, &root, buf, buflen);
> + res = __d_path(path, &root, buf, buflen);
> spin_unlock(&dcache_lock);
> path_put(&root);
> return res;
> @@ -1976,7 +1977,7 @@ asmlinkage long sys_getcwd(char __user *
> unsigned long len;
> char * cwd;
>
> - cwd = __d_path(pwd.dentry, pwd.mnt, &root, page, PAGE_SIZE);
> + cwd = __d_path(&pwd, &root, page, PAGE_SIZE);
> spin_unlock(&dcache_lock);
>
> error = PTR_ERR(cwd);
> Index: linux/fs/namespace.c
> ===================================================================
> --- linux.orig/fs/namespace.c 2008-03-11 12:39:15.000000000 +0100
> +++ linux/fs/namespace.c 2008-03-11 17:00:11.000000000 +0100
> @@ -683,17 +683,17 @@ EXPORT_SYMBOL(save_mount_options);
> /* iterator */
> static void *m_start(struct seq_file *m, loff_t *pos)
> {
> - struct mnt_namespace *n = m->private;
> + struct proc_mounts *p = m->private;
>
> down_read(&namespace_sem);
> - return seq_list_start(&n->list, *pos);
> + return seq_list_start(&p->ns->list, *pos);
> }
>
> static void *m_next(struct seq_file *m, void *v, loff_t *pos)
> {
> - struct mnt_namespace *n = m->private;
> + struct proc_mounts *p = m->private;
>
> - return seq_list_next(v, &n->list, pos);
> + return seq_list_next(v, &p->ns->list, pos);
> }
>
> static void m_stop(struct seq_file *m, void *v)
> @@ -777,13 +777,52 @@ const struct seq_operations mounts_op =
> .show = show_vfsmnt
> };
>
> +/*
> + * Return true if 'path' is reachable from 'root'
> + */
> +static bool is_path_reachable(const struct path *path, const struct path *root)
> +{
> + struct dentry *dentry = path->dentry;
> + struct vfsmount *mnt = path->mnt;
> + bool res = false;
> +
> + spin_lock(&dcache_lock);
> + for (;;) {
> + if (dentry == root->dentry && mnt == root->mnt) {
> + res = true;
> + break;
> + }
> + if (dentry == mnt->mnt_root || IS_ROOT(dentry)) {
> + /* Global root? */
> + spin_lock(&vfsmount_lock);
> + if (mnt->mnt_parent == mnt) {
> + spin_unlock(&vfsmount_lock);
> + break;
> + }
> + dentry = mnt->mnt_mountpoint;
> + mnt = mnt->mnt_parent;
> + spin_unlock(&vfsmount_lock);
> + continue;
> + }
> + dentry = dentry->d_parent;
> + }
> + spin_unlock(&dcache_lock);
> +
> + return res;
> +}
> +
> static int show_mountinfo(struct seq_file *m, void *v)
> {
> + struct proc_mounts *p = m->private;
> struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
> struct super_block *sb = mnt->mnt_sb;
> struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
> int err = 0;
>
> + /* Skip unreachable mounts */
> + if (!is_path_reachable(&mnt_path, &p->root))
> + return 0;
> +
> seq_printf(m, "%i %i %u:%u ", mnt->mnt_id, mnt->mnt_parent->mnt_id,
> MAJOR(sb->s_dev), MINOR(sb->s_dev));
> show_type(m, sb);
> @@ -792,7 +831,7 @@ static int show_mountinfo(struct seq_fil
> seq_putc(m, ' ');
> seq_dentry(m, mnt->mnt_root, " \t\n\\");
> seq_putc(m, ' ');
> - seq_path(m, &mnt_path, " \t\n\\");
> + seq_path_root(m, &mnt_path, &p->root, " \t\n\\");
> seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
> show_mnt_opts(m, mnt);
> seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw");
> Index: linux/fs/proc/base.c
> ===================================================================
> --- linux.orig/fs/proc/base.c 2008-03-11 12:38:48.000000000 +0100
> +++ linux/fs/proc/base.c 2008-03-11 16:22:08.000000000 +0100
> @@ -502,17 +502,14 @@ static const struct inode_operations pro
> .setattr = proc_setattr,
> };
>
> -struct proc_mounts {
> - struct seq_file m;
> - int event;
> -};
> -
> 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 fs_struct *fs = NULL;
> + struct path root;
> struct proc_mounts *p;
> int ret = -EINVAL;
>
> @@ -525,40 +522,61 @@ static int mounts_open_common(struct ino
> get_mnt_ns(ns);
> }
> rcu_read_unlock();
> -
> + if (ns)
> + fs = get_fs_struct(task);
> put_task_struct(task);
> }
>
> - if (ns) {
> - ret = -ENOMEM;
> - p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL);
> - if (p) {
> - file->private_data = &p->m;
> - ret = seq_open(file, op);
> - if (!ret) {
> - p->m.private = ns;
> - p->event = ns->event;
> - return 0;
> - }
> - kfree(p);
> - }
> - put_mnt_ns(ns);
> - }
> + if (!ns)
> + goto err;
> + if (!fs)
> + goto err_put_ns;
> +
> + read_lock(&fs->lock);
> + root = fs->root;
> + path_get(&root);
> + read_unlock(&fs->lock);
> + put_fs_struct(fs);
> +
> + 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->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 seq_file *m = file->private_data;
> - struct mnt_namespace *ns = m->private;
> - put_mnt_ns(ns);
> + 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;
> - struct mnt_namespace *ns = p->m.private;
> + struct mnt_namespace *ns = p->ns;
> unsigned res = 0;
>
> poll_wait(file, &ns->poll, wait);
> Index: linux/fs/seq_file.c
> ===================================================================
> --- linux.orig/fs/seq_file.c 2008-03-11 12:39:15.000000000 +0100
> +++ linux/fs/seq_file.c 2008-03-11 16:22:08.000000000 +0100
> @@ -392,6 +392,29 @@ int seq_path(struct seq_file *m, struct
> EXPORT_SYMBOL(seq_path);
>
> #ifdef CONFIG_PROC_FS
> +int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
> + char *esc)
> +{
> + if (m->count < m->size) {
> + char *s = m->buf + m->count;
> + char *p;
> +
> + spin_lock(&dcache_lock);
> + p = __d_path(path, root, s, m->size - m->count);
> + spin_unlock(&dcache_lock);
> + if (!IS_ERR(p)) {
> + s = mangle_path(s, p, esc);
> + if (s) {
> + p = m->buf + m->count;
> + m->count = s - m->buf;
> + return s - p;
> + }
> + }
> + }
> + m->count = m->size;
> + return -1;
> +}
> +
> /*
> * returns the path of the 'dentry' from the root of its filesystem.
> */
> Index: linux/include/linux/dcache.h
> ===================================================================
> --- linux.orig/include/linux/dcache.h 2008-03-11 12:39:15.000000000 +0100
> +++ linux/include/linux/dcache.h 2008-03-11 16:22:08.000000000 +0100
> @@ -302,6 +302,7 @@ extern int d_validate(struct dentry *, s
> */
> extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
>
> +extern char *__d_path(struct path *path, struct path *root, char *, int);
> extern char *d_path(struct path *, char *, int);
>
> #ifdef CONFIG_PROC_FS
> Index: linux/include/linux/mnt_namespace.h
> ===================================================================
> --- linux.orig/include/linux/mnt_namespace.h 2008-03-11 12:38:48.000000000 +0100
> +++ linux/include/linux/mnt_namespace.h 2008-03-11 16:22:08.000000000 +0100
> @@ -5,6 +5,7 @@
> #include <linux/mount.h>
> #include <linux/sched.h>
> #include <linux/nsproxy.h>
> +#include <linux/seq_file.h>
>
> struct mnt_namespace {
> atomic_t count;
> @@ -14,6 +15,13 @@ struct mnt_namespace {
> int event;
> };
>
> +struct proc_mounts {
> + struct seq_file m; /* must be the first element */
> + struct mnt_namespace *ns;
> + struct path root;
> + int event;
> +};
> +
> extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *,
> struct fs_struct *);
> extern void __put_mnt_ns(struct mnt_namespace *ns);
> Index: linux/include/linux/seq_file.h
> ===================================================================
> --- linux.orig/include/linux/seq_file.h 2008-03-11 12:39:15.000000000 +0100
> +++ linux/include/linux/seq_file.h 2008-03-11 16:22:08.000000000 +0100
> @@ -46,6 +46,8 @@ int seq_printf(struct seq_file *, const
> int seq_path(struct seq_file *, struct path *, char *);
>
> #ifdef CONFIG_PROC_FS
> +int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
> + char *esc);
> int seq_dentry(struct seq_file *, struct dentry *, char *);
> #endif /* CONFIG_PROC_FS */
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
