fs/file.c

   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);
  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 void close_files(struct files_struct * files)
 352 {
 353         int i, j;
 354         struct fdtable *fdt;
 355
 356         j = 0;
 357
 358         /*
 359          * It is safe to dereference the fd table without RCU or
 360          * ->file_lock because this is the last reference to the
 361          * files structure.  But use RCU to shut RCU-lockdep up.
 362          */
 363         rcu_read_lock();
 364         fdt = files_fdtable(files);
 365         rcu_read_unlock();
 366         for (;;) {
 367                 unsigned long set;
 368                 i = j * BITS_PER_LONG;
 369                 if (i >= fdt->max_fds)
 370                         break;
 371                 set = fdt->open_fds[j++];
 372                 while (set) {
 373                         if (set & 1) {
 374                                 struct file * file = xchg(&fdt->fd[i], NULL);
 375                                 if (file) {
 376                                         filp_close(file, files);
 377                                         cond_resched();
 378                                 }
 379                         }
 380                         i++;
 381                         set >>= 1;
 382                 }
 383         }
 384 }
 385
 386 struct files_struct *get_files_struct(struct task_struct *task)
 387 {
 388         struct files_struct *files;
 389
 390         task_lock(task);
 391         files = task->files;
 392         if (files)
 393                 atomic_inc(&files->count);
 394         task_unlock(task);
 395
 396         return files;
 397 }
 398
 399 void put_files_struct(struct files_struct *files)
 400 {
 401         struct fdtable *fdt;
 402
 403         if (atomic_dec_and_test(&files->count)) {
 404                 close_files(files);
 405                 /* not really needed, since nobody can see us */
 406                 rcu_read_lock();
 407                 fdt = files_fdtable(files);
 408                 rcu_read_unlock();
 409                 /* free the arrays if they are not embedded */
 410                 if (fdt != &files->fdtab)
 411                         __free_fdtable(fdt);
 412                 kmem_cache_free(files_cachep, files);
 413         }
 414 }
 415
 416 void reset_files_struct(struct files_struct *files)
 417 {
 418         struct task_struct *tsk = current;
 419         struct files_struct *old;
 420
 421         old = tsk->files;
 422         task_lock(tsk);
 423         tsk->files = files;
 424         task_unlock(tsk);
 425         put_files_struct(old);
 426 }
 427
 428 void exit_files(struct task_struct *tsk)
 429 {
 430         struct files_struct * files = tsk->files;
 431
 432         if (files) {
 433                 task_lock(tsk);
 434                 tsk->files = NULL;
 435                 task_unlock(tsk);
 436                 put_files_struct(files);
 437         }
 438 }
 439
 440 void __init files_defer_init(void)
 441 {
 442         sysctl_nr_open_max = min((size_t)INT_MAX, ~(size_t)0/sizeof(void *)) &
 443                              -BITS_PER_LONG;
 444 }
 445
 446 struct files_struct init_files = {
 447         .count          = ATOMIC_INIT(1),
 448         .fdt            = &init_files.fdtab,
 449         .fdtab          = {
 450                 .max_fds        = NR_OPEN_DEFAULT,
 451                 .fd             = &init_files.fd_array[0],
 452                 .close_on_exec  = init_files.close_on_exec_init,
 453                 .open_fds       = init_files.open_fds_init,
 454         },
 455         .file_lock      = __SPIN_LOCK_UNLOCKED(init_files.file_lock),
 456 };
 457
 458 /*
 459  * allocate a file descriptor, mark it busy.
 460  */
 461 int __alloc_fd(struct files_struct *files,
 462                unsigned start, unsigned end, unsigned flags)
 463 {
 464         unsigned int fd;
 465         int error;
 466         struct fdtable *fdt;
 467
 468         spin_lock(&files->file_lock);
 469 repeat:
 470         fdt = files_fdtable(files);
 471         fd = start;
 472         if (fd < files->next_fd)
 473                 fd = files->next_fd;
 474
 475         if (fd < fdt->max_fds)
 476                 fd = find_next_zero_bit(fdt->open_fds, fdt->max_fds, fd);
 477
 478         /*
 479          * N.B. For clone tasks sharing a files structure, this test
 480          * will limit the total number of files that can be opened.
 481          */
 482         error = -EMFILE;
 483         if (fd >= end)
 484                 goto out;
 485
 486         error = expand_files(files, fd);
 487         if (error < 0)
 488                 goto out;
 489
 490         /*
 491          * If we needed to expand the fs array we
 492          * might have blocked - try again.
 493          */
 494         if (error)
 495                 goto repeat;
 496
 497         if (start <= files->next_fd)
 498                 files->next_fd = fd + 1;
 499
 500         __set_open_fd(fd, fdt);
 501         if (flags & O_CLOEXEC)
 502                 __set_close_on_exec(fd, fdt);
 503         else
 504                 __clear_close_on_exec(fd, fdt);
 505         error = fd;
 506 #if 1
 507         /* Sanity check */
 508         if (rcu_dereference_raw(fdt->fd[fd]) != NULL) {
 509                 printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);
 510                 rcu_assign_pointer(fdt->fd[fd], NULL);
 511         }
 512 #endif
 513
 514 out:
 515         spin_unlock(&files->file_lock);
 516         return error;
 517 }
 518
 519 static int alloc_fd(unsigned start, unsigned flags)
 520 {
 521         return __alloc_fd(current->files, start, rlimit(RLIMIT_NOFILE), flags);
 522 }
 523
 524 int get_unused_fd_flags(unsigned flags)
 525 {
 526         return __alloc_fd(current->files, 0, rlimit(RLIMIT_NOFILE), flags);
 527 }
 528 EXPORT_SYMBOL(get_unused_fd_flags);
 529
 530 static void __put_unused_fd(struct files_struct *files, unsigned int fd)
 531 {
 532         struct fdtable *fdt = files_fdtable(files);
 533         __clear_open_fd(fd, fdt);
 534         if (fd < files->next_fd)
 535                 files->next_fd = fd;
 536 }
 537
 538 void put_unused_fd(unsigned int fd)
 539 {
 540         struct files_struct *files = current->files;
 541         spin_lock(&files->file_lock);
 542         __put_unused_fd(files, fd);
 543         spin_unlock(&files->file_lock);
 544 }
 545
 546 EXPORT_SYMBOL(put_unused_fd);
 547
 548 /*
 549  * Install a file pointer in the fd array.
 550  *
 551  * The VFS is full of places where we drop the files lock between
 552  * setting the open_fds bitmap and installing the file in the file
 553  * array.  At any such point, we are vulnerable to a dup2() race
 554  * installing a file in the array before us.  We need to detect this and
 555  * fput() the struct file we are about to overwrite in this case.
 556  *
 557  * It should never happen - if we allow dup2() do it, _really_ bad things
 558  * will follow.
 559  *
 560  * NOTE: __fd_install() variant is really, really low-level; don't
 561  * use it unless you are forced to by truly lousy API shoved down
 562  * your throat.  'files' *MUST* be either current->files or obtained
 563  * by get_files_struct(current) done by whoever had given it to you,
 564  * or really bad things will happen.  Normally you want to use
 565  * fd_install() instead.
 566  */
 567
 568 void __fd_install(struct files_struct *files, unsigned int fd,
 569                 struct file *file)
 570 {
 571         struct fdtable *fdt;
 572         spin_lock(&files->file_lock);
 573         fdt = files_fdtable(files);
 574         BUG_ON(fdt->fd[fd] != NULL);
 575         rcu_assign_pointer(fdt->fd[fd], file);
 576         spin_unlock(&files->file_lock);
 577 }
 578
 579 void fd_install(unsigned int fd, struct file *file)
 580 {
 581         __fd_install(current->files, fd, file);
 582 }
 583
 584 EXPORT_SYMBOL(fd_install);
 585
 586 /*
 587  * The same warnings as for __alloc_fd()/__fd_install() apply here...
 588  */
 589 int __close_fd(struct files_struct *files, unsigned fd)
 590 {
 591         struct file *file;
 592         struct fdtable *fdt;
 593
 594         spin_lock(&files->file_lock);
 595         fdt = files_fdtable(files);
 596         if (fd >= fdt->max_fds)
 597                 goto out_unlock;
 598         file = fdt->fd[fd];
 599         if (!file)
 600                 goto out_unlock;
 601         rcu_assign_pointer(fdt->fd[fd], NULL);
 602         __clear_close_on_exec(fd, fdt);
 603         __put_unused_fd(files, fd);
 604         spin_unlock(&files->file_lock);
 605         return filp_close(file, files);
 606
 607 out_unlock:
 608         spin_unlock(&files->file_lock);
 609         return -EBADF;
 610 }
 611
 612 void do_close_on_exec(struct files_struct *files)
 613 {
 614         unsigned i;
 615         struct fdtable *fdt;
 616
 617         /* exec unshares first */
 618         spin_lock(&files->file_lock);
 619         for (i = 0; ; i++) {
 620                 unsigned long set;
 621                 unsigned fd = i * BITS_PER_LONG;
 622                 fdt = files_fdtable(files);
 623                 if (fd >= fdt->max_fds)
 624                         break;
 625                 set = fdt->close_on_exec[i];
 626                 if (!set)
 627                         continue;
 628                 fdt->close_on_exec[i] = 0;
 629                 for ( ; set ; fd++, set >>= 1) {
 630                         struct file *file;
 631                         if (!(set & 1))
 632                                 continue;
 633                         file = fdt->fd[fd];
 634                         if (!file)
 635                                 continue;
 636                         rcu_assign_pointer(fdt->fd[fd], NULL);
 637                         __put_unused_fd(files, fd);
 638                         spin_unlock(&files->file_lock);
 639                         filp_close(file, files);
 640                         cond_resched();
 641                         spin_lock(&files->file_lock);
 642                 }
 643
 644         }
 645         spin_unlock(&files->file_lock);
 646 }
 647
 648 struct file *fget(unsigned int fd)
 649 {
 650         struct file *file;
 651         struct files_struct *files = current->files;
 652
 653         rcu_read_lock();
 654         file = fcheck_files(files, fd);
 655         if (file) {
 656                 /* File object ref couldn't be taken */
 657                 if (file->f_mode & FMODE_PATH ||
 658                     !atomic_long_inc_not_zero(&file->f_count))
 659                         file = NULL;
 660         }
 661         rcu_read_unlock();
 662
 663         return file;
 664 }
 665
 666 EXPORT_SYMBOL(fget);
 667
 668 struct file *fget_raw(unsigned int fd)
 669 {
 670         struct file *file;
 671         struct files_struct *files = current->files;
 672
 673         rcu_read_lock();
 674         file = fcheck_files(files, fd);
 675         if (file) {
 676                 /* File object ref couldn't be taken */
 677                 if (!atomic_long_inc_not_zero(&file->f_count))
 678                         file = NULL;
 679         }
 680         rcu_read_unlock();
 681
 682         return file;
 683 }
 684
 685 EXPORT_SYMBOL(fget_raw);
 686
 687 /*
 688  * Lightweight file lookup - no refcnt increment if fd table isn't shared.
 689  *
 690  * You can use this instead of fget if you satisfy all of the following
 691  * conditions:
 692  * 1) You must call fput_light before exiting the syscall and returning control
 693  *    to userspace (i.e. you cannot remember the returned struct file * after
 694  *    returning to userspace).
 695  * 2) You must not call filp_close on the returned struct file * in between
 696  *    calls to fget_light and fput_light.
 697  * 3) You must not clone the current task in between the calls to fget_light
 698  *    and fput_light.
 699  *
 700  * The fput_needed flag returned by fget_light should be passed to the
 701  * corresponding fput_light.
 702  */
 703 struct file *fget_light(unsigned int fd, int *fput_needed)
 704 {
 705         struct file *file;
 706         struct files_struct *files = current->files;
 707
 708         *fput_needed = 0;
 709         if (atomic_read(&files->count) == 1) {
 710                 file = fcheck_files(files, fd);
 711                 if (file && (file->f_mode & FMODE_PATH))
 712                         file = NULL;
 713         } else {
 714                 rcu_read_lock();
 715                 file = fcheck_files(files, fd);
 716                 if (file) {
 717                         if (!(file->f_mode & FMODE_PATH) &&
 718                             atomic_long_inc_not_zero(&file->f_count))
 719                                 *fput_needed = 1;
 720                         else
 721                                 /* Didn't get the reference, someone's freed */
 722                                 file = NULL;
 723                 }
 724                 rcu_read_unlock();
 725         }
 726
 727         return file;
 728 }
 729 EXPORT_SYMBOL(fget_light);
 730
 731 struct file *fget_raw_light(unsigned int fd, int *fput_needed)
 732 {
 733         struct file *file;
 734         struct files_struct *files = current->files;
 735
 736         *fput_needed = 0;
 737         if (atomic_read(&files->count) == 1) {
 738                 file = fcheck_files(files, fd);
 739         } else {
 740                 rcu_read_lock();
 741                 file = fcheck_files(files, fd);
 742                 if (file) {
 743                         if (atomic_long_inc_not_zero(&file->f_count))
 744                                 *fput_needed = 1;
 745                         else
 746                                 /* Didn't get the reference, someone's freed */
 747                                 file = NULL;
 748                 }
 749                 rcu_read_unlock();
 750         }
 751
 752         return file;
 753 }
 754
 755 void set_close_on_exec(unsigned int fd, int flag)
 756 {
 757         struct files_struct *files = current->files;
 758         struct fdtable *fdt;
 759         spin_lock(&files->file_lock);
 760         fdt = files_fdtable(files);
 761         if (flag)
 762                 __set_close_on_exec(fd, fdt);
 763         else
 764                 __clear_close_on_exec(fd, fdt);
 765         spin_unlock(&files->file_lock);
 766 }
 767
 768 bool get_close_on_exec(unsigned int fd)
 769 {
 770         struct files_struct *files = current->files;
 771         struct fdtable *fdt;
 772         bool res;
 773         rcu_read_lock();
 774         fdt = files_fdtable(files);
 775         res = close_on_exec(fd, fdt);
 776         rcu_read_unlock();
 777         return res;
 778 }
 779
 780 static int do_dup2(struct files_struct *files,
 781         struct file *file, unsigned fd, unsigned flags)
 782 {
 783         struct file *tofree;
 784         struct fdtable *fdt;
 785
 786         /*
 787          * We need to detect attempts to do dup2() over allocated but still
 788          * not finished descriptor.  NB: OpenBSD avoids that at the price of
 789          * extra work in their equivalent of fget() - they insert struct
 790          * file immediately after grabbing descriptor, mark it larval if
 791          * more work (e.g. actual opening) is needed and make sure that
 792          * fget() treats larval files as absent.  Potentially interesting,
 793          * but while extra work in fget() is trivial, locking implications
 794          * and amount of surgery on open()-related paths in VFS are not.
 795          * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
 796          * deadlocks in rather amusing ways, AFAICS.  All of that is out of
 797          * scope of POSIX or SUS, since neither considers shared descriptor
 798          * tables and this condition does not arise without those.
 799          */
 800         fdt = files_fdtable(files);
 801         tofree = fdt->fd[fd];
 802         if (!tofree && fd_is_open(fd, fdt))
 803                 goto Ebusy;
 804         get_file(file);
 805         rcu_assign_pointer(fdt->fd[fd], file);
 806         __set_open_fd(fd, fdt);
 807         if (flags & O_CLOEXEC)
 808                 __set_close_on_exec(fd, fdt);
 809         else
 810                 __clear_close_on_exec(fd, fdt);
 811         spin_unlock(&files->file_lock);
 812
 813         if (tofree)
 814                 filp_close(tofree, files);
 815
 816         return fd;
 817
 818 Ebusy:
 819         spin_unlock(&files->file_lock);
 820         return -EBUSY;
 821 }
 822
 823 int replace_fd(unsigned fd, struct file *file, unsigned flags)
 824 {
 825         int err;
 826         struct files_struct *files = current->files;
 827
 828         if (!file)
 829                 return __close_fd(files, fd);
 830
 831         if (fd >= rlimit(RLIMIT_NOFILE))
 832                 return -EBADF;
 833
 834         spin_lock(&files->file_lock);
 835         err = expand_files(files, fd);
 836         if (unlikely(err < 0))
 837                 goto out_unlock;
 838         return do_dup2(files, file, fd, flags);
 839
 840 out_unlock:
 841         spin_unlock(&files->file_lock);
 842         return err;
 843 }
 844
 845 SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
 846 {
 847         int err = -EBADF;
 848         struct file *file;
 849         struct files_struct *files = current->files;
 850
 851         if ((flags & ~O_CLOEXEC) != 0)
 852                 return -EINVAL;
 853
 854         if (unlikely(oldfd == newfd))
 855                 return -EINVAL;
 856
 857         if (newfd >= rlimit(RLIMIT_NOFILE))
 858                 return -EBADF;
 859
 860         spin_lock(&files->file_lock);
 861         err = expand_files(files, newfd);
 862         file = fcheck(oldfd);
 863         if (unlikely(!file))
 864                 goto Ebadf;
 865         if (unlikely(err < 0)) {
 866                 if (err == -EMFILE)
 867                         goto Ebadf;
 868                 goto out_unlock;
 869         }
 870         return do_dup2(files, file, newfd, flags);
 871
 872 Ebadf:
 873         err = -EBADF;
 874 out_unlock:
 875         spin_unlock(&files->file_lock);
 876         return err;
 877 }
 878
 879 SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
 880 {
 881         if (unlikely(newfd == oldfd)) { /* corner case */
 882                 struct files_struct *files = current->files;
 883                 int retval = oldfd;
 884
 885                 rcu_read_lock();
 886                 if (!fcheck_files(files, oldfd))
 887                         retval = -EBADF;
 888                 rcu_read_unlock();
 889                 return retval;
 890         }
 891         return sys_dup3(oldfd, newfd, 0);
 892 }
 893
 894 SYSCALL_DEFINE1(dup, unsigned int, fildes)
 895 {
 896         int ret = -EBADF;
 897         struct file *file = fget_raw(fildes);
 898
 899         if (file) {
 900                 ret = get_unused_fd();
 901                 if (ret >= 0)
 902                         fd_install(ret, file);
 903                 else
 904                         fput(file);
 905         }
 906         return ret;
 907 }
 908
 909 int f_dupfd(unsigned int from, struct file *file, unsigned flags)
 910 {
 911         int err;
 912         if (from >= rlimit(RLIMIT_NOFILE))
 913                 return -EINVAL;
 914         err = alloc_fd(from, flags);
 915         if (err >= 0) {
 916                 get_file(file);
 917                 fd_install(err, file);
 918         }
 919         return err;
 920 }
 921
 922 int iterate_fd(struct files_struct *files, unsigned n,
 923                 int (*f)(const void *, struct file *, unsigned),
 924                 const void *p)
 925 {
 926         struct fdtable *fdt;
 927         int res = 0;
 928         if (!files)
 929                 return 0;
 930         spin_lock(&files->file_lock);
 931         for (fdt = files_fdtable(files); n < fdt->max_fds; n++) {
 932                 struct file *file;
 933                 file = rcu_dereference_check_fdtable(files, fdt->fd[n]);
 934                 if (!file)
 935                         continue;
 936                 res = f(p, file, n);
 937                 if (res)
 938                         break;
 939         }
 940         spin_unlock(&files->file_lock);
 941         return res;
 942 }
 943 EXPORT_SYMBOL(iterate_fd);