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 <linux/user_namespace.h> 15 #include "internal.h" 16 17 18 static const struct proc_ns_operations *ns_entries[] = { 19 #ifdef CONFIG_NET_NS 20 &netns_operations, 21 #endif 22 #ifdef CONFIG_UTS_NS 23 &utsns_operations, 24 #endif 25 #ifdef CONFIG_IPC_NS 26 &ipcns_operations, 27 #endif 28 #ifdef CONFIG_PID_NS 29 &pidns_operations, 30 #endif 31 #ifdef CONFIG_USER_NS 32 &userns_operations, 33 #endif 34 &mntns_operations, 35 }; 36 37 static const struct file_operations ns_file_operations = { 38 .llseek = no_llseek, 39 }; 40 41 static const struct inode_operations ns_inode_operations = { 42 .setattr = proc_setattr, 43 }; 44 45 static int ns_delete_dentry(const struct dentry *dentry) 46 { 47 /* Don't cache namespace inodes when not in use */ 48 return 1; 49 } 50 51 static char *ns_dname(struct dentry *dentry, char *buffer, int buflen) 52 { 53 struct inode *inode = dentry->d_inode; 54 const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops; 55 56 return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]", 57 ns_ops->name, inode->i_ino); 58 } 59 60 const struct dentry_operations ns_dentry_operations = 61 { 62 .d_delete = ns_delete_dentry, 63 .d_dname = ns_dname, 64 }; 65 66 static struct dentry *proc_ns_get_dentry(struct super_block *sb, 67 struct task_struct *task, const struct proc_ns_operations *ns_ops) 68 { 69 struct dentry *dentry, *result; 70 struct inode *inode; 71 struct proc_inode *ei; 72 struct qstr qname = { .name = "", }; 73 void *ns; 74 75 ns = ns_ops->get(task); 76 if (!ns) 77 return ERR_PTR(-ENOENT); 78 79 dentry = d_alloc_pseudo(sb, &qname); 80 if (!dentry) { 81 ns_ops->put(ns); 82 return ERR_PTR(-ENOMEM); 83 } 84 85 inode = iget_locked(sb, ns_ops->inum(ns)); 86 if (!inode) { 87 dput(dentry); 88 ns_ops->put(ns); 89 return ERR_PTR(-ENOMEM); 90 } 91 92 ei = PROC_I(inode); 93 if (inode->i_state & I_NEW) { 94 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 95 inode->i_op = &ns_inode_operations; 96 inode->i_mode = S_IFREG | S_IRUGO; 97 inode->i_fop = &ns_file_operations; 98 ei->ns_ops = ns_ops; 99 ei->ns = ns; 100 unlock_new_inode(inode); 101 } else { 102 ns_ops->put(ns); 103 } 104 105 d_set_d_op(dentry, &ns_dentry_operations); 106 result = d_instantiate_unique(dentry, inode); 107 if (result) { 108 dput(dentry); 109 dentry = result; 110 } 111 112 return dentry; 113 } 114 115 static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd) 116 { 117 struct inode *inode = dentry->d_inode; 118 struct super_block *sb = inode->i_sb; 119 struct proc_inode *ei = PROC_I(inode); 120 struct task_struct *task; 121 struct dentry *ns_dentry; 122 void *error = ERR_PTR(-EACCES); 123 124 task = get_proc_task(inode); 125 if (!task) 126 goto out; 127 128 if (!ptrace_may_access(task, PTRACE_MODE_READ)) 129 goto out_put_task; 130 131 ns_dentry = proc_ns_get_dentry(sb, task, ei->ns_ops); 132 if (IS_ERR(ns_dentry)) { 133 error = ERR_CAST(ns_dentry); 134 goto out_put_task; 135 } 136 137 dput(nd->path.dentry); 138 nd->path.dentry = ns_dentry; 139 error = NULL; 140 141 out_put_task: 142 put_task_struct(task); 143 out: 144 return error; 145 } 146 147 static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen) 148 { 149 struct inode *inode = dentry->d_inode; 150 struct proc_inode *ei = PROC_I(inode); 151 const struct proc_ns_operations *ns_ops = ei->ns_ops; 152 struct task_struct *task; 153 void *ns; 154 char name[50]; 155 int len = -EACCES; 156 157 task = get_proc_task(inode); 158 if (!task) 159 goto out; 160 161 if (!ptrace_may_access(task, PTRACE_MODE_READ)) 162 goto out_put_task; 163 164 len = -ENOENT; 165 ns = ns_ops->get(task); 166 if (!ns) 167 goto out_put_task; 168 169 snprintf(name, sizeof(name), "%s:[%u]", ns_ops->name, ns_ops->inum(ns)); 170 len = strlen(name); 171 172 if (len > buflen) 173 len = buflen; 174 if (copy_to_user(buffer, name, len)) 175 len = -EFAULT; 176 177 ns_ops->put(ns); 178 out_put_task: 179 put_task_struct(task); 180 out: 181 return len; 182 } 183 184 static const struct inode_operations proc_ns_link_inode_operations = { 185 .readlink = proc_ns_readlink, 186 .follow_link = proc_ns_follow_link, 187 .setattr = proc_setattr, 188 }; 189 190 static struct dentry *proc_ns_instantiate(struct inode *dir, 191 struct dentry *dentry, struct task_struct *task, const void *ptr) 192 { 193 const struct proc_ns_operations *ns_ops = ptr; 194 struct inode *inode; 195 struct proc_inode *ei; 196 struct dentry *error = ERR_PTR(-ENOENT); 197 198 inode = proc_pid_make_inode(dir->i_sb, task); 199 if (!inode) 200 goto out; 201 202 ei = PROC_I(inode); 203 inode->i_mode = S_IFLNK|S_IRWXUGO; 204 inode->i_op = &proc_ns_link_inode_operations; 205 ei->ns_ops = ns_ops; 206 207 d_set_d_op(dentry, &pid_dentry_operations); 208 d_add(dentry, inode); 209 /* Close the race of the process dying before we return the dentry */ 210 if (pid_revalidate(dentry, 0)) 211 error = NULL; 212 out: 213 return error; 214 } 215 216 static int proc_ns_fill_cache(struct file *filp, void *dirent, 217 filldir_t filldir, struct task_struct *task, 218 const struct proc_ns_operations *ops) 219 { 220 return proc_fill_cache(filp, dirent, filldir, 221 ops->name, strlen(ops->name), 222 proc_ns_instantiate, task, ops); 223 } 224 225 static int proc_ns_dir_readdir(struct file *filp, void *dirent, 226 filldir_t filldir) 227 { 228 int i; 229 struct dentry *dentry = filp->f_path.dentry; 230 struct inode *inode = dentry->d_inode; 231 struct task_struct *task = get_proc_task(inode); 232 const struct proc_ns_operations **entry, **last; 233 ino_t ino; 234 int ret; 235 236 ret = -ENOENT; 237 if (!task) 238 goto out_no_task; 239 240 ret = 0; 241 i = filp->f_pos; 242 switch (i) { 243 case 0: 244 ino = inode->i_ino; 245 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 246 goto out; 247 i++; 248 filp->f_pos++; 249 /* fall through */ 250 case 1: 251 ino = parent_ino(dentry); 252 if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) 253 goto out; 254 i++; 255 filp->f_pos++; 256 /* fall through */ 257 default: 258 i -= 2; 259 if (i >= ARRAY_SIZE(ns_entries)) { 260 ret = 1; 261 goto out; 262 } 263 entry = ns_entries + i; 264 last = &ns_entries[ARRAY_SIZE(ns_entries) - 1]; 265 while (entry <= last) { 266 if (proc_ns_fill_cache(filp, dirent, filldir, 267 task, *entry) < 0) 268 goto out; 269 filp->f_pos++; 270 entry++; 271 } 272 } 273 274 ret = 1; 275 out: 276 put_task_struct(task); 277 out_no_task: 278 return ret; 279 } 280 281 const struct file_operations proc_ns_dir_operations = { 282 .read = generic_read_dir, 283 .readdir = proc_ns_dir_readdir, 284 }; 285 286 static struct dentry *proc_ns_dir_lookup(struct inode *dir, 287 struct dentry *dentry, unsigned int flags) 288 { 289 struct dentry *error; 290 struct task_struct *task = get_proc_task(dir); 291 const struct proc_ns_operations **entry, **last; 292 unsigned int len = dentry->d_name.len; 293 294 error = ERR_PTR(-ENOENT); 295 296 if (!task) 297 goto out_no_task; 298 299 last = &ns_entries[ARRAY_SIZE(ns_entries)]; 300 for (entry = ns_entries; entry < last; entry++) { 301 if (strlen((*entry)->name) != len) 302 continue; 303 if (!memcmp(dentry->d_name.name, (*entry)->name, len)) 304 break; 305 } 306 if (entry == last) 307 goto out; 308 309 error = proc_ns_instantiate(dir, dentry, task, *entry); 310 out: 311 put_task_struct(task); 312 out_no_task: 313 return error; 314 } 315 316 const struct inode_operations proc_ns_dir_inode_operations = { 317 .lookup = proc_ns_dir_lookup, 318 .getattr = pid_getattr, 319 .setattr = proc_setattr, 320 }; 321 322 struct file *proc_ns_fget(int fd) 323 { 324 struct file *file; 325 326 file = fget(fd); 327 if (!file) 328 return ERR_PTR(-EBADF); 329 330 if (file->f_op != &ns_file_operations) 331 goto out_invalid; 332 333 return file; 334 335 out_invalid: 336 fput(file); 337 return ERR_PTR(-EINVAL); 338 } 339 340 bool proc_ns_inode(struct inode *inode) 341 { 342 return inode->i_fop == &ns_file_operations; 343 } 344