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 validate_process_creds(); 688 689 /* 690 * If we get here, then the client has already done an "open", 691 * and (hopefully) checked permission - so allow OWNER_OVERRIDE 692 * in case a chmod has now revoked permission. 693 */ 694 err = fh_verify(rqstp, fhp, type, access | NFSD_MAY_OWNER_OVERRIDE); 695 if (err) 696 goto out; 697 698 dentry = fhp->fh_dentry; 699 inode = dentry->d_inode; 700 701 /* Disallow write access to files with the append-only bit set 702 * or any access when mandatory locking enabled 703 */ 704 err = nfserr_perm; 705 if (IS_APPEND(inode) && (access & NFSD_MAY_WRITE)) 706 goto out; 707 /* 708 * We must ignore files (but only files) which might have mandatory 709 * locks on them because there is no way to know if the accesser has 710 * the lock. 711 */ 712 if (S_ISREG((inode)->i_mode) && mandatory_lock(inode)) 713 goto out; 714 715 if (!inode->i_fop) 716 goto out; 717 718 /* 719 * Check to see if there are any leases on this file. 720 * This may block while leases are broken. 721 */ 722 host_err = break_lease(inode, O_NONBLOCK | ((access & NFSD_MAY_WRITE) ? FMODE_WRITE : 0)); 723 if (host_err == -EWOULDBLOCK) 724 host_err = -ETIMEDOUT; 725 if (host_err) /* NOMEM or WOULDBLOCK */ 726 goto out_nfserr; 727 728 if (access & NFSD_MAY_WRITE) { 729 if (access & NFSD_MAY_READ) 730 flags = O_RDWR|O_LARGEFILE; 731 else 732 flags = O_WRONLY|O_LARGEFILE; 733 734 vfs_dq_init(inode); 735 } 736 *filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt), 737 flags, current_cred()); 738 if (IS_ERR(*filp)) 739 host_err = PTR_ERR(*filp); 740 else 741 ima_counts_get(*filp); 742 out_nfserr: 743 err = nfserrno(host_err); 744 out: 745 validate_process_creds(); 746 return err; 747 } 748 749 /* 750 * Close a file. 751 */ 752 void 753 nfsd_close(struct file *filp) 754 { 755 fput(filp); 756 } 757 758 /* 759 * Sync a file 760 * As this calls fsync (not fdatasync) there is no need for a write_inode 761 * after it. 762 */ 763 static inline int nfsd_dosync(struct file *filp, struct dentry *dp, 764 const struct file_operations *fop) 765 { 766 struct inode *inode = dp->d_inode; 767 int (*fsync) (struct file *, struct dentry *, int); 768 int err; 769 770 err = filemap_fdatawrite(inode->i_mapping); 771 if (err == 0 && fop && (fsync = fop->fsync)) 772 err = fsync(filp, dp, 0); 773 if (err == 0) 774 err = filemap_fdatawait(inode->i_mapping); 775 776 return err; 777 } 778 779 static int 780 nfsd_sync(struct file *filp) 781 { 782 int err; 783 struct inode *inode = filp->f_path.dentry->d_inode; 784 dprintk("nfsd: sync file %s\n", filp->f_path.dentry->d_name.name); 785 mutex_lock(&inode->i_mutex); 786 err=nfsd_dosync(filp, filp->f_path.dentry, filp->f_op); 787 mutex_unlock(&inode->i_mutex); 788 789 return err; 790 } 791 792 int 793 nfsd_sync_dir(struct dentry *dp) 794 { 795 return nfsd_dosync(NULL, dp, dp->d_inode->i_fop); 796 } 797 798 /* 799 * Obtain the readahead parameters for the file 800 * specified by (dev, ino). 801 */ 802 803 static inline struct raparms * 804 nfsd_get_raparms(dev_t dev, ino_t ino) 805 { 806 struct raparms *ra, **rap, **frap = NULL; 807 int depth = 0; 808 unsigned int hash; 809 struct raparm_hbucket *rab; 810 811 hash = jhash_2words(dev, ino, 0xfeedbeef) & RAPARM_HASH_MASK; 812 rab = &raparm_hash[hash]; 813 814 spin_lock(&rab->pb_lock); 815 for (rap = &rab->pb_head; (ra = *rap); rap = &ra->p_next) { 816 if (ra->p_ino == ino && ra->p_dev == dev) 817 goto found; 818 depth++; 819 if (ra->p_count == 0) 820 frap = rap; 821 } 822 depth = nfsdstats.ra_size*11/10; 823 if (!frap) { 824 spin_unlock(&rab->pb_lock); 825 return NULL; 826 } 827 rap = frap; 828 ra = *frap; 829 ra->p_dev = dev; 830 ra->p_ino = ino; 831 ra->p_set = 0; 832 ra->p_hindex = hash; 833 found: 834 if (rap != &rab->pb_head) { 835 *rap = ra->p_next; 836 ra->p_next = rab->pb_head; 837 rab->pb_head = ra; 838 } 839 ra->p_count++; 840 nfsdstats.ra_depth[depth*10/nfsdstats.ra_size]++; 841 spin_unlock(&rab->pb_lock); 842 return ra; 843 } 844 845 /* 846 * Grab and keep cached pages associated with a file in the svc_rqst 847 * so that they can be passed to the network sendmsg/sendpage routines 848 * directly. They will be released after the sending has completed. 849 */ 850 static int 851 nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 852 struct splice_desc *sd) 853 { 854 struct svc_rqst *rqstp = sd->u.data; 855 struct page **pp = rqstp->rq_respages + rqstp->rq_resused; 856 struct page *page = buf->page; 857 size_t size; 858 int ret; 859 860 ret = buf->ops->confirm(pipe, buf); 861 if (unlikely(ret)) 862 return ret; 863 864 size = sd->len; 865 866 if (rqstp->rq_res.page_len == 0) { 867 get_page(page); 868 put_page(*pp); 869 *pp = page; 870 rqstp->rq_resused++; 871 rqstp->rq_res.page_base = buf->offset; 872 rqstp->rq_res.page_len = size; 873 } else if (page != pp[-1]) { 874 get_page(page); 875 if (*pp) 876 put_page(*pp); 877 *pp = page; 878 rqstp->rq_resused++; 879 rqstp->rq_res.page_len += size; 880 } else 881 rqstp->rq_res.page_len += size; 882 883 return size; 884 } 885 886 static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe, 887 struct splice_desc *sd) 888 { 889 return __splice_from_pipe(pipe, sd, nfsd_splice_actor); 890 } 891 892 static inline int svc_msnfs(struct svc_fh *ffhp) 893 { 894 #ifdef MSNFS 895 return (ffhp->fh_export->ex_flags & NFSEXP_MSNFS); 896 #else 897 return 0; 898 #endif 899 } 900 901 static __be32 902 nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file, 903 loff_t offset, struct kvec *vec, int vlen, unsigned long *count) 904 { 905 struct inode *inode; 906 struct raparms *ra; 907 mm_segment_t oldfs; 908 __be32 err; 909 int host_err; 910 911 err = nfserr_perm; 912 inode = file->f_path.dentry->d_inode; 913 914 if (svc_msnfs(fhp) && !lock_may_read(inode, offset, *count)) 915 goto out; 916 917 /* Get readahead parameters */ 918 ra = nfsd_get_raparms(inode->i_sb->s_dev, inode->i_ino); 919 920 if (ra && ra->p_set) 921 file->f_ra = ra->p_ra; 922 923 if (file->f_op->splice_read && rqstp->rq_splice_ok) { 924 struct splice_desc sd = { 925 .len = 0, 926 .total_len = *count, 927 .pos = offset, 928 .u.data = rqstp, 929 }; 930 931 rqstp->rq_resused = 1; 932 host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor); 933 } else { 934 oldfs = get_fs(); 935 set_fs(KERNEL_DS); 936 host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset); 937 set_fs(oldfs); 938 } 939 940 /* Write back readahead params */ 941 if (ra) { 942 struct raparm_hbucket *rab = &raparm_hash[ra->p_hindex]; 943 spin_lock(&rab->pb_lock); 944 ra->p_ra = file->f_ra; 945 ra->p_set = 1; 946 ra->p_count--; 947 spin_unlock(&rab->pb_lock); 948 } 949 950 if (host_err >= 0) { 951 nfsdstats.io_read += host_err; 952 *count = host_err; 953 err = 0; 954 fsnotify_access(file->f_path.dentry); 955 } else 956 err = nfserrno(host_err); 957 out: 958 return err; 959 } 960 961 static void kill_suid(struct dentry *dentry) 962 { 963 struct iattr ia; 964 ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV; 965 966 mutex_lock(&dentry->d_inode->i_mutex); 967 notify_change(dentry, &ia); 968 mutex_unlock(&dentry->d_inode->i_mutex); 969 } 970 971 /* 972 * Gathered writes: If another process is currently writing to the file, 973 * there's a high chance this is another nfsd (triggered by a bulk write 974 * from a client's biod). Rather than syncing the file with each write 975 * request, we sleep for 10 msec. 976 * 977 * I don't know if this roughly approximates C. Juszak's idea of 978 * gathered writes, but it's a nice and simple solution (IMHO), and it 979 * seems to work:-) 980 * 981 * Note: we do this only in the NFSv2 case, since v3 and higher have a 982 * better tool (separate unstable writes and commits) for solving this 983 * problem. 984 */ 985 static int wait_for_concurrent_writes(struct file *file) 986 { 987 struct inode *inode = file->f_path.dentry->d_inode; 988 static ino_t last_ino; 989 static dev_t last_dev; 990 int err = 0; 991 992 if (atomic_read(&inode->i_writecount) > 1 993 || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) { 994 dprintk("nfsd: write defer %d\n", task_pid_nr(current)); 995 msleep(10); 996 dprintk("nfsd: write resume %d\n", task_pid_nr(current)); 997 } 998 999 if (inode->i_state & I_DIRTY) { 1000 dprintk("nfsd: write sync %d\n", task_pid_nr(current)); 1001 err = nfsd_sync(file); 1002 } 1003 last_ino = inode->i_ino; 1004 last_dev = inode->i_sb->s_dev; 1005 return err; 1006 } 1007 1008 static __be32 1009 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file, 1010 loff_t offset, struct kvec *vec, int vlen, 1011 unsigned long *cnt, int *stablep) 1012 { 1013 struct svc_export *exp; 1014 struct dentry *dentry; 1015 struct inode *inode; 1016 mm_segment_t oldfs; 1017 __be32 err = 0; 1018 int host_err; 1019 int stable = *stablep; 1020 int use_wgather; 1021 1022 #ifdef MSNFS 1023 err = nfserr_perm; 1024 1025 if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) && 1026 (!lock_may_write(file->f_path.dentry->d_inode, offset, *cnt))) 1027 goto out; 1028 #endif 1029 1030 dentry = file->f_path.dentry; 1031 inode = dentry->d_inode; 1032 exp = fhp->fh_export; 1033 1034 /* 1035 * Request sync writes if 1036 * - the sync export option has been set, or 1037 * - the client requested O_SYNC behavior (NFSv3 feature). 1038 * - The file system doesn't support fsync(). 1039 * When NFSv2 gathered writes have been configured for this volume, 1040 * flushing the data to disk is handled separately below. 1041 */ 1042 use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp); 1043 1044 if (!file->f_op->fsync) {/* COMMIT3 cannot work */ 1045 stable = 2; 1046 *stablep = 2; /* FILE_SYNC */ 1047 } 1048 1049 if (!EX_ISSYNC(exp)) 1050 stable = 0; 1051 if (stable && !use_wgather) { 1052 spin_lock(&file->f_lock); 1053 file->f_flags |= O_SYNC; 1054 spin_unlock(&file->f_lock); 1055 } 1056 1057 /* Write the data. */ 1058 oldfs = get_fs(); set_fs(KERNEL_DS); 1059 host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &offset); 1060 set_fs(oldfs); 1061 if (host_err < 0) 1062 goto out_nfserr; 1063 *cnt = host_err; 1064 nfsdstats.io_write += host_err; 1065 fsnotify_modify(file->f_path.dentry); 1066 1067 /* clear setuid/setgid flag after write */ 1068 if (inode->i_mode & (S_ISUID | S_ISGID)) 1069 kill_suid(dentry); 1070 1071 if (stable && use_wgather) 1072 host_err = wait_for_concurrent_writes(file); 1073 1074 out_nfserr: 1075 dprintk("nfsd: write complete host_err=%d\n", host_err); 1076 if (host_err >= 0) 1077 err = 0; 1078 else 1079 err = nfserrno(host_err); 1080 out: 1081 return err; 1082 } 1083 1084 /* 1085 * Read data from a file. count must contain the requested read count 1086 * on entry. On return, *count contains the number of bytes actually read. 1087 * N.B. After this call fhp needs an fh_put 1088 */ 1089 __be32 1090 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file, 1091 loff_t offset, struct kvec *vec, int vlen, 1092 unsigned long *count) 1093 { 1094 __be32 err; 1095 1096 if (file) { 1097 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, 1098 NFSD_MAY_READ|NFSD_MAY_OWNER_OVERRIDE); 1099 if (err) 1100 goto out; 1101 err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count); 1102 } else { 1103 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file); 1104 if (err) 1105 goto out; 1106 err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count); 1107 nfsd_close(file); 1108 } 1109 out: 1110 return err; 1111 } 1112 1113 /* 1114 * Write data to a file. 1115 * The stable flag requests synchronous writes. 1116 * N.B. After this call fhp needs an fh_put 1117 */ 1118 __be32 1119 nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file, 1120 loff_t offset, struct kvec *vec, int vlen, unsigned long *cnt, 1121 int *stablep) 1122 { 1123 __be32 err = 0; 1124 1125 if (file) { 1126 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, 1127 NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE); 1128 if (err) 1129 goto out; 1130 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt, 1131 stablep); 1132 } else { 1133 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file); 1134 if (err) 1135 goto out; 1136 1137 if (cnt) 1138 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, 1139 cnt, stablep); 1140 nfsd_close(file); 1141 } 1142 out: 1143 return err; 1144 } 1145 1146 #ifdef CONFIG_NFSD_V3 1147 /* 1148 * Commit all pending writes to stable storage. 1149 * Strictly speaking, we could sync just the indicated file region here, 1150 * but there's currently no way we can ask the VFS to do so. 1151 * 1152 * Unfortunately we cannot lock the file to make sure we return full WCC 1153 * data to the client, as locking happens lower down in the filesystem. 1154 */ 1155 __be32 1156 nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp, 1157 loff_t offset, unsigned long count) 1158 { 1159 struct file *file; 1160 __be32 err; 1161 1162 if ((u64)count > ~(u64)offset) 1163 return nfserr_inval; 1164 1165 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file); 1166 if (err) 1167 return err; 1168 if (EX_ISSYNC(fhp->fh_export)) { 1169 if (file->f_op && file->f_op->fsync) { 1170 err = nfserrno(nfsd_sync(file)); 1171 } else { 1172 err = nfserr_notsupp; 1173 } 1174 } 1175 1176 nfsd_close(file); 1177 return err; 1178 } 1179 #endif /* CONFIG_NFSD_V3 */ 1180 1181 static __be32 1182 nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp, 1183 struct iattr *iap) 1184 { 1185 /* 1186 * Mode has already been set earlier in create: 1187 */ 1188 iap->ia_valid &= ~ATTR_MODE; 1189 /* 1190 * Setting uid/gid works only for root. Irix appears to 1191 * send along the gid on create when it tries to implement 1192 * setgid directories via NFS: 1193 */ 1194 if (current_fsuid() != 0) 1195 iap->ia_valid &= ~(ATTR_UID|ATTR_GID); 1196 if (iap->ia_valid) 1197 return nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0); 1198 return 0; 1199 } 1200 1201 /* HPUX client sometimes creates a file in mode 000, and sets size to 0. 1202 * setting size to 0 may fail for some specific file systems by the permission 1203 * checking which requires WRITE permission but the mode is 000. 1204 * we ignore the resizing(to 0) on the just new created file, since the size is 1205 * 0 after file created. 1206 * 1207 * call this only after vfs_create() is called. 1208 * */ 1209 static void 1210 nfsd_check_ignore_resizing(struct iattr *iap) 1211 { 1212 if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0)) 1213 iap->ia_valid &= ~ATTR_SIZE; 1214 } 1215 1216 /* 1217 * Create a file (regular, directory, device, fifo); UNIX sockets 1218 * not yet implemented. 1219 * If the response fh has been verified, the parent directory should 1220 * already be locked. Note that the parent directory is left locked. 1221 * 1222 * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp 1223 */ 1224 __be32 1225 nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp, 1226 char *fname, int flen, struct iattr *iap, 1227 int type, dev_t rdev, struct svc_fh *resfhp) 1228 { 1229 struct dentry *dentry, *dchild = NULL; 1230 struct inode *dirp; 1231 __be32 err; 1232 __be32 err2; 1233 int host_err; 1234 1235 err = nfserr_perm; 1236 if (!flen) 1237 goto out; 1238 err = nfserr_exist; 1239 if (isdotent(fname, flen)) 1240 goto out; 1241 1242 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 1243 if (err) 1244 goto out; 1245 1246 dentry = fhp->fh_dentry; 1247 dirp = dentry->d_inode; 1248 1249 err = nfserr_notdir; 1250 if (!dirp->i_op->lookup) 1251 goto out; 1252 /* 1253 * Check whether the response file handle has been verified yet. 1254 * If it has, the parent directory should already be locked. 1255 */ 1256 if (!resfhp->fh_dentry) { 1257 /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */ 1258 fh_lock_nested(fhp, I_MUTEX_PARENT); 1259 dchild = lookup_one_len(fname, dentry, flen); 1260 host_err = PTR_ERR(dchild); 1261 if (IS_ERR(dchild)) 1262 goto out_nfserr; 1263 err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); 1264 if (err) 1265 goto out; 1266 } else { 1267 /* called from nfsd_proc_create */ 1268 dchild = dget(resfhp->fh_dentry); 1269 if (!fhp->fh_locked) { 1270 /* not actually possible */ 1271 printk(KERN_ERR 1272 "nfsd_create: parent %s/%s not locked!\n", 1273 dentry->d_parent->d_name.name, 1274 dentry->d_name.name); 1275 err = nfserr_io; 1276 goto out; 1277 } 1278 } 1279 /* 1280 * Make sure the child dentry is still negative ... 1281 */ 1282 err = nfserr_exist; 1283 if (dchild->d_inode) { 1284 dprintk("nfsd_create: dentry %s/%s not negative!\n", 1285 dentry->d_name.name, dchild->d_name.name); 1286 goto out; 1287 } 1288 1289 if (!(iap->ia_valid & ATTR_MODE)) 1290 iap->ia_mode = 0; 1291 iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type; 1292 1293 err = nfserr_inval; 1294 if (!S_ISREG(type) && !S_ISDIR(type) && !special_file(type)) { 1295 printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n", 1296 type); 1297 goto out; 1298 } 1299 1300 host_err = mnt_want_write(fhp->fh_export->ex_path.mnt); 1301 if (host_err) 1302 goto out_nfserr; 1303 1304 /* 1305 * Get the dir op function pointer. 1306 */ 1307 err = 0; 1308 switch (type) { 1309 case S_IFREG: 1310 host_err = vfs_create(dirp, dchild, iap->ia_mode, NULL); 1311 if (!host_err) 1312 nfsd_check_ignore_resizing(iap); 1313 break; 1314 case S_IFDIR: 1315 host_err = vfs_mkdir(dirp, dchild, iap->ia_mode); 1316 break; 1317 case S_IFCHR: 1318 case S_IFBLK: 1319 case S_IFIFO: 1320 case S_IFSOCK: 1321 host_err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev); 1322 break; 1323 } 1324 if (host_err < 0) { 1325 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1326 goto out_nfserr; 1327 } 1328 1329 if (EX_ISSYNC(fhp->fh_export)) { 1330 err = nfserrno(nfsd_sync_dir(dentry)); 1331 write_inode_now(dchild->d_inode, 1); 1332 } 1333 1334 err2 = nfsd_create_setattr(rqstp, resfhp, iap); 1335 if (err2) 1336 err = err2; 1337 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1338 /* 1339 * Update the file handle to get the new inode info. 1340 */ 1341 if (!err) 1342 err = fh_update(resfhp); 1343 out: 1344 if (dchild && !IS_ERR(dchild)) 1345 dput(dchild); 1346 return err; 1347 1348 out_nfserr: 1349 err = nfserrno(host_err); 1350 goto out; 1351 } 1352 1353 #ifdef CONFIG_NFSD_V3 1354 /* 1355 * NFSv3 version of nfsd_create 1356 */ 1357 __be32 1358 nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp, 1359 char *fname, int flen, struct iattr *iap, 1360 struct svc_fh *resfhp, int createmode, u32 *verifier, 1361 int *truncp, int *created) 1362 { 1363 struct dentry *dentry, *dchild = NULL; 1364 struct inode *dirp; 1365 __be32 err; 1366 __be32 err2; 1367 int host_err; 1368 __u32 v_mtime=0, v_atime=0; 1369 1370 err = nfserr_perm; 1371 if (!flen) 1372 goto out; 1373 err = nfserr_exist; 1374 if (isdotent(fname, flen)) 1375 goto out; 1376 if (!(iap->ia_valid & ATTR_MODE)) 1377 iap->ia_mode = 0; 1378 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 1379 if (err) 1380 goto out; 1381 1382 dentry = fhp->fh_dentry; 1383 dirp = dentry->d_inode; 1384 1385 /* Get all the sanity checks out of the way before 1386 * we lock the parent. */ 1387 err = nfserr_notdir; 1388 if (!dirp->i_op->lookup) 1389 goto out; 1390 fh_lock_nested(fhp, I_MUTEX_PARENT); 1391 1392 /* 1393 * Compose the response file handle. 1394 */ 1395 dchild = lookup_one_len(fname, dentry, flen); 1396 host_err = PTR_ERR(dchild); 1397 if (IS_ERR(dchild)) 1398 goto out_nfserr; 1399 1400 err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); 1401 if (err) 1402 goto out; 1403 1404 if (createmode == NFS3_CREATE_EXCLUSIVE) { 1405 /* solaris7 gets confused (bugid 4218508) if these have 1406 * the high bit set, so just clear the high bits. If this is 1407 * ever changed to use different attrs for storing the 1408 * verifier, then do_open_lookup() will also need to be fixed 1409 * accordingly. 1410 */ 1411 v_mtime = verifier[0]&0x7fffffff; 1412 v_atime = verifier[1]&0x7fffffff; 1413 } 1414 1415 host_err = mnt_want_write(fhp->fh_export->ex_path.mnt); 1416 if (host_err) 1417 goto out_nfserr; 1418 if (dchild->d_inode) { 1419 err = 0; 1420 1421 switch (createmode) { 1422 case NFS3_CREATE_UNCHECKED: 1423 if (! S_ISREG(dchild->d_inode->i_mode)) 1424 err = nfserr_exist; 1425 else if (truncp) { 1426 /* in nfsv4, we need to treat this case a little 1427 * differently. we don't want to truncate the 1428 * file now; this would be wrong if the OPEN 1429 * fails for some other reason. furthermore, 1430 * if the size is nonzero, we should ignore it 1431 * according to spec! 1432 */ 1433 *truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size; 1434 } 1435 else { 1436 iap->ia_valid &= ATTR_SIZE; 1437 goto set_attr; 1438 } 1439 break; 1440 case NFS3_CREATE_EXCLUSIVE: 1441 if ( dchild->d_inode->i_mtime.tv_sec == v_mtime 1442 && dchild->d_inode->i_atime.tv_sec == v_atime 1443 && dchild->d_inode->i_size == 0 ) 1444 break; 1445 /* fallthru */ 1446 case NFS3_CREATE_GUARDED: 1447 err = nfserr_exist; 1448 } 1449 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1450 goto out; 1451 } 1452 1453 host_err = vfs_create(dirp, dchild, iap->ia_mode, NULL); 1454 if (host_err < 0) { 1455 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1456 goto out_nfserr; 1457 } 1458 if (created) 1459 *created = 1; 1460 1461 if (EX_ISSYNC(fhp->fh_export)) { 1462 err = nfserrno(nfsd_sync_dir(dentry)); 1463 /* setattr will sync the child (or not) */ 1464 } 1465 1466 nfsd_check_ignore_resizing(iap); 1467 1468 if (createmode == NFS3_CREATE_EXCLUSIVE) { 1469 /* Cram the verifier into atime/mtime */ 1470 iap->ia_valid = ATTR_MTIME|ATTR_ATIME 1471 | ATTR_MTIME_SET|ATTR_ATIME_SET; 1472 /* XXX someone who knows this better please fix it for nsec */ 1473 iap->ia_mtime.tv_sec = v_mtime; 1474 iap->ia_atime.tv_sec = v_atime; 1475 iap->ia_mtime.tv_nsec = 0; 1476 iap->ia_atime.tv_nsec = 0; 1477 } 1478 1479 set_attr: 1480 err2 = nfsd_create_setattr(rqstp, resfhp, iap); 1481 if (err2) 1482 err = err2; 1483 1484 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1485 /* 1486 * Update the filehandle to get the new inode info. 1487 */ 1488 if (!err) 1489 err = fh_update(resfhp); 1490 1491 out: 1492 fh_unlock(fhp); 1493 if (dchild && !IS_ERR(dchild)) 1494 dput(dchild); 1495 return err; 1496 1497 out_nfserr: 1498 err = nfserrno(host_err); 1499 goto out; 1500 } 1501 #endif /* CONFIG_NFSD_V3 */ 1502 1503 /* 1504 * Read a symlink. On entry, *lenp must contain the maximum path length that 1505 * fits into the buffer. On return, it contains the true length. 1506 * N.B. After this call fhp needs an fh_put 1507 */ 1508 __be32 1509 nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp) 1510 { 1511 struct dentry *dentry; 1512 struct inode *inode; 1513 mm_segment_t oldfs; 1514 __be32 err; 1515 int host_err; 1516 1517 err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP); 1518 if (err) 1519 goto out; 1520 1521 dentry = fhp->fh_dentry; 1522 inode = dentry->d_inode; 1523 1524 err = nfserr_inval; 1525 if (!inode->i_op->readlink) 1526 goto out; 1527 1528 touch_atime(fhp->fh_export->ex_path.mnt, dentry); 1529 /* N.B. Why does this call need a get_fs()?? 1530 * Remove the set_fs and watch the fireworks:-) --okir 1531 */ 1532 1533 oldfs = get_fs(); set_fs(KERNEL_DS); 1534 host_err = inode->i_op->readlink(dentry, buf, *lenp); 1535 set_fs(oldfs); 1536 1537 if (host_err < 0) 1538 goto out_nfserr; 1539 *lenp = host_err; 1540 err = 0; 1541 out: 1542 return err; 1543 1544 out_nfserr: 1545 err = nfserrno(host_err); 1546 goto out; 1547 } 1548 1549 /* 1550 * Create a symlink and look up its inode 1551 * N.B. After this call _both_ fhp and resfhp need an fh_put 1552 */ 1553 __be32 1554 nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp, 1555 char *fname, int flen, 1556 char *path, int plen, 1557 struct svc_fh *resfhp, 1558 struct iattr *iap) 1559 { 1560 struct dentry *dentry, *dnew; 1561 __be32 err, cerr; 1562 int host_err; 1563 1564 err = nfserr_noent; 1565 if (!flen || !plen) 1566 goto out; 1567 err = nfserr_exist; 1568 if (isdotent(fname, flen)) 1569 goto out; 1570 1571 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 1572 if (err) 1573 goto out; 1574 fh_lock(fhp); 1575 dentry = fhp->fh_dentry; 1576 dnew = lookup_one_len(fname, dentry, flen); 1577 host_err = PTR_ERR(dnew); 1578 if (IS_ERR(dnew)) 1579 goto out_nfserr; 1580 1581 host_err = mnt_want_write(fhp->fh_export->ex_path.mnt); 1582 if (host_err) 1583 goto out_nfserr; 1584 1585 if (unlikely(path[plen] != 0)) { 1586 char *path_alloced = kmalloc(plen+1, GFP_KERNEL); 1587 if (path_alloced == NULL) 1588 host_err = -ENOMEM; 1589 else { 1590 strncpy(path_alloced, path, plen); 1591 path_alloced[plen] = 0; 1592 host_err = vfs_symlink(dentry->d_inode, dnew, path_alloced); 1593 kfree(path_alloced); 1594 } 1595 } else 1596 host_err = vfs_symlink(dentry->d_inode, dnew, path); 1597 1598 if (!host_err) { 1599 if (EX_ISSYNC(fhp->fh_export)) 1600 host_err = nfsd_sync_dir(dentry); 1601 } 1602 err = nfserrno(host_err); 1603 fh_unlock(fhp); 1604 1605 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1606 1607 cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp); 1608 dput(dnew); 1609 if (err==0) err = cerr; 1610 out: 1611 return err; 1612 1613 out_nfserr: 1614 err = nfserrno(host_err); 1615 goto out; 1616 } 1617 1618 /* 1619 * Create a hardlink 1620 * N.B. After this call _both_ ffhp and tfhp need an fh_put 1621 */ 1622 __be32 1623 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, 1624 char *name, int len, struct svc_fh *tfhp) 1625 { 1626 struct dentry *ddir, *dnew, *dold; 1627 struct inode *dirp, *dest; 1628 __be32 err; 1629 int host_err; 1630 1631 err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE); 1632 if (err) 1633 goto out; 1634 err = fh_verify(rqstp, tfhp, -S_IFDIR, NFSD_MAY_NOP); 1635 if (err) 1636 goto out; 1637 1638 err = nfserr_perm; 1639 if (!len) 1640 goto out; 1641 err = nfserr_exist; 1642 if (isdotent(name, len)) 1643 goto out; 1644 1645 fh_lock_nested(ffhp, I_MUTEX_PARENT); 1646 ddir = ffhp->fh_dentry; 1647 dirp = ddir->d_inode; 1648 1649 dnew = lookup_one_len(name, ddir, len); 1650 host_err = PTR_ERR(dnew); 1651 if (IS_ERR(dnew)) 1652 goto out_nfserr; 1653 1654 dold = tfhp->fh_dentry; 1655 dest = dold->d_inode; 1656 1657 host_err = mnt_want_write(tfhp->fh_export->ex_path.mnt); 1658 if (host_err) { 1659 err = nfserrno(host_err); 1660 goto out_dput; 1661 } 1662 host_err = vfs_link(dold, dirp, dnew); 1663 if (!host_err) { 1664 if (EX_ISSYNC(ffhp->fh_export)) { 1665 err = nfserrno(nfsd_sync_dir(ddir)); 1666 write_inode_now(dest, 1); 1667 } 1668 err = 0; 1669 } else { 1670 if (host_err == -EXDEV && rqstp->rq_vers == 2) 1671 err = nfserr_acces; 1672 else 1673 err = nfserrno(host_err); 1674 } 1675 mnt_drop_write(tfhp->fh_export->ex_path.mnt); 1676 out_dput: 1677 dput(dnew); 1678 out_unlock: 1679 fh_unlock(ffhp); 1680 out: 1681 return err; 1682 1683 out_nfserr: 1684 err = nfserrno(host_err); 1685 goto out_unlock; 1686 } 1687 1688 /* 1689 * Rename a file 1690 * N.B. After this call _both_ ffhp and tfhp need an fh_put 1691 */ 1692 __be32 1693 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, 1694 struct svc_fh *tfhp, char *tname, int tlen) 1695 { 1696 struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap; 1697 struct inode *fdir, *tdir; 1698 __be32 err; 1699 int host_err; 1700 1701 err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE); 1702 if (err) 1703 goto out; 1704 err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE); 1705 if (err) 1706 goto out; 1707 1708 fdentry = ffhp->fh_dentry; 1709 fdir = fdentry->d_inode; 1710 1711 tdentry = tfhp->fh_dentry; 1712 tdir = tdentry->d_inode; 1713 1714 err = (rqstp->rq_vers == 2) ? nfserr_acces : nfserr_xdev; 1715 if (ffhp->fh_export != tfhp->fh_export) 1716 goto out; 1717 1718 err = nfserr_perm; 1719 if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen)) 1720 goto out; 1721 1722 /* cannot use fh_lock as we need deadlock protective ordering 1723 * so do it by hand */ 1724 trap = lock_rename(tdentry, fdentry); 1725 ffhp->fh_locked = tfhp->fh_locked = 1; 1726 fill_pre_wcc(ffhp); 1727 fill_pre_wcc(tfhp); 1728 1729 odentry = lookup_one_len(fname, fdentry, flen); 1730 host_err = PTR_ERR(odentry); 1731 if (IS_ERR(odentry)) 1732 goto out_nfserr; 1733 1734 host_err = -ENOENT; 1735 if (!odentry->d_inode) 1736 goto out_dput_old; 1737 host_err = -EINVAL; 1738 if (odentry == trap) 1739 goto out_dput_old; 1740 1741 ndentry = lookup_one_len(tname, tdentry, tlen); 1742 host_err = PTR_ERR(ndentry); 1743 if (IS_ERR(ndentry)) 1744 goto out_dput_old; 1745 host_err = -ENOTEMPTY; 1746 if (ndentry == trap) 1747 goto out_dput_new; 1748 1749 if (svc_msnfs(ffhp) && 1750 ((atomic_read(&odentry->d_count) > 1) 1751 || (atomic_read(&ndentry->d_count) > 1))) { 1752 host_err = -EPERM; 1753 goto out_dput_new; 1754 } 1755 1756 host_err = -EXDEV; 1757 if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt) 1758 goto out_dput_new; 1759 host_err = mnt_want_write(ffhp->fh_export->ex_path.mnt); 1760 if (host_err) 1761 goto out_dput_new; 1762 1763 host_err = vfs_rename(fdir, odentry, tdir, ndentry); 1764 if (!host_err && EX_ISSYNC(tfhp->fh_export)) { 1765 host_err = nfsd_sync_dir(tdentry); 1766 if (!host_err) 1767 host_err = nfsd_sync_dir(fdentry); 1768 } 1769 1770 mnt_drop_write(ffhp->fh_export->ex_path.mnt); 1771 1772 out_dput_new: 1773 dput(ndentry); 1774 out_dput_old: 1775 dput(odentry); 1776 out_nfserr: 1777 err = nfserrno(host_err); 1778 1779 /* we cannot reply on fh_unlock on the two filehandles, 1780 * as that would do the wrong thing if the two directories 1781 * were the same, so again we do it by hand 1782 */ 1783 fill_post_wcc(ffhp); 1784 fill_post_wcc(tfhp); 1785 unlock_rename(tdentry, fdentry); 1786 ffhp->fh_locked = tfhp->fh_locked = 0; 1787 1788 out: 1789 return err; 1790 } 1791 1792 /* 1793 * Unlink a file or directory 1794 * N.B. After this call fhp needs an fh_put 1795 */ 1796 __be32 1797 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, 1798 char *fname, int flen) 1799 { 1800 struct dentry *dentry, *rdentry; 1801 struct inode *dirp; 1802 __be32 err; 1803 int host_err; 1804 1805 err = nfserr_acces; 1806 if (!flen || isdotent(fname, flen)) 1807 goto out; 1808 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE); 1809 if (err) 1810 goto out; 1811 1812 fh_lock_nested(fhp, I_MUTEX_PARENT); 1813 dentry = fhp->fh_dentry; 1814 dirp = dentry->d_inode; 1815 1816 rdentry = lookup_one_len(fname, dentry, flen); 1817 host_err = PTR_ERR(rdentry); 1818 if (IS_ERR(rdentry)) 1819 goto out_nfserr; 1820 1821 if (!rdentry->d_inode) { 1822 dput(rdentry); 1823 err = nfserr_noent; 1824 goto out; 1825 } 1826 1827 if (!type) 1828 type = rdentry->d_inode->i_mode & S_IFMT; 1829 1830 host_err = mnt_want_write(fhp->fh_export->ex_path.mnt); 1831 if (host_err) 1832 goto out_nfserr; 1833 1834 if (type != S_IFDIR) { /* It's UNLINK */ 1835 #ifdef MSNFS 1836 if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) && 1837 (atomic_read(&rdentry->d_count) > 1)) { 1838 host_err = -EPERM; 1839 } else 1840 #endif 1841 host_err = vfs_unlink(dirp, rdentry); 1842 } else { /* It's RMDIR */ 1843 host_err = vfs_rmdir(dirp, rdentry); 1844 } 1845 1846 dput(rdentry); 1847 1848 if (host_err) 1849 goto out_drop; 1850 if (EX_ISSYNC(fhp->fh_export)) 1851 host_err = nfsd_sync_dir(dentry); 1852 1853 out_drop: 1854 mnt_drop_write(fhp->fh_export->ex_path.mnt); 1855 out_nfserr: 1856 err = nfserrno(host_err); 1857 out: 1858 return err; 1859 } 1860 1861 /* 1862 * We do this buffering because we must not call back into the file 1863 * system's ->lookup() method from the filldir callback. That may well 1864 * deadlock a number of file systems. 1865 * 1866 * This is based heavily on the implementation of same in XFS. 1867 */ 1868 struct buffered_dirent { 1869 u64 ino; 1870 loff_t offset; 1871 int namlen; 1872 unsigned int d_type; 1873 char name[]; 1874 }; 1875 1876 struct readdir_data { 1877 char *dirent; 1878 size_t used; 1879 int full; 1880 }; 1881 1882 static int nfsd_buffered_filldir(void *__buf, const char *name, int namlen, 1883 loff_t offset, u64 ino, unsigned int d_type) 1884 { 1885 struct readdir_data *buf = __buf; 1886 struct buffered_dirent *de = (void *)(buf->dirent + buf->used); 1887 unsigned int reclen; 1888 1889 reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64)); 1890 if (buf->used + reclen > PAGE_SIZE) { 1891 buf->full = 1; 1892 return -EINVAL; 1893 } 1894 1895 de->namlen = namlen; 1896 de->offset = offset; 1897 de->ino = ino; 1898 de->d_type = d_type; 1899 memcpy(de->name, name, namlen); 1900 buf->used += reclen; 1901 1902 return 0; 1903 } 1904 1905 static __be32 nfsd_buffered_readdir(struct file *file, filldir_t func, 1906 struct readdir_cd *cdp, loff_t *offsetp) 1907 { 1908 struct readdir_data buf; 1909 struct buffered_dirent *de; 1910 int host_err; 1911 int size; 1912 loff_t offset; 1913 1914 buf.dirent = (void *)__get_free_page(GFP_KERNEL); 1915 if (!buf.dirent) 1916 return nfserrno(-ENOMEM); 1917 1918 offset = *offsetp; 1919 1920 while (1) { 1921 struct inode *dir_inode = file->f_path.dentry->d_inode; 1922 unsigned int reclen; 1923 1924 cdp->err = nfserr_eof; /* will be cleared on successful read */ 1925 buf.used = 0; 1926 buf.full = 0; 1927 1928 host_err = vfs_readdir(file, nfsd_buffered_filldir, &buf); 1929 if (buf.full) 1930 host_err = 0; 1931 1932 if (host_err < 0) 1933 break; 1934 1935 size = buf.used; 1936 1937 if (!size) 1938 break; 1939 1940 /* 1941 * Various filldir functions may end up calling back into 1942 * lookup_one_len() and the file system's ->lookup() method. 1943 * These expect i_mutex to be held, as it would within readdir. 1944 */ 1945 host_err = mutex_lock_killable(&dir_inode->i_mutex); 1946 if (host_err) 1947 break; 1948 1949 de = (struct buffered_dirent *)buf.dirent; 1950 while (size > 0) { 1951 offset = de->offset; 1952 1953 if (func(cdp, de->name, de->namlen, de->offset, 1954 de->ino, de->d_type)) 1955 break; 1956 1957 if (cdp->err != nfs_ok) 1958 break; 1959 1960 reclen = ALIGN(sizeof(*de) + de->namlen, 1961 sizeof(u64)); 1962 size -= reclen; 1963 de = (struct buffered_dirent *)((char *)de + reclen); 1964 } 1965 mutex_unlock(&dir_inode->i_mutex); 1966 if (size > 0) /* We bailed out early */ 1967 break; 1968 1969 offset = vfs_llseek(file, 0, SEEK_CUR); 1970 } 1971 1972 free_page((unsigned long)(buf.dirent)); 1973 1974 if (host_err) 1975 return nfserrno(host_err); 1976 1977 *offsetp = offset; 1978 return cdp->err; 1979 } 1980 1981 /* 1982 * Read entries from a directory. 1983 * The NFSv3/4 verifier we ignore for now. 1984 */ 1985 __be32 1986 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp, 1987 struct readdir_cd *cdp, filldir_t func) 1988 { 1989 __be32 err; 1990 struct file *file; 1991 loff_t offset = *offsetp; 1992 1993 err = nfsd_open(rqstp, fhp, S_IFDIR, NFSD_MAY_READ, &file); 1994 if (err) 1995 goto out; 1996 1997 offset = vfs_llseek(file, offset, 0); 1998 if (offset < 0) { 1999 err = nfserrno((int)offset); 2000 goto out_close; 2001 } 2002 2003 err = nfsd_buffered_readdir(file, func, cdp, offsetp); 2004 2005 if (err == nfserr_eof || err == nfserr_toosmall) 2006 err = nfs_ok; /* can still be found in ->err */ 2007 out_close: 2008 nfsd_close(file); 2009 out: 2010 return err; 2011 } 2012 2013 /* 2014 * Get file system stats 2015 * N.B. After this call fhp needs an fh_put 2016 */ 2017 __be32 2018 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access) 2019 { 2020 __be32 err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access); 2021 if (!err && vfs_statfs(fhp->fh_dentry,stat)) 2022 err = nfserr_io; 2023 return err; 2024 } 2025 2026 static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp) 2027 { 2028 return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY; 2029 } 2030 2031 /* 2032 * Check for a user's access permissions to this inode. 2033 */ 2034 __be32 2035 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp, 2036 struct dentry *dentry, int acc) 2037 { 2038 struct inode *inode = dentry->d_inode; 2039 struct path path; 2040 int err; 2041 2042 if (acc == NFSD_MAY_NOP) 2043 return 0; 2044 #if 0 2045 dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n", 2046 acc, 2047 (acc & NFSD_MAY_READ)? " read" : "", 2048 (acc & NFSD_MAY_WRITE)? " write" : "", 2049 (acc & NFSD_MAY_EXEC)? " exec" : "", 2050 (acc & NFSD_MAY_SATTR)? " sattr" : "", 2051 (acc & NFSD_MAY_TRUNC)? " trunc" : "", 2052 (acc & NFSD_MAY_LOCK)? " lock" : "", 2053 (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "", 2054 inode->i_mode, 2055 IS_IMMUTABLE(inode)? " immut" : "", 2056 IS_APPEND(inode)? " append" : "", 2057 __mnt_is_readonly(exp->ex_path.mnt)? " ro" : ""); 2058 dprintk(" owner %d/%d user %d/%d\n", 2059 inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid()); 2060 #endif 2061 2062 /* Normally we reject any write/sattr etc access on a read-only file 2063 * system. But if it is IRIX doing check on write-access for a 2064 * device special file, we ignore rofs. 2065 */ 2066 if (!(acc & NFSD_MAY_LOCAL_ACCESS)) 2067 if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) { 2068 if (exp_rdonly(rqstp, exp) || 2069 __mnt_is_readonly(exp->ex_path.mnt)) 2070 return nfserr_rofs; 2071 if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode)) 2072 return nfserr_perm; 2073 } 2074 if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode)) 2075 return nfserr_perm; 2076 2077 if (acc & NFSD_MAY_LOCK) { 2078 /* If we cannot rely on authentication in NLM requests, 2079 * just allow locks, otherwise require read permission, or 2080 * ownership 2081 */ 2082 if (exp->ex_flags & NFSEXP_NOAUTHNLM) 2083 return 0; 2084 else 2085 acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE; 2086 } 2087 /* 2088 * The file owner always gets access permission for accesses that 2089 * would normally be checked at open time. This is to make 2090 * file access work even when the client has done a fchmod(fd, 0). 2091 * 2092 * However, `cp foo bar' should fail nevertheless when bar is 2093 * readonly. A sensible way to do this might be to reject all 2094 * attempts to truncate a read-only file, because a creat() call 2095 * always implies file truncation. 2096 * ... but this isn't really fair. A process may reasonably call 2097 * ftruncate on an open file descriptor on a file with perm 000. 2098 * We must trust the client to do permission checking - using "ACCESS" 2099 * with NFSv3. 2100 */ 2101 if ((acc & NFSD_MAY_OWNER_OVERRIDE) && 2102 inode->i_uid == current_fsuid()) 2103 return 0; 2104 2105 /* This assumes NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */ 2106 err = inode_permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC)); 2107 2108 /* Allow read access to binaries even when mode 111 */ 2109 if (err == -EACCES && S_ISREG(inode->i_mode) && 2110 acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE)) 2111 err = inode_permission(inode, MAY_EXEC); 2112 if (err) 2113 goto nfsd_out; 2114 2115 /* Do integrity (permission) checking now, but defer incrementing 2116 * IMA counts to the actual file open. 2117 */ 2118 path.mnt = exp->ex_path.mnt; 2119 path.dentry = dentry; 2120 err = ima_path_check(&path, acc & (MAY_READ | MAY_WRITE | MAY_EXEC), 2121 IMA_COUNT_LEAVE); 2122 nfsd_out: 2123 return err? nfserrno(err) : 0; 2124 } 2125 2126 void 2127 nfsd_racache_shutdown(void) 2128 { 2129 struct raparms *raparm, *last_raparm; 2130 unsigned int i; 2131 2132 dprintk("nfsd: freeing readahead buffers.\n"); 2133 2134 for (i = 0; i < RAPARM_HASH_SIZE; i++) { 2135 raparm = raparm_hash[i].pb_head; 2136 while(raparm) { 2137 last_raparm = raparm; 2138 raparm = raparm->p_next; 2139 kfree(last_raparm); 2140 } 2141 raparm_hash[i].pb_head = NULL; 2142 } 2143 } 2144 /* 2145 * Initialize readahead param cache 2146 */ 2147 int 2148 nfsd_racache_init(int cache_size) 2149 { 2150 int i; 2151 int j = 0; 2152 int nperbucket; 2153 struct raparms **raparm = NULL; 2154 2155 2156 if (raparm_hash[0].pb_head) 2157 return 0; 2158 nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE); 2159 if (nperbucket < 2) 2160 nperbucket = 2; 2161 cache_size = nperbucket * RAPARM_HASH_SIZE; 2162 2163 dprintk("nfsd: allocating %d readahead buffers.\n", cache_size); 2164 2165 for (i = 0; i < RAPARM_HASH_SIZE; i++) { 2166 spin_lock_init(&raparm_hash[i].pb_lock); 2167 2168 raparm = &raparm_hash[i].pb_head; 2169 for (j = 0; j < nperbucket; j++) { 2170 *raparm = kzalloc(sizeof(struct raparms), GFP_KERNEL); 2171 if (!*raparm) 2172 goto out_nomem; 2173 raparm = &(*raparm)->p_next; 2174 } 2175 *raparm = NULL; 2176 } 2177 2178 nfsdstats.ra_size = cache_size; 2179 return 0; 2180 2181 out_nomem: 2182 dprintk("nfsd: kmalloc failed, freeing readahead buffers\n"); 2183 nfsd_racache_shutdown(); 2184 return -ENOMEM; 2185 } 2186 2187 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 2188 struct posix_acl * 2189 nfsd_get_posix_acl(struct svc_fh *fhp, int type) 2190 { 2191 struct inode *inode = fhp->fh_dentry->d_inode; 2192 char *name; 2193 void *value = NULL; 2194 ssize_t size; 2195 struct posix_acl *acl; 2196 2197 if (!IS_POSIXACL(inode)) 2198 return ERR_PTR(-EOPNOTSUPP); 2199 2200 switch (type) { 2201 case ACL_TYPE_ACCESS: 2202 name = POSIX_ACL_XATTR_ACCESS; 2203 break; 2204 case ACL_TYPE_DEFAULT: 2205 name = POSIX_ACL_XATTR_DEFAULT; 2206 break; 2207 default: 2208 return ERR_PTR(-EOPNOTSUPP); 2209 } 2210 2211 size = nfsd_getxattr(fhp->fh_dentry, name, &value); 2212 if (size < 0) 2213 return ERR_PTR(size); 2214 2215 acl = posix_acl_from_xattr(value, size); 2216 kfree(value); 2217 return acl; 2218 } 2219 2220 int 2221 nfsd_set_posix_acl(struct svc_fh *fhp, int type, struct posix_acl *acl) 2222 { 2223 struct inode *inode = fhp->fh_dentry->d_inode; 2224 char *name; 2225 void *value = NULL; 2226 size_t size; 2227 int error; 2228 2229 if (!IS_POSIXACL(inode) || 2230 !inode->i_op->setxattr || !inode->i_op->removexattr) 2231 return -EOPNOTSUPP; 2232 switch(type) { 2233 case ACL_TYPE_ACCESS: 2234 name = POSIX_ACL_XATTR_ACCESS; 2235 break; 2236 case ACL_TYPE_DEFAULT: 2237 name = POSIX_ACL_XATTR_DEFAULT; 2238 break; 2239 default: 2240 return -EOPNOTSUPP; 2241 } 2242 2243 if (acl && acl->a_count) { 2244 size = posix_acl_xattr_size(acl->a_count); 2245 value = kmalloc(size, GFP_KERNEL); 2246 if (!value) 2247 return -ENOMEM; 2248 error = posix_acl_to_xattr(acl, value, size); 2249 if (error < 0) 2250 goto getout; 2251 size = error; 2252 } else 2253 size = 0; 2254 2255 error = mnt_want_write(fhp->fh_export->ex_path.mnt); 2256 if (error) 2257 goto getout; 2258 if (size) 2259 error = vfs_setxattr(fhp->fh_dentry, name, value, size, 0); 2260 else { 2261 if (!S_ISDIR(inode->i_mode) && type == ACL_TYPE_DEFAULT) 2262 error = 0; 2263 else { 2264 error = vfs_removexattr(fhp->fh_dentry, name); 2265 if (error == -ENODATA) 2266 error = 0; 2267 } 2268 } 2269 mnt_drop_write(fhp->fh_export->ex_path.mnt); 2270 2271 getout: 2272 kfree(value); 2273 return error; 2274 } 2275 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */ 2276