[apple/xnu.git] / bsd / vfs / vfs_bio.c

/*
 * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*-
 * Copyright (c) 1994 Christopher G. Demetriou
 * Copyright (c) 1982, 1986, 1989, 1993
 *      The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * All or some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
 * the permission of UNIX System Laboratories, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The NEXTSTEP Software License Agreement specifies the terms
 * and conditions for redistribution.
 *
 *      @(#)vfs_bio.c   8.6 (Berkeley) 1/11/94
 */

/*
 * Some references:
 *      Bach: The Design of the UNIX Operating System (Prentice Hall, 1986)
 *      Leffler, et al.: The Design and Implementation of the 4.3BSD
 *              UNIX Operating System (Addison Welley, 1989)
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/vnode.h>
#include <sys/mount.h>
#include <sys/trace.h>
#include <sys/malloc.h>
#include <sys/resourcevar.h>
#include <miscfs/specfs/specdev.h>
#include <sys/ubc.h>
#include <vm/vm_pageout.h>
#if DIAGNOSTIC
#include <kern/assert.h>
#endif /* DIAGNOSTIC */
#include <kern/task.h>
#include <kern/zalloc.h>

#include <sys/kdebug.h>
#include <machine/spl.h>

static __inline__ void bufqinc(int q);
static __inline__ void bufqdec(int q);

static struct buf *getnewbuf(int slpflag, int slptimeo, int *queue);
static int bcleanbuf(struct buf *bp);
extern void vwakeup();

extern int niobuf;      /* The number of IO buffer headers for cluster IO */
int blaundrycnt;

/* zone allocated buffer headers */
static zone_t buf_hdr_zone;
static int buf_hdr_count;

#if TRACE
struct  proc *traceproc;
int     tracewhich, tracebuf[TRCSIZ];
u_int   tracex;
char    traceflags[TR_NFLAGS];
#endif /* TRACE */

/*
 * Definitions for the buffer hash lists.
 */
#define BUFHASH(dvp, lbn)       \
        (&bufhashtbl[((long)(dvp) / sizeof(*(dvp)) + (int)(lbn)) & bufhash])
LIST_HEAD(bufhashhdr, buf) *bufhashtbl, invalhash;
u_long  bufhash;

/* Definitions for the buffer stats. */
struct bufstats bufstats;

/* Number of delayed write buffers */
int nbdwrite = 0;

/*
 * Insq/Remq for the buffer hash lists.
 */
#if 0
#define binshash(bp, dp)        LIST_INSERT_HEAD(dp, bp, b_hash)
#define bremhash(bp)            LIST_REMOVE(bp, b_hash)
#endif /* 0 */


TAILQ_HEAD(ioqueue, buf) iobufqueue;
TAILQ_HEAD(bqueues, buf) bufqueues[BQUEUES];
static int needbuffer;
static int need_iobuffer;

/*
 * Insq/Remq for the buffer free lists.
 */
#define binsheadfree(bp, dp, whichq)    do { \
                                    TAILQ_INSERT_HEAD(dp, bp, b_freelist); \
                                        bufqinc((whichq));      \
                                        (bp)->b_whichq = whichq; \
                                    (bp)->b_timestamp = time.tv_sec; \
                                } while (0)

#define binstailfree(bp, dp, whichq)    do { \
                                    TAILQ_INSERT_TAIL(dp, bp, b_freelist); \
                                        bufqinc((whichq));      \
                                        (bp)->b_whichq = whichq; \
                                    (bp)->b_timestamp = time.tv_sec; \
                                } while (0)

#define BHASHENTCHECK(bp)       \
        if ((bp)->b_hash.le_prev != (struct buf **)0xdeadbeef)  \
                panic("%x: b_hash.le_prev is not deadbeef", (bp));

#define BLISTNONE(bp)   \
        (bp)->b_hash.le_next = (struct buf *)0; \
        (bp)->b_hash.le_prev = (struct buf **)0xdeadbeef;

/*
 * Insq/Remq for the vnode usage lists.
 */
#define bufinsvn(bp, dp)        LIST_INSERT_HEAD(dp, bp, b_vnbufs)
#define bufremvn(bp) {                                                  \
        LIST_REMOVE(bp, b_vnbufs);                                      \
        (bp)->b_vnbufs.le_next = NOLIST;                                \
}

simple_lock_data_t bufhashlist_slock;           /* lock on buffer hash list */

/* number of per vnode, "in flight" buffer writes */
#define BUFWRITE_THROTTLE       9


/*
 * Time in seconds before a buffer on a list is 
 * considered as a stale buffer 
 */
#define LRU_IS_STALE 120 /* default value for the LRU */
#define AGE_IS_STALE 60  /* default value for the AGE */
#define META_IS_STALE 180 /* default value for the BQ_META */

int lru_is_stale = LRU_IS_STALE;
int age_is_stale = AGE_IS_STALE;
int meta_is_stale = META_IS_STALE;

/* LIST_INSERT_HEAD() with assertions */
static __inline__ void
blistenterhead(struct bufhashhdr * head, struct buf * bp)
{
        if ((bp->b_hash.le_next = (head)->lh_first) != NULL)
                (head)->lh_first->b_hash.le_prev = &(bp)->b_hash.le_next;
        (head)->lh_first = bp;
        bp->b_hash.le_prev = &(head)->lh_first;
        if (bp->b_hash.le_prev == (struct buf **)0xdeadbeef) 
                panic("blistenterhead: le_prev is deadbeef");
}

static __inline__ void 
binshash(struct buf *bp, struct bufhashhdr *dp)
{
        struct buf *nbp;

        simple_lock(&bufhashlist_slock);

#if 0
        if((bad = incore(bp->b_vp, bp->b_lblkno)))
                panic("binshash: already incore bp 0x%x, bad 0x%x\n", bp, bad);
#endif /* 0 */

        BHASHENTCHECK(bp);

        nbp = dp->lh_first;
        for(; nbp != NULL; nbp = nbp->b_hash.le_next) {
                if(nbp == bp) 
                        panic("buf already in hashlist");
        }

        blistenterhead(dp, bp);
        simple_unlock(&bufhashlist_slock);
}

static __inline__ void 
bremhash(struct buf *bp) 
{
        simple_lock(&bufhashlist_slock);
        if (bp->b_hash.le_prev == (struct buf **)0xdeadbeef) 
                panic("bremhash le_prev is deadbeef");
        if (bp->b_hash.le_next == bp) 
                panic("bremhash: next points to self");

        if (bp->b_hash.le_next != NULL)
                bp->b_hash.le_next->b_hash.le_prev = bp->b_hash.le_prev;
        *bp->b_hash.le_prev = (bp)->b_hash.le_next;
        simple_unlock(&bufhashlist_slock);
}

/*
 * Remove a buffer from the free list it's on
 */
void
bremfree(bp)
        struct buf *bp;
{
        struct bqueues *dp = NULL;
        int whichq = -1;

        /*
         * We only calculate the head of the freelist when removing
         * the last element of the list as that is the only time that
         * it is needed (e.g. to reset the tail pointer).
         *
         * NB: This makes an assumption about how tailq's are implemented.
         */
        if (bp->b_freelist.tqe_next == NULL) {
                for (dp = bufqueues; dp < &bufqueues[BQUEUES]; dp++)
                        if (dp->tqh_last == &bp->b_freelist.tqe_next)
                                break;
                if (dp == &bufqueues[BQUEUES])
                        panic("bremfree: lost tail");
        }
        TAILQ_REMOVE(dp, bp, b_freelist);
        whichq = bp->b_whichq;
        bufqdec(whichq);
        bp->b_whichq = -1;
        bp->b_timestamp = 0; 
}

/*
 * Associate a buffer with a vnode.
 */
static void
bgetvp(vp, bp)
        register struct vnode *vp;
        register struct buf *bp;
{

        if (bp->b_vp != vp)
                panic("bgetvp: not free");
        VHOLD(vp);
        bp->b_vp = vp;
        if (vp->v_type == VBLK || vp->v_type == VCHR)
                bp->b_dev = vp->v_rdev;
        else
                bp->b_dev = NODEV;
        /*
         * Insert onto list for new vnode.
         */
        bufinsvn(bp, &vp->v_cleanblkhd);
}

/*
 * Disassociate a buffer from a vnode.
 */
static void
brelvp(bp)
        register struct buf *bp;
{
        struct vnode *vp;

        if (bp->b_vp == (struct vnode *) 0)
                panic("brelvp: NULL vp");
        /*
         * Delete from old vnode list, if on one.
         */
        if (bp->b_vnbufs.le_next != NOLIST)
                bufremvn(bp);
        vp = bp->b_vp;
        bp->b_vp = (struct vnode *) 0;
        HOLDRELE(vp);
}

/*
 * Reassign a buffer from one vnode to another.
 * Used to assign file specific control information
 * (indirect blocks) to the vnode to which they belong.
 */
void
reassignbuf(bp, newvp)
        register struct buf *bp;
        register struct vnode *newvp;
{
        register struct buflists *listheadp;

        if (newvp == NULL) {
                printf("reassignbuf: NULL");
                return;
        }
        /*
         * Delete from old vnode list, if on one.
         */
        if (bp->b_vnbufs.le_next != NOLIST)
                bufremvn(bp);
        /*
         * If dirty, put on list of dirty buffers;
         * otherwise insert onto list of clean buffers.
         */
        if (ISSET(bp->b_flags, B_DELWRI))
                listheadp = &newvp->v_dirtyblkhd;
        else
                listheadp = &newvp->v_cleanblkhd;
        bufinsvn(bp, listheadp);
}

