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