fs/proc/fd.c

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