static __inline__ void
bufhdrinit(struct buf *bp)
{
        bzero((char *)bp, sizeof *bp);
        bp->b_dev = NODEV;
        bp->b_rcred = NOCRED;
        bp->b_wcred = NOCRED;
        bp->b_vnbufs.le_next = NOLIST;
        bp->b_flags = B_INVAL;

        return;
}

/*
 * Initialize buffers and hash links for buffers.
 */
__private_extern__ void
bufinit()
{
        register struct buf *bp;
        register struct bqueues *dp;
        register int i;
        int metabuf;
        long whichq;
        static void bufzoneinit();
        static void bcleanbuf_thread_init();

        /* Initialize the buffer queues ('freelists') and the hash table */
        for (dp = bufqueues; dp < &bufqueues[BQUEUES]; dp++)
                TAILQ_INIT(dp);
        bufhashtbl = hashinit(nbuf, M_CACHE, &bufhash);

        simple_lock_init(&bufhashlist_slock );

        metabuf = nbuf/8; /* reserved for meta buf */

        /* Initialize the buffer headers */
        for (i = 0; i < nbuf; i++) {
                bp = &buf[i];
                bufhdrinit(bp);

                /*
                 * metabuf buffer headers on the meta-data list and
                 * rest of the buffer headers on the empty list
                 */
                if (--metabuf) 
                        whichq = BQ_META;
                else 
                        whichq = BQ_EMPTY;

                BLISTNONE(bp);
                dp = &bufqueues[whichq];
                binsheadfree(bp, dp, whichq);
                binshash(bp, &invalhash);
        }

        for (; i < nbuf + niobuf; i++) {
                bp = &buf[i];
                bufhdrinit(bp);
                binsheadfree(bp, &iobufqueue, -1);
        }

        printf("using %d buffer headers and %d cluster IO buffer headers\n",
                nbuf, niobuf);

        /* Set up zones used by the buffer cache */
        bufzoneinit();

        /* start the bcleanbuf() thread */
        bcleanbuf_thread_init();

#if 0   /* notyet */
        {
        static void bufq_balance_thread_init();
        /* create a thread to do dynamic buffer queue balancing */
        bufq_balance_thread_init();
        }
#endif /* notyet */
}

static struct buf *
bio_doread(vp, blkno, size, cred, async, queuetype)
        struct vnode *vp;
        daddr_t blkno;
        int size;
        struct ucred *cred;
        int async;
        int queuetype;
{
        register struct buf *bp;
        struct proc     *p = current_proc();

        bp = getblk(vp, blkno, size, 0, 0, queuetype);

        /*
         * If buffer does not have data valid, start a read.
         * Note that if buffer is B_INVAL, getblk() won't return it.
         * Therefore, it's valid if it's I/O has completed or been delayed.
         */
        if (!ISSET(bp->b_flags, (B_DONE | B_DELWRI))) {
                /* Start I/O for the buffer (keeping credentials). */
                SET(bp->b_flags, B_READ | async);
                if (cred != NOCRED && bp->b_rcred == NOCRED) {
                        /*
                         * NFS has embedded ucred.
                         * Can not crhold() here as that causes zone corruption
                         */
                        bp->b_rcred = crdup(cred);
                }

                VOP_STRATEGY(bp);

                trace(TR_BREADMISS, pack(vp, size), blkno);

                /* Pay for the read. */
                if (p && p->p_stats) 
                        p->p_stats->p_ru.ru_inblock++;          /* XXX */
        } else if (async) {
                brelse(bp);
        }

        trace(TR_BREADHIT, pack(vp, size), blkno);

        return (bp);
}
/*
 * Read a disk block.
 * This algorithm described in Bach (p.54).
 */
int
bread(vp, blkno, size, cred, bpp)
        struct vnode *vp;
        daddr_t blkno;
        int size;
        struct ucred *cred;
        struct buf **bpp;
{
        register struct buf *bp;

        /* Get buffer for block. */
        bp = *bpp = bio_doread(vp, blkno, size, cred, 0, BLK_READ);

        /* Wait for the read to complete, and return result. */
        return (biowait(bp));
}

/*
 * Read a disk block. [bread() for meta-data]
 * This algorithm described in Bach (p.54).
 */
int
meta_bread(vp, blkno, size, cred, bpp)
        struct vnode *vp;
        daddr_t blkno;
        int size;
        struct ucred *cred;
        struct buf **bpp;
{
        register struct buf *bp;

        /* Get buffer for block. */
        bp = *bpp = bio_doread(vp, blkno, size, cred, 0, BLK_META);

        /* Wait for the read to complete, and return result. */
        return (biowait(bp));
}

/*
 * Read-ahead multiple disk blocks. The first is sync, the rest async.
 * Trivial modification to the breada algorithm presented in Bach (p.55).
 */
int
breadn(vp, blkno, size, rablks, rasizes, nrablks, cred, bpp)
        struct vnode *vp;
        daddr_t blkno; int size;
        daddr_t rablks[]; int rasizes[];
        int nrablks;
        struct ucred *cred;
        struct buf **bpp;
{
        register struct buf *bp;
        int i;

        bp = *bpp = bio_doread(vp, blkno, size, cred, 0, BLK_READ);

        /*
         * For each of the read-ahead blocks, start a read, if necessary.
         */
        for (i = 0; i < nrablks; i++) {
                /* If it's in the cache, just go on to next one. */
                if (incore(vp, rablks[i]))
                        continue;

                /* Get a buffer for the read-ahead block */
                (void) bio_doread(vp, rablks[i], rasizes[i], cred, B_ASYNC, BLK_READ);
        }

        /* Otherwise, we had to start a read for it; wait until it's valid. */
        return (biowait(bp));
}

/*
 * Read with single-block read-ahead.  Defined in Bach (p.55), but
 * implemented as a call to breadn().
 * XXX for compatibility with old file systems.
 */
int
breada(vp, blkno, size, rablkno, rabsize, cred, bpp)
        struct vnode *vp;
        daddr_t blkno; int size;
        daddr_t rablkno; int rabsize;
        struct ucred *cred;
        struct buf **bpp;
{

        return (breadn(vp, blkno, size, &rablkno, &rabsize, 1, cred, bpp));     
}

/*
 * Block write.  Described in Bach (p.56)
 */
int
bwrite(bp)
        struct buf *bp;
{
        int rv, sync, wasdelayed;
        struct proc     *p = current_proc();
        struct vnode *vp = bp->b_vp;

        /* Remember buffer type, to switch on it later. */
        sync = !ISSET(bp->b_flags, B_ASYNC);
        wasdelayed = ISSET(bp->b_flags, B_DELWRI);
        CLR(bp->b_flags, (B_READ | B_DONE | B_ERROR | B_DELWRI));
        if (wasdelayed) {
                nbdwrite--;
                wakeup((caddr_t)&nbdwrite);
        }

        if (!sync) {
                /*
                 * If not synchronous, pay for the I/O operation and make
                 * sure the buf is on the correct vnode queue.  We have
                 * to do this now, because if we don't, the vnode may not
                 * be properly notified that its I/O has completed.
                 */
                if (wasdelayed)
                        reassignbuf(bp, vp);
                else
                if (p && p->p_stats) 
                        p->p_stats->p_ru.ru_oublock++;          /* XXX */
        }

        trace(TR_BUFWRITE, pack(vp, bp->b_bcount), bp->b_lblkno);

        /* Initiate disk write.  Make sure the appropriate party is charged. */
        SET(bp->b_flags, B_WRITEINPROG);
        vp->v_numoutput++;
        
        VOP_STRATEGY(bp);

        if (sync) {
                /*
                 * If I/O was synchronous, wait for it to complete.
                 */
                rv = biowait(bp);

                /*
                 * Pay for the I/O operation, if it's not been paid for, and
                 * make sure it's on the correct vnode queue. (async operatings
                 * were payed for above.)
                 */
                if (wasdelayed)
                        reassignbuf(bp, vp);
                else
                if (p && p->p_stats) 
                        p->p_stats->p_ru.ru_oublock++;          /* XXX */

                /* Release the buffer. */
                // XXXdbg - only if the unused bit is set
                if (!ISSET(bp->b_flags, B_NORELSE)) {
                    brelse(bp);
                } else {
                    CLR(bp->b_flags, B_NORELSE);
                }

                return (rv);
        } else {
                return (0);
        }
}

int
vn_bwrite(ap)
        struct vop_bwrite_args *ap;
{
        return (bwrite(ap->a_bp));
}

/*
 * Delayed write.
 *
 * The buffer is marked dirty, but is not queued for I/O.
 * This routine should be used when the buffer is expected
 * to be modified again soon, typically a small write that
 * partially fills a buffer.
 *
 * NB: magnetic tapes cannot be delayed; they must be
 * written in the order that the writes are requested.
 *
 * Described in Leffler, et al. (pp. 208-213).
 *
 * Note: With the abilitty to allocate additional buffer
 * headers, we can get in to the situation where "too" many 
 * bdwrite()s can create situation where the kernel can create
 * buffers faster than the disks can service. Doing a bawrite() in
 * cases were we have "too many" outstanding bdwrite()s avoids that.
 */
