1 /* $NetBSD: lfs.c,v 1.23 2006/06/05 23:27:36 christos 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 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by the NetBSD 20 * Foundation, Inc. and its contributors. 21 * 4. Neither the name of The NetBSD Foundation nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 26 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 /* 38 * Copyright (c) 1989, 1991, 1993 39 * The Regents of the University of California. All rights reserved. 40 * (c) UNIX System Laboratories, Inc. 41 * All or some portions of this file are derived from material licensed 42 * to the University of California by American Telephone and Telegraph 43 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 44 * the permission of UNIX System Laboratories, Inc. 45 * 46 * Redistribution and use in source and binary forms, with or without 47 * modification, are permitted provided that the following conditions 48 * are met: 49 * 1. Redistributions of source code must retain the above copyright 50 * notice, this list of conditions and the following disclaimer. 51 * 2. Redistributions in binary form must reproduce the above copyright 52 * notice, this list of conditions and the following disclaimer in the 53 * documentation and/or other materials provided with the distribution. 54 * 3. Neither the name of the University nor the names of its contributors 55 * may be used to endorse or promote products derived from this software 56 * without specific prior written permission. 57 * 58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 68 * SUCH DAMAGE. 69 * 70 * @(#)ufs_bmap.c 8.8 (Berkeley) 8/11/95 71 */ 72 73 74 #include <sys/types.h> 75 #include <sys/param.h> 76 #include <sys/time.h> 77 #include <sys/buf.h> 78 #include <sys/mount.h> 79 80 #include <ufs/ufs/inode.h> 81 #include <ufs/ufs/ufsmount.h> 82 #define vnode uvnode 83 #include <ufs/lfs/lfs.h> 84 #undef vnode 85 86 #include <assert.h> 87 #include <err.h> 88 #include <errno.h> 89 #include <stdarg.h> 90 #include <stdio.h> 91 #include <stdlib.h> 92 #include <string.h> 93 #include <unistd.h> 94 95 #include "bufcache.h" 96 #include "vnode.h" 97 #include "lfs_user.h" 98 #include "segwrite.h" 99 100 #define panic call_panic 101 102 extern u_int32_t cksum(void *, size_t); 103 extern u_int32_t lfs_sb_cksum(struct dlfs *); 104 extern void pwarn(const char *, ...); 105 106 extern struct uvnodelst vnodelist; 107 extern struct uvnodelst getvnodelist[VNODE_HASH_MAX]; 108 extern int nvnodes; 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 = pread(bp->b_vp->v_fd, bp->b_data, bp->b_bcount, 124 dbtob(bp->b_blkno)); 125 if (count == bp->b_bcount) 126 bp->b_flags |= B_DONE; 127 } else { 128 count = pwrite(bp->b_vp->v_fd, bp->b_data, bp->b_bcount, 129 dbtob(bp->b_blkno)); 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 fs->lfs_avail -= btofsb(fs, bp->b_bcount); 148 } 149 bp->b_flags |= B_DELWRI | B_LOCKED; 150 reassignbuf(bp, bp->b_vp); 151 brelse(bp); 152 return 0; 153 } 154 155 /* 156 * ufs_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 ufs_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[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 < NDADDR) { 174 if (nump != NULL) 175 *nump = 0; 176 *bnp = fsbtodb(fs, ip->i_ffs1_db[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 = ufs_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 = ip->i_ffs1_ib[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); 206 207 xap->in_exists = 1; 208 bp = getblk(vp, metalbn, fs->lfs_bsize); 209 210 if (!(bp->b_flags & (B_DONE | B_DELWRI))) { 211 bp->b_blkno = fsbtodb(fs, daddr); 212 bp->b_flags |= B_READ; 213 VOP_STRATEGY(bp); 214 } 215 daddr = ((ufs_daddr_t *) bp->b_data)[xap->in_off]; 216 } 217 if (bp) 218 brelse(bp); 219 220 daddr = fsbtodb(fs, (ufs_daddr_t) 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 the i_ffs1_ib and 232 * once with the offset into the page itself. 233 */ 234 int 235 ufs_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 = fs->lfs_nindir; 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 NIADDR - i is the number of levels 259 * of indirection needed to locate the requested block. */ 260 261 bn -= NDADDR; 262 for (lbc = 0, i = 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 + 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 = NIADDR - i; 282 ap->in_exists = 0; 283 ap++; 284 for (++numlevels; i <= 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) & (fs->lfs_nindir - 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 ufs_bmaparray(vp->v_fs, vp, lbn, daddrp, NULL, NULL); 310 } 311 312 /* Search a block for a specific dinode. */ 313 struct ufs1_dinode * 314 lfs_ifind(struct lfs * fs, ino_t ino, struct ubuf * bp) 315 { 316 struct ufs1_dinode *dip = (struct ufs1_dinode *) bp->b_data; 317 struct ufs1_dinode *ldip, *fin; 318 319 fin = dip + 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 (ldip = fin - 1; ldip >= dip; --ldip) 327 if (ldip->di_inumber == ino) 328 return (ldip); 329 return NULL; 330 } 331 332 /* 333 * lfs_raw_vget makes us a new vnode from the inode at the given disk address. 334 * XXX it currently loses atime information. 335 */ 336 struct uvnode * 337 lfs_raw_vget(struct lfs * fs, ino_t ino, int fd, ufs_daddr_t daddr) 338 { 339 struct uvnode *vp; 340 struct inode *ip; 341 struct ufs1_dinode *dip; 342 struct ubuf *bp; 343 int i, hash; 344 345 vp = (struct uvnode *) malloc(sizeof(*vp)); 346 if (vp == NULL) 347 err(1, NULL); 348 memset(vp, 0, sizeof(*vp)); 349 vp->v_fd = fd; 350 vp->v_fs = fs; 351 vp->v_usecount = 0; 352 vp->v_strategy_op = lfs_vop_strategy; 353 vp->v_bwrite_op = lfs_vop_bwrite; 354 vp->v_bmap_op = lfs_vop_bmap; 355 LIST_INIT(&vp->v_cleanblkhd); 356 LIST_INIT(&vp->v_dirtyblkhd); 357 358 ip = (struct inode *) malloc(sizeof(*ip)); 359 if (ip == NULL) 360 err(1, NULL); 361 memset(ip, 0, sizeof(*ip)); 362 363 ip->i_din.ffs1_din = (struct ufs1_dinode *) 364 malloc(sizeof(struct ufs1_dinode)); 365 if (ip->i_din.ffs1_din == NULL) 366 err(1, NULL); 367 memset(ip->i_din.ffs1_din, 0, sizeof (struct ufs1_dinode)); 368 369 /* Initialize the inode -- from lfs_vcreate. */ 370 ip->inode_ext.lfs = malloc(sizeof(struct lfs_inode_ext)); 371 if (ip->inode_ext.lfs == NULL) 372 err(1, NULL); 373 memset(ip->inode_ext.lfs, 0, sizeof(struct lfs_inode_ext)); 374 vp->v_data = ip; 375 /* ip->i_vnode = vp; */ 376 ip->i_number = ino; 377 ip->i_lockf = 0; 378 ip->i_diroff = 0; 379 ip->i_lfs_effnblks = 0; 380 ip->i_flag = 0; 381 382 /* Load inode block and find inode */ 383 if (daddr > 0) { 384 bread(fs->lfs_devvp, fsbtodb(fs, daddr), fs->lfs_ibsize, NULL, &bp); 385 bp->b_flags |= B_AGE; 386 dip = lfs_ifind(fs, ino, bp); 387 if (dip == NULL) { 388 brelse(bp); 389 free(ip); 390 free(vp); 391 return NULL; 392 } 393 memcpy(ip->i_din.ffs1_din, dip, sizeof(*dip)); 394 brelse(bp); 395 } 396 ip->i_number = ino; 397 /* ip->i_devvp = fs->lfs_devvp; */ 398 ip->i_lfs = fs; 399 400 ip->i_ffs_effnlink = ip->i_ffs1_nlink; 401 ip->i_lfs_effnblks = ip->i_ffs1_blocks; 402 ip->i_lfs_osize = ip->i_ffs1_size; 403 #if 0 404 if (fs->lfs_version > 1) { 405 ip->i_ffs1_atime = ts.tv_sec; 406 ip->i_ffs1_atimensec = ts.tv_nsec; 407 } 408 #endif 409 410 memset(ip->i_lfs_fragsize, 0, NDADDR * sizeof(*ip->i_lfs_fragsize)); 411 for (i = 0; i < NDADDR; i++) 412 if (ip->i_ffs1_db[i] != 0) 413 ip->i_lfs_fragsize[i] = blksize(fs, ip, i); 414 415 ++nvnodes; 416 hash = ((int)(intptr_t)fs + ino) & (VNODE_HASH_MAX - 1); 417 LIST_INSERT_HEAD(&getvnodelist[hash], vp, v_getvnodes); 418 LIST_INSERT_HEAD(&vnodelist, vp, v_mntvnodes); 419 420 return vp; 421 } 422 423 static struct uvnode * 424 lfs_vget(void *vfs, ino_t ino) 425 { 426 struct lfs *fs = (struct lfs *)vfs; 427 ufs_daddr_t daddr; 428 struct ubuf *bp; 429 IFILE *ifp; 430 431 LFS_IENTRY(ifp, fs, ino, bp); 432 daddr = ifp->if_daddr; 433 brelse(bp); 434 if (daddr <= 0 || dtosn(fs, daddr) >= fs->lfs_nseg) 435 return NULL; 436 return lfs_raw_vget(fs, ino, fs->lfs_ivnode->v_fd, daddr); 437 } 438 439 /* Check superblock magic number and checksum */ 440 static int 441 check_sb(struct lfs *fs) 442 { 443 u_int32_t checksum; 444 445 if (fs->lfs_magic != LFS_MAGIC) { 446 printf("Superblock magic number (0x%lx) does not match " 447 "expected 0x%lx\n", (unsigned long) fs->lfs_magic, 448 (unsigned long) LFS_MAGIC); 449 return 1; 450 } 451 /* checksum */ 452 checksum = lfs_sb_cksum(&(fs->lfs_dlfs)); 453 if (fs->lfs_cksum != checksum) { 454 printf("Superblock checksum (%lx) does not match computed checksum (%lx)\n", 455 (unsigned long) fs->lfs_cksum, (unsigned long) checksum); 456 return 1; 457 } 458 return 0; 459 } 460 461 /* Initialize LFS library; load superblocks and choose which to use. */ 462 struct lfs * 463 lfs_init(int devfd, daddr_t sblkno, daddr_t idaddr, int dummy_read, int debug) 464 { 465 struct uvnode *devvp; 466 struct ubuf *bp; 467 int tryalt; 468 struct lfs *fs, *altfs; 469 int error; 470 471 vfs_init(); 472 473 devvp = (struct uvnode *) malloc(sizeof(*devvp)); 474 if (devvp == NULL) 475 err(1, NULL); 476 memset(devvp, 0, sizeof(*devvp)); 477 devvp->v_fs = NULL; 478 devvp->v_fd = devfd; 479 devvp->v_strategy_op = raw_vop_strategy; 480 devvp->v_bwrite_op = raw_vop_bwrite; 481 devvp->v_bmap_op = raw_vop_bmap; 482 LIST_INIT(&devvp->v_cleanblkhd); 483 LIST_INIT(&devvp->v_dirtyblkhd); 484 485 tryalt = 0; 486 if (dummy_read) { 487 if (sblkno == 0) 488 sblkno = btodb(LFS_LABELPAD); 489 fs = (struct lfs *) malloc(sizeof(*fs)); 490 if (fs == NULL) 491 err(1, NULL); 492 memset(fs, 0, sizeof(*fs)); 493 fs->lfs_devvp = devvp; 494 } else { 495 if (sblkno == 0) { 496 sblkno = btodb(LFS_LABELPAD); 497 tryalt = 1; 498 } else if (debug) { 499 printf("No -b flag given, not attempting to verify checkpoint\n"); 500 } 501 error = bread(devvp, sblkno, LFS_SBPAD, NOCRED, &bp); 502 fs = (struct lfs *) malloc(sizeof(*fs)); 503 if (fs == NULL) 504 err(1, NULL); 505 memset(fs, 0, sizeof(*fs)); 506 fs->lfs_dlfs = *((struct dlfs *) bp->b_data); 507 fs->lfs_devvp = devvp; 508 bp->b_flags |= B_INVAL; 509 brelse(bp); 510 511 if (tryalt) { 512 error = bread(devvp, fsbtodb(fs, fs->lfs_sboffs[1]), 513 LFS_SBPAD, NOCRED, &bp); 514 altfs = (struct lfs *) malloc(sizeof(*altfs)); 515 if (altfs == NULL) 516 err(1, NULL); 517 memset(altfs, 0, sizeof(*altfs)); 518 altfs->lfs_dlfs = *((struct dlfs *) bp->b_data); 519 altfs->lfs_devvp = devvp; 520 bp->b_flags |= B_INVAL; 521 brelse(bp); 522 523 if (check_sb(fs) || fs->lfs_idaddr <= 0) { 524 if (debug) 525 printf("Primary superblock is no good, using first alternate\n"); 526 free(fs); 527 fs = altfs; 528 } else { 529 /* If both superblocks check out, try verification */ 530 if (check_sb(altfs)) { 531 if (debug) 532 printf("First alternate superblock is no good, using primary\n"); 533 free(altfs); 534 } else { 535 if (lfs_verify(fs, altfs, devvp, debug) == fs) { 536 free(altfs); 537 } else { 538 free(fs); 539 fs = altfs; 540 } 541 } 542 } 543 } 544 if (check_sb(fs)) { 545 free(fs); 546 return NULL; 547 } 548 } 549 550 /* Compatibility */ 551 if (fs->lfs_version < 2) { 552 fs->lfs_sumsize = LFS_V1_SUMMARY_SIZE; 553 fs->lfs_ibsize = fs->lfs_bsize; 554 fs->lfs_start = fs->lfs_sboffs[0]; 555 fs->lfs_tstamp = fs->lfs_otstamp; 556 fs->lfs_fsbtodb = 0; 557 } 558 559 if (!dummy_read) { 560 fs->lfs_suflags = (u_int32_t **) malloc(2 * sizeof(u_int32_t *)); 561 if (fs->lfs_suflags == NULL) 562 err(1, NULL); 563 fs->lfs_suflags[0] = (u_int32_t *) malloc(fs->lfs_nseg * sizeof(u_int32_t)); 564 if (fs->lfs_suflags[0] == NULL) 565 err(1, NULL); 566 fs->lfs_suflags[1] = (u_int32_t *) malloc(fs->lfs_nseg * sizeof(u_int32_t)); 567 if (fs->lfs_suflags[1] == NULL) 568 err(1, NULL); 569 } 570 571 if (idaddr == 0) 572 idaddr = fs->lfs_idaddr; 573 else 574 fs->lfs_idaddr = idaddr; 575 /* NB: If dummy_read!=0, idaddr==0 here so we get a fake inode. */ 576 fs->lfs_ivnode = lfs_raw_vget(fs, 577 (dummy_read ? LFS_IFILE_INUM : fs->lfs_ifile), devvp->v_fd, 578 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 ufs_daddr_t 598 try_verify(struct lfs *osb, struct uvnode *devvp, ufs_daddr_t goal, int debug) 599 { 600 ufs_daddr_t daddr, odaddr; 601 SEGSUM *sp; 602 int bc, flag; 603 struct ubuf *bp; 604 ufs_daddr_t nodirop_daddr; 605 u_int64_t serial; 606 607 odaddr = -1; 608 daddr = osb->lfs_offset; 609 nodirop_daddr = daddr; 610 serial = osb->lfs_serial; 611 while (daddr != goal) { 612 flag = 0; 613 oncemore: 614 /* Read in summary block */ 615 bread(devvp, fsbtodb(osb, daddr), osb->lfs_sumsize, NULL, &bp); 616 sp = (SEGSUM *)bp->b_data; 617 618 /* 619 * Could be a superblock instead of a segment summary. 620 * XXX should use gseguse, but right now we need to do more 621 * setup before we can...fix this 622 */ 623 if (sp->ss_magic != SS_MAGIC || 624 sp->ss_ident != osb->lfs_ident || 625 sp->ss_serial < serial || 626 sp->ss_sumsum != cksum(&sp->ss_datasum, osb->lfs_sumsize - 627 sizeof(sp->ss_sumsum))) { 628 brelse(bp); 629 if (flag == 0) { 630 flag = 1; 631 daddr += btofsb(osb, LFS_SBPAD); 632 goto oncemore; 633 } 634 break; 635 } 636 ++serial; 637 bc = check_summary(osb, sp, daddr, debug, devvp, NULL); 638 if (bc == 0) { 639 brelse(bp); 640 break; 641 } 642 assert (bc > 0); 643 odaddr = daddr; 644 daddr += btofsb(osb, osb->lfs_sumsize + bc); 645 if (dtosn(osb, odaddr) != dtosn(osb, daddr) || 646 dtosn(osb, daddr) != dtosn(osb, daddr + 647 btofsb(osb, osb->lfs_sumsize + osb->lfs_bsize))) { 648 daddr = sp->ss_next; 649 } 650 if (!(sp->ss_flags & SS_CONT)) 651 nodirop_daddr = daddr; 652 brelse(bp); 653 } 654 655 if (goal == 0) 656 return nodirop_daddr; 657 else 658 return daddr; 659 } 660 661 /* Use try_verify to check whether the newer superblock is valid. */ 662 struct lfs * 663 lfs_verify(struct lfs *sb0, struct lfs *sb1, struct uvnode *devvp, int debug) 664 { 665 ufs_daddr_t daddr; 666 struct lfs *osb, *nsb; 667 668 /* 669 * Verify the checkpoint of the newer superblock, 670 * if the timestamp/serial number of the two superblocks is 671 * different. 672 */ 673 674 osb = NULL; 675 if (debug) 676 printf("sb0 %lld, sb1 %lld\n", (long long) sb0->lfs_serial, 677 (long long) sb1->lfs_serial); 678 679 if ((sb0->lfs_version == 1 && 680 sb0->lfs_otstamp != sb1->lfs_otstamp) || 681 (sb0->lfs_version > 1 && 682 sb0->lfs_serial != sb1->lfs_serial)) { 683 if (sb0->lfs_version == 1) { 684 if (sb0->lfs_otstamp > sb1->lfs_otstamp) { 685 osb = sb1; 686 nsb = sb0; 687 } else { 688 osb = sb0; 689 nsb = sb1; 690 } 691 } else { 692 if (sb0->lfs_serial > sb1->lfs_serial) { 693 osb = sb1; 694 nsb = sb0; 695 } else { 696 osb = sb0; 697 nsb = sb1; 698 } 699 } 700 if (debug) { 701 printf("Attempting to verify newer checkpoint..."); 702 fflush(stdout); 703 } 704 daddr = try_verify(osb, devvp, nsb->lfs_offset, debug); 705 706 if (debug) 707 printf("done.\n"); 708 if (daddr == nsb->lfs_offset) { 709 pwarn("** Newer checkpoint verified, recovered %lld seconds of data\n", 710 (long long) nsb->lfs_tstamp - (long long) osb->lfs_tstamp); 711 sbdirty(); 712 } else { 713 pwarn("** Newer checkpoint invalid, lost %lld seconds of data\n", (long long) nsb->lfs_tstamp - (long long) osb->lfs_tstamp); 714 } 715 return (daddr == nsb->lfs_offset ? nsb : osb); 716 } 717 /* Nothing to check */ 718 return osb; 719 } 720 721 /* Verify a partial-segment summary; return the number of bytes on disk. */ 722 int 723 check_summary(struct lfs *fs, SEGSUM *sp, ufs_daddr_t pseg_addr, int debug, 724 struct uvnode *devvp, void (func(ufs_daddr_t, FINFO *))) 725 { 726 FINFO *fp; 727 int bc; /* Bytes in partial segment */ 728 int nblocks; 729 ufs_daddr_t seg_addr, daddr; 730 ufs_daddr_t *dp, *idp; 731 struct ubuf *bp; 732 int i, j, k, datac, len; 733 long sn; 734 u_int32_t *datap; 735 u_int32_t ccksum; 736 737 sn = dtosn(fs, pseg_addr); 738 seg_addr = sntod(fs, sn); 739 740 /* We've already checked the sumsum, just do the data bounds and sum */ 741 742 /* Count the blocks. */ 743 nblocks = howmany(sp->ss_ninos, INOPB(fs)); 744 bc = nblocks << (fs->lfs_version > 1 ? fs->lfs_ffshift : fs->lfs_bshift); 745 assert(bc >= 0); 746 747 fp = (FINFO *) (sp + 1); 748 for (i = 0; i < sp->ss_nfinfo; i++) { 749 nblocks += fp->fi_nblocks; 750 bc += fp->fi_lastlength + ((fp->fi_nblocks - 1) 751 << fs->lfs_bshift); 752 assert(bc >= 0); 753 fp = (FINFO *) (fp->fi_blocks + fp->fi_nblocks); 754 } 755 datap = (u_int32_t *) malloc(nblocks * sizeof(*datap)); 756 if (datap == NULL) 757 err(1, NULL); 758 datac = 0; 759 760 dp = (ufs_daddr_t *) sp; 761 dp += fs->lfs_sumsize / sizeof(ufs_daddr_t); 762 dp--; 763 764 idp = dp; 765 daddr = pseg_addr + btofsb(fs, fs->lfs_sumsize); 766 fp = (FINFO *) (sp + 1); 767 for (i = 0, j = 0; 768 i < sp->ss_nfinfo || j < howmany(sp->ss_ninos, INOPB(fs)); i++) { 769 if (i >= sp->ss_nfinfo && *idp != daddr) { 770 pwarn("Not enough inode blocks in pseg at 0x%" PRIx32 771 ": found %d, wanted %d\n", 772 pseg_addr, j, howmany(sp->ss_ninos, INOPB(fs))); 773 if (debug) 774 pwarn("*idp=%x, daddr=%" PRIx32 "\n", *idp, 775 daddr); 776 break; 777 } 778 while (j < howmany(sp->ss_ninos, INOPB(fs)) && *idp == daddr) { 779 bread(devvp, fsbtodb(fs, daddr), fs->lfs_ibsize, NOCRED, &bp); 780 datap[datac++] = ((u_int32_t *) (bp->b_data))[0]; 781 brelse(bp); 782 783 ++j; 784 daddr += btofsb(fs, fs->lfs_ibsize); 785 --idp; 786 } 787 if (i < sp->ss_nfinfo) { 788 if (func) 789 func(daddr, fp); 790 for (k = 0; k < fp->fi_nblocks; k++) { 791 len = (k == fp->fi_nblocks - 1 ? 792 fp->fi_lastlength 793 : fs->lfs_bsize); 794 bread(devvp, fsbtodb(fs, daddr), len, NOCRED, &bp); 795 datap[datac++] = ((u_int32_t *) (bp->b_data))[0]; 796 brelse(bp); 797 daddr += btofsb(fs, len); 798 } 799 fp = (FINFO *) (fp->fi_blocks + fp->fi_nblocks); 800 } 801 } 802 803 if (datac != nblocks) { 804 pwarn("Partial segment at 0x%llx expected %d blocks counted %d\n", 805 (long long) pseg_addr, nblocks, datac); 806 } 807 ccksum = cksum(datap, nblocks * sizeof(u_int32_t)); 808 /* Check the data checksum */ 809 if (ccksum != sp->ss_datasum) { 810 pwarn("Partial segment at 0x%" PRIx32 " data checksum" 811 " mismatch: given 0x%x, computed 0x%x\n", 812 pseg_addr, sp->ss_datasum, ccksum); 813 free(datap); 814 return 0; 815 } 816 free(datap); 817 assert(bc >= 0); 818 return bc; 819 } 820 821 /* print message and exit */ 822 void 823 my_vpanic(int fatal, const char *fmt, va_list ap) 824 { 825 (void) vprintf(fmt, ap); 826 exit(8); 827 } 828 829 void 830 call_panic(const char *fmt, ...) 831 { 832 va_list ap; 833 834 va_start(ap, fmt); 835 panic_func(1, fmt, ap); 836 va_end(ap); 837 } 838 839 /* Allocate a new inode. */ 840 struct uvnode * 841 lfs_valloc(struct lfs *fs, ino_t ino) 842 { 843 struct ubuf *bp, *cbp; 844 struct ifile *ifp; 845 ino_t new_ino; 846 int error; 847 int new_gen; 848 CLEANERINFO *cip; 849 850 /* Get the head of the freelist. */ 851 LFS_GET_HEADFREE(fs, cip, cbp, &new_ino); 852 853 /* 854 * Remove the inode from the free list and write the new start 855 * of the free list into the superblock. 856 */ 857 LFS_IENTRY(ifp, fs, new_ino, bp); 858 if (ifp->if_daddr != LFS_UNUSED_DADDR) 859 panic("lfs_valloc: inuse inode %d on the free list", new_ino); 860 LFS_PUT_HEADFREE(fs, cip, cbp, ifp->if_nextfree); 861 862 new_gen = ifp->if_version; /* version was updated by vfree */ 863 brelse(bp); 864 865 /* Extend IFILE so that the next lfs_valloc will succeed. */ 866 if (fs->lfs_freehd == LFS_UNUSED_INUM) { 867 if ((error = extend_ifile(fs)) != 0) { 868 LFS_PUT_HEADFREE(fs, cip, cbp, new_ino); 869 return NULL; 870 } 871 } 872 873 /* Set superblock modified bit and increment file count. */ 874 sbdirty(); 875 ++fs->lfs_nfiles; 876 877 return lfs_raw_vget(fs, ino, fs->lfs_devvp->v_fd, 0x0); 878 } 879 880 /* 881 * Add a new block to the Ifile, to accommodate future file creations. 882 */ 883 int 884 extend_ifile(struct lfs *fs) 885 { 886 struct uvnode *vp; 887 struct inode *ip; 888 IFILE *ifp; 889 IFILE_V1 *ifp_v1; 890 struct ubuf *bp, *cbp; 891 daddr_t i, blkno, max; 892 ino_t oldlast; 893 CLEANERINFO *cip; 894 895 vp = fs->lfs_ivnode; 896 ip = VTOI(vp); 897 blkno = lblkno(fs, ip->i_ffs1_size); 898 899 bp = getblk(vp, blkno, fs->lfs_bsize); /* XXX VOP_BALLOC() */ 900 ip->i_ffs1_size += fs->lfs_bsize; 901 902 i = (blkno - fs->lfs_segtabsz - fs->lfs_cleansz) * 903 fs->lfs_ifpb; 904 LFS_GET_HEADFREE(fs, cip, cbp, &oldlast); 905 LFS_PUT_HEADFREE(fs, cip, cbp, i); 906 max = i + fs->lfs_ifpb; 907 fs->lfs_bfree -= btofsb(fs, fs->lfs_bsize); 908 909 if (fs->lfs_version == 1) { 910 for (ifp_v1 = (IFILE_V1 *)bp->b_data; i < max; ++ifp_v1) { 911 ifp_v1->if_version = 1; 912 ifp_v1->if_daddr = LFS_UNUSED_DADDR; 913 ifp_v1->if_nextfree = ++i; 914 } 915 ifp_v1--; 916 ifp_v1->if_nextfree = oldlast; 917 } else { 918 for (ifp = (IFILE *)bp->b_data; i < max; ++ifp) { 919 ifp->if_version = 1; 920 ifp->if_daddr = LFS_UNUSED_DADDR; 921 ifp->if_nextfree = ++i; 922 } 923 ifp--; 924 ifp->if_nextfree = oldlast; 925 } 926 LFS_PUT_TAILFREE(fs, cip, cbp, max - 1); 927 928 LFS_BWRITE_LOG(bp); 929 930 return 0; 931 } 932 933