1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/fs/nfs/dir.c 4 * 5 * Copyright (C) 1992 Rick Sladkey 6 * 7 * nfs directory handling functions 8 * 9 * 10 Apr 1996 Added silly rename for unlink --okir 10 * 28 Sep 1996 Improved directory cache --okir 11 * 23 Aug 1997 Claus Heine claus@momo.math.rwth-aachen.de 12 * Re-implemented silly rename for unlink, newly implemented 13 * silly rename for nfs_rename() following the suggestions 14 * of Olaf Kirch (okir) found in this file. 15 * Following Linus comments on my original hack, this version 16 * depends only on the dcache stuff and doesn't touch the inode 17 * layer (iput() and friends). 18 * 6 Jun 1999 Cache readdir lookups in the page cache. -DaveM 19 */ 20 21 #include <linux/compat.h> 22 #include <linux/module.h> 23 #include <linux/time.h> 24 #include <linux/errno.h> 25 #include <linux/stat.h> 26 #include <linux/fcntl.h> 27 #include <linux/string.h> 28 #include <linux/kernel.h> 29 #include <linux/slab.h> 30 #include <linux/mm.h> 31 #include <linux/sunrpc/clnt.h> 32 #include <linux/nfs_fs.h> 33 #include <linux/nfs_mount.h> 34 #include <linux/pagemap.h> 35 #include <linux/pagevec.h> 36 #include <linux/namei.h> 37 #include <linux/mount.h> 38 #include <linux/swap.h> 39 #include <linux/sched.h> 40 #include <linux/kmemleak.h> 41 #include <linux/xattr.h> 42 #include <linux/hash.h> 43 44 #include "delegation.h" 45 #include "iostat.h" 46 #include "internal.h" 47 #include "fscache.h" 48 49 #include "nfstrace.h" 50 51 /* #define NFS_DEBUG_VERBOSE 1 */ 52 53 static int nfs_opendir(struct inode *, struct file *); 54 static int nfs_closedir(struct inode *, struct file *); 55 static int nfs_readdir(struct file *, struct dir_context *); 56 static int nfs_fsync_dir(struct file *, loff_t, loff_t, int); 57 static loff_t nfs_llseek_dir(struct file *, loff_t, int); 58 static void nfs_readdir_free_folio(struct folio *); 59 60 const struct file_operations nfs_dir_operations = { 61 .llseek = nfs_llseek_dir, 62 .read = generic_read_dir, 63 .iterate_shared = nfs_readdir, 64 .open = nfs_opendir, 65 .release = nfs_closedir, 66 .fsync = nfs_fsync_dir, 67 }; 68 69 const struct address_space_operations nfs_dir_aops = { 70 .free_folio = nfs_readdir_free_folio, 71 }; 72 73 #define NFS_INIT_DTSIZE PAGE_SIZE 74 75 static struct nfs_open_dir_context * 76 alloc_nfs_open_dir_context(struct inode *dir) 77 { 78 struct nfs_inode *nfsi = NFS_I(dir); 79 struct nfs_open_dir_context *ctx; 80 81 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT); 82 if (ctx != NULL) { 83 ctx->attr_gencount = nfsi->attr_gencount; 84 ctx->dtsize = NFS_INIT_DTSIZE; 85 spin_lock(&dir->i_lock); 86 if (list_empty(&nfsi->open_files) && 87 (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER)) 88 nfs_set_cache_invalid(dir, 89 NFS_INO_INVALID_DATA | 90 NFS_INO_REVAL_FORCED); 91 list_add_tail_rcu(&ctx->list, &nfsi->open_files); 92 memcpy(ctx->verf, nfsi->cookieverf, sizeof(ctx->verf)); 93 spin_unlock(&dir->i_lock); 94 return ctx; 95 } 96 return ERR_PTR(-ENOMEM); 97 } 98 99 static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx) 100 { 101 spin_lock(&dir->i_lock); 102 list_del_rcu(&ctx->list); 103 spin_unlock(&dir->i_lock); 104 kfree_rcu(ctx, rcu_head); 105 } 106 107 /* 108 * Open file 109 */ 110 static int 111 nfs_opendir(struct inode *inode, struct file *filp) 112 { 113 int res = 0; 114 struct nfs_open_dir_context *ctx; 115 116 dfprintk(FILE, "NFS: open dir(%pD2)\n", filp); 117 118 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 119 120 ctx = alloc_nfs_open_dir_context(inode); 121 if (IS_ERR(ctx)) { 122 res = PTR_ERR(ctx); 123 goto out; 124 } 125 filp->private_data = ctx; 126 out: 127 return res; 128 } 129 130 static int 131 nfs_closedir(struct inode *inode, struct file *filp) 132 { 133 put_nfs_open_dir_context(file_inode(filp), filp->private_data); 134 return 0; 135 } 136 137 struct nfs_cache_array_entry { 138 u64 cookie; 139 u64 ino; 140 const char *name; 141 unsigned int name_len; 142 unsigned char d_type; 143 }; 144 145 struct nfs_cache_array { 146 u64 change_attr; 147 u64 last_cookie; 148 unsigned int size; 149 unsigned char page_full : 1, 150 page_is_eof : 1, 151 cookies_are_ordered : 1; 152 struct nfs_cache_array_entry array[]; 153 }; 154 155 struct nfs_readdir_descriptor { 156 struct file *file; 157 struct folio *folio; 158 struct dir_context *ctx; 159 pgoff_t folio_index; 160 pgoff_t folio_index_max; 161 u64 dir_cookie; 162 u64 last_cookie; 163 loff_t current_index; 164 165 __be32 verf[NFS_DIR_VERIFIER_SIZE]; 166 unsigned long dir_verifier; 167 unsigned long timestamp; 168 unsigned long gencount; 169 unsigned long attr_gencount; 170 unsigned int cache_entry_index; 171 unsigned int buffer_fills; 172 unsigned int dtsize; 173 bool clear_cache; 174 bool plus; 175 bool eob; 176 bool eof; 177 }; 178 179 static void nfs_set_dtsize(struct nfs_readdir_descriptor *desc, unsigned int sz) 180 { 181 struct nfs_server *server = NFS_SERVER(file_inode(desc->file)); 182 unsigned int maxsize = server->dtsize; 183 184 if (sz > maxsize) 185 sz = maxsize; 186 if (sz < NFS_MIN_FILE_IO_SIZE) 187 sz = NFS_MIN_FILE_IO_SIZE; 188 desc->dtsize = sz; 189 } 190 191 static void nfs_shrink_dtsize(struct nfs_readdir_descriptor *desc) 192 { 193 nfs_set_dtsize(desc, desc->dtsize >> 1); 194 } 195 196 static void nfs_grow_dtsize(struct nfs_readdir_descriptor *desc) 197 { 198 nfs_set_dtsize(desc, desc->dtsize << 1); 199 } 200 201 static void nfs_readdir_page_init_array(struct page *page, u64 last_cookie, 202 u64 change_attr) 203 { 204 struct nfs_cache_array *array; 205 206 array = kmap_local_page(page); 207 array->change_attr = change_attr; 208 array->last_cookie = last_cookie; 209 array->size = 0; 210 array->page_full = 0; 211 array->page_is_eof = 0; 212 array->cookies_are_ordered = 1; 213 kunmap_local(array); 214 } 215 216 /* 217 * we are freeing strings created by nfs_add_to_readdir_array() 218 */ 219 static void nfs_readdir_clear_array(struct page *page) 220 { 221 struct nfs_cache_array *array; 222 unsigned int i; 223 224 array = kmap_local_page(page); 225 for (i = 0; i < array->size; i++) 226 kfree(array->array[i].name); 227 array->size = 0; 228 kunmap_local(array); 229 } 230 231 static void nfs_readdir_free_folio(struct folio *folio) 232 { 233 nfs_readdir_clear_array(&folio->page); 234 } 235 236 static void nfs_readdir_page_reinit_array(struct page *page, u64 last_cookie, 237 u64 change_attr) 238 { 239 nfs_readdir_clear_array(page); 240 nfs_readdir_page_init_array(page, last_cookie, change_attr); 241 } 242 243 static struct page * 244 nfs_readdir_page_array_alloc(u64 last_cookie, gfp_t gfp_flags) 245 { 246 struct page *page = alloc_page(gfp_flags); 247 if (page) 248 nfs_readdir_page_init_array(page, last_cookie, 0); 249 return page; 250 } 251 252 static void nfs_readdir_page_array_free(struct page *page) 253 { 254 if (page) { 255 nfs_readdir_clear_array(page); 256 put_page(page); 257 } 258 } 259 260 static u64 nfs_readdir_array_index_cookie(struct nfs_cache_array *array) 261 { 262 return array->size == 0 ? array->last_cookie : array->array[0].cookie; 263 } 264 265 static void nfs_readdir_array_set_eof(struct nfs_cache_array *array) 266 { 267 array->page_is_eof = 1; 268 array->page_full = 1; 269 } 270 271 static bool nfs_readdir_array_is_full(struct nfs_cache_array *array) 272 { 273 return array->page_full; 274 } 275 276 /* 277 * the caller is responsible for freeing qstr.name 278 * when called by nfs_readdir_add_to_array, the strings will be freed in 279 * nfs_clear_readdir_array() 280 */ 281 static const char *nfs_readdir_copy_name(const char *name, unsigned int len) 282 { 283 const char *ret = kmemdup_nul(name, len, GFP_KERNEL); 284 285 /* 286 * Avoid a kmemleak false positive. The pointer to the name is stored 287 * in a page cache page which kmemleak does not scan. 288 */ 289 if (ret != NULL) 290 kmemleak_not_leak(ret); 291 return ret; 292 } 293 294 static size_t nfs_readdir_array_maxentries(void) 295 { 296 return (PAGE_SIZE - sizeof(struct nfs_cache_array)) / 297 sizeof(struct nfs_cache_array_entry); 298 } 299 300 /* 301 * Check that the next array entry lies entirely within the page bounds 302 */ 303 static int nfs_readdir_array_can_expand(struct nfs_cache_array *array) 304 { 305 if (array->page_full) 306 return -ENOSPC; 307 if (array->size == nfs_readdir_array_maxentries()) { 308 array->page_full = 1; 309 return -ENOSPC; 310 } 311 return 0; 312 } 313 314 static int nfs_readdir_page_array_append(struct page *page, 315 const struct nfs_entry *entry, 316 u64 *cookie) 317 { 318 struct nfs_cache_array *array; 319 struct nfs_cache_array_entry *cache_entry; 320 const char *name; 321 int ret = -ENOMEM; 322 323 name = nfs_readdir_copy_name(entry->name, entry->len); 324 325 array = kmap_atomic(page); 326 if (!name) 327 goto out; 328 ret = nfs_readdir_array_can_expand(array); 329 if (ret) { 330 kfree(name); 331 goto out; 332 } 333 334 cache_entry = &array->array[array->size]; 335 cache_entry->cookie = array->last_cookie; 336 cache_entry->ino = entry->ino; 337 cache_entry->d_type = entry->d_type; 338 cache_entry->name_len = entry->len; 339 cache_entry->name = name; 340 array->last_cookie = entry->cookie; 341 if (array->last_cookie <= cache_entry->cookie) 342 array->cookies_are_ordered = 0; 343 array->size++; 344 if (entry->eof != 0) 345 nfs_readdir_array_set_eof(array); 346 out: 347 *cookie = array->last_cookie; 348 kunmap_atomic(array); 349 return ret; 350 } 351 352 #define NFS_READDIR_COOKIE_MASK (U32_MAX >> 14) 353 /* 354 * Hash algorithm allowing content addressible access to sequences 355 * of directory cookies. Content is addressed by the value of the 356 * cookie index of the first readdir entry in a page. 357 * 358 * We select only the first 18 bits to avoid issues with excessive 359 * memory use for the page cache XArray. 18 bits should allow the caching 360 * of 262144 pages of sequences of readdir entries. Since each page holds 361 * 127 readdir entries for a typical 64-bit system, that works out to a 362 * cache of ~ 33 million entries per directory. 363 */ 364 static pgoff_t nfs_readdir_page_cookie_hash(u64 cookie) 365 { 366 if (cookie == 0) 367 return 0; 368 return hash_64(cookie, 18); 369 } 370 371 static bool nfs_readdir_page_validate(struct page *page, u64 last_cookie, 372 u64 change_attr) 373 { 374 struct nfs_cache_array *array = kmap_local_page(page); 375 int ret = true; 376 377 if (array->change_attr != change_attr) 378 ret = false; 379 if (nfs_readdir_array_index_cookie(array) != last_cookie) 380 ret = false; 381 kunmap_local(array); 382 return ret; 383 } 384 385 static void nfs_readdir_page_unlock_and_put(struct page *page) 386 { 387 unlock_page(page); 388 put_page(page); 389 } 390 391 static void nfs_readdir_page_init_and_validate(struct page *page, u64 cookie, 392 u64 change_attr) 393 { 394 if (PageUptodate(page)) { 395 if (nfs_readdir_page_validate(page, cookie, change_attr)) 396 return; 397 nfs_readdir_clear_array(page); 398 } 399 nfs_readdir_page_init_array(page, cookie, change_attr); 400 SetPageUptodate(page); 401 } 402 403 static struct page *nfs_readdir_page_get_locked(struct address_space *mapping, 404 u64 cookie, u64 change_attr) 405 { 406 pgoff_t index = nfs_readdir_page_cookie_hash(cookie); 407 struct page *page; 408 409 page = grab_cache_page(mapping, index); 410 if (!page) 411 return NULL; 412 nfs_readdir_page_init_and_validate(page, cookie, change_attr); 413 return page; 414 } 415 416 static u64 nfs_readdir_page_last_cookie(struct page *page) 417 { 418 struct nfs_cache_array *array; 419 u64 ret; 420 421 array = kmap_local_page(page); 422 ret = array->last_cookie; 423 kunmap_local(array); 424 return ret; 425 } 426 427 static bool nfs_readdir_page_needs_filling(struct page *page) 428 { 429 struct nfs_cache_array *array; 430 bool ret; 431 432 array = kmap_local_page(page); 433 ret = !nfs_readdir_array_is_full(array); 434 kunmap_local(array); 435 return ret; 436 } 437 438 static void nfs_readdir_page_set_eof(struct page *page) 439 { 440 struct nfs_cache_array *array; 441 442 array = kmap_local_page(page); 443 nfs_readdir_array_set_eof(array); 444 kunmap_local(array); 445 } 446 447 static struct page *nfs_readdir_page_get_next(struct address_space *mapping, 448 u64 cookie, u64 change_attr) 449 { 450 pgoff_t index = nfs_readdir_page_cookie_hash(cookie); 451 struct page *page; 452 453 page = grab_cache_page_nowait(mapping, index); 454 if (!page) 455 return NULL; 456 nfs_readdir_page_init_and_validate(page, cookie, change_attr); 457 if (nfs_readdir_page_last_cookie(page) != cookie) 458 nfs_readdir_page_reinit_array(page, cookie, change_attr); 459 return page; 460 } 461 462 static inline 463 int is_32bit_api(void) 464 { 465 #ifdef CONFIG_COMPAT 466 return in_compat_syscall(); 467 #else 468 return (BITS_PER_LONG == 32); 469 #endif 470 } 471 472 static 473 bool nfs_readdir_use_cookie(const struct file *filp) 474 { 475 if ((filp->f_mode & FMODE_32BITHASH) || 476 (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api())) 477 return false; 478 return true; 479 } 480 481 static void nfs_readdir_seek_next_array(struct nfs_cache_array *array, 482 struct nfs_readdir_descriptor *desc) 483 { 484 if (array->page_full) { 485 desc->last_cookie = array->last_cookie; 486 desc->current_index += array->size; 487 desc->cache_entry_index = 0; 488 desc->folio_index++; 489 } else 490 desc->last_cookie = nfs_readdir_array_index_cookie(array); 491 } 492 493 static void nfs_readdir_rewind_search(struct nfs_readdir_descriptor *desc) 494 { 495 desc->current_index = 0; 496 desc->last_cookie = 0; 497 desc->folio_index = 0; 498 } 499 500 static int nfs_readdir_search_for_pos(struct nfs_cache_array *array, 501 struct nfs_readdir_descriptor *desc) 502 { 503 loff_t diff = desc->ctx->pos - desc->current_index; 504 unsigned int index; 505 506 if (diff < 0) 507 goto out_eof; 508 if (diff >= array->size) { 509 if (array->page_is_eof) 510 goto out_eof; 511 nfs_readdir_seek_next_array(array, desc); 512 return -EAGAIN; 513 } 514 515 index = (unsigned int)diff; 516 desc->dir_cookie = array->array[index].cookie; 517 desc->cache_entry_index = index; 518 return 0; 519 out_eof: 520 desc->eof = true; 521 return -EBADCOOKIE; 522 } 523 524 static bool nfs_readdir_array_cookie_in_range(struct nfs_cache_array *array, 525 u64 cookie) 526 { 527 if (!array->cookies_are_ordered) 528 return true; 529 /* Optimisation for monotonically increasing cookies */ 530 if (cookie >= array->last_cookie) 531 return false; 532 if (array->size && cookie < array->array[0].cookie) 533 return false; 534 return true; 535 } 536 537 static int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, 538 struct nfs_readdir_descriptor *desc) 539 { 540 unsigned int i; 541 int status = -EAGAIN; 542 543 if (!nfs_readdir_array_cookie_in_range(array, desc->dir_cookie)) 544 goto check_eof; 545 546 for (i = 0; i < array->size; i++) { 547 if (array->array[i].cookie == desc->dir_cookie) { 548 if (nfs_readdir_use_cookie(desc->file)) 549 desc->ctx->pos = desc->dir_cookie; 550 else 551 desc->ctx->pos = desc->current_index + i; 552 desc->cache_entry_index = i; 553 return 0; 554 } 555 } 556 check_eof: 557 if (array->page_is_eof) { 558 status = -EBADCOOKIE; 559 if (desc->dir_cookie == array->last_cookie) 560 desc->eof = true; 561 } else 562 nfs_readdir_seek_next_array(array, desc); 563 return status; 564 } 565 566 static int nfs_readdir_search_array(struct nfs_readdir_descriptor *desc) 567 { 568 struct nfs_cache_array *array; 569 int status; 570 571 array = kmap_local_folio(desc->folio, 0); 572 573 if (desc->dir_cookie == 0) 574 status = nfs_readdir_search_for_pos(array, desc); 575 else 576 status = nfs_readdir_search_for_cookie(array, desc); 577 578 kunmap_local(array); 579 return status; 580 } 581 582 /* Fill a page with xdr information before transferring to the cache page */ 583 static int nfs_readdir_xdr_filler(struct nfs_readdir_descriptor *desc, 584 __be32 *verf, u64 cookie, 585 struct page **pages, size_t bufsize, 586 __be32 *verf_res) 587 { 588 struct inode *inode = file_inode(desc->file); 589 struct nfs_readdir_arg arg = { 590 .dentry = file_dentry(desc->file), 591 .cred = desc->file->f_cred, 592 .verf = verf, 593 .cookie = cookie, 594 .pages = pages, 595 .page_len = bufsize, 596 .plus = desc->plus, 597 }; 598 struct nfs_readdir_res res = { 599 .verf = verf_res, 600 }; 601 unsigned long timestamp, gencount; 602 int error; 603 604 again: 605 timestamp = jiffies; 606 gencount = nfs_inc_attr_generation_counter(); 607 desc->dir_verifier = nfs_save_change_attribute(inode); 608 error = NFS_PROTO(inode)->readdir(&arg, &res); 609 if (error < 0) { 610 /* We requested READDIRPLUS, but the server doesn't grok it */ 611 if (error == -ENOTSUPP && desc->plus) { 612 NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS; 613 desc->plus = arg.plus = false; 614 goto again; 615 } 616 goto error; 617 } 618 desc->timestamp = timestamp; 619 desc->gencount = gencount; 620 error: 621 return error; 622 } 623 624 static int xdr_decode(struct nfs_readdir_descriptor *desc, 625 struct nfs_entry *entry, struct xdr_stream *xdr) 626 { 627 struct inode *inode = file_inode(desc->file); 628 int error; 629 630 error = NFS_PROTO(inode)->decode_dirent(xdr, entry, desc->plus); 631 if (error) 632 return error; 633 entry->fattr->time_start = desc->timestamp; 634 entry->fattr->gencount = desc->gencount; 635 return 0; 636 } 637 638 /* Match file and dirent using either filehandle or fileid 639 * Note: caller is responsible for checking the fsid 640 */ 641 static 642 int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry) 643 { 644 struct inode *inode; 645 struct nfs_inode *nfsi; 646 647 if (d_really_is_negative(dentry)) 648 return 0; 649 650 inode = d_inode(dentry); 651 if (is_bad_inode(inode) || NFS_STALE(inode)) 652 return 0; 653 654 nfsi = NFS_I(inode); 655 if (entry->fattr->fileid != nfsi->fileid) 656 return 0; 657 if (entry->fh->size && nfs_compare_fh(entry->fh, &nfsi->fh) != 0) 658 return 0; 659 return 1; 660 } 661 662 #define NFS_READDIR_CACHE_USAGE_THRESHOLD (8UL) 663 664 static bool nfs_use_readdirplus(struct inode *dir, struct dir_context *ctx, 665 unsigned int cache_hits, 666 unsigned int cache_misses) 667 { 668 if (!nfs_server_capable(dir, NFS_CAP_READDIRPLUS)) 669 return false; 670 if (ctx->pos == 0 || 671 cache_hits + cache_misses > NFS_READDIR_CACHE_USAGE_THRESHOLD) 672 return true; 673 return false; 674 } 675 676 /* 677 * This function is called by the getattr code to request the 678 * use of readdirplus to accelerate any future lookups in the same 679 * directory. 680 */ 681 void nfs_readdir_record_entry_cache_hit(struct inode *dir) 682 { 683 struct nfs_inode *nfsi = NFS_I(dir); 684 struct nfs_open_dir_context *ctx; 685 686 if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) && 687 S_ISDIR(dir->i_mode)) { 688 rcu_read_lock(); 689 list_for_each_entry_rcu (ctx, &nfsi->open_files, list) 690 atomic_inc(&ctx->cache_hits); 691 rcu_read_unlock(); 692 } 693 } 694 695 /* 696 * This function is mainly for use by nfs_getattr(). 697 * 698 * If this is an 'ls -l', we want to force use of readdirplus. 699 */ 700 void nfs_readdir_record_entry_cache_miss(struct inode *dir) 701 { 702 struct nfs_inode *nfsi = NFS_I(dir); 703 struct nfs_open_dir_context *ctx; 704 705 if (nfs_server_capable(dir, NFS_CAP_READDIRPLUS) && 706 S_ISDIR(dir->i_mode)) { 707 rcu_read_lock(); 708 list_for_each_entry_rcu (ctx, &nfsi->open_files, list) 709 atomic_inc(&ctx->cache_misses); 710 rcu_read_unlock(); 711 } 712 } 713 714 static void nfs_lookup_advise_force_readdirplus(struct inode *dir, 715 unsigned int flags) 716 { 717 if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE)) 718 return; 719 if (flags & (LOOKUP_EXCL | LOOKUP_PARENT | LOOKUP_REVAL)) 720 return; 721 nfs_readdir_record_entry_cache_miss(dir); 722 } 723 724 static 725 void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry, 726 unsigned long dir_verifier) 727 { 728 struct qstr filename = QSTR_INIT(entry->name, entry->len); 729 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 730 struct dentry *dentry; 731 struct dentry *alias; 732 struct inode *inode; 733 int status; 734 735 if (!(entry->fattr->valid & NFS_ATTR_FATTR_FILEID)) 736 return; 737 if (!(entry->fattr->valid & NFS_ATTR_FATTR_FSID)) 738 return; 739 if (filename.len == 0) 740 return; 741 /* Validate that the name doesn't contain any illegal '\0' */ 742 if (strnlen(filename.name, filename.len) != filename.len) 743 return; 744 /* ...or '/' */ 745 if (strnchr(filename.name, filename.len, '/')) 746 return; 747 if (filename.name[0] == '.') { 748 if (filename.len == 1) 749 return; 750 if (filename.len == 2 && filename.name[1] == '.') 751 return; 752 } 753 filename.hash = full_name_hash(parent, filename.name, filename.len); 754 755 dentry = d_lookup(parent, &filename); 756 again: 757 if (!dentry) { 758 dentry = d_alloc_parallel(parent, &filename, &wq); 759 if (IS_ERR(dentry)) 760 return; 761 } 762 if (!d_in_lookup(dentry)) { 763 /* Is there a mountpoint here? If so, just exit */ 764 if (!nfs_fsid_equal(&NFS_SB(dentry->d_sb)->fsid, 765 &entry->fattr->fsid)) 766 goto out; 767 if (nfs_same_file(dentry, entry)) { 768 if (!entry->fh->size) 769 goto out; 770 nfs_set_verifier(dentry, dir_verifier); 771 status = nfs_refresh_inode(d_inode(dentry), entry->fattr); 772 if (!status) 773 nfs_setsecurity(d_inode(dentry), entry->fattr); 774 trace_nfs_readdir_lookup_revalidate(d_inode(parent), 775 dentry, 0, status); 776 goto out; 777 } else { 778 trace_nfs_readdir_lookup_revalidate_failed( 779 d_inode(parent), dentry, 0); 780 d_invalidate(dentry); 781 dput(dentry); 782 dentry = NULL; 783 goto again; 784 } 785 } 786 if (!entry->fh->size) { 787 d_lookup_done(dentry); 788 goto out; 789 } 790 791 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr); 792 alias = d_splice_alias(inode, dentry); 793 d_lookup_done(dentry); 794 if (alias) { 795 if (IS_ERR(alias)) 796 goto out; 797 dput(dentry); 798 dentry = alias; 799 } 800 nfs_set_verifier(dentry, dir_verifier); 801 trace_nfs_readdir_lookup(d_inode(parent), dentry, 0); 802 out: 803 dput(dentry); 804 } 805 806 static int nfs_readdir_entry_decode(struct nfs_readdir_descriptor *desc, 807 struct nfs_entry *entry, 808 struct xdr_stream *stream) 809 { 810 int ret; 811 812 if (entry->fattr->label) 813 entry->fattr->label->len = NFS4_MAXLABELLEN; 814 ret = xdr_decode(desc, entry, stream); 815 if (ret || !desc->plus) 816 return ret; 817 nfs_prime_dcache(file_dentry(desc->file), entry, desc->dir_verifier); 818 return 0; 819 } 820 821 /* Perform conversion from xdr to cache array */ 822 static int nfs_readdir_folio_filler(struct nfs_readdir_descriptor *desc, 823 struct nfs_entry *entry, 824 struct page **xdr_pages, unsigned int buflen, 825 struct folio **arrays, size_t narrays, 826 u64 change_attr) 827 { 828 struct address_space *mapping = desc->file->f_mapping; 829 struct folio *folio = *arrays; 830 struct xdr_stream stream; 831 struct page *scratch, *new; 832 struct xdr_buf buf; 833 u64 cookie; 834 int status; 835 836 scratch = alloc_page(GFP_KERNEL); 837 if (scratch == NULL) 838 return -ENOMEM; 839 840 xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen); 841 xdr_set_scratch_page(&stream, scratch); 842 843 do { 844 status = nfs_readdir_entry_decode(desc, entry, &stream); 845 if (status != 0) 846 break; 847 848 status = nfs_readdir_page_array_append(folio_page(folio, 0), entry, &cookie); 849 if (status != -ENOSPC) 850 continue; 851 852 if (folio->mapping != mapping) { 853 if (!--narrays) 854 break; 855 new = nfs_readdir_page_array_alloc(cookie, GFP_KERNEL); 856 if (!new) 857 break; 858 arrays++; 859 *arrays = folio = page_folio(new); 860 } else { 861 new = nfs_readdir_page_get_next(mapping, cookie, 862 change_attr); 863 if (!new) 864 break; 865 if (folio != *arrays) 866 nfs_readdir_page_unlock_and_put(folio_page(folio, 0)); 867 folio = page_folio(new); 868 } 869 desc->folio_index_max++; 870 status = nfs_readdir_page_array_append(folio_page(folio, 0), entry, &cookie); 871 } while (!status && !entry->eof); 872 873 switch (status) { 874 case -EBADCOOKIE: 875 if (!entry->eof) 876 break; 877 nfs_readdir_page_set_eof(folio_page(folio, 0)); 878 fallthrough; 879 case -EAGAIN: 880 status = 0; 881 break; 882 case -ENOSPC: 883 status = 0; 884 if (!desc->plus) 885 break; 886 while (!nfs_readdir_entry_decode(desc, entry, &stream)) 887 ; 888 } 889 890 if (folio != *arrays) 891 nfs_readdir_page_unlock_and_put(folio_page(folio, 0)); 892 893 put_page(scratch); 894 return status; 895 } 896 897 static void nfs_readdir_free_pages(struct page **pages, size_t npages) 898 { 899 while (npages--) 900 put_page(pages[npages]); 901 kfree(pages); 902 } 903 904 /* 905 * nfs_readdir_alloc_pages() will allocate pages that must be freed with a call 906 * to nfs_readdir_free_pages() 907 */ 908 static struct page **nfs_readdir_alloc_pages(size_t npages) 909 { 910 struct page **pages; 911 size_t i; 912 913 pages = kmalloc_array(npages, sizeof(*pages), GFP_KERNEL); 914 if (!pages) 915 return NULL; 916 for (i = 0; i < npages; i++) { 917 struct page *page = alloc_page(GFP_KERNEL); 918 if (page == NULL) 919 goto out_freepages; 920 pages[i] = page; 921 } 922 return pages; 923 924 out_freepages: 925 nfs_readdir_free_pages(pages, i); 926 return NULL; 927 } 928 929 static int nfs_readdir_xdr_to_array(struct nfs_readdir_descriptor *desc, 930 __be32 *verf_arg, __be32 *verf_res, 931 struct folio **arrays, size_t narrays) 932 { 933 u64 change_attr; 934 struct page **pages; 935 struct folio *folio = *arrays; 936 struct nfs_entry *entry; 937 size_t array_size; 938 struct inode *inode = file_inode(desc->file); 939 unsigned int dtsize = desc->dtsize; 940 unsigned int pglen; 941 int status = -ENOMEM; 942 943 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 944 if (!entry) 945 return -ENOMEM; 946 entry->cookie = nfs_readdir_page_last_cookie(folio_page(folio, 0)); 947 entry->fh = nfs_alloc_fhandle(); 948 entry->fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 949 entry->server = NFS_SERVER(inode); 950 if (entry->fh == NULL || entry->fattr == NULL) 951 goto out; 952 953 array_size = (dtsize + PAGE_SIZE - 1) >> PAGE_SHIFT; 954 pages = nfs_readdir_alloc_pages(array_size); 955 if (!pages) 956 goto out; 957 958 change_attr = inode_peek_iversion_raw(inode); 959 status = nfs_readdir_xdr_filler(desc, verf_arg, entry->cookie, pages, 960 dtsize, verf_res); 961 if (status < 0) 962 goto free_pages; 963 964 pglen = status; 965 if (pglen != 0) 966 status = nfs_readdir_folio_filler(desc, entry, pages, pglen, 967 arrays, narrays, change_attr); 968 else 969 nfs_readdir_page_set_eof(folio_page(folio, 0)); 970 desc->buffer_fills++; 971 972 free_pages: 973 nfs_readdir_free_pages(pages, array_size); 974 out: 975 nfs_free_fattr(entry->fattr); 976 nfs_free_fhandle(entry->fh); 977 kfree(entry); 978 return status; 979 } 980 981 static void nfs_readdir_folio_put(struct nfs_readdir_descriptor *desc) 982 { 983 folio_put(desc->folio); 984 desc->folio = NULL; 985 } 986 987 static void 988 nfs_readdir_folio_unlock_and_put_cached(struct nfs_readdir_descriptor *desc) 989 { 990 folio_unlock(desc->folio); 991 nfs_readdir_folio_put(desc); 992 } 993 994 static struct folio * 995 nfs_readdir_folio_get_cached(struct nfs_readdir_descriptor *desc) 996 { 997 struct address_space *mapping = desc->file->f_mapping; 998 u64 change_attr = inode_peek_iversion_raw(mapping->host); 999 u64 cookie = desc->last_cookie; 1000 struct page *page; 1001 1002 page = nfs_readdir_page_get_locked(mapping, cookie, change_attr); 1003 if (!page) 1004 return NULL; 1005 if (desc->clear_cache && !nfs_readdir_page_needs_filling(page)) 1006 nfs_readdir_page_reinit_array(page, cookie, change_attr); 1007 return page_folio(page); 1008 } 1009 1010 /* 1011 * Returns 0 if desc->dir_cookie was found on page desc->page_index 1012 * and locks the page to prevent removal from the page cache. 1013 */ 1014 static int find_and_lock_cache_page(struct nfs_readdir_descriptor *desc) 1015 { 1016 struct inode *inode = file_inode(desc->file); 1017 struct nfs_inode *nfsi = NFS_I(inode); 1018 __be32 verf[NFS_DIR_VERIFIER_SIZE]; 1019 int res; 1020 1021 desc->folio = nfs_readdir_folio_get_cached(desc); 1022 if (!desc->folio) 1023 return -ENOMEM; 1024 if (nfs_readdir_page_needs_filling(folio_page(desc->folio, 0))) { 1025 /* Grow the dtsize if we had to go back for more pages */ 1026 if (desc->folio_index == desc->folio_index_max) 1027 nfs_grow_dtsize(desc); 1028 desc->folio_index_max = desc->folio_index; 1029 trace_nfs_readdir_cache_fill(desc->file, nfsi->cookieverf, 1030 desc->last_cookie, 1031 desc->folio->index, desc->dtsize); 1032 res = nfs_readdir_xdr_to_array(desc, nfsi->cookieverf, verf, 1033 &desc->folio, 1); 1034 if (res < 0) { 1035 nfs_readdir_folio_unlock_and_put_cached(desc); 1036 trace_nfs_readdir_cache_fill_done(inode, res); 1037 if (res == -EBADCOOKIE || res == -ENOTSYNC) { 1038 invalidate_inode_pages2(desc->file->f_mapping); 1039 nfs_readdir_rewind_search(desc); 1040 trace_nfs_readdir_invalidate_cache_range( 1041 inode, 0, MAX_LFS_FILESIZE); 1042 return -EAGAIN; 1043 } 1044 return res; 1045 } 1046 /* 1047 * Set the cookie verifier if the page cache was empty 1048 */ 1049 if (desc->last_cookie == 0 && 1050 memcmp(nfsi->cookieverf, verf, sizeof(nfsi->cookieverf))) { 1051 memcpy(nfsi->cookieverf, verf, 1052 sizeof(nfsi->cookieverf)); 1053 invalidate_inode_pages2_range(desc->file->f_mapping, 1, 1054 -1); 1055 trace_nfs_readdir_invalidate_cache_range( 1056 inode, 1, MAX_LFS_FILESIZE); 1057 } 1058 desc->clear_cache = false; 1059 } 1060 res = nfs_readdir_search_array(desc); 1061 if (res == 0) 1062 return 0; 1063 nfs_readdir_folio_unlock_and_put_cached(desc); 1064 return res; 1065 } 1066 1067 /* Search for desc->dir_cookie from the beginning of the page cache */ 1068 static int readdir_search_pagecache(struct nfs_readdir_descriptor *desc) 1069 { 1070 int res; 1071 1072 do { 1073 res = find_and_lock_cache_page(desc); 1074 } while (res == -EAGAIN); 1075 return res; 1076 } 1077 1078 #define NFS_READDIR_CACHE_MISS_THRESHOLD (16UL) 1079 1080 /* 1081 * Once we've found the start of the dirent within a page: fill 'er up... 1082 */ 1083 static void nfs_do_filldir(struct nfs_readdir_descriptor *desc, 1084 const __be32 *verf) 1085 { 1086 struct file *file = desc->file; 1087 struct nfs_cache_array *array; 1088 unsigned int i; 1089 bool first_emit = !desc->dir_cookie; 1090 1091 array = kmap_local_folio(desc->folio, 0); 1092 for (i = desc->cache_entry_index; i < array->size; i++) { 1093 struct nfs_cache_array_entry *ent; 1094 1095 ent = &array->array[i]; 1096 if (!dir_emit(desc->ctx, ent->name, ent->name_len, 1097 nfs_compat_user_ino64(ent->ino), ent->d_type)) { 1098 desc->eob = true; 1099 break; 1100 } 1101 memcpy(desc->verf, verf, sizeof(desc->verf)); 1102 if (i == array->size - 1) { 1103 desc->dir_cookie = array->last_cookie; 1104 nfs_readdir_seek_next_array(array, desc); 1105 } else { 1106 desc->dir_cookie = array->array[i + 1].cookie; 1107 desc->last_cookie = array->array[0].cookie; 1108 } 1109 if (nfs_readdir_use_cookie(file)) 1110 desc->ctx->pos = desc->dir_cookie; 1111 else 1112 desc->ctx->pos++; 1113 if (first_emit && i > NFS_READDIR_CACHE_MISS_THRESHOLD + 1) { 1114 desc->eob = true; 1115 break; 1116 } 1117 } 1118 if (array->page_is_eof) 1119 desc->eof = !desc->eob; 1120 1121 kunmap_local(array); 1122 dfprintk(DIRCACHE, "NFS: nfs_do_filldir() filling ended @ cookie %llu\n", 1123 (unsigned long long)desc->dir_cookie); 1124 } 1125 1126 /* 1127 * If we cannot find a cookie in our cache, we suspect that this is 1128 * because it points to a deleted file, so we ask the server to return 1129 * whatever it thinks is the next entry. We then feed this to filldir. 1130 * If all goes well, we should then be able to find our way round the 1131 * cache on the next call to readdir_search_pagecache(); 1132 * 1133 * NOTE: we cannot add the anonymous page to the pagecache because 1134 * the data it contains might not be page aligned. Besides, 1135 * we should already have a complete representation of the 1136 * directory in the page cache by the time we get here. 1137 */ 1138 static int uncached_readdir(struct nfs_readdir_descriptor *desc) 1139 { 1140 struct folio **arrays; 1141 size_t i, sz = 512; 1142 __be32 verf[NFS_DIR_VERIFIER_SIZE]; 1143 int status = -ENOMEM; 1144 1145 dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %llu\n", 1146 (unsigned long long)desc->dir_cookie); 1147 1148 arrays = kcalloc(sz, sizeof(*arrays), GFP_KERNEL); 1149 if (!arrays) 1150 goto out; 1151 arrays[0] = page_folio(nfs_readdir_page_array_alloc(desc->dir_cookie, GFP_KERNEL)); 1152 if (!arrays[0]) 1153 goto out; 1154 1155 desc->folio_index = 0; 1156 desc->cache_entry_index = 0; 1157 desc->last_cookie = desc->dir_cookie; 1158 desc->folio_index_max = 0; 1159 1160 trace_nfs_readdir_uncached(desc->file, desc->verf, desc->last_cookie, 1161 -1, desc->dtsize); 1162 1163 status = nfs_readdir_xdr_to_array(desc, desc->verf, verf, arrays, sz); 1164 if (status < 0) { 1165 trace_nfs_readdir_uncached_done(file_inode(desc->file), status); 1166 goto out_free; 1167 } 1168 1169 for (i = 0; !desc->eob && i < sz && arrays[i]; i++) { 1170 desc->folio = arrays[i]; 1171 nfs_do_filldir(desc, verf); 1172 } 1173 desc->folio = NULL; 1174 1175 /* 1176 * Grow the dtsize if we have to go back for more pages, 1177 * or shrink it if we're reading too many. 1178 */ 1179 if (!desc->eof) { 1180 if (!desc->eob) 1181 nfs_grow_dtsize(desc); 1182 else if (desc->buffer_fills == 1 && 1183 i < (desc->folio_index_max >> 1)) 1184 nfs_shrink_dtsize(desc); 1185 } 1186 out_free: 1187 for (i = 0; i < sz && arrays[i]; i++) 1188 nfs_readdir_page_array_free(folio_page(arrays[i], 0)); 1189 out: 1190 if (!nfs_readdir_use_cookie(desc->file)) 1191 nfs_readdir_rewind_search(desc); 1192 desc->folio_index_max = -1; 1193 kfree(arrays); 1194 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, status); 1195 return status; 1196 } 1197 1198 static bool nfs_readdir_handle_cache_misses(struct inode *inode, 1199 struct nfs_readdir_descriptor *desc, 1200 unsigned int cache_misses, 1201 bool force_clear) 1202 { 1203 if (desc->ctx->pos == 0 || !desc->plus) 1204 return false; 1205 if (cache_misses <= NFS_READDIR_CACHE_MISS_THRESHOLD && !force_clear) 1206 return false; 1207 trace_nfs_readdir_force_readdirplus(inode); 1208 return true; 1209 } 1210 1211 /* The file offset position represents the dirent entry number. A 1212 last cookie cache takes care of the common case of reading the 1213 whole directory. 1214 */ 1215 static int nfs_readdir(struct file *file, struct dir_context *ctx) 1216 { 1217 struct dentry *dentry = file_dentry(file); 1218 struct inode *inode = d_inode(dentry); 1219 struct nfs_inode *nfsi = NFS_I(inode); 1220 struct nfs_open_dir_context *dir_ctx = file->private_data; 1221 struct nfs_readdir_descriptor *desc; 1222 unsigned int cache_hits, cache_misses; 1223 bool force_clear; 1224 int res; 1225 1226 dfprintk(FILE, "NFS: readdir(%pD2) starting at cookie %llu\n", 1227 file, (long long)ctx->pos); 1228 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 1229 1230 /* 1231 * ctx->pos points to the dirent entry number. 1232 * *desc->dir_cookie has the cookie for the next entry. We have 1233 * to either find the entry with the appropriate number or 1234 * revalidate the cookie. 1235 */ 1236 nfs_revalidate_mapping(inode, file->f_mapping); 1237 1238 res = -ENOMEM; 1239 desc = kzalloc(sizeof(*desc), GFP_KERNEL); 1240 if (!desc) 1241 goto out; 1242 desc->file = file; 1243 desc->ctx = ctx; 1244 desc->folio_index_max = -1; 1245 1246 spin_lock(&file->f_lock); 1247 desc->dir_cookie = dir_ctx->dir_cookie; 1248 desc->folio_index = dir_ctx->page_index; 1249 desc->last_cookie = dir_ctx->last_cookie; 1250 desc->attr_gencount = dir_ctx->attr_gencount; 1251 desc->eof = dir_ctx->eof; 1252 nfs_set_dtsize(desc, dir_ctx->dtsize); 1253 memcpy(desc->verf, dir_ctx->verf, sizeof(desc->verf)); 1254 cache_hits = atomic_xchg(&dir_ctx->cache_hits, 0); 1255 cache_misses = atomic_xchg(&dir_ctx->cache_misses, 0); 1256 force_clear = dir_ctx->force_clear; 1257 spin_unlock(&file->f_lock); 1258 1259 if (desc->eof) { 1260 res = 0; 1261 goto out_free; 1262 } 1263 1264 desc->plus = nfs_use_readdirplus(inode, ctx, cache_hits, cache_misses); 1265 force_clear = nfs_readdir_handle_cache_misses(inode, desc, cache_misses, 1266 force_clear); 1267 desc->clear_cache = force_clear; 1268 1269 do { 1270 res = readdir_search_pagecache(desc); 1271 1272 if (res == -EBADCOOKIE) { 1273 res = 0; 1274 /* This means either end of directory */ 1275 if (desc->dir_cookie && !desc->eof) { 1276 /* Or that the server has 'lost' a cookie */ 1277 res = uncached_readdir(desc); 1278 if (res == 0) 1279 continue; 1280 if (res == -EBADCOOKIE || res == -ENOTSYNC) 1281 res = 0; 1282 } 1283 break; 1284 } 1285 if (res == -ETOOSMALL && desc->plus) { 1286 nfs_zap_caches(inode); 1287 desc->plus = false; 1288 desc->eof = false; 1289 continue; 1290 } 1291 if (res < 0) 1292 break; 1293 1294 nfs_do_filldir(desc, nfsi->cookieverf); 1295 nfs_readdir_folio_unlock_and_put_cached(desc); 1296 if (desc->folio_index == desc->folio_index_max) 1297 desc->clear_cache = force_clear; 1298 } while (!desc->eob && !desc->eof); 1299 1300 spin_lock(&file->f_lock); 1301 dir_ctx->dir_cookie = desc->dir_cookie; 1302 dir_ctx->last_cookie = desc->last_cookie; 1303 dir_ctx->attr_gencount = desc->attr_gencount; 1304 dir_ctx->page_index = desc->folio_index; 1305 dir_ctx->force_clear = force_clear; 1306 dir_ctx->eof = desc->eof; 1307 dir_ctx->dtsize = desc->dtsize; 1308 memcpy(dir_ctx->verf, desc->verf, sizeof(dir_ctx->verf)); 1309 spin_unlock(&file->f_lock); 1310 out_free: 1311 kfree(desc); 1312 1313 out: 1314 dfprintk(FILE, "NFS: readdir(%pD2) returns %d\n", file, res); 1315 return res; 1316 } 1317 1318 static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int whence) 1319 { 1320 struct nfs_open_dir_context *dir_ctx = filp->private_data; 1321 1322 dfprintk(FILE, "NFS: llseek dir(%pD2, %lld, %d)\n", 1323 filp, offset, whence); 1324 1325 switch (whence) { 1326 default: 1327 return -EINVAL; 1328 case SEEK_SET: 1329 if (offset < 0) 1330 return -EINVAL; 1331 spin_lock(&filp->f_lock); 1332 break; 1333 case SEEK_CUR: 1334 if (offset == 0) 1335 return filp->f_pos; 1336 spin_lock(&filp->f_lock); 1337 offset += filp->f_pos; 1338 if (offset < 0) { 1339 spin_unlock(&filp->f_lock); 1340 return -EINVAL; 1341 } 1342 } 1343 if (offset != filp->f_pos) { 1344 filp->f_pos = offset; 1345 dir_ctx->page_index = 0; 1346 if (!nfs_readdir_use_cookie(filp)) { 1347 dir_ctx->dir_cookie = 0; 1348 dir_ctx->last_cookie = 0; 1349 } else { 1350 dir_ctx->dir_cookie = offset; 1351 dir_ctx->last_cookie = offset; 1352 } 1353 dir_ctx->eof = false; 1354 } 1355 spin_unlock(&filp->f_lock); 1356 return offset; 1357 } 1358 1359 /* 1360 * All directory operations under NFS are synchronous, so fsync() 1361 * is a dummy operation. 1362 */ 1363 static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end, 1364 int datasync) 1365 { 1366 dfprintk(FILE, "NFS: fsync dir(%pD2) datasync %d\n", filp, datasync); 1367 1368 nfs_inc_stats(file_inode(filp), NFSIOS_VFSFSYNC); 1369 return 0; 1370 } 1371 1372 /** 1373 * nfs_force_lookup_revalidate - Mark the directory as having changed 1374 * @dir: pointer to directory inode 1375 * 1376 * This forces the revalidation code in nfs_lookup_revalidate() to do a 1377 * full lookup on all child dentries of 'dir' whenever a change occurs 1378 * on the server that might have invalidated our dcache. 1379 * 1380 * Note that we reserve bit '0' as a tag to let us know when a dentry 1381 * was revalidated while holding a delegation on its inode. 1382 * 1383 * The caller should be holding dir->i_lock 1384 */ 1385 void nfs_force_lookup_revalidate(struct inode *dir) 1386 { 1387 NFS_I(dir)->cache_change_attribute += 2; 1388 } 1389 EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate); 1390 1391 /** 1392 * nfs_verify_change_attribute - Detects NFS remote directory changes 1393 * @dir: pointer to parent directory inode 1394 * @verf: previously saved change attribute 1395 * 1396 * Return "false" if the verifiers doesn't match the change attribute. 1397 * This would usually indicate that the directory contents have changed on 1398 * the server, and that any dentries need revalidating. 1399 */ 1400 static bool nfs_verify_change_attribute(struct inode *dir, unsigned long verf) 1401 { 1402 return (verf & ~1UL) == nfs_save_change_attribute(dir); 1403 } 1404 1405 static void nfs_set_verifier_delegated(unsigned long *verf) 1406 { 1407 *verf |= 1UL; 1408 } 1409 1410 #if IS_ENABLED(CONFIG_NFS_V4) 1411 static void nfs_unset_verifier_delegated(unsigned long *verf) 1412 { 1413 *verf &= ~1UL; 1414 } 1415 #endif /* IS_ENABLED(CONFIG_NFS_V4) */ 1416 1417 static bool nfs_test_verifier_delegated(unsigned long verf) 1418 { 1419 return verf & 1; 1420 } 1421 1422 static bool nfs_verifier_is_delegated(struct dentry *dentry) 1423 { 1424 return nfs_test_verifier_delegated(dentry->d_time); 1425 } 1426 1427 static void nfs_set_verifier_locked(struct dentry *dentry, unsigned long verf) 1428 { 1429 struct inode *inode = d_inode(dentry); 1430 struct inode *dir = d_inode(dentry->d_parent); 1431 1432 if (!nfs_verify_change_attribute(dir, verf)) 1433 return; 1434 if (inode && NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) 1435 nfs_set_verifier_delegated(&verf); 1436 dentry->d_time = verf; 1437 } 1438 1439 /** 1440 * nfs_set_verifier - save a parent directory verifier in the dentry 1441 * @dentry: pointer to dentry 1442 * @verf: verifier to save 1443 * 1444 * Saves the parent directory verifier in @dentry. If the inode has 1445 * a delegation, we also tag the dentry as having been revalidated 1446 * while holding a delegation so that we know we don't have to 1447 * look it up again after a directory change. 1448 */ 1449 void nfs_set_verifier(struct dentry *dentry, unsigned long verf) 1450 { 1451 1452 spin_lock(&dentry->d_lock); 1453 nfs_set_verifier_locked(dentry, verf); 1454 spin_unlock(&dentry->d_lock); 1455 } 1456 EXPORT_SYMBOL_GPL(nfs_set_verifier); 1457 1458 #if IS_ENABLED(CONFIG_NFS_V4) 1459 /** 1460 * nfs_clear_verifier_delegated - clear the dir verifier delegation tag 1461 * @inode: pointer to inode 1462 * 1463 * Iterates through the dentries in the inode alias list and clears 1464 * the tag used to indicate that the dentry has been revalidated 1465 * while holding a delegation. 1466 * This function is intended for use when the delegation is being 1467 * returned or revoked. 1468 */ 1469 void nfs_clear_verifier_delegated(struct inode *inode) 1470 { 1471 struct dentry *alias; 1472 1473 if (!inode) 1474 return; 1475 spin_lock(&inode->i_lock); 1476 hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) { 1477 spin_lock(&alias->d_lock); 1478 nfs_unset_verifier_delegated(&alias->d_time); 1479 spin_unlock(&alias->d_lock); 1480 } 1481 spin_unlock(&inode->i_lock); 1482 } 1483 EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated); 1484 #endif /* IS_ENABLED(CONFIG_NFS_V4) */ 1485 1486 static int nfs_dentry_verify_change(struct inode *dir, struct dentry *dentry) 1487 { 1488 if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE) && 1489 d_really_is_negative(dentry)) 1490 return dentry->d_time == inode_peek_iversion_raw(dir); 1491 return nfs_verify_change_attribute(dir, dentry->d_time); 1492 } 1493 1494 /* 1495 * A check for whether or not the parent directory has changed. 1496 * In the case it has, we assume that the dentries are untrustworthy 1497 * and may need to be looked up again. 1498 * If rcu_walk prevents us from performing a full check, return 0. 1499 */ 1500 static int nfs_check_verifier(struct inode *dir, struct dentry *dentry, 1501 int rcu_walk) 1502 { 1503 if (IS_ROOT(dentry)) 1504 return 1; 1505 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) 1506 return 0; 1507 if (!nfs_dentry_verify_change(dir, dentry)) 1508 return 0; 1509 /* Revalidate nfsi->cache_change_attribute before we declare a match */ 1510 if (nfs_mapping_need_revalidate_inode(dir)) { 1511 if (rcu_walk) 1512 return 0; 1513 if (__nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 1514 return 0; 1515 } 1516 if (!nfs_dentry_verify_change(dir, dentry)) 1517 return 0; 1518 return 1; 1519 } 1520 1521 /* 1522 * Use intent information to check whether or not we're going to do 1523 * an O_EXCL create using this path component. 1524 */ 1525 static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags) 1526 { 1527 if (NFS_PROTO(dir)->version == 2) 1528 return 0; 1529 return flags & LOOKUP_EXCL; 1530 } 1531 1532 /* 1533 * Inode and filehandle revalidation for lookups. 1534 * 1535 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 1536 * or if the intent information indicates that we're about to open this 1537 * particular file and the "nocto" mount flag is not set. 1538 * 1539 */ 1540 static 1541 int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags) 1542 { 1543 struct nfs_server *server = NFS_SERVER(inode); 1544 int ret; 1545 1546 if (IS_AUTOMOUNT(inode)) 1547 return 0; 1548 1549 if (flags & LOOKUP_OPEN) { 1550 switch (inode->i_mode & S_IFMT) { 1551 case S_IFREG: 1552 /* A NFSv4 OPEN will revalidate later */ 1553 if (server->caps & NFS_CAP_ATOMIC_OPEN) 1554 goto out; 1555 fallthrough; 1556 case S_IFDIR: 1557 if (server->flags & NFS_MOUNT_NOCTO) 1558 break; 1559 /* NFS close-to-open cache consistency validation */ 1560 goto out_force; 1561 } 1562 } 1563 1564 /* VFS wants an on-the-wire revalidation */ 1565 if (flags & LOOKUP_REVAL) 1566 goto out_force; 1567 out: 1568 if (inode->i_nlink > 0 || 1569 (inode->i_nlink == 0 && 1570 test_bit(NFS_INO_PRESERVE_UNLINKED, &NFS_I(inode)->flags))) 1571 return 0; 1572 else 1573 return -ESTALE; 1574 out_force: 1575 if (flags & LOOKUP_RCU) 1576 return -ECHILD; 1577 ret = __nfs_revalidate_inode(server, inode); 1578 if (ret != 0) 1579 return ret; 1580 goto out; 1581 } 1582 1583 static void nfs_mark_dir_for_revalidate(struct inode *inode) 1584 { 1585 spin_lock(&inode->i_lock); 1586 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE); 1587 spin_unlock(&inode->i_lock); 1588 } 1589 1590 /* 1591 * We judge how long we want to trust negative 1592 * dentries by looking at the parent inode mtime. 1593 * 1594 * If parent mtime has changed, we revalidate, else we wait for a 1595 * period corresponding to the parent's attribute cache timeout value. 1596 * 1597 * If LOOKUP_RCU prevents us from performing a full check, return 1 1598 * suggesting a reval is needed. 1599 * 1600 * Note that when creating a new file, or looking up a rename target, 1601 * then it shouldn't be necessary to revalidate a negative dentry. 1602 */ 1603 static inline 1604 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 1605 unsigned int flags) 1606 { 1607 if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET)) 1608 return 0; 1609 if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) 1610 return 1; 1611 /* Case insensitive server? Revalidate negative dentries */ 1612 if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE)) 1613 return 1; 1614 return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU); 1615 } 1616 1617 static int 1618 nfs_lookup_revalidate_done(struct inode *dir, struct dentry *dentry, 1619 struct inode *inode, int error) 1620 { 1621 switch (error) { 1622 case 1: 1623 break; 1624 case 0: 1625 /* 1626 * We can't d_drop the root of a disconnected tree: 1627 * its d_hash is on the s_anon list and d_drop() would hide 1628 * it from shrink_dcache_for_unmount(), leading to busy 1629 * inodes on unmount and further oopses. 1630 */ 1631 if (inode && IS_ROOT(dentry)) 1632 error = 1; 1633 break; 1634 } 1635 trace_nfs_lookup_revalidate_exit(dir, dentry, 0, error); 1636 return error; 1637 } 1638 1639 static int 1640 nfs_lookup_revalidate_negative(struct inode *dir, struct dentry *dentry, 1641 unsigned int flags) 1642 { 1643 int ret = 1; 1644 if (nfs_neg_need_reval(dir, dentry, flags)) { 1645 if (flags & LOOKUP_RCU) 1646 return -ECHILD; 1647 ret = 0; 1648 } 1649 return nfs_lookup_revalidate_done(dir, dentry, NULL, ret); 1650 } 1651 1652 static int 1653 nfs_lookup_revalidate_delegated(struct inode *dir, struct dentry *dentry, 1654 struct inode *inode) 1655 { 1656 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1657 return nfs_lookup_revalidate_done(dir, dentry, inode, 1); 1658 } 1659 1660 static int nfs_lookup_revalidate_dentry(struct inode *dir, 1661 struct dentry *dentry, 1662 struct inode *inode, unsigned int flags) 1663 { 1664 struct nfs_fh *fhandle; 1665 struct nfs_fattr *fattr; 1666 unsigned long dir_verifier; 1667 int ret; 1668 1669 trace_nfs_lookup_revalidate_enter(dir, dentry, flags); 1670 1671 ret = -ENOMEM; 1672 fhandle = nfs_alloc_fhandle(); 1673 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode)); 1674 if (fhandle == NULL || fattr == NULL) 1675 goto out; 1676 1677 dir_verifier = nfs_save_change_attribute(dir); 1678 ret = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr); 1679 if (ret < 0) { 1680 switch (ret) { 1681 case -ESTALE: 1682 case -ENOENT: 1683 ret = 0; 1684 break; 1685 case -ETIMEDOUT: 1686 if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL) 1687 ret = 1; 1688 } 1689 goto out; 1690 } 1691 1692 /* Request help from readdirplus */ 1693 nfs_lookup_advise_force_readdirplus(dir, flags); 1694 1695 ret = 0; 1696 if (nfs_compare_fh(NFS_FH(inode), fhandle)) 1697 goto out; 1698 if (nfs_refresh_inode(inode, fattr) < 0) 1699 goto out; 1700 1701 nfs_setsecurity(inode, fattr); 1702 nfs_set_verifier(dentry, dir_verifier); 1703 1704 ret = 1; 1705 out: 1706 nfs_free_fattr(fattr); 1707 nfs_free_fhandle(fhandle); 1708 1709 /* 1710 * If the lookup failed despite the dentry change attribute being 1711 * a match, then we should revalidate the directory cache. 1712 */ 1713 if (!ret && nfs_dentry_verify_change(dir, dentry)) 1714 nfs_mark_dir_for_revalidate(dir); 1715 return nfs_lookup_revalidate_done(dir, dentry, inode, ret); 1716 } 1717 1718 /* 1719 * This is called every time the dcache has a lookup hit, 1720 * and we should check whether we can really trust that 1721 * lookup. 1722 * 1723 * NOTE! The hit can be a negative hit too, don't assume 1724 * we have an inode! 1725 * 1726 * If the parent directory is seen to have changed, we throw out the 1727 * cached dentry and do a new lookup. 1728 */ 1729 static int 1730 nfs_do_lookup_revalidate(struct inode *dir, struct dentry *dentry, 1731 unsigned int flags) 1732 { 1733 struct inode *inode; 1734 int error; 1735 1736 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 1737 inode = d_inode(dentry); 1738 1739 if (!inode) 1740 return nfs_lookup_revalidate_negative(dir, dentry, flags); 1741 1742 if (is_bad_inode(inode)) { 1743 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n", 1744 __func__, dentry); 1745 goto out_bad; 1746 } 1747 1748 if ((flags & LOOKUP_RENAME_TARGET) && d_count(dentry) < 2 && 1749 nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE)) 1750 goto out_bad; 1751 1752 if (nfs_verifier_is_delegated(dentry)) 1753 return nfs_lookup_revalidate_delegated(dir, dentry, inode); 1754 1755 /* Force a full look up iff the parent directory has changed */ 1756 if (!(flags & (LOOKUP_EXCL | LOOKUP_REVAL)) && 1757 nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) { 1758 error = nfs_lookup_verify_inode(inode, flags); 1759 if (error) { 1760 if (error == -ESTALE) 1761 nfs_mark_dir_for_revalidate(dir); 1762 goto out_bad; 1763 } 1764 goto out_valid; 1765 } 1766 1767 if (flags & LOOKUP_RCU) 1768 return -ECHILD; 1769 1770 if (NFS_STALE(inode)) 1771 goto out_bad; 1772 1773 return nfs_lookup_revalidate_dentry(dir, dentry, inode, flags); 1774 out_valid: 1775 return nfs_lookup_revalidate_done(dir, dentry, inode, 1); 1776 out_bad: 1777 if (flags & LOOKUP_RCU) 1778 return -ECHILD; 1779 return nfs_lookup_revalidate_done(dir, dentry, inode, 0); 1780 } 1781 1782 static int 1783 __nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags, 1784 int (*reval)(struct inode *, struct dentry *, unsigned int)) 1785 { 1786 struct dentry *parent; 1787 struct inode *dir; 1788 int ret; 1789 1790 if (flags & LOOKUP_RCU) { 1791 if (dentry->d_fsdata == NFS_FSDATA_BLOCKED) 1792 return -ECHILD; 1793 parent = READ_ONCE(dentry->d_parent); 1794 dir = d_inode_rcu(parent); 1795 if (!dir) 1796 return -ECHILD; 1797 ret = reval(dir, dentry, flags); 1798 if (parent != READ_ONCE(dentry->d_parent)) 1799 return -ECHILD; 1800 } else { 1801 /* Wait for unlink to complete */ 1802 wait_var_event(&dentry->d_fsdata, 1803 dentry->d_fsdata != NFS_FSDATA_BLOCKED); 1804 parent = dget_parent(dentry); 1805 ret = reval(d_inode(parent), dentry, flags); 1806 dput(parent); 1807 } 1808 return ret; 1809 } 1810 1811 static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags) 1812 { 1813 return __nfs_lookup_revalidate(dentry, flags, nfs_do_lookup_revalidate); 1814 } 1815 1816 /* 1817 * A weaker form of d_revalidate for revalidating just the d_inode(dentry) 1818 * when we don't really care about the dentry name. This is called when a 1819 * pathwalk ends on a dentry that was not found via a normal lookup in the 1820 * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals). 1821 * 1822 * In this situation, we just want to verify that the inode itself is OK 1823 * since the dentry might have changed on the server. 1824 */ 1825 static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags) 1826 { 1827 struct inode *inode = d_inode(dentry); 1828 int error = 0; 1829 1830 /* 1831 * I believe we can only get a negative dentry here in the case of a 1832 * procfs-style symlink. Just assume it's correct for now, but we may 1833 * eventually need to do something more here. 1834 */ 1835 if (!inode) { 1836 dfprintk(LOOKUPCACHE, "%s: %pd2 has negative inode\n", 1837 __func__, dentry); 1838 return 1; 1839 } 1840 1841 if (is_bad_inode(inode)) { 1842 dfprintk(LOOKUPCACHE, "%s: %pd2 has dud inode\n", 1843 __func__, dentry); 1844 return 0; 1845 } 1846 1847 error = nfs_lookup_verify_inode(inode, flags); 1848 dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n", 1849 __func__, inode->i_ino, error ? "invalid" : "valid"); 1850 return !error; 1851 } 1852 1853 /* 1854 * This is called from dput() when d_count is going to 0. 1855 */ 1856 static int nfs_dentry_delete(const struct dentry *dentry) 1857 { 1858 dfprintk(VFS, "NFS: dentry_delete(%pd2, %x)\n", 1859 dentry, dentry->d_flags); 1860 1861 /* Unhash any dentry with a stale inode */ 1862 if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry))) 1863 return 1; 1864 1865 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1866 /* Unhash it, so that ->d_iput() would be called */ 1867 return 1; 1868 } 1869 if (!(dentry->d_sb->s_flags & SB_ACTIVE)) { 1870 /* Unhash it, so that ancestors of killed async unlink 1871 * files will be cleaned up during umount */ 1872 return 1; 1873 } 1874 return 0; 1875 1876 } 1877 1878 /* Ensure that we revalidate inode->i_nlink */ 1879 static void nfs_drop_nlink(struct inode *inode) 1880 { 1881 spin_lock(&inode->i_lock); 1882 /* drop the inode if we're reasonably sure this is the last link */ 1883 if (inode->i_nlink > 0) 1884 drop_nlink(inode); 1885 NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter(); 1886 nfs_set_cache_invalid( 1887 inode, NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME | 1888 NFS_INO_INVALID_NLINK); 1889 spin_unlock(&inode->i_lock); 1890 } 1891 1892 /* 1893 * Called when the dentry loses inode. 1894 * We use it to clean up silly-renamed files. 1895 */ 1896 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 1897 { 1898 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1899 nfs_complete_unlink(dentry, inode); 1900 nfs_drop_nlink(inode); 1901 } 1902 iput(inode); 1903 } 1904 1905 static void nfs_d_release(struct dentry *dentry) 1906 { 1907 /* free cached devname value, if it survived that far */ 1908 if (unlikely(dentry->d_fsdata)) { 1909 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1910 WARN_ON(1); 1911 else 1912 kfree(dentry->d_fsdata); 1913 } 1914 } 1915 1916 const struct dentry_operations nfs_dentry_operations = { 1917 .d_revalidate = nfs_lookup_revalidate, 1918 .d_weak_revalidate = nfs_weak_revalidate, 1919 .d_delete = nfs_dentry_delete, 1920 .d_iput = nfs_dentry_iput, 1921 .d_automount = nfs_d_automount, 1922 .d_release = nfs_d_release, 1923 }; 1924 EXPORT_SYMBOL_GPL(nfs_dentry_operations); 1925 1926 struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags) 1927 { 1928 struct dentry *res; 1929 struct inode *inode = NULL; 1930 struct nfs_fh *fhandle = NULL; 1931 struct nfs_fattr *fattr = NULL; 1932 unsigned long dir_verifier; 1933 int error; 1934 1935 dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry); 1936 nfs_inc_stats(dir, NFSIOS_VFSLOOKUP); 1937 1938 if (unlikely(dentry->d_name.len > NFS_SERVER(dir)->namelen)) 1939 return ERR_PTR(-ENAMETOOLONG); 1940 1941 /* 1942 * If we're doing an exclusive create, optimize away the lookup 1943 * but don't hash the dentry. 1944 */ 1945 if (nfs_is_exclusive_create(dir, flags) || flags & LOOKUP_RENAME_TARGET) 1946 return NULL; 1947 1948 res = ERR_PTR(-ENOMEM); 1949 fhandle = nfs_alloc_fhandle(); 1950 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(dir)); 1951 if (fhandle == NULL || fattr == NULL) 1952 goto out; 1953 1954 dir_verifier = nfs_save_change_attribute(dir); 1955 trace_nfs_lookup_enter(dir, dentry, flags); 1956 error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr); 1957 if (error == -ENOENT) { 1958 if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE)) 1959 dir_verifier = inode_peek_iversion_raw(dir); 1960 goto no_entry; 1961 } 1962 if (error < 0) { 1963 res = ERR_PTR(error); 1964 goto out; 1965 } 1966 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1967 res = ERR_CAST(inode); 1968 if (IS_ERR(res)) 1969 goto out; 1970 1971 /* Notify readdir to use READDIRPLUS */ 1972 nfs_lookup_advise_force_readdirplus(dir, flags); 1973 1974 no_entry: 1975 res = d_splice_alias(inode, dentry); 1976 if (res != NULL) { 1977 if (IS_ERR(res)) 1978 goto out; 1979 dentry = res; 1980 } 1981 nfs_set_verifier(dentry, dir_verifier); 1982 out: 1983 trace_nfs_lookup_exit(dir, dentry, flags, PTR_ERR_OR_ZERO(res)); 1984 nfs_free_fattr(fattr); 1985 nfs_free_fhandle(fhandle); 1986 return res; 1987 } 1988 EXPORT_SYMBOL_GPL(nfs_lookup); 1989 1990 void nfs_d_prune_case_insensitive_aliases(struct inode *inode) 1991 { 1992 /* Case insensitive server? Revalidate dentries */ 1993 if (inode && nfs_server_capable(inode, NFS_CAP_CASE_INSENSITIVE)) 1994 d_prune_aliases(inode); 1995 } 1996 EXPORT_SYMBOL_GPL(nfs_d_prune_case_insensitive_aliases); 1997 1998 #if IS_ENABLED(CONFIG_NFS_V4) 1999 static int nfs4_lookup_revalidate(struct dentry *, unsigned int); 2000 2001 const struct dentry_operations nfs4_dentry_operations = { 2002 .d_revalidate = nfs4_lookup_revalidate, 2003 .d_weak_revalidate = nfs_weak_revalidate, 2004 .d_delete = nfs_dentry_delete, 2005 .d_iput = nfs_dentry_iput, 2006 .d_automount = nfs_d_automount, 2007 .d_release = nfs_d_release, 2008 }; 2009 EXPORT_SYMBOL_GPL(nfs4_dentry_operations); 2010 2011 static struct nfs_open_context *create_nfs_open_context(struct dentry *dentry, int open_flags, struct file *filp) 2012 { 2013 return alloc_nfs_open_context(dentry, flags_to_mode(open_flags), filp); 2014 } 2015 2016 static int do_open(struct inode *inode, struct file *filp) 2017 { 2018 nfs_fscache_open_file(inode, filp); 2019 return 0; 2020 } 2021 2022 static int nfs_finish_open(struct nfs_open_context *ctx, 2023 struct dentry *dentry, 2024 struct file *file, unsigned open_flags) 2025 { 2026 int err; 2027 2028 err = finish_open(file, dentry, do_open); 2029 if (err) 2030 goto out; 2031 if (S_ISREG(file_inode(file)->i_mode)) 2032 nfs_file_set_open_context(file, ctx); 2033 else 2034 err = -EOPENSTALE; 2035 out: 2036 return err; 2037 } 2038 2039 int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 2040 struct file *file, unsigned open_flags, 2041 umode_t mode) 2042 { 2043 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 2044 struct nfs_open_context *ctx; 2045 struct dentry *res; 2046 struct iattr attr = { .ia_valid = ATTR_OPEN }; 2047 struct inode *inode; 2048 unsigned int lookup_flags = 0; 2049 unsigned long dir_verifier; 2050 bool switched = false; 2051 int created = 0; 2052 int err; 2053 2054 /* Expect a negative dentry */ 2055 BUG_ON(d_inode(dentry)); 2056 2057 dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n", 2058 dir->i_sb->s_id, dir->i_ino, dentry); 2059 2060 err = nfs_check_flags(open_flags); 2061 if (err) 2062 return err; 2063 2064 /* NFS only supports OPEN on regular files */ 2065 if ((open_flags & O_DIRECTORY)) { 2066 if (!d_in_lookup(dentry)) { 2067 /* 2068 * Hashed negative dentry with O_DIRECTORY: dentry was 2069 * revalidated and is fine, no need to perform lookup 2070 * again 2071 */ 2072 return -ENOENT; 2073 } 2074 lookup_flags = LOOKUP_OPEN|LOOKUP_DIRECTORY; 2075 goto no_open; 2076 } 2077 2078 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) 2079 return -ENAMETOOLONG; 2080 2081 if (open_flags & O_CREAT) { 2082 struct nfs_server *server = NFS_SERVER(dir); 2083 2084 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) 2085 mode &= ~current_umask(); 2086 2087 attr.ia_valid |= ATTR_MODE; 2088 attr.ia_mode = mode; 2089 } 2090 if (open_flags & O_TRUNC) { 2091 attr.ia_valid |= ATTR_SIZE; 2092 attr.ia_size = 0; 2093 } 2094 2095 if (!(open_flags & O_CREAT) && !d_in_lookup(dentry)) { 2096 d_drop(dentry); 2097 switched = true; 2098 dentry = d_alloc_parallel(dentry->d_parent, 2099 &dentry->d_name, &wq); 2100 if (IS_ERR(dentry)) 2101 return PTR_ERR(dentry); 2102 if (unlikely(!d_in_lookup(dentry))) 2103 return finish_no_open(file, dentry); 2104 } 2105 2106 ctx = create_nfs_open_context(dentry, open_flags, file); 2107 err = PTR_ERR(ctx); 2108 if (IS_ERR(ctx)) 2109 goto out; 2110 2111 trace_nfs_atomic_open_enter(dir, ctx, open_flags); 2112 inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, &created); 2113 if (created) 2114 file->f_mode |= FMODE_CREATED; 2115 if (IS_ERR(inode)) { 2116 err = PTR_ERR(inode); 2117 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err); 2118 put_nfs_open_context(ctx); 2119 d_drop(dentry); 2120 switch (err) { 2121 case -ENOENT: 2122 d_splice_alias(NULL, dentry); 2123 if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE)) 2124 dir_verifier = inode_peek_iversion_raw(dir); 2125 else 2126 dir_verifier = nfs_save_change_attribute(dir); 2127 nfs_set_verifier(dentry, dir_verifier); 2128 break; 2129 case -EISDIR: 2130 case -ENOTDIR: 2131 goto no_open; 2132 case -ELOOP: 2133 if (!(open_flags & O_NOFOLLOW)) 2134 goto no_open; 2135 break; 2136 /* case -EINVAL: */ 2137 default: 2138 break; 2139 } 2140 goto out; 2141 } 2142 file->f_mode |= FMODE_CAN_ODIRECT; 2143 2144 err = nfs_finish_open(ctx, ctx->dentry, file, open_flags); 2145 trace_nfs_atomic_open_exit(dir, ctx, open_flags, err); 2146 put_nfs_open_context(ctx); 2147 out: 2148 if (unlikely(switched)) { 2149 d_lookup_done(dentry); 2150 dput(dentry); 2151 } 2152 return err; 2153 2154 no_open: 2155 res = nfs_lookup(dir, dentry, lookup_flags); 2156 if (!res) { 2157 inode = d_inode(dentry); 2158 if ((lookup_flags & LOOKUP_DIRECTORY) && inode && 2159 !(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))) 2160 res = ERR_PTR(-ENOTDIR); 2161 else if (inode && S_ISREG(inode->i_mode)) 2162 res = ERR_PTR(-EOPENSTALE); 2163 } else if (!IS_ERR(res)) { 2164 inode = d_inode(res); 2165 if ((lookup_flags & LOOKUP_DIRECTORY) && inode && 2166 !(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))) { 2167 dput(res); 2168 res = ERR_PTR(-ENOTDIR); 2169 } else if (inode && S_ISREG(inode->i_mode)) { 2170 dput(res); 2171 res = ERR_PTR(-EOPENSTALE); 2172 } 2173 } 2174 if (switched) { 2175 d_lookup_done(dentry); 2176 if (!res) 2177 res = dentry; 2178 else 2179 dput(dentry); 2180 } 2181 if (IS_ERR(res)) 2182 return PTR_ERR(res); 2183 return finish_no_open(file, res); 2184 } 2185 EXPORT_SYMBOL_GPL(nfs_atomic_open); 2186 2187 static int 2188 nfs4_do_lookup_revalidate(struct inode *dir, struct dentry *dentry, 2189 unsigned int flags) 2190 { 2191 struct inode *inode; 2192 2193 if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY)) 2194 goto full_reval; 2195 if (d_mountpoint(dentry)) 2196 goto full_reval; 2197 2198 inode = d_inode(dentry); 2199 2200 /* We can't create new files in nfs_open_revalidate(), so we 2201 * optimize away revalidation of negative dentries. 2202 */ 2203 if (inode == NULL) 2204 goto full_reval; 2205 2206 if (nfs_verifier_is_delegated(dentry)) 2207 return nfs_lookup_revalidate_delegated(dir, dentry, inode); 2208 2209 /* NFS only supports OPEN on regular files */ 2210 if (!S_ISREG(inode->i_mode)) 2211 goto full_reval; 2212 2213 /* We cannot do exclusive creation on a positive dentry */ 2214 if (flags & (LOOKUP_EXCL | LOOKUP_REVAL)) 2215 goto reval_dentry; 2216 2217 /* Check if the directory changed */ 2218 if (!nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) 2219 goto reval_dentry; 2220 2221 /* Let f_op->open() actually open (and revalidate) the file */ 2222 return 1; 2223 reval_dentry: 2224 if (flags & LOOKUP_RCU) 2225 return -ECHILD; 2226 return nfs_lookup_revalidate_dentry(dir, dentry, inode, flags); 2227 2228 full_reval: 2229 return nfs_do_lookup_revalidate(dir, dentry, flags); 2230 } 2231 2232 static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags) 2233 { 2234 return __nfs_lookup_revalidate(dentry, flags, 2235 nfs4_do_lookup_revalidate); 2236 } 2237 2238 #endif /* CONFIG_NFSV4 */ 2239 2240 struct dentry * 2241 nfs_add_or_obtain(struct dentry *dentry, struct nfs_fh *fhandle, 2242 struct nfs_fattr *fattr) 2243 { 2244 struct dentry *parent = dget_parent(dentry); 2245 struct inode *dir = d_inode(parent); 2246 struct inode *inode; 2247 struct dentry *d; 2248 int error; 2249 2250 d_drop(dentry); 2251 2252 if (fhandle->size == 0) { 2253 error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr); 2254 if (error) 2255 goto out_error; 2256 } 2257 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2258 if (!(fattr->valid & NFS_ATTR_FATTR)) { 2259 struct nfs_server *server = NFS_SB(dentry->d_sb); 2260 error = server->nfs_client->rpc_ops->getattr(server, fhandle, 2261 fattr, NULL); 2262 if (error < 0) 2263 goto out_error; 2264 } 2265 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 2266 d = d_splice_alias(inode, dentry); 2267 out: 2268 dput(parent); 2269 return d; 2270 out_error: 2271 d = ERR_PTR(error); 2272 goto out; 2273 } 2274 EXPORT_SYMBOL_GPL(nfs_add_or_obtain); 2275 2276 /* 2277 * Code common to create, mkdir, and mknod. 2278 */ 2279 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 2280 struct nfs_fattr *fattr) 2281 { 2282 struct dentry *d; 2283 2284 d = nfs_add_or_obtain(dentry, fhandle, fattr); 2285 if (IS_ERR(d)) 2286 return PTR_ERR(d); 2287 2288 /* Callers don't care */ 2289 dput(d); 2290 return 0; 2291 } 2292 EXPORT_SYMBOL_GPL(nfs_instantiate); 2293 2294 /* 2295 * Following a failed create operation, we drop the dentry rather 2296 * than retain a negative dentry. This avoids a problem in the event 2297 * that the operation succeeded on the server, but an error in the 2298 * reply path made it appear to have failed. 2299 */ 2300 int nfs_create(struct mnt_idmap *idmap, struct inode *dir, 2301 struct dentry *dentry, umode_t mode, bool excl) 2302 { 2303 struct iattr attr; 2304 int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT; 2305 int error; 2306 2307 dfprintk(VFS, "NFS: create(%s/%lu), %pd\n", 2308 dir->i_sb->s_id, dir->i_ino, dentry); 2309 2310 attr.ia_mode = mode; 2311 attr.ia_valid = ATTR_MODE; 2312 2313 trace_nfs_create_enter(dir, dentry, open_flags); 2314 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags); 2315 trace_nfs_create_exit(dir, dentry, open_flags, error); 2316 if (error != 0) 2317 goto out_err; 2318 return 0; 2319 out_err: 2320 d_drop(dentry); 2321 return error; 2322 } 2323 EXPORT_SYMBOL_GPL(nfs_create); 2324 2325 /* 2326 * See comments for nfs_proc_create regarding failed operations. 2327 */ 2328 int 2329 nfs_mknod(struct mnt_idmap *idmap, struct inode *dir, 2330 struct dentry *dentry, umode_t mode, dev_t rdev) 2331 { 2332 struct iattr attr; 2333 int status; 2334 2335 dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n", 2336 dir->i_sb->s_id, dir->i_ino, dentry); 2337 2338 attr.ia_mode = mode; 2339 attr.ia_valid = ATTR_MODE; 2340 2341 trace_nfs_mknod_enter(dir, dentry); 2342 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 2343 trace_nfs_mknod_exit(dir, dentry, status); 2344 if (status != 0) 2345 goto out_err; 2346 return 0; 2347 out_err: 2348 d_drop(dentry); 2349 return status; 2350 } 2351 EXPORT_SYMBOL_GPL(nfs_mknod); 2352 2353 /* 2354 * See comments for nfs_proc_create regarding failed operations. 2355 */ 2356 int nfs_mkdir(struct mnt_idmap *idmap, struct inode *dir, 2357 struct dentry *dentry, umode_t mode) 2358 { 2359 struct iattr attr; 2360 int error; 2361 2362 dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n", 2363 dir->i_sb->s_id, dir->i_ino, dentry); 2364 2365 attr.ia_valid = ATTR_MODE; 2366 attr.ia_mode = mode | S_IFDIR; 2367 2368 trace_nfs_mkdir_enter(dir, dentry); 2369 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 2370 trace_nfs_mkdir_exit(dir, dentry, error); 2371 if (error != 0) 2372 goto out_err; 2373 return 0; 2374 out_err: 2375 d_drop(dentry); 2376 return error; 2377 } 2378 EXPORT_SYMBOL_GPL(nfs_mkdir); 2379 2380 static void nfs_dentry_handle_enoent(struct dentry *dentry) 2381 { 2382 if (simple_positive(dentry)) 2383 d_delete(dentry); 2384 } 2385 2386 static void nfs_dentry_remove_handle_error(struct inode *dir, 2387 struct dentry *dentry, int error) 2388 { 2389 switch (error) { 2390 case -ENOENT: 2391 if (d_really_is_positive(dentry)) 2392 d_delete(dentry); 2393 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2394 break; 2395 case 0: 2396 nfs_d_prune_case_insensitive_aliases(d_inode(dentry)); 2397 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2398 } 2399 } 2400 2401 int nfs_rmdir(struct inode *dir, struct dentry *dentry) 2402 { 2403 int error; 2404 2405 dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n", 2406 dir->i_sb->s_id, dir->i_ino, dentry); 2407 2408 trace_nfs_rmdir_enter(dir, dentry); 2409 if (d_really_is_positive(dentry)) { 2410 down_write(&NFS_I(d_inode(dentry))->rmdir_sem); 2411 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 2412 /* Ensure the VFS deletes this inode */ 2413 switch (error) { 2414 case 0: 2415 clear_nlink(d_inode(dentry)); 2416 break; 2417 case -ENOENT: 2418 nfs_dentry_handle_enoent(dentry); 2419 } 2420 up_write(&NFS_I(d_inode(dentry))->rmdir_sem); 2421 } else 2422 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 2423 nfs_dentry_remove_handle_error(dir, dentry, error); 2424 trace_nfs_rmdir_exit(dir, dentry, error); 2425 2426 return error; 2427 } 2428 EXPORT_SYMBOL_GPL(nfs_rmdir); 2429 2430 /* 2431 * Remove a file after making sure there are no pending writes, 2432 * and after checking that the file has only one user. 2433 * 2434 * We invalidate the attribute cache and free the inode prior to the operation 2435 * to avoid possible races if the server reuses the inode. 2436 */ 2437 static int nfs_safe_remove(struct dentry *dentry) 2438 { 2439 struct inode *dir = d_inode(dentry->d_parent); 2440 struct inode *inode = d_inode(dentry); 2441 int error = -EBUSY; 2442 2443 dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry); 2444 2445 /* If the dentry was sillyrenamed, we simply call d_delete() */ 2446 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 2447 error = 0; 2448 goto out; 2449 } 2450 2451 trace_nfs_remove_enter(dir, dentry); 2452 if (inode != NULL) { 2453 error = NFS_PROTO(dir)->remove(dir, dentry); 2454 if (error == 0) 2455 nfs_drop_nlink(inode); 2456 } else 2457 error = NFS_PROTO(dir)->remove(dir, dentry); 2458 if (error == -ENOENT) 2459 nfs_dentry_handle_enoent(dentry); 2460 trace_nfs_remove_exit(dir, dentry, error); 2461 out: 2462 return error; 2463 } 2464 2465 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 2466 * belongs to an active ".nfs..." file and we return -EBUSY. 2467 * 2468 * If sillyrename() returns 0, we do nothing, otherwise we unlink. 2469 */ 2470 int nfs_unlink(struct inode *dir, struct dentry *dentry) 2471 { 2472 int error; 2473 2474 dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id, 2475 dir->i_ino, dentry); 2476 2477 trace_nfs_unlink_enter(dir, dentry); 2478 spin_lock(&dentry->d_lock); 2479 if (d_count(dentry) > 1 && !test_bit(NFS_INO_PRESERVE_UNLINKED, 2480 &NFS_I(d_inode(dentry))->flags)) { 2481 spin_unlock(&dentry->d_lock); 2482 /* Start asynchronous writeout of the inode */ 2483 write_inode_now(d_inode(dentry), 0); 2484 error = nfs_sillyrename(dir, dentry); 2485 goto out; 2486 } 2487 /* We must prevent any concurrent open until the unlink 2488 * completes. ->d_revalidate will wait for ->d_fsdata 2489 * to clear. We set it here to ensure no lookup succeeds until 2490 * the unlink is complete on the server. 2491 */ 2492 error = -ETXTBSY; 2493 if (WARN_ON(dentry->d_flags & DCACHE_NFSFS_RENAMED) || 2494 WARN_ON(dentry->d_fsdata == NFS_FSDATA_BLOCKED)) { 2495 spin_unlock(&dentry->d_lock); 2496 goto out; 2497 } 2498 /* old devname */ 2499 kfree(dentry->d_fsdata); 2500 dentry->d_fsdata = NFS_FSDATA_BLOCKED; 2501 2502 spin_unlock(&dentry->d_lock); 2503 error = nfs_safe_remove(dentry); 2504 nfs_dentry_remove_handle_error(dir, dentry, error); 2505 dentry->d_fsdata = NULL; 2506 wake_up_var(&dentry->d_fsdata); 2507 out: 2508 trace_nfs_unlink_exit(dir, dentry, error); 2509 return error; 2510 } 2511 EXPORT_SYMBOL_GPL(nfs_unlink); 2512 2513 /* 2514 * To create a symbolic link, most file systems instantiate a new inode, 2515 * add a page to it containing the path, then write it out to the disk 2516 * using prepare_write/commit_write. 2517 * 2518 * Unfortunately the NFS client can't create the in-core inode first 2519 * because it needs a file handle to create an in-core inode (see 2520 * fs/nfs/inode.c:nfs_fhget). We only have a file handle *after* the 2521 * symlink request has completed on the server. 2522 * 2523 * So instead we allocate a raw page, copy the symname into it, then do 2524 * the SYMLINK request with the page as the buffer. If it succeeds, we 2525 * now have a new file handle and can instantiate an in-core NFS inode 2526 * and move the raw page into its mapping. 2527 */ 2528 int nfs_symlink(struct mnt_idmap *idmap, struct inode *dir, 2529 struct dentry *dentry, const char *symname) 2530 { 2531 struct page *page; 2532 char *kaddr; 2533 struct iattr attr; 2534 unsigned int pathlen = strlen(symname); 2535 int error; 2536 2537 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id, 2538 dir->i_ino, dentry, symname); 2539 2540 if (pathlen > PAGE_SIZE) 2541 return -ENAMETOOLONG; 2542 2543 attr.ia_mode = S_IFLNK | S_IRWXUGO; 2544 attr.ia_valid = ATTR_MODE; 2545 2546 page = alloc_page(GFP_USER); 2547 if (!page) 2548 return -ENOMEM; 2549 2550 kaddr = page_address(page); 2551 memcpy(kaddr, symname, pathlen); 2552 if (pathlen < PAGE_SIZE) 2553 memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen); 2554 2555 trace_nfs_symlink_enter(dir, dentry); 2556 error = NFS_PROTO(dir)->symlink(dir, dentry, page, pathlen, &attr); 2557 trace_nfs_symlink_exit(dir, dentry, error); 2558 if (error != 0) { 2559 dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n", 2560 dir->i_sb->s_id, dir->i_ino, 2561 dentry, symname, error); 2562 d_drop(dentry); 2563 __free_page(page); 2564 return error; 2565 } 2566 2567 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2568 2569 /* 2570 * No big deal if we can't add this page to the page cache here. 2571 * READLINK will get the missing page from the server if needed. 2572 */ 2573 if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0, 2574 GFP_KERNEL)) { 2575 SetPageUptodate(page); 2576 unlock_page(page); 2577 /* 2578 * add_to_page_cache_lru() grabs an extra page refcount. 2579 * Drop it here to avoid leaking this page later. 2580 */ 2581 put_page(page); 2582 } else 2583 __free_page(page); 2584 2585 return 0; 2586 } 2587 EXPORT_SYMBOL_GPL(nfs_symlink); 2588 2589 int 2590 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 2591 { 2592 struct inode *inode = d_inode(old_dentry); 2593 int error; 2594 2595 dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n", 2596 old_dentry, dentry); 2597 2598 trace_nfs_link_enter(inode, dir, dentry); 2599 d_drop(dentry); 2600 if (S_ISREG(inode->i_mode)) 2601 nfs_sync_inode(inode); 2602 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 2603 if (error == 0) { 2604 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 2605 ihold(inode); 2606 d_add(dentry, inode); 2607 } 2608 trace_nfs_link_exit(inode, dir, dentry, error); 2609 return error; 2610 } 2611 EXPORT_SYMBOL_GPL(nfs_link); 2612 2613 static void 2614 nfs_unblock_rename(struct rpc_task *task, struct nfs_renamedata *data) 2615 { 2616 struct dentry *new_dentry = data->new_dentry; 2617 2618 new_dentry->d_fsdata = NULL; 2619 wake_up_var(&new_dentry->d_fsdata); 2620 } 2621 2622 /* 2623 * RENAME 2624 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 2625 * different file handle for the same inode after a rename (e.g. when 2626 * moving to a different directory). A fail-safe method to do so would 2627 * be to look up old_dir/old_name, create a link to new_dir/new_name and 2628 * rename the old file using the sillyrename stuff. This way, the original 2629 * file in old_dir will go away when the last process iput()s the inode. 2630 * 2631 * FIXED. 2632 * 2633 * It actually works quite well. One needs to have the possibility for 2634 * at least one ".nfs..." file in each directory the file ever gets 2635 * moved or linked to which happens automagically with the new 2636 * implementation that only depends on the dcache stuff instead of 2637 * using the inode layer 2638 * 2639 * Unfortunately, things are a little more complicated than indicated 2640 * above. For a cross-directory move, we want to make sure we can get 2641 * rid of the old inode after the operation. This means there must be 2642 * no pending writes (if it's a file), and the use count must be 1. 2643 * If these conditions are met, we can drop the dentries before doing 2644 * the rename. 2645 */ 2646 int nfs_rename(struct mnt_idmap *idmap, struct inode *old_dir, 2647 struct dentry *old_dentry, struct inode *new_dir, 2648 struct dentry *new_dentry, unsigned int flags) 2649 { 2650 struct inode *old_inode = d_inode(old_dentry); 2651 struct inode *new_inode = d_inode(new_dentry); 2652 struct dentry *dentry = NULL; 2653 struct rpc_task *task; 2654 bool must_unblock = false; 2655 int error = -EBUSY; 2656 2657 if (flags) 2658 return -EINVAL; 2659 2660 dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n", 2661 old_dentry, new_dentry, 2662 d_count(new_dentry)); 2663 2664 trace_nfs_rename_enter(old_dir, old_dentry, new_dir, new_dentry); 2665 /* 2666 * For non-directories, check whether the target is busy and if so, 2667 * make a copy of the dentry and then do a silly-rename. If the 2668 * silly-rename succeeds, the copied dentry is hashed and becomes 2669 * the new target. 2670 */ 2671 if (new_inode && !S_ISDIR(new_inode->i_mode)) { 2672 /* We must prevent any concurrent open until the unlink 2673 * completes. ->d_revalidate will wait for ->d_fsdata 2674 * to clear. We set it here to ensure no lookup succeeds until 2675 * the unlink is complete on the server. 2676 */ 2677 error = -ETXTBSY; 2678 if (WARN_ON(new_dentry->d_flags & DCACHE_NFSFS_RENAMED) || 2679 WARN_ON(new_dentry->d_fsdata == NFS_FSDATA_BLOCKED)) 2680 goto out; 2681 if (new_dentry->d_fsdata) { 2682 /* old devname */ 2683 kfree(new_dentry->d_fsdata); 2684 new_dentry->d_fsdata = NULL; 2685 } 2686 2687 spin_lock(&new_dentry->d_lock); 2688 if (d_count(new_dentry) > 2) { 2689 int err; 2690 2691 spin_unlock(&new_dentry->d_lock); 2692 2693 /* copy the target dentry's name */ 2694 dentry = d_alloc(new_dentry->d_parent, 2695 &new_dentry->d_name); 2696 if (!dentry) 2697 goto out; 2698 2699 /* silly-rename the existing target ... */ 2700 err = nfs_sillyrename(new_dir, new_dentry); 2701 if (err) 2702 goto out; 2703 2704 new_dentry = dentry; 2705 new_inode = NULL; 2706 } else { 2707 new_dentry->d_fsdata = NFS_FSDATA_BLOCKED; 2708 must_unblock = true; 2709 spin_unlock(&new_dentry->d_lock); 2710 } 2711 2712 } 2713 2714 if (S_ISREG(old_inode->i_mode)) 2715 nfs_sync_inode(old_inode); 2716 task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, 2717 must_unblock ? nfs_unblock_rename : NULL); 2718 if (IS_ERR(task)) { 2719 error = PTR_ERR(task); 2720 goto out; 2721 } 2722 2723 error = rpc_wait_for_completion_task(task); 2724 if (error != 0) { 2725 ((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1; 2726 /* Paired with the atomic_dec_and_test() barrier in rpc_do_put_task() */ 2727 smp_wmb(); 2728 } else 2729 error = task->tk_status; 2730 rpc_put_task(task); 2731 /* Ensure the inode attributes are revalidated */ 2732 if (error == 0) { 2733 spin_lock(&old_inode->i_lock); 2734 NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter(); 2735 nfs_set_cache_invalid(old_inode, NFS_INO_INVALID_CHANGE | 2736 NFS_INO_INVALID_CTIME | 2737 NFS_INO_REVAL_FORCED); 2738 spin_unlock(&old_inode->i_lock); 2739 } 2740 out: 2741 trace_nfs_rename_exit(old_dir, old_dentry, 2742 new_dir, new_dentry, error); 2743 if (!error) { 2744 if (new_inode != NULL) 2745 nfs_drop_nlink(new_inode); 2746 /* 2747 * The d_move() should be here instead of in an async RPC completion 2748 * handler because we need the proper locks to move the dentry. If 2749 * we're interrupted by a signal, the async RPC completion handler 2750 * should mark the directories for revalidation. 2751 */ 2752 d_move(old_dentry, new_dentry); 2753 nfs_set_verifier(old_dentry, 2754 nfs_save_change_attribute(new_dir)); 2755 } else if (error == -ENOENT) 2756 nfs_dentry_handle_enoent(old_dentry); 2757 2758 /* new dentry created? */ 2759 if (dentry) 2760 dput(dentry); 2761 return error; 2762 } 2763 EXPORT_SYMBOL_GPL(nfs_rename); 2764 2765 static DEFINE_SPINLOCK(nfs_access_lru_lock); 2766 static LIST_HEAD(nfs_access_lru_list); 2767 static atomic_long_t nfs_access_nr_entries; 2768 2769 static unsigned long nfs_access_max_cachesize = 4*1024*1024; 2770 module_param(nfs_access_max_cachesize, ulong, 0644); 2771 MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache length"); 2772 2773 static void nfs_access_free_entry(struct nfs_access_entry *entry) 2774 { 2775 put_group_info(entry->group_info); 2776 kfree_rcu(entry, rcu_head); 2777 smp_mb__before_atomic(); 2778 atomic_long_dec(&nfs_access_nr_entries); 2779 smp_mb__after_atomic(); 2780 } 2781 2782 static void nfs_access_free_list(struct list_head *head) 2783 { 2784 struct nfs_access_entry *cache; 2785 2786 while (!list_empty(head)) { 2787 cache = list_entry(head->next, struct nfs_access_entry, lru); 2788 list_del(&cache->lru); 2789 nfs_access_free_entry(cache); 2790 } 2791 } 2792 2793 static unsigned long 2794 nfs_do_access_cache_scan(unsigned int nr_to_scan) 2795 { 2796 LIST_HEAD(head); 2797 struct nfs_inode *nfsi, *next; 2798 struct nfs_access_entry *cache; 2799 long freed = 0; 2800 2801 spin_lock(&nfs_access_lru_lock); 2802 list_for_each_entry_safe(nfsi, next, &nfs_access_lru_list, access_cache_inode_lru) { 2803 struct inode *inode; 2804 2805 if (nr_to_scan-- == 0) 2806 break; 2807 inode = &nfsi->vfs_inode; 2808 spin_lock(&inode->i_lock); 2809 if (list_empty(&nfsi->access_cache_entry_lru)) 2810 goto remove_lru_entry; 2811 cache = list_entry(nfsi->access_cache_entry_lru.next, 2812 struct nfs_access_entry, lru); 2813 list_move(&cache->lru, &head); 2814 rb_erase(&cache->rb_node, &nfsi->access_cache); 2815 freed++; 2816 if (!list_empty(&nfsi->access_cache_entry_lru)) 2817 list_move_tail(&nfsi->access_cache_inode_lru, 2818 &nfs_access_lru_list); 2819 else { 2820 remove_lru_entry: 2821 list_del_init(&nfsi->access_cache_inode_lru); 2822 smp_mb__before_atomic(); 2823 clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags); 2824 smp_mb__after_atomic(); 2825 } 2826 spin_unlock(&inode->i_lock); 2827 } 2828 spin_unlock(&nfs_access_lru_lock); 2829 nfs_access_free_list(&head); 2830 return freed; 2831 } 2832 2833 unsigned long 2834 nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc) 2835 { 2836 int nr_to_scan = sc->nr_to_scan; 2837 gfp_t gfp_mask = sc->gfp_mask; 2838 2839 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 2840 return SHRINK_STOP; 2841 return nfs_do_access_cache_scan(nr_to_scan); 2842 } 2843 2844 2845 unsigned long 2846 nfs_access_cache_count(struct shrinker *shrink, struct shrink_control *sc) 2847 { 2848 return vfs_pressure_ratio(atomic_long_read(&nfs_access_nr_entries)); 2849 } 2850 2851 static void 2852 nfs_access_cache_enforce_limit(void) 2853 { 2854 long nr_entries = atomic_long_read(&nfs_access_nr_entries); 2855 unsigned long diff; 2856 unsigned int nr_to_scan; 2857 2858 if (nr_entries < 0 || nr_entries <= nfs_access_max_cachesize) 2859 return; 2860 nr_to_scan = 100; 2861 diff = nr_entries - nfs_access_max_cachesize; 2862 if (diff < nr_to_scan) 2863 nr_to_scan = diff; 2864 nfs_do_access_cache_scan(nr_to_scan); 2865 } 2866 2867 static void __nfs_access_zap_cache(struct nfs_inode *nfsi, struct list_head *head) 2868 { 2869 struct rb_root *root_node = &nfsi->access_cache; 2870 struct rb_node *n; 2871 struct nfs_access_entry *entry; 2872 2873 /* Unhook entries from the cache */ 2874 while ((n = rb_first(root_node)) != NULL) { 2875 entry = rb_entry(n, struct nfs_access_entry, rb_node); 2876 rb_erase(n, root_node); 2877 list_move(&entry->lru, head); 2878 } 2879 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 2880 } 2881 2882 void nfs_access_zap_cache(struct inode *inode) 2883 { 2884 LIST_HEAD(head); 2885 2886 if (test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags) == 0) 2887 return; 2888 /* Remove from global LRU init */ 2889 spin_lock(&nfs_access_lru_lock); 2890 if (test_and_clear_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 2891 list_del_init(&NFS_I(inode)->access_cache_inode_lru); 2892 2893 spin_lock(&inode->i_lock); 2894 __nfs_access_zap_cache(NFS_I(inode), &head); 2895 spin_unlock(&inode->i_lock); 2896 spin_unlock(&nfs_access_lru_lock); 2897 nfs_access_free_list(&head); 2898 } 2899 EXPORT_SYMBOL_GPL(nfs_access_zap_cache); 2900 2901 static int access_cmp(const struct cred *a, const struct nfs_access_entry *b) 2902 { 2903 struct group_info *ga, *gb; 2904 int g; 2905 2906 if (uid_lt(a->fsuid, b->fsuid)) 2907 return -1; 2908 if (uid_gt(a->fsuid, b->fsuid)) 2909 return 1; 2910 2911 if (gid_lt(a->fsgid, b->fsgid)) 2912 return -1; 2913 if (gid_gt(a->fsgid, b->fsgid)) 2914 return 1; 2915 2916 ga = a->group_info; 2917 gb = b->group_info; 2918 if (ga == gb) 2919 return 0; 2920 if (ga == NULL) 2921 return -1; 2922 if (gb == NULL) 2923 return 1; 2924 if (ga->ngroups < gb->ngroups) 2925 return -1; 2926 if (ga->ngroups > gb->ngroups) 2927 return 1; 2928 2929 for (g = 0; g < ga->ngroups; g++) { 2930 if (gid_lt(ga->gid[g], gb->gid[g])) 2931 return -1; 2932 if (gid_gt(ga->gid[g], gb->gid[g])) 2933 return 1; 2934 } 2935 return 0; 2936 } 2937 2938 static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, const struct cred *cred) 2939 { 2940 struct rb_node *n = NFS_I(inode)->access_cache.rb_node; 2941 2942 while (n != NULL) { 2943 struct nfs_access_entry *entry = 2944 rb_entry(n, struct nfs_access_entry, rb_node); 2945 int cmp = access_cmp(cred, entry); 2946 2947 if (cmp < 0) 2948 n = n->rb_left; 2949 else if (cmp > 0) 2950 n = n->rb_right; 2951 else 2952 return entry; 2953 } 2954 return NULL; 2955 } 2956 2957 static u64 nfs_access_login_time(const struct task_struct *task, 2958 const struct cred *cred) 2959 { 2960 const struct task_struct *parent; 2961 const struct cred *pcred; 2962 u64 ret; 2963 2964 rcu_read_lock(); 2965 for (;;) { 2966 parent = rcu_dereference(task->real_parent); 2967 pcred = rcu_dereference(parent->cred); 2968 if (parent == task || cred_fscmp(pcred, cred) != 0) 2969 break; 2970 task = parent; 2971 } 2972 ret = task->start_time; 2973 rcu_read_unlock(); 2974 return ret; 2975 } 2976 2977 static int nfs_access_get_cached_locked(struct inode *inode, const struct cred *cred, u32 *mask, bool may_block) 2978 { 2979 struct nfs_inode *nfsi = NFS_I(inode); 2980 u64 login_time = nfs_access_login_time(current, cred); 2981 struct nfs_access_entry *cache; 2982 bool retry = true; 2983 int err; 2984 2985 spin_lock(&inode->i_lock); 2986 for(;;) { 2987 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 2988 goto out_zap; 2989 cache = nfs_access_search_rbtree(inode, cred); 2990 err = -ENOENT; 2991 if (cache == NULL) 2992 goto out; 2993 /* Found an entry, is our attribute cache valid? */ 2994 if (!nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS)) 2995 break; 2996 if (!retry) 2997 break; 2998 err = -ECHILD; 2999 if (!may_block) 3000 goto out; 3001 spin_unlock(&inode->i_lock); 3002 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode); 3003 if (err) 3004 return err; 3005 spin_lock(&inode->i_lock); 3006 retry = false; 3007 } 3008 err = -ENOENT; 3009 if ((s64)(login_time - cache->timestamp) > 0) 3010 goto out; 3011 *mask = cache->mask; 3012 list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru); 3013 err = 0; 3014 out: 3015 spin_unlock(&inode->i_lock); 3016 return err; 3017 out_zap: 3018 spin_unlock(&inode->i_lock); 3019 nfs_access_zap_cache(inode); 3020 return -ENOENT; 3021 } 3022 3023 static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cred, u32 *mask) 3024 { 3025 /* Only check the most recently returned cache entry, 3026 * but do it without locking. 3027 */ 3028 struct nfs_inode *nfsi = NFS_I(inode); 3029 u64 login_time = nfs_access_login_time(current, cred); 3030 struct nfs_access_entry *cache; 3031 int err = -ECHILD; 3032 struct list_head *lh; 3033 3034 rcu_read_lock(); 3035 if (nfsi->cache_validity & NFS_INO_INVALID_ACCESS) 3036 goto out; 3037 lh = rcu_dereference(list_tail_rcu(&nfsi->access_cache_entry_lru)); 3038 cache = list_entry(lh, struct nfs_access_entry, lru); 3039 if (lh == &nfsi->access_cache_entry_lru || 3040 access_cmp(cred, cache) != 0) 3041 cache = NULL; 3042 if (cache == NULL) 3043 goto out; 3044 if ((s64)(login_time - cache->timestamp) > 0) 3045 goto out; 3046 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS)) 3047 goto out; 3048 *mask = cache->mask; 3049 err = 0; 3050 out: 3051 rcu_read_unlock(); 3052 return err; 3053 } 3054 3055 int nfs_access_get_cached(struct inode *inode, const struct cred *cred, 3056 u32 *mask, bool may_block) 3057 { 3058 int status; 3059 3060 status = nfs_access_get_cached_rcu(inode, cred, mask); 3061 if (status != 0) 3062 status = nfs_access_get_cached_locked(inode, cred, mask, 3063 may_block); 3064 3065 return status; 3066 } 3067 EXPORT_SYMBOL_GPL(nfs_access_get_cached); 3068 3069 static void nfs_access_add_rbtree(struct inode *inode, 3070 struct nfs_access_entry *set, 3071 const struct cred *cred) 3072 { 3073 struct nfs_inode *nfsi = NFS_I(inode); 3074 struct rb_root *root_node = &nfsi->access_cache; 3075 struct rb_node **p = &root_node->rb_node; 3076 struct rb_node *parent = NULL; 3077 struct nfs_access_entry *entry; 3078 int cmp; 3079 3080 spin_lock(&inode->i_lock); 3081 while (*p != NULL) { 3082 parent = *p; 3083 entry = rb_entry(parent, struct nfs_access_entry, rb_node); 3084 cmp = access_cmp(cred, entry); 3085 3086 if (cmp < 0) 3087 p = &parent->rb_left; 3088 else if (cmp > 0) 3089 p = &parent->rb_right; 3090 else 3091 goto found; 3092 } 3093 rb_link_node(&set->rb_node, parent, p); 3094 rb_insert_color(&set->rb_node, root_node); 3095 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 3096 spin_unlock(&inode->i_lock); 3097 return; 3098 found: 3099 rb_replace_node(parent, &set->rb_node, root_node); 3100 list_add_tail(&set->lru, &nfsi->access_cache_entry_lru); 3101 list_del(&entry->lru); 3102 spin_unlock(&inode->i_lock); 3103 nfs_access_free_entry(entry); 3104 } 3105 3106 void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set, 3107 const struct cred *cred) 3108 { 3109 struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL); 3110 if (cache == NULL) 3111 return; 3112 RB_CLEAR_NODE(&cache->rb_node); 3113 cache->fsuid = cred->fsuid; 3114 cache->fsgid = cred->fsgid; 3115 cache->group_info = get_group_info(cred->group_info); 3116 cache->mask = set->mask; 3117 cache->timestamp = ktime_get_ns(); 3118 3119 /* The above field assignments must be visible 3120 * before this item appears on the lru. We cannot easily 3121 * use rcu_assign_pointer, so just force the memory barrier. 3122 */ 3123 smp_wmb(); 3124 nfs_access_add_rbtree(inode, cache, cred); 3125 3126 /* Update accounting */ 3127 smp_mb__before_atomic(); 3128 atomic_long_inc(&nfs_access_nr_entries); 3129 smp_mb__after_atomic(); 3130 3131 /* Add inode to global LRU list */ 3132 if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) { 3133 spin_lock(&nfs_access_lru_lock); 3134 if (!test_and_set_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) 3135 list_add_tail(&NFS_I(inode)->access_cache_inode_lru, 3136 &nfs_access_lru_list); 3137 spin_unlock(&nfs_access_lru_lock); 3138 } 3139 nfs_access_cache_enforce_limit(); 3140 } 3141 EXPORT_SYMBOL_GPL(nfs_access_add_cache); 3142 3143 #define NFS_MAY_READ (NFS_ACCESS_READ) 3144 #define NFS_MAY_WRITE (NFS_ACCESS_MODIFY | \ 3145 NFS_ACCESS_EXTEND | \ 3146 NFS_ACCESS_DELETE) 3147 #define NFS_FILE_MAY_WRITE (NFS_ACCESS_MODIFY | \ 3148 NFS_ACCESS_EXTEND) 3149 #define NFS_DIR_MAY_WRITE NFS_MAY_WRITE 3150 #define NFS_MAY_LOOKUP (NFS_ACCESS_LOOKUP) 3151 #define NFS_MAY_EXECUTE (NFS_ACCESS_EXECUTE) 3152 static int 3153 nfs_access_calc_mask(u32 access_result, umode_t umode) 3154 { 3155 int mask = 0; 3156 3157 if (access_result & NFS_MAY_READ) 3158 mask |= MAY_READ; 3159 if (S_ISDIR(umode)) { 3160 if ((access_result & NFS_DIR_MAY_WRITE) == NFS_DIR_MAY_WRITE) 3161 mask |= MAY_WRITE; 3162 if ((access_result & NFS_MAY_LOOKUP) == NFS_MAY_LOOKUP) 3163 mask |= MAY_EXEC; 3164 } else if (S_ISREG(umode)) { 3165 if ((access_result & NFS_FILE_MAY_WRITE) == NFS_FILE_MAY_WRITE) 3166 mask |= MAY_WRITE; 3167 if ((access_result & NFS_MAY_EXECUTE) == NFS_MAY_EXECUTE) 3168 mask |= MAY_EXEC; 3169 } else if (access_result & NFS_MAY_WRITE) 3170 mask |= MAY_WRITE; 3171 return mask; 3172 } 3173 3174 void nfs_access_set_mask(struct nfs_access_entry *entry, u32 access_result) 3175 { 3176 entry->mask = access_result; 3177 } 3178 EXPORT_SYMBOL_GPL(nfs_access_set_mask); 3179 3180 static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask) 3181 { 3182 struct nfs_access_entry cache; 3183 bool may_block = (mask & MAY_NOT_BLOCK) == 0; 3184 int cache_mask = -1; 3185 int status; 3186 3187 trace_nfs_access_enter(inode); 3188 3189 status = nfs_access_get_cached(inode, cred, &cache.mask, may_block); 3190 if (status == 0) 3191 goto out_cached; 3192 3193 status = -ECHILD; 3194 if (!may_block) 3195 goto out; 3196 3197 /* 3198 * Determine which access bits we want to ask for... 3199 */ 3200 cache.mask = NFS_ACCESS_READ | NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND | 3201 nfs_access_xattr_mask(NFS_SERVER(inode)); 3202 if (S_ISDIR(inode->i_mode)) 3203 cache.mask |= NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP; 3204 else 3205 cache.mask |= NFS_ACCESS_EXECUTE; 3206 status = NFS_PROTO(inode)->access(inode, &cache, cred); 3207 if (status != 0) { 3208 if (status == -ESTALE) { 3209 if (!S_ISDIR(inode->i_mode)) 3210 nfs_set_inode_stale(inode); 3211 else 3212 nfs_zap_caches(inode); 3213 } 3214 goto out; 3215 } 3216 nfs_access_add_cache(inode, &cache, cred); 3217 out_cached: 3218 cache_mask = nfs_access_calc_mask(cache.mask, inode->i_mode); 3219 if ((mask & ~cache_mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0) 3220 status = -EACCES; 3221 out: 3222 trace_nfs_access_exit(inode, mask, cache_mask, status); 3223 return status; 3224 } 3225 3226 static int nfs_open_permission_mask(int openflags) 3227 { 3228 int mask = 0; 3229 3230 if (openflags & __FMODE_EXEC) { 3231 /* ONLY check exec rights */ 3232 mask = MAY_EXEC; 3233 } else { 3234 if ((openflags & O_ACCMODE) != O_WRONLY) 3235 mask |= MAY_READ; 3236 if ((openflags & O_ACCMODE) != O_RDONLY) 3237 mask |= MAY_WRITE; 3238 } 3239 3240 return mask; 3241 } 3242 3243 int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags) 3244 { 3245 return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags)); 3246 } 3247 EXPORT_SYMBOL_GPL(nfs_may_open); 3248 3249 static int nfs_execute_ok(struct inode *inode, int mask) 3250 { 3251 struct nfs_server *server = NFS_SERVER(inode); 3252 int ret = 0; 3253 3254 if (S_ISDIR(inode->i_mode)) 3255 return 0; 3256 if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_MODE)) { 3257 if (mask & MAY_NOT_BLOCK) 3258 return -ECHILD; 3259 ret = __nfs_revalidate_inode(server, inode); 3260 } 3261 if (ret == 0 && !execute_ok(inode)) 3262 ret = -EACCES; 3263 return ret; 3264 } 3265 3266 int nfs_permission(struct mnt_idmap *idmap, 3267 struct inode *inode, 3268 int mask) 3269 { 3270 const struct cred *cred = current_cred(); 3271 int res = 0; 3272 3273 nfs_inc_stats(inode, NFSIOS_VFSACCESS); 3274 3275 if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0) 3276 goto out; 3277 /* Is this sys_access() ? */ 3278 if (mask & (MAY_ACCESS | MAY_CHDIR)) 3279 goto force_lookup; 3280 3281 switch (inode->i_mode & S_IFMT) { 3282 case S_IFLNK: 3283 goto out; 3284 case S_IFREG: 3285 if ((mask & MAY_OPEN) && 3286 nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN)) 3287 return 0; 3288 break; 3289 case S_IFDIR: 3290 /* 3291 * Optimize away all write operations, since the server 3292 * will check permissions when we perform the op. 3293 */ 3294 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 3295 goto out; 3296 } 3297 3298 force_lookup: 3299 if (!NFS_PROTO(inode)->access) 3300 goto out_notsup; 3301 3302 res = nfs_do_access(inode, cred, mask); 3303 out: 3304 if (!res && (mask & MAY_EXEC)) 3305 res = nfs_execute_ok(inode, mask); 3306 3307 dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n", 3308 inode->i_sb->s_id, inode->i_ino, mask, res); 3309 return res; 3310 out_notsup: 3311 if (mask & MAY_NOT_BLOCK) 3312 return -ECHILD; 3313 3314 res = nfs_revalidate_inode(inode, NFS_INO_INVALID_MODE | 3315 NFS_INO_INVALID_OTHER); 3316 if (res == 0) 3317 res = generic_permission(&nop_mnt_idmap, inode, mask); 3318 goto out; 3319 } 3320 EXPORT_SYMBOL_GPL(nfs_permission); 3321