__private_extern__ int
bdwrite_internal(bp, return_error)
        struct buf *bp;
        int return_error;
{
        struct proc *p = current_proc();
        struct vnode *vp = bp->b_vp;

        /*
         * If the block hasn't been seen before:
         *      (1) Mark it as having been seen,
         *      (2) Charge for the write.
         *      (3) Make sure it's on its vnode's correct block list,
         */
        if (!ISSET(bp->b_flags, B_DELWRI)) {
                SET(bp->b_flags, B_DELWRI);
                if (p && p->p_stats) 
                        p->p_stats->p_ru.ru_oublock++;          /* XXX */
                nbdwrite ++;
                reassignbuf(bp, vp);
        }

        /* If this is a tape block, write it the block now. */
        if (ISSET(bp->b_flags, B_TAPE)) {
                /* bwrite(bp); */
                VOP_BWRITE(bp);
                return (0);
        }

        /*
         * If the vnode has "too many" write operations in progress
         * wait for them to finish the IO
         */
        while (vp->v_numoutput >= BUFWRITE_THROTTLE) {
                vp->v_flag |= VTHROTTLED;
                (void)tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "bdwrite", 0);
        }

        /*
         * If we have too many delayed write buffers, 
         * more than we can "safely" handle, just fall back to
         * doing the async write
         */
        if (nbdwrite < 0)
                panic("bdwrite: Negative nbdwrite");

        // can't do a bawrite() if the LOCKED bit is set because the
        // buffer is part of a transaction and can't go to disk until
        // the LOCKED bit is cleared.
        if (!ISSET(bp->b_flags, B_LOCKED) && nbdwrite > ((nbuf/4)*3)) {
                if (return_error)
                        return (EAGAIN);
                else
                        bawrite(bp);
                return (0);
        }
         
        /* Otherwise, the "write" is done, so mark and release the buffer. */
        SET(bp->b_flags, B_DONE);
        brelse(bp);
        return (0);
}

void
bdwrite(bp)
        struct buf *bp;
{
        (void) bdwrite_internal(bp, 0);
}
 

/*
 * Asynchronous block write; just an asynchronous bwrite().
 *
 * Note: With the abilitty to allocate additional buffer
 * headers, we can get in to the situation where "too" many 
 * bawrite()s can create situation where the kernel can create
 * buffers faster than the disks can service.
 * We limit the number of "in flight" writes a vnode can have to
 * avoid this.
 */
static int
bawrite_internal(bp, throttle)
        struct buf *bp;
        int throttle;
{
        struct vnode *vp = bp->b_vp;

        if (vp) {
                /*
                 * If the vnode has "too many" write operations in progress
                 * wait for them to finish the IO
                 */
                while (vp->v_numoutput >= BUFWRITE_THROTTLE) {
                        if (throttle) {
                                vp->v_flag |= VTHROTTLED;
                                (void)tsleep((caddr_t)&vp->v_numoutput,
                                                PRIBIO + 1, "bawrite", 0);
                        } else
                                return (EWOULDBLOCK);
                }
        }

        SET(bp->b_flags, B_ASYNC);
        VOP_BWRITE(bp);
        return (0);
}

void
bawrite(bp)
        struct buf *bp;
{
        (void) bawrite_internal(bp, 1);
}

/* 
 *      bwillwrite:
 * 
 *      Called prior to the locking of any vnodes when we are expecting to
 *      write.  We do not want to starve the buffer cache with too many
 *      dirty buffers so we block here.  By blocking prior to the locking
 *      of any vnodes we attempt to avoid the situation where a locked vnode
 *      prevents the various system daemons from flushing related buffers.
 */ 
 
void 
bwillwrite(void) 
{
        /* XXX To be implemented later */
}

/*
 * Release a buffer on to the free lists.
 * Described in Bach (p. 46).
 */
void
brelse(bp)
        struct buf *bp;
{
        struct bqueues *bufq;
        int s;
        long whichq;

        KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 388)) | DBG_FUNC_START,
                     bp->b_lblkno * PAGE_SIZE, (int)bp, (int)bp->b_data,
                     bp->b_flags, 0);

        trace(TR_BRELSE, pack(bp->b_vp, bp->b_bufsize), bp->b_lblkno);

        // if we're invalidating a buffer that has the B_CALL bit
        // set then call the b_iodone function so it gets cleaned
        // up properly.
        //
        if (ISSET(bp->b_flags, B_META) && ISSET(bp->b_flags, B_INVAL)) {
                if (ISSET(bp->b_flags, B_CALL) && !ISSET(bp->b_flags, B_DELWRI)) {
                        panic("brelse: CALL flag set but not DELWRI! bp 0x%x\n", bp);
                }
                if (ISSET(bp->b_flags, B_CALL)) {       /* if necessary, call out */
                        void    (*iodone_func)(struct buf *) = bp->b_iodone;

                        CLR(bp->b_flags, B_CALL);       /* but note callout done */
                        bp->b_iodone = NULL;

                        if (iodone_func == NULL) {
                                panic("brelse: bp @ 0x%x has NULL b_iodone!\n", bp);
                        }
                        (*iodone_func)(bp);
                }
        }
        
        /* IO is done. Cleanup the UPL state */
        if (!ISSET(bp->b_flags, B_META)
                && UBCINFOEXISTS(bp->b_vp) && bp->b_bufsize) {
                kern_return_t kret;
                upl_t         upl;
                int           upl_flags;

                if ( !ISSET(bp->b_flags, B_PAGELIST)) {
                        if ( !ISSET(bp->b_flags, B_INVAL)) {
                                kret = ubc_create_upl(bp->b_vp, 
                                                                ubc_blktooff(bp->b_vp, bp->b_lblkno),
                                                                bp->b_bufsize, 
                                                            &upl,
                                                                NULL,
                                                                UPL_PRECIOUS);
                                if (kret != KERN_SUCCESS)
                                        panic("brelse: Failed to get pagelists");
#ifdef  UBC_DEBUG
                                upl_ubc_alias_set(upl, bp, 5);
#endif /* UBC_DEBUG */
                        } else
                                upl = (upl_t) 0;
                } else {
                        upl = bp->b_pagelist;
                        kret = ubc_upl_unmap(upl);

                        if (kret != KERN_SUCCESS)
                                panic("kernel_upl_unmap failed");
                        bp->b_data = 0;
                }
                if (upl) {
                        if (bp->b_flags & (B_ERROR | B_INVAL)) {
                            if (bp->b_flags & (B_READ | B_INVAL))
                                        upl_flags = UPL_ABORT_DUMP_PAGES;
                                else
                                        upl_flags = 0;
                                ubc_upl_abort(upl, upl_flags);
                        } else {
                            if (ISSET(bp->b_flags, B_NEEDCOMMIT))
                                    upl_flags = UPL_COMMIT_CLEAR_DIRTY ;
                            else if (ISSET(bp->b_flags, B_DELWRI | B_WASDIRTY))
                                        upl_flags = UPL_COMMIT_SET_DIRTY ;
                                else
                                    upl_flags = UPL_COMMIT_CLEAR_DIRTY ;
                                ubc_upl_commit_range(upl, 0, bp->b_bufsize, upl_flags |
                                        UPL_COMMIT_INACTIVATE | UPL_COMMIT_FREE_ON_EMPTY);
                        }
                        s = splbio();
                        CLR(bp->b_flags, B_PAGELIST);
                        bp->b_pagelist = 0;
                        splx(s);
                }
        } else {
                if(ISSET(bp->b_flags, B_PAGELIST))
                        panic("brelse: pagelist set for non VREG; vp=%x", bp->b_vp);
        }       

        /* Wake up any processes waiting for any buffer to become free. */
        if (needbuffer) {
                needbuffer = 0;
                wakeup(&needbuffer);
        }

        /* Wake up any proceeses waiting for _this_ buffer to become free. */
        if (ISSET(bp->b_flags, B_WANTED)) {
                CLR(bp->b_flags, B_WANTED);
                wakeup(bp);
        }

        /* Block disk interrupts. */
        s = splbio();

        /*
         * Determine which queue the buffer should be on, then put it there.
         */

        /* If it's locked, don't report an error; try again later. */
        if (ISSET(bp->b_flags, (B_LOCKED|B_ERROR)) == (B_LOCKED|B_ERROR))
                CLR(bp->b_flags, B_ERROR);

        /* If it's not cacheable, or an error, mark it invalid. */
        if (ISSET(bp->b_flags, (B_NOCACHE|B_ERROR)))
                SET(bp->b_flags, B_INVAL);

        if ((bp->b_bufsize <= 0) || ISSET(bp->b_flags, B_INVAL)) {
                /*
                 * If it's invalid or empty, dissociate it from its vnode
                 * and put on the head of the appropriate queue.
                 */
                if (bp->b_vp)
                        brelvp(bp);
                if (ISSET(bp->b_flags, B_DELWRI)) {
                        CLR(bp->b_flags, B_DELWRI);
                        nbdwrite--;
                        wakeup((caddr_t)&nbdwrite);
                }
                if (bp->b_bufsize <= 0)
                        whichq = BQ_EMPTY;      /* no data */
                else if (ISSET(bp->b_flags, B_META))
                        whichq = BQ_META;               /* meta-data */
                else
                        whichq = BQ_AGE;        /* invalid data */

                bufq = &bufqueues[whichq];
                binsheadfree(bp, bufq, whichq);
        } else {
                /*
                 * It has valid data.  Put it on the end of the appropriate
                 * queue, so that it'll stick around for as long as possible.
                 */
                if (ISSET(bp->b_flags, B_LOCKED))
                        whichq = BQ_LOCKED;             /* locked in core */
                else if (ISSET(bp->b_flags, B_META))
                        whichq = BQ_META;               /* meta-data */
                else if (ISSET(bp->b_flags, B_AGE))
                        whichq = BQ_AGE;                /* stale but valid data */
                else
                        whichq = BQ_LRU;                /* valid data */

                bufq = &bufqueues[whichq];
                binstailfree(bp, bufq, whichq);
        }

        /* Unlock the buffer. */
        CLR(bp->b_flags, (B_AGE | B_ASYNC | B_BUSY | B_NOCACHE));

        /* Allow disk interrupts. */
        splx(s);

        KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 388)) | DBG_FUNC_END,
                     (int)bp, (int)bp->b_data, bp->b_flags, 0, 0);
}

