fs/ufs/lufs.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/systm.h>
#include <sys/types.h>
#include <sys/vnode.h>
#include <sys/buf.h>
#include <sys/errno.h>
#include <sys/fssnap_if.h>
#include <sys/fs/ufs_inode.h>
#include <sys/fs/ufs_filio.h>
#include <sys/sysmacros.h>
#include <sys/modctl.h>
#include <sys/fs/ufs_log.h>
#include <sys/fs/ufs_bio.h>
#include <sys/fs/ufs_fsdir.h>
#include <sys/debug.h>
#include <sys/atomic.h>
#include <sys/kmem.h>
#include <sys/inttypes.h>
#include <sys/vfs.h>
#include <sys/mntent.h>
#include <sys/conf.h>
#include <sys/param.h>
#include <sys/kstat.h>
#include <sys/cmn_err.h>
#include <sys/sdt.h>

#define LUFS_GENID_PRIME    UINT64_C(4294967291)
#define LUFS_GENID_BASE     UINT64_C(311)
#define LUFS_NEXT_ID(id)    ((uint32_t)(((id) * LUFS_GENID_BASE) % \
                    LUFS_GENID_PRIME))

extern  kmutex_t    ufs_scan_lock;

static kmutex_t log_mutex;  /* general purpose log layer lock */
kmutex_t    ml_scan;    /* Scan thread syncronization */
kcondvar_t  ml_scan_cv; /* Scan thread syncronization */

struct kmem_cache   *lufs_sv;
struct kmem_cache   *lufs_bp;

/* Tunables */
uint_t      ldl_maxlogsize  = LDL_MAXLOGSIZE;
uint_t      ldl_minlogsize  = LDL_MINLOGSIZE;
uint_t      ldl_softlogcap  = LDL_SOFTLOGCAP;
uint32_t    ldl_divisor = LDL_DIVISOR;
uint32_t    ldl_mintransfer = LDL_MINTRANSFER;
uint32_t    ldl_maxtransfer = LDL_MAXTRANSFER;
uint32_t    ldl_minbufsize  = LDL_MINBUFSIZE;
uint32_t    ldl_cgsizereq   = 0;

/* Generation of header ids */
static kmutex_t genid_mutex;
static uint32_t last_loghead_ident = UINT32_C(0);

/*
 * Logging delta and roll statistics
 */
struct delta_kstats {
    kstat_named_t ds_superblock_deltas;
    kstat_named_t ds_bitmap_deltas;
    kstat_named_t ds_suminfo_deltas;
    kstat_named_t ds_allocblk_deltas;
    kstat_named_t ds_ab0_deltas;
    kstat_named_t ds_dir_deltas;
    kstat_named_t ds_inode_deltas;
    kstat_named_t ds_fbiwrite_deltas;
    kstat_named_t ds_quota_deltas;
    kstat_named_t ds_shadow_deltas;

    kstat_named_t ds_superblock_rolled;
    kstat_named_t ds_bitmap_rolled;
    kstat_named_t ds_suminfo_rolled;
    kstat_named_t ds_allocblk_rolled;
    kstat_named_t ds_ab0_rolled;
    kstat_named_t ds_dir_rolled;
    kstat_named_t ds_inode_rolled;
    kstat_named_t ds_fbiwrite_rolled;
    kstat_named_t ds_quota_rolled;
    kstat_named_t ds_shadow_rolled;
} dkstats = {
    { "superblock_deltas",  KSTAT_DATA_UINT64 },
    { "bitmap_deltas",  KSTAT_DATA_UINT64 },
    { "suminfo_deltas", KSTAT_DATA_UINT64 },
    { "allocblk_deltas",    KSTAT_DATA_UINT64 },
    { "ab0_deltas",     KSTAT_DATA_UINT64 },
    { "dir_deltas",     KSTAT_DATA_UINT64 },
    { "inode_deltas",   KSTAT_DATA_UINT64 },
    { "fbiwrite_deltas",    KSTAT_DATA_UINT64 },
    { "quota_deltas",   KSTAT_DATA_UINT64 },
    { "shadow_deltas",  KSTAT_DATA_UINT64 },

    { "superblock_rolled",  KSTAT_DATA_UINT64 },
    { "bitmap_rolled",  KSTAT_DATA_UINT64 },
    { "suminfo_rolled", KSTAT_DATA_UINT64 },
    { "allocblk_rolled",    KSTAT_DATA_UINT64 },
    { "ab0_rolled",     KSTAT_DATA_UINT64 },
    { "dir_rolled",     KSTAT_DATA_UINT64 },
    { "inode_rolled",   KSTAT_DATA_UINT64 },
    { "fbiwrite_rolled",    KSTAT_DATA_UINT64 },
    { "quota_rolled",   KSTAT_DATA_UINT64 },
    { "shadow_rolled",  KSTAT_DATA_UINT64 }
};

uint64_t delta_stats[DT_MAX];
uint64_t roll_stats[DT_MAX];

/*
 * General logging kstats
 */
struct logstats logstats = {
    { "master_reads",       KSTAT_DATA_UINT64 },
    { "master_writes",      KSTAT_DATA_UINT64 },
    { "log_reads_inmem",        KSTAT_DATA_UINT64 },
    { "log_reads",          KSTAT_DATA_UINT64 },
    { "log_writes",         KSTAT_DATA_UINT64 },
    { "log_master_reads",       KSTAT_DATA_UINT64 },
    { "log_roll_reads",     KSTAT_DATA_UINT64 },
    { "log_roll_writes",        KSTAT_DATA_UINT64 }
};

int
trans_not_done(struct buf *cb)
{
    sema_v(&cb->b_io);
    return (0);
}

static void
trans_wait_panic(struct buf *cb)
{
    while ((cb->b_flags & B_DONE) == 0)
        drv_usecwait(10);
}

int
trans_not_wait(struct buf *cb)
{
    /*
     * In case of panic, busy wait for completion
     */
    if (panicstr)
        trans_wait_panic(cb);
    else
        sema_p(&cb->b_io);

    return (geterror(cb));
}

int
trans_wait(struct buf *cb)
{
    /*
     * In case of panic, busy wait for completion and run md daemon queues
     */
    if (panicstr)
        trans_wait_panic(cb);
    return (biowait(cb));
}

static void
setsum(int32_t *sp, int32_t *lp, int nb)
{
    int32_t csum = 0;

    *sp = 0;
    nb /= sizeof (int32_t);
    while (nb--)
        csum += *lp++;
    *sp = csum;
}

static int
checksum(int32_t *sp, int32_t *lp, int nb)
{
    int32_t ssum = *sp;

    setsum(sp, lp, nb);
    if (ssum != *sp) {
        *sp = ssum;
        return (0);
    }
    return (1);
}

