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 int error; 918 919 /* Check that we are indeed trying to open this file */ 920 if (!is_atomic_open(dir, nd)) 921 goto no_open; 922 923 if (dentry->d_name.len > NFS_SERVER(dir)->namelen) { 924 res = ERR_PTR(-ENAMETOOLONG); 925 goto out; 926 } 927 dentry->d_op = NFS_PROTO(dir)->dentry_ops; 928 929 /* Let vfs_create() deal with O_EXCL */ 930 if (nd->intent.open.flags & O_EXCL) { 931 d_add(dentry, NULL); 932 goto out; 933 } 934 935 /* Open the file on the server */ 936 lock_kernel(); 937 /* Revalidate parent directory attribute cache */ 938 error = nfs_revalidate_inode(NFS_SERVER(dir), dir); 939 if (error < 0) { 940 res = ERR_PTR(error); 941 unlock_kernel(); 942 goto out; 943 } 944 945 if (nd->intent.open.flags & O_CREAT) { 946 nfs_begin_data_update(dir); 947 res = nfs4_atomic_open(dir, dentry, nd); 948 nfs_end_data_update(dir); 949 } else 950 res = nfs4_atomic_open(dir, dentry, nd); 951 unlock_kernel(); 952 if (IS_ERR(res)) { 953 error = PTR_ERR(res); 954 switch (error) { 955 /* Make a negative dentry */ 956 case -ENOENT: 957 res = NULL; 958 goto out; 959 /* This turned out not to be a regular file */ 960 case -ELOOP: 961 if (!(nd->intent.open.flags & O_NOFOLLOW)) 962 goto no_open; 963 /* case -EISDIR: */ 964 /* case -EINVAL: */ 965 default: 966 goto out; 967 } 968 } else 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, nd); 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, nd); 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 } else 1538 new_inode->i_nlink--; 1539 1540 go_ahead: 1541 /* 1542 * ... prune child dentries and writebacks if needed. 1543 */ 1544 if (atomic_read(&old_dentry->d_count) > 1) { 1545 nfs_wb_all(old_inode); 1546 shrink_dcache_parent(old_dentry); 1547 } 1548 1549 if (new_inode) 1550 d_delete(new_dentry); 1551 1552 nfs_begin_data_update(old_dir); 1553 nfs_begin_data_update(new_dir); 1554 nfs_begin_data_update(old_inode); 1555 error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name, 1556 new_dir, &new_dentry->d_name); 1557 nfs_end_data_update(old_inode); 1558 nfs_end_data_update(new_dir); 1559 nfs_end_data_update(old_dir); 1560 out: 1561 if (rehash) 1562 d_rehash(rehash); 1563 if (!error) { 1564 if (!S_ISDIR(old_inode->i_mode)) 1565 d_move(old_dentry, new_dentry); 1566 nfs_renew_times(new_dentry); 1567 nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir)); 1568 } 1569 1570 /* new dentry created? */ 1571 if (dentry) 1572 dput(dentry); 1573 unlock_kernel(); 1574 return error; 1575 } 1576 1577 int nfs_access_get_cached(struct inode *inode, struct rpc_cred *cred, struct nfs_access_entry *res) 1578 { 1579 struct nfs_inode *nfsi = NFS_I(inode); 1580 struct nfs_access_entry *cache = &nfsi->cache_access; 1581 1582 if (cache->cred != cred 1583 || time_after(jiffies, cache->jiffies + NFS_ATTRTIMEO(inode)) 1584 || (nfsi->cache_validity & NFS_INO_INVALID_ACCESS)) 1585 return -ENOENT; 1586 memcpy(res, cache, sizeof(*res)); 1587 return 0; 1588 } 1589 1590 void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 1591 { 1592 struct nfs_inode *nfsi = NFS_I(inode); 1593 struct nfs_access_entry *cache = &nfsi->cache_access; 1594 1595 if (cache->cred != set->cred) { 1596 if (cache->cred) 1597 put_rpccred(cache->cred); 1598 cache->cred = get_rpccred(set->cred); 1599 } 1600 /* FIXME: replace current access_cache BKL reliance with inode->i_lock */ 1601 spin_lock(&inode->i_lock); 1602 nfsi->cache_validity &= ~NFS_INO_INVALID_ACCESS; 1603 spin_unlock(&inode->i_lock); 1604 cache->jiffies = set->jiffies; 1605 cache->mask = set->mask; 1606 } 1607 1608 static int nfs_do_access(struct inode *inode, struct rpc_cred *cred, int mask) 1609 { 1610 struct nfs_access_entry cache; 1611 int status; 1612 1613 status = nfs_access_get_cached(inode, cred, &cache); 1614 if (status == 0) 1615 goto out; 1616 1617 /* Be clever: ask server to check for all possible rights */ 1618 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ; 1619 cache.cred = cred; 1620 cache.jiffies = jiffies; 1621 status = NFS_PROTO(inode)->access(inode, &cache); 1622 if (status != 0) 1623 return status; 1624 nfs_access_add_cache(inode, &cache); 1625 out: 1626 if ((cache.mask & mask) == mask) 1627 return 0; 1628 return -EACCES; 1629 } 1630 1631 int nfs_permission(struct inode *inode, int mask, struct nameidata *nd) 1632 { 1633 struct rpc_cred *cred; 1634 int res = 0; 1635 1636 if (mask == 0) 1637 goto out; 1638 /* Is this sys_access() ? */ 1639 if (nd != NULL && (nd->flags & LOOKUP_ACCESS)) 1640 goto force_lookup; 1641 1642 switch (inode->i_mode & S_IFMT) { 1643 case S_IFLNK: 1644 goto out; 1645 case S_IFREG: 1646 /* NFSv4 has atomic_open... */ 1647 if (nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN) 1648 && nd != NULL 1649 && (nd->flags & LOOKUP_OPEN)) 1650 goto out; 1651 break; 1652 case S_IFDIR: 1653 /* 1654 * Optimize away all write operations, since the server 1655 * will check permissions when we perform the op. 1656 */ 1657 if ((mask & MAY_WRITE) && !(mask & MAY_READ)) 1658 goto out; 1659 } 1660 1661 force_lookup: 1662 lock_kernel(); 1663 1664 if (!NFS_PROTO(inode)->access) 1665 goto out_notsup; 1666 1667 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0); 1668 if (!IS_ERR(cred)) { 1669 res = nfs_do_access(inode, cred, mask); 1670 put_rpccred(cred); 1671 } else 1672 res = PTR_ERR(cred); 1673 unlock_kernel(); 1674 out: 1675 return res; 1676 out_notsup: 1677 res = nfs_revalidate_inode(NFS_SERVER(inode), inode); 1678 if (res == 0) 1679 res = generic_permission(inode, mask, NULL); 1680 unlock_kernel(); 1681 return res; 1682 } 1683 1684 /* 1685 * Local variables: 1686 * version-control: t 1687 * kept-new-versions: 5 1688 * End: 1689 */ 1690