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