1/*- 2 * Copyright 2000 Hans Reiser 3 * See README for licensing and copyright details 4 * 5 * Ported to FreeBSD by Jean-S��bastien P��dron <jspedron@club-internet.fr> 6 * 7 * $FreeBSD$ 8 */ 9 10#include <gnu/fs/reiserfs/reiserfs_fs.h> 11 12const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING; 13const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING; 14const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING; 15 16/* 17 * Default recommended I/O size is 128k. There might be broken 18 * applications that are confused by this. Use nolargeio mount option to 19 * get usual i/o size = PAGE_SIZE. 20 */ 21int reiserfs_default_io_size = 128 * 1024; 22 23static vfs_cmount_t reiserfs_cmount; 24static vfs_fhtovp_t reiserfs_fhtovp; 25static vfs_mount_t reiserfs_mount; 26static vfs_root_t reiserfs_root; 27static vfs_statfs_t reiserfs_statfs; 28static vfs_unmount_t reiserfs_unmount; 29 30static int reiserfs_mountfs(struct vnode *devvp, struct mount *mp, 31 struct thread *td); 32static void load_bitmap_info_data(struct reiserfs_sb_info *sbi, 33 struct reiserfs_bitmap_info *bi); 34static int read_bitmaps(struct reiserfs_mount *rmp); 35static int read_old_bitmaps(struct reiserfs_mount *rmp); 36static int read_super_block(struct reiserfs_mount *rmp, int offset); 37static hashf_t hash_function(struct reiserfs_mount *rmp); 38 39static int get_root_node(struct reiserfs_mount *rmp, 40 struct reiserfs_node **root); 41uint32_t find_hash_out(struct reiserfs_mount *rmp); 42 43MALLOC_DEFINE(M_REISERFSMNT, "reiserfs_mount", "ReiserFS mount structure"); 44MALLOC_DEFINE(M_REISERFSPATH, "reiserfs_path", "ReiserFS path structure"); 45MALLOC_DEFINE(M_REISERFSNODE, "reiserfs_node", "ReiserFS vnode private part"); 46 47/* ------------------------------------------------------------------- 48 * VFS operations 49 * -------------------------------------------------------------------*/ 50 51static int 52reiserfs_cmount(struct mntarg *ma, void *data, uint64_t flags) 53{ 54 struct reiserfs_args args; 55 struct export_args exp; 56 int error; 57 58 error = copyin(data, &args, sizeof(args)); 59 if (error) 60 return (error); 61 vfs_oexport_conv(&args.export, &exp); 62 63 ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN); 64 ma = mount_arg(ma, "export", &exp, sizeof(exp)); 65 66 error = kernel_mount(ma, flags); 67 68 return (error); 69} 70 71/* 72 * Mount system call 73 */ 74static int 75reiserfs_mount(struct mount *mp) 76{ 77 size_t size; 78 int error, len; 79 accmode_t accmode; 80 char *path, *fspec; 81 struct vnode *devvp; 82 struct vfsoptlist *opts; 83 struct reiserfs_mount *rmp; 84 struct reiserfs_sb_info *sbi; 85 struct nameidata nd, *ndp = &nd; 86 struct thread *td; 87 88 td = curthread; 89 if (!(mp->mnt_flag & MNT_RDONLY)) 90 return EROFS; 91 92 /* Get the new options passed to mount */ 93 opts = mp->mnt_optnew; 94 95 /* `fspath' contains the mount point (eg. /mnt/linux); REQUIRED */ 96 vfs_getopt(opts, "fspath", (void **)&path, NULL); 97 reiserfs_log(LOG_INFO, "mount point is `%s'\n", path); 98 99 /* `from' contains the device name (eg. /dev/ad0s1); REQUIRED */ 100 fspec = NULL; 101 error = vfs_getopt(opts, "from", (void **)&fspec, &len); 102 if (!error && fspec[len - 1] != '\0') 103 return (EINVAL); 104 reiserfs_log(LOG_INFO, "device is `%s'\n", fspec); 105 106 /* Handle MNT_UPDATE (mp->mnt_flag) */ 107 if (mp->mnt_flag & MNT_UPDATE) { 108 /* For now, only NFS export is supported. */ 109 if (vfs_flagopt(opts, "export", NULL, 0)) 110 return (0); 111 } 112 113 /* Not an update, or updating the name: look up the name 114 * and verify that it refers to a sensible disk device. */ 115 if (fspec == NULL) 116 return (EINVAL); 117 118 NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td); 119 if ((error = namei(ndp)) != 0) 120 return (error); 121 NDFREE(ndp, NDF_ONLY_PNBUF); 122 devvp = ndp->ni_vp; 123 124 if (!vn_isdisk(devvp, &error)) { 125 vput(devvp); 126 return (error); 127 } 128 129 /* If mount by non-root, then verify that user has necessary 130 * permissions on the device. */ 131 accmode = VREAD; 132 if ((mp->mnt_flag & MNT_RDONLY) == 0) 133 accmode |= VWRITE; 134 error = VOP_ACCESS(devvp, accmode, td->td_ucred, td); 135 if (error) 136 error = priv_check(td, PRIV_VFS_MOUNT_PERM); 137 if (error) { 138 vput(devvp); 139 return (error); 140 } 141 142 if ((mp->mnt_flag & MNT_UPDATE) == 0) { 143 error = reiserfs_mountfs(devvp, mp, td); 144 } else { 145 /* TODO Handle MNT_UPDATE */ 146 vput(devvp); 147 return (EOPNOTSUPP); 148 } 149 150 if (error) { 151 vrele(devvp); 152 return (error); 153 } 154 155 rmp = VFSTOREISERFS(mp); 156 sbi = rmp->rm_reiserfs; 157 158 /* 159 * Note that this strncpy() is ok because of a check at the start 160 * of reiserfs_mount(). 161 */ 162 reiserfs_log(LOG_DEBUG, "prepare statfs data\n"); 163 (void)copystr(fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); 164 bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); 165 (void)reiserfs_statfs(mp, &mp->mnt_stat); 166 167 reiserfs_log(LOG_DEBUG, "done\n"); 168 return (0); 169} 170 171/* 172 * Unmount system call 173 */ 174static int 175reiserfs_unmount(struct mount *mp, int mntflags) 176{ 177 int error, flags = 0; 178 struct reiserfs_mount *rmp; 179 struct reiserfs_sb_info *sbi; 180 181 reiserfs_log(LOG_DEBUG, "get private data\n"); 182 rmp = VFSTOREISERFS(mp); 183 sbi = rmp->rm_reiserfs; 184 185 /* Flangs handling */ 186 reiserfs_log(LOG_DEBUG, "handle mntflags\n"); 187 if (mntflags & MNT_FORCE) 188 flags |= FORCECLOSE; 189 190 /* Flush files -> vflush */ 191 reiserfs_log(LOG_DEBUG, "flush vnodes\n"); 192 if ((error = vflush(mp, 0, flags, curthread))) 193 return (error); 194 195 /* XXX Super block update */ 196 197 if (sbi) { 198 if (SB_AP_BITMAP(sbi)) { 199 int i; 200 reiserfs_log(LOG_DEBUG, 201 "release bitmap buffers (total: %d)\n", 202 SB_BMAP_NR(sbi)); 203 for (i = 0; i < SB_BMAP_NR(sbi); i++) { 204 if (SB_AP_BITMAP(sbi)[i].bp_data) { 205 free(SB_AP_BITMAP(sbi)[i].bp_data, 206 M_REISERFSMNT); 207 SB_AP_BITMAP(sbi)[i].bp_data = NULL; 208 } 209 } 210 211 reiserfs_log(LOG_DEBUG, "free bitmaps structure\n"); 212 free(SB_AP_BITMAP(sbi), M_REISERFSMNT); 213 SB_AP_BITMAP(sbi) = NULL; 214 } 215 216 if (sbi->s_rs) { 217 reiserfs_log(LOG_DEBUG, "free super block data\n"); 218 free(sbi->s_rs, M_REISERFSMNT); 219 sbi->s_rs = NULL; 220 } 221 } 222 223 reiserfs_log(LOG_DEBUG, "close device\n"); 224#if defined(si_mountpoint) 225 rmp->rm_devvp->v_rdev->si_mountpoint = NULL; 226#endif 227 228 DROP_GIANT(); 229 g_topology_lock(); 230 g_vfs_close(rmp->rm_cp); 231 g_topology_unlock(); 232 PICKUP_GIANT(); 233 vrele(rmp->rm_devvp); 234 dev_rel(rmp->rm_dev); 235 236 if (sbi) { 237 reiserfs_log(LOG_DEBUG, "free sbi\n"); 238 free(sbi, M_REISERFSMNT); 239 sbi = rmp->rm_reiserfs = NULL; 240 } 241 if (rmp) { 242 reiserfs_log(LOG_DEBUG, "free rmp\n"); 243 free(rmp, M_REISERFSMNT); 244 rmp = NULL; 245 } 246 247 mp->mnt_data = 0; 248 MNT_ILOCK(mp); 249 mp->mnt_flag &= ~MNT_LOCAL; 250 MNT_IUNLOCK(mp); 251 252 reiserfs_log(LOG_DEBUG, "done\n"); 253 return (error); 254} 255 256/* 257 * Return the root of a filesystem. 258 */ 259static int 260reiserfs_root(struct mount *mp, int flags, struct vnode **vpp) 261{ 262 int error; 263 struct vnode *vp; 264 struct cpu_key rootkey; 265 266 rootkey.on_disk_key.k_dir_id = REISERFS_ROOT_PARENT_OBJECTID; 267 rootkey.on_disk_key.k_objectid = REISERFS_ROOT_OBJECTID; 268 269 error = reiserfs_iget(mp, &rootkey, &vp, curthread); 270 271 if (error == 0) 272 *vpp = vp; 273 return (error); 274} 275 276/* 277 * The statfs syscall 278 */ 279static int 280reiserfs_statfs(struct mount *mp, struct statfs *sbp) 281{ 282 struct reiserfs_mount *rmp; 283 struct reiserfs_sb_info *sbi; 284 struct reiserfs_super_block *rs; 285 286 reiserfs_log(LOG_DEBUG, "get private data\n"); 287 rmp = VFSTOREISERFS(mp); 288 sbi = rmp->rm_reiserfs; 289 rs = sbi->s_rs; 290 291 reiserfs_log(LOG_DEBUG, "fill statfs structure\n"); 292 sbp->f_bsize = sbi->s_blocksize; 293 sbp->f_iosize = sbp->f_bsize; 294 sbp->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1; 295 sbp->f_bfree = sb_free_blocks(rs); 296 sbp->f_bavail = sbp->f_bfree; 297 sbp->f_files = 0; 298 sbp->f_ffree = 0; 299 reiserfs_log(LOG_DEBUG, " block size = %ju\n", 300 (intmax_t)sbp->f_bsize); 301 reiserfs_log(LOG_DEBUG, " IO size = %ju\n", 302 (intmax_t)sbp->f_iosize); 303 reiserfs_log(LOG_DEBUG, " block count = %ju\n", 304 (intmax_t)sbp->f_blocks); 305 reiserfs_log(LOG_DEBUG, " free blocks = %ju\n", 306 (intmax_t)sbp->f_bfree); 307 reiserfs_log(LOG_DEBUG, " avail blocks = %ju\n", 308 (intmax_t)sbp->f_bavail); 309 reiserfs_log(LOG_DEBUG, "...done\n"); 310 311 if (sbp != &mp->mnt_stat) { 312 reiserfs_log(LOG_DEBUG, "copying monut point info\n"); 313 sbp->f_type = mp->mnt_vfc->vfc_typenum; 314 bcopy((caddr_t)mp->mnt_stat.f_mntonname, 315 (caddr_t)&sbp->f_mntonname[0], MNAMELEN); 316 bcopy((caddr_t)mp->mnt_stat.f_mntfromname, 317 (caddr_t)&sbp->f_mntfromname[0], MNAMELEN); 318 reiserfs_log(LOG_DEBUG, " mount from: %s\n", 319 sbp->f_mntfromname); 320 reiserfs_log(LOG_DEBUG, " mount on: %s\n", 321 sbp->f_mntonname); 322 reiserfs_log(LOG_DEBUG, "...done\n"); 323 } 324 325 return (0); 326} 327 328/* 329 * File handle to vnode 330 * 331 * Have to be really careful about stale file handles: 332 * - check that the inode key is valid 333 * - call ffs_vget() to get the locked inode 334 * - check for an unallocated inode (i_mode == 0) 335 * - check that the given client host has export rights and return 336 * those rights via. exflagsp and credanonp 337 */ 338static int 339reiserfs_fhtovp(struct mount *mp, struct fid *fhp, int flags, 340 struct vnode **vpp) 341{ 342 int error; 343 struct rfid *rfhp; 344 struct vnode *nvp; 345 struct cpu_key key; 346 struct reiserfs_node *ip; 347 struct reiserfs_sb_info *sbi; 348 struct thread *td = curthread; 349 350 rfhp = (struct rfid *)fhp; 351 sbi = VFSTOREISERFS(mp)->rm_reiserfs; 352 353 /* Check that the key is valid */ 354 if (rfhp->rfid_dirid < REISERFS_ROOT_PARENT_OBJECTID && 355 rfhp->rfid_objectid < REISERFS_ROOT_OBJECTID) 356 return (ESTALE); 357 358 reiserfs_log(LOG_DEBUG, 359 "file handle key is (dirid=%d, objectid=%d)\n", 360 rfhp->rfid_dirid, rfhp->rfid_objectid); 361 key.on_disk_key.k_dir_id = rfhp->rfid_dirid; 362 key.on_disk_key.k_objectid = rfhp->rfid_objectid; 363 364 reiserfs_log(LOG_DEBUG, "read this inode\n"); 365 error = reiserfs_iget(mp, &key, &nvp, td); 366 if (error) { 367 *vpp = NULLVP; 368 return (error); 369 } 370 371 reiserfs_log(LOG_DEBUG, "check validity\n"); 372 ip = VTOI(nvp); 373 if (ip->i_mode == 0 || ip->i_generation != rfhp->rfid_gen) { 374 vput(nvp); 375 *vpp = NULLVP; 376 return (ESTALE); 377 } 378 379 reiserfs_log(LOG_DEBUG, "return it\n"); 380 *vpp = nvp; 381 return (0); 382} 383 384/* ------------------------------------------------------------------- 385 * Functions for the journal 386 * -------------------------------------------------------------------*/ 387 388int 389is_reiserfs_3_5(struct reiserfs_super_block *rs) 390{ 391 392 return (!strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string, 393 strlen(reiserfs_3_5_magic_string))); 394} 395 396int 397is_reiserfs_3_6(struct reiserfs_super_block *rs) 398{ 399 400 return (!strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string, 401 strlen(reiserfs_3_6_magic_string))); 402} 403 404int 405is_reiserfs_jr(struct reiserfs_super_block *rs) 406{ 407 408 return (!strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string, 409 strlen(reiserfs_jr_magic_string))); 410} 411 412static int 413is_any_reiserfs_magic_string(struct reiserfs_super_block *rs) 414{ 415 416 return ((is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) || 417 is_reiserfs_jr(rs))); 418} 419 420/* ------------------------------------------------------------------- 421 * Internal functions 422 * -------------------------------------------------------------------*/ 423 424/* 425 * Common code for mount and mountroot 426 */ 427static int 428reiserfs_mountfs(struct vnode *devvp, struct mount *mp, struct thread *td) 429{ 430 int error, old_format = 0; 431 struct reiserfs_mount *rmp; 432 struct reiserfs_sb_info *sbi; 433 struct reiserfs_super_block *rs; 434 struct cdev *dev; 435 436 struct g_consumer *cp; 437 struct bufobj *bo; 438 439 //ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 440 441 dev = devvp->v_rdev; 442 dev_ref(dev); 443 DROP_GIANT(); 444 g_topology_lock(); 445 error = g_vfs_open(devvp, &cp, "reiserfs", /* read-only */ 0); 446 g_topology_unlock(); 447 PICKUP_GIANT(); 448 VOP_UNLOCK(devvp, 0); 449 if (error) { 450 dev_rel(dev); 451 return (error); 452 } 453 454 bo = &devvp->v_bufobj; 455 bo->bo_private = cp; 456 bo->bo_ops = g_vfs_bufops; 457 458 if (devvp->v_rdev->si_iosize_max != 0) 459 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max; 460 if (mp->mnt_iosize_max > MAXPHYS) 461 mp->mnt_iosize_max = MAXPHYS; 462 463 rmp = NULL; 464 sbi = NULL; 465 466 /* rmp contains any information about this specific mount */ 467 rmp = malloc(sizeof *rmp, M_REISERFSMNT, M_WAITOK | M_ZERO); 468 if (!rmp) { 469 error = (ENOMEM); 470 goto out; 471 } 472 sbi = malloc(sizeof *sbi, M_REISERFSMNT, M_WAITOK | M_ZERO); 473 if (!sbi) { 474 error = (ENOMEM); 475 goto out; 476 } 477 rmp->rm_reiserfs = sbi; 478 rmp->rm_mountp = mp; 479 rmp->rm_devvp = devvp; 480 rmp->rm_dev = dev; 481 rmp->rm_bo = &devvp->v_bufobj; 482 rmp->rm_cp = cp; 483 484 /* Set default values for options: non-aggressive tails */ 485 REISERFS_SB(sbi)->s_mount_opt = (1 << REISERFS_SMALLTAIL); 486 REISERFS_SB(sbi)->s_rd_only = 1; 487 REISERFS_SB(sbi)->s_devvp = devvp; 488 489 /* Read the super block */ 490 if ((error = read_super_block(rmp, REISERFS_OLD_DISK_OFFSET)) == 0) { 491 /* The read process succeeded, it's an old format */ 492 old_format = 1; 493 } else if ((error = read_super_block(rmp, REISERFS_DISK_OFFSET)) != 0) { 494 reiserfs_log(LOG_ERR, "can not find a ReiserFS filesystem\n"); 495 goto out; 496 } 497 498 rs = SB_DISK_SUPER_BLOCK(sbi); 499 500 /* 501 * Let's do basic sanity check to verify that underlying device is 502 * not smaller than the filesystem. If the check fails then abort and 503 * scream, because bad stuff will happen otherwise. 504 */ 505#if 0 506 if (s->s_bdev && s->s_bdev->bd_inode && 507 i_size_read(s->s_bdev->bd_inode) < 508 sb_block_count(rs) * sb_blocksize(rs)) { 509 reiserfs_log(LOG_ERR, 510 "reiserfs: filesystem cannot be mounted because it is " 511 "bigger than the device.\n"); 512 reiserfs_log(LOG_ERR, "reiserfs: you may need to run fsck " 513 "rr may be you forgot to reboot after fdisk when it " 514 "told you to.\n"); 515 goto out; 516 } 517#endif 518 519 /* 520 * XXX This is from the original Linux code, but why affecting 2 values 521 * to the same variable? 522 */ 523 sbi->s_mount_state = SB_REISERFS_STATE(sbi); 524 sbi->s_mount_state = REISERFS_VALID_FS; 525 526 if ((error = (old_format ? 527 read_old_bitmaps(rmp) : read_bitmaps(rmp)))) { 528 reiserfs_log(LOG_ERR, "unable to read bitmap\n"); 529 goto out; 530 } 531 532 /* Make data=ordered the default */ 533 if (!reiserfs_data_log(sbi) && !reiserfs_data_ordered(sbi) && 534 !reiserfs_data_writeback(sbi)) { 535 REISERFS_SB(sbi)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED); 536 } 537 538 if (reiserfs_data_log(sbi)) { 539 reiserfs_log(LOG_INFO, "using journaled data mode\n"); 540 } else if (reiserfs_data_ordered(sbi)) { 541 reiserfs_log(LOG_INFO, "using ordered data mode\n"); 542 } else { 543 reiserfs_log(LOG_INFO, "using writeback data mode\n"); 544 } 545 546 /* TODO Not yet supported */ 547#if 0 548 if(journal_init(sbi, jdev_name, old_format, commit_max_age)) { 549 reiserfs_log(LOG_ERR, "unable to initialize journal space\n"); 550 goto out; 551 } else { 552 jinit_done = 1 ; /* once this is set, journal_release must 553 be called if we error out of the mount */ 554 } 555 556 if (reread_meta_blocks(sbi)) { 557 reiserfs_log(LOG_ERR, 558 "unable to reread meta blocks after journal init\n"); 559 goto out; 560 } 561#endif 562 563 /* Define and initialize hash function */ 564 sbi->s_hash_function = hash_function(rmp); 565 566 if (sbi->s_hash_function == NULL) { 567 reiserfs_log(LOG_ERR, "couldn't determined hash function\n"); 568 error = (EINVAL); 569 goto out; 570 } 571 572 if (is_reiserfs_3_5(rs) || 573 (is_reiserfs_jr(rs) && SB_VERSION(sbi) == REISERFS_VERSION_1)) 574 bit_set(&(sbi->s_properties), REISERFS_3_5); 575 else 576 bit_set(&(sbi->s_properties), REISERFS_3_6); 577 578 mp->mnt_data = rmp; 579 mp->mnt_stat.f_fsid.val[0] = dev2udev(dev); 580 mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum; 581 MNT_ILOCK(mp); 582 mp->mnt_flag |= MNT_LOCAL; 583 MNT_IUNLOCK(mp); 584#if defined(si_mountpoint) 585 devvp->v_rdev->si_mountpoint = mp; 586#endif 587 588 return (0); 589 590out: 591 reiserfs_log(LOG_INFO, "*** error during mount ***\n"); 592 if (sbi) { 593 if (SB_AP_BITMAP(sbi)) { 594 int i; 595 for (i = 0; i < SB_BMAP_NR(sbi); i++) { 596 if (!SB_AP_BITMAP(sbi)[i].bp_data) 597 break; 598 free(SB_AP_BITMAP(sbi)[i].bp_data, 599 M_REISERFSMNT); 600 } 601 free(SB_AP_BITMAP(sbi), M_REISERFSMNT); 602 } 603 604 if (sbi->s_rs) { 605 free(sbi->s_rs, M_REISERFSMNT); 606 sbi->s_rs = NULL; 607 } 608 } 609 610 if (cp != NULL) { 611 DROP_GIANT(); 612 g_topology_lock(); 613 g_vfs_close(cp); 614 g_topology_unlock(); 615 PICKUP_GIANT(); 616 } 617 618 if (sbi) 619 free(sbi, M_REISERFSMNT); 620 if (rmp) 621 free(rmp, M_REISERFSMNT); 622 dev_rel(dev); 623 return (error); 624} 625 626/* 627 * Read the super block 628 */ 629static int 630read_super_block(struct reiserfs_mount *rmp, int offset) 631{ 632 struct buf *bp; 633 int error, bits; 634 struct reiserfs_super_block *rs; 635 struct reiserfs_sb_info *sbi; 636 uint16_t fs_blocksize; 637 638 if (offset == REISERFS_OLD_DISK_OFFSET) { 639 reiserfs_log(LOG_DEBUG, 640 "reiserfs/super: read old format super block\n"); 641 } else { 642 reiserfs_log(LOG_DEBUG, 643 "reiserfs/super: read new format super block\n"); 644 } 645 646 /* Read the super block */ 647 if ((error = bread(rmp->rm_devvp, offset * btodb(REISERFS_BSIZE), 648 REISERFS_BSIZE, NOCRED, &bp)) != 0) { 649 reiserfs_log(LOG_ERR, "can't read device\n"); 650 return (error); 651 } 652 653 /* Get it from the buffer data */ 654 rs = (struct reiserfs_super_block *)bp->b_data; 655 if (!is_any_reiserfs_magic_string(rs)) { 656 brelse(bp); 657 return (EINVAL); 658 } 659 660 fs_blocksize = sb_blocksize(rs); 661 brelse(bp); 662 bp = NULL; 663 664 if (fs_blocksize <= 0) { 665 reiserfs_log(LOG_ERR, "unexpected null block size"); 666 return (EINVAL); 667 } 668 669 /* Read the super block (for double check) 670 * We can't read the same blkno with a different size: it causes 671 * panic() if INVARIANTS is set. So we keep REISERFS_BSIZE */ 672 if ((error = bread(rmp->rm_devvp, 673 offset * REISERFS_BSIZE / fs_blocksize * btodb(fs_blocksize), 674 REISERFS_BSIZE, NOCRED, &bp)) != 0) { 675 reiserfs_log(LOG_ERR, "can't reread the super block\n"); 676 return (error); 677 } 678 679 rs = (struct reiserfs_super_block *)bp->b_data; 680 if (sb_blocksize(rs) != fs_blocksize) { 681 reiserfs_log(LOG_ERR, "unexpected block size " 682 "(found=%u, expected=%u)\n", 683 sb_blocksize(rs), fs_blocksize); 684 brelse(bp); 685 return (EINVAL); 686 } 687 688 reiserfs_log(LOG_DEBUG, "magic: `%s'\n", rs->s_v1.s_magic); 689 reiserfs_log(LOG_DEBUG, "label: `%s'\n", rs->s_label); 690 reiserfs_log(LOG_DEBUG, "block size: %6d\n", sb_blocksize(rs)); 691 reiserfs_log(LOG_DEBUG, "block count: %6u\n", 692 rs->s_v1.s_block_count); 693 reiserfs_log(LOG_DEBUG, "bitmaps number: %6u\n", 694 rs->s_v1.s_bmap_nr); 695 696 if (rs->s_v1.s_root_block == -1) { 697 log(LOG_ERR, 698 "reiserfs: Unfinished reiserfsck --rebuild-tree run " 699 "detected. Please\n" 700 "run reiserfsck --rebuild-tree and wait for a " 701 "completion. If that\n" 702 "fails, get newer reiserfsprogs package"); 703 brelse(bp); 704 return (EINVAL); 705 } 706 707 sbi = rmp->rm_reiserfs; 708 sbi->s_blocksize = fs_blocksize; 709 710 for (bits = 9, fs_blocksize >>= 9; fs_blocksize >>= 1; bits++) 711 ; 712 sbi->s_blocksize_bits = bits; 713 714 /* Copy the buffer and release it */ 715 sbi->s_rs = malloc(sizeof *rs, M_REISERFSMNT, M_WAITOK | M_ZERO); 716 if (!sbi->s_rs) { 717 reiserfs_log(LOG_ERR, "can not read the super block\n"); 718 brelse(bp); 719 return (ENOMEM); 720 } 721 bcopy(rs, sbi->s_rs, sizeof(struct reiserfs_super_block)); 722 brelse(bp); 723 724 if (is_reiserfs_jr(rs)) { 725 if (sb_version(rs) == REISERFS_VERSION_2) 726 reiserfs_log(LOG_INFO, "found reiserfs format \"3.6\"" 727 " with non-standard journal"); 728 else if (sb_version(rs) == REISERFS_VERSION_1) 729 reiserfs_log(LOG_INFO, "found reiserfs format \"3.5\"" 730 " with non-standard journal"); 731 else { 732 reiserfs_log(LOG_ERR, "found unknown " 733 "format \"%u\" of reiserfs with non-standard magic", 734 sb_version(rs)); 735 return (EINVAL); 736 } 737 } else { 738 /* 739 * s_version of standard format may contain incorrect 740 * information, so we just look at the magic string 741 */ 742 reiserfs_log(LOG_INFO, 743 "found reiserfs format \"%s\" with standard journal\n", 744 is_reiserfs_3_5(rs) ? "3.5" : "3.6"); 745 } 746 747 return (0); 748} 749 750/* 751 * load_bitmap_info_data - Sets up the reiserfs_bitmap_info structure 752 * from disk. 753 * @sbi - superblock info for this filesystem 754 * @bi - the bitmap info to be loaded. Requires that bi->bp is valid. 755 * 756 * This routine counts how many free bits there are, finding the first 757 * zero as a side effect. Could also be implemented as a loop of 758 * test_bit() calls, or a loop of find_first_zero_bit() calls. This 759 * implementation is similar to find_first_zero_bit(), but doesn't 760 * return after it finds the first bit. Should only be called on fs 761 * mount, but should be fairly efficient anyways. 762 * 763 * bi->first_zero_hint is considered unset if it == 0, since the bitmap 764 * itself will invariably occupt block 0 represented in the bitmap. The 765 * only exception to this is when free_count also == 0, since there will 766 * be no free blocks at all. 767 */ 768static void 769load_bitmap_info_data(struct reiserfs_sb_info *sbi, 770 struct reiserfs_bitmap_info *bi) 771{ 772 unsigned long *cur; 773 774 cur = (unsigned long *)bi->bp_data; 775 while ((char *)cur < (bi->bp_data + sbi->s_blocksize)) { 776 /* 777 * No need to scan if all 0's or all 1's. 778 * Since we're only counting 0's, we can simply ignore 779 * all 1's 780 */ 781 if (*cur == 0) { 782 if (bi->first_zero_hint == 0) { 783 bi->first_zero_hint = 784 ((char *)cur - bi->bp_data) << 3; 785 } 786 bi->free_count += sizeof(unsigned long) * 8; 787 } else if (*cur != ~0L) { 788 int b; 789 790 for (b = 0; b < sizeof(unsigned long) * 8; b++) { 791 if (!reiserfs_test_le_bit(b, cur)) { 792 bi->free_count++; 793 if (bi->first_zero_hint == 0) 794 bi->first_zero_hint = 795 (((char *)cur - 796 bi->bp_data) << 3) + b; 797 } 798 } 799 } 800 cur++; 801 } 802} 803 804/* 805 * Read the bitmaps 806 */ 807static int 808read_bitmaps(struct reiserfs_mount *rmp) 809{ 810 int i, bmap_nr; 811 struct buf *bp = NULL; 812 struct reiserfs_sb_info *sbi = rmp->rm_reiserfs; 813 814 /* Allocate memory for the table of bitmaps */ 815 SB_AP_BITMAP(sbi) = 816 malloc(sizeof(struct reiserfs_bitmap_info) * SB_BMAP_NR(sbi), 817 M_REISERFSMNT, M_WAITOK | M_ZERO); 818 if (!SB_AP_BITMAP(sbi)) 819 return (ENOMEM); 820 821 /* Read all the bitmaps */ 822 for (i = 0, 823 bmap_nr = (REISERFS_DISK_OFFSET_IN_BYTES / sbi->s_blocksize + 1) * 824 btodb(sbi->s_blocksize); 825 i < SB_BMAP_NR(sbi); i++, bmap_nr = sbi->s_blocksize * 8 * i) { 826 SB_AP_BITMAP(sbi)[i].bp_data = malloc(sbi->s_blocksize, 827 M_REISERFSMNT, M_WAITOK | M_ZERO); 828 if (!SB_AP_BITMAP(sbi)[i].bp_data) 829 return (ENOMEM); 830 bread(rmp->rm_devvp, bmap_nr, sbi->s_blocksize, NOCRED, &bp); 831 bcopy(bp->b_data, SB_AP_BITMAP(sbi)[i].bp_data, 832 sbi->s_blocksize); 833 brelse(bp); 834 bp = NULL; 835 836 /*if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) 837 ll_rw_block(READ, 1, &SB_AP_BITMAP(s)[i].bh);*/ 838 } 839 840 for (i = 0; i < SB_BMAP_NR(sbi); i++) { 841 /*if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) { 842 reiserfs_warning(s,"sh-2029: reiserfs read_bitmaps: " 843 "bitmap block (#%lu) reading failed", 844 SB_AP_BITMAP(s)[i].bh->b_blocknr); 845 for (i = 0; i < SB_BMAP_NR(s); i++) 846 brelse(SB_AP_BITMAP(s)[i].bh); 847 vfree(SB_AP_BITMAP(s)); 848 SB_AP_BITMAP(s) = NULL; 849 return 1; 850 }*/ 851 load_bitmap_info_data(sbi, SB_AP_BITMAP(sbi) + i); 852 reiserfs_log(LOG_DEBUG, 853 "%d free blocks (starting at block %ld)\n", 854 SB_AP_BITMAP(sbi)[i].free_count, 855 (long)SB_AP_BITMAP(sbi)[i].first_zero_hint); 856 } 857 858 return (0); 859} 860 861// TODO Not supported 862static int 863read_old_bitmaps(struct reiserfs_mount *rmp) 864{ 865 866 return (EOPNOTSUPP); 867#if 0 868 int i; 869 struct reiserfs_sb_info *sbi = rmp->rm_reiserfs; 870 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(sbi); 871 872 /* First of bitmap blocks */ 873 int bmp1 = (REISERFS_OLD_DISK_OFFSET / sbi->s_blocksize) * 874 btodb(sbi->s_blocksize); 875 876 /* Read true bitmap */ 877 SB_AP_BITMAP(sbi) = 878 malloc(sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs), 879 M_REISERFSMNT, M_WAITOK | M_ZERO); 880 if (!SB_AP_BITMAP(sbi)) 881 return 1; 882 883 for (i = 0; i < sb_bmap_nr(rs); i ++) { 884 SB_AP_BITMAP(sbi)[i].bp = getblk(rmp->rm_devvp, 885 (bmp1 + i) * btodb(sbi->s_blocksize), sbi->s_blocksize, 0, 0, 0); 886 if (!SB_AP_BITMAP(sbi)[i].bp) 887 return 1; 888 load_bitmap_info_data(sbi, SB_AP_BITMAP(sbi) + i); 889 } 890 891 return 0; 892#endif 893} 894 895/* ------------------------------------------------------------------- 896 * Hash detection stuff 897 * -------------------------------------------------------------------*/ 898 899static int 900get_root_node(struct reiserfs_mount *rmp, struct reiserfs_node **root) 901{ 902 struct reiserfs_node *ip; 903 struct reiserfs_iget_args args; 904 905 /* Allocate the node structure */ 906 reiserfs_log(LOG_DEBUG, "malloc(struct reiserfs_node)\n"); 907 ip = malloc(sizeof(struct reiserfs_node), 908 M_REISERFSNODE, M_WAITOK | M_ZERO); 909 910 /* Fill the structure */ 911 reiserfs_log(LOG_DEBUG, "filling *ip\n"); 912 ip->i_dev = rmp->rm_dev; 913 ip->i_number = REISERFS_ROOT_OBJECTID; 914 ip->i_ino = REISERFS_ROOT_PARENT_OBJECTID; 915 ip->i_reiserfs = rmp->rm_reiserfs; 916 917 /* Read the inode */ 918 args.objectid = ip->i_number; 919 args.dirid = ip->i_ino; 920 reiserfs_log(LOG_DEBUG, "call reiserfs_read_locked_inode(" 921 "objectid=%d,dirid=%d)\n", args.objectid, args.dirid); 922 reiserfs_read_locked_inode(ip, &args); 923 924 ip->i_devvp = rmp->rm_devvp; 925 //XXX VREF(ip->i_devvp); Is it necessary ? 926 927 *root = ip; 928 return (0); 929} 930 931/* 932 * If root directory is empty - we set default - Yura's - hash and warn 933 * about it. 934 * FIXME: we look for only one name in a directory. If tea and yura both 935 * have the same value - we ask user to send report to the mailing list 936 */ 937uint32_t find_hash_out(struct reiserfs_mount *rmp) 938{ 939 int retval; 940 struct cpu_key key; 941 INITIALIZE_PATH(path); 942 struct reiserfs_node *ip; 943 struct reiserfs_sb_info *sbi; 944 struct reiserfs_dir_entry de; 945 uint32_t hash = DEFAULT_HASH; 946 947 get_root_node(rmp, &ip); 948 if (!ip) 949 return (UNSET_HASH); 950 951 sbi = rmp->rm_reiserfs; 952 953 do { 954 uint32_t teahash, r5hash, yurahash; 955 956 reiserfs_log(LOG_DEBUG, "make_cpu_key\n"); 957 make_cpu_key(&key, ip, ~0, TYPE_DIRENTRY, 3); 958 reiserfs_log(LOG_DEBUG, "search_by_entry_key for " 959 "key(objectid=%d,dirid=%d)\n", 960 key.on_disk_key.k_objectid, key.on_disk_key.k_dir_id); 961 retval = search_by_entry_key(sbi, &key, &path, &de); 962 if (retval == IO_ERROR) { 963 pathrelse(&path); 964 return (UNSET_HASH); 965 } 966 if (retval == NAME_NOT_FOUND) 967 de.de_entry_num--; 968 969 reiserfs_log(LOG_DEBUG, "name found\n"); 970 971 set_de_name_and_namelen(&de); 972 973 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) { 974 /* Allow override in this case */ 975 if (reiserfs_rupasov_hash(sbi)) { 976 hash = YURA_HASH; 977 } 978 reiserfs_log(LOG_DEBUG, 979 "FS seems to be empty, autodetect " 980 "is using the default hash"); 981 break; 982 } 983 984 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen)); 985 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, 986 de.de_namelen)); 987 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen)); 988 if (((teahash == r5hash) && 989 (GET_HASH_VALUE( 990 deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)) || 991 ((teahash == yurahash) && 992 (yurahash == 993 GET_HASH_VALUE( 994 deh_offset(&(de.de_deh[de.de_entry_num]))))) || 995 ((r5hash == yurahash) && 996 (yurahash == 997 GET_HASH_VALUE( 998 deh_offset(&(de.de_deh[de.de_entry_num])))))) { 999 reiserfs_log(LOG_ERR, 1000 "unable to automatically detect hash " 1001 "function. Please mount with -o " 1002 "hash={tea,rupasov,r5}"); 1003 hash = UNSET_HASH; 1004 break; 1005 } 1006 1007 if (GET_HASH_VALUE( 1008 deh_offset(&(de.de_deh[de.de_entry_num]))) == yurahash) { 1009 reiserfs_log(LOG_DEBUG, "detected YURA hash\n"); 1010 hash = YURA_HASH; 1011 } else if (GET_HASH_VALUE( 1012 deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash) { 1013 reiserfs_log(LOG_DEBUG, "detected TEA hash\n"); 1014 hash = TEA_HASH; 1015 } else if (GET_HASH_VALUE( 1016 deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) { 1017 reiserfs_log(LOG_DEBUG, "detected R5 hash\n"); 1018 hash = R5_HASH; 1019 } else { 1020 reiserfs_log(LOG_WARNING, "unrecognised hash function"); 1021 hash = UNSET_HASH; 1022 } 1023 } while (0); 1024 1025 pathrelse(&path); 1026 return (hash); 1027} 1028 1029/* Finds out which hash names are sorted with */ 1030static int 1031what_hash(struct reiserfs_mount *rmp) 1032{ 1033 uint32_t code; 1034 struct reiserfs_sb_info *sbi = rmp->rm_reiserfs; 1035 1036 find_hash_out(rmp); 1037 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(sbi)); 1038 1039 /* 1040 * reiserfs_hash_detect() == true if any of the hash mount options 1041 * were used. We must check them to make sure the user isn't using a 1042 * bad hash value 1043 */ 1044 if (code == UNSET_HASH || reiserfs_hash_detect(sbi)) 1045 code = find_hash_out(rmp); 1046 1047 if (code != UNSET_HASH && reiserfs_hash_detect(sbi)) { 1048 /* 1049 * Detection has found the hash, and we must check against 1050 * the mount options 1051 */ 1052 if (reiserfs_rupasov_hash(sbi) && code != YURA_HASH) { 1053 reiserfs_log(LOG_ERR, "error, %s hash detected, " 1054 "unable to force rupasov hash", 1055 reiserfs_hashname(code)); 1056 code = UNSET_HASH; 1057 } else if (reiserfs_tea_hash(sbi) && code != TEA_HASH) { 1058 reiserfs_log(LOG_ERR, "error, %s hash detected, " 1059 "unable to force tea hash", 1060 reiserfs_hashname(code)); 1061 code = UNSET_HASH; 1062 } else if (reiserfs_r5_hash(sbi) && code != R5_HASH) { 1063 reiserfs_log(LOG_ERR, "error, %s hash detected, " 1064 "unable to force r5 hash", 1065 reiserfs_hashname(code)); 1066 code = UNSET_HASH; 1067 } 1068 } else { 1069 /* 1070 * Find_hash_out was not called or could not determine 1071 * the hash 1072 */ 1073 if (reiserfs_rupasov_hash(sbi)) { 1074 code = YURA_HASH; 1075 } else if (reiserfs_tea_hash(sbi)) { 1076 code = TEA_HASH; 1077 } else if (reiserfs_r5_hash(sbi)) { 1078 code = R5_HASH; 1079 } 1080 } 1081 1082 /* TODO Not supported yet */ 1083#if 0 1084 /* If we are mounted RW, and we have a new valid hash code, update 1085 * the super */ 1086 if (code != UNSET_HASH && 1087 !(s->s_flags & MS_RDONLY) && 1088 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) { 1089 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code); 1090 } 1091#endif 1092 1093 return (code); 1094} 1095 1096/* Return pointer to appropriate function */ 1097static hashf_t 1098hash_function(struct reiserfs_mount *rmp) 1099{ 1100 1101 switch (what_hash(rmp)) { 1102 case TEA_HASH: 1103 reiserfs_log(LOG_INFO, "using tea hash to sort names\n"); 1104 return (keyed_hash); 1105 case YURA_HASH: 1106 reiserfs_log(LOG_INFO, "using rupasov hash to sort names\n"); 1107 return (yura_hash); 1108 case R5_HASH: 1109 reiserfs_log(LOG_INFO, "using r5 hash to sort names\n"); 1110 return (r5_hash); 1111 } 1112 1113 return (NULL); 1114} 1115 1116/* ------------------------------------------------------------------- 1117 * VFS registration 1118 * -------------------------------------------------------------------*/ 1119 1120static struct vfsops reiser_vfsops = { 1121 .vfs_cmount = reiserfs_cmount, 1122 .vfs_mount = reiserfs_mount, 1123 .vfs_unmount = reiserfs_unmount, 1124 //.vfs_checkexp = reiserfs_checkexp, 1125 //.vfs_extattrctl = reiserfs_extattrctl, 1126 .vfs_fhtovp = reiserfs_fhtovp, 1127 //.vfs_quotactl = reiserfs_quotactl, 1128 .vfs_root = reiserfs_root, 1129 //.vfs_start = reiserfs_start, 1130 .vfs_statfs = reiserfs_statfs, 1131 //.vfs_sync = reiserfs_sync, 1132 //.vfs_vget = reiserfs_vget, 1133}; 1134 1135VFS_SET(reiser_vfsops, reiserfs, VFCF_READONLY); 1136