root/fs/proc/inode.c

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

DEFINITIONS

This source file includes following definitions.
  1. proc_put_inode
  2. proc_put_super
  3. proc_read_super
  4. proc_statfs
  5. proc_read_inode
  6. proc_write_inode

   1 /*
   2  *  linux/fs/proc/inode.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6 
   7 #include <linux/sched.h>
   8 #include <linux/proc_fs.h>
   9 #include <linux/kernel.h>
  10 #include <linux/mm.h>
  11 #include <linux/string.h>
  12 #include <linux/stat.h>
  13 #include <linux/locks.h>
  14 #include <linux/limits.h>
  15 
  16 #include <asm/system.h>
  17 #include <asm/segment.h>
  18 
  19 extern unsigned long prof_len;
  20 
  21 void proc_put_inode(struct inode *inode)
     /* [previous][next][first][last][top][bottom][index][help] */
  22 {
  23         if (inode->i_nlink)
  24                 return;
  25         inode->i_size = 0;
  26 }
  27 
  28 void proc_put_super(struct super_block *sb)
     /* [previous][next][first][last][top][bottom][index][help] */
  29 {
  30         lock_super(sb);
  31         sb->s_dev = 0;
  32         unlock_super(sb);
  33 }
  34 
  35 static struct super_operations proc_sops = { 
  36         proc_read_inode,
  37         NULL,
  38         proc_write_inode,
  39         proc_put_inode,
  40         proc_put_super,
  41         NULL,
  42         proc_statfs,
  43         NULL
  44 };
  45 
  46 struct super_block *proc_read_super(struct super_block *s,void *data, 
     /* [previous][next][first][last][top][bottom][index][help] */
  47                                     int silent)
  48 {
  49         lock_super(s);
  50         s->s_blocksize = 1024;
  51         s->s_blocksize_bits = 10;
  52         s->s_magic = PROC_SUPER_MAGIC;
  53         s->s_op = &proc_sops;
  54         unlock_super(s);
  55         if (!(s->s_mounted = iget(s,PROC_ROOT_INO))) {
  56                 s->s_dev = 0;
  57                 printk("get root inode failed\n");
  58                 return NULL;
  59         }
  60         return s;
  61 }
  62 
  63 void proc_statfs(struct super_block *sb, struct statfs *buf)
     /* [previous][next][first][last][top][bottom][index][help] */
  64 {
  65         put_fs_long(PROC_SUPER_MAGIC, &buf->f_type);
  66         put_fs_long(PAGE_SIZE/sizeof(long), &buf->f_bsize);
  67         put_fs_long(0, &buf->f_blocks);
  68         put_fs_long(0, &buf->f_bfree);
  69         put_fs_long(0, &buf->f_bavail);
  70         put_fs_long(0, &buf->f_files);
  71         put_fs_long(0, &buf->f_ffree);
  72         put_fs_long(NAME_MAX, &buf->f_namelen);
  73         /* Don't know what value to put in buf->f_fsid */
  74 }
  75 
  76 void proc_read_inode(struct inode * inode)
     /* [previous][next][first][last][top][bottom][index][help] */
  77 {
  78         unsigned long ino, pid;
  79         struct task_struct * p;
  80         int i;
  81         
  82         inode->i_op = NULL;
  83         inode->i_mode = 0;
  84         inode->i_uid = 0;
  85         inode->i_gid = 0;
  86         inode->i_nlink = 1;
  87         inode->i_size = 0;
  88         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  89         inode->i_blocks = 0;
  90         inode->i_blksize = 1024;
  91         ino = inode->i_ino;
  92         pid = ino >> 16;
  93         p = task[0];
  94         for (i = 0; i < NR_TASKS ; i++)
  95                 if ((p = task[i]) && (p->pid == pid))
  96                         break;
  97         if (!p || i >= NR_TASKS)
  98                 return;
  99         if (ino == PROC_ROOT_INO) {
 100                 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
 101                 inode->i_nlink = 2;
 102                 for (i = 1 ; i < NR_TASKS ; i++)
 103                         if (task[i])
 104                                 inode->i_nlink++;
 105                 inode->i_op = &proc_root_inode_operations;
 106                 return;
 107         }
 108 
 109         /* files within /proc/net */
 110         if ((ino >= PROC_NET_UNIX) && (ino < PROC_NET_LAST)) {
 111                 inode->i_mode = S_IFREG | S_IRUGO;
 112                 inode->i_op = &proc_net_inode_operations;
 113                 return;
 114         }
 115 
 116         if (!pid) {
 117                 switch (ino) {
 118                         case PROC_KMSG:
 119                                 inode->i_mode = S_IFREG | S_IRUGO;
 120                                 inode->i_op = &proc_kmsg_inode_operations;
 121                                 break;
 122                         case PROC_NET:
 123                                 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
 124                                 inode->i_nlink = 2;
 125                                 inode->i_op = &proc_net_inode_operations;
 126                                 break;
 127                         case PROC_KCORE:
 128                                 inode->i_mode = S_IFREG | S_IRUSR;
 129                                 inode->i_op = &proc_kcore_inode_operations;
 130                                 inode->i_size = high_memory + PAGE_SIZE;
 131                                 break;
 132 #ifdef CONFIG_PROFILE
 133                         case PROC_PROFILE:
 134                                 inode->i_mode = S_IFREG | S_IRUGO | S_IWUSR;
 135                                 inode->i_op = &proc_profile_inode_operations;
 136                                 inode->i_size = (1+prof_len) * sizeof(unsigned long);
 137                                 break;
 138 #endif
 139                         default:
 140                                 inode->i_mode = S_IFREG | S_IRUGO;
 141                                 inode->i_op = &proc_array_inode_operations;
 142                                 break;
 143                 }
 144                 return;
 145         }
 146         ino &= 0x0000ffff;
 147         inode->i_uid = p->euid;
 148         inode->i_gid = p->egid;
 149         switch (ino) {
 150                 case PROC_PID_INO:
 151                         inode->i_nlink = 4;
 152                         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
 153                         inode->i_op = &proc_base_inode_operations;
 154                         return;
 155                 case PROC_PID_MEM:
 156                         inode->i_op = &proc_mem_inode_operations;
 157                         inode->i_mode = S_IFREG | S_IRUSR | S_IWUSR;
 158                         return;
 159                 case PROC_PID_CWD:
 160                 case PROC_PID_ROOT:
 161                 case PROC_PID_EXE:
 162                         inode->i_op = &proc_link_inode_operations;
 163                         inode->i_size = 64;
 164                         inode->i_mode = S_IFLNK | S_IRWXU;
 165                         return;
 166                 case PROC_PID_FD:
 167                         inode->i_mode = S_IFDIR | S_IRUSR | S_IXUSR;
 168                         inode->i_op = &proc_fd_inode_operations;
 169                         inode->i_nlink = 2;
 170                         return;
 171                 case PROC_PID_ENVIRON:
 172                 case PROC_PID_CMDLINE:
 173                 case PROC_PID_STAT:
 174                 case PROC_PID_STATM:
 175                 case PROC_PID_MAPS:
 176                         inode->i_mode = S_IFREG | S_IRUGO;
 177                         inode->i_op = &proc_array_inode_operations;
 178                         return;
 179         }
 180         switch (ino >> 8) {
 181                 case PROC_PID_FD_DIR:
 182                         ino &= 0xff;
 183                         if (ino >= NR_OPEN || !p->files->fd[ino])
 184                                 return;
 185                         inode->i_op = &proc_link_inode_operations;
 186                         inode->i_size = 64;
 187                         inode->i_mode = S_IFLNK;
 188                         if (p->files->fd[ino]->f_mode & 1)
 189                                 inode->i_mode |= S_IRUSR | S_IXUSR;
 190                         if (p->files->fd[ino]->f_mode & 2)
 191                                 inode->i_mode |= S_IWUSR | S_IXUSR;
 192                         return;
 193         }
 194         return;
 195 }
 196 
 197 void proc_write_inode(struct inode * inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 198 {
 199         inode->i_dirt=0;
 200 }

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