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 extern void free_proc_entry(struct proc_dir_entry *);
  23
  24 static inline 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 static 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                         if (de->deleted) {
  46                                 printk("de_put: deferred delete of %s\n",
  47                                         de->name);
  48                                 free_proc_entry(de);
  49                         }
  50                 }
  51                 unlock_kernel();
  52         }
  53 }
  54
  55 /*
  56  * Decrement the use count of the proc_dir_entry.
  57  */
  58 static void proc_delete_inode(struct inode *inode)
  59 {
  60         struct proc_dir_entry *de;
  61         struct task_struct *tsk;
  62
  63         truncate_inode_pages(&inode->i_data, 0);
  64
  65         /* Let go of any associated process */
  66         tsk = PROC_I(inode)->task;
  67         if (tsk)
  68                 put_task_struct(tsk);
  69
  70         /* Let go of any associated proc directory entry */
  71         de = PROC_I(inode)->pde;
  72         if (de) {
  73                 if (de->owner)
  74                         module_put(de->owner);
  75                 de_put(de);
  76         }
  77         clear_inode(inode);
  78 }
  79
  80 struct vfsmount *proc_mnt;
  81
  82 static void proc_read_inode(struct inode * inode)
  83 {
  84         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  85 }
  86
  87 static kmem_cache_t * proc_inode_cachep;
  88
  89 static struct inode *proc_alloc_inode(struct super_block *sb)
  90 {
  91         struct proc_inode *ei;
  92         struct inode *inode;
  93
  94         ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, SLAB_KERNEL);
  95         if (!ei)
  96                 return NULL;
  97         ei->task = NULL;
  98         ei->type = 0;
  99         ei->op.proc_get_link = NULL;
 100         ei->pde = NULL;
 101         inode = &ei->vfs_inode;
 102         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 103         return inode;
 104 }
 105
 106 static void proc_destroy_inode(struct inode *inode)
 107 {
 108         kmem_cache_free(proc_inode_cachep, PROC_I(inode));
 109 }
 110
 111 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
 112 {
 113         struct proc_inode *ei = (struct proc_inode *) foo;
 114
 115         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 116             SLAB_CTOR_CONSTRUCTOR)
 117                 inode_init_once(&ei->vfs_inode);
 118 }
 119
 120 int __init proc_init_inodecache(void)
 121 {
 122         proc_inode_cachep = kmem_cache_create("proc_inode_cache",
 123                                              sizeof(struct proc_inode),
 124                                              0, SLAB_RECLAIM_ACCOUNT,
 125                                              init_once, NULL);
 126         if (proc_inode_cachep == NULL)
 127                 return -ENOMEM;
 128         return 0;
 129 }
 130
 131 static int proc_remount(struct super_block *sb, int *flags, char *data)
 132 {
 133         *flags |= MS_NODIRATIME;
 134         return 0;
 135 }
 136
 137 static struct super_operations proc_sops = {
 138         .alloc_inode    = proc_alloc_inode,
 139         .destroy_inode  = proc_destroy_inode,
 140         .read_inode     = proc_read_inode,
 141         .drop_inode     = generic_delete_inode,
 142         .delete_inode   = proc_delete_inode,
 143         .statfs         = simple_statfs,
 144         .remount_fs     = proc_remount,
 145 };
 146
 147 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
 148                                 struct proc_dir_entry *de)
 149 {
 150         struct inode * inode;
 151
 152         /*
 153          * Increment the use count so the dir entry can't disappear.
 154          */
 155         de_get(de);
 156
 157         WARN_ON(de && de->deleted);
 158
 159         if (de != NULL && !try_module_get(de->owner))
 160                 goto out_mod;
 161
 162         inode = iget(sb, ino);
 163         if (!inode)
 164                 goto out_ino;
 165
 166         PROC_I(inode)->pde = de;
 167         if (de) {
 168                 if (de->mode) {
 169                         inode->i_mode = de->mode;
 170                         inode->i_uid = de->uid;
 171                         inode->i_gid = de->gid;
 172                 }
 173                 if (de->size)
 174                         inode->i_size = de->size;
 175                 if (de->nlink)
 176                         inode->i_nlink = de->nlink;
 177                 if (de->proc_iops)
 178                         inode->i_op = de->proc_iops;
 179                 if (de->proc_fops)
 180                         inode->i_fop = de->proc_fops;
 181         }
 182
 183         return inode;
 184
 185 out_ino:
 186         if (de != NULL)
 187                 module_put(de->owner);
 188 out_mod:
 189         de_put(de);
 190         return NULL;
 191 }
 192
 193 int proc_fill_super(struct super_block *s, void *data, int silent)
 194 {
 195         struct inode * root_inode;
 196
 197         s->s_flags |= MS_NODIRATIME;
 198         s->s_blocksize = 1024;
 199         s->s_blocksize_bits = 10;
 200         s->s_magic = PROC_SUPER_MAGIC;
 201         s->s_op = &proc_sops;
 202         s->s_time_gran = 1;
 203
 204         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
 205         if (!root_inode)
 206                 goto out_no_root;
 207         /*
 208          * Fixup the root inode's nlink value
 209          */
 210         root_inode->i_nlink += nr_processes();
 211         root_inode->i_uid = 0;
 212         root_inode->i_gid = 0;
 213         s->s_root = d_alloc_root(root_inode);
 214         if (!s->s_root)
 215                 goto out_no_root;
 216         return 0;
 217
 218 out_no_root:
 219         printk("proc_read_super: get root inode failed\n");
 220         iput(root_inode);
 221         return -ENOMEM;
 222 }
 223 MODULE_LICENSE("GPL");