fs/nfsd/vfs.c

   1 /*
   2  * File operations used by nfsd. Some of these have been ripped from
   3  * other parts of the kernel because they weren't exported, others
   4  * are partial duplicates with added or changed functionality.
   5  *
   6  * Note that several functions dget() the dentry upon which they want
   7  * to act, most notably those that create directory entries. Response
   8  * dentry's are dput()'d if necessary in the release callback.
   9  * So if you notice code paths that apparently fail to dput() the
  10  * dentry, don't worry--they have been taken care of.
  11  *
  12  * Copyright (C) 1995-1999 Olaf Kirch <[email protected]>
  13  * Zerocpy NFS support (C) 2002 Hirokazu Takahashi <[email protected]>
  14  */
  15
  16 #include <linux/fs.h>
  17 #include <linux/file.h>
  18 #include <linux/splice.h>
  19 #include <linux/falloc.h>
  20 #include <linux/fcntl.h>
  21 #include <linux/namei.h>
  22 #include <linux/delay.h>
  23 #include <linux/fsnotify.h>
  24 #include <linux/posix_acl_xattr.h>
  25 #include <linux/xattr.h>
  26 #include <linux/jhash.h>
  27 #include <linux/ima.h>
  28 #include <linux/slab.h>
  29 #include <asm/uaccess.h>
  30 #include <linux/exportfs.h>
  31 #include <linux/writeback.h>
  32 #include <linux/security.h>
  33
  34 #ifdef CONFIG_NFSD_V3
  35 #include "xdr3.h"
  36 #endif /* CONFIG_NFSD_V3 */
  37
  38 #ifdef CONFIG_NFSD_V4
  39 #include "acl.h"
  40 #include "idmap.h"
  41 #endif /* CONFIG_NFSD_V4 */
  42
  43 #include "nfsd.h"
  44 #include "vfs.h"
  45
  46 #define NFSDDBG_FACILITY                NFSDDBG_FILEOP
  47
  48
  49 /*
  50  * This is a cache of readahead params that help us choose the proper
  51  * readahead strategy. Initially, we set all readahead parameters to 0
  52  * and let the VFS handle things.
  53  * If you increase the number of cached files very much, you'll need to
  54  * add a hash table here.
  55  */
  56 struct raparms {
  57         struct raparms          *p_next;
  58         unsigned int            p_count;
  59         ino_t                   p_ino;
  60         dev_t                   p_dev;
  61         int                     p_set;
  62         struct file_ra_state    p_ra;
  63         unsigned int            p_hindex;
  64 };
  65
  66 struct raparm_hbucket {
  67         struct raparms          *pb_head;
  68         spinlock_t              pb_lock;
  69 } ____cacheline_aligned_in_smp;
  70
  71 #define RAPARM_HASH_BITS        4
  72 #define RAPARM_HASH_SIZE        (1<<RAPARM_HASH_BITS)
  73 #define RAPARM_HASH_MASK        (RAPARM_HASH_SIZE-1)
  74 static struct raparm_hbucket    raparm_hash[RAPARM_HASH_SIZE];
  75
  76 /*
  77  * Called from nfsd_lookup and encode_dirent. Check if we have crossed
  78  * a mount point.
  79  * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged,
  80  *  or nfs_ok having possibly changed *dpp and *expp
  81  */
  82 int
  83 nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
  84                         struct svc_export **expp)
  85 {
  86         struct svc_export *exp = *expp, *exp2 = NULL;
  87         struct dentry *dentry = *dpp;
  88         struct path path = {.mnt = mntget(exp->ex_path.mnt),
  89                             .dentry = dget(dentry)};
  90         int err = 0;
  91
  92         err = follow_down(&path);
  93         if (err < 0)
  94                 goto out;
  95
  96         exp2 = rqst_exp_get_by_name(rqstp, &path);
  97         if (IS_ERR(exp2)) {
  98                 err = PTR_ERR(exp2);
  99                 /*
 100                  * We normally allow NFS clients to continue
 101                  * "underneath" a mountpoint that is not exported.
 102                  * The exception is V4ROOT, where no traversal is ever
 103                  * allowed without an explicit export of the new
 104                  * directory.
 105                  */
 106                 if (err == -ENOENT && !(exp->ex_flags & NFSEXP_V4ROOT))
 107                         err = 0;
 108                 path_put(&path);
 109                 goto out;
 110         }
 111         if (nfsd_v4client(rqstp) ||
 112                 (exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) {
 113                 /* successfully crossed mount point */
 114                 /*
 115                  * This is subtle: path.dentry is *not* on path.mnt
 116                  * at this point.  The only reason we are safe is that
 117                  * original mnt is pinned down by exp, so we should
 118                  * put path *before* putting exp
 119                  */
 120                 *dpp = path.dentry;
 121                 path.dentry = dentry;
 122                 *expp = exp2;
 123                 exp2 = exp;
 124         }
 125         path_put(&path);
 126         exp_put(exp2);
 127 out:
 128         return err;
 129 }
 130
 131 static void follow_to_parent(struct path *path)
 132 {
 133         struct dentry *dp;
 134
 135         while (path->dentry == path->mnt->mnt_root && follow_up(path))
 136                 ;
 137         dp = dget_parent(path->dentry);
 138         dput(path->dentry);
 139         path->dentry = dp;
 140 }
 141
 142 static int nfsd_lookup_parent(struct svc_rqst *rqstp, struct dentry *dparent, struct svc_export **exp, struct dentry **dentryp)
 143 {
 144         struct svc_export *exp2;
 145         struct path path = {.mnt = mntget((*exp)->ex_path.mnt),
 146                             .dentry = dget(dparent)};
 147
 148         follow_to_parent(&path);
 149
 150         exp2 = rqst_exp_parent(rqstp, &path);
 151         if (PTR_ERR(exp2) == -ENOENT) {
 152                 *dentryp = dget(dparent);
 153         } else if (IS_ERR(exp2)) {
 154                 path_put(&path);
 155                 return PTR_ERR(exp2);
 156         } else {
 157                 *dentryp = dget(path.dentry);
 158                 exp_put(*exp);
 159                 *exp = exp2;
 160         }
 161         path_put(&path);
 162         return 0;
 163 }
 164
 165 /*
 166  * For nfsd purposes, we treat V4ROOT exports as though there was an
 167  * export at *every* directory.
 168  */
 169 int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp)
 170 {
 171         if (d_mountpoint(dentry))
 172                 return 1;
 173         if (nfsd4_is_junction(dentry))
 174                 return 1;
 175         if (!(exp->ex_flags & NFSEXP_V4ROOT))
 176                 return 0;
 177         return dentry->d_inode != NULL;
 178 }
 179
 180 __be32
 181 nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
 182                    const char *name, unsigned int len,
 183                    struct svc_export **exp_ret, struct dentry **dentry_ret)
 184 {
 185         struct svc_export       *exp;
 186         struct dentry           *dparent;
 187         struct dentry           *dentry;
 188         int                     host_err;
 189
 190         dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
 191
 192         dparent = fhp->fh_dentry;
 193         exp = exp_get(fhp->fh_export);
 194
 195         /* Lookup the name, but don't follow links */
 196         if (isdotent(name, len)) {
 197                 if (len==1)
 198                         dentry = dget(dparent);
 199                 else if (dparent != exp->ex_path.dentry)
 200                         dentry = dget_parent(dparent);
 201                 else if (!EX_NOHIDE(exp) && !nfsd_v4client(rqstp))
 202                         dentry = dget(dparent); /* .. == . just like at / */
 203                 else {
 204                         /* checking mountpoint crossing is very different when stepping up */
 205                         host_err = nfsd_lookup_parent(rqstp, dparent, &exp, &dentry);
 206                         if (host_err)
 207                                 goto out_nfserr;
 208                 }
 209         } else {
 210                 /*
 211                  * In the nfsd4_open() case, this may be held across
 212                  * subsequent open and delegation acquisition which may
 213                  * need to take the child's i_mutex:
 214                  */
 215                 fh_lock_nested(fhp, I_MUTEX_PARENT);
 216                 dentry = lookup_one_len(name, dparent, len);
 217                 host_err = PTR_ERR(dentry);
 218                 if (IS_ERR(dentry))
 219                         goto out_nfserr;
 220                 /*
 221                  * check if we have crossed a mount point ...
 222                  */
 223                 if (nfsd_mountpoint(dentry, exp)) {
 224                         if ((host_err = nfsd_cross_mnt(rqstp, &dentry, &exp))) {
 225                                 dput(dentry);
 226                                 goto out_nfserr;
 227                         }
 228                 }
 229         }
 230         *dentry_ret = dentry;
 231         *exp_ret = exp;
 232         return 0;
 233
 234 out_nfserr:
 235         exp_put(exp);
 236         return nfserrno(host_err);
 237 }
 238
 239 /*
 240  * Look up one component of a pathname.
 241  * N.B. After this call _both_ fhp and resfh need an fh_put
 242  *
 243  * If the lookup would cross a mountpoint, and the mounted filesystem
 244  * is exported to the client with NFSEXP_NOHIDE, then the lookup is
 245  * accepted as it stands and the mounted directory is
 246  * returned. Otherwise the covered directory is returned.
 247  * NOTE: this mountpoint crossing is not supported properly by all
 248  *   clients and is explicitly disallowed for NFSv3
 249  *      NeilBrown <[email protected]>
 250  */
 251 __be32
 252 nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
 253                                 unsigned int len, struct svc_fh *resfh)
 254 {
 255         struct svc_export       *exp;
 256         struct dentry           *dentry;
 257         __be32 err;
 258
 259         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
 260         if (err)
 261                 return err;
 262         err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
 263         if (err)
 264                 return err;
 265         err = check_nfsd_access(exp, rqstp);
 266         if (err)
 267                 goto out;
 268         /*
 269          * Note: we compose the file handle now, but as the
 270          * dentry may be negative, it may need to be updated.
 271          */
 272         err = fh_compose(resfh, exp, dentry, fhp);
 273         if (!err && !dentry->d_inode)
 274                 err = nfserr_noent;
 275 out:
 276         dput(dentry);
 277         exp_put(exp);
 278         return err;
 279 }
 280
 281 /*
 282  * Commit metadata changes to stable storage.
 283  */
 284 static int
 285 commit_metadata(struct svc_fh *fhp)
 286 {
 287         struct inode *inode = fhp->fh_dentry->d_inode;
 288         const struct export_operations *export_ops = inode->i_sb->s_export_op;
 289
 290         if (!EX_ISSYNC(fhp->fh_export))
 291                 return 0;
 292
 293         if (export_ops->commit_metadata)
 294                 return export_ops->commit_metadata(inode);
 295         return sync_inode_metadata(inode, 1);
 296 }
 297
 298 /*
 299  * Go over the attributes and take care of the small differences between
 300  * NFS semantics and what Linux expects.
 301  */
 302 static void
 303 nfsd_sanitize_attrs(struct inode *inode, struct iattr *iap)
 304 {
 305         /*
 306          * NFSv2 does not differentiate between "set-[ac]time-to-now"
 307          * which only requires access, and "set-[ac]time-to-X" which
 308          * requires ownership.
 309          * So if it looks like it might be "set both to the same time which
 310          * is close to now", and if inode_change_ok fails, then we
 311          * convert to "set to now" instead of "set to explicit time"
 312          *
 313          * We only call inode_change_ok as the last test as technically
 314          * it is not an interface that we should be using.
 315          */
 316 #define BOTH_TIME_SET (ATTR_ATIME_SET | ATTR_MTIME_SET)
 317 #define MAX_TOUCH_TIME_ERROR (30*60)
 318         if ((iap->ia_valid & BOTH_TIME_SET) == BOTH_TIME_SET &&
 319             iap->ia_mtime.tv_sec == iap->ia_atime.tv_sec) {
 320                 /*
 321                  * Looks probable.
 322                  *
 323                  * Now just make sure time is in the right ballpark.
 324                  * Solaris, at least, doesn't seem to care what the time
 325                  * request is.  We require it be within 30 minutes of now.
 326                  */
 327                 time_t delta = iap->ia_atime.tv_sec - get_seconds();
 328                 if (delta < 0)
 329                         delta = -delta;
 330                 if (delta < MAX_TOUCH_TIME_ERROR &&
 331                     inode_change_ok(inode, iap) != 0) {
 332                         /*
 333                          * Turn off ATTR_[AM]TIME_SET but leave ATTR_[AM]TIME.
 334                          * This will cause notify_change to set these times
 335                          * to "now"
 336                          */
 337                         iap->ia_valid &= ~BOTH_TIME_SET;
 338                 }
 339         }
 340
 341         /* sanitize the mode change */
 342         if (iap->ia_valid & ATTR_MODE) {
 343                 iap->ia_mode &= S_IALLUGO;
 344                 iap->ia_mode |= (inode->i_mode & ~S_IALLUGO);
 345         }
 346
 347         /* Revoke setuid/setgid on chown */
 348         if (!S_ISDIR(inode->i_mode) &&
 349             ((iap->ia_valid & ATTR_UID) || (iap->ia_valid & ATTR_GID))) {
 350                 iap->ia_valid |= ATTR_KILL_PRIV;
 351                 if (iap->ia_valid & ATTR_MODE) {
 352                         /* we're setting mode too, just clear the s*id bits */
 353                         iap->ia_mode &= ~S_ISUID;
 354                         if (iap->ia_mode & S_IXGRP)
 355                                 iap->ia_mode &= ~S_ISGID;
 356                 } else {
 357                         /* set ATTR_KILL_* bits and let VFS handle it */
 358                         iap->ia_valid |= (ATTR_KILL_SUID | ATTR_KILL_SGID);
 359                 }
 360         }
 361 }
 362
 363 static __be32
 364 nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
 365                 struct iattr *iap)
 366 {
 367         struct inode *inode = fhp->fh_dentry->d_inode;
 368         int host_err;
 369
 370         if (iap->ia_size < inode->i_size) {
 371                 __be32 err;
 372
 373                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
 374                                 NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE);
 375                 if (err)
 376                         return err;
 377         }
 378
 379         host_err = get_write_access(inode);
 380         if (host_err)
 381                 goto out_nfserrno;
 382
 383         host_err = locks_verify_truncate(inode, NULL, iap->ia_size);
 384         if (host_err)
 385                 goto out_put_write_access;
 386         return 0;
 387
 388 out_put_write_access:
 389         put_write_access(inode);
 390 out_nfserrno:
 391         return nfserrno(host_err);
 392 }
 393
 394 /*
 395  * Set various file attributes.  After this call fhp needs an fh_put.
 396  */
 397 __be32
 398 nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
 399              int check_guard, time_t guardtime)
 400 {
 401         struct dentry   *dentry;
 402         struct inode    *inode;
 403         int             accmode = NFSD_MAY_SATTR;
 404         umode_t         ftype = 0;
 405         __be32          err;
 406         int             host_err;
 407         bool            get_write_count;
 408         int             size_change = 0;
 409
 410         if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
 411                 accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
 412         if (iap->ia_valid & ATTR_SIZE)
 413                 ftype = S_IFREG;
 414
 415         /* Callers that do fh_verify should do the fh_want_write: */
 416         get_write_count = !fhp->fh_dentry;
 417
 418         /* Get inode */
 419         err = fh_verify(rqstp, fhp, ftype, accmode);
 420         if (err)
 421                 goto out;
 422         if (get_write_count) {
 423                 host_err = fh_want_write(fhp);
 424                 if (host_err)
 425                         return nfserrno(host_err);
 426         }
 427
 428         dentry = fhp->fh_dentry;
 429         inode = dentry->d_inode;
 430
 431         /* Ignore any mode updates on symlinks */
 432         if (S_ISLNK(inode->i_mode))
 433                 iap->ia_valid &= ~ATTR_MODE;
 434
 435         if (!iap->ia_valid)
 436                 goto out;
 437
 438         nfsd_sanitize_attrs(inode, iap);
 439
 440         /*
 441          * The size case is special, it changes the file in addition to the
 442          * attributes.
 443          */
 444         if (iap->ia_valid & ATTR_SIZE) {
 445                 err = nfsd_get_write_access(rqstp, fhp, iap);
 446                 if (err)
 447                         goto out;
 448                 size_change = 1;
 449
 450                 /*
 451                  * RFC5661, Section 18.30.4:
 452                  *   Changing the size of a file with SETATTR indirectly
 453                  *   changes the time_modify and change attributes.
 454                  *
 455                  * (and similar for the older RFCs)
 456                  */
 457                 if (iap->ia_size != i_size_read(inode))
 458                         iap->ia_valid |= ATTR_MTIME;
 459         }
 460
 461         iap->ia_valid |= ATTR_CTIME;
 462
 463         if (check_guard && guardtime != inode->i_ctime.tv_sec) {
 464                 err = nfserr_notsync;
 465                 goto out_put_write_access;
 466         }
 467
 468         fh_lock(fhp);
 469         host_err = notify_change(dentry, iap, NULL);
 470         fh_unlock(fhp);
 471         err = nfserrno(host_err);
 472
 473 out_put_write_access:
 474         if (size_change)
 475                 put_write_access(inode);
 476         if (!err)
 477                 err = nfserrno(commit_metadata(fhp));
 478 out:
 479         return err;
 480 }
 481
 482 #if defined(CONFIG_NFSD_V4)
 483 /*
 484  * NFS junction information is stored in an extended attribute.
 485  */
 486 #define NFSD_JUNCTION_XATTR_NAME        XATTR_TRUSTED_PREFIX "junction.nfs"
 487
 488 /**
 489  * nfsd4_is_junction - Test if an object could be an NFS junction
 490  *
 491  * @dentry: object to test
 492  *
 493  * Returns 1 if "dentry" appears to contain NFS junction information.
 494  * Otherwise 0 is returned.
 495  */
 496 int nfsd4_is_junction(struct dentry *dentry)
 497 {
 498         struct inode *inode = dentry->d_inode;
 499
 500         if (inode == NULL)
 501                 return 0;
 502         if (inode->i_mode & S_IXUGO)
 503                 return 0;
 504         if (!(inode->i_mode & S_ISVTX))
 505                 return 0;
 506         if (vfs_getxattr(dentry, NFSD_JUNCTION_XATTR_NAME, NULL, 0) <= 0)
 507                 return 0;
 508         return 1;
 509 }
 510 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
 511 __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
 512                 struct xdr_netobj *label)
 513 {
 514         __be32 error;
 515         int host_error;
 516         struct dentry *dentry;
 517
 518         error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR);
 519         if (error)
 520                 return error;
 521
 522         dentry = fhp->fh_dentry;
 523
 524         mutex_lock(&dentry->d_inode->i_mutex);
 525         host_error = security_inode_setsecctx(dentry, label->data, label->len);
 526         mutex_unlock(&dentry->d_inode->i_mutex);
 527         return nfserrno(host_error);
 528 }
 529 #else
 530 __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
 531                 struct xdr_netobj *label)
 532 {
 533         return nfserr_notsupp;
 534 }
 535 #endif
 536
 537 __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
 538                            struct file *file, loff_t offset, loff_t len,
 539                            int flags)
 540 {
 541         __be32 err;
 542         int error;
 543
 544         if (!S_ISREG(file_inode(file)->i_mode))
 545                 return nfserr_inval;
 546
 547         err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, NFSD_MAY_WRITE);
 548         if (err)
 549                 return err;
 550
 551         error = vfs_fallocate(file, flags, offset, len);
 552         if (!error)
 553                 error = commit_metadata(fhp);
 554
 555         return nfserrno(error);
 556 }
 557 #endif /* defined(CONFIG_NFSD_V4) */
 558
 559 #ifdef CONFIG_NFSD_V3
 560 /*
 561  * Check server access rights to a file system object
 562  */
 563 struct accessmap {
 564         u32             access;
 565         int             how;
 566 };
 567 static struct accessmap nfs3_regaccess[] = {
 568     {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
 569     {   NFS3_ACCESS_EXECUTE,    NFSD_MAY_EXEC                   },
 570     {   NFS3_ACCESS_MODIFY,     NFSD_MAY_WRITE|NFSD_MAY_TRUNC   },
 571     {   NFS3_ACCESS_EXTEND,     NFSD_MAY_WRITE                  },
 572
 573     {   0,                      0                               }
 574 };
 575
 576 static struct accessmap nfs3_diraccess[] = {
 577     {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
 578     {   NFS3_ACCESS_LOOKUP,     NFSD_MAY_EXEC                   },
 579     {   NFS3_ACCESS_MODIFY,     NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC},
 580     {   NFS3_ACCESS_EXTEND,     NFSD_MAY_EXEC|NFSD_MAY_WRITE    },
 581     {   NFS3_ACCESS_DELETE,     NFSD_MAY_REMOVE                 },
 582
 583     {   0,                      0                               }
 584 };
 585
 586 static struct accessmap nfs3_anyaccess[] = {
 587         /* Some clients - Solaris 2.6 at least, make an access call
 588          * to the server to check for access for things like /dev/null
 589          * (which really, the server doesn't care about).  So
 590          * We provide simple access checking for them, looking
 591          * mainly at mode bits, and we make sure to ignore read-only
 592          * filesystem checks
 593          */
 594     {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
 595     {   NFS3_ACCESS_EXECUTE,    NFSD_MAY_EXEC                   },
 596     {   NFS3_ACCESS_MODIFY,     NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS    },
 597     {   NFS3_ACCESS_EXTEND,     NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS    },
 598
 599     {   0,                      0                               }
 600 };
 601
 602 __be32
 603 nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported)
 604 {
 605         struct accessmap        *map;
 606         struct svc_export       *export;
 607         struct dentry           *dentry;
 608         u32                     query, result = 0, sresult = 0;
 609         __be32                  error;
 610
 611         error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
 612         if (error)
 613                 goto out;
 614
 615         export = fhp->fh_export;
 616         dentry = fhp->fh_dentry;
 617
 618         if (d_is_reg(dentry))
 619                 map = nfs3_regaccess;
 620         else if (d_is_dir(dentry))
 621                 map = nfs3_diraccess;
 622         else
 623                 map = nfs3_anyaccess;
 624
 625
 626         query = *access;
 627         for  (; map->access; map++) {
 628                 if (map->access & query) {
 629                         __be32 err2;
 630
 631                         sresult |= map->access;
 632
 633                         err2 = nfsd_permission(rqstp, export, dentry, map->how);
 634                         switch (err2) {
 635                         case nfs_ok:
 636                                 result |= map->access;
 637                                 break;
 638
 639                         /* the following error codes just mean the access was not allowed,
 640                          * rather than an error occurred */
 641                         case nfserr_rofs:
 642                         case nfserr_acces:
 643                         case nfserr_perm:
 644                                 /* simply don't "or" in the access bit. */
 645                                 break;
 646                         default:
 647                                 error = err2;
 648                                 goto out;
 649                         }
 650                 }
 651         }
 652         *access = result;
 653         if (supported)
 654                 *supported = sresult;
 655
 656  out:
 657         return error;
 658 }
 659 #endif /* CONFIG_NFSD_V3 */
 660
 661 static int nfsd_open_break_lease(struct inode *inode, int access)
 662 {
 663         unsigned int mode;
 664
 665         if (access & NFSD_MAY_NOT_BREAK_LEASE)
 666                 return 0;
 667         mode = (access & NFSD_MAY_WRITE) ? O_WRONLY : O_RDONLY;
 668         return break_lease(inode, mode | O_NONBLOCK);
 669 }
 670
 671 /*
 672  * Open an existing file or directory.
 673  * The may_flags argument indicates the type of open (read/write/lock)
 674  * and additional flags.
 675  * N.B. After this call fhp needs an fh_put
 676  */
 677 __be32
 678 nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
 679                         int may_flags, struct file **filp)
 680 {
 681         struct path     path;
 682         struct inode    *inode;
 683         struct file     *file;
 684         int             flags = O_RDONLY|O_LARGEFILE;
 685         __be32          err;
 686         int             host_err = 0;
 687
 688         validate_process_creds();
 689
 690         /*
 691          * If we get here, then the client has already done an "open",
 692          * and (hopefully) checked permission - so allow OWNER_OVERRIDE
 693          * in case a chmod has now revoked permission.
 694          *
 695          * Arguably we should also allow the owner override for
 696          * directories, but we never have and it doesn't seem to have
 697          * caused anyone a problem.  If we were to change this, note
 698          * also that our filldir callbacks would need a variant of
 699          * lookup_one_len that doesn't check permissions.
 700          */
 701         if (type == S_IFREG)
 702                 may_flags |= NFSD_MAY_OWNER_OVERRIDE;
 703         err = fh_verify(rqstp, fhp, type, may_flags);
 704         if (err)
 705                 goto out;
 706
 707         path.mnt = fhp->fh_export->ex_path.mnt;
 708         path.dentry = fhp->fh_dentry;
 709         inode = path.dentry->d_inode;
 710
 711         /* Disallow write access to files with the append-only bit set
 712          * or any access when mandatory locking enabled
 713          */
 714         err = nfserr_perm;
 715         if (IS_APPEND(inode) && (may_flags & NFSD_MAY_WRITE))
 716                 goto out;
 717         /*
 718          * We must ignore files (but only files) which might have mandatory
 719          * locks on them because there is no way to know if the accesser has
 720          * the lock.
 721          */
 722         if (S_ISREG((inode)->i_mode) && mandatory_lock(inode))
 723                 goto out;
 724
 725         if (!inode->i_fop)
 726                 goto out;
 727
 728         host_err = nfsd_open_break_lease(inode, may_flags);
 729         if (host_err) /* NOMEM or WOULDBLOCK */
 730                 goto out_nfserr;
 731
 732         if (may_flags & NFSD_MAY_WRITE) {
 733                 if (may_flags & NFSD_MAY_READ)
 734                         flags = O_RDWR|O_LARGEFILE;
 735                 else
 736                         flags = O_WRONLY|O_LARGEFILE;
 737         }
 738
 739         file = dentry_open(&path, flags, current_cred());
 740         if (IS_ERR(file)) {
 741                 host_err = PTR_ERR(file);
 742                 goto out_nfserr;
 743         }
 744
 745         host_err = ima_file_check(file, may_flags, 0);
 746         if (host_err) {
 747                 nfsd_close(file);
 748                 goto out_nfserr;
 749         }
 750
 751         if (may_flags & NFSD_MAY_64BIT_COOKIE)
 752                 file->f_mode |= FMODE_64BITHASH;
 753         else
 754                 file->f_mode |= FMODE_32BITHASH;
 755
 756         *filp = file;
 757 out_nfserr:
 758         err = nfserrno(host_err);
 759 out:
 760         validate_process_creds();
 761         return err;
 762 }
 763
 764 /*
 765  * Close a file.
 766  */
 767 void
 768 nfsd_close(struct file *filp)
 769 {
 770         fput(filp);
 771 }
 772
 773 /*
 774  * Obtain the readahead parameters for the file
 775  * specified by (dev, ino).
 776  */
 777
 778 static inline struct raparms *
 779 nfsd_get_raparms(dev_t dev, ino_t ino)
 780 {
 781         struct raparms  *ra, **rap, **frap = NULL;
 782         int depth = 0;
 783         unsigned int hash;
 784         struct raparm_hbucket *rab;
 785
 786         hash = jhash_2words(dev, ino, 0xfeedbeef) & RAPARM_HASH_MASK;
 787         rab = &raparm_hash[hash];
 788
 789         spin_lock(&rab->pb_lock);
 790         for (rap = &rab->pb_head; (ra = *rap); rap = &ra->p_next) {
 791                 if (ra->p_ino == ino && ra->p_dev == dev)
 792                         goto found;
 793                 depth++;
 794                 if (ra->p_count == 0)
 795                         frap = rap;
 796         }
 797         depth = nfsdstats.ra_size;
 798         if (!frap) {
 799                 spin_unlock(&rab->pb_lock);
 800                 return NULL;
 801         }
 802         rap = frap;
 803         ra = *frap;
 804         ra->p_dev = dev;
 805         ra->p_ino = ino;
 806         ra->p_set = 0;
 807         ra->p_hindex = hash;
 808 found:
 809         if (rap != &rab->pb_head) {
 810                 *rap = ra->p_next;
 811                 ra->p_next   = rab->pb_head;
 812                 rab->pb_head = ra;
 813         }
 814         ra->p_count++;
 815         nfsdstats.ra_depth[depth*10/nfsdstats.ra_size]++;
 816         spin_unlock(&rab->pb_lock);
 817         return ra;
 818 }
 819
 820 /*
 821  * Grab and keep cached pages associated with a file in the svc_rqst
 822  * so that they can be passed to the network sendmsg/sendpage routines
 823  * directly. They will be released after the sending has completed.
 824  */
 825 static int
 826 nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
 827                   struct splice_desc *sd)
 828 {
 829         struct svc_rqst *rqstp = sd->u.data;
 830         struct page **pp = rqstp->rq_next_page;
 831         struct page *page = buf->page;
 832         size_t size;
 833
 834         size = sd->len;
 835
 836         if (rqstp->rq_res.page_len == 0) {
 837                 get_page(page);
 838                 put_page(*rqstp->rq_next_page);
 839                 *(rqstp->rq_next_page++) = page;
 840                 rqstp->rq_res.page_base = buf->offset;
 841                 rqstp->rq_res.page_len = size;
 842         } else if (page != pp[-1]) {
 843                 get_page(page);
 844                 if (*rqstp->rq_next_page)
 845                         put_page(*rqstp->rq_next_page);
 846                 *(rqstp->rq_next_page++) = page;
 847                 rqstp->rq_res.page_len += size;
 848         } else
 849                 rqstp->rq_res.page_len += size;
 850
 851         return size;
 852 }
 853
 854 static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe,
 855                                     struct splice_desc *sd)
 856 {
 857         return __splice_from_pipe(pipe, sd, nfsd_splice_actor);
 858 }
 859
 860 static __be32
 861 nfsd_finish_read(struct file *file, unsigned long *count, int host_err)
 862 {
 863         if (host_err >= 0) {
 864                 nfsdstats.io_read += host_err;
 865                 *count = host_err;
 866                 fsnotify_access(file);
 867                 return 0;
 868         } else
 869                 return nfserrno(host_err);
 870 }
 871
 872 __be32 nfsd_splice_read(struct svc_rqst *rqstp,
 873                      struct file *file, loff_t offset, unsigned long *count)
 874 {
 875         struct splice_desc sd = {
 876                 .len            = 0,
 877                 .total_len      = *count,
 878                 .pos            = offset,
 879                 .u.data         = rqstp,
 880         };
 881         int host_err;
 882
 883         rqstp->rq_next_page = rqstp->rq_respages + 1;
 884         host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
 885         return nfsd_finish_read(file, count, host_err);
 886 }
 887
 888 __be32 nfsd_readv(struct file *file, loff_t offset, struct kvec *vec, int vlen,
 889                 unsigned long *count)
 890 {
 891         mm_segment_t oldfs;
 892         int host_err;
 893
 894         oldfs = get_fs();
 895         set_fs(KERNEL_DS);
 896         host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset);
 897         set_fs(oldfs);
 898         return nfsd_finish_read(file, count, host_err);
 899 }
 900
 901 static __be32
 902 nfsd_vfs_read(struct svc_rqst *rqstp, struct file *file,
 903               loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
 904 {
 905         if (file->f_op->splice_read && test_bit(RQ_SPLICE_OK, &rqstp->rq_flags))
 906                 return nfsd_splice_read(rqstp, file, offset, count);
 907         else
 908                 return nfsd_readv(file, offset, vec, vlen, count);
 909 }
 910
 911 /*
 912  * Gathered writes: If another process is currently writing to the file,
 913  * there's a high chance this is another nfsd (triggered by a bulk write
 914  * from a client's biod). Rather than syncing the file with each write
 915  * request, we sleep for 10 msec.
 916  *
 917  * I don't know if this roughly approximates C. Juszak's idea of
 918  * gathered writes, but it's a nice and simple solution (IMHO), and it
 919  * seems to work:-)
 920  *
 921  * Note: we do this only in the NFSv2 case, since v3 and higher have a
 922  * better tool (separate unstable writes and commits) for solving this
 923  * problem.
 924  */
 925 static int wait_for_concurrent_writes(struct file *file)
 926 {
 927         struct inode *inode = file_inode(file);
 928         static ino_t last_ino;
 929         static dev_t last_dev;
 930         int err = 0;
 931
 932         if (atomic_read(&inode->i_writecount) > 1
 933             || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) {
 934                 dprintk("nfsd: write defer %d\n", task_pid_nr(current));
 935                 msleep(10);
 936                 dprintk("nfsd: write resume %d\n", task_pid_nr(current));
 937         }
 938
 939         if (inode->i_state & I_DIRTY) {
 940                 dprintk("nfsd: write sync %d\n", task_pid_nr(current));
 941                 err = vfs_fsync(file, 0);
 942         }
 943         last_ino = inode->i_ino;
 944         last_dev = inode->i_sb->s_dev;
 945         return err;
 946 }
 947
 948 static __be32
 949 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
 950                                 loff_t offset, struct kvec *vec, int vlen,
 951                                 unsigned long *cnt, int *stablep)
 952 {
 953         struct svc_export       *exp;
 954         struct inode            *inode;
 955         mm_segment_t            oldfs;
 956         __be32                  err = 0;
 957         int                     host_err;
 958         int                     stable = *stablep;
 959         int                     use_wgather;
 960         loff_t                  pos = offset;
 961         loff_t                  end = LLONG_MAX;
 962         unsigned int            pflags = current->flags;
 963
 964         if (test_bit(RQ_LOCAL, &rqstp->rq_flags))
 965                 /*
 966                  * We want less throttling in balance_dirty_pages()
 967                  * and shrink_inactive_list() so that nfs to
 968                  * localhost doesn't cause nfsd to lock up due to all
 969                  * the client's dirty pages or its congested queue.
 970                  */
 971                 current->flags |= PF_LESS_THROTTLE;
 972
 973         inode = file_inode(file);
 974         exp   = fhp->fh_export;
 975
 976         use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp);
 977
 978         if (!EX_ISSYNC(exp))
 979                 stable = 0;
 980
 981         /* Write the data. */
 982         oldfs = get_fs(); set_fs(KERNEL_DS);
 983         host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &pos);
 984         set_fs(oldfs);
 985         if (host_err < 0)
 986                 goto out_nfserr;
 987         *cnt = host_err;
 988         nfsdstats.io_write += host_err;
 989         fsnotify_modify(file);
 990
 991         if (stable) {
 992                 if (use_wgather) {
 993                         host_err = wait_for_concurrent_writes(file);
 994                 } else {
 995                         if (*cnt)
 996                                 end = offset + *cnt - 1;
 997                         host_err = vfs_fsync_range(file, offset, end, 0);
 998                 }
 999         }
1000
1001 out_nfserr:
1002         dprintk("nfsd: write complete host_err=%d\n", host_err);
1003         if (host_err >= 0)
1004                 err = 0;
1005         else
1006                 err = nfserrno(host_err);
1007         if (test_bit(RQ_LOCAL, &rqstp->rq_flags))
1008                 tsk_restore_flags(current, pflags, PF_LESS_THROTTLE);
1009         return err;
1010 }
1011
1012 __be32 nfsd_get_tmp_read_open(struct svc_rqst *rqstp, struct svc_fh *fhp,
1013                 struct file **file, struct raparms **ra)
1014 {
1015         struct inode *inode;
1016         __be32 err;
1017
1018         err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, file);
1019         if (err)
1020                 return err;
1021
1022         inode = file_inode(*file);
1023
1024         /* Get readahead parameters */
1025         *ra = nfsd_get_raparms(inode->i_sb->s_dev, inode->i_ino);
1026
1027         if (*ra && (*ra)->p_set)
1028                 (*file)->f_ra = (*ra)->p_ra;
1029         return nfs_ok;
1030 }
1031
1032 void nfsd_put_tmp_read_open(struct file *file, struct raparms *ra)
1033 {
1034         /* Write back readahead params */
1035         if (ra) {
1036                 struct raparm_hbucket *rab = &raparm_hash[ra->p_hindex];
1037                 spin_lock(&rab->pb_lock);
1038                 ra->p_ra = file->f_ra;
1039                 ra->p_set = 1;
1040                 ra->p_count--;
1041                 spin_unlock(&rab->pb_lock);
1042         }
1043         nfsd_close(file);
1044 }
1045
1046 /*
1047  * Read data from a file. count must contain the requested read count
1048  * on entry. On return, *count contains the number of bytes actually read.
1049  * N.B. After this call fhp needs an fh_put
1050  */
1051 __be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
1052         loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
1053 {
1054         struct file *file;
1055         struct raparms  *ra;
1056         __be32 err;
1057
1058         err = nfsd_get_tmp_read_open(rqstp, fhp, &file, &ra);
1059         if (err)
1060                 return err;
1061
1062         err = nfsd_vfs_read(rqstp, file, offset, vec, vlen, count);
1063
1064         nfsd_put_tmp_read_open(file, ra);
1065
1066         return err;
1067 }
1068
1069 /*
1070  * Write data to a file.
1071  * The stable flag requests synchronous writes.
1072  * N.B. After this call fhp needs an fh_put
1073  */
1074 __be32
1075 nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1076                 loff_t offset, struct kvec *vec, int vlen, unsigned long *cnt,
1077                 int *stablep)
1078 {
1079         __be32                  err = 0;
1080
1081         if (file) {
1082                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
1083                                 NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE);
1084                 if (err)
1085                         goto out;
1086                 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt,
1087                                 stablep);
1088         } else {
1089                 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
1090                 if (err)
1091                         goto out;
1092
1093                 if (cnt)
1094                         err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen,
1095                                              cnt, stablep);
1096                 nfsd_close(file);
1097         }
1098 out:
1099         return err;
1100 }
1101
1102 #ifdef CONFIG_NFSD_V3
1103 /*
1104  * Commit all pending writes to stable storage.
1105  *
1106  * Note: we only guarantee that data that lies within the range specified
1107  * by the 'offset' and 'count' parameters will be synced.
1108  *
1109  * Unfortunately we cannot lock the file to make sure we return full WCC
1110  * data to the client, as locking happens lower down in the filesystem.
1111  */
1112 __be32
1113 nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
1114                loff_t offset, unsigned long count)
1115 {
1116         struct file     *file;
1117         loff_t          end = LLONG_MAX;
1118         __be32          err = nfserr_inval;
1119
1120         if (offset < 0)
1121                 goto out;
1122         if (count != 0) {
1123                 end = offset + (loff_t)count - 1;
1124                 if (end < offset)
1125                         goto out;
1126         }
1127
1128         err = nfsd_open(rqstp, fhp, S_IFREG,
1129                         NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &file);
1130         if (err)
1131                 goto out;
1132         if (EX_ISSYNC(fhp->fh_export)) {
1133                 int err2 = vfs_fsync_range(file, offset, end, 0);
1134
1135                 if (err2 != -EINVAL)
1136                         err = nfserrno(err2);
1137                 else
1138                         err = nfserr_notsupp;
1139         }
1140
1141         nfsd_close(file);
1142 out:
1143         return err;
1144 }
1145 #endif /* CONFIG_NFSD_V3 */
1146
1147 static __be32
1148 nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp,
1149                         struct iattr *iap)
1150 {
1151         /*
1152          * Mode has already been set earlier in create:
1153          */
1154         iap->ia_valid &= ~ATTR_MODE;
1155         /*
1156          * Setting uid/gid works only for root.  Irix appears to
1157          * send along the gid on create when it tries to implement
1158          * setgid directories via NFS:
1159          */
1160         if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID))
1161                 iap->ia_valid &= ~(ATTR_UID|ATTR_GID);
1162         if (iap->ia_valid)
1163                 return nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
1164         /* Callers expect file metadata to be committed here */
1165         return nfserrno(commit_metadata(resfhp));
1166 }
1167
1168 /* HPUX client sometimes creates a file in mode 000, and sets size to 0.
1169  * setting size to 0 may fail for some specific file systems by the permission
1170  * checking which requires WRITE permission but the mode is 000.
1171  * we ignore the resizing(to 0) on the just new created file, since the size is
1172  * 0 after file created.
1173  *
1174  * call this only after vfs_create() is called.
1175  * */
1176 static void
1177 nfsd_check_ignore_resizing(struct iattr *iap)
1178 {
1179         if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0))
1180                 iap->ia_valid &= ~ATTR_SIZE;
1181 }
1182
1183 /*
1184  * Create a file (regular, directory, device, fifo); UNIX sockets
1185  * not yet implemented.
1186  * If the response fh has been verified, the parent directory should
1187  * already be locked. Note that the parent directory is left locked.
1188  *
1189  * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp
1190  */
1191 __be32
1192 nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1193                 char *fname, int flen, struct iattr *iap,
1194                 int type, dev_t rdev, struct svc_fh *resfhp)
1195 {
1196         struct dentry   *dentry, *dchild = NULL;
1197         struct inode    *dirp;
1198         __be32          err;
1199         __be32          err2;
1200         int             host_err;
1201
1202         err = nfserr_perm;
1203         if (!flen)
1204                 goto out;
1205         err = nfserr_exist;
1206         if (isdotent(fname, flen))
1207                 goto out;
1208
1209         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1210         if (err)
1211                 goto out;
1212
1213         dentry = fhp->fh_dentry;
1214         dirp = dentry->d_inode;
1215
1216         err = nfserr_notdir;
1217         if (!dirp->i_op->lookup)
1218                 goto out;
1219         /*
1220          * Check whether the response file handle has been verified yet.
1221          * If it has, the parent directory should already be locked.
1222          */
1223         if (!resfhp->fh_dentry) {
1224                 host_err = fh_want_write(fhp);
1225                 if (host_err)
1226                         goto out_nfserr;
1227
1228                 /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */
1229                 fh_lock_nested(fhp, I_MUTEX_PARENT);
1230                 dchild = lookup_one_len(fname, dentry, flen);
1231                 host_err = PTR_ERR(dchild);
1232                 if (IS_ERR(dchild))
1233                         goto out_nfserr;
1234                 err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1235                 if (err)
1236                         goto out;
1237         } else {
1238                 /* called from nfsd_proc_create */
1239                 dchild = dget(resfhp->fh_dentry);
1240                 if (!fhp->fh_locked) {
1241                         /* not actually possible */
1242                         printk(KERN_ERR
1243                                 "nfsd_create: parent %pd2 not locked!\n",
1244                                 dentry);
1245                         err = nfserr_io;
1246                         goto out;
1247                 }
1248         }
1249         /*
1250          * Make sure the child dentry is still negative ...
1251          */
1252         err = nfserr_exist;
1253         if (dchild->d_inode) {
1254                 dprintk("nfsd_create: dentry %pd/%pd not negative!\n",
1255                         dentry, dchild);
1256                 goto out;
1257         }
1258
1259         if (!(iap->ia_valid & ATTR_MODE))
1260                 iap->ia_mode = 0;
1261         iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type;
1262
1263         err = nfserr_inval;
1264         if (!S_ISREG(type) && !S_ISDIR(type) && !special_file(type)) {
1265                 printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n",
1266                        type);
1267                 goto out;
1268         }
1269
1270         /*
1271          * Get the dir op function pointer.
1272          */
1273         err = 0;
1274         host_err = 0;
1275         switch (type) {
1276         case S_IFREG:
1277                 host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
1278                 if (!host_err)
1279                         nfsd_check_ignore_resizing(iap);
1280                 break;
1281         case S_IFDIR:
1282                 host_err = vfs_mkdir(dirp, dchild, iap->ia_mode);
1283                 break;
1284         case S_IFCHR:
1285         case S_IFBLK:
1286         case S_IFIFO:
1287         case S_IFSOCK:
1288                 host_err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev);
1289                 break;
1290         }
1291         if (host_err < 0)
1292                 goto out_nfserr;
1293
1294         err = nfsd_create_setattr(rqstp, resfhp, iap);
1295
1296         /*
1297          * nfsd_create_setattr already committed the child.  Transactional
1298          * filesystems had a chance to commit changes for both parent and
1299          * child * simultaneously making the following commit_metadata a
1300          * noop.
1301          */
1302         err2 = nfserrno(commit_metadata(fhp));
1303         if (err2)
1304                 err = err2;
1305         /*
1306          * Update the file handle to get the new inode info.
1307          */
1308         if (!err)
1309                 err = fh_update(resfhp);
1310 out:
1311         if (dchild && !IS_ERR(dchild))
1312                 dput(dchild);
1313         return err;
1314
1315 out_nfserr:
1316         err = nfserrno(host_err);
1317         goto out;
1318 }
1319
1320 #ifdef CONFIG_NFSD_V3
1321
1322 static inline int nfsd_create_is_exclusive(int createmode)
1323 {
1324         return createmode == NFS3_CREATE_EXCLUSIVE
1325                || createmode == NFS4_CREATE_EXCLUSIVE4_1;
1326 }
1327
1328 /*
1329  * NFSv3 and NFSv4 version of nfsd_create
1330  */
1331 __be32
1332 do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1333                 char *fname, int flen, struct iattr *iap,
1334                 struct svc_fh *resfhp, int createmode, u32 *verifier,
1335                 bool *truncp, bool *created)
1336 {
1337         struct dentry   *dentry, *dchild = NULL;
1338         struct inode    *dirp;
1339         __be32          err;
1340         int             host_err;
1341         __u32           v_mtime=0, v_atime=0;
1342
1343         err = nfserr_perm;
1344         if (!flen)
1345                 goto out;
1346         err = nfserr_exist;
1347         if (isdotent(fname, flen))
1348                 goto out;
1349         if (!(iap->ia_valid & ATTR_MODE))
1350                 iap->ia_mode = 0;
1351         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
1352         if (err)
1353                 goto out;
1354
1355         dentry = fhp->fh_dentry;
1356         dirp = dentry->d_inode;
1357
1358         /* Get all the sanity checks out of the way before
1359          * we lock the parent. */
1360         err = nfserr_notdir;
1361         if (!dirp->i_op->lookup)
1362                 goto out;
1363
1364         host_err = fh_want_write(fhp);
1365         if (host_err)
1366                 goto out_nfserr;
1367
1368         fh_lock_nested(fhp, I_MUTEX_PARENT);
1369
1370         /*
1371          * Compose the response file handle.
1372          */
1373         dchild = lookup_one_len(fname, dentry, flen);
1374         host_err = PTR_ERR(dchild);
1375         if (IS_ERR(dchild))
1376                 goto out_nfserr;
1377
1378         /* If file doesn't exist, check for permissions to create one */
1379         if (!dchild->d_inode) {
1380                 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1381                 if (err)
1382                         goto out;
1383         }
1384
1385         err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1386         if (err)
1387                 goto out;
1388
1389         if (nfsd_create_is_exclusive(createmode)) {
1390                 /* solaris7 gets confused (bugid 4218508) if these have
1391                  * the high bit set, so just clear the high bits. If this is
1392                  * ever changed to use different attrs for storing the
1393                  * verifier, then do_open_lookup() will also need to be fixed
1394                  * accordingly.
1395                  */
1396                 v_mtime = verifier[0]&0x7fffffff;
1397                 v_atime = verifier[1]&0x7fffffff;
1398         }
1399
1400         if (dchild->d_inode) {
1401                 err = 0;
1402
1403                 switch (createmode) {
1404                 case NFS3_CREATE_UNCHECKED:
1405                         if (! d_is_reg(dchild))
1406                                 goto out;
1407                         else if (truncp) {
1408                                 /* in nfsv4, we need to treat this case a little
1409                                  * differently.  we don't want to truncate the
1410                                  * file now; this would be wrong if the OPEN
1411                                  * fails for some other reason.  furthermore,
1412                                  * if the size is nonzero, we should ignore it
1413                                  * according to spec!
1414                                  */
1415                                 *truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size;
1416                         }
1417                         else {
1418                                 iap->ia_valid &= ATTR_SIZE;
1419                                 goto set_attr;
1420                         }
1421                         break;
1422                 case NFS3_CREATE_EXCLUSIVE:
1423                         if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
1424                             && dchild->d_inode->i_atime.tv_sec == v_atime
1425                             && dchild->d_inode->i_size  == 0 ) {
1426                                 if (created)
1427                                         *created = 1;
1428                                 break;
1429                         }
1430                 case NFS4_CREATE_EXCLUSIVE4_1:
1431                         if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
1432                             && dchild->d_inode->i_atime.tv_sec == v_atime
1433                             && dchild->d_inode->i_size  == 0 ) {
1434                                 if (created)
1435                                         *created = 1;
1436                                 goto set_attr;
1437                         }
1438                          /* fallthru */
1439                 case NFS3_CREATE_GUARDED:
1440                         err = nfserr_exist;
1441                 }
1442                 fh_drop_write(fhp);
1443                 goto out;
1444         }
1445
1446         host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
1447         if (host_err < 0) {
1448                 fh_drop_write(fhp);
1449                 goto out_nfserr;
1450         }
1451         if (created)
1452                 *created = 1;
1453
1454         nfsd_check_ignore_resizing(iap);
1455
1456         if (nfsd_create_is_exclusive(createmode)) {
1457                 /* Cram the verifier into atime/mtime */
1458                 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
1459                         | ATTR_MTIME_SET|ATTR_ATIME_SET;
1460                 /* XXX someone who knows this better please fix it for nsec */
1461                 iap->ia_mtime.tv_sec = v_mtime;
1462                 iap->ia_atime.tv_sec = v_atime;
1463                 iap->ia_mtime.tv_nsec = 0;
1464                 iap->ia_atime.tv_nsec = 0;
1465         }
1466
1467  set_attr:
1468         err = nfsd_create_setattr(rqstp, resfhp, iap);
1469
1470         /*
1471          * nfsd_create_setattr already committed the child
1472          * (and possibly also the parent).
1473          */
1474         if (!err)
1475                 err = nfserrno(commit_metadata(fhp));
1476
1477         /*
1478          * Update the filehandle to get the new inode info.
1479          */
1480         if (!err)
1481                 err = fh_update(resfhp);
1482
1483  out:
1484         fh_unlock(fhp);
1485         if (dchild && !IS_ERR(dchild))
1486                 dput(dchild);
1487         fh_drop_write(fhp);
1488         return err;
1489
1490  out_nfserr:
1491         err = nfserrno(host_err);
1492         goto out;
1493 }
1494 #endif /* CONFIG_NFSD_V3 */
1495
1496 /*
1497  * Read a symlink. On entry, *lenp must contain the maximum path length that
1498  * fits into the buffer. On return, it contains the true length.
1499  * N.B. After this call fhp needs an fh_put
1500  */
1501 __be32
1502 nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
1503 {
1504         struct inode    *inode;
1505         mm_segment_t    oldfs;
1506         __be32          err;
1507         int             host_err;
1508         struct path path;
1509
1510         err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP);
1511         if (err)
1512                 goto out;
1513
1514         path.mnt = fhp->fh_export->ex_path.mnt;
1515         path.dentry = fhp->fh_dentry;
1516         inode = path.dentry->d_inode;
1517
1518         err = nfserr_inval;
1519         if (!inode->i_op->readlink)
1520                 goto out;
1521
1522         touch_atime(&path);
1523         /* N.B. Why does this call need a get_fs()??
1524          * Remove the set_fs and watch the fireworks:-) --okir
1525          */
1526
1527         oldfs = get_fs(); set_fs(KERNEL_DS);
1528         host_err = inode->i_op->readlink(path.dentry, (char __user *)buf, *lenp);
1529         set_fs(oldfs);
1530
1531         if (host_err < 0)
1532                 goto out_nfserr;
1533         *lenp = host_err;
1534         err = 0;
1535 out:
1536         return err;
1537
1538 out_nfserr:
1539         err = nfserrno(host_err);
1540         goto out;
1541 }
1542
1543 /*
1544  * Create a symlink and look up its inode
1545  * N.B. After this call _both_ fhp and resfhp need an fh_put
1546  */
1547 __be32
1548 nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
1549                                 char *fname, int flen,
1550                                 char *path,
1551                                 struct svc_fh *resfhp)
1552 {
1553         struct dentry   *dentry, *dnew;
1554         __be32          err, cerr;
1555         int             host_err;
1556
1557         err = nfserr_noent;
1558         if (!flen || path[0] == '\0')
1559                 goto out;
1560         err = nfserr_exist;
1561         if (isdotent(fname, flen))
1562                 goto out;
1563
1564         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1565         if (err)
1566                 goto out;
1567
1568         host_err = fh_want_write(fhp);
1569         if (host_err)
1570                 goto out_nfserr;
1571
1572         fh_lock(fhp);
1573         dentry = fhp->fh_dentry;
1574         dnew = lookup_one_len(fname, dentry, flen);
1575         host_err = PTR_ERR(dnew);
1576         if (IS_ERR(dnew))
1577                 goto out_nfserr;
1578
1579         host_err = vfs_symlink(dentry->d_inode, dnew, path);
1580         err = nfserrno(host_err);
1581         if (!err)
1582                 err = nfserrno(commit_metadata(fhp));
1583         fh_unlock(fhp);
1584
1585         fh_drop_write(fhp);
1586
1587         cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp);
1588         dput(dnew);
1589         if (err==0) err = cerr;
1590 out:
1591         return err;
1592
1593 out_nfserr:
1594         err = nfserrno(host_err);
1595         goto out;
1596 }
1597
1598 /*
1599  * Create a hardlink
1600  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1601  */
1602 __be32
1603 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
1604                                 char *name, int len, struct svc_fh *tfhp)
1605 {
1606         struct dentry   *ddir, *dnew, *dold;
1607         struct inode    *dirp;
1608         __be32          err;
1609         int             host_err;
1610
1611         err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE);
1612         if (err)
1613                 goto out;
1614         err = fh_verify(rqstp, tfhp, 0, NFSD_MAY_NOP);
1615         if (err)
1616                 goto out;
1617         err = nfserr_isdir;
1618         if (d_is_dir(tfhp->fh_dentry))
1619                 goto out;
1620         err = nfserr_perm;
1621         if (!len)
1622                 goto out;
1623         err = nfserr_exist;
1624         if (isdotent(name, len))
1625                 goto out;
1626
1627         host_err = fh_want_write(tfhp);
1628         if (host_err) {
1629                 err = nfserrno(host_err);
1630                 goto out;
1631         }
1632
1633         fh_lock_nested(ffhp, I_MUTEX_PARENT);
1634         ddir = ffhp->fh_dentry;
1635         dirp = ddir->d_inode;
1636
1637         dnew = lookup_one_len(name, ddir, len);
1638         host_err = PTR_ERR(dnew);
1639         if (IS_ERR(dnew))
1640                 goto out_nfserr;
1641
1642         dold = tfhp->fh_dentry;
1643
1644         err = nfserr_noent;
1645         if (!dold->d_inode)
1646                 goto out_dput;
1647         host_err = vfs_link(dold, dirp, dnew, NULL);
1648         if (!host_err) {
1649                 err = nfserrno(commit_metadata(ffhp));
1650                 if (!err)
1651                         err = nfserrno(commit_metadata(tfhp));
1652         } else {
1653                 if (host_err == -EXDEV && rqstp->rq_vers == 2)
1654                         err = nfserr_acces;
1655                 else
1656                         err = nfserrno(host_err);
1657         }
1658 out_dput:
1659         dput(dnew);
1660 out_unlock:
1661         fh_unlock(ffhp);
1662         fh_drop_write(tfhp);
1663 out:
1664         return err;
1665
1666 out_nfserr:
1667         err = nfserrno(host_err);
1668         goto out_unlock;
1669 }
1670
1671 /*
1672  * Rename a file
1673  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1674  */
1675 __be32
1676 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
1677                             struct svc_fh *tfhp, char *tname, int tlen)
1678 {
1679         struct dentry   *fdentry, *tdentry, *odentry, *ndentry, *trap;
1680         struct inode    *fdir, *tdir;
1681         __be32          err;
1682         int             host_err;
1683
1684         err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE);
1685         if (err)
1686                 goto out;
1687         err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE);
1688         if (err)
1689                 goto out;
1690
1691         fdentry = ffhp->fh_dentry;
1692         fdir = fdentry->d_inode;
1693
1694         tdentry = tfhp->fh_dentry;
1695         tdir = tdentry->d_inode;
1696
1697         err = nfserr_perm;
1698         if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
1699                 goto out;
1700
1701         host_err = fh_want_write(ffhp);
1702         if (host_err) {
1703                 err = nfserrno(host_err);
1704                 goto out;
1705         }
1706
1707         /* cannot use fh_lock as we need deadlock protective ordering
1708          * so do it by hand */
1709         trap = lock_rename(tdentry, fdentry);
1710         ffhp->fh_locked = tfhp->fh_locked = 1;
1711         fill_pre_wcc(ffhp);
1712         fill_pre_wcc(tfhp);
1713
1714         odentry = lookup_one_len(fname, fdentry, flen);
1715         host_err = PTR_ERR(odentry);
1716         if (IS_ERR(odentry))
1717                 goto out_nfserr;
1718
1719         host_err = -ENOENT;
1720         if (!odentry->d_inode)
1721                 goto out_dput_old;
1722         host_err = -EINVAL;
1723         if (odentry == trap)
1724                 goto out_dput_old;
1725
1726         ndentry = lookup_one_len(tname, tdentry, tlen);
1727         host_err = PTR_ERR(ndentry);
1728         if (IS_ERR(ndentry))
1729                 goto out_dput_old;
1730         host_err = -ENOTEMPTY;
1731         if (ndentry == trap)
1732                 goto out_dput_new;
1733
1734         host_err = -EXDEV;
1735         if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt)
1736                 goto out_dput_new;
1737         if (ffhp->fh_export->ex_path.dentry != tfhp->fh_export->ex_path.dentry)
1738                 goto out_dput_new;
1739
1740         host_err = vfs_rename(fdir, odentry, tdir, ndentry, NULL, 0);
1741         if (!host_err) {
1742                 host_err = commit_metadata(tfhp);
1743                 if (!host_err)
1744                         host_err = commit_metadata(ffhp);
1745         }
1746  out_dput_new:
1747         dput(ndentry);
1748  out_dput_old:
1749         dput(odentry);
1750  out_nfserr:
1751         err = nfserrno(host_err);
1752         /*
1753          * We cannot rely on fh_unlock on the two filehandles,
1754          * as that would do the wrong thing if the two directories
1755          * were the same, so again we do it by hand.
1756          */
1757         fill_post_wcc(ffhp);
1758         fill_post_wcc(tfhp);
1759         unlock_rename(tdentry, fdentry);
1760         ffhp->fh_locked = tfhp->fh_locked = 0;
1761         fh_drop_write(ffhp);
1762
1763 out:
1764         return err;
1765 }
1766
1767 /*
1768  * Unlink a file or directory
1769  * N.B. After this call fhp needs an fh_put
1770  */
1771 __be32
1772 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
1773                                 char *fname, int flen)
1774 {
1775         struct dentry   *dentry, *rdentry;
1776         struct inode    *dirp;
1777         __be32          err;
1778         int             host_err;
1779
1780         err = nfserr_acces;
1781         if (!flen || isdotent(fname, flen))
1782                 goto out;
1783         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE);
1784         if (err)
1785                 goto out;
1786
1787         host_err = fh_want_write(fhp);
1788         if (host_err)
1789                 goto out_nfserr;
1790
1791         fh_lock_nested(fhp, I_MUTEX_PARENT);
1792         dentry = fhp->fh_dentry;
1793         dirp = dentry->d_inode;
1794
1795         rdentry = lookup_one_len(fname, dentry, flen);
1796         host_err = PTR_ERR(rdentry);
1797         if (IS_ERR(rdentry))
1798                 goto out_nfserr;
1799
1800         if (!rdentry->d_inode) {
1801                 dput(rdentry);
1802                 err = nfserr_noent;
1803                 goto out;
1804         }
1805
1806         if (!type)
1807                 type = rdentry->d_inode->i_mode & S_IFMT;
1808
1809         if (type != S_IFDIR)
1810                 host_err = vfs_unlink(dirp, rdentry, NULL);
1811         else
1812                 host_err = vfs_rmdir(dirp, rdentry);
1813         if (!host_err)
1814                 host_err = commit_metadata(fhp);
1815         dput(rdentry);
1816
1817 out_nfserr:
1818         err = nfserrno(host_err);
1819 out:
1820         return err;
1821 }
1822
1823 /*
1824  * We do this buffering because we must not call back into the file
1825  * system's ->lookup() method from the filldir callback. That may well
1826  * deadlock a number of file systems.
1827  *
1828  * This is based heavily on the implementation of same in XFS.
1829  */
1830 struct buffered_dirent {
1831         u64             ino;
1832         loff_t          offset;
1833         int             namlen;
1834         unsigned int    d_type;
1835         char            name[];
1836 };
1837
1838 struct readdir_data {
1839         struct dir_context ctx;
1840         char            *dirent;
1841         size_t          used;
1842         int             full;
1843 };
1844
1845 static int nfsd_buffered_filldir(struct dir_context *ctx, const char *name,
1846                                  int namlen, loff_t offset, u64 ino,
1847                                  unsigned int d_type)
1848 {
1849         struct readdir_data *buf =
1850                 container_of(ctx, struct readdir_data, ctx);
1851         struct buffered_dirent *de = (void *)(buf->dirent + buf->used);
1852         unsigned int reclen;
1853
1854         reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64));
1855         if (buf->used + reclen > PAGE_SIZE) {
1856                 buf->full = 1;
1857                 return -EINVAL;
1858         }
1859
1860         de->namlen = namlen;
1861         de->offset = offset;
1862         de->ino = ino;
1863         de->d_type = d_type;
1864         memcpy(de->name, name, namlen);
1865         buf->used += reclen;
1866
1867         return 0;
1868 }
1869
1870 static __be32 nfsd_buffered_readdir(struct file *file, nfsd_filldir_t func,
1871                                     struct readdir_cd *cdp, loff_t *offsetp)
1872 {
1873         struct buffered_dirent *de;
1874         int host_err;
1875         int size;
1876         loff_t offset;
1877         struct readdir_data buf = {
1878                 .ctx.actor = nfsd_buffered_filldir,
1879                 .dirent = (void *)__get_free_page(GFP_KERNEL)
1880         };
1881
1882         if (!buf.dirent)
1883                 return nfserrno(-ENOMEM);
1884
1885         offset = *offsetp;
1886
1887         while (1) {
1888                 struct inode *dir_inode = file_inode(file);
1889                 unsigned int reclen;
1890
1891                 cdp->err = nfserr_eof; /* will be cleared on successful read */
1892                 buf.used = 0;
1893                 buf.full = 0;
1894
1895                 host_err = iterate_dir(file, &buf.ctx);
1896                 if (buf.full)
1897                         host_err = 0;
1898
1899                 if (host_err < 0)
1900                         break;
1901
1902                 size = buf.used;
1903
1904                 if (!size)
1905                         break;
1906
1907                 /*
1908                  * Various filldir functions may end up calling back into
1909                  * lookup_one_len() and the file system's ->lookup() method.
1910                  * These expect i_mutex to be held, as it would within readdir.
1911                  */
1912                 host_err = mutex_lock_killable(&dir_inode->i_mutex);
1913                 if (host_err)
1914                         break;
1915
1916                 de = (struct buffered_dirent *)buf.dirent;
1917                 while (size > 0) {
1918                         offset = de->offset;
1919
1920                         if (func(cdp, de->name, de->namlen, de->offset,
1921                                  de->ino, de->d_type))
1922                                 break;
1923
1924                         if (cdp->err != nfs_ok)
1925                                 break;
1926
1927                         reclen = ALIGN(sizeof(*de) + de->namlen,
1928                                        sizeof(u64));
1929                         size -= reclen;
1930                         de = (struct buffered_dirent *)((char *)de + reclen);
1931                 }
1932                 mutex_unlock(&dir_inode->i_mutex);
1933                 if (size > 0) /* We bailed out early */
1934                         break;
1935
1936                 offset = vfs_llseek(file, 0, SEEK_CUR);
1937         }
1938
1939         free_page((unsigned long)(buf.dirent));
1940
1941         if (host_err)
1942                 return nfserrno(host_err);
1943
1944         *offsetp = offset;
1945         return cdp->err;
1946 }
1947
1948 /*
1949  * Read entries from a directory.
1950  * The  NFSv3/4 verifier we ignore for now.
1951  */
1952 __be32
1953 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp,
1954              struct readdir_cd *cdp, nfsd_filldir_t func)
1955 {
1956         __be32          err;
1957         struct file     *file;
1958         loff_t          offset = *offsetp;
1959         int             may_flags = NFSD_MAY_READ;
1960
1961         /* NFSv2 only supports 32 bit cookies */
1962         if (rqstp->rq_vers > 2)
1963                 may_flags |= NFSD_MAY_64BIT_COOKIE;
1964
1965         err = nfsd_open(rqstp, fhp, S_IFDIR, may_flags, &file);
1966         if (err)
1967                 goto out;
1968
1969         offset = vfs_llseek(file, offset, SEEK_SET);
1970         if (offset < 0) {
1971                 err = nfserrno((int)offset);
1972                 goto out_close;
1973         }
1974
1975         err = nfsd_buffered_readdir(file, func, cdp, offsetp);
1976
1977         if (err == nfserr_eof || err == nfserr_toosmall)
1978                 err = nfs_ok; /* can still be found in ->err */
1979 out_close:
1980         nfsd_close(file);
1981 out:
1982         return err;
1983 }
1984
1985 /*
1986  * Get file system stats
1987  * N.B. After this call fhp needs an fh_put
1988  */
1989 __be32
1990 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access)
1991 {
1992         __be32 err;
1993
1994         err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access);
1995         if (!err) {
1996                 struct path path = {
1997                         .mnt    = fhp->fh_export->ex_path.mnt,
1998                         .dentry = fhp->fh_dentry,
1999                 };
2000                 if (vfs_statfs(&path, stat))
2001                         err = nfserr_io;
2002         }
2003         return err;
2004 }
2005
2006 static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp)
2007 {
2008         return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY;
2009 }
2010
2011 /*
2012  * Check for a user's access permissions to this inode.
2013  */
2014 __be32
2015 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
2016                                         struct dentry *dentry, int acc)
2017 {
2018         struct inode    *inode = dentry->d_inode;
2019         int             err;
2020
2021         if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
2022                 return 0;
2023 #if 0
2024         dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
2025                 acc,
2026                 (acc & NFSD_MAY_READ)?  " read"  : "",
2027                 (acc & NFSD_MAY_WRITE)? " write" : "",
2028                 (acc & NFSD_MAY_EXEC)?  " exec"  : "",
2029                 (acc & NFSD_MAY_SATTR)? " sattr" : "",
2030                 (acc & NFSD_MAY_TRUNC)? " trunc" : "",
2031                 (acc & NFSD_MAY_LOCK)?  " lock"  : "",
2032                 (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "",
2033                 inode->i_mode,
2034                 IS_IMMUTABLE(inode)?    " immut" : "",
2035                 IS_APPEND(inode)?       " append" : "",
2036                 __mnt_is_readonly(exp->ex_path.mnt)?    " ro" : "");
2037         dprintk("      owner %d/%d user %d/%d\n",
2038                 inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid());
2039 #endif
2040
2041         /* Normally we reject any write/sattr etc access on a read-only file
2042          * system.  But if it is IRIX doing check on write-access for a
2043          * device special file, we ignore rofs.
2044          */
2045         if (!(acc & NFSD_MAY_LOCAL_ACCESS))
2046                 if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) {
2047                         if (exp_rdonly(rqstp, exp) ||
2048                             __mnt_is_readonly(exp->ex_path.mnt))
2049                                 return nfserr_rofs;
2050                         if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode))
2051                                 return nfserr_perm;
2052                 }
2053         if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode))
2054                 return nfserr_perm;
2055
2056         if (acc & NFSD_MAY_LOCK) {
2057                 /* If we cannot rely on authentication in NLM requests,
2058                  * just allow locks, otherwise require read permission, or
2059                  * ownership
2060                  */
2061                 if (exp->ex_flags & NFSEXP_NOAUTHNLM)
2062                         return 0;
2063                 else
2064                         acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE;
2065         }
2066         /*
2067          * The file owner always gets access permission for accesses that
2068          * would normally be checked at open time. This is to make
2069          * file access work even when the client has done a fchmod(fd, 0).
2070          *
2071          * However, `cp foo bar' should fail nevertheless when bar is
2072          * readonly. A sensible way to do this might be to reject all
2073          * attempts to truncate a read-only file, because a creat() call
2074          * always implies file truncation.
2075          * ... but this isn't really fair.  A process may reasonably call
2076          * ftruncate on an open file descriptor on a file with perm 000.
2077          * We must trust the client to do permission checking - using "ACCESS"
2078          * with NFSv3.
2079          */
2080         if ((acc & NFSD_MAY_OWNER_OVERRIDE) &&
2081             uid_eq(inode->i_uid, current_fsuid()))
2082                 return 0;
2083
2084         /* This assumes  NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */
2085         err = inode_permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC));
2086
2087         /* Allow read access to binaries even when mode 111 */
2088         if (err == -EACCES && S_ISREG(inode->i_mode) &&
2089              (acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE) ||
2090               acc == (NFSD_MAY_READ | NFSD_MAY_READ_IF_EXEC)))
2091                 err = inode_permission(inode, MAY_EXEC);
2092
2093         return err? nfserrno(err) : 0;
2094 }
2095
2096 void
2097 nfsd_racache_shutdown(void)
2098 {
2099         struct raparms *raparm, *last_raparm;
2100         unsigned int i;
2101
2102         dprintk("nfsd: freeing readahead buffers.\n");
2103
2104         for (i = 0; i < RAPARM_HASH_SIZE; i++) {
2105                 raparm = raparm_hash[i].pb_head;
2106                 while(raparm) {
2107                         last_raparm = raparm;
2108                         raparm = raparm->p_next;
2109                         kfree(last_raparm);
2110                 }
2111                 raparm_hash[i].pb_head = NULL;
2112         }
2113 }
2114 /*
2115  * Initialize readahead param cache
2116  */
2117 int
2118 nfsd_racache_init(int cache_size)
2119 {
2120         int     i;
2121         int     j = 0;
2122         int     nperbucket;
2123         struct raparms **raparm = NULL;
2124
2125
2126         if (raparm_hash[0].pb_head)
2127                 return 0;
2128         nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE);
2129         nperbucket = max(2, nperbucket);
2130         cache_size = nperbucket * RAPARM_HASH_SIZE;
2131
2132         dprintk("nfsd: allocating %d readahead buffers.\n", cache_size);
2133
2134         for (i = 0; i < RAPARM_HASH_SIZE; i++) {
2135                 spin_lock_init(&raparm_hash[i].pb_lock);
2136
2137                 raparm = &raparm_hash[i].pb_head;
2138                 for (j = 0; j < nperbucket; j++) {
2139                         *raparm = kzalloc(sizeof(struct raparms), GFP_KERNEL);
2140                         if (!*raparm)
2141                                 goto out_nomem;
2142                         raparm = &(*raparm)->p_next;
2143                 }
2144                 *raparm = NULL;
2145         }
2146
2147         nfsdstats.ra_size = cache_size;
2148         return 0;
2149
2150 out_nomem:
2151         dprintk("nfsd: kmalloc failed, freeing readahead buffers\n");
2152         nfsd_racache_shutdown();
2153         return -ENOMEM;
2154 }