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