take the targets of /proc/*/ns/* symlinks to separate fs

New pseudo-filesystem: nsfs.  Targets of /proc/*/ns/* live there now.
It's not mountable (not even registered, so it's not in /proc/filesystems,
etc.).  Files on it *are* bindable - we explicitly permit that in do_loopback().

This stuff lives in fs/nsfs.c now; proc_ns_fget() moved there as well.
get_proc_ns() is a macro now (it's simply returning ->i_private; would
have been an inline, if not for header ordering headache).
proc_ns_inode() is an ex-parrot.  The interface used in procfs is
ns_get_path(path, task, ops) and ns_get_name(buf, size, task, ops).

Dentries and inodes are never hashed; a non-counting reference to dentry
is stashed in ns_common (removed by ->d_prune()) and reused by ns_get_path()
if present.  See ns_get_path()/ns_prune_dentry/nsfs_evict() for details
of that mechanism.

As the result, proc_ns_follow_link() has stopped poking in nd->path.mnt;
it does nd_jump_link() on a consistent <vfsmount,dentry> pair it gets
from ns_get_path().

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

2 files changed, 13 insertions, 144 deletions

diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index a212996e0987..57a9be9a6668 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -32,7 +32,6 @@ static void proc_evict_inode(struct inode *inode)
 {
         struct proc_dir_entry *de;
         struct ctl_table_header *head;
-        struct ns_common *ns;
 
         truncate_inode_pages_final(&inode->i_data);
         clear_inode(inode);
@@ -49,10 +48,6 @@ static void proc_evict_inode(struct inode *inode)
                 RCU_INIT_POINTER(PROC_I(inode)->sysctl, NULL);
                 sysctl_head_put(head);
         }
-        /* Release any associated namespace */
-        ns = PROC_I(inode)->ns.ns;
-        if (ns && ns->ops)
-                ns->ops->put(ns);
 }
 
 static struct kmem_cache * proc_inode_cachep;
diff --git a/fs/proc/namespaces.c b/fs/proc/namespaces.c
index 18fc1cf899de..aaaac77abad0 100644
--- a/fs/proc/namespaces.c
+++ b/fs/proc/namespaces.c
@@ -1,10 +1,6 @@
 #include <linux/proc_fs.h>
 #include <linux/nsproxy.h>
-#include <linux/sched.h>
 #include <linux/ptrace.h>
-#include <linux/fs_struct.h>
-#include <linux/mount.h>
-#include <linux/path.h>
 #include <linux/namei.h>
 #include <linux/file.h>
 #include <linux/utsname.h>
@@ -34,139 +30,45 @@ static const struct proc_ns_operations *ns_entries[] = {
         &mntns_operations,
 };
 
-static const struct file_operations ns_file_operations = {
-        .llseek         = no_llseek,
-};
-
-static const struct inode_operations ns_inode_operations = {
-        .setattr        = proc_setattr,
-};
-
-static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
-{
-        struct inode *inode = dentry->d_inode;
-        const struct proc_ns_operations *ns_ops = dentry->d_fsdata;
-
-        return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]",
-                ns_ops->name, inode->i_ino);
-}
-
-const struct dentry_operations ns_dentry_operations =
-{
-        .d_delete       = always_delete_dentry,
-        .d_dname        = ns_dname,
-};
-
-static struct dentry *proc_ns_get_dentry(struct super_block *sb,
-        struct task_struct *task, const struct proc_ns_operations *ns_ops)
-{
-        struct dentry *dentry, *result;
-        struct inode *inode;
-        struct proc_inode *ei;
-        struct qstr qname = { .name = "", };
-        struct ns_common *ns;
-
-        ns = ns_ops->get(task);
-        if (!ns)
-                return ERR_PTR(-ENOENT);
-
-        dentry = d_alloc_pseudo(sb, &qname);
-        if (!dentry) {
-                ns_ops->put(ns);
-                return ERR_PTR(-ENOMEM);
-        }
-        dentry->d_fsdata = (void *)ns_ops;
-
-        inode = iget_locked(sb, ns->inum);
-        if (!inode) {
-                dput(dentry);
-                ns_ops->put(ns);
-                return ERR_PTR(-ENOMEM);
-        }
-
-        ei = PROC_I(inode);
-        if (inode->i_state & I_NEW) {
-                inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-                inode->i_op = &ns_inode_operations;
-                inode->i_mode = S_IFREG | S_IRUGO;
-                inode->i_fop = &ns_file_operations;
-                ei->ns.ns_ops = ns_ops;
-                ei->ns.ns = ns;
-                unlock_new_inode(inode);
-        } else {
-                ns_ops->put(ns);
-        }
-
-        d_set_d_op(dentry, &ns_dentry_operations);
-        result = d_instantiate_unique(dentry, inode);
-        if (result) {
-                dput(dentry);
-                dentry = result;
-        }
-
-        return dentry;
-}
-
 static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
         struct inode *inode = dentry->d_inode;
