Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * linux/fs/file.c
4 : : *
5 : : * Copyright (C) 1998-1999, Stephen Tweedie and Bill Hawes
6 : : *
7 : : * Manage the dynamic fd arrays in the process files_struct.
8 : : */
9 : :
10 : : #include <linux/syscalls.h>
11 : : #include <linux/export.h>
12 : : #include <linux/fs.h>
13 : : #include <linux/mm.h>
14 : : #include <linux/sched/signal.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/file.h>
17 : : #include <linux/fdtable.h>
18 : : #include <linux/bitops.h>
19 : : #include <linux/spinlock.h>
20 : : #include <linux/rcupdate.h>
21 : :
22 : : unsigned int sysctl_nr_open __read_mostly = 1024*1024;
23 : : unsigned int sysctl_nr_open_min = BITS_PER_LONG;
24 : : /* our min() is unusable in constant expressions ;-/ */
25 : : #define __const_min(x, y) ((x) < (y) ? (x) : (y))
26 : : unsigned int sysctl_nr_open_max =
27 : : __const_min(INT_MAX, ~(size_t)0/sizeof(void *)) & -BITS_PER_LONG;
28 : :
29 : 221 : static void __free_fdtable(struct fdtable *fdt)
30 : : {
31 : 221 : kvfree(fdt->fd);
32 : 221 : kvfree(fdt->open_fds);
33 : 221 : kfree(fdt);
34 : 221 : }
35 : :
36 : 0 : static void free_fdtable_rcu(struct rcu_head *rcu)
37 : : {
38 : 0 : __free_fdtable(container_of(rcu, struct fdtable, rcu));
39 : 0 : }
40 : :
41 : : #define BITBIT_NR(nr) BITS_TO_LONGS(BITS_TO_LONGS(nr))
42 : : #define BITBIT_SIZE(nr) (BITBIT_NR(nr) * sizeof(long))
43 : :
44 : : /*
45 : : * Copy 'count' fd bits from the old table to the new table and clear the extra
46 : : * space if any. This does not copy the file pointers. Called with the files
47 : : * spinlock held for write.
48 : : */
49 : 12558 : static void copy_fd_bitmaps(struct fdtable *nfdt, struct fdtable *ofdt,
50 : : unsigned int count)
51 : : {
52 : 12558 : unsigned int cpy, set;
53 : :
54 : 12558 : cpy = count / BITS_PER_BYTE;
55 : 12558 : set = (nfdt->max_fds - count) / BITS_PER_BYTE;
56 : 12558 : memcpy(nfdt->open_fds, ofdt->open_fds, cpy);
57 : 12558 : memset((char *)nfdt->open_fds + cpy, 0, set);
58 : 12558 : memcpy(nfdt->close_on_exec, ofdt->close_on_exec, cpy);
59 : 12558 : memset((char *)nfdt->close_on_exec + cpy, 0, set);
60 : :
61 : 12558 : cpy = BITBIT_SIZE(count);
62 : 12558 : set = BITBIT_SIZE(nfdt->max_fds) - cpy;
63 : 12558 : memcpy(nfdt->full_fds_bits, ofdt->full_fds_bits, cpy);
64 : 12558 : memset((char *)nfdt->full_fds_bits + cpy, 0, set);
65 : 12558 : }
66 : :
67 : : /*
68 : : * Copy all file descriptors from the old table to the new, expanded table and
69 : : * clear the extra space. Called with the files spinlock held for write.
70 : : */
71 : 52 : static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
72 : : {
73 : 52 : unsigned int cpy, set;
74 : :
75 [ - + ]: 52 : BUG_ON(nfdt->max_fds < ofdt->max_fds);
76 : :
77 : 52 : cpy = ofdt->max_fds * sizeof(struct file *);
78 : 52 : set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *);
79 : 52 : memcpy(nfdt->fd, ofdt->fd, cpy);
80 : 52 : memset((char *)nfdt->fd + cpy, 0, set);
81 : :
82 : 52 : copy_fd_bitmaps(nfdt, ofdt, ofdt->max_fds);
83 : 52 : }
84 : :
85 : 273 : static struct fdtable * alloc_fdtable(unsigned int nr)
86 : : {
87 : 273 : struct fdtable *fdt;
88 : 273 : void *data;
89 : :
90 : : /*
91 : : * Figure out how many fds we actually want to support in this fdtable.
92 : : * Allocation steps are keyed to the size of the fdarray, since it
93 : : * grows far faster than any of the other dynamic data. We try to fit
94 : : * the fdarray into comfortable page-tuned chunks: starting at 1024B
95 : : * and growing in powers of two from there on.
96 : : */
97 : 273 : nr /= (1024 / sizeof(struct file *));
98 [ - + - - : 273 : nr = roundup_pow_of_two(nr + 1);
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - -
- ]
99 : 273 : nr *= (1024 / sizeof(struct file *));
100 : : /*
101 : : * Note that this can drive nr *below* what we had passed if sysctl_nr_open
102 : : * had been set lower between the check in expand_files() and here. Deal
103 : : * with that in caller, it's cheaper that way.
104 : : *
105 : : * We make sure that nr remains a multiple of BITS_PER_LONG - otherwise
106 : : * bitmaps handling below becomes unpleasant, to put it mildly...
107 : : */
108 [ - + ]: 273 : if (unlikely(nr > sysctl_nr_open))
109 : 0 : nr = ((sysctl_nr_open - 1) | (BITS_PER_LONG - 1)) + 1;
110 : :
111 : 273 : fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL_ACCOUNT);
112 [ - + ]: 273 : if (!fdt)
113 : 0 : goto out;
114 : 273 : fdt->max_fds = nr;
115 : 273 : data = kvmalloc_array(nr, sizeof(struct file *), GFP_KERNEL_ACCOUNT);
116 [ - + ]: 273 : if (!data)
117 : 0 : goto out_fdt;
118 : 273 : fdt->fd = data;
119 : :
120 : 273 : data = kvmalloc(max_t(size_t,
121 : : 2 * nr / BITS_PER_BYTE + BITBIT_SIZE(nr), L1_CACHE_BYTES),
122 : : GFP_KERNEL_ACCOUNT);
123 [ - + ]: 273 : if (!data)
124 : 0 : goto out_arr;
125 : 273 : fdt->open_fds = data;
126 : 273 : data += nr / BITS_PER_BYTE;
127 : 273 : fdt->close_on_exec = data;
128 : 273 : data += nr / BITS_PER_BYTE;
129 : 273 : fdt->full_fds_bits = data;
130 : :
131 : 273 : return fdt;
132 : :
133 : : out_arr:
134 : 0 : kvfree(fdt->fd);
135 : 0 : out_fdt:
136 : 0 : kfree(fdt);
137 : : out:
138 : : return NULL;
139 : : }
140 : :
141 : : /*
142 : : * Expand the file descriptor table.
143 : : * This function will allocate a new fdtable and both fd array and fdset, of
144 : : * the given size.
145 : : * Return <0 error code on error; 1 on successful completion.
146 : : * The files->file_lock should be held on entry, and will be held on exit.
147 : : */
148 : 52 : static int expand_fdtable(struct files_struct *files, unsigned int nr)
149 : : __releases(files->file_lock)
150 : : __acquires(files->file_lock)
151 : : {
152 : 52 : struct fdtable *new_fdt, *cur_fdt;
153 : :
154 : 52 : spin_unlock(&files->file_lock);
155 : 52 : new_fdt = alloc_fdtable(nr);
156 : :
157 : : /* make sure all __fd_install() have seen resize_in_progress
158 : : * or have finished their rcu_read_lock_sched() section.
159 : : */
160 [ - + ]: 52 : if (atomic_read(&files->count) > 1)
161 : 0 : synchronize_rcu();
162 : :
163 : 52 : spin_lock(&files->file_lock);
164 [ + - ]: 52 : if (!new_fdt)
165 : : return -ENOMEM;
166 : : /*
167 : : * extremely unlikely race - sysctl_nr_open decreased between the check in
168 : : * caller and alloc_fdtable(). Cheaper to catch it here...
169 : : */
170 [ - + ]: 52 : if (unlikely(new_fdt->max_fds <= nr)) {
171 : 0 : __free_fdtable(new_fdt);
172 : 0 : return -EMFILE;
173 : : }
174 [ - + ]: 52 : cur_fdt = files_fdtable(files);
175 [ - + ]: 52 : BUG_ON(nr < cur_fdt->max_fds);
176 : 52 : copy_fdtable(new_fdt, cur_fdt);
177 [ - + ]: 52 : rcu_assign_pointer(files->fdt, new_fdt);
178 [ - + ]: 52 : if (cur_fdt != &files->fdtab)
179 : 0 : call_rcu(&cur_fdt->rcu, free_fdtable_rcu);
180 : : /* coupled with smp_rmb() in __fd_install() */
181 : 52 : smp_wmb();
182 : 52 : return 1;
183 : : }
184 : :
185 : : /*
186 : : * Expand files.
187 : : * This function will expand the file structures, if the requested size exceeds
188 : : * the current capacity and there is room for expansion.
189 : : * Return <0 error code on error; 0 when nothing done; 1 when files were
190 : : * expanded and execution may have blocked.
191 : : * The files->file_lock should be held on entry, and will be held on exit.
192 : : */
193 : 679767 : static int expand_files(struct files_struct *files, unsigned int nr)
194 : : __releases(files->file_lock)
195 : : __acquires(files->file_lock)
196 : : {
197 : 679767 : struct fdtable *fdt;
198 : 679767 : int expanded = 0;
199 : :
200 : 679767 : repeat:
201 [ + + ]: 679767 : fdt = files_fdtable(files);
202 : :
203 : : /* Do we need to expand? */
204 [ + + ]: 679767 : if (nr < fdt->max_fds)
205 : 679715 : return expanded;
206 : :
207 : : /* Can we expand? */
208 [ + - ]: 52 : if (nr >= sysctl_nr_open)
209 : : return -EMFILE;
210 : :
211 [ - + ]: 52 : if (unlikely(files->resize_in_progress)) {
212 : 0 : spin_unlock(&files->file_lock);
213 : 0 : expanded = 1;
214 [ # # # # ]: 0 : wait_event(files->resize_wait, !files->resize_in_progress);
215 : 0 : spin_lock(&files->file_lock);
216 : 0 : goto repeat;
217 : : }
218 : :
219 : : /* All good, so we try */
220 : 52 : files->resize_in_progress = true;
221 : 52 : expanded = expand_fdtable(files, nr);
222 : 52 : files->resize_in_progress = false;
223 : :
224 : 52 : wake_up_all(&files->resize_wait);
225 : 52 : return expanded;
226 : : }
227 : :
228 : 649672 : static inline void __set_close_on_exec(unsigned int fd, struct fdtable *fdt)
229 : : {
230 : 649672 : __set_bit(fd, fdt->close_on_exec);
231 : 649672 : }
232 : :
233 : : static inline void __clear_close_on_exec(unsigned int fd, struct fdtable *fdt)
234 : : {
235 : : if (test_bit(fd, fdt->close_on_exec))
236 : : __clear_bit(fd, fdt->close_on_exec);
237 : : }
238 : :
239 : : static inline void __set_open_fd(unsigned int fd, struct fdtable *fdt)
240 : : {
241 : : __set_bit(fd, fdt->open_fds);
242 : : fd /= BITS_PER_LONG;
243 : : if (!~fdt->open_fds[fd])
244 : : __set_bit(fd, fdt->full_fds_bits);
245 : : }
246 : :
247 : : static inline void __clear_open_fd(unsigned int fd, struct fdtable *fdt)
248 : : {
249 : : __clear_bit(fd, fdt->open_fds);
250 : : __clear_bit(fd / BITS_PER_LONG, fdt->full_fds_bits);
251 : : }
252 : :
253 : 12727 : static unsigned int count_open_files(struct fdtable *fdt)
254 : : {
255 : 12727 : unsigned int size = fdt->max_fds;
256 : 12727 : unsigned int i;
257 : :
258 : : /* Find the last open fd */
259 [ + + + - ]: 34034 : for (i = size / BITS_PER_LONG; i > 0; ) {
260 [ + + - + ]: 33631 : if (fdt->open_fds[--i])
261 : : break;
262 : : }
263 : 12727 : i = (i + 1) * BITS_PER_LONG;
264 : 221 : return i;
265 : : }
266 : :
267 : : /*
268 : : * Allocate a new files structure and copy contents from the
269 : : * passed in files structure.
270 : : * errorp will be valid only when the returned files_struct is NULL.
271 : : */
272 : 12506 : struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
273 : : {
274 : 12506 : struct files_struct *newf;
275 : 12506 : struct file **old_fds, **new_fds;
276 : 12506 : unsigned int open_files, i;
277 : 12506 : struct fdtable *old_fdt, *new_fdt;
278 : :
279 : 12506 : *errorp = -ENOMEM;
280 : 12506 : newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
281 [ - + ]: 12506 : if (!newf)
282 : 0 : goto out;
283 : :
284 : 12506 : atomic_set(&newf->count, 1);
285 : :
286 : 12506 : spin_lock_init(&newf->file_lock);
287 : 12506 : newf->resize_in_progress = false;
288 : 12506 : init_waitqueue_head(&newf->resize_wait);
289 : 12506 : newf->next_fd = 0;
290 : 12506 : new_fdt = &newf->fdtab;
291 : 12506 : new_fdt->max_fds = NR_OPEN_DEFAULT;
292 : 12506 : new_fdt->close_on_exec = newf->close_on_exec_init;
293 : 12506 : new_fdt->open_fds = newf->open_fds_init;
294 : 12506 : new_fdt->full_fds_bits = newf->full_fds_bits_init;
295 : 12506 : new_fdt->fd = &newf->fd_array[0];
296 : :
297 : 12506 : spin_lock(&oldf->file_lock);
298 : 12506 : old_fdt = files_fdtable(oldf);
299 : 12506 : open_files = count_open_files(old_fdt);
300 : :
301 : : /*
302 : : * Check whether we need to allocate a larger fd array and fd set.
303 : : */
304 [ + + ]: 12727 : while (unlikely(open_files > new_fdt->max_fds)) {
305 : 221 : spin_unlock(&oldf->file_lock);
306 : :
307 [ - + ]: 221 : if (new_fdt != &newf->fdtab)
308 : 0 : __free_fdtable(new_fdt);
309 : :
310 : 221 : new_fdt = alloc_fdtable(open_files - 1);
311 [ - + ]: 221 : if (!new_fdt) {
312 : 0 : *errorp = -ENOMEM;
313 : 0 : goto out_release;
314 : : }
315 : :
316 : : /* beyond sysctl_nr_open; nothing to do */
317 [ - + ]: 221 : if (unlikely(new_fdt->max_fds < open_files)) {
318 : 0 : __free_fdtable(new_fdt);
319 : 0 : *errorp = -EMFILE;
320 : 0 : goto out_release;
321 : : }
322 : :
323 : : /*
324 : : * Reacquire the oldf lock and a pointer to its fd table
325 : : * who knows it may have a new bigger fd table. We need
326 : : * the latest pointer.
327 : : */
328 : 221 : spin_lock(&oldf->file_lock);
329 : 221 : old_fdt = files_fdtable(oldf);
330 : 221 : open_files = count_open_files(old_fdt);
331 : : }
332 : :
333 : 12506 : copy_fd_bitmaps(new_fdt, old_fdt, open_files);
334 : :
335 : 12506 : old_fds = old_fdt->fd;
336 : 12506 : new_fds = new_fdt->fd;
337 : :
338 [ + + ]: 855322 : for (i = open_files; i != 0; i--) {
339 : 842816 : struct file *f = *old_fds++;
340 [ + + ]: 842816 : if (f) {
341 : 112340 : get_file(f);
342 : : } else {
343 : : /*
344 : : * The fd may be claimed in the fd bitmap but not yet
345 : : * instantiated in the files array if a sibling thread
346 : : * is partway through open(). So make sure that this
347 : : * fd is available to the new process.
348 : : */
349 : 730476 : __clear_open_fd(open_files - i, new_fdt);
350 : : }
351 : 842816 : rcu_assign_pointer(*new_fds++, f);
352 : : }
353 : 12506 : spin_unlock(&oldf->file_lock);
354 : :
355 : : /* clear the remainder */
356 : 12506 : memset(new_fds, 0, (new_fdt->max_fds - open_files) * sizeof(struct file *));
357 : :
358 : 12506 : rcu_assign_pointer(newf->fdt, new_fdt);
359 : :
360 : 12506 : return newf;
361 : :
362 : 0 : out_release:
363 : 0 : kmem_cache_free(files_cachep, newf);
364 : : out:
365 : : return NULL;
366 : : }
367 : :
368 : 12207 : static struct fdtable *close_files(struct files_struct * files)
369 : : {
370 : : /*
371 : : * It is safe to dereference the fd table without RCU or
372 : : * ->file_lock because this is the last reference to the
373 : : * files structure.
374 : : */
375 : 12207 : struct fdtable *fdt = rcu_dereference_raw(files->fdt);
376 : 12207 : unsigned int i, j = 0;
377 : :
378 : 25077 : for (;;) {
379 : 25077 : unsigned long set;
380 : 25077 : i = j * BITS_PER_LONG;
381 [ + + ]: 25077 : if (i >= fdt->max_fds)
382 : : break;
383 : 12870 : set = fdt->open_fds[j++];
384 [ + + ]: 62465 : while (set) {
385 [ + + ]: 49595 : if (set & 1) {
386 : 28899 : struct file * file = xchg(&fdt->fd[i], NULL);
387 [ + - ]: 28899 : if (file) {
388 : 28899 : filp_close(file, files);
389 : 28899 : cond_resched();
390 : : }
391 : : }
392 : 49595 : i++;
393 : 49595 : set >>= 1;
394 : : }
395 : : }
396 : :
397 : 12207 : return fdt;
398 : : }
399 : :
400 : 9412 : struct files_struct *get_files_struct(struct task_struct *task)
401 : : {
402 : 9412 : struct files_struct *files;
403 : :
404 : 9412 : task_lock(task);
405 : 9412 : files = task->files;
406 [ + - ]: 9412 : if (files)
407 : 9412 : atomic_inc(&files->count);
408 : 9412 : task_unlock(task);
409 : :
410 : 9412 : return files;
411 : : }
412 : :
413 : 21944 : void put_files_struct(struct files_struct *files)
414 : : {
415 [ + + ]: 21944 : if (atomic_dec_and_test(&files->count)) {
416 : 12207 : struct fdtable *fdt = close_files(files);
417 : :
418 : : /* free the arrays if they are not embedded */
419 [ + + ]: 12207 : if (fdt != &files->fdtab)
420 : 221 : __free_fdtable(fdt);
421 : 12207 : kmem_cache_free(files_cachep, files);
422 : : }
423 : 21944 : }
424 : :
425 : 0 : void reset_files_struct(struct files_struct *files)
426 : : {
427 : 0 : struct task_struct *tsk = current;
428 : 0 : struct files_struct *old;
429 : :
430 : 0 : old = tsk->files;
431 : 0 : task_lock(tsk);
432 : 0 : tsk->files = files;
433 : 0 : task_unlock(tsk);
434 : 0 : put_files_struct(old);
435 : 0 : }
436 : :
437 : 12532 : void exit_files(struct task_struct *tsk)
438 : : {
439 : 12532 : struct files_struct * files = tsk->files;
440 : :
441 [ + - ]: 12532 : if (files) {
442 : 12532 : task_lock(tsk);
443 : 12532 : tsk->files = NULL;
444 : 12532 : task_unlock(tsk);
445 : 12532 : put_files_struct(files);
446 : : }
447 : 12532 : }
448 : :
449 : : struct files_struct init_files = {
450 : : .count = ATOMIC_INIT(1),
451 : : .fdt = &init_files.fdtab,
452 : : .fdtab = {
453 : : .max_fds = NR_OPEN_DEFAULT,
454 : : .fd = &init_files.fd_array[0],
455 : : .close_on_exec = init_files.close_on_exec_init,
456 : : .open_fds = init_files.open_fds_init,
457 : : .full_fds_bits = init_files.full_fds_bits_init,
458 : : },
459 : : .file_lock = __SPIN_LOCK_UNLOCKED(init_files.file_lock),
460 : : .resize_wait = __WAIT_QUEUE_HEAD_INITIALIZER(init_files.resize_wait),
461 : : };
462 : :
463 : 662763 : static unsigned int find_next_fd(struct fdtable *fdt, unsigned int start)
464 : : {
465 : 662763 : unsigned int maxfd = fdt->max_fds;
466 : 662763 : unsigned int maxbit = maxfd / BITS_PER_LONG;
467 : 662763 : unsigned int bitbit = start / BITS_PER_LONG;
468 : :
469 : 662763 : bitbit = find_next_zero_bit(fdt->full_fds_bits, maxbit, bitbit) * BITS_PER_LONG;
470 [ + - ]: 662763 : if (bitbit > maxfd)
471 : : return maxfd;
472 : 662763 : if (bitbit > start)
473 : : start = bitbit;
474 : 662763 : return find_next_zero_bit(fdt->open_fds, maxfd, start);
475 : : }
476 : :
477 : : /*
478 : : * allocate a file descriptor, mark it busy.
479 : : */
480 : 662763 : int __alloc_fd(struct files_struct *files,
481 : : unsigned start, unsigned end, unsigned flags)
482 : : {
483 : 662763 : unsigned int fd;
484 : 662763 : int error;
485 : 662763 : struct fdtable *fdt;
486 : :
487 : 662763 : spin_lock(&files->file_lock);
488 : 662763 : repeat:
489 [ + - ]: 662763 : fdt = files_fdtable(files);
490 : 662763 : fd = start;
491 : 662763 : if (fd < files->next_fd)
492 : : fd = files->next_fd;
493 : :
494 [ + - ]: 662763 : if (fd < fdt->max_fds)
495 : 662763 : fd = find_next_fd(fdt, fd);
496 : :
497 : : /*
498 : : * N.B. For clone tasks sharing a files structure, this test
499 : : * will limit the total number of files that can be opened.
500 : : */
501 : 662763 : error = -EMFILE;
502 [ - + ]: 662763 : if (fd >= end)
503 : 0 : goto out;
504 : :
505 : 662763 : error = expand_files(files, fd);
506 [ - + ]: 662763 : if (error < 0)
507 : 0 : goto out;
508 : :
509 : : /*
510 : : * If we needed to expand the fs array we
511 : : * might have blocked - try again.
512 : : */
513 [ - + ]: 662763 : if (error)
514 : 0 : goto repeat;
515 : :
516 [ + + ]: 662763 : if (start <= files->next_fd)
517 : 655041 : files->next_fd = fd + 1;
518 : :
519 : 662763 : __set_open_fd(fd, fdt);
520 [ + + ]: 662763 : if (flags & O_CLOEXEC)
521 : 637491 : __set_close_on_exec(fd, fdt);
522 : : else
523 : 25272 : __clear_close_on_exec(fd, fdt);
524 : 662763 : error = fd;
525 : : #if 1
526 : : /* Sanity check */
527 [ + - ]: 662763 : if (rcu_access_pointer(fdt->fd[fd]) != NULL) {
528 : 0 : printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);
529 : 0 : rcu_assign_pointer(fdt->fd[fd], NULL);
530 : : }
531 : : #endif
532 : :
533 : 662763 : out:
534 : 662763 : spin_unlock(&files->file_lock);
535 : 662763 : return error;
536 : : }
537 : :
538 : 17979 : static int alloc_fd(unsigned start, unsigned flags)
539 : : {
540 : 17979 : return __alloc_fd(current->files, start, rlimit(RLIMIT_NOFILE), flags);
541 : : }
542 : :
543 : 644784 : int __get_unused_fd_flags(unsigned flags, unsigned long nofile)
544 : : {
545 : 644784 : return __alloc_fd(current->files, 0, nofile, flags);
546 : : }
547 : :
548 : 644407 : int get_unused_fd_flags(unsigned flags)
549 : : {
550 : 644407 : return __get_unused_fd_flags(flags, rlimit(RLIMIT_NOFILE));
551 : : }
552 : : EXPORT_SYMBOL(get_unused_fd_flags);
553 : :
554 : 750117 : static void __put_unused_fd(struct files_struct *files, unsigned int fd)
555 : : {
556 : 750117 : struct fdtable *fdt = files_fdtable(files);
557 : 750117 : __clear_open_fd(fd, fdt);
558 [ - + - - : 750117 : if (fd < files->next_fd)
+ + + - ]
559 : 529190 : files->next_fd = fd;
560 : : }
561 : :
562 : 124434 : void put_unused_fd(unsigned int fd)
563 : : {
564 : 124434 : struct files_struct *files = current->files;
565 : 124434 : spin_lock(&files->file_lock);
566 : 124434 : __put_unused_fd(files, fd);
567 : 124434 : spin_unlock(&files->file_lock);
568 : 124434 : }
569 : :
570 : : EXPORT_SYMBOL(put_unused_fd);
571 : :
572 : : /*
573 : : * Install a file pointer in the fd array.
574 : : *
575 : : * The VFS is full of places where we drop the files lock between
576 : : * setting the open_fds bitmap and installing the file in the file
577 : : * array. At any such point, we are vulnerable to a dup2() race
578 : : * installing a file in the array before us. We need to detect this and
579 : : * fput() the struct file we are about to overwrite in this case.
580 : : *
581 : : * It should never happen - if we allow dup2() do it, _really_ bad things
582 : : * will follow.
583 : : *
584 : : * NOTE: __fd_install() variant is really, really low-level; don't
585 : : * use it unless you are forced to by truly lousy API shoved down
586 : : * your throat. 'files' *MUST* be either current->files or obtained
587 : : * by get_files_struct(current) done by whoever had given it to you,
588 : : * or really bad things will happen. Normally you want to use
589 : : * fd_install() instead.
590 : : */
591 : :
592 : 538316 : void __fd_install(struct files_struct *files, unsigned int fd,
593 : : struct file *file)
594 : : {
595 : 538316 : struct fdtable *fdt;
596 : :
597 : 538316 : rcu_read_lock_sched();
598 : :
599 [ - + ]: 538316 : if (unlikely(files->resize_in_progress)) {
600 : 0 : rcu_read_unlock_sched();
601 : 0 : spin_lock(&files->file_lock);
602 [ # # ]: 0 : fdt = files_fdtable(files);
603 [ # # ]: 0 : BUG_ON(fdt->fd[fd] != NULL);
604 : 0 : rcu_assign_pointer(fdt->fd[fd], file);
605 : 0 : spin_unlock(&files->file_lock);
606 : 0 : return;
607 : : }
608 : : /* coupled with smp_wmb() in expand_fdtable() */
609 : 538316 : smp_rmb();
610 [ - + ]: 538316 : fdt = rcu_dereference_sched(files->fdt);
611 [ - + ]: 538316 : BUG_ON(fdt->fd[fd] != NULL);
612 : 538316 : rcu_assign_pointer(fdt->fd[fd], file);
613 : 538316 : rcu_read_unlock_sched();
614 : : }
615 : :
616 : 538316 : void fd_install(unsigned int fd, struct file *file)
617 : : {
618 : 520311 : __fd_install(current->files, fd, file);
619 : 18005 : }
620 : :
621 : : EXPORT_SYMBOL(fd_install);
622 : :
623 : : /*
624 : : * The same warnings as for __alloc_fd()/__fd_install() apply here...
625 : : */
626 : 577739 : int __close_fd(struct files_struct *files, unsigned fd)
627 : : {
628 : 577739 : struct file *file;
629 : 577739 : struct fdtable *fdt;
630 : :
631 : 577739 : spin_lock(&files->file_lock);
632 [ - + ]: 577739 : fdt = files_fdtable(files);
633 [ - + ]: 577739 : if (fd >= fdt->max_fds)
634 : 0 : goto out_unlock;
635 : 577739 : file = fdt->fd[fd];
636 [ + + ]: 577739 : if (!file)
637 : 91 : goto out_unlock;
638 : 577648 : rcu_assign_pointer(fdt->fd[fd], NULL);
639 : 577648 : __put_unused_fd(files, fd);
640 : 577648 : spin_unlock(&files->file_lock);
641 : 577648 : return filp_close(file, files);
642 : :
643 : 91 : out_unlock:
644 : 91 : spin_unlock(&files->file_lock);
645 : 91 : return -EBADF;
646 : : }
647 : : EXPORT_SYMBOL(__close_fd); /* for ksys_close() */
648 : :
649 : : /*
650 : : * variant of __close_fd that gets a ref on the file for later fput.
651 : : * The caller must ensure that filp_close() called on the file, and then
652 : : * an fput().
653 : : */
654 : 0 : int __close_fd_get_file(unsigned int fd, struct file **res)
655 : : {
656 : 0 : struct files_struct *files = current->files;
657 : 0 : struct file *file;
658 : 0 : struct fdtable *fdt;
659 : :
660 : 0 : spin_lock(&files->file_lock);
661 [ # # ]: 0 : fdt = files_fdtable(files);
662 [ # # ]: 0 : if (fd >= fdt->max_fds)
663 : 0 : goto out_unlock;
664 : 0 : file = fdt->fd[fd];
665 [ # # ]: 0 : if (!file)
666 : 0 : goto out_unlock;
667 : 0 : rcu_assign_pointer(fdt->fd[fd], NULL);
668 : 0 : __put_unused_fd(files, fd);
669 : 0 : spin_unlock(&files->file_lock);
670 : 0 : get_file(file);
671 : 0 : *res = file;
672 : 0 : return 0;
673 : :
674 : 0 : out_unlock:
675 : 0 : spin_unlock(&files->file_lock);
676 : 0 : *res = NULL;
677 : 0 : return -ENOENT;
678 : : }
679 : :
680 : 12012 : void do_close_on_exec(struct files_struct *files)
681 : : {
682 : 12012 : unsigned i;
683 : 12012 : struct fdtable *fdt;
684 : :
685 : : /* exec unshares first */
686 : 12012 : spin_lock(&files->file_lock);
687 : 24687 : for (i = 0; ; i++) {
688 : 24687 : unsigned long set;
689 : 24687 : unsigned fd = i * BITS_PER_LONG;
690 [ + + ]: 24687 : fdt = files_fdtable(files);
691 [ + + ]: 24687 : if (fd >= fdt->max_fds)
692 : : break;
693 : 12675 : set = fdt->close_on_exec[i];
694 [ + + ]: 12675 : if (!set)
695 : 806 : continue;
696 : 11869 : fdt->close_on_exec[i] = 0;
697 [ + + ]: 182179 : for ( ; set ; fd++, set >>= 1) {
698 : 170310 : struct file *file;
699 [ + + ]: 170310 : if (!(set & 1))
700 : 82953 : continue;
701 : 87357 : file = fdt->fd[fd];
702 [ + + ]: 87357 : if (!file)
703 : 39322 : continue;
704 : 48035 : rcu_assign_pointer(fdt->fd[fd], NULL);
705 : 48035 : __put_unused_fd(files, fd);
706 : 48035 : spin_unlock(&files->file_lock);
707 : 48035 : filp_close(file, files);
708 : 48035 : cond_resched();
709 : 48035 : spin_lock(&files->file_lock);
710 : : }
711 : :
712 : : }
713 : 12012 : spin_unlock(&files->file_lock);
714 : 12012 : }
715 : :
716 : 260196 : static struct file *__fget_files(struct files_struct *files, unsigned int fd,
717 : : fmode_t mask, unsigned int refs)
718 : : {
719 : 260196 : struct file *file;
720 : :
721 : 260196 : rcu_read_lock();
722 : 260196 : loop:
723 [ + - ]: 260196 : file = fcheck_files(files, fd);
724 [ + - ]: 260196 : if (file) {
725 : : /* File object ref couldn't be taken.
726 : : * dup2() atomicity guarantee is the reason
727 : : * we loop to catch the new file (or NULL pointer)
728 : : */
729 [ + - ]: 260196 : if (file->f_mode & mask)
730 : : file = NULL;
731 [ - + ]: 260196 : else if (!get_file_rcu_many(file, refs))
732 : 0 : goto loop;
733 : : }
734 : 260196 : rcu_read_unlock();
735 : :
736 : 260196 : return file;
737 : : }
738 : :
739 : 260196 : static inline struct file *__fget(unsigned int fd, fmode_t mask,
740 : : unsigned int refs)
741 : : {
742 : 260196 : return __fget_files(current->files, fd, mask, refs);
743 : : }
744 : :
745 : 0 : struct file *fget_many(unsigned int fd, unsigned int refs)
746 : : {
747 : 0 : return __fget(fd, FMODE_PATH, refs);
748 : : }
749 : :
750 : 250510 : struct file *fget(unsigned int fd)
751 : : {
752 : 250510 : return __fget(fd, FMODE_PATH, 1);
753 : : }
754 : : EXPORT_SYMBOL(fget);
755 : :
756 : 364 : struct file *fget_raw(unsigned int fd)
757 : : {
758 : 338 : return __fget(fd, 0, 1);
759 : : }
760 : : EXPORT_SYMBOL(fget_raw);
761 : :
762 : 0 : struct file *fget_task(struct task_struct *task, unsigned int fd)
763 : : {
764 : 0 : struct file *file = NULL;
765 : :
766 : 0 : task_lock(task);
767 [ # # ]: 0 : if (task->files)
768 : 0 : file = __fget_files(task->files, fd, 0, 1);
769 : 0 : task_unlock(task);
770 : :
771 : 0 : return file;
772 : : }
773 : :
774 : : /*
775 : : * Lightweight file lookup - no refcnt increment if fd table isn't shared.
776 : : *
777 : : * You can use this instead of fget if you satisfy all of the following
778 : : * conditions:
779 : : * 1) You must call fput_light before exiting the syscall and returning control
780 : : * to userspace (i.e. you cannot remember the returned struct file * after
781 : : * returning to userspace).
782 : : * 2) You must not call filp_close on the returned struct file * in between
783 : : * calls to fget_light and fput_light.
784 : : * 3) You must not clone the current task in between the calls to fget_light
785 : : * and fput_light.
786 : : *
787 : : * The fput_needed flag returned by fget_light should be passed to the
788 : : * corresponding fput_light.
789 : : */
790 : 1243721 : static unsigned long __fget_light(unsigned int fd, fmode_t mask)
791 : : {
792 : 1243721 : struct files_struct *files = current->files;
793 : 1243721 : struct file *file;
794 : :
795 [ + + ]: 1243721 : if (atomic_read(&files->count) == 1) {
796 [ + + ]: 1234399 : file = __fcheck_files(files, fd);
797 [ + + + - ]: 1234282 : if (!file || unlikely(file->f_mode & mask))
798 : : return 0;
799 : 1234269 : return (unsigned long)file;
800 : : } else {
801 : 9322 : file = __fget(fd, mask, 1);
802 [ + - ]: 9322 : if (!file)
803 : : return 0;
804 : 9322 : return FDPUT_FPUT | (unsigned long)file;
805 : : }
806 : : }
807 : 433805 : unsigned long __fdget(unsigned int fd)
808 : : {
809 : 195391 : return __fget_light(fd, FMODE_PATH);
810 : : }
811 : : EXPORT_SYMBOL(__fdget);
812 : :
813 : 809916 : unsigned long __fdget_raw(unsigned int fd)
814 : : {
815 : 809916 : return __fget_light(fd, 0);
816 : : }
817 : :
818 : 238414 : unsigned long __fdget_pos(unsigned int fd)
819 : : {
820 : 238414 : unsigned long v = __fdget(fd);
821 : 238414 : struct file *file = (struct file *)(v & ~3);
822 : :
823 [ + - + + ]: 238414 : if (file && (file->f_mode & FMODE_ATOMIC_POS)) {
824 [ + + ]: 137453 : if (file_count(file) > 1) {
825 : 22841 : v |= FDPUT_POS_UNLOCK;
826 : 22841 : mutex_lock(&file->f_pos_lock);
827 : : }
828 : : }
829 : 238414 : return v;
830 : : }
831 : :
832 : 22828 : void __f_unlock_pos(struct file *f)
833 : : {
834 : 22828 : mutex_unlock(&f->f_pos_lock);
835 : 22828 : }
836 : :
837 : : /*
838 : : * We only lock f_pos if we have threads or if the file might be
839 : : * shared with another process. In both cases we'll have an elevated
840 : : * file count (done either by fdget() or by fork()).
841 : : */
842 : :
843 : 12181 : void set_close_on_exec(unsigned int fd, int flag)
844 : : {
845 : 12181 : struct files_struct *files = current->files;
846 : 12181 : struct fdtable *fdt;
847 : 12181 : spin_lock(&files->file_lock);
848 [ + - ]: 12181 : fdt = files_fdtable(files);
849 [ + - ]: 12181 : if (flag)
850 : 12181 : __set_close_on_exec(fd, fdt);
851 : : else
852 : 0 : __clear_close_on_exec(fd, fdt);
853 : 12181 : spin_unlock(&files->file_lock);
854 : 12181 : }
855 : :
856 : 351 : bool get_close_on_exec(unsigned int fd)
857 : : {
858 : 351 : struct files_struct *files = current->files;
859 : 351 : struct fdtable *fdt;
860 : 351 : bool res;
861 : 351 : rcu_read_lock();
862 : 351 : fdt = files_fdtable(files);
863 : 351 : res = close_on_exec(fd, fdt);
864 : 351 : rcu_read_unlock();
865 : 351 : return res;
866 : : }
867 : :
868 : 17004 : static int do_dup2(struct files_struct *files,
869 : : struct file *file, unsigned fd, unsigned flags)
870 : : __releases(&files->file_lock)
871 : : {
872 : 17004 : struct file *tofree;
873 : 17004 : struct fdtable *fdt;
874 : :
875 : : /*
876 : : * We need to detect attempts to do dup2() over allocated but still
877 : : * not finished descriptor. NB: OpenBSD avoids that at the price of
878 : : * extra work in their equivalent of fget() - they insert struct
879 : : * file immediately after grabbing descriptor, mark it larval if
880 : : * more work (e.g. actual opening) is needed and make sure that
881 : : * fget() treats larval files as absent. Potentially interesting,
882 : : * but while extra work in fget() is trivial, locking implications
883 : : * and amount of surgery on open()-related paths in VFS are not.
884 : : * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
885 : : * deadlocks in rather amusing ways, AFAICS. All of that is out of
886 : : * scope of POSIX or SUS, since neither considers shared descriptor
887 : : * tables and this condition does not arise without those.
888 : : */
889 [ + + ]: 17004 : fdt = files_fdtable(files);
890 : 17004 : tofree = fdt->fd[fd];
891 [ + + - + ]: 17004 : if (!tofree && fd_is_open(fd, fdt))
892 : 0 : goto Ebusy;
893 : 17004 : get_file(file);
894 : 17004 : rcu_assign_pointer(fdt->fd[fd], file);
895 : 17004 : __set_open_fd(fd, fdt);
896 [ - + ]: 17004 : if (flags & O_CLOEXEC)
897 : 0 : __set_close_on_exec(fd, fdt);
898 : : else
899 : 17004 : __clear_close_on_exec(fd, fdt);
900 : 17004 : spin_unlock(&files->file_lock);
901 : :
902 [ + + ]: 17004 : if (tofree)
903 : 9282 : filp_close(tofree, files);
904 : :
905 : 17004 : return fd;
906 : :
907 : : Ebusy:
908 : 0 : spin_unlock(&files->file_lock);
909 : 0 : return -EBUSY;
910 : : }
911 : :
912 : 0 : int replace_fd(unsigned fd, struct file *file, unsigned flags)
913 : : {
914 : 0 : int err;
915 [ # # ]: 0 : struct files_struct *files = current->files;
916 : :
917 [ # # ]: 0 : if (!file)
918 : 0 : return __close_fd(files, fd);
919 : :
920 [ # # ]: 0 : if (fd >= rlimit(RLIMIT_NOFILE))
921 : : return -EBADF;
922 : :
923 : 0 : spin_lock(&files->file_lock);
924 : 0 : err = expand_files(files, fd);
925 [ # # ]: 0 : if (unlikely(err < 0))
926 : 0 : goto out_unlock;
927 : 0 : return do_dup2(files, file, fd, flags);
928 : :
929 : : out_unlock:
930 : 0 : spin_unlock(&files->file_lock);
931 : 0 : return err;
932 : : }
933 : :
934 : 17004 : static int ksys_dup3(unsigned int oldfd, unsigned int newfd, int flags)
935 : : {
936 : 17004 : int err = -EBADF;
937 : 17004 : struct file *file;
938 [ + - ]: 17004 : struct files_struct *files = current->files;
939 : :
940 [ + - ]: 17004 : if ((flags & ~O_CLOEXEC) != 0)
941 : : return -EINVAL;
942 : :
943 [ + - ]: 17004 : if (unlikely(oldfd == newfd))
944 : : return -EINVAL;
945 : :
946 [ + - ]: 17004 : if (newfd >= rlimit(RLIMIT_NOFILE))
947 : : return -EBADF;
948 : :
949 : 17004 : spin_lock(&files->file_lock);
950 : 17004 : err = expand_files(files, newfd);
951 [ + - ]: 17004 : file = fcheck(oldfd);
952 [ - + ]: 17004 : if (unlikely(!file))
953 : 0 : goto Ebadf;
954 [ - + ]: 17004 : if (unlikely(err < 0)) {
955 [ # # ]: 0 : if (err == -EMFILE)
956 : 0 : goto Ebadf;
957 : 0 : goto out_unlock;
958 : : }
959 : 17004 : return do_dup2(files, file, newfd, flags);
960 : :
961 : 0 : Ebadf:
962 : : err = -EBADF;
963 : 0 : out_unlock:
964 : 0 : spin_unlock(&files->file_lock);
965 : 0 : return err;
966 : : }
967 : :
968 : 1456 : SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
969 : : {
970 : 728 : return ksys_dup3(oldfd, newfd, flags);
971 : : }
972 : :
973 : 32552 : SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
974 : : {
975 [ - + ]: 16276 : if (unlikely(newfd == oldfd)) { /* corner case */
976 : 0 : struct files_struct *files = current->files;
977 : 0 : int retval = oldfd;
978 : :
979 : 0 : rcu_read_lock();
980 [ # # # # ]: 0 : if (!fcheck_files(files, oldfd))
981 : 0 : retval = -EBADF;
982 : 0 : rcu_read_unlock();
983 : 0 : return retval;
984 : : }
985 : 16276 : return ksys_dup3(oldfd, newfd, 0);
986 : : }
987 : :
988 : 26 : int ksys_dup(unsigned int fildes)
989 : : {
990 : 26 : int ret = -EBADF;
991 : 26 : struct file *file = fget_raw(fildes);
992 : :
993 [ + - ]: 26 : if (file) {
994 : 26 : ret = get_unused_fd_flags(0);
995 [ + - ]: 26 : if (ret >= 0)
996 : 26 : fd_install(ret, file);
997 : : else
998 : 0 : fput(file);
999 : : }
1000 : 26 : return ret;
1001 : : }
1002 : :
1003 : 0 : SYSCALL_DEFINE1(dup, unsigned int, fildes)
1004 : : {
1005 : 0 : return ksys_dup(fildes);
1006 : : }
1007 : :
1008 : 17979 : int f_dupfd(unsigned int from, struct file *file, unsigned flags)
1009 : : {
1010 : 17979 : int err;
1011 [ + - ]: 17979 : if (from >= rlimit(RLIMIT_NOFILE))
1012 : : return -EINVAL;
1013 : 17979 : err = alloc_fd(from, flags);
1014 [ + - ]: 17979 : if (err >= 0) {
1015 : 17979 : get_file(file);
1016 : 17979 : fd_install(err, file);
1017 : : }
1018 : : return err;
1019 : : }
1020 : :
1021 : 0 : int iterate_fd(struct files_struct *files, unsigned n,
1022 : : int (*f)(const void *, struct file *, unsigned),
1023 : : const void *p)
1024 : : {
1025 : 0 : struct fdtable *fdt;
1026 : 0 : int res = 0;
1027 [ # # ]: 0 : if (!files)
1028 : : return 0;
1029 : 0 : spin_lock(&files->file_lock);
1030 [ # # ]: 0 : for (fdt = files_fdtable(files); n < fdt->max_fds; n++) {
1031 : 0 : struct file *file;
1032 [ # # ]: 0 : file = rcu_dereference_check_fdtable(files, fdt->fd[n]);
1033 [ # # ]: 0 : if (!file)
1034 : 0 : continue;
1035 : 0 : res = f(p, file, n);
1036 [ # # ]: 0 : if (res)
1037 : : break;
1038 : : }
1039 : 0 : spin_unlock(&files->file_lock);
1040 : 0 : return res;
1041 : : }
1042 : : EXPORT_SYMBOL(iterate_fd);
|
