fs/proc/fd.c

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