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.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.ns_ops = ns_ops; 99 ei->ns.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 path ns_path; 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_path.dentry = proc_ns_get_dentry(sb, task, ei->ns.ns_ops); 132 if (IS_ERR(ns_path.dentry)) { 133 error = ERR_CAST(ns_path.dentry); 134 goto out_put_task; 135 } 136 137 ns_path.mnt = mntget(nd->path.mnt); 138 nd_jump_link(nd, &ns_path); 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.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 int 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 197 inode = proc_pid_make_inode(dir->i_sb, task); 198 if (!inode) 199 goto out; 200 201 ei = PROC_I(inode); 202 inode->i_mode = S_IFLNK|S_IRWXUGO; 203 inode->i_op = &proc_ns_link_inode_operations; 204 ei->ns.ns_ops = ns_ops; 205 206 d_set_d_op(dentry, &pid_dentry_operations); 207 d_add(dentry, inode); 208 /* Close the race of the process dying before we return the dentry */ 209 if (pid_revalidate(dentry, 0)) 210 return 0; 211 out: 212 return -ENOENT; 213 } 214 215 static int proc_ns_dir_readdir(struct file *file, struct dir_context *ctx) 216 { 217 struct task_struct *task = get_proc_task(file_inode(file)); 218 const struct proc_ns_operations **entry, **last; 219 220 if (!task) 221 return -ENOENT; 222 223 if (!dir_emit_dots(file, ctx)) 224 goto out; 225 if (ctx->pos >= 2 + ARRAY_SIZE(ns_entries)) 226 goto out; 227 entry = ns_entries + (ctx->pos - 2); 228 last = &ns_entries[ARRAY_SIZE(ns_entries) - 1]; 229 while (entry <= last) { 230 const struct proc_ns_operations *ops = *entry; 231 if (!proc_fill_cache(file, ctx, ops->name, strlen(ops->name), 232 proc_ns_instantiate, task, ops)) 233 break; 234 ctx->pos++; 235 entry++; 236 } 237 out: 238 put_task_struct(task); 239 return 0; 240 } 241 242 const struct file_operations proc_ns_dir_operations = { 243 .read = generic_read_dir, 244 .iterate = proc_ns_dir_readdir, 245 }; 246 247 static struct dentry *proc_ns_dir_lookup(struct inode *dir, 248 struct dentry *dentry, unsigned int flags) 249 { 250 int error; 251 struct task_struct *task = get_proc_task(dir); 252 const struct proc_ns_operations **entry, **last; 253 unsigned int len = dentry->d_name.len; 254 255 error = -ENOENT; 256 257 if (!task) 258 goto out_no_task; 259 260 last = &ns_entries[ARRAY_SIZE(ns_entries)]; 261 for (entry = ns_entries; entry < last; entry++) { 262 if (strlen((*entry)->name) != len) 263 continue; 264 if (!memcmp(dentry->d_name.name, (*entry)->name, len)) 265 break; 266 } 267 if (entry == last) 268 goto out; 269 270 error = proc_ns_instantiate(dir, dentry, task, *entry); 271 out: 272 put_task_struct(task); 273 out_no_task: 274 return ERR_PTR(error); 275 } 276 277 const struct inode_operations proc_ns_dir_inode_operations = { 278 .lookup = proc_ns_dir_lookup, 279 .getattr = pid_getattr, 280 .setattr = proc_setattr, 281 }; 282 283 struct file *proc_ns_fget(int fd) 284 { 285 struct file *file; 286 287 file = fget(fd); 288 if (!file) 289 return ERR_PTR(-EBADF); 290 291 if (file->f_op != &ns_file_operations) 292 goto out_invalid; 293 294 return file; 295 296 out_invalid: 297 fput(file); 298 return ERR_PTR(-EINVAL); 299 } 300 301 struct proc_ns *get_proc_ns(struct inode *inode) 302 { 303 return &PROC_I(inode)->ns; 304 } 305 306 bool proc_ns_inode(struct inode *inode) 307 { 308 return inode->i_fop == &ns_file_operations; 309 } 310