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/slab.h> 16 #include <linux/fs.h> 17 #include <linux/pagemap.h> 18 #include <linux/ctype.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 }; 47 48 const struct inode_operations afs_dir_inode_operations = { 49 .create = afs_create, 50 .lookup = afs_lookup, 51 .link = afs_link, 52 .unlink = afs_unlink, 53 .symlink = afs_symlink, 54 .mkdir = afs_mkdir, 55 .rmdir = afs_rmdir, 56 .rename = afs_rename, 57 .permission = afs_permission, 58 .getattr = afs_inode_getattr, 59 }; 60 61 static struct dentry_operations afs_fs_dentry_operations = { 62 .d_revalidate = afs_d_revalidate, 63 .d_delete = afs_d_delete, 64 .d_release = afs_d_release, 65 }; 66 67 #define AFS_DIR_HASHTBL_SIZE 128 68 #define AFS_DIR_DIRENT_SIZE 32 69 #define AFS_DIRENT_PER_BLOCK 64 70 71 union afs_dirent { 72 struct { 73 uint8_t valid; 74 uint8_t unused[1]; 75 __be16 hash_next; 76 __be32 vnode; 77 __be32 unique; 78 uint8_t name[16]; 79 uint8_t overflow[4]; /* if any char of the name (inc 80 * NUL) reaches here, consume 81 * the next dirent too */ 82 } u; 83 uint8_t extended_name[32]; 84 }; 85 86 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */ 87 struct afs_dir_pagehdr { 88 __be16 npages; 89 __be16 magic; 90 #define AFS_DIR_MAGIC htons(1234) 91 uint8_t nentries; 92 uint8_t bitmap[8]; 93 uint8_t pad[19]; 94 }; 95 96 /* directory block layout */ 97 union afs_dir_block { 98 99 struct afs_dir_pagehdr pagehdr; 100 101 struct { 102 struct afs_dir_pagehdr pagehdr; 103 uint8_t alloc_ctrs[128]; 104 /* dir hash table */ 105 uint16_t hashtable[AFS_DIR_HASHTBL_SIZE]; 106 } hdr; 107 108 union afs_dirent dirents[AFS_DIRENT_PER_BLOCK]; 109 }; 110 111 /* layout on a linux VM page */ 112 struct afs_dir_page { 113 union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)]; 114 }; 115 116 struct afs_lookup_cookie { 117 struct afs_fid fid; 118 const char *name; 119 size_t nlen; 120 int found; 121 }; 122 123 /* 124 * check that a directory page is valid 125 */ 126 static inline void afs_dir_check_page(struct inode *dir, struct page *page) 127 { 128 struct afs_dir_page *dbuf; 129 loff_t latter; 130 int tmp, qty; 131 132 #if 0 133 /* check the page count */ 134 qty = desc.size / sizeof(dbuf->blocks[0]); 135 if (qty == 0) 136 goto error; 137 138 if (page->index == 0 && qty != ntohs(dbuf->blocks[0].pagehdr.npages)) { 139 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n", 140 __FUNCTION__, dir->i_ino, qty, 141 ntohs(dbuf->blocks[0].pagehdr.npages)); 142 goto error; 143 } 144 #endif 145 146 /* determine how many magic numbers there should be in this page */ 147 latter = dir->i_size - page_offset(page); 148 if (latter >= PAGE_SIZE) 149 qty = PAGE_SIZE; 150 else 151 qty = latter; 152 qty /= sizeof(union afs_dir_block); 153 154 /* check them */ 155 dbuf = page_address(page); 156 for (tmp = 0; tmp < qty; tmp++) { 157 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) { 158 printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n", 159 __FUNCTION__, dir->i_ino, tmp, qty, 160 ntohs(dbuf->blocks[tmp].pagehdr.magic)); 161 goto error; 162 } 163 } 164 165 SetPageChecked(page); 166 return; 167 168 error: 169 SetPageChecked(page); 170 SetPageError(page); 171 } 172 173 /* 174 * discard a page cached in the pagecache 175 */ 176 static inline void afs_dir_put_page(struct page *page) 177 { 178 kunmap(page); 179 page_cache_release(page); 180 } 181 182 /* 183 * get a page into the pagecache 184 */ 185 static struct page *afs_dir_get_page(struct inode *dir, unsigned long index, 186 struct key *key) 187 { 188 struct page *page; 189 struct file file = { 190 .private_data = key, 191 }; 192 193 _enter("{%lu},%lu", dir->i_ino, index); 194 195 page = read_mapping_page(dir->i_mapping, index, &file); 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 * look up an entry in a directory 482 */ 483 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 484 struct nameidata *nd) 485 { 486 struct afs_vnode *vnode; 487 struct afs_fid fid; 488 struct inode *inode; 489 struct key *key; 490 int ret; 491 492 vnode = AFS_FS_I(dir); 493 494 _enter("{%x:%d},%p{%s},", 495 vnode->fid.vid, vnode->fid.vnode, dentry, dentry->d_name.name); 496 497 ASSERTCMP(dentry->d_inode, ==, NULL); 498 499 if (dentry->d_name.len > 255) { 500 _leave(" = -ENAMETOOLONG"); 501 return ERR_PTR(-ENAMETOOLONG); 502 } 503 504 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { 505 _leave(" = -ESTALE"); 506 return ERR_PTR(-ESTALE); 507 } 508 509 key = afs_request_key(vnode->volume->cell); 510 if (IS_ERR(key)) { 511 _leave(" = %ld [key]", PTR_ERR(key)); 512 return ERR_PTR(PTR_ERR(key)); 513 } 514 515 ret = afs_validate(vnode, key); 516 if (ret < 0) { 517 key_put(key); 518 _leave(" = %d [val]", ret); 519 return ERR_PTR(ret); 520 } 521 522 ret = afs_do_lookup(dir, dentry, &fid, key); 523 if (ret < 0) { 524 key_put(key); 525 if (ret == -ENOENT) { 526 d_add(dentry, NULL); 527 _leave(" = NULL [negative]"); 528 return NULL; 529 } 530 _leave(" = %d [do]", ret); 531 return ERR_PTR(ret); 532 } 533 dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version; 534 535 /* instantiate the dentry */ 536 inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL); 537 key_put(key); 538 if (IS_ERR(inode)) { 539 _leave(" = %ld", PTR_ERR(inode)); 540 return ERR_PTR(PTR_ERR(inode)); 541 } 542 543 dentry->d_op = &afs_fs_dentry_operations; 544 545 d_add(dentry, inode); 546 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%lu }", 547 fid.vnode, 548 fid.unique, 549 dentry->d_inode->i_ino, 550 dentry->d_inode->i_version); 551 552 return NULL; 553 } 554 555 /* 556 * check that a dentry lookup hit has found a valid entry 557 * - NOTE! the hit can be a negative hit too, so we can't assume we have an 558 * inode 559 */ 560 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd) 561 { 562 struct afs_vnode *vnode, *dir; 563 struct afs_fid fid; 564 struct dentry *parent; 565 struct key *key; 566 void *dir_version; 567 int ret; 568 569 vnode = AFS_FS_I(dentry->d_inode); 570 571 if (dentry->d_inode) 572 _enter("{v={%x:%u} n=%s fl=%lx},", 573 vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name, 574 vnode->flags); 575 else 576 _enter("{neg n=%s}", dentry->d_name.name); 577 578 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell); 579 if (IS_ERR(key)) 580 key = NULL; 581 582 /* lock down the parent dentry so we can peer at it */ 583 parent = dget_parent(dentry); 584 if (!parent->d_inode) 585 goto out_bad; 586 587 dir = AFS_FS_I(parent->d_inode); 588 589 /* validate the parent directory */ 590 if (test_bit(AFS_VNODE_MODIFIED, &dir->flags)) 591 afs_validate(dir, key); 592 593 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) { 594 _debug("%s: parent dir deleted", dentry->d_name.name); 595 goto out_bad; 596 } 597 598 dir_version = (void *) (unsigned long) dir->status.data_version; 599 if (dentry->d_fsdata == dir_version) 600 goto out_valid; /* the dir contents are unchanged */ 601 602 _debug("dir modified"); 603 604 /* search the directory for this vnode */ 605 ret = afs_do_lookup(&dir->vfs_inode, dentry, &fid, key); 606 switch (ret) { 607 case 0: 608 /* the filename maps to something */ 609 if (!dentry->d_inode) 610 goto out_bad; 611 if (is_bad_inode(dentry->d_inode)) { 612 printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n", 613 parent->d_name.name, dentry->d_name.name); 614 goto out_bad; 615 } 616 617 /* if the vnode ID has changed, then the dirent points to a 618 * different file */ 619 if (fid.vnode != vnode->fid.vnode) { 620 _debug("%s: dirent changed [%u != %u]", 621 dentry->d_name.name, fid.vnode, 622 vnode->fid.vnode); 623 goto not_found; 624 } 625 626 /* if the vnode ID uniqifier has changed, then the file has 627 * been deleted and replaced, and the original vnode ID has 628 * been reused */ 629 if (fid.unique != vnode->fid.unique) { 630 _debug("%s: file deleted (uq %u -> %u I:%lu)", 631 dentry->d_name.name, fid.unique, 632 vnode->fid.unique, dentry->d_inode->i_version); 633 spin_lock(&vnode->lock); 634 set_bit(AFS_VNODE_DELETED, &vnode->flags); 635 spin_unlock(&vnode->lock); 636 goto not_found; 637 } 638 goto out_valid; 639 640 case -ENOENT: 641 /* the filename is unknown */ 642 _debug("%s: dirent not found", dentry->d_name.name); 643 if (dentry->d_inode) 644 goto not_found; 645 goto out_valid; 646 647 default: 648 _debug("failed to iterate dir %s: %d", 649 parent->d_name.name, ret); 650 goto out_bad; 651 } 652 653 out_valid: 654 dentry->d_fsdata = dir_version; 655 out_skip: 656 dput(parent); 657 key_put(key); 658 _leave(" = 1 [valid]"); 659 return 1; 660 661 /* the dirent, if it exists, now points to a different vnode */ 662 not_found: 663 spin_lock(&dentry->d_lock); 664 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 665 spin_unlock(&dentry->d_lock); 666 667 out_bad: 668 if (dentry->d_inode) { 669 /* don't unhash if we have submounts */ 670 if (have_submounts(dentry)) 671 goto out_skip; 672 } 673 674 _debug("dropping dentry %s/%s", 675 parent->d_name.name, dentry->d_name.name); 676 shrink_dcache_parent(dentry); 677 d_drop(dentry); 678 dput(parent); 679 key_put(key); 680 681 _leave(" = 0 [bad]"); 682 return 0; 683 } 684 685 /* 686 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't 687 * sleep) 688 * - called from dput() when d_count is going to 0. 689 * - return 1 to request dentry be unhashed, 0 otherwise 690 */ 691 static int afs_d_delete(struct dentry *dentry) 692 { 693 _enter("%s", dentry->d_name.name); 694 695 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 696 goto zap; 697 698 if (dentry->d_inode && 699 test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dentry->d_inode)->flags)) 700 goto zap; 701 702 _leave(" = 0 [keep]"); 703 return 0; 704 705 zap: 706 _leave(" = 1 [zap]"); 707 return 1; 708 } 709 710 /* 711 * handle dentry release 712 */ 713 static void afs_d_release(struct dentry *dentry) 714 { 715 _enter("%s", dentry->d_name.name); 716 } 717 718 /* 719 * create a directory on an AFS filesystem 720 */ 721 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 722 { 723 struct afs_file_status status; 724 struct afs_callback cb; 725 struct afs_server *server; 726 struct afs_vnode *dvnode, *vnode; 727 struct afs_fid fid; 728 struct inode *inode; 729 struct key *key; 730 int ret; 731 732 dvnode = AFS_FS_I(dir); 733 734 _enter("{%x:%d},{%s},%o", 735 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode); 736 737 ret = -ENAMETOOLONG; 738 if (dentry->d_name.len > 255) 739 goto error; 740 741 key = afs_request_key(dvnode->volume->cell); 742 if (IS_ERR(key)) { 743 ret = PTR_ERR(key); 744 goto error; 745 } 746 747 mode |= S_IFDIR; 748 ret = afs_vnode_create(dvnode, key, dentry->d_name.name, 749 mode, &fid, &status, &cb, &server); 750 if (ret < 0) 751 goto mkdir_error; 752 753 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb); 754 if (IS_ERR(inode)) { 755 /* ENOMEM at a really inconvenient time - just abandon the new 756 * directory on the server */ 757 ret = PTR_ERR(inode); 758 goto iget_error; 759 } 760 761 /* apply the status report we've got for the new vnode */ 762 vnode = AFS_FS_I(inode); 763 spin_lock(&vnode->lock); 764 vnode->update_cnt++; 765 spin_unlock(&vnode->lock); 766 afs_vnode_finalise_status_update(vnode, server); 767 afs_put_server(server); 768 769 d_instantiate(dentry, inode); 770 if (d_unhashed(dentry)) { 771 _debug("not hashed"); 772 d_rehash(dentry); 773 } 774 key_put(key); 775 _leave(" = 0"); 776 return 0; 777 778 iget_error: 779 afs_put_server(server); 780 mkdir_error: 781 key_put(key); 782 error: 783 d_drop(dentry); 784 _leave(" = %d", ret); 785 return ret; 786 } 787 788 /* 789 * remove a directory from an AFS filesystem 790 */ 791 static int afs_rmdir(struct inode *dir, struct dentry *dentry) 792 { 793 struct afs_vnode *dvnode, *vnode; 794 struct key *key; 795 int ret; 796 797 dvnode = AFS_FS_I(dir); 798 799 _enter("{%x:%d},{%s}", 800 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name); 801 802 ret = -ENAMETOOLONG; 803 if (dentry->d_name.len > 255) 804 goto error; 805 806 key = afs_request_key(dvnode->volume->cell); 807 if (IS_ERR(key)) { 808 ret = PTR_ERR(key); 809 goto error; 810 } 811 812 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, true); 813 if (ret < 0) 814 goto rmdir_error; 815 816 if (dentry->d_inode) { 817 vnode = AFS_FS_I(dentry->d_inode); 818 clear_nlink(&vnode->vfs_inode); 819 set_bit(AFS_VNODE_DELETED, &vnode->flags); 820 afs_discard_callback_on_delete(vnode); 821 } 822 823 key_put(key); 824 _leave(" = 0"); 825 return 0; 826 827 rmdir_error: 828 key_put(key); 829 error: 830 _leave(" = %d", ret); 831 return ret; 832 } 833 834 /* 835 * remove a file from an AFS filesystem 836 */ 837 static int afs_unlink(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:%d},{%s}", 846 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name); 847 848 ret = -ENAMETOOLONG; 849 if (dentry->d_name.len > 255) 850 goto error; 851 852 key = afs_request_key(dvnode->volume->cell); 853 if (IS_ERR(key)) { 854 ret = PTR_ERR(key); 855 goto error; 856 } 857 858 if (dentry->d_inode) { 859 vnode = AFS_FS_I(dentry->d_inode); 860 861 /* make sure we have a callback promise on the victim */ 862 ret = afs_validate(vnode, key); 863 if (ret < 0) 864 goto error; 865 } 866 867 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, false); 868 if (ret < 0) 869 goto remove_error; 870 871 if (dentry->d_inode) { 872 /* if the file wasn't deleted due to excess hard links, the 873 * fileserver will break the callback promise on the file - if 874 * it had one - before it returns to us, and if it was deleted, 875 * it won't 876 * 877 * however, if we didn't have a callback promise outstanding, 878 * or it was outstanding on a different server, then it won't 879 * break it either... 880 */ 881 vnode = AFS_FS_I(dentry->d_inode); 882 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 883 _debug("AFS_VNODE_DELETED"); 884 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) 885 _debug("AFS_VNODE_CB_BROKEN"); 886 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags); 887 ret = afs_validate(vnode, key); 888 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, ret); 889 } 890 891 key_put(key); 892 _leave(" = 0"); 893 return 0; 894 895 remove_error: 896 key_put(key); 897 error: 898 _leave(" = %d", ret); 899 return ret; 900 } 901 902 /* 903 * create a regular file on an AFS filesystem 904 */ 905 static int afs_create(struct inode *dir, struct dentry *dentry, int mode, 906 struct nameidata *nd) 907 { 908 struct afs_file_status status; 909 struct afs_callback cb; 910 struct afs_server *server; 911 struct afs_vnode *dvnode, *vnode; 912 struct afs_fid fid; 913 struct inode *inode; 914 struct key *key; 915 int ret; 916 917 dvnode = AFS_FS_I(dir); 918 919 _enter("{%x:%d},{%s},%o,", 920 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode); 921 922 ret = -ENAMETOOLONG; 923 if (dentry->d_name.len > 255) 924 goto error; 925 926 key = afs_request_key(dvnode->volume->cell); 927 if (IS_ERR(key)) { 928 ret = PTR_ERR(key); 929 goto error; 930 } 931 932 mode |= S_IFREG; 933 ret = afs_vnode_create(dvnode, key, dentry->d_name.name, 934 mode, &fid, &status, &cb, &server); 935 if (ret < 0) 936 goto create_error; 937 938 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb); 939 if (IS_ERR(inode)) { 940 /* ENOMEM at a really inconvenient time - just abandon the new 941 * directory on the server */ 942 ret = PTR_ERR(inode); 943 goto iget_error; 944 } 945 946 /* apply the status report we've got for the new vnode */ 947 vnode = AFS_FS_I(inode); 948 spin_lock(&vnode->lock); 949 vnode->update_cnt++; 950 spin_unlock(&vnode->lock); 951 afs_vnode_finalise_status_update(vnode, server); 952 afs_put_server(server); 953 954 d_instantiate(dentry, inode); 955 if (d_unhashed(dentry)) { 956 _debug("not hashed"); 957 d_rehash(dentry); 958 } 959 key_put(key); 960 _leave(" = 0"); 961 return 0; 962 963 iget_error: 964 afs_put_server(server); 965 create_error: 966 key_put(key); 967 error: 968 d_drop(dentry); 969 _leave(" = %d", ret); 970 return ret; 971 } 972 973 /* 974 * create a hard link between files in an AFS filesystem 975 */ 976 static int afs_link(struct dentry *from, struct inode *dir, 977 struct dentry *dentry) 978 { 979 struct afs_vnode *dvnode, *vnode; 980 struct key *key; 981 int ret; 982 983 vnode = AFS_FS_I(from->d_inode); 984 dvnode = AFS_FS_I(dir); 985 986 _enter("{%x:%d},{%x:%d},{%s}", 987 vnode->fid.vid, vnode->fid.vnode, 988 dvnode->fid.vid, dvnode->fid.vnode, 989 dentry->d_name.name); 990 991 ret = -ENAMETOOLONG; 992 if (dentry->d_name.len > 255) 993 goto error; 994 995 key = afs_request_key(dvnode->volume->cell); 996 if (IS_ERR(key)) { 997 ret = PTR_ERR(key); 998 goto error; 999 } 1000 1001 ret = afs_vnode_link(dvnode, vnode, key, dentry->d_name.name); 1002 if (ret < 0) 1003 goto link_error; 1004 1005 atomic_inc(&vnode->vfs_inode.i_count); 1006 d_instantiate(dentry, &vnode->vfs_inode); 1007 key_put(key); 1008 _leave(" = 0"); 1009 return 0; 1010 1011 link_error: 1012 key_put(key); 1013 error: 1014 d_drop(dentry); 1015 _leave(" = %d", ret); 1016 return ret; 1017 } 1018 1019 /* 1020 * create a symlink in an AFS filesystem 1021 */ 1022 static int afs_symlink(struct inode *dir, struct dentry *dentry, 1023 const char *content) 1024 { 1025 struct afs_file_status status; 1026 struct afs_server *server; 1027 struct afs_vnode *dvnode, *vnode; 1028 struct afs_fid fid; 1029 struct inode *inode; 1030 struct key *key; 1031 int ret; 1032 1033 dvnode = AFS_FS_I(dir); 1034 1035 _enter("{%x:%d},{%s},%s", 1036 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, 1037 content); 1038 1039 ret = -ENAMETOOLONG; 1040 if (dentry->d_name.len > 255) 1041 goto error; 1042 1043 ret = -EINVAL; 1044 if (strlen(content) > 1023) 1045 goto error; 1046 1047 key = afs_request_key(dvnode->volume->cell); 1048 if (IS_ERR(key)) { 1049 ret = PTR_ERR(key); 1050 goto error; 1051 } 1052 1053 ret = afs_vnode_symlink(dvnode, key, dentry->d_name.name, content, 1054 &fid, &status, &server); 1055 if (ret < 0) 1056 goto create_error; 1057 1058 inode = afs_iget(dir->i_sb, key, &fid, &status, NULL); 1059 if (IS_ERR(inode)) { 1060 /* ENOMEM at a really inconvenient time - just abandon the new 1061 * directory on the server */ 1062 ret = PTR_ERR(inode); 1063 goto iget_error; 1064 } 1065 1066 /* apply the status report we've got for the new vnode */ 1067 vnode = AFS_FS_I(inode); 1068 spin_lock(&vnode->lock); 1069 vnode->update_cnt++; 1070 spin_unlock(&vnode->lock); 1071 afs_vnode_finalise_status_update(vnode, server); 1072 afs_put_server(server); 1073 1074 d_instantiate(dentry, inode); 1075 if (d_unhashed(dentry)) { 1076 _debug("not hashed"); 1077 d_rehash(dentry); 1078 } 1079 key_put(key); 1080 _leave(" = 0"); 1081 return 0; 1082 1083 iget_error: 1084 afs_put_server(server); 1085 create_error: 1086 key_put(key); 1087 error: 1088 d_drop(dentry); 1089 _leave(" = %d", ret); 1090 return ret; 1091 } 1092 1093 /* 1094 * rename a file in an AFS filesystem and/or move it between directories 1095 */ 1096 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry, 1097 struct inode *new_dir, struct dentry *new_dentry) 1098 { 1099 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode; 1100 struct key *key; 1101 int ret; 1102 1103 vnode = AFS_FS_I(old_dentry->d_inode); 1104 orig_dvnode = AFS_FS_I(old_dir); 1105 new_dvnode = AFS_FS_I(new_dir); 1106 1107 _enter("{%x:%d},{%x:%d},{%x:%d},{%s}", 1108 orig_dvnode->fid.vid, orig_dvnode->fid.vnode, 1109 vnode->fid.vid, vnode->fid.vnode, 1110 new_dvnode->fid.vid, new_dvnode->fid.vnode, 1111 new_dentry->d_name.name); 1112 1113 ret = -ENAMETOOLONG; 1114 if (new_dentry->d_name.len > 255) 1115 goto error; 1116 1117 key = afs_request_key(orig_dvnode->volume->cell); 1118 if (IS_ERR(key)) { 1119 ret = PTR_ERR(key); 1120 goto error; 1121 } 1122 1123 ret = afs_vnode_rename(orig_dvnode, new_dvnode, key, 1124 old_dentry->d_name.name, 1125 new_dentry->d_name.name); 1126 if (ret < 0) 1127 goto rename_error; 1128 key_put(key); 1129 _leave(" = 0"); 1130 return 0; 1131 1132 rename_error: 1133 key_put(key); 1134 error: 1135 d_drop(new_dentry); 1136 _leave(" = %d", ret); 1137 return ret; 1138 } 1139