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