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 nfs_fattr_init(&fattr); 536 desc->entry = &my_entry; 537 538 while(!desc->entry->eof) { 539 res = readdir_search_pagecache(desc); 540 541 if (res == -EBADCOOKIE) { 542 /* This means either end of directory */ 543 if (*desc->dir_cookie && desc->entry->cookie != *desc->dir_cookie) { 544 /* Or that the server has 'lost' a cookie */ 545 res = uncached_readdir(desc, dirent, filldir); 546 if (res >= 0) 547 continue; 548 } 549 res = 0; 550 break; 551 } 552 if (res == -ETOOSMALL && desc->plus) { 553 clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode)); 554 nfs_zap_caches(inode); 555 desc->plus = 0; 556 desc->entry->eof = 0; 557 continue; 558 } 559 if (res < 0) 560 break; 561 562 res = nfs_do_filldir(desc, dirent, filldir); 563 if (res < 0) { 564 res = 0; 565 break; 566 } 567 } 568 unlock_kernel(); 569 if (res < 0) 570 return res; 571 return 0; 572 } 573 574 loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 575 { 576 down(&filp->f_dentry->d_inode->i_sem); 577 switch (origin) { 578 case 1: 579 offset += filp->f_pos; 580 case 0: 581 if (offset >= 0) 582 break; 583 default: 584 offset = -EINVAL; 585 goto out; 586 } 587 if (offset != filp->f_pos) { 588 filp->f_pos = offset; 589 ((struct nfs_open_context *)filp->private_data)->dir_cookie = 0; 590 } 591 out: 592 up(&filp->f_dentry->d_inode->i_sem); 593 return offset; 594 } 595 596 /* 597 * All directory operations under NFS are synchronous, so fsync() 598 * is a dummy operation. 599 */ 600 int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync) 601 { 602 return 0; 603 } 604 605 /* 606 * A check for whether or not the parent directory has changed. 607 * In the case it has, we assume that the dentries are untrustworthy 608 * and may need to be looked up again. 609 */ 610 static inline int nfs_check_verifier(struct inode *dir, struct dentry *dentry) 611 { 612 if (IS_ROOT(dentry)) 613 return 1; 614 if ((NFS_I(dir)->cache_validity & NFS_INO_INVALID_ATTR) != 0 615 || nfs_attribute_timeout(dir)) 616 return 0; 617 return nfs_verify_change_attribute(dir, (unsigned long)dentry->d_fsdata); 618 } 619 620 static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf) 621 { 622 dentry->d_fsdata = (void *)verf; 623 } 624 625 /* 626 * Whenever an NFS operation succeeds, we know that the dentry 627 * is valid, so we update the revalidation timestamp. 628 */ 629 static inline void nfs_renew_times(struct dentry * dentry) 630 { 631 dentry->d_time = jiffies; 632 } 633 634 /* 635 * Return the intent data that applies to this particular path component 636 * 637 * Note that the current set of intents only apply to the very last 638 * component of the path. 639 * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT. 640 */ 641 static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask) 642 { 643 if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT)) 644 return 0; 645 return nd->flags & mask; 646 } 647 648 /* 649 * Inode and filehandle revalidation for lookups. 650 * 651 * We force revalidation in the cases where the VFS sets LOOKUP_REVAL, 652 * or if the intent information indicates that we're about to open this 653 * particular file and the "nocto" mount flag is not set. 654 * 655 */ 656 static inline 657 int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd) 658 { 659 struct nfs_server *server = NFS_SERVER(inode); 660 661 if (nd != NULL) { 662 /* VFS wants an on-the-wire revalidation */ 663 if (nd->flags & LOOKUP_REVAL) 664 goto out_force; 665 /* This is an open(2) */ 666 if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 && 667 !(server->flags & NFS_MOUNT_NOCTO)) 668 goto out_force; 669 } 670 return nfs_revalidate_inode(server, inode); 671 out_force: 672 return __nfs_revalidate_inode(server, inode); 673 } 674 675 /* 676 * We judge how long we want to trust negative 677 * dentries by looking at the parent inode mtime. 678 * 679 * If parent mtime has changed, we revalidate, else we wait for a 680 * period corresponding to the parent's attribute cache timeout value. 681 */ 682 static inline 683 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 684 struct nameidata *nd) 685 { 686 /* Don't revalidate a negative dentry if we're creating a new file */ 687 if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0) 688 return 0; 689 return !nfs_check_verifier(dir, dentry); 690 } 691 692 /* 693 * This is called every time the dcache has a lookup hit, 694 * and we should check whether we can really trust that 695 * lookup. 696 * 697 * NOTE! The hit can be a negative hit too, don't assume 698 * we have an inode! 699 * 700 * If the parent directory is seen to have changed, we throw out the 701 * cached dentry and do a new lookup. 702 */ 703 static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd) 704 { 705 struct inode *dir; 706 struct inode *inode; 707 struct dentry *parent; 708 int error; 709 struct nfs_fh fhandle; 710 struct nfs_fattr fattr; 711 unsigned long verifier; 712 713 parent = dget_parent(dentry); 714 lock_kernel(); 715 dir = parent->d_inode; 716 inode = dentry->d_inode; 717 718 if (!inode) { 719 if (nfs_neg_need_reval(dir, dentry, nd)) 720 goto out_bad; 721 goto out_valid; 722 } 723 724 if (is_bad_inode(inode)) { 725 dfprintk(VFS, "nfs_lookup_validate: %s/%s has dud inode\n", 726 dentry->d_parent->d_name.name, dentry->d_name.name); 727 goto out_bad; 728 } 729 730 /* Revalidate parent directory attribute cache */ 731 if (nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0) 732 goto out_zap_parent; 733 734 /* Force a full look up iff the parent directory has changed */ 735 if (nfs_check_verifier(dir, dentry)) { 736 if (nfs_lookup_verify_inode(inode, nd)) 737 goto out_zap_parent; 738 goto out_valid; 739 } 740 741 if (NFS_STALE(inode)) 742 goto out_bad; 743 744 verifier = nfs_save_change_attribute(dir); 745 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr); 746 if (error) 747 goto out_bad; 748 if (nfs_compare_fh(NFS_FH(inode), &fhandle)) 749 goto out_bad; 750 if ((error = nfs_refresh_inode(inode, &fattr)) != 0) 751 goto out_bad; 752 753 nfs_renew_times(dentry); 754 nfs_set_verifier(dentry, verifier); 755 out_valid: 756 unlock_kernel(); 757 dput(parent); 758 return 1; 759 out_zap_parent: 760 nfs_zap_caches(dir); 761 out_bad: 762 NFS_CACHEINV(dir); 763 if (inode && S_ISDIR(inode->i_mode)) { 764 /* Purge readdir caches. */ 765 nfs_zap_caches(inode); 766 /* If we have submounts, don't unhash ! */ 767 if (have_submounts(dentry)) 768 goto out_valid; 769 shrink_dcache_parent(dentry); 770 } 771 d_drop(dentry); 772 unlock_kernel(); 773 dput(parent); 774 return 0; 775 } 776 777 /* 778 * This is called from dput() when d_count is going to 0. 779 */ 780 static int nfs_dentry_delete(struct dentry *dentry) 781 { 782 dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n", 783 dentry->d_parent->d_name.name, dentry->d_name.name, 784 dentry->d_flags); 785 786 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 787 /* Unhash it, so that ->d_iput() would be called */ 788 return 1; 789 } 790 if (!(dentry->d_sb->s_flags & MS_ACTIVE)) { 791 /* Unhash it, so that ancestors of killed async unlink 792 * files will be cleaned up during umount */ 793 return 1; 794 } 795 return 0; 796 797 } 798 799 /* 800 * Called when the dentry loses inode. 801 * We use it to clean up silly-renamed files. 802 */ 803 static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode) 804 { 805 nfs_inode_return_delegation(inode); 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 857 /* If we're doing an exclusive create, optimize away the lookup */ 858 if (nfs_is_exclusive_create(dir, nd)) 859 goto no_entry; 860 861 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, &fhandle, &fattr); 862 if (error == -ENOENT) 863 goto no_entry; 864 if (error < 0) { 865 res = ERR_PTR(error); 866 goto out_unlock; 867 } 868 res = ERR_PTR(-EACCES); 869 inode = nfs_fhget(dentry->d_sb, &fhandle, &fattr); 870 if (!inode) 871 goto out_unlock; 872 no_entry: 873 res = d_add_unique(dentry, inode); 874 if (res != NULL) 875 dentry = res; 876 nfs_renew_times(dentry); 877 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 878 out_unlock: 879 unlock_kernel(); 880 out: 881 return res; 882 } 883 884 #ifdef CONFIG_NFS_V4 885 static int nfs_open_revalidate(struct dentry *, struct nameidata *); 886 887 struct dentry_operations nfs4_dentry_operations = { 888 .d_revalidate = nfs_open_revalidate, 889 .d_delete = nfs_dentry_delete, 890 .d_iput = nfs_dentry_iput, 891 }; 892 893 /* 894 * Use intent information to determine whether we need to substitute 895 * the NFSv4-style stateful OPEN for the LOOKUP call 896 */ 897 static int is_atomic_open(struct inode *dir, struct nameidata *nd) 898 { 899 if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0) 900 return 0; 901 /* NFS does not (yet) have a stateful open for directories */ 902 if (nd->flags & LOOKUP_DIRECTORY) 903 return 0; 904 /* Are we trying to write to a read only partition? */ 905 if (IS_RDONLY(dir) && (nd->intent.open.flags & (O_CREAT|O_TRUNC|FMODE_WRITE))) 906 return 0; 907 return 1; 908 } 909 910 static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 911 { 912 struct dentry *res = NULL; 913 int error; 914 915 /* Check that we are indeed trying to open this file */ 916 if (!is_atomic_open(dir, nd)) 917 goto no_open; 918 919 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 920 res = ERR_PTR(-ENAMETOOLONG); 921 goto out; 922 } 923 dentry->d_op = NFS_PROTO(dir)->dentry_ops; 924 925 /* Let vfs_create() deal with O_EXCL */ 926 if (nd->intent.open.flags & O_EXCL) { 927 d_add(dentry, NULL); 928 goto out; 929 } 930 931 /* Open the file on the server */ 932 lock_kernel(); 933 /* Revalidate parent directory attribute cache */ 934 error = nfs_revalidate_inode(NFS_SERVER(dir), dir); 935 if (error < 0) { 936 res = ERR_PTR(error); 937 unlock_kernel(); 938 goto out; 939 } 940 941 if (nd->intent.open.flags & O_CREAT) { 942 nfs_begin_data_update(dir); 943 res = nfs4_atomic_open(dir, dentry, nd); 944 nfs_end_data_update(dir); 945 } else 946 res = nfs4_atomic_open(dir, dentry, nd); 947 unlock_kernel(); 948 if (IS_ERR(res)) { 949 error = PTR_ERR(res); 950 switch (error) { 951 /* Make a negative dentry */ 952 case -ENOENT: 953 res = NULL; 954 goto out; 955 /* This turned out not to be a regular file */ 956 case -EISDIR: 957 case -ENOTDIR: 958 goto no_open; 959 case -ELOOP: 960 if (!(nd->intent.open.flags & O_NOFOLLOW)) 961 goto no_open; 962 /* case -EINVAL: */ 963 default: 964 goto out; 965 } 966 } else if (res != NULL) 967 dentry = res; 968 nfs_renew_times(dentry); 969 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 970 out: 971 return res; 972 no_open: 973 return nfs_lookup(dir, dentry, nd); 974 } 975 976 static int nfs_open_revalidate(struct dentry *dentry, struct nameidata *nd) 977 { 978 struct dentry *parent = NULL; 979 struct inode *inode = dentry->d_inode; 980 struct inode *dir; 981 unsigned long verifier; 982 int openflags, ret = 0; 983 984 parent = dget_parent(dentry); 985 dir = parent->d_inode; 986 if (!is_atomic_open(dir, nd)) 987 goto no_open; 988 /* We can't create new files in nfs_open_revalidate(), so we 989 * optimize away revalidation of negative dentries. 990 */ 991 if (inode == NULL) 992 goto out; 993 /* NFS only supports OPEN on regular files */ 994 if (!S_ISREG(inode->i_mode)) 995 goto no_open; 996 openflags = nd->intent.open.flags; 997 /* We cannot do exclusive creation on a positive dentry */ 998 if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) 999 goto no_open; 1000 /* We can't create new files, or truncate existing ones here */ 1001 openflags &= ~(O_CREAT|O_TRUNC); 1002 1003 /* 1004 * Note: we're not holding inode->i_sem and so may be racing with 1005 * operations that change the directory. We therefore save the 1006 * change attribute *before* we do the RPC call. 1007 */ 1008 lock_kernel(); 1009 verifier = nfs_save_change_attribute(dir); 1010 ret = nfs4_open_revalidate(dir, dentry, openflags, nd); 1011 if (!ret) 1012 nfs_set_verifier(dentry, verifier); 1013 unlock_kernel(); 1014 out: 1015 dput(parent); 1016 if (!ret) 1017 d_drop(dentry); 1018 return ret; 1019 no_open: 1020 dput(parent); 1021 if (inode != NULL && nfs_have_delegation(inode, FMODE_READ)) 1022 return 1; 1023 return nfs_lookup_revalidate(dentry, nd); 1024 } 1025 #endif /* CONFIG_NFSV4 */ 1026 1027 static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc) 1028 { 1029 struct dentry *parent = desc->file->f_dentry; 1030 struct inode *dir = parent->d_inode; 1031 struct nfs_entry *entry = desc->entry; 1032 struct dentry *dentry, *alias; 1033 struct qstr name = { 1034 .name = entry->name, 1035 .len = entry->len, 1036 }; 1037 struct inode *inode; 1038 1039 switch (name.len) { 1040 case 2: 1041 if (name.name[0] == '.' && name.name[1] == '.') 1042 return dget_parent(parent); 1043 break; 1044 case 1: 1045 if (name.name[0] == '.') 1046 return dget(parent); 1047 } 1048 name.hash = full_name_hash(name.name, name.len); 1049 dentry = d_lookup(parent, &name); 1050 if (dentry != NULL) 1051 return dentry; 1052 if (!desc->plus || !(entry->fattr->valid & NFS_ATTR_FATTR)) 1053 return NULL; 1054 /* Note: caller is already holding the dir->i_sem! */ 1055 dentry = d_alloc(parent, &name); 1056 if (dentry == NULL) 1057 return NULL; 1058 dentry->d_op = NFS_PROTO(dir)->dentry_ops; 1059 inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr); 1060 if (!inode) { 1061 dput(dentry); 1062 return NULL; 1063 } 1064 alias = d_add_unique(dentry, inode); 1065 if (alias != NULL) { 1066 dput(dentry); 1067 dentry = alias; 1068 } 1069 nfs_renew_times(dentry); 1070 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1071 return dentry; 1072 } 1073 1074 /* 1075 * Code common to create, mkdir, and mknod. 1076 */ 1077 int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle, 1078 struct nfs_fattr *fattr) 1079 { 1080 struct inode *inode; 1081 int error = -EACCES; 1082 1083 /* We may have been initialized further down */ 1084 if (dentry->d_inode) 1085 return 0; 1086 if (fhandle->size == 0) { 1087 struct inode *dir = dentry->d_parent->d_inode; 1088 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr); 1089 if (error) 1090 goto out_err; 1091 } 1092 if (!(fattr->valid & NFS_ATTR_FATTR)) { 1093 struct nfs_server *server = NFS_SB(dentry->d_sb); 1094 error = server->rpc_ops->getattr(server, fhandle, fattr); 1095 if (error < 0) 1096 goto out_err; 1097 } 1098 error = -ENOMEM; 1099 inode = nfs_fhget(dentry->d_sb, fhandle, fattr); 1100 if (inode == NULL) 1101 goto out_err; 1102 d_instantiate(dentry, inode); 1103 return 0; 1104 out_err: 1105 d_drop(dentry); 1106 return error; 1107 } 1108 1109 /* 1110 * Following a failed create operation, we drop the dentry rather 1111 * than retain a negative dentry. This avoids a problem in the event 1112 * that the operation succeeded on the server, but an error in the 1113 * reply path made it appear to have failed. 1114 */ 1115 static int nfs_create(struct inode *dir, struct dentry *dentry, int mode, 1116 struct nameidata *nd) 1117 { 1118 struct iattr attr; 1119 int error; 1120 int open_flags = 0; 1121 1122 dfprintk(VFS, "NFS: create(%s/%ld, %s\n", dir->i_sb->s_id, 1123 dir->i_ino, dentry->d_name.name); 1124 1125 attr.ia_mode = mode; 1126 attr.ia_valid = ATTR_MODE; 1127 1128 if (nd && (nd->flags & LOOKUP_CREATE)) 1129 open_flags = nd->intent.open.flags; 1130 1131 lock_kernel(); 1132 nfs_begin_data_update(dir); 1133 error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, nd); 1134 nfs_end_data_update(dir); 1135 if (error != 0) 1136 goto out_err; 1137 nfs_renew_times(dentry); 1138 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1139 unlock_kernel(); 1140 return 0; 1141 out_err: 1142 unlock_kernel(); 1143 d_drop(dentry); 1144 return error; 1145 } 1146 1147 /* 1148 * See comments for nfs_proc_create regarding failed operations. 1149 */ 1150 static int 1151 nfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) 1152 { 1153 struct iattr attr; 1154 int status; 1155 1156 dfprintk(VFS, "NFS: mknod(%s/%ld, %s\n", dir->i_sb->s_id, 1157 dir->i_ino, dentry->d_name.name); 1158 1159 if (!new_valid_dev(rdev)) 1160 return -EINVAL; 1161 1162 attr.ia_mode = mode; 1163 attr.ia_valid = ATTR_MODE; 1164 1165 lock_kernel(); 1166 nfs_begin_data_update(dir); 1167 status = NFS_PROTO(dir)->mknod(dir, dentry, &attr, rdev); 1168 nfs_end_data_update(dir); 1169 if (status != 0) 1170 goto out_err; 1171 nfs_renew_times(dentry); 1172 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1173 unlock_kernel(); 1174 return 0; 1175 out_err: 1176 unlock_kernel(); 1177 d_drop(dentry); 1178 return status; 1179 } 1180 1181 /* 1182 * See comments for nfs_proc_create regarding failed operations. 1183 */ 1184 static int nfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 1185 { 1186 struct iattr attr; 1187 int error; 1188 1189 dfprintk(VFS, "NFS: mkdir(%s/%ld, %s\n", dir->i_sb->s_id, 1190 dir->i_ino, dentry->d_name.name); 1191 1192 attr.ia_valid = ATTR_MODE; 1193 attr.ia_mode = mode | S_IFDIR; 1194 1195 lock_kernel(); 1196 nfs_begin_data_update(dir); 1197 error = NFS_PROTO(dir)->mkdir(dir, dentry, &attr); 1198 nfs_end_data_update(dir); 1199 if (error != 0) 1200 goto out_err; 1201 nfs_renew_times(dentry); 1202 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1203 unlock_kernel(); 1204 return 0; 1205 out_err: 1206 d_drop(dentry); 1207 unlock_kernel(); 1208 return error; 1209 } 1210 1211 static int nfs_rmdir(struct inode *dir, struct dentry *dentry) 1212 { 1213 int error; 1214 1215 dfprintk(VFS, "NFS: rmdir(%s/%ld, %s\n", dir->i_sb->s_id, 1216 dir->i_ino, dentry->d_name.name); 1217 1218 lock_kernel(); 1219 nfs_begin_data_update(dir); 1220 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 1221 /* Ensure the VFS deletes this inode */ 1222 if (error == 0 && dentry->d_inode != NULL) 1223 dentry->d_inode->i_nlink = 0; 1224 nfs_end_data_update(dir); 1225 unlock_kernel(); 1226 1227 return error; 1228 } 1229 1230 static int nfs_sillyrename(struct inode *dir, struct dentry *dentry) 1231 { 1232 static unsigned int sillycounter; 1233 const int i_inosize = sizeof(dir->i_ino)*2; 1234 const int countersize = sizeof(sillycounter)*2; 1235 const int slen = sizeof(".nfs") + i_inosize + countersize - 1; 1236 char silly[slen+1]; 1237 struct qstr qsilly; 1238 struct dentry *sdentry; 1239 int error = -EIO; 1240 1241 dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n", 1242 dentry->d_parent->d_name.name, dentry->d_name.name, 1243 atomic_read(&dentry->d_count)); 1244 1245 #ifdef NFS_PARANOIA 1246 if (!dentry->d_inode) 1247 printk("NFS: silly-renaming %s/%s, negative dentry??\n", 1248 dentry->d_parent->d_name.name, dentry->d_name.name); 1249 #endif 1250 /* 1251 * We don't allow a dentry to be silly-renamed twice. 1252 */ 1253 error = -EBUSY; 1254 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1255 goto out; 1256 1257 sprintf(silly, ".nfs%*.*lx", 1258 i_inosize, i_inosize, dentry->d_inode->i_ino); 1259 1260 /* Return delegation in anticipation of the rename */ 1261 nfs_inode_return_delegation(dentry->d_inode); 1262 1263 sdentry = NULL; 1264 do { 1265 char *suffix = silly + slen - countersize; 1266 1267 dput(sdentry); 1268 sillycounter++; 1269 sprintf(suffix, "%*.*x", countersize, countersize, sillycounter); 1270 1271 dfprintk(VFS, "trying to rename %s to %s\n", 1272 dentry->d_name.name, silly); 1273 1274 sdentry = lookup_one_len(silly, dentry->d_parent, slen); 1275 /* 1276 * N.B. Better to return EBUSY here ... it could be 1277 * dangerous to delete the file while it's in use. 1278 */ 1279 if (IS_ERR(sdentry)) 1280 goto out; 1281 } while(sdentry->d_inode != NULL); /* need negative lookup */ 1282 1283 qsilly.name = silly; 1284 qsilly.len = strlen(silly); 1285 nfs_begin_data_update(dir); 1286 if (dentry->d_inode) { 1287 nfs_begin_data_update(dentry->d_inode); 1288 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name, 1289 dir, &qsilly); 1290 nfs_end_data_update(dentry->d_inode); 1291 } else 1292 error = NFS_PROTO(dir)->rename(dir, &dentry->d_name, 1293 dir, &qsilly); 1294 nfs_end_data_update(dir); 1295 if (!error) { 1296 nfs_renew_times(dentry); 1297 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1298 d_move(dentry, sdentry); 1299 error = nfs_async_unlink(dentry); 1300 /* If we return 0 we don't unlink */ 1301 } 1302 dput(sdentry); 1303 out: 1304 return error; 1305 } 1306 1307 /* 1308 * Remove a file after making sure there are no pending writes, 1309 * and after checking that the file has only one user. 1310 * 1311 * We invalidate the attribute cache and free the inode prior to the operation 1312 * to avoid possible races if the server reuses the inode. 1313 */ 1314 static int nfs_safe_remove(struct dentry *dentry) 1315 { 1316 struct inode *dir = dentry->d_parent->d_inode; 1317 struct inode *inode = dentry->d_inode; 1318 int error = -EBUSY; 1319 1320 dfprintk(VFS, "NFS: safe_remove(%s/%s)\n", 1321 dentry->d_parent->d_name.name, dentry->d_name.name); 1322 1323 /* If the dentry was sillyrenamed, we simply call d_delete() */ 1324 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 1325 error = 0; 1326 goto out; 1327 } 1328 1329 nfs_begin_data_update(dir); 1330 if (inode != NULL) { 1331 nfs_inode_return_delegation(inode); 1332 nfs_begin_data_update(inode); 1333 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1334 /* The VFS may want to delete this inode */ 1335 if (error == 0) 1336 inode->i_nlink--; 1337 nfs_end_data_update(inode); 1338 } else 1339 error = NFS_PROTO(dir)->remove(dir, &dentry->d_name); 1340 nfs_end_data_update(dir); 1341 out: 1342 return error; 1343 } 1344 1345 /* We do silly rename. In case sillyrename() returns -EBUSY, the inode 1346 * belongs to an active ".nfs..." file and we return -EBUSY. 1347 * 1348 * If sillyrename() returns 0, we do nothing, otherwise we unlink. 1349 */ 1350 static int nfs_unlink(struct inode *dir, struct dentry *dentry) 1351 { 1352 int error; 1353 int need_rehash = 0; 1354 1355 dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id, 1356 dir->i_ino, dentry->d_name.name); 1357 1358 lock_kernel(); 1359 spin_lock(&dcache_lock); 1360 spin_lock(&dentry->d_lock); 1361 if (atomic_read(&dentry->d_count) > 1) { 1362 spin_unlock(&dentry->d_lock); 1363 spin_unlock(&dcache_lock); 1364 error = nfs_sillyrename(dir, dentry); 1365 unlock_kernel(); 1366 return error; 1367 } 1368 if (!d_unhashed(dentry)) { 1369 __d_drop(dentry); 1370 need_rehash = 1; 1371 } 1372 spin_unlock(&dentry->d_lock); 1373 spin_unlock(&dcache_lock); 1374 error = nfs_safe_remove(dentry); 1375 if (!error) { 1376 nfs_renew_times(dentry); 1377 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1378 } else if (need_rehash) 1379 d_rehash(dentry); 1380 unlock_kernel(); 1381 return error; 1382 } 1383 1384 static int 1385 nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) 1386 { 1387 struct iattr attr; 1388 struct nfs_fattr sym_attr; 1389 struct nfs_fh sym_fh; 1390 struct qstr qsymname; 1391 int error; 1392 1393 dfprintk(VFS, "NFS: symlink(%s/%ld, %s, %s)\n", dir->i_sb->s_id, 1394 dir->i_ino, dentry->d_name.name, symname); 1395 1396 #ifdef NFS_PARANOIA 1397 if (dentry->d_inode) 1398 printk("nfs_proc_symlink: %s/%s not negative!\n", 1399 dentry->d_parent->d_name.name, dentry->d_name.name); 1400 #endif 1401 /* 1402 * Fill in the sattr for the call. 1403 * Note: SunOS 4.1.2 crashes if the mode isn't initialized! 1404 */ 1405 attr.ia_valid = ATTR_MODE; 1406 attr.ia_mode = S_IFLNK | S_IRWXUGO; 1407 1408 qsymname.name = symname; 1409 qsymname.len = strlen(symname); 1410 1411 lock_kernel(); 1412 nfs_begin_data_update(dir); 1413 error = NFS_PROTO(dir)->symlink(dir, &dentry->d_name, &qsymname, 1414 &attr, &sym_fh, &sym_attr); 1415 nfs_end_data_update(dir); 1416 if (!error) { 1417 error = nfs_instantiate(dentry, &sym_fh, &sym_attr); 1418 } else { 1419 if (error == -EEXIST) 1420 printk("nfs_proc_symlink: %s/%s already exists??\n", 1421 dentry->d_parent->d_name.name, dentry->d_name.name); 1422 d_drop(dentry); 1423 } 1424 unlock_kernel(); 1425 return error; 1426 } 1427 1428 static int 1429 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 1430 { 1431 struct inode *inode = old_dentry->d_inode; 1432 int error; 1433 1434 dfprintk(VFS, "NFS: link(%s/%s -> %s/%s)\n", 1435 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1436 dentry->d_parent->d_name.name, dentry->d_name.name); 1437 1438 lock_kernel(); 1439 nfs_begin_data_update(dir); 1440 nfs_begin_data_update(inode); 1441 error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name); 1442 if (error == 0) { 1443 atomic_inc(&inode->i_count); 1444 d_instantiate(dentry, inode); 1445 } 1446 nfs_end_data_update(inode); 1447 nfs_end_data_update(dir); 1448 unlock_kernel(); 1449 return error; 1450 } 1451 1452 /* 1453 * RENAME 1454 * FIXME: Some nfsds, like the Linux user space nfsd, may generate a 1455 * different file handle for the same inode after a rename (e.g. when 1456 * moving to a different directory). A fail-safe method to do so would 1457 * be to look up old_dir/old_name, create a link to new_dir/new_name and 1458 * rename the old file using the sillyrename stuff. This way, the original 1459 * file in old_dir will go away when the last process iput()s the inode. 1460 * 1461 * FIXED. 1462 * 1463 * It actually works quite well. One needs to have the possibility for 1464 * at least one ".nfs..." file in each directory the file ever gets 1465 * moved or linked to which happens automagically with the new 1466 * implementation that only depends on the dcache stuff instead of 1467 * using the inode layer 1468 * 1469 * Unfortunately, things are a little more complicated than indicated 1470 * above. For a cross-directory move, we want to make sure we can get 1471 * rid of the old inode after the operation. This means there must be 1472 * no pending writes (if it's a file), and the use count must be 1. 1473 * If these conditions are met, we can drop the dentries before doing 1474 * the rename. 1475 */ 1476 static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 1477 struct inode *new_dir, struct dentry *new_dentry) 1478 { 1479 struct inode *old_inode = old_dentry->d_inode; 1480 struct inode *new_inode = new_dentry->d_inode; 1481 struct dentry *dentry = NULL, *rehash = NULL; 1482 int error = -EBUSY; 1483 1484 /* 1485 * To prevent any new references to the target during the rename, 1486 * we unhash the dentry and free the inode in advance. 1487 */ 1488 lock_kernel(); 1489 if (!d_unhashed(new_dentry)) { 1490 d_drop(new_dentry); 1491 rehash = new_dentry; 1492 } 1493 1494 dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n", 1495 old_dentry->d_parent->d_name.name, old_dentry->d_name.name, 1496 new_dentry->d_parent->d_name.name, new_dentry->d_name.name, 1497 atomic_read(&new_dentry->d_count)); 1498 1499 /* 1500 * First check whether the target is busy ... we can't 1501 * safely do _any_ rename if the target is in use. 1502 * 1503 * For files, make a copy of the dentry and then do a 1504 * silly-rename. If the silly-rename succeeds, the 1505 * copied dentry is hashed and becomes the new target. 1506 */ 1507 if (!new_inode) 1508 goto go_ahead; 1509 if (S_ISDIR(new_inode->i_mode)) { 1510 error = -EISDIR; 1511 if (!S_ISDIR(old_inode->i_mode)) 1512 goto out; 1513 } else if (atomic_read(&new_dentry->d_count) > 2) { 1514 int err; 1515 /* copy the target dentry's name */ 1516 dentry = d_alloc(new_dentry->d_parent, 1517 &new_dentry->d_name); 1518 if (!dentry) 1519 goto out; 1520 1521 /* silly-rename the existing target ... */ 1522 err = nfs_sillyrename(new_dir, new_dentry); 1523 if (!err) { 1524 new_dentry = rehash = dentry; 1525 new_inode = NULL; 1526 /* instantiate the replacement target */ 1527 d_instantiate(new_dentry, NULL); 1528 } else if (atomic_read(&new_dentry->d_count) > 1) { 1529 /* dentry still busy? */ 1530 #ifdef NFS_PARANOIA 1531 printk("nfs_rename: target %s/%s busy, d_count=%d\n", 1532 new_dentry->d_parent->d_name.name, 1533 new_dentry->d_name.name, 1534 atomic_read(&new_dentry->d_count)); 1535 #endif 1536 goto out; 1537 } 1538 } else 1539 new_inode->i_nlink--; 1540 1541 go_ahead: 1542 /* 1543 * ... prune child dentries and writebacks if needed. 1544 */ 1545 if (atomic_read(&old_dentry->d_count) > 1) { 1546 nfs_wb_all(old_inode); 1547 shrink_dcache_parent(old_dentry); 1548 } 1549 nfs_inode_return_delegation(old_inode); 1550 1551 if (new_inode) 1552 d_delete(new_dentry); 1553 1554 nfs_begin_data_update(old_dir); 1555 nfs_begin_data_update(new_dir); 1556 nfs_begin_data_update(old_inode); 1557 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 1558 new_dir, &new_dentry->d_name); 1559 nfs_end_data_update(old_inode); 1560 nfs_end_data_update(new_dir); 1561 nfs_end_data_update(old_dir); 1562 out: 1563 if (rehash) 1564 d_rehash(rehash); 1565 if (!error) { 1566 if (!S_ISDIR(old_inode->i_mode)) 1567 d_move(old_dentry, new_dentry); 1568 nfs_renew_times(new_dentry); 1569 nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir)); 1570 } 1571 1572 /* new dentry created? */ 1573 if (dentry) 1574 dput(dentry); 1575 unlock_kernel(); 1576 return error; 1577 } 1578 1579 int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 1580 { 1581 struct nfs_inode *nfsi = NFS_I(inode); 1582 struct nfs_access_entry *cache = &nfsi->cache_access; 1583 1584 if (cache->cred != cred 1585 || time_after(jiffies, cache->jiffies + NFS_ATTRTIMEO(inode)) 1586 || (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)) 1587 return -ENOENT; 1588 memcpy(res, cache, sizeof(*res)); 1589 return 0; 1590 } 1591 1592 void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 1593 { 1594 struct nfs_inode *nfsi = NFS_I(inode); 1595 struct nfs_access_entry *cache = &nfsi->cache_access; 1596 1597 if (cache->cred != set->cred) { 1598 if (cache->cred) 1599 put_rpccred(cache->cred); 1600 cache->cred = get_rpccred(set->cred); 1601 } 1602 /* FIXME: replace current access_cache BKL reliance with inode->i_lock */ 1603 spin_lock(&inode->i_lock); 1604 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 1605 spin_unlock(&inode->i_lock); 1606 cache->jiffies = set->jiffies; 1607 cache->mask = set->mask; 1608 } 1609 1610 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 1611 { 1612 struct nfs_access_entry cache; 1613 int status; 1614 1615 status = nfs_access_get_cached(inode, cred, &cache); 1616 if (status == 0) 1617 goto out; 1618 1619 /* Be clever: ask server to check for all possible rights */ 1620 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 1621 cache.cred = cred; 1622 cache.jiffies = jiffies; 1623 status = NFS_PROTO(inode)->access(inode, &cache); 1624 if (status != 0) 1625 return status; 1626 nfs_access_add_cache(inode, &cache); 1627 out: 1628 if ((cache.mask & mask) == mask) 1629 return 0; 1630 return -EACCES; 1631 } 1632 1633 int nfs_permission(struct inode *inode, int mask, struct nameidata *nd) 1634 { 1635 struct rpc_cred *cred; 1636 int res = 0; 1637 1638 if (mask == 0) 1639 goto out; 1640 /* Is this sys_access() ? */ 1641 if (nd != NULL && (nd->flags & LOOKUP_ACCESS)) 1642 goto force_lookup; 1643 1644 switch (inode->i_mode & S_IFMT) { 1645 case S_IFLNK: 1646 goto out; 1647 case S_IFREG: 1648 /* NFSv4 has atomic_open... */ 1649 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 1650 && nd != NULL 1651 && (nd->flags & LOOKUP_OPEN)) 1652 goto out; 1653 break; 1654 case S_IFDIR: 1655 /* 1656 * Optimize away all write operations, since the server 1657 * will check permissions when we perform the op. 1658 */ 1659 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 1660 goto out; 1661 } 1662 1663 force_lookup: 1664 lock_kernel(); 1665 1666 if (!NFS_PROTO(inode)->access) 1667 goto out_notsup; 1668 1669 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0); 1670 if (!IS_ERR(cred)) { 1671 res = nfs_do_access(inode, cred, mask); 1672 put_rpccred(cred); 1673 } else 1674 res = PTR_ERR(cred); 1675 unlock_kernel(); 1676 out: 1677 return res; 1678 out_notsup: 1679 res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 1680 if (res == 0) 1681 res = generic_permission(inode, mask, NULL); 1682 unlock_kernel(); 1683 return res; 1684 } 1685 1686 /* 1687 * Local variables: 1688 * version-control: t 1689 * kept-new-versions: 5 1690 * End: 1691 */ 1692