1 /* dir.c: AFS filesystem directory handling 2 * 3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/fs.h> 16 #include <linux/namei.h> 17 #include <linux/pagemap.h> 18 #include <linux/ctype.h> 19 #include <linux/sched.h> 20 #include "internal.h" 21 22 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 23 struct nameidata *nd); 24 static int afs_dir_open(struct inode *inode, struct file *file); 25 static int afs_readdir(struct file *file, void *dirent, filldir_t filldir); 26 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd); 27 static int afs_d_delete(const struct dentry *dentry); 28 static void afs_d_release(struct dentry *dentry); 29 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen, 30 loff_t fpos, u64 ino, unsigned dtype); 31 static int afs_create(struct inode *dir, struct dentry *dentry, int mode, 32 struct nameidata *nd); 33 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode); 34 static int afs_rmdir(struct inode *dir, struct dentry *dentry); 35 static int afs_unlink(struct inode *dir, struct dentry *dentry); 36 static int afs_link(struct dentry *from, struct inode *dir, 37 struct dentry *dentry); 38 static int afs_symlink(struct inode *dir, struct dentry *dentry, 39 const char *content); 40 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry, 41 struct inode *new_dir, struct dentry *new_dentry); 42 43 const struct file_operations afs_dir_file_operations = { 44 .open = afs_dir_open, 45 .release = afs_release, 46 .readdir = afs_readdir, 47 .lock = afs_lock, 48 .llseek = generic_file_llseek, 49 }; 50 51 const struct inode_operations afs_dir_inode_operations = { 52 .create = afs_create, 53 .lookup = afs_lookup, 54 .link = afs_link, 55 .unlink = afs_unlink, 56 .symlink = afs_symlink, 57 .mkdir = afs_mkdir, 58 .rmdir = afs_rmdir, 59 .rename = afs_rename, 60 .permission = afs_permission, 61 .getattr = afs_getattr, 62 .setattr = afs_setattr, 63 }; 64 65 const struct dentry_operations afs_fs_dentry_operations = { 66 .d_revalidate = afs_d_revalidate, 67 .d_delete = afs_d_delete, 68 .d_release = afs_d_release, 69 .d_automount = afs_d_automount, 70 }; 71 72 #define AFS_DIR_HASHTBL_SIZE 128 73 #define AFS_DIR_DIRENT_SIZE 32 74 #define AFS_DIRENT_PER_BLOCK 64 75 76 union afs_dirent { 77 struct { 78 uint8_t valid; 79 uint8_t unused[1]; 80 __be16 hash_next; 81 __be32 vnode; 82 __be32 unique; 83 uint8_t name[16]; 84 uint8_t overflow[4]; /* if any char of the name (inc 85 * NUL) reaches here, consume 86 * the next dirent too */ 87 } u; 88 uint8_t extended_name[32]; 89 }; 90 91 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */ 92 struct afs_dir_pagehdr { 93 __be16 npages; 94 __be16 magic; 95 #define AFS_DIR_MAGIC htons(1234) 96 uint8_t nentries; 97 uint8_t bitmap[8]; 98 uint8_t pad[19]; 99 }; 100 101 /* directory block layout */ 102 union afs_dir_block { 103 104 struct afs_dir_pagehdr pagehdr; 105 106 struct { 107 struct afs_dir_pagehdr pagehdr; 108 uint8_t alloc_ctrs[128]; 109 /* dir hash table */ 110 uint16_t hashtable[AFS_DIR_HASHTBL_SIZE]; 111 } hdr; 112 113 union afs_dirent dirents[AFS_DIRENT_PER_BLOCK]; 114 }; 115 116 /* layout on a linux VM page */ 117 struct afs_dir_page { 118 union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)]; 119 }; 120 121 struct afs_lookup_cookie { 122 struct afs_fid fid; 123 const char *name; 124 size_t nlen; 125 int found; 126 }; 127 128 /* 129 * check that a directory page is valid 130 */ 131 static inline void afs_dir_check_page(struct inode *dir, struct page *page) 132 { 133 struct afs_dir_page *dbuf; 134 loff_t latter; 135 int tmp, qty; 136 137 #if 0 138 /* check the page count */ 139 qty = desc.size / sizeof(dbuf->blocks[0]); 140 if (qty == 0) 141 goto error; 142 143 if (page->index == 0 && qty != ntohs(dbuf->blocks[0].pagehdr.npages)) { 144 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n", 145 __func__, dir->i_ino, qty, 146 ntohs(dbuf->blocks[0].pagehdr.npages)); 147 goto error; 148 } 149 #endif 150 151 /* determine how many magic numbers there should be in this page */ 152 latter = dir->i_size - page_offset(page); 153 if (latter >= PAGE_SIZE) 154 qty = PAGE_SIZE; 155 else 156 qty = latter; 157 qty /= sizeof(union afs_dir_block); 158 159 /* check them */ 160 dbuf = page_address(page); 161 for (tmp = 0; tmp < qty; tmp++) { 162 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) { 163 printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n", 164 __func__, dir->i_ino, tmp, qty, 165 ntohs(dbuf->blocks[tmp].pagehdr.magic)); 166 goto error; 167 } 168 } 169 170 SetPageChecked(page); 171 return; 172 173 error: 174 SetPageChecked(page); 175 SetPageError(page); 176 } 177 178 /* 179 * discard a page cached in the pagecache 180 */ 181 static inline void afs_dir_put_page(struct page *page) 182 { 183 kunmap(page); 184 page_cache_release(page); 185 } 186 187 /* 188 * get a page into the pagecache 189 */ 190 static struct page *afs_dir_get_page(struct inode *dir, unsigned long index, 191 struct key *key) 192 { 193 struct page *page; 194 _enter("{%lu},%lu", dir->i_ino, index); 195 196 page = read_cache_page(dir->i_mapping, index, afs_page_filler, key); 197 if (!IS_ERR(page)) { 198 kmap(page); 199 if (!PageChecked(page)) 200 afs_dir_check_page(dir, page); 201 if (PageError(page)) 202 goto fail; 203 } 204 return page; 205 206 fail: 207 afs_dir_put_page(page); 208 _leave(" = -EIO"); 209 return ERR_PTR(-EIO); 210 } 211 212 /* 213 * open an AFS directory file 214 */ 215 static int afs_dir_open(struct inode *inode, struct file *file) 216 { 217 _enter("{%lu}", inode->i_ino); 218 219 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048); 220 BUILD_BUG_ON(sizeof(union afs_dirent) != 32); 221 222 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags)) 223 return -ENOENT; 224 225 return afs_open(inode, file); 226 } 227 228 /* 229 * deal with one block in an AFS directory 230 */ 231 static int afs_dir_iterate_block(unsigned *fpos, 232 union afs_dir_block *block, 233 unsigned blkoff, 234 void *cookie, 235 filldir_t filldir) 236 { 237 union afs_dirent *dire; 238 unsigned offset, next, curr; 239 size_t nlen; 240 int tmp, ret; 241 242 _enter("%u,%x,%p,,",*fpos,blkoff,block); 243 244 curr = (*fpos - blkoff) / sizeof(union afs_dirent); 245 246 /* walk through the block, an entry at a time */ 247 for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries; 248 offset < AFS_DIRENT_PER_BLOCK; 249 offset = next 250 ) { 251 next = offset + 1; 252 253 /* skip entries marked unused in the bitmap */ 254 if (!(block->pagehdr.bitmap[offset / 8] & 255 (1 << (offset % 8)))) { 256 _debug("ENT[%Zu.%u]: unused", 257 blkoff / sizeof(union afs_dir_block), offset); 258 if (offset >= curr) 259 *fpos = blkoff + 260 next * sizeof(union afs_dirent); 261 continue; 262 } 263 264 /* got a valid entry */ 265 dire = &block->dirents[offset]; 266 nlen = strnlen(dire->u.name, 267 sizeof(*block) - 268 offset * sizeof(union afs_dirent)); 269 270 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"", 271 blkoff / sizeof(union afs_dir_block), offset, 272 (offset < curr ? "skip" : "fill"), 273 nlen, dire->u.name); 274 275 /* work out where the next possible entry is */ 276 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) { 277 if (next >= AFS_DIRENT_PER_BLOCK) { 278 _debug("ENT[%Zu.%u]:" 279 " %u travelled beyond end dir block" 280 " (len %u/%Zu)", 281 blkoff / sizeof(union afs_dir_block), 282 offset, next, tmp, nlen); 283 return -EIO; 284 } 285 if (!(block->pagehdr.bitmap[next / 8] & 286 (1 << (next % 8)))) { 287 _debug("ENT[%Zu.%u]:" 288 " %u unmarked extension (len %u/%Zu)", 289 blkoff / sizeof(union afs_dir_block), 290 offset, next, tmp, nlen); 291 return -EIO; 292 } 293 294 _debug("ENT[%Zu.%u]: ext %u/%Zu", 295 blkoff / sizeof(union afs_dir_block), 296 next, tmp, nlen); 297 next++; 298 } 299 300 /* skip if starts before the current position */ 301 if (offset < curr) 302 continue; 303 304 /* found the next entry */ 305 ret = filldir(cookie, 306 dire->u.name, 307 nlen, 308 blkoff + offset * sizeof(union afs_dirent), 309 ntohl(dire->u.vnode), 310 filldir == afs_lookup_filldir ? 311 ntohl(dire->u.unique) : DT_UNKNOWN); 312 if (ret < 0) { 313 _leave(" = 0 [full]"); 314 return 0; 315 } 316 317 *fpos = blkoff + next * sizeof(union afs_dirent); 318 } 319 320 _leave(" = 1 [more]"); 321 return 1; 322 } 323 324 /* 325 * iterate through the data blob that lists the contents of an AFS directory 326 */ 327 static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie, 328 filldir_t filldir, struct key *key) 329 { 330 union afs_dir_block *dblock; 331 struct afs_dir_page *dbuf; 332 struct page *page; 333 unsigned blkoff, limit; 334 int ret; 335 336 _enter("{%lu},%u,,", dir->i_ino, *fpos); 337 338 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) { 339 _leave(" = -ESTALE"); 340 return -ESTALE; 341 } 342 343 /* round the file position up to the next entry boundary */ 344 *fpos += sizeof(union afs_dirent) - 1; 345 *fpos &= ~(sizeof(union afs_dirent) - 1); 346 347 /* walk through the blocks in sequence */ 348 ret = 0; 349 while (*fpos < dir->i_size) { 350 blkoff = *fpos & ~(sizeof(union afs_dir_block) - 1); 351 352 /* fetch the appropriate page from the directory */ 353 page = afs_dir_get_page(dir, blkoff / PAGE_SIZE, key); 354 if (IS_ERR(page)) { 355 ret = PTR_ERR(page); 356 break; 357 } 358 359 limit = blkoff & ~(PAGE_SIZE - 1); 360 361 dbuf = page_address(page); 362 363 /* deal with the individual blocks stashed on this page */ 364 do { 365 dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) / 366 sizeof(union afs_dir_block)]; 367 ret = afs_dir_iterate_block(fpos, dblock, blkoff, 368 cookie, filldir); 369 if (ret != 1) { 370 afs_dir_put_page(page); 371 goto out; 372 } 373 374 blkoff += sizeof(union afs_dir_block); 375 376 } while (*fpos < dir->i_size && blkoff < limit); 377 378 afs_dir_put_page(page); 379 ret = 0; 380 } 381 382 out: 383 _leave(" = %d", ret); 384 return ret; 385 } 386 387 /* 388 * read an AFS directory 389 */ 390 static int afs_readdir(struct file *file, void *cookie, filldir_t filldir) 391 { 392 unsigned fpos; 393 int ret; 394 395 _enter("{%Ld,{%lu}}", 396 file->f_pos, file->f_path.dentry->d_inode->i_ino); 397 398 ASSERT(file->private_data != NULL); 399 400 fpos = file->f_pos; 401 ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos, 402 cookie, filldir, file->private_data); 403 file->f_pos = fpos; 404 405 _leave(" = %d", ret); 406 return ret; 407 } 408 409 /* 410 * search the directory for a name 411 * - if afs_dir_iterate_block() spots this function, it'll pass the FID 412 * uniquifier through dtype 413 */ 414 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen, 415 loff_t fpos, u64 ino, unsigned dtype) 416 { 417 struct afs_lookup_cookie *cookie = _cookie; 418 419 _enter("{%s,%Zu},%s,%u,,%llu,%u", 420 cookie->name, cookie->nlen, name, nlen, 421 (unsigned long long) ino, dtype); 422 423 /* insanity checks first */ 424 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048); 425 BUILD_BUG_ON(sizeof(union afs_dirent) != 32); 426 427 if (cookie->nlen != nlen || memcmp(cookie->name, name, nlen) != 0) { 428 _leave(" = 0 [no]"); 429 return 0; 430 } 431 432 cookie->fid.vnode = ino; 433 cookie->fid.unique = dtype; 434 cookie->found = 1; 435 436 _leave(" = -1 [found]"); 437 return -1; 438 } 439 440 /* 441 * do a lookup in a directory 442 * - just returns the FID the dentry name maps to if found 443 */ 444 static int afs_do_lookup(struct inode *dir, struct dentry *dentry, 445 struct afs_fid *fid, struct key *key) 446 { 447 struct afs_lookup_cookie cookie; 448 struct afs_super_info *as; 449 unsigned fpos; 450 int ret; 451 452 _enter("{%lu},%p{%s},", dir->i_ino, dentry, dentry->d_name.name); 453 454 as = dir->i_sb->s_fs_info; 455 456 /* search the directory */ 457 cookie.name = dentry->d_name.name; 458 cookie.nlen = dentry->d_name.len; 459 cookie.fid.vid = as->volume->vid; 460 cookie.found = 0; 461 462 fpos = 0; 463 ret = afs_dir_iterate(dir, &fpos, &cookie, afs_lookup_filldir, 464 key); 465 if (ret < 0) { 466 _leave(" = %d [iter]", ret); 467 return ret; 468 } 469 470 ret = -ENOENT; 471 if (!cookie.found) { 472 _leave(" = -ENOENT [not found]"); 473 return -ENOENT; 474 } 475 476 *fid = cookie.fid; 477 _leave(" = 0 { vn=%u u=%u }", fid->vnode, fid->unique); 478 return 0; 479 } 480 481 /* 482 * Try to auto mount the mountpoint with pseudo directory, if the autocell 483 * operation is setted. 484 */ 485 static struct inode *afs_try_auto_mntpt( 486 int ret, struct dentry *dentry, struct inode *dir, struct key *key, 487 struct afs_fid *fid) 488 { 489 const char *devname = dentry->d_name.name; 490 struct afs_vnode *vnode = AFS_FS_I(dir); 491 struct inode *inode; 492 493 _enter("%d, %p{%s}, {%x:%u}, %p", 494 ret, dentry, devname, vnode->fid.vid, vnode->fid.vnode, key); 495 496 if (ret != -ENOENT || 497 !test_bit(AFS_VNODE_AUTOCELL, &vnode->flags)) 498 goto out; 499 500 inode = afs_iget_autocell(dir, devname, strlen(devname), key); 501 if (IS_ERR(inode)) { 502 ret = PTR_ERR(inode); 503 goto out; 504 } 505 506 *fid = AFS_FS_I(inode)->fid; 507 _leave("= %p", inode); 508 return inode; 509 510 out: 511 _leave("= %d", ret); 512 return ERR_PTR(ret); 513 } 514 515 /* 516 * look up an entry in a directory 517 */ 518 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 519 struct nameidata *nd) 520 { 521 struct afs_vnode *vnode; 522 struct afs_fid fid; 523 struct inode *inode; 524 struct key *key; 525 int ret; 526 527 vnode = AFS_FS_I(dir); 528 529 _enter("{%x:%u},%p{%s},", 530 vnode->fid.vid, vnode->fid.vnode, dentry, dentry->d_name.name); 531 532 ASSERTCMP(dentry->d_inode, ==, NULL); 533 534 if (dentry->d_name.len >= AFSNAMEMAX) { 535 _leave(" = -ENAMETOOLONG"); 536 return ERR_PTR(-ENAMETOOLONG); 537 } 538 539 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { 540 _leave(" = -ESTALE"); 541 return ERR_PTR(-ESTALE); 542 } 543 544 key = afs_request_key(vnode->volume->cell); 545 if (IS_ERR(key)) { 546 _leave(" = %ld [key]", PTR_ERR(key)); 547 return ERR_CAST(key); 548 } 549 550 ret = afs_validate(vnode, key); 551 if (ret < 0) { 552 key_put(key); 553 _leave(" = %d [val]", ret); 554 return ERR_PTR(ret); 555 } 556 557 ret = afs_do_lookup(dir, dentry, &fid, key); 558 if (ret < 0) { 559 inode = afs_try_auto_mntpt(ret, dentry, dir, key, &fid); 560 if (!IS_ERR(inode)) { 561 key_put(key); 562 goto success; 563 } 564 565 ret = PTR_ERR(inode); 566 key_put(key); 567 if (ret == -ENOENT) { 568 d_add(dentry, NULL); 569 _leave(" = NULL [negative]"); 570 return NULL; 571 } 572 _leave(" = %d [do]", ret); 573 return ERR_PTR(ret); 574 } 575 dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version; 576 577 /* instantiate the dentry */ 578 inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL); 579 key_put(key); 580 if (IS_ERR(inode)) { 581 _leave(" = %ld", PTR_ERR(inode)); 582 return ERR_CAST(inode); 583 } 584 585 success: 586 d_add(dentry, inode); 587 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%llu }", 588 fid.vnode, 589 fid.unique, 590 dentry->d_inode->i_ino, 591 (unsigned long long)dentry->d_inode->i_version); 592 593 return NULL; 594 } 595 596 /* 597 * check that a dentry lookup hit has found a valid entry 598 * - NOTE! the hit can be a negative hit too, so we can't assume we have an 599 * inode 600 */ 601 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd) 602 { 603 struct afs_vnode *vnode, *dir; 604 struct afs_fid uninitialized_var(fid); 605 struct dentry *parent; 606 struct key *key; 607 void *dir_version; 608 int ret; 609 610 if (nd->flags & LOOKUP_RCU) 611 return -ECHILD; 612 613 vnode = AFS_FS_I(dentry->d_inode); 614 615 if (dentry->d_inode) 616 _enter("{v={%x:%u} n=%s fl=%lx},", 617 vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name, 618 vnode->flags); 619 else 620 _enter("{neg n=%s}", dentry->d_name.name); 621 622 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell); 623 if (IS_ERR(key)) 624 key = NULL; 625 626 /* lock down the parent dentry so we can peer at it */ 627 parent = dget_parent(dentry); 628 if (!parent->d_inode) 629 goto out_bad; 630 631 dir = AFS_FS_I(parent->d_inode); 632 633 /* validate the parent directory */ 634 if (test_bit(AFS_VNODE_MODIFIED, &dir->flags)) 635 afs_validate(dir, key); 636 637 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) { 638 _debug("%s: parent dir deleted", dentry->d_name.name); 639 goto out_bad; 640 } 641 642 dir_version = (void *) (unsigned long) dir->status.data_version; 643 if (dentry->d_fsdata == dir_version) 644 goto out_valid; /* the dir contents are unchanged */ 645 646 _debug("dir modified"); 647 648 /* search the directory for this vnode */ 649 ret = afs_do_lookup(&dir->vfs_inode, dentry, &fid, key); 650 switch (ret) { 651 case 0: 652 /* the filename maps to something */ 653 if (!dentry->d_inode) 654 goto out_bad; 655 if (is_bad_inode(dentry->d_inode)) { 656 printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n", 657 parent->d_name.name, dentry->d_name.name); 658 goto out_bad; 659 } 660 661 /* if the vnode ID has changed, then the dirent points to a 662 * different file */ 663 if (fid.vnode != vnode->fid.vnode) { 664 _debug("%s: dirent changed [%u != %u]", 665 dentry->d_name.name, fid.vnode, 666 vnode->fid.vnode); 667 goto not_found; 668 } 669 670 /* if the vnode ID uniqifier has changed, then the file has 671 * been deleted and replaced, and the original vnode ID has 672 * been reused */ 673 if (fid.unique != vnode->fid.unique) { 674 _debug("%s: file deleted (uq %u -> %u I:%llu)", 675 dentry->d_name.name, fid.unique, 676 vnode->fid.unique, 677 (unsigned long long)dentry->d_inode->i_version); 678 spin_lock(&vnode->lock); 679 set_bit(AFS_VNODE_DELETED, &vnode->flags); 680 spin_unlock(&vnode->lock); 681 goto not_found; 682 } 683 goto out_valid; 684 685 case -ENOENT: 686 /* the filename is unknown */ 687 _debug("%s: dirent not found", dentry->d_name.name); 688 if (dentry->d_inode) 689 goto not_found; 690 goto out_valid; 691 692 default: 693 _debug("failed to iterate dir %s: %d", 694 parent->d_name.name, ret); 695 goto out_bad; 696 } 697 698 out_valid: 699 dentry->d_fsdata = dir_version; 700 out_skip: 701 dput(parent); 702 key_put(key); 703 _leave(" = 1 [valid]"); 704 return 1; 705 706 /* the dirent, if it exists, now points to a different vnode */ 707 not_found: 708 spin_lock(&dentry->d_lock); 709 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 710 spin_unlock(&dentry->d_lock); 711 712 out_bad: 713 if (dentry->d_inode) { 714 /* don't unhash if we have submounts */ 715 if (have_submounts(dentry)) 716 goto out_skip; 717 } 718 719 _debug("dropping dentry %s/%s", 720 parent->d_name.name, dentry->d_name.name); 721 shrink_dcache_parent(dentry); 722 d_drop(dentry); 723 dput(parent); 724 key_put(key); 725 726 _leave(" = 0 [bad]"); 727 return 0; 728 } 729 730 /* 731 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't 732 * sleep) 733 * - called from dput() when d_count is going to 0. 734 * - return 1 to request dentry be unhashed, 0 otherwise 735 */ 736 static int afs_d_delete(const struct dentry *dentry) 737 { 738 _enter("%s", dentry->d_name.name); 739 740 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 741 goto zap; 742 743 if (dentry->d_inode && 744 (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dentry->d_inode)->flags) || 745 test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(dentry->d_inode)->flags))) 746 goto zap; 747 748 _leave(" = 0 [keep]"); 749 return 0; 750 751 zap: 752 _leave(" = 1 [zap]"); 753 return 1; 754 } 755 756 /* 757 * handle dentry release 758 */ 759 static void afs_d_release(struct dentry *dentry) 760 { 761 _enter("%s", dentry->d_name.name); 762 } 763 764 /* 765 * create a directory on an AFS filesystem 766 */ 767 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 768 { 769 struct afs_file_status status; 770 struct afs_callback cb; 771 struct afs_server *server; 772 struct afs_vnode *dvnode, *vnode; 773 struct afs_fid fid; 774 struct inode *inode; 775 struct key *key; 776 int ret; 777 778 dvnode = AFS_FS_I(dir); 779 780 _enter("{%x:%u},{%s},%o", 781 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode); 782 783 ret = -ENAMETOOLONG; 784 if (dentry->d_name.len >= AFSNAMEMAX) 785 goto error; 786 787 key = afs_request_key(dvnode->volume->cell); 788 if (IS_ERR(key)) { 789 ret = PTR_ERR(key); 790 goto error; 791 } 792 793 mode |= S_IFDIR; 794 ret = afs_vnode_create(dvnode, key, dentry->d_name.name, 795 mode, &fid, &status, &cb, &server); 796 if (ret < 0) 797 goto mkdir_error; 798 799 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb); 800 if (IS_ERR(inode)) { 801 /* ENOMEM at a really inconvenient time - just abandon the new 802 * directory on the server */ 803 ret = PTR_ERR(inode); 804 goto iget_error; 805 } 806 807 /* apply the status report we've got for the new vnode */ 808 vnode = AFS_FS_I(inode); 809 spin_lock(&vnode->lock); 810 vnode->update_cnt++; 811 spin_unlock(&vnode->lock); 812 afs_vnode_finalise_status_update(vnode, server); 813 afs_put_server(server); 814 815 d_instantiate(dentry, inode); 816 if (d_unhashed(dentry)) { 817 _debug("not hashed"); 818 d_rehash(dentry); 819 } 820 key_put(key); 821 _leave(" = 0"); 822 return 0; 823 824 iget_error: 825 afs_put_server(server); 826 mkdir_error: 827 key_put(key); 828 error: 829 d_drop(dentry); 830 _leave(" = %d", ret); 831 return ret; 832 } 833 834 /* 835 * remove a directory from an AFS filesystem 836 */ 837 static int afs_rmdir(struct inode *dir, struct dentry *dentry) 838 { 839 struct afs_vnode *dvnode, *vnode; 840 struct key *key; 841 int ret; 842 843 dvnode = AFS_FS_I(dir); 844 845 _enter("{%x:%u},{%s}", 846 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name); 847 848 dentry_unhash(dentry); 849 850 ret = -ENAMETOOLONG; 851 if (dentry->d_name.len >= AFSNAMEMAX) 852 goto error; 853 854 key = afs_request_key(dvnode->volume->cell); 855 if (IS_ERR(key)) { 856 ret = PTR_ERR(key); 857 goto error; 858 } 859 860 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, true); 861 if (ret < 0) 862 goto rmdir_error; 863 864 if (dentry->d_inode) { 865 vnode = AFS_FS_I(dentry->d_inode); 866 clear_nlink(&vnode->vfs_inode); 867 set_bit(AFS_VNODE_DELETED, &vnode->flags); 868 afs_discard_callback_on_delete(vnode); 869 } 870 871 key_put(key); 872 _leave(" = 0"); 873 return 0; 874 875 rmdir_error: 876 key_put(key); 877 error: 878 _leave(" = %d", ret); 879 return ret; 880 } 881 882 /* 883 * remove a file from an AFS filesystem 884 */ 885 static int afs_unlink(struct inode *dir, struct dentry *dentry) 886 { 887 struct afs_vnode *dvnode, *vnode; 888 struct key *key; 889 int ret; 890 891 dvnode = AFS_FS_I(dir); 892 893 _enter("{%x:%u},{%s}", 894 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name); 895 896 ret = -ENAMETOOLONG; 897 if (dentry->d_name.len >= AFSNAMEMAX) 898 goto error; 899 900 key = afs_request_key(dvnode->volume->cell); 901 if (IS_ERR(key)) { 902 ret = PTR_ERR(key); 903 goto error; 904 } 905 906 if (dentry->d_inode) { 907 vnode = AFS_FS_I(dentry->d_inode); 908 909 /* make sure we have a callback promise on the victim */ 910 ret = afs_validate(vnode, key); 911 if (ret < 0) 912 goto error; 913 } 914 915 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, false); 916 if (ret < 0) 917 goto remove_error; 918 919 if (dentry->d_inode) { 920 /* if the file wasn't deleted due to excess hard links, the 921 * fileserver will break the callback promise on the file - if 922 * it had one - before it returns to us, and if it was deleted, 923 * it won't 924 * 925 * however, if we didn't have a callback promise outstanding, 926 * or it was outstanding on a different server, then it won't 927 * break it either... 928 */ 929 vnode = AFS_FS_I(dentry->d_inode); 930 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 931 _debug("AFS_VNODE_DELETED"); 932 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) 933 _debug("AFS_VNODE_CB_BROKEN"); 934 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags); 935 ret = afs_validate(vnode, key); 936 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, ret); 937 } 938 939 key_put(key); 940 _leave(" = 0"); 941 return 0; 942 943 remove_error: 944 key_put(key); 945 error: 946 _leave(" = %d", ret); 947 return ret; 948 } 949 950 /* 951 * create a regular file on an AFS filesystem 952 */ 953 static int afs_create(struct inode *dir, struct dentry *dentry, int mode, 954 struct nameidata *nd) 955 { 956 struct afs_file_status status; 957 struct afs_callback cb; 958 struct afs_server *server; 959 struct afs_vnode *dvnode, *vnode; 960 struct afs_fid fid; 961 struct inode *inode; 962 struct key *key; 963 int ret; 964 965 dvnode = AFS_FS_I(dir); 966 967 _enter("{%x:%u},{%s},%o,", 968 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode); 969 970 ret = -ENAMETOOLONG; 971 if (dentry->d_name.len >= AFSNAMEMAX) 972 goto error; 973 974 key = afs_request_key(dvnode->volume->cell); 975 if (IS_ERR(key)) { 976 ret = PTR_ERR(key); 977 goto error; 978 } 979 980 mode |= S_IFREG; 981 ret = afs_vnode_create(dvnode, key, dentry->d_name.name, 982 mode, &fid, &status, &cb, &server); 983 if (ret < 0) 984 goto create_error; 985 986 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb); 987 if (IS_ERR(inode)) { 988 /* ENOMEM at a really inconvenient time - just abandon the new 989 * directory on the server */ 990 ret = PTR_ERR(inode); 991 goto iget_error; 992 } 993 994 /* apply the status report we've got for the new vnode */ 995 vnode = AFS_FS_I(inode); 996 spin_lock(&vnode->lock); 997 vnode->update_cnt++; 998 spin_unlock(&vnode->lock); 999 afs_vnode_finalise_status_update(vnode, server); 1000 afs_put_server(server); 1001 1002 d_instantiate(dentry, inode); 1003 if (d_unhashed(dentry)) { 1004 _debug("not hashed"); 1005 d_rehash(dentry); 1006 } 1007 key_put(key); 1008 _leave(" = 0"); 1009 return 0; 1010 1011 iget_error: 1012 afs_put_server(server); 1013 create_error: 1014 key_put(key); 1015 error: 1016 d_drop(dentry); 1017 _leave(" = %d", ret); 1018 return ret; 1019 } 1020 1021 /* 1022 * create a hard link between files in an AFS filesystem 1023 */ 1024 static int afs_link(struct dentry *from, struct inode *dir, 1025 struct dentry *dentry) 1026 { 1027 struct afs_vnode *dvnode, *vnode; 1028 struct key *key; 1029 int ret; 1030 1031 vnode = AFS_FS_I(from->d_inode); 1032 dvnode = AFS_FS_I(dir); 1033 1034 _enter("{%x:%u},{%x:%u},{%s}", 1035 vnode->fid.vid, vnode->fid.vnode, 1036 dvnode->fid.vid, dvnode->fid.vnode, 1037 dentry->d_name.name); 1038 1039 ret = -ENAMETOOLONG; 1040 if (dentry->d_name.len >= AFSNAMEMAX) 1041 goto error; 1042 1043 key = afs_request_key(dvnode->volume->cell); 1044 if (IS_ERR(key)) { 1045 ret = PTR_ERR(key); 1046 goto error; 1047 } 1048 1049 ret = afs_vnode_link(dvnode, vnode, key, dentry->d_name.name); 1050 if (ret < 0) 1051 goto link_error; 1052 1053 ihold(&vnode->vfs_inode); 1054 d_instantiate(dentry, &vnode->vfs_inode); 1055 key_put(key); 1056 _leave(" = 0"); 1057 return 0; 1058 1059 link_error: 1060 key_put(key); 1061 error: 1062 d_drop(dentry); 1063 _leave(" = %d", ret); 1064 return ret; 1065 } 1066 1067 /* 1068 * create a symlink in an AFS filesystem 1069 */ 1070 static int afs_symlink(struct inode *dir, struct dentry *dentry, 1071 const char *content) 1072 { 1073 struct afs_file_status status; 1074 struct afs_server *server; 1075 struct afs_vnode *dvnode, *vnode; 1076 struct afs_fid fid; 1077 struct inode *inode; 1078 struct key *key; 1079 int ret; 1080 1081 dvnode = AFS_FS_I(dir); 1082 1083 _enter("{%x:%u},{%s},%s", 1084 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, 1085 content); 1086 1087 ret = -ENAMETOOLONG; 1088 if (dentry->d_name.len >= AFSNAMEMAX) 1089 goto error; 1090 1091 ret = -EINVAL; 1092 if (strlen(content) >= AFSPATHMAX) 1093 goto error; 1094 1095 key = afs_request_key(dvnode->volume->cell); 1096 if (IS_ERR(key)) { 1097 ret = PTR_ERR(key); 1098 goto error; 1099 } 1100 1101 ret = afs_vnode_symlink(dvnode, key, dentry->d_name.name, content, 1102 &fid, &status, &server); 1103 if (ret < 0) 1104 goto create_error; 1105 1106 inode = afs_iget(dir->i_sb, key, &fid, &status, NULL); 1107 if (IS_ERR(inode)) { 1108 /* ENOMEM at a really inconvenient time - just abandon the new 1109 * directory on the server */ 1110 ret = PTR_ERR(inode); 1111 goto iget_error; 1112 } 1113 1114 /* apply the status report we've got for the new vnode */ 1115 vnode = AFS_FS_I(inode); 1116 spin_lock(&vnode->lock); 1117 vnode->update_cnt++; 1118 spin_unlock(&vnode->lock); 1119 afs_vnode_finalise_status_update(vnode, server); 1120 afs_put_server(server); 1121 1122 d_instantiate(dentry, inode); 1123 if (d_unhashed(dentry)) { 1124 _debug("not hashed"); 1125 d_rehash(dentry); 1126 } 1127 key_put(key); 1128 _leave(" = 0"); 1129 return 0; 1130 1131 iget_error: 1132 afs_put_server(server); 1133 create_error: 1134 key_put(key); 1135 error: 1136 d_drop(dentry); 1137 _leave(" = %d", ret); 1138 return ret; 1139 } 1140 1141 /* 1142 * rename a file in an AFS filesystem and/or move it between directories 1143 */ 1144 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry, 1145 struct inode *new_dir, struct dentry *new_dentry) 1146 { 1147 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode; 1148 struct key *key; 1149 int ret; 1150 1151 vnode = AFS_FS_I(old_dentry->d_inode); 1152 orig_dvnode = AFS_FS_I(old_dir); 1153 new_dvnode = AFS_FS_I(new_dir); 1154 1155 _enter("{%x:%u},{%x:%u},{%x:%u},{%s}", 1156 orig_dvnode->fid.vid, orig_dvnode->fid.vnode, 1157 vnode->fid.vid, vnode->fid.vnode, 1158 new_dvnode->fid.vid, new_dvnode->fid.vnode, 1159 new_dentry->d_name.name); 1160 1161 ret = -ENAMETOOLONG; 1162 if (new_dentry->d_name.len >= AFSNAMEMAX) 1163 goto error; 1164 1165 key = afs_request_key(orig_dvnode->volume->cell); 1166 if (IS_ERR(key)) { 1167 ret = PTR_ERR(key); 1168 goto error; 1169 } 1170 1171 ret = afs_vnode_rename(orig_dvnode, new_dvnode, key, 1172 old_dentry->d_name.name, 1173 new_dentry->d_name.name); 1174 if (ret < 0) 1175 goto rename_error; 1176 key_put(key); 1177 _leave(" = 0"); 1178 return 0; 1179 1180 rename_error: 1181 key_put(key); 1182 error: 1183 d_drop(new_dentry); 1184 _leave(" = %d", ret); 1185 return ret; 1186 } 1187