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 61066 : static void file_free_rcu(struct rcu_head *head)
46 : {
47 61066 : struct file *f = container_of(head, struct file, f_u.fu_rcuhead);
48 :
49 61066 : put_cred(f->f_cred);
50 61092 : kmem_cache_free(filp_cachep, f);
51 61072 : }
52 :
53 61085 : static inline void file_free(struct file *f)
54 : {
55 61085 : security_file_free(f);
56 61092 : if (!(f->f_mode & FMODE_NOACCOUNT))
57 61053 : percpu_counter_dec(&nr_files);
58 61087 : call_rcu(&f->f_u.fu_rcuhead, file_free_rcu);
59 61072 : }
60 :
61 : /*
62 : * Return the total number of open files in the system
63 : */
64 61635 : static long get_nr_files(void)
65 : {
66 61635 : return percpu_counter_read_positive(&nr_files);
67 : }
68 :
69 : /*
70 : * Return the maximum number of open files in the system
71 : */
72 717 : unsigned long get_max_files(void)
73 : {
74 717 : 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 *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 *buffer, size_t *lenp, loff_t *ppos)
91 : {
92 : return -ENOSYS;
93 : }
94 : #endif
95 :
96 61665 : static struct file *__alloc_file(int flags, const struct cred *cred)
97 : {
98 61665 : struct file *f;
99 61665 : int error;
100 :
101 61665 : f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL);
102 61700 : if (unlikely(!f))
103 61700 : return ERR_PTR(-ENOMEM);
104 :
105 61700 : f->f_cred = get_cred(cred);
106 61700 : error = security_file_alloc(f);
107 61700 : if (unlikely(error)) {
108 0 : file_free_rcu(&f->f_u.fu_rcuhead);
109 0 : return ERR_PTR(error);
110 : }
111 :
112 61700 : atomic_long_set(&f->f_count, 1);
113 61700 : rwlock_init(&f->f_owner.lock);
114 61700 : spin_lock_init(&f->f_lock);
115 61700 : mutex_init(&f->f_pos_lock);
116 61700 : f->f_flags = flags;
117 61700 : f->f_mode = OPEN_FMODE(flags);
118 : /* f->f_version: 0 */
119 :
120 61700 : return f;
121 : }
122 :
123 : /* Find an unused file structure and return a pointer to it.
124 : * Returns an error pointer if some error happend e.g. we over file
125 : * structures limit, run out of memory or operation is not permitted.
126 : *
127 : * Be very careful using this. You are responsible for
128 : * getting write access to any mount that you might assign
129 : * to this filp, if it is opened for write. If this is not
130 : * done, you will imbalance int the mount's writer count
131 : * and a warning at __fput() time.
132 : */
133 61635 : struct file *alloc_empty_file(int flags, const struct cred *cred)
134 : {
135 61635 : static long old_max;
136 61635 : struct file *f;
137 :
138 : /*
139 : * Privileged users can go above max_files
140 : */
141 61635 : if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) {
142 : /*
143 : * percpu_counters are inaccurate. Do an expensive check before
144 : * we go and fail.
145 : */
146 0 : if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files)
147 0 : goto over;
148 : }
149 :
150 61635 : f = __alloc_file(flags, cred);
151 61661 : if (!IS_ERR(f))
152 61661 : percpu_counter_inc(&nr_files);
153 :
154 : return f;
155 :
156 0 : over:
157 : /* Ran out of filps - report that */
158 0 : if (get_nr_files() > old_max) {
159 0 : pr_info("VFS: file-max limit %lu reached\n", get_max_files());
160 0 : old_max = get_nr_files();
161 : }
162 61661 : return ERR_PTR(-ENFILE);
163 : }
164 :
165 : /*
166 : * Variant of alloc_empty_file() that doesn't check and modify nr_files.
167 : *
168 : * Should not be used unless there's a very good reason to do so.
169 : */
170 39 : struct file *alloc_empty_file_noaccount(int flags, const struct cred *cred)
171 : {
172 39 : struct file *f = __alloc_file(flags, cred);
173 :
174 39 : if (!IS_ERR(f))
175 39 : f->f_mode |= FMODE_NOACCOUNT;
176 :
177 39 : return f;
178 : }
179 :
180 : /**
181 : * alloc_file - allocate and initialize a 'struct file'
182 : *
183 : * @path: the (dentry, vfsmount) pair for the new file
184 : * @flags: O_... flags with which the new file will be opened
185 : * @fop: the 'struct file_operations' for the new file
186 : */
187 1477 : static struct file *alloc_file(const struct path *path, int flags,
188 : const struct file_operations *fop)
189 : {
190 1477 : struct file *file;
191 :
192 1477 : file = alloc_empty_file(flags, current_cred());
193 1477 : if (IS_ERR(file))
194 : return file;
195 :
196 1477 : file->f_path = *path;
197 1477 : file->f_inode = path->dentry->d_inode;
198 1477 : file->f_mapping = path->dentry->d_inode->i_mapping;
199 1477 : file->f_wb_err = filemap_sample_wb_err(file->f_mapping);
200 1477 : file->f_sb_err = file_sample_sb_err(file);
201 1477 : if ((file->f_mode & FMODE_READ) &&
202 1136 : likely(fop->read || fop->read_iter))
203 1112 : file->f_mode |= FMODE_CAN_READ;
204 1477 : if ((file->f_mode & FMODE_WRITE) &&
205 1116 : likely(fop->write || fop->write_iter))
206 1046 : file->f_mode |= FMODE_CAN_WRITE;
207 1477 : file->f_mode |= FMODE_OPENED;
208 1477 : file->f_op = fop;
209 1477 : if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
210 361 : i_readcount_inc(path->dentry->d_inode);
211 : return file;
212 : }
213 :
214 1136 : 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 1136 : static const struct dentry_operations anon_ops = {
219 : .d_dname = simple_dname
220 : };
221 1136 : struct qstr this = QSTR_INIT(name, strlen(name));
222 1136 : struct path path;
223 1136 : struct file *file;
224 :
225 1136 : path.dentry = d_alloc_pseudo(mnt->mnt_sb, &this);
226 1136 : if (!path.dentry)
227 1136 : return ERR_PTR(-ENOMEM);
228 1136 : if (!mnt->mnt_sb->s_d_op)
229 6 : d_set_d_op(path.dentry, &anon_ops);
230 1136 : path.mnt = mntget(mnt);
231 1136 : d_instantiate(path.dentry, inode);
232 1136 : file = alloc_file(&path, flags, fops);
233 1136 : 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 341 : struct file *alloc_file_clone(struct file *base, int flags,
242 : const struct file_operations *fops)
243 : {
244 341 : struct file *f = alloc_file(&base->f_path, flags, fops);
245 341 : if (!IS_ERR(f)) {
246 341 : path_get(&f->f_path);
247 341 : f->f_mapping = base->f_mapping;
248 : }
249 341 : return f;
250 : }
251 :
252 : /* the real guts of fput() - releasing the last reference to file
253 : */
254 61063 : static void __fput(struct file *file)
255 : {
256 61063 : struct dentry *dentry = file->f_path.dentry;
257 61063 : struct vfsmount *mnt = file->f_path.mnt;
258 61063 : struct inode *inode = file->f_inode;
259 61063 : fmode_t mode = file->f_mode;
260 :
261 61063 : if (unlikely(!(file->f_mode & FMODE_OPENED)))
262 14610 : goto out;
263 :
264 46453 : might_sleep();
265 :
266 46485 : fsnotify_close(file);
267 : /*
268 : * The function eventpoll_release() should be the first called
269 : * in the file cleanup chain.
270 : */
271 46488 : eventpoll_release(file);
272 46488 : locks_remove_file(file);
273 :
274 46455 : ima_file_free(file);
275 46455 : if (unlikely(file->f_flags & FASYNC)) {
276 0 : if (file->f_op->fasync)
277 0 : file->f_op->fasync(-1, file, 0);
278 : }
279 46455 : if (file->f_op->release)
280 15104 : file->f_op->release(inode, file);
281 46457 : if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL &&
282 : !(mode & FMODE_PATH))) {
283 365 : cdev_put(inode->i_cdev);
284 : }
285 46457 : fops_put(file->f_op);
286 46457 : put_pid(file->f_owner.pid);
287 46458 : if ((mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
288 13800 : i_readcount_dec(inode);
289 46458 : if (mode & FMODE_WRITER) {
290 1163 : put_write_access(inode);
291 1163 : __mnt_drop_write(mnt);
292 : }
293 46458 : dput(dentry);
294 46480 : if (unlikely(mode & FMODE_NEED_UNMOUNT))
295 0 : dissolve_on_fput(mnt);
296 46480 : mntput(mnt);
297 61090 : out:
298 61090 : file_free(file);
299 61073 : }
300 :
301 : static LLIST_HEAD(delayed_fput_list);
302 1 : static void delayed_fput(struct work_struct *unused)
303 : {
304 1 : struct llist_node *node = llist_del_all(&delayed_fput_list);
305 1 : struct file *f, *t;
306 :
307 2 : llist_for_each_entry_safe(f, t, node, f_u.fu_llist)
308 0 : __fput(f);
309 1 : }
310 :
311 61071 : static void ____fput(struct callback_head *work)
312 : {
313 61071 : __fput(container_of(work, struct file, f_u.fu_rcuhead));
314 61081 : }
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 1 : void flush_delayed_fput(void)
327 : {
328 1 : delayed_fput(NULL);
329 1 : }
330 : EXPORT_SYMBOL_GPL(flush_delayed_fput);
331 :
332 : static DECLARE_DELAYED_WORK(delayed_fput_work, delayed_fput);
333 :
334 197502 : void fput_many(struct file *file, unsigned int refs)
335 : {
336 395022 : if (atomic_long_sub_and_test(refs, &file->f_count)) {
337 61105 : struct task_struct *task = current;
338 :
339 61105 : if (likely(!in_interrupt() && !(task->flags & PF_KTHREAD))) {
340 61105 : init_task_work(&file->f_u.fu_rcuhead, ____fput);
341 61105 : if (!task_work_add(task, &file->f_u.fu_rcuhead, TWA_RESUME))
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 0 : if (llist_add(&file->f_u.fu_llist, &delayed_fput_list))
351 0 : schedule_delayed_work(&delayed_fput_work, 1);
352 : }
353 : }
354 :
355 197507 : void fput(struct file *file)
356 : {
357 197507 : fput_many(file, 1);
358 197527 : }
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 1 : void __init files_init(void)
380 : {
381 1 : filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
382 : SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT, NULL);
383 1 : percpu_counter_init(&nr_files, 0, GFP_KERNEL);
384 1 : }
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 1 : void __init files_maxfiles_init(void)
391 : {
392 1 : unsigned long n;
393 1 : unsigned long nr_pages = totalram_pages();
394 1 : unsigned long memreserve = (nr_pages - nr_free_pages()) * 3/2;
395 :
396 1 : memreserve = min(memreserve, nr_pages - 1);
397 1 : n = ((nr_pages - memreserve) * (PAGE_SIZE / 1024)) / 10;
398 :
399 1 : files_stat.max_files = max_t(unsigned long, n, NR_FILE);
400 1 : }
|
