2 * linux/fs/file_table.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
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>
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/hardirq.h>
27 #include <linux/task_work.h>
28 #include <linux/ima.h>
30 #include <linux/atomic.h>
34 /* sysctl tunables... */
35 struct files_stat_struct files_stat
= {
39 /* SLAB cache for file structures */
40 static struct kmem_cache
*filp_cachep __read_mostly
;
42 static struct percpu_counter nr_files __cacheline_aligned_in_smp
;
44 static void file_free_rcu(struct rcu_head
*head
)
46 struct file
*f
= container_of(head
, struct file
, f_u
.fu_rcuhead
);
49 kmem_cache_free(filp_cachep
, f
);
52 static inline void file_free(struct file
*f
)
54 percpu_counter_dec(&nr_files
);
55 call_rcu(&f
->f_u
.fu_rcuhead
, file_free_rcu
);
59 * Return the total number of open files in the system
61 static long get_nr_files(void)
63 return percpu_counter_read_positive(&nr_files
);
67 * Return the maximum number of open files in the system
69 unsigned long get_max_files(void)
71 return files_stat
.max_files
;
73 EXPORT_SYMBOL_GPL(get_max_files
);
76 * Handle nr_files sysctl
78 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
79 int proc_nr_files(ctl_table
*table
, int write
,
80 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
82 files_stat
.nr_files
= get_nr_files();
83 return proc_doulongvec_minmax(table
, write
, buffer
, lenp
, ppos
);
86 int proc_nr_files(ctl_table
*table
, int write
,
87 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
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.
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.
103 struct file
*get_empty_filp(void)
105 const struct cred
*cred
= current_cred();
111 * Privileged users can go above max_files
113 if (get_nr_files() >= files_stat
.max_files
&& !capable(CAP_SYS_ADMIN
)) {
115 * percpu_counters are inaccurate. Do an expensive check before
118 if (percpu_counter_sum_positive(&nr_files
) >= files_stat
.max_files
)
122 f
= kmem_cache_zalloc(filp_cachep
, GFP_KERNEL
);
124 return ERR_PTR(-ENOMEM
);
126 percpu_counter_inc(&nr_files
);
127 f
->f_cred
= get_cred(cred
);
128 error
= security_file_alloc(f
);
129 if (unlikely(error
)) {
131 return ERR_PTR(error
);
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 */
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();
148 return ERR_PTR(-ENFILE
);
152 * alloc_file - allocate and initialize a 'struct file'
153 * @mnt: the vfsmount on which the file will reside
154 * @dentry: the dentry representing 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
158 * Use this instead of get_empty_filp() to get a new
159 * 'struct file'. Do so because of the same initialization
160 * pitfalls reasons listed for init_file(). This is a
161 * preferred interface to using init_file().
163 * If all the callers of init_file() are eliminated, its
164 * code should be moved into this function.
166 struct file
*alloc_file(struct path
*path
, fmode_t mode
,
167 const struct file_operations
*fop
)
171 file
= get_empty_filp();
175 file
->f_path
= *path
;
176 file
->f_inode
= path
->dentry
->d_inode
;
177 file
->f_mapping
= path
->dentry
->d_inode
->i_mapping
;
182 * These mounts don't really matter in practice
183 * for r/o bind mounts. They aren't userspace-
184 * visible. We do this for consistency, and so
185 * that we can do debugging checks at __fput()
187 if ((mode
& FMODE_WRITE
) && !special_file(path
->dentry
->d_inode
->i_mode
)) {
188 WARN_ON(mnt_clone_write(path
->mnt
));
190 if ((mode
& (FMODE_READ
| FMODE_WRITE
)) == FMODE_READ
)
191 i_readcount_inc(path
->dentry
->d_inode
);
194 EXPORT_SYMBOL(alloc_file
);
197 * drop_file_write_access - give up ability to write to a file
198 * @file: the file to which we will stop writing
200 * This is a central place which will give up the ability
201 * to write to @file, along with access to write through
204 static void drop_file_write_access(struct file
*file
)
206 struct vfsmount
*mnt
= file
->f_path
.mnt
;
207 struct dentry
*dentry
= file
->f_path
.dentry
;
208 struct inode
*inode
= dentry
->d_inode
;
210 if (special_file(inode
->i_mode
))
213 put_write_access(inode
);
214 __mnt_drop_write(mnt
);
217 /* the real guts of fput() - releasing the last reference to file
219 static void __fput(struct file
*file
)
221 struct dentry
*dentry
= file
->f_path
.dentry
;
222 struct vfsmount
*mnt
= file
->f_path
.mnt
;
223 struct inode
*inode
= file
->f_inode
;
227 fsnotify_close(file
);
229 * The function eventpoll_release() should be the first called
230 * in the file cleanup chain.
232 eventpoll_release(file
);
233 locks_remove_flock(file
);
235 if (unlikely(file
->f_flags
& FASYNC
)) {
236 if (file
->f_op
->fasync
)
237 file
->f_op
->fasync(-1, file
, 0);
240 if (file
->f_op
->release
)
241 file
->f_op
->release(inode
, file
);
242 security_file_free(file
);
243 if (unlikely(S_ISCHR(inode
->i_mode
) && inode
->i_cdev
!= NULL
&&
244 !(file
->f_mode
& FMODE_PATH
))) {
245 cdev_put(inode
->i_cdev
);
247 fops_put(file
->f_op
);
248 put_pid(file
->f_owner
.pid
);
249 if ((file
->f_mode
& (FMODE_READ
| FMODE_WRITE
)) == FMODE_READ
)
250 i_readcount_dec(inode
);
251 if (file
->f_mode
& FMODE_WRITE
)
252 drop_file_write_access(file
);
253 file
->f_path
.dentry
= NULL
;
254 file
->f_path
.mnt
= NULL
;
255 file
->f_inode
= NULL
;
261 static LLIST_HEAD(delayed_fput_list
);
262 static void delayed_fput(struct work_struct
*unused
)
264 struct llist_node
*node
= llist_del_all(&delayed_fput_list
);
265 struct llist_node
*next
;
267 for (; node
; node
= next
) {
268 next
= llist_next(node
);
269 __fput(llist_entry(node
, struct file
, f_u
.fu_llist
));
273 static void ____fput(struct callback_head
*work
)
275 __fput(container_of(work
, struct file
, f_u
.fu_rcuhead
));
279 * If kernel thread really needs to have the final fput() it has done
280 * to complete, call this. The only user right now is the boot - we
281 * *do* need to make sure our writes to binaries on initramfs has
282 * not left us with opened struct file waiting for __fput() - execve()
283 * won't work without that. Please, don't add more callers without
284 * very good reasons; in particular, never call that with locks
285 * held and never call that from a thread that might need to do
286 * some work on any kind of umount.
288 void flush_delayed_fput(void)
293 static DECLARE_DELAYED_WORK(delayed_fput_work
, delayed_fput
);
295 void fput(struct file
*file
)
297 if (atomic_long_dec_and_test(&file
->f_count
)) {
298 struct task_struct
*task
= current
;
300 if (likely(!in_interrupt() && !(task
->flags
& PF_KTHREAD
))) {
301 init_task_work(&file
->f_u
.fu_rcuhead
, ____fput
);
302 if (!task_work_add(task
, &file
->f_u
.fu_rcuhead
, true))
305 * After this task has run exit_task_work(),
306 * task_work_add() will fail. Fall through to delayed
307 * fput to avoid leaking *file.
311 if (llist_add(&file
->f_u
.fu_llist
, &delayed_fput_list
))
312 schedule_delayed_work(&delayed_fput_work
, 1);
317 * synchronous analog of fput(); for kernel threads that might be needed
318 * in some umount() (and thus can't use flush_delayed_fput() without
319 * risking deadlocks), need to wait for completion of __fput() and know
320 * for this specific struct file it won't involve anything that would
321 * need them. Use only if you really need it - at the very least,
322 * don't blindly convert fput() by kernel thread to that.
324 void __fput_sync(struct file
*file
)
326 if (atomic_long_dec_and_test(&file
->f_count
)) {
327 struct task_struct
*task
= current
;
328 BUG_ON(!(task
->flags
& PF_KTHREAD
));
335 void put_filp(struct file
*file
)
337 if (atomic_long_dec_and_test(&file
->f_count
)) {
338 security_file_free(file
);
343 void __init
files_init(unsigned long mempages
)
347 filp_cachep
= kmem_cache_create("filp", sizeof(struct file
), 0,
348 SLAB_HWCACHE_ALIGN
| SLAB_PANIC
, NULL
);
351 * One file with associated inode and dcache is very roughly 1K.
352 * Per default don't use more than 10% of our memory for files.
355 n
= (mempages
* (PAGE_SIZE
/ 1024)) / 10;
356 files_stat
.max_files
= max_t(unsigned long, n
, NR_FILE
);
358 percpu_counter_init(&nr_files
, 0);