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