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