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