fs/proc/fd.c

   1 /*
   2  *  linux/fs/proc/fd.c
   3  *
   4  *  Copyright (C) 1991, 1992 Linus Torvalds
   5  *
   6  *  proc fd directory handling functions
   7  *
   8  *  01-May-98 Edgar Toernig <froese@gmx.de>
   9  *      Added support for more than 256 fds.
  10  *      Limit raised to 32768.
  11  */
  12
  13 #include <linux/errno.h>
  14 #include <linux/sched.h>
  15 #include <linux/file.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/stat.h>
  18
  19 #include <asm/uaccess.h>
  20
  21 static int proc_readfd(struct file *, void *, filldir_t);
  22 static struct dentry *proc_lookupfd(struct inode *, struct dentry *);
  23
  24 static struct file_operations proc_fd_operations = {
  25         NULL,                   /* lseek - default */
  26         NULL,                   /* read - bad */
  27         NULL,                   /* write - bad */
  28         proc_readfd,            /* readdir */
  29         NULL,                   /* poll - default */
  30         NULL,                   /* ioctl - default */
  31         NULL,                   /* mmap */
  32         NULL,                   /* no special open code */
  33         NULL,                   /* flush */
  34         NULL,                   /* no special release code */
  35         NULL                    /* can't fsync */
  36 };
  37
  38 /*
  39  * proc directories can do almost nothing..
  40  */
  41 struct inode_operations proc_fd_inode_operations = {
  42         &proc_fd_operations,    /* default base directory file-ops */
  43         NULL,                   /* create */
  44         proc_lookupfd,          /* lookup */
  45         NULL,                   /* link */
  46         NULL,                   /* unlink */
  47         NULL,                   /* symlink */
  48         NULL,                   /* mkdir */
  49         NULL,                   /* rmdir */
  50         NULL,                   /* mknod */
  51         NULL,                   /* rename */
  52         NULL,                   /* readlink */
  53         NULL,                   /* follow_link */
  54         NULL,                   /* get_block */
  55         NULL,                   /* readpage */
  56         NULL,                   /* writepage */
  57         NULL,                   /* flushpage */
  58         NULL,                   /* truncate */
  59         proc_permission,        /* permission */
  60         NULL,                   /* smap */
  61         NULL                    /* revalidate */
  62 };
  63
  64 /*
  65  * NOTE! Normally we'd indicate that a file does not
  66  * exist by creating a negative dentry and returning
  67  * a successful return code. However, for this case
  68  * we do not want to create negative dentries, because
  69  * the state of the world can change behind our backs.
  70  *
  71  * Thus just return -ENOENT instead.
  72  */
  73 static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry)
  74 {
  75         unsigned int ino, pid, fd, c;
  76         struct task_struct * p;
  77         struct file * file;
  78         struct inode *inode;
  79         const char *name;
  80         int len, err;
  81
  82         err = -ENOENT;
  83         ino = dir->i_ino;
  84         pid = ino >> 16;
  85         ino &= 0x0000ffff;
  86
  87         if (!pid || ino != PROC_PID_FD)
  88                 goto out;
  89
  90         fd = 0;
  91         len = dentry->d_name.len;
  92         name = dentry->d_name.name;
  93         while (len-- > 0) {
  94                 c = *name - '0';
  95                 name++;
  96                 if (c > 9)
  97                         goto out;
  98                 fd *= 10;
  99                 fd += c;
 100                 if (fd & 0xffff8000)
 101                         goto out;
 102         }
 103
 104         read_lock(&tasklist_lock);
 105         file = NULL;
 106         p = find_task_by_pid(pid);
 107         if (p)
 108                 file = fcheck_task(p, fd);
 109         read_unlock(&tasklist_lock);
 110
 111         /*
 112          *      File handle is invalid if it is out of range, if the process
 113          *      has no files (Zombie) if the file is closed, or if its inode
 114          *      is NULL
 115          */
 116
 117         if (!file || !file->f_dentry)
 118                 goto out;
 119
 120         ino = (pid << 16) + PROC_PID_FD_DIR + fd;
 121         inode = proc_get_inode(dir->i_sb, ino, NULL);
 122         if (inode) {
 123                 dentry->d_op = &proc_dentry_operations;
 124                 d_add(dentry, inode);
 125                 return NULL;
 126         }
 127 out:
 128         return ERR_PTR(err);
 129 }
 130
 131 #define NUMBUF 10
 132
 133 static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
 134 {
 135         struct inode *inode = filp->f_dentry->d_inode;
 136         struct task_struct * p, **tarrayp;
 137         unsigned int fd, pid, ino;
 138         int retval;
 139         char buf[NUMBUF];
 140
 141         retval = 0;
 142         ino = inode->i_ino;
 143         pid = ino >> 16;
 144         ino &= 0x0000ffff;
 145         if (ino != PROC_PID_FD)
 146                 goto out;
 147
 148         for (fd = filp->f_pos; fd < 2; fd++, filp->f_pos++) {
 149                 ino = inode->i_ino;
 150                 if (fd)
 151                         ino = (ino & 0xffff0000) | PROC_PID_INO;
 152                 if (filldir(dirent, "..", fd+1, fd, ino) < 0)
 153                         goto out;
 154         }
 155
 156         read_lock(&tasklist_lock);
 157         p = find_task_by_pid(pid);
 158         if (!p)
 159                 goto out_unlock;
 160         tarrayp = p->tarray_ptr;
 161
 162         for (fd -= 2 ; p->files && fd < p->files->max_fds; fd++, filp->f_pos++)
 163         {
 164                 struct file * file = fcheck_task(p, fd);
 165                 unsigned int i,j;
 166
 167                 if (!file || !file->f_dentry)
 168                         continue;
 169
 170                 j = NUMBUF;
 171                 i = fd;
 172                 do {
 173                         j--;
 174                         buf[j] = '0' + (i % 10);
 175                         i /= 10;
 176                 } while (i);
 177
 178                 /* Drop the task lock, as the filldir function may block */
 179                 read_unlock(&tasklist_lock);
 180
 181                 ino = (pid << 16) + PROC_PID_FD_DIR + fd;
 182                 if (filldir(dirent, buf+j, NUMBUF-j, fd+2, ino) < 0)
 183                         goto out;
 184
 185                 read_lock(&tasklist_lock);
 186                 /* filldir() might have slept, so we must re-validate "p" */
 187                 if (p != *tarrayp || p->pid != pid)
 188                         break;
 189         }
 190 out_unlock:
 191         read_unlock(&tasklist_lock);
 192
 193 out:
 194         return retval;
 195 }