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