fs/proc/namespaces.c

   1 #include <linux/proc_fs.h>
   2 #include <linux/nsproxy.h>
   3 #include <linux/ptrace.h>
   4 #include <linux/namei.h>
   5 #include <linux/file.h>
   6 #include <linux/utsname.h>
   7 #include <net/net_namespace.h>
   8 #include <linux/ipc_namespace.h>
   9 #include <linux/pid_namespace.h>
  10 #include <linux/user_namespace.h>
  11 #include "internal.h"
  12
  13
  14 static const struct proc_ns_operations *ns_entries[] = {
  15 #ifdef CONFIG_NET_NS
  16         &netns_operations,
  17 #endif
  18 #ifdef CONFIG_UTS_NS
  19         &utsns_operations,
  20 #endif
  21 #ifdef CONFIG_IPC_NS
  22         &ipcns_operations,
  23 #endif
  24 #ifdef CONFIG_PID_NS
  25         &pidns_operations,
  26 #endif
  27 #ifdef CONFIG_USER_NS
  28         &userns_operations,
  29 #endif
  30         &mntns_operations,
  31 };
  32
  33 static const char *proc_ns_get_link(struct dentry *dentry,
  34                                     struct inode *inode,
  35                                     struct delayed_call *done)
  36 {
  37         const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
  38         struct task_struct *task;
  39         struct path ns_path;
  40         void *error = ERR_PTR(-EACCES);
  41
  42         if (!dentry)
  43                 return ERR_PTR(-ECHILD);
  44
  45         task = get_proc_task(inode);
  46         if (!task)
  47                 return error;
  48
  49         if (ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) {
  50                 error = ns_get_path(&ns_path, task, ns_ops);
  51                 if (!error)
  52                         nd_jump_link(&ns_path);
  53         }
  54         put_task_struct(task);
  55         return error;
  56 }
  57
  58 static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen)
  59 {
  60         struct inode *inode = d_inode(dentry);
  61         const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
  62         struct task_struct *task;
  63         char name[50];
  64         int res = -EACCES;
  65
  66         task = get_proc_task(inode);
  67         if (!task)
  68                 return res;
  69
  70         if (ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) {
  71                 res = ns_get_name(name, sizeof(name), task, ns_ops);
  72                 if (res >= 0)
  73                         res = readlink_copy(buffer, buflen, name);
  74         }
  75         put_task_struct(task);
  76         return res;
  77 }
  78
  79 static const struct inode_operations proc_ns_link_inode_operations = {
  80         .readlink       = proc_ns_readlink,
  81         .get_link       = proc_ns_get_link,
  82         .setattr        = proc_setattr,
  83 };
  84
  85 static int proc_ns_instantiate(struct inode *dir,
  86         struct dentry *dentry, struct task_struct *task, const void *ptr)
  87 {
  88         const struct proc_ns_operations *ns_ops = ptr;
  89         struct inode *inode;
  90         struct proc_inode *ei;
  91
  92         inode = proc_pid_make_inode(dir->i_sb, task);
  93         if (!inode)
  94                 goto out;
  95
  96         ei = PROC_I(inode);
  97         inode->i_mode = S_IFLNK|S_IRWXUGO;
  98         inode->i_op = &proc_ns_link_inode_operations;
  99         ei->ns_ops = ns_ops;
 100
 101         d_set_d_op(dentry, &pid_dentry_operations);
 102         d_add(dentry, inode);
 103         /* Close the race of the process dying before we return the dentry */
 104         if (pid_revalidate(dentry, 0))
 105                 return 0;
 106 out:
 107         return -ENOENT;
 108 }
 109
 110 static int proc_ns_dir_readdir(struct file *file, struct dir_context *ctx)
 111 {
 112         struct task_struct *task = get_proc_task(file_inode(file));
 113         const struct proc_ns_operations **entry, **last;
 114
 115         if (!task)
 116                 return -ENOENT;
 117
 118         if (!dir_emit_dots(file, ctx))
 119                 goto out;
 120         if (ctx->pos >= 2 + ARRAY_SIZE(ns_entries))
 121                 goto out;
 122         entry = ns_entries + (ctx->pos - 2);
 123         last = &ns_entries[ARRAY_SIZE(ns_entries) - 1];
 124         while (entry <= last) {
 125                 const struct proc_ns_operations *ops = *entry;
 126                 if (!proc_fill_cache(file, ctx, ops->name, strlen(ops->name),
 127                                      proc_ns_instantiate, task, ops))
 128                         break;
 129                 ctx->pos++;
 130                 entry++;
 131         }
 132 out:
 133         put_task_struct(task);
 134         return 0;
 135 }
 136
 137 const struct file_operations proc_ns_dir_operations = {
 138         .read           = generic_read_dir,
 139         .iterate        = proc_ns_dir_readdir,
 140 };
 141
 142 static struct dentry *proc_ns_dir_lookup(struct inode *dir,
 143                                 struct dentry *dentry, unsigned int flags)
 144 {
 145         int error;
 146         struct task_struct *task = get_proc_task(dir);
 147         const struct proc_ns_operations **entry, **last;
 148         unsigned int len = dentry->d_name.len;
 149
 150         error = -ENOENT;
 151
 152         if (!task)
 153                 goto out_no_task;
 154
 155         last = &ns_entries[ARRAY_SIZE(ns_entries)];
 156         for (entry = ns_entries; entry < last; entry++) {
 157                 if (strlen((*entry)->name) != len)
 158                         continue;
 159                 if (!memcmp(dentry->d_name.name, (*entry)->name, len))
 160                         break;
 161         }
 162         if (entry == last)
 163                 goto out;
 164
 165         error = proc_ns_instantiate(dir, dentry, task, *entry);
 166 out:
 167         put_task_struct(task);
 168 out_no_task:
 169         return ERR_PTR(error);
 170 }
 171
 172 const struct inode_operations proc_ns_dir_inode_operations = {
 173         .lookup         = proc_ns_dir_lookup,
 174         .getattr        = pid_getattr,
 175         .setattr        = proc_setattr,
 176 };