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/vmalloc.h> 37 #include <linux/kmemleak.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 = nfs4_getxattr, 129 .setxattr = nfs4_setxattr, 130 .listxattr = nfs4_listxattr, 131 }; 132 133 #endif /* CONFIG_NFS_V4 */ 134 135 /* 136 * Open file 137 */ 138 static int 139 nfs_opendir(struct inode *inode, struct file *filp) 140 { 141 int res; 142 143 dfprintk(FILE, "NFS: open dir(%s/%s)\n", 144 filp->f_path.dentry->d_parent->d_name.name, 145 filp->f_path.dentry->d_name.name); 146 147 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 148 149 /* Call generic open code in order to cache credentials */ 150 res = nfs_open(inode, filp); 151 if (filp->f_path.dentry == filp->f_path.mnt->mnt_root) { 152 /* This is a mountpoint, so d_revalidate will never 153 * have been called, so we need to refresh the 154 * inode (for close-open consistency) ourselves. 155 */ 156 __nfs_revalidate_inode(NFS_SERVER(inode), inode); 157 } 158 return res; 159 } 160 161 struct nfs_cache_array_entry { 162 u64 cookie; 163 u64 ino; 164 struct qstr string; 165 unsigned char d_type; 166 }; 167 168 struct nfs_cache_array { 169 unsigned int size; 170 int eof_index; 171 u64 last_cookie; 172 struct nfs_cache_array_entry array[0]; 173 }; 174 175 typedef __be32 * (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, struct nfs_server *, int); 176 typedef struct { 177 struct file *file; 178 struct page *page; 179 unsigned long page_index; 180 u64 *dir_cookie; 181 u64 last_cookie; 182 loff_t current_index; 183 decode_dirent_t decode; 184 185 unsigned long timestamp; 186 unsigned long gencount; 187 unsigned int cache_entry_index; 188 unsigned int plus:1; 189 unsigned int eof:1; 190 } nfs_readdir_descriptor_t; 191 192 /* 193 * The caller is responsible for calling nfs_readdir_release_array(page) 194 */ 195 static 196 struct nfs_cache_array *nfs_readdir_get_array(struct page *page) 197 { 198 void *ptr; 199 if (page == NULL) 200 return ERR_PTR(-EIO); 201 ptr = kmap(page); 202 if (ptr == NULL) 203 return ERR_PTR(-ENOMEM); 204 return ptr; 205 } 206 207 static 208 void nfs_readdir_release_array(struct page *page) 209 { 210 kunmap(page); 211 } 212 213 /* 214 * we are freeing strings created by nfs_add_to_readdir_array() 215 */ 216 static 217 void nfs_readdir_clear_array(struct page *page) 218 { 219 struct nfs_cache_array *array; 220 int i; 221 222 array = kmap_atomic(page, KM_USER0); 223 for (i = 0; i < array->size; i++) 224 kfree(array->array[i].string.name); 225 kunmap_atomic(array, KM_USER0); 226 } 227 228 /* 229 * the caller is responsible for freeing qstr.name 230 * when called by nfs_readdir_add_to_array, the strings will be freed in 231 * nfs_clear_readdir_array() 232 */ 233 static 234 int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int len) 235 { 236 string->len = len; 237 string->name = kmemdup(name, len, GFP_KERNEL); 238 if (string->name == NULL) 239 return -ENOMEM; 240 /* 241 * Avoid a kmemleak false positive. The pointer to the name is stored 242 * in a page cache page which kmemleak does not scan. 243 */ 244 kmemleak_not_leak(string->name); 245 string->hash = full_name_hash(name, len); 246 return 0; 247 } 248 249 static 250 int nfs_readdir_add_to_array(struct nfs_entry *entry, struct page *page) 251 { 252 struct nfs_cache_array *array = nfs_readdir_get_array(page); 253 struct nfs_cache_array_entry *cache_entry; 254 int ret; 255 256 if (IS_ERR(array)) 257 return PTR_ERR(array); 258 259 cache_entry = &array->array[array->size]; 260 261 /* Check that this entry lies within the page bounds */ 262 ret = -ENOSPC; 263 if ((char *)&cache_entry[1] - (char *)page_address(page) > PAGE_SIZE) 264 goto out; 265 266 cache_entry->cookie = entry->prev_cookie; 267 cache_entry->ino = entry->ino; 268 cache_entry->d_type = entry->d_type; 269 ret = nfs_readdir_make_qstr(&cache_entry->string, entry->name, entry->len); 270 if (ret) 271 goto out; 272 array->last_cookie = entry->cookie; 273 array->size++; 274 if (entry->eof != 0) 275 array->eof_index = array->size; 276 out: 277 nfs_readdir_release_array(page); 278 return ret; 279 } 280 281 static 282 int nfs_readdir_search_for_pos(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 283 { 284 loff_t diff = desc->file->f_pos - desc->current_index; 285 unsigned int index; 286 287 if (diff < 0) 288 goto out_eof; 289 if (diff >= array->size) { 290 if (array->eof_index >= 0) 291 goto out_eof; 292 desc->current_index += array->size; 293 return -EAGAIN; 294 } 295 296 index = (unsigned int)diff; 297 *desc->dir_cookie = array->array[index].cookie; 298 desc->cache_entry_index = index; 299 return 0; 300 out_eof: 301 desc->eof = 1; 302 return -EBADCOOKIE; 303 } 304 305 static 306 int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_descriptor_t *desc) 307 { 308 int i; 309 int status = -EAGAIN; 310 311 for (i = 0; i < array->size; i++) { 312 if (array->array[i].cookie == *desc->dir_cookie) { 313 desc->cache_entry_index = i; 314 return 0; 315 } 316 } 317 if (array->eof_index >= 0) { 318 status = -EBADCOOKIE; 319 if (*desc->dir_cookie == array->last_cookie) 320 desc->eof = 1; 321 } 322 return status; 323 } 324 325 static 326 int nfs_readdir_search_array(nfs_readdir_descriptor_t *desc) 327 { 328 struct nfs_cache_array *array; 329 int status; 330 331 array = nfs_readdir_get_array(desc->page); 332 if (IS_ERR(array)) { 333 status = PTR_ERR(array); 334 goto out; 335 } 336 337 if (*desc->dir_cookie == 0) 338 status = nfs_readdir_search_for_pos(array, desc); 339 else 340 status = nfs_readdir_search_for_cookie(array, desc); 341 342 if (status == -EAGAIN) { 343 desc->last_cookie = array->last_cookie; 344 desc->page_index++; 345 } 346 nfs_readdir_release_array(desc->page); 347 out: 348 return status; 349 } 350 351 /* Fill a page with xdr information before transferring to the cache page */ 352 static 353 int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 354 struct nfs_entry *entry, struct file *file, struct inode *inode) 355 { 356 struct rpc_cred *cred = nfs_file_cred(file); 357 unsigned long timestamp, gencount; 358 int error; 359 360 again: 361 timestamp = jiffies; 362 gencount = nfs_inc_attr_generation_counter(); 363 error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, entry->cookie, pages, 364 NFS_SERVER(inode)->dtsize, desc->plus); 365 if (error < 0) { 366 /* We requested READDIRPLUS, but the server doesn't grok it */ 367 if (error == -ENOTSUPP && desc->plus) { 368 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 369 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags); 370 desc->plus = 0; 371 goto again; 372 } 373 goto error; 374 } 375 desc->timestamp = timestamp; 376 desc->gencount = gencount; 377 error: 378 return error; 379 } 380 381 /* Fill in an entry based on the xdr code stored in desc->page */ 382 static 383 int xdr_decode(nfs_readdir_descriptor_t *desc, struct nfs_entry *entry, struct xdr_stream *stream) 384 { 385 __be32 *p = desc->decode(stream, entry, NFS_SERVER(desc->file->f_path.dentry->d_inode), desc->plus); 386 if (IS_ERR(p)) 387 return PTR_ERR(p); 388 389 entry->fattr->time_start = desc->timestamp; 390 entry->fattr->gencount = desc->gencount; 391 return 0; 392 } 393 394 static 395 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 396 { 397 if (dentry->d_inode == NULL) 398 goto different; 399 if (nfs_compare_fh(entry->fh, NFS_FH(dentry->d_inode)) != 0) 400 goto different; 401 return 1; 402 different: 403 return 0; 404 } 405 406 static 407 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry) 408 { 409 struct qstr filename = { 410 .len = entry->len, 411 .name = entry->name, 412 }; 413 struct dentry *dentry; 414 struct dentry *alias; 415 struct inode *dir = parent->d_inode; 416 struct inode *inode; 417 418 if (filename.name[0] == '.') { 419 if (filename.len == 1) 420 return; 421 if (filename.len == 2 && filename.name[1] == '.') 422 return; 423 } 424 filename.hash = full_name_hash(filename.name, filename.len); 425 426 dentry = d_lookup(parent, &filename); 427 if (dentry != NULL) { 428 if (nfs_same_file(dentry, entry)) { 429 nfs_refresh_inode(dentry->d_inode, entry->fattr); 430 goto out; 431 } else { 432 d_drop(dentry); 433 dput(dentry); 434 } 435 } 436 437 dentry = d_alloc(parent, &filename); 438 if (dentry == NULL) 439 return; 440 441 d_set_d_op(dentry, NFS_PROTO(dir)->dentry_ops); 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 void *xdr_page, struct page *page, unsigned int buflen) 463 { 464 struct xdr_stream stream; 465 struct xdr_buf buf; 466 __be32 *ptr = xdr_page; 467 struct nfs_cache_array *array; 468 unsigned int count = 0; 469 int status; 470 471 buf.head->iov_base = xdr_page; 472 buf.head->iov_len = buflen; 473 buf.tail->iov_len = 0; 474 buf.page_base = 0; 475 buf.page_len = 0; 476 buf.buflen = buf.head->iov_len; 477 buf.len = buf.head->iov_len; 478 479 xdr_init_decode(&stream, &buf, ptr); 480 481 482 do { 483 status = xdr_decode(desc, entry, &stream); 484 if (status != 0) { 485 if (status == -EAGAIN) 486 status = 0; 487 break; 488 } 489 490 count++; 491 492 if (desc->plus != 0) 493 nfs_prime_dcache(desc->file->f_path.dentry, entry); 494 495 status = nfs_readdir_add_to_array(entry, page); 496 if (status != 0) 497 break; 498 } while (!entry->eof); 499 500 if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) { 501 array = nfs_readdir_get_array(page); 502 if (!IS_ERR(array)) { 503 array->eof_index = array->size; 504 status = 0; 505 nfs_readdir_release_array(page); 506 } else 507 status = PTR_ERR(array); 508 } 509 return status; 510 } 511 512 static 513 void nfs_readdir_free_pagearray(struct page **pages, unsigned int npages) 514 { 515 unsigned int i; 516 for (i = 0; i < npages; i++) 517 put_page(pages[i]); 518 } 519 520 static 521 void nfs_readdir_free_large_page(void *ptr, struct page **pages, 522 unsigned int npages) 523 { 524 vm_unmap_ram(ptr, npages); 525 nfs_readdir_free_pagearray(pages, npages); 526 } 527 528 /* 529 * nfs_readdir_large_page will allocate pages that must be freed with a call 530 * to nfs_readdir_free_large_page 531 */ 532 static 533 void *nfs_readdir_large_page(struct page **pages, unsigned int npages) 534 { 535 void *ptr; 536 unsigned int i; 537 538 for (i = 0; i < npages; i++) { 539 struct page *page = alloc_page(GFP_KERNEL); 540 if (page == NULL) 541 goto out_freepages; 542 pages[i] = page; 543 } 544 545 ptr = vm_map_ram(pages, npages, 0, PAGE_KERNEL); 546 if (!IS_ERR_OR_NULL(ptr)) 547 return ptr; 548 out_freepages: 549 nfs_readdir_free_pagearray(pages, i); 550 return NULL; 551 } 552 553 static 554 int nfs_readdir_xdr_to_array(nfs_readdir_descriptor_t *desc, struct page *page, struct inode *inode) 555 { 556 struct page *pages[NFS_MAX_READDIR_PAGES]; 557 void *pages_ptr = NULL; 558 struct nfs_entry entry; 559 struct file *file = desc->file; 560 struct nfs_cache_array *array; 561 int status = -ENOMEM; 562 unsigned int array_size = ARRAY_SIZE(pages); 563 564 entry.prev_cookie = 0; 565 entry.cookie = desc->last_cookie; 566 entry.eof = 0; 567 entry.fh = nfs_alloc_fhandle(); 568 entry.fattr = nfs_alloc_fattr(); 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 pages_ptr = nfs_readdir_large_page(pages, array_size); 581 if (!pages_ptr) 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_ptr, 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 d_set_d_op(dentry, NFS_PROTO(dir)->dentry_ops); 1196 1197 /* 1198 * If we're doing an exclusive create, optimize away the lookup 1199 * but don't hash the dentry. 1200 */ 1201 if (nfs_is_exclusive_create(dir, nd)) { 1202 d_instantiate(dentry, NULL); 1203 res = NULL; 1204 goto out; 1205 } 1206 1207 res = ERR_PTR(-ENOMEM); 1208 fhandle = nfs_alloc_fhandle(); 1209 fattr = nfs_alloc_fattr(); 1210 if (fhandle == NULL || fattr == NULL) 1211 goto out; 1212 1213 parent = dentry->d_parent; 1214 /* Protect against concurrent sillydeletes */ 1215 nfs_block_sillyrename(parent); 1216 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1217 if (error == -ENOENT) 1218 goto no_entry; 1219 if (error < 0) { 1220 res = ERR_PTR(error); 1221 goto out_unblock_sillyrename; 1222 } 1223 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1224 res = (struct dentry *)inode; 1225 if (IS_ERR(res)) 1226 goto out_unblock_sillyrename; 1227 1228 no_entry: 1229 res = d_materialise_unique(dentry, inode); 1230 if (res != NULL) { 1231 if (IS_ERR(res)) 1232 goto out_unblock_sillyrename; 1233 dentry = res; 1234 } 1235 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1236 out_unblock_sillyrename: 1237 nfs_unblock_sillyrename(parent); 1238 out: 1239 nfs_free_fattr(fattr); 1240 nfs_free_fhandle(fhandle); 1241 return res; 1242 } 1243 1244 #ifdef CONFIG_NFS_V4 1245 static int nfs_open_revalidate(struct dentry *, struct nameidata *); 1246 1247 const struct dentry_operations nfs4_dentry_operations = { 1248 .d_revalidate = nfs_open_revalidate, 1249 .d_delete = nfs_dentry_delete, 1250 .d_iput = nfs_dentry_iput, 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 d_set_d_op(dentry, NFS_PROTO(dir)->dentry_ops); 1341 1342 /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash 1343 * the dentry. */ 1344 if (nd->flags & LOOKUP_EXCL) { 1345 d_instantiate(dentry, NULL); 1346 goto out; 1347 } 1348 1349 ctx = nameidata_to_nfs_open_context(dentry, nd); 1350 res = ERR_CAST(ctx); 1351 if (IS_ERR(ctx)) 1352 goto out; 1353 1354 open_flags = nd->intent.open.flags; 1355 if (nd->flags & LOOKUP_CREATE) { 1356 attr.ia_mode = nd->intent.open.create_mode; 1357 attr.ia_valid = ATTR_MODE; 1358 if (!IS_POSIXACL(dir)) 1359 attr.ia_mode &= ~current_umask(); 1360 } else { 1361 open_flags &= ~(O_EXCL | O_CREAT); 1362 attr.ia_valid = 0; 1363 } 1364 1365 /* Open the file on the server */ 1366 nfs_block_sillyrename(dentry->d_parent); 1367 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr); 1368 if (IS_ERR(inode)) { 1369 nfs_unblock_sillyrename(dentry->d_parent); 1370 put_nfs_open_context(ctx); 1371 switch (PTR_ERR(inode)) { 1372 /* Make a negative dentry */ 1373 case -ENOENT: 1374 d_add(dentry, NULL); 1375 res = NULL; 1376 goto out; 1377 /* This turned out not to be a regular file */ 1378 case -ENOTDIR: 1379 goto no_open; 1380 case -ELOOP: 1381 if (!(nd->intent.open.flags & O_NOFOLLOW)) 1382 goto no_open; 1383 /* case -EISDIR: */ 1384 /* case -EINVAL: */ 1385 default: 1386 res = ERR_CAST(inode); 1387 goto out; 1388 } 1389 } 1390 res = d_add_unique(dentry, inode); 1391 nfs_unblock_sillyrename(dentry->d_parent); 1392 if (res != NULL) { 1393 dput(ctx->path.dentry); 1394 ctx->path.dentry = dget(res); 1395 dentry = res; 1396 } 1397 err = nfs_intent_set_file(nd, ctx); 1398 if (err < 0) { 1399 if (res != NULL) 1400 dput(res); 1401 return ERR_PTR(err); 1402 } 1403 out: 1404 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1405 return res; 1406 no_open: 1407 return nfs_lookup(dir, dentry, nd); 1408 } 1409 1410 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 1411 { 1412 struct dentry *parent = NULL; 1413 struct inode *inode; 1414 struct inode *dir; 1415 struct nfs_open_context *ctx; 1416 int openflags, ret = 0; 1417 1418 if (nd->flags & LOOKUP_RCU) 1419 return -ECHILD; 1420 1421 inode = dentry->d_inode; 1422 if (!is_atomic_open(nd) || d_mountpoint(dentry)) 1423 goto no_open; 1424 1425 parent = dget_parent(dentry); 1426 dir = parent->d_inode; 1427 1428 /* We can't create new files in nfs_open_revalidate(), so we 1429 * optimize away revalidation of negative dentries. 1430 */ 1431 if (inode == NULL) { 1432 if (!nfs_neg_need_reval(dir, dentry, nd)) 1433 ret = 1; 1434 goto out; 1435 } 1436 1437 /* NFS only supports OPEN on regular files */ 1438 if (!S_ISREG(inode->i_mode)) 1439 goto no_open_dput; 1440 openflags = nd->intent.open.flags; 1441 /* We cannot do exclusive creation on a positive dentry */ 1442 if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 1443 goto no_open_dput; 1444 /* We can't create new files, or truncate existing ones here */ 1445 openflags &= ~(O_CREAT|O_EXCL|O_TRUNC); 1446 1447 ctx = nameidata_to_nfs_open_context(dentry, nd); 1448 ret = PTR_ERR(ctx); 1449 if (IS_ERR(ctx)) 1450 goto out; 1451 /* 1452 * Note: we're not holding inode->i_mutex and so may be racing with 1453 * operations that change the directory. We therefore save the 1454 * change attribute *before* we do the RPC call. 1455 */ 1456 inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, NULL); 1457 if (IS_ERR(inode)) { 1458 ret = PTR_ERR(inode); 1459 switch (ret) { 1460 case -EPERM: 1461 case -EACCES: 1462 case -EDQUOT: 1463 case -ENOSPC: 1464 case -EROFS: 1465 goto out_put_ctx; 1466 default: 1467 goto out_drop; 1468 } 1469 } 1470 iput(inode); 1471 if (inode != dentry->d_inode) 1472 goto out_drop; 1473 1474 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1475 ret = nfs_intent_set_file(nd, ctx); 1476 if (ret >= 0) 1477 ret = 1; 1478 out: 1479 dput(parent); 1480 return ret; 1481 out_drop: 1482 d_drop(dentry); 1483 ret = 0; 1484 out_put_ctx: 1485 put_nfs_open_context(ctx); 1486 goto out; 1487 1488 no_open_dput: 1489 dput(parent); 1490 no_open: 1491 return nfs_lookup_revalidate(dentry, nd); 1492 } 1493 1494 static int nfs_open_create(struct inode *dir, struct dentry *dentry, int mode, 1495 struct nameidata *nd) 1496 { 1497 struct nfs_open_context *ctx = NULL; 1498 struct iattr attr; 1499 int error; 1500 int open_flags = 0; 1501 1502 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1503 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1504 1505 attr.ia_mode = mode; 1506 attr.ia_valid = ATTR_MODE; 1507 1508 if ((nd->flags & LOOKUP_CREATE) != 0) { 1509 open_flags = nd->intent.open.flags; 1510 1511 ctx = nameidata_to_nfs_open_context(dentry, nd); 1512 error = PTR_ERR(ctx); 1513 if (IS_ERR(ctx)) 1514 goto out_err_drop; 1515 } 1516 1517 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx); 1518 if (error != 0) 1519 goto out_put_ctx; 1520 if (ctx != NULL) { 1521 error = nfs_intent_set_file(nd, ctx); 1522 if (error < 0) 1523 goto out_err; 1524 } 1525 return 0; 1526 out_put_ctx: 1527 if (ctx != NULL) 1528 put_nfs_open_context(ctx); 1529 out_err_drop: 1530 d_drop(dentry); 1531 out_err: 1532 return error; 1533 } 1534 1535 #endif /* CONFIG_NFSV4 */ 1536 1537 /* 1538 * Code common to create, mkdir, and mknod. 1539 */ 1540 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 1541 struct nfs_fattr *fattr) 1542 { 1543 struct dentry *parent = dget_parent(dentry); 1544 struct inode *dir = parent->d_inode; 1545 struct inode *inode; 1546 int error = -EACCES; 1547 1548 d_drop(dentry); 1549 1550 /* We may have been initialized further down */ 1551 if (dentry->d_inode) 1552 goto out; 1553 if (fhandle->size == 0) { 1554 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1555 if (error) 1556 goto out_error; 1557 } 1558 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1559 if (!(fattr->valid & NFS_ATTR_FATTR)) { 1560 struct nfs_server *server = NFS_SB(dentry->d_sb); 1561 error = server->nfs_client->rpc_ops->getattr(server, fhandle, fattr); 1562 if (error < 0) 1563 goto out_error; 1564 } 1565 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1566 error = PTR_ERR(inode); 1567 if (IS_ERR(inode)) 1568 goto out_error; 1569 d_add(dentry, inode); 1570 out: 1571 dput(parent); 1572 return 0; 1573 out_error: 1574 nfs_mark_for_revalidate(dir); 1575 dput(parent); 1576 return error; 1577 } 1578 1579 /* 1580 * Following a failed create operation, we drop the dentry rather 1581 * than retain a negative dentry. This avoids a problem in the event 1582 * that the operation succeeded on the server, but an error in the 1583 * reply path made it appear to have failed. 1584 */ 1585 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 1586 struct nameidata *nd) 1587 { 1588 struct iattr attr; 1589 int error; 1590 1591 dfprintk(VFS, "NFS: create(%s/%ld), %s\n", 1592 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1593 1594 attr.ia_mode = mode; 1595 attr.ia_valid = ATTR_MODE; 1596 1597 error = NFS_PROTO(dir)->create(dir, dentry, &attr, 0, NULL); 1598 if (error != 0) 1599 goto out_err; 1600 return 0; 1601 out_err: 1602 d_drop(dentry); 1603 return error; 1604 } 1605 1606 /* 1607 * See comments for nfs_proc_create regarding failed operations. 1608 */ 1609 static int 1610 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 1611 { 1612 struct iattr attr; 1613 int status; 1614 1615 dfprintk(VFS, "NFS: mknod(%s/%ld), %s\n", 1616 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1617 1618 if (!new_valid_dev(rdev)) 1619 return -EINVAL; 1620 1621 attr.ia_mode = mode; 1622 attr.ia_valid = ATTR_MODE; 1623 1624 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 1625 if (status != 0) 1626 goto out_err; 1627 return 0; 1628 out_err: 1629 d_drop(dentry); 1630 return status; 1631 } 1632 1633 /* 1634 * See comments for nfs_proc_create regarding failed operations. 1635 */ 1636 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 1637 { 1638 struct iattr attr; 1639 int error; 1640 1641 dfprintk(VFS, "NFS: mkdir(%s/%ld), %s\n", 1642 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1643 1644 attr.ia_valid = ATTR_MODE; 1645 attr.ia_mode = mode | S_IFDIR; 1646 1647 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 1648 if (error != 0) 1649 goto out_err; 1650 return 0; 1651 out_err: 1652 d_drop(dentry); 1653 return error; 1654 } 1655 1656 static void nfs_dentry_handle_enoent(struct dentry *dentry) 1657 { 1658 if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1659 d_delete(dentry); 1660 } 1661 1662 static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 1663 { 1664 int error; 1665 1666 dfprintk(VFS, "NFS: rmdir(%s/%ld), %s\n", 1667 dir->i_sb->s_id, dir->i_ino, dentry->d_name.name); 1668 1669 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 1670 /* Ensure the VFS deletes this inode */ 1671 if (error == 0 && dentry->d_inode != NULL) 1672 clear_nlink(dentry->d_inode); 1673 else if (error == -ENOENT) 1674 nfs_dentry_handle_enoent(dentry); 1675 1676 return error; 1677 } 1678 1679 /* 1680 * Remove a file after making sure there are no pending writes, 1681 * and after checking that the file has only one user. 1682 * 1683 * We invalidate the attribute cache and free the inode prior to the operation 1684 * to avoid possible races if the server reuses the inode. 1685 */ 1686 static int nfs_safe_remove(struct dentry *dentry) 1687 { 1688 struct inode *dir = dentry->d_parent->d_inode; 1689 struct inode *inode = dentry->d_inode; 1690 int error = -EBUSY; 1691 1692 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 1693 dentry->d_parent->d_name.name, dentry->d_name.name); 1694 1695 /* If the dentry was sillyrenamed, we simply call d_delete() */ 1696 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1697 error = 0; 1698 goto out; 1699 } 1700 1701 if (inode != NULL) { 1702 nfs_inode_return_delegation(inode); 1703 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1704 /* The VFS may want to delete this inode */ 1705 if (error == 0) 1706 nfs_drop_nlink(inode); 1707 nfs_mark_for_revalidate(inode); 1708 } else 1709 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1710 if (error == -ENOENT) 1711 nfs_dentry_handle_enoent(dentry); 1712 out: 1713 return error; 1714 } 1715 1716 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 1717 * belongs to an active ".nfs..." file and we return -EBUSY. 1718 * 1719 * If sillyrename() returns 0, we do nothing, otherwise we unlink. 1720 */ 1721 static int nfs_unlink(struct inode *dir, struct dentry *dentry) 1722 { 1723 int error; 1724 int need_rehash = 0; 1725 1726 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 1727 dir->i_ino, dentry->d_name.name); 1728 1729 spin_lock(&dentry->d_lock); 1730 if (dentry->d_count > 1) { 1731 spin_unlock(&dentry->d_lock); 1732 /* Start asynchronous writeout of the inode */ 1733 write_inode_now(dentry->d_inode, 0); 1734 error = nfs_sillyrename(dir, dentry); 1735 return error; 1736 } 1737 if (!d_unhashed(dentry)) { 1738 __d_drop(dentry); 1739 need_rehash = 1; 1740 } 1741 spin_unlock(&dentry->d_lock); 1742 error = nfs_safe_remove(dentry); 1743 if (!error || error == -ENOENT) { 1744 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1745 } else if (need_rehash) 1746 d_rehash(dentry); 1747 return error; 1748 } 1749 1750 /* 1751 * To create a symbolic link, most file systems instantiate a new inode, 1752 * add a page to it containing the path, then write it out to the disk 1753 * using prepare_write/commit_write. 1754 * 1755 * Unfortunately the NFS client can't create the in-core inode first 1756 * because it needs a file handle to create an in-core inode (see 1757 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 1758 * symlink request has completed on the server. 1759 * 1760 * So instead we allocate a raw page, copy the symname into it, then do 1761 * the SYMLINK request with the page as the buffer. If it succeeds, we 1762 * now have a new file handle and can instantiate an in-core NFS inode 1763 * and move the raw page into its mapping. 1764 */ 1765 static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 1766 { 1767 struct pagevec lru_pvec; 1768 struct page *page; 1769 char *kaddr; 1770 struct iattr attr; 1771 unsigned int pathlen = strlen(symname); 1772 int error; 1773 1774 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 1775 dir->i_ino, dentry->d_name.name, symname); 1776 1777 if (pathlen > PAGE_SIZE) 1778 return -ENAMETOOLONG; 1779 1780 attr.ia_mode = S_IFLNK | S_IRWXUGO; 1781 attr.ia_valid = ATTR_MODE; 1782 1783 page = alloc_page(GFP_HIGHUSER); 1784 if (!page) 1785 return -ENOMEM; 1786 1787 kaddr = kmap_atomic(page, KM_USER0); 1788 memcpy(kaddr, symname, pathlen); 1789 if (pathlen < PAGE_SIZE) 1790 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 1791 kunmap_atomic(kaddr, KM_USER0); 1792 1793 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 1794 if (error != 0) { 1795 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s) error %d\n", 1796 dir->i_sb->s_id, dir->i_ino, 1797 dentry->d_name.name, symname, error); 1798 d_drop(dentry); 1799 __free_page(page); 1800 return error; 1801 } 1802 1803 /* 1804 * No big deal if we can't add this page to the page cache here. 1805 * READLINK will get the missing page from the server if needed. 1806 */ 1807 pagevec_init(&lru_pvec, 0); 1808 if (!add_to_page_cache(page, dentry->d_inode->i_mapping, 0, 1809 GFP_KERNEL)) { 1810 pagevec_add(&lru_pvec, page); 1811 pagevec_lru_add_file(&lru_pvec); 1812 SetPageUptodate(page); 1813 unlock_page(page); 1814 } else 1815 __free_page(page); 1816 1817 return 0; 1818 } 1819 1820 static int 1821 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 1822 { 1823 struct inode *inode = old_dentry->d_inode; 1824 int error; 1825 1826 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 1827 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1828 dentry->d_parent->d_name.name, dentry->d_name.name); 1829 1830 nfs_inode_return_delegation(inode); 1831 1832 d_drop(dentry); 1833 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1834 if (error == 0) { 1835 ihold(inode); 1836 d_add(dentry, inode); 1837 } 1838 return error; 1839 } 1840 1841 /* 1842 * RENAME 1843 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 1844 * different file handle for the same inode after a rename (e.g. when 1845 * moving to a different directory). A fail-safe method to do so would 1846 * be to look up old_dir/old_name, create a link to new_dir/new_name and 1847 * rename the old file using the sillyrename stuff. This way, the original 1848 * file in old_dir will go away when the last process iput()s the inode. 1849 * 1850 * FIXED. 1851 * 1852 * It actually works quite well. One needs to have the possibility for 1853 * at least one ".nfs..." file in each directory the file ever gets 1854 * moved or linked to which happens automagically with the new 1855 * implementation that only depends on the dcache stuff instead of 1856 * using the inode layer 1857 * 1858 * Unfortunately, things are a little more complicated than indicated 1859 * above. For a cross-directory move, we want to make sure we can get 1860 * rid of the old inode after the operation. This means there must be 1861 * no pending writes (if it's a file), and the use count must be 1. 1862 * If these conditions are met, we can drop the dentries before doing 1863 * the rename. 1864 */ 1865 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 1866 struct inode *new_dir, struct dentry *new_dentry) 1867 { 1868 struct inode *old_inode = old_dentry->d_inode; 1869 struct inode *new_inode = new_dentry->d_inode; 1870 struct dentry *dentry = NULL, *rehash = NULL; 1871 int error = -EBUSY; 1872 1873 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 1874 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1875 new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 1876 new_dentry->d_count); 1877 1878 /* 1879 * For non-directories, check whether the target is busy and if so, 1880 * make a copy of the dentry and then do a silly-rename. If the 1881 * silly-rename succeeds, the copied dentry is hashed and becomes 1882 * the new target. 1883 */ 1884 if (new_inode && !S_ISDIR(new_inode->i_mode)) { 1885 /* 1886 * To prevent any new references to the target during the 1887 * rename, we unhash the dentry in advance. 1888 */ 1889 if (!d_unhashed(new_dentry)) { 1890 d_drop(new_dentry); 1891 rehash = new_dentry; 1892 } 1893 1894 if (new_dentry->d_count > 2) { 1895 int err; 1896 1897 /* copy the target dentry's name */ 1898 dentry = d_alloc(new_dentry->d_parent, 1899 &new_dentry->d_name); 1900 if (!dentry) 1901 goto out; 1902 1903 /* silly-rename the existing target ... */ 1904 err = nfs_sillyrename(new_dir, new_dentry); 1905 if (err) 1906 goto out; 1907 1908 new_dentry = dentry; 1909 rehash = NULL; 1910 new_inode = NULL; 1911 } 1912 } 1913 1914 nfs_inode_return_delegation(old_inode); 1915 if (new_inode != NULL) 1916 nfs_inode_return_delegation(new_inode); 1917 1918 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 1919 new_dir, &new_dentry->d_name); 1920 nfs_mark_for_revalidate(old_inode); 1921 out: 1922 if (rehash) 1923 d_rehash(rehash); 1924 if (!error) { 1925 if (new_inode != NULL) 1926 nfs_drop_nlink(new_inode); 1927 d_move(old_dentry, new_dentry); 1928 nfs_set_verifier(new_dentry, 1929 nfs_save_change_attribute(new_dir)); 1930 } else if (error == -ENOENT) 1931 nfs_dentry_handle_enoent(old_dentry); 1932 1933 /* new dentry created? */ 1934 if (dentry) 1935 dput(dentry); 1936 return error; 1937 } 1938 1939 static DEFINE_SPINLOCK(nfs_access_lru_lock); 1940 static LIST_HEAD(nfs_access_lru_list); 1941 static atomic_long_t nfs_access_nr_entries; 1942 1943 static void nfs_access_free_entry(struct nfs_access_entry *entry) 1944 { 1945 put_rpccred(entry->cred); 1946 kfree(entry); 1947 smp_mb__before_atomic_dec(); 1948 atomic_long_dec(&nfs_access_nr_entries); 1949 smp_mb__after_atomic_dec(); 1950 } 1951 1952 static void nfs_access_free_list(struct list_head *head) 1953 { 1954 struct nfs_access_entry *cache; 1955 1956 while (!list_empty(head)) { 1957 cache = list_entry(head->next, struct nfs_access_entry, lru); 1958 list_del(&cache->lru); 1959 nfs_access_free_entry(cache); 1960 } 1961 } 1962 1963 int nfs_access_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 1964 { 1965 LIST_HEAD(head); 1966 struct nfs_inode *nfsi, *next; 1967 struct nfs_access_entry *cache; 1968 1969 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 1970 return (nr_to_scan == 0) ? 0 : -1; 1971 1972 spin_lock(&nfs_access_lru_lock); 1973 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 1974 struct inode *inode; 1975 1976 if (nr_to_scan-- == 0) 1977 break; 1978 inode = &nfsi->vfs_inode; 1979 spin_lock(&inode->i_lock); 1980 if (list_empty(&nfsi->access_cache_entry_lru)) 1981 goto remove_lru_entry; 1982 cache = list_entry(nfsi->access_cache_entry_lru.next, 1983 struct nfs_access_entry, lru); 1984 list_move(&cache->lru, &head); 1985 rb_erase(&cache->rb_node, &nfsi->access_cache); 1986 if (!list_empty(&nfsi->access_cache_entry_lru)) 1987 list_move_tail(&nfsi->access_cache_inode_lru, 1988 &nfs_access_lru_list); 1989 else { 1990 remove_lru_entry: 1991 list_del_init(&nfsi->access_cache_inode_lru); 1992 smp_mb__before_clear_bit(); 1993 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 1994 smp_mb__after_clear_bit(); 1995 } 1996 spin_unlock(&inode->i_lock); 1997 } 1998 spin_unlock(&nfs_access_lru_lock); 1999 nfs_access_free_list(&head); 2000 return (atomic_long_read(&nfs_access_nr_entries) / 100) * sysctl_vfs_cache_pressure; 2001 } 2002 2003 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 2004 { 2005 struct rb_root *root_node = &nfsi->access_cache; 2006 struct rb_node *n; 2007 struct nfs_access_entry *entry; 2008 2009 /* Unhook entries from the cache */ 2010 while ((n = rb_first(root_node)) != NULL) { 2011 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2012 rb_erase(n, root_node); 2013 list_move(&entry->lru, head); 2014 } 2015 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 2016 } 2017 2018 void nfs_access_zap_cache(struct inode *inode) 2019 { 2020 LIST_HEAD(head); 2021 2022 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 2023 return; 2024 /* Remove from global LRU init */ 2025 spin_lock(&nfs_access_lru_lock); 2026 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2027 list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2028 2029 spin_lock(&inode->i_lock); 2030 __nfs_access_zap_cache(NFS_I(inode), &head); 2031 spin_unlock(&inode->i_lock); 2032 spin_unlock(&nfs_access_lru_lock); 2033 nfs_access_free_list(&head); 2034 } 2035 2036 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, struct rpc_cred *cred) 2037 { 2038 struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 2039 struct nfs_access_entry *entry; 2040 2041 while (n != NULL) { 2042 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2043 2044 if (cred < entry->cred) 2045 n = n->rb_left; 2046 else if (cred > entry->cred) 2047 n = n->rb_right; 2048 else 2049 return entry; 2050 } 2051 return NULL; 2052 } 2053 2054 static int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 2055 { 2056 struct nfs_inode *nfsi = NFS_I(inode); 2057 struct nfs_access_entry *cache; 2058 int err = -ENOENT; 2059 2060 spin_lock(&inode->i_lock); 2061 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 2062 goto out_zap; 2063 cache = nfs_access_search_rbtree(inode, cred); 2064 if (cache == NULL) 2065 goto out; 2066 if (!nfs_have_delegated_attributes(inode) && 2067 !time_in_range_open(jiffies, cache->jiffies, cache->jiffies + nfsi->attrtimeo)) 2068 goto out_stale; 2069 res->jiffies = cache->jiffies; 2070 res->cred = cache->cred; 2071 res->mask = cache->mask; 2072 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 2073 err = 0; 2074 out: 2075 spin_unlock(&inode->i_lock); 2076 return err; 2077 out_stale: 2078 rb_erase(&cache->rb_node, &nfsi->access_cache); 2079 list_del(&cache->lru); 2080 spin_unlock(&inode->i_lock); 2081 nfs_access_free_entry(cache); 2082 return -ENOENT; 2083 out_zap: 2084 spin_unlock(&inode->i_lock); 2085 nfs_access_zap_cache(inode); 2086 return -ENOENT; 2087 } 2088 2089 static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set) 2090 { 2091 struct nfs_inode *nfsi = NFS_I(inode); 2092 struct rb_root *root_node = &nfsi->access_cache; 2093 struct rb_node **p = &root_node->rb_node; 2094 struct rb_node *parent = NULL; 2095 struct nfs_access_entry *entry; 2096 2097 spin_lock(&inode->i_lock); 2098 while (*p != NULL) { 2099 parent = *p; 2100 entry = rb_entry(parent, struct nfs_access_entry, rb_node); 2101 2102 if (set->cred < entry->cred) 2103 p = &parent->rb_left; 2104 else if (set->cred > entry->cred) 2105 p = &parent->rb_right; 2106 else 2107 goto found; 2108 } 2109 rb_link_node(&set->rb_node, parent, p); 2110 rb_insert_color(&set->rb_node, root_node); 2111 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2112 spin_unlock(&inode->i_lock); 2113 return; 2114 found: 2115 rb_replace_node(parent, &set->rb_node, root_node); 2116 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 2117 list_del(&entry->lru); 2118 spin_unlock(&inode->i_lock); 2119 nfs_access_free_entry(entry); 2120 } 2121 2122 static void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 2123 { 2124 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 2125 if (cache == NULL) 2126 return; 2127 RB_CLEAR_NODE(&cache->rb_node); 2128 cache->jiffies = set->jiffies; 2129 cache->cred = get_rpccred(set->cred); 2130 cache->mask = set->mask; 2131 2132 nfs_access_add_rbtree(inode, cache); 2133 2134 /* Update accounting */ 2135 smp_mb__before_atomic_inc(); 2136 atomic_long_inc(&nfs_access_nr_entries); 2137 smp_mb__after_atomic_inc(); 2138 2139 /* Add inode to global LRU list */ 2140 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 2141 spin_lock(&nfs_access_lru_lock); 2142 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2143 list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 2144 &nfs_access_lru_list); 2145 spin_unlock(&nfs_access_lru_lock); 2146 } 2147 } 2148 2149 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 2150 { 2151 struct nfs_access_entry cache; 2152 int status; 2153 2154 status = nfs_access_get_cached(inode, cred, &cache); 2155 if (status == 0) 2156 goto out; 2157 2158 /* Be clever: ask server to check for all possible rights */ 2159 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 2160 cache.cred = cred; 2161 cache.jiffies = jiffies; 2162 status = NFS_PROTO(inode)->access(inode, &cache); 2163 if (status != 0) { 2164 if (status == -ESTALE) { 2165 nfs_zap_caches(inode); 2166 if (!S_ISDIR(inode->i_mode)) 2167 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 2168 } 2169 return status; 2170 } 2171 nfs_access_add_cache(inode, &cache); 2172 out: 2173 if ((mask & ~cache.mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2174 return 0; 2175 return -EACCES; 2176 } 2177 2178 static int nfs_open_permission_mask(int openflags) 2179 { 2180 int mask = 0; 2181 2182 if (openflags & FMODE_READ) 2183 mask |= MAY_READ; 2184 if (openflags & FMODE_WRITE) 2185 mask |= MAY_WRITE; 2186 if (openflags & FMODE_EXEC) 2187 mask |= MAY_EXEC; 2188 return mask; 2189 } 2190 2191 int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 2192 { 2193 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 2194 } 2195 2196 int nfs_permission(struct inode *inode, int mask, unsigned int flags) 2197 { 2198 struct rpc_cred *cred; 2199 int res = 0; 2200 2201 if (flags & IPERM_FLAG_RCU) 2202 return -ECHILD; 2203 2204 nfs_inc_stats(inode, NFSIOS_VFSACCESS); 2205 2206 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 2207 goto out; 2208 /* Is this sys_access() ? */ 2209 if (mask & (MAY_ACCESS | MAY_CHDIR)) 2210 goto force_lookup; 2211 2212 switch (inode->i_mode & S_IFMT) { 2213 case S_IFLNK: 2214 goto out; 2215 case S_IFREG: 2216 /* NFSv4 has atomic_open... */ 2217 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 2218 && (mask & MAY_OPEN) 2219 && !(mask & MAY_EXEC)) 2220 goto out; 2221 break; 2222 case S_IFDIR: 2223 /* 2224 * Optimize away all write operations, since the server 2225 * will check permissions when we perform the op. 2226 */ 2227 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 2228 goto out; 2229 } 2230 2231 force_lookup: 2232 if (!NFS_PROTO(inode)->access) 2233 goto out_notsup; 2234 2235 cred = rpc_lookup_cred(); 2236 if (!IS_ERR(cred)) { 2237 res = nfs_do_access(inode, cred, mask); 2238 put_rpccred(cred); 2239 } else 2240 res = PTR_ERR(cred); 2241 out: 2242 if (!res && (mask & MAY_EXEC) && !execute_ok(inode)) 2243 res = -EACCES; 2244 2245 dfprintk(VFS, "NFS: permission(%s/%ld), mask=0x%x, res=%d\n", 2246 inode->i_sb->s_id, inode->i_ino, mask, res); 2247 return res; 2248 out_notsup: 2249 res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 2250 if (res == 0) 2251 res = generic_permission(inode, mask, flags, NULL); 2252 goto out; 2253 } 2254 2255 /* 2256 * Local variables: 2257 * version-control: t 2258 * kept-new-versions: 5 2259 * End: 2260 */ 2261