void
lufs_unsnarf(ufsvfs_t *ufsvfsp)
{
    ml_unit_t *ul;
    mt_map_t *mtm;

    ul = ufsvfsp->vfs_log;
    if (ul == NULL)
        return;

    mtm = ul->un_logmap;

    /*
     * Wait for a pending top_issue_sync which is
     * dispatched (via taskq_dispatch()) but hasnt completed yet.
     */

    mutex_enter(&mtm->mtm_lock);

    while (mtm->mtm_taskq_sync_count != 0) {
        cv_wait(&mtm->mtm_cv, &mtm->mtm_lock);
    }

    mutex_exit(&mtm->mtm_lock);

    /* Roll committed transactions */
    logmap_roll_dev(ul);

    /* Kill the roll thread */
    logmap_kill_roll(ul);

    /* release saved alloction info */
    if (ul->un_ebp)
        kmem_free(ul->un_ebp, ul->un_nbeb);

    /* release circular bufs */
    free_cirbuf(&ul->un_rdbuf);
    free_cirbuf(&ul->un_wrbuf);

    /* release maps */
    if (ul->un_logmap)
        ul->un_logmap = map_put(ul->un_logmap);
    if (ul->un_deltamap)
        ul->un_deltamap = map_put(ul->un_deltamap);
    if (ul->un_matamap)
        ul->un_matamap = map_put(ul->un_matamap);

    mutex_destroy(&ul->un_log_mutex);
    mutex_destroy(&ul->un_state_mutex);

    /* release state buffer MUST BE LAST!! (contains our ondisk data) */
    if (ul->un_bp)
        brelse(ul->un_bp);
    kmem_free(ul, sizeof (*ul));

    ufsvfsp->vfs_log = NULL;
}

int
lufs_snarf(ufsvfs_t *ufsvfsp, struct fs *fs, int ronly)
{
    buf_t       *bp, *tbp;
    ml_unit_t   *ul;
    extent_block_t  *ebp;
    ic_extent_block_t  *nebp;
    size_t      nb;
    daddr_t     bno;    /* in disk blocks */
    int     i;

    /* LINTED: warning: logical expression always true: op "||" */
    ASSERT(sizeof (ml_odunit_t) < DEV_BSIZE);

    /*
     * Get the allocation table
     *  During a remount the superblock pointed to by the ufsvfsp
     *  is out of date.  Hence the need for the ``new'' superblock
     *  pointer, fs, passed in as a parameter.
     */
    bp = UFS_BREAD(ufsvfsp, ufsvfsp->vfs_dev, logbtodb(fs, fs->fs_logbno),
        fs->fs_bsize);
    if (bp->b_flags & B_ERROR) {
        brelse(bp);
        return (EIO);
    }
    ebp = (void *)bp->b_un.b_addr;
    if (!checksum(&ebp->chksum, (int32_t *)bp->b_un.b_addr,
        fs->fs_bsize)) {
        brelse(bp);
        return (ENODEV);
    }

    /*
     * It is possible to get log blocks with all zeros.
     * We should also check for nextents to be zero in such case.
     */
    if (ebp->type != LUFS_EXTENTS || ebp->nextents == 0) {
        brelse(bp);
        return (EDOM);
    }
    /*
     * Put allocation into memory.  This requires conversion between
     * on the ondisk format of the extent (type extent_t) and the
     * in-core format of the extent (type ic_extent_t).  The
     * difference is the in-core form of the extent block stores
     * the physical offset of the extent in disk blocks, which
     * can require more than a 32-bit field.
     */
    nb = (size_t)(sizeof (ic_extent_block_t) +
        ((ebp->nextents - 1) * sizeof (ic_extent_t)));
    nebp = kmem_alloc(nb, KM_SLEEP);
    nebp->ic_nextents = ebp->nextents;
    nebp->ic_nbytes = ebp->nbytes;
    nebp->ic_nextbno = ebp->nextbno;
    for (i = 0; i < ebp->nextents; i++) {
        nebp->ic_extents[i].ic_lbno = ebp->extents[i].lbno;
        nebp->ic_extents[i].ic_nbno = ebp->extents[i].nbno;
        nebp->ic_extents[i].ic_pbno =
            logbtodb(fs, ebp->extents[i].pbno);
    }
    brelse(bp);

    /*
     * Get the log state
     */
    bno = nebp->ic_extents[0].ic_pbno;
    bp = UFS_BREAD(ufsvfsp, ufsvfsp->vfs_dev, bno, DEV_BSIZE);
    if (bp->b_flags & B_ERROR) {
        brelse(bp);
        bp = UFS_BREAD(ufsvfsp, ufsvfsp->vfs_dev, bno + 1, DEV_BSIZE);
        if (bp->b_flags & B_ERROR) {
            brelse(bp);
            kmem_free(nebp, nb);
            return (EIO);
        }
    }

    /*
     * Put ondisk struct into an anonymous buffer
     *  This buffer will contain the memory for the ml_odunit struct
     */
    tbp = ngeteblk(dbtob(LS_SECTORS));
    tbp->b_edev = bp->b_edev;
    tbp->b_dev = bp->b_dev;
    tbp->b_blkno = bno;
    bcopy(bp->b_un.b_addr, tbp->b_un.b_addr, DEV_BSIZE);
    bcopy(bp->b_un.b_addr, tbp->b_un.b_addr + DEV_BSIZE, DEV_BSIZE);
    bp->b_flags |= (B_STALE | B_AGE);
    brelse(bp);
    bp = tbp;

    /*
     * Verify the log state
     *
     * read/only mounts w/bad logs are allowed.  umount will
     * eventually roll the bad log until the first IO error.
     * fsck will then repair the file system.
     *
     * read/write mounts with bad logs are not allowed.
     *
     */
    ul = (ml_unit_t *)kmem_zalloc(sizeof (*ul), KM_SLEEP);
    bcopy(bp->b_un.b_addr, &ul->un_ondisk, sizeof (ml_odunit_t));
    if ((ul->un_chksum != ul->un_head_ident + ul->un_tail_ident) ||
        (ul->un_version != LUFS_VERSION_LATEST) ||
        (!ronly && ul->un_badlog)) {
        kmem_free(ul, sizeof (*ul));
        brelse(bp);
        kmem_free(nebp, nb);
        return (EIO);
    }
    /*
     * Initialize the incore-only fields
     */
    if (ronly)
        ul->un_flags |= LDL_NOROLL;
    ul->un_bp = bp;
    ul->un_ufsvfs = ufsvfsp;
    ul->un_dev = ufsvfsp->vfs_dev;
    ul->un_ebp = nebp;
    ul->un_nbeb = nb;
    ul->un_maxresv = btodb(ul->un_logsize) * LDL_USABLE_BSIZE;
    ul->un_deltamap = map_get(ul, deltamaptype, DELTAMAP_NHASH);
    ul->un_logmap = map_get(ul, logmaptype, LOGMAP_NHASH);
    if (ul->un_debug & MT_MATAMAP)
        ul->un_matamap = map_get(ul, matamaptype, DELTAMAP_NHASH);
    mutex_init(&ul->un_log_mutex, NULL, MUTEX_DEFAULT, NULL);
    mutex_init(&ul->un_state_mutex, NULL, MUTEX_DEFAULT, NULL);

    /*
     * Aquire the ufs_scan_lock before linking the mtm data
     * structure so that we keep ufs_sync() and ufs_update() away
     * when they execute the ufs_scan_inodes() run while we're in
     * progress of enabling/disabling logging.
     */
    mutex_enter(&ufs_scan_lock);
    ufsvfsp->vfs_log = ul;

    /* remember the state of the log before the log scan */
    logmap_logscan(ul);
    mutex_exit(&ufs_scan_lock);

    /*
     * Error during scan
     *
     * If this is a read/only mount; ignore the error.
     * At a later time umount/fsck will repair the fs.
     *
     */
    if (ul->un_flags & LDL_ERROR) {
        if (!ronly) {
            /*
             * Aquire the ufs_scan_lock before de-linking
             * the mtm data structure so that we keep ufs_sync()
             * and ufs_update() away when they execute the
             * ufs_scan_inodes() run while we're in progress of
             * enabling/disabling logging.
             */
            mutex_enter(&ufs_scan_lock);
            lufs_unsnarf(ufsvfsp);
            mutex_exit(&ufs_scan_lock);
            return (EIO);
        }
        ul->un_flags &= ~LDL_ERROR;
    }
    if (!ronly)
        logmap_start_roll(ul);
    return (0);
}

