ffs_vfsops.c revision 1.311
1 /* $NetBSD: ffs_vfsops.c,v 1.311 2015/02/14 07:20:11 maxv Exp $ */ 2 3 /*- 4 * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Wasabi Systems, Inc, and by Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 1989, 1991, 1993, 1994 34 * The Regents of the University of California. All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 3. Neither the name of the University nor the names of its contributors 45 * may be used to endorse or promote products derived from this software 46 * without specific prior written permission. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 58 * SUCH DAMAGE. 59 * 60 * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95 61 */ 62 63 #include <sys/cdefs.h> 64 __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.311 2015/02/14 07:20:11 maxv Exp $"); 65 66 #if defined(_KERNEL_OPT) 67 #include "opt_ffs.h" 68 #include "opt_quota.h" 69 #include "opt_wapbl.h" 70 #endif 71 72 #include <sys/param.h> 73 #include <sys/systm.h> 74 #include <sys/namei.h> 75 #include <sys/proc.h> 76 #include <sys/kernel.h> 77 #include <sys/vnode.h> 78 #include <sys/socket.h> 79 #include <sys/mount.h> 80 #include <sys/buf.h> 81 #include <sys/device.h> 82 #include <sys/disk.h> 83 #include <sys/mbuf.h> 84 #include <sys/file.h> 85 #include <sys/disklabel.h> 86 #include <sys/ioctl.h> 87 #include <sys/errno.h> 88 #include <sys/kmem.h> 89 #include <sys/pool.h> 90 #include <sys/lock.h> 91 #include <sys/sysctl.h> 92 #include <sys/conf.h> 93 #include <sys/kauth.h> 94 #include <sys/wapbl.h> 95 #include <sys/fstrans.h> 96 #include <sys/module.h> 97 98 #include <miscfs/genfs/genfs.h> 99 #include <miscfs/specfs/specdev.h> 100 101 #include <ufs/ufs/quota.h> 102 #include <ufs/ufs/ufsmount.h> 103 #include <ufs/ufs/inode.h> 104 #include <ufs/ufs/dir.h> 105 #include <ufs/ufs/ufs_extern.h> 106 #include <ufs/ufs/ufs_bswap.h> 107 #include <ufs/ufs/ufs_wapbl.h> 108 109 #include <ufs/ffs/fs.h> 110 #include <ufs/ffs/ffs_extern.h> 111 112 MODULE(MODULE_CLASS_VFS, ffs, NULL); 113 114 static int 115 ffs_vfs_fsync(vnode_t *, int); 116 117 static int 118 ffs_superblock_validate(struct fs *fs, u_int32_t fs_sbsize, int32_t fs_bsize); 119 120 static struct sysctllog *ffs_sysctl_log; 121 122 static kauth_listener_t ffs_snapshot_listener; 123 124 /* how many times ffs_init() was called */ 125 int ffs_initcount = 0; 126 127 #ifdef DEBUG_FFS_MOUNT 128 #define DPRINTF(a) printf a 129 #else 130 #define DPRINTF(a) do {} while (/*CONSTCOND*/0) 131 #endif 132 133 extern const struct vnodeopv_desc ffs_vnodeop_opv_desc; 134 extern const struct vnodeopv_desc ffs_specop_opv_desc; 135 extern const struct vnodeopv_desc ffs_fifoop_opv_desc; 136 137 const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = { 138 &ffs_vnodeop_opv_desc, 139 &ffs_specop_opv_desc, 140 &ffs_fifoop_opv_desc, 141 NULL, 142 }; 143 144 struct vfsops ffs_vfsops = { 145 .vfs_name = MOUNT_FFS, 146 .vfs_min_mount_data = sizeof (struct ufs_args), 147 .vfs_mount = ffs_mount, 148 .vfs_start = ufs_start, 149 .vfs_unmount = ffs_unmount, 150 .vfs_root = ufs_root, 151 .vfs_quotactl = ufs_quotactl, 152 .vfs_statvfs = ffs_statvfs, 153 .vfs_sync = ffs_sync, 154 .vfs_vget = ufs_vget, 155 .vfs_loadvnode = ffs_loadvnode, 156 .vfs_fhtovp = ffs_fhtovp, 157 .vfs_vptofh = ffs_vptofh, 158 .vfs_init = ffs_init, 159 .vfs_reinit = ffs_reinit, 160 .vfs_done = ffs_done, 161 .vfs_mountroot = ffs_mountroot, 162 .vfs_snapshot = ffs_snapshot, 163 .vfs_extattrctl = ffs_extattrctl, 164 .vfs_suspendctl = ffs_suspendctl, 165 .vfs_renamelock_enter = genfs_renamelock_enter, 166 .vfs_renamelock_exit = genfs_renamelock_exit, 167 .vfs_fsync = ffs_vfs_fsync, 168 .vfs_opv_descs = ffs_vnodeopv_descs 169 }; 170 171 static const struct genfs_ops ffs_genfsops = { 172 .gop_size = ffs_gop_size, 173 .gop_alloc = ufs_gop_alloc, 174 .gop_write = genfs_gop_write, 175 .gop_markupdate = ufs_gop_markupdate, 176 }; 177 178 static const struct ufs_ops ffs_ufsops = { 179 .uo_itimes = ffs_itimes, 180 .uo_update = ffs_update, 181 .uo_truncate = ffs_truncate, 182 .uo_valloc = ffs_valloc, 183 .uo_vfree = ffs_vfree, 184 .uo_balloc = ffs_balloc, 185 .uo_snapgone = ffs_snapgone, 186 }; 187 188 static int 189 ffs_snapshot_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, 190 void *arg0, void *arg1, void *arg2, void *arg3) 191 { 192 vnode_t *vp = arg2; 193 int result = KAUTH_RESULT_DEFER; 194 195 if (action != KAUTH_SYSTEM_FS_SNAPSHOT) 196 return result; 197 198 if (VTOI(vp)->i_uid == kauth_cred_geteuid(cred)) 199 result = KAUTH_RESULT_ALLOW; 200 201 return result; 202 } 203 204 static int 205 ffs_modcmd(modcmd_t cmd, void *arg) 206 { 207 int error; 208 209 #if 0 210 extern int doasyncfree; 211 #endif 212 #ifdef UFS_EXTATTR 213 extern int ufs_extattr_autocreate; 214 #endif 215 extern int ffs_log_changeopt; 216 217 switch (cmd) { 218 case MODULE_CMD_INIT: 219 error = vfs_attach(&ffs_vfsops); 220 if (error != 0) 221 break; 222 223 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 224 CTLFLAG_PERMANENT, 225 CTLTYPE_NODE, "ffs", 226 SYSCTL_DESCR("Berkeley Fast File System"), 227 NULL, 0, NULL, 0, 228 CTL_VFS, 1, CTL_EOL); 229 /* 230 * @@@ should we even bother with these first three? 231 */ 232 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 233 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 234 CTLTYPE_INT, "doclusterread", NULL, 235 sysctl_notavail, 0, NULL, 0, 236 CTL_VFS, 1, FFS_CLUSTERREAD, CTL_EOL); 237 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 238 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 239 CTLTYPE_INT, "doclusterwrite", NULL, 240 sysctl_notavail, 0, NULL, 0, 241 CTL_VFS, 1, FFS_CLUSTERWRITE, CTL_EOL); 242 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 243 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 244 CTLTYPE_INT, "doreallocblks", NULL, 245 sysctl_notavail, 0, NULL, 0, 246 CTL_VFS, 1, FFS_REALLOCBLKS, CTL_EOL); 247 #if 0 248 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 249 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 250 CTLTYPE_INT, "doasyncfree", 251 SYSCTL_DESCR("Release dirty blocks asynchronously"), 252 NULL, 0, &doasyncfree, 0, 253 CTL_VFS, 1, FFS_ASYNCFREE, CTL_EOL); 254 #endif 255 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 256 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 257 CTLTYPE_INT, "log_changeopt", 258 SYSCTL_DESCR("Log changes in optimization strategy"), 259 NULL, 0, &ffs_log_changeopt, 0, 260 CTL_VFS, 1, FFS_LOG_CHANGEOPT, CTL_EOL); 261 #ifdef UFS_EXTATTR 262 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL, 263 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 264 CTLTYPE_INT, "extattr_autocreate", 265 SYSCTL_DESCR("Size of attribute for " 266 "backing file autocreation"), 267 NULL, 0, &ufs_extattr_autocreate, 0, 268 CTL_VFS, 1, FFS_EXTATTR_AUTOCREATE, CTL_EOL); 269 270 #endif /* UFS_EXTATTR */ 271 272 ffs_snapshot_listener = kauth_listen_scope(KAUTH_SCOPE_SYSTEM, 273 ffs_snapshot_cb, NULL); 274 if (ffs_snapshot_listener == NULL) 275 printf("ffs_modcmd: can't listen on system scope.\n"); 276 277 break; 278 case MODULE_CMD_FINI: 279 error = vfs_detach(&ffs_vfsops); 280 if (error != 0) 281 break; 282 sysctl_teardown(&ffs_sysctl_log); 283 if (ffs_snapshot_listener != NULL) 284 kauth_unlisten_scope(ffs_snapshot_listener); 285 break; 286 default: 287 error = ENOTTY; 288 break; 289 } 290 291 return (error); 292 } 293 294 pool_cache_t ffs_inode_cache; 295 pool_cache_t ffs_dinode1_cache; 296 pool_cache_t ffs_dinode2_cache; 297 298 static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t); 299 static void ffs_oldfscompat_write(struct fs *, struct ufsmount *); 300 301 /* 302 * Called by main() when ffs is going to be mounted as root. 303 */ 304 305 int 306 ffs_mountroot(void) 307 { 308 struct fs *fs; 309 struct mount *mp; 310 struct lwp *l = curlwp; /* XXX */ 311 struct ufsmount *ump; 312 int error; 313 314 if (device_class(root_device) != DV_DISK) 315 return (ENODEV); 316 317 if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) { 318 vrele(rootvp); 319 return (error); 320 } 321 322 /* 323 * We always need to be able to mount the root file system. 324 */ 325 mp->mnt_flag |= MNT_FORCE; 326 if ((error = ffs_mountfs(rootvp, mp, l)) != 0) { 327 vfs_unbusy(mp, false, NULL); 328 vfs_destroy(mp); 329 return (error); 330 } 331 mp->mnt_flag &= ~MNT_FORCE; 332 mountlist_append(mp); 333 ump = VFSTOUFS(mp); 334 fs = ump->um_fs; 335 memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt)); 336 (void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0); 337 (void)ffs_statvfs(mp, &mp->mnt_stat); 338 vfs_unbusy(mp, false, NULL); 339 setrootfstime((time_t)fs->fs_time); 340 return (0); 341 } 342 343 /* 344 * VFS Operations. 345 * 346 * mount system call 347 */ 348 int 349 ffs_mount(struct mount *mp, const char *path, void *data, size_t *data_len) 350 { 351 struct lwp *l = curlwp; 352 struct vnode *devvp = NULL; 353 struct ufs_args *args = data; 354 struct ufsmount *ump = NULL; 355 struct fs *fs; 356 int error = 0, flags, update; 357 mode_t accessmode; 358 359 if (args == NULL) { 360 DPRINTF(("%s: NULL args\n", __func__)); 361 return EINVAL; 362 } 363 if (*data_len < sizeof(*args)) { 364 DPRINTF(("%s: bad size args %zu != %zu\n", 365 __func__, *data_len, sizeof(*args))); 366 return EINVAL; 367 } 368 369 if (mp->mnt_flag & MNT_GETARGS) { 370 ump = VFSTOUFS(mp); 371 if (ump == NULL) { 372 DPRINTF(("%s: no ump\n", __func__)); 373 return EIO; 374 } 375 args->fspec = NULL; 376 *data_len = sizeof *args; 377 return 0; 378 } 379 380 update = mp->mnt_flag & MNT_UPDATE; 381 382 /* Check arguments */ 383 if (args->fspec != NULL) { 384 /* 385 * Look up the name and verify that it's sane. 386 */ 387 error = namei_simple_user(args->fspec, 388 NSM_FOLLOW_NOEMULROOT, &devvp); 389 if (error != 0) { 390 DPRINTF(("%s: namei_simple_user %d\n", __func__, 391 error)); 392 return error; 393 } 394 395 if (!update) { 396 /* 397 * Be sure this is a valid block device 398 */ 399 if (devvp->v_type != VBLK) { 400 DPRINTF(("%s: non block device %d\n", 401 __func__, devvp->v_type)); 402 error = ENOTBLK; 403 } else if (bdevsw_lookup(devvp->v_rdev) == NULL) { 404 DPRINTF(("%s: can't find block device 0x%jx\n", 405 __func__, devvp->v_rdev)); 406 error = ENXIO; 407 } 408 } else { 409 /* 410 * Be sure we're still naming the same device 411 * used for our initial mount 412 */ 413 ump = VFSTOUFS(mp); 414 if (devvp != ump->um_devvp) { 415 if (devvp->v_rdev != ump->um_devvp->v_rdev) { 416 DPRINTF(("%s: wrong device 0x%jx" 417 " != 0x%jx\n", __func__, 418 (uintmax_t)devvp->v_rdev, 419 (uintmax_t)ump->um_devvp->v_rdev)); 420 error = EINVAL; 421 } else { 422 vrele(devvp); 423 devvp = ump->um_devvp; 424 vref(devvp); 425 } 426 } 427 } 428 } else { 429 if (!update) { 430 /* New mounts must have a filename for the device */ 431 DPRINTF(("%s: no filename for mount\n", __func__)); 432 return EINVAL; 433 } else { 434 /* Use the extant mount */ 435 ump = VFSTOUFS(mp); 436 devvp = ump->um_devvp; 437 vref(devvp); 438 } 439 } 440 441 /* 442 * If mount by non-root, then verify that user has necessary 443 * permissions on the device. 444 * 445 * Permission to update a mount is checked higher, so here we presume 446 * updating the mount is okay (for example, as far as securelevel goes) 447 * which leaves us with the normal check. 448 */ 449 if (error == 0) { 450 accessmode = VREAD; 451 if (update ? 452 (mp->mnt_iflag & IMNT_WANTRDWR) != 0 : 453 (mp->mnt_flag & MNT_RDONLY) == 0) 454 accessmode |= VWRITE; 455 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 456 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT, 457 KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp, 458 KAUTH_ARG(accessmode)); 459 if (error) { 460 DPRINTF(("%s: kauth %d\n", __func__, error)); 461 } 462 VOP_UNLOCK(devvp); 463 } 464 465 if (error) { 466 vrele(devvp); 467 return (error); 468 } 469 470 #ifdef WAPBL 471 /* WAPBL can only be enabled on a r/w mount. */ 472 if ((mp->mnt_flag & MNT_RDONLY) && !(mp->mnt_iflag & IMNT_WANTRDWR)) { 473 mp->mnt_flag &= ~MNT_LOG; 474 } 475 #else /* !WAPBL */ 476 mp->mnt_flag &= ~MNT_LOG; 477 #endif /* !WAPBL */ 478 479 if (!update) { 480 int xflags; 481 482 if (mp->mnt_flag & MNT_RDONLY) 483 xflags = FREAD; 484 else 485 xflags = FREAD | FWRITE; 486 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 487 error = VOP_OPEN(devvp, xflags, FSCRED); 488 VOP_UNLOCK(devvp); 489 if (error) { 490 DPRINTF(("%s: VOP_OPEN %d\n", __func__, error)); 491 goto fail; 492 } 493 error = ffs_mountfs(devvp, mp, l); 494 if (error) { 495 DPRINTF(("%s: ffs_mountfs %d\n", __func__, error)); 496 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 497 (void)VOP_CLOSE(devvp, xflags, NOCRED); 498 VOP_UNLOCK(devvp); 499 goto fail; 500 } 501 502 ump = VFSTOUFS(mp); 503 fs = ump->um_fs; 504 } else { 505 /* 506 * Update the mount. 507 */ 508 509 /* 510 * The initial mount got a reference on this 511 * device, so drop the one obtained via 512 * namei(), above. 513 */ 514 vrele(devvp); 515 516 ump = VFSTOUFS(mp); 517 fs = ump->um_fs; 518 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { 519 /* 520 * Changing from r/w to r/o 521 */ 522 flags = WRITECLOSE; 523 if (mp->mnt_flag & MNT_FORCE) 524 flags |= FORCECLOSE; 525 error = ffs_flushfiles(mp, flags, l); 526 if (error == 0) 527 error = UFS_WAPBL_BEGIN(mp); 528 if (error == 0 && 529 ffs_cgupdate(ump, MNT_WAIT) == 0 && 530 fs->fs_clean & FS_WASCLEAN) { 531 if (mp->mnt_flag & MNT_SOFTDEP) 532 fs->fs_flags &= ~FS_DOSOFTDEP; 533 fs->fs_clean = FS_ISCLEAN; 534 (void) ffs_sbupdate(ump, MNT_WAIT); 535 } 536 if (error) { 537 DPRINTF(("%s: wapbl %d\n", __func__, error)); 538 return error; 539 } 540 UFS_WAPBL_END(mp); 541 } 542 543 #ifdef WAPBL 544 if ((mp->mnt_flag & MNT_LOG) == 0) { 545 error = ffs_wapbl_stop(mp, mp->mnt_flag & MNT_FORCE); 546 if (error) { 547 DPRINTF(("%s: ffs_wapbl_stop %d\n", 548 __func__, error)); 549 return error; 550 } 551 } 552 #endif /* WAPBL */ 553 554 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { 555 /* 556 * Finish change from r/w to r/o 557 */ 558 fs->fs_ronly = 1; 559 fs->fs_fmod = 0; 560 } 561 562 if (mp->mnt_flag & MNT_RELOAD) { 563 error = ffs_reload(mp, l->l_cred, l); 564 if (error) { 565 DPRINTF(("%s: ffs_reload %d\n", 566 __func__, error)); 567 return error; 568 } 569 } 570 571 if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) { 572 /* 573 * Changing from read-only to read/write 574 */ 575 #ifndef QUOTA2 576 if (fs->fs_flags & FS_DOQUOTA2) { 577 ump->um_flags |= UFS_QUOTA2; 578 uprintf("%s: options QUOTA2 not enabled%s\n", 579 mp->mnt_stat.f_mntonname, 580 (mp->mnt_flag & MNT_FORCE) ? "" : 581 ", not mounting"); 582 DPRINTF(("%s: ffs_quota2 %d\n", 583 __func__, EINVAL)); 584 return EINVAL; 585 } 586 #endif 587 fs->fs_ronly = 0; 588 fs->fs_clean <<= 1; 589 fs->fs_fmod = 1; 590 #ifdef WAPBL 591 if (fs->fs_flags & FS_DOWAPBL) { 592 const char *nm = mp->mnt_stat.f_mntonname; 593 if (!mp->mnt_wapbl_replay) { 594 printf("%s: log corrupted;" 595 " replay cancelled\n", nm); 596 return EFTYPE; 597 } 598 printf("%s: replaying log to disk\n", nm); 599 error = wapbl_replay_write(mp->mnt_wapbl_replay, 600 devvp); 601 if (error) { 602 DPRINTF(( 603 "%s: %s: wapbl_replay_write %d\n", 604 __func__, nm, error)); 605 return error; 606 } 607 wapbl_replay_stop(mp->mnt_wapbl_replay); 608 fs->fs_clean = FS_WASCLEAN; 609 } 610 #endif /* WAPBL */ 611 if (fs->fs_snapinum[0] != 0) 612 ffs_snapshot_mount(mp); 613 } 614 615 #ifdef WAPBL 616 error = ffs_wapbl_start(mp); 617 if (error) { 618 DPRINTF(("%s: ffs_wapbl_start %d\n", 619 __func__, error)); 620 return error; 621 } 622 #endif /* WAPBL */ 623 624 #ifdef QUOTA2 625 if (!fs->fs_ronly) { 626 error = ffs_quota2_mount(mp); 627 if (error) { 628 DPRINTF(("%s: ffs_quota2_mount %d\n", 629 __func__, error)); 630 return error; 631 } 632 } 633 #endif 634 635 if ((mp->mnt_flag & MNT_DISCARD) && !(ump->um_discarddata)) 636 ump->um_discarddata = ffs_discard_init(devvp, fs); 637 638 if (args->fspec == NULL) 639 return 0; 640 } 641 642 error = set_statvfs_info(path, UIO_USERSPACE, args->fspec, 643 UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l); 644 if (error == 0) 645 (void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, 646 sizeof(fs->fs_fsmnt)); 647 else { 648 DPRINTF(("%s: set_statvfs_info %d\n", __func__, error)); 649 } 650 fs->fs_flags &= ~FS_DOSOFTDEP; 651 if (fs->fs_fmod != 0) { /* XXX */ 652 int err; 653 654 fs->fs_fmod = 0; 655 if (fs->fs_clean & FS_WASCLEAN) 656 fs->fs_time = time_second; 657 else { 658 printf("%s: file system not clean (fs_clean=%#x); " 659 "please fsck(8)\n", mp->mnt_stat.f_mntfromname, 660 fs->fs_clean); 661 printf("%s: lost blocks %" PRId64 " files %d\n", 662 mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks, 663 fs->fs_pendinginodes); 664 } 665 err = UFS_WAPBL_BEGIN(mp); 666 if (err == 0) { 667 (void) ffs_cgupdate(ump, MNT_WAIT); 668 UFS_WAPBL_END(mp); 669 } 670 } 671 if ((mp->mnt_flag & MNT_SOFTDEP) != 0) { 672 printf("%s: `-o softdep' is no longer supported, " 673 "consider `-o log'\n", mp->mnt_stat.f_mntfromname); 674 mp->mnt_flag &= ~MNT_SOFTDEP; 675 } 676 677 return (error); 678 679 fail: 680 vrele(devvp); 681 return (error); 682 } 683 684 /* 685 * Reload all incore data for a filesystem (used after running fsck on 686 * the root filesystem and finding things to fix). The filesystem must 687 * be mounted read-only. 688 * 689 * Things to do to update the mount: 690 * 1) invalidate all cached meta-data. 691 * 2) re-read superblock from disk. 692 * 3) re-read summary information from disk. 693 * 4) invalidate all inactive vnodes. 694 * 5) invalidate all cached file data. 695 * 6) re-read inode data for all active vnodes. 696 */ 697 int 698 ffs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l) 699 { 700 struct vnode *vp, *devvp; 701 struct inode *ip; 702 void *space; 703 struct buf *bp; 704 struct fs *fs, *newfs; 705 struct dkwedge_info dkw; 706 int i, bsize, blks, error; 707 int32_t *lp; 708 struct ufsmount *ump; 709 daddr_t sblockloc; 710 struct vnode_iterator *marker; 711 712 if ((mp->mnt_flag & MNT_RDONLY) == 0) 713 return (EINVAL); 714 715 ump = VFSTOUFS(mp); 716 717 /* 718 * Step 1: invalidate all cached meta-data. 719 */ 720 devvp = ump->um_devvp; 721 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 722 error = vinvalbuf(devvp, 0, cred, l, 0, 0); 723 VOP_UNLOCK(devvp); 724 if (error) 725 panic("ffs_reload: dirty1"); 726 727 /* 728 * Step 2: re-read superblock from disk. XXX: We don't handle 729 * possibility that superblock moved. 730 */ 731 fs = ump->um_fs; 732 error = bread(devvp, fs->fs_sblockloc / DEV_BSIZE, fs->fs_sbsize, 733 NOCRED, 0, &bp); 734 if (error) 735 return (error); 736 newfs = kmem_alloc(fs->fs_sbsize, KM_SLEEP); 737 memcpy(newfs, bp->b_data, fs->fs_sbsize); 738 739 #ifdef FFS_EI 740 if (ump->um_flags & UFS_NEEDSWAP) { 741 ffs_sb_swap((struct fs*)bp->b_data, newfs); 742 fs->fs_flags |= FS_SWAPPED; 743 } else 744 #endif 745 fs->fs_flags &= ~FS_SWAPPED; 746 747 if ((newfs->fs_magic != FS_UFS1_MAGIC && 748 newfs->fs_magic != FS_UFS2_MAGIC)) { 749 brelse(bp, 0); 750 kmem_free(newfs, fs->fs_sbsize); 751 return (EIO); /* XXX needs translation */ 752 } 753 if (!ffs_superblock_validate(newfs, newfs->fs_sbsize, newfs->fs_bsize)) { 754 brelse(bp, 0); 755 kmem_free(newfs, fs->fs_sbsize); 756 return (EINVAL); 757 } 758 759 /* Store off old fs_sblockloc for fs_oldfscompat_read. */ 760 sblockloc = fs->fs_sblockloc; 761 /* 762 * Copy pointer fields back into superblock before copying in XXX 763 * new superblock. These should really be in the ufsmount. XXX 764 * Note that important parameters (eg fs_ncg) are unchanged. 765 */ 766 newfs->fs_csp = fs->fs_csp; 767 newfs->fs_maxcluster = fs->fs_maxcluster; 768 newfs->fs_contigdirs = fs->fs_contigdirs; 769 newfs->fs_ronly = fs->fs_ronly; 770 newfs->fs_active = fs->fs_active; 771 memcpy(fs, newfs, (u_int)fs->fs_sbsize); 772 brelse(bp, 0); 773 kmem_free(newfs, fs->fs_sbsize); 774 775 /* Recheck for apple UFS filesystem */ 776 ump->um_flags &= ~UFS_ISAPPLEUFS; 777 /* First check to see if this is tagged as an Apple UFS filesystem 778 * in the disklabel 779 */ 780 if (getdiskinfo(devvp, &dkw) == 0 && 781 strcmp(dkw.dkw_ptype, DKW_PTYPE_APPLEUFS) == 0) 782 ump->um_flags |= UFS_ISAPPLEUFS; 783 #ifdef APPLE_UFS 784 else { 785 /* Manually look for an apple ufs label, and if a valid one 786 * is found, then treat it like an Apple UFS filesystem anyway 787 * 788 * EINVAL is most probably a blocksize or alignment problem, 789 * it is unlikely that this is an Apple UFS filesystem then. 790 */ 791 error = bread(devvp, 792 (daddr_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE), 793 APPLEUFS_LABEL_SIZE, cred, 0, &bp); 794 if (error && error != EINVAL) { 795 return error; 796 } 797 if (error == 0) { 798 error = ffs_appleufs_validate(fs->fs_fsmnt, 799 (struct appleufslabel *)bp->b_data, NULL); 800 if (error == 0) 801 ump->um_flags |= UFS_ISAPPLEUFS; 802 brelse(bp, 0); 803 } 804 bp = NULL; 805 } 806 #else 807 if (ump->um_flags & UFS_ISAPPLEUFS) 808 return (EIO); 809 #endif 810 811 if (UFS_MPISAPPLEUFS(ump)) { 812 /* see comment about NeXT below */ 813 ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN; 814 ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ; 815 mp->mnt_iflag |= IMNT_DTYPE; 816 } else { 817 ump->um_maxsymlinklen = fs->fs_maxsymlinklen; 818 ump->um_dirblksiz = UFS_DIRBLKSIZ; 819 if (ump->um_maxsymlinklen > 0) 820 mp->mnt_iflag |= IMNT_DTYPE; 821 else 822 mp->mnt_iflag &= ~IMNT_DTYPE; 823 } 824 ffs_oldfscompat_read(fs, ump, sblockloc); 825 826 mutex_enter(&ump->um_lock); 827 ump->um_maxfilesize = fs->fs_maxfilesize; 828 if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) { 829 uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n", 830 mp->mnt_stat.f_mntonname, fs->fs_flags, 831 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting"); 832 if ((mp->mnt_flag & MNT_FORCE) == 0) { 833 mutex_exit(&ump->um_lock); 834 return (EINVAL); 835 } 836 } 837 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 838 fs->fs_pendingblocks = 0; 839 fs->fs_pendinginodes = 0; 840 } 841 mutex_exit(&ump->um_lock); 842 843 ffs_statvfs(mp, &mp->mnt_stat); 844 /* 845 * Step 3: re-read summary information from disk. 846 */ 847 blks = howmany(fs->fs_cssize, fs->fs_fsize); 848 space = fs->fs_csp; 849 for (i = 0; i < blks; i += fs->fs_frag) { 850 bsize = fs->fs_bsize; 851 if (i + fs->fs_frag > blks) 852 bsize = (blks - i) * fs->fs_fsize; 853 error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), bsize, 854 NOCRED, 0, &bp); 855 if (error) { 856 return (error); 857 } 858 #ifdef FFS_EI 859 if (UFS_FSNEEDSWAP(fs)) 860 ffs_csum_swap((struct csum *)bp->b_data, 861 (struct csum *)space, bsize); 862 else 863 #endif 864 memcpy(space, bp->b_data, (size_t)bsize); 865 space = (char *)space + bsize; 866 brelse(bp, 0); 867 } 868 /* 869 * We no longer know anything about clusters per cylinder group. 870 */ 871 if (fs->fs_contigsumsize > 0) { 872 lp = fs->fs_maxcluster; 873 for (i = 0; i < fs->fs_ncg; i++) 874 *lp++ = fs->fs_contigsumsize; 875 } 876 877 vfs_vnode_iterator_init(mp, &marker); 878 while ((vp = vfs_vnode_iterator_next(marker, NULL, NULL))) { 879 /* 880 * Step 4: invalidate all inactive vnodes. 881 */ 882 if (vrecycle(vp)) 883 continue; 884 /* 885 * Step 5: invalidate all cached file data. 886 */ 887 if (vn_lock(vp, LK_EXCLUSIVE)) { 888 vrele(vp); 889 continue; 890 } 891 if (vinvalbuf(vp, 0, cred, l, 0, 0)) 892 panic("ffs_reload: dirty2"); 893 /* 894 * Step 6: re-read inode data for all active vnodes. 895 */ 896 ip = VTOI(vp); 897 error = bread(devvp, FFS_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)), 898 (int)fs->fs_bsize, NOCRED, 0, &bp); 899 if (error) { 900 vput(vp); 901 break; 902 } 903 ffs_load_inode(bp, ip, fs, ip->i_number); 904 brelse(bp, 0); 905 vput(vp); 906 } 907 vfs_vnode_iterator_destroy(marker); 908 return (error); 909 } 910 911 /* 912 * Possible superblock locations ordered from most to least likely. 913 */ 914 static const int sblock_try[] = SBLOCKSEARCH; 915 916 917 static int 918 ffs_superblock_validate(struct fs *fs, u_int32_t fs_sbsize, int32_t fs_bsize) 919 { 920 /* Check the superblock size */ 921 if (fs_sbsize > SBLOCKSIZE || fs_sbsize < sizeof(struct fs)) 922 return 0; 923 924 /* Check the file system blocksize */ 925 if (fs_bsize > MAXBSIZE || fs_bsize < MINBSIZE) 926 return 0; 927 if (!powerof2(fs_bsize)) 928 return 0; 929 930 /* Check the size of frag blocks */ 931 if (!powerof2(fs->fs_fsize)) 932 return 0; 933 934 if (fs->fs_size == 0) 935 return 0; 936 if (fs->fs_cssize == 0) 937 return 0; 938 939 /* Block size cannot be smaller than fragment size */ 940 if (fs_bsize < fs->fs_fsize) 941 return 0; 942 943 return 1; 944 } 945 946 /* 947 * Common code for mount and mountroot 948 */ 949 int 950 ffs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l) 951 { 952 struct ufsmount *ump = NULL; 953 struct buf *bp = NULL; 954 struct fs *fs = NULL; 955 dev_t dev; 956 struct dkwedge_info dkw; 957 void *space; 958 daddr_t sblockloc = 0; 959 int blks, fstype = 0; 960 int error, i, bsize, ronly, bset = 0; 961 #ifdef FFS_EI 962 int needswap = 0; /* keep gcc happy */ 963 #endif 964 int32_t *lp; 965 kauth_cred_t cred; 966 u_int32_t fs_sbsize = 8192; /* keep gcc happy*/ 967 u_int32_t allocsbsize; 968 969 dev = devvp->v_rdev; 970 cred = l ? l->l_cred : NOCRED; 971 972 /* Flush out any old buffers remaining from a previous use. */ 973 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 974 error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0); 975 VOP_UNLOCK(devvp); 976 if (error) { 977 DPRINTF(("%s: vinvalbuf %d\n", __func__, error)); 978 return error; 979 } 980 981 ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 982 983 error = fstrans_mount(mp); 984 if (error) { 985 DPRINTF(("%s: fstrans_mount %d\n", __func__, error)); 986 return error; 987 } 988 989 ump = kmem_zalloc(sizeof(*ump), KM_SLEEP); 990 mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE); 991 error = ffs_snapshot_init(ump); 992 if (error) { 993 DPRINTF(("%s: ffs_snapshot_init %d\n", __func__, error)); 994 goto out; 995 } 996 ump->um_ops = &ffs_ufsops; 997 998 #ifdef WAPBL 999 sbagain: 1000 #endif 1001 /* 1002 * Try reading the superblock in each of its possible locations. 1003 */ 1004 for (i = 0; ; i++) { 1005 daddr_t fsblockloc; 1006 int32_t fs_bsize; 1007 1008 if (bp != NULL) { 1009 brelse(bp, BC_NOCACHE); 1010 bp = NULL; 1011 } 1012 if (sblock_try[i] == -1) { 1013 DPRINTF(("%s: sblock_try\n", __func__)); 1014 error = EINVAL; 1015 fs = NULL; 1016 goto out; 1017 } 1018 1019 error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE, 1020 cred, 0, &bp); 1021 if (error) { 1022 DPRINTF(("%s: bread@0x%x %d\n", __func__, 1023 sblock_try[i] / DEV_BSIZE, error)); 1024 fs = NULL; 1025 goto out; 1026 } 1027 fs = (struct fs*)bp->b_data; 1028 1029 fsblockloc = sblockloc = sblock_try[i]; 1030 DPRINTF(("%s: fs_magic 0x%x\n", __func__, fs->fs_magic)); 1031 if (fs->fs_magic == FS_UFS1_MAGIC) { 1032 fs_sbsize = fs->fs_sbsize; 1033 fstype = UFS1; 1034 fs_bsize = fs->fs_bsize; 1035 #ifdef FFS_EI 1036 needswap = 0; 1037 } else if (fs->fs_magic == FS_UFS1_MAGIC_SWAPPED) { 1038 fs_sbsize = bswap32(fs->fs_sbsize); 1039 fstype = UFS1; 1040 fs_bsize = bswap32(fs->fs_bsize); 1041 needswap = 1; 1042 #endif 1043 } else if (fs->fs_magic == FS_UFS2_MAGIC) { 1044 fs_sbsize = fs->fs_sbsize; 1045 fstype = UFS2; 1046 fs_bsize = fs->fs_bsize; 1047 #ifdef FFS_EI 1048 needswap = 0; 1049 } else if (fs->fs_magic == FS_UFS2_MAGIC_SWAPPED) { 1050 fs_sbsize = bswap32(fs->fs_sbsize); 1051 fstype = UFS2; 1052 fs_bsize = bswap32(fs->fs_bsize); 1053 needswap = 1; 1054 #endif 1055 } else 1056 continue; 1057 1058 /* fs->fs_sblockloc isn't defined for old filesystems */ 1059 if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) { 1060 if (sblockloc == SBLOCK_UFS2) 1061 /* 1062 * This is likely to be the first alternate 1063 * in a filesystem with 64k blocks. 1064 * Don't use it. 1065 */ 1066 continue; 1067 fsblockloc = sblockloc; 1068 } else { 1069 fsblockloc = fs->fs_sblockloc; 1070 #ifdef FFS_EI 1071 if (needswap) 1072 fsblockloc = bswap64(fsblockloc); 1073 #endif 1074 } 1075 1076 /* Check we haven't found an alternate superblock */ 1077 if (fsblockloc != sblockloc) 1078 continue; 1079 1080 if (!ffs_superblock_validate(fs, fs_sbsize, fs_bsize)) 1081 continue; 1082 1083 /* Ok seems to be a good superblock */ 1084 break; 1085 } 1086 1087 fs = kmem_alloc((u_long)fs_sbsize, KM_SLEEP); 1088 memcpy(fs, bp->b_data, fs_sbsize); 1089 ump->um_fs = fs; 1090 1091 #ifdef FFS_EI 1092 if (needswap) { 1093 ffs_sb_swap((struct fs*)bp->b_data, fs); 1094 fs->fs_flags |= FS_SWAPPED; 1095 } else 1096 #endif 1097 fs->fs_flags &= ~FS_SWAPPED; 1098 1099 #ifdef WAPBL 1100 if ((mp->mnt_wapbl_replay == 0) && (fs->fs_flags & FS_DOWAPBL)) { 1101 error = ffs_wapbl_replay_start(mp, fs, devvp); 1102 if (error && (mp->mnt_flag & MNT_FORCE) == 0) { 1103 DPRINTF(("%s: ffs_wapbl_replay_start %d\n", __func__, 1104 error)); 1105 goto out; 1106 } 1107 if (!error) { 1108 if (!ronly) { 1109 /* XXX fsmnt may be stale. */ 1110 printf("%s: replaying log to disk\n", 1111 fs->fs_fsmnt); 1112 error = wapbl_replay_write(mp->mnt_wapbl_replay, 1113 devvp); 1114 if (error) { 1115 DPRINTF(("%s: wapbl_replay_write %d\n", 1116 __func__, error)); 1117 goto out; 1118 } 1119 wapbl_replay_stop(mp->mnt_wapbl_replay); 1120 fs->fs_clean = FS_WASCLEAN; 1121 } else { 1122 /* XXX fsmnt may be stale */ 1123 printf("%s: replaying log to memory\n", 1124 fs->fs_fsmnt); 1125 } 1126 1127 /* Force a re-read of the superblock */ 1128 brelse(bp, BC_INVAL); 1129 bp = NULL; 1130 kmem_free(fs, fs_sbsize); 1131 fs = NULL; 1132 goto sbagain; 1133 } 1134 } 1135 #else /* !WAPBL */ 1136 if ((fs->fs_flags & FS_DOWAPBL) && (mp->mnt_flag & MNT_FORCE) == 0) { 1137 error = EPERM; 1138 DPRINTF(("%s: no force %d\n", __func__, error)); 1139 goto out; 1140 } 1141 #endif /* !WAPBL */ 1142 1143 ffs_oldfscompat_read(fs, ump, sblockloc); 1144 ump->um_maxfilesize = fs->fs_maxfilesize; 1145 1146 if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) { 1147 uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n", 1148 mp->mnt_stat.f_mntonname, fs->fs_flags, 1149 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting"); 1150 if ((mp->mnt_flag & MNT_FORCE) == 0) { 1151 error = EINVAL; 1152 DPRINTF(("%s: no force %d\n", __func__, error)); 1153 goto out; 1154 } 1155 } 1156 1157 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 1158 fs->fs_pendingblocks = 0; 1159 fs->fs_pendinginodes = 0; 1160 } 1161 1162 ump->um_fstype = fstype; 1163 if (fs->fs_sbsize < SBLOCKSIZE) 1164 brelse(bp, BC_INVAL); 1165 else 1166 brelse(bp, 0); 1167 bp = NULL; 1168 1169 /* First check to see if this is tagged as an Apple UFS filesystem 1170 * in the disklabel 1171 */ 1172 if (getdiskinfo(devvp, &dkw) == 0 && 1173 strcmp(dkw.dkw_ptype, DKW_PTYPE_APPLEUFS) == 0) 1174 ump->um_flags |= UFS_ISAPPLEUFS; 1175 #ifdef APPLE_UFS 1176 else { 1177 /* Manually look for an apple ufs label, and if a valid one 1178 * is found, then treat it like an Apple UFS filesystem anyway 1179 */ 1180 error = bread(devvp, 1181 (daddr_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE), 1182 APPLEUFS_LABEL_SIZE, cred, 0, &bp); 1183 if (error) { 1184 DPRINTF(("%s: apple bread@0x%jx %d\n", __func__, 1185 (intmax_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE), 1186 error)); 1187 goto out; 1188 } 1189 error = ffs_appleufs_validate(fs->fs_fsmnt, 1190 (struct appleufslabel *)bp->b_data, NULL); 1191 if (error == 0) 1192 ump->um_flags |= UFS_ISAPPLEUFS; 1193 brelse(bp, 0); 1194 bp = NULL; 1195 } 1196 #else 1197 if (ump->um_flags & UFS_ISAPPLEUFS) { 1198 DPRINTF(("%s: bad apple\n", __func__)); 1199 error = EINVAL; 1200 goto out; 1201 } 1202 #endif 1203 1204 #if 0 1205 /* 1206 * XXX This code changes the behaviour of mounting dirty filesystems, to 1207 * XXX require "mount -f ..." to mount them. This doesn't match what 1208 * XXX mount(8) describes and is disabled for now. 1209 */ 1210 /* 1211 * If the file system is not clean, don't allow it to be mounted 1212 * unless MNT_FORCE is specified. (Note: MNT_FORCE is always set 1213 * for the root file system.) 1214 */ 1215 if (fs->fs_flags & FS_DOWAPBL) { 1216 /* 1217 * wapbl normally expects to be FS_WASCLEAN when the FS_DOWAPBL 1218 * bit is set, although there's a window in unmount where it 1219 * could be FS_ISCLEAN 1220 */ 1221 if ((mp->mnt_flag & MNT_FORCE) == 0 && 1222 (fs->fs_clean & (FS_WASCLEAN | FS_ISCLEAN)) == 0) { 1223 error = EPERM; 1224 goto out; 1225 } 1226 } else 1227 if ((fs->fs_clean & FS_ISCLEAN) == 0 && 1228 (mp->mnt_flag & MNT_FORCE) == 0) { 1229 error = EPERM; 1230 goto out; 1231 } 1232 #endif 1233 1234 /* 1235 * Verify that we can access the last block in the fs 1236 * if we're mounting read/write. 1237 */ 1238 1239 if (!ronly) { 1240 error = bread(devvp, FFS_FSBTODB(fs, fs->fs_size - 1), 1241 fs->fs_fsize, cred, 0, &bp); 1242 if (error) { 1243 DPRINTF(("%s: bread@0x%jx %d\n", __func__, 1244 (intmax_t)FFS_FSBTODB(fs, fs->fs_size - 1), 1245 error)); 1246 bset = BC_INVAL; 1247 goto out; 1248 } 1249 if (bp->b_bcount != fs->fs_fsize) { 1250 DPRINTF(("%s: bcount %x != fsize %x\n", __func__, 1251 bp->b_bcount, fs->fs_fsize)); 1252 error = EINVAL; 1253 } 1254 brelse(bp, BC_INVAL); 1255 bp = NULL; 1256 } 1257 1258 fs->fs_ronly = ronly; 1259 /* Don't bump fs_clean if we're replaying journal */ 1260 if (!((fs->fs_flags & FS_DOWAPBL) && (fs->fs_clean & FS_WASCLEAN))) { 1261 if (ronly == 0) { 1262 fs->fs_clean <<= 1; 1263 fs->fs_fmod = 1; 1264 } 1265 } 1266 1267 bsize = fs->fs_cssize; 1268 blks = howmany(bsize, fs->fs_fsize); 1269 if (fs->fs_contigsumsize > 0) 1270 bsize += fs->fs_ncg * sizeof(int32_t); 1271 bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs); 1272 allocsbsize = bsize; 1273 space = kmem_alloc((u_long)allocsbsize, KM_SLEEP); 1274 fs->fs_csp = space; 1275 1276 for (i = 0; i < blks; i += fs->fs_frag) { 1277 bsize = fs->fs_bsize; 1278 if (i + fs->fs_frag > blks) 1279 bsize = (blks - i) * fs->fs_fsize; 1280 error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), bsize, 1281 cred, 0, &bp); 1282 if (error) { 1283 DPRINTF(("%s: bread@0x%jx %d\n", __func__, 1284 (intmax_t)FFS_FSBTODB(fs, fs->fs_csaddr + i), 1285 error)); 1286 goto out1; 1287 } 1288 #ifdef FFS_EI 1289 if (needswap) 1290 ffs_csum_swap((struct csum *)bp->b_data, 1291 (struct csum *)space, bsize); 1292 else 1293 #endif 1294 memcpy(space, bp->b_data, (u_int)bsize); 1295 1296 space = (char *)space + bsize; 1297 brelse(bp, 0); 1298 bp = NULL; 1299 } 1300 if (fs->fs_contigsumsize > 0) { 1301 fs->fs_maxcluster = lp = space; 1302 for (i = 0; i < fs->fs_ncg; i++) 1303 *lp++ = fs->fs_contigsumsize; 1304 space = lp; 1305 } 1306 bsize = fs->fs_ncg * sizeof(*fs->fs_contigdirs); 1307 fs->fs_contigdirs = space; 1308 space = (char *)space + bsize; 1309 memset(fs->fs_contigdirs, 0, bsize); 1310 /* Compatibility for old filesystems - XXX */ 1311 if (fs->fs_avgfilesize <= 0) 1312 fs->fs_avgfilesize = AVFILESIZ; 1313 if (fs->fs_avgfpdir <= 0) 1314 fs->fs_avgfpdir = AFPDIR; 1315 fs->fs_active = NULL; 1316 mp->mnt_data = ump; 1317 mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev; 1318 mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_FFS); 1319 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0]; 1320 mp->mnt_stat.f_namemax = FFS_MAXNAMLEN; 1321 if (UFS_MPISAPPLEUFS(ump)) { 1322 /* NeXT used to keep short symlinks in the inode even 1323 * when using FS_42INODEFMT. In that case fs->fs_maxsymlinklen 1324 * is probably -1, but we still need to be able to identify 1325 * short symlinks. 1326 */ 1327 ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN; 1328 ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ; 1329 mp->mnt_iflag |= IMNT_DTYPE; 1330 } else { 1331 ump->um_maxsymlinklen = fs->fs_maxsymlinklen; 1332 ump->um_dirblksiz = UFS_DIRBLKSIZ; 1333 if (ump->um_maxsymlinklen > 0) 1334 mp->mnt_iflag |= IMNT_DTYPE; 1335 else 1336 mp->mnt_iflag &= ~IMNT_DTYPE; 1337 } 1338 mp->mnt_fs_bshift = fs->fs_bshift; 1339 mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */ 1340 mp->mnt_flag |= MNT_LOCAL; 1341 mp->mnt_iflag |= IMNT_MPSAFE; 1342 #ifdef FFS_EI 1343 if (needswap) 1344 ump->um_flags |= UFS_NEEDSWAP; 1345 #endif 1346 ump->um_mountp = mp; 1347 ump->um_dev = dev; 1348 ump->um_devvp = devvp; 1349 ump->um_nindir = fs->fs_nindir; 1350 ump->um_lognindir = ffs(fs->fs_nindir) - 1; 1351 ump->um_bptrtodb = fs->fs_fshift - DEV_BSHIFT; 1352 ump->um_seqinc = fs->fs_frag; 1353 for (i = 0; i < MAXQUOTAS; i++) 1354 ump->um_quotas[i] = NULLVP; 1355 spec_node_setmountedfs(devvp, mp); 1356 if (ronly == 0 && fs->fs_snapinum[0] != 0) 1357 ffs_snapshot_mount(mp); 1358 #ifdef WAPBL 1359 if (!ronly) { 1360 KDASSERT(fs->fs_ronly == 0); 1361 /* 1362 * ffs_wapbl_start() needs mp->mnt_stat initialised if it 1363 * needs to create a new log file in-filesystem. 1364 */ 1365 error = ffs_statvfs(mp, &mp->mnt_stat); 1366 if (error) { 1367 DPRINTF(("%s: ffs_statvfs %d\n", __func__, error)); 1368 goto out1; 1369 } 1370 1371 error = ffs_wapbl_start(mp); 1372 if (error) { 1373 DPRINTF(("%s: ffs_wapbl_start %d\n", __func__, error)); 1374 goto out1; 1375 } 1376 } 1377 #endif /* WAPBL */ 1378 if (ronly == 0) { 1379 #ifdef QUOTA2 1380 error = ffs_quota2_mount(mp); 1381 if (error) { 1382 DPRINTF(("%s: ffs_quota2_mount %d\n", __func__, error)); 1383 goto out1; 1384 } 1385 #else 1386 if (fs->fs_flags & FS_DOQUOTA2) { 1387 ump->um_flags |= UFS_QUOTA2; 1388 uprintf("%s: options QUOTA2 not enabled%s\n", 1389 mp->mnt_stat.f_mntonname, 1390 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting"); 1391 if ((mp->mnt_flag & MNT_FORCE) == 0) { 1392 error = EINVAL; 1393 DPRINTF(("%s: quota disabled %d\n", __func__, 1394 error)); 1395 goto out1; 1396 } 1397 } 1398 #endif 1399 } 1400 1401 if (mp->mnt_flag & MNT_DISCARD) 1402 ump->um_discarddata = ffs_discard_init(devvp, fs); 1403 1404 return (0); 1405 out1: 1406 kmem_free(fs->fs_csp, allocsbsize); 1407 out: 1408 #ifdef WAPBL 1409 if (mp->mnt_wapbl_replay) { 1410 wapbl_replay_stop(mp->mnt_wapbl_replay); 1411 wapbl_replay_free(mp->mnt_wapbl_replay); 1412 mp->mnt_wapbl_replay = 0; 1413 } 1414 #endif 1415 1416 fstrans_unmount(mp); 1417 if (fs) 1418 kmem_free(fs, fs->fs_sbsize); 1419 spec_node_setmountedfs(devvp, NULL); 1420 if (bp) 1421 brelse(bp, bset); 1422 if (ump) { 1423 if (ump->um_oldfscompat) 1424 kmem_free(ump->um_oldfscompat, 512 + 3*sizeof(int32_t)); 1425 mutex_destroy(&ump->um_lock); 1426 kmem_free(ump, sizeof(*ump)); 1427 mp->mnt_data = NULL; 1428 } 1429 return (error); 1430 } 1431 1432 /* 1433 * Sanity checks for loading old filesystem superblocks. 1434 * See ffs_oldfscompat_write below for unwound actions. 1435 * 1436 * XXX - Parts get retired eventually. 1437 * Unfortunately new bits get added. 1438 */ 1439 static void 1440 ffs_oldfscompat_read(struct fs *fs, struct ufsmount *ump, daddr_t sblockloc) 1441 { 1442 off_t maxfilesize; 1443 int32_t *extrasave; 1444 1445 if ((fs->fs_magic != FS_UFS1_MAGIC) || 1446 (fs->fs_old_flags & FS_FLAGS_UPDATED)) 1447 return; 1448 1449 if (!ump->um_oldfscompat) 1450 ump->um_oldfscompat = kmem_alloc(512 + 3*sizeof(int32_t), 1451 KM_SLEEP); 1452 1453 memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512); 1454 extrasave = ump->um_oldfscompat; 1455 extrasave += 512/sizeof(int32_t); 1456 extrasave[0] = fs->fs_old_npsect; 1457 extrasave[1] = fs->fs_old_interleave; 1458 extrasave[2] = fs->fs_old_trackskew; 1459 1460 /* These fields will be overwritten by their 1461 * original values in fs_oldfscompat_write, so it is harmless 1462 * to modify them here. 1463 */ 1464 fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir; 1465 fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree; 1466 fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree; 1467 fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree; 1468 1469 fs->fs_maxbsize = fs->fs_bsize; 1470 fs->fs_time = fs->fs_old_time; 1471 fs->fs_size = fs->fs_old_size; 1472 fs->fs_dsize = fs->fs_old_dsize; 1473 fs->fs_csaddr = fs->fs_old_csaddr; 1474 fs->fs_sblockloc = sblockloc; 1475 1476 fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL); 1477 1478 if (fs->fs_old_postblformat == FS_42POSTBLFMT) { 1479 fs->fs_old_nrpos = 8; 1480 fs->fs_old_npsect = fs->fs_old_nsect; 1481 fs->fs_old_interleave = 1; 1482 fs->fs_old_trackskew = 0; 1483 } 1484 1485 if (fs->fs_old_inodefmt < FS_44INODEFMT) { 1486 fs->fs_maxfilesize = (u_quad_t) 1LL << 39; 1487 fs->fs_qbmask = ~fs->fs_bmask; 1488 fs->fs_qfmask = ~fs->fs_fmask; 1489 } 1490 1491 maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1; 1492 if (fs->fs_maxfilesize > maxfilesize) 1493 fs->fs_maxfilesize = maxfilesize; 1494 1495 /* Compatibility for old filesystems */ 1496 if (fs->fs_avgfilesize <= 0) 1497 fs->fs_avgfilesize = AVFILESIZ; 1498 if (fs->fs_avgfpdir <= 0) 1499 fs->fs_avgfpdir = AFPDIR; 1500 1501 #if 0 1502 if (bigcgs) { 1503 fs->fs_save_cgsize = fs->fs_cgsize; 1504 fs->fs_cgsize = fs->fs_bsize; 1505 } 1506 #endif 1507 } 1508 1509 /* 1510 * Unwinding superblock updates for old filesystems. 1511 * See ffs_oldfscompat_read above for details. 1512 * 1513 * XXX - Parts get retired eventually. 1514 * Unfortunately new bits get added. 1515 */ 1516 static void 1517 ffs_oldfscompat_write(struct fs *fs, struct ufsmount *ump) 1518 { 1519 int32_t *extrasave; 1520 1521 if ((fs->fs_magic != FS_UFS1_MAGIC) || 1522 (fs->fs_old_flags & FS_FLAGS_UPDATED)) 1523 return; 1524 1525 fs->fs_old_time = fs->fs_time; 1526 fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir; 1527 fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree; 1528 fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree; 1529 fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree; 1530 fs->fs_old_flags = fs->fs_flags; 1531 1532 #if 0 1533 if (bigcgs) { 1534 fs->fs_cgsize = fs->fs_save_cgsize; 1535 } 1536 #endif 1537 1538 memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512); 1539 extrasave = ump->um_oldfscompat; 1540 extrasave += 512/sizeof(int32_t); 1541 fs->fs_old_npsect = extrasave[0]; 1542 fs->fs_old_interleave = extrasave[1]; 1543 fs->fs_old_trackskew = extrasave[2]; 1544 1545 } 1546 1547 /* 1548 * unmount vfs operation 1549 */ 1550 int 1551 ffs_unmount(struct mount *mp, int mntflags) 1552 { 1553 struct lwp *l = curlwp; 1554 struct ufsmount *ump = VFSTOUFS(mp); 1555 struct fs *fs = ump->um_fs; 1556 int error, flags; 1557 u_int32_t bsize; 1558 #ifdef WAPBL 1559 extern int doforce; 1560 #endif 1561 1562 if (ump->um_discarddata) { 1563 ffs_discard_finish(ump->um_discarddata, mntflags); 1564 ump->um_discarddata = NULL; 1565 } 1566 1567 flags = 0; 1568 if (mntflags & MNT_FORCE) 1569 flags |= FORCECLOSE; 1570 if ((error = ffs_flushfiles(mp, flags, l)) != 0) 1571 return (error); 1572 error = UFS_WAPBL_BEGIN(mp); 1573 if (error == 0) 1574 if (fs->fs_ronly == 0 && 1575 ffs_cgupdate(ump, MNT_WAIT) == 0 && 1576 fs->fs_clean & FS_WASCLEAN) { 1577 fs->fs_clean = FS_ISCLEAN; 1578 fs->fs_fmod = 0; 1579 (void) ffs_sbupdate(ump, MNT_WAIT); 1580 } 1581 if (error == 0) 1582 UFS_WAPBL_END(mp); 1583 #ifdef WAPBL 1584 KASSERT(!(mp->mnt_wapbl_replay && mp->mnt_wapbl)); 1585 if (mp->mnt_wapbl_replay) { 1586 KDASSERT(fs->fs_ronly); 1587 wapbl_replay_stop(mp->mnt_wapbl_replay); 1588 wapbl_replay_free(mp->mnt_wapbl_replay); 1589 mp->mnt_wapbl_replay = 0; 1590 } 1591 error = ffs_wapbl_stop(mp, doforce && (mntflags & MNT_FORCE)); 1592 if (error) { 1593 return error; 1594 } 1595 #endif /* WAPBL */ 1596 1597 if (ump->um_devvp->v_type != VBAD) 1598 spec_node_setmountedfs(ump->um_devvp, NULL); 1599 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 1600 (void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD | FWRITE, 1601 NOCRED); 1602 vput(ump->um_devvp); 1603 1604 bsize = fs->fs_cssize; 1605 if (fs->fs_contigsumsize > 0) 1606 bsize += fs->fs_ncg * sizeof(int32_t); 1607 bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs); 1608 kmem_free(fs->fs_csp, bsize); 1609 1610 kmem_free(fs, fs->fs_sbsize); 1611 if (ump->um_oldfscompat != NULL) 1612 kmem_free(ump->um_oldfscompat, 512 + 3*sizeof(int32_t)); 1613 mutex_destroy(&ump->um_lock); 1614 ffs_snapshot_fini(ump); 1615 kmem_free(ump, sizeof(*ump)); 1616 mp->mnt_data = NULL; 1617 mp->mnt_flag &= ~MNT_LOCAL; 1618 fstrans_unmount(mp); 1619 return (0); 1620 } 1621 1622 /* 1623 * Flush out all the files in a filesystem. 1624 */ 1625 int 1626 ffs_flushfiles(struct mount *mp, int flags, struct lwp *l) 1627 { 1628 extern int doforce; 1629 struct ufsmount *ump; 1630 int error; 1631 1632 if (!doforce) 1633 flags &= ~FORCECLOSE; 1634 ump = VFSTOUFS(mp); 1635 #ifdef QUOTA 1636 if ((error = quota1_umount(mp, flags)) != 0) 1637 return (error); 1638 #endif 1639 #ifdef QUOTA2 1640 if ((error = quota2_umount(mp, flags)) != 0) 1641 return (error); 1642 #endif 1643 #ifdef UFS_EXTATTR 1644 if (ump->um_fstype == UFS1) { 1645 if (ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_STARTED) 1646 ufs_extattr_stop(mp, l); 1647 if (ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_INITIALIZED) 1648 ufs_extattr_uepm_destroy(&ump->um_extattr); 1649 mp->mnt_flag &= ~MNT_EXTATTR; 1650 } 1651 #endif 1652 if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0) 1653 return (error); 1654 ffs_snapshot_unmount(mp); 1655 /* 1656 * Flush all the files. 1657 */ 1658 error = vflush(mp, NULLVP, flags); 1659 if (error) 1660 return (error); 1661 /* 1662 * Flush filesystem metadata. 1663 */ 1664 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 1665 error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0); 1666 VOP_UNLOCK(ump->um_devvp); 1667 if (flags & FORCECLOSE) /* XXXDBJ */ 1668 error = 0; 1669 1670 #ifdef WAPBL 1671 if (error) 1672 return error; 1673 if (mp->mnt_wapbl) { 1674 error = wapbl_flush(mp->mnt_wapbl, 1); 1675 if (flags & FORCECLOSE) 1676 error = 0; 1677 } 1678 #endif 1679 1680 return (error); 1681 } 1682 1683 /* 1684 * Get file system statistics. 1685 */ 1686 int 1687 ffs_statvfs(struct mount *mp, struct statvfs *sbp) 1688 { 1689 struct ufsmount *ump; 1690 struct fs *fs; 1691 1692 ump = VFSTOUFS(mp); 1693 fs = ump->um_fs; 1694 mutex_enter(&ump->um_lock); 1695 sbp->f_bsize = fs->fs_bsize; 1696 sbp->f_frsize = fs->fs_fsize; 1697 sbp->f_iosize = fs->fs_bsize; 1698 sbp->f_blocks = fs->fs_dsize; 1699 sbp->f_bfree = ffs_blkstofrags(fs, fs->fs_cstotal.cs_nbfree) + 1700 fs->fs_cstotal.cs_nffree + FFS_DBTOFSB(fs, fs->fs_pendingblocks); 1701 sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t) 1702 fs->fs_minfree) / (u_int64_t) 100; 1703 if (sbp->f_bfree > sbp->f_bresvd) 1704 sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd; 1705 else 1706 sbp->f_bavail = 0; 1707 sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO; 1708 sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes; 1709 sbp->f_favail = sbp->f_ffree; 1710 sbp->f_fresvd = 0; 1711 mutex_exit(&ump->um_lock); 1712 copy_statvfs_info(sbp, mp); 1713 1714 return (0); 1715 } 1716 1717 struct ffs_sync_ctx { 1718 int waitfor; 1719 bool is_suspending; 1720 }; 1721 1722 static bool 1723 ffs_sync_selector(void *cl, struct vnode *vp) 1724 { 1725 struct ffs_sync_ctx *c = cl; 1726 struct inode *ip; 1727 1728 ip = VTOI(vp); 1729 /* 1730 * Skip the vnode/inode if inaccessible. 1731 */ 1732 if (ip == NULL || vp->v_type == VNON) 1733 return false; 1734 1735 /* 1736 * We deliberately update inode times here. This will 1737 * prevent a massive queue of updates accumulating, only 1738 * to be handled by a call to unmount. 1739 * 1740 * XXX It would be better to have the syncer trickle these 1741 * out. Adjustment needed to allow registering vnodes for 1742 * sync when the vnode is clean, but the inode dirty. Or 1743 * have ufs itself trickle out inode updates. 1744 * 1745 * If doing a lazy sync, we don't care about metadata or 1746 * data updates, because they are handled by each vnode's 1747 * synclist entry. In this case we are only interested in 1748 * writing back modified inodes. 1749 */ 1750 if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE | 1751 IN_MODIFY | IN_MODIFIED | IN_ACCESSED)) == 0 && 1752 (c->waitfor == MNT_LAZY || (LIST_EMPTY(&vp->v_dirtyblkhd) && 1753 UVM_OBJ_IS_CLEAN(&vp->v_uobj)))) 1754 return false; 1755 1756 if (vp->v_type == VBLK && c->is_suspending) 1757 return false; 1758 1759 return true; 1760 } 1761 1762 /* 1763 * Go through the disk queues to initiate sandbagged IO; 1764 * go through the inodes to write those that have been modified; 1765 * initiate the writing of the super block if it has been modified. 1766 * 1767 * Note: we are always called with the filesystem marked `MPBUSY'. 1768 */ 1769 int 1770 ffs_sync(struct mount *mp, int waitfor, kauth_cred_t cred) 1771 { 1772 struct vnode *vp; 1773 struct ufsmount *ump = VFSTOUFS(mp); 1774 struct fs *fs; 1775 struct vnode_iterator *marker; 1776 int error, allerror = 0; 1777 bool is_suspending; 1778 struct ffs_sync_ctx ctx; 1779 1780 fs = ump->um_fs; 1781 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */ 1782 printf("fs = %s\n", fs->fs_fsmnt); 1783 panic("update: rofs mod"); 1784 } 1785 1786 fstrans_start(mp, FSTRANS_SHARED); 1787 is_suspending = (fstrans_getstate(mp) == FSTRANS_SUSPENDING); 1788 /* 1789 * Write back each (modified) inode. 1790 */ 1791 vfs_vnode_iterator_init(mp, &marker); 1792 1793 ctx.waitfor = waitfor; 1794 ctx.is_suspending = is_suspending; 1795 while ((vp = vfs_vnode_iterator_next(marker, ffs_sync_selector, &ctx))) 1796 { 1797 error = vn_lock(vp, LK_EXCLUSIVE); 1798 if (error) { 1799 vrele(vp); 1800 continue; 1801 } 1802 if (waitfor == MNT_LAZY) { 1803 error = UFS_WAPBL_BEGIN(vp->v_mount); 1804 if (!error) { 1805 error = ffs_update(vp, NULL, NULL, 1806 UPDATE_CLOSE); 1807 UFS_WAPBL_END(vp->v_mount); 1808 } 1809 } else { 1810 error = VOP_FSYNC(vp, cred, FSYNC_NOLOG | 1811 (waitfor == MNT_WAIT ? FSYNC_WAIT : 0), 0, 0); 1812 } 1813 if (error) 1814 allerror = error; 1815 vput(vp); 1816 } 1817 vfs_vnode_iterator_destroy(marker); 1818 1819 /* 1820 * Force stale file system control information to be flushed. 1821 */ 1822 if (waitfor != MNT_LAZY && (ump->um_devvp->v_numoutput > 0 || 1823 !LIST_EMPTY(&ump->um_devvp->v_dirtyblkhd))) { 1824 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 1825 if ((error = VOP_FSYNC(ump->um_devvp, cred, 1826 (waitfor == MNT_WAIT ? FSYNC_WAIT : 0) | FSYNC_NOLOG, 1827 0, 0)) != 0) 1828 allerror = error; 1829 VOP_UNLOCK(ump->um_devvp); 1830 } 1831 #if defined(QUOTA) || defined(QUOTA2) 1832 qsync(mp); 1833 #endif 1834 /* 1835 * Write back modified superblock. 1836 */ 1837 if (fs->fs_fmod != 0) { 1838 fs->fs_fmod = 0; 1839 fs->fs_time = time_second; 1840 error = UFS_WAPBL_BEGIN(mp); 1841 if (error) 1842 allerror = error; 1843 else { 1844 if ((error = ffs_cgupdate(ump, waitfor))) 1845 allerror = error; 1846 UFS_WAPBL_END(mp); 1847 } 1848 } 1849 1850 #ifdef WAPBL 1851 if (mp->mnt_wapbl) { 1852 error = wapbl_flush(mp->mnt_wapbl, 0); 1853 if (error) 1854 allerror = error; 1855 } 1856 #endif 1857 1858 fstrans_done(mp); 1859 return (allerror); 1860 } 1861 1862 /* 1863 * Read an inode from disk and initialize this vnode / inode pair. 1864 * Caller assures no other thread will try to load this inode. 1865 */ 1866 int 1867 ffs_loadvnode(struct mount *mp, struct vnode *vp, 1868 const void *key, size_t key_len, const void **new_key) 1869 { 1870 ino_t ino; 1871 struct fs *fs; 1872 struct inode *ip; 1873 struct ufsmount *ump; 1874 struct buf *bp; 1875 dev_t dev; 1876 int error; 1877 1878 KASSERT(key_len == sizeof(ino)); 1879 memcpy(&ino, key, key_len); 1880 ump = VFSTOUFS(mp); 1881 dev = ump->um_dev; 1882 fs = ump->um_fs; 1883 1884 /* Read in the disk contents for the inode. */ 1885 error = bread(ump->um_devvp, FFS_FSBTODB(fs, ino_to_fsba(fs, ino)), 1886 (int)fs->fs_bsize, NOCRED, 0, &bp); 1887 if (error) 1888 return error; 1889 1890 /* Allocate and initialize inode. */ 1891 ip = pool_cache_get(ffs_inode_cache, PR_WAITOK); 1892 memset(ip, 0, sizeof(struct inode)); 1893 vp->v_tag = VT_UFS; 1894 vp->v_op = ffs_vnodeop_p; 1895 vp->v_vflag |= VV_LOCKSWORK; 1896 vp->v_data = ip; 1897 ip->i_vnode = vp; 1898 ip->i_ump = ump; 1899 ip->i_fs = fs; 1900 ip->i_dev = dev; 1901 ip->i_number = ino; 1902 #if defined(QUOTA) || defined(QUOTA2) 1903 ufsquota_init(ip); 1904 #endif 1905 1906 /* Initialize genfs node. */ 1907 genfs_node_init(vp, &ffs_genfsops); 1908 1909 if (ip->i_ump->um_fstype == UFS1) 1910 ip->i_din.ffs1_din = pool_cache_get(ffs_dinode1_cache, 1911 PR_WAITOK); 1912 else 1913 ip->i_din.ffs2_din = pool_cache_get(ffs_dinode2_cache, 1914 PR_WAITOK); 1915 ffs_load_inode(bp, ip, fs, ino); 1916 brelse(bp, 0); 1917 1918 /* Initialize the vnode from the inode. */ 1919 ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp); 1920 1921 /* Finish inode initialization. */ 1922 ip->i_devvp = ump->um_devvp; 1923 vref(ip->i_devvp); 1924 1925 /* 1926 * Ensure that uid and gid are correct. This is a temporary 1927 * fix until fsck has been changed to do the update. 1928 */ 1929 1930 if (fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */ 1931 ip->i_uid = ip->i_ffs1_ouid; /* XXX */ 1932 ip->i_gid = ip->i_ffs1_ogid; /* XXX */ 1933 } /* XXX */ 1934 uvm_vnp_setsize(vp, ip->i_size); 1935 *new_key = &ip->i_number; 1936 return 0; 1937 } 1938 1939 /* 1940 * File handle to vnode 1941 * 1942 * Have to be really careful about stale file handles: 1943 * - check that the inode number is valid 1944 * - call ffs_vget() to get the locked inode 1945 * - check for an unallocated inode (i_mode == 0) 1946 * - check that the given client host has export rights and return 1947 * those rights via. exflagsp and credanonp 1948 */ 1949 int 1950 ffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp) 1951 { 1952 struct ufid ufh; 1953 struct fs *fs; 1954 1955 if (fhp->fid_len != sizeof(struct ufid)) 1956 return EINVAL; 1957 1958 memcpy(&ufh, fhp, sizeof(ufh)); 1959 fs = VFSTOUFS(mp)->um_fs; 1960 if (ufh.ufid_ino < UFS_ROOTINO || 1961 ufh.ufid_ino >= fs->fs_ncg * fs->fs_ipg) 1962 return (ESTALE); 1963 return (ufs_fhtovp(mp, &ufh, vpp)); 1964 } 1965 1966 /* 1967 * Vnode pointer to File handle 1968 */ 1969 /* ARGSUSED */ 1970 int 1971 ffs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size) 1972 { 1973 struct inode *ip; 1974 struct ufid ufh; 1975 1976 if (*fh_size < sizeof(struct ufid)) { 1977 *fh_size = sizeof(struct ufid); 1978 return E2BIG; 1979 } 1980 ip = VTOI(vp); 1981 *fh_size = sizeof(struct ufid); 1982 memset(&ufh, 0, sizeof(ufh)); 1983 ufh.ufid_len = sizeof(struct ufid); 1984 ufh.ufid_ino = ip->i_number; 1985 ufh.ufid_gen = ip->i_gen; 1986 memcpy(fhp, &ufh, sizeof(ufh)); 1987 return (0); 1988 } 1989 1990 void 1991 ffs_init(void) 1992 { 1993 if (ffs_initcount++ > 0) 1994 return; 1995 1996 ffs_inode_cache = pool_cache_init(sizeof(struct inode), 0, 0, 0, 1997 "ffsino", NULL, IPL_NONE, NULL, NULL, NULL); 1998 ffs_dinode1_cache = pool_cache_init(sizeof(struct ufs1_dinode), 0, 0, 0, 1999 "ffsdino1", NULL, IPL_NONE, NULL, NULL, NULL); 2000 ffs_dinode2_cache = pool_cache_init(sizeof(struct ufs2_dinode), 0, 0, 0, 2001 "ffsdino2", NULL, IPL_NONE, NULL, NULL, NULL); 2002 ufs_init(); 2003 } 2004 2005 void 2006 ffs_reinit(void) 2007 { 2008 2009 ufs_reinit(); 2010 } 2011 2012 void 2013 ffs_done(void) 2014 { 2015 if (--ffs_initcount > 0) 2016 return; 2017 2018 ufs_done(); 2019 pool_cache_destroy(ffs_dinode2_cache); 2020 pool_cache_destroy(ffs_dinode1_cache); 2021 pool_cache_destroy(ffs_inode_cache); 2022 } 2023 2024 /* 2025 * Write a superblock and associated information back to disk. 2026 */ 2027 int 2028 ffs_sbupdate(struct ufsmount *mp, int waitfor) 2029 { 2030 struct fs *fs = mp->um_fs; 2031 struct buf *bp; 2032 int error = 0; 2033 u_int32_t saveflag; 2034 2035 error = ffs_getblk(mp->um_devvp, 2036 fs->fs_sblockloc / DEV_BSIZE, FFS_NOBLK, 2037 fs->fs_sbsize, false, &bp); 2038 if (error) 2039 return error; 2040 saveflag = fs->fs_flags & FS_INTERNAL; 2041 fs->fs_flags &= ~FS_INTERNAL; 2042 2043 memcpy(bp->b_data, fs, fs->fs_sbsize); 2044 2045 ffs_oldfscompat_write((struct fs *)bp->b_data, mp); 2046 #ifdef FFS_EI 2047 if (mp->um_flags & UFS_NEEDSWAP) 2048 ffs_sb_swap((struct fs *)bp->b_data, (struct fs *)bp->b_data); 2049 #endif 2050 fs->fs_flags |= saveflag; 2051 2052 if (waitfor == MNT_WAIT) 2053 error = bwrite(bp); 2054 else 2055 bawrite(bp); 2056 return (error); 2057 } 2058 2059 int 2060 ffs_cgupdate(struct ufsmount *mp, int waitfor) 2061 { 2062 struct fs *fs = mp->um_fs; 2063 struct buf *bp; 2064 int blks; 2065 void *space; 2066 int i, size, error = 0, allerror = 0; 2067 2068 allerror = ffs_sbupdate(mp, waitfor); 2069 blks = howmany(fs->fs_cssize, fs->fs_fsize); 2070 space = fs->fs_csp; 2071 for (i = 0; i < blks; i += fs->fs_frag) { 2072 size = fs->fs_bsize; 2073 if (i + fs->fs_frag > blks) 2074 size = (blks - i) * fs->fs_fsize; 2075 error = ffs_getblk(mp->um_devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), 2076 FFS_NOBLK, size, false, &bp); 2077 if (error) 2078 break; 2079 #ifdef FFS_EI 2080 if (mp->um_flags & UFS_NEEDSWAP) 2081 ffs_csum_swap((struct csum*)space, 2082 (struct csum*)bp->b_data, size); 2083 else 2084 #endif 2085 memcpy(bp->b_data, space, (u_int)size); 2086 space = (char *)space + size; 2087 if (waitfor == MNT_WAIT) 2088 error = bwrite(bp); 2089 else 2090 bawrite(bp); 2091 } 2092 if (!allerror && error) 2093 allerror = error; 2094 return (allerror); 2095 } 2096 2097 int 2098 ffs_extattrctl(struct mount *mp, int cmd, struct vnode *vp, 2099 int attrnamespace, const char *attrname) 2100 { 2101 #ifdef UFS_EXTATTR 2102 /* 2103 * File-backed extended attributes are only supported on UFS1. 2104 * UFS2 has native extended attributes. 2105 */ 2106 if (VFSTOUFS(mp)->um_fstype == UFS1) 2107 return (ufs_extattrctl(mp, cmd, vp, attrnamespace, attrname)); 2108 #endif 2109 return (vfs_stdextattrctl(mp, cmd, vp, attrnamespace, attrname)); 2110 } 2111 2112 int 2113 ffs_suspendctl(struct mount *mp, int cmd) 2114 { 2115 int error; 2116 struct lwp *l = curlwp; 2117 2118 switch (cmd) { 2119 case SUSPEND_SUSPEND: 2120 if ((error = fstrans_setstate(mp, FSTRANS_SUSPENDING)) != 0) 2121 return error; 2122 error = ffs_sync(mp, MNT_WAIT, l->l_proc->p_cred); 2123 if (error == 0) 2124 error = fstrans_setstate(mp, FSTRANS_SUSPENDED); 2125 #ifdef WAPBL 2126 if (error == 0 && mp->mnt_wapbl) 2127 error = wapbl_flush(mp->mnt_wapbl, 1); 2128 #endif 2129 if (error != 0) { 2130 (void) fstrans_setstate(mp, FSTRANS_NORMAL); 2131 return error; 2132 } 2133 return 0; 2134 2135 case SUSPEND_RESUME: 2136 return fstrans_setstate(mp, FSTRANS_NORMAL); 2137 2138 default: 2139 return EINVAL; 2140 } 2141 } 2142 2143 /* 2144 * Synch vnode for a mounted file system. 2145 */ 2146 static int 2147 ffs_vfs_fsync(vnode_t *vp, int flags) 2148 { 2149 int error, i, pflags; 2150 #ifdef WAPBL 2151 struct mount *mp; 2152 #endif 2153 2154 KASSERT(vp->v_type == VBLK); 2155 KASSERT(spec_node_getmountedfs(vp) != NULL); 2156 2157 /* 2158 * Flush all dirty data associated with the vnode. 2159 */ 2160 pflags = PGO_ALLPAGES | PGO_CLEANIT; 2161 if ((flags & FSYNC_WAIT) != 0) 2162 pflags |= PGO_SYNCIO; 2163 mutex_enter(vp->v_interlock); 2164 error = VOP_PUTPAGES(vp, 0, 0, pflags); 2165 if (error) 2166 return error; 2167 2168 #ifdef WAPBL 2169 mp = spec_node_getmountedfs(vp); 2170 if (mp && mp->mnt_wapbl) { 2171 /* 2172 * Don't bother writing out metadata if the syncer is 2173 * making the request. We will let the sync vnode 2174 * write it out in a single burst through a call to 2175 * VFS_SYNC(). 2176 */ 2177 if ((flags & (FSYNC_DATAONLY | FSYNC_LAZY | FSYNC_NOLOG)) != 0) 2178 return 0; 2179 2180 /* 2181 * Don't flush the log if the vnode being flushed 2182 * contains no dirty buffers that could be in the log. 2183 */ 2184 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) { 2185 error = wapbl_flush(mp->mnt_wapbl, 0); 2186 if (error) 2187 return error; 2188 } 2189 2190 if ((flags & FSYNC_WAIT) != 0) { 2191 mutex_enter(vp->v_interlock); 2192 while (vp->v_numoutput) 2193 cv_wait(&vp->v_cv, vp->v_interlock); 2194 mutex_exit(vp->v_interlock); 2195 } 2196 2197 return 0; 2198 } 2199 #endif /* WAPBL */ 2200 2201 error = vflushbuf(vp, flags); 2202 if (error == 0 && (flags & FSYNC_CACHE) != 0) { 2203 i = 1; 2204 (void)VOP_IOCTL(vp, DIOCCACHESYNC, &i, FWRITE, 2205 kauth_cred_get()); 2206 } 2207 2208 return error; 2209 } 2210
Indexes created Thu Oct 02 07:10:07 GMT 2025