release/src-rt-6.x/linux/linux-2.6/fs/proc/inode.c

   1 /*
   2  *  linux/fs/proc/inode.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/time.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/file.h>
  14 #include <linux/limits.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/smp_lock.h>
  18
  19 #include <asm/system.h>
  20 #include <asm/uaccess.h>
  21
  22 #include "internal.h"
  23
  24 struct proc_dir_entry *de_get(struct proc_dir_entry *de)
  25 {
  26         if (de)
  27                 atomic_inc(&de->count);
  28         return de;
  29 }
  30
  31 /*
  32  * Decrements the use count and checks for deferred deletion.
  33  */
  34 void de_put(struct proc_dir_entry *de)
  35 {
  36         if (de) {
  37                 lock_kernel();
  38                 if (!atomic_read(&de->count)) {
  39                         printk("de_put: entry %s already free!\n", de->name);
  40                         unlock_kernel();
  41                         return;
  42                 }
  43
  44                 if (atomic_dec_and_test(&de->count))
  45                         free_proc_entry(de);
  46                 unlock_kernel();
  47         }
  48 }
  49
  50 /*
  51  * Decrement the use count of the proc_dir_entry.
  52  */
  53 static void proc_delete_inode(struct inode *inode)
  54 {
  55         struct proc_dir_entry *de;
  56
  57         truncate_inode_pages(&inode->i_data, 0);
  58
  59         /* Stop tracking associated processes */
  60         put_pid(PROC_I(inode)->pid);
  61
  62         /* Let go of any associated proc directory entry */
  63         de = PROC_I(inode)->pde;
  64         if (de) {
  65                 if (de->owner)
  66                         module_put(de->owner);
  67                 de_put(de);
  68         }
  69         clear_inode(inode);
  70 }
  71
  72 struct vfsmount *proc_mnt;
  73
  74 static void proc_read_inode(struct inode * inode)
  75 {
  76         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  77 }
  78
  79 static struct kmem_cache * proc_inode_cachep;
  80
  81 static struct inode *proc_alloc_inode(struct super_block *sb)
  82 {
  83         struct proc_inode *ei;
  84         struct inode *inode;
  85
  86         ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
  87         if (!ei)
  88                 return NULL;
  89         ei->pid = NULL;
  90         ei->fd = 0;
  91         ei->op.proc_get_link = NULL;
  92         ei->pde = NULL;
  93         inode = &ei->vfs_inode;
  94         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  95         return inode;
  96 }
  97
  98 static void proc_destroy_inode(struct inode *inode)
  99 {
 100         kmem_cache_free(proc_inode_cachep, PROC_I(inode));
 101 }
 102
 103 static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
 104 {
 105         struct proc_inode *ei = (struct proc_inode *) foo;
 106
 107         inode_init_once(&ei->vfs_inode);
 108 }
 109
 110 int __init proc_init_inodecache(void)
 111 {
 112         proc_inode_cachep = kmem_cache_create("proc_inode_cache",
 113                                              sizeof(struct proc_inode),
 114                                              0, (SLAB_RECLAIM_ACCOUNT|
 115                                                 SLAB_MEM_SPREAD),
 116                                              init_once, NULL);
 117         if (proc_inode_cachep == NULL)
 118                 return -ENOMEM;
 119         return 0;
 120 }
 121
 122 static int proc_remount(struct super_block *sb, int *flags, char *data)
 123 {
 124         *flags |= MS_NODIRATIME;
 125         return 0;
 126 }
 127
 128 static const struct super_operations proc_sops = {
 129         .alloc_inode    = proc_alloc_inode,
 130         .destroy_inode  = proc_destroy_inode,
 131         .read_inode     = proc_read_inode,
 132         .drop_inode     = generic_delete_inode,
 133         .delete_inode   = proc_delete_inode,
 134         .statfs         = simple_statfs,
 135         .remount_fs     = proc_remount,
 136 };
 137
 138 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
 139                                 struct proc_dir_entry *de)
 140 {
 141         struct inode * inode;
 142
 143         if (de != NULL && !try_module_get(de->owner))
 144                 goto out_mod;
 145
 146         inode = iget(sb, ino);
 147         if (!inode)
 148                 goto out_ino;
 149
 150         PROC_I(inode)->fd = 0;
 151         PROC_I(inode)->pde = de;
 152         if (de) {
 153                 if (de->mode) {
 154                         inode->i_mode = de->mode;
 155                         inode->i_uid = de->uid;
 156                         inode->i_gid = de->gid;
 157                 }
 158                 if (de->size)
 159                         inode->i_size = de->size;
 160                 if (de->nlink)
 161                         inode->i_nlink = de->nlink;
 162                 if (de->proc_iops)
 163                         inode->i_op = de->proc_iops;
 164                 if (de->proc_fops)
 165                         inode->i_fop = de->proc_fops;
 166         }
 167
 168         return inode;
 169
 170 out_ino:
 171         if (de != NULL)
 172                 module_put(de->owner);
 173 out_mod:
 174         return NULL;
 175 }
 176
 177 int proc_fill_super(struct super_block *s, void *data, int silent)
 178 {
 179         struct inode * root_inode;
 180
 181         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
 182         s->s_blocksize = 1024;
 183         s->s_blocksize_bits = 10;
 184         s->s_magic = PROC_SUPER_MAGIC;
 185         s->s_op = &proc_sops;
 186         s->s_time_gran = 1;
 187
 188         de_get(&proc_root);
 189         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
 190         if (!root_inode)
 191                 goto out_no_root;
 192         root_inode->i_uid = 0;
 193         root_inode->i_gid = 0;
 194         s->s_root = d_alloc_root(root_inode);
 195         if (!s->s_root)
 196                 goto out_no_root;
 197         return 0;
 198
 199 out_no_root:
 200         printk("proc_read_super: get root inode failed\n");
 201         iput(root_inode);
 202         de_put(&proc_root);
 203         return -ENOMEM;
 204 }
 205 MODULE_LICENSE("GPL");