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