Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/fs/file_table.c
4 : : *
5 : : * Copyright (C) 1991, 1992 Linus Torvalds
6 : : * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
7 : : */
8 : :
9 : : #include <linux/string.h>
10 : : #include <linux/slab.h>
11 : : #include <linux/file.h>
12 : : #include <linux/fdtable.h>
13 : : #include <linux/init.h>
14 : : #include <linux/module.h>
15 : : #include <linux/fs.h>
16 : : #include <linux/security.h>
17 : : #include <linux/cred.h>
18 : : #include <linux/eventpoll.h>
19 : : #include <linux/rcupdate.h>
20 : : #include <linux/mount.h>
21 : : #include <linux/capability.h>
22 : : #include <linux/cdev.h>
23 : : #include <linux/fsnotify.h>
24 : : #include <linux/sysctl.h>
25 : : #include <linux/percpu_counter.h>
26 : : #include <linux/percpu.h>
27 : : #include <linux/task_work.h>
28 : : #include <linux/ima.h>
29 : : #include <linux/swap.h>
30 : :
31 : : #include <linux/atomic.h>
32 : :
33 : : #include "internal.h"
34 : :
35 : : /* sysctl tunables... */
36 : : struct files_stat_struct files_stat = {
37 : : .max_files = NR_FILE
38 : : };
39 : :
40 : : /* SLAB cache for file structures */
41 : : static struct kmem_cache *filp_cachep __read_mostly;
42 : :
43 : : static struct percpu_counter nr_files __cacheline_aligned_in_smp;
44 : :
45 : 1473324 : static void file_free_rcu(struct rcu_head *head)
46 : : {
47 : 1473324 : struct file *f = container_of(head, struct file, f_u.fu_rcuhead);
48 : :
49 : 1473324 : put_cred(f->f_cred);
50 : 1473324 : kmem_cache_free(filp_cachep, f);
51 : 1473324 : }
52 : :
53 : 1475189 : static inline void file_free(struct file *f)
54 : : {
55 : 1475189 : security_file_free(f);
56 [ + - ]: 1475189 : if (!(f->f_mode & FMODE_NOACCOUNT))
57 : 1475189 : percpu_counter_dec(&nr_files);
58 : 1475189 : call_rcu(&f->f_u.fu_rcuhead, file_free_rcu);
59 : 1475189 : }
60 : :
61 : : /*
62 : : * Return the total number of open files in the system
63 : : */
64 : 1486613 : static long get_nr_files(void)
65 : : {
66 : 1486613 : return percpu_counter_read_positive(&nr_files);
67 : : }
68 : :
69 : : /*
70 : : * Return the maximum number of open files in the system
71 : : */
72 : 8092 : unsigned long get_max_files(void)
73 : : {
74 : 8092 : return files_stat.max_files;
75 : : }
76 : : EXPORT_SYMBOL_GPL(get_max_files);
77 : :
78 : : /*
79 : : * Handle nr_files sysctl
80 : : */
81 : : #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
82 : 0 : int proc_nr_files(struct ctl_table *table, int write,
83 : : void __user *buffer, size_t *lenp, loff_t *ppos)
84 : : {
85 : 0 : files_stat.nr_files = get_nr_files();
86 : 0 : return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
87 : : }
88 : : #else
89 : : int proc_nr_files(struct ctl_table *table, int write,
90 : : void __user *buffer, size_t *lenp, loff_t *ppos)
91 : : {
92 : : return -ENOSYS;
93 : : }
94 : : #endif
95 : :
96 : 1486613 : static struct file *__alloc_file(int flags, const struct cred *cred)
97 : : {
98 : 1486613 : struct file *f;
99 : 1486613 : int error;
100 : :
101 : 1486613 : f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
102 [ + - ]: 1486613 : if (unlikely(!f))
103 : : return ERR_PTR(-ENOMEM);
104 : :
105 [ + - ]: 1486613 : f->f_cred = get_cred(cred);
106 : 1486613 : error = security_file_alloc(f);
107 [ - + ]: 1486613 : if (unlikely(error)) {
108 : 0 : file_free_rcu(&f->f_u.fu_rcuhead);
109 : 0 : return ERR_PTR(error);
110 : : }
111 : :
112 : 1486613 : atomic_long_set(&f->f_count, 1);
113 : 1486613 : rwlock_init(&f->f_owner.lock);
114 : 1486613 : spin_lock_init(&f->f_lock);
115 : 1486613 : mutex_init(&f->f_pos_lock);
116 : 1486613 : eventpoll_init_file(f);
117 : 1486613 : f->f_flags = flags;
118 : 1486613 : f->f_mode = OPEN_FMODE(flags);
119 : : /* f->f_version: 0 */
120 : :
121 : 1486613 : return f;
122 : : }
123 : :
124 : : /* Find an unused file structure and return a pointer to it.
125 : : * Returns an error pointer if some error happend e.g. we over file
126 : : * structures limit, run out of memory or operation is not permitted.
127 : : *
128 : : * Be very careful using this. You are responsible for
129 : : * getting write access to any mount that you might assign
130 : : * to this filp, if it is opened for write. If this is not
131 : : * done, you will imbalance int the mount's writer count
132 : : * and a warning at __fput() time.
133 : : */
134 : 1486613 : struct file *alloc_empty_file(int flags, const struct cred *cred)
135 : : {
136 : 1486613 : static long old_max;
137 : 1486613 : struct file *f;
138 : :
139 : : /*
140 : : * Privileged users can go above max_files
141 : : */
142 [ - + - - ]: 1486613 : if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
143 : : /*
144 : : * percpu_counters are inaccurate. Do an expensive check before
145 : : * we go and fail.
146 : : */
147 [ # # ]: 0 : if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
148 : 0 : goto over;
149 : : }
150 : :
151 : 1486613 : f = __alloc_file(flags, cred);
152 [ + - ]: 1486613 : if (!IS_ERR(f))
153 : 1486613 : percpu_counter_inc(&nr_files);
154 : :
155 : : return f;
156 : :
157 : : over:
158 : : /* Ran out of filps - report that */
159 [ # # ]: 0 : if (get_nr_files() > old_max) {
160 : 0 : pr_info("VFS: file-max limit %lu reached\n", get_max_files());
161 : 0 : old_max = get_nr_files();
162 : : }
163 : : return ERR_PTR(-ENFILE);
164 : : }
165 : :
166 : : /*
167 : : * Variant of alloc_empty_file() that doesn't check and modify nr_files.
168 : : *
169 : : * Should not be used unless there's a very good reason to do so.
170 : : */
171 : 0 : struct file *alloc_empty_file_noaccount(int flags, const struct cred *cred)
172 : : {
173 : 0 : struct file *f = __alloc_file(flags, cred);
174 : :
175 [ # # ]: 0 : if (!IS_ERR(f))
176 : 0 : f->f_mode |= FMODE_NOACCOUNT;
177 : :
178 : 0 : return f;
179 : : }
180 : :
181 : : /**
182 : : * alloc_file - allocate and initialize a 'struct file'
183 : : *
184 : : * @path: the (dentry, vfsmount) pair for the new file
185 : : * @flags: O_... flags with which the new file will be opened
186 : : * @fop: the 'struct file_operations' for the new file
187 : : */
188 : 12908 : static struct file *alloc_file(const struct path *path, int flags,
189 : : const struct file_operations *fop)
190 : : {
191 : 12908 : struct file *file;
192 : :
193 : 12908 : file = alloc_empty_file(flags, current_cred());
194 [ + - ]: 12908 : if (IS_ERR(file))
195 : : return file;
196 : :
197 : 12908 : file->f_path = *path;
198 : 12908 : file->f_inode = path->dentry->d_inode;
199 : 12908 : file->f_mapping = path->dentry->d_inode->i_mapping;
200 : 12908 : file->f_wb_err = filemap_sample_wb_err(file->f_mapping);
201 [ + + ]: 12908 : if ((file->f_mode & FMODE_READ) &&
202 [ + + + + ]: 12124 : likely(fop->read || fop->read_iter))
203 : 11452 : file->f_mode |= FMODE_CAN_READ;
204 [ + + ]: 12908 : if ((file->f_mode & FMODE_WRITE) &&
205 [ + - + + ]: 11816 : likely(fop->write || fop->write_iter))
206 : 9828 : file->f_mode |= FMODE_CAN_WRITE;
207 : 12908 : file->f_mode |= FMODE_OPENED;
208 : 12908 : file->f_op = fop;
209 [ + + ]: 12908 : if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
210 : 1092 : i_readcount_inc(path->dentry->d_inode);
211 : : return file;
212 : : }
213 : :
214 : 12124 : struct file *alloc_file_pseudo(struct inode *inode, struct vfsmount *mnt,
215 : : const char *name, int flags,
216 : : const struct file_operations *fops)
217 : : {
218 : 12124 : static const struct dentry_operations anon_ops = {
219 : : .d_dname = simple_dname
220 : : };
221 : 12124 : struct qstr this = QSTR_INIT(name, strlen(name));
222 : 12124 : struct path path;
223 : 12124 : struct file *file;
224 : :
225 : 12124 : path.dentry = d_alloc_pseudo(mnt->mnt_sb, &this);
226 [ + - ]: 12124 : if (!path.dentry)
227 : : return ERR_PTR(-ENOMEM);
228 [ - + ]: 12124 : if (!mnt->mnt_sb->s_d_op)
229 : 0 : d_set_d_op(path.dentry, &anon_ops);
230 : 12124 : path.mnt = mntget(mnt);
231 : 12124 : d_instantiate(path.dentry, inode);
232 : 12124 : file = alloc_file(&path, flags, fops);
233 [ - + ]: 12124 : if (IS_ERR(file)) {
234 : 0 : ihold(inode);
235 : 0 : path_put(&path);
236 : : }
237 : : return file;
238 : : }
239 : : EXPORT_SYMBOL(alloc_file_pseudo);
240 : :
241 : 784 : struct file *alloc_file_clone(struct file *base, int flags,
242 : : const struct file_operations *fops)
243 : : {
244 : 784 : struct file *f = alloc_file(&base->f_path, flags, fops);
245 [ + - ]: 784 : if (!IS_ERR(f)) {
246 : 784 : path_get(&f->f_path);
247 : 784 : f->f_mapping = base->f_mapping;
248 : : }
249 : 784 : return f;
250 : : }
251 : :
252 : : /* the real guts of fput() - releasing the last reference to file
253 : : */
254 : 1475189 : static void __fput(struct file *file)
255 : : {
256 : 1475189 : struct dentry *dentry = file->f_path.dentry;
257 : 1475189 : struct vfsmount *mnt = file->f_path.mnt;
258 : 1475189 : struct inode *inode = file->f_inode;
259 : 1475189 : fmode_t mode = file->f_mode;
260 : :
261 [ + + ]: 1475189 : if (unlikely(!(file->f_mode & FMODE_OPENED)))
262 : 322844 : goto out;
263 : :
264 : 1152345 : might_sleep();
265 : :
266 : 1152345 : fsnotify_close(file);
267 : : /*
268 : : * The function eventpoll_release() should be the first called
269 : : * in the file cleanup chain.
270 : : */
271 [ + + ]: 1152345 : eventpoll_release(file);
272 : 1152345 : locks_remove_file(file);
273 : :
274 [ - + ]: 1152345 : ima_file_free(file);
275 [ - + ]: 1152345 : if (unlikely(file->f_flags & FASYNC)) {
276 [ # # ]: 0 : if (file->f_op->fasync)
277 : 0 : file->f_op->fasync(-1, file, 0);
278 : : }
279 [ + + ]: 1152345 : if (file->f_op->release)
280 : 480820 : file->f_op->release(inode, file);
281 [ + + + - : 1152345 : if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL &&
+ - ]
282 : : !(mode & FMODE_PATH))) {
283 : 6072 : cdev_put(inode->i_cdev);
284 : : }
285 [ + - ]: 1152345 : fops_put(file->f_op);
286 : 1152345 : put_pid(file->f_owner.pid);
287 [ + + ]: 1152345 : if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
288 : 450159 : i_readcount_dec(inode);
289 [ + + ]: 1152345 : if (mode & FMODE_WRITER) {
290 : 37126 : put_write_access(inode);
291 : 37126 : __mnt_drop_write(mnt);
292 : : }
293 : 1152345 : dput(dentry);
294 [ - + ]: 1152345 : if (unlikely(mode & FMODE_NEED_UNMOUNT))
295 : 0 : dissolve_on_fput(mnt);
296 : 1152345 : mntput(mnt);
297 : 1475189 : out:
298 : 1475189 : file_free(file);
299 : 1475189 : }
300 : :
301 : : static LLIST_HEAD(delayed_fput_list);
302 : 187 : static void delayed_fput(struct work_struct *unused)
303 : : {
304 : 187 : struct llist_node *node = llist_del_all(&delayed_fput_list);
305 : 187 : struct file *f, *t;
306 : :
307 [ + + ]: 1242 : llist_for_each_entry_safe(f, t, node, f_u.fu_llist)
308 : 868 : __fput(f);
309 : 187 : }
310 : :
311 : 1474321 : static void ____fput(struct callback_head *work)
312 : : {
313 : 1474321 : __fput(container_of(work, struct file, f_u.fu_rcuhead));
314 : 1474321 : }
315 : :
316 : : /*
317 : : * If kernel thread really needs to have the final fput() it has done
318 : : * to complete, call this. The only user right now is the boot - we
319 : : * *do* need to make sure our writes to binaries on initramfs has
320 : : * not left us with opened struct file waiting for __fput() - execve()
321 : : * won't work without that. Please, don't add more callers without
322 : : * very good reasons; in particular, never call that with locks
323 : : * held and never call that from a thread that might need to do
324 : : * some work on any kind of umount.
325 : : */
326 : 28 : void flush_delayed_fput(void)
327 : : {
328 : 28 : delayed_fput(NULL);
329 : 28 : }
330 : : EXPORT_SYMBOL_GPL(flush_delayed_fput);
331 : :
332 : : static DECLARE_DELAYED_WORK(delayed_fput_work, delayed_fput);
333 : :
334 : 4773443 : void fput_many(struct file *file, unsigned int refs)
335 : : {
336 [ + + ]: 4773443 : if (atomic_long_sub_and_test(refs, &file->f_count)) {
337 [ + - ]: 1475189 : struct task_struct *task = current;
338 : :
339 [ + - + + ]: 1475189 : if (likely(!in_interrupt() && !(task->flags & PF_KTHREAD))) {
340 : 1474321 : init_task_work(&file->f_u.fu_rcuhead, ____fput);
341 [ - + ]: 1474321 : if (!task_work_add(task, &file->f_u.fu_rcuhead, true))
342 : : return;
343 : : /*
344 : : * After this task has run exit_task_work(),
345 : : * task_work_add() will fail. Fall through to delayed
346 : : * fput to avoid leaking *file.
347 : : */
348 : : }
349 : :
350 [ + + ]: 868 : if (llist_add(&file->f_u.fu_llist, &delayed_fput_list))
351 : 159 : schedule_delayed_work(&delayed_fput_work, 1);
352 : : }
353 : : }
354 : :
355 : 4773443 : void fput(struct file *file)
356 : : {
357 : 4773443 : fput_many(file, 1);
358 : 4773443 : }
359 : :
360 : : /*
361 : : * synchronous analog of fput(); for kernel threads that might be needed
362 : : * in some umount() (and thus can't use flush_delayed_fput() without
363 : : * risking deadlocks), need to wait for completion of __fput() and know
364 : : * for this specific struct file it won't involve anything that would
365 : : * need them. Use only if you really need it - at the very least,
366 : : * don't blindly convert fput() by kernel thread to that.
367 : : */
368 : 0 : void __fput_sync(struct file *file)
369 : : {
370 [ # # ]: 0 : if (atomic_long_dec_and_test(&file->f_count)) {
371 [ # # ]: 0 : struct task_struct *task = current;
372 [ # # ]: 0 : BUG_ON(!(task->flags & PF_KTHREAD));
373 : 0 : __fput(file);
374 : : }
375 : 0 : }
376 : :
377 : : EXPORT_SYMBOL(fput);
378 : :
379 : 28 : void __init files_init(void)
380 : : {
381 : 28 : filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
382 : : SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT, NULL);
383 : 28 : percpu_counter_init(&nr_files, 0, GFP_KERNEL);
384 : 28 : }
385 : :
386 : : /*
387 : : * One file with associated inode and dcache is very roughly 1K. Per default
388 : : * do not use more than 10% of our memory for files.
389 : : */
390 : 28 : void __init files_maxfiles_init(void)
391 : : {
392 : 28 : unsigned long n;
393 : 28 : unsigned long nr_pages = totalram_pages();
394 : 28 : unsigned long memreserve = (nr_pages - nr_free_pages()) * 3/2;
395 : :
396 : 28 : memreserve = min(memreserve, nr_pages - 1);
397 : 28 : n = ((nr_pages - memreserve) * (PAGE_SIZE / 1024)) / 10;
398 : :
399 : 28 : files_stat.max_files = max_t(unsigned long, n, NR_FILE);
400 : 28 : }
|
