Loading...
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#include <linux/percpu.h>
25#include <linux/hardirq.h>
26#include <linux/task_work.h>
27#include <linux/ima.h>
28#include <linux/swap.h>
29
30#include <linux/atomic.h>
31
32#include "internal.h"
33
34/* sysctl tunables... */
35struct files_stat_struct files_stat = {
36 .max_files = NR_FILE
37};
38
39/* SLAB cache for file structures */
40static struct kmem_cache *filp_cachep __read_mostly;
41
42static struct percpu_counter nr_files __cacheline_aligned_in_smp;
43
44static void file_free_rcu(struct rcu_head *head)
45{
46 struct file *f = container_of(head, struct file, f_u.fu_rcuhead);
47
48 put_cred(f->f_cred);
49 kmem_cache_free(filp_cachep, f);
50}
51
52static inline void file_free(struct file *f)
53{
54 percpu_counter_dec(&nr_files);
55 call_rcu(&f->f_u.fu_rcuhead, file_free_rcu);
56}
57
58/*
59 * Return the total number of open files in the system
60 */
61static long get_nr_files(void)
62{
63 return percpu_counter_read_positive(&nr_files);
64}
65
66/*
67 * Return the maximum number of open files in the system
68 */
69unsigned long get_max_files(void)
70{
71 return files_stat.max_files;
72}
73EXPORT_SYMBOL_GPL(get_max_files);
74
75/*
76 * Handle nr_files sysctl
77 */
78#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
79int proc_nr_files(struct ctl_table *table, int write,
80 void __user *buffer, size_t *lenp, loff_t *ppos)
81{
82 files_stat.nr_files = get_nr_files();
83 return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
84}
85#else
86int proc_nr_files(struct ctl_table *table, int write,
87 void __user *buffer, size_t *lenp, loff_t *ppos)
88{
89 return -ENOSYS;
90}
91#endif
92
93/* Find an unused file structure and return a pointer to it.
94 * Returns an error pointer if some error happend e.g. we over file
95 * structures limit, run out of memory or operation is not permitted.
96 *
97 * Be very careful using this. You are responsible for
98 * getting write access to any mount that you might assign
99 * to this filp, if it is opened for write. If this is not
100 * done, you will imbalance int the mount's writer count
101 * and a warning at __fput() time.
102 */
103struct file *get_empty_filp(void)
104{
105 const struct cred *cred = current_cred();
106 static long old_max;
107 struct file *f;
108 int error;
109
110 /*
111 * Privileged users can go above max_files
112 */
113 if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
114 /*
115 * percpu_counters are inaccurate. Do an expensive check before
116 * we go and fail.
117 */
118 if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
119 goto over;
120 }
121
122 f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
123 if (unlikely(!f))
124 return ERR_PTR(-ENOMEM);
125
126 percpu_counter_inc(&nr_files);
127 f->f_cred = get_cred(cred);
128 error = security_file_alloc(f);
129 if (unlikely(error)) {
130 file_free(f);
131 return ERR_PTR(error);
132 }
133
134 atomic_long_set(&f->f_count, 1);
135 rwlock_init(&f->f_owner.lock);
136 spin_lock_init(&f->f_lock);
137 mutex_init(&f->f_pos_lock);
138 eventpoll_init_file(f);
139 /* f->f_version: 0 */
140 return f;
141
142over:
143 /* Ran out of filps - report that */
144 if (get_nr_files() > old_max) {
145 pr_info("VFS: file-max limit %lu reached\n", get_max_files());
146 old_max = get_nr_files();
147 }
148 return ERR_PTR(-ENFILE);
149}
150
151/**
152 * alloc_file - allocate and initialize a 'struct file'
153 *
154 * @path: the (dentry, vfsmount) pair for the new file
155 * @mode: the mode with which the new file will be opened
156 * @fop: the 'struct file_operations' for the new file
157 */
158struct file *alloc_file(const struct path *path, fmode_t mode,
159 const struct file_operations *fop)
160{
161 struct file *file;
162
163 file = get_empty_filp();
164 if (IS_ERR(file))
165 return file;
166
167 file->f_path = *path;
168 file->f_inode = path->dentry->d_inode;
169 file->f_mapping = path->dentry->d_inode->i_mapping;
170 if ((mode & FMODE_READ) &&
171 likely(fop->read || fop->read_iter))
172 mode |= FMODE_CAN_READ;
173 if ((mode & FMODE_WRITE) &&
174 likely(fop->write || fop->write_iter))
175 mode |= FMODE_CAN_WRITE;
176 file->f_mode = mode;
177 file->f_op = fop;
178 if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
179 i_readcount_inc(path->dentry->d_inode);
180 return file;
181}
182EXPORT_SYMBOL(alloc_file);
183
184/* the real guts of fput() - releasing the last reference to file
185 */
186static void __fput(struct file *file)
187{
188 struct dentry *dentry = file->f_path.dentry;
189 struct vfsmount *mnt = file->f_path.mnt;
190 struct inode *inode = file->f_inode;
191
192 might_sleep();
193
194 fsnotify_close(file);
195 /*
196 * The function eventpoll_release() should be the first called
197 * in the file cleanup chain.
198 */
199 eventpoll_release(file);
200 locks_remove_file(file);
201
202 if (unlikely(file->f_flags & FASYNC)) {
203 if (file->f_op->fasync)
204 file->f_op->fasync(-1, file, 0);
205 }
206 ima_file_free(file);
207 if (file->f_op->release)
208 file->f_op->release(inode, file);
209 security_file_free(file);
210 if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL &&
211 !(file->f_mode & FMODE_PATH))) {
212 cdev_put(inode->i_cdev);
213 }
214 fops_put(file->f_op);
215 put_pid(file->f_owner.pid);
216 if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
217 i_readcount_dec(inode);
218 if (file->f_mode & FMODE_WRITER) {
219 put_write_access(inode);
220 __mnt_drop_write(mnt);
221 }
222 file->f_path.dentry = NULL;
223 file->f_path.mnt = NULL;
224 file->f_inode = NULL;
225 file_free(file);
226 dput(dentry);
227 mntput(mnt);
228}
229
230static LLIST_HEAD(delayed_fput_list);
231static void delayed_fput(struct work_struct *unused)
232{
233 struct llist_node *node = llist_del_all(&delayed_fput_list);
234 struct llist_node *next;
235
236 for (; node; node = next) {
237 next = llist_next(node);
238 __fput(llist_entry(node, struct file, f_u.fu_llist));
239 }
240}
241
242static void ____fput(struct callback_head *work)
243{
244 __fput(container_of(work, struct file, f_u.fu_rcuhead));
245}
246
247/*
248 * If kernel thread really needs to have the final fput() it has done
249 * to complete, call this. The only user right now is the boot - we
250 * *do* need to make sure our writes to binaries on initramfs has
251 * not left us with opened struct file waiting for __fput() - execve()
252 * won't work without that. Please, don't add more callers without
253 * very good reasons; in particular, never call that with locks
254 * held and never call that from a thread that might need to do
255 * some work on any kind of umount.
256 */
257void flush_delayed_fput(void)
258{
259 delayed_fput(NULL);
260}
261
262static DECLARE_DELAYED_WORK(delayed_fput_work, delayed_fput);
263
264void fput(struct file *file)
265{
266 if (atomic_long_dec_and_test(&file->f_count)) {
267 struct task_struct *task = current;
268
269 if (likely(!in_interrupt() && !(task->flags & PF_KTHREAD))) {
270 init_task_work(&file->f_u.fu_rcuhead, ____fput);
271 if (!task_work_add(task, &file->f_u.fu_rcuhead, true))
272 return;
273 /*
274 * After this task has run exit_task_work(),
275 * task_work_add() will fail. Fall through to delayed
276 * fput to avoid leaking *file.
277 */
278 }
279
280 if (llist_add(&file->f_u.fu_llist, &delayed_fput_list))
281 schedule_delayed_work(&delayed_fput_work, 1);
282 }
283}
284
285/*
286 * synchronous analog of fput(); for kernel threads that might be needed
287 * in some umount() (and thus can't use flush_delayed_fput() without
288 * risking deadlocks), need to wait for completion of __fput() and know
289 * for this specific struct file it won't involve anything that would
290 * need them. Use only if you really need it - at the very least,
291 * don't blindly convert fput() by kernel thread to that.
292 */
293void __fput_sync(struct file *file)
294{
295 if (atomic_long_dec_and_test(&file->f_count)) {
296 struct task_struct *task = current;
297 BUG_ON(!(task->flags & PF_KTHREAD));
298 __fput(file);
299 }
300}
301
302EXPORT_SYMBOL(fput);
303
304void put_filp(struct file *file)
305{
306 if (atomic_long_dec_and_test(&file->f_count)) {
307 security_file_free(file);
308 file_free(file);
309 }
310}
311
312void __init files_init(void)
313{
314 filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
315 SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
316 percpu_counter_init(&nr_files, 0, GFP_KERNEL);
317}
318
319/*
320 * One file with associated inode and dcache is very roughly 1K. Per default
321 * do not use more than 10% of our memory for files.
322 */
323void __init files_maxfiles_init(void)
324{
325 unsigned long n;
326 unsigned long memreserve = (totalram_pages - nr_free_pages()) * 3/2;
327
328 memreserve = min(memreserve, totalram_pages - 1);
329 n = ((totalram_pages - memreserve) * (PAGE_SIZE / 1024)) / 10;
330
331 files_stat.max_files = max_t(unsigned long, n, NR_FILE);
332}
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/lglock.h>
24#include <linux/percpu_counter.h>
25#include <linux/percpu.h>
26#include <linux/ima.h>
27
28#include <linux/atomic.h>
29
30#include "internal.h"
31
32/* sysctl tunables... */
33struct files_stat_struct files_stat = {
34 .max_files = NR_FILE
35};
36
37DEFINE_LGLOCK(files_lglock);
38
39/* SLAB cache for file structures */
40static struct kmem_cache *filp_cachep __read_mostly;
41
42static struct percpu_counter nr_files __cacheline_aligned_in_smp;
43
44static inline void file_free_rcu(struct rcu_head *head)
45{
46 struct file *f = container_of(head, struct file, f_u.fu_rcuhead);
47
48 put_cred(f->f_cred);
49 kmem_cache_free(filp_cachep, f);
50}
51
52static inline void file_free(struct file *f)
53{
54 percpu_counter_dec(&nr_files);
55 file_check_state(f);
56 call_rcu(&f->f_u.fu_rcuhead, file_free_rcu);
57}
58
59/*
60 * Return the total number of open files in the system
61 */
62static long get_nr_files(void)
63{
64 return percpu_counter_read_positive(&nr_files);
65}
66
67/*
68 * Return the maximum number of open files in the system
69 */
70unsigned long get_max_files(void)
71{
72 return files_stat.max_files;
73}
74EXPORT_SYMBOL_GPL(get_max_files);
75
76/*
77 * Handle nr_files sysctl
78 */
79#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
80int proc_nr_files(ctl_table *table, int write,
81 void __user *buffer, size_t *lenp, loff_t *ppos)
82{
83 files_stat.nr_files = get_nr_files();
84 return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
85}
86#else
87int proc_nr_files(ctl_table *table, int write,
88 void __user *buffer, size_t *lenp, loff_t *ppos)
89{
90 return -ENOSYS;
91}
92#endif
93
94/* Find an unused file structure and return a pointer to it.
95 * Returns NULL, if there are no more free file structures or
96 * we run out of memory.
97 *
98 * Be very careful using this. You are responsible for
99 * getting write access to any mount that you might assign
100 * to this filp, if it is opened for write. If this is not
101 * done, you will imbalance int the mount's writer count
102 * and a warning at __fput() time.
103 */
104struct file *get_empty_filp(void)
105{
106 const struct cred *cred = current_cred();
107 static long old_max;
108 struct file * f;
109
110 /*
111 * Privileged users can go above max_files
112 */
113 if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
114 /*
115 * percpu_counters are inaccurate. Do an expensive check before
116 * we go and fail.
117 */
118 if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
119 goto over;
120 }
121
122 f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
123 if (f == NULL)
124 goto fail;
125
126 percpu_counter_inc(&nr_files);
127 f->f_cred = get_cred(cred);
128 if (security_file_alloc(f))
129 goto fail_sec;
130
131 INIT_LIST_HEAD(&f->f_u.fu_list);
132 atomic_long_set(&f->f_count, 1);
133 rwlock_init(&f->f_owner.lock);
134 spin_lock_init(&f->f_lock);
135 eventpoll_init_file(f);
136 /* f->f_version: 0 */
137 return f;
138
139over:
140 /* Ran out of filps - report that */
141 if (get_nr_files() > old_max) {
142 pr_info("VFS: file-max limit %lu reached\n", get_max_files());
143 old_max = get_nr_files();
144 }
145 goto fail;
146
147fail_sec:
148 file_free(f);
149fail:
150 return NULL;
151}
152
153/**
154 * alloc_file - allocate and initialize a 'struct file'
155 * @mnt: the vfsmount on which the file will reside
156 * @dentry: the dentry representing the new file
157 * @mode: the mode with which the new file will be opened
158 * @fop: the 'struct file_operations' for the new file
159 *
160 * Use this instead of get_empty_filp() to get a new
161 * 'struct file'. Do so because of the same initialization
162 * pitfalls reasons listed for init_file(). This is a
163 * preferred interface to using init_file().
164 *
165 * If all the callers of init_file() are eliminated, its
166 * code should be moved into this function.
167 */
168struct file *alloc_file(struct path *path, fmode_t mode,
169 const struct file_operations *fop)
170{
171 struct file *file;
172
173 file = get_empty_filp();
174 if (!file)
175 return NULL;
176
177 file->f_path = *path;
178 file->f_mapping = path->dentry->d_inode->i_mapping;
179 file->f_mode = mode;
180 file->f_op = fop;
181
182 /*
183 * These mounts don't really matter in practice
184 * for r/o bind mounts. They aren't userspace-
185 * visible. We do this for consistency, and so
186 * that we can do debugging checks at __fput()
187 */
188 if ((mode & FMODE_WRITE) && !special_file(path->dentry->d_inode->i_mode)) {
189 file_take_write(file);
190 WARN_ON(mnt_clone_write(path->mnt));
191 }
192 if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
193 i_readcount_inc(path->dentry->d_inode);
194 return file;
195}
196EXPORT_SYMBOL(alloc_file);
197
198/**
199 * drop_file_write_access - give up ability to write to a file
200 * @file: the file to which we will stop writing
201 *
202 * This is a central place which will give up the ability
203 * to write to @file, along with access to write through
204 * its vfsmount.
205 */
206static void drop_file_write_access(struct file *file)
207{
208 struct vfsmount *mnt = file->f_path.mnt;
209 struct dentry *dentry = file->f_path.dentry;
210 struct inode *inode = dentry->d_inode;
211
212 put_write_access(inode);
213
214 if (special_file(inode->i_mode))
215 return;
216 if (file_check_writeable(file) != 0)
217 return;
218 mnt_drop_write(mnt);
219 file_release_write(file);
220}
221
222/* the real guts of fput() - releasing the last reference to file
223 */
224static void __fput(struct file *file)
225{
226 struct dentry *dentry = file->f_path.dentry;
227 struct vfsmount *mnt = file->f_path.mnt;
228 struct inode *inode = dentry->d_inode;
229
230 might_sleep();
231
232 fsnotify_close(file);
233 /*
234 * The function eventpoll_release() should be the first called
235 * in the file cleanup chain.
236 */
237 eventpoll_release(file);
238 locks_remove_flock(file);
239
240 if (unlikely(file->f_flags & FASYNC)) {
241 if (file->f_op && file->f_op->fasync)
242 file->f_op->fasync(-1, file, 0);
243 }
244 if (file->f_op && file->f_op->release)
245 file->f_op->release(inode, file);
246 security_file_free(file);
247 ima_file_free(file);
248 if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL &&
249 !(file->f_mode & FMODE_PATH))) {
250 cdev_put(inode->i_cdev);
251 }
252 fops_put(file->f_op);
253 put_pid(file->f_owner.pid);
254 file_sb_list_del(file);
255 if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
256 i_readcount_dec(inode);
257 if (file->f_mode & FMODE_WRITE)
258 drop_file_write_access(file);
259 file->f_path.dentry = NULL;
260 file->f_path.mnt = NULL;
261 file_free(file);
262 dput(dentry);
263 mntput(mnt);
264}
265
266void fput(struct file *file)
267{
268 if (atomic_long_dec_and_test(&file->f_count))
269 __fput(file);
270}
271
272EXPORT_SYMBOL(fput);
273
274struct file *fget(unsigned int fd)
275{
276 struct file *file;
277 struct files_struct *files = current->files;
278
279 rcu_read_lock();
280 file = fcheck_files(files, fd);
281 if (file) {
282 /* File object ref couldn't be taken */
283 if (file->f_mode & FMODE_PATH ||
284 !atomic_long_inc_not_zero(&file->f_count))
285 file = NULL;
286 }
287 rcu_read_unlock();
288
289 return file;
290}
291
292EXPORT_SYMBOL(fget);
293
294struct file *fget_raw(unsigned int fd)
295{
296 struct file *file;
297 struct files_struct *files = current->files;
298
299 rcu_read_lock();
300 file = fcheck_files(files, fd);
301 if (file) {
302 /* File object ref couldn't be taken */
303 if (!atomic_long_inc_not_zero(&file->f_count))
304 file = NULL;
305 }
306 rcu_read_unlock();
307
308 return file;
309}
310
311EXPORT_SYMBOL(fget_raw);
312
313/*
314 * Lightweight file lookup - no refcnt increment if fd table isn't shared.
315 *
316 * You can use this instead of fget if you satisfy all of the following
317 * conditions:
318 * 1) You must call fput_light before exiting the syscall and returning control
319 * to userspace (i.e. you cannot remember the returned struct file * after
320 * returning to userspace).
321 * 2) You must not call filp_close on the returned struct file * in between
322 * calls to fget_light and fput_light.
323 * 3) You must not clone the current task in between the calls to fget_light
324 * and fput_light.
325 *
326 * The fput_needed flag returned by fget_light should be passed to the
327 * corresponding fput_light.
328 */
329struct file *fget_light(unsigned int fd, int *fput_needed)
330{
331 struct file *file;
332 struct files_struct *files = current->files;
333
334 *fput_needed = 0;
335 if (atomic_read(&files->count) == 1) {
336 file = fcheck_files(files, fd);
337 if (file && (file->f_mode & FMODE_PATH))
338 file = NULL;
339 } else {
340 rcu_read_lock();
341 file = fcheck_files(files, fd);
342 if (file) {
343 if (!(file->f_mode & FMODE_PATH) &&
344 atomic_long_inc_not_zero(&file->f_count))
345 *fput_needed = 1;
346 else
347 /* Didn't get the reference, someone's freed */
348 file = NULL;
349 }
350 rcu_read_unlock();
351 }
352
353 return file;
354}
355
356struct file *fget_raw_light(unsigned int fd, int *fput_needed)
357{
358 struct file *file;
359 struct files_struct *files = current->files;
360
361 *fput_needed = 0;
362 if (atomic_read(&files->count) == 1) {
363 file = fcheck_files(files, fd);
364 } else {
365 rcu_read_lock();
366 file = fcheck_files(files, fd);
367 if (file) {
368 if (atomic_long_inc_not_zero(&file->f_count))
369 *fput_needed = 1;
370 else
371 /* Didn't get the reference, someone's freed */
372 file = NULL;
373 }
374 rcu_read_unlock();
375 }
376
377 return file;
378}
379
380void put_filp(struct file *file)
381{
382 if (atomic_long_dec_and_test(&file->f_count)) {
383 security_file_free(file);
384 file_sb_list_del(file);
385 file_free(file);
386 }
387}
388
389static inline int file_list_cpu(struct file *file)
390{
391#ifdef CONFIG_SMP
392 return file->f_sb_list_cpu;
393#else
394 return smp_processor_id();
395#endif
396}
397
398/* helper for file_sb_list_add to reduce ifdefs */
399static inline void __file_sb_list_add(struct file *file, struct super_block *sb)
400{
401 struct list_head *list;
402#ifdef CONFIG_SMP
403 int cpu;
404 cpu = smp_processor_id();
405 file->f_sb_list_cpu = cpu;
406 list = per_cpu_ptr(sb->s_files, cpu);
407#else
408 list = &sb->s_files;
409#endif
410 list_add(&file->f_u.fu_list, list);
411}
412
413/**
414 * file_sb_list_add - add a file to the sb's file list
415 * @file: file to add
416 * @sb: sb to add it to
417 *
418 * Use this function to associate a file with the superblock of the inode it
419 * refers to.
420 */
421void file_sb_list_add(struct file *file, struct super_block *sb)
422{
423 lg_local_lock(&files_lglock);
424 __file_sb_list_add(file, sb);
425 lg_local_unlock(&files_lglock);
426}
427
428/**
429 * file_sb_list_del - remove a file from the sb's file list
430 * @file: file to remove
431 * @sb: sb to remove it from
432 *
433 * Use this function to remove a file from its superblock.
434 */
435void file_sb_list_del(struct file *file)
436{
437 if (!list_empty(&file->f_u.fu_list)) {
438 lg_local_lock_cpu(&files_lglock, file_list_cpu(file));
439 list_del_init(&file->f_u.fu_list);
440 lg_local_unlock_cpu(&files_lglock, file_list_cpu(file));
441 }
442}
443
444#ifdef CONFIG_SMP
445
446/*
447 * These macros iterate all files on all CPUs for a given superblock.
448 * files_lglock must be held globally.
449 */
450#define do_file_list_for_each_entry(__sb, __file) \
451{ \
452 int i; \
453 for_each_possible_cpu(i) { \
454 struct list_head *list; \
455 list = per_cpu_ptr((__sb)->s_files, i); \
456 list_for_each_entry((__file), list, f_u.fu_list)
457
458#define while_file_list_for_each_entry \
459 } \
460}
461
462#else
463
464#define do_file_list_for_each_entry(__sb, __file) \
465{ \
466 struct list_head *list; \
467 list = &(sb)->s_files; \
468 list_for_each_entry((__file), list, f_u.fu_list)
469
470#define while_file_list_for_each_entry \
471}
472
473#endif
474
475/**
476 * mark_files_ro - mark all files read-only
477 * @sb: superblock in question
478 *
479 * All files are marked read-only. We don't care about pending
480 * delete files so this should be used in 'force' mode only.
481 */
482void mark_files_ro(struct super_block *sb)
483{
484 struct file *f;
485
486retry:
487 lg_global_lock(&files_lglock);
488 do_file_list_for_each_entry(sb, f) {
489 struct vfsmount *mnt;
490 if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
491 continue;
492 if (!file_count(f))
493 continue;
494 if (!(f->f_mode & FMODE_WRITE))
495 continue;
496 spin_lock(&f->f_lock);
497 f->f_mode &= ~FMODE_WRITE;
498 spin_unlock(&f->f_lock);
499 if (file_check_writeable(f) != 0)
500 continue;
501 file_release_write(f);
502 mnt = mntget(f->f_path.mnt);
503 /* This can sleep, so we can't hold the spinlock. */
504 lg_global_unlock(&files_lglock);
505 mnt_drop_write(mnt);
506 mntput(mnt);
507 goto retry;
508 } while_file_list_for_each_entry;
509 lg_global_unlock(&files_lglock);
510}
511
512void __init files_init(unsigned long mempages)
513{
514 unsigned long n;
515
516 filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
517 SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
518
519 /*
520 * One file with associated inode and dcache is very roughly 1K.
521 * Per default don't use more than 10% of our memory for files.
522 */
523
524 n = (mempages * (PAGE_SIZE / 1024)) / 10;
525 files_stat.max_files = max_t(unsigned long, n, NR_FILE);
526 files_defer_init();
527 lg_lock_init(&files_lglock, "files_lglock");
528 percpu_counter_init(&nr_files, 0);
529}