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