![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lfs_segment.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / ufs / lfs|
Return to lfs_segment.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / ufs / lfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* $NetBSD: lfs_segment.c,v 1.3 1994/08/21 03:15:32 cgd Exp $ */ ! 26: ! 27: /* ! 28: * Copyright (c) 1991, 1993 ! 29: * The Regents of the University of California. All rights reserved. ! 30: * ! 31: * Redistribution and use in source and binary forms, with or without ! 32: * modification, are permitted provided that the following conditions ! 33: * are met: ! 34: * 1. Redistributions of source code must retain the above copyright ! 35: * notice, this list of conditions and the following disclaimer. ! 36: * 2. Redistributions in binary form must reproduce the above copyright ! 37: * notice, this list of conditions and the following disclaimer in the ! 38: * documentation and/or other materials provided with the distribution. ! 39: * 3. All advertising materials mentioning features or use of this software ! 40: * must display the following acknowledgement: ! 41: * This product includes software developed by the University of ! 42: * California, Berkeley and its contributors. ! 43: * 4. Neither the name of the University nor the names of its contributors ! 44: * may be used to endorse or promote products derived from this software ! 45: * without specific prior written permission. ! 46: * ! 47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 57: * SUCH DAMAGE. ! 58: * ! 59: * @(#)lfs_segment.c 8.5 (Berkeley) 1/4/94 ! 60: */ ! 61: ! 62: #include <sys/param.h> ! 63: #include <sys/systm.h> ! 64: #include <sys/namei.h> ! 65: #include <sys/kernel.h> ! 66: #include <sys/resourcevar.h> ! 67: #include <sys/file.h> ! 68: #include <sys/stat.h> ! 69: #include <sys/buf.h> ! 70: #include <sys/proc.h> ! 71: #include <sys/conf.h> ! 72: #include <sys/vnode.h> ! 73: #include <sys/malloc.h> ! 74: #include <sys/mount.h> ! 75: ! 76: #include <miscfs/specfs/specdev.h> ! 77: #include <miscfs/fifofs/fifo.h> ! 78: ! 79: #include <ufs/ufs/quota.h> ! 80: #include <ufs/ufs/inode.h> ! 81: #include <ufs/ufs/dir.h> ! 82: #include <ufs/ufs/ufsmount.h> ! 83: #include <ufs/ufs/ufs_extern.h> ! 84: ! 85: #include <ufs/lfs/lfs.h> ! 86: #include <ufs/lfs/lfs_extern.h> ! 87: ! 88: extern int count_lock_queue __P((void)); ! 89: ! 90: #define MAX_ACTIVE 10 ! 91: /* ! 92: * Determine if it's OK to start a partial in this segment, or if we need ! 93: * to go on to a new segment. ! 94: */ ! 95: #define LFS_PARTIAL_FITS(fs) \ ! 96: ((fs)->lfs_dbpseg - ((fs)->lfs_offset - (fs)->lfs_curseg) > \ ! 97: 1 << (fs)->lfs_fsbtodb) ! 98: ! 99: void lfs_callback __P((struct buf *)); ! 100: void lfs_gather __P((struct lfs *, struct segment *, ! 101: struct vnode *, int (*) __P((struct lfs *, struct buf *)))); ! 102: int lfs_gatherblock __P((struct segment *, struct buf *, int *)); ! 103: void lfs_iset __P((struct inode *, daddr_t, time_t)); ! 104: int lfs_match_data __P((struct lfs *, struct buf *)); ! 105: int lfs_match_dindir __P((struct lfs *, struct buf *)); ! 106: int lfs_match_indir __P((struct lfs *, struct buf *)); ! 107: int lfs_match_tindir __P((struct lfs *, struct buf *)); ! 108: void lfs_newseg __P((struct lfs *)); ! 109: void lfs_shellsort __P((struct buf **, daddr_t *, register int)); ! 110: void lfs_supercallback __P((struct buf *)); ! 111: void lfs_updatemeta __P((struct segment *)); ! 112: int lfs_vref __P((struct vnode *)); ! 113: void lfs_vunref __P((struct vnode *)); ! 114: void lfs_writefile __P((struct lfs *, struct segment *, struct vnode *)); ! 115: int lfs_writeinode __P((struct lfs *, struct segment *, struct inode *)); ! 116: int lfs_writeseg __P((struct lfs *, struct segment *)); ! 117: void lfs_writesuper __P((struct lfs *)); ! 118: void lfs_writevnodes __P((struct lfs *fs, struct mount *mp, ! 119: struct segment *sp, int dirops)); ! 120: ! 121: int lfs_allclean_wakeup; /* Cleaner wakeup address. */ ! 122: ! 123: /* Statistics Counters */ ! 124: #define DOSTATS ! 125: struct lfs_stats lfs_stats; ! 126: ! 127: /* op values to lfs_writevnodes */ ! 128: #define VN_REG 0 ! 129: #define VN_DIROP 1 ! 130: #define VN_EMPTY 2 ! 131: ! 132: /* ! 133: * Ifile and meta data blocks are not marked busy, so segment writes MUST be ! 134: * single threaded. Currently, there are two paths into lfs_segwrite, sync() ! 135: * and getnewbuf(). They both mark the file system busy. Lfs_vflush() ! 136: * explicitly marks the file system busy. So lfs_segwrite is safe. I think. ! 137: */ ! 138: ! 139: int ! 140: lfs_vflush(vp) ! 141: struct vnode *vp; ! 142: { ! 143: struct inode *ip; ! 144: struct lfs *fs; ! 145: struct segment *sp; ! 146: ! 147: fs = VFSTOUFS(vp->v_mount)->um_lfs; ! 148: if (fs->lfs_nactive > MAX_ACTIVE) ! 149: return(lfs_segwrite(vp->v_mount, SEGM_SYNC|SEGM_CKP)); ! 150: lfs_seglock(fs, SEGM_SYNC); ! 151: sp = fs->lfs_sp; ! 152: ! 153: ! 154: ip = VTOI(vp); ! 155: if (vp->v_dirtyblkhd.lh_first == NULL) ! 156: lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY); ! 157: ! 158: do { ! 159: do { ! 160: if (vp->v_dirtyblkhd.lh_first != NULL) ! 161: lfs_writefile(fs, sp, vp); ! 162: } while (lfs_writeinode(fs, sp, ip)); ! 163: ! 164: } while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM); ! 165: ! 166: #ifdef DOSTATS ! 167: ++lfs_stats.nwrites; ! 168: if (sp->seg_flags & SEGM_SYNC) ! 169: ++lfs_stats.nsync_writes; ! 170: if (sp->seg_flags & SEGM_CKP) ! 171: ++lfs_stats.ncheckpoints; ! 172: #endif ! 173: lfs_segunlock(fs); ! 174: return (0); ! 175: } ! 176: ! 177: void ! 178: lfs_writevnodes(fs, mp, sp, op) ! 179: struct lfs *fs; ! 180: struct mount *mp; ! 181: struct segment *sp; ! 182: int op; ! 183: { ! 184: struct inode *ip; ! 185: struct vnode *vp; ! 186: ! 187: loop: ! 188: for (vp = mp->mnt_vnodelist.lh_first; ! 189: vp != NULL; ! 190: vp = vp->v_mntvnodes.le_next) { ! 191: /* ! 192: * If the vnode that we are about to sync is no longer ! 193: * associated with this mount point, start over. ! 194: */ ! 195: if (vp->v_mount != mp) ! 196: goto loop; ! 197: ! 198: /* XXX ignore dirops for now ! 199: if (op == VN_DIROP && !(vp->v_flag & VDIROP) || ! 200: op != VN_DIROP && (vp->v_flag & VDIROP)) ! 201: continue; ! 202: */ ! 203: ! 204: if (op == VN_EMPTY && vp->v_dirtyblkhd.lh_first) ! 205: continue; ! 206: ! 207: if (vp->v_type == VNON) ! 208: continue; ! 209: ! 210: if (lfs_vref(vp)) ! 211: continue; ! 212: ! 213: /* ! 214: * Write the inode/file if dirty and it's not the ! 215: * the IFILE. ! 216: */ ! 217: ip = VTOI(vp); ! 218: if ((ip->i_flag & ! 219: (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE) || ! 220: vp->v_dirtyblkhd.lh_first != NULL) && ! 221: ip->i_number != LFS_IFILE_INUM) { ! 222: if (vp->v_dirtyblkhd.lh_first != NULL) ! 223: lfs_writefile(fs, sp, vp); ! 224: (void) lfs_writeinode(fs, sp, ip); ! 225: } ! 226: vp->v_flag &= ~VDIROP; ! 227: lfs_vunref(vp); ! 228: } ! 229: } ! 230: ! 231: int ! 232: lfs_segwrite(mp, flags) ! 233: struct mount *mp; ! 234: int flags; /* Do a checkpoint. */ ! 235: { ! 236: struct buf *bp; ! 237: struct inode *ip; ! 238: struct lfs *fs; ! 239: struct segment *sp; ! 240: struct vnode *vp; ! 241: SEGUSE *segusep; ! 242: daddr_t ibno; ! 243: CLEANERINFO *cip; ! 244: int clean, do_ckp, error, i; ! 245: ! 246: fs = VFSTOUFS(mp)->um_lfs; ! 247: ! 248: /* ! 249: * If we have fewer than 2 clean segments, wait until cleaner ! 250: * writes. ! 251: */ ! 252: do { ! 253: LFS_CLEANERINFO(cip, fs, bp); ! 254: clean = cip->clean; ! 255: brelse(bp); ! 256: if (clean <= 2) { ! 257: printf ("segs clean: %d\n", clean); ! 258: wakeup(&lfs_allclean_wakeup); ! 259: if (error = tsleep(&fs->lfs_avail, PRIBIO + 1, ! 260: "lfs writer", 0)) ! 261: return (error); ! 262: } ! 263: } while (clean <= 2 ); ! 264: ! 265: /* ! 266: * Allocate a segment structure and enough space to hold pointers to ! 267: * the maximum possible number of buffers which can be described in a ! 268: * single summary block. ! 269: */ ! 270: do_ckp = flags & SEGM_CKP || fs->lfs_nactive > MAX_ACTIVE; ! 271: lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0)); ! 272: sp = fs->lfs_sp; ! 273: ! 274: lfs_writevnodes(fs, mp, sp, VN_REG); ! 275: ! 276: /* XXX ignore ordering of dirops for now */ ! 277: /* XXX ! 278: fs->lfs_writer = 1; ! 279: if (fs->lfs_dirops && (error = ! 280: tsleep(&fs->lfs_writer, PRIBIO + 1, "lfs writer", 0))) { ! 281: free(sp->bpp, M_SEGMENT); ! 282: free(sp, M_SEGMENT); ! 283: fs->lfs_writer = 0; ! 284: return (error); ! 285: } ! 286: ! 287: lfs_writevnodes(fs, mp, sp, VN_DIROP); ! 288: */ ! 289: ! 290: /* ! 291: * If we are doing a checkpoint, mark everything since the ! 292: * last checkpoint as no longer ACTIVE. ! 293: */ ! 294: if (do_ckp) ! 295: for (ibno = fs->lfs_cleansz + fs->lfs_segtabsz; ! 296: --ibno >= fs->lfs_cleansz; ) { ! 297: if (bread(fs->lfs_ivnode, ibno, fs->lfs_bsize, ! 298: NOCRED, &bp)) ! 299: ! 300: panic("lfs: ifile read"); ! 301: segusep = (SEGUSE *)bp->b_data; ! 302: for (i = fs->lfs_sepb; i--; segusep++) ! 303: segusep->su_flags &= ~SEGUSE_ACTIVE; ! 304: ! 305: error = VOP_BWRITE(bp); ! 306: } ! 307: ! 308: if (do_ckp || fs->lfs_doifile) { ! 309: redo: ! 310: vp = fs->lfs_ivnode; ! 311: while (vget(vp, 1)); ! 312: ip = VTOI(vp); ! 313: if (vp->v_dirtyblkhd.lh_first != NULL) ! 314: lfs_writefile(fs, sp, vp); ! 315: (void)lfs_writeinode(fs, sp, ip); ! 316: vput(vp); ! 317: if (lfs_writeseg(fs, sp) && do_ckp) ! 318: goto redo; ! 319: } else ! 320: (void) lfs_writeseg(fs, sp); ! 321: ! 322: /* ! 323: * If the I/O count is non-zero, sleep until it reaches zero. At the ! 324: * moment, the user's process hangs around so we can sleep. ! 325: */ ! 326: /* XXX ignore dirops for now ! 327: fs->lfs_writer = 0; ! 328: fs->lfs_doifile = 0; ! 329: wakeup(&fs->lfs_dirops); ! 330: */ ! 331: ! 332: #ifdef DOSTATS ! 333: ++lfs_stats.nwrites; ! 334: if (sp->seg_flags & SEGM_SYNC) ! 335: ++lfs_stats.nsync_writes; ! 336: if (sp->seg_flags & SEGM_CKP) ! 337: ++lfs_stats.ncheckpoints; ! 338: #endif ! 339: lfs_segunlock(fs); ! 340: return (0); ! 341: } ! 342: ! 343: /* ! 344: * Write the dirty blocks associated with a vnode. ! 345: */ ! 346: void ! 347: lfs_writefile(fs, sp, vp) ! 348: struct lfs *fs; ! 349: struct segment *sp; ! 350: struct vnode *vp; ! 351: { ! 352: struct buf *bp; ! 353: struct finfo *fip; ! 354: IFILE *ifp; ! 355: ! 356: if (sp->seg_bytes_left < fs->lfs_bsize || ! 357: sp->sum_bytes_left < sizeof(struct finfo)) ! 358: (void) lfs_writeseg(fs, sp); ! 359: ! 360: sp->sum_bytes_left -= sizeof(struct finfo) - sizeof(daddr_t); ! 361: ++((SEGSUM *)(sp->segsum))->ss_nfinfo; ! 362: ! 363: fip = sp->fip; ! 364: fip->fi_nblocks = 0; ! 365: fip->fi_ino = VTOI(vp)->i_number; ! 366: LFS_IENTRY(ifp, fs, fip->fi_ino, bp); ! 367: fip->fi_version = ifp->if_version; ! 368: brelse(bp); ! 369: ! 370: /* ! 371: * It may not be necessary to write the meta-data blocks at this point, ! 372: * as the roll-forward recovery code should be able to reconstruct the ! 373: * list. ! 374: */ ! 375: lfs_gather(fs, sp, vp, lfs_match_data); ! 376: lfs_gather(fs, sp, vp, lfs_match_indir); ! 377: lfs_gather(fs, sp, vp, lfs_match_dindir); ! 378: #ifdef TRIPLE ! 379: lfs_gather(fs, sp, vp, lfs_match_tindir); ! 380: #endif ! 381: ! 382: fip = sp->fip; ! 383: if (fip->fi_nblocks != 0) { ! 384: sp->fip = ! 385: (struct finfo *)((caddr_t)fip + sizeof(struct finfo) + ! 386: sizeof(daddr_t) * (fip->fi_nblocks - 1)); ! 387: sp->start_lbp = &sp->fip->fi_blocks[0]; ! 388: } else { ! 389: sp->sum_bytes_left += sizeof(struct finfo) - sizeof(daddr_t); ! 390: --((SEGSUM *)(sp->segsum))->ss_nfinfo; ! 391: } ! 392: } ! 393: ! 394: int ! 395: lfs_writeinode(fs, sp, ip) ! 396: struct lfs *fs; ! 397: struct segment *sp; ! 398: struct inode *ip; ! 399: { ! 400: struct buf *bp, *ibp; ! 401: IFILE *ifp; ! 402: SEGUSE *sup; ! 403: daddr_t daddr; ! 404: ino_t ino; ! 405: int error, i, ndx; ! 406: int redo_ifile = 0; ! 407: ! 408: if (!(ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE))) ! 409: return(0); ! 410: ! 411: /* Allocate a new inode block if necessary. */ ! 412: if (sp->ibp == NULL) { ! 413: /* Allocate a new segment if necessary. */ ! 414: if (sp->seg_bytes_left < fs->lfs_bsize || ! 415: sp->sum_bytes_left < sizeof(daddr_t)) ! 416: (void) lfs_writeseg(fs, sp); ! 417: ! 418: /* Get next inode block. */ ! 419: daddr = fs->lfs_offset; ! 420: fs->lfs_offset += fsbtodb(fs, 1); ! 421: sp->ibp = *sp->cbpp++ = ! 422: lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, daddr, ! 423: fs->lfs_bsize); ! 424: /* Zero out inode numbers */ ! 425: for (i = 0; i < INOPB(fs); ++i) ! 426: ((struct dinode *)sp->ibp->b_data)[i].di_inumber = 0; ! 427: ++sp->start_bpp; ! 428: fs->lfs_avail -= fsbtodb(fs, 1); ! 429: /* Set remaining space counters. */ ! 430: sp->seg_bytes_left -= fs->lfs_bsize; ! 431: sp->sum_bytes_left -= sizeof(daddr_t); ! 432: ndx = LFS_SUMMARY_SIZE / sizeof(daddr_t) - ! 433: sp->ninodes / INOPB(fs) - 1; ! 434: ((daddr_t *)(sp->segsum))[ndx] = daddr; ! 435: } ! 436: ! 437: /* Update the inode times and copy the inode onto the inode page. */ ! 438: if (ip->i_flag & IN_MODIFIED) ! 439: --fs->lfs_uinodes; ! 440: ITIMES(ip, &time, &time); ! 441: ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE); ! 442: bp = sp->ibp; ! 443: ((struct dinode *)bp->b_data)[sp->ninodes % INOPB(fs)] = ip->i_din; ! 444: /* Increment inode count in segment summary block. */ ! 445: ++((SEGSUM *)(sp->segsum))->ss_ninos; ! 446: ! 447: /* If this page is full, set flag to allocate a new page. */ ! 448: if (++sp->ninodes % INOPB(fs) == 0) ! 449: sp->ibp = NULL; ! 450: ! 451: /* ! 452: * If updating the ifile, update the super-block. Update the disk ! 453: * address and access times for this inode in the ifile. ! 454: */ ! 455: ino = ip->i_number; ! 456: if (ino == LFS_IFILE_INUM) { ! 457: daddr = fs->lfs_idaddr; ! 458: fs->lfs_idaddr = bp->b_blkno; ! 459: } else { ! 460: LFS_IENTRY(ifp, fs, ino, ibp); ! 461: daddr = ifp->if_daddr; ! 462: ifp->if_daddr = bp->b_blkno; ! 463: error = VOP_BWRITE(ibp); ! 464: } ! 465: ! 466: /* ! 467: * No need to update segment usage if there was no former inode address ! 468: * or if the last inode address is in the current partial segment. ! 469: */ ! 470: if (daddr != LFS_UNUSED_DADDR && ! 471: !(daddr >= fs->lfs_lastpseg && daddr <= bp->b_blkno)) { ! 472: LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); ! 473: #if DIAGNOSTIC ! 474: if (sup->su_nbytes < sizeof(struct dinode)) { ! 475: /* XXX -- Change to a panic. */ ! 476: printf("lfs: negative bytes (segment %d)\n", ! 477: datosn(fs, daddr)); ! 478: panic("negative bytes"); ! 479: } ! 480: #endif ! 481: sup->su_nbytes -= sizeof(struct dinode); ! 482: redo_ifile = ! 483: (ino == LFS_IFILE_INUM && !(bp->b_flags & B_GATHERED)); ! 484: error = VOP_BWRITE(bp); ! 485: } ! 486: return (redo_ifile); ! 487: } ! 488: ! 489: int ! 490: lfs_gatherblock(sp, bp, sptr) ! 491: struct segment *sp; ! 492: struct buf *bp; ! 493: int *sptr; ! 494: { ! 495: struct lfs *fs; ! 496: int version; ! 497: ! 498: /* ! 499: * If full, finish this segment. We may be doing I/O, so ! 500: * release and reacquire the splbio(). ! 501: */ ! 502: #if DIAGNOSTIC ! 503: if (sp->vp == NULL) ! 504: panic ("lfs_gatherblock: Null vp in segment"); ! 505: #endif ! 506: fs = sp->fs; ! 507: if (sp->sum_bytes_left < sizeof(daddr_t) || ! 508: sp->seg_bytes_left < fs->lfs_bsize) { ! 509: if (sptr) ! 510: splx(*sptr); ! 511: lfs_updatemeta(sp); ! 512: ! 513: version = sp->fip->fi_version; ! 514: (void) lfs_writeseg(fs, sp); ! 515: ! 516: sp->fip->fi_version = version; ! 517: sp->fip->fi_ino = VTOI(sp->vp)->i_number; ! 518: /* Add the current file to the segment summary. */ ! 519: ++((SEGSUM *)(sp->segsum))->ss_nfinfo; ! 520: sp->sum_bytes_left -= ! 521: sizeof(struct finfo) - sizeof(daddr_t); ! 522: ! 523: if (sptr) ! 524: *sptr = splbio(); ! 525: return(1); ! 526: } ! 527: ! 528: /* Insert into the buffer list, update the FINFO block. */ ! 529: bp->b_flags |= B_GATHERED; ! 530: *sp->cbpp++ = bp; ! 531: sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno; ! 532: ! 533: sp->sum_bytes_left -= sizeof(daddr_t); ! 534: sp->seg_bytes_left -= fs->lfs_bsize; ! 535: return(0); ! 536: } ! 537: ! 538: void ! 539: lfs_gather(fs, sp, vp, match) ! 540: struct lfs *fs; ! 541: struct segment *sp; ! 542: struct vnode *vp; ! 543: int (*match) __P((struct lfs *, struct buf *)); ! 544: { ! 545: struct buf *bp; ! 546: int s; ! 547: ! 548: sp->vp = vp; ! 549: s = splbio(); ! 550: loop: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next) { ! 551: if (bp->b_flags & B_BUSY || !match(fs, bp) || ! 552: bp->b_flags & B_GATHERED) ! 553: continue; ! 554: #if DIAGNOSTIC ! 555: if (!(bp->b_flags & B_DELWRI)) ! 556: panic("lfs_gather: bp not B_DELWRI"); ! 557: if (!(bp->b_flags & B_LOCKED)) ! 558: panic("lfs_gather: bp not B_LOCKED"); ! 559: #endif ! 560: if (lfs_gatherblock(sp, bp, &s)) ! 561: goto loop; ! 562: } ! 563: splx(s); ! 564: lfs_updatemeta(sp); ! 565: sp->vp = NULL; ! 566: } ! 567: ! 568: ! 569: /* ! 570: * Update the metadata that points to the blocks listed in the FINFO ! 571: * array. ! 572: */ ! 573: void ! 574: lfs_updatemeta(sp) ! 575: struct segment *sp; ! 576: { ! 577: SEGUSE *sup; ! 578: struct buf *bp; ! 579: struct lfs *fs; ! 580: struct vnode *vp; ! 581: struct indir a[NIADDR + 2], *ap; ! 582: struct inode *ip; ! 583: daddr_t daddr, lbn, off; ! 584: int db_per_fsb, error, i, nblocks, num; ! 585: ! 586: vp = sp->vp; ! 587: nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp; ! 588: if (vp == NULL || nblocks == 0) ! 589: return; ! 590: ! 591: /* Sort the blocks. */ ! 592: if (!(sp->seg_flags & SEGM_CLEAN)) ! 593: lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks); ! 594: ! 595: /* ! 596: * Assign disk addresses, and update references to the logical ! 597: * block and the segment usage information. ! 598: */ ! 599: fs = sp->fs; ! 600: db_per_fsb = fsbtodb(fs, 1); ! 601: for (i = nblocks; i--; ++sp->start_bpp) { ! 602: lbn = *sp->start_lbp++; ! 603: (*sp->start_bpp)->b_blkno = off = fs->lfs_offset; ! 604: fs->lfs_offset += db_per_fsb; ! 605: ! 606: if (error = ufs_bmaparray(vp, lbn, &daddr, a, &num, NULL)) ! 607: panic("lfs_updatemeta: ufs_bmaparray %d", error); ! 608: ip = VTOI(vp); ! 609: switch (num) { ! 610: case 0: ! 611: ip->i_db[lbn] = off; ! 612: break; ! 613: case 1: ! 614: ip->i_ib[a[0].in_off] = off; ! 615: break; ! 616: default: ! 617: ap = &a[num - 1]; ! 618: if (bread(vp, ap->in_lbn, fs->lfs_bsize, NOCRED, &bp)) ! 619: panic("lfs_updatemeta: bread bno %d", ! 620: ap->in_lbn); ! 621: /* ! 622: * Bread may create a new indirect block which needs ! 623: * to get counted for the inode. ! 624: */ ! 625: if (bp->b_blkno == -1 && !(bp->b_flags & B_CACHE)) { ! 626: printf ("Updatemeta allocating indirect block: shouldn't happen\n"); ! 627: ip->i_blocks += btodb(fs->lfs_bsize); ! 628: fs->lfs_bfree -= btodb(fs->lfs_bsize); ! 629: } ! 630: ((daddr_t *)bp->b_data)[ap->in_off] = off; ! 631: VOP_BWRITE(bp); ! 632: } ! 633: ! 634: /* Update segment usage information. */ ! 635: if (daddr != UNASSIGNED && ! 636: !(daddr >= fs->lfs_lastpseg && daddr <= off)) { ! 637: LFS_SEGENTRY(sup, fs, datosn(fs, daddr), bp); ! 638: #if DIAGNOSTIC ! 639: if (sup->su_nbytes < fs->lfs_bsize) { ! 640: /* XXX -- Change to a panic. */ ! 641: printf("lfs: negative bytes (segment %d)\n", ! 642: datosn(fs, daddr)); ! 643: panic ("Negative Bytes"); ! 644: } ! 645: #endif ! 646: sup->su_nbytes -= fs->lfs_bsize; ! 647: error = VOP_BWRITE(bp); ! 648: } ! 649: } ! 650: } ! 651: ! 652: /* ! 653: * Start a new segment. ! 654: */ ! 655: int ! 656: lfs_initseg(fs) ! 657: struct lfs *fs; ! 658: { ! 659: struct segment *sp; ! 660: SEGUSE *sup; ! 661: SEGSUM *ssp; ! 662: struct buf *bp; ! 663: int repeat; ! 664: ! 665: sp = fs->lfs_sp; ! 666: ! 667: repeat = 0; ! 668: /* Advance to the next segment. */ ! 669: if (!LFS_PARTIAL_FITS(fs)) { ! 670: /* Wake up any cleaning procs waiting on this file system. */ ! 671: wakeup(&lfs_allclean_wakeup); ! 672: ! 673: lfs_newseg(fs); ! 674: repeat = 1; ! 675: fs->lfs_offset = fs->lfs_curseg; ! 676: sp->seg_number = datosn(fs, fs->lfs_curseg); ! 677: sp->seg_bytes_left = fs->lfs_dbpseg * DEV_BSIZE; ! 678: ! 679: /* ! 680: * If the segment contains a superblock, update the offset ! 681: * and summary address to skip over it. ! 682: */ ! 683: LFS_SEGENTRY(sup, fs, sp->seg_number, bp); ! 684: if (sup->su_flags & SEGUSE_SUPERBLOCK) { ! 685: fs->lfs_offset += LFS_SBPAD / DEV_BSIZE; ! 686: sp->seg_bytes_left -= LFS_SBPAD; ! 687: } ! 688: brelse(bp); ! 689: } else { ! 690: sp->seg_number = datosn(fs, fs->lfs_curseg); ! 691: sp->seg_bytes_left = (fs->lfs_dbpseg - ! 692: (fs->lfs_offset - fs->lfs_curseg)) * DEV_BSIZE; ! 693: } ! 694: fs->lfs_lastpseg = fs->lfs_offset; ! 695: ! 696: sp->fs = fs; ! 697: sp->ibp = NULL; ! 698: sp->ninodes = 0; ! 699: ! 700: /* Get a new buffer for SEGSUM and enter it into the buffer list. */ ! 701: sp->cbpp = sp->bpp; ! 702: *sp->cbpp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, fs->lfs_offset, ! 703: LFS_SUMMARY_SIZE); ! 704: sp->segsum = (*sp->cbpp)->b_data; ! 705: bzero(sp->segsum, LFS_SUMMARY_SIZE); ! 706: sp->start_bpp = ++sp->cbpp; ! 707: fs->lfs_offset += LFS_SUMMARY_SIZE / DEV_BSIZE; ! 708: ! 709: /* Set point to SEGSUM, initialize it. */ ! 710: ssp = sp->segsum; ! 711: ssp->ss_next = fs->lfs_nextseg; ! 712: ssp->ss_nfinfo = ssp->ss_ninos = 0; ! 713: ! 714: /* Set pointer to first FINFO, initialize it. */ ! 715: sp->fip = (struct finfo *)((caddr_t)sp->segsum + sizeof(SEGSUM)); ! 716: sp->fip->fi_nblocks = 0; ! 717: sp->start_lbp = &sp->fip->fi_blocks[0]; ! 718: ! 719: sp->seg_bytes_left -= LFS_SUMMARY_SIZE; ! 720: sp->sum_bytes_left = LFS_SUMMARY_SIZE - sizeof(SEGSUM); ! 721: ! 722: return(repeat); ! 723: } ! 724: ! 725: /* ! 726: * Return the next segment to write. ! 727: */ ! 728: void ! 729: lfs_newseg(fs) ! 730: struct lfs *fs; ! 731: { ! 732: CLEANERINFO *cip; ! 733: SEGUSE *sup; ! 734: struct buf *bp; ! 735: int curseg, isdirty, sn; ! 736: ! 737: LFS_SEGENTRY(sup, fs, datosn(fs, fs->lfs_nextseg), bp); ! 738: sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE; ! 739: sup->su_nbytes = 0; ! 740: sup->su_nsums = 0; ! 741: sup->su_ninos = 0; ! 742: (void) VOP_BWRITE(bp); ! 743: ! 744: LFS_CLEANERINFO(cip, fs, bp); ! 745: --cip->clean; ! 746: ++cip->dirty; ! 747: (void) VOP_BWRITE(bp); ! 748: ! 749: fs->lfs_lastseg = fs->lfs_curseg; ! 750: fs->lfs_curseg = fs->lfs_nextseg; ! 751: for (sn = curseg = datosn(fs, fs->lfs_curseg);;) { ! 752: sn = (sn + 1) % fs->lfs_nseg; ! 753: if (sn == curseg) ! 754: panic("lfs_nextseg: no clean segments"); ! 755: LFS_SEGENTRY(sup, fs, sn, bp); ! 756: isdirty = sup->su_flags & SEGUSE_DIRTY; ! 757: brelse(bp); ! 758: if (!isdirty) ! 759: break; ! 760: } ! 761: ! 762: ++fs->lfs_nactive; ! 763: fs->lfs_nextseg = sntoda(fs, sn); ! 764: #ifdef DOSTATS ! 765: ++lfs_stats.segsused; ! 766: #endif ! 767: } ! 768: ! 769: int ! 770: lfs_writeseg(fs, sp) ! 771: struct lfs *fs; ! 772: struct segment *sp; ! 773: { ! 774: extern int locked_queue_count; ! 775: struct buf **bpp, *bp, *cbp; ! 776: SEGUSE *sup; ! 777: SEGSUM *ssp; ! 778: dev_t i_dev; ! 779: size_t size; ! 780: u_long *datap, *dp; ! 781: int ch_per_blk, do_again, i, nblocks, num, s; ! 782: int (*strategy)__P((struct vop_strategy_args *)); ! 783: struct vop_strategy_args vop_strategy_a; ! 784: u_short ninos; ! 785: char *p; ! 786: ! 787: /* ! 788: * If there are no buffers other than the segment summary to write ! 789: * and it is not a checkpoint, don't do anything. On a checkpoint, ! 790: * even if there aren't any buffers, you need to write the superblock. ! 791: */ ! 792: if ((nblocks = sp->cbpp - sp->bpp) == 1) ! 793: return (0); ! 794: ! 795: ssp = (SEGSUM *)sp->segsum; ! 796: ! 797: /* Update the segment usage information. */ ! 798: LFS_SEGENTRY(sup, fs, sp->seg_number, bp); ! 799: ninos = (ssp->ss_ninos + INOPB(fs) - 1) / INOPB(fs); ! 800: sup->su_nbytes += nblocks - 1 - ninos << fs->lfs_bshift; ! 801: sup->su_nbytes += ssp->ss_ninos * sizeof(struct dinode); ! 802: sup->su_nbytes += LFS_SUMMARY_SIZE; ! 803: sup->su_lastmod = time.tv_sec; ! 804: sup->su_ninos += ninos; ! 805: ++sup->su_nsums; ! 806: do_again = !(bp->b_flags & B_GATHERED); ! 807: (void)VOP_BWRITE(bp); ! 808: /* ! 809: * Compute checksum across data and then across summary; the first ! 810: * block (the summary block) is skipped. Set the create time here ! 811: * so that it's guaranteed to be later than the inode mod times. ! 812: * ! 813: * XXX ! 814: * Fix this to do it inline, instead of malloc/copy. ! 815: */ ! 816: // datap = dp = malloc(nblocks * sizeof(u_long), M_SEGMENT, M_WAITOK); ! 817: MALLOC(dp, caddr_t, nblocks * sizeof(u_long), M_SEGMENT, M_WAITOK); ! 818: datap = dp; ! 819: for (bpp = sp->bpp, i = nblocks - 1; i--;) { ! 820: if ((*++bpp)->b_flags & B_INVAL) { ! 821: if (copyin((*bpp)->b_saveaddr, dp++, sizeof(u_long))) ! 822: panic("lfs_writeseg: copyin failed"); ! 823: } else ! 824: *dp++ = ((u_long *)(*bpp)->b_data)[0]; ! 825: } ! 826: ssp->ss_create = time.tv_sec; ! 827: ssp->ss_datasum = cksum(datap, (nblocks - 1) * sizeof(u_long)); ! 828: ssp->ss_sumsum = ! 829: cksum(&ssp->ss_datasum, LFS_SUMMARY_SIZE - sizeof(ssp->ss_sumsum)); ! 830: free(datap, M_SEGMENT); ! 831: #if DIAGNOSTIC ! 832: if (fs->lfs_bfree < fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE) ! 833: panic("lfs_writeseg: No diskspace for summary"); ! 834: #endif ! 835: fs->lfs_bfree -= (fsbtodb(fs, ninos) + LFS_SUMMARY_SIZE / DEV_BSIZE); ! 836: ! 837: i_dev = VTOI(fs->lfs_ivnode)->i_dev; ! 838: strategy = VTOI(fs->lfs_ivnode)->i_devvp->v_op[VOFFSET(vop_strategy)]; ! 839: ! 840: /* ! 841: * When we simply write the blocks we lose a rotation for every block ! 842: * written. To avoid this problem, we allocate memory in chunks, copy ! 843: * the buffers into the chunk and write the chunk. MAXPHYS is the ! 844: * largest size I/O devices can handle. ! 845: * When the data is copied to the chunk, turn off the the B_LOCKED bit ! 846: * and brelse the buffer (which will move them to the LRU list). Add ! 847: * the B_CALL flag to the buffer header so we can count I/O's for the ! 848: * checkpoints and so we can release the allocated memory. ! 849: * ! 850: * XXX ! 851: * This should be removed if the new virtual memory system allows us to ! 852: * easily make the buffers contiguous in kernel memory and if that's ! 853: * fast enough. ! 854: */ ! 855: ch_per_blk = MAXPHYS / fs->lfs_bsize; ! 856: for (bpp = sp->bpp, i = nblocks; i;) { ! 857: num = ch_per_blk; ! 858: if (num > i) ! 859: num = i; ! 860: i -= num; ! 861: size = num * fs->lfs_bsize; ! 862: ! 863: cbp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, ! 864: (*bpp)->b_blkno, size); ! 865: cbp->b_dev = i_dev; ! 866: cbp->b_flags |= B_ASYNC | B_BUSY; ! 867: ! 868: s = splbio(); ! 869: ++fs->lfs_iocount; ! 870: for (p = cbp->b_data; num--;) { ! 871: bp = *bpp++; ! 872: /* ! 873: * Fake buffers from the cleaner are marked as B_INVAL. ! 874: * We need to copy the data from user space rather than ! 875: * from the buffer indicated. ! 876: * XXX == what do I do on an error? ! 877: */ ! 878: if (bp->b_flags & B_INVAL) { ! 879: if (copyin(bp->b_saveaddr, p, bp->b_bcount)) ! 880: panic("lfs_writeseg: copyin failed"); ! 881: } else ! 882: bcopy(bp->b_data, p, bp->b_bcount); ! 883: p += bp->b_bcount; ! 884: if (bp->b_flags & B_LOCKED) ! 885: --locked_queue_count; ! 886: bp->b_flags &= ~(B_ERROR | B_READ | B_DELWRI | ! 887: B_LOCKED | B_GATHERED); ! 888: if (bp->b_flags & B_CALL) { ! 889: /* if B_CALL, it was created with newbuf */ ! 890: brelvp(bp); ! 891: if (!(bp->b_flags & B_INVAL)) ! 892: free(bp->b_data, M_SEGMENT); ! 893: free(bp, M_SEGMENT); ! 894: } else { ! 895: bremfree(bp); ! 896: bp->b_flags |= B_DONE; ! 897: reassignbuf(bp, bp->b_vp); ! 898: brelse(bp); ! 899: } ! 900: } ! 901: ++cbp->b_vp->v_numoutput; ! 902: splx(s); ! 903: cbp->b_bcount = p - (char *)cbp->b_data; ! 904: /* ! 905: * XXXX This is a gross and disgusting hack. Since these ! 906: * buffers are physically addressed, they hang off the ! 907: * device vnode (devvp). As a result, they have no way ! 908: * of getting to the LFS superblock or lfs structure to ! 909: * keep track of the number of I/O's pending. So, I am ! 910: * going to stuff the fs into the saveaddr field of ! 911: * the buffer (yuk). ! 912: */ ! 913: cbp->b_saveaddr = (caddr_t)fs; ! 914: vop_strategy_a.a_desc = VDESC(vop_strategy); ! 915: vop_strategy_a.a_bp = cbp; ! 916: (strategy)(&vop_strategy_a); ! 917: } ! 918: /* ! 919: * XXX ! 920: * Vinvalbuf can move locked buffers off the locked queue ! 921: * and we have no way of knowing about this. So, after ! 922: * doing a big write, we recalculate how many bufers are ! 923: * really still left on the locked queue. ! 924: */ ! 925: locked_queue_count = count_lock_queue(); ! 926: wakeup(&locked_queue_count); ! 927: #ifdef DOSTATS ! 928: ++lfs_stats.psegwrites; ! 929: lfs_stats.blocktot += nblocks - 1; ! 930: if (fs->lfs_sp->seg_flags & SEGM_SYNC) ! 931: ++lfs_stats.psyncwrites; ! 932: if (fs->lfs_sp->seg_flags & SEGM_CLEAN) { ! 933: ++lfs_stats.pcleanwrites; ! 934: lfs_stats.cleanblocks += nblocks - 1; ! 935: } ! 936: #endif ! 937: return (lfs_initseg(fs) || do_again); ! 938: } ! 939: ! 940: void ! 941: lfs_writesuper(fs) ! 942: struct lfs *fs; ! 943: { ! 944: struct buf *bp; ! 945: dev_t i_dev; ! 946: int (*strategy) __P((struct vop_strategy_args *)); ! 947: int s; ! 948: struct vop_strategy_args vop_strategy_a; ! 949: ! 950: i_dev = VTOI(fs->lfs_ivnode)->i_dev; ! 951: strategy = VTOI(fs->lfs_ivnode)->i_devvp->v_op[VOFFSET(vop_strategy)]; ! 952: ! 953: /* Checksum the superblock and copy it into a buffer. */ ! 954: fs->lfs_cksum = cksum(fs, sizeof(struct lfs) - sizeof(fs->lfs_cksum)); ! 955: bp = lfs_newbuf(VTOI(fs->lfs_ivnode)->i_devvp, fs->lfs_sboffs[0], ! 956: LFS_SBPAD); ! 957: *(struct lfs *)bp->b_data = *fs; ! 958: ! 959: /* XXX Toggle between first two superblocks; for now just write first */ ! 960: bp->b_dev = i_dev; ! 961: bp->b_flags |= B_BUSY | B_CALL | B_ASYNC; ! 962: bp->b_flags &= ~(B_DONE | B_ERROR | B_READ | B_DELWRI); ! 963: bp->b_iodone = lfs_supercallback; ! 964: vop_strategy_a.a_desc = VDESC(vop_strategy); ! 965: vop_strategy_a.a_bp = bp; ! 966: s = splbio(); ! 967: ++bp->b_vp->v_numoutput; ! 968: splx(s); ! 969: (strategy)(&vop_strategy_a); ! 970: } ! 971: ! 972: /* ! 973: * Logical block number match routines used when traversing the dirty block ! 974: * chain. ! 975: */ ! 976: int ! 977: lfs_match_data(fs, bp) ! 978: struct lfs *fs; ! 979: struct buf *bp; ! 980: { ! 981: return (bp->b_lblkno >= 0); ! 982: } ! 983: ! 984: int ! 985: lfs_match_indir(fs, bp) ! 986: struct lfs *fs; ! 987: struct buf *bp; ! 988: { ! 989: int lbn; ! 990: ! 991: lbn = bp->b_lblkno; ! 992: return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 0); ! 993: } ! 994: ! 995: int ! 996: lfs_match_dindir(fs, bp) ! 997: struct lfs *fs; ! 998: struct buf *bp; ! 999: { ! 1000: int lbn; ! 1001: ! 1002: lbn = bp->b_lblkno; ! 1003: return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 1); ! 1004: } ! 1005: ! 1006: int ! 1007: lfs_match_tindir(fs, bp) ! 1008: struct lfs *fs; ! 1009: struct buf *bp; ! 1010: { ! 1011: int lbn; ! 1012: ! 1013: lbn = bp->b_lblkno; ! 1014: return (lbn < 0 && (-lbn - NDADDR) % NINDIR(fs) == 2); ! 1015: } ! 1016: ! 1017: /* ! 1018: * Allocate a new buffer header. ! 1019: */ ! 1020: struct buf * ! 1021: lfs_newbuf(vp, daddr, size) ! 1022: struct vnode *vp; ! 1023: daddr_t daddr; ! 1024: size_t size; ! 1025: { ! 1026: struct buf *bp; ! 1027: size_t nbytes; ! 1028: ! 1029: nbytes = roundup(size, DEV_BSIZE); ! 1030: // bp = malloc(sizeof(struct buf), M_SEGMENT, M_WAITOK); ! 1031: MALLOC(bp, struct buf *, sizeof(struct buf), M_SEGMENT, M_WAITOK); ! 1032: bzero(bp, sizeof(struct buf)); ! 1033: if (nbytes) ! 1034: // bp->b_data = malloc(nbytes, M_SEGMENT, M_WAITOK); ! 1035: MALLOC(bp->d_data, caddr_t, nbytes, M_SEGMENT, M_WAITOK); ! 1036: bgetvp(vp, bp); ! 1037: bp->b_bufsize = size; ! 1038: bp->b_bcount = size; ! 1039: bp->b_lblkno = daddr; ! 1040: bp->b_blkno = daddr; ! 1041: bp->b_error = 0; ! 1042: bp->b_resid = 0; ! 1043: bp->b_iodone = lfs_callback; ! 1044: bp->b_flags |= B_BUSY | B_CALL | B_NOCACHE; ! 1045: return (bp); ! 1046: } ! 1047: ! 1048: void ! 1049: lfs_callback(bp) ! 1050: struct buf *bp; ! 1051: { ! 1052: struct lfs *fs; ! 1053: ! 1054: fs = (struct lfs *)bp->b_saveaddr; ! 1055: #if DIAGNOSTIC ! 1056: if (fs->lfs_iocount == 0) ! 1057: panic("lfs_callback: zero iocount\n"); ! 1058: #endif ! 1059: if (--fs->lfs_iocount == 0) ! 1060: wakeup(&fs->lfs_iocount); ! 1061: ! 1062: brelvp(bp); ! 1063: free(bp->b_data, M_SEGMENT); ! 1064: free(bp, M_SEGMENT); ! 1065: } ! 1066: ! 1067: void ! 1068: lfs_supercallback(bp) ! 1069: struct buf *bp; ! 1070: { ! 1071: brelvp(bp); ! 1072: free(bp->b_data, M_SEGMENT); ! 1073: free(bp, M_SEGMENT); ! 1074: } ! 1075: ! 1076: /* ! 1077: * Shellsort (diminishing increment sort) from Data Structures and ! 1078: * Algorithms, Aho, Hopcraft and Ullman, 1983 Edition, page 290; ! 1079: * see also Knuth Vol. 3, page 84. The increments are selected from ! 1080: * formula (8), page 95. Roughly O(N^3/2). ! 1081: */ ! 1082: /* ! 1083: * This is our own private copy of shellsort because we want to sort ! 1084: * two parallel arrays (the array of buffer pointers and the array of ! 1085: * logical block numbers) simultaneously. Note that we cast the array ! 1086: * of logical block numbers to a unsigned in this routine so that the ! 1087: * negative block numbers (meta data blocks) sort AFTER the data blocks. ! 1088: */ ! 1089: void ! 1090: lfs_shellsort(bp_array, lb_array, nmemb) ! 1091: struct buf **bp_array; ! 1092: daddr_t *lb_array; ! 1093: register int nmemb; ! 1094: { ! 1095: static int __rsshell_increments[] = { 4, 1, 0 }; ! 1096: register int incr, *incrp, t1, t2; ! 1097: struct buf *bp_temp; ! 1098: u_long lb_temp; ! 1099: ! 1100: for (incrp = __rsshell_increments; incr = *incrp++;) ! 1101: for (t1 = incr; t1 < nmemb; ++t1) ! 1102: for (t2 = t1 - incr; t2 >= 0;) ! 1103: if (lb_array[t2] > lb_array[t2 + incr]) { ! 1104: lb_temp = lb_array[t2]; ! 1105: lb_array[t2] = lb_array[t2 + incr]; ! 1106: lb_array[t2 + incr] = lb_temp; ! 1107: bp_temp = bp_array[t2]; ! 1108: bp_array[t2] = bp_array[t2 + incr]; ! 1109: bp_array[t2 + incr] = bp_temp; ! 1110: t2 -= incr; ! 1111: } else ! 1112: break; ! 1113: } ! 1114: ! 1115: /* ! 1116: * Check VXLOCK. Return 1 if the vnode is locked. Otherwise, vget it. ! 1117: */ ! 1118: lfs_vref(vp) ! 1119: register struct vnode *vp; ! 1120: { ! 1121: ! 1122: if (vp->v_flag & VXLOCK) ! 1123: return(1); ! 1124: return (vget(vp, 0)); ! 1125: } ! 1126: ! 1127: void ! 1128: lfs_vunref(vp) ! 1129: register struct vnode *vp; ! 1130: { ! 1131: extern int lfs_no_inactive; ! 1132: ! 1133: /* ! 1134: * This is vrele except that we do not want to VOP_INACTIVE ! 1135: * this vnode. Rather than inline vrele here, we use a global ! 1136: * flag to tell lfs_inactive not to run. Yes, its gross. ! 1137: */ ! 1138: lfs_no_inactive = 1; ! 1139: vrele(vp); ! 1140: lfs_no_inactive = 0; ! 1141: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.