1 #include <linux/sched.h> 2 #include <linux/errno.h> 3 #include <linux/dcache.h> 4 #include <linux/path.h> 5 #include <linux/fdtable.h> 6 #include <linux/namei.h> 7 #include <linux/pid.h> 8 #include <linux/security.h> 9 #include <linux/file.h> 10 #include <linux/seq_file.h> 11 12 #include <linux/proc_fs.h> 13 14 #include "internal.h" 15 #include "fd.h" 16 17 static int seq_show(struct seq_file *m, void *v) 18 { 19 struct files_struct *files = NULL; 20 int f_flags = 0, ret = -ENOENT; 21 struct file *file = NULL; 22 struct task_struct *task; 23 24 task = get_proc_task(m->private); 25 if (!task) 26 return -ENOENT; 27 28 files = get_files_struct(task); 29 put_task_struct(task); 30 31 if (files) { 32 int fd = proc_fd(m->private); 33 34 spin_lock(&files->file_lock); 35 file = fcheck_files(files, fd); 36 if (file) { 37 struct fdtable *fdt = files_fdtable(files); 38 39 f_flags = file->f_flags; 40 if (close_on_exec(fd, fdt)) 41 f_flags |= O_CLOEXEC; 42 43 get_file(file); 44 ret = 0; 45 } 46 spin_unlock(&files->file_lock); 47 put_files_struct(files); 48 } 49 50 if (!ret) { 51 seq_printf(m, "pos:\t%lli\nflags:\t0%o\n", 52 (long long)file->f_pos, f_flags); 53 fput(file); 54 } 55 56 return ret; 57 } 58 59 static int seq_fdinfo_open(struct inode *inode, struct file *file) 60 { 61 return single_open(file, seq_show, inode); 62 } 63 64 static const struct file_operations proc_fdinfo_file_operations = { 65 .open = seq_fdinfo_open, 66 .read = seq_read, 67 .llseek = seq_lseek, 68 .release = single_release, 69 }; 70 71 static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags) 72 { 73 struct files_struct *files; 74 struct task_struct *task; 75 const struct cred *cred; 76 struct inode *inode; 77 int fd; 78 79 if (flags & LOOKUP_RCU) 80 return -ECHILD; 81 82 inode = dentry->d_inode; 83 task = get_proc_task(inode); 84 fd = proc_fd(inode); 85 86 if (task) { 87 files = get_files_struct(task); 88 if (files) { 89 struct file *file; 90 91 rcu_read_lock(); 92 file = fcheck_files(files, fd); 93 if (file) { 94 unsigned f_mode = file->f_mode; 95 96 rcu_read_unlock(); 97 put_files_struct(files); 98 99 if (task_dumpable(task)) { 100 rcu_read_lock(); 101 cred = __task_cred(task); 102 inode->i_uid = cred->euid; 103 inode->i_gid = cred->egid; 104 rcu_read_unlock(); 105 } else { 106 inode->i_uid = GLOBAL_ROOT_UID; 107 inode->i_gid = GLOBAL_ROOT_GID; 108 } 109 110 if (S_ISLNK(inode->i_mode)) { 111 unsigned i_mode = S_IFLNK; 112 if (f_mode & FMODE_READ) 113 i_mode |= S_IRUSR | S_IXUSR; 114 if (f_mode & FMODE_WRITE) 115 i_mode |= S_IWUSR | S_IXUSR; 116 inode->i_mode = i_mode; 117 } 118 119 security_task_to_inode(task, inode); 120 put_task_struct(task); 121 return 1; 122 } 123 rcu_read_unlock(); 124 put_files_struct(files); 125 } 126 put_task_struct(task); 127 } 128 129 d_drop(dentry); 130 return 0; 131 } 132 133 static const struct dentry_operations tid_fd_dentry_operations = { 134 .d_revalidate = tid_fd_revalidate, 135 .d_delete = pid_delete_dentry, 136 }; 137 138 static int proc_fd_link(struct dentry *dentry, struct path *path) 139 { 140 struct files_struct *files = NULL; 141 struct task_struct *task; 142 int ret = -ENOENT; 143 144 task = get_proc_task(dentry->d_inode); 145 if (task) { 146 files = get_files_struct(task); 147 put_task_struct(task); 148 } 149 150 if (files) { 151 int fd = proc_fd(dentry->d_inode); 152 struct file *fd_file; 153 154 spin_lock(&files->file_lock); 155 fd_file = fcheck_files(files, fd); 156 if (fd_file) { 157 *path = fd_file->f_path; 158 path_get(&fd_file->f_path); 159 ret = 0; 160 } 161 spin_unlock(&files->file_lock); 162 put_files_struct(files); 163 } 164 165 return ret; 166 } 167 168 static struct dentry * 169 proc_fd_instantiate(struct inode *dir, struct dentry *dentry, 170 struct task_struct *task, const void *ptr) 171 { 172 struct dentry *error = ERR_PTR(-ENOENT); 173 unsigned fd = (unsigned long)ptr; 174 struct proc_inode *ei; 175 struct inode *inode; 176 177 inode = proc_pid_make_inode(dir->i_sb, task); 178 if (!inode) 179 goto out; 180 181 ei = PROC_I(inode); 182 ei->fd = fd; 183 184 inode->i_mode = S_IFLNK; 185 inode->i_op = &proc_pid_link_inode_operations; 186 inode->i_size = 64; 187 188 ei->op.proc_get_link = proc_fd_link; 189 190 d_set_d_op(dentry, &tid_fd_dentry_operations); 191 d_add(dentry, inode); 192 193 /* Close the race of the process dying before we return the dentry */ 194 if (tid_fd_revalidate(dentry, 0)) 195 error = NULL; 196 out: 197 return error; 198 } 199 200 static struct dentry *proc_lookupfd_common(struct inode *dir, 201 struct dentry *dentry, 202 instantiate_t instantiate) 203 { 204 struct task_struct *task = get_proc_task(dir); 205 struct dentry *result = ERR_PTR(-ENOENT); 206 unsigned fd = name_to_int(dentry); 207 208 if (!task) 209 goto out_no_task; 210 if (fd == ~0U) 211 goto out; 212 213 result = instantiate(dir, dentry, task, (void *)(unsigned long)fd); 214 out: 215 put_task_struct(task); 216 out_no_task: 217 return result; 218 } 219 220 static int proc_readfd_common(struct file * filp, void * dirent, 221 filldir_t filldir, instantiate_t instantiate) 222 { 223 struct dentry *dentry = filp->f_path.dentry; 224 struct inode *inode = dentry->d_inode; 225 struct task_struct *p = get_proc_task(inode); 226 struct files_struct *files; 227 unsigned int fd, ino; 228 int retval; 229 230 retval = -ENOENT; 231 if (!p) 232 goto out_no_task; 233 retval = 0; 234 235 fd = filp->f_pos; 236 switch (fd) { 237 case 0: 238 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 239 goto out; 240 filp->f_pos++; 241 case 1: 242 ino = parent_ino(dentry); 243 if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0) 244 goto out; 245 filp->f_pos++; 246 default: 247 files = get_files_struct(p); 248 if (!files) 249 goto out; 250 rcu_read_lock(); 251 for (fd = filp->f_pos - 2; 252 fd < files_fdtable(files)->max_fds; 253 fd++, filp->f_pos++) { 254 char name[PROC_NUMBUF]; 255 int len; 256 int rv; 257 258 if (!fcheck_files(files, fd)) 259 continue; 260 rcu_read_unlock(); 261 262 len = snprintf(name, sizeof(name), "%d", fd); 263 rv = proc_fill_cache(filp, dirent, filldir, 264 name, len, instantiate, p, 265 (void *)(unsigned long)fd); 266 if (rv < 0) 267 goto out_fd_loop; 268 rcu_read_lock(); 269 } 270 rcu_read_unlock(); 271 out_fd_loop: 272 put_files_struct(files); 273 } 274 out: 275 put_task_struct(p); 276 out_no_task: 277 return retval; 278 } 279 280 static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir) 281 { 282 return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate); 283 } 284 285 const struct file_operations proc_fd_operations = { 286 .read = generic_read_dir, 287 .readdir = proc_readfd, 288 .llseek = default_llseek, 289 }; 290 291 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry, 292 unsigned int flags) 293 { 294 return proc_lookupfd_common(dir, dentry, proc_fd_instantiate); 295 } 296 297 /* 298 * /proc/pid/fd needs a special permission handler so that a process can still 299 * access /proc/self/fd after it has executed a setuid(). 300 */ 301 int proc_fd_permission(struct inode *inode, int mask) 302 { 303 int rv = generic_permission(inode, mask); 304 if (rv == 0) 305 return 0; 306 if (task_pid(current) == proc_pid(inode)) 307 rv = 0; 308 return rv; 309 } 310 311 const struct inode_operations proc_fd_inode_operations = { 312 .lookup = proc_lookupfd, 313 .permission = proc_fd_permission, 314 .setattr = proc_setattr, 315 }; 316 317 static struct dentry * 318 proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry, 319 struct task_struct *task, const void *ptr) 320 { 321 struct dentry *error = ERR_PTR(-ENOENT); 322 unsigned fd = (unsigned long)ptr; 323 struct proc_inode *ei; 324 struct inode *inode; 325 326 inode = proc_pid_make_inode(dir->i_sb, task); 327 if (!inode) 328 goto out; 329 330 ei = PROC_I(inode); 331 ei->fd = fd; 332 333 inode->i_mode = S_IFREG | S_IRUSR; 334 inode->i_fop = &proc_fdinfo_file_operations; 335 336 d_set_d_op(dentry, &tid_fd_dentry_operations); 337 d_add(dentry, inode); 338 339 /* Close the race of the process dying before we return the dentry */ 340 if (tid_fd_revalidate(dentry, 0)) 341 error = NULL; 342 out: 343 return error; 344 } 345 346 static struct dentry * 347 proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags) 348 { 349 return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate); 350 } 351 352 static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir) 353 { 354 return proc_readfd_common(filp, dirent, filldir, 355 proc_fdinfo_instantiate); 356 } 357 358 const struct inode_operations proc_fdinfo_inode_operations = { 359 .lookup = proc_lookupfdinfo, 360 .setattr = proc_setattr, 361 }; 362 363 const struct file_operations proc_fdinfo_operations = { 364 .read = generic_read_dir, 365 .readdir = proc_readfdinfo, 366 .llseek = default_llseek, 367 }; 368