-        struct super_block *sb = inode->i_sb;
-        struct proc_inode *ei = PROC_I(inode);
+        const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns.ns_ops;
         struct task_struct *task;
         struct path ns_path;
         void *error = ERR_PTR(-EACCES);
 
         task = get_proc_task(inode);
         if (!task)
-                goto out;
+                return error;
 
-        if (!ptrace_may_access(task, PTRACE_MODE_READ))
-                goto out_put_task;
-
-        ns_path.dentry = proc_ns_get_dentry(sb, task, ei->ns.ns_ops);
-        if (IS_ERR(ns_path.dentry)) {
-                error = ERR_CAST(ns_path.dentry);
-                goto out_put_task;
+        if (ptrace_may_access(task, PTRACE_MODE_READ)) {
+                error = ns_get_path(&ns_path, task, ns_ops);
+                if (!error)
+                        nd_jump_link(nd, &ns_path);
         }
-
-        ns_path.mnt = mntget(nd->path.mnt);
-        nd_jump_link(nd, &ns_path);
-        error = NULL;
-
-out_put_task:
         put_task_struct(task);
-out:
         return error;
 }
 
 static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen)
 {
         struct inode *inode = dentry->d_inode;
-        struct proc_inode *ei = PROC_I(inode);
-        const struct proc_ns_operations *ns_ops = ei->ns.ns_ops;
+        const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns.ns_ops;
         struct task_struct *task;
-        struct ns_common *ns;
         char name[50];
         int res = -EACCES;
 
         task = get_proc_task(inode);
         if (!task)
-                goto out;
-
-        if (!ptrace_may_access(task, PTRACE_MODE_READ))
-                goto out_put_task;
+                return res;
 
-        res = -ENOENT;
-        ns = ns_ops->get(task);
-        if (!ns)
-                goto out_put_task;
-
-        snprintf(name, sizeof(name), "%s:[%u]", ns_ops->name, ns->inum);
-        res = readlink_copy(buffer, buflen, name);
-        ns_ops->put(ns);
-out_put_task:
+        if (ptrace_may_access(task, PTRACE_MODE_READ)) {
+                res = ns_get_name(name, sizeof(name), task, ns_ops);
+                if (res >= 0)
+                        res = readlink_copy(buffer, buflen, name);
+        }
         put_task_struct(task);
-out:
         return res;
 }
 
@@ -268,31 +170,3 @@ const struct inode_operations proc_ns_dir_inode_operations = {
         .getattr        = pid_getattr,
         .setattr        = proc_setattr,
 };
-
-struct file *proc_ns_fget(int fd)
-{
-        struct file *file;
-
-        file = fget(fd);
-        if (!file)
-                return ERR_PTR(-EBADF);
-
-        if (file->f_op != &ns_file_operations)
-                goto out_invalid;
-
-        return file;
-
-out_invalid:
-        fput(file);
-        return ERR_PTR(-EINVAL);
-}
-
-struct ns_common *get_proc_ns(struct inode *inode)
-{
-        return PROC_I(inode)->ns.ns;
-}
-
-bool proc_ns_inode(struct inode *inode)
-{
-        return inode->i_fop == &ns_file_operations;
-}