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