1 /* 2 * linux/fs/nfs/dir.c 3 * 4 * Copyright (C) 1992 Rick Sladkey 5 * 6 * nfs directory handling functions 7 * 8 * 10 Apr 1996 Added silly rename for unlink --okir 9 * 28 Sep 1996 Improved directory cache --okir 10 * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de 11 * Re-implemented silly rename for unlink, newly implemented 12 * silly rename for nfs_rename() following the suggestions 13 * of Olaf Kirch (okir) found in this file. 14 * Following Linus comments on my original hack, this version 15 * depends only on the dcache stuff and doesn't touch the inode 16 * layer (iput() and friends). 17 * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM 18 */ 19 20 #include <linux/time.h> 21 #include <linux/errno.h> 22 #include <linux/stat.h> 23 #include <linux/fcntl.h> 24 #include <linux/string.h> 25 #include <linux/kernel.h> 26 #include <linux/slab.h> 27 #include <linux/mm.h> 28 #include <linux/sunrpc/clnt.h> 29 #include <linux/nfs_fs.h> 30 #include <linux/nfs_mount.h> 31 #include <linux/pagemap.h> 32 #include <linux/pagevec.h> 33 #include <linux/namei.h> 34 #include <linux/mount.h> 35 #include <linux/sched.h> 36 #include <linux/kmemleak.h> 37 #include <linux/xattr.h> 38 39 #include "delegation.h" 40 #include "iostat.h" 41 #include "internal.h" 42 #include "fscache.h" 43 44 /* #define NFS_DEBUG_VERBOSE 1 */ 45 46 static int nfs_opendir(struct inode *, struct file *); 47 static int nfs_readdir(struct file *, void *, filldir_t); 48 static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *); 49 static int nfs_create(struct inode *, struct dentry *, int, struct nameidata *); 50 static int nfs_mkdir(struct inode *, struct dentry *, int); 51 static int nfs_rmdir(struct inode *, struct dentry *); 52 static int nfs_unlink(struct inode *, struct dentry *); 53 static int nfs_symlink(struct inode *, struct dentry *, const char *); 54 static int nfs_link(struct dentry *, struct inode *, struct dentry *); 55 static int nfs_mknod(struct inode *, struct dentry *, int, dev_t); 56 static int nfs_rename(struct inode *, struct dentry *, 57 struct inode *, struct dentry *); 58 static int nfs_fsync_dir(struct file *, int); 59 static loff_t nfs_llseek_dir(struct file *, loff_t, int); 60 static void nfs_readdir_clear_array(struct page*); 61 62 const struct file_operations nfs_dir_operations = { 63 .llseek = nfs_llseek_dir, 64 .read = generic_read_dir, 65 .readdir = nfs_readdir, 66 .open = nfs_opendir, 67 .release = nfs_release, 68 .fsync = nfs_fsync_dir, 69 }; 70 71 const struct inode_operations nfs_dir_inode_operations = { 72 .create = nfs_create, 73 .lookup = nfs_lookup, 74 .link = nfs_link, 75 .unlink = nfs_unlink, 76 .symlink = nfs_symlink, 77 .mkdir = nfs_mkdir, 78 .rmdir = nfs_rmdir, 79 .mknod = nfs_mknod, 80 .rename = nfs_rename, 81 .permission = nfs_permission, 82 .getattr = nfs_getattr, 83 .setattr = nfs_setattr, 84 }; 85 86 const struct address_space_operations nfs_dir_aops = { 87 .freepage = nfs_readdir_clear_array, 88 }; 89 90 #ifdef CONFIG_NFS_V3 91 const struct inode_operations nfs3_dir_inode_operations = { 92 .create = nfs_create, 93 .lookup = nfs_lookup, 94 .link = nfs_link, 95 .unlink = nfs_unlink, 96 .symlink = nfs_symlink, 97 .mkdir = nfs_mkdir, 98 .rmdir = nfs_rmdir, 99 .mknod = nfs_mknod, 100 .rename = nfs_rename, 101 .permission = nfs_permission, 102 .getattr = nfs_getattr, 103 .setattr = nfs_setattr, 104 .listxattr = nfs3_listxattr, 105 .getxattr = nfs3_getxattr, 106 .setxattr = nfs3_setxattr, 107 .removexattr = nfs3_removexattr, 108 }; 109 #endif /* CONFIG_NFS_V3 */ 110 111 #ifdef CONFIG_NFS_V4 112 113 static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *); 114 static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd); 115 const struct inode_operations nfs4_dir_inode_operations = { 116 .create = nfs_open_create, 117 .lookup = nfs_atomic_lookup, 118 .link = nfs_link, 119 .unlink = nfs_unlink, 120 .symlink = nfs_symlink, 121 .mkdir = nfs_mkdir, 122 .rmdir = nfs_rmdir, 123 .mknod = nfs_mknod, 124 .rename = nfs_rename, 125 .permission = nfs_permission, 126 .getattr = nfs_getattr, 127 .setattr = nfs_setattr, 128 .getxattr = generic_getxattr, 129 .setxattr = generic_setxattr, 130 .listxattr = generic_listxattr, 131 .removexattr = generic_removexattr, 132 }; 133 134 #endif /* CONFIG_NFS_V4 */ 135 136 /* 137 * Open file 138 */ 139 static int 140 nfs_opendir(struct inode *inode, struct file *filp) 141 { 142 int res; 143 144 dfprintk(FILE, "NFS: open dir(%s/%s)\n", 145 filp->f_path.dentry->d_parent->d_name.name, 146 filp->f_path.dentry->d_name.name); 147 148 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 149 150 /* Call generic open code in order to cache credentials */ 151 res = nfs_open(inode, filp); 152 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 153 /* This is a mountpoint, so d_revalidate will never 154 * have been called, so we need to refresh the 155 * inode (for close-open consistency) ourselves. 156 */ 157 __nfs_revalidate_inode(NFS_SERVER(inode), inode); 158 } 159 return res; 160 } 161 162 struct nfs_cache_array_entry { 163 u64 cookie; 164 u64 ino; 165 struct qstr string; 166 unsigned char d_type; 167 }; 168 169 struct nfs_cache_array { 170 unsigned int size; 171 int eof_index; 172 u64 last_cookie; 173 struct nfs_cache_array_entry array[0]; 174 }; 175 176 typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int); 177 typedef struct { 178 struct file *file; 179 struct page *page; 180 unsigned long page_index; 181 u64 *dir_cookie; 182 u64 last_cookie; 183 loff_t current_index; 184 decode_dirent_t decode; 185 186 unsigned long timestamp; 187 unsigned long gencount; 188 unsigned int cache_entry_index; 189 unsigned int plus:1; 190 unsigned int eof:1; 191 } nfs_readdir_descriptor_t; 192 193 /* 194 * The caller is responsible for calling nfs_readdir_release_array(page) 195 */ 196 static 197 struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 198 { 199 void *ptr; 200 if (page == NULL) 201 return ERR_PTR(-EIO); 202 ptr = kmap(page); 203 if (ptr == NULL) 204 return ERR_PTR(-ENOMEM); 205 return ptr; 206 } 207 208 static 209 void nfs_readdir_release_array(struct page *page) 210 { 211 kunmap(page); 212 } 213 214 /* 215 * we are freeing strings created by nfs_add_to_readdir_array() 216 */ 217 static 218 void nfs_readdir_clear_array(struct page *page) 219 { 220 struct nfs_cache_array *array; 221 int i; 222 223 array = kmap_atomic(page, KM_USER0); 224 for (i = 0; i < array->size; i++) 225 kfree(array->array[i].string.name); 226 kunmap_atomic(array, KM_USER0); 227 } 228 229 /* 230 * the caller is responsible for freeing qstr.name 231 * when called by nfs_readdir_add_to_array, the strings will be freed in 232 * nfs_clear_readdir_array() 233 */ 234 static 235 int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len) 236 { 237 string->len = len; 238 string->name = kmemdup(name, len, GFP_KERNEL); 239 if (string->name == NULL) 240 return -ENOMEM; 241 /* 242 * Avoid a kmemleak false positive. The pointer to the name is stored 243 * in a page cache page which kmemleak does not scan. 244 */ 245 kmemleak_not_leak(string->name); 246 string->hash = full_name_hash(name, len); 247 return 0; 248 } 249 250 static 251 int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page) 252 { 253 struct nfs_cache_array *array = nfs_readdir_get_array(page); 254 struct nfs_cache_array_entry *cache_entry; 255 int ret; 256 257 if (IS_ERR(array)) 258 return PTR_ERR(array); 259 260 cache_entry = &array->array[array->size]; 261 262 /* Check that this entry lies within the page bounds */ 263 ret = -ENOSPC; 264 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE) 265 goto out; 266 267 cache_entry->cookie = entry->prev_cookie; 268 cache_entry->ino = entry->ino; 269 cache_entry->d_type = entry->d_type; 270 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len); 271 if (ret) 272 goto out; 273 array->last_cookie = entry->cookie; 274 array->size++; 275 if (entry->eof != 0) 276 array->eof_index = array->size; 277 out: 278 nfs_readdir_release_array(page); 279 return ret; 280 } 281 282 static 283 int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 284 { 285 loff_t diff = desc->file->f_pos - desc->current_index; 286 unsigned int index; 287 288 if (diff < 0) 289 goto out_eof; 290 if (diff >= array->size) { 291 if (array->eof_index >= 0) 292 goto out_eof; 293 desc->current_index += array->size; 294 return -EAGAIN; 295 } 296 297 index = (unsigned int)diff; 298 *desc->dir_cookie = array->array[index].cookie; 299 desc->cache_entry_index = index; 300 return 0; 301 out_eof: 302 desc->eof = 1; 303 return -EBADCOOKIE; 304 } 305 306 static 307 int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 308 { 309 int i; 310 int status = -EAGAIN; 311 312 for (i = 0; i < array->size; i++) { 313 if (array->array[i].cookie == *desc->dir_cookie) { 314 desc->cache_entry_index = i; 315 return 0; 316 } 317 } 318 if (array->eof_index >= 0) { 319 status = -EBADCOOKIE; 320 if (*desc->dir_cookie == array->last_cookie) 321 desc->eof = 1; 322 } 323 return status; 324 } 325 326 static 327 int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 328 { 329 struct nfs_cache_array *array; 330 int status; 331 332 array = nfs_readdir_get_array(desc->page); 333 if (IS_ERR(array)) { 334 status = PTR_ERR(array); 335 goto out; 336 } 337 338 if (*desc->dir_cookie == 0) 339 status = nfs_readdir_search_for_pos(array, desc); 340 else 341 status = nfs_readdir_search_for_cookie(array, desc); 342 343 if (status == -EAGAIN) { 344 desc->last_cookie = array->last_cookie; 345 desc->page_index++; 346 } 347 nfs_readdir_release_array(desc->page); 348 out: 349 return status; 350 } 351 352 /* Fill a page with xdr information before transferring to the cache page */ 353 static 354 int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 355 struct nfs_entry *entry, struct file *file, struct inode *inode) 356 { 357 struct rpc_cred *cred = nfs_file_cred(file); 358 unsigned long timestamp, gencount; 359 int error; 360 361 again: 362 timestamp = jiffies; 363 gencount = nfs_inc_attr_generation_counter(); 364 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages, 365 NFS_SERVER(inode)->dtsize, desc->plus); 366 if (error < 0) { 367 /* We requested READDIRPLUS, but the server doesn't grok it */ 368 if (error == -ENOTSUPP && desc->plus) { 369 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 370 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 371 desc->plus = 0; 372 goto again; 373 } 374 goto error; 375 } 376 desc->timestamp = timestamp; 377 desc->gencount = gencount; 378 error: 379 return error; 380 } 381 382 static int xdr_decode(nfs_readdir_descriptor_t *desc, 383 struct nfs_entry *entry, struct xdr_stream *xdr) 384 { 385 int error; 386 387 error = desc->decode(xdr, entry, desc->plus); 388 if (error) 389 return error; 390 entry->fattr->time_start = desc->timestamp; 391 entry->fattr->gencount = desc->gencount; 392 return 0; 393 } 394 395 static 396 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 397 { 398 if (dentry->d_inode == NULL) 399 goto different; 400 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0) 401 goto different; 402 return 1; 403 different: 404 return 0; 405 } 406 407 static 408 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry) 409 { 410 struct qstr filename = { 411 .len = entry->len, 412 .name = entry->name, 413 }; 414 struct dentry *dentry; 415 struct dentry *alias; 416 struct inode *dir = parent->d_inode; 417 struct inode *inode; 418 419 if (filename.name[0] == '.') { 420 if (filename.len == 1) 421 return; 422 if (filename.len == 2 && filename.name[1] == '.') 423 return; 424 } 425 filename.hash = full_name_hash(filename.name, filename.len); 426 427 dentry = d_lookup(parent, &filename); 428 if (dentry != NULL) { 429 if (nfs_same_file(dentry, entry)) { 430 nfs_refresh_inode(dentry->d_inode, entry->fattr); 431 goto out; 432 } else { 433 d_drop(dentry); 434 dput(dentry); 435 } 436 } 437 438 dentry = d_alloc(parent, &filename); 439 if (dentry == NULL) 440 return; 441 442 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr); 443 if (IS_ERR(inode)) 444 goto out; 445 446 alias = d_materialise_unique(dentry, inode); 447 if (IS_ERR(alias)) 448 goto out; 449 else if (alias) { 450 nfs_set_verifier(alias, nfs_save_change_attribute(dir)); 451 dput(alias); 452 } else 453 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 454 455 out: 456 dput(dentry); 457 } 458 459 /* Perform conversion from xdr to cache array */ 460 static 461 int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, 462 struct page **xdr_pages, struct page *page, unsigned int buflen) 463 { 464 struct xdr_stream stream; 465 struct xdr_buf buf = { 466 .pages = xdr_pages, 467 .page_len = buflen, 468 .buflen = buflen, 469 .len = buflen, 470 }; 471 struct page *scratch; 472 struct nfs_cache_array *array; 473 unsigned int count = 0; 474 int status; 475 476 scratch = alloc_page(GFP_KERNEL); 477 if (scratch == NULL) 478 return -ENOMEM; 479 480 xdr_init_decode(&stream, &buf, NULL); 481 xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE); 482 483 do { 484 status = xdr_decode(desc, entry, &stream); 485 if (status != 0) { 486 if (status == -EAGAIN) 487 status = 0; 488 break; 489 } 490 491 count++; 492 493 if (desc->plus != 0) 494 nfs_prime_dcache(desc->file->f_path.dentry, entry); 495 496 status = nfs_readdir_add_to_array(entry, page); 497 if (status != 0) 498 break; 499 } while (!entry->eof); 500 501 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) { 502 array = nfs_readdir_get_array(page); 503 if (!IS_ERR(array)) { 504 array->eof_index = array->size; 505 status = 0; 506 nfs_readdir_release_array(page); 507 } else 508 status = PTR_ERR(array); 509 } 510 511 put_page(scratch); 512 return status; 513 } 514 515 static 516 void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages) 517 { 518 unsigned int i; 519 for (i = 0; i < npages; i++) 520 put_page(pages[i]); 521 } 522 523 static 524 void nfs_readdir_free_large_page(void *ptr, struct page **pages, 525 unsigned int npages) 526 { 527 nfs_readdir_free_pagearray(pages, npages); 528 } 529 530 /* 531 * nfs_readdir_large_page will allocate pages that must be freed with a call 532 * to nfs_readdir_free_large_page 533 */ 534 static 535 int nfs_readdir_large_page(struct page **pages, unsigned int npages) 536 { 537 unsigned int i; 538 539 for (i = 0; i < npages; i++) { 540 struct page *page = alloc_page(GFP_KERNEL); 541 if (page == NULL) 542 goto out_freepages; 543 pages[i] = page; 544 } 545 return 0; 546 547 out_freepages: 548 nfs_readdir_free_pagearray(pages, i); 549 return -ENOMEM; 550 } 551 552 static 553 int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 554 { 555 struct page *pages[NFS_MAX_READDIR_PAGES]; 556 void *pages_ptr = NULL; 557 struct nfs_entry entry; 558 struct file *file = desc->file; 559 struct nfs_cache_array *array; 560 int status = -ENOMEM; 561 unsigned int array_size = ARRAY_SIZE(pages); 562 563 entry.prev_cookie = 0; 564 entry.cookie = desc->last_cookie; 565 entry.eof = 0; 566 entry.fh = nfs_alloc_fhandle(); 567 entry.fattr = nfs_alloc_fattr(); 568 entry.server = NFS_SERVER(inode); 569 if (entry.fh == NULL || entry.fattr == NULL) 570 goto out; 571 572 array = nfs_readdir_get_array(page); 573 if (IS_ERR(array)) { 574 status = PTR_ERR(array); 575 goto out; 576 } 577 memset(array, 0, sizeof(struct nfs_cache_array)); 578 array->eof_index = -1; 579 580 status = nfs_readdir_large_page(pages, array_size); 581 if (status < 0) 582 goto out_release_array; 583 do { 584 unsigned int pglen; 585 status = nfs_readdir_xdr_filler(pages, desc, &entry, file, inode); 586 587 if (status < 0) 588 break; 589 pglen = status; 590 status = nfs_readdir_page_filler(desc, &entry, pages, page, pglen); 591 if (status < 0) { 592 if (status == -ENOSPC) 593 status = 0; 594 break; 595 } 596 } while (array->eof_index < 0); 597 598 nfs_readdir_free_large_page(pages_ptr, pages, array_size); 599 out_release_array: 600 nfs_readdir_release_array(page); 601 out: 602 nfs_free_fattr(entry.fattr); 603 nfs_free_fhandle(entry.fh); 604 return status; 605 } 606 607 /* 608 * Now we cache directories properly, by converting xdr information 609 * to an array that can be used for lookups later. This results in 610 * fewer cache pages, since we can store more information on each page. 611 * We only need to convert from xdr once so future lookups are much simpler 612 */ 613 static 614 int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page* page) 615 { 616 struct inode *inode = desc->file->f_path.dentry->d_inode; 617 int ret; 618 619 ret = nfs_readdir_xdr_to_array(desc, page, inode); 620 if (ret < 0) 621 goto error; 622 SetPageUptodate(page); 623 624 if (invalidate_inode_pages2_range(inode->i_mapping, page->index + 1, -1) < 0) { 625 /* Should never happen */ 626 nfs_zap_mapping(inode, inode->i_mapping); 627 } 628 unlock_page(page); 629 return 0; 630 error: 631 unlock_page(page); 632 return ret; 633 } 634 635 static 636 void cache_page_release(nfs_readdir_descriptor_t *desc) 637 { 638 if (!desc->page->mapping) 639 nfs_readdir_clear_array(desc->page); 640 page_cache_release(desc->page); 641 desc->page = NULL; 642 } 643 644 static 645 struct page *get_cache_page(nfs_readdir_descriptor_t *desc) 646 { 647 return read_cache_page(desc->file->f_path.dentry->d_inode->i_mapping, 648 desc->page_index, (filler_t *)nfs_readdir_filler, desc); 649 } 650 651 /* 652 * Returns 0 if desc->dir_cookie was found on page desc->page_index 653 */ 654 static 655 int find_cache_page(nfs_readdir_descriptor_t *desc) 656 { 657 int res; 658 659 desc->page = get_cache_page(desc); 660 if (IS_ERR(desc->page)) 661 return PTR_ERR(desc->page); 662 663 res = nfs_readdir_search_array(desc); 664 if (res != 0) 665 cache_page_release(desc); 666 return res; 667 } 668 669 /* Search for desc->dir_cookie from the beginning of the page cache */ 670 static inline 671 int readdir_search_pagecache(nfs_readdir_descriptor_t *desc) 672 { 673 int res; 674 675 if (desc->page_index == 0) { 676 desc->current_index = 0; 677 desc->last_cookie = 0; 678 } 679 do { 680 res = find_cache_page(desc); 681 } while (res == -EAGAIN); 682 return res; 683 } 684 685 /* 686 * Once we've found the start of the dirent within a page: fill 'er up... 687 */ 688 static 689 int nfs_do_filldir(nfs_readdir_descriptor_t *desc, void *dirent, 690 filldir_t filldir) 691 { 692 struct file *file = desc->file; 693 int i = 0; 694 int res = 0; 695 struct nfs_cache_array *array = NULL; 696 697 array = nfs_readdir_get_array(desc->page); 698 if (IS_ERR(array)) { 699 res = PTR_ERR(array); 700 goto out; 701 } 702 703 for (i = desc->cache_entry_index; i < array->size; i++) { 704 struct nfs_cache_array_entry *ent; 705 706 ent = &array->array[i]; 707 if (filldir(dirent, ent->string.name, ent->string.len, 708 file->f_pos, nfs_compat_user_ino64(ent->ino), 709 ent->d_type) < 0) { 710 desc->eof = 1; 711 break; 712 } 713 file->f_pos++; 714 if (i < (array->size-1)) 715 *desc->dir_cookie = array->array[i+1].cookie; 716 else 717 *desc->dir_cookie = array->last_cookie; 718 } 719 if (array->eof_index >= 0) 720 desc->eof = 1; 721 722 nfs_readdir_release_array(desc->page); 723 out: 724 cache_page_release(desc); 725 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %Lu; returning = %d\n", 726 (unsigned long long)*desc->dir_cookie, res); 727 return res; 728 } 729 730 /* 731 * If we cannot find a cookie in our cache, we suspect that this is 732 * because it points to a deleted file, so we ask the server to return 733 * whatever it thinks is the next entry. We then feed this to filldir. 734 * If all goes well, we should then be able to find our way round the 735 * cache on the next call to readdir_search_pagecache(); 736 * 737 * NOTE: we cannot add the anonymous page to the pagecache because 738 * the data it contains might not be page aligned. Besides, 739 * we should already have a complete representation of the 740 * directory in the page cache by the time we get here. 741 */ 742 static inline 743 int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent, 744 filldir_t filldir) 745 { 746 struct page *page = NULL; 747 int status; 748 struct inode *inode = desc->file->f_path.dentry->d_inode; 749 750 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n", 751 (unsigned long long)*desc->dir_cookie); 752 753 page = alloc_page(GFP_HIGHUSER); 754 if (!page) { 755 status = -ENOMEM; 756 goto out; 757 } 758 759 desc->page_index = 0; 760 desc->last_cookie = *desc->dir_cookie; 761 desc->page = page; 762 763 status = nfs_readdir_xdr_to_array(desc, page, inode); 764 if (status < 0) 765 goto out_release; 766 767 status = nfs_do_filldir(desc, dirent, filldir); 768 769 out: 770 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 771 __func__, status); 772 return status; 773 out_release: 774 cache_page_release(desc); 775 goto out; 776 } 777 778 /* The file offset position represents the dirent entry number. A 779 last cookie cache takes care of the common case of reading the 780 whole directory. 781 */ 782 static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 783 { 784 struct dentry *dentry = filp->f_path.dentry; 785 struct inode *inode = dentry->d_inode; 786 nfs_readdir_descriptor_t my_desc, 787 *desc = &my_desc; 788 int res; 789 790 dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n", 791 dentry->d_parent->d_name.name, dentry->d_name.name, 792 (long long)filp->f_pos); 793 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 794 795 /* 796 * filp->f_pos points to the dirent entry number. 797 * *desc->dir_cookie has the cookie for the next entry. We have 798 * to either find the entry with the appropriate number or 799 * revalidate the cookie. 800 */ 801 memset(desc, 0, sizeof(*desc)); 802 803 desc->file = filp; 804 desc->dir_cookie = &nfs_file_open_context(filp)->dir_cookie; 805 desc->decode = NFS_PROTO(inode)->decode_dirent; 806 desc->plus = NFS_USE_READDIRPLUS(inode); 807 808 nfs_block_sillyrename(dentry); 809 res = nfs_revalidate_mapping(inode, filp->f_mapping); 810 if (res < 0) 811 goto out; 812 813 do { 814 res = readdir_search_pagecache(desc); 815 816 if (res == -EBADCOOKIE) { 817 res = 0; 818 /* This means either end of directory */ 819 if (*desc->dir_cookie && desc->eof == 0) { 820 /* Or that the server has 'lost' a cookie */ 821 res = uncached_readdir(desc, dirent, filldir); 822 if (res == 0) 823 continue; 824 } 825 break; 826 } 827 if (res == -ETOOSMALL && desc->plus) { 828 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 829 nfs_zap_caches(inode); 830 desc->page_index = 0; 831 desc->plus = 0; 832 desc->eof = 0; 833 continue; 834 } 835 if (res < 0) 836 break; 837 838 res = nfs_do_filldir(desc, dirent, filldir); 839 if (res < 0) 840 break; 841 } while (!desc->eof); 842 out: 843 nfs_unblock_sillyrename(dentry); 844 if (res > 0) 845 res = 0; 846 dfprintk(FILE, "NFS: readdir(%s/%s) returns %d\n", 847 dentry->d_parent->d_name.name, dentry->d_name.name, 848 res); 849 return res; 850 } 851 852 static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 853 { 854 struct dentry *dentry = filp->f_path.dentry; 855 struct inode *inode = dentry->d_inode; 856 857 dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n", 858 dentry->d_parent->d_name.name, 859 dentry->d_name.name, 860 offset, origin); 861 862 mutex_lock(&inode->i_mutex); 863 switch (origin) { 864 case 1: 865 offset += filp->f_pos; 866 case 0: 867 if (offset >= 0) 868 break; 869 default: 870 offset = -EINVAL; 871 goto out; 872 } 873 if (offset != filp->f_pos) { 874 filp->f_pos = offset; 875 nfs_file_open_context(filp)->dir_cookie = 0; 876 } 877 out: 878 mutex_unlock(&inode->i_mutex); 879 return offset; 880 } 881 882 /* 883 * All directory operations under NFS are synchronous, so fsync() 884 * is a dummy operation. 885 */ 886 static int nfs_fsync_dir(struct file *filp, int datasync) 887 { 888 struct dentry *dentry = filp->f_path.dentry; 889 890 dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n", 891 dentry->d_parent->d_name.name, dentry->d_name.name, 892 datasync); 893 894 nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC); 895 return 0; 896 } 897 898 /** 899 * nfs_force_lookup_revalidate - Mark the directory as having changed 900 * @dir - pointer to directory inode 901 * 902 * This forces the revalidation code in nfs_lookup_revalidate() to do a 903 * full lookup on all child dentries of 'dir' whenever a change occurs 904 * on the server that might have invalidated our dcache. 905 * 906 * The caller should be holding dir->i_lock 907 */ 908 void nfs_force_lookup_revalidate(struct inode *dir) 909 { 910 NFS_I(dir)->cache_change_attribute++; 911 } 912 913 /* 914 * A check for whether or not the parent directory has changed. 915 * In the case it has, we assume that the dentries are untrustworthy 916 * and may need to be looked up again. 917 */ 918 static int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 919 { 920 if (IS_ROOT(dentry)) 921 return 1; 922 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 923 return 0; 924 if (!nfs_verify_change_attribute(dir, dentry->d_time)) 925 return 0; 926 /* Revalidate nfsi->cache_change_attribute before we declare a match */ 927 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 928 return 0; 929 if (!nfs_verify_change_attribute(dir, dentry->d_time)) 930 return 0; 931 return 1; 932 } 933 934 /* 935 * Return the intent data that applies to this particular path component 936 * 937 * Note that the current set of intents only apply to the very last 938 * component of the path. 939 * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT. 940 */ 941 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, 942 unsigned int mask) 943 { 944 if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT)) 945 return 0; 946 return nd->flags & mask; 947 } 948 949 /* 950 * Use intent information to check whether or not we're going to do 951 * an O_EXCL create using this path component. 952 */ 953 static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd) 954 { 955 if (NFS_PROTO(dir)->version == 2) 956 return 0; 957 return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL); 958 } 959 960 /* 961 * Inode and filehandle revalidation for lookups. 962 * 963 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 964 * or if the intent information indicates that we're about to open this 965 * particular file and the "nocto" mount flag is not set. 966 * 967 */ 968 static inline 969 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 970 { 971 struct nfs_server *server = NFS_SERVER(inode); 972 973 if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags)) 974 return 0; 975 if (nd != NULL) { 976 /* VFS wants an on-the-wire revalidation */ 977 if (nd->flags & LOOKUP_REVAL) 978 goto out_force; 979 /* This is an open(2) */ 980 if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 981 !(server->flags & NFS_MOUNT_NOCTO) && 982 (S_ISREG(inode->i_mode) || 983 S_ISDIR(inode->i_mode))) 984 goto out_force; 985 return 0; 986 } 987 return nfs_revalidate_inode(server, inode); 988 out_force: 989 return __nfs_revalidate_inode(server, inode); 990 } 991 992 /* 993 * We judge how long we want to trust negative 994 * dentries by looking at the parent inode mtime. 995 * 996 * If parent mtime has changed, we revalidate, else we wait for a 997 * period corresponding to the parent's attribute cache timeout value. 998 */ 999 static inline 1000 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 1001 struct nameidata *nd) 1002 { 1003 /* Don't revalidate a negative dentry if we're creating a new file */ 1004 if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 1005 return 0; 1006 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 1007 return 1; 1008 return !nfs_check_verifier(dir, dentry); 1009 } 1010 1011 /* 1012 * This is called every time the dcache has a lookup hit, 1013 * and we should check whether we can really trust that 1014 * lookup. 1015 * 1016 * NOTE! The hit can be a negative hit too, don't assume 1017 * we have an inode! 1018 * 1019 * If the parent directory is seen to have changed, we throw out the 1020 * cached dentry and do a new lookup. 1021 */ 1022 static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd) 1023 { 1024 struct inode *dir; 1025 struct inode *inode; 1026 struct dentry *parent; 1027 struct nfs_fh *fhandle = NULL; 1028 struct nfs_fattr *fattr = NULL; 1029 int error; 1030 1031 if (nd->flags & LOOKUP_RCU) 1032 return -ECHILD; 1033 1034 parent = dget_parent(dentry); 1035 dir = parent->d_inode; 1036 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 1037 inode = dentry->d_inode; 1038 1039 if (!inode) { 1040 if (nfs_neg_need_reval(dir, dentry, nd)) 1041 goto out_bad; 1042 goto out_valid; 1043 } 1044 1045 if (is_bad_inode(inode)) { 1046 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 1047 __func__, dentry->d_parent->d_name.name, 1048 dentry->d_name.name); 1049 goto out_bad; 1050 } 1051 1052 if (nfs_have_delegation(inode, FMODE_READ)) 1053 goto out_set_verifier; 1054 1055 /* Force a full look up iff the parent directory has changed */ 1056 if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) { 1057 if (nfs_lookup_verify_inode(inode, nd)) 1058 goto out_zap_parent; 1059 goto out_valid; 1060 } 1061 1062 if (NFS_STALE(inode)) 1063 goto out_bad; 1064 1065 error = -ENOMEM; 1066 fhandle = nfs_alloc_fhandle(); 1067 fattr = nfs_alloc_fattr(); 1068 if (fhandle == NULL || fattr == NULL) 1069 goto out_error; 1070 1071 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1072 if (error) 1073 goto out_bad; 1074 if (nfs_compare_fh(NFS_FH(inode), fhandle)) 1075 goto out_bad; 1076 if ((error = nfs_refresh_inode(inode, fattr)) != 0) 1077 goto out_bad; 1078 1079 nfs_free_fattr(fattr); 1080 nfs_free_fhandle(fhandle); 1081 out_set_verifier: 1082 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1083 out_valid: 1084 dput(parent); 1085 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 1086 __func__, dentry->d_parent->d_name.name, 1087 dentry->d_name.name); 1088 return 1; 1089 out_zap_parent: 1090 nfs_zap_caches(dir); 1091 out_bad: 1092 nfs_mark_for_revalidate(dir); 1093 if (inode && S_ISDIR(inode->i_mode)) { 1094 /* Purge readdir caches. */ 1095 nfs_zap_caches(inode); 1096 /* If we have submounts, don't unhash ! */ 1097 if (have_submounts(dentry)) 1098 goto out_valid; 1099 if (dentry->d_flags & DCACHE_DISCONNECTED) 1100 goto out_valid; 1101 shrink_dcache_parent(dentry); 1102 } 1103 d_drop(dentry); 1104 nfs_free_fattr(fattr); 1105 nfs_free_fhandle(fhandle); 1106 dput(parent); 1107 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 1108 __func__, dentry->d_parent->d_name.name, 1109 dentry->d_name.name); 1110 return 0; 1111 out_error: 1112 nfs_free_fattr(fattr); 1113 nfs_free_fhandle(fhandle); 1114 dput(parent); 1115 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) lookup returned error %d\n", 1116 __func__, dentry->d_parent->d_name.name, 1117 dentry->d_name.name, error); 1118 return error; 1119 } 1120 1121 /* 1122 * This is called from dput() when d_count is going to 0. 1123 */ 1124 static int nfs_dentry_delete(const struct dentry *dentry) 1125 { 1126 dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 1127 dentry->d_parent->d_name.name, dentry->d_name.name, 1128 dentry->d_flags); 1129 1130 /* Unhash any dentry with a stale inode */ 1131 if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode)) 1132 return 1; 1133 1134 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1135 /* Unhash it, so that ->d_iput() would be called */ 1136 return 1; 1137 } 1138 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 1139 /* Unhash it, so that ancestors of killed async unlink 1140 * files will be cleaned up during umount */ 1141 return 1; 1142 } 1143 return 0; 1144 1145 } 1146 1147 static void nfs_drop_nlink(struct inode *inode) 1148 { 1149 spin_lock(&inode->i_lock); 1150 if (inode->i_nlink > 0) 1151 drop_nlink(inode); 1152 spin_unlock(&inode->i_lock); 1153 } 1154 1155 /* 1156 * Called when the dentry loses inode. 1157 * We use it to clean up silly-renamed files. 1158 */ 1159 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 1160 { 1161 if (S_ISDIR(inode->i_mode)) 1162 /* drop any readdir cache as it could easily be old */ 1163 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; 1164 1165 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1166 drop_nlink(inode); 1167 nfs_complete_unlink(dentry, inode); 1168 } 1169 iput(inode); 1170 } 1171 1172 const struct dentry_operations nfs_dentry_operations = { 1173 .d_revalidate = nfs_lookup_revalidate, 1174 .d_delete = nfs_dentry_delete, 1175 .d_iput = nfs_dentry_iput, 1176 }; 1177 1178 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 1179 { 1180 struct dentry *res; 1181 struct dentry *parent; 1182 struct inode *inode = NULL; 1183 struct nfs_fh *fhandle = NULL; 1184 struct nfs_fattr *fattr = NULL; 1185 int error; 1186 1187 dfprintk(VFS, "NFS: lookup(%s/%s)\n", 1188 dentry->d_parent->d_name.name, dentry->d_name.name); 1189 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 1190 1191 res = ERR_PTR(-ENAMETOOLONG); 1192 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 1193 goto out; 1194 1195 /* 1196 * If we're doing an exclusive create, optimize away the lookup 1197 * but don't hash the dentry. 1198 */ 1199 if (nfs_is_exclusive_create(dir, nd)) { 1200 d_instantiate(dentry, NULL); 1201 res = NULL; 1202 goto out; 1203 } 1204 1205 res = ERR_PTR(-ENOMEM); 1206 fhandle = nfs_alloc_fhandle(); 1207 fattr = nfs_alloc_fattr(); 1208 if (fhandle == NULL || fattr == NULL) 1209 goto out; 1210 1211 parent = dentry->d_parent; 1212 /* Protect against concurrent sillydeletes */ 1213 nfs_block_sillyrename(parent); 1214 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1215 if (error == -ENOENT) 1216 goto no_entry; 1217 if (error < 0) { 1218 res = ERR_PTR(error); 1219 goto out_unblock_sillyrename; 1220 } 1221 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1222 res = ERR_CAST(inode); 1223 if (IS_ERR(res)) 1224 goto out_unblock_sillyrename; 1225 1226 no_entry: 1227 res = d_materialise_unique(dentry, inode); 1228 if (res != NULL) { 1229 if (IS_ERR(res)) 1230 goto out_unblock_sillyrename; 1231 dentry = res; 1232 } 1233 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1234 out_unblock_sillyrename: 1235 nfs_unblock_sillyrename(parent); 1236 out: 1237 nfs_free_fattr(fattr); 1238 nfs_free_fhandle(fhandle); 1239 return res; 1240 } 1241 1242 #ifdef CONFIG_NFS_V4 1243 static int nfs_open_revalidate(struct dentry *, struct nameidata *); 1244 1245 const struct dentry_operations nfs4_dentry_operations = { 1246 .d_revalidate = nfs_open_revalidate, 1247 .d_delete = nfs_dentry_delete, 1248 .d_iput = nfs_dentry_iput, 1249 }; 1250 1251 /* 1252 * Use intent information to determine whether we need to substitute 1253 * the NFSv4-style stateful OPEN for the LOOKUP call 1254 */ 1255 static int is_atomic_open(struct nameidata *nd) 1256 { 1257 if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 1258 return 0; 1259 /* NFS does not (yet) have a stateful open for directories */ 1260 if (nd->flags & LOOKUP_DIRECTORY) 1261 return 0; 1262 /* Are we trying to write to a read only partition? */ 1263 if (__mnt_is_readonly(nd->path.mnt) && 1264 (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 1265 return 0; 1266 return 1; 1267 } 1268 1269 static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd) 1270 { 1271 struct path path = { 1272 .mnt = nd->path.mnt, 1273 .dentry = dentry, 1274 }; 1275 struct nfs_open_context *ctx; 1276 struct rpc_cred *cred; 1277 fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 1278 1279 cred = rpc_lookup_cred(); 1280 if (IS_ERR(cred)) 1281 return ERR_CAST(cred); 1282 ctx = alloc_nfs_open_context(&path, cred, fmode); 1283 put_rpccred(cred); 1284 if (ctx == NULL) 1285 return ERR_PTR(-ENOMEM); 1286 return ctx; 1287 } 1288 1289 static int do_open(struct inode *inode, struct file *filp) 1290 { 1291 nfs_fscache_set_inode_cookie(inode, filp); 1292 return 0; 1293 } 1294 1295 static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx) 1296 { 1297 struct file *filp; 1298 int ret = 0; 1299 1300 /* If the open_intent is for execute, we have an extra check to make */ 1301 if (ctx->mode & FMODE_EXEC) { 1302 ret = nfs_may_open(ctx->path.dentry->d_inode, 1303 ctx->cred, 1304 nd->intent.open.flags); 1305 if (ret < 0) 1306 goto out; 1307 } 1308 filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open); 1309 if (IS_ERR(filp)) 1310 ret = PTR_ERR(filp); 1311 else 1312 nfs_file_set_open_context(filp, ctx); 1313 out: 1314 put_nfs_open_context(ctx); 1315 return ret; 1316 } 1317 1318 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 1319 { 1320 struct nfs_open_context *ctx; 1321 struct iattr attr; 1322 struct dentry *res = NULL; 1323 struct inode *inode; 1324 int open_flags; 1325 int err; 1326 1327 dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n", 1328 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1329 1330 /* Check that we are indeed trying to open this file */ 1331 if (!is_atomic_open(nd)) 1332 goto no_open; 1333 1334 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 1335 res = ERR_PTR(-ENAMETOOLONG); 1336 goto out; 1337 } 1338 1339 /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash 1340 * the dentry. */ 1341 if (nd->flags & LOOKUP_EXCL) { 1342 d_instantiate(dentry, NULL); 1343 goto out; 1344 } 1345 1346 ctx = nameidata_to_nfs_open_context(dentry, nd); 1347 res = ERR_CAST(ctx); 1348 if (IS_ERR(ctx)) 1349 goto out; 1350 1351 open_flags = nd->intent.open.flags; 1352 if (nd->flags & LOOKUP_CREATE) { 1353 attr.ia_mode = nd->intent.open.create_mode; 1354 attr.ia_valid = ATTR_MODE; 1355 attr.ia_mode &= ~current_umask(); 1356 } else { 1357 open_flags &= ~(O_EXCL | O_CREAT); 1358 attr.ia_valid = 0; 1359 } 1360 1361 /* Open the file on the server */ 1362 nfs_block_sillyrename(dentry->d_parent); 1363 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1364 if (IS_ERR(inode)) { 1365 nfs_unblock_sillyrename(dentry->d_parent); 1366 put_nfs_open_context(ctx); 1367 switch (PTR_ERR(inode)) { 1368 /* Make a negative dentry */ 1369 case -ENOENT: 1370 d_add(dentry, NULL); 1371 res = NULL; 1372 goto out; 1373 /* This turned out not to be a regular file */ 1374 case -ENOTDIR: 1375 goto no_open; 1376 case -ELOOP: 1377 if (!(nd->intent.open.flags & O_NOFOLLOW)) 1378 goto no_open; 1379 /* case -EISDIR: */ 1380 /* case -EINVAL: */ 1381 default: 1382 res = ERR_CAST(inode); 1383 goto out; 1384 } 1385 } 1386 res = d_add_unique(dentry, inode); 1387 nfs_unblock_sillyrename(dentry->d_parent); 1388 if (res != NULL) { 1389 dput(ctx->path.dentry); 1390 ctx->path.dentry = dget(res); 1391 dentry = res; 1392 } 1393 err = nfs_intent_set_file(nd, ctx); 1394 if (err < 0) { 1395 if (res != NULL) 1396 dput(res); 1397 return ERR_PTR(err); 1398 } 1399 out: 1400 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1401 return res; 1402 no_open: 1403 return nfs_lookup(dir, dentry, nd); 1404 } 1405 1406 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 1407 { 1408 struct dentry *parent = NULL; 1409 struct inode *inode = dentry->d_inode; 1410 struct inode *dir; 1411 struct nfs_open_context *ctx; 1412 int openflags, ret = 0; 1413 1414 if (!is_atomic_open(nd) || d_mountpoint(dentry)) 1415 goto no_open; 1416 1417 parent = dget_parent(dentry); 1418 dir = parent->d_inode; 1419 1420 /* We can't create new files in nfs_open_revalidate(), so we 1421 * optimize away revalidation of negative dentries. 1422 */ 1423 if (inode == NULL) { 1424 if (!nfs_neg_need_reval(dir, dentry, nd)) 1425 ret = 1; 1426 goto out; 1427 } 1428 1429 /* NFS only supports OPEN on regular files */ 1430 if (!S_ISREG(inode->i_mode)) 1431 goto no_open_dput; 1432 openflags = nd->intent.open.flags; 1433 /* We cannot do exclusive creation on a positive dentry */ 1434 if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 1435 goto no_open_dput; 1436 /* We can't create new files, or truncate existing ones here */ 1437 openflags &= ~(O_CREAT|O_EXCL|O_TRUNC); 1438 1439 ctx = nameidata_to_nfs_open_context(dentry, nd); 1440 ret = PTR_ERR(ctx); 1441 if (IS_ERR(ctx)) 1442 goto out; 1443 /* 1444 * Note: we're not holding inode->i_mutex and so may be racing with 1445 * operations that change the directory. We therefore save the 1446 * change attribute *before* we do the RPC call. 1447 */ 1448 inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL); 1449 if (IS_ERR(inode)) { 1450 ret = PTR_ERR(inode); 1451 switch (ret) { 1452 case -EPERM: 1453 case -EACCES: 1454 case -EDQUOT: 1455 case -ENOSPC: 1456 case -EROFS: 1457 goto out_put_ctx; 1458 default: 1459 goto out_drop; 1460 } 1461 } 1462 iput(inode); 1463 if (inode != dentry->d_inode) 1464 goto out_drop; 1465 1466 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1467 ret = nfs_intent_set_file(nd, ctx); 1468 if (ret >= 0) 1469 ret = 1; 1470 out: 1471 dput(parent); 1472 return ret; 1473 out_drop: 1474 d_drop(dentry); 1475 ret = 0; 1476 out_put_ctx: 1477 put_nfs_open_context(ctx); 1478 goto out; 1479 1480 no_open_dput: 1481 dput(parent); 1482 no_open: 1483 return nfs_lookup_revalidate(dentry, nd); 1484 } 1485 1486 static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, 1487 struct nameidata *nd) 1488 { 1489 struct nfs_open_context *ctx = NULL; 1490 struct iattr attr; 1491 int error; 1492 int open_flags = 0; 1493 1494 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1495 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1496 1497 attr.ia_mode = mode; 1498 attr.ia_valid = ATTR_MODE; 1499 1500 if ((nd->flags & LOOKUP_CREATE) != 0) { 1501 open_flags = nd->intent.open.flags; 1502 1503 ctx = nameidata_to_nfs_open_context(dentry, nd); 1504 error = PTR_ERR(ctx); 1505 if (IS_ERR(ctx)) 1506 goto out_err_drop; 1507 } 1508 1509 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx); 1510 if (error != 0) 1511 goto out_put_ctx; 1512 if (ctx != NULL) { 1513 error = nfs_intent_set_file(nd, ctx); 1514 if (error < 0) 1515 goto out_err; 1516 } 1517 return 0; 1518 out_put_ctx: 1519 if (ctx != NULL) 1520 put_nfs_open_context(ctx); 1521 out_err_drop: 1522 d_drop(dentry); 1523 out_err: 1524 return error; 1525 } 1526 1527 #endif /* CONFIG_NFSV4 */ 1528 1529 /* 1530 * Code common to create, mkdir, and mknod. 1531 */ 1532 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 1533 struct nfs_fattr *fattr) 1534 { 1535 struct dentry *parent = dget_parent(dentry); 1536 struct inode *dir = parent->d_inode; 1537 struct inode *inode; 1538 int error = -EACCES; 1539 1540 d_drop(dentry); 1541 1542 /* We may have been initialized further down */ 1543 if (dentry->d_inode) 1544 goto out; 1545 if (fhandle->size == 0) { 1546 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1547 if (error) 1548 goto out_error; 1549 } 1550 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1551 if (!(fattr->valid & NFS_ATTR_FATTR)) { 1552 struct nfs_server *server = NFS_SB(dentry->d_sb); 1553 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 1554 if (error < 0) 1555 goto out_error; 1556 } 1557 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1558 error = PTR_ERR(inode); 1559 if (IS_ERR(inode)) 1560 goto out_error; 1561 d_add(dentry, inode); 1562 out: 1563 dput(parent); 1564 return 0; 1565 out_error: 1566 nfs_mark_for_revalidate(dir); 1567 dput(parent); 1568 return error; 1569 } 1570 1571 /* 1572 * Following a failed create operation, we drop the dentry rather 1573 * than retain a negative dentry. This avoids a problem in the event 1574 * that the operation succeeded on the server, but an error in the 1575 * reply path made it appear to have failed. 1576 */ 1577 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 1578 struct nameidata *nd) 1579 { 1580 struct iattr attr; 1581 int error; 1582 1583 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1584 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1585 1586 attr.ia_mode = mode; 1587 attr.ia_valid = ATTR_MODE; 1588 1589 error = NFS_PROTO(dir)->create(dir, dentry, &attr, 0, NULL); 1590 if (error != 0) 1591 goto out_err; 1592 return 0; 1593 out_err: 1594 d_drop(dentry); 1595 return error; 1596 } 1597 1598 /* 1599 * See comments for nfs_proc_create regarding failed operations. 1600 */ 1601 static int 1602 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 1603 { 1604 struct iattr attr; 1605 int status; 1606 1607 dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 1608 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1609 1610 if (!new_valid_dev(rdev)) 1611 return -EINVAL; 1612 1613 attr.ia_mode = mode; 1614 attr.ia_valid = ATTR_MODE; 1615 1616 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 1617 if (status != 0) 1618 goto out_err; 1619 return 0; 1620 out_err: 1621 d_drop(dentry); 1622 return status; 1623 } 1624 1625 /* 1626 * See comments for nfs_proc_create regarding failed operations. 1627 */ 1628 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 1629 { 1630 struct iattr attr; 1631 int error; 1632 1633 dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 1634 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1635 1636 attr.ia_valid = ATTR_MODE; 1637 attr.ia_mode = mode | S_IFDIR; 1638 1639 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 1640 if (error != 0) 1641 goto out_err; 1642 return 0; 1643 out_err: 1644 d_drop(dentry); 1645 return error; 1646 } 1647 1648 static void nfs_dentry_handle_enoent(struct dentry *dentry) 1649 { 1650 if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1651 d_delete(dentry); 1652 } 1653 1654 static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 1655 { 1656 int error; 1657 1658 dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 1659 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1660 1661 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 1662 /* Ensure the VFS deletes this inode */ 1663 if (error == 0 && dentry->d_inode != NULL) 1664 clear_nlink(dentry->d_inode); 1665 else if (error == -ENOENT) 1666 nfs_dentry_handle_enoent(dentry); 1667 1668 return error; 1669 } 1670 1671 /* 1672 * Remove a file after making sure there are no pending writes, 1673 * and after checking that the file has only one user. 1674 * 1675 * We invalidate the attribute cache and free the inode prior to the operation 1676 * to avoid possible races if the server reuses the inode. 1677 */ 1678 static int nfs_safe_remove(struct dentry *dentry) 1679 { 1680 struct inode *dir = dentry->d_parent->d_inode; 1681 struct inode *inode = dentry->d_inode; 1682 int error = -EBUSY; 1683 1684 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 1685 dentry->d_parent->d_name.name, dentry->d_name.name); 1686 1687 /* If the dentry was sillyrenamed, we simply call d_delete() */ 1688 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1689 error = 0; 1690 goto out; 1691 } 1692 1693 if (inode != NULL) { 1694 nfs_inode_return_delegation(inode); 1695 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1696 /* The VFS may want to delete this inode */ 1697 if (error == 0) 1698 nfs_drop_nlink(inode); 1699 nfs_mark_for_revalidate(inode); 1700 } else 1701 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1702 if (error == -ENOENT) 1703 nfs_dentry_handle_enoent(dentry); 1704 out: 1705 return error; 1706 } 1707 1708 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 1709 * belongs to an active ".nfs..." file and we return -EBUSY. 1710 * 1711 * If sillyrename() returns 0, we do nothing, otherwise we unlink. 1712 */ 1713 static int nfs_unlink(struct inode *dir, struct dentry *dentry) 1714 { 1715 int error; 1716 int need_rehash = 0; 1717 1718 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 1719 dir->i_ino, dentry->d_name.name); 1720 1721 spin_lock(&dentry->d_lock); 1722 if (dentry->d_count > 1) { 1723 spin_unlock(&dentry->d_lock); 1724 /* Start asynchronous writeout of the inode */ 1725 write_inode_now(dentry->d_inode, 0); 1726 error = nfs_sillyrename(dir, dentry); 1727 return error; 1728 } 1729 if (!d_unhashed(dentry)) { 1730 __d_drop(dentry); 1731 need_rehash = 1; 1732 } 1733 spin_unlock(&dentry->d_lock); 1734 error = nfs_safe_remove(dentry); 1735 if (!error || error == -ENOENT) { 1736 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1737 } else if (need_rehash) 1738 d_rehash(dentry); 1739 return error; 1740 } 1741 1742 /* 1743 * To create a symbolic link, most file systems instantiate a new inode, 1744 * add a page to it containing the path, then write it out to the disk 1745 * using prepare_write/commit_write. 1746 * 1747 * Unfortunately the NFS client can't create the in-core inode first 1748 * because it needs a file handle to create an in-core inode (see 1749 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1750 * symlink request has completed on the server. 1751 * 1752 * So instead we allocate a raw page, copy the symname into it, then do 1753 * the SYMLINK request with the page as the buffer. If it succeeds, we 1754 * now have a new file handle and can instantiate an in-core NFS inode 1755 * and move the raw page into its mapping. 1756 */ 1757 static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 1758 { 1759 struct pagevec lru_pvec; 1760 struct page *page; 1761 char *kaddr; 1762 struct iattr attr; 1763 unsigned int pathlen = strlen(symname); 1764 int error; 1765 1766 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 1767 dir->i_ino, dentry->d_name.name, symname); 1768 1769 if (pathlen > PAGE_SIZE) 1770 return -ENAMETOOLONG; 1771 1772 attr.ia_mode = S_IFLNK | S_IRWXUGO; 1773 attr.ia_valid = ATTR_MODE; 1774 1775 page = alloc_page(GFP_HIGHUSER); 1776 if (!page) 1777 return -ENOMEM; 1778 1779 kaddr = kmap_atomic(page, KM_USER0); 1780 memcpy(kaddr, symname, pathlen); 1781 if (pathlen < PAGE_SIZE) 1782 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1783 kunmap_atomic(kaddr, KM_USER0); 1784 1785 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1786 if (error != 0) { 1787 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1788 dir->i_sb->s_id, dir->i_ino, 1789 dentry->d_name.name, symname, error); 1790 d_drop(dentry); 1791 __free_page(page); 1792 return error; 1793 } 1794 1795 /* 1796 * No big deal if we can't add this page to the page cache here. 1797 * READLINK will get the missing page from the server if needed. 1798 */ 1799 pagevec_init(&lru_pvec, 0); 1800 if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1801 GFP_KERNEL)) { 1802 pagevec_add(&lru_pvec, page); 1803 pagevec_lru_add_file(&lru_pvec); 1804 SetPageUptodate(page); 1805 unlock_page(page); 1806 } else 1807 __free_page(page); 1808 1809 return 0; 1810 } 1811 1812 static int 1813 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 1814 { 1815 struct inode *inode = old_dentry->d_inode; 1816 int error; 1817 1818 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 1819 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1820 dentry->d_parent->d_name.name, dentry->d_name.name); 1821 1822 nfs_inode_return_delegation(inode); 1823 1824 d_drop(dentry); 1825 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1826 if (error == 0) { 1827 ihold(inode); 1828 d_add(dentry, inode); 1829 } 1830 return error; 1831 } 1832 1833 /* 1834 * RENAME 1835 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 1836 * different file handle for the same inode after a rename (e.g. when 1837 * moving to a different directory). A fail-safe method to do so would 1838 * be to look up old_dir/old_name, create a link to new_dir/new_name and 1839 * rename the old file using the sillyrename stuff. This way, the original 1840 * file in old_dir will go away when the last process iput()s the inode. 1841 * 1842 * FIXED. 1843 * 1844 * It actually works quite well. One needs to have the possibility for 1845 * at least one ".nfs..." file in each directory the file ever gets 1846 * moved or linked to which happens automagically with the new 1847 * implementation that only depends on the dcache stuff instead of 1848 * using the inode layer 1849 * 1850 * Unfortunately, things are a little more complicated than indicated 1851 * above. For a cross-directory move, we want to make sure we can get 1852 * rid of the old inode after the operation. This means there must be 1853 * no pending writes (if it's a file), and the use count must be 1. 1854 * If these conditions are met, we can drop the dentries before doing 1855 * the rename. 1856 */ 1857 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 1858 struct inode *new_dir, struct dentry *new_dentry) 1859 { 1860 struct inode *old_inode = old_dentry->d_inode; 1861 struct inode *new_inode = new_dentry->d_inode; 1862 struct dentry *dentry = NULL, *rehash = NULL; 1863 int error = -EBUSY; 1864 1865 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 1866 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1867 new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 1868 new_dentry->d_count); 1869 1870 /* 1871 * For non-directories, check whether the target is busy and if so, 1872 * make a copy of the dentry and then do a silly-rename. If the 1873 * silly-rename succeeds, the copied dentry is hashed and becomes 1874 * the new target. 1875 */ 1876 if (new_inode && !S_ISDIR(new_inode->i_mode)) { 1877 /* 1878 * To prevent any new references to the target during the 1879 * rename, we unhash the dentry in advance. 1880 */ 1881 if (!d_unhashed(new_dentry)) { 1882 d_drop(new_dentry); 1883 rehash = new_dentry; 1884 } 1885 1886 if (new_dentry->d_count > 2) { 1887 int err; 1888 1889 /* copy the target dentry's name */ 1890 dentry = d_alloc(new_dentry->d_parent, 1891 &new_dentry->d_name); 1892 if (!dentry) 1893 goto out; 1894 1895 /* silly-rename the existing target ... */ 1896 err = nfs_sillyrename(new_dir, new_dentry); 1897 if (err) 1898 goto out; 1899 1900 new_dentry = dentry; 1901 rehash = NULL; 1902 new_inode = NULL; 1903 } 1904 } 1905 1906 nfs_inode_return_delegation(old_inode); 1907 if (new_inode != NULL) 1908 nfs_inode_return_delegation(new_inode); 1909 1910 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 1911 new_dir, &new_dentry->d_name); 1912 nfs_mark_for_revalidate(old_inode); 1913 out: 1914 if (rehash) 1915 d_rehash(rehash); 1916 if (!error) { 1917 if (new_inode != NULL) 1918 nfs_drop_nlink(new_inode); 1919 d_move(old_dentry, new_dentry); 1920 nfs_set_verifier(new_dentry, 1921 nfs_save_change_attribute(new_dir)); 1922 } else if (error == -ENOENT) 1923 nfs_dentry_handle_enoent(old_dentry); 1924 1925 /* new dentry created? */ 1926 if (dentry) 1927 dput(dentry); 1928 return error; 1929 } 1930 1931 static DEFINE_SPINLOCK(nfs_access_lru_lock); 1932 static LIST_HEAD(nfs_access_lru_list); 1933 static atomic_long_t nfs_access_nr_entries; 1934 1935 static void nfs_access_free_entry(struct nfs_access_entry *entry) 1936 { 1937 put_rpccred(entry->cred); 1938 kfree(entry); 1939 smp_mb__before_atomic_dec(); 1940 atomic_long_dec(&nfs_access_nr_entries); 1941 smp_mb__after_atomic_dec(); 1942 } 1943 1944 static void nfs_access_free_list(struct list_head *head) 1945 { 1946 struct nfs_access_entry *cache; 1947 1948 while (!list_empty(head)) { 1949 cache = list_entry(head->next, struct nfs_access_entry, lru); 1950 list_del(&cache->lru); 1951 nfs_access_free_entry(cache); 1952 } 1953 } 1954 1955 int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 1956 { 1957 LIST_HEAD(head); 1958 struct nfs_inode *nfsi, *next; 1959 struct nfs_access_entry *cache; 1960 1961 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 1962 return (nr_to_scan == 0) ? 0 : -1; 1963 1964 spin_lock(&nfs_access_lru_lock); 1965 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 1966 struct inode *inode; 1967 1968 if (nr_to_scan-- == 0) 1969 break; 1970 inode = &nfsi->vfs_inode; 1971 spin_lock(&inode->i_lock); 1972 if (list_empty(&nfsi->access_cache_entry_lru)) 1973 goto remove_lru_entry; 1974 cache = list_entry(nfsi->access_cache_entry_lru.next, 1975 struct nfs_access_entry, lru); 1976 list_move(&cache->lru, &head); 1977 rb_erase(&cache->rb_node, &nfsi->access_cache); 1978 if (!list_empty(&nfsi->access_cache_entry_lru)) 1979 list_move_tail(&nfsi->access_cache_inode_lru, 1980 &nfs_access_lru_list); 1981 else { 1982 remove_lru_entry: 1983 list_del_init(&nfsi->access_cache_inode_lru); 1984 smp_mb__before_clear_bit(); 1985 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 1986 smp_mb__after_clear_bit(); 1987 } 1988 spin_unlock(&inode->i_lock); 1989 } 1990 spin_unlock(&nfs_access_lru_lock); 1991 nfs_access_free_list(&head); 1992 return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 1993 } 1994 1995 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 1996 { 1997 struct rb_root *root_node = &nfsi->access_cache; 1998 struct rb_node *n; 1999 struct nfs_access_entry *entry; 2000 2001 /* Unhook entries from the cache */ 2002 while ((n = rb_first(root_node)) != NULL) { 2003 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2004 rb_erase(n, root_node); 2005 list_move(&entry->lru, head); 2006 } 2007 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 2008 } 2009 2010 void nfs_access_zap_cache(struct inode *inode) 2011 { 2012 LIST_HEAD(head); 2013 2014 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 2015 return; 2016 /* Remove from global LRU init */ 2017 spin_lock(&nfs_access_lru_lock); 2018 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2019 list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2020 2021 spin_lock(&inode->i_lock); 2022 __nfs_access_zap_cache(NFS_I(inode), &head); 2023 spin_unlock(&inode->i_lock); 2024 spin_unlock(&nfs_access_lru_lock); 2025 nfs_access_free_list(&head); 2026 } 2027 2028 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 2029 { 2030 struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 2031 struct nfs_access_entry *entry; 2032 2033 while (n != NULL) { 2034 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2035 2036 if (cred < entry->cred) 2037 n = n->rb_left; 2038 else if (cred > entry->cred) 2039 n = n->rb_right; 2040 else 2041 return entry; 2042 } 2043 return NULL; 2044 } 2045 2046 static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 2047 { 2048 struct nfs_inode *nfsi = NFS_I(inode); 2049 struct nfs_access_entry *cache; 2050 int err = -ENOENT; 2051 2052 spin_lock(&inode->i_lock); 2053 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 2054 goto out_zap; 2055 cache = nfs_access_search_rbtree(inode, cred); 2056 if (cache == NULL) 2057 goto out; 2058 if (!nfs_have_delegated_attributes(inode) && 2059 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 2060 goto out_stale; 2061 res->jiffies = cache->jiffies; 2062 res->cred = cache->cred; 2063 res->mask = cache->mask; 2064 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 2065 err = 0; 2066 out: 2067 spin_unlock(&inode->i_lock); 2068 return err; 2069 out_stale: 2070 rb_erase(&cache->rb_node, &nfsi->access_cache); 2071 list_del(&cache->lru); 2072 spin_unlock(&inode->i_lock); 2073 nfs_access_free_entry(cache); 2074 return -ENOENT; 2075 out_zap: 2076 spin_unlock(&inode->i_lock); 2077 nfs_access_zap_cache(inode); 2078 return -ENOENT; 2079 } 2080 2081 static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 2082 { 2083 struct nfs_inode *nfsi = NFS_I(inode); 2084 struct rb_root *root_node = &nfsi->access_cache; 2085 struct rb_node **p = &root_node->rb_node; 2086 struct rb_node *parent = NULL; 2087 struct nfs_access_entry *entry; 2088 2089 spin_lock(&inode->i_lock); 2090 while (*p != NULL) { 2091 parent = *p; 2092 entry = rb_entry(parent, struct nfs_access_entry, rb_node); 2093 2094 if (set->cred < entry->cred) 2095 p = &parent->rb_left; 2096 else if (set->cred > entry->cred) 2097 p = &parent->rb_right; 2098 else 2099 goto found; 2100 } 2101 rb_link_node(&set->rb_node, parent, p); 2102 rb_insert_color(&set->rb_node, root_node); 2103 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2104 spin_unlock(&inode->i_lock); 2105 return; 2106 found: 2107 rb_replace_node(parent, &set->rb_node, root_node); 2108 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2109 list_del(&entry->lru); 2110 spin_unlock(&inode->i_lock); 2111 nfs_access_free_entry(entry); 2112 } 2113 2114 static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 2115 { 2116 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 2117 if (cache == NULL) 2118 return; 2119 RB_CLEAR_NODE(&cache->rb_node); 2120 cache->jiffies = set->jiffies; 2121 cache->cred = get_rpccred(set->cred); 2122 cache->mask = set->mask; 2123 2124 nfs_access_add_rbtree(inode, cache); 2125 2126 /* Update accounting */ 2127 smp_mb__before_atomic_inc(); 2128 atomic_long_inc(&nfs_access_nr_entries); 2129 smp_mb__after_atomic_inc(); 2130 2131 /* Add inode to global LRU list */ 2132 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2133 spin_lock(&nfs_access_lru_lock); 2134 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2135 list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 2136 &nfs_access_lru_list); 2137 spin_unlock(&nfs_access_lru_lock); 2138 } 2139 } 2140 2141 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 2142 { 2143 struct nfs_access_entry cache; 2144 int status; 2145 2146 status = nfs_access_get_cached(inode, cred, &cache); 2147 if (status == 0) 2148 goto out; 2149 2150 /* Be clever: ask server to check for all possible rights */ 2151 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 2152 cache.cred = cred; 2153 cache.jiffies = jiffies; 2154 status = NFS_PROTO(inode)->access(inode, &cache); 2155 if (status != 0) { 2156 if (status == -ESTALE) { 2157 nfs_zap_caches(inode); 2158 if (!S_ISDIR(inode->i_mode)) 2159 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2160 } 2161 return status; 2162 } 2163 nfs_access_add_cache(inode, &cache); 2164 out: 2165 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2166 return 0; 2167 return -EACCES; 2168 } 2169 2170 static int nfs_open_permission_mask(int openflags) 2171 { 2172 int mask = 0; 2173 2174 if (openflags & FMODE_READ) 2175 mask |= MAY_READ; 2176 if (openflags & FMODE_WRITE) 2177 mask |= MAY_WRITE; 2178 if (openflags & FMODE_EXEC) 2179 mask |= MAY_EXEC; 2180 return mask; 2181 } 2182 2183 int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2184 { 2185 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2186 } 2187 2188 int nfs_permission(struct inode *inode, int mask, unsigned int flags) 2189 { 2190 struct rpc_cred *cred; 2191 int res = 0; 2192 2193 if (flags & IPERM_FLAG_RCU) 2194 return -ECHILD; 2195 2196 nfs_inc_stats(inode, NFSIOS_VFSACCESS); 2197 2198 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2199 goto out; 2200 /* Is this sys_access() ? */ 2201 if (mask & (MAY_ACCESS | MAY_CHDIR)) 2202 goto force_lookup; 2203 2204 switch (inode->i_mode & S_IFMT) { 2205 case S_IFLNK: 2206 goto out; 2207 case S_IFREG: 2208 /* NFSv4 has atomic_open... */ 2209 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 2210 && (mask & MAY_OPEN) 2211 && !(mask & MAY_EXEC)) 2212 goto out; 2213 break; 2214 case S_IFDIR: 2215 /* 2216 * Optimize away all write operations, since the server 2217 * will check permissions when we perform the op. 2218 */ 2219 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 2220 goto out; 2221 } 2222 2223 force_lookup: 2224 if (!NFS_PROTO(inode)->access) 2225 goto out_notsup; 2226 2227 cred = rpc_lookup_cred(); 2228 if (!IS_ERR(cred)) { 2229 res = nfs_do_access(inode, cred, mask); 2230 put_rpccred(cred); 2231 } else 2232 res = PTR_ERR(cred); 2233 out: 2234 if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2235 res = -EACCES; 2236 2237 dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 2238 inode->i_sb->s_id, inode->i_ino, mask, res); 2239 return res; 2240 out_notsup: 2241 res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 2242 if (res == 0) 2243 res = generic_permission(inode, mask, flags, NULL); 2244 goto out; 2245 } 2246 2247 /* 2248 * Local variables: 2249 * version-control: t 2250 * kept-new-versions: 5 2251 * End: 2252 */ 2253