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
;
180 if ((mode
& (FMODE_READ
| FMODE_WRITE
)) == FMODE_READ
)
181 i_readcount_inc(path
->dentry
->d_inode
);
184 EXPORT_SYMBOL(alloc_file
);
186 /* the real guts of fput() - releasing the last reference to file
188 static void __fput(struct file
*file
)
190 struct dentry
*dentry
= file
->f_path
.dentry
;
191 struct vfsmount
*mnt
= file
->f_path
.mnt
;
192 struct inode
*inode
= file
->f_inode
;
196 fsnotify_close(file
);
198 * The function eventpoll_release() should be the first called
199 * in the file cleanup chain.
201 eventpoll_release(file
);
202 locks_remove_file(file
);
204 if (unlikely(file
->f_flags
& FASYNC
)) {
205 if (file
->f_op
->fasync
)
206 file
->f_op
->fasync(-1, file
, 0);
209 if (file
->f_op
->release
)
210 file
->f_op
->release(inode
, file
);
211 security_file_free(file
);
212 if (unlikely(S_ISCHR(inode
->i_mode
) && inode
->i_cdev
!= NULL
&&
213 !(file
->f_mode
& FMODE_PATH
))) {
214 cdev_put(inode
->i_cdev
);
216 fops_put(file
->f_op
);
217 put_pid(file
->f_owner
.pid
);
218 if ((file
->f_mode
& (FMODE_READ
| FMODE_WRITE
)) == FMODE_READ
)
219 i_readcount_dec(inode
);
220 if (file
->f_mode
& FMODE_WRITER
) {
221 put_write_access(inode
);
222 __mnt_drop_write(mnt
);
224 file
->f_path
.dentry
= NULL
;
225 file
->f_path
.mnt
= NULL
;
226 file
->f_inode
= NULL
;
232 static LLIST_HEAD(delayed_fput_list
);
233 static void delayed_fput(struct work_struct
*unused
)
235 struct llist_node
*node
= llist_del_all(&delayed_fput_list
);
236 struct llist_node
*next
;
238 for (; node
; node
= next
) {
239 next
= llist_next(node
);
240 __fput(llist_entry(node
, struct file
, f_u
.fu_llist
));
244 static void ____fput(struct callback_head
*work
)
246 __fput(container_of(work
, struct file
, f_u
.fu_rcuhead
));
250 * If kernel thread really needs to have the final fput() it has done
251 * to complete, call this. The only user right now is the boot - we
252 * *do* need to make sure our writes to binaries on initramfs has
253 * not left us with opened struct file waiting for __fput() - execve()
254 * won't work without that. Please, don't add more callers without
255 * very good reasons; in particular, never call that with locks
256 * held and never call that from a thread that might need to do
257 * some work on any kind of umount.
259 void flush_delayed_fput(void)
264 static DECLARE_DELAYED_WORK(delayed_fput_work
, delayed_fput
);
266 void fput(struct file
*file
)
268 if (atomic_long_dec_and_test(&file
->f_count
)) {
269 struct task_struct
*task
= current
;
271 if (likely(!in_interrupt() && !(task
->flags
& PF_KTHREAD
))) {
272 init_task_work(&file
->f_u
.fu_rcuhead
, ____fput
);
273 if (!task_work_add(task
, &file
->f_u
.fu_rcuhead
, true))
276 * After this task has run exit_task_work(),
277 * task_work_add() will fail. Fall through to delayed
278 * fput to avoid leaking *file.
282 if (llist_add(&file
->f_u
.fu_llist
, &delayed_fput_list
))
283 schedule_delayed_work(&delayed_fput_work
, 1);
288 * synchronous analog of fput(); for kernel threads that might be needed
289 * in some umount() (and thus can't use flush_delayed_fput() without
290 * risking deadlocks), need to wait for completion of __fput() and know
291 * for this specific struct file it won't involve anything that would
292 * need them. Use only if you really need it - at the very least,
293 * don't blindly convert fput() by kernel thread to that.
295 void __fput_sync(struct file
*file
)
297 if (atomic_long_dec_and_test(&file
->f_count
)) {
298 struct task_struct
*task
= current
;
299 BUG_ON(!(task
->flags
& PF_KTHREAD
));
306 void put_filp(struct file
*file
)
308 if (atomic_long_dec_and_test(&file
->f_count
)) {
309 security_file_free(file
);
314 void __init
files_init(unsigned long mempages
)
318 filp_cachep
= kmem_cache_create("filp", sizeof(struct file
), 0,
319 SLAB_HWCACHE_ALIGN
| SLAB_PANIC
, NULL
);
322 * One file with associated inode and dcache is very roughly 1K.
323 * Per default don't use more than 10% of our memory for files.
326 n
= (mempages
* (PAGE_SIZE
/ 1024)) / 10;
327 files_stat
.max_files
= max_t(unsigned long, n
, NR_FILE
);
328 percpu_counter_init(&nr_files
, 0);