uint32_t
lufs_hd_genid(const ml_unit_t *up)
{
    uint32_t id;

    mutex_enter(&genid_mutex);

    /*
     * The formula below implements an exponential, modular sequence.
     *
     * ID(N) = (SEED * (BASE^N)) % PRIME
     *
     * The numbers will be pseudo random.  They depend on SEED, BASE, PRIME,
     * but will sweep through almost all of the range 1....PRIME-1.
     * Most  importantly  they  will  not  repeat  for PRIME-2 (4294967289)
     * repetitions.  If they would repeat that  could possibly cause  hangs,
     * panics at mount/umount and failed mount operations.
     */
    id = LUFS_NEXT_ID(last_loghead_ident);

    /* Checking if new identity used already */
    if (up != NULL && up->un_head_ident == id) {
        DTRACE_PROBE1(head_ident_collision, uint32_t, id);

        /*
         * The  following  preserves  the  algorithm  for  the fix  for
         * "panic: free: freeing free frag, dev:0x2000000018, blk:34605,
         * cg:26, ino:148071,".
         * If  the header identities  un_head_ident  are  equal  to the
         * present element  in the sequence,  the next element  of  the
         * sequence is returned instead.
         */
        id = LUFS_NEXT_ID(id);
    }

    last_loghead_ident = id;

    mutex_exit(&genid_mutex);

    return (id);
}

static void
lufs_genid_init(void)
{
    uint64_t seed;

    /* Initialization */
    mutex_init(&genid_mutex, NULL, MUTEX_DEFAULT, NULL);

    /* Seed the algorithm */
    do {
        timestruc_t tv;

        gethrestime(&tv);

        seed = (tv.tv_nsec << 3);
        seed ^= tv.tv_sec;

        last_loghead_ident = (uint32_t)(seed % LUFS_GENID_PRIME);
    } while (last_loghead_ident == UINT32_C(0));
}

static int
lufs_initialize(
    ufsvfs_t *ufsvfsp,
    daddr_t bno,
    size_t nb,
    struct fiolog *flp)
{
    ml_odunit_t *ud, *ud2;
    buf_t       *bp;

    /* LINTED: warning: logical expression always true: op "||" */
    ASSERT(sizeof (ml_odunit_t) < DEV_BSIZE);
    ASSERT(nb >= ldl_minlogsize);

    bp = UFS_GETBLK(ufsvfsp, ufsvfsp->vfs_dev, bno, dbtob(LS_SECTORS));
    bzero(bp->b_un.b_addr, bp->b_bcount);

    ud = (void *)bp->b_un.b_addr;
    ud->od_version = LUFS_VERSION_LATEST;
    ud->od_maxtransfer = MIN(ufsvfsp->vfs_iotransz, ldl_maxtransfer);
    if (ud->od_maxtransfer < ldl_mintransfer)
        ud->od_maxtransfer = ldl_mintransfer;
    ud->od_devbsize = DEV_BSIZE;

    ud->od_requestsize = flp->nbytes_actual;
    ud->od_statesize = dbtob(LS_SECTORS);
    ud->od_logsize = nb - ud->od_statesize;

    ud->od_statebno = INT32_C(0);

    ud->od_head_ident = lufs_hd_genid(NULL);
    ud->od_tail_ident = ud->od_head_ident;
    ud->od_chksum = ud->od_head_ident + ud->od_tail_ident;

    ud->od_bol_lof = dbtob(ud->od_statebno) + ud->od_statesize;
    ud->od_eol_lof = ud->od_bol_lof + ud->od_logsize;
    ud->od_head_lof = ud->od_bol_lof;
    ud->od_tail_lof = ud->od_bol_lof;

    ASSERT(lufs_initialize_debug(ud));

    ud2 = (void *)(bp->b_un.b_addr + DEV_BSIZE);
    bcopy(ud, ud2, sizeof (*ud));

    UFS_BWRITE2(ufsvfsp, bp);
    if (bp->b_flags & B_ERROR) {
        brelse(bp);
        return (EIO);
    }
    brelse(bp);

    return (0);
}

/*
 * Free log space
 *  Assumes the file system is write locked and is not logging
 */
