~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/file.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp