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