static int
lufs_free(struct ufsvfs *ufsvfsp)
{
    int     error = 0, i, j;
    buf_t       *bp = NULL;
    extent_t    *ep;
    extent_block_t  *ebp;
    struct fs   *fs = ufsvfsp->vfs_fs;
    daddr_t     fno;
    int32_t     logbno;
    long        nfno;
    inode_t     *ip = NULL;
    char        clean;

    /*
     * Nothing to free
     */
    if (fs->fs_logbno == 0)
        return (0);

    /*
     * Mark the file system as FSACTIVE and no log but honor the
     * current value of fs_reclaim.  The reclaim thread could have
     * been active when lufs_disable() was called and if fs_reclaim
     * is reset to zero here it could lead to lost inodes.
     */
    ufsvfsp->vfs_ulockfs.ul_sbowner = curthread;
    mutex_enter(&ufsvfsp->vfs_lock);
    clean = fs->fs_clean;
    logbno = fs->fs_logbno;
    fs->fs_clean = FSACTIVE;
    fs->fs_logbno = INT32_C(0);
    ufs_sbwrite(ufsvfsp);
    mutex_exit(&ufsvfsp->vfs_lock);
    ufsvfsp->vfs_ulockfs.ul_sbowner = (kthread_id_t)-1;
    if (ufsvfsp->vfs_bufp->b_flags & B_ERROR) {
        error = EIO;
        fs->fs_clean = clean;
        fs->fs_logbno = logbno;
        goto errout;
    }

    /*
     * fetch the allocation block
     *  superblock -> one block of extents -> log data
     */
    bp = UFS_BREAD(ufsvfsp, ufsvfsp->vfs_dev, logbtodb(fs, logbno),
        fs->fs_bsize);
    if (bp->b_flags & B_ERROR) {
        error = EIO;
        goto errout;
    }

    /*
     * Free up the allocated space (dummy inode needed for free())
     */
    ip = ufs_alloc_inode(ufsvfsp, UFSROOTINO);
    ebp = (void *)bp->b_un.b_addr;
    for (i = 0, ep = &ebp->extents[0]; i < ebp->nextents; ++i, ++ep) {
        fno = logbtofrag(fs, ep->pbno);
        nfno = dbtofsb(fs, ep->nbno);
        for (j = 0; j < nfno; j += fs->fs_frag, fno += fs->fs_frag)
            free(ip, fno, fs->fs_bsize, 0);
    }
    free(ip, logbtofrag(fs, logbno), fs->fs_bsize, 0);
    brelse(bp);
    bp = NULL;

    /*
     * Push the metadata dirtied during the allocations
     */
    ufsvfsp->vfs_ulockfs.ul_sbowner = curthread;
    sbupdate(ufsvfsp->vfs_vfs);
    ufsvfsp->vfs_ulockfs.ul_sbowner = (kthread_id_t)-1;
    bflush(ufsvfsp->vfs_dev);
    error = bfinval(ufsvfsp->vfs_dev, 0);
    if (error)
        goto errout;

    /*
     * Free the dummy inode
     */
    ufs_free_inode(ip);

    return (0);

errout:
    /*
     * Free up all resources
     */
    if (bp)
        brelse(bp);
    if (ip)
        ufs_free_inode(ip);
    return (error);
}

/*
 * Allocate log space
 *  Assumes the file system is write locked and is not logging
 */
static int
lufs_alloc(struct ufsvfs *ufsvfsp, struct fiolog *flp, size_t minb, cred_t *cr)
{
    int     error = 0;
    buf_t       *bp = NULL;
    extent_t    *ep, *nep;
    extent_block_t  *ebp;
    struct fs   *fs = ufsvfsp->vfs_fs;
    daddr_t     fno;    /* in frags */
    daddr_t     bno;    /* in disk blocks */
    int32_t     logbno = INT32_C(0);    /* will be fs_logbno */
    struct inode    *ip = NULL;
    size_t      nb = flp->nbytes_actual;
    size_t      tb = 0;

    /*
     * Mark the file system as FSACTIVE
     */
    ufsvfsp->vfs_ulockfs.ul_sbowner = curthread;
    mutex_enter(&ufsvfsp->vfs_lock);
    fs->fs_clean = FSACTIVE;
    ufs_sbwrite(ufsvfsp);
    mutex_exit(&ufsvfsp->vfs_lock);
    ufsvfsp->vfs_ulockfs.ul_sbowner = (kthread_id_t)-1;

    /*
     * Allocate the allocation block (need dummy shadow inode;
     * we use a shadow inode so the quota sub-system ignores
     * the block allocations.)
     *  superblock -> one block of extents -> log data
     */
    ip = ufs_alloc_inode(ufsvfsp, UFSROOTINO);
    ip->i_mode = IFSHAD;        /* make the dummy a shadow inode */
    rw_enter(&ip->i_contents, RW_WRITER);
    fno = contigpref(ufsvfsp, nb + fs->fs_bsize, minb);
    error = alloc(ip, fno, fs->fs_bsize, &fno, cr);
    if (error)
        goto errout;
    bno = fsbtodb(fs, fno);

    bp = UFS_BREAD(ufsvfsp, ufsvfsp->vfs_dev, bno, fs->fs_bsize);
    if (bp->b_flags & B_ERROR) {
        error = EIO;
        goto errout;
    }

    ebp = (void *)bp->b_un.b_addr;
    ebp->type = LUFS_EXTENTS;
    ebp->nextbno = UINT32_C(0);
    ebp->nextents = UINT32_C(0);
    ebp->chksum = INT32_C(0);
    if (fs->fs_magic == FS_MAGIC)
        logbno = bno;
    else
        logbno = dbtofsb(fs, bno);

    /*
     * Initialize the first extent
     */
    ep = &ebp->extents[0];
    error = alloc(ip, fno + fs->fs_frag, fs->fs_bsize, &fno, cr);
    if (error)
        goto errout;
    bno = fsbtodb(fs, fno);

    ep->lbno = UINT32_C(0);
    if (fs->fs_magic == FS_MAGIC)
        ep->pbno = (uint32_t)bno;
    else
        ep->pbno = (uint32_t)fno;
    ep->nbno = (uint32_t)fsbtodb(fs, fs->fs_frag);
    ebp->nextents = UINT32_C(1);
    tb = fs->fs_bsize;
    nb -= fs->fs_bsize;

    while (nb) {
        error = alloc(ip, fno + fs->fs_frag, fs->fs_bsize, &fno, cr);
        if (error) {
            if (tb < minb)
                goto errout;
            error = 0;
            break;
        }
        bno = fsbtodb(fs, fno);
        if ((daddr_t)((logbtodb(fs, ep->pbno) + ep->nbno) == bno))
            ep->nbno += (uint32_t)(fsbtodb(fs, fs->fs_frag));
        else {
            nep = ep + 1;
            if ((caddr_t)(nep + 1) >
                (bp->b_un.b_addr + fs->fs_bsize)) {
                free(ip, fno, fs->fs_bsize, 0);
                break;
            }
            nep->lbno = ep->lbno + ep->nbno;
            if (fs->fs_magic == FS_MAGIC)
                nep->pbno = (uint32_t)bno;
            else
                nep->pbno = (uint32_t)fno;
            nep->nbno = (uint32_t)(fsbtodb(fs, fs->fs_frag));
            ebp->nextents++;
            ep = nep;
        }
        tb += fs->fs_bsize;
        nb -= fs->fs_bsize;
    }

    if (tb < minb) {    /* Failed to reach minimum log size */
        error = ENOSPC;
        goto errout;
    }

    ebp->nbytes = (uint32_t)tb;
    setsum(&ebp->chksum, (int32_t *)bp->b_un.b_addr, fs->fs_bsize);
    UFS_BWRITE2(ufsvfsp, bp);
    if (bp->b_flags & B_ERROR) {
        error = EIO;
        goto errout;
    }
    /*
     * Initialize the first two sectors of the log
     */
    error = lufs_initialize(ufsvfsp, logbtodb(fs, ebp->extents[0].pbno),
        tb, flp);
    if (error)
        goto errout;

    /*
     * We are done initializing the allocation block and the log
     */
    brelse(bp);
    bp = NULL;

    /*
     * Update the superblock and push the dirty metadata
     */
    ufsvfsp->vfs_ulockfs.ul_sbowner = curthread;
    sbupdate(ufsvfsp->vfs_vfs);
    ufsvfsp->vfs_ulockfs.ul_sbowner = (kthread_id_t)-1;
    bflush(ufsvfsp->vfs_dev);
    error = bfinval(ufsvfsp->vfs_dev, 1);
    if (error)
        goto errout;
    if (ufsvfsp->vfs_bufp->b_flags & B_ERROR) {
        error = EIO;
        goto errout;
    }

    /*
     * Everything is safely on disk; update log space pointer in sb
     */
    ufsvfsp->vfs_ulockfs.ul_sbowner = curthread;
    mutex_enter(&ufsvfsp->vfs_lock);
    fs->fs_logbno = (uint32_t)logbno;
    ufs_sbwrite(ufsvfsp);
    mutex_exit(&ufsvfsp->vfs_lock);
    ufsvfsp->vfs_ulockfs.ul_sbowner = (kthread_id_t)-1;

    /*
     * Free the dummy inode
     */
    rw_exit(&ip->i_contents);
    ufs_free_inode(ip);

    /* inform user of real log size */
    flp->nbytes_actual = tb;
    return (0);

errout:
    /*
     * Free all resources
     */
    if (bp)
        brelse(bp);
    if (logbno) {
        fs->fs_logbno = logbno;
        (void) lufs_free(ufsvfsp);
    }
    if (ip) {
        rw_exit(&ip->i_contents);
        ufs_free_inode(ip);
    }
    return (error);
}

