1 /* $NetBSD: ext2fs_vfsops.c,v 1.175 2013/11/23 13:35:36 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1989, 1991, 1993, 1994 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)ffs_vfsops.c 8.14 (Berkeley) 11/28/94 32 * Modified for ext2fs by Manuel Bouyer. 33 */ 34 35 /* 36 * Copyright (c) 1997 Manuel Bouyer. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 50 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 51 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 52 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 53 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 54 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 55 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 56 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 57 * 58 * @(#)ffs_vfsops.c 8.14 (Berkeley) 11/28/94 59 * Modified for ext2fs by Manuel Bouyer. 60 */ 61 62 #include <sys/cdefs.h> 63 __KERNEL_RCSID(0, "$NetBSD: ext2fs_vfsops.c,v 1.175 2013/11/23 13:35:36 christos Exp $"); 64 65 #if defined(_KERNEL_OPT) 66 #include "opt_compat_netbsd.h" 67 #endif 68 69 #include <sys/param.h> 70 #include <sys/systm.h> 71 #include <sys/sysctl.h> 72 #include <sys/namei.h> 73 #include <sys/proc.h> 74 #include <sys/kernel.h> 75 #include <sys/vnode.h> 76 #include <sys/socket.h> 77 #include <sys/mount.h> 78 #include <sys/buf.h> 79 #include <sys/device.h> 80 #include <sys/mbuf.h> 81 #include <sys/file.h> 82 #include <sys/disklabel.h> 83 #include <sys/ioctl.h> 84 #include <sys/errno.h> 85 #include <sys/malloc.h> 86 #include <sys/pool.h> 87 #include <sys/lock.h> 88 #include <sys/conf.h> 89 #include <sys/kauth.h> 90 #include <sys/module.h> 91 92 #include <miscfs/genfs/genfs.h> 93 #include <miscfs/specfs/specdev.h> 94 95 #include <ufs/ufs/quota.h> 96 #include <ufs/ufs/ufsmount.h> 97 #include <ufs/ufs/inode.h> 98 #include <ufs/ufs/dir.h> 99 #include <ufs/ufs/ufs_extern.h> 100 101 #include <ufs/ext2fs/ext2fs.h> 102 #include <ufs/ext2fs/ext2fs_dir.h> 103 #include <ufs/ext2fs/ext2fs_extern.h> 104 105 MODULE(MODULE_CLASS_VFS, ext2fs, "ffs"); 106 107 int ext2fs_sbupdate(struct ufsmount *, int); 108 static int ext2fs_checksb(struct ext2fs *, int); 109 110 static struct sysctllog *ext2fs_sysctl_log; 111 112 extern const struct vnodeopv_desc ext2fs_vnodeop_opv_desc; 113 extern const struct vnodeopv_desc ext2fs_specop_opv_desc; 114 extern const struct vnodeopv_desc ext2fs_fifoop_opv_desc; 115 116 const struct vnodeopv_desc * const ext2fs_vnodeopv_descs[] = { 117 &ext2fs_vnodeop_opv_desc, 118 &ext2fs_specop_opv_desc, 119 &ext2fs_fifoop_opv_desc, 120 NULL, 121 }; 122 123 struct vfsops ext2fs_vfsops = { 124 MOUNT_EXT2FS, 125 sizeof (struct ufs_args), 126 ext2fs_mount, 127 ufs_start, 128 ext2fs_unmount, 129 ufs_root, 130 ufs_quotactl, 131 ext2fs_statvfs, 132 ext2fs_sync, 133 ext2fs_vget, 134 ext2fs_fhtovp, 135 ext2fs_vptofh, 136 ext2fs_init, 137 ext2fs_reinit, 138 ext2fs_done, 139 ext2fs_mountroot, 140 (int (*)(struct mount *, struct vnode *, struct timespec *)) eopnotsupp, 141 vfs_stdextattrctl, 142 (void *)eopnotsupp, /* vfs_suspendctl */ 143 genfs_renamelock_enter, 144 genfs_renamelock_exit, 145 (void *)eopnotsupp, 146 ext2fs_vnodeopv_descs, 147 0, 148 { NULL, NULL }, 149 }; 150 151 static const struct genfs_ops ext2fs_genfsops = { 152 .gop_size = genfs_size, 153 .gop_alloc = ext2fs_gop_alloc, 154 .gop_write = genfs_gop_write, 155 .gop_markupdate = ufs_gop_markupdate, 156 }; 157 158 static const struct ufs_ops ext2fs_ufsops = { 159 .uo_itimes = ext2fs_itimes, 160 .uo_update = ext2fs_update, 161 .uo_vfree = ext2fs_vfree, 162 }; 163 164 /* Fill in the inode uid/gid from ext2 halves. */ 165 void 166 ext2fs_set_inode_guid(struct inode *ip) 167 { 168 169 ip->i_gid = ip->i_e2fs_gid; 170 ip->i_uid = ip->i_e2fs_uid; 171 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) { 172 ip->i_gid |= ip->i_e2fs_gid_high << 16; 173 ip->i_uid |= ip->i_e2fs_uid_high << 16; 174 } 175 } 176 177 static int 178 ext2fs_modcmd(modcmd_t cmd, void *arg) 179 { 180 int error; 181 182 switch (cmd) { 183 case MODULE_CMD_INIT: 184 error = vfs_attach(&ext2fs_vfsops); 185 if (error != 0) 186 break; 187 sysctl_createv(&ext2fs_sysctl_log, 0, NULL, NULL, 188 CTLFLAG_PERMANENT, 189 CTLTYPE_NODE, "vfs", NULL, 190 NULL, 0, NULL, 0, 191 CTL_VFS, CTL_EOL); 192 sysctl_createv(&ext2fs_sysctl_log, 0, NULL, NULL, 193 CTLFLAG_PERMANENT, 194 CTLTYPE_NODE, "ext2fs", 195 SYSCTL_DESCR("Linux EXT2FS file system"), 196 NULL, 0, NULL, 0, 197 CTL_VFS, 17, CTL_EOL); 198 /* 199 * XXX the "17" above could be dynamic, thereby eliminating 200 * one more instance of the "number to vfs" mapping problem, 201 * but "17" is the order as taken from sys/mount.h 202 */ 203 break; 204 case MODULE_CMD_FINI: 205 error = vfs_detach(&ext2fs_vfsops); 206 if (error != 0) 207 break; 208 sysctl_teardown(&ext2fs_sysctl_log); 209 break; 210 default: 211 error = ENOTTY; 212 break; 213 } 214 215 return (error); 216 } 217 218 /* 219 * XXX Same structure as FFS inodes? Should we share a common pool? 220 */ 221 struct pool ext2fs_inode_pool; 222 struct pool ext2fs_dinode_pool; 223 224 extern u_long ext2gennumber; 225 226 void 227 ext2fs_init(void) 228 { 229 230 pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0, 231 "ext2fsinopl", &pool_allocator_nointr, IPL_NONE); 232 pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0, 233 "ext2dinopl", &pool_allocator_nointr, IPL_NONE); 234 ufs_init(); 235 } 236 237 void 238 ext2fs_reinit(void) 239 { 240 ufs_reinit(); 241 } 242 243 void 244 ext2fs_done(void) 245 { 246 247 ufs_done(); 248 pool_destroy(&ext2fs_inode_pool); 249 pool_destroy(&ext2fs_dinode_pool); 250 } 251 252 /* 253 * Called by main() when ext2fs is going to be mounted as root. 254 * 255 * Name is updated by mount(8) after booting. 256 */ 257 #define ROOTNAME "root_device" 258 259 int 260 ext2fs_mountroot(void) 261 { 262 extern struct vnode *rootvp; 263 struct m_ext2fs *fs; 264 struct mount *mp; 265 struct ufsmount *ump; 266 int error; 267 268 if (device_class(root_device) != DV_DISK) 269 return (ENODEV); 270 271 if ((error = vfs_rootmountalloc(MOUNT_EXT2FS, "root_device", &mp))) { 272 vrele(rootvp); 273 return (error); 274 } 275 276 if ((error = ext2fs_mountfs(rootvp, mp)) != 0) { 277 vfs_unbusy(mp, false, NULL); 278 vfs_destroy(mp); 279 return (error); 280 } 281 mountlist_append(mp); 282 ump = VFSTOUFS(mp); 283 fs = ump->um_e2fs; 284 memset(fs->e2fs_fsmnt, 0, sizeof(fs->e2fs_fsmnt)); 285 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt, 286 sizeof(fs->e2fs_fsmnt) - 1, 0); 287 if (fs->e2fs.e2fs_rev > E2FS_REV0) { 288 memset(fs->e2fs.e2fs_fsmnt, 0, sizeof(fs->e2fs.e2fs_fsmnt)); 289 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt, 290 sizeof(fs->e2fs.e2fs_fsmnt) - 1, 0); 291 } 292 (void)ext2fs_statvfs(mp, &mp->mnt_stat); 293 vfs_unbusy(mp, false, NULL); 294 setrootfstime((time_t)fs->e2fs.e2fs_wtime); 295 return (0); 296 } 297 298 /* 299 * VFS Operations. 300 * 301 * mount system call 302 */ 303 int 304 ext2fs_mount(struct mount *mp, const char *path, void *data, size_t *data_len) 305 { 306 struct lwp *l = curlwp; 307 struct vnode *devvp; 308 struct ufs_args *args = data; 309 struct ufsmount *ump = NULL; 310 struct m_ext2fs *fs; 311 size_t size; 312 int error = 0, flags, update; 313 mode_t accessmode; 314 315 if (*data_len < sizeof *args) 316 return EINVAL; 317 318 if (mp->mnt_flag & MNT_GETARGS) { 319 ump = VFSTOUFS(mp); 320 if (ump == NULL) 321 return EIO; 322 memset(args, 0, sizeof *args); 323 args->fspec = NULL; 324 *data_len = sizeof *args; 325 return 0; 326 } 327 328 update = mp->mnt_flag & MNT_UPDATE; 329 330 /* Check arguments */ 331 if (args->fspec != NULL) { 332 /* 333 * Look up the name and verify that it's sane. 334 */ 335 error = namei_simple_user(args->fspec, 336 NSM_FOLLOW_NOEMULROOT, &devvp); 337 if (error != 0) 338 return (error); 339 340 if (!update) { 341 /* 342 * Be sure this is a valid block device 343 */ 344 if (devvp->v_type != VBLK) 345 error = ENOTBLK; 346 else if (bdevsw_lookup(devvp->v_rdev) == NULL) 347 error = ENXIO; 348 } else { 349 /* 350 * Be sure we're still naming the same device 351 * used for our initial mount 352 */ 353 ump = VFSTOUFS(mp); 354 if (devvp != ump->um_devvp) { 355 if (devvp->v_rdev != ump->um_devvp->v_rdev) 356 error = EINVAL; 357 else { 358 vrele(devvp); 359 devvp = ump->um_devvp; 360 vref(devvp); 361 } 362 } 363 } 364 } else { 365 if (!update) { 366 /* New mounts must have a filename for the device */ 367 return (EINVAL); 368 } else { 369 ump = VFSTOUFS(mp); 370 devvp = ump->um_devvp; 371 vref(devvp); 372 } 373 } 374 375 /* 376 * If mount by non-root, then verify that user has necessary 377 * permissions on the device. 378 * 379 * Permission to update a mount is checked higher, so here we presume 380 * updating the mount is okay (for example, as far as securelevel goes) 381 * which leaves us with the normal check. 382 */ 383 if (error == 0) { 384 accessmode = VREAD; 385 if (update ? 386 (mp->mnt_iflag & IMNT_WANTRDWR) != 0 : 387 (mp->mnt_flag & MNT_RDONLY) == 0) 388 accessmode |= VWRITE; 389 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 390 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT, 391 KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp, 392 KAUTH_ARG(accessmode)); 393 VOP_UNLOCK(devvp); 394 } 395 396 if (error) { 397 vrele(devvp); 398 return (error); 399 } 400 401 if (!update) { 402 int xflags; 403 404 if (mp->mnt_flag & MNT_RDONLY) 405 xflags = FREAD; 406 else 407 xflags = FREAD|FWRITE; 408 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 409 error = VOP_OPEN(devvp, xflags, FSCRED); 410 VOP_UNLOCK(devvp); 411 if (error) 412 goto fail; 413 error = ext2fs_mountfs(devvp, mp); 414 if (error) { 415 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 416 (void)VOP_CLOSE(devvp, xflags, NOCRED); 417 VOP_UNLOCK(devvp); 418 goto fail; 419 } 420 421 ump = VFSTOUFS(mp); 422 fs = ump->um_e2fs; 423 } else { 424 /* 425 * Update the mount. 426 */ 427 428 /* 429 * The initial mount got a reference on this 430 * device, so drop the one obtained via 431 * namei(), above. 432 */ 433 vrele(devvp); 434 435 ump = VFSTOUFS(mp); 436 fs = ump->um_e2fs; 437 if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { 438 /* 439 * Changing from r/w to r/o 440 */ 441 flags = WRITECLOSE; 442 if (mp->mnt_flag & MNT_FORCE) 443 flags |= FORCECLOSE; 444 error = ext2fs_flushfiles(mp, flags); 445 if (error == 0 && 446 ext2fs_cgupdate(ump, MNT_WAIT) == 0 && 447 (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) { 448 fs->e2fs.e2fs_state = E2FS_ISCLEAN; 449 (void) ext2fs_sbupdate(ump, MNT_WAIT); 450 } 451 if (error) 452 return (error); 453 fs->e2fs_ronly = 1; 454 } 455 456 if (mp->mnt_flag & MNT_RELOAD) { 457 error = ext2fs_reload(mp, l->l_cred, l); 458 if (error) 459 return (error); 460 } 461 462 if (fs->e2fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) { 463 /* 464 * Changing from read-only to read/write 465 */ 466 fs->e2fs_ronly = 0; 467 if (fs->e2fs.e2fs_state == E2FS_ISCLEAN) 468 fs->e2fs.e2fs_state = 0; 469 else 470 fs->e2fs.e2fs_state = E2FS_ERRORS; 471 fs->e2fs_fmod = 1; 472 } 473 if (args->fspec == NULL) 474 return 0; 475 } 476 477 error = set_statvfs_info(path, UIO_USERSPACE, args->fspec, 478 UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l); 479 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt, 480 sizeof(fs->e2fs_fsmnt) - 1, &size); 481 memset(fs->e2fs_fsmnt + size, 0, sizeof(fs->e2fs_fsmnt) - size); 482 if (fs->e2fs.e2fs_rev > E2FS_REV0) { 483 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt, 484 sizeof(fs->e2fs.e2fs_fsmnt) - 1, &size); 485 memset(fs->e2fs.e2fs_fsmnt, 0, 486 sizeof(fs->e2fs.e2fs_fsmnt) - size); 487 } 488 if (fs->e2fs_fmod != 0) { /* XXX */ 489 fs->e2fs_fmod = 0; 490 if (fs->e2fs.e2fs_state == 0) 491 fs->e2fs.e2fs_wtime = time_second; 492 else 493 printf("%s: file system not clean; please fsck(8)\n", 494 mp->mnt_stat.f_mntfromname); 495 (void) ext2fs_cgupdate(ump, MNT_WAIT); 496 } 497 return (error); 498 499 fail: 500 vrele(devvp); 501 return (error); 502 } 503 504 /* 505 * Reload all incore data for a filesystem (used after running fsck on 506 * the root filesystem and finding things to fix). The filesystem must 507 * be mounted read-only. 508 * 509 * Things to do to update the mount: 510 * 1) invalidate all cached meta-data. 511 * 2) re-read superblock from disk. 512 * 3) re-read summary information from disk. 513 * 4) invalidate all inactive vnodes. 514 * 5) invalidate all cached file data. 515 * 6) re-read inode data for all active vnodes. 516 */ 517 int 518 ext2fs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l) 519 { 520 struct vnode *vp, *mvp, *devvp; 521 struct inode *ip; 522 struct buf *bp; 523 struct m_ext2fs *fs; 524 struct ext2fs *newfs; 525 int i, error; 526 void *cp; 527 struct ufsmount *ump; 528 529 if ((mp->mnt_flag & MNT_RDONLY) == 0) 530 return (EINVAL); 531 532 ump = VFSTOUFS(mp); 533 /* 534 * Step 1: invalidate all cached meta-data. 535 */ 536 devvp = ump->um_devvp; 537 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 538 error = vinvalbuf(devvp, 0, cred, l, 0, 0); 539 VOP_UNLOCK(devvp); 540 if (error) 541 panic("ext2fs_reload: dirty1"); 542 /* 543 * Step 2: re-read superblock from disk. 544 */ 545 error = bread(devvp, SBLOCK, SBSIZE, NOCRED, 0, &bp); 546 if (error) { 547 return (error); 548 } 549 newfs = (struct ext2fs *)bp->b_data; 550 error = ext2fs_checksb(newfs, (mp->mnt_flag & MNT_RDONLY) != 0); 551 if (error) { 552 brelse(bp, 0); 553 return (error); 554 } 555 556 fs = ump->um_e2fs; 557 /* 558 * copy in new superblock, and compute in-memory values 559 */ 560 e2fs_sbload(newfs, &fs->e2fs); 561 fs->e2fs_ncg = 562 howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock, 563 fs->e2fs.e2fs_bpg); 564 fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT; 565 fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize; 566 fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize; 567 fs->e2fs_qbmask = fs->e2fs_bsize - 1; 568 fs->e2fs_bmask = ~fs->e2fs_qbmask; 569 fs->e2fs_ngdb = 570 howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd)); 571 fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE(fs); 572 fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb; 573 brelse(bp, 0); 574 575 /* 576 * Step 3: re-read summary information from disk. 577 */ 578 579 for (i = 0; i < fs->e2fs_ngdb; i++) { 580 error = bread(devvp , 581 EXT2_FSBTODB(fs, fs->e2fs.e2fs_first_dblock + 582 1 /* superblock */ + i), 583 fs->e2fs_bsize, NOCRED, 0, &bp); 584 if (error) { 585 return (error); 586 } 587 e2fs_cgload((struct ext2_gd *)bp->b_data, 588 &fs->e2fs_gd[i * fs->e2fs_bsize / sizeof(struct ext2_gd)], 589 fs->e2fs_bsize); 590 brelse(bp, 0); 591 } 592 593 /* Allocate a marker vnode. */ 594 mvp = vnalloc(mp); 595 /* 596 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone() 597 * and vclean() can be called indirectly 598 */ 599 mutex_enter(&mntvnode_lock); 600 loop: 601 for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) { 602 vmark(mvp, vp); 603 if (vp->v_mount != mp || vismarker(vp)) 604 continue; 605 /* 606 * Step 4: invalidate all inactive vnodes. 607 */ 608 if (vrecycle(vp, &mntvnode_lock)) { 609 mutex_enter(&mntvnode_lock); 610 (void)vunmark(mvp); 611 goto loop; 612 } 613 /* 614 * Step 5: invalidate all cached file data. 615 */ 616 mutex_enter(vp->v_interlock); 617 mutex_exit(&mntvnode_lock); 618 if (vget(vp, LK_EXCLUSIVE)) { 619 mutex_enter(&mntvnode_lock); 620 (void)vunmark(mvp); 621 goto loop; 622 } 623 if (vinvalbuf(vp, 0, cred, l, 0, 0)) 624 panic("ext2fs_reload: dirty2"); 625 /* 626 * Step 6: re-read inode data for all active vnodes. 627 */ 628 ip = VTOI(vp); 629 error = bread(devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)), 630 (int)fs->e2fs_bsize, NOCRED, 0, &bp); 631 if (error) { 632 vput(vp); 633 mutex_enter(&mntvnode_lock); 634 (void)vunmark(mvp); 635 break; 636 } 637 cp = (char *)bp->b_data + 638 (ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE(fs)); 639 e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din); 640 ext2fs_set_inode_guid(ip); 641 brelse(bp, 0); 642 vput(vp); 643 mutex_enter(&mntvnode_lock); 644 } 645 mutex_exit(&mntvnode_lock); 646 vnfree(mvp); 647 return (error); 648 } 649 650 /* 651 * Common code for mount and mountroot 652 */ 653 int 654 ext2fs_mountfs(struct vnode *devvp, struct mount *mp) 655 { 656 struct lwp *l = curlwp; 657 struct ufsmount *ump; 658 struct buf *bp; 659 struct ext2fs *fs; 660 struct m_ext2fs *m_fs; 661 dev_t dev; 662 int error, i, ronly; 663 kauth_cred_t cred; 664 665 dev = devvp->v_rdev; 666 cred = l ? l->l_cred : NOCRED; 667 668 /* Flush out any old buffers remaining from a previous use. */ 669 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 670 error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0); 671 VOP_UNLOCK(devvp); 672 if (error) 673 return (error); 674 675 ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 676 677 bp = NULL; 678 ump = NULL; 679 680 #ifdef DEBUG_EXT2 681 printf("ext2 sb size: %zu\n", sizeof(struct ext2fs)); 682 #endif 683 error = bread(devvp, SBLOCK, SBSIZE, cred, 0, &bp); 684 if (error) 685 goto out; 686 fs = (struct ext2fs *)bp->b_data; 687 error = ext2fs_checksb(fs, ronly); 688 if (error) 689 goto out; 690 ump = kmem_zalloc(sizeof(*ump), KM_SLEEP); 691 ump->um_fstype = UFS1; 692 ump->um_ops = &ext2fs_ufsops; 693 ump->um_e2fs = kmem_zalloc(sizeof(struct m_ext2fs), KM_SLEEP); 694 e2fs_sbload((struct ext2fs *)bp->b_data, &ump->um_e2fs->e2fs); 695 brelse(bp, 0); 696 bp = NULL; 697 m_fs = ump->um_e2fs; 698 m_fs->e2fs_ronly = ronly; 699 700 #ifdef DEBUG_EXT2 701 printf("ext2 ino size %zu\n", EXT2_DINODE_SIZE(m_fs)); 702 #endif 703 if (ronly == 0) { 704 if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN) 705 m_fs->e2fs.e2fs_state = 0; 706 else 707 m_fs->e2fs.e2fs_state = E2FS_ERRORS; 708 m_fs->e2fs_fmod = 1; 709 } 710 711 /* compute dynamic sb infos */ 712 m_fs->e2fs_ncg = 713 howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock, 714 m_fs->e2fs.e2fs_bpg); 715 m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT; 716 m_fs->e2fs_bsize = MINBSIZE << m_fs->e2fs.e2fs_log_bsize; 717 m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize; 718 m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1; 719 m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask; 720 m_fs->e2fs_ngdb = 721 howmany(m_fs->e2fs_ncg, m_fs->e2fs_bsize / sizeof(struct ext2_gd)); 722 m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE(m_fs); 723 m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg / m_fs->e2fs_ipb; 724 725 m_fs->e2fs_gd = kmem_alloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, KM_SLEEP); 726 for (i = 0; i < m_fs->e2fs_ngdb; i++) { 727 error = bread(devvp , 728 EXT2_FSBTODB(m_fs, m_fs->e2fs.e2fs_first_dblock + 729 1 /* superblock */ + i), 730 m_fs->e2fs_bsize, NOCRED, 0, &bp); 731 if (error) { 732 kmem_free(m_fs->e2fs_gd, 733 m_fs->e2fs_ngdb * m_fs->e2fs_bsize); 734 goto out; 735 } 736 e2fs_cgload((struct ext2_gd *)bp->b_data, 737 &m_fs->e2fs_gd[ 738 i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)], 739 m_fs->e2fs_bsize); 740 brelse(bp, 0); 741 bp = NULL; 742 } 743 744 mp->mnt_data = ump; 745 mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev; 746 mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_EXT2FS); 747 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0]; 748 mp->mnt_stat.f_namemax = EXT2FS_MAXNAMLEN; 749 mp->mnt_flag |= MNT_LOCAL; 750 mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */ 751 mp->mnt_fs_bshift = m_fs->e2fs_bshift; 752 mp->mnt_iflag |= IMNT_DTYPE; 753 ump->um_flags = 0; 754 ump->um_mountp = mp; 755 ump->um_dev = dev; 756 ump->um_devvp = devvp; 757 ump->um_nindir = EXT2_NINDIR(m_fs); 758 ump->um_lognindir = ffs(EXT2_NINDIR(m_fs)) - 1; 759 ump->um_bptrtodb = m_fs->e2fs_fsbtodb; 760 ump->um_seqinc = 1; /* no frags */ 761 ump->um_maxsymlinklen = EXT2_MAXSYMLINKLEN; 762 ump->um_dirblksiz = m_fs->e2fs_bsize; 763 ump->um_maxfilesize = ((uint64_t)0x80000000 * m_fs->e2fs_bsize - 1); 764 spec_node_setmountedfs(devvp, mp); 765 return (0); 766 767 out: 768 if (bp != NULL) 769 brelse(bp, 0); 770 if (ump) { 771 kmem_free(ump->um_e2fs, sizeof(struct m_ext2fs)); 772 kmem_free(ump, sizeof(*ump)); 773 mp->mnt_data = NULL; 774 } 775 return (error); 776 } 777 778 /* 779 * unmount system call 780 */ 781 int 782 ext2fs_unmount(struct mount *mp, int mntflags) 783 { 784 struct ufsmount *ump; 785 struct m_ext2fs *fs; 786 int error, flags; 787 788 flags = 0; 789 if (mntflags & MNT_FORCE) 790 flags |= FORCECLOSE; 791 if ((error = ext2fs_flushfiles(mp, flags)) != 0) 792 return (error); 793 ump = VFSTOUFS(mp); 794 fs = ump->um_e2fs; 795 if (fs->e2fs_ronly == 0 && 796 ext2fs_cgupdate(ump, MNT_WAIT) == 0 && 797 (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) { 798 fs->e2fs.e2fs_state = E2FS_ISCLEAN; 799 (void) ext2fs_sbupdate(ump, MNT_WAIT); 800 } 801 if (ump->um_devvp->v_type != VBAD) 802 spec_node_setmountedfs(ump->um_devvp, NULL); 803 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 804 error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE, 805 NOCRED); 806 vput(ump->um_devvp); 807 kmem_free(fs->e2fs_gd, fs->e2fs_ngdb * fs->e2fs_bsize); 808 kmem_free(fs, sizeof(*fs)); 809 kmem_free(ump, sizeof(*ump)); 810 mp->mnt_data = NULL; 811 mp->mnt_flag &= ~MNT_LOCAL; 812 return (error); 813 } 814 815 /* 816 * Flush out all the files in a filesystem. 817 */ 818 int 819 ext2fs_flushfiles(struct mount *mp, int flags) 820 { 821 extern int doforce; 822 int error; 823 824 if (!doforce) 825 flags &= ~FORCECLOSE; 826 error = vflush(mp, NULLVP, flags); 827 return (error); 828 } 829 830 /* 831 * Get file system statistics. 832 */ 833 int 834 ext2fs_statvfs(struct mount *mp, struct statvfs *sbp) 835 { 836 struct ufsmount *ump; 837 struct m_ext2fs *fs; 838 uint32_t overhead, overhead_per_group, ngdb; 839 int i, ngroups; 840 841 ump = VFSTOUFS(mp); 842 fs = ump->um_e2fs; 843 if (fs->e2fs.e2fs_magic != E2FS_MAGIC) 844 panic("ext2fs_statvfs"); 845 846 /* 847 * Compute the overhead (FS structures) 848 */ 849 overhead_per_group = 850 1 /* block bitmap */ + 851 1 /* inode bitmap */ + 852 fs->e2fs_itpg; 853 overhead = fs->e2fs.e2fs_first_dblock + 854 fs->e2fs_ncg * overhead_per_group; 855 if (fs->e2fs.e2fs_rev > E2FS_REV0 && 856 fs->e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) { 857 for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) { 858 if (cg_has_sb(i)) 859 ngroups++; 860 } 861 } else { 862 ngroups = fs->e2fs_ncg; 863 } 864 ngdb = fs->e2fs_ngdb; 865 if (fs->e2fs.e2fs_rev > E2FS_REV0 && 866 fs->e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE) 867 ngdb += fs->e2fs.e2fs_reserved_ngdb; 868 overhead += ngroups * (1 /* superblock */ + ngdb); 869 870 sbp->f_bsize = fs->e2fs_bsize; 871 sbp->f_frsize = MINBSIZE << fs->e2fs.e2fs_fsize; 872 sbp->f_iosize = fs->e2fs_bsize; 873 sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead; 874 sbp->f_bfree = fs->e2fs.e2fs_fbcount; 875 sbp->f_bresvd = fs->e2fs.e2fs_rbcount; 876 if (sbp->f_bfree > sbp->f_bresvd) 877 sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd; 878 else 879 sbp->f_bavail = 0; 880 sbp->f_files = fs->e2fs.e2fs_icount; 881 sbp->f_ffree = fs->e2fs.e2fs_ficount; 882 sbp->f_favail = fs->e2fs.e2fs_ficount; 883 sbp->f_fresvd = 0; 884 copy_statvfs_info(sbp, mp); 885 return (0); 886 } 887 888 /* 889 * Go through the disk queues to initiate sandbagged IO; 890 * go through the inodes to write those that have been modified; 891 * initiate the writing of the super block if it has been modified. 892 * 893 * Note: we are always called with the filesystem marked `MPBUSY'. 894 */ 895 int 896 ext2fs_sync(struct mount *mp, int waitfor, kauth_cred_t cred) 897 { 898 struct vnode *vp, *mvp; 899 struct inode *ip; 900 struct ufsmount *ump = VFSTOUFS(mp); 901 struct m_ext2fs *fs; 902 int error, allerror = 0; 903 904 fs = ump->um_e2fs; 905 if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) { /* XXX */ 906 printf("fs = %s\n", fs->e2fs_fsmnt); 907 panic("update: rofs mod"); 908 } 909 910 /* Allocate a marker vnode. */ 911 mvp = vnalloc(mp); 912 913 /* 914 * Write back each (modified) inode. 915 */ 916 mutex_enter(&mntvnode_lock); 917 loop: 918 /* 919 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone() 920 * and vclean() can be called indirectly 921 */ 922 for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) { 923 vmark(mvp, vp); 924 if (vp->v_mount != mp || vismarker(vp)) 925 continue; 926 mutex_enter(vp->v_interlock); 927 ip = VTOI(vp); 928 if (ip == NULL || (vp->v_iflag & (VI_XLOCK|VI_CLEAN)) != 0 || 929 vp->v_type == VNON || 930 ((ip->i_flag & 931 (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) == 0 && 932 LIST_EMPTY(&vp->v_dirtyblkhd) && 933 UVM_OBJ_IS_CLEAN(&vp->v_uobj))) 934 { 935 mutex_exit(vp->v_interlock); 936 continue; 937 } 938 mutex_exit(&mntvnode_lock); 939 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT); 940 if (error) { 941 mutex_enter(&mntvnode_lock); 942 if (error == ENOENT) { 943 mutex_enter(&mntvnode_lock); 944 (void)vunmark(mvp); 945 goto loop; 946 } 947 continue; 948 } 949 if (vp->v_type == VREG && waitfor == MNT_LAZY) 950 error = ext2fs_update(vp, NULL, NULL, 0); 951 else 952 error = VOP_FSYNC(vp, cred, 953 waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0); 954 if (error) 955 allerror = error; 956 vput(vp); 957 mutex_enter(&mntvnode_lock); 958 } 959 mutex_exit(&mntvnode_lock); 960 vnfree(mvp); 961 /* 962 * Force stale file system control information to be flushed. 963 */ 964 if (waitfor != MNT_LAZY) { 965 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 966 if ((error = VOP_FSYNC(ump->um_devvp, cred, 967 waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0)) != 0) 968 allerror = error; 969 VOP_UNLOCK(ump->um_devvp); 970 } 971 /* 972 * Write back modified superblock. 973 */ 974 if (fs->e2fs_fmod != 0) { 975 fs->e2fs_fmod = 0; 976 fs->e2fs.e2fs_wtime = time_second; 977 if ((error = ext2fs_cgupdate(ump, waitfor))) 978 allerror = error; 979 } 980 return (allerror); 981 } 982 983 /* 984 * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it 985 * in from disk. If it is in core, wait for the lock bit to clear, then 986 * return the inode locked. Detection and handling of mount points must be 987 * done by the calling routine. 988 */ 989 int 990 ext2fs_vget(struct mount *mp, ino_t ino, struct vnode **vpp) 991 { 992 struct m_ext2fs *fs; 993 struct inode *ip; 994 struct ufsmount *ump; 995 struct buf *bp; 996 struct vnode *vp; 997 dev_t dev; 998 int error; 999 void *cp; 1000 1001 ump = VFSTOUFS(mp); 1002 dev = ump->um_dev; 1003 retry: 1004 if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) 1005 return (0); 1006 1007 /* Allocate a new vnode/inode. */ 1008 error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, NULL, &vp); 1009 if (error) { 1010 *vpp = NULL; 1011 return (error); 1012 } 1013 ip = pool_get(&ext2fs_inode_pool, PR_WAITOK); 1014 1015 mutex_enter(&ufs_hashlock); 1016 if ((*vpp = ufs_ihashget(dev, ino, 0)) != NULL) { 1017 mutex_exit(&ufs_hashlock); 1018 ungetnewvnode(vp); 1019 pool_put(&ext2fs_inode_pool, ip); 1020 goto retry; 1021 } 1022 1023 vp->v_vflag |= VV_LOCKSWORK; 1024 1025 memset(ip, 0, sizeof(struct inode)); 1026 vp->v_data = ip; 1027 ip->i_vnode = vp; 1028 ip->i_ump = ump; 1029 ip->i_e2fs = fs = ump->um_e2fs; 1030 ip->i_dev = dev; 1031 ip->i_number = ino; 1032 ip->i_e2fs_last_lblk = 0; 1033 ip->i_e2fs_last_blk = 0; 1034 genfs_node_init(vp, &ext2fs_genfsops); 1035 1036 /* 1037 * Put it onto its hash chain and lock it so that other requests for 1038 * this inode will block if they arrive while we are sleeping waiting 1039 * for old data structures to be purged or for the contents of the 1040 * disk portion of this inode to be read. 1041 */ 1042 1043 ufs_ihashins(ip); 1044 mutex_exit(&ufs_hashlock); 1045 1046 /* Read in the disk contents for the inode, copy into the inode. */ 1047 error = bread(ump->um_devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ino)), 1048 (int)fs->e2fs_bsize, NOCRED, 0, &bp); 1049 if (error) { 1050 1051 /* 1052 * The inode does not contain anything useful, so it would 1053 * be misleading to leave it on its hash chain. With mode 1054 * still zero, it will be unlinked and returned to the free 1055 * list by vput(). 1056 */ 1057 1058 vput(vp); 1059 *vpp = NULL; 1060 return (error); 1061 } 1062 cp = (char *)bp->b_data + (ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE(fs)); 1063 ip->i_din.e2fs_din = pool_get(&ext2fs_dinode_pool, PR_WAITOK); 1064 e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din); 1065 ext2fs_set_inode_guid(ip); 1066 brelse(bp, 0); 1067 1068 /* If the inode was deleted, reset all fields */ 1069 if (ip->i_e2fs_dtime != 0) { 1070 ip->i_e2fs_mode = 0; 1071 (void)ext2fs_setsize(ip, 0); 1072 (void)ext2fs_setnblock(ip, 0); 1073 memset(ip->i_e2fs_blocks, 0, sizeof(ip->i_e2fs_blocks)); 1074 } 1075 1076 /* 1077 * Initialize the vnode from the inode, check for aliases. 1078 */ 1079 1080 error = ext2fs_vinit(mp, ext2fs_specop_p, ext2fs_fifoop_p, &vp); 1081 if (error) { 1082 vput(vp); 1083 *vpp = NULL; 1084 return (error); 1085 } 1086 /* 1087 * Finish inode initialization now that aliasing has been resolved. 1088 */ 1089 1090 ip->i_devvp = ump->um_devvp; 1091 vref(ip->i_devvp); 1092 1093 /* 1094 * Set up a generation number for this inode if it does not 1095 * already have one. This should only happen on old filesystems. 1096 */ 1097 1098 if (ip->i_e2fs_gen == 0) { 1099 if (++ext2gennumber < (u_long)time_second) 1100 ext2gennumber = time_second; 1101 ip->i_e2fs_gen = ext2gennumber; 1102 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) 1103 ip->i_flag |= IN_MODIFIED; 1104 } 1105 uvm_vnp_setsize(vp, ext2fs_size(ip)); 1106 *vpp = vp; 1107 return (0); 1108 } 1109 1110 /* 1111 * File handle to vnode 1112 * 1113 * Have to be really careful about stale file handles: 1114 * - check that the inode number is valid 1115 * - call ext2fs_vget() to get the locked inode 1116 * - check for an unallocated inode (i_mode == 0) 1117 */ 1118 int 1119 ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp) 1120 { 1121 struct inode *ip; 1122 struct vnode *nvp; 1123 int error; 1124 struct ufid ufh; 1125 struct m_ext2fs *fs; 1126 1127 if (fhp->fid_len != sizeof(struct ufid)) 1128 return EINVAL; 1129 1130 memcpy(&ufh, fhp, sizeof(struct ufid)); 1131 fs = VFSTOUFS(mp)->um_e2fs; 1132 if ((ufh.ufid_ino < EXT2_FIRSTINO && ufh.ufid_ino != EXT2_ROOTINO) || 1133 ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg) 1134 return (ESTALE); 1135 1136 if ((error = VFS_VGET(mp, ufh.ufid_ino, &nvp)) != 0) { 1137 *vpp = NULLVP; 1138 return (error); 1139 } 1140 ip = VTOI(nvp); 1141 if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 || 1142 ip->i_e2fs_gen != ufh.ufid_gen) { 1143 vput(nvp); 1144 *vpp = NULLVP; 1145 return (ESTALE); 1146 } 1147 *vpp = nvp; 1148 return (0); 1149 } 1150 1151 /* 1152 * Vnode pointer to File handle 1153 */ 1154 /* ARGSUSED */ 1155 int 1156 ext2fs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size) 1157 { 1158 struct inode *ip; 1159 struct ufid ufh; 1160 1161 if (*fh_size < sizeof(struct ufid)) { 1162 *fh_size = sizeof(struct ufid); 1163 return E2BIG; 1164 } 1165 *fh_size = sizeof(struct ufid); 1166 1167 ip = VTOI(vp); 1168 memset(&ufh, 0, sizeof(ufh)); 1169 ufh.ufid_len = sizeof(struct ufid); 1170 ufh.ufid_ino = ip->i_number; 1171 ufh.ufid_gen = ip->i_e2fs_gen; 1172 memcpy(fhp, &ufh, sizeof(ufh)); 1173 return (0); 1174 } 1175 1176 /* 1177 * Write a superblock and associated information back to disk. 1178 */ 1179 int 1180 ext2fs_sbupdate(struct ufsmount *mp, int waitfor) 1181 { 1182 struct m_ext2fs *fs = mp->um_e2fs; 1183 struct buf *bp; 1184 int error = 0; 1185 1186 bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0); 1187 e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data); 1188 if (waitfor == MNT_WAIT) 1189 error = bwrite(bp); 1190 else 1191 bawrite(bp); 1192 return (error); 1193 } 1194 1195 int 1196 ext2fs_cgupdate(struct ufsmount *mp, int waitfor) 1197 { 1198 struct m_ext2fs *fs = mp->um_e2fs; 1199 struct buf *bp; 1200 int i, error = 0, allerror = 0; 1201 1202 allerror = ext2fs_sbupdate(mp, waitfor); 1203 for (i = 0; i < fs->e2fs_ngdb; i++) { 1204 bp = getblk(mp->um_devvp, EXT2_FSBTODB(fs, 1205 fs->e2fs.e2fs_first_dblock + 1206 1 /* superblock */ + i), fs->e2fs_bsize, 0, 0); 1207 e2fs_cgsave(&fs->e2fs_gd[ 1208 i * fs->e2fs_bsize / sizeof(struct ext2_gd)], 1209 (struct ext2_gd *)bp->b_data, fs->e2fs_bsize); 1210 if (waitfor == MNT_WAIT) 1211 error = bwrite(bp); 1212 else 1213 bawrite(bp); 1214 } 1215 1216 if (!allerror && error) 1217 allerror = error; 1218 return (allerror); 1219 } 1220 1221 static int 1222 ext2fs_checksb(struct ext2fs *fs, int ronly) 1223 { 1224 uint32_t u32; 1225 1226 if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) { 1227 return (EINVAL); /* XXX needs translation */ 1228 } 1229 if (fs2h32(fs->e2fs_rev) > E2FS_REV1) { 1230 #ifdef DIAGNOSTIC 1231 printf("ext2fs: unsupported revision number: %x\n", 1232 fs2h32(fs->e2fs_rev)); 1233 #endif 1234 return (EINVAL); /* XXX needs translation */ 1235 } 1236 if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */ 1237 #ifdef DIAGNOSTIC 1238 printf("ext2fs: bad block size: %d " 1239 "(expected <= 2 for ext2 fs)\n", 1240 fs2h32(fs->e2fs_log_bsize)); 1241 #endif 1242 return (EINVAL); /* XXX needs translation */ 1243 } 1244 if (fs2h32(fs->e2fs_rev) > E2FS_REV0) { 1245 char buf[256]; 1246 if (fs2h32(fs->e2fs_first_ino) != EXT2_FIRSTINO) { 1247 printf("ext2fs: unsupported first inode position\n"); 1248 return (EINVAL); /* XXX needs translation */ 1249 } 1250 u32 = fs2h32(fs->e2fs_features_incompat) & ~EXT2F_INCOMPAT_SUPP; 1251 if (u32) { 1252 snprintb(buf, sizeof(buf), EXT2F_INCOMPAT_BITS, u32); 1253 printf("ext2fs: unsupported incompat features: %s\n", 1254 buf); 1255 return EINVAL; /* XXX needs translation */ 1256 } 1257 u32 = fs2h32(fs->e2fs_features_rocompat) & ~EXT2F_ROCOMPAT_SUPP; 1258 if (!ronly && u32) { 1259 snprintb(buf, sizeof(buf), EXT2F_ROCOMPAT_BITS, u32); 1260 printf("ext2fs: unsupported ro-incompat features: %s\n", 1261 buf); 1262 return EROFS; /* XXX needs translation */ 1263 } 1264 } 1265 return (0); 1266 } 1267