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