/*
 * Determine if a block is in the cache.
 * Just look on what would be its hash chain.  If it's there, return
 * a pointer to it, unless it's marked invalid.  If it's marked invalid,
 * we normally don't return the buffer, unless the caller explicitly
 * wants us to.
 */
struct buf *
incore(vp, blkno)
        struct vnode *vp;
        daddr_t blkno;
{
        struct buf *bp;

        bp = BUFHASH(vp, blkno)->lh_first;

        /* Search hash chain */
        for (; bp != NULL; bp = bp->b_hash.le_next) {
                if (bp->b_lblkno == blkno && bp->b_vp == vp &&
                    !ISSET(bp->b_flags, B_INVAL))
                        return (bp);
        }

        return (0);
}


/* XXX FIXME -- Update the comment to reflect the UBC changes (please) -- */
/*
 * Get a block of requested size that is associated with
 * a given vnode and block offset. If it is found in the
 * block cache, mark it as having been found, make it busy
 * and return it. Otherwise, return an empty block of the
 * correct size. It is up to the caller to insure that the
 * cached blocks be of the correct size.
 */
struct buf *
getblk(vp, blkno, size, slpflag, slptimeo, operation)
        register struct vnode *vp;
        daddr_t blkno;
        int size, slpflag, slptimeo, operation;
{
        struct buf *bp;
        int s, err;
        upl_t upl;
        upl_page_info_t *pl;
        kern_return_t kret;
        int error=0;
        int pagedirty = 0;

        KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 386)) | DBG_FUNC_START,
                     blkno * PAGE_SIZE, size, operation, 0, 0);
start:

        s = splbio();
        if ((bp = incore(vp, blkno))) {
                /* Found in the Buffer Cache */
                if (ISSET(bp->b_flags, B_BUSY)) {
                        /* but is busy */
                        switch (operation) {
                        case BLK_READ:
                        case BLK_WRITE:
                        case BLK_META:
                                SET(bp->b_flags, B_WANTED);
                                bufstats.bufs_busyincore++;
                                err = tsleep(bp, slpflag | (PRIBIO + 1), "getblk",
                                    slptimeo);
                                splx(s);
                                /*
                                 * Callers who call with PCATCH or timeout are
                                 * willing to deal with the NULL pointer
                                 */
                                if (err && ((slpflag & PCATCH) || 
                                                         ((err == EWOULDBLOCK) && slptimeo)))
                                        return (NULL);
                                goto start;
                                /*NOTREACHED*/
                                break;

                        case BLK_PAGEIN:
                                /* pagein operation must not use getblk */
                                panic("getblk: pagein for incore busy buffer");
                                splx(s);
                                /*NOTREACHED*/
                                break;

                        case BLK_PAGEOUT:
                                /* pageout operation must not use getblk */
                                panic("getblk: pageout for incore busy buffer");
                                splx(s);
                                /*NOTREACHED*/
                                break;

                        default:
                                panic("getblk: %d unknown operation 1", operation);
                                /*NOTREACHED*/
                                break;
                        }               
                } else {
                        /* not busy */
                        SET(bp->b_flags, (B_BUSY | B_CACHE));
                        bremfree(bp);
                        bufstats.bufs_incore++;
                        splx(s);

                        allocbuf(bp, size);
                        if (ISSET(bp->b_flags, B_PAGELIST))
                                        panic("pagelist buffer is not busy");

                        switch (operation) {
                        case BLK_READ:
                        case BLK_WRITE:
                                if (UBCISVALID(bp->b_vp) && bp->b_bufsize) {
                                        kret = ubc_create_upl(vp,
                                                                        ubc_blktooff(vp, bp->b_lblkno), 
                                                                        bp->b_bufsize, 
                                                                        &upl, 
                                                                        &pl,
                                                                        UPL_PRECIOUS);
                                        if (kret != KERN_SUCCESS)
                                                panic("Failed to get pagelists");

                                        SET(bp->b_flags, B_PAGELIST);
                                        bp->b_pagelist = upl;

                                        if (!upl_valid_page(pl, 0)) {
                                                if (vp->v_tag != VT_NFS)
                                                        panic("getblk: incore buffer without valid page");
                                                CLR(bp->b_flags, B_CACHE);
                                        }

                                        if (upl_dirty_page(pl, 0))
                                                SET(bp->b_flags, B_WASDIRTY);
                                        else
                                                CLR(bp->b_flags, B_WASDIRTY);

                                        kret = ubc_upl_map(upl, (vm_address_t *)&(bp->b_data));
                                        if (kret != KERN_SUCCESS)
                                                panic("getblk: ubc_upl_map() failed with (%d)",
                                                                  kret);
                                        if (bp->b_data == 0)
                                                panic("ubc_upl_map mapped 0");
                                }
                                break;

                        case BLK_META:
                                /*
                                 * VM is not involved in IO for the meta data
                                 * buffer already has valid data 
                                 */
                                if(bp->b_data == 0)
                                        panic("bp->b_data null incore buf=%x", bp);
                                break;

                        case BLK_PAGEIN:
                        case BLK_PAGEOUT:
                                panic("getblk: paging operation 1");
                                break;

                        default:
                                panic("getblk: %d unknown operation 2", operation);
                                /*NOTREACHED*/
                                break;
                        }
                }
        } else { /* not incore() */
                int queue = BQ_EMPTY; /* Start with no preference */
                splx(s);
                
                if ((operation == BLK_META) || (UBCINVALID(vp)) ||
                        !(UBCINFOEXISTS(vp))) {
                        operation = BLK_META;
                }
                if ((bp = getnewbuf(slpflag, slptimeo, &queue)) == NULL)
                        goto start;
                if (incore(vp, blkno)) {
                        SET(bp->b_flags, B_INVAL);
                        binshash(bp, &invalhash);
                        brelse(bp);
                        goto start;
                }
                /*
                 * NOTE: YOU CAN NOT BLOCK UNTIL binshash() HAS BEEN
                 *       CALLED!  BE CAREFUL.
                 */

                /*
                 * if it is meta, the queue may be set to other 
                 * type so reset as well as mark it to be B_META
                 * so that when buffer is released it will goto META queue
                 * Also, if the vnode is not VREG, then it is META
                 */
                if (operation == BLK_META) {
                        SET(bp->b_flags, B_META);
                        queue = BQ_META;
                }

                bp->b_blkno = bp->b_lblkno = blkno;
                bp->b_vp = vp;

                /*
                 * Insert in the hash so that incore() can find it 
                 */
                binshash(bp, BUFHASH(vp, blkno)); 

                s = splbio();
                bgetvp(vp, bp);
                splx(s);

                allocbuf(bp, size);

                switch (operation) {
                case BLK_META:
                        /* buffer data is invalid */

                        if(bp->b_data == 0)
                                panic("bp->b_data is null %x",bp);

                        bufstats.bufs_miss++;

                        /* wakeup the buffer */ 
                        CLR(bp->b_flags, B_WANTED);
                        wakeup(bp);
                        break;

                case BLK_READ:
                case BLK_WRITE:

                        if (ISSET(bp->b_flags, B_PAGELIST))
                                panic("B_PAGELIST in bp=%x",bp);

                        kret = ubc_create_upl(vp,
                                                        ubc_blktooff(vp, blkno),
                                                        bp->b_bufsize, 
                                                        &upl,
                                                        &pl,
                                                        UPL_PRECIOUS);
                        if (kret != KERN_SUCCESS)
                                panic("Failed to get pagelists");

#ifdef  UBC_DEBUG
                        upl_ubc_alias_set(upl, bp, 4);
#endif /* UBC_DEBUG */
                        bp->b_pagelist = upl;

                        SET(bp->b_flags, B_PAGELIST);

                        if (upl_valid_page(pl, 0)) {
                                SET(bp->b_flags, B_CACHE | B_DONE);
                                bufstats.bufs_vmhits++;

                                pagedirty = upl_dirty_page(pl, 0);

                                if (pagedirty)
                                        SET(bp->b_flags, B_WASDIRTY);

                                if (vp->v_tag == VT_NFS) {
                                        off_t  f_offset;
                                        int    valid_size;

                                        bp->b_validoff = 0;
                                        bp->b_dirtyoff = 0;

                                        f_offset = ubc_blktooff(vp, blkno);

                                        if (f_offset > vp->v_ubcinfo->ui_size) {
                                                CLR(bp->b_flags, (B_CACHE|B_DONE|B_WASDIRTY));
                                                bp->b_validend = 0;
                                                bp->b_dirtyend = 0;
                                        } else {
                                                valid_size = min(((unsigned int)(vp->v_ubcinfo->ui_size - f_offset)), PAGE_SIZE);
                                                bp->b_validend = valid_size;

                                                if (pagedirty)
                                                       bp->b_dirtyend = valid_size;
                                                else
                                                       bp->b_dirtyend = 0;

                                                KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 386)) | DBG_FUNC_NONE,
                                                             bp->b_validend, bp->b_dirtyend, 
                                                             (int)vp->v_ubcinfo->ui_size, 0, 0);
                                        }
                                } else {
                                        bp->b_validoff = 0;
                                        bp->b_dirtyoff = 0;

                                        if (pagedirty) {
                                                /* page is dirty */
                                                bp->b_validend = bp->b_bcount;
                                                bp->b_dirtyend = bp->b_bcount;
                                        } else {
                                                /* page is clean */
                                                bp->b_validend = bp->b_bcount;
                                                bp->b_dirtyend = 0;
                                        }
                                }
                                error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
                                if(error) {
                                        panic("getblk: VOP_BMAP failed");
                                        /*NOTREACHED*/
                                        /*
                                         * XXX:  We probably should invalidate the VM Page
                                         */
                                        bp->b_error = error;
                                        SET(bp->b_flags, (B_ERROR | B_INVAL));
                                        /* undo B_DONE that was set before upl_commit() */
                                        CLR(bp->b_flags, B_DONE);
                                        brelse(bp);
                                        return (0);
                                }
                        } else {
                                bufstats.bufs_miss++;
                        }
                        kret = ubc_upl_map(upl, (vm_address_t *)&(bp->b_data));
                        if (kret != KERN_SUCCESS) {
                                panic("getblk: ubc_upl_map() "
                                      "failed with (%d)", kret);
                        }
                        if (bp->b_data == 0)
                                panic("kernel_upl_map mapped 0");

                        break;

                case BLK_PAGEIN:
                case BLK_PAGEOUT:
                        panic("getblk: paging operation 2");
                        break;
                default:
                        panic("getblk: %d unknown operation 3", operation);
                        /*NOTREACHED*/
                        break;
                }
        }

        if (bp->b_data == NULL)
                panic("getblk: bp->b_addr is null");

        if (bp->b_bufsize & 0xfff) {
                if (ISSET(bp->b_flags, B_META) && (bp->b_bufsize & 0x1ff))
                        panic("getblk: bp->b_bufsize = %d", bp->b_bufsize);
        }

        KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 386)) | DBG_FUNC_END,
                     (int)bp, (int)bp->b_data, bp->b_flags, 3, 0);

        return (bp);
}