/*
 * Disable logging
 */
int
lufs_disable(vnode_t *vp, struct fiolog *flp)
{
    int     error = 0;
    inode_t     *ip = VTOI(vp);
    ufsvfs_t    *ufsvfsp = ip->i_ufsvfs;
    struct fs   *fs = ufsvfsp->vfs_fs;
    struct lockfs   lf;
    struct ulockfs  *ulp;

    flp->error = FIOLOG_ENONE;

    /*
     * Logging is already disabled; done
     */
    if (fs->fs_logbno == 0 || ufsvfsp->vfs_log == NULL)
        return (0);

    /*
     * Readonly file system
     */
    if (fs->fs_ronly) {
        flp->error = FIOLOG_EROFS;
        return (0);
    }

    /*
     * File system must be write locked to disable logging
     */
    error = ufs_fiolfss(vp, &lf);
    if (error) {
        return (error);
    }
    if (!LOCKFS_IS_ULOCK(&lf)) {
        flp->error = FIOLOG_EULOCK;
        return (0);
    }
    lf.lf_lock = LOCKFS_WLOCK;
    lf.lf_flags = 0;
    lf.lf_comment = NULL;
    error = ufs_fiolfs(vp, &lf, 1);
    if (error) {
        flp->error = FIOLOG_EWLOCK;
        return (0);
    }

    if (ufsvfsp->vfs_log == NULL || fs->fs_logbno == 0)
        goto errout;

    /*
     * WE ARE COMMITTED TO DISABLING LOGGING PAST THIS POINT
     */

    /*
     * Disable logging:
     * Suspend the reclaim thread and force the delete thread to exit.
     *  When a nologging mount has completed there may still be
     *  work for reclaim to do so just suspend this thread until
     *  it's [deadlock-] safe for it to continue.  The delete
     *  thread won't be needed as ufs_iinactive() calls
     *  ufs_delete() when logging is disabled.
     * Freeze and drain reader ops.
     *  Commit any outstanding reader transactions (ufs_flush).
     *  Set the ``unmounted'' bit in the ufstrans struct.
     *  If debug, remove metadata from matamap.
     *  Disable matamap processing.
     *  NULL the trans ops table.
     *  Free all of the incore structs related to logging.
     * Allow reader ops.
     */
    ufs_thread_suspend(&ufsvfsp->vfs_reclaim);
    ufs_thread_exit(&ufsvfsp->vfs_delete);

    vfs_lock_wait(ufsvfsp->vfs_vfs);
    ulp = &ufsvfsp->vfs_ulockfs;
    mutex_enter(&ulp->ul_lock);
    atomic_inc_ulong(&ufs_quiesce_pend);
    (void) ufs_quiesce(ulp);

    (void) ufs_flush(ufsvfsp->vfs_vfs);

    TRANS_MATA_UMOUNT(ufsvfsp);
    ufsvfsp->vfs_domatamap = 0;

    /*
     * Free all of the incore structs
     * Aquire the ufs_scan_lock before de-linking the mtm data
     * structure so that we keep ufs_sync() and ufs_update() away
     * when they execute the ufs_scan_inodes() run while we're in
     * progress of enabling/disabling logging.
     */
    mutex_enter(&ufs_scan_lock);
    (void) lufs_unsnarf(ufsvfsp);
    mutex_exit(&ufs_scan_lock);

    atomic_dec_ulong(&ufs_quiesce_pend);
    mutex_exit(&ulp->ul_lock);
    vfs_setmntopt(ufsvfsp->vfs_vfs, MNTOPT_NOLOGGING, NULL, 0);
    vfs_unlock(ufsvfsp->vfs_vfs);

    fs->fs_rolled = FS_ALL_ROLLED;
    ufsvfsp->vfs_nolog_si = 0;

    /*
     * Free the log space and mark the superblock as FSACTIVE
     */
    (void) lufs_free(ufsvfsp);

    /*
     * Allow the reclaim thread to continue.
     */
    ufs_thread_continue(&ufsvfsp->vfs_reclaim);

    /*
     * Unlock the file system
     */
    lf.lf_lock = LOCKFS_ULOCK;
    lf.lf_flags = 0;
    error = ufs_fiolfs(vp, &lf, 1);
    if (error)
        flp->error = FIOLOG_ENOULOCK;

    return (0);

errout:
    lf.lf_lock = LOCKFS_ULOCK;
    lf.lf_flags = 0;
    (void) ufs_fiolfs(vp, &lf, 1);
    return (error);
}

/*
 * Enable logging
 */
