fs/proc/inode.c

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

DEFINITIONS