/*
 * Get an empty, disassociated buffer of given size.
 */
struct buf *
geteblk(size)
        int size;
{
        struct buf *bp;
    int queue = BQ_EMPTY;

        while ((bp = getnewbuf(0, 0, &queue)) == 0)
                ;
        SET(bp->b_flags, (B_META|B_INVAL));

#if DIAGNOSTIC
        assert(queue == BQ_EMPTY);
#endif /* DIAGNOSTIC */
        /* XXX need to implement logic to deal with other queues */

        binshash(bp, &invalhash);
        allocbuf(bp, size);
        bufstats.bufs_eblk++;

        return (bp);
}

/*
 * Zones for the meta data buffers
 */

#define MINMETA 512
#define MAXMETA 4096

struct meta_zone_entry {
        zone_t mz_zone;
        vm_size_t mz_size;
        vm_size_t mz_max;
        char *mz_name;
};

struct meta_zone_entry meta_zones[] = {
        {NULL, (MINMETA * 1), 128 * (MINMETA * 1), "buf.512" },
        {NULL, (MINMETA * 2),  64 * (MINMETA * 2), "buf.1024" },
        {NULL, (MINMETA * 4),  16 * (MINMETA * 4), "buf.2048" },
        {NULL, (MINMETA * 8), 512 * (MINMETA * 8), "buf.4096" },
        {NULL, 0, 0, "" } /* End */
};

/*
 * Initialize the meta data zones
 */
static void
bufzoneinit(void)
{
        int i;

        for (i = 0; meta_zones[i].mz_size != 0; i++) {
                meta_zones[i].mz_zone = 
                                zinit(meta_zones[i].mz_size,
                                        meta_zones[i].mz_max,
                                        PAGE_SIZE,
                                        meta_zones[i].mz_name);
        }
        buf_hdr_zone = zinit(sizeof(struct buf), 32, PAGE_SIZE, "buf headers");
}

static __inline__ zone_t
getbufzone(size_t size)
{
        int i;

        if ((size % 512) || (size < MINMETA) || (size > MAXMETA))
                panic("getbufzone: incorect size = %d", size);

    for (i = 0; meta_zones[i].mz_size != 0; i++) {
                if (meta_zones[i].mz_size >= size)
                        break;
        }

        return (meta_zones[i].mz_zone);
}

/*
 * With UBC, there is no need to expand / shrink the file data 
 * buffer. The VM uses the same pages, hence no waste.
 * All the file data buffers can have one size.
 * In fact expand / shrink would be an expensive operation.
 *
 * Only exception to this is meta-data buffers. Most of the
 * meta data operations are smaller than PAGE_SIZE. Having the
 * meta-data buffers grow and shrink as needed, optimizes use
 * of the kernel wired memory.
 */

int
allocbuf(bp, size)
        struct buf *bp;
        int size;
{
        vm_size_t desired_size;

        desired_size = roundup(size, CLBYTES);

        if(desired_size < PAGE_SIZE)
                desired_size = PAGE_SIZE;
        if (desired_size > MAXBSIZE)
                panic("allocbuf: buffer larger than MAXBSIZE requested");

        if (ISSET(bp->b_flags, B_META)) {
                kern_return_t kret;
                zone_t zprev, z;
                size_t nsize = roundup(size, MINMETA);

                if (bp->b_data) {
                        vm_offset_t elem = (vm_offset_t)bp->b_data;

                        if (ISSET(bp->b_flags, B_ZALLOC))
                                if (bp->b_bufsize <= MAXMETA) {
                                        if (bp->b_bufsize < nsize) {
                                                /* reallocate to a bigger size */
                                                desired_size = nsize;

                                                zprev = getbufzone(bp->b_bufsize);
                                                z = getbufzone(nsize);
                                                bp->b_data = (caddr_t)zalloc(z);
                                                if(bp->b_data == 0)
                                                        panic("allocbuf: zalloc() returned NULL");
                                                bcopy(elem, bp->b_data, bp->b_bufsize);
                                                zfree(zprev, elem);
                                        } else {
                                                desired_size = bp->b_bufsize;
                                        }
                                } else
                                        panic("allocbuf: B_ZALLOC set incorrectly");
                        else
                                if (bp->b_bufsize < desired_size) {
                                        /* reallocate to a bigger size */
                                        kret = kmem_alloc(kernel_map, &bp->b_data, desired_size);
                                        if (kret != KERN_SUCCESS)
                                                panic("allocbuf: kmem_alloc() returned %d", kret);
                                        if(bp->b_data == 0)
                                                panic("allocbuf: null b_data");
                                        bcopy(elem, bp->b_data, bp->b_bufsize);
                                        kmem_free(kernel_map, elem, bp->b_bufsize); 
                                } else {
                                        desired_size = bp->b_bufsize;
                                }
                } else {
                        /* new allocation */
                        if (nsize <= MAXMETA) {
                                desired_size = nsize;
                                z = getbufzone(nsize);
                                bp->b_data = (caddr_t)zalloc(z);
                                if(bp->b_data == 0)
                                        panic("allocbuf: zalloc() returned NULL 2");
                                SET(bp->b_flags, B_ZALLOC);
                        } else {
                                kret = kmem_alloc(kernel_map, &bp->b_data, desired_size);
                                if (kret != KERN_SUCCESS)
                                        panic("allocbuf: kmem_alloc() 2 returned %d", kret);
                                if(bp->b_data == 0)
                                        panic("allocbuf: null b_data 2");
                        }
                }
        }

        if (ISSET(bp->b_flags, B_META) && (bp->b_data == 0))
                panic("allocbuf: bp->b_data is NULL, buf @ 0x%x", bp);

        bp->b_bufsize = desired_size;
        bp->b_bcount = size;
        return (0);
}

/*
 *      Get a new buffer from one of the free lists.
 *
 *      Request for a queue is passes in. The queue from which the buffer was taken
 *      from is returned. Out of range queue requests get BQ_EMPTY. Request for
 *      BQUEUE means no preference. Use heuristics in that case.
 *      Heuristics is as follows:
 *      Try BQ_AGE, BQ_LRU, BQ_EMPTY, BQ_META in that order.
 *      If none available block till one is made available.
 *      If buffers available on both BQ_AGE and BQ_LRU, check the timestamps.
 *      Pick the most stale buffer.
 *      If found buffer was marked delayed write, start the async. write
 *      and restart the search.
 *      Initialize the fields and disassociate the buffer from the vnode.
 *      Remove the buffer from the hash. Return the buffer and the queue
 *      on which it was found.
 */