int
lufs_enable(struct vnode *vp, struct fiolog *flp, cred_t *cr)
{
    int     error;
    int     reclaim;
    inode_t     *ip = VTOI(vp);
    ufsvfs_t    *ufsvfsp = ip->i_ufsvfs;
    struct fs   *fs;
    ml_unit_t   *ul;
    struct lockfs   lf;
    struct ulockfs  *ulp;
    vfs_t       *vfsp = ufsvfsp->vfs_vfs;
    uint64_t    tmp_nbytes_actual;
    uint64_t    cg_minlogsize;
    uint32_t    cgsize;
    static int  minlogsizewarn = 0;
    static int  maxlogsizewarn = 0;

    /*
     * Check if logging is already enabled
     */
    if (ufsvfsp->vfs_log) {
        flp->error = FIOLOG_ETRANS;
        /* for root ensure logging option is set */
        vfs_setmntopt(vfsp, MNTOPT_LOGGING, NULL, 0);
        return (0);
    }
    fs = ufsvfsp->vfs_fs;

    /*
     * Come back here to recheck if we had to disable the log.
     */
recheck:
    error = 0;
    reclaim = 0;
    flp->error = FIOLOG_ENONE;

    /*
     * The size of the ufs log is determined using the following rules:
     *
     * 1) If no size is requested the log size is calculated as a
     *    ratio of the total file system size. By default this is
     *    1MB of log per 1GB of file system. This calculation is then
     *    capped at the log size specified by ldl_softlogcap.
     * 2) The log size requested may then be increased based on the
     *    number of cylinder groups contained in the file system.
     *    To prevent a hang the log has to be large enough to contain a
     *    single transaction that alters every cylinder group in the file
     *    system. This is calculated as cg_minlogsize.
     * 3) Finally a check is made that the log size requested is within
     *    the limits of ldl_minlogsize and ldl_maxlogsize.
     */

    /*
     * Adjust requested log size
     */
    flp->nbytes_actual = flp->nbytes_requested;
    if (flp->nbytes_actual == 0) {
        tmp_nbytes_actual =
            (((uint64_t)fs->fs_size) / ldl_divisor) << fs->fs_fshift;
        flp->nbytes_actual = (uint_t)MIN(tmp_nbytes_actual, INT_MAX);
        /*
         * The 1MB per 1GB log size allocation only applies up to
         * ldl_softlogcap size of log.
         */
        flp->nbytes_actual = MIN(flp->nbytes_actual, ldl_softlogcap);
    }

    cgsize = ldl_cgsizereq ? ldl_cgsizereq : LDL_CGSIZEREQ(fs);

    /*
     * Determine the log size required based on the number of cylinder
     * groups in the file system. The log has to be at least this size
     * to prevent possible hangs due to log space exhaustion.
     */
    cg_minlogsize = cgsize * fs->fs_ncg;

    /*
     * Ensure that the minimum log size isn't so small that it could lead
     * to a full log hang.
     */
    if (ldl_minlogsize < LDL_MINLOGSIZE) {
        ldl_minlogsize = LDL_MINLOGSIZE;
        if (!minlogsizewarn) {
            cmn_err(CE_WARN, "ldl_minlogsize too small, increasing "
                "to 0x%x", LDL_MINLOGSIZE);
            minlogsizewarn = 1;
        }
    }

    /*
     * Ensure that the maximum log size isn't greater than INT_MAX as the
     * logical log offset fields would overflow.
     */
    if (ldl_maxlogsize > INT_MAX) {
        ldl_maxlogsize = INT_MAX;
        if (!maxlogsizewarn) {
            cmn_err(CE_WARN, "ldl_maxlogsize too large, reducing "
                "to 0x%x", INT_MAX);
            maxlogsizewarn = 1;
        }
    }

    if (cg_minlogsize > ldl_maxlogsize) {
        cmn_err(CE_WARN,
            "%s: reducing calculated log size from 0x%x to "
            "ldl_maxlogsize (0x%x).", fs->fs_fsmnt, (int)cg_minlogsize,
            ldl_maxlogsize);
    }

    cg_minlogsize = MAX(cg_minlogsize, ldl_minlogsize);
    cg_minlogsize = MIN(cg_minlogsize, ldl_maxlogsize);

    flp->nbytes_actual = MAX(flp->nbytes_actual, cg_minlogsize);
    flp->nbytes_actual = MAX(flp->nbytes_actual, ldl_minlogsize);
    flp->nbytes_actual = MIN(flp->nbytes_actual, ldl_maxlogsize);
    flp->nbytes_actual = blkroundup(fs, flp->nbytes_actual);

    /*
     * logging is enabled and the log is the right size; done
     */
    ul = ufsvfsp->vfs_log;
    if (ul && fs->fs_logbno && (flp->nbytes_actual == ul->un_requestsize))
            return (0);

    /*
     * Readonly file system
     */
    if (fs->fs_ronly) {
        flp->error = FIOLOG_EROFS;
        return (0);
    }

    /*
     * File system must be write locked to enable logging
     */
    error = ufs_fiolfss(vp, &lf);
    if (error) {
        return (error);
    }
    if (!LOCKFS_IS_ULOCK(&lf)) {
        flp->error = FIOLOG_EULOCK;
        return (0);
    }
    lf.lf_lock = LOCKFS_WLOCK;
    lf.lf_flags = 0;
    lf.lf_comment = NULL;
    error = ufs_fiolfs(vp, &lf, 1);
    if (error) {
        flp->error = FIOLOG_EWLOCK;
        return (0);
    }

    /*
     * Grab appropriate locks to synchronize with the rest
     * of the system
     */
    vfs_lock_wait(vfsp);
    ulp = &ufsvfsp->vfs_ulockfs;
    mutex_enter(&ulp->ul_lock);

    /*
     * File system must be fairly consistent to enable logging
     */
    if (fs->fs_clean != FSLOG &&
        fs->fs_clean != FSACTIVE &&
        fs->fs_clean != FSSTABLE &&
        fs->fs_clean != FSCLEAN) {
        flp->error = FIOLOG_ECLEAN;
        goto unlockout;
    }

    /*
     * A write-locked file system is only active if there are
     * open deleted files; so remember to set FS_RECLAIM later.
     */
    if (fs->fs_clean == FSACTIVE)
        reclaim = FS_RECLAIM;

    /*
     * Logging is already enabled; must be changing the log's size
     */
    if (fs->fs_logbno && ufsvfsp->vfs_log) {
        /*
         * Before we can disable logging, we must give up our
         * lock.  As a consequence of unlocking and disabling the
         * log, the fs structure may change.  Because of this, when
         * disabling is complete, we will go back to recheck to
         * repeat all of the checks that we performed to get to
         * this point.  Disabling sets fs->fs_logbno to 0, so this
         * will not put us into an infinite loop.
         */
        mutex_exit(&ulp->ul_lock);
        vfs_unlock(vfsp);

        lf.lf_lock = LOCKFS_ULOCK;
        lf.lf_flags = 0;
        error = ufs_fiolfs(vp, &lf, 1);
        if (error) {
            flp->error = FIOLOG_ENOULOCK;
            return (0);
        }
        error = lufs_disable(vp, flp);
        if (error || (flp->error != FIOLOG_ENONE))
            return (0);
        goto recheck;
    }

    error = lufs_alloc(ufsvfsp, flp, cg_minlogsize, cr);
    if (error)
        goto errout;

    /*
     * Create all of the incore structs
     */
    error = lufs_snarf(ufsvfsp, fs, 0);
    if (error)
        goto errout;

    /*
     * DON'T ``GOTO ERROUT'' PAST THIS POINT
     */

    /*
     * Pretend we were just mounted with logging enabled
     *      Get the ops vector
     *      If debug, record metadata locations with log subsystem
     *      Start the delete thread
     *      Start the reclaim thread, if necessary
     */
    vfs_setmntopt(vfsp, MNTOPT_LOGGING, NULL, 0);

    TRANS_DOMATAMAP(ufsvfsp);
    TRANS_MATA_MOUNT(ufsvfsp);
    TRANS_MATA_SI(ufsvfsp, fs);
    ufs_thread_start(&ufsvfsp->vfs_delete, ufs_thread_delete, vfsp);
    if (fs->fs_reclaim & (FS_RECLAIM|FS_RECLAIMING)) {
        fs->fs_reclaim &= ~FS_RECLAIM;
        fs->fs_reclaim |=  FS_RECLAIMING;
        ufs_thread_start(&ufsvfsp->vfs_reclaim,
            ufs_thread_reclaim, vfsp);
    } else
        fs->fs_reclaim |= reclaim;

    mutex_exit(&ulp->ul_lock);
    vfs_unlock(vfsp);

    /*
     * Unlock the file system
     */
    lf.lf_lock = LOCKFS_ULOCK;
    lf.lf_flags = 0;
    error = ufs_fiolfs(vp, &lf, 1);
    if (error) {
        flp->error = FIOLOG_ENOULOCK;
        return (0);
    }

    /*
     * There's nothing in the log yet (we've just allocated it)
     * so directly write out the super block.
     * Note, we have to force this sb out to disk
     * (not just to the log) so that if we crash we know we are logging
     */
    mutex_enter(&ufsvfsp->vfs_lock);
    fs->fs_clean = FSLOG;
    fs->fs_rolled = FS_NEED_ROLL; /* Mark the fs as unrolled */
    UFS_BWRITE2(NULL, ufsvfsp->vfs_bufp);
    mutex_exit(&ufsvfsp->vfs_lock);

    return (0);

errout:
    /*
     * Aquire the ufs_scan_lock before de-linking the mtm data
     * structure so that we keep ufs_sync() and ufs_update() away
     * when they execute the ufs_scan_inodes() run while we're in
     * progress of enabling/disabling logging.
     */
    mutex_enter(&ufs_scan_lock);
    (void) lufs_unsnarf(ufsvfsp);
    mutex_exit(&ufs_scan_lock);

    (void) lufs_free(ufsvfsp);
unlockout:
    mutex_exit(&ulp->ul_lock);
    vfs_unlock(vfsp);

    lf.lf_lock = LOCKFS_ULOCK;
    lf.lf_flags = 0;
    (void) ufs_fiolfs(vp, &lf, 1);
    return (error);
}

