1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 1998-1999, Stephen Tweedie and Bill Hawes
7 * Manage the dynamic fd arrays in the process files_struct.
10 #include <linux/syscalls.h>
11 #include <linux/export.h>
14 #include <linux/mmzone.h>
15 #include <linux/time.h>
16 #include <linux/sched/signal.h>
17 #include <linux/slab.h>
18 #include <linux/vmalloc.h>
19 #include <linux/file.h>
20 #include <linux/fdtable.h>
21 #include <linux/bitops.h>
22 #include <linux/interrupt.h>
23 #include <linux/spinlock.h>
24 #include <linux/rcupdate.h>
25 #include <linux/workqueue.h>
27 unsigned int sysctl_nr_open __read_mostly = 1024*1024;
28 unsigned int sysctl_nr_open_min = BITS_PER_LONG;
29 /* our min() is unusable in constant expressions ;-/ */
30 #define __const_min(x, y) ((x) < (y) ? (x) : (y))
31 unsigned int sysctl_nr_open_max =
32 __const_min(INT_MAX, ~(size_t)0/sizeof(void *)) & -BITS_PER_LONG;
34 static void __free_fdtable(struct fdtable *fdt)
37 kvfree(fdt->open_fds);
41 static void free_fdtable_rcu(struct rcu_head *rcu)
43 __free_fdtable(container_of(rcu, struct fdtable, rcu));
46 #define BITBIT_NR(nr) BITS_TO_LONGS(BITS_TO_LONGS(nr))
47 #define BITBIT_SIZE(nr) (BITBIT_NR(nr) * sizeof(long))
50 * Copy 'count' fd bits from the old table to the new table and clear the extra
51 * space if any. This does not copy the file pointers. Called with the files
52 * spinlock held for write.
54 static void copy_fd_bitmaps(struct fdtable *nfdt, struct fdtable *ofdt,
57 unsigned int cpy, set;
59 cpy = count / BITS_PER_BYTE;
60 set = (nfdt->max_fds - count) / BITS_PER_BYTE;
61 memcpy(nfdt->open_fds, ofdt->open_fds, cpy);
62 memset((char *)nfdt->open_fds + cpy, 0, set);
63 memcpy(nfdt->close_on_exec, ofdt->close_on_exec, cpy);
64 memset((char *)nfdt->close_on_exec + cpy, 0, set);
66 cpy = BITBIT_SIZE(count);
67 set = BITBIT_SIZE(nfdt->max_fds) - cpy;
68 memcpy(nfdt->full_fds_bits, ofdt->full_fds_bits, cpy);
69 memset((char *)nfdt->full_fds_bits + cpy, 0, set);
73 * Copy all file descriptors from the old table to the new, expanded table and
74 * clear the extra space. Called with the files spinlock held for write.
76 static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
80 BUG_ON(nfdt->max_fds < ofdt->max_fds);
82 cpy = ofdt->max_fds * sizeof(struct file *);
83 set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *);
84 memcpy(nfdt->fd, ofdt->fd, cpy);
85 memset((char *)nfdt->fd + cpy, 0, set);
87 copy_fd_bitmaps(nfdt, ofdt, ofdt->max_fds);
90 static struct fdtable * alloc_fdtable(unsigned int nr)
96 * Figure out how many fds we actually want to support in this fdtable.
97 * Allocation steps are keyed to the size of the fdarray, since it
98 * grows far faster than any of the other dynamic data. We try to fit
99 * the fdarray into comfortable page-tuned chunks: starting at 1024B
100 * and growing in powers of two from there on.
102 nr /= (1024 / sizeof(struct file *));
103 nr = roundup_pow_of_two(nr + 1);
104 nr *= (1024 / sizeof(struct file *));
106 * Note that this can drive nr *below* what we had passed if sysctl_nr_open
107 * had been set lower between the check in expand_files() and here. Deal
108 * with that in caller, it's cheaper that way.
110 * We make sure that nr remains a multiple of BITS_PER_LONG - otherwise
111 * bitmaps handling below becomes unpleasant, to put it mildly...
113 if (unlikely(nr > sysctl_nr_open))
114 nr = ((sysctl_nr_open - 1) | (BITS_PER_LONG - 1)) + 1;
116 fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL_ACCOUNT);
120 data = kvmalloc_array(nr, sizeof(struct file *), GFP_KERNEL_ACCOUNT);
125 data = kvmalloc(max_t(size_t,
126 2 * nr / BITS_PER_BYTE + BITBIT_SIZE(nr), L1_CACHE_BYTES),
130 fdt->open_fds = data;
131 data += nr / BITS_PER_BYTE;
132 fdt->close_on_exec = data;
133 data += nr / BITS_PER_BYTE;
134 fdt->full_fds_bits = data;
147 * Expand the file descriptor table.
148 * This function will allocate a new fdtable and both fd array and fdset, of
150 * Return <0 error code on error; 1 on successful completion.
151 * The files->file_lock should be held on entry, and will be held on exit.
153 static int expand_fdtable(struct files_struct *files, unsigned int nr)
154 __releases(files->file_lock)
155 __acquires(files->file_lock)
157 struct fdtable *new_fdt, *cur_fdt;
159 spin_unlock(&files->file_lock);
160 new_fdt = alloc_fdtable(nr);
162 /* make sure all __fd_install() have seen resize_in_progress
163 * or have finished their rcu_read_lock_sched() section.
165 if (atomic_read(&files->count) > 1)
168 spin_lock(&files->file_lock);
172 * extremely unlikely race - sysctl_nr_open decreased between the check in
173 * caller and alloc_fdtable(). Cheaper to catch it here...
175 if (unlikely(new_fdt->max_fds <= nr)) {
176 __free_fdtable(new_fdt);
179 cur_fdt = files_fdtable(files);
180 BUG_ON(nr < cur_fdt->max_fds);
181 copy_fdtable(new_fdt, cur_fdt);
182 rcu_assign_pointer(files->fdt, new_fdt);
183 if (cur_fdt != &files->fdtab)
184 call_rcu(&cur_fdt->rcu, free_fdtable_rcu);
185 /* coupled with smp_rmb() in __fd_install() */
192 * This function will expand the file structures, if the requested size exceeds
193 * the current capacity and there is room for expansion.
194 * Return <0 error code on error; 0 when nothing done; 1 when files were
195 * expanded and execution may have blocked.
196 * The files->file_lock should be held on entry, and will be held on exit.
198 static int expand_files(struct files_struct *files, unsigned int nr)
199 __releases(files->file_lock)
200 __acquires(files->file_lock)
206 fdt = files_fdtable(files);
208 /* Do we need to expand? */
209 if (nr < fdt->max_fds)
213 if (nr >= sysctl_nr_open)
216 if (unlikely(files->resize_in_progress)) {
217 spin_unlock(&files->file_lock);
219 wait_event(files->resize_wait, !files->resize_in_progress);
220 spin_lock(&files->file_lock);
224 /* All good, so we try */
225 files->resize_in_progress = true;
226 expanded = expand_fdtable(files, nr);
227 files->resize_in_progress = false;
229 wake_up_all(&files->resize_wait);
233 static inline void __set_close_on_exec(unsigned int fd, struct fdtable *fdt)
235 __set_bit(fd, fdt->close_on_exec);
238 static inline void __clear_close_on_exec(unsigned int fd, struct fdtable *fdt)
240 if (test_bit(fd, fdt->close_on_exec))
241 __clear_bit(fd, fdt->close_on_exec);
244 static inline void __set_open_fd(unsigned int fd, struct fdtable *fdt)
246 __set_bit(fd, fdt->open_fds);
248 if (!~fdt->open_fds[fd])
249 __set_bit(fd, fdt->full_fds_bits);
252 static inline void __clear_open_fd(unsigned int fd, struct fdtable *fdt)
254 __clear_bit(fd, fdt->open_fds);
255 __clear_bit(fd / BITS_PER_LONG, fdt->full_fds_bits);
258 static unsigned int count_open_files(struct fdtable *fdt)
260 unsigned int size = fdt->max_fds;
263 /* Find the last open fd */
264 for (i = size / BITS_PER_LONG; i > 0; ) {
265 if (fdt->open_fds[--i])
268 i = (i + 1) * BITS_PER_LONG;
273 * Allocate a new files structure and copy contents from the
274 * passed in files structure.
275 * errorp will be valid only when the returned files_struct is NULL.
277 struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
279 struct files_struct *newf;
280 struct file **old_fds, **new_fds;
281 unsigned int open_files, i;
282 struct fdtable *old_fdt, *new_fdt;
285 newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
289 atomic_set(&newf->count, 1);
291 spin_lock_init(&newf->file_lock);
292 newf->resize_in_progress = false;
293 init_waitqueue_head(&newf->resize_wait);
295 new_fdt = &newf->fdtab;
296 new_fdt->max_fds = NR_OPEN_DEFAULT;
297 new_fdt->close_on_exec = newf->close_on_exec_init;
298 new_fdt->open_fds = newf->open_fds_init;
299 new_fdt->full_fds_bits = newf->full_fds_bits_init;
300 new_fdt->fd = &newf->fd_array[0];
302 spin_lock(&oldf->file_lock);
303 old_fdt = files_fdtable(oldf);
304 open_files = count_open_files(old_fdt);
307 * Check whether we need to allocate a larger fd array and fd set.
309 while (unlikely(open_files > new_fdt->max_fds)) {
310 spin_unlock(&oldf->file_lock);
312 if (new_fdt != &newf->fdtab)
313 __free_fdtable(new_fdt);
315 new_fdt = alloc_fdtable(open_files - 1);
321 /* beyond sysctl_nr_open; nothing to do */
322 if (unlikely(new_fdt->max_fds < open_files)) {
323 __free_fdtable(new_fdt);
329 * Reacquire the oldf lock and a pointer to its fd table
330 * who knows it may have a new bigger fd table. We need
331 * the latest pointer.
333 spin_lock(&oldf->file_lock);
334 old_fdt = files_fdtable(oldf);
335 open_files = count_open_files(old_fdt);
338 copy_fd_bitmaps(new_fdt, old_fdt, open_files);
340 old_fds = old_fdt->fd;
341 new_fds = new_fdt->fd;
343 for (i = open_files; i != 0; i--) {
344 struct file *f = *old_fds++;
349 * The fd may be claimed in the fd bitmap but not yet
350 * instantiated in the files array if a sibling thread
351 * is partway through open(). So make sure that this
352 * fd is available to the new process.
354 __clear_open_fd(open_files - i, new_fdt);
356 rcu_assign_pointer(*new_fds++, f);
358 spin_unlock(&oldf->file_lock);
360 /* clear the remainder */
361 memset(new_fds, 0, (new_fdt->max_fds - open_files) * sizeof(struct file *));
363 rcu_assign_pointer(newf->fdt, new_fdt);
368 kmem_cache_free(files_cachep, newf);
373 static struct fdtable *close_files(struct files_struct * files)
376 * It is safe to dereference the fd table without RCU or
377 * ->file_lock because this is the last reference to the
380 struct fdtable *fdt = rcu_dereference_raw(files->fdt);
381 unsigned int i, j = 0;
385 i = j * BITS_PER_LONG;
386 if (i >= fdt->max_fds)
388 set = fdt->open_fds[j++];
391 struct file * file = xchg(&fdt->fd[i], NULL);
393 filp_close(file, files);
394 cond_resched_rcu_qs();
405 struct files_struct *get_files_struct(struct task_struct *task)
407 struct files_struct *files;
412 atomic_inc(&files->count);
418 void put_files_struct(struct files_struct *files)
420 if (atomic_dec_and_test(&files->count)) {
421 struct fdtable *fdt = close_files(files);
423 /* free the arrays if they are not embedded */
424 if (fdt != &files->fdtab)
426 kmem_cache_free(files_cachep, files);
430 void reset_files_struct(struct files_struct *files)
432 struct task_struct *tsk = current;
433 struct files_struct *old;
439 put_files_struct(old);
442 void exit_files(struct task_struct *tsk)
444 struct files_struct * files = tsk->files;
450 put_files_struct(files);
454 struct files_struct init_files = {
455 .count = ATOMIC_INIT(1),
456 .fdt = &init_files.fdtab,
458 .max_fds = NR_OPEN_DEFAULT,
459 .fd = &init_files.fd_array[0],
460 .close_on_exec = init_files.close_on_exec_init,
461 .open_fds = init_files.open_fds_init,
462 .full_fds_bits = init_files.full_fds_bits_init,
464 .file_lock = __SPIN_LOCK_UNLOCKED(init_files.file_lock),
465 .resize_wait = __WAIT_QUEUE_HEAD_INITIALIZER(init_files.resize_wait),
468 static unsigned int find_next_fd(struct fdtable *fdt, unsigned int start)
470 unsigned int maxfd = fdt->max_fds;
471 unsigned int maxbit = maxfd / BITS_PER_LONG;
472 unsigned int bitbit = start / BITS_PER_LONG;
474 bitbit = find_next_zero_bit(fdt->full_fds_bits, maxbit, bitbit) * BITS_PER_LONG;
479 return find_next_zero_bit(fdt->open_fds, maxfd, start);
483 * allocate a file descriptor, mark it busy.
485 int __alloc_fd(struct files_struct *files,
486 unsigned start, unsigned end, unsigned flags)
492 spin_lock(&files->file_lock);
494 fdt = files_fdtable(files);
496 if (fd < files->next_fd)
499 if (fd < fdt->max_fds)
500 fd = find_next_fd(fdt, fd);
503 * N.B. For clone tasks sharing a files structure, this test
504 * will limit the total number of files that can be opened.
510 error = expand_files(files, fd);
515 * If we needed to expand the fs array we
516 * might have blocked - try again.
521 if (start <= files->next_fd)
522 files->next_fd = fd + 1;
524 __set_open_fd(fd, fdt);
525 if (flags & O_CLOEXEC)
526 __set_close_on_exec(fd, fdt);
528 __clear_close_on_exec(fd, fdt);
532 if (rcu_access_pointer(fdt->fd[fd]) != NULL) {
533 printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);
534 rcu_assign_pointer(fdt->fd[fd], NULL);
539 spin_unlock(&files->file_lock);
543 static int alloc_fd(unsigned start, unsigned flags)
545 return __alloc_fd(current->files, start, rlimit(RLIMIT_NOFILE), flags);
548 int get_unused_fd_flags(unsigned flags)
550 return __alloc_fd(current->files, 0, rlimit(RLIMIT_NOFILE), flags);
552 EXPORT_SYMBOL(get_unused_fd_flags);
554 static void __put_unused_fd(struct files_struct *files, unsigned int fd)
556 struct fdtable *fdt = files_fdtable(files);
557 __clear_open_fd(fd, fdt);
558 if (fd < files->next_fd)
562 void put_unused_fd(unsigned int fd)
564 struct files_struct *files = current->files;
565 spin_lock(&files->file_lock);
566 __put_unused_fd(files, fd);
567 spin_unlock(&files->file_lock);
570 EXPORT_SYMBOL(put_unused_fd);
573 * Install a file pointer in the fd array.
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.
581 * It should never happen - if we allow dup2() do it, _really_ bad things
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.
592 void __fd_install(struct files_struct *files, unsigned int fd,
598 rcu_read_lock_sched();
600 while (unlikely(files->resize_in_progress)) {
601 rcu_read_unlock_sched();
602 wait_event(files->resize_wait, !files->resize_in_progress);
603 rcu_read_lock_sched();
605 /* coupled with smp_wmb() in expand_fdtable() */
607 fdt = rcu_dereference_sched(files->fdt);
608 BUG_ON(fdt->fd[fd] != NULL);
609 rcu_assign_pointer(fdt->fd[fd], file);
610 rcu_read_unlock_sched();
613 void fd_install(unsigned int fd, struct file *file)
615 __fd_install(current->files, fd, file);
618 EXPORT_SYMBOL(fd_install);
621 * The same warnings as for __alloc_fd()/__fd_install() apply here...
623 int __close_fd(struct files_struct *files, unsigned fd)
628 spin_lock(&files->file_lock);
629 fdt = files_fdtable(files);
630 if (fd >= fdt->max_fds)
632 fd = array_index_nospec(fd, fdt->max_fds);
636 rcu_assign_pointer(fdt->fd[fd], NULL);
637 __clear_close_on_exec(fd, fdt);
638 __put_unused_fd(files, fd);
639 spin_unlock(&files->file_lock);
640 return filp_close(file, files);
643 spin_unlock(&files->file_lock);
647 void do_close_on_exec(struct files_struct *files)
652 /* exec unshares first */
653 spin_lock(&files->file_lock);
656 unsigned fd = i * BITS_PER_LONG;
657 fdt = files_fdtable(files);
658 if (fd >= fdt->max_fds)
660 set = fdt->close_on_exec[i];
663 fdt->close_on_exec[i] = 0;
664 for ( ; set ; fd++, set >>= 1) {
671 rcu_assign_pointer(fdt->fd[fd], NULL);
672 __put_unused_fd(files, fd);
673 spin_unlock(&files->file_lock);
674 filp_close(file, files);
676 spin_lock(&files->file_lock);
680 spin_unlock(&files->file_lock);
683 static inline struct file *__fget_files_rcu(struct files_struct *files,
684 unsigned int fd, fmode_t mask, unsigned int refs)
688 struct fdtable *fdt = rcu_dereference_raw(files->fdt);
689 struct file __rcu **fdentry;
691 if (unlikely(fd >= fdt->max_fds))
694 fdentry = fdt->fd + array_index_nospec(fd, fdt->max_fds);
695 file = rcu_dereference_raw(*fdentry);
699 if (unlikely(file->f_mode & mask))
703 * Ok, we have a file pointer. However, because we do
704 * this all locklessly under RCU, we may be racing with
705 * that file being closed.
707 * Such a race can take two forms:
709 * (a) the file ref already went down to zero,
710 * and get_file_rcu_many() fails. Just try
713 if (unlikely(!get_file_rcu_many(file, refs)))
717 * (b) the file table entry has changed under us.
718 * Note that we don't need to re-check the 'fdt->fd'
719 * pointer having changed, because it always goes
720 * hand-in-hand with 'fdt'.
722 * If so, we need to put our refs and try again.
724 if (unlikely(rcu_dereference_raw(files->fdt) != fdt) ||
725 unlikely(rcu_dereference_raw(*fdentry) != file)) {
726 fput_many(file, refs);
731 * Ok, we have a ref to the file, and checked that it
739 static struct file *__fget(unsigned int fd, fmode_t mask, unsigned int refs)
741 struct files_struct *files = current->files;
745 file = __fget_files_rcu(files, fd, mask, refs);
751 struct file *fget_many(unsigned int fd, unsigned int refs)
753 return __fget(fd, FMODE_PATH, refs);
756 struct file *fget(unsigned int fd)
758 return __fget(fd, FMODE_PATH, 1);
762 struct file *fget_raw(unsigned int fd)
764 return __fget(fd, 0, 1);
766 EXPORT_SYMBOL(fget_raw);
769 * Lightweight file lookup - no refcnt increment if fd table isn't shared.
771 * You can use this instead of fget if you satisfy all of the following
773 * 1) You must call fput_light before exiting the syscall and returning control
774 * to userspace (i.e. you cannot remember the returned struct file * after
775 * returning to userspace).
776 * 2) You must not call filp_close on the returned struct file * in between
777 * calls to fget_light and fput_light.
778 * 3) You must not clone the current task in between the calls to fget_light
781 * The fput_needed flag returned by fget_light should be passed to the
782 * corresponding fput_light.
784 static unsigned long __fget_light(unsigned int fd, fmode_t mask)
786 struct files_struct *files = current->files;
789 if (atomic_read(&files->count) == 1) {
790 file = __fcheck_files(files, fd);
791 if (!file || unlikely(file->f_mode & mask))
793 return (unsigned long)file;
795 file = __fget(fd, mask, 1);
798 return FDPUT_FPUT | (unsigned long)file;
801 unsigned long __fdget(unsigned int fd)
803 return __fget_light(fd, FMODE_PATH);
805 EXPORT_SYMBOL(__fdget);
807 unsigned long __fdget_raw(unsigned int fd)
809 return __fget_light(fd, 0);
812 unsigned long __fdget_pos(unsigned int fd)
814 unsigned long v = __fdget(fd);
815 struct file *file = (struct file *)(v & ~3);
817 if (file && (file->f_mode & FMODE_ATOMIC_POS)) {
818 if (file_count(file) > 1) {
819 v |= FDPUT_POS_UNLOCK;
820 mutex_lock(&file->f_pos_lock);
826 void __f_unlock_pos(struct file *f)
828 mutex_unlock(&f->f_pos_lock);
832 * We only lock f_pos if we have threads or if the file might be
833 * shared with another process. In both cases we'll have an elevated
834 * file count (done either by fdget() or by fork()).
837 void set_close_on_exec(unsigned int fd, int flag)
839 struct files_struct *files = current->files;
841 spin_lock(&files->file_lock);
842 fdt = files_fdtable(files);
844 __set_close_on_exec(fd, fdt);
846 __clear_close_on_exec(fd, fdt);
847 spin_unlock(&files->file_lock);
850 bool get_close_on_exec(unsigned int fd)
852 struct files_struct *files = current->files;
856 fdt = files_fdtable(files);
857 res = close_on_exec(fd, fdt);
862 static int do_dup2(struct files_struct *files,
863 struct file *file, unsigned fd, unsigned flags)
864 __releases(&files->file_lock)
870 * We need to detect attempts to do dup2() over allocated but still
871 * not finished descriptor. NB: OpenBSD avoids that at the price of
872 * extra work in their equivalent of fget() - they insert struct
873 * file immediately after grabbing descriptor, mark it larval if
874 * more work (e.g. actual opening) is needed and make sure that
875 * fget() treats larval files as absent. Potentially interesting,
876 * but while extra work in fget() is trivial, locking implications
877 * and amount of surgery on open()-related paths in VFS are not.
878 * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
879 * deadlocks in rather amusing ways, AFAICS. All of that is out of
880 * scope of POSIX or SUS, since neither considers shared descriptor
881 * tables and this condition does not arise without those.
883 fdt = files_fdtable(files);
884 tofree = fdt->fd[fd];
885 if (!tofree && fd_is_open(fd, fdt))
888 rcu_assign_pointer(fdt->fd[fd], file);
889 __set_open_fd(fd, fdt);
890 if (flags & O_CLOEXEC)
891 __set_close_on_exec(fd, fdt);
893 __clear_close_on_exec(fd, fdt);
894 spin_unlock(&files->file_lock);
897 filp_close(tofree, files);
902 spin_unlock(&files->file_lock);
906 int replace_fd(unsigned fd, struct file *file, unsigned flags)
909 struct files_struct *files = current->files;
912 return __close_fd(files, fd);
914 if (fd >= rlimit(RLIMIT_NOFILE))
917 spin_lock(&files->file_lock);
918 err = expand_files(files, fd);
919 if (unlikely(err < 0))
921 return do_dup2(files, file, fd, flags);
924 spin_unlock(&files->file_lock);
928 SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
932 struct files_struct *files = current->files;
934 if ((flags & ~O_CLOEXEC) != 0)
937 if (unlikely(oldfd == newfd))
940 if (newfd >= rlimit(RLIMIT_NOFILE))
943 spin_lock(&files->file_lock);
944 err = expand_files(files, newfd);
945 file = fcheck(oldfd);
948 if (unlikely(err < 0)) {
953 return do_dup2(files, file, newfd, flags);
958 spin_unlock(&files->file_lock);
962 SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
964 if (unlikely(newfd == oldfd)) { /* corner case */
965 struct files_struct *files = current->files;
969 if (!fcheck_files(files, oldfd))
974 return sys_dup3(oldfd, newfd, 0);
977 SYSCALL_DEFINE1(dup, unsigned int, fildes)
980 struct file *file = fget_raw(fildes);
983 ret = get_unused_fd_flags(0);
985 fd_install(ret, file);
992 int f_dupfd(unsigned int from, struct file *file, unsigned flags)
995 if (from >= rlimit(RLIMIT_NOFILE))
997 err = alloc_fd(from, flags);
1000 fd_install(err, file);
1005 int iterate_fd(struct files_struct *files, unsigned n,
1006 int (*f)(const void *, struct file *, unsigned),
1009 struct fdtable *fdt;
1013 spin_lock(&files->file_lock);
1014 for (fdt = files_fdtable(files); n < fdt->max_fds; n++) {
1016 file = rcu_dereference_check_fdtable(files, fdt->fd[n]);
1019 res = f(p, file, n);
1023 spin_unlock(&files->file_lock);
1026 EXPORT_SYMBOL(iterate_fd);