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