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                 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 };