release/src-rt-6.x/linux/linux-2.6/fs/open.c

   1 /*
   2  *  linux/fs/open.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/string.h>
   8 #include <linux/mm.h>
   9 #include <linux/file.h>
  10 #include <linux/quotaops.h>
  11 #include <linux/fsnotify.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/tty.h>
  15 #include <linux/namei.h>
  16 #include <linux/backing-dev.h>
  17 #include <linux/capability.h>
  18 #include <linux/security.h>
  19 #include <linux/mount.h>
  20 #include <linux/vfs.h>
  21 #include <linux/fcntl.h>
  22 #include <asm/uaccess.h>
  23 #include <linux/fs.h>
  24 #include <linux/personality.h>
  25 #include <linux/pagemap.h>
  26 #include <linux/syscalls.h>
  27 #include <linux/rcupdate.h>
  28 #include <linux/audit.h>
  29
  30 int vfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  31 {
  32         int retval = -ENODEV;
  33
  34         if (dentry) {
  35                 retval = -ENOSYS;
  36                 if (dentry->d_sb->s_op->statfs) {
  37                         memset(buf, 0, sizeof(*buf));
  38                         retval = security_sb_statfs(dentry);
  39                         if (retval)
  40                                 return retval;
  41                         retval = dentry->d_sb->s_op->statfs(dentry, buf);
  42                         if (retval == 0 && buf->f_frsize == 0)
  43                                 buf->f_frsize = buf->f_bsize;
  44                 }
  45         }
  46         return retval;
  47 }
  48
  49 EXPORT_SYMBOL(vfs_statfs);
  50
  51 static int vfs_statfs_native(struct dentry *dentry, struct statfs *buf)
  52 {
  53         struct kstatfs st;
  54         int retval;
  55
  56         retval = vfs_statfs(dentry, &st);
  57         if (retval)
  58                 return retval;
  59
  60         if (sizeof(*buf) == sizeof(st))
  61                 memcpy(buf, &st, sizeof(st));
  62         else {
  63                 if (sizeof buf->f_blocks == 4) {
  64                         if ((st.f_blocks | st.f_bfree | st.f_bavail) &
  65                             0xffffffff00000000ULL)
  66                                 return -EOVERFLOW;
  67                         /*
  68                          * f_files and f_ffree may be -1; it's okay to stuff
  69                          * that into 32 bits
  70                          */
  71                         if (st.f_files != -1 &&
  72                             (st.f_files & 0xffffffff00000000ULL))
  73                                 return -EOVERFLOW;
  74                         if (st.f_ffree != -1 &&
  75                             (st.f_ffree & 0xffffffff00000000ULL))
  76                                 return -EOVERFLOW;
  77                 }
  78
  79                 buf->f_type = st.f_type;
  80                 buf->f_bsize = st.f_bsize;
  81                 buf->f_blocks = st.f_blocks;
  82                 buf->f_bfree = st.f_bfree;
  83                 buf->f_bavail = st.f_bavail;
  84                 buf->f_files = st.f_files;
  85                 buf->f_ffree = st.f_ffree;
  86                 buf->f_fsid = st.f_fsid;
  87                 buf->f_namelen = st.f_namelen;
  88                 buf->f_frsize = st.f_frsize;
  89                 memset(buf->f_spare, 0, sizeof(buf->f_spare));
  90         }
  91         return 0;
  92 }
  93
  94 static int vfs_statfs64(struct dentry *dentry, struct statfs64 *buf)
  95 {
  96         struct kstatfs st;
  97         int retval;
  98
  99         retval = vfs_statfs(dentry, &st);
 100         if (retval)
 101                 return retval;
 102
 103         if (sizeof(*buf) == sizeof(st))
 104                 memcpy(buf, &st, sizeof(st));
 105         else {
 106                 buf->f_type = st.f_type;
 107                 buf->f_bsize = st.f_bsize;
 108                 buf->f_blocks = st.f_blocks;
 109                 buf->f_bfree = st.f_bfree;
 110                 buf->f_bavail = st.f_bavail;
 111                 buf->f_files = st.f_files;
 112                 buf->f_ffree = st.f_ffree;
 113                 buf->f_fsid = st.f_fsid;
 114                 buf->f_namelen = st.f_namelen;
 115                 buf->f_frsize = st.f_frsize;
 116                 memset(buf->f_spare, 0, sizeof(buf->f_spare));
 117         }
 118         return 0;
 119 }
 120
 121 asmlinkage long sys_statfs(const char __user * path, struct statfs __user * buf)
 122 {
 123         struct nameidata nd;
 124         int error;
 125
 126         error = user_path_walk(path, &nd);
 127         if (!error) {
 128                 struct statfs tmp;
 129                 error = vfs_statfs_native(nd.dentry, &tmp);
 130                 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
 131                         error = -EFAULT;
 132                 path_release(&nd);
 133         }
 134         return error;
 135 }
 136
 137
 138 asmlinkage long sys_statfs64(const char __user *path, size_t sz, struct statfs64 __user *buf)
 139 {
 140         struct nameidata nd;
 141         long error;
 142
 143         if (sz != sizeof(*buf))
 144                 return -EINVAL;
 145         error = user_path_walk(path, &nd);
 146         if (!error) {
 147                 struct statfs64 tmp;
 148                 error = vfs_statfs64(nd.dentry, &tmp);
 149                 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
 150                         error = -EFAULT;
 151                 path_release(&nd);
 152         }
 153         return error;
 154 }
 155
 156
 157 asmlinkage long sys_fstatfs(unsigned int fd, struct statfs __user * buf)
 158 {
 159         struct file * file;
 160         struct statfs tmp;
 161         int error;
 162
 163         error = -EBADF;
 164         file = fget(fd);
 165         if (!file)
 166                 goto out;
 167         error = vfs_statfs_native(file->f_path.dentry, &tmp);
 168         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
 169                 error = -EFAULT;
 170         fput(file);
 171 out:
 172         return error;
 173 }
 174
 175 asmlinkage long sys_fstatfs64(unsigned int fd, size_t sz, struct statfs64 __user *buf)
 176 {
 177         struct file * file;
 178         struct statfs64 tmp;
 179         int error;
 180
 181         if (sz != sizeof(*buf))
 182                 return -EINVAL;
 183
 184         error = -EBADF;
 185         file = fget(fd);
 186         if (!file)
 187                 goto out;
 188         error = vfs_statfs64(file->f_path.dentry, &tmp);
 189         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
 190                 error = -EFAULT;
 191         fput(file);
 192 out:
 193         return error;
 194 }
 195
 196 int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
 197         struct file *filp)
 198 {
 199         int err;
 200         struct iattr newattrs;
 201
 202         /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
 203         if (length < 0)
 204                 return -EINVAL;
 205
 206         newattrs.ia_size = length;
 207         newattrs.ia_valid = ATTR_SIZE | time_attrs;
 208         if (filp) {
 209                 newattrs.ia_file = filp;
 210                 newattrs.ia_valid |= ATTR_FILE;
 211         }
 212
 213         /* Remove suid/sgid on truncate too */
 214         newattrs.ia_valid |= should_remove_suid(dentry);
 215
 216         mutex_lock(&dentry->d_inode->i_mutex);
 217         err = notify_change(dentry, &newattrs);
 218         mutex_unlock(&dentry->d_inode->i_mutex);
 219         return err;
 220 }
 221
 222 static long do_sys_truncate(const char __user * path, loff_t length)
 223 {
 224         struct nameidata nd;
 225         struct inode * inode;
 226         int error;
 227
 228         error = -EINVAL;
 229         if (length < 0) /* sorry, but loff_t says... */
 230                 goto out;
 231
 232         error = user_path_walk(path, &nd);
 233         if (error)
 234                 goto out;
 235         inode = nd.dentry->d_inode;
 236
 237         /* For directories it's -EISDIR, for other non-regulars - -EINVAL */
 238         error = -EISDIR;
 239         if (S_ISDIR(inode->i_mode))
 240                 goto dput_and_out;
 241
 242         error = -EINVAL;
 243         if (!S_ISREG(inode->i_mode))
 244                 goto dput_and_out;
 245
 246         error = vfs_permission(&nd, MAY_WRITE);
 247         if (error)
 248                 goto dput_and_out;
 249
 250         error = -EROFS;
 251         if (IS_RDONLY(inode))
 252                 goto dput_and_out;
 253
 254         error = -EPERM;
 255         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 256                 goto dput_and_out;
 257
 258         error = get_write_access(inode);
 259         if (error)
 260                 goto dput_and_out;
 261
 262         /*
 263          * Make sure that there are no leases.  get_write_access() protects
 264          * against the truncate racing with a lease-granting setlease().
 265          */
 266         error = break_lease(inode, FMODE_WRITE);
 267         if (error)
 268                 goto put_write_and_out;
 269
 270         error = locks_verify_truncate(inode, NULL, length);
 271         if (!error) {
 272                 DQUOT_INIT(inode);
 273                 error = do_truncate(nd.dentry, length, 0, NULL);
 274         }
 275
 276 put_write_and_out:
 277         put_write_access(inode);
 278 dput_and_out:
 279         path_release(&nd);
 280 out:
 281         return error;
 282 }
 283
 284 asmlinkage long sys_truncate(const char __user * path, unsigned long length)
 285 {
 286         /* on 32-bit boxen it will cut the range 2^31--2^32-1 off */
 287         return do_sys_truncate(path, (long)length);
 288 }
 289
 290 static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
 291 {
 292         struct inode * inode;
 293         struct dentry *dentry;
 294         struct file * file;
 295         int error;
 296
 297         error = -EINVAL;
 298         if (length < 0)
 299                 goto out;
 300         error = -EBADF;
 301         file = fget(fd);
 302         if (!file)
 303                 goto out;
 304
 305         /* explicitly opened as large or we are on 64-bit box */
 306         if (file->f_flags & O_LARGEFILE)
 307                 small = 0;
 308
 309         dentry = file->f_path.dentry;
 310         inode = dentry->d_inode;
 311         error = -EINVAL;
 312         if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
 313                 goto out_putf;
 314
 315         error = -EINVAL;
 316         /* Cannot ftruncate over 2^31 bytes without large file support */
 317         if (small && length > MAX_NON_LFS)
 318                 goto out_putf;
 319
 320         error = -EPERM;
 321         if (IS_APPEND(inode))
 322                 goto out_putf;
 323
 324         error = locks_verify_truncate(inode, file, length);
 325         if (!error)
 326                 error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, file);
 327 out_putf:
 328         fput(file);
 329 out:
 330         return error;
 331 }
 332
 333 asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length)
 334 {
 335         long ret = do_sys_ftruncate(fd, length, 1);
 336         /* avoid REGPARM breakage on x86: */
 337         prevent_tail_call(ret);
 338         return ret;
 339 }
 340
 341 /* LFS versions of truncate are only needed on 32 bit machines */
 342 #if BITS_PER_LONG == 32
 343 asmlinkage long sys_truncate64(const char __user * path, loff_t length)
 344 {
 345         return do_sys_truncate(path, length);
 346 }
 347
 348 asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length)
 349 {
 350         long ret = do_sys_ftruncate(fd, length, 0);
 351         /* avoid REGPARM breakage on x86: */
 352         prevent_tail_call(ret);
 353         return ret;
 354 }
 355 #endif
 356
 357 /*
 358  * access() needs to use the real uid/gid, not the effective uid/gid.
 359  * We do this by temporarily clearing all FS-related capabilities and
 360  * switching the fsuid/fsgid around to the real ones.
 361  */
 362 asmlinkage long sys_faccessat(int dfd, const char __user *filename, int mode)
 363 {
 364         struct nameidata nd;
 365         int old_fsuid, old_fsgid;
 366         kernel_cap_t old_cap;
 367         int res;
 368
 369         if (mode & ~S_IRWXO)    /* where's F_OK, X_OK, W_OK, R_OK? */
 370                 return -EINVAL;
 371
 372         old_fsuid = current->fsuid;
 373         old_fsgid = current->fsgid;
 374         old_cap = current->cap_effective;
 375
 376         current->fsuid = current->uid;
 377         current->fsgid = current->gid;
 378
 379         /*
 380          * Clear the capabilities if we switch to a non-root user
 381          *
 382          * FIXME: There is a race here against sys_capset.  The
 383          * capabilities can change yet we will restore the old
 384          * value below.  We should hold task_capabilities_lock,
 385          * but we cannot because user_path_walk can sleep.
 386          */
 387         if (current->uid)
 388                 cap_clear(current->cap_effective);
 389         else
 390                 current->cap_effective = current->cap_permitted;
 391
 392         res = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW|LOOKUP_ACCESS, &nd);
 393         if (res)
 394                 goto out;
 395
 396         res = vfs_permission(&nd, mode);
 397         /* SuS v2 requires we report a read only fs too */
 398         if(res || !(mode & S_IWOTH) ||
 399            special_file(nd.dentry->d_inode->i_mode))
 400                 goto out_path_release;
 401
 402         if(IS_RDONLY(nd.dentry->d_inode))
 403                 res = -EROFS;
 404
 405 out_path_release:
 406         path_release(&nd);
 407 out:
 408         current->fsuid = old_fsuid;
 409         current->fsgid = old_fsgid;
 410         current->cap_effective = old_cap;
 411
 412         return res;
 413 }
 414
 415 asmlinkage long sys_access(const char __user *filename, int mode)
 416 {
 417         return sys_faccessat(AT_FDCWD, filename, mode);
 418 }
 419
 420 asmlinkage long sys_chdir(const char __user * filename)
 421 {
 422         struct nameidata nd;
 423         int error;
 424
 425         error = __user_walk(filename,
 426                             LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_CHDIR, &nd);
 427         if (error)
 428                 goto out;
 429
 430         error = vfs_permission(&nd, MAY_EXEC);
 431         if (error)
 432                 goto dput_and_out;
 433
 434         set_fs_pwd(current->fs, nd.mnt, nd.dentry);
 435
 436 dput_and_out:
 437         path_release(&nd);
 438 out:
 439         return error;
 440 }
 441
 442 asmlinkage long sys_fchdir(unsigned int fd)
 443 {
 444         struct file *file;
 445         struct dentry *dentry;
 446         struct inode *inode;
 447         struct vfsmount *mnt;
 448         int error;
 449
 450         error = -EBADF;
 451         file = fget(fd);
 452         if (!file)
 453                 goto out;
 454
 455         dentry = file->f_path.dentry;
 456         mnt = file->f_path.mnt;
 457         inode = dentry->d_inode;
 458
 459         error = -ENOTDIR;
 460         if (!S_ISDIR(inode->i_mode))
 461                 goto out_putf;
 462
 463         error = file_permission(file, MAY_EXEC);
 464         if (!error)
 465                 set_fs_pwd(current->fs, mnt, dentry);
 466 out_putf:
 467         fput(file);
 468 out:
 469         return error;
 470 }
 471
 472 asmlinkage long sys_chroot(const char __user * filename)
 473 {
 474         struct nameidata nd;
 475         int error;
 476
 477         error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd);
 478         if (error)
 479                 goto out;
 480
 481         error = vfs_permission(&nd, MAY_EXEC);
 482         if (error)
 483                 goto dput_and_out;
 484
 485         error = -EPERM;
 486         if (!capable(CAP_SYS_CHROOT))
 487                 goto dput_and_out;
 488
 489         set_fs_root(current->fs, nd.mnt, nd.dentry);
 490         set_fs_altroot();
 491         error = 0;
 492 dput_and_out:
 493         path_release(&nd);
 494 out:
 495         return error;
 496 }
 497
 498 asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
 499 {
 500         struct inode * inode;
 501         struct dentry * dentry;
 502         struct file * file;
 503         int err = -EBADF;
 504         struct iattr newattrs;
 505
 506         file = fget(fd);
 507         if (!file)
 508                 goto out;
 509
 510         dentry = file->f_path.dentry;
 511         inode = dentry->d_inode;
 512
 513         audit_inode(NULL, inode);
 514
 515         err = -EROFS;
 516         if (IS_RDONLY(inode))
 517                 goto out_putf;
 518         err = -EPERM;
 519         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 520                 goto out_putf;
 521         mutex_lock(&inode->i_mutex);
 522         if (mode == (mode_t) -1)
 523                 mode = inode->i_mode;
 524         newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
 525         newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
 526         err = notify_change(dentry, &newattrs);
 527         mutex_unlock(&inode->i_mutex);
 528
 529 out_putf:
 530         fput(file);
 531 out:
 532         return err;
 533 }
 534
 535 asmlinkage long sys_fchmodat(int dfd, const char __user *filename,
 536                              mode_t mode)
 537 {
 538         struct nameidata nd;
 539         struct inode * inode;
 540         int error;
 541         struct iattr newattrs;
 542
 543         error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd);
 544         if (error)
 545                 goto out;
 546         inode = nd.dentry->d_inode;
 547
 548         error = -EROFS;
 549         if (IS_RDONLY(inode))
 550                 goto dput_and_out;
 551
 552         error = -EPERM;
 553         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 554                 goto dput_and_out;
 555
 556         mutex_lock(&inode->i_mutex);
 557         if (mode == (mode_t) -1)
 558                 mode = inode->i_mode;
 559         newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
 560         newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
 561         error = notify_change(nd.dentry, &newattrs);
 562         mutex_unlock(&inode->i_mutex);
 563
 564 dput_and_out:
 565         path_release(&nd);
 566 out:
 567         return error;
 568 }
 569
 570 asmlinkage long sys_chmod(const char __user *filename, mode_t mode)
 571 {
 572         return sys_fchmodat(AT_FDCWD, filename, mode);
 573 }
 574
 575 static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
 576 {
 577         struct inode * inode;
 578         int error;
 579         struct iattr newattrs;
 580
 581         error = -ENOENT;
 582         if (!(inode = dentry->d_inode)) {
 583                 printk(KERN_ERR "chown_common: NULL inode\n");
 584                 goto out;
 585         }
 586         error = -EROFS;
 587         if (IS_RDONLY(inode))
 588                 goto out;
 589         error = -EPERM;
 590         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 591                 goto out;
 592         newattrs.ia_valid =  ATTR_CTIME;
 593         if (user != (uid_t) -1) {
 594                 newattrs.ia_valid |= ATTR_UID;
 595                 newattrs.ia_uid = user;
 596         }
 597         if (group != (gid_t) -1) {
 598                 newattrs.ia_valid |= ATTR_GID;
 599                 newattrs.ia_gid = group;
 600         }
 601         if (!S_ISDIR(inode->i_mode))
 602                 newattrs.ia_valid |= ATTR_KILL_SUID|ATTR_KILL_SGID;
 603         mutex_lock(&inode->i_mutex);
 604         error = notify_change(dentry, &newattrs);
 605         mutex_unlock(&inode->i_mutex);
 606 out:
 607         return error;
 608 }
 609
 610 asmlinkage long sys_chown(const char __user * filename, uid_t user, gid_t group)
 611 {
 612         struct nameidata nd;
 613         int error;
 614
 615         error = user_path_walk(filename, &nd);
 616         if (error)
 617                 goto out;
 618         error = chown_common(nd.dentry, user, group);
 619         path_release(&nd);
 620 out:
 621         return error;
 622 }
 623
 624 asmlinkage long sys_fchownat(int dfd, const char __user *filename, uid_t user,
 625                              gid_t group, int flag)
 626 {
 627         struct nameidata nd;
 628         int error = -EINVAL;
 629         int follow;
 630
 631         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
 632                 goto out;
 633
 634         follow = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
 635         error = __user_walk_fd(dfd, filename, follow, &nd);
 636         if (error)
 637                 goto out;
 638         error = chown_common(nd.dentry, user, group);
 639         path_release(&nd);
 640 out:
 641         return error;
 642 }
 643
 644 asmlinkage long sys_lchown(const char __user * filename, uid_t user, gid_t group)
 645 {
 646         struct nameidata nd;
 647         int error;
 648
 649         error = user_path_walk_link(filename, &nd);
 650         if (error)
 651                 goto out;
 652         error = chown_common(nd.dentry, user, group);
 653         path_release(&nd);
 654 out:
 655         return error;
 656 }
 657
 658
 659 asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
 660 {
 661         struct file * file;
 662         int error = -EBADF;
 663         struct dentry * dentry;
 664
 665         file = fget(fd);
 666         if (!file)
 667                 goto out;
 668
 669         dentry = file->f_path.dentry;
 670         audit_inode(NULL, dentry->d_inode);
 671         error = chown_common(dentry, user, group);
 672         fput(file);
 673 out:
 674         return error;
 675 }
 676
 677 static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
 678                                         int flags, struct file *f,
 679                                         int (*open)(struct inode *, struct file *))
 680 {
 681         struct inode *inode;
 682         int error;
 683
 684         f->f_flags = flags;
 685         f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK |
 686                                 FMODE_PREAD | FMODE_PWRITE;
 687         inode = dentry->d_inode;
 688         if (f->f_mode & FMODE_WRITE) {
 689                 error = get_write_access(inode);
 690                 if (error)
 691                         goto cleanup_file;
 692         }
 693
 694         f->f_mapping = inode->i_mapping;
 695         f->f_path.dentry = dentry;
 696         f->f_path.mnt = mnt;
 697         f->f_pos = 0;
 698         f->f_op = fops_get(inode->i_fop);
 699         file_move(f, &inode->i_sb->s_files);
 700
 701         if (!open && f->f_op)
 702                 open = f->f_op->open;
 703         if (open) {
 704                 error = open(inode, f);
 705                 if (error)
 706                         goto cleanup_all;
 707         }
 708
 709         f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
 710
 711         file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
 712
 713         /* NB: we're sure to have correct a_ops only after f_op->open */
 714         if (f->f_flags & O_DIRECT) {
 715                 if (!f->f_mapping->a_ops ||
 716                     ((!f->f_mapping->a_ops->direct_IO) &&
 717                     (!f->f_mapping->a_ops->get_xip_page))) {
 718                         fput(f);
 719                         f = ERR_PTR(-EINVAL);
 720                 }
 721         }
 722
 723         return f;
 724
 725 cleanup_all:
 726         fops_put(f->f_op);
 727         if (f->f_mode & FMODE_WRITE)
 728                 put_write_access(inode);
 729         file_kill(f);
 730         f->f_path.dentry = NULL;
 731         f->f_path.mnt = NULL;
 732 cleanup_file:
 733         put_filp(f);
 734         dput(dentry);
 735         mntput(mnt);
 736         return ERR_PTR(error);
 737 }
 738
 739 /*
 740  * Note that while the flag value (low two bits) for sys_open means:
 741  *      00 - read-only
 742  *      01 - write-only
 743  *      10 - read-write
 744  *      11 - special
 745  * it is changed into
 746  *      00 - no permissions needed
 747  *      01 - read-permission
 748  *      10 - write-permission
 749  *      11 - read-write
 750  * for the internal routines (ie open_namei()/follow_link() etc). 00 is
 751  * used by symlinks.
 752  */
 753 static struct file *do_filp_open(int dfd, const char *filename, int flags,
 754                                  int mode)
 755 {
 756         int namei_flags, error;
 757         struct nameidata nd;
 758
 759         namei_flags = flags;
 760         if ((namei_flags+1) & O_ACCMODE)
 761                 namei_flags++;
 762
 763         error = open_namei(dfd, filename, namei_flags, mode, &nd);
 764         if (!error)
 765                 return nameidata_to_filp(&nd, flags);
 766
 767         return ERR_PTR(error);
 768 }
 769
 770 struct file *filp_open(const char *filename, int flags, int mode)
 771 {
 772         return do_filp_open(AT_FDCWD, filename, flags, mode);
 773 }
 774 EXPORT_SYMBOL(filp_open);
 775
 776 /**
 777  * lookup_instantiate_filp - instantiates the open intent filp
 778  * @nd: pointer to nameidata
 779  * @dentry: pointer to dentry
 780  * @open: open callback
 781  *
 782  * Helper for filesystems that want to use lookup open intents and pass back
 783  * a fully instantiated struct file to the caller.
 784  * This function is meant to be called from within a filesystem's
 785  * lookup method.
 786  * Beware of calling it for non-regular files! Those ->open methods might block
 787  * (e.g. in fifo_open), leaving you with parent locked (and in case of fifo,
 788  * leading to a deadlock, as nobody can open that fifo anymore, because
 789  * another process to open fifo will block on locked parent when doing lookup).
 790  * Note that in case of error, nd->intent.open.file is destroyed, but the
 791  * path information remains valid.
 792  * If the open callback is set to NULL, then the standard f_op->open()
 793  * filesystem callback is substituted.
 794  */
 795 struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
 796                 int (*open)(struct inode *, struct file *))
 797 {
 798         if (IS_ERR(nd->intent.open.file))
 799                 goto out;
 800         if (IS_ERR(dentry))
 801                 goto out_err;
 802         nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->mnt),
 803                                              nd->intent.open.flags - 1,
 804                                              nd->intent.open.file,
 805                                              open);
 806 out:
 807         return nd->intent.open.file;
 808 out_err:
 809         release_open_intent(nd);
 810         nd->intent.open.file = (struct file *)dentry;
 811         goto out;
 812 }
 813 EXPORT_SYMBOL_GPL(lookup_instantiate_filp);
 814
 815 /**
 816  * nameidata_to_filp - convert a nameidata to an open filp.
 817  * @nd: pointer to nameidata
 818  * @flags: open flags
 819  *
 820  * Note that this function destroys the original nameidata
 821  */
 822 struct file *nameidata_to_filp(struct nameidata *nd, int flags)
 823 {
 824         struct file *filp;
 825
 826         /* Pick up the filp from the open intent */
 827         filp = nd->intent.open.file;
 828         /* Has the filesystem initialised the file for us? */
 829         if (filp->f_path.dentry == NULL)
 830                 filp = __dentry_open(nd->dentry, nd->mnt, flags, filp, NULL);
 831         else
 832                 path_release(nd);
 833         return filp;
 834 }
 835
 836 /*
 837  * dentry_open() will have done dput(dentry) and mntput(mnt) if it returns an
 838  * error.
 839  */
 840 struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
 841 {
 842         int error;
 843         struct file *f;
 844
 845         error = -ENFILE;
 846         f = get_empty_filp();
 847         if (f == NULL) {
 848                 dput(dentry);
 849                 mntput(mnt);
 850                 return ERR_PTR(error);
 851         }
 852
 853         return __dentry_open(dentry, mnt, flags, f, NULL);
 854 }
 855 EXPORT_SYMBOL(dentry_open);
 856
 857 /*
 858  * Find an empty file descriptor entry, and mark it busy.
 859  */
 860 int get_unused_fd_flags(int flags)
 861 {
 862         struct files_struct * files = current->files;
 863         int fd, error;
 864         struct fdtable *fdt;
 865
 866         error = -EMFILE;
 867         spin_lock(&files->file_lock);
 868
 869 repeat:
 870         fdt = files_fdtable(files);
 871         fd = find_next_zero_bit(fdt->open_fds->fds_bits, fdt->max_fds,
 872                                 files->next_fd);
 873
 874         /*
 875          * N.B. For clone tasks sharing a files structure, this test
 876          * will limit the total number of files that can be opened.
 877          */
 878         if (fd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
 879                 goto out;
 880
 881         /* Do we need to expand the fd array or fd set?  */
 882         error = expand_files(files, fd);
 883         if (error < 0)
 884                 goto out;
 885
 886         if (error) {
 887                 /*
 888                  * If we needed to expand the fs array we
 889                  * might have blocked - try again.
 890                  */
 891                 error = -EMFILE;
 892                 goto repeat;
 893         }
 894
 895         FD_SET(fd, fdt->open_fds);
 896         if (flags & O_CLOEXEC)
 897                 FD_SET(fd, fdt->close_on_exec);
 898         else
 899                 FD_CLR(fd, fdt->close_on_exec);
 900         files->next_fd = fd + 1;
 901 #if 1
 902         /* Sanity check */
 903         if (fdt->fd[fd] != NULL) {
 904                 printk(KERN_WARNING "get_unused_fd: slot %d not NULL!\n", fd);
 905                 fdt->fd[fd] = NULL;
 906         }
 907 #endif
 908         error = fd;
 909
 910 out:
 911         spin_unlock(&files->file_lock);
 912         return error;
 913 }
 914
 915 int get_unused_fd(void)
 916 {
 917         return get_unused_fd_flags(0);
 918 }
 919
 920 EXPORT_SYMBOL(get_unused_fd);
 921
 922 static void __put_unused_fd(struct files_struct *files, unsigned int fd)
 923 {
 924         struct fdtable *fdt = files_fdtable(files);
 925         __FD_CLR(fd, fdt->open_fds);
 926         if (fd < files->next_fd)
 927                 files->next_fd = fd;
 928 }
 929
 930 void fastcall put_unused_fd(unsigned int fd)
 931 {
 932         struct files_struct *files = current->files;
 933         spin_lock(&files->file_lock);
 934         __put_unused_fd(files, fd);
 935         spin_unlock(&files->file_lock);
 936 }
 937
 938 EXPORT_SYMBOL(put_unused_fd);
 939
 940 /*
 941  * Install a file pointer in the fd array.
 942  *
 943  * The VFS is full of places where we drop the files lock between
 944  * setting the open_fds bitmap and installing the file in the file
 945  * array.  At any such point, we are vulnerable to a dup2() race
 946  * installing a file in the array before us.  We need to detect this and
 947  * fput() the struct file we are about to overwrite in this case.
 948  *
 949  * It should never happen - if we allow dup2() do it, _really_ bad things
 950  * will follow.
 951  */
 952
 953 void fastcall fd_install(unsigned int fd, struct file * file)
 954 {
 955         struct files_struct *files = current->files;
 956         struct fdtable *fdt;
 957         spin_lock(&files->file_lock);
 958         fdt = files_fdtable(files);
 959         BUG_ON(fdt->fd[fd] != NULL);
 960         rcu_assign_pointer(fdt->fd[fd], file);
 961         spin_unlock(&files->file_lock);
 962 }
 963
 964 EXPORT_SYMBOL(fd_install);
 965
 966 long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
 967 {
 968         char *tmp = getname(filename);
 969         int fd = PTR_ERR(tmp);
 970
 971         if (!IS_ERR(tmp)) {
 972                 fd = get_unused_fd_flags(flags);
 973                 if (fd >= 0) {
 974                         struct file *f = do_filp_open(dfd, tmp, flags, mode);
 975                         if (IS_ERR(f)) {
 976                                 put_unused_fd(fd);
 977                                 fd = PTR_ERR(f);
 978                         } else {
 979                                 fsnotify_open(f->f_path.dentry);
 980                                 fd_install(fd, f);
 981                         }
 982                 }
 983                 putname(tmp);
 984         }
 985         return fd;
 986 }
 987
 988 asmlinkage long sys_open(const char __user *filename, int flags, int mode)
 989 {
 990         long ret;
 991
 992         if (force_o_largefile())
 993                 flags |= O_LARGEFILE;
 994
 995         ret = do_sys_open(AT_FDCWD, filename, flags, mode);
 996         /* avoid REGPARM breakage on x86: */
 997         prevent_tail_call(ret);
 998         return ret;
 999 }
1000 EXPORT_SYMBOL_GPL(sys_open);
1001
1002 asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
1003                            int mode)
1004 {
1005         long ret;
1006
1007         if (force_o_largefile())
1008                 flags |= O_LARGEFILE;
1009
1010         ret = do_sys_open(dfd, filename, flags, mode);
1011         /* avoid REGPARM breakage on x86: */
1012         prevent_tail_call(ret);
1013         return ret;
1014 }
1015
1016 #ifndef __alpha__
1017
1018 /*
1019  * For backward compatibility?  Maybe this should be moved
1020  * into arch/i386 instead?
1021  */
1022 asmlinkage long sys_creat(const char __user * pathname, int mode)
1023 {
1024         return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
1025 }
1026
1027 #endif
1028
1029 /*
1030  * "id" is the POSIX thread ID. We use the
1031  * files pointer for this..
1032  */
1033 int filp_close(struct file *filp, fl_owner_t id)
1034 {
1035         int retval = 0;
1036
1037         if (!file_count(filp)) {
1038                 printk(KERN_ERR "VFS: Close: file count is 0\n");
1039                 return 0;
1040         }
1041
1042         if (filp->f_op && filp->f_op->flush)
1043                 retval = filp->f_op->flush(filp, id);
1044
1045         dnotify_flush(filp, id);
1046         locks_remove_posix(filp, id);
1047         fput(filp);
1048         return retval;
1049 }
1050
1051 EXPORT_SYMBOL(filp_close);
1052
1053 /*
1054  * Careful here! We test whether the file pointer is NULL before
1055  * releasing the fd. This ensures that one clone task can't release
1056  * an fd while another clone is opening it.
1057  */
1058 asmlinkage long sys_close(unsigned int fd)
1059 {
1060         struct file * filp;
1061         struct files_struct *files = current->files;
1062         struct fdtable *fdt;
1063         int retval;
1064
1065         spin_lock(&files->file_lock);
1066         fdt = files_fdtable(files);
1067         if (fd >= fdt->max_fds)
1068                 goto out_unlock;
1069         filp = fdt->fd[fd];
1070         if (!filp)
1071                 goto out_unlock;
1072         rcu_assign_pointer(fdt->fd[fd], NULL);
1073         FD_CLR(fd, fdt->close_on_exec);
1074         __put_unused_fd(files, fd);
1075         spin_unlock(&files->file_lock);
1076         retval = filp_close(filp, files);
1077
1078         /* can't restart close syscall because file table entry was cleared */
1079         if (unlikely(retval == -ERESTARTSYS ||
1080                      retval == -ERESTARTNOINTR ||
1081                      retval == -ERESTARTNOHAND ||
1082                      retval == -ERESTART_RESTARTBLOCK))
1083                 retval = -EINTR;
1084
1085         return retval;
1086
1087 out_unlock:
1088         spin_unlock(&files->file_lock);
1089         return -EBADF;
1090 }
1091
1092 EXPORT_SYMBOL(sys_close);
1093
1094 /*
1095  * This routine simulates a hangup on the tty, to arrange that users
1096  * are given clean terminals at login time.
1097  */
1098 asmlinkage long sys_vhangup(void)
1099 {
1100         if (capable(CAP_SYS_TTY_CONFIG)) {
1101                 /* XXX: this needs locking */
1102                 tty_vhangup(current->signal->tty);
1103                 return 0;
1104         }
1105         return -EPERM;
1106 }
1107
1108 /*
1109  * Called when an inode is about to be open.
1110  * We use this to disallow opening large files on 32bit systems if
1111  * the caller didn't specify O_LARGEFILE.  On 64bit systems we force
1112  * on this flag in sys_open.
1113  */
1114 int generic_file_open(struct inode * inode, struct file * filp)
1115 {
1116         if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
1117                 return -EFBIG;
1118         return 0;
1119 }
1120
1121 EXPORT_SYMBOL(generic_file_open);
1122
1123 /*
1124  * This is used by subsystems that don't want seekable
1125  * file descriptors
1126  */
1127 int nonseekable_open(struct inode *inode, struct file *filp)
1128 {
1129         filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
1130         return 0;
1131 }
1132
1133 EXPORT_SYMBOL(nonseekable_open);