1 /* $NetBSD: lfs.c,v 1.69 2015/10/15 06:24:55 dholland Exp $ */ 2 /*- 3 * Copyright (c) 2003 The NetBSD Foundation, Inc. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to The NetBSD Foundation 7 * by Konrad E. Schroder <perseant@hhhh.org>. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 22 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 /* 31 * Copyright (c) 1989, 1991, 1993 32 * The Regents of the University of California. All rights reserved. 33 * (c) UNIX System Laboratories, Inc. 34 * All or some portions of this file are derived from material licensed 35 * to the University of California by American Telephone and Telegraph 36 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 37 * the permission of UNIX System Laboratories, Inc. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. Neither the name of the University nor the names of its contributors 48 * may be used to endorse or promote products derived from this software 49 * without specific prior written permission. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 54 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 61 * SUCH DAMAGE. 62 * 63 * @(#)ufs_bmap.c 8.8 (Berkeley) 8/11/95 64 */ 65 66 67 #include <sys/types.h> 68 #include <sys/param.h> 69 #include <sys/time.h> 70 #include <sys/buf.h> 71 #include <sys/mount.h> 72 73 #define vnode uvnode 74 #include <ufs/lfs/lfs.h> 75 #include <ufs/lfs/lfs_inode.h> 76 #include <ufs/lfs/lfs_accessors.h> 77 #undef vnode 78 79 #include <assert.h> 80 #include <err.h> 81 #include <errno.h> 82 #include <stdarg.h> 83 #include <stdio.h> 84 #include <stdlib.h> 85 #include <string.h> 86 #include <unistd.h> 87 #include <util.h> 88 89 #include "bufcache.h" 90 #include "vnode.h" 91 #include "lfs_user.h" 92 #include "segwrite.h" 93 #include "kernelops.h" 94 95 #define panic call_panic 96 97 extern u_int32_t cksum(void *, size_t); 98 extern u_int32_t lfs_sb_cksum(struct lfs *); 99 extern void pwarn(const char *, ...); 100 101 extern struct uvnodelst vnodelist; 102 extern struct uvnodelst getvnodelist[VNODE_HASH_MAX]; 103 extern int nvnodes; 104 105 long dev_bsize = DEV_BSIZE; 106 107 static int 108 lfs_fragextend(struct uvnode *, int, int, daddr_t, struct ubuf **); 109 110 int fsdirty = 0; 111 void (*panic_func)(int, const char *, va_list) = my_vpanic; 112 113 /* 114 * LFS buffer and uvnode operations 115 */ 116 117 int 118 lfs_vop_strategy(struct ubuf * bp) 119 { 120 int count; 121 122 if (bp->b_flags & B_READ) { 123 count = kops.ko_pread(bp->b_vp->v_fd, bp->b_data, bp->b_bcount, 124 bp->b_blkno * dev_bsize); 125 if (count == bp->b_bcount) 126 bp->b_flags |= B_DONE; 127 } else { 128 count = kops.ko_pwrite(bp->b_vp->v_fd, bp->b_data, bp->b_bcount, 129 bp->b_blkno * dev_bsize); 130 if (count == 0) { 131 perror("pwrite"); 132 return -1; 133 } 134 bp->b_flags &= ~B_DELWRI; 135 reassignbuf(bp, bp->b_vp); 136 } 137 return 0; 138 } 139 140 int 141 lfs_vop_bwrite(struct ubuf * bp) 142 { 143 struct lfs *fs; 144 145 fs = bp->b_vp->v_fs; 146 if (!(bp->b_flags & B_DELWRI)) { 147 lfs_sb_subavail(fs, lfs_btofsb(fs, bp->b_bcount)); 148 } 149 bp->b_flags |= B_DELWRI | B_LOCKED; 150 reassignbuf(bp, bp->b_vp); 151 brelse(bp, 0); 152 return 0; 153 } 154 155 /* 156 * ulfs_bmaparray does the bmap conversion, and if requested returns the 157 * array of logical blocks which must be traversed to get to a block. 158 * Each entry contains the offset into that block that gets you to the 159 * next block and the disk address of the block (if it is assigned). 160 */ 161 int 162 ulfs_bmaparray(struct lfs * fs, struct uvnode * vp, daddr_t bn, daddr_t * bnp, struct indir * ap, int *nump) 163 { 164 struct inode *ip; 165 struct ubuf *bp; 166 struct indir a[ULFS_NIADDR + 1], *xap; 167 daddr_t daddr; 168 daddr_t metalbn; 169 int error, num; 170 171 ip = VTOI(vp); 172 173 if (bn >= 0 && bn < ULFS_NDADDR) { 174 if (nump != NULL) 175 *nump = 0; 176 *bnp = LFS_FSBTODB(fs, lfs_dino_getdb(fs, ip->i_din, bn)); 177 if (*bnp == 0) 178 *bnp = -1; 179 return (0); 180 } 181 xap = ap == NULL ? a : ap; 182 if (!nump) 183 nump = # 184 if ((error = ulfs_getlbns(fs, vp, bn, xap, nump)) != 0) 185 return (error); 186 187 num = *nump; 188 189 /* Get disk address out of indirect block array */ 190 daddr = lfs_dino_getib(fs, ip->i_din, xap->in_off); 191 192 for (bp = NULL, ++xap; --num; ++xap) { 193 /* Exit the loop if there is no disk address assigned yet and 194 * the indirect block isn't in the cache, or if we were 195 * looking for an indirect block and we've found it. */ 196 197 metalbn = xap->in_lbn; 198 if ((daddr == 0 && !incore(vp, metalbn)) || metalbn == bn) 199 break; 200 /* 201 * If we get here, we've either got the block in the cache 202 * or we have a disk address for it, go fetch it. 203 */ 204 if (bp) 205 brelse(bp, 0); 206 207 xap->in_exists = 1; 208 bp = getblk(vp, metalbn, lfs_sb_getbsize(fs)); 209 210 if (!(bp->b_flags & (B_DONE | B_DELWRI))) { 211 bp->b_blkno = LFS_FSBTODB(fs, daddr); 212 bp->b_flags |= B_READ; 213 VOP_STRATEGY(bp); 214 } 215 daddr = lfs_iblock_get(fs, bp->b_data, xap->in_off); 216 } 217 if (bp) 218 brelse(bp, 0); 219 220 daddr = LFS_FSBTODB(fs, daddr); 221 *bnp = daddr == 0 ? -1 : daddr; 222 return (0); 223 } 224 225 /* 226 * Create an array of logical block number/offset pairs which represent the 227 * path of indirect blocks required to access a data block. The first "pair" 228 * contains the logical block number of the appropriate single, double or 229 * triple indirect block and the offset into the inode indirect block array. 230 * Note, the logical block number of the inode single/double/triple indirect 231 * block appears twice in the array, once with the offset into di_ib and 232 * once with the offset into the page itself. 233 */ 234 int 235 ulfs_getlbns(struct lfs * fs, struct uvnode * vp, daddr_t bn, struct indir * ap, int *nump) 236 { 237 daddr_t metalbn, realbn; 238 int64_t blockcnt; 239 int lbc; 240 int i, numlevels, off; 241 int lognindir, indir; 242 243 metalbn = 0; /* XXXGCC -Wuninitialized [sh3] */ 244 245 if (nump) 246 *nump = 0; 247 numlevels = 0; 248 realbn = bn; 249 if (bn < 0) 250 bn = -bn; 251 252 lognindir = -1; 253 for (indir = lfs_sb_getnindir(fs); indir; indir >>= 1) 254 ++lognindir; 255 256 /* Determine the number of levels of indirection. After this loop is 257 * done, blockcnt indicates the number of data blocks possible at the 258 * given level of indirection, and ULFS_NIADDR - i is the number of levels 259 * of indirection needed to locate the requested block. */ 260 261 bn -= ULFS_NDADDR; 262 for (lbc = 0, i = ULFS_NIADDR;; i--, bn -= blockcnt) { 263 if (i == 0) 264 return (EFBIG); 265 266 lbc += lognindir; 267 blockcnt = (int64_t) 1 << lbc; 268 269 if (bn < blockcnt) 270 break; 271 } 272 273 /* Calculate the address of the first meta-block. */ 274 metalbn = -((realbn >= 0 ? realbn : -realbn) - bn + ULFS_NIADDR - i); 275 276 /* At each iteration, off is the offset into the bap array which is an 277 * array of disk addresses at the current level of indirection. The 278 * logical block number and the offset in that block are stored into 279 * the argument array. */ 280 ap->in_lbn = metalbn; 281 ap->in_off = off = ULFS_NIADDR - i; 282 ap->in_exists = 0; 283 ap++; 284 for (++numlevels; i <= ULFS_NIADDR; i++) { 285 /* If searching for a meta-data block, quit when found. */ 286 if (metalbn == realbn) 287 break; 288 289 lbc -= lognindir; 290 blockcnt = (int64_t) 1 << lbc; 291 off = (bn >> lbc) & (lfs_sb_getnindir(fs) - 1); 292 293 ++numlevels; 294 ap->in_lbn = metalbn; 295 ap->in_off = off; 296 ap->in_exists = 0; 297 ++ap; 298 299 metalbn -= -1 + (off << lbc); 300 } 301 if (nump) 302 *nump = numlevels; 303 return (0); 304 } 305 306 int 307 lfs_vop_bmap(struct uvnode * vp, daddr_t lbn, daddr_t * daddrp) 308 { 309 return ulfs_bmaparray(vp->v_fs, vp, lbn, daddrp, NULL, NULL); 310 } 311 312 /* Search a block for a specific dinode. */ 313 union lfs_dinode * 314 lfs_ifind(struct lfs *fs, ino_t ino, struct ubuf *bp) 315 { 316 union lfs_dinode *ldip; 317 unsigned i, num; 318 319 num = LFS_INOPB(fs); 320 321 /* 322 * Read the inode block backwards, since later versions of the 323 * inode will supercede earlier ones. Though it is unlikely, it is 324 * possible that the same inode will appear in the same inode block. 325 */ 326 for (i = num; i-- > 0; ) { 327 ldip = DINO_IN_BLOCK(fs, bp->b_data, i); 328 if (lfs_dino_getinumber(fs, ldip) == ino) 329 return (ldip); 330 } 331 return NULL; 332 } 333 334 /* 335 * lfs_raw_vget makes us a new vnode from the inode at the given disk address. 336 * XXX it currently loses atime information. 337 */ 338 struct uvnode * 339 lfs_raw_vget(struct lfs * fs, ino_t ino, int fd, daddr_t daddr) 340 { 341 struct uvnode *vp; 342 struct inode *ip; 343 union lfs_dinode *dip; 344 struct ubuf *bp; 345 int i, hash; 346 347 vp = ecalloc(1, sizeof(*vp)); 348 vp->v_fd = fd; 349 vp->v_fs = fs; 350 vp->v_usecount = 0; 351 vp->v_strategy_op = lfs_vop_strategy; 352 vp->v_bwrite_op = lfs_vop_bwrite; 353 vp->v_bmap_op = lfs_vop_bmap; 354 LIST_INIT(&vp->v_cleanblkhd); 355 LIST_INIT(&vp->v_dirtyblkhd); 356 357 ip = ecalloc(1, sizeof(*ip)); 358 359 ip->i_din = dip = ecalloc(1, sizeof(*dip)); 360 361 /* Initialize the inode -- from lfs_vcreate. */ 362 ip->inode_ext.lfs = ecalloc(1, sizeof(*ip->inode_ext.lfs)); 363 vp->v_data = ip; 364 /* ip->i_vnode = vp; */ 365 ip->i_number = ino; 366 ip->i_lockf = 0; 367 ip->i_lfs_effnblks = 0; 368 ip->i_flag = 0; 369 370 /* Load inode block and find inode */ 371 if (daddr > 0) { 372 bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs), 373 0, &bp); 374 bp->b_flags |= B_AGE; 375 dip = lfs_ifind(fs, ino, bp); 376 if (dip == NULL) { 377 brelse(bp, 0); 378 free(ip); 379 free(vp); 380 return NULL; 381 } 382 lfs_copy_dinode(fs, ip->i_din, dip); 383 brelse(bp, 0); 384 } 385 ip->i_number = ino; 386 /* ip->i_devvp = fs->lfs_devvp; */ 387 ip->i_lfs = fs; 388 389 ip->i_lfs_effnblks = lfs_dino_getblocks(fs, ip->i_din); 390 ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din); 391 #if 0 392 if (lfs_sb_getversion(fs) > 1) { 393 lfs_dino_setatime(fs, ip->i_din, ts.tv_sec); 394 lfs_dino_setatimensec(fs, ip->i_din, ts.tv_nsec); 395 } 396 #endif 397 398 memset(ip->i_lfs_fragsize, 0, ULFS_NDADDR * sizeof(*ip->i_lfs_fragsize)); 399 for (i = 0; i < ULFS_NDADDR; i++) 400 if (lfs_dino_getdb(fs, ip->i_din, i) != 0) 401 ip->i_lfs_fragsize[i] = lfs_blksize(fs, ip, i); 402 403 ++nvnodes; 404 hash = ((int)(intptr_t)fs + ino) & (VNODE_HASH_MAX - 1); 405 LIST_INSERT_HEAD(&getvnodelist[hash], vp, v_getvnodes); 406 LIST_INSERT_HEAD(&vnodelist, vp, v_mntvnodes); 407 408 return vp; 409 } 410 411 static struct uvnode * 412 lfs_vget(void *vfs, ino_t ino) 413 { 414 struct lfs *fs = (struct lfs *)vfs; 415 daddr_t daddr; 416 struct ubuf *bp; 417 IFILE *ifp; 418 419 LFS_IENTRY(ifp, fs, ino, bp); 420 daddr = lfs_if_getdaddr(fs, ifp); 421 brelse(bp, 0); 422 if (daddr <= 0 || lfs_dtosn(fs, daddr) >= lfs_sb_getnseg(fs)) 423 return NULL; 424 return lfs_raw_vget(fs, ino, fs->lfs_ivnode->v_fd, daddr); 425 } 426 427 /* 428 * Check superblock magic number and checksum. 429 * Sets lfs_is64 and lfs_dobyteswap. 430 */ 431 static int 432 check_sb(struct lfs *fs) 433 { 434 u_int32_t checksum; 435 u_int32_t magic; 436 437 /* we can read the magic out of either the 32-bit or 64-bit dlfs */ 438 magic = fs->lfs_dlfs_u.u_32.dlfs_magic; 439 440 switch (magic) { 441 case LFS_MAGIC: 442 fs->lfs_is64 = false; 443 fs->lfs_dobyteswap = false; 444 break; 445 case LFS_MAGIC_SWAPPED: 446 fs->lfs_is64 = false; 447 fs->lfs_dobyteswap = true; 448 break; 449 case LFS64_MAGIC: 450 fs->lfs_is64 = true; 451 fs->lfs_dobyteswap = false; 452 break; 453 case LFS64_MAGIC_SWAPPED: 454 fs->lfs_is64 = true; 455 fs->lfs_dobyteswap = true; 456 break; 457 default: 458 printf("Superblock magic number (0x%lx) does not match " 459 "expected 0x%lx\n", (unsigned long) magic, 460 (unsigned long) LFS_MAGIC); 461 return 1; 462 } 463 464 /* checksum */ 465 checksum = lfs_sb_cksum(fs); 466 if (lfs_sb_getcksum(fs) != checksum) { 467 printf("Superblock checksum (%lx) does not match computed checksum (%lx)\n", 468 (unsigned long) lfs_sb_getcksum(fs), (unsigned long) checksum); 469 return 1; 470 } 471 return 0; 472 } 473 474 /* Initialize LFS library; load superblocks and choose which to use. */ 475 struct lfs * 476 lfs_init(int devfd, daddr_t sblkno, daddr_t idaddr, int dummy_read, int debug) 477 { 478 struct uvnode *devvp; 479 struct ubuf *bp; 480 int tryalt; 481 struct lfs *fs, *altfs; 482 483 vfs_init(); 484 485 devvp = ecalloc(1, sizeof(*devvp)); 486 devvp->v_fs = NULL; 487 devvp->v_fd = devfd; 488 devvp->v_strategy_op = raw_vop_strategy; 489 devvp->v_bwrite_op = raw_vop_bwrite; 490 devvp->v_bmap_op = raw_vop_bmap; 491 LIST_INIT(&devvp->v_cleanblkhd); 492 LIST_INIT(&devvp->v_dirtyblkhd); 493 494 tryalt = 0; 495 if (dummy_read) { 496 if (sblkno == 0) 497 sblkno = LFS_LABELPAD / dev_bsize; 498 fs = ecalloc(1, sizeof(*fs)); 499 fs->lfs_devvp = devvp; 500 } else { 501 if (sblkno == 0) { 502 sblkno = LFS_LABELPAD / dev_bsize; 503 tryalt = 1; 504 } else if (debug) { 505 printf("No -b flag given, not attempting to verify checkpoint\n"); 506 } 507 508 dev_bsize = DEV_BSIZE; 509 510 (void)bread(devvp, sblkno, LFS_SBPAD, 0, &bp); 511 fs = ecalloc(1, sizeof(*fs)); 512 __CTASSERT(sizeof(struct dlfs) == sizeof(struct dlfs64)); 513 memcpy(&fs->lfs_dlfs_u, bp->b_data, sizeof(struct dlfs)); 514 fs->lfs_devvp = devvp; 515 bp->b_flags |= B_INVAL; 516 brelse(bp, 0); 517 518 dev_bsize = lfs_sb_getfsize(fs) >> lfs_sb_getfsbtodb(fs); 519 520 if (tryalt) { 521 (void)bread(devvp, LFS_FSBTODB(fs, lfs_sb_getsboff(fs, 1)), 522 LFS_SBPAD, 0, &bp); 523 altfs = ecalloc(1, sizeof(*altfs)); 524 memcpy(&altfs->lfs_dlfs_u, bp->b_data, 525 sizeof(struct dlfs)); 526 altfs->lfs_devvp = devvp; 527 bp->b_flags |= B_INVAL; 528 brelse(bp, 0); 529 530 if (check_sb(fs) || lfs_sb_getidaddr(fs) <= 0) { 531 if (debug) 532 printf("Primary superblock is no good, using first alternate\n"); 533 free(fs); 534 fs = altfs; 535 } else { 536 /* If both superblocks check out, try verification */ 537 if (check_sb(altfs)) { 538 if (debug) 539 printf("First alternate superblock is no good, using primary\n"); 540 free(altfs); 541 } else { 542 if (lfs_verify(fs, altfs, devvp, debug) == fs) { 543 free(altfs); 544 } else { 545 free(fs); 546 fs = altfs; 547 } 548 } 549 } 550 } 551 if (check_sb(fs)) { 552 free(fs); 553 return NULL; 554 } 555 } 556 557 /* Compatibility */ 558 if (lfs_sb_getversion(fs) < 2) { 559 lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE); 560 lfs_sb_setibsize(fs, lfs_sb_getbsize(fs)); 561 lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0)); 562 lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs)); 563 lfs_sb_setfsbtodb(fs, 0); 564 } 565 566 if (!dummy_read) { 567 fs->lfs_suflags = emalloc(2 * sizeof(u_int32_t *)); 568 fs->lfs_suflags[0] = emalloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t)); 569 fs->lfs_suflags[1] = emalloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t)); 570 } 571 572 if (idaddr == 0) 573 idaddr = lfs_sb_getidaddr(fs); 574 else 575 lfs_sb_setidaddr(fs, idaddr); 576 /* NB: If dummy_read!=0, idaddr==0 here so we get a fake inode. */ 577 fs->lfs_ivnode = lfs_raw_vget(fs, LFS_IFILE_INUM, 578 devvp->v_fd, idaddr); 579 if (fs->lfs_ivnode == NULL) 580 return NULL; 581 582 register_vget((void *)fs, lfs_vget); 583 584 return fs; 585 } 586 587 /* 588 * Check partial segment validity between fs->lfs_offset and the given goal. 589 * 590 * If goal == 0, just keep on going until the segments stop making sense, 591 * and return the address of the last valid partial segment. 592 * 593 * If goal != 0, return the address of the first partial segment that failed, 594 * or "goal" if we reached it without failure (the partial segment *at* goal 595 * need not be valid). 596 */ 597 daddr_t 598 try_verify(struct lfs *osb, struct uvnode *devvp, daddr_t goal, int debug) 599 { 600 daddr_t daddr, odaddr; 601 SEGSUM *sp; 602 int i, bc, hitclean; 603 struct ubuf *bp; 604 daddr_t nodirop_daddr; 605 u_int64_t serial; 606 607 bc = 0; 608 hitclean = 0; 609 odaddr = -1; 610 daddr = lfs_sb_getoffset(osb); 611 nodirop_daddr = daddr; 612 serial = lfs_sb_getserial(osb); 613 while (daddr != goal) { 614 /* 615 * Don't mistakenly read a superblock, if there is one here. 616 */ 617 if (lfs_sntod(osb, lfs_dtosn(osb, daddr)) == daddr) { 618 if (daddr == lfs_sb_gets0addr(osb)) 619 daddr += lfs_btofsb(osb, LFS_LABELPAD); 620 for (i = 0; i < LFS_MAXNUMSB; i++) { 621 /* XXX dholland 20150828 I think this is wrong */ 622 if (lfs_sb_getsboff(osb, i) < daddr) 623 break; 624 if (lfs_sb_getsboff(osb, i) == daddr) 625 daddr += lfs_btofsb(osb, LFS_SBPAD); 626 } 627 } 628 629 /* Read in summary block */ 630 bread(devvp, LFS_FSBTODB(osb, daddr), lfs_sb_getsumsize(osb), 631 0, &bp); 632 sp = (SEGSUM *)bp->b_data; 633 634 /* 635 * Check for a valid segment summary belonging to our fs. 636 */ 637 if (lfs_ss_getmagic(osb, sp) != SS_MAGIC || 638 lfs_ss_getident(osb, sp) != lfs_sb_getident(osb) || 639 lfs_ss_getserial(osb, sp) < serial || /* XXX strengthen this */ 640 lfs_ss_getsumsum(osb, sp) != 641 cksum((char *)sp + lfs_ss_getsumstart(osb), 642 lfs_sb_getsumsize(osb) - lfs_ss_getsumstart(osb))) { 643 brelse(bp, 0); 644 if (debug) { 645 if (lfs_ss_getmagic(osb, sp) != SS_MAGIC) 646 pwarn("pseg at 0x%jx: " 647 "wrong magic number\n", 648 (uintmax_t)daddr); 649 else if (lfs_ss_getident(osb, sp) != lfs_sb_getident(osb)) 650 pwarn("pseg at 0x%jx: " 651 "expected ident %jx, got %jx\n", 652 (uintmax_t)daddr, 653 (uintmax_t)lfs_ss_getident(osb, sp), 654 (uintmax_t)lfs_sb_getident(osb)); 655 else if (lfs_ss_getserial(osb, sp) >= serial) 656 pwarn("pseg at 0x%jx: " 657 "serial %d < %d\n", 658 (uintmax_t)daddr, 659 (int)lfs_ss_getserial(osb, sp), (int)serial); 660 else 661 pwarn("pseg at 0x%jx: " 662 "summary checksum wrong\n", 663 (uintmax_t)daddr); 664 } 665 break; 666 } 667 if (debug && lfs_ss_getserial(osb, sp) != serial) 668 pwarn("warning, serial=%d ss_serial=%d\n", 669 (int)serial, (int)lfs_ss_getserial(osb, sp)); 670 ++serial; 671 bc = check_summary(osb, sp, daddr, debug, devvp, NULL); 672 if (bc == 0) { 673 brelse(bp, 0); 674 break; 675 } 676 if (debug) 677 pwarn("summary good: 0x%x/%d\n", (uintmax_t)daddr, 678 (int)lfs_ss_getserial(osb, sp)); 679 assert (bc > 0); 680 odaddr = daddr; 681 daddr += lfs_btofsb(osb, lfs_sb_getsumsize(osb) + bc); 682 if (lfs_dtosn(osb, odaddr) != lfs_dtosn(osb, daddr) || 683 lfs_dtosn(osb, daddr) != lfs_dtosn(osb, daddr + 684 lfs_btofsb(osb, lfs_sb_getsumsize(osb) + lfs_sb_getbsize(osb)) - 1)) { 685 daddr = lfs_ss_getnext(osb, sp); 686 } 687 688 /* 689 * Check for the beginning and ending of a sequence of 690 * dirops. Writes from the cleaner never involve new 691 * information, and are always checkpoints; so don't try 692 * to roll forward through them. Likewise, psegs written 693 * by a previous roll-forward attempt are not interesting. 694 */ 695 if (lfs_ss_getflags(osb, sp) & (SS_CLEAN | SS_RFW)) 696 hitclean = 1; 697 if (hitclean == 0 && (lfs_ss_getflags(osb, sp) & SS_CONT) == 0) 698 nodirop_daddr = daddr; 699 700 brelse(bp, 0); 701 } 702 703 if (goal == 0) 704 return nodirop_daddr; 705 else 706 return daddr; 707 } 708 709 /* Use try_verify to check whether the newer superblock is valid. */ 710 struct lfs * 711 lfs_verify(struct lfs *sb0, struct lfs *sb1, struct uvnode *devvp, int debug) 712 { 713 daddr_t daddr; 714 struct lfs *osb, *nsb; 715 716 /* 717 * Verify the checkpoint of the newer superblock, 718 * if the timestamp/serial number of the two superblocks is 719 * different. 720 */ 721 722 osb = NULL; 723 if (debug) 724 pwarn("sb0 %ju, sb1 %ju", 725 (uintmax_t) lfs_sb_getserial(sb0), 726 (uintmax_t) lfs_sb_getserial(sb1)); 727 728 if ((lfs_sb_getversion(sb0) == 1 && 729 lfs_sb_getotstamp(sb0) != lfs_sb_getotstamp(sb1)) || 730 (lfs_sb_getversion(sb0) > 1 && 731 lfs_sb_getserial(sb0) != lfs_sb_getserial(sb1))) { 732 if (lfs_sb_getversion(sb0) == 1) { 733 if (lfs_sb_getotstamp(sb0) > lfs_sb_getotstamp(sb1)) { 734 osb = sb1; 735 nsb = sb0; 736 } else { 737 osb = sb0; 738 nsb = sb1; 739 } 740 } else { 741 if (lfs_sb_getserial(sb0) > lfs_sb_getserial(sb1)) { 742 osb = sb1; 743 nsb = sb0; 744 } else { 745 osb = sb0; 746 nsb = sb1; 747 } 748 } 749 if (debug) { 750 printf("Attempting to verify newer checkpoint..."); 751 fflush(stdout); 752 } 753 daddr = try_verify(osb, devvp, lfs_sb_getoffset(nsb), debug); 754 755 if (debug) 756 printf("done.\n"); 757 if (daddr == lfs_sb_getoffset(nsb)) { 758 pwarn("** Newer checkpoint verified; recovered %jd seconds of data\n", 759 (intmax_t)(lfs_sb_gettstamp(nsb) - lfs_sb_gettstamp(osb))); 760 sbdirty(); 761 } else { 762 pwarn("** Newer checkpoint invalid; lost %jd seconds of data\n", (intmax_t)(lfs_sb_gettstamp(nsb) - lfs_sb_gettstamp(osb))); 763 } 764 return (daddr == lfs_sb_getoffset(nsb) ? nsb : osb); 765 } 766 /* Nothing to check */ 767 return osb; 768 } 769 770 /* Verify a partial-segment summary; return the number of bytes on disk. */ 771 int 772 check_summary(struct lfs *fs, SEGSUM *sp, daddr_t pseg_addr, int debug, 773 struct uvnode *devvp, void (func(daddr_t, FINFO *))) 774 { 775 FINFO *fp; 776 int bc; /* Bytes in partial segment */ 777 int nblocks; 778 daddr_t daddr; 779 IINFO *iibase, *iip; 780 struct ubuf *bp; 781 int i, j, k, datac, len; 782 lfs_checkword *datap; 783 u_int32_t ccksum; 784 785 /* We've already checked the sumsum, just do the data bounds and sum */ 786 787 /* Count the blocks. */ 788 nblocks = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); 789 bc = nblocks << (lfs_sb_getversion(fs) > 1 ? lfs_sb_getffshift(fs) : lfs_sb_getbshift(fs)); 790 assert(bc >= 0); 791 792 fp = SEGSUM_FINFOBASE(fs, sp); 793 for (i = 0; i < lfs_ss_getnfinfo(fs, sp); i++) { 794 nblocks += lfs_fi_getnblocks(fs, fp); 795 bc += lfs_fi_getlastlength(fs, fp) + ((lfs_fi_getnblocks(fs, fp) - 1) 796 << lfs_sb_getbshift(fs)); 797 assert(bc >= 0); 798 fp = NEXT_FINFO(fs, fp); 799 if (((char *)fp) - (char *)sp > lfs_sb_getsumsize(fs)) 800 return 0; 801 } 802 datap = emalloc(nblocks * sizeof(*datap)); 803 datac = 0; 804 805 iibase = SEGSUM_IINFOSTART(fs, sp); 806 807 iip = iibase; 808 daddr = pseg_addr + lfs_btofsb(fs, lfs_sb_getsumsize(fs)); 809 fp = SEGSUM_FINFOBASE(fs, sp); 810 for (i = 0, j = 0; 811 i < lfs_ss_getnfinfo(fs, sp) || j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) { 812 if (i >= lfs_ss_getnfinfo(fs, sp) && lfs_ii_getblock(fs, iip) != daddr) { 813 pwarn("Not enough inode blocks in pseg at 0x%jx: " 814 "found %d, wanted %d\n", 815 pseg_addr, j, howmany(lfs_ss_getninos(fs, sp), 816 LFS_INOPB(fs))); 817 if (debug) 818 pwarn("iip=0x%jx, daddr=0x%jx\n", 819 (uintmax_t)lfs_ii_getblock(fs, iip), 820 (intmax_t)daddr); 821 break; 822 } 823 while (j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) && lfs_ii_getblock(fs, iip) == daddr) { 824 bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs), 825 0, &bp); 826 datap[datac++] = ((lfs_checkword *)bp->b_data)[0]; 827 brelse(bp, 0); 828 829 ++j; 830 daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs)); 831 iip = NEXTLOWER_IINFO(fs, iip); 832 } 833 if (i < lfs_ss_getnfinfo(fs, sp)) { 834 if (func) 835 func(daddr, fp); 836 for (k = 0; k < lfs_fi_getnblocks(fs, fp); k++) { 837 len = (k == lfs_fi_getnblocks(fs, fp) - 1 ? 838 lfs_fi_getlastlength(fs, fp) 839 : lfs_sb_getbsize(fs)); 840 bread(devvp, LFS_FSBTODB(fs, daddr), len, 841 0, &bp); 842 datap[datac++] = ((lfs_checkword *)bp->b_data)[0]; 843 brelse(bp, 0); 844 daddr += lfs_btofsb(fs, len); 845 } 846 fp = NEXT_FINFO(fs, fp); 847 } 848 } 849 850 if (datac != nblocks) { 851 pwarn("Partial segment at 0x%jx expected %d blocks counted %d\n", 852 (intmax_t)pseg_addr, nblocks, datac); 853 } 854 ccksum = cksum(datap, nblocks * sizeof(datap[0])); 855 /* Check the data checksum */ 856 if (ccksum != lfs_ss_getdatasum(fs, sp)) { 857 pwarn("Partial segment at 0x%jx data checksum" 858 " mismatch: given 0x%x, computed 0x%x\n", 859 (uintmax_t)pseg_addr, lfs_ss_getdatasum(fs, sp), ccksum); 860 free(datap); 861 return 0; 862 } 863 free(datap); 864 assert(bc >= 0); 865 return bc; 866 } 867 868 /* print message and exit */ 869 void 870 my_vpanic(int fatal, const char *fmt, va_list ap) 871 { 872 (void) vprintf(fmt, ap); 873 exit(8); 874 } 875 876 void 877 call_panic(const char *fmt, ...) 878 { 879 va_list ap; 880 881 va_start(ap, fmt); 882 panic_func(1, fmt, ap); 883 va_end(ap); 884 } 885 886 /* Allocate a new inode. */ 887 struct uvnode * 888 lfs_valloc(struct lfs *fs, ino_t ino) 889 { 890 struct ubuf *bp, *cbp; 891 IFILE *ifp; 892 ino_t new_ino; 893 int error; 894 CLEANERINFO *cip; 895 896 /* Get the head of the freelist. */ 897 LFS_GET_HEADFREE(fs, cip, cbp, &new_ino); 898 899 /* 900 * Remove the inode from the free list and write the new start 901 * of the free list into the superblock. 902 */ 903 LFS_IENTRY(ifp, fs, new_ino, bp); 904 if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR) 905 panic("lfs_valloc: inuse inode %d on the free list", new_ino); 906 LFS_PUT_HEADFREE(fs, cip, cbp, lfs_if_getnextfree(fs, ifp)); 907 908 brelse(bp, 0); 909 910 /* Extend IFILE so that the next lfs_valloc will succeed. */ 911 if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) { 912 if ((error = extend_ifile(fs)) != 0) { 913 LFS_PUT_HEADFREE(fs, cip, cbp, new_ino); 914 return NULL; 915 } 916 } 917 918 /* Set superblock modified bit and increment file count. */ 919 sbdirty(); 920 lfs_sb_addnfiles(fs, 1); 921 922 return lfs_raw_vget(fs, ino, fs->lfs_devvp->v_fd, 0x0); 923 } 924 925 #ifdef IN_FSCK_LFS 926 void reset_maxino(ino_t); 927 #endif 928 929 /* 930 * Add a new block to the Ifile, to accommodate future file creations. 931 */ 932 int 933 extend_ifile(struct lfs *fs) 934 { 935 struct uvnode *vp; 936 struct inode *ip; 937 IFILE64 *ifp64; 938 IFILE32 *ifp32; 939 IFILE_V1 *ifp_v1; 940 struct ubuf *bp, *cbp; 941 daddr_t i, blkno, max; 942 ino_t oldlast; 943 CLEANERINFO *cip; 944 945 vp = fs->lfs_ivnode; 946 ip = VTOI(vp); 947 blkno = lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din)); 948 949 lfs_balloc(vp, lfs_dino_getsize(fs, ip->i_din), lfs_sb_getbsize(fs), &bp); 950 lfs_dino_setsize(fs, ip->i_din, 951 lfs_dino_getsize(fs, ip->i_din) + lfs_sb_getbsize(fs)); 952 ip->i_flag |= IN_MODIFIED; 953 954 i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) * 955 lfs_sb_getifpb(fs); 956 LFS_GET_HEADFREE(fs, cip, cbp, &oldlast); 957 LFS_PUT_HEADFREE(fs, cip, cbp, i); 958 max = i + lfs_sb_getifpb(fs); 959 lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getbsize(fs))); 960 961 if (fs->lfs_is64) { 962 for (ifp64 = (IFILE64 *)bp->b_data; i < max; ++ifp64) { 963 ifp64->if_version = 1; 964 ifp64->if_daddr = LFS_UNUSED_DADDR; 965 ifp64->if_nextfree = ++i; 966 } 967 ifp64--; 968 ifp64->if_nextfree = oldlast; 969 } else if (lfs_sb_getversion(fs) > 1) { 970 for (ifp32 = (IFILE32 *)bp->b_data; i < max; ++ifp32) { 971 ifp32->if_version = 1; 972 ifp32->if_daddr = LFS_UNUSED_DADDR; 973 ifp32->if_nextfree = ++i; 974 } 975 ifp32--; 976 ifp32->if_nextfree = oldlast; 977 } else { 978 for (ifp_v1 = (IFILE_V1 *)bp->b_data; i < max; ++ifp_v1) { 979 ifp_v1->if_version = 1; 980 ifp_v1->if_daddr = LFS_UNUSED_DADDR; 981 ifp_v1->if_nextfree = ++i; 982 } 983 ifp_v1--; 984 ifp_v1->if_nextfree = oldlast; 985 } 986 LFS_PUT_TAILFREE(fs, cip, cbp, max - 1); 987 988 LFS_BWRITE_LOG(bp); 989 990 #ifdef IN_FSCK_LFS 991 reset_maxino(((lfs_dino_getsize(fs, ip->i_din) >> lfs_sb_getbshift(fs)) 992 - lfs_sb_getsegtabsz(fs) 993 - lfs_sb_getcleansz(fs)) * lfs_sb_getifpb(fs)); 994 #endif 995 return 0; 996 } 997 998 /* 999 * Allocate a block, and to inode and filesystem block accounting for it 1000 * and for any indirect blocks the may need to be created in order for 1001 * this block to be created. 1002 * 1003 * Blocks which have never been accounted for (i.e., which "do not exist") 1004 * have disk address 0, which is translated by ulfs_bmap to the special value 1005 * UNASSIGNED == -1, as in the historical ULFS. 1006 * 1007 * Blocks which have been accounted for but which have not yet been written 1008 * to disk are given the new special disk address UNWRITTEN == -2, so that 1009 * they can be differentiated from completely new blocks. 1010 */ 1011 int 1012 lfs_balloc(struct uvnode *vp, off_t startoffset, int iosize, struct ubuf **bpp) 1013 { 1014 int offset; 1015 daddr_t daddr, idaddr; 1016 struct ubuf *ibp, *bp; 1017 struct inode *ip; 1018 struct lfs *fs; 1019 struct indir indirs[ULFS_NIADDR+2], *idp; 1020 daddr_t lbn, lastblock; 1021 int bcount; 1022 int error, frags, i, nsize, osize, num; 1023 1024 ip = VTOI(vp); 1025 fs = ip->i_lfs; 1026 offset = lfs_blkoff(fs, startoffset); 1027 lbn = lfs_lblkno(fs, startoffset); 1028 1029 /* 1030 * Three cases: it's a block beyond the end of file, it's a block in 1031 * the file that may or may not have been assigned a disk address or 1032 * we're writing an entire block. 1033 * 1034 * Note, if the daddr is UNWRITTEN, the block already exists in 1035 * the cache (it was read or written earlier). If so, make sure 1036 * we don't count it as a new block or zero out its contents. If 1037 * it did not, make sure we allocate any necessary indirect 1038 * blocks. 1039 * 1040 * If we are writing a block beyond the end of the file, we need to 1041 * check if the old last block was a fragment. If it was, we need 1042 * to rewrite it. 1043 */ 1044 1045 if (bpp) 1046 *bpp = NULL; 1047 1048 /* Check for block beyond end of file and fragment extension needed. */ 1049 lastblock = lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din)); 1050 if (lastblock < ULFS_NDADDR && lastblock < lbn) { 1051 osize = lfs_blksize(fs, ip, lastblock); 1052 if (osize < lfs_sb_getbsize(fs) && osize > 0) { 1053 if ((error = lfs_fragextend(vp, osize, lfs_sb_getbsize(fs), 1054 lastblock, 1055 (bpp ? &bp : NULL)))) 1056 return (error); 1057 lfs_dino_setsize(fs, ip->i_din, (lastblock + 1) * lfs_sb_getbsize(fs)); 1058 ip->i_flag |= IN_CHANGE | IN_UPDATE; 1059 if (bpp) 1060 (void) VOP_BWRITE(bp); 1061 } 1062 } 1063 1064 /* 1065 * If the block we are writing is a direct block, it's the last 1066 * block in the file, and offset + iosize is less than a full 1067 * block, we can write one or more fragments. There are two cases: 1068 * the block is brand new and we should allocate it the correct 1069 * size or it already exists and contains some fragments and 1070 * may need to extend it. 1071 */ 1072 if (lbn < ULFS_NDADDR && lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din)) <= lbn) { 1073 osize = lfs_blksize(fs, ip, lbn); 1074 nsize = lfs_fragroundup(fs, offset + iosize); 1075 if (lfs_lblktosize(fs, lbn) >= lfs_dino_getsize(fs, ip->i_din)) { 1076 /* Brand new block or fragment */ 1077 frags = lfs_numfrags(fs, nsize); 1078 if (bpp) { 1079 *bpp = bp = getblk(vp, lbn, nsize); 1080 bp->b_blkno = UNWRITTEN; 1081 } 1082 ip->i_lfs_effnblks += frags; 1083 lfs_sb_subbfree(fs, frags); 1084 lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN); 1085 } else { 1086 if (nsize <= osize) { 1087 /* No need to extend */ 1088 if (bpp && (error = bread(vp, lbn, osize, 1089 0, &bp))) 1090 return error; 1091 } else { 1092 /* Extend existing block */ 1093 if ((error = 1094 lfs_fragextend(vp, osize, nsize, lbn, 1095 (bpp ? &bp : NULL)))) 1096 return error; 1097 } 1098 if (bpp) 1099 *bpp = bp; 1100 } 1101 return 0; 1102 } 1103 1104 error = ulfs_bmaparray(fs, vp, lbn, &daddr, &indirs[0], &num); 1105 if (error) 1106 return (error); 1107 1108 /* 1109 * Do byte accounting all at once, so we can gracefully fail *before* 1110 * we start assigning blocks. 1111 */ 1112 frags = LFS_FSBTODB(fs, 1); /* frags = VFSTOULFS(vp->v_mount)->um_seqinc; */ 1113 bcount = 0; 1114 if (daddr == UNASSIGNED) { 1115 bcount = frags; 1116 } 1117 for (i = 1; i < num; ++i) { 1118 if (!indirs[i].in_exists) { 1119 bcount += frags; 1120 } 1121 } 1122 lfs_sb_subbfree(fs, bcount); 1123 ip->i_lfs_effnblks += bcount; 1124 1125 if (daddr == UNASSIGNED) { 1126 if (num > 0 && lfs_dino_getib(fs, ip->i_din, indirs[0].in_off) == 0) { 1127 lfs_dino_setib(fs, ip->i_din, indirs[0].in_off, 1128 UNWRITTEN); 1129 } 1130 1131 /* 1132 * Create new indirect blocks if necessary 1133 */ 1134 if (num > 1) { 1135 idaddr = lfs_dino_getib(fs, ip->i_din, indirs[0].in_off); 1136 for (i = 1; i < num; ++i) { 1137 ibp = getblk(vp, indirs[i].in_lbn, 1138 lfs_sb_getbsize(fs)); 1139 if (!indirs[i].in_exists) { 1140 memset(ibp->b_data, 0, ibp->b_bufsize); 1141 ibp->b_blkno = UNWRITTEN; 1142 } else if (!(ibp->b_flags & (B_DELWRI | B_DONE))) { 1143 ibp->b_blkno = LFS_FSBTODB(fs, idaddr); 1144 ibp->b_flags |= B_READ; 1145 VOP_STRATEGY(ibp); 1146 } 1147 /* 1148 * This block exists, but the next one may not. 1149 * If that is the case mark it UNWRITTEN to 1150 * keep the accounting straight. 1151 */ 1152 if (lfs_iblock_get(fs, ibp->b_data, 1153 indirs[i].in_off) == 0) 1154 lfs_iblock_set(fs, ibp->b_data, 1155 indirs[i].in_off, UNWRITTEN); 1156 idaddr = lfs_iblock_get(fs, ibp->b_data, 1157 indirs[i].in_off); 1158 if ((error = VOP_BWRITE(ibp))) 1159 return error; 1160 } 1161 } 1162 } 1163 1164 1165 /* 1166 * Get the existing block from the cache, if requested. 1167 */ 1168 if (bpp) 1169 *bpp = bp = getblk(vp, lbn, lfs_blksize(fs, ip, lbn)); 1170 1171 /* 1172 * The block we are writing may be a brand new block 1173 * in which case we need to do accounting. 1174 * 1175 * We can tell a truly new block because ulfs_bmaparray will say 1176 * it is UNASSIGNED. Once we allocate it we will assign it the 1177 * disk address UNWRITTEN. 1178 */ 1179 if (daddr == UNASSIGNED) { 1180 if (bpp) { 1181 /* Note the new address */ 1182 bp->b_blkno = UNWRITTEN; 1183 } 1184 1185 switch (num) { 1186 case 0: 1187 lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN); 1188 break; 1189 case 1: 1190 lfs_dino_setib(fs, ip->i_din, indirs[0].in_off, 1191 UNWRITTEN); 1192 break; 1193 default: 1194 idp = &indirs[num - 1]; 1195 if (bread(vp, idp->in_lbn, lfs_sb_getbsize(fs), 0, &ibp)) 1196 panic("lfs_balloc: bread bno %lld", 1197 (long long)idp->in_lbn); 1198 lfs_iblock_set(fs, ibp->b_data, idp->in_off, 1199 UNWRITTEN); 1200 VOP_BWRITE(ibp); 1201 } 1202 } else if (bpp && !(bp->b_flags & (B_DONE|B_DELWRI))) { 1203 /* 1204 * Not a brand new block, also not in the cache; 1205 * read it in from disk. 1206 */ 1207 if (iosize == lfs_sb_getbsize(fs)) 1208 /* Optimization: I/O is unnecessary. */ 1209 bp->b_blkno = daddr; 1210 else { 1211 /* 1212 * We need to read the block to preserve the 1213 * existing bytes. 1214 */ 1215 bp->b_blkno = daddr; 1216 bp->b_flags |= B_READ; 1217 VOP_STRATEGY(bp); 1218 return 0; 1219 } 1220 } 1221 1222 return (0); 1223 } 1224 1225 int 1226 lfs_fragextend(struct uvnode *vp, int osize, int nsize, daddr_t lbn, 1227 struct ubuf **bpp) 1228 { 1229 struct inode *ip; 1230 struct lfs *fs; 1231 int frags; 1232 int error; 1233 1234 ip = VTOI(vp); 1235 fs = ip->i_lfs; 1236 frags = (long)lfs_numfrags(fs, nsize - osize); 1237 error = 0; 1238 1239 /* 1240 * If we are not asked to actually return the block, all we need 1241 * to do is allocate space for it. UBC will handle dirtying the 1242 * appropriate things and making sure it all goes to disk. 1243 * Don't bother to read in that case. 1244 */ 1245 if (bpp && (error = bread(vp, lbn, osize, 0, bpp))) { 1246 brelse(*bpp, 0); 1247 goto out; 1248 } 1249 1250 lfs_sb_subbfree(fs, frags); 1251 ip->i_lfs_effnblks += frags; 1252 ip->i_flag |= IN_CHANGE | IN_UPDATE; 1253 1254 if (bpp) { 1255 (*bpp)->b_data = erealloc((*bpp)->b_data, nsize); 1256 (void)memset((*bpp)->b_data + osize, 0, nsize - osize); 1257 } 1258 1259 out: 1260 return (error); 1261 } 1262