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 (IS_AUTOMOUNT(inode)) 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 .d_automount = nfs_d_automount, 1177 }; 1178 1179 static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd) 1180 { 1181 struct dentry *res; 1182 struct dentry *parent; 1183 struct inode *inode = NULL; 1184 struct nfs_fh *fhandle = NULL; 1185 struct nfs_fattr *fattr = NULL; 1186 int error; 1187 1188 dfprintk(VFS, "NFS: lookup(%s/%s)\n", 1189 dentry->d_parent->d_name.name, dentry->d_name.name); 1190 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 1191 1192 res = ERR_PTR(-ENAMETOOLONG); 1193 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 1194 goto out; 1195 1196 /* 1197 * If we're doing an exclusive create, optimize away the lookup 1198 * but don't hash the dentry. 1199 */ 1200 if (nfs_is_exclusive_create(dir, nd)) { 1201 d_instantiate(dentry, NULL); 1202 res = NULL; 1203 goto out; 1204 } 1205 1206 res = ERR_PTR(-ENOMEM); 1207 fhandle = nfs_alloc_fhandle(); 1208 fattr = nfs_alloc_fattr(); 1209 if (fhandle == NULL || fattr == NULL) 1210 goto out; 1211 1212 parent = dentry->d_parent; 1213 /* Protect against concurrent sillydeletes */ 1214 nfs_block_sillyrename(parent); 1215 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1216 if (error == -ENOENT) 1217 goto no_entry; 1218 if (error < 0) { 1219 res = ERR_PTR(error); 1220 goto out_unblock_sillyrename; 1221 } 1222 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1223 res = ERR_CAST(inode); 1224 if (IS_ERR(res)) 1225 goto out_unblock_sillyrename; 1226 1227 no_entry: 1228 res = d_materialise_unique(dentry, inode); 1229 if (res != NULL) { 1230 if (IS_ERR(res)) 1231 goto out_unblock_sillyrename; 1232 dentry = res; 1233 } 1234 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1235 out_unblock_sillyrename: 1236 nfs_unblock_sillyrename(parent); 1237 out: 1238 nfs_free_fattr(fattr); 1239 nfs_free_fhandle(fhandle); 1240 return res; 1241 } 1242 1243 #ifdef CONFIG_NFS_V4 1244 static int nfs_open_revalidate(struct dentry *, struct nameidata *); 1245 1246 const struct dentry_operations nfs4_dentry_operations = { 1247 .d_revalidate = nfs_open_revalidate, 1248 .d_delete = nfs_dentry_delete, 1249 .d_iput = nfs_dentry_iput, 1250 .d_automount = nfs_d_automount, 1251 }; 1252 1253 /* 1254 * Use intent information to determine whether we need to substitute 1255 * the NFSv4-style stateful OPEN for the LOOKUP call 1256 */ 1257 static int is_atomic_open(struct nameidata *nd) 1258 { 1259 if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 1260 return 0; 1261 /* NFS does not (yet) have a stateful open for directories */ 1262 if (nd->flags & LOOKUP_DIRECTORY) 1263 return 0; 1264 /* Are we trying to write to a read only partition? */ 1265 if (__mnt_is_readonly(nd->path.mnt) && 1266 (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 1267 return 0; 1268 return 1; 1269 } 1270 1271 static struct nfs_open_context *nameidata_to_nfs_open_context(struct dentry *dentry, struct nameidata *nd) 1272 { 1273 struct path path = { 1274 .mnt = nd->path.mnt, 1275 .dentry = dentry, 1276 }; 1277 struct nfs_open_context *ctx; 1278 struct rpc_cred *cred; 1279 fmode_t fmode = nd->intent.open.flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); 1280 1281 cred = rpc_lookup_cred(); 1282 if (IS_ERR(cred)) 1283 return ERR_CAST(cred); 1284 ctx = alloc_nfs_open_context(&path, cred, fmode); 1285 put_rpccred(cred); 1286 if (ctx == NULL) 1287 return ERR_PTR(-ENOMEM); 1288 return ctx; 1289 } 1290 1291 static int do_open(struct inode *inode, struct file *filp) 1292 { 1293 nfs_fscache_set_inode_cookie(inode, filp); 1294 return 0; 1295 } 1296 1297 static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx) 1298 { 1299 struct file *filp; 1300 int ret = 0; 1301 1302 /* If the open_intent is for execute, we have an extra check to make */ 1303 if (ctx->mode & FMODE_EXEC) { 1304 ret = nfs_may_open(ctx->path.dentry->d_inode, 1305 ctx->cred, 1306 nd->intent.open.flags); 1307 if (ret < 0) 1308 goto out; 1309 } 1310 filp = lookup_instantiate_filp(nd, ctx->path.dentry, do_open); 1311 if (IS_ERR(filp)) 1312 ret = PTR_ERR(filp); 1313 else 1314 nfs_file_set_open_context(filp, ctx); 1315 out: 1316 put_nfs_open_context(ctx); 1317 return ret; 1318 } 1319 1320 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 1321 { 1322 struct nfs_open_context *ctx; 1323 struct iattr attr; 1324 struct dentry *res = NULL; 1325 struct inode *inode; 1326 int open_flags; 1327 int err; 1328 1329 dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n", 1330 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1331 1332 /* Check that we are indeed trying to open this file */ 1333 if (!is_atomic_open(nd)) 1334 goto no_open; 1335 1336 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 1337 res = ERR_PTR(-ENAMETOOLONG); 1338 goto out; 1339 } 1340 1341 /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash 1342 * the dentry. */ 1343 if (nd->flags & LOOKUP_EXCL) { 1344 d_instantiate(dentry, NULL); 1345 goto out; 1346 } 1347 1348 ctx = nameidata_to_nfs_open_context(dentry, nd); 1349 res = ERR_CAST(ctx); 1350 if (IS_ERR(ctx)) 1351 goto out; 1352 1353 open_flags = nd->intent.open.flags; 1354 if (nd->flags & LOOKUP_CREATE) { 1355 attr.ia_mode = nd->intent.open.create_mode; 1356 attr.ia_valid = ATTR_MODE; 1357 attr.ia_mode &= ~current_umask(); 1358 } else { 1359 open_flags &= ~(O_EXCL | O_CREAT); 1360 attr.ia_valid = 0; 1361 } 1362 1363 /* Open the file on the server */ 1364 nfs_block_sillyrename(dentry->d_parent); 1365 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1366 if (IS_ERR(inode)) { 1367 nfs_unblock_sillyrename(dentry->d_parent); 1368 put_nfs_open_context(ctx); 1369 switch (PTR_ERR(inode)) { 1370 /* Make a negative dentry */ 1371 case -ENOENT: 1372 d_add(dentry, NULL); 1373 res = NULL; 1374 goto out; 1375 /* This turned out not to be a regular file */ 1376 case -ENOTDIR: 1377 goto no_open; 1378 case -ELOOP: 1379 if (!(nd->intent.open.flags & O_NOFOLLOW)) 1380 goto no_open; 1381 /* case -EISDIR: */ 1382 /* case -EINVAL: */ 1383 default: 1384 res = ERR_CAST(inode); 1385 goto out; 1386 } 1387 } 1388 res = d_add_unique(dentry, inode); 1389 nfs_unblock_sillyrename(dentry->d_parent); 1390 if (res != NULL) { 1391 dput(ctx->path.dentry); 1392 ctx->path.dentry = dget(res); 1393 dentry = res; 1394 } 1395 err = nfs_intent_set_file(nd, ctx); 1396 if (err < 0) { 1397 if (res != NULL) 1398 dput(res); 1399 return ERR_PTR(err); 1400 } 1401 out: 1402 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1403 return res; 1404 no_open: 1405 return nfs_lookup(dir, dentry, nd); 1406 } 1407 1408 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 1409 { 1410 struct dentry *parent = NULL; 1411 struct inode *inode; 1412 struct inode *dir; 1413 struct nfs_open_context *ctx; 1414 int openflags, ret = 0; 1415 1416 if (nd->flags & LOOKUP_RCU) 1417 return -ECHILD; 1418 1419 inode = dentry->d_inode; 1420 if (!is_atomic_open(nd) || d_mountpoint(dentry)) 1421 goto no_open; 1422 1423 parent = dget_parent(dentry); 1424 dir = parent->d_inode; 1425 1426 /* We can't create new files in nfs_open_revalidate(), so we 1427 * optimize away revalidation of negative dentries. 1428 */ 1429 if (inode == NULL) { 1430 if (!nfs_neg_need_reval(dir, dentry, nd)) 1431 ret = 1; 1432 goto out; 1433 } 1434 1435 /* NFS only supports OPEN on regular files */ 1436 if (!S_ISREG(inode->i_mode)) 1437 goto no_open_dput; 1438 openflags = nd->intent.open.flags; 1439 /* We cannot do exclusive creation on a positive dentry */ 1440 if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 1441 goto no_open_dput; 1442 /* We can't create new files, or truncate existing ones here */ 1443 openflags &= ~(O_CREAT|O_EXCL|O_TRUNC); 1444 1445 ctx = nameidata_to_nfs_open_context(dentry, nd); 1446 ret = PTR_ERR(ctx); 1447 if (IS_ERR(ctx)) 1448 goto out; 1449 /* 1450 * Note: we're not holding inode->i_mutex and so may be racing with 1451 * operations that change the directory. We therefore save the 1452 * change attribute *before* we do the RPC call. 1453 */ 1454 inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL); 1455 if (IS_ERR(inode)) { 1456 ret = PTR_ERR(inode); 1457 switch (ret) { 1458 case -EPERM: 1459 case -EACCES: 1460 case -EDQUOT: 1461 case -ENOSPC: 1462 case -EROFS: 1463 goto out_put_ctx; 1464 default: 1465 goto out_drop; 1466 } 1467 } 1468 iput(inode); 1469 if (inode != dentry->d_inode) 1470 goto out_drop; 1471 1472 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1473 ret = nfs_intent_set_file(nd, ctx); 1474 if (ret >= 0) 1475 ret = 1; 1476 out: 1477 dput(parent); 1478 return ret; 1479 out_drop: 1480 d_drop(dentry); 1481 ret = 0; 1482 out_put_ctx: 1483 put_nfs_open_context(ctx); 1484 goto out; 1485 1486 no_open_dput: 1487 dput(parent); 1488 no_open: 1489 return nfs_lookup_revalidate(dentry, nd); 1490 } 1491 1492 static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, 1493 struct nameidata *nd) 1494 { 1495 struct nfs_open_context *ctx = NULL; 1496 struct iattr attr; 1497 int error; 1498 int open_flags = 0; 1499 1500 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1501 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1502 1503 attr.ia_mode = mode; 1504 attr.ia_valid = ATTR_MODE; 1505 1506 if ((nd->flags & LOOKUP_CREATE) != 0) { 1507 open_flags = nd->intent.open.flags; 1508 1509 ctx = nameidata_to_nfs_open_context(dentry, nd); 1510 error = PTR_ERR(ctx); 1511 if (IS_ERR(ctx)) 1512 goto out_err_drop; 1513 } 1514 1515 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx); 1516 if (error != 0) 1517 goto out_put_ctx; 1518 if (ctx != NULL) { 1519 error = nfs_intent_set_file(nd, ctx); 1520 if (error < 0) 1521 goto out_err; 1522 } 1523 return 0; 1524 out_put_ctx: 1525 if (ctx != NULL) 1526 put_nfs_open_context(ctx); 1527 out_err_drop: 1528 d_drop(dentry); 1529 out_err: 1530 return error; 1531 } 1532 1533 #endif /* CONFIG_NFSV4 */ 1534 1535 /* 1536 * Code common to create, mkdir, and mknod. 1537 */ 1538 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 1539 struct nfs_fattr *fattr) 1540 { 1541 struct dentry *parent = dget_parent(dentry); 1542 struct inode *dir = parent->d_inode; 1543 struct inode *inode; 1544 int error = -EACCES; 1545 1546 d_drop(dentry); 1547 1548 /* We may have been initialized further down */ 1549 if (dentry->d_inode) 1550 goto out; 1551 if (fhandle->size == 0) { 1552 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1553 if (error) 1554 goto out_error; 1555 } 1556 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1557 if (!(fattr->valid & NFS_ATTR_FATTR)) { 1558 struct nfs_server *server = NFS_SB(dentry->d_sb); 1559 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 1560 if (error < 0) 1561 goto out_error; 1562 } 1563 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1564 error = PTR_ERR(inode); 1565 if (IS_ERR(inode)) 1566 goto out_error; 1567 d_add(dentry, inode); 1568 out: 1569 dput(parent); 1570 return 0; 1571 out_error: 1572 nfs_mark_for_revalidate(dir); 1573 dput(parent); 1574 return error; 1575 } 1576 1577 /* 1578 * Following a failed create operation, we drop the dentry rather 1579 * than retain a negative dentry. This avoids a problem in the event 1580 * that the operation succeeded on the server, but an error in the 1581 * reply path made it appear to have failed. 1582 */ 1583 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 1584 struct nameidata *nd) 1585 { 1586 struct iattr attr; 1587 int error; 1588 int open_flags = 0; 1589 1590 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1591 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1592 1593 attr.ia_mode = mode; 1594 attr.ia_valid = ATTR_MODE; 1595 1596 if ((nd->flags & LOOKUP_CREATE) != 0) 1597 open_flags = nd->intent.open.flags; 1598 1599 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, NULL); 1600 if (error != 0) 1601 goto out_err; 1602 return 0; 1603 out_err: 1604 d_drop(dentry); 1605 return error; 1606 } 1607 1608 /* 1609 * See comments for nfs_proc_create regarding failed operations. 1610 */ 1611 static int 1612 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 1613 { 1614 struct iattr attr; 1615 int status; 1616 1617 dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 1618 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1619 1620 if (!new_valid_dev(rdev)) 1621 return -EINVAL; 1622 1623 attr.ia_mode = mode; 1624 attr.ia_valid = ATTR_MODE; 1625 1626 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 1627 if (status != 0) 1628 goto out_err; 1629 return 0; 1630 out_err: 1631 d_drop(dentry); 1632 return status; 1633 } 1634 1635 /* 1636 * See comments for nfs_proc_create regarding failed operations. 1637 */ 1638 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 1639 { 1640 struct iattr attr; 1641 int error; 1642 1643 dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 1644 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1645 1646 attr.ia_valid = ATTR_MODE; 1647 attr.ia_mode = mode | S_IFDIR; 1648 1649 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 1650 if (error != 0) 1651 goto out_err; 1652 return 0; 1653 out_err: 1654 d_drop(dentry); 1655 return error; 1656 } 1657 1658 static void nfs_dentry_handle_enoent(struct dentry *dentry) 1659 { 1660 if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1661 d_delete(dentry); 1662 } 1663 1664 static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 1665 { 1666 int error; 1667 1668 dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 1669 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1670 1671 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 1672 /* Ensure the VFS deletes this inode */ 1673 if (error == 0 && dentry->d_inode != NULL) 1674 clear_nlink(dentry->d_inode); 1675 else if (error == -ENOENT) 1676 nfs_dentry_handle_enoent(dentry); 1677 1678 return error; 1679 } 1680 1681 /* 1682 * Remove a file after making sure there are no pending writes, 1683 * and after checking that the file has only one user. 1684 * 1685 * We invalidate the attribute cache and free the inode prior to the operation 1686 * to avoid possible races if the server reuses the inode. 1687 */ 1688 static int nfs_safe_remove(struct dentry *dentry) 1689 { 1690 struct inode *dir = dentry->d_parent->d_inode; 1691 struct inode *inode = dentry->d_inode; 1692 int error = -EBUSY; 1693 1694 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 1695 dentry->d_parent->d_name.name, dentry->d_name.name); 1696 1697 /* If the dentry was sillyrenamed, we simply call d_delete() */ 1698 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1699 error = 0; 1700 goto out; 1701 } 1702 1703 if (inode != NULL) { 1704 nfs_inode_return_delegation(inode); 1705 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1706 /* The VFS may want to delete this inode */ 1707 if (error == 0) 1708 nfs_drop_nlink(inode); 1709 nfs_mark_for_revalidate(inode); 1710 } else 1711 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1712 if (error == -ENOENT) 1713 nfs_dentry_handle_enoent(dentry); 1714 out: 1715 return error; 1716 } 1717 1718 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 1719 * belongs to an active ".nfs..." file and we return -EBUSY. 1720 * 1721 * If sillyrename() returns 0, we do nothing, otherwise we unlink. 1722 */ 1723 static int nfs_unlink(struct inode *dir, struct dentry *dentry) 1724 { 1725 int error; 1726 int need_rehash = 0; 1727 1728 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 1729 dir->i_ino, dentry->d_name.name); 1730 1731 spin_lock(&dentry->d_lock); 1732 if (dentry->d_count > 1) { 1733 spin_unlock(&dentry->d_lock); 1734 /* Start asynchronous writeout of the inode */ 1735 write_inode_now(dentry->d_inode, 0); 1736 error = nfs_sillyrename(dir, dentry); 1737 return error; 1738 } 1739 if (!d_unhashed(dentry)) { 1740 __d_drop(dentry); 1741 need_rehash = 1; 1742 } 1743 spin_unlock(&dentry->d_lock); 1744 error = nfs_safe_remove(dentry); 1745 if (!error || error == -ENOENT) { 1746 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1747 } else if (need_rehash) 1748 d_rehash(dentry); 1749 return error; 1750 } 1751 1752 /* 1753 * To create a symbolic link, most file systems instantiate a new inode, 1754 * add a page to it containing the path, then write it out to the disk 1755 * using prepare_write/commit_write. 1756 * 1757 * Unfortunately the NFS client can't create the in-core inode first 1758 * because it needs a file handle to create an in-core inode (see 1759 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1760 * symlink request has completed on the server. 1761 * 1762 * So instead we allocate a raw page, copy the symname into it, then do 1763 * the SYMLINK request with the page as the buffer. If it succeeds, we 1764 * now have a new file handle and can instantiate an in-core NFS inode 1765 * and move the raw page into its mapping. 1766 */ 1767 static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 1768 { 1769 struct pagevec lru_pvec; 1770 struct page *page; 1771 char *kaddr; 1772 struct iattr attr; 1773 unsigned int pathlen = strlen(symname); 1774 int error; 1775 1776 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 1777 dir->i_ino, dentry->d_name.name, symname); 1778 1779 if (pathlen > PAGE_SIZE) 1780 return -ENAMETOOLONG; 1781 1782 attr.ia_mode = S_IFLNK | S_IRWXUGO; 1783 attr.ia_valid = ATTR_MODE; 1784 1785 page = alloc_page(GFP_HIGHUSER); 1786 if (!page) 1787 return -ENOMEM; 1788 1789 kaddr = kmap_atomic(page, KM_USER0); 1790 memcpy(kaddr, symname, pathlen); 1791 if (pathlen < PAGE_SIZE) 1792 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1793 kunmap_atomic(kaddr, KM_USER0); 1794 1795 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1796 if (error != 0) { 1797 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1798 dir->i_sb->s_id, dir->i_ino, 1799 dentry->d_name.name, symname, error); 1800 d_drop(dentry); 1801 __free_page(page); 1802 return error; 1803 } 1804 1805 /* 1806 * No big deal if we can't add this page to the page cache here. 1807 * READLINK will get the missing page from the server if needed. 1808 */ 1809 pagevec_init(&lru_pvec, 0); 1810 if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1811 GFP_KERNEL)) { 1812 pagevec_add(&lru_pvec, page); 1813 pagevec_lru_add_file(&lru_pvec); 1814 SetPageUptodate(page); 1815 unlock_page(page); 1816 } else 1817 __free_page(page); 1818 1819 return 0; 1820 } 1821 1822 static int 1823 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 1824 { 1825 struct inode *inode = old_dentry->d_inode; 1826 int error; 1827 1828 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 1829 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1830 dentry->d_parent->d_name.name, dentry->d_name.name); 1831 1832 nfs_inode_return_delegation(inode); 1833 1834 d_drop(dentry); 1835 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1836 if (error == 0) { 1837 ihold(inode); 1838 d_add(dentry, inode); 1839 } 1840 return error; 1841 } 1842 1843 /* 1844 * RENAME 1845 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 1846 * different file handle for the same inode after a rename (e.g. when 1847 * moving to a different directory). A fail-safe method to do so would 1848 * be to look up old_dir/old_name, create a link to new_dir/new_name and 1849 * rename the old file using the sillyrename stuff. This way, the original 1850 * file in old_dir will go away when the last process iput()s the inode. 1851 * 1852 * FIXED. 1853 * 1854 * It actually works quite well. One needs to have the possibility for 1855 * at least one ".nfs..." file in each directory the file ever gets 1856 * moved or linked to which happens automagically with the new 1857 * implementation that only depends on the dcache stuff instead of 1858 * using the inode layer 1859 * 1860 * Unfortunately, things are a little more complicated than indicated 1861 * above. For a cross-directory move, we want to make sure we can get 1862 * rid of the old inode after the operation. This means there must be 1863 * no pending writes (if it's a file), and the use count must be 1. 1864 * If these conditions are met, we can drop the dentries before doing 1865 * the rename. 1866 */ 1867 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 1868 struct inode *new_dir, struct dentry *new_dentry) 1869 { 1870 struct inode *old_inode = old_dentry->d_inode; 1871 struct inode *new_inode = new_dentry->d_inode; 1872 struct dentry *dentry = NULL, *rehash = NULL; 1873 int error = -EBUSY; 1874 1875 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 1876 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1877 new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 1878 new_dentry->d_count); 1879 1880 /* 1881 * For non-directories, check whether the target is busy and if so, 1882 * make a copy of the dentry and then do a silly-rename. If the 1883 * silly-rename succeeds, the copied dentry is hashed and becomes 1884 * the new target. 1885 */ 1886 if (new_inode && !S_ISDIR(new_inode->i_mode)) { 1887 /* 1888 * To prevent any new references to the target during the 1889 * rename, we unhash the dentry in advance. 1890 */ 1891 if (!d_unhashed(new_dentry)) { 1892 d_drop(new_dentry); 1893 rehash = new_dentry; 1894 } 1895 1896 if (new_dentry->d_count > 2) { 1897 int err; 1898 1899 /* copy the target dentry's name */ 1900 dentry = d_alloc(new_dentry->d_parent, 1901 &new_dentry->d_name); 1902 if (!dentry) 1903 goto out; 1904 1905 /* silly-rename the existing target ... */ 1906 err = nfs_sillyrename(new_dir, new_dentry); 1907 if (err) 1908 goto out; 1909 1910 new_dentry = dentry; 1911 rehash = NULL; 1912 new_inode = NULL; 1913 } 1914 } 1915 1916 nfs_inode_return_delegation(old_inode); 1917 if (new_inode != NULL) 1918 nfs_inode_return_delegation(new_inode); 1919 1920 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 1921 new_dir, &new_dentry->d_name); 1922 nfs_mark_for_revalidate(old_inode); 1923 out: 1924 if (rehash) 1925 d_rehash(rehash); 1926 if (!error) { 1927 if (new_inode != NULL) 1928 nfs_drop_nlink(new_inode); 1929 d_move(old_dentry, new_dentry); 1930 nfs_set_verifier(new_dentry, 1931 nfs_save_change_attribute(new_dir)); 1932 } else if (error == -ENOENT) 1933 nfs_dentry_handle_enoent(old_dentry); 1934 1935 /* new dentry created? */ 1936 if (dentry) 1937 dput(dentry); 1938 return error; 1939 } 1940 1941 static DEFINE_SPINLOCK(nfs_access_lru_lock); 1942 static LIST_HEAD(nfs_access_lru_list); 1943 static atomic_long_t nfs_access_nr_entries; 1944 1945 static void nfs_access_free_entry(struct nfs_access_entry *entry) 1946 { 1947 put_rpccred(entry->cred); 1948 kfree(entry); 1949 smp_mb__before_atomic_dec(); 1950 atomic_long_dec(&nfs_access_nr_entries); 1951 smp_mb__after_atomic_dec(); 1952 } 1953 1954 static void nfs_access_free_list(struct list_head *head) 1955 { 1956 struct nfs_access_entry *cache; 1957 1958 while (!list_empty(head)) { 1959 cache = list_entry(head->next, struct nfs_access_entry, lru); 1960 list_del(&cache->lru); 1961 nfs_access_free_entry(cache); 1962 } 1963 } 1964 1965 int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 1966 { 1967 LIST_HEAD(head); 1968 struct nfs_inode *nfsi, *next; 1969 struct nfs_access_entry *cache; 1970 1971 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 1972 return (nr_to_scan == 0) ? 0 : -1; 1973 1974 spin_lock(&nfs_access_lru_lock); 1975 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 1976 struct inode *inode; 1977 1978 if (nr_to_scan-- == 0) 1979 break; 1980 inode = &nfsi->vfs_inode; 1981 spin_lock(&inode->i_lock); 1982 if (list_empty(&nfsi->access_cache_entry_lru)) 1983 goto remove_lru_entry; 1984 cache = list_entry(nfsi->access_cache_entry_lru.next, 1985 struct nfs_access_entry, lru); 1986 list_move(&cache->lru, &head); 1987 rb_erase(&cache->rb_node, &nfsi->access_cache); 1988 if (!list_empty(&nfsi->access_cache_entry_lru)) 1989 list_move_tail(&nfsi->access_cache_inode_lru, 1990 &nfs_access_lru_list); 1991 else { 1992 remove_lru_entry: 1993 list_del_init(&nfsi->access_cache_inode_lru); 1994 smp_mb__before_clear_bit(); 1995 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 1996 smp_mb__after_clear_bit(); 1997 } 1998 spin_unlock(&inode->i_lock); 1999 } 2000 spin_unlock(&nfs_access_lru_lock); 2001 nfs_access_free_list(&head); 2002 return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 2003 } 2004 2005 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 2006 { 2007 struct rb_root *root_node = &nfsi->access_cache; 2008 struct rb_node *n; 2009 struct nfs_access_entry *entry; 2010 2011 /* Unhook entries from the cache */ 2012 while ((n = rb_first(root_node)) != NULL) { 2013 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2014 rb_erase(n, root_node); 2015 list_move(&entry->lru, head); 2016 } 2017 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 2018 } 2019 2020 void nfs_access_zap_cache(struct inode *inode) 2021 { 2022 LIST_HEAD(head); 2023 2024 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 2025 return; 2026 /* Remove from global LRU init */ 2027 spin_lock(&nfs_access_lru_lock); 2028 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2029 list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2030 2031 spin_lock(&inode->i_lock); 2032 __nfs_access_zap_cache(NFS_I(inode), &head); 2033 spin_unlock(&inode->i_lock); 2034 spin_unlock(&nfs_access_lru_lock); 2035 nfs_access_free_list(&head); 2036 } 2037 2038 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 2039 { 2040 struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 2041 struct nfs_access_entry *entry; 2042 2043 while (n != NULL) { 2044 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2045 2046 if (cred < entry->cred) 2047 n = n->rb_left; 2048 else if (cred > entry->cred) 2049 n = n->rb_right; 2050 else 2051 return entry; 2052 } 2053 return NULL; 2054 } 2055 2056 static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 2057 { 2058 struct nfs_inode *nfsi = NFS_I(inode); 2059 struct nfs_access_entry *cache; 2060 int err = -ENOENT; 2061 2062 spin_lock(&inode->i_lock); 2063 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 2064 goto out_zap; 2065 cache = nfs_access_search_rbtree(inode, cred); 2066 if (cache == NULL) 2067 goto out; 2068 if (!nfs_have_delegated_attributes(inode) && 2069 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 2070 goto out_stale; 2071 res->jiffies = cache->jiffies; 2072 res->cred = cache->cred; 2073 res->mask = cache->mask; 2074 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 2075 err = 0; 2076 out: 2077 spin_unlock(&inode->i_lock); 2078 return err; 2079 out_stale: 2080 rb_erase(&cache->rb_node, &nfsi->access_cache); 2081 list_del(&cache->lru); 2082 spin_unlock(&inode->i_lock); 2083 nfs_access_free_entry(cache); 2084 return -ENOENT; 2085 out_zap: 2086 spin_unlock(&inode->i_lock); 2087 nfs_access_zap_cache(inode); 2088 return -ENOENT; 2089 } 2090 2091 static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 2092 { 2093 struct nfs_inode *nfsi = NFS_I(inode); 2094 struct rb_root *root_node = &nfsi->access_cache; 2095 struct rb_node **p = &root_node->rb_node; 2096 struct rb_node *parent = NULL; 2097 struct nfs_access_entry *entry; 2098 2099 spin_lock(&inode->i_lock); 2100 while (*p != NULL) { 2101 parent = *p; 2102 entry = rb_entry(parent, struct nfs_access_entry, rb_node); 2103 2104 if (set->cred < entry->cred) 2105 p = &parent->rb_left; 2106 else if (set->cred > entry->cred) 2107 p = &parent->rb_right; 2108 else 2109 goto found; 2110 } 2111 rb_link_node(&set->rb_node, parent, p); 2112 rb_insert_color(&set->rb_node, root_node); 2113 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2114 spin_unlock(&inode->i_lock); 2115 return; 2116 found: 2117 rb_replace_node(parent, &set->rb_node, root_node); 2118 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2119 list_del(&entry->lru); 2120 spin_unlock(&inode->i_lock); 2121 nfs_access_free_entry(entry); 2122 } 2123 2124 static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 2125 { 2126 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 2127 if (cache == NULL) 2128 return; 2129 RB_CLEAR_NODE(&cache->rb_node); 2130 cache->jiffies = set->jiffies; 2131 cache->cred = get_rpccred(set->cred); 2132 cache->mask = set->mask; 2133 2134 nfs_access_add_rbtree(inode, cache); 2135 2136 /* Update accounting */ 2137 smp_mb__before_atomic_inc(); 2138 atomic_long_inc(&nfs_access_nr_entries); 2139 smp_mb__after_atomic_inc(); 2140 2141 /* Add inode to global LRU list */ 2142 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2143 spin_lock(&nfs_access_lru_lock); 2144 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2145 list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 2146 &nfs_access_lru_list); 2147 spin_unlock(&nfs_access_lru_lock); 2148 } 2149 } 2150 2151 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 2152 { 2153 struct nfs_access_entry cache; 2154 int status; 2155 2156 status = nfs_access_get_cached(inode, cred, &cache); 2157 if (status == 0) 2158 goto out; 2159 2160 /* Be clever: ask server to check for all possible rights */ 2161 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 2162 cache.cred = cred; 2163 cache.jiffies = jiffies; 2164 status = NFS_PROTO(inode)->access(inode, &cache); 2165 if (status != 0) { 2166 if (status == -ESTALE) { 2167 nfs_zap_caches(inode); 2168 if (!S_ISDIR(inode->i_mode)) 2169 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2170 } 2171 return status; 2172 } 2173 nfs_access_add_cache(inode, &cache); 2174 out: 2175 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2176 return 0; 2177 return -EACCES; 2178 } 2179 2180 static int nfs_open_permission_mask(int openflags) 2181 { 2182 int mask = 0; 2183 2184 if (openflags & FMODE_READ) 2185 mask |= MAY_READ; 2186 if (openflags & FMODE_WRITE) 2187 mask |= MAY_WRITE; 2188 if (openflags & FMODE_EXEC) 2189 mask |= MAY_EXEC; 2190 return mask; 2191 } 2192 2193 int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2194 { 2195 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2196 } 2197 2198 int nfs_permission(struct inode *inode, int mask, unsigned int flags) 2199 { 2200 struct rpc_cred *cred; 2201 int res = 0; 2202 2203 if (flags & IPERM_FLAG_RCU) 2204 return -ECHILD; 2205 2206 nfs_inc_stats(inode, NFSIOS_VFSACCESS); 2207 2208 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2209 goto out; 2210 /* Is this sys_access() ? */ 2211 if (mask & (MAY_ACCESS | MAY_CHDIR)) 2212 goto force_lookup; 2213 2214 switch (inode->i_mode & S_IFMT) { 2215 case S_IFLNK: 2216 goto out; 2217 case S_IFREG: 2218 /* NFSv4 has atomic_open... */ 2219 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 2220 && (mask & MAY_OPEN) 2221 && !(mask & MAY_EXEC)) 2222 goto out; 2223 break; 2224 case S_IFDIR: 2225 /* 2226 * Optimize away all write operations, since the server 2227 * will check permissions when we perform the op. 2228 */ 2229 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 2230 goto out; 2231 } 2232 2233 force_lookup: 2234 if (!NFS_PROTO(inode)->access) 2235 goto out_notsup; 2236 2237 cred = rpc_lookup_cred(); 2238 if (!IS_ERR(cred)) { 2239 res = nfs_do_access(inode, cred, mask); 2240 put_rpccred(cred); 2241 } else 2242 res = PTR_ERR(cred); 2243 out: 2244 if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2245 res = -EACCES; 2246 2247 dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 2248 inode->i_sb->s_id, inode->i_ino, mask, res); 2249 return res; 2250 out_notsup: 2251 res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 2252 if (res == 0) 2253 res = generic_permission(inode, mask, flags, NULL); 2254 goto out; 2255 } 2256 2257 /* 2258 * Local variables: 2259 * version-control: t 2260 * kept-new-versions: 5 2261 * End: 2262 */ 2263