void
lufs_read_strategy(ml_unit_t *ul, buf_t *bp)
{
    mt_map_t    *logmap = ul->un_logmap;
    offset_t    mof = ldbtob(bp->b_blkno);
    off_t       nb  = bp->b_bcount;
    mapentry_t  *age;
    char        *va;
    int     (*saviodone)();
    int     entire_range;

    /*
     * get a linked list of overlapping deltas
     * returns with &mtm->mtm_rwlock held
     */
    entire_range = logmap_list_get(logmap, mof, nb, &age);

    /*
     * no overlapping deltas were found; read master
     */
    if (age == NULL) {
        rw_exit(&logmap->mtm_rwlock);
        if (ul->un_flags & LDL_ERROR) {
            bp->b_flags |= B_ERROR;
            bp->b_error = EIO;
            biodone(bp);
        } else {
            ul->un_ufsvfs->vfs_iotstamp = ddi_get_lbolt();
            logstats.ls_lreads.value.ui64++;
            (void) bdev_strategy(bp);
            lwp_stat_update(LWP_STAT_INBLK, 1);
        }
        return;
    }

    va = bp_mapin_common(bp, VM_SLEEP);
    /*
     * if necessary, sync read the data from master
     *  errors are returned in bp
     */
    if (!entire_range) {
        saviodone = bp->b_iodone;
        bp->b_iodone = trans_not_done;
        logstats.ls_mreads.value.ui64++;
        (void) bdev_strategy(bp);
        lwp_stat_update(LWP_STAT_INBLK, 1);
        if (trans_not_wait(bp))
            ldl_seterror(ul, "Error reading master");
        bp->b_iodone = saviodone;
    }

    /*
     * sync read the data from the log
     *  errors are returned inline
     */
    if (ldl_read(ul, va, mof, nb, age)) {
        bp->b_flags |= B_ERROR;
        bp->b_error = EIO;
    }

    /*
     * unlist the deltas
     */
    logmap_list_put(logmap, age);

    /*
     * all done
     */
    if (ul->un_flags & LDL_ERROR) {
        bp->b_flags |= B_ERROR;
        bp->b_error = EIO;
    }
    biodone(bp);
}

void
lufs_write_strategy(ml_unit_t *ul, buf_t *bp)
{
    offset_t    mof = ldbtob(bp->b_blkno);
    off_t       nb  = bp->b_bcount;
    char        *va;
    mapentry_t  *me;

    ASSERT((nb & DEV_BMASK) == 0);
    ul->un_logmap->mtm_ref = 1;

    /*
     * if there are deltas, move into log
     */
    me = deltamap_remove(ul->un_deltamap, mof, nb);
    if (me) {

        va = bp_mapin_common(bp, VM_SLEEP);

        ASSERT(((ul->un_debug & MT_WRITE_CHECK) == 0) ||
            (ul->un_matamap == NULL)||
            matamap_within(ul->un_matamap, mof, nb));

        /*
         * move to logmap
         */
        if (ufs_crb_enable) {
            logmap_add_buf(ul, va, mof, me,
                bp->b_un.b_addr, nb);
        } else {
            logmap_add(ul, va, mof, me);
        }

        if (ul->un_flags & LDL_ERROR) {
            bp->b_flags |= B_ERROR;
            bp->b_error = EIO;
        }
        biodone(bp);
        return;
    }
    if (ul->un_flags & LDL_ERROR) {
        bp->b_flags |= B_ERROR;
        bp->b_error = EIO;
        biodone(bp);
        return;
    }

    /*
     * Check that we are not updating metadata, or if so then via B_PHYS.
     */
    ASSERT((ul->un_matamap == NULL) ||
        !(matamap_overlap(ul->un_matamap, mof, nb) &&
        ((bp->b_flags & B_PHYS) == 0)));

    ul->un_ufsvfs->vfs_iotstamp = ddi_get_lbolt();
    logstats.ls_lwrites.value.ui64++;

    /* If snapshots are enabled, write through the snapshot driver */
    if (ul->un_ufsvfs->vfs_snapshot)
        fssnap_strategy(&ul->un_ufsvfs->vfs_snapshot, bp);
    else
        (void) bdev_strategy(bp);

    lwp_stat_update(LWP_STAT_OUBLK, 1);
}

