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