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