1 /* $NetBSD: ffs_wapbl.c,v 1.50 2024/12/30 09:03:07 hannken Exp $ */ 2 3 /*- 4 * Copyright (c) 2003,2006,2008 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. 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 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: ffs_wapbl.c,v 1.50 2024/12/30 09:03:07 hannken Exp $"); 34 35 #define WAPBL_INTERNAL 36 37 #if defined(_KERNEL_OPT) 38 #include "opt_ffs.h" 39 #endif 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/kernel.h> 44 #include <sys/vnode.h> 45 #include <sys/mount.h> 46 #include <sys/file.h> 47 #include <sys/disk.h> 48 #include <sys/ioctl.h> 49 #include <sys/errno.h> 50 #include <sys/kauth.h> 51 #include <sys/wapbl.h> 52 53 #include <ufs/ufs/inode.h> 54 #include <ufs/ufs/quota.h> 55 #include <ufs/ufs/ufsmount.h> 56 #include <ufs/ufs/ufs_bswap.h> 57 #include <ufs/ufs/ufs_extern.h> 58 #include <ufs/ufs/ufs_wapbl.h> 59 60 #include <ufs/ffs/fs.h> 61 #include <ufs/ffs/ffs_extern.h> 62 63 #undef WAPBL_DEBUG 64 #ifdef WAPBL_DEBUG 65 int ffs_wapbl_debug = 1; 66 #define DPRINTF(fmt, args...) \ 67 do { \ 68 if (ffs_wapbl_debug) \ 69 printf("%s:%d "fmt, __func__ , __LINE__, ##args); \ 70 } while (/* CONSTCOND */0) 71 #else 72 #define DPRINTF(fmt, args...) \ 73 do { \ 74 /* nothing */ \ 75 } while (/* CONSTCOND */0) 76 #endif 77 78 static int ffs_superblock_layout(struct fs *); 79 static int wapbl_log_position(struct mount *, struct fs *, struct vnode *, 80 daddr_t *, size_t *, size_t *, uint64_t *); 81 static int wapbl_create_infs_log(struct mount *, struct fs *, struct vnode *, 82 daddr_t *, size_t *, uint64_t *); 83 static void wapbl_find_log_start(struct mount *, struct vnode *, off_t, 84 daddr_t *, daddr_t *, size_t *); 85 static int wapbl_remove_log(struct mount *); 86 static int wapbl_allocate_log_file(struct mount *, struct vnode *, 87 daddr_t *, size_t *, uint64_t *); 88 89 /* 90 * Return the super block layout format - UFS1 or UFS2. 91 * WAPBL only works with UFS2 layout (which is still available 92 * with FFSv1). 93 * 94 * XXX Should this be in ufs/ffs/fs.h? Same style of check is 95 * also used in ffs_alloc.c in a few places. 96 */ 97 static int 98 ffs_superblock_layout(struct fs *fs) 99 { 100 if ((fs->fs_magic == FS_UFS1_MAGIC) && 101 ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0)) 102 return 1; 103 else 104 return 2; 105 } 106 107 /* 108 * This function is invoked after a log is replayed to 109 * disk to perform logical cleanup actions as described by 110 * the log 111 */ 112 void 113 ffs_wapbl_replay_finish(struct mount *mp) 114 { 115 struct wapbl_replay *wr = mp->mnt_wapbl_replay; 116 int i; 117 int error; 118 119 if (!wr) 120 return; 121 122 KDASSERT((mp->mnt_flag & MNT_RDONLY) == 0); 123 124 for (i = 0; i < wr->wr_inodescnt; i++) { 125 struct vnode *vp; 126 struct inode *ip; 127 error = VFS_VGET(mp, wr->wr_inodes[i].wr_inumber, 128 LK_EXCLUSIVE, &vp); 129 if (error) { 130 printf("%s: %s: unable to cleanup inode %" PRIu32 "\n", 131 __func__, VFSTOUFS(mp)->um_fs->fs_fsmnt, 132 wr->wr_inodes[i].wr_inumber); 133 continue; 134 } 135 ip = VTOI(vp); 136 KDASSERT(wr->wr_inodes[i].wr_inumber == ip->i_number); 137 #ifdef WAPBL_DEBUG 138 printf("%s%s: %s: cleaning inode %" PRIu64 " size=%" PRIu64 139 " mode=%o nlink=%d\n", 140 __func__, VFSTOUFS(mp)->um_fs->fs_fsmnt, 141 ip->i_number, ip->i_size, ip->i_mode, ip->i_nlink); 142 #endif 143 KASSERT(ip->i_nlink == 0); 144 145 /* 146 * The journal may have left partially allocated inodes in mode 147 * zero. This may occur if a crash occurs between the node 148 * allocation in ffs_nodeallocg and when the node is properly 149 * initialized in ufs_makeinode. If so, just deallocate them. 150 */ 151 if (ip->i_mode == 0) { 152 error = UFS_WAPBL_BEGIN(mp); 153 if (error) { 154 printf("%s: %s: " 155 "unable to cleanup inode %" PRIu32 "\n", 156 __func__, VFSTOUFS(mp)->um_fs->fs_fsmnt, 157 wr->wr_inodes[i].wr_inumber); 158 } else { 159 ffs_vfree(vp, ip->i_number, 160 wr->wr_inodes[i].wr_imode); 161 UFS_WAPBL_END(mp); 162 } 163 } 164 vput(vp); 165 } 166 wapbl_replay_stop(wr); 167 wapbl_replay_free(wr); 168 mp->mnt_wapbl_replay = NULL; 169 } 170 171 /* Callback for wapbl */ 172 void 173 ffs_wapbl_sync_metadata(struct mount *mp, struct wapbl_dealloc *fdealloc) 174 { 175 struct ufsmount *ump = VFSTOUFS(mp); 176 struct fs *fs = ump->um_fs; 177 int error __diagused; 178 struct wapbl_dealloc *wd; 179 180 UFS_WAPBL_JLOCK_ASSERT(ump->um_mountp); 181 182 for (wd = fdealloc; wd != NULL; wd = TAILQ_NEXT(wd, wd_entries)) { 183 /* 184 * blkfree errors are unreported, might silently fail 185 * if it cannot read the cylinder group block 186 */ 187 ffs_blkfree(fs, ump->um_devvp, 188 FFS_DBTOFSB(fs, wd->wd_blkno), wd->wd_len, -1); 189 } 190 191 mutex_enter(&ump->um_lock); 192 if (fs->fs_fmod != 0) { 193 fs->fs_fmod = 0; 194 fs->fs_time = time_second; 195 mutex_exit(&ump->um_lock); 196 error = ffs_cgupdate(ump, 0); 197 KASSERT(error == 0); 198 } else { 199 mutex_exit(&ump->um_lock); 200 } 201 } 202 203 void 204 ffs_wapbl_abort_sync_metadata(struct mount *mp, struct wapbl_dealloc *fdealloc) 205 { 206 struct ufsmount *ump = VFSTOUFS(mp); 207 struct fs *fs = ump->um_fs; 208 struct wapbl_dealloc *wd; 209 210 for (wd = fdealloc; wd != NULL; wd = TAILQ_NEXT(wd, wd_entries)) { 211 /* 212 * Since the above blkfree may have failed, this blkalloc might 213 * fail as well, so don't check its error. Note that if the 214 * blkfree succeeded above, then this shouldn't fail because 215 * the buffer will be locked in the current transaction. 216 */ 217 ffs_blkalloc_ump(ump, FFS_DBTOFSB(fs, wd->wd_blkno), 218 wd->wd_len); 219 } 220 } 221 222 static int 223 wapbl_remove_log(struct mount *mp) 224 { 225 struct ufsmount *ump = VFSTOUFS(mp); 226 struct fs *fs = ump->um_fs; 227 struct vnode *vp; 228 struct inode *ip; 229 ino_t log_ino; 230 int error; 231 232 /* If super block layout is too old to support WAPBL, return */ 233 if (ffs_superblock_layout(fs) < 2) 234 return 0; 235 236 /* If all the log locators are 0, just clean up */ 237 if (fs->fs_journallocs[0] == 0 && 238 fs->fs_journallocs[1] == 0 && 239 fs->fs_journallocs[2] == 0 && 240 fs->fs_journallocs[3] == 0) { 241 DPRINTF("empty locators, just clear\n"); 242 goto done; 243 } 244 245 switch (fs->fs_journal_location) { 246 case UFS_WAPBL_JOURNALLOC_NONE: 247 /* nothing! */ 248 DPRINTF("no log\n"); 249 break; 250 251 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM: 252 log_ino = fs->fs_journallocs[UFS_WAPBL_INFS_INO]; 253 DPRINTF("in-fs log, ino = %" PRId64 "\n",log_ino); 254 255 /* if no existing log inode, just clear all fields and bail */ 256 if (log_ino == 0) 257 goto done; 258 error = VFS_VGET(mp, log_ino, LK_EXCLUSIVE, &vp); 259 if (error != 0) { 260 printf("%s: %s: vget failed %d\n", __func__, 261 fs->fs_fsmnt, error); 262 /* clear out log info on error */ 263 goto done; 264 } 265 ip = VTOI(vp); 266 KASSERT(log_ino == ip->i_number); 267 if ((ip->i_flags & SF_LOG) == 0) { 268 printf("%s: %s: try to clear non-log inode " 269 "%" PRId64 "\n", __func__, fs->fs_fsmnt, log_ino); 270 vput(vp); 271 /* clear out log info on error */ 272 goto done; 273 } 274 275 /* 276 * remove the log inode by setting its link count back 277 * to zero and bail. 278 */ 279 ip->i_nlink = 0; 280 DIP_ASSIGN(ip, nlink, 0); 281 vput(vp); 282 break; 283 284 case UFS_WAPBL_JOURNALLOC_END_PARTITION: 285 DPRINTF("end-of-partition log\n"); 286 /* no extra work required */ 287 break; 288 289 default: 290 printf("%s: %s: unknown journal type %d\n", __func__, 291 fs->fs_fsmnt, fs->fs_journal_location); 292 break; 293 } 294 295 296 done: 297 /* Clear out all previous knowledge of journal */ 298 fs->fs_journal_version = 0; 299 fs->fs_journal_location = 0; 300 fs->fs_journal_flags = 0; 301 fs->fs_journallocs[0] = 0; 302 fs->fs_journallocs[1] = 0; 303 fs->fs_journallocs[2] = 0; 304 fs->fs_journallocs[3] = 0; 305 (void) ffs_sbupdate(ump, MNT_WAIT); 306 307 return 0; 308 } 309 310 int 311 ffs_wapbl_start(struct mount *mp) 312 { 313 struct ufsmount *ump = VFSTOUFS(mp); 314 struct fs *fs = ump->um_fs; 315 struct vnode *devvp = ump->um_devvp; 316 daddr_t off; 317 size_t count; 318 size_t blksize; 319 uint64_t extradata; 320 int error; 321 322 if (mp->mnt_wapbl == NULL) { 323 if (fs->fs_journal_flags & UFS_WAPBL_FLAGS_CLEAR_LOG) { 324 /* Clear out any existing journal file */ 325 error = wapbl_remove_log(mp); 326 if (error != 0) 327 return error; 328 } 329 330 if (mp->mnt_flag & MNT_LOG) { 331 KDASSERT(fs->fs_ronly == 0); 332 333 /* WAPBL needs UFS2 format super block */ 334 if (ffs_superblock_layout(fs) < 2) { 335 printf("%s: %s: fs superblock in old format, " 336 "not journaling\n", __func__, 337 VFSTOUFS(mp)->um_fs->fs_fsmnt); 338 mp->mnt_flag &= ~MNT_LOG; 339 return EINVAL; 340 } 341 342 error = wapbl_log_position(mp, fs, devvp, &off, 343 &count, &blksize, &extradata); 344 if (error) 345 return error; 346 347 /* 348 * Make sure we don't carry over any delayed write 349 * buffers when updating to log. Need to turn off 350 * async termporarily, to prevent ffs_sync() writes 351 * themselves being turned into delayed writes. 352 */ 353 if (mp->mnt_flag & MNT_UPDATE) { 354 int saveflag = mp->mnt_flag & MNT_ASYNC; 355 mp->mnt_flag &= ~MNT_ASYNC; 356 ffs_sync(mp, MNT_WAIT, FSCRED); 357 mp->mnt_flag |= saveflag; 358 } 359 360 error = wapbl_start(&mp->mnt_wapbl, mp, devvp, off, 361 count, blksize, mp->mnt_wapbl_replay, 362 ffs_wapbl_sync_metadata, 363 ffs_wapbl_abort_sync_metadata); 364 if (error) 365 return error; 366 367 mp->mnt_wapbl_op = &wapbl_ops; 368 369 #ifdef WAPBL_DEBUG 370 printf("%s: %s: enabling logging\n", __func__, 371 fs->fs_fsmnt); 372 #endif 373 374 if ((fs->fs_flags & FS_DOWAPBL) == 0) { 375 fs->fs_flags |= FS_DOWAPBL; 376 if ((error = UFS_WAPBL_BEGIN(mp)) != 0) 377 goto out; 378 error = ffs_sbupdate(ump, MNT_WAIT); 379 if (error) { 380 UFS_WAPBL_END(mp); 381 goto out; 382 } 383 UFS_WAPBL_END(mp); 384 error = wapbl_flush(mp->mnt_wapbl, 1); 385 if (error) 386 goto out; 387 } 388 389 /* 390 * XXX discard interferes with block deallocation 391 * registration and hence log consistency 392 */ 393 if (mp->mnt_flag & MNT_DISCARD) { 394 CLR(mp->mnt_flag, MNT_DISCARD); 395 printf("%s: %s: disabling discard to preserve log consistency\n", __func__, 396 fs->fs_fsmnt); 397 398 if (ump->um_discarddata != NULL) { 399 ffs_discard_finish(ump->um_discarddata, 400 0); 401 ump->um_discarddata = NULL; 402 } 403 } 404 405 } else if (fs->fs_flags & FS_DOWAPBL) { 406 fs->fs_fmod = 1; 407 fs->fs_flags &= ~FS_DOWAPBL; 408 } 409 } 410 411 /* 412 * It is recommended that you finish replay with logging enabled. 413 * However, even if logging is not enabled, the remaining log 414 * replay should be safely recoverable with an fsck, so perform 415 * it anyway. 416 */ 417 if ((fs->fs_ronly == 0) && mp->mnt_wapbl_replay) { 418 int saveflag = mp->mnt_flag & MNT_RDONLY; 419 /* 420 * Make sure MNT_RDONLY is not set so that the inode 421 * cleanup in ufs_inactive will actually do its work. 422 */ 423 mp->mnt_flag &= ~MNT_RDONLY; 424 ffs_wapbl_replay_finish(mp); 425 mp->mnt_flag |= saveflag; 426 KASSERT(fs->fs_ronly == 0); 427 } 428 429 return 0; 430 out: 431 ffs_wapbl_stop(mp, MNT_FORCE); 432 return error; 433 } 434 435 int 436 ffs_wapbl_stop(struct mount *mp, int force) 437 { 438 struct ufsmount *ump = VFSTOUFS(mp); 439 struct fs *fs = ump->um_fs; 440 int error; 441 442 if (mp->mnt_wapbl) { 443 KDASSERT(fs->fs_ronly == 0); 444 445 /* 446 * Make sure turning off FS_DOWAPBL is only removed 447 * as the only change in the final flush since otherwise 448 * a transaction may reorder writes. 449 */ 450 error = wapbl_flush(mp->mnt_wapbl, 1); 451 if (error && !force) 452 return error; 453 if (error && force) 454 goto forceout; 455 error = UFS_WAPBL_BEGIN(mp); 456 if (error && !force) 457 return error; 458 if (error && force) 459 goto forceout; 460 KASSERT(fs->fs_flags & FS_DOWAPBL); 461 462 fs->fs_flags &= ~FS_DOWAPBL; 463 error = ffs_sbupdate(ump, MNT_WAIT); 464 KASSERT(error == 0); /* XXX a bit drastic! */ 465 UFS_WAPBL_END(mp); 466 forceout: 467 error = wapbl_stop(mp->mnt_wapbl, force); 468 if (error) { 469 KASSERT(!force); 470 fs->fs_flags |= FS_DOWAPBL; 471 return error; 472 } 473 fs->fs_flags &= ~FS_DOWAPBL; /* Repeat in case of forced error */ 474 mp->mnt_wapbl = NULL; 475 476 #ifdef WAPBL_DEBUG 477 printf("%s: %s: disabled logging\n", __func__, fs->fs_fsmnt); 478 #endif 479 } 480 481 return 0; 482 } 483 484 int 485 ffs_wapbl_replay_start(struct mount *mp, struct fs *fs, struct vnode *devvp) 486 { 487 int error; 488 daddr_t off; 489 size_t count; 490 size_t blksize; 491 uint64_t extradata; 492 493 /* 494 * WAPBL needs UFS2 format super block, if we got here with a 495 * UFS1 format super block something is amiss... 496 */ 497 if (ffs_superblock_layout(fs) < 2) 498 return EINVAL; 499 500 error = wapbl_log_position(mp, fs, devvp, &off, &count, &blksize, 501 &extradata); 502 503 if (error) 504 return error; 505 506 error = wapbl_replay_start(&mp->mnt_wapbl_replay, devvp, off, 507 count, blksize); 508 if (error) 509 return error; 510 511 mp->mnt_wapbl_op = &wapbl_ops; 512 513 return 0; 514 } 515 516 /* 517 * If the superblock doesn't already have a recorded journal location 518 * then we allocate the journal in one of two positions: 519 * 520 * - At the end of the partition after the filesystem if there's 521 * enough space. "Enough space" is defined as >= 1MB of journal 522 * per 1GB of filesystem or 64MB, whichever is smaller. 523 * 524 * - Inside the filesystem. We try to allocate a contiguous journal 525 * based on the total filesystem size - the target is 1MB of journal 526 * per 1GB of filesystem, up to a maximum journal size of 64MB. As 527 * a worst case allowing for fragmentation, we'll allocate a journal 528 * 1/4 of the desired size but never smaller than 1MB. 529 * 530 * XXX In the future if we allow for non-contiguous journal files we 531 * can tighten the above restrictions. 532 * 533 * XXX 534 * These seems like a lot of duplication both here and in some of 535 * the userland tools (fsck_ffs, dumpfs, tunefs) with similar 536 * "switch (fs_journal_location)" constructs. Can we centralise 537 * this sort of code somehow/somewhere? 538 */ 539 static int 540 wapbl_log_position(struct mount *mp, struct fs *fs, struct vnode *devvp, 541 daddr_t *startp, size_t *countp, size_t *blksizep, uint64_t *extradatap) 542 { 543 struct ufsmount *ump = VFSTOUFS(mp); 544 daddr_t logstart, logend, desired_logsize; 545 uint64_t numsecs; 546 unsigned secsize; 547 int error, location; 548 549 if (fs->fs_journal_version == UFS_WAPBL_VERSION) { 550 switch (fs->fs_journal_location) { 551 case UFS_WAPBL_JOURNALLOC_END_PARTITION: 552 DPRINTF("found existing end-of-partition log\n"); 553 *startp = fs->fs_journallocs[UFS_WAPBL_EPART_ADDR]; 554 *countp = fs->fs_journallocs[UFS_WAPBL_EPART_COUNT]; 555 *blksizep = fs->fs_journallocs[UFS_WAPBL_EPART_BLKSZ]; 556 DPRINTF(" start = %" PRId64 ", size = %zu, " 557 "blksize = %zu\n", *startp, *countp, *blksizep); 558 return 0; 559 560 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM: 561 DPRINTF("found existing in-filesystem log\n"); 562 *startp = fs->fs_journallocs[UFS_WAPBL_INFS_ADDR]; 563 *countp = fs->fs_journallocs[UFS_WAPBL_INFS_COUNT]; 564 *blksizep = fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ]; 565 DPRINTF(" start = %" PRId64 ", size = %zu, " 566 "blksize = %zu\n", *startp, *countp, *blksizep); 567 return 0; 568 569 default: 570 printf("%s: %s: unknown journal type %d\n", __func__, 571 fs->fs_fsmnt, fs->fs_journal_location); 572 return EINVAL; 573 } 574 } 575 576 desired_logsize = 577 ffs_lfragtosize(fs, fs->fs_size) / UFS_WAPBL_JOURNAL_SCALE; 578 DPRINTF("desired log size = %" PRId64 " kB\n", desired_logsize / 1024); 579 desired_logsize = uimax(desired_logsize, UFS_WAPBL_MIN_JOURNAL_SIZE); 580 desired_logsize = uimin(desired_logsize, UFS_WAPBL_MAX_JOURNAL_SIZE); 581 DPRINTF("adjusted desired log size = %" PRId64 " kB\n", 582 desired_logsize / 1024); 583 584 /* Is there space after after filesystem on partition for log? */ 585 logstart = FFS_FSBTODB(fs, fs->fs_size); 586 error = getdisksize(devvp, &numsecs, &secsize); 587 if (error) 588 return error; 589 KDASSERT(secsize != 0); 590 logend = btodb(numsecs * secsize); 591 592 if (dbtob(logend - logstart) >= desired_logsize) { 593 DPRINTF("enough space, use end-of-partition log\n"); 594 595 location = UFS_WAPBL_JOURNALLOC_END_PARTITION; 596 *blksizep = secsize; 597 598 *startp = logstart; 599 *countp = (logend - logstart); 600 *extradatap = 0; 601 602 /* convert to physical block numbers */ 603 *startp = dbtob(*startp) / secsize; 604 *countp = dbtob(*countp) / secsize; 605 606 fs->fs_journallocs[UFS_WAPBL_EPART_ADDR] = *startp; 607 fs->fs_journallocs[UFS_WAPBL_EPART_COUNT] = *countp; 608 fs->fs_journallocs[UFS_WAPBL_EPART_BLKSZ] = *blksizep; 609 fs->fs_journallocs[UFS_WAPBL_EPART_UNUSED] = *extradatap; 610 } else { 611 DPRINTF("end-of-partition has only %" PRId64 " free\n", 612 logend - logstart); 613 614 location = UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM; 615 *blksizep = secsize; 616 617 error = wapbl_create_infs_log(mp, fs, devvp, 618 startp, countp, extradatap); 619 ffs_sync(mp, MNT_WAIT, FSCRED); 620 621 /* convert to physical block numbers */ 622 *startp = dbtob(*startp) / secsize; 623 *countp = dbtob(*countp) / secsize; 624 625 fs->fs_journallocs[UFS_WAPBL_INFS_ADDR] = *startp; 626 fs->fs_journallocs[UFS_WAPBL_INFS_COUNT] = *countp; 627 fs->fs_journallocs[UFS_WAPBL_INFS_BLKSZ] = *blksizep; 628 fs->fs_journallocs[UFS_WAPBL_INFS_INO] = *extradatap; 629 } 630 631 if (error == 0) { 632 /* update superblock with log location */ 633 fs->fs_journal_version = UFS_WAPBL_VERSION; 634 fs->fs_journal_location = location; 635 fs->fs_journal_flags = 0; 636 637 error = ffs_sbupdate(ump, MNT_WAIT); 638 } 639 640 return error; 641 } 642 643 /* 644 * Try to create a journal log inside the filesystem. 645 */ 646 static int 647 wapbl_create_infs_log(struct mount *mp, struct fs *fs, struct vnode *devvp, 648 daddr_t *startp, size_t *countp, uint64_t *extradatap) 649 { 650 struct vnode *vp, *rvp; 651 struct vattr va; 652 struct inode *ip; 653 int error; 654 655 if ((error = VFS_ROOT(mp, LK_EXCLUSIVE, &rvp)) != 0) 656 return error; 657 658 vattr_null(&va); 659 va.va_type = VREG; 660 va.va_mode = 0; 661 662 error = vcache_new(mp, rvp, &va, NOCRED, NULL, &vp); 663 vput(rvp); 664 if (error) 665 return error; 666 667 error = vn_lock(vp, LK_EXCLUSIVE); 668 if (error) { 669 vrele(vp); 670 return error; 671 } 672 673 ip = VTOI(vp); 674 ip->i_flags = SF_LOG; 675 DIP_ASSIGN(ip, flags, ip->i_flags); 676 ip->i_nlink = 1; 677 DIP_ASSIGN(ip, nlink, 1); 678 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 679 ffs_update(vp, NULL, NULL, UPDATE_WAIT); 680 681 if ((error = wapbl_allocate_log_file(mp, vp, 682 startp, countp, extradatap)) != 0) { 683 /* 684 * If we couldn't allocate the space for the log file, 685 * remove the inode by setting its link count back to 686 * zero and bail. 687 */ 688 ip->i_nlink = 0; 689 DIP_ASSIGN(ip, nlink, 0); 690 vput(vp); 691 692 return error; 693 } 694 695 /* 696 * Now that we have the place-holder inode for the journal, 697 * we don't need the vnode ever again. 698 */ 699 vput(vp); 700 701 return 0; 702 } 703 704 int 705 wapbl_allocate_log_file(struct mount *mp, struct vnode *vp, 706 daddr_t *startp, size_t *countp, uint64_t *extradatap) 707 { 708 struct ufsmount *ump = VFSTOUFS(mp); 709 struct fs *fs = ump->um_fs; 710 daddr_t addr, indir_addr; 711 off_t logsize; 712 size_t size; 713 int error; 714 715 logsize = 0; 716 /* check if there's a suggested log size */ 717 if (fs->fs_journal_flags & UFS_WAPBL_FLAGS_CREATE_LOG && 718 fs->fs_journal_location == UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM) 719 logsize = fs->fs_journallocs[UFS_WAPBL_INFS_COUNT]; 720 721 if (vp->v_size > 0) { 722 printf("%s: %s: file size (%" PRId64 ") non zero\n", __func__, 723 fs->fs_fsmnt, vp->v_size); 724 return EEXIST; 725 } 726 wapbl_find_log_start(mp, vp, logsize, &addr, &indir_addr, &size); 727 if (addr == 0) { 728 printf("%s: %s: log not allocated, largest extent is " 729 "%" PRId64 "MB\n", __func__, fs->fs_fsmnt, 730 ffs_lblktosize(fs, size) / (1024 * 1024)); 731 return ENOSPC; 732 } 733 734 logsize = ffs_lblktosize(fs, size); /* final log size */ 735 736 VTOI(vp)->i_ffs_first_data_blk = addr; 737 VTOI(vp)->i_ffs_first_indir_blk = indir_addr; 738 739 error = GOP_ALLOC(vp, 0, logsize, B_CONTIG, FSCRED); 740 if (error) { 741 printf("%s: %s: GOP_ALLOC error %d\n", __func__, fs->fs_fsmnt, 742 error); 743 return error; 744 } 745 746 *startp = FFS_FSBTODB(fs, addr); 747 *countp = btodb(logsize); 748 *extradatap = VTOI(vp)->i_number; 749 750 return 0; 751 } 752 753 /* 754 * Find a suitable location for the journal in the filesystem. 755 * 756 * Our strategy here is to look for a contiguous block of free space 757 * at least "logfile" MB in size (plus room for any indirect blocks). 758 * We start at the middle of the filesystem and check each cylinder 759 * group working outwards. If "logfile" MB is not available as a 760 * single contiguous chunk, then return the address and size of the 761 * largest chunk found. 762 * 763 * XXX 764 * At what stage does the search fail? Is if the largest space we could 765 * find is less than a quarter the requested space reasonable? If the 766 * search fails entirely, return a block address if "0" it indicate this. 767 */ 768 static void 769 wapbl_find_log_start(struct mount *mp, struct vnode *vp, off_t logsize, 770 daddr_t *addr, daddr_t *indir_addr, size_t *size) 771 { 772 struct ufsmount *ump = VFSTOUFS(mp); 773 struct fs *fs = ump->um_fs; 774 struct vnode *devvp = ump->um_devvp; 775 struct cg *cgp; 776 struct buf *bp; 777 uint8_t *blksfree; 778 daddr_t blkno, best_addr, start_addr; 779 daddr_t desired_blks, min_desired_blks; 780 daddr_t freeblks, best_blks; 781 int bpcg, cg, error, fixedsize, indir_blks, n, s; 782 const int needswap = UFS_FSNEEDSWAP(fs); 783 784 if (logsize == 0) { 785 fixedsize = 0; /* We can adjust the size if tight */ 786 logsize = ffs_lfragtosize(fs, fs->fs_dsize) / 787 UFS_WAPBL_JOURNAL_SCALE; 788 DPRINTF("suggested log size = %" PRId64 "\n", logsize); 789 logsize = uimax(logsize, UFS_WAPBL_MIN_JOURNAL_SIZE); 790 logsize = uimin(logsize, UFS_WAPBL_MAX_JOURNAL_SIZE); 791 DPRINTF("adjusted log size = %" PRId64 "\n", logsize); 792 } else { 793 fixedsize = 1; 794 DPRINTF("fixed log size = %" PRId64 "\n", logsize); 795 } 796 797 desired_blks = logsize / fs->fs_bsize; 798 DPRINTF("desired blocks = %" PRId64 "\n", desired_blks); 799 800 /* add in number of indirect blocks needed */ 801 indir_blks = 0; 802 if (desired_blks >= UFS_NDADDR) { 803 struct indir indirs[UFS_NIADDR + 2]; 804 int num; 805 806 error = ufs_getlbns(vp, desired_blks, indirs, &num); 807 if (error) { 808 printf("%s: %s: ufs_getlbns failed, error %d!\n", 809 __func__, fs->fs_fsmnt, error); 810 goto bad; 811 } 812 813 switch (num) { 814 case 2: 815 indir_blks = 1; /* 1st level indirect */ 816 break; 817 case 3: 818 indir_blks = 1 + /* 1st level indirect */ 819 1 + /* 2nd level indirect */ 820 indirs[1].in_off + 1; /* extra 1st level indirect */ 821 break; 822 default: 823 printf("%s: %s: unexpected numlevels %d from " 824 "ufs_getlbns\n", __func__, fs->fs_fsmnt, num); 825 *size = 0; 826 goto bad; 827 } 828 desired_blks += indir_blks; 829 } 830 DPRINTF("desired blocks = %" PRId64 " (including indirect)\n", 831 desired_blks); 832 833 /* 834 * If a specific size wasn't requested, allow for a smaller log 835 * if we're really tight for space... 836 */ 837 min_desired_blks = desired_blks; 838 if (!fixedsize) 839 min_desired_blks = desired_blks / 4; 840 841 /* Look at number of blocks per CG. If it's too small, bail early. */ 842 bpcg = ffs_fragstoblks(fs, fs->fs_fpg); 843 if (min_desired_blks > bpcg) { 844 printf("%s: %s: cylinder group size of %" PRId64 " MB " 845 " is not big enough for journal\n", __func__, fs->fs_fsmnt, 846 ffs_lblktosize(fs, bpcg) / (1024 * 1024)); 847 goto bad; 848 } 849 850 /* 851 * Start with the middle cylinder group, and search outwards in 852 * both directions until we either find the requested log size 853 * or reach the start/end of the file system. If we reach the 854 * start/end without finding enough space for the full requested 855 * log size, use the largest extent found if it is large enough 856 * to satisfy the our minimum size. 857 * 858 * XXX 859 * Can we just use the cluster contigsum stuff (esp on UFS2) 860 * here to simplify this search code? 861 */ 862 best_addr = 0; 863 best_blks = 0; 864 for (cg = fs->fs_ncg / 2, s = 0, n = 1; 865 best_blks < desired_blks && cg >= 0 && cg < fs->fs_ncg; 866 s++, n = -n, cg += n * s) { 867 DPRINTF("check cg %d of %d\n", cg, fs->fs_ncg); 868 error = bread(devvp, FFS_FSBTODB(fs, cgtod(fs, cg)), 869 fs->fs_cgsize, 0, &bp); 870 if (error) { 871 continue; 872 } 873 cgp = (struct cg *)bp->b_data; 874 if (!cg_chkmagic(cgp, UFS_FSNEEDSWAP(fs))) { 875 brelse(bp, 0); 876 continue; 877 } 878 879 blksfree = cg_blksfree(cgp, needswap); 880 881 for (blkno = 0; blkno < bpcg;) { 882 /* look for next free block */ 883 /* XXX use scanc() and fragtbl[] here? */ 884 for (; blkno < bpcg - min_desired_blks; blkno++) 885 if (ffs_isblock(fs, blksfree, blkno)) 886 break; 887 888 /* past end of search space in this CG? */ 889 if (blkno >= bpcg - min_desired_blks) 890 break; 891 892 /* count how many free blocks in this extent */ 893 start_addr = blkno; 894 for (freeblks = 0; blkno < bpcg; blkno++, freeblks++) 895 if (!ffs_isblock(fs, blksfree, blkno)) 896 break; 897 898 if (freeblks > best_blks) { 899 best_blks = freeblks; 900 best_addr = ffs_blkstofrags(fs, start_addr) + 901 cgbase(fs, cg); 902 903 if (freeblks >= desired_blks) { 904 DPRINTF("found len %" PRId64 905 " at offset %" PRId64 " in gc\n", 906 freeblks, start_addr); 907 break; 908 } 909 } 910 } 911 brelse(bp, 0); 912 } 913 DPRINTF("best found len = %" PRId64 ", wanted %" PRId64 914 " at addr %" PRId64 "\n", best_blks, desired_blks, best_addr); 915 916 if (best_blks < min_desired_blks) { 917 *addr = 0; 918 *indir_addr = 0; 919 } else { 920 /* put indirect blocks at start, and data blocks after */ 921 *addr = best_addr + ffs_blkstofrags(fs, indir_blks); 922 *indir_addr = best_addr; 923 } 924 *size = uimin(desired_blks, best_blks) - indir_blks; 925 return; 926 927 bad: 928 *addr = 0; 929 *indir_addr = 0; 930 *size = 0; 931 return; 932 } 933
Indexes created Wed Sep 24 05:09:52 GMT 2025