switch alloc_file() to passing struct path
[linux-2.6.git] / fs / file_table.c
1 /*
2  *  linux/fs/file_table.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
6  */
7
8 #include <linux/string.h>
9 #include <linux/slab.h>
10 #include <linux/file.h>
11 #include <linux/fdtable.h>
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/fs.h>
15 #include <linux/security.h>
16 #include <linux/eventpoll.h>
17 #include <linux/rcupdate.h>
18 #include <linux/mount.h>
19 #include <linux/capability.h>
20 #include <linux/cdev.h>
21 #include <linux/fsnotify.h>
22 #include <linux/sysctl.h>
23 #include <linux/percpu_counter.h>
24
25 #include <asm/atomic.h>
26
27 /* sysctl tunables... */
28 struct files_stat_struct files_stat = {
29         .max_files = NR_FILE
30 };
31
32 /* public. Not pretty! */
33 __cacheline_aligned_in_smp DEFINE_SPINLOCK(files_lock);
34
35 /* SLAB cache for file structures */
36 static struct kmem_cache *filp_cachep __read_mostly;
37
38 static struct percpu_counter nr_files __cacheline_aligned_in_smp;
39
40 static inline void file_free_rcu(struct rcu_head *head)
41 {
42         struct file *f = container_of(head, struct file, f_u.fu_rcuhead);
43
44         put_cred(f->f_cred);
45         kmem_cache_free(filp_cachep, f);
46 }
47
48 static inline void file_free(struct file *f)
49 {
50         percpu_counter_dec(&nr_files);
51         file_check_state(f);
52         call_rcu(&f->f_u.fu_rcuhead, file_free_rcu);
53 }
54
55 /*
56  * Return the total number of open files in the system
57  */
58 static int get_nr_files(void)
59 {
60         return percpu_counter_read_positive(&nr_files);
61 }
62
63 /*
64  * Return the maximum number of open files in the system
65  */
66 int get_max_files(void)
67 {
68         return files_stat.max_files;
69 }
70 EXPORT_SYMBOL_GPL(get_max_files);
71
72 /*
73  * Handle nr_files sysctl
74  */
75 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
76 int proc_nr_files(ctl_table *table, int write,
77                      void __user *buffer, size_t *lenp, loff_t *ppos)
78 {
79         files_stat.nr_files = get_nr_files();
80         return proc_dointvec(table, write, buffer, lenp, ppos);
81 }
82 #else
83 int proc_nr_files(ctl_table *table, int write,
84                      void __user *buffer, size_t *lenp, loff_t *ppos)
85 {
86         return -ENOSYS;
87 }
88 #endif
89
90 /* Find an unused file structure and return a pointer to it.
91  * Returns NULL, if there are no more free file structures or
92  * we run out of memory.
93  *
94  * Be very careful using this.  You are responsible for
95  * getting write access to any mount that you might assign
96  * to this filp, if it is opened for write.  If this is not
97  * done, you will imbalance int the mount's writer count
98  * and a warning at __fput() time.
99  */
100 struct file *get_empty_filp(void)
101 {
102         const struct cred *cred = current_cred();
103         static int old_max;
104         struct file * f;
105
106         /*
107          * Privileged users can go above max_files
108          */
109         if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
110                 /*
111                  * percpu_counters are inaccurate.  Do an expensive check before
112                  * we go and fail.
113                  */
114                 if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
115                         goto over;
116         }
117
118         f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
119         if (f == NULL)
120                 goto fail;
121
122         percpu_counter_inc(&nr_files);
123         if (security_file_alloc(f))
124                 goto fail_sec;
125
126         INIT_LIST_HEAD(&f->f_u.fu_list);
127         atomic_long_set(&f->f_count, 1);
128         rwlock_init(&f->f_owner.lock);
129         f->f_cred = get_cred(cred);
130         spin_lock_init(&f->f_lock);
131         eventpoll_init_file(f);
132         /* f->f_version: 0 */
133         return f;
134
135 over:
136         /* Ran out of filps - report that */
137         if (get_nr_files() > old_max) {
138                 printk(KERN_INFO "VFS: file-max limit %d reached\n",
139                                         get_max_files());
140                 old_max = get_nr_files();
141         }
142         goto fail;
143
144 fail_sec:
145         file_free(f);
146 fail:
147         return NULL;
148 }
149
150 /**
151  * alloc_file - allocate and initialize a 'struct file'
152  * @mnt: the vfsmount on which the file will reside
153  * @dentry: the dentry representing the new file
154  * @mode: the mode with which the new file will be opened
155  * @fop: the 'struct file_operations' for the new file
156  *
157  * Use this instead of get_empty_filp() to get a new
158  * 'struct file'.  Do so because of the same initialization
159  * pitfalls reasons listed for init_file().  This is a
160  * preferred interface to using init_file().
161  *
162  * If all the callers of init_file() are eliminated, its
163  * code should be moved into this function.
164  */
165 struct file *alloc_file(struct path *path, fmode_t mode,
166                 const struct file_operations *fop)
167 {
168         struct file *file;
169
170         file = get_empty_filp();
171         if (!file)
172                 return NULL;
173
174         file->f_path = *path;
175         file->f_mapping = path->dentry->d_inode->i_mapping;
176         file->f_mode = mode;
177         file->f_op = fop;
178
179         /*
180          * These mounts don't really matter in practice
181          * for r/o bind mounts.  They aren't userspace-
182          * visible.  We do this for consistency, and so
183          * that we can do debugging checks at __fput()
184          */
185         if ((mode & FMODE_WRITE) && !special_file(path->dentry->d_inode->i_mode)) {
186                 int error = 0;
187                 file_take_write(file);
188                 error = mnt_clone_write(path->mnt);
189                 WARN_ON(error);
190         }
191         return file;
192 }
193
194 void fput(struct file *file)
195 {
196         if (atomic_long_dec_and_test(&file->f_count))
197                 __fput(file);
198 }
199
200 EXPORT_SYMBOL(fput);
201
202 /**
203  * drop_file_write_access - give up ability to write to a file
204  * @file: the file to which we will stop writing
205  *
206  * This is a central place which will give up the ability
207  * to write to @file, along with access to write through
208  * its vfsmount.
209  */
210 void drop_file_write_access(struct file *file)
211 {
212         struct vfsmount *mnt = file->f_path.mnt;
213         struct dentry *dentry = file->f_path.dentry;
214         struct inode *inode = dentry->d_inode;
215
216         put_write_access(inode);
217
218         if (special_file(inode->i_mode))
219                 return;
220         if (file_check_writeable(file) != 0)
221                 return;
222         mnt_drop_write(mnt);
223         file_release_write(file);
224 }
225 EXPORT_SYMBOL_GPL(drop_file_write_access);
226
227 /* __fput is called from task context when aio completion releases the last
228  * last use of a struct file *.  Do not use otherwise.
229  */
230 void __fput(struct file *file)
231 {
232         struct dentry *dentry = file->f_path.dentry;
233         struct vfsmount *mnt = file->f_path.mnt;
234         struct inode *inode = dentry->d_inode;
235
236         might_sleep();
237
238         fsnotify_close(file);
239         /*
240          * The function eventpoll_release() should be the first called
241          * in the file cleanup chain.
242          */
243         eventpoll_release(file);
244         locks_remove_flock(file);
245
246         if (unlikely(file->f_flags & FASYNC)) {
247                 if (file->f_op && file->f_op->fasync)
248                         file->f_op->fasync(-1, file, 0);
249         }
250         if (file->f_op && file->f_op->release)
251                 file->f_op->release(inode, file);
252         security_file_free(file);
253         if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL))
254                 cdev_put(inode->i_cdev);
255         fops_put(file->f_op);
256         put_pid(file->f_owner.pid);
257         file_kill(file);
258         if (file->f_mode & FMODE_WRITE)
259                 drop_file_write_access(file);
260         file->f_path.dentry = NULL;
261         file->f_path.mnt = NULL;
262         file_free(file);
263         dput(dentry);
264         mntput(mnt);
265 }
266
267 struct file *fget(unsigned int fd)
268 {
269         struct file *file;
270         struct files_struct *files = current->files;
271
272         rcu_read_lock();
273         file = fcheck_files(files, fd);
274         if (file) {
275                 if (!atomic_long_inc_not_zero(&file->f_count)) {
276                         /* File object ref couldn't be taken */
277                         rcu_read_unlock();
278                         return NULL;
279                 }
280         }
281         rcu_read_unlock();
282
283         return file;
284 }
285
286 EXPORT_SYMBOL(fget);
287
288 /*
289  * Lightweight file lookup - no refcnt increment if fd table isn't shared. 
290  * You can use this only if it is guranteed that the current task already 
291  * holds a refcnt to that file. That check has to be done at fget() only
292  * and a flag is returned to be passed to the corresponding fput_light().
293  * There must not be a cloning between an fget_light/fput_light pair.
294  */
295 struct file *fget_light(unsigned int fd, int *fput_needed)
296 {
297         struct file *file;
298         struct files_struct *files = current->files;
299
300         *fput_needed = 0;
301         if (likely((atomic_read(&files->count) == 1))) {
302                 file = fcheck_files(files, fd);
303         } else {
304                 rcu_read_lock();
305                 file = fcheck_files(files, fd);
306                 if (file) {
307                         if (atomic_long_inc_not_zero(&file->f_count))
308                                 *fput_needed = 1;
309                         else
310                                 /* Didn't get the reference, someone's freed */
311                                 file = NULL;
312                 }
313                 rcu_read_unlock();
314         }
315
316         return file;
317 }
318
319
320 void put_filp(struct file *file)
321 {
322         if (atomic_long_dec_and_test(&file->f_count)) {
323                 security_file_free(file);
324                 file_kill(file);
325                 file_free(file);
326         }
327 }
328
329 void file_move(struct file *file, struct list_head *list)
330 {
331         if (!list)
332                 return;
333         file_list_lock();
334         list_move(&file->f_u.fu_list, list);
335         file_list_unlock();
336 }
337
338 void file_kill(struct file *file)
339 {
340         if (!list_empty(&file->f_u.fu_list)) {
341                 file_list_lock();
342                 list_del_init(&file->f_u.fu_list);
343                 file_list_unlock();
344         }
345 }
346
347 int fs_may_remount_ro(struct super_block *sb)
348 {
349         struct file *file;
350
351         /* Check that no files are currently opened for writing. */
352         file_list_lock();
353         list_for_each_entry(file, &sb->s_files, f_u.fu_list) {
354                 struct inode *inode = file->f_path.dentry->d_inode;
355
356                 /* File with pending delete? */
357                 if (inode->i_nlink == 0)
358                         goto too_bad;
359
360                 /* Writeable file? */
361                 if (S_ISREG(inode->i_mode) && (file->f_mode & FMODE_WRITE))
362                         goto too_bad;
363         }
364         file_list_unlock();
365         return 1; /* Tis' cool bro. */
366 too_bad:
367         file_list_unlock();
368         return 0;
369 }
370
371 /**
372  *      mark_files_ro - mark all files read-only
373  *      @sb: superblock in question
374  *
375  *      All files are marked read-only.  We don't care about pending
376  *      delete files so this should be used in 'force' mode only.
377  */
378 void mark_files_ro(struct super_block *sb)
379 {
380         struct file *f;
381
382 retry:
383         file_list_lock();
384         list_for_each_entry(f, &sb->s_files, f_u.fu_list) {
385                 struct vfsmount *mnt;
386                 if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
387                        continue;
388                 if (!file_count(f))
389                         continue;
390                 if (!(f->f_mode & FMODE_WRITE))
391                         continue;
392                 f->f_mode &= ~FMODE_WRITE;
393                 if (file_check_writeable(f) != 0)
394                         continue;
395                 file_release_write(f);
396                 mnt = mntget(f->f_path.mnt);
397                 file_list_unlock();
398                 /*
399                  * This can sleep, so we can't hold
400                  * the file_list_lock() spinlock.
401                  */
402                 mnt_drop_write(mnt);
403                 mntput(mnt);
404                 goto retry;
405         }
406         file_list_unlock();
407 }
408
409 void __init files_init(unsigned long mempages)
410
411         int n; 
412
413         filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
414                         SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
415
416         /*
417          * One file with associated inode and dcache is very roughly 1K.
418          * Per default don't use more than 10% of our memory for files. 
419          */ 
420
421         n = (mempages * (PAGE_SIZE / 1024)) / 10;
422         files_stat.max_files = n; 
423         if (files_stat.max_files < NR_FILE)
424                 files_stat.max_files = NR_FILE;
425         files_defer_init();
426         percpu_counter_init(&nr_files, 0);
427