void
lufs_strategy(ml_unit_t *ul, buf_t *bp)
{
    if (bp->b_flags & B_READ)
        lufs_read_strategy(ul, bp);
    else
        lufs_write_strategy(ul, bp);
}

/* ARGSUSED */
static int
delta_stats_update(kstat_t *ksp, int rw)
{
    if (rw == KSTAT_WRITE) {
        delta_stats[DT_SB] = dkstats.ds_superblock_deltas.value.ui64;
        delta_stats[DT_CG] = dkstats.ds_bitmap_deltas.value.ui64;
        delta_stats[DT_SI] = dkstats.ds_suminfo_deltas.value.ui64;
        delta_stats[DT_AB] = dkstats.ds_allocblk_deltas.value.ui64;
        delta_stats[DT_ABZERO] = dkstats.ds_ab0_deltas.value.ui64;
        delta_stats[DT_DIR] = dkstats.ds_dir_deltas.value.ui64;
        delta_stats[DT_INODE] = dkstats.ds_inode_deltas.value.ui64;
        delta_stats[DT_FBI] = dkstats.ds_fbiwrite_deltas.value.ui64;
        delta_stats[DT_QR] = dkstats.ds_quota_deltas.value.ui64;
        delta_stats[DT_SHAD] = dkstats.ds_shadow_deltas.value.ui64;

        roll_stats[DT_SB] = dkstats.ds_superblock_rolled.value.ui64;
        roll_stats[DT_CG] = dkstats.ds_bitmap_rolled.value.ui64;
        roll_stats[DT_SI] = dkstats.ds_suminfo_rolled.value.ui64;
        roll_stats[DT_AB] = dkstats.ds_allocblk_rolled.value.ui64;
        roll_stats[DT_ABZERO] = dkstats.ds_ab0_rolled.value.ui64;
        roll_stats[DT_DIR] = dkstats.ds_dir_rolled.value.ui64;
        roll_stats[DT_INODE] = dkstats.ds_inode_rolled.value.ui64;
        roll_stats[DT_FBI] = dkstats.ds_fbiwrite_rolled.value.ui64;
        roll_stats[DT_QR] = dkstats.ds_quota_rolled.value.ui64;
        roll_stats[DT_SHAD] = dkstats.ds_shadow_rolled.value.ui64;
    } else {
        dkstats.ds_superblock_deltas.value.ui64 = delta_stats[DT_SB];
        dkstats.ds_bitmap_deltas.value.ui64 = delta_stats[DT_CG];
        dkstats.ds_suminfo_deltas.value.ui64 = delta_stats[DT_SI];
        dkstats.ds_allocblk_deltas.value.ui64 = delta_stats[DT_AB];
        dkstats.ds_ab0_deltas.value.ui64 = delta_stats[DT_ABZERO];
        dkstats.ds_dir_deltas.value.ui64 = delta_stats[DT_DIR];
        dkstats.ds_inode_deltas.value.ui64 = delta_stats[DT_INODE];
        dkstats.ds_fbiwrite_deltas.value.ui64 = delta_stats[DT_FBI];
        dkstats.ds_quota_deltas.value.ui64 = delta_stats[DT_QR];
        dkstats.ds_shadow_deltas.value.ui64 = delta_stats[DT_SHAD];

        dkstats.ds_superblock_rolled.value.ui64 = roll_stats[DT_SB];
        dkstats.ds_bitmap_rolled.value.ui64 = roll_stats[DT_CG];
        dkstats.ds_suminfo_rolled.value.ui64 = roll_stats[DT_SI];
        dkstats.ds_allocblk_rolled.value.ui64 = roll_stats[DT_AB];
        dkstats.ds_ab0_rolled.value.ui64 = roll_stats[DT_ABZERO];
        dkstats.ds_dir_rolled.value.ui64 = roll_stats[DT_DIR];
        dkstats.ds_inode_rolled.value.ui64 = roll_stats[DT_INODE];
        dkstats.ds_fbiwrite_rolled.value.ui64 = roll_stats[DT_FBI];
        dkstats.ds_quota_rolled.value.ui64 = roll_stats[DT_QR];
        dkstats.ds_shadow_rolled.value.ui64 = roll_stats[DT_SHAD];
    }
    return (0);
}

extern size_t ufs_crb_limit;
extern int ufs_max_crb_divisor;

void
lufs_init(void)
{
    kstat_t *ksp;

    /* Create kmem caches */
    lufs_sv = kmem_cache_create("lufs_save", sizeof (lufs_save_t), 0,
        NULL, NULL, NULL, NULL, NULL, 0);
    lufs_bp = kmem_cache_create("lufs_bufs", sizeof (lufs_buf_t), 0,
        NULL, NULL, NULL, NULL, NULL, 0);

    mutex_init(&log_mutex, NULL, MUTEX_DEFAULT, NULL);

    _init_top();

    if (bio_lufs_strategy == NULL)
        bio_lufs_strategy = (void (*) (void *, buf_t *)) lufs_strategy;

    /*
     * Initialise general logging and delta kstats
     */
    ksp = kstat_create("ufs_log", 0, "logstats", "ufs", KSTAT_TYPE_NAMED,
        sizeof (logstats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
    if (ksp) {
        ksp->ks_data = (void *) &logstats;
        kstat_install(ksp);
    }

    ksp = kstat_create("ufs_log", 0, "deltastats", "ufs", KSTAT_TYPE_NAMED,
        sizeof (dkstats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
    if (ksp) {
        ksp->ks_data = (void *) &dkstats;
        ksp->ks_update = delta_stats_update;
        kstat_install(ksp);
    }

    /* Initialize  generation of logging ids */
    lufs_genid_init();

    /*
     * Set up the maximum amount of kmem that the crbs (system wide)
     * can use.
     */
    ufs_crb_limit = kmem_maxavail() / ufs_max_crb_divisor;
}