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