static struct buf *
getnewbuf(slpflag, slptimeo, queue)
        int slpflag, slptimeo;
        int *queue;
{
        register struct buf *bp;
        register struct buf *lru_bp;
        register struct buf *age_bp;
        register struct buf *meta_bp;
        register int age_time, lru_time, bp_time, meta_time;
        int s;
        int req = *queue; /* save it for restarts */

start:
        s = splbio();
        
        /* invalid request gets empty queue */
        if ((*queue > BQUEUES) || (*queue < 0)
                || (*queue == BQ_LAUNDRY) || (*queue == BQ_LOCKED))
                *queue = BQ_EMPTY;

        /* (*queue == BQUEUES) means no preference */
        if (*queue != BQUEUES) {
                /* Try for the requested queue first */
                bp = bufqueues[*queue].tqh_first;
                if (bp)
                        goto found;
        }

        /* Unable to use requested queue */
        age_bp = bufqueues[BQ_AGE].tqh_first;
        lru_bp = bufqueues[BQ_LRU].tqh_first;
        meta_bp = bufqueues[BQ_META].tqh_first;

        if (!age_bp && !lru_bp && !meta_bp) {
                /*
                 * Unavailble on AGE or LRU or META queues
                 * Try the empty list first
                 */
                bp = bufqueues[BQ_EMPTY].tqh_first;
                if (bp) {
                        *queue = BQ_EMPTY;
                        goto found;
                }

                /* Create a new temparory buffer header */
                bp = (struct buf *)zalloc(buf_hdr_zone);
        
                if (bp) {
                        bufhdrinit(bp);
                        BLISTNONE(bp);
                        binshash(bp, &invalhash);
                        SET(bp->b_flags, B_HDRALLOC);
                        *queue = BQ_EMPTY;
                        binsheadfree(bp, &bufqueues[BQ_EMPTY], BQ_EMPTY);
                        buf_hdr_count++;
                        goto found;
                }

                /* Log this error condition */
                printf("getnewbuf: No useful buffers");

                /* wait for a free buffer of any kind */
                needbuffer = 1;
                bufstats.bufs_sleeps++;
                tsleep(&needbuffer, slpflag|(PRIBIO+1), "getnewbuf", slptimeo);
                splx(s);
                return (0);
        }

        /* Buffer available either on AGE or LRU or META */
        bp = NULL;
        *queue = -1;

        /* Buffer available either on AGE or LRU */
        if (!age_bp) {
                bp = lru_bp;
                *queue = BQ_LRU;
        } else if (!lru_bp) {
                bp = age_bp;
                *queue = BQ_AGE;
        } else { /* buffer available on both AGE and LRU */
                age_time = time.tv_sec - age_bp->b_timestamp;
                lru_time = time.tv_sec - lru_bp->b_timestamp;
                if ((age_time < 0) || (lru_time < 0)) { /* time set backwards */
                        bp = age_bp;
                        *queue = BQ_AGE;
                        /*
                         * we should probably re-timestamp eveything in the
                         * queues at this point with the current time
                         */
                } else {
                        if ((lru_time >= lru_is_stale) && (age_time < age_is_stale)) {
                                bp = lru_bp;
                                *queue = BQ_LRU;
                        } else {
                                bp = age_bp;
                                *queue = BQ_AGE;
                        }
                }
        }

        if (!bp) { /* Neither on AGE nor on LRU */
                bp = meta_bp;
                *queue = BQ_META;
        }  else if (meta_bp) {
                bp_time = time.tv_sec - bp->b_timestamp;
                meta_time = time.tv_sec - meta_bp->b_timestamp;

                if (!(bp_time < 0) && !(meta_time < 0)) {
                        /* time not set backwards */
                        int bp_is_stale;
                        bp_is_stale = (*queue == BQ_LRU) ? 
                                        lru_is_stale : age_is_stale;

                        if ((meta_time >= meta_is_stale) && 
                                        (bp_time < bp_is_stale)) {
                                bp = meta_bp;
                                *queue = BQ_META;
                        }
                }
        }

        if (bp == NULL)
                panic("getnewbuf: null bp");

found:
        if (ISSET(bp->b_flags, B_LOCKED)) {
            panic("getnewbuf: bp @ 0x%x is LOCKED! (flags 0x%x)\n", bp, bp->b_flags);
        }
        
        if (bp->b_hash.le_prev == (struct buf **)0xdeadbeef) 
                panic("getnewbuf: le_prev is deadbeef, buf @ 0x%x", bp);

        if(ISSET(bp->b_flags, B_BUSY))
                panic("getnewbuf reusing BUSY buf @ 0x%x", bp);

        /* Clean it */
        if (bcleanbuf(bp)) {
                /* bawrite() issued, buffer not ready */
                splx(s);
                *queue = req;
                goto start;
        }
        splx(s);
        return (bp); 
}

#include <mach/mach_types.h>
#include <mach/memory_object_types.h>
#include <kern/sched_prim.h>

/* 
 * Clean a buffer.
 * Returns 0 is buffer is ready to use,
 * Returns 1 if issued a bawrite() to indicate 
 * that the buffer is not ready.
 */
static int
bcleanbuf(struct buf *bp)
{
        int s;
        struct ucred *cred;
        int     hdralloc = 0;

        s = splbio();

        /* Remove from the queue */
        bremfree(bp);

        /* Buffer is no longer on free lists. */
        SET(bp->b_flags, B_BUSY);

        /* Check whether the buffer header was "allocated" */
        if (ISSET(bp->b_flags, B_HDRALLOC))
                hdralloc = 1;

        if (bp->b_hash.le_prev == (struct buf **)0xdeadbeef) 
                panic("bcleanbuf: le_prev is deadbeef");

        /*
         * If buffer was a delayed write, start the IO by queuing
         * it on the LAUNDRY queue, and return 1
         */
        if (ISSET(bp->b_flags, B_DELWRI)) {
                splx(s);
                binstailfree(bp, &bufqueues[BQ_LAUNDRY], BQ_LAUNDRY);
                blaundrycnt++;
                wakeup(&blaundrycnt);
                /* and give it a chance to run */
                (void)thread_block(THREAD_CONTINUE_NULL);
                return (1);
        }

        if (bp->b_vp)
                brelvp(bp);
        bremhash(bp);
        BLISTNONE(bp);

        splx(s);

        if (ISSET(bp->b_flags, B_META)) {
                vm_offset_t elem = (vm_offset_t)bp->b_data;
                if (elem == 0)
                        panic("bcleanbuf: NULL bp->b_data B_META buffer");

                if (ISSET(bp->b_flags, B_ZALLOC)) {
                        if (bp->b_bufsize <= MAXMETA) {
                                zone_t z;

                                z = getbufzone(bp->b_bufsize);
                                bp->b_data = (caddr_t)0xdeadbeef;
                                zfree(z, elem);
                                CLR(bp->b_flags, B_ZALLOC);
                        } else
                                panic("bcleanbuf: B_ZALLOC set incorrectly");
                } else {
                        bp->b_data = (caddr_t)0xdeadbeef;
                        kmem_free(kernel_map, elem, bp->b_bufsize); 
                }
        }

        trace(TR_BRELSE, pack(bp->b_vp, bp->b_bufsize), bp->b_lblkno);

        /* disassociate us from our vnode, if we had one... */
        s = splbio();

        /* clear out various other fields */
        bp->b_bufsize = 0;
        bp->b_data = 0;
        bp->b_flags = B_BUSY;
        if (hdralloc)
                SET(bp->b_flags, B_HDRALLOC);
        bp->b_dev = NODEV;
        bp->b_blkno = bp->b_lblkno = 0;
        bp->b_iodone = 0;
        bp->b_error = 0;
        bp->b_resid = 0;
        bp->b_bcount = 0;
        bp->b_dirtyoff = bp->b_dirtyend = 0;
        bp->b_validoff = bp->b_validend = 0;

        /* nuke any credentials we were holding */
        cred = bp->b_rcred;
        if (cred != NOCRED) {
                bp->b_rcred = NOCRED; 
                crfree(cred);
        }
        cred = bp->b_wcred;
        if (cred != NOCRED) {
                bp->b_wcred = NOCRED;
                crfree(cred);
        }
        splx(s);
        return (0);
}


/*
 * Wait for operations on the buffer to complete.
 * When they do, extract and return the I/O's error value.
 */
int
biowait(bp)
        struct buf *bp;
{
        int s;

        s = splbio();
        while (!ISSET(bp->b_flags, B_DONE))
                tsleep(bp, PRIBIO + 1, "biowait", 0);
        splx(s);
        
        /* check for interruption of I/O (e.g. via NFS), then errors. */
        if (ISSET(bp->b_flags, B_EINTR)) {
                CLR(bp->b_flags, B_EINTR);
                return (EINTR);
        } else if (ISSET(bp->b_flags, B_ERROR))
                return (bp->b_error ? bp->b_error : EIO);
        else
                return (0);
}

/*
 * Mark I/O complete on a buffer.
 *
 * If a callback has been requested, e.g. the pageout
 * daemon, do so. Otherwise, awaken waiting processes.
 *
 * [ Leffler, et al., says on p.247:
 *      "This routine wakes up the blocked process, frees the buffer
 *      for an asynchronous write, or, for a request by the pagedaemon
 *      process, invokes a procedure specified in the buffer structure" ]
 *
 * In real life, the pagedaemon (or other system processes) wants
 * to do async stuff to, and doesn't want the buffer brelse()'d.
 * (for swap pager, that puts swap buffers on the free lists (!!!),
 * for the vn device, that puts malloc'd buffers on the free lists!)
 */
void
biodone(bp)
        struct buf *bp;
{
        boolean_t       funnel_state;
        struct vnode *vp;

        funnel_state = thread_funnel_set(kernel_flock, TRUE);

        KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 387)) | DBG_FUNC_START,
                     (int)bp, (int)bp->b_data, bp->b_flags, 0, 0);

        if (ISSET(bp->b_flags, B_DONE))
                panic("biodone already");
        SET(bp->b_flags, B_DONE);               /* note that it's done */
        /*
         * I/O was done, so don't believe
         * the DIRTY state from VM anymore
         */
        CLR(bp->b_flags, B_WASDIRTY);

        if (!ISSET(bp->b_flags, B_READ) && !ISSET(bp->b_flags, B_RAW))
                vwakeup(bp);     /* wake up reader */
           
        if (kdebug_enable) {
            int    code = DKIO_DONE;

            if (bp->b_flags & B_READ)
                code |= DKIO_READ;
            if (bp->b_flags & B_ASYNC)
                code |= DKIO_ASYNC;

            if (bp->b_flags & B_META)
                code |= DKIO_META;
            else if (bp->b_flags & (B_PGIN | B_PAGEOUT))
                code |= DKIO_PAGING;

            KERNEL_DEBUG_CONSTANT(FSDBG_CODE(DBG_DKRW, code) | DBG_FUNC_NONE,
                                    bp, bp->b_vp, bp->b_resid, bp->b_error, 0);
        }
        
        /* Wakeup the throttled write operations as needed */
        vp = bp->b_vp;
        if (vp
                && (vp->v_flag & VTHROTTLED)
                && (vp->v_numoutput <= (BUFWRITE_THROTTLE / 3))) {
                vp->v_flag &= ~VTHROTTLED;
                wakeup((caddr_t)&vp->v_numoutput);
        }

        if (ISSET(bp->b_flags, B_CALL)) {       /* if necessary, call out */
                void    (*iodone_func)(struct buf *) = bp->b_iodone;

                CLR(bp->b_flags, B_CALL);       /* but note callout done */
                bp->b_iodone = NULL;

                if (iodone_func == NULL) {
                        panic("biodone: bp @ 0x%x has NULL b_iodone!\n", bp);                   
                } else { 
                        (*iodone_func)(bp);
                }
        } else if (ISSET(bp->b_flags, B_ASYNC)) /* if async, release it */
                brelse(bp);
        else {                                  /* or just wakeup the buffer */ 
                CLR(bp->b_flags, B_WANTED);
                wakeup(bp);
        }

        KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 387)) | DBG_FUNC_END,
                     (int)bp, (int)bp->b_data, bp->b_flags, 0, 0);

        thread_funnel_set(kernel_flock, funnel_state);
}

/*
 * Return a count of buffers on the "locked" queue.
 */
int
count_lock_queue()
{
        register struct buf *bp;
        register int n = 0;

        for (bp = bufqueues[BQ_LOCKED].tqh_first; bp;
            bp = bp->b_freelist.tqe_next)
                n++;
        return (n);
}

/*
 * Return a count of 'busy' buffers. Used at the time of shutdown.
 */
int
count_busy_buffers()
{
        register struct buf *bp;
        register int nbusy = 0;

        for (bp = &buf[nbuf]; --bp >= buf; )
                if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY)
                        nbusy++;
        return (nbusy);
}

#if DIAGNOSTIC
/*
 * Print out statistics on the current allocation of the buffer pool.
 * Can be enabled to print out on every ``sync'' by setting "syncprt"
 * in vfs_syscalls.c using sysctl.
 */
void
vfs_bufstats()
{
        int s, i, j, count;
        register struct buf *bp;
        register struct bqueues *dp;
        int counts[MAXBSIZE/CLBYTES+1];
        static char *bname[BQUEUES] =
                { "LOCKED", "LRU", "AGE", "EMPTY", "META", "LAUNDRY" };

        for (dp = bufqueues, i = 0; dp < &bufqueues[BQUEUES]; dp++, i++) {
                count = 0;
                for (j = 0; j <= MAXBSIZE/CLBYTES; j++)
                        counts[j] = 0;
                s = splbio();
                for (bp = dp->tqh_first; bp; bp = bp->b_freelist.tqe_next) {
                        counts[bp->b_bufsize/CLBYTES]++;
                        count++;
                }
                splx(s);
                printf("%s: total-%d", bname[i], count);
                for (j = 0; j <= MAXBSIZE/CLBYTES; j++)
                        if (counts[j] != 0)
                                printf(", %d-%d", j * CLBYTES, counts[j]);
                printf("\n");
        }
}
#endif /* DIAGNOSTIC */

#define NRESERVEDIOBUFS 64

__private_extern__ struct buf *
alloc_io_buf(vp, priv)
        struct vnode *vp;
        int priv;
{
        register struct buf *bp;
        int s;

        s = splbio();

        while (niobuf - NRESERVEDIOBUFS < bufstats.bufs_iobufinuse && !priv) {
                need_iobuffer = 1;
                bufstats.bufs_iobufsleeps++;
                (void) tsleep(&need_iobuffer, (PRIBIO+1), "alloc_io_buf", 0);
        }

        while ((bp = iobufqueue.tqh_first) == NULL) {
                need_iobuffer = 1;
                bufstats.bufs_iobufsleeps++;
                (void) tsleep(&need_iobuffer, (PRIBIO+1), "alloc_io_buf1", 0);
        }

        TAILQ_REMOVE(&iobufqueue, bp, b_freelist);
        bp->b_timestamp = 0; 

        /* clear out various fields */
        bp->b_flags = B_BUSY;
        bp->b_blkno = bp->b_lblkno = 0;

        bp->b_iodone = 0;
        bp->b_error = 0;
        bp->b_resid = 0;
        bp->b_bcount = 0;
        bp->b_bufsize = 0;
        bp->b_vp = vp;

        if (vp->v_type == VBLK || vp->v_type == VCHR)
                bp->b_dev = vp->v_rdev;
        else
                bp->b_dev = NODEV;
        bufstats.bufs_iobufinuse++;
        if (bufstats.bufs_iobufinuse > bufstats.bufs_iobufmax)
                bufstats.bufs_iobufmax = bufstats.bufs_iobufinuse;
        splx(s);

        return (bp);
}

__private_extern__ void
free_io_buf(bp)
        struct buf *bp;
{
        int s;

        s = splbio();
        /* put buffer back on the head of the iobufqueue */
        bp->b_vp = NULL;
        bp->b_flags = B_INVAL;

        binsheadfree(bp, &iobufqueue, -1);

        /* Wake up any processes waiting for any buffer to become free. */
        if (need_iobuffer) {
                need_iobuffer = 0;
                wakeup(&need_iobuffer);
        }
        bufstats.bufs_iobufinuse--;
        splx(s);
}

/* disabled for now */

/* XXX move this to a separate file */
/*
 * Dynamic Scaling of the Buffer Queues
 */

typedef long long blsize_t;

blsize_t MAXNBUF; /* initialize to (mem_size / PAGE_SIZE) */
/* Global tunable limits */
blsize_t nbufh;                 /* number of buffer headers */
blsize_t nbuflow;               /* minimum number of buffer headers required */
blsize_t nbufhigh;              /* maximum number of buffer headers allowed */
blsize_t nbuftarget;    /* preferred number of buffer headers */

/*
 * assertions:
 *
 * 1.   0 < nbuflow <= nbufh <= nbufhigh
 * 2.   nbufhigh <= MAXNBUF
 * 3.   0 < nbuflow <= nbuftarget <= nbufhigh
 * 4.   nbufh can not be set by sysctl().
 */

/* Per queue tunable limits */

struct bufqlim {
        blsize_t        bl_nlow;        /* minimum number of buffer headers required */
        blsize_t        bl_num;         /* number of buffer headers on the queue */
        blsize_t        bl_nlhigh;      /* maximum number of buffer headers allowed */
        blsize_t        bl_target;      /* preferred number of buffer headers */
        long    bl_stale;       /* Seconds after which a buffer is considered stale */
} bufqlim[BQUEUES];

/*
 * assertions:
 *
 * 1.   0 <= bl_nlow <= bl_num <= bl_nlhigh
 * 2.   bl_nlhigh <= MAXNBUF
 * 3.  bufqlim[BQ_META].bl_nlow != 0
 * 4.  bufqlim[BQ_META].bl_nlow > (number of possible concurrent 
 *                                                                      file system IO operations)
 * 5.   bl_num can not be set by sysctl().
 * 6.   bl_nhigh <= nbufhigh
 */

/*
 * Rationale:
 * ----------
 * Defining it blsize_t as long permits 2^31 buffer headers per queue.
 * Which can describe (2^31 * PAGE_SIZE) memory per queue.
 * 
 * These limits are exported to by means of sysctl().
 * It was decided to define blsize_t as a 64 bit quantity.
 * This will make sure that we will not be required to change it
 * as long as we do not exceed 64 bit address space for the kernel.
 * 
 * low and high numbers parameters initialized at compile time
 * and boot arguments can be used to override them. sysctl() 
 * would not change the value. sysctl() can get all the values 
 * but can set only target. num is the current level.
 *
 * Advantages of having a "bufqscan" thread doing the balancing are, 
 * Keep enough bufs on BQ_EMPTY.
 *      getnewbuf() by default will always select a buffer from the BQ_EMPTY.
 *              getnewbuf() perfoms best if a buffer was found there.
 *              Also this minimizes the possibility of starting IO
 *              from getnewbuf(). That's a performance win, too.
 *
 *      Localize complex logic [balancing as well as time aging]
 *              to balancebufq().
 *
 *      Simplify getnewbuf() logic by elimination of time aging code.
 */

/* 
 * Algorithm:
 * -----------
 * The goal of the dynamic scaling of the buffer queues to to keep
 * the size of the LRU close to bl_target. Buffers on a queue would
 * be time aged.
 *
 * There would be a thread which will be responsible for "balancing"
 * the buffer cache queues.
 *
 * The scan order would be:     AGE, LRU, META, EMPTY.
 */

long bufqscanwait = 0;

static void bufqscan_thread();
static int balancebufq(int q);
static int btrimempty(int n);
static __inline__ int initbufqscan(void);
static __inline__ int nextbufq(int q);
static void buqlimprt(int all);

