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/smp_lock.h> 19 #include "vnode.h" 20 #include "volume.h" 21 #include <rxrpc/call.h> 22 #include "super.h" 23 #include "internal.h" 24 25 static struct dentry *afs_dir_lookup(struct inode *dir, struct dentry *dentry, 26 struct nameidata *nd); 27 static int afs_dir_open(struct inode *inode, struct file *file); 28 static int afs_dir_readdir(struct file *file, void *dirent, filldir_t filldir); 29 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd); 30 static int afs_d_delete(struct dentry *dentry); 31 static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen, 32 loff_t fpos, u64 ino, unsigned dtype); 33 34 const struct file_operations afs_dir_file_operations = { 35 .open = afs_dir_open, 36 .readdir = afs_dir_readdir, 37 }; 38 39 const struct inode_operations afs_dir_inode_operations = { 40 .lookup = afs_dir_lookup, 41 .getattr = afs_inode_getattr, 42 #if 0 /* TODO */ 43 .create = afs_dir_create, 44 .link = afs_dir_link, 45 .unlink = afs_dir_unlink, 46 .symlink = afs_dir_symlink, 47 .mkdir = afs_dir_mkdir, 48 .rmdir = afs_dir_rmdir, 49 .mknod = afs_dir_mknod, 50 .rename = afs_dir_rename, 51 #endif 52 }; 53 54 static struct dentry_operations afs_fs_dentry_operations = { 55 .d_revalidate = afs_d_revalidate, 56 .d_delete = afs_d_delete, 57 }; 58 59 #define AFS_DIR_HASHTBL_SIZE 128 60 #define AFS_DIR_DIRENT_SIZE 32 61 #define AFS_DIRENT_PER_BLOCK 64 62 63 union afs_dirent { 64 struct { 65 uint8_t valid; 66 uint8_t unused[1]; 67 __be16 hash_next; 68 __be32 vnode; 69 __be32 unique; 70 uint8_t name[16]; 71 uint8_t overflow[4]; /* if any char of the name (inc 72 * NUL) reaches here, consume 73 * the next dirent too */ 74 } u; 75 uint8_t extended_name[32]; 76 }; 77 78 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */ 79 struct afs_dir_pagehdr { 80 __be16 npages; 81 __be16 magic; 82 #define AFS_DIR_MAGIC htons(1234) 83 uint8_t nentries; 84 uint8_t bitmap[8]; 85 uint8_t pad[19]; 86 }; 87 88 /* directory block layout */ 89 union afs_dir_block { 90 91 struct afs_dir_pagehdr pagehdr; 92 93 struct { 94 struct afs_dir_pagehdr pagehdr; 95 uint8_t alloc_ctrs[128]; 96 /* dir hash table */ 97 uint16_t hashtable[AFS_DIR_HASHTBL_SIZE]; 98 } hdr; 99 100 union afs_dirent dirents[AFS_DIRENT_PER_BLOCK]; 101 }; 102 103 /* layout on a linux VM page */ 104 struct afs_dir_page { 105 union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)]; 106 }; 107 108 struct afs_dir_lookup_cookie { 109 struct afs_fid fid; 110 const char *name; 111 size_t nlen; 112 int found; 113 }; 114 115 /*****************************************************************************/ 116 /* 117 * check that a directory page is valid 118 */ 119 static inline void afs_dir_check_page(struct inode *dir, struct page *page) 120 { 121 struct afs_dir_page *dbuf; 122 loff_t latter; 123 int tmp, qty; 124 125 #if 0 126 /* check the page count */ 127 qty = desc.size / sizeof(dbuf->blocks[0]); 128 if (qty == 0) 129 goto error; 130 131 if (page->index==0 && qty!=ntohs(dbuf->blocks[0].pagehdr.npages)) { 132 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n", 133 __FUNCTION__,dir->i_ino,qty,ntohs(dbuf->blocks[0].pagehdr.npages)); 134 goto error; 135 } 136 #endif 137 138 /* determine how many magic numbers there should be in this page */ 139 latter = dir->i_size - page_offset(page); 140 if (latter >= PAGE_SIZE) 141 qty = PAGE_SIZE; 142 else 143 qty = latter; 144 qty /= sizeof(union afs_dir_block); 145 146 /* check them */ 147 dbuf = page_address(page); 148 for (tmp = 0; tmp < qty; tmp++) { 149 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) { 150 printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n", 151 __FUNCTION__, dir->i_ino, tmp, qty, 152 ntohs(dbuf->blocks[tmp].pagehdr.magic)); 153 goto error; 154 } 155 } 156 157 SetPageChecked(page); 158 return; 159 160 error: 161 SetPageChecked(page); 162 SetPageError(page); 163 164 } /* end afs_dir_check_page() */ 165 166 /*****************************************************************************/ 167 /* 168 * discard a page cached in the pagecache 169 */ 170 static inline void afs_dir_put_page(struct page *page) 171 { 172 kunmap(page); 173 page_cache_release(page); 174 175 } /* end afs_dir_put_page() */ 176 177 /*****************************************************************************/ 178 /* 179 * get a page into the pagecache 180 */ 181 static struct page *afs_dir_get_page(struct inode *dir, unsigned long index) 182 { 183 struct page *page; 184 185 _enter("{%lu},%lu", dir->i_ino, index); 186 187 page = read_mapping_page(dir->i_mapping, index, NULL); 188 if (!IS_ERR(page)) { 189 wait_on_page_locked(page); 190 kmap(page); 191 if (!PageUptodate(page)) 192 goto fail; 193 if (!PageChecked(page)) 194 afs_dir_check_page(dir, page); 195 if (PageError(page)) 196 goto fail; 197 } 198 return page; 199 200 fail: 201 afs_dir_put_page(page); 202 return ERR_PTR(-EIO); 203 } /* end afs_dir_get_page() */ 204 205 /*****************************************************************************/ 206 /* 207 * open an AFS directory file 208 */ 209 static int afs_dir_open(struct inode *inode, struct file *file) 210 { 211 _enter("{%lu}", inode->i_ino); 212 213 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048); 214 BUILD_BUG_ON(sizeof(union afs_dirent) != 32); 215 216 if (AFS_FS_I(inode)->flags & AFS_VNODE_DELETED) 217 return -ENOENT; 218 219 _leave(" = 0"); 220 return 0; 221 222 } /* end afs_dir_open() */ 223 224 /*****************************************************************************/ 225 /* 226 * deal with one block in an AFS directory 227 */ 228 static int afs_dir_iterate_block(unsigned *fpos, 229 union afs_dir_block *block, 230 unsigned blkoff, 231 void *cookie, 232 filldir_t filldir) 233 { 234 union afs_dirent *dire; 235 unsigned offset, next, curr; 236 size_t nlen; 237 int tmp, ret; 238 239 _enter("%u,%x,%p,,",*fpos,blkoff,block); 240 241 curr = (*fpos - blkoff) / sizeof(union afs_dirent); 242 243 /* walk through the block, an entry at a time */ 244 for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries; 245 offset < AFS_DIRENT_PER_BLOCK; 246 offset = next 247 ) { 248 next = offset + 1; 249 250 /* skip entries marked unused in the bitmap */ 251 if (!(block->pagehdr.bitmap[offset / 8] & 252 (1 << (offset % 8)))) { 253 _debug("ENT[%Zu.%u]: unused\n", 254 blkoff / sizeof(union afs_dir_block), offset); 255 if (offset >= curr) 256 *fpos = blkoff + 257 next * sizeof(union afs_dirent); 258 continue; 259 } 260 261 /* got a valid entry */ 262 dire = &block->dirents[offset]; 263 nlen = strnlen(dire->u.name, 264 sizeof(*block) - 265 offset * sizeof(union afs_dirent)); 266 267 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"\n", 268 blkoff / sizeof(union afs_dir_block), offset, 269 (offset < curr ? "skip" : "fill"), 270 nlen, dire->u.name); 271 272 /* work out where the next possible entry is */ 273 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) { 274 if (next >= AFS_DIRENT_PER_BLOCK) { 275 _debug("ENT[%Zu.%u]:" 276 " %u travelled beyond end dir block" 277 " (len %u/%Zu)\n", 278 blkoff / sizeof(union afs_dir_block), 279 offset, next, tmp, nlen); 280 return -EIO; 281 } 282 if (!(block->pagehdr.bitmap[next / 8] & 283 (1 << (next % 8)))) { 284 _debug("ENT[%Zu.%u]:" 285 " %u unmarked extension (len %u/%Zu)\n", 286 blkoff / sizeof(union afs_dir_block), 287 offset, next, tmp, nlen); 288 return -EIO; 289 } 290 291 _debug("ENT[%Zu.%u]: ext %u/%Zu\n", 292 blkoff / sizeof(union afs_dir_block), 293 next, tmp, nlen); 294 next++; 295 } 296 297 /* skip if starts before the current position */ 298 if (offset < curr) 299 continue; 300 301 /* found the next entry */ 302 ret = filldir(cookie, 303 dire->u.name, 304 nlen, 305 blkoff + offset * sizeof(union afs_dirent), 306 ntohl(dire->u.vnode), 307 filldir == afs_dir_lookup_filldir ? 308 ntohl(dire->u.unique) : DT_UNKNOWN); 309 if (ret < 0) { 310 _leave(" = 0 [full]"); 311 return 0; 312 } 313 314 *fpos = blkoff + next * sizeof(union afs_dirent); 315 } 316 317 _leave(" = 1 [more]"); 318 return 1; 319 } /* end afs_dir_iterate_block() */ 320 321 /*****************************************************************************/ 322 /* 323 * read an AFS directory 324 */ 325 static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie, 326 filldir_t filldir) 327 { 328 union afs_dir_block *dblock; 329 struct afs_dir_page *dbuf; 330 struct page *page; 331 unsigned blkoff, limit; 332 int ret; 333 334 _enter("{%lu},%u,,", dir->i_ino, *fpos); 335 336 if (AFS_FS_I(dir)->flags & AFS_VNODE_DELETED) { 337 _leave(" = -ESTALE"); 338 return -ESTALE; 339 } 340 341 /* round the file position up to the next entry boundary */ 342 *fpos += sizeof(union afs_dirent) - 1; 343 *fpos &= ~(sizeof(union afs_dirent) - 1); 344 345 /* walk through the blocks in sequence */ 346 ret = 0; 347 while (*fpos < dir->i_size) { 348 blkoff = *fpos & ~(sizeof(union afs_dir_block) - 1); 349 350 /* fetch the appropriate page from the directory */ 351 page = afs_dir_get_page(dir, blkoff / PAGE_SIZE); 352 if (IS_ERR(page)) { 353 ret = PTR_ERR(page); 354 break; 355 } 356 357 limit = blkoff & ~(PAGE_SIZE - 1); 358 359 dbuf = page_address(page); 360 361 /* deal with the individual blocks stashed on this page */ 362 do { 363 dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) / 364 sizeof(union afs_dir_block)]; 365 ret = afs_dir_iterate_block(fpos, dblock, blkoff, 366 cookie, filldir); 367 if (ret != 1) { 368 afs_dir_put_page(page); 369 goto out; 370 } 371 372 blkoff += sizeof(union afs_dir_block); 373 374 } while (*fpos < dir->i_size && blkoff < limit); 375 376 afs_dir_put_page(page); 377 ret = 0; 378 } 379 380 out: 381 _leave(" = %d", ret); 382 return ret; 383 } /* end afs_dir_iterate() */ 384 385 /*****************************************************************************/ 386 /* 387 * read an AFS directory 388 */ 389 static int afs_dir_readdir(struct file *file, void *cookie, filldir_t filldir) 390 { 391 unsigned fpos; 392 int ret; 393 394 _enter("{%Ld,{%lu}}", file->f_pos, file->f_path.dentry->d_inode->i_ino); 395 396 fpos = file->f_pos; 397 ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos, cookie, filldir); 398 file->f_pos = fpos; 399 400 _leave(" = %d", ret); 401 return ret; 402 } /* end afs_dir_readdir() */ 403 404 /*****************************************************************************/ 405 /* 406 * search the directory for a name 407 * - if afs_dir_iterate_block() spots this function, it'll pass the FID 408 * uniquifier through dtype 409 */ 410 static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen, 411 loff_t fpos, u64 ino, unsigned dtype) 412 { 413 struct afs_dir_lookup_cookie *cookie = _cookie; 414 415 _enter("{%s,%Zu},%s,%u,,%lu,%u", 416 cookie->name, cookie->nlen, name, nlen, ino, dtype); 417 418 if (cookie->nlen != nlen || memcmp(cookie->name, name, nlen) != 0) { 419 _leave(" = 0 [no]"); 420 return 0; 421 } 422 423 cookie->fid.vnode = ino; 424 cookie->fid.unique = dtype; 425 cookie->found = 1; 426 427 _leave(" = -1 [found]"); 428 return -1; 429 } /* end afs_dir_lookup_filldir() */ 430 431 /*****************************************************************************/ 432 /* 433 * look up an entry in a directory 434 */ 435 static struct dentry *afs_dir_lookup(struct inode *dir, struct dentry *dentry, 436 struct nameidata *nd) 437 { 438 struct afs_dir_lookup_cookie cookie; 439 struct afs_super_info *as; 440 struct afs_vnode *vnode; 441 struct inode *inode; 442 unsigned fpos; 443 int ret; 444 445 _enter("{%lu},%p{%s}", dir->i_ino, dentry, dentry->d_name.name); 446 447 /* insanity checks first */ 448 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048); 449 BUILD_BUG_ON(sizeof(union afs_dirent) != 32); 450 451 if (dentry->d_name.len > 255) { 452 _leave(" = -ENAMETOOLONG"); 453 return ERR_PTR(-ENAMETOOLONG); 454 } 455 456 vnode = AFS_FS_I(dir); 457 if (vnode->flags & AFS_VNODE_DELETED) { 458 _leave(" = -ESTALE"); 459 return ERR_PTR(-ESTALE); 460 } 461 462 as = dir->i_sb->s_fs_info; 463 464 /* search the directory */ 465 cookie.name = dentry->d_name.name; 466 cookie.nlen = dentry->d_name.len; 467 cookie.fid.vid = as->volume->vid; 468 cookie.found = 0; 469 470 fpos = 0; 471 ret = afs_dir_iterate(dir, &fpos, &cookie, afs_dir_lookup_filldir); 472 if (ret < 0) { 473 _leave(" = %d", ret); 474 return ERR_PTR(ret); 475 } 476 477 ret = -ENOENT; 478 if (!cookie.found) { 479 _leave(" = %d", ret); 480 return ERR_PTR(ret); 481 } 482 483 /* instantiate the dentry */ 484 ret = afs_iget(dir->i_sb, &cookie.fid, &inode); 485 if (ret < 0) { 486 _leave(" = %d", ret); 487 return ERR_PTR(ret); 488 } 489 490 dentry->d_op = &afs_fs_dentry_operations; 491 dentry->d_fsdata = (void *) (unsigned long) vnode->status.version; 492 493 d_add(dentry, inode); 494 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%lu }", 495 cookie.fid.vnode, 496 cookie.fid.unique, 497 dentry->d_inode->i_ino, 498 dentry->d_inode->i_version); 499 500 return NULL; 501 } /* end afs_dir_lookup() */ 502 503 /*****************************************************************************/ 504 /* 505 * check that a dentry lookup hit has found a valid entry 506 * - NOTE! the hit can be a negative hit too, so we can't assume we have an 507 * inode 508 * (derived from nfs_lookup_revalidate) 509 */ 510 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd) 511 { 512 struct afs_dir_lookup_cookie cookie; 513 struct dentry *parent; 514 struct inode *inode, *dir; 515 unsigned fpos; 516 int ret; 517 518 _enter("{sb=%p n=%s},", dentry->d_sb, dentry->d_name.name); 519 520 /* lock down the parent dentry so we can peer at it */ 521 parent = dget_parent(dentry->d_parent); 522 523 dir = parent->d_inode; 524 inode = dentry->d_inode; 525 526 /* handle a negative dentry */ 527 if (!inode) 528 goto out_bad; 529 530 /* handle a bad inode */ 531 if (is_bad_inode(inode)) { 532 printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n", 533 dentry->d_parent->d_name.name, dentry->d_name.name); 534 goto out_bad; 535 } 536 537 /* force a full look up if the parent directory changed since last the 538 * server was consulted 539 * - otherwise this inode must still exist, even if the inode details 540 * themselves have changed 541 */ 542 if (AFS_FS_I(dir)->flags & AFS_VNODE_CHANGED) 543 afs_vnode_fetch_status(AFS_FS_I(dir)); 544 545 if (AFS_FS_I(dir)->flags & AFS_VNODE_DELETED) { 546 _debug("%s: parent dir deleted", dentry->d_name.name); 547 goto out_bad; 548 } 549 550 if (AFS_FS_I(inode)->flags & AFS_VNODE_DELETED) { 551 _debug("%s: file already deleted", dentry->d_name.name); 552 goto out_bad; 553 } 554 555 if ((unsigned long) dentry->d_fsdata != 556 (unsigned long) AFS_FS_I(dir)->status.version) { 557 _debug("%s: parent changed %lu -> %u", 558 dentry->d_name.name, 559 (unsigned long) dentry->d_fsdata, 560 (unsigned) AFS_FS_I(dir)->status.version); 561 562 /* search the directory for this vnode */ 563 cookie.name = dentry->d_name.name; 564 cookie.nlen = dentry->d_name.len; 565 cookie.fid.vid = AFS_FS_I(inode)->volume->vid; 566 cookie.found = 0; 567 568 fpos = 0; 569 ret = afs_dir_iterate(dir, &fpos, &cookie, 570 afs_dir_lookup_filldir); 571 if (ret < 0) { 572 _debug("failed to iterate dir %s: %d", 573 parent->d_name.name, ret); 574 goto out_bad; 575 } 576 577 if (!cookie.found) { 578 _debug("%s: dirent not found", dentry->d_name.name); 579 goto not_found; 580 } 581 582 /* if the vnode ID has changed, then the dirent points to a 583 * different file */ 584 if (cookie.fid.vnode != AFS_FS_I(inode)->fid.vnode) { 585 _debug("%s: dirent changed", dentry->d_name.name); 586 goto not_found; 587 } 588 589 /* if the vnode ID uniqifier has changed, then the file has 590 * been deleted */ 591 if (cookie.fid.unique != AFS_FS_I(inode)->fid.unique) { 592 _debug("%s: file deleted (uq %u -> %u I:%lu)", 593 dentry->d_name.name, 594 cookie.fid.unique, 595 AFS_FS_I(inode)->fid.unique, 596 inode->i_version); 597 spin_lock(&AFS_FS_I(inode)->lock); 598 AFS_FS_I(inode)->flags |= AFS_VNODE_DELETED; 599 spin_unlock(&AFS_FS_I(inode)->lock); 600 invalidate_remote_inode(inode); 601 goto out_bad; 602 } 603 604 dentry->d_fsdata = 605 (void *) (unsigned long) AFS_FS_I(dir)->status.version; 606 } 607 608 out_valid: 609 dput(parent); 610 _leave(" = 1 [valid]"); 611 return 1; 612 613 /* the dirent, if it exists, now points to a different vnode */ 614 not_found: 615 spin_lock(&dentry->d_lock); 616 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 617 spin_unlock(&dentry->d_lock); 618 619 out_bad: 620 if (inode) { 621 /* don't unhash if we have submounts */ 622 if (have_submounts(dentry)) 623 goto out_valid; 624 } 625 626 shrink_dcache_parent(dentry); 627 628 _debug("dropping dentry %s/%s", 629 dentry->d_parent->d_name.name, dentry->d_name.name); 630 d_drop(dentry); 631 632 dput(parent); 633 634 _leave(" = 0 [bad]"); 635 return 0; 636 } /* end afs_d_revalidate() */ 637 638 /*****************************************************************************/ 639 /* 640 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't 641 * sleep) 642 * - called from dput() when d_count is going to 0. 643 * - return 1 to request dentry be unhashed, 0 otherwise 644 */ 645 static int afs_d_delete(struct dentry *dentry) 646 { 647 _enter("%s", dentry->d_name.name); 648 649 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 650 goto zap; 651 652 if (dentry->d_inode) { 653 if (AFS_FS_I(dentry->d_inode)->flags & AFS_VNODE_DELETED) 654 goto zap; 655 } 656 657 _leave(" = 0 [keep]"); 658 return 0; 659 660 zap: 661 _leave(" = 1 [zap]"); 662 return 1; 663 } /* end afs_d_delete() */ 664