1 #include <linux/proc_fs.h> 2 #include <linux/nsproxy.h> 3 #include <linux/sched.h> 4 #include <linux/ptrace.h> 5 #include <linux/fs_struct.h> 6 #include <linux/mount.h> 7 #include <linux/path.h> 8 #include <linux/namei.h> 9 #include <linux/file.h> 10 #include <linux/utsname.h> 11 #include <net/net_namespace.h> 12 #include <linux/ipc_namespace.h> 13 #include <linux/pid_namespace.h> 14 #include "internal.h" 15 16 17 static const struct proc_ns_operations *ns_entries[] = { 18 #ifdef CONFIG_NET_NS 19 &netns_operations, 20 #endif 21 #ifdef CONFIG_UTS_NS 22 &utsns_operations, 23 #endif 24 #ifdef CONFIG_IPC_NS 25 &ipcns_operations, 26 #endif 27 }; 28 29 static const struct file_operations ns_file_operations = { 30 .llseek = no_llseek, 31 }; 32 33 static struct dentry *proc_ns_instantiate(struct inode *dir, 34 struct dentry *dentry, struct task_struct *task, const void *ptr) 35 { 36 const struct proc_ns_operations *ns_ops = ptr; 37 struct inode *inode; 38 struct proc_inode *ei; 39 struct dentry *error = ERR_PTR(-ENOENT); 40 void *ns; 41 42 inode = proc_pid_make_inode(dir->i_sb, task); 43 if (!inode) 44 goto out; 45 46 ns = ns_ops->get(task); 47 if (!ns) 48 goto out_iput; 49 50 ei = PROC_I(inode); 51 inode->i_mode = S_IFREG|S_IRUSR; 52 inode->i_fop = &ns_file_operations; 53 ei->ns_ops = ns_ops; 54 ei->ns = ns; 55 56 d_set_d_op(dentry, &pid_dentry_operations); 57 d_add(dentry, inode); 58 /* Close the race of the process dying before we return the dentry */ 59 if (pid_revalidate(dentry, 0)) 60 error = NULL; 61 out: 62 return error; 63 out_iput: 64 iput(inode); 65 goto out; 66 } 67 68 static int proc_ns_fill_cache(struct file *filp, void *dirent, 69 filldir_t filldir, struct task_struct *task, 70 const struct proc_ns_operations *ops) 71 { 72 return proc_fill_cache(filp, dirent, filldir, 73 ops->name, strlen(ops->name), 74 proc_ns_instantiate, task, ops); 75 } 76 77 static int proc_ns_dir_readdir(struct file *filp, void *dirent, 78 filldir_t filldir) 79 { 80 int i; 81 struct dentry *dentry = filp->f_path.dentry; 82 struct inode *inode = dentry->d_inode; 83 struct task_struct *task = get_proc_task(inode); 84 const struct proc_ns_operations **entry, **last; 85 ino_t ino; 86 int ret; 87 88 ret = -ENOENT; 89 if (!task) 90 goto out_no_task; 91 92 ret = -EPERM; 93 if (!ptrace_may_access(task, PTRACE_MODE_READ)) 94 goto out; 95 96 ret = 0; 97 i = filp->f_pos; 98 switch (i) { 99 case 0: 100 ino = inode->i_ino; 101 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 102 goto out; 103 i++; 104 filp->f_pos++; 105 /* fall through */ 106 case 1: 107 ino = parent_ino(dentry); 108 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 109 goto out; 110 i++; 111 filp->f_pos++; 112 /* fall through */ 113 default: 114 i -= 2; 115 if (i >= ARRAY_SIZE(ns_entries)) { 116 ret = 1; 117 goto out; 118 } 119 entry = ns_entries + i; 120 last = &ns_entries[ARRAY_SIZE(ns_entries) - 1]; 121 while (entry <= last) { 122 if (proc_ns_fill_cache(filp, dirent, filldir, 123 task, *entry) < 0) 124 goto out; 125 filp->f_pos++; 126 entry++; 127 } 128 } 129 130 ret = 1; 131 out: 132 put_task_struct(task); 133 out_no_task: 134 return ret; 135 } 136 137 const struct file_operations proc_ns_dir_operations = { 138 .read = generic_read_dir, 139 .readdir = 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 struct dentry *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 = ERR_PTR(-ENOENT); 151 152 if (!task) 153 goto out_no_task; 154 155 error = ERR_PTR(-EPERM); 156 if (!ptrace_may_access(task, PTRACE_MODE_READ)) 157 goto out; 158 159 last = &ns_entries[ARRAY_SIZE(ns_entries)]; 160 for (entry = ns_entries; entry < last; entry++) { 161 if (strlen((*entry)->name) != len) 162 continue; 163 if (!memcmp(dentry->d_name.name, (*entry)->name, len)) 164 break; 165 } 166 error = ERR_PTR(-ENOENT); 167 if (entry == last) 168 goto out; 169 170 error = proc_ns_instantiate(dir, dentry, task, *entry); 171 out: 172 put_task_struct(task); 173 out_no_task: 174 return error; 175 } 176 177 const struct inode_operations proc_ns_dir_inode_operations = { 178 .lookup = proc_ns_dir_lookup, 179 .getattr = pid_getattr, 180 .setattr = proc_setattr, 181 }; 182 183 struct file *proc_ns_fget(int fd) 184 { 185 struct file *file; 186 187 file = fget(fd); 188 if (!file) 189 return ERR_PTR(-EBADF); 190 191 if (file->f_op != &ns_file_operations) 192 goto out_invalid; 193 194 return file; 195 196 out_invalid: 197 fput(file); 198 return ERR_PTR(-EINVAL); 199 } 200 201