static void
bufq_balance_thread_init()
{

        if (bufqscanwait++ == 0) {

                /* Initalize globals */
                MAXNBUF = (mem_size / PAGE_SIZE);
                nbufh = nbuf;
                nbuflow = min(nbufh, 100);
                nbufhigh = min(MAXNBUF, max(nbufh, 2048));
                nbuftarget = (mem_size >> 5) / PAGE_SIZE;
                nbuftarget = max(nbuflow, nbuftarget);
                nbuftarget = min(nbufhigh, nbuftarget);

                /*
                 * Initialize the bufqlim 
                 */ 

                /* LOCKED queue */
                bufqlim[BQ_LOCKED].bl_nlow = 0;
                bufqlim[BQ_LOCKED].bl_nlhigh = 32;
                bufqlim[BQ_LOCKED].bl_target = 0;
                bufqlim[BQ_LOCKED].bl_stale = 30;

                /* LRU queue */
                bufqlim[BQ_LRU].bl_nlow = 0;
                bufqlim[BQ_LRU].bl_nlhigh = nbufhigh/4;
                bufqlim[BQ_LRU].bl_target = nbuftarget/4;
                bufqlim[BQ_LRU].bl_stale = LRU_IS_STALE;

                /* AGE queue */
                bufqlim[BQ_AGE].bl_nlow = 0;
                bufqlim[BQ_AGE].bl_nlhigh = nbufhigh/4;
                bufqlim[BQ_AGE].bl_target = nbuftarget/4;
                bufqlim[BQ_AGE].bl_stale = AGE_IS_STALE;

                /* EMPTY queue */
                bufqlim[BQ_EMPTY].bl_nlow = 0;
                bufqlim[BQ_EMPTY].bl_nlhigh = nbufhigh/4;
                bufqlim[BQ_EMPTY].bl_target = nbuftarget/4;
                bufqlim[BQ_EMPTY].bl_stale = 600000;

                /* META queue */
                bufqlim[BQ_META].bl_nlow = 0;
                bufqlim[BQ_META].bl_nlhigh = nbufhigh/4;
                bufqlim[BQ_META].bl_target = nbuftarget/4;
                bufqlim[BQ_META].bl_stale = META_IS_STALE;

                /* LAUNDRY queue */
                bufqlim[BQ_LOCKED].bl_nlow = 0;
                bufqlim[BQ_LOCKED].bl_nlhigh = 32;
                bufqlim[BQ_LOCKED].bl_target = 0;
                bufqlim[BQ_LOCKED].bl_stale = 30;

                buqlimprt(1);
        }

        /* create worker thread */
        kernel_thread(kernel_task, bufqscan_thread);
}

/* The workloop for the buffer balancing thread */
static void
bufqscan_thread()
{
        boolean_t       funnel_state;
        int moretodo = 0;

        funnel_state = thread_funnel_set(kernel_flock, TRUE);

        for(;;) {
                do {
                        int q;  /* buffer queue to process */
                
                        q = initbufqscan();
                        for (; q; ) {
                                moretodo |= balancebufq(q);
                                q = nextbufq(q);
                        }
                } while (moretodo);

#if DIAGNOSTIC
                vfs_bufstats();
                buqlimprt(0);
#endif
                (void)tsleep((void *)&bufqscanwait, PRIBIO, "bufqscanwait", 60 * hz);
                moretodo = 0;
        }

        (void) thread_funnel_set(kernel_flock, FALSE);
}

/* Seed for the buffer queue balancing */
static __inline__ int
initbufqscan()
{
        /* Start with AGE queue */
        return (BQ_AGE);
}

/* Pick next buffer queue to balance */
static __inline__ int
nextbufq(int q)
{
        int order[] = { BQ_AGE, BQ_LRU, BQ_META, BQ_EMPTY, 0 };
        
        q++;
        q %= sizeof(order);
        return (order[q]);
}

/* function to balance the buffer queues */
static int
balancebufq(int q)
{
        int moretodo = 0;
        int s = splbio();
        int n;
        
        /* reject invalid q */
        if ((q < 0) || (q >= BQUEUES))
                goto out;

        /* LOCKED or LAUNDRY queue MUST not be balanced */
        if ((q == BQ_LOCKED) || (q == BQ_LAUNDRY))
                goto out;

        n = (bufqlim[q].bl_num - bufqlim[q].bl_target);

        /* If queue has less than target nothing more to do */
        if (n < 0)
                goto out;

        if ( n > 8 ) {
                /* Balance only a small amount (12.5%) at a time */
                n >>= 3;
        }

        /* EMPTY queue needs special handling */
        if (q == BQ_EMPTY) {
                moretodo |= btrimempty(n);
                goto out;
        }
        
        for (; n > 0; n--) {
                struct buf *bp = bufqueues[q].tqh_first;
                if (!bp)
                        break;
                
                /* check if it's stale */
                if ((time.tv_sec - bp->b_timestamp) > bufqlim[q].bl_stale) {
                        if (bcleanbuf(bp)) {
                                /* bawrite() issued, bp not ready */
                                moretodo = 1;
                        } else {
                                /* release the cleaned buffer to BQ_EMPTY */
                                SET(bp->b_flags, B_INVAL);
                                brelse(bp);
                        }
                } else
                        break;          
        }

out:
        splx(s);
        return (moretodo);              
}

static int
btrimempty(int n)
{
        /*
         * When struct buf are allocated dynamically, this would
         * reclaim upto 'n' struct buf from the empty queue.
         */
         
         return (0);
}

static __inline__ void
bufqinc(int q)
{
        if ((q < 0) || (q >= BQUEUES))
                return;

        bufqlim[q].bl_num++;
        return;
}

static __inline__ void
bufqdec(int q)
{
        if ((q < 0) || (q >= BQUEUES))
                return; 

        bufqlim[q].bl_num--;
        return;
}

static void
buqlimprt(int all)
{
        int i;
    static char *bname[BQUEUES] =
                { "LOCKED", "LRU", "AGE", "EMPTY", "META", "LAUNDRY" };

        if (all)
                for (i = 0; i < BQUEUES; i++) {
                        printf("%s : ", bname[i]);
                        printf("min = %ld, ", (long)bufqlim[i].bl_nlow);
                        printf("cur = %ld, ", (long)bufqlim[i].bl_num);
                        printf("max = %ld, ", (long)bufqlim[i].bl_nlhigh);
                        printf("target = %ld, ", (long)bufqlim[i].bl_target);
                        printf("stale after %ld seconds\n", bufqlim[i].bl_stale);
                }
        else
                for (i = 0; i < BQUEUES; i++) {
                        printf("%s : ", bname[i]);
                        printf("cur = %ld, ", (long)bufqlim[i].bl_num);
                }
}

/*
 * If the getnewbuf() calls bcleanbuf() on the same thread
 * there is a potential for stack overrun and deadlocks.
 * So we always handoff the work to worker thread for completion
 */

static void
bcleanbuf_thread_init()
{
        static void bcleanbuf_thread();

        /* create worker thread */
        kernel_thread(kernel_task, bcleanbuf_thread);
}

static void
bcleanbuf_thread()
{
        boolean_t       funnel_state;
        struct buf *bp;
        int error = 0;
        int loopcnt = 0;

        funnel_state = thread_funnel_set(kernel_flock, TRUE);

doit:
        while (blaundrycnt == 0)
                (void)tsleep((void *)&blaundrycnt, PRIBIO, "blaundry", 60 * hz);
        bp = TAILQ_FIRST(&bufqueues[BQ_LAUNDRY]);
        /* Remove from the queue */
        bremfree(bp);
        blaundrycnt--;
        /* do the IO */
        error = bawrite_internal(bp, 0);
        if (error) {
                binstailfree(bp, &bufqueues[BQ_LAUNDRY], BQ_LAUNDRY);
                blaundrycnt++;
                if (loopcnt > 10) {
                        (void)tsleep((void *)&blaundrycnt, PRIBIO, "blaundry", 1);
                        loopcnt = 0;
                } else {
                        (void)thread_block(THREAD_CONTINUE_NULL);
                        loopcnt++;
                }
        }
        /* start again */
        goto doit;

        (void) thread_funnel_set(kernel_flock, funnel_state);
}


static int
bp_cmp(void *a, void *b)
{
    struct buf *bp_a = *(struct buf **)a,
               *bp_b = *(struct buf **)b;
    daddr_t res;

    // don't have to worry about negative block
    // numbers so this is ok to do.
    //
    res = (bp_a->b_blkno - bp_b->b_blkno);

    return (int)res;
}

#define NFLUSH 32

int
bflushq(int whichq, struct mount *mp)
{
        struct buf *bp, *next;
        int         i, buf_count, s;
        int         counter=0, total_writes=0;
        static struct buf *flush_table[NFLUSH];

        if (whichq < 0 || whichq >= BQUEUES) {
            return;
        }


  restart:
        bp = TAILQ_FIRST(&bufqueues[whichq]);
        for(buf_count=0; bp; bp=next) {
            next = bp->b_freelist.tqe_next;
                        
            if (bp->b_vp == NULL || bp->b_vp->v_mount != mp) {
                continue;
            }

            if ((bp->b_flags & B_DELWRI) && (bp->b_flags & B_BUSY) == 0) {
                if (whichq != BQ_LOCKED && (bp->b_flags & B_LOCKED)) {
                    panic("bflushq: bp @ 0x%x is locked!\n", bp);
                }
                
                bremfree(bp);
                bp->b_flags |= B_BUSY;
                flush_table[buf_count] = bp;
                buf_count++;
                total_writes++;

                if (buf_count >= NFLUSH) {
                    qsort(flush_table, buf_count, sizeof(struct buf *), bp_cmp);

                    for(i=0; i < buf_count; i++) {
                        bawrite(flush_table[i]);
                    }

                    goto restart;
                }
            }
        }

        if (buf_count > 0) {
            qsort(flush_table, buf_count, sizeof(struct buf *), bp_cmp);
            for(i=0; i < buf_count; i++) {
                bawrite(flush_table[i]);
            }
        }

        return total_writes;
}