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