root/fs/proc/root.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. proc_lookuproot
  2. proc_readroot

   1 /*
   2  *  linux/fs/proc/root.c
   3  *
   4  *  Copyright (C) 1991, 1992 Linus Torvalds
   5  *
   6  *  proc root directory handling functions
   7  */
   8 
   9 #include <asm/segment.h>
  10 
  11 #include <linux/errno.h>
  12 #include <linux/sched.h>
  13 #include <linux/proc_fs.h>
  14 #include <linux/stat.h>
  15 #include <linux/config.h>
  16 
  17 static int proc_readroot(struct inode *, struct file *, struct dirent *, int);
  18 static int proc_lookuproot(struct inode *,const char *,int,struct inode **);
  19 
  20 static struct file_operations proc_root_operations = {
  21         NULL,                   /* lseek - default */
  22         NULL,                   /* read - bad */
  23         NULL,                   /* write - bad */
  24         proc_readroot,          /* readdir */
  25         NULL,                   /* select - default */
  26         NULL,                   /* ioctl - default */
  27         NULL,                   /* mmap */
  28         NULL,                   /* no special open code */
  29         NULL,                   /* no special release code */
  30         NULL                    /* no fsync */
  31 };
  32 
  33 /*
  34  * proc directories can do almost nothing..
  35  */
  36 struct inode_operations proc_root_inode_operations = {
  37         &proc_root_operations,  /* default base directory file-ops */
  38         NULL,                   /* create */
  39         proc_lookuproot,        /* lookup */
  40         NULL,                   /* link */
  41         NULL,                   /* unlink */
  42         NULL,                   /* symlink */
  43         NULL,                   /* mkdir */
  44         NULL,                   /* rmdir */
  45         NULL,                   /* mknod */
  46         NULL,                   /* rename */
  47         NULL,                   /* readlink */
  48         NULL,                   /* follow_link */
  49         NULL,                   /* bmap */
  50         NULL,                   /* truncate */
  51         NULL                    /* permission */
  52 };
  53 
  54 static struct proc_dir_entry root_dir[] = {
  55         { 1,1,"." },
  56         { 1,2,".." },
  57         { 2,7,"loadavg" },
  58         { 3,6,"uptime" },
  59         { 4,7,"meminfo" },
  60         { 5,4,"kmsg" },
  61         { 6,7,"version" },
  62         { 7,4,"self" }, /* will change inode # */
  63         { 8,3,"net" },
  64 #ifdef CONFIG_DEBUG_MALLOC
  65         {13,6,"malloc" },
  66 #endif
  67         {14,5,"kcore" },
  68         {16,7,"modules" },
  69         {17,4,"stat" },
  70         {18,7,"devices" },
  71 };
  72 
  73 #define NR_ROOT_DIRENTRY ((sizeof (root_dir))/(sizeof (root_dir[0])))
  74 
  75 static int proc_lookuproot(struct inode * dir,const char * name, int len,
     /* [previous][next][first][last][top][bottom][index][help] */
  76         struct inode ** result)
  77 {
  78         unsigned int pid, c;
  79         int i, ino;
  80 
  81         *result = NULL;
  82         if (!dir)
  83                 return -ENOENT;
  84         if (!S_ISDIR(dir->i_mode)) {
  85                 iput(dir);
  86                 return -ENOENT;
  87         }
  88         i = NR_ROOT_DIRENTRY;
  89         while (i-- > 0 && !proc_match(len,name,root_dir+i))
  90                 /* nothing */;
  91         if (i >= 0) {
  92                 ino = root_dir[i].low_ino;
  93                 if (ino == 1) {
  94                         *result = dir;
  95                         return 0;
  96                 }
  97                 if (ino == 7) /* self modifying inode ... */
  98                         ino = (current->pid << 16) + 2;
  99         } else {
 100                 pid = 0;
 101                 while (len-- > 0) {
 102                         c = *name - '0';
 103                         name++;
 104                         if (c > 9) {
 105                                 pid = 0;
 106                                 break;
 107                         }
 108                         pid *= 10;
 109                         pid += c;
 110                         if (pid & 0xffff0000) {
 111                                 pid = 0;
 112                                 break;
 113                         }
 114                 }
 115                 for (i = 0 ; i < NR_TASKS ; i++)
 116                         if (task[i] && task[i]->pid == pid)
 117                                 break;
 118                 if (!pid || i >= NR_TASKS) {
 119                         iput(dir);
 120                         return -ENOENT;
 121                 }
 122                 ino = (pid << 16) + 2;
 123         }
 124         if (!(*result = iget(dir->i_sb,ino))) {
 125                 iput(dir);
 126                 return -ENOENT;
 127         }
 128         iput(dir);
 129         return 0;
 130 }
 131 
 132 static int proc_readroot(struct inode * inode, struct file * filp,
     /* [previous][next][first][last][top][bottom][index][help] */
 133         struct dirent * dirent, int count)
 134 {
 135         struct task_struct * p;
 136         unsigned int nr,pid;
 137         int i,j;
 138 
 139         if (!inode || !S_ISDIR(inode->i_mode))
 140                 return -EBADF;
 141 repeat:
 142         nr = filp->f_pos;
 143         if (nr < NR_ROOT_DIRENTRY) {
 144                 struct proc_dir_entry * de = root_dir + nr;
 145 
 146                 filp->f_pos++;
 147                 i = de->namelen;
 148                 put_fs_long(de->low_ino, &dirent->d_ino);
 149                 put_fs_word(i,&dirent->d_reclen);
 150                 put_fs_byte(0,i+dirent->d_name);
 151                 j = i;
 152                 while (i--)
 153                         put_fs_byte(de->name[i], i+dirent->d_name);
 154                 return j;
 155         }
 156         nr -= NR_ROOT_DIRENTRY;
 157         if (nr >= NR_TASKS)
 158                 return 0;
 159         filp->f_pos++;
 160         p = task[nr];
 161         if (!p || !(pid = p->pid))
 162                 goto repeat;
 163         if (pid & 0xffff0000)
 164                 goto repeat;
 165         j = 10;
 166         i = 1;
 167         while (pid >= j) {
 168                 j *= 10;
 169                 i++;
 170         }
 171         j = i;
 172         put_fs_long((pid << 16)+2, &dirent->d_ino);
 173         put_fs_word(i, &dirent->d_reclen);
 174         put_fs_byte(0, i+dirent->d_name);
 175         while (i--) {
 176                 put_fs_byte('0'+(pid % 10), i+dirent->d_name);
 177                 pid /= 10;
 178         }
 179         return j;
 180 }

/* [previous][next][first][last][top][bottom][index][help] */