8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / uts / common / fs / ufs / ufs_alloc.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.
 */

/*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
/*        All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#include <sys/condvar_impl.h>
#include <sys/types.h>
#include <sys/t_lock.h>
#include <sys/debug.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/signal.h>
#include <sys/cred.h>
#include <sys/proc.h>
#include <sys/disp.h>
#include <sys/user.h>
#include <sys/buf.h>
#include <sys/vfs.h>
#include <sys/vnode.h>
#include <sys/acl.h>
#include <sys/fs/ufs_fs.h>
#include <sys/fs/ufs_inode.h>
#include <sys/fs/ufs_acl.h>
#include <sys/fs/ufs_bio.h>
#include <sys/fs/ufs_quota.h>
#include <sys/kmem.h>
#include <sys/fs/ufs_trans.h>
#include <sys/fs/ufs_panic.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/sysmacros.h>
#include <sys/file.h>
#include <sys/fcntl.h>
#include <sys/flock.h>
#include <fs/fs_subr.h>
#include <sys/cmn_err.h>
#include <sys/policy.h>
#include <sys/fs/ufs_log.h>

static ino_t    hashalloc();
static daddr_t  fragextend();
static daddr_t  alloccg();
static daddr_t  alloccgblk();
static ino_t    ialloccg();
static daddr_t  mapsearch();
static int      findlogstartcg();

extern int      inside[], around[];
extern uchar_t  *fragtbl[];
void delay();

/*
 * Allocate a block in the file system.
 *
 * The size of the requested block is given, which must be some
 * multiple of fs_fsize and <= fs_bsize.
 * A preference may be optionally specified. If a preference is given
 * the following hierarchy is used to allocate a block:
 *   1) allocate the requested block.
 *   2) allocate a rotationally optimal block in the same cylinder.
 *   3) allocate a block in the same cylinder group.
 *   4) quadratically rehash into other cylinder groups, until an
 *      available block is located.
 * If no block preference is given the following hierarchy is used
 * to allocate a block:
 *   1) allocate a block in the cylinder group that contains the
 *      inode for the file.
 *   2) quadratically rehash into other cylinder groups, until an
 *      available block is located.
 */
int
alloc(struct inode *ip, daddr_t bpref, int size, daddr_t *bnp, cred_t *cr)
{
        struct fs *fs;
        struct ufsvfs *ufsvfsp;
        daddr_t bno;
        int cg;
        int err;
        char *errmsg = NULL;
        size_t len;
        clock_t now;

        ufsvfsp = ip->i_ufsvfs;
        fs = ufsvfsp->vfs_fs;
        if ((unsigned)size > fs->fs_bsize || fragoff(fs, size) != 0) {
                err = ufs_fault(ITOV(ip), "alloc: bad size, dev = 0x%lx,"
                    " bsize = %d, size = %d, fs = %s\n",
                    ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
                return (err);
        }
        if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)
                goto nospace;
        if (freespace(fs, ufsvfsp) <= 0 &&
            secpolicy_fs_minfree(cr, ufsvfsp->vfs_vfs) != 0)
                goto nospace;
        err = chkdq(ip, (long)btodb(size), 0, cr, &errmsg, &len);
        /* Note that may not have err, but may have errmsg */
        if (errmsg != NULL) {
                uprintf(errmsg);
                kmem_free(errmsg, len);
                errmsg = NULL;
        }
        if (err)
                return (err);
        if (bpref >= fs->fs_size)
                bpref = 0;
        if (bpref == 0)
                cg = (int)itog(fs, ip->i_number);
        else
                cg = dtog(fs, bpref);

        bno = (daddr_t)hashalloc(ip, cg, (long)bpref, size,
            (ulong_t (*)())alloccg);
        if (bno > 0) {
                *bnp = bno;
                return (0);
        }

        /*
         * hashalloc() failed because some other thread grabbed
         * the last block so unwind the quota operation.  We can
         * ignore the return because subtractions don't fail and
         * size is guaranteed to be >= zero by our caller.
         */
        (void) chkdq(ip, -(long)btodb(size), 0, cr, (char **)NULL,
            (size_t *)NULL);

nospace:
        now = ddi_get_lbolt();
        mutex_enter(&ufsvfsp->vfs_lock);
        if ((now - ufsvfsp->vfs_lastwhinetime) > (hz << 2) &&
            (!(TRANS_ISTRANS(ufsvfsp)) || !(ip->i_flag & IQUIET))) {
                ufsvfsp->vfs_lastwhinetime = now;
                cmn_err(CE_NOTE, "alloc: %s: file system full", fs->fs_fsmnt);
        }
        mutex_exit(&ufsvfsp->vfs_lock);
        return (ENOSPC);
}

/*
 * Reallocate a fragment to a bigger size
 *
 * The number and size of the old block is given, and a preference
 * and new size is also specified.  The allocator attempts to extend
 * the original block.  Failing that, the regular block allocator is
 * invoked to get an appropriate block.
 */
int
realloccg(struct inode *ip, daddr_t bprev, daddr_t bpref, int osize,
    int nsize, daddr_t *bnp, cred_t *cr)
{
        daddr_t bno;
        struct fs *fs;
        struct ufsvfs *ufsvfsp;
        int cg, request;
        int err;
        char *errmsg = NULL;
        size_t len;
        clock_t now;

        ufsvfsp = ip->i_ufsvfs;
        fs = ufsvfsp->vfs_fs;
        if ((unsigned)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||
            (unsigned)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {
                err = ufs_fault(ITOV(ip),
                    "realloccg: bad size, dev=0x%lx, bsize=%d, "
                    "osize=%d, nsize=%d, fs=%s\n",
                    ip->i_dev, fs->fs_bsize, osize, nsize, fs->fs_fsmnt);
                return (err);
        }
        if (freespace(fs, ufsvfsp) <= 0 &&
            secpolicy_fs_minfree(cr, ufsvfsp->vfs_vfs) != 0)
                goto nospace;
        if (bprev == 0) {
                err = ufs_fault(ITOV(ip),
                    "realloccg: bad bprev, dev = 0x%lx, bsize = %d,"
                    " bprev = %ld, fs = %s\n", ip->i_dev, fs->fs_bsize, bprev,
                    fs->fs_fsmnt);
                return (err);
        }
        err = chkdq(ip, (long)btodb(nsize - osize), 0, cr, &errmsg, &len);
        /* Note that may not have err, but may have errmsg */
        if (errmsg != NULL) {
                uprintf(errmsg);
                kmem_free(errmsg, len);
                errmsg = NULL;
        }
        if (err)
                return (err);
        cg = dtog(fs, bprev);
        bno = fragextend(ip, cg, (long)bprev, osize, nsize);
        if (bno != 0) {
                *bnp = bno;
                return (0);
        }
        if (bpref >= fs->fs_size)
                bpref = 0;

        /*
         * When optimizing for time we allocate a full block and
         * then only use the upper portion for this request. When
         * this file grows again it will grow into the unused portion
         * of the block (See fragextend() above).  This saves time
         * because an extra disk write would be needed if the frags
         * following the current allocation were not free. The extra
         * disk write is needed to move the data from its current
         * location into the newly allocated position.
         *
         * When optimizing for space we allocate a run of frags
         * that is just the right size for this request.
         */
        request = (fs->fs_optim == FS_OPTTIME) ? fs->fs_bsize : nsize;
        bno = (daddr_t)hashalloc(ip, cg, (long)bpref, request,
            (ulong_t (*)())alloccg);
        if (bno > 0) {
                *bnp = bno;
                if (nsize < request)
                        (void) free(ip, bno + numfrags(fs, nsize),
                            (off_t)(request - nsize), I_NOCANCEL);
                return (0);
        }

        /*
         * hashalloc() failed because some other thread grabbed
         * the last block so unwind the quota operation.  We can
         * ignore the return because subtractions don't fail, and
         * our caller guarantees nsize >= osize.
         */
        (void) chkdq(ip, -(long)btodb(nsize - osize), 0, cr, (char **)NULL,
            (size_t *)NULL);

nospace:
        now = ddi_get_lbolt();
        mutex_enter(&ufsvfsp->vfs_lock);
        if ((now - ufsvfsp->vfs_lastwhinetime) > (hz << 2) &&
            (!(TRANS_ISTRANS(ufsvfsp)) || !(ip->i_flag & IQUIET))) {
                ufsvfsp->vfs_lastwhinetime = now;
                cmn_err(CE_NOTE,
                    "realloccg %s: file system full", fs->fs_fsmnt);
        }
        mutex_exit(&ufsvfsp->vfs_lock);
        return (ENOSPC);
}

/*
 * Allocate an inode in the file system.
 *
 * A preference may be optionally specified. If a preference is given
 * the following hierarchy is used to allocate an inode:
 *   1) allocate the requested inode.
 *   2) allocate an inode in the same cylinder group.
 *   3) quadratically rehash into other cylinder groups, until an
 *      available inode is located.
 * If no inode preference is given the following hierarchy is used
 * to allocate an inode:
 *   1) allocate an inode in cylinder group 0.
 *   2) quadratically rehash into other cylinder groups, until an
 *      available inode is located.
 */
int
ufs_ialloc(struct inode *pip,
    ino_t ipref, mode_t mode, struct inode **ipp, cred_t *cr)
{
        struct inode *ip;
        struct fs *fs;
        int cg;
        ino_t ino;
        int err;
        int nifree;
        struct ufsvfs *ufsvfsp = pip->i_ufsvfs;
        char *errmsg = NULL;
        size_t len;

        ASSERT(RW_WRITE_HELD(&pip->i_rwlock));
        fs = pip->i_fs;
loop:
        nifree = fs->fs_cstotal.cs_nifree;

        if (nifree == 0)
                goto noinodes;
        /*
         * Shadow inodes don't count against a user's inode allocation.
         * They are an implementation method and not a resource.
         */
        if ((mode != IFSHAD) && (mode != IFATTRDIR)) {
                err = chkiq((struct ufsvfs *)ITOV(pip)->v_vfsp->vfs_data,
                    /* change */ 1, (struct inode *)NULL, crgetuid(cr), 0,
                    cr, &errmsg, &len);
                /*
                 * As we haven't acquired any locks yet, dump the message
                 * now.
                 */
                if (errmsg != NULL) {
                        uprintf(errmsg);
                        kmem_free(errmsg, len);
                        errmsg = NULL;
                }
                if (err)
                        return (err);
        }

        if (ipref >= (ulong_t)(fs->fs_ncg * fs->fs_ipg))
                ipref = 0;
        cg = (int)itog(fs, ipref);
        ino = (ino_t)hashalloc(pip, cg, (long)ipref, (int)mode,
            (ulong_t (*)())ialloccg);
        if (ino == 0) {
                if ((mode != IFSHAD) && (mode != IFATTRDIR)) {
                        /*
                         * We can safely ignore the return from chkiq()
                         * because deallocations can only fail if we
                         * can't get the user's quota info record off
                         * the disk due to an I/O error.  In that case,
                         * the quota subsystem is already messed up.
                         */
                        (void) chkiq(ufsvfsp, /* change */ -1,
                            (struct inode *)NULL, crgetuid(cr), 0, cr,
                            (char **)NULL, (size_t *)NULL);
                }
                goto noinodes;
        }
        err = ufs_iget(pip->i_vfs, ino, ipp, cr);
        if (err) {
                if ((mode != IFSHAD) && (mode != IFATTRDIR)) {
                        /*
                         * See above comment about why it is safe to ignore an
                         * error return here.
                         */
                        (void) chkiq(ufsvfsp, /* change */ -1,
                            (struct inode *)NULL, crgetuid(cr), 0, cr,
                            (char **)NULL, (size_t *)NULL);
                }
                ufs_ifree(pip, ino, 0);
                return (err);
        }
        ip = *ipp;
        ASSERT(!ip->i_ufs_acl);
        ASSERT(!ip->i_dquot);
        rw_enter(&ip->i_contents, RW_WRITER);

        /*
         * Check if we really got a free inode, if not then complain
         * and mark the inode ISTALE so that it will be freed by the
         * ufs idle thread eventually and will not be sent to ufs_delete().
         */
        if (ip->i_mode || (ip->i_nlink > 0)) {
                ip->i_flag |= ISTALE;
                rw_exit(&ip->i_contents);
                VN_RELE(ITOV(ip));
                cmn_err(CE_WARN,
                    "%s: unexpected allocated inode %d, run fsck(1M)%s",
                    fs->fs_fsmnt, (int)ino,
                    (TRANS_ISTRANS(ufsvfsp) ? " -o f" : ""));
                goto loop;
        }

        /*
         * Check the inode has no size or data blocks.
         * This could have happened if the truncation failed when
         * deleting the inode. It used to be possible for this to occur
         * if a block allocation failed when iteratively truncating a
         * large file using logging and with a full file system.
         * This was fixed with bug fix 4348738. However, truncation may
         * still fail on an IO error. So in all cases for safety and
         * security we clear out the size; the blocks allocated; and
         * pointers to the blocks. This will ultimately cause a fsck
         * error of un-accounted for blocks, but its a fairly benign error,
         * and possibly the correct thing to do anyway as accesssing those
         * blocks agains may lead to more IO errors.
         */
        if (ip->i_size || ip->i_blocks) {
                int i;

                if (ip->i_size) {
                        cmn_err(CE_WARN,
                            "%s: free inode %d had size 0x%llx, run fsck(1M)%s",
                            fs->fs_fsmnt, (int)ino, ip->i_size,
                            (TRANS_ISTRANS(ufsvfsp) ? " -o f" : ""));
                }
                /*
                 * Clear any garbage left behind.
                 */
                ip->i_size = (u_offset_t)0;
                ip->i_blocks = 0;
                for (i = 0; i < NDADDR; i++)
                        ip->i_db[i] = 0;
                for (i = 0; i < NIADDR; i++)
                        ip->i_ib[i] = 0;
        }

        /*
         * Initialize the link count
         */
        ip->i_nlink = 0;

        /*
         * Clear the old flags
         */
        ip->i_flag &= IREF;

        /*
         * Access times are not really defined if the fs is mounted
         * with 'noatime'. But it can cause nfs clients to fail
         * open() if the atime is not a legal value. Set a legal value
         * here when the inode is allocated.
         */
        if (ufsvfsp->vfs_noatime) {
                mutex_enter(&ufs_iuniqtime_lock);
                ip->i_atime = iuniqtime;
                mutex_exit(&ufs_iuniqtime_lock);
        }
        rw_exit(&ip->i_contents);
        return (0);
noinodes:
        if (!(TRANS_ISTRANS(ufsvfsp)) || !(pip->i_flag & IQUIET))
                cmn_err(CE_NOTE, "%s: out of inodes\n", fs->fs_fsmnt);
        return (ENOSPC);
}

/*
 * Find a cylinder group to place a directory.
 * Returns an inumber within the selected cylinder group.
 * Note, the vfs_lock is not needed as we don't require exact cg summary info.
 *
 * If the switch ufs_close_dirs is set, then the policy is to use
 * the current cg if it has more than 25% free inodes and more
 * than 25% free blocks. Otherwise the cgs are searched from
 * the beginning and the first cg with the same criteria is
 * used. If that is also null then we revert to the old algorithm.
 * This tends to cluster files at the beginning of the disk
 * until the disk gets full.
 *
 * Otherwise if ufs_close_dirs is not set then the original policy is
 * used which is to select from among those cylinder groups with
 * above the average number of free inodes, the one with the smallest
 * number of directories.
 */

int ufs_close_dirs = 1; /* allocate directories close as possible */

ino_t
dirpref(inode_t *dp)
{
        int cg, minndir, mincg, avgifree, mininode, minbpg, ifree;
        struct fs *fs = dp->i_fs;

        cg = itog(fs, dp->i_number);
        mininode = fs->fs_ipg >> 2;
        minbpg = fs->fs_maxbpg >> 2;
        if (ufs_close_dirs &&
            (fs->fs_cs(fs, cg).cs_nifree > mininode) &&
            (fs->fs_cs(fs, cg).cs_nbfree > minbpg)) {
                return (dp->i_number);
        }

        avgifree = fs->fs_cstotal.cs_nifree / fs->fs_ncg;
        minndir = fs->fs_ipg;
        mincg = 0;
        for (cg = 0; cg < fs->fs_ncg; cg++) {
                ifree = fs->fs_cs(fs, cg).cs_nifree;
                if (ufs_close_dirs &&
                    (ifree > mininode) &&
                    (fs->fs_cs(fs, cg).cs_nbfree > minbpg)) {
                        return ((ino_t)(fs->fs_ipg * cg));
                }
                if ((fs->fs_cs(fs, cg).cs_ndir < minndir) &&
                    (ifree >= avgifree)) {
                        mincg = cg;
                        minndir = fs->fs_cs(fs, cg).cs_ndir;
                }
        }
        return ((ino_t)(fs->fs_ipg * mincg));
}

/*
 * Select the desired position for the next block in a file.  The file is
 * logically divided into sections. The first section is composed of the
 * direct blocks. Each additional section contains fs_maxbpg blocks.
 *
 * If no blocks have been allocated in the first section, the policy is to
 * request a block in the same cylinder group as the inode that describes
 * the file. If no blocks have been allocated in any other section, the
 * policy is to place the section in a cylinder group with a greater than
 * average number of free blocks.  An appropriate cylinder group is found
 * by using a rotor that sweeps the cylinder groups. When a new group of
 * blocks is needed, the sweep begins in the cylinder group following the
 * cylinder group from which the previous allocation was made. The sweep
 * continues until a cylinder group with greater than the average number
 * of free blocks is found. If the allocation is for the first block in an
 * indirect block, the information on the previous allocation is unavailable;
 * here a best guess is made based upon the logical block number being
 * allocated.
 *
 * If a section is already partially allocated, the policy is to
 * contiguously allocate fs_maxcontig blocks.  The end of one of these
 * contiguous blocks and the beginning of the next is physically separated
 * so that the disk head will be in transit between them for at least
 * fs_rotdelay milliseconds.  This is to allow time for the processor to
 * schedule another I/O transfer.
 */
daddr_t
blkpref(struct inode *ip, daddr_t lbn, int indx, daddr32_t *bap)
{
        struct fs *fs;
        struct ufsvfs *ufsvfsp;
        int cg;
        int avgbfree, startcg;
        daddr_t nextblk;

        ufsvfsp = ip->i_ufsvfs;
        fs = ip->i_fs;
        if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {
                if (lbn < NDADDR) {
                        cg = itog(fs, ip->i_number);
                        return (fs->fs_fpg * cg + fs->fs_frag);
                }
                /*
                 * Find a cylinder with greater than average
                 * number of unused data blocks.
                 */
                if (indx == 0 || bap[indx - 1] == 0)
                        startcg = itog(fs, ip->i_number) + lbn / fs->fs_maxbpg;
                else
                        startcg = dtog(fs, bap[indx - 1]) + 1;
                startcg %= fs->fs_ncg;

                mutex_enter(&ufsvfsp->vfs_lock);
                avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
                /*
                 * used for computing log space for writes/truncs
                 */
                ufsvfsp->vfs_avgbfree = avgbfree;
                for (cg = startcg; cg < fs->fs_ncg; cg++)
                        if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
                                fs->fs_cgrotor = cg;
                                mutex_exit(&ufsvfsp->vfs_lock);
                                return (fs->fs_fpg * cg + fs->fs_frag);
                        }
                for (cg = 0; cg <= startcg; cg++)
                        if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
                                fs->fs_cgrotor = cg;
                                mutex_exit(&ufsvfsp->vfs_lock);
                                return (fs->fs_fpg * cg + fs->fs_frag);
                        }
                mutex_exit(&ufsvfsp->vfs_lock);
                return (NULL);
        }
        /*
         * One or more previous blocks have been laid out. If less
         * than fs_maxcontig previous blocks are contiguous, the
         * next block is requested contiguously, otherwise it is
         * requested rotationally delayed by fs_rotdelay milliseconds.
         */

        nextblk = bap[indx - 1];
        /*
         * Provision for fallocate to return positive
         * blk preference based on last allocation
         */
        if (nextblk < 0 && nextblk != UFS_HOLE) {
                nextblk = (-bap[indx - 1]) + fs->fs_frag;
        } else {
                nextblk = bap[indx - 1] + fs->fs_frag;
        }

        if (indx > fs->fs_maxcontig && bap[indx - fs->fs_maxcontig] +
            blkstofrags(fs, fs->fs_maxcontig) != nextblk) {
                return (nextblk);
        }
        if (fs->fs_rotdelay != 0)
                /*
                 * Here we convert ms of delay to frags as:
                 * (frags) = (ms) * (rev/sec) * (sect/rev) /
                 *      ((sect/frag) * (ms/sec))
                 * then round up to the next block.
                 */
                nextblk += roundup(fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect /
                    (NSPF(fs) * 1000), fs->fs_frag);
        return (nextblk);
}

/*
 * Free a block or fragment.
 *
 * The specified block or fragment is placed back in the
 * free map. If a fragment is deallocated, a possible
 * block reassembly is checked.
 */
void
free(struct inode *ip, daddr_t bno, off_t size, int flags)
{
        struct fs *fs = ip->i_fs;
        struct ufsvfs *ufsvfsp = ip->i_ufsvfs;
        struct ufs_q *delq = &ufsvfsp->vfs_delete;
        struct ufs_delq_info *delq_info = &ufsvfsp->vfs_delete_info;
        struct cg *cgp;
        struct buf *bp;
        int cg, bmap, bbase;
        int i;
        uchar_t *blksfree;
        int *blktot;
        short *blks;
        daddr_t blkno, cylno, rpos;

        /*
         * fallocate'd files will have negative block address.
         * So negate it again to get original block address.
         */
        if (bno < 0 && (bno % fs->fs_frag == 0) && bno != UFS_HOLE) {
                bno = -bno;
        }

        if ((unsigned long)size > fs->fs_bsize || fragoff(fs, size) != 0) {
                (void) ufs_fault(ITOV(ip),
                    "free: bad size, dev = 0x%lx, bsize = %d, size = %d, "
                    "fs = %s\n", ip->i_dev, fs->fs_bsize,
                    (int)size, fs->fs_fsmnt);
                return;
        }
        cg = dtog(fs, bno);
        ASSERT(!ufs_badblock(ip, bno));
        bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
            (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || !cg_chkmagic(cgp)) {
                brelse(bp);
                return;
        }

        if (!(flags & I_NOCANCEL))
                TRANS_CANCEL(ufsvfsp, ldbtob(fsbtodb(fs, bno)), size, flags);
        if (flags & (I_DIR|I_IBLK|I_SHAD|I_QUOTA)) {
                TRANS_MATA_FREE(ufsvfsp, ldbtob(fsbtodb(fs, bno)), size);
        }
        blksfree = cg_blksfree(cgp);
        blktot = cg_blktot(cgp);
        mutex_enter(&ufsvfsp->vfs_lock);
        cgp->cg_time = gethrestime_sec();
        bno = dtogd(fs, bno);
        if (size == fs->fs_bsize) {
                blkno = fragstoblks(fs, bno);
                cylno = cbtocylno(fs, bno);
                rpos = cbtorpos(ufsvfsp, bno);
                blks = cg_blks(ufsvfsp, cgp, cylno);
                if (!isclrblock(fs, blksfree, blkno)) {
                        mutex_exit(&ufsvfsp->vfs_lock);
                        brelse(bp);
                        (void) ufs_fault(ITOV(ip), "free: freeing free block, "
                            "dev:0x%lx, block:%ld, ino:%lu, fs:%s",
                            ip->i_dev, bno, ip->i_number, fs->fs_fsmnt);
                        return;
                }
                setblock(fs, blksfree, blkno);
                blks[rpos]++;
                blktot[cylno]++;
                cgp->cg_cs.cs_nbfree++;         /* Log below */
                fs->fs_cstotal.cs_nbfree++;
                fs->fs_cs(fs, cg).cs_nbfree++;
                if (TRANS_ISTRANS(ufsvfsp) && (flags & I_ACCT)) {
                        mutex_enter(&delq->uq_mutex);
                        delq_info->delq_unreclaimed_blocks -=
                            btodb(fs->fs_bsize);
                        mutex_exit(&delq->uq_mutex);
                }
        } else {
                bbase = bno - fragnum(fs, bno);
                /*
                 * Decrement the counts associated with the old frags
                 */
                bmap = blkmap(fs, blksfree, bbase);
                fragacct(fs, bmap, cgp->cg_frsum, -1);
                /*
                 * Deallocate the fragment
                 */
                for (i = 0; i < numfrags(fs, size); i++) {
                        if (isset(blksfree, bno + i)) {
                                brelse(bp);
                                mutex_exit(&ufsvfsp->vfs_lock);
                                (void) ufs_fault(ITOV(ip),
                                    "free: freeing free frag, "
                                    "dev:0x%lx, blk:%ld, cg:%d, "
                                    "ino:%lu, fs:%s",
                                    ip->i_dev,
                                    bno + i,
                                    cgp->cg_cgx,
                                    ip->i_number,
                                    fs->fs_fsmnt);
                                return;
                        }
                        setbit(blksfree, bno + i);
                }
                cgp->cg_cs.cs_nffree += i;
                fs->fs_cstotal.cs_nffree += i;
                fs->fs_cs(fs, cg).cs_nffree += i;
                if (TRANS_ISTRANS(ufsvfsp) && (flags & I_ACCT)) {
                        mutex_enter(&delq->uq_mutex);
                        delq_info->delq_unreclaimed_blocks -=
                            btodb(i * fs->fs_fsize);
                        mutex_exit(&delq->uq_mutex);
                }
                /*
                 * Add back in counts associated with the new frags
                 */
                bmap = blkmap(fs, blksfree, bbase);
                fragacct(fs, bmap, cgp->cg_frsum, 1);
                /*
                 * If a complete block has been reassembled, account for it
                 */
                blkno = fragstoblks(fs, bbase);
                if (isblock(fs, blksfree, blkno)) {
                        cylno = cbtocylno(fs, bbase);
                        rpos = cbtorpos(ufsvfsp, bbase);
                        blks = cg_blks(ufsvfsp, cgp, cylno);
                        blks[rpos]++;
                        blktot[cylno]++;
                        cgp->cg_cs.cs_nffree -= fs->fs_frag;
                        fs->fs_cstotal.cs_nffree -= fs->fs_frag;
                        fs->fs_cs(fs, cg).cs_nffree -= fs->fs_frag;
                        cgp->cg_cs.cs_nbfree++;
                        fs->fs_cstotal.cs_nbfree++;
                        fs->fs_cs(fs, cg).cs_nbfree++;
                }
        }
        fs->fs_fmod = 1;
        ufs_notclean(ufsvfsp);
        TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
        TRANS_SI(ufsvfsp, fs, cg);
        bdrwrite(bp);
}

/*
 * Free an inode.
 *
 * The specified inode is placed back in the free map.
 */
void
ufs_ifree(struct inode *ip, ino_t ino, mode_t mode)
{
        struct fs *fs = ip->i_fs;
        struct ufsvfs *ufsvfsp = ip->i_ufsvfs;
        struct cg *cgp;
        struct buf *bp;
        unsigned int inot;
        int cg;
        char *iused;

        if (ip->i_number == ino && ip->i_mode != 0) {
                (void) ufs_fault(ITOV(ip),
                    "ufs_ifree: illegal mode: (imode) %o, (omode) %o, ino %d, "
                    "fs = %s\n",
                    ip->i_mode, mode, (int)ip->i_number, fs->fs_fsmnt);
                return;
        }
        if (ino >= fs->fs_ipg * fs->fs_ncg) {
                (void) ufs_fault(ITOV(ip),
                    "ifree: range, dev = 0x%x, ino = %d, fs = %s\n",
                    (int)ip->i_dev, (int)ino, fs->fs_fsmnt);
                return;
        }
        cg = (int)itog(fs, ino);
        bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
            (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || !cg_chkmagic(cgp)) {
                brelse(bp);
                return;
        }
        mutex_enter(&ufsvfsp->vfs_lock);
        cgp->cg_time = gethrestime_sec();
        iused = cg_inosused(cgp);
        inot = (unsigned int)(ino % (ulong_t)fs->fs_ipg);
        if (isclr(iused, inot)) {
                mutex_exit(&ufsvfsp->vfs_lock);
                brelse(bp);
                (void) ufs_fault(ITOV(ip), "ufs_ifree: freeing free inode, "
                    "mode: (imode) %o, (omode) %o, ino:%d, "
                    "fs:%s",
                    ip->i_mode, mode, (int)ino, fs->fs_fsmnt);
                return;
        }
        clrbit(iused, inot);

        if (inot < (ulong_t)cgp->cg_irotor)
                cgp->cg_irotor = inot;
        cgp->cg_cs.cs_nifree++;
        fs->fs_cstotal.cs_nifree++;
        fs->fs_cs(fs, cg).cs_nifree++;
        if (((mode & IFMT) == IFDIR) || ((mode & IFMT) == IFATTRDIR)) {
                cgp->cg_cs.cs_ndir--;
                fs->fs_cstotal.cs_ndir--;
                fs->fs_cs(fs, cg).cs_ndir--;
        }
        fs->fs_fmod = 1;
        ufs_notclean(ufsvfsp);
        TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
        TRANS_SI(ufsvfsp, fs, cg);
        bdrwrite(bp);
}

/*
 * Implement the cylinder overflow algorithm.
 *
 * The policy implemented by this algorithm is:
 *   1) allocate the block in its requested cylinder group.
 *   2) quadratically rehash on the cylinder group number.
 *   3) brute force search for a free block.
 * The size parameter means size for data blocks, mode for inodes.
 */
static ino_t
hashalloc(struct inode *ip, int cg, long pref, int size, ulong_t (*allocator)())
{
        struct fs *fs;
        int i;
        long result;
        int icg = cg;

        fs = ip->i_fs;
        /*
         * 1: preferred cylinder group
         */
        result = (*allocator)(ip, cg, pref, size);
        if (result)
                return (result);
        /*
         * 2: quadratic rehash
         */
        for (i = 1; i < fs->fs_ncg; i *= 2) {
                cg += i;
                if (cg >= fs->fs_ncg)
                        cg -= fs->fs_ncg;
                result = (*allocator)(ip, cg, 0, size);
                if (result)
                        return (result);
        }
        /*
         * 3: brute force search
         * Note that we start at i == 2, since 0 was checked initially,
         * and 1 is always checked in the quadratic rehash.
         */
        cg = (icg + 2) % fs->fs_ncg;
        for (i = 2; i < fs->fs_ncg; i++) {
                result = (*allocator)(ip, cg, 0, size);
                if (result)
                        return (result);
                cg++;
                if (cg == fs->fs_ncg)
                        cg = 0;
        }
        return (NULL);
}

/*
 * Determine whether a fragment can be extended.
 *
 * Check to see if the necessary fragments are available, and
 * if they are, allocate them.
 */
static daddr_t
fragextend(struct inode *ip, int cg, long bprev, int osize, int nsize)
{
        struct ufsvfs *ufsvfsp = ip->i_ufsvfs;
        struct fs *fs = ip->i_fs;
        struct buf *bp;
        struct cg *cgp;
        uchar_t *blksfree;
        long bno;
        int frags, bbase;
        int i, j;

        if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, nsize - osize))
                return (NULL);
        frags = numfrags(fs, nsize);
        bbase = (int)fragnum(fs, bprev);
        if (bbase > fragnum(fs, (bprev + frags - 1))) {
                /* cannot extend across a block boundary */
                return (NULL);
        }

        bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
            (int)fs->fs_cgsize);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || !cg_chkmagic(cgp)) {
                brelse(bp);
                return (NULL);
        }

        blksfree = cg_blksfree(cgp);
        mutex_enter(&ufsvfsp->vfs_lock);
        bno = dtogd(fs, bprev);
        for (i = numfrags(fs, osize); i < frags; i++) {
                if (isclr(blksfree, bno + i)) {
                        mutex_exit(&ufsvfsp->vfs_lock);
                        brelse(bp);
                        return (NULL);
                }
                if ((TRANS_ISCANCEL(ufsvfsp, ldbtob(fsbtodb(fs, bprev + i)),
                    fs->fs_fsize))) {
                        mutex_exit(&ufsvfsp->vfs_lock);
                        brelse(bp);
                        return (NULL);
                }
        }

        cgp->cg_time = gethrestime_sec();
        /*
         * The current fragment can be extended,
         * deduct the count on fragment being extended into
         * increase the count on the remaining fragment (if any)
         * allocate the extended piece.
         */
        for (i = frags; i < fs->fs_frag - bbase; i++)
                if (isclr(blksfree, bno + i))
                        break;
        j = i - numfrags(fs, osize);
        cgp->cg_frsum[j]--;
        ASSERT(cgp->cg_frsum[j] >= 0);
        if (i != frags)
                cgp->cg_frsum[i - frags]++;
        for (i = numfrags(fs, osize); i < frags; i++) {
                clrbit(blksfree, bno + i);
                cgp->cg_cs.cs_nffree--;
                fs->fs_cs(fs, cg).cs_nffree--;
                fs->fs_cstotal.cs_nffree--;
        }
        fs->fs_fmod = 1;
        ufs_notclean(ufsvfsp);
        TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
        TRANS_SI(ufsvfsp, fs, cg);
        bdrwrite(bp);
        return ((daddr_t)bprev);
}

/*
 * Determine whether a block can be allocated.
 *
 * Check to see if a block of the apprpriate size
 * is available, and if it is, allocate it.
 */
static daddr_t
alloccg(struct inode *ip, int cg, daddr_t bpref, int size)
{
        struct ufsvfs *ufsvfsp = ip->i_ufsvfs;
        struct fs *fs = ip->i_fs;
        struct buf *bp;
        struct cg *cgp;
        uchar_t *blksfree;
        int bno, frags;
        int allocsiz;
        int i;

        /*
         * Searching for space could be time expensive so do some
         * up front checking to verify that there is actually space
         * available (free blocks or free frags).
         */
        if (fs->fs_cs(fs, cg).cs_nbfree == 0) {
                if (size == fs->fs_bsize)
                        return (0);

                /*
                 * If there are not enough free frags then return.
                 */
                if (fs->fs_cs(fs, cg).cs_nffree < numfrags(fs, size))
                        return (0);
        }

        bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
            (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || !cg_chkmagic(cgp) ||
            (cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)) {
                brelse(bp);
                return (0);
        }
        blksfree = cg_blksfree(cgp);
        mutex_enter(&ufsvfsp->vfs_lock);
        cgp->cg_time = gethrestime_sec();
        if (size == fs->fs_bsize) {
                if ((bno = alloccgblk(ufsvfsp, cgp, bpref, bp)) == 0)
                        goto errout;
                fs->fs_fmod = 1;
                ufs_notclean(ufsvfsp);
                TRANS_SI(ufsvfsp, fs, cg);
                bdrwrite(bp);
                return (bno);
        }
        /*
         * Check fragment bitmap to see if any fragments are already available.
         * mapsearch() may fail because the fragment that fits this request
         * might still be on the cancel list and not available for re-use yet.
         * Look for a bigger sized fragment to allocate first before we have
         * to give up and fragment a whole new block eventually.
         */
        frags = numfrags(fs, size);
        allocsiz = frags;
next_size:
        for (; allocsiz < fs->fs_frag; allocsiz++)
                if (cgp->cg_frsum[allocsiz] != 0)
                        break;

        if (allocsiz != fs->fs_frag) {
                bno = mapsearch(ufsvfsp, cgp, bpref, allocsiz);
                if (bno < 0 && allocsiz < (fs->fs_frag - 1)) {
                        allocsiz++;
                        goto next_size;
                }
        }

        if (allocsiz == fs->fs_frag || bno < 0) {
                /*
                 * No fragments were available, so a block
                 * will be allocated and hacked up.
                 */
                if (cgp->cg_cs.cs_nbfree == 0)
                        goto errout;
                if ((bno = alloccgblk(ufsvfsp, cgp, bpref, bp)) == 0)
                        goto errout;
                bpref = dtogd(fs, bno);
                for (i = frags; i < fs->fs_frag; i++)
                        setbit(blksfree, bpref + i);
                i = fs->fs_frag - frags;
                cgp->cg_cs.cs_nffree += i;
                fs->fs_cstotal.cs_nffree += i;
                fs->fs_cs(fs, cg).cs_nffree += i;
                cgp->cg_frsum[i]++;
                fs->fs_fmod = 1;
                ufs_notclean(ufsvfsp);
                TRANS_SI(ufsvfsp, fs, cg);
                bdrwrite(bp);
                return (bno);
        }

        for (i = 0; i < frags; i++)
                clrbit(blksfree, bno + i);
        cgp->cg_cs.cs_nffree -= frags;
        fs->fs_cstotal.cs_nffree -= frags;
        fs->fs_cs(fs, cg).cs_nffree -= frags;
        cgp->cg_frsum[allocsiz]--;
        ASSERT(cgp->cg_frsum[allocsiz] >= 0);
        if (frags != allocsiz) {
                cgp->cg_frsum[allocsiz - frags]++;
        }
        fs->fs_fmod = 1;
        ufs_notclean(ufsvfsp);
        TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
        TRANS_SI(ufsvfsp, fs, cg);
        bdrwrite(bp);
        return (cg * fs->fs_fpg + bno);
errout:
        mutex_exit(&ufsvfsp->vfs_lock);
        brelse(bp);
        return (0);
}

/*
 * Allocate a block in a cylinder group.
 *
 * This algorithm implements the following policy:
 *   1) allocate the requested block.
 *   2) allocate a rotationally optimal block in the same cylinder.
 *   3) allocate the next available block on the block rotor for the
 *      specified cylinder group.
 * Note that this routine only allocates fs_bsize blocks; these
 * blocks may be fragmented by the routine that allocates them.
 */
static daddr_t
alloccgblk(
        struct ufsvfs *ufsvfsp,
        struct cg *cgp,
        daddr_t bpref,
        struct buf *bp)
{
        daddr_t bno;
        int cylno, pos, delta, rotbl_size;
        short *cylbp;
        int i;
        struct fs *fs;
        uchar_t *blksfree;
        daddr_t blkno, rpos, frag;
        short *blks;
        int32_t *blktot;

        ASSERT(MUTEX_HELD(&ufsvfsp->vfs_lock));
        fs = ufsvfsp->vfs_fs;
        blksfree = cg_blksfree(cgp);
        if (bpref == 0) {
                bpref = cgp->cg_rotor;
                goto norot;
        }
        bpref = blknum(fs, bpref);
        bpref = dtogd(fs, bpref);
        /*
         * If the requested block is available, use it.
         */
        if (isblock(fs, blksfree, (daddr_t)fragstoblks(fs, bpref))) {
                bno = bpref;
                goto gotit;
        }
        /*
         * Check for a block available on the same cylinder.
         */
        cylno = cbtocylno(fs, bpref);
        if (cg_blktot(cgp)[cylno] == 0)
                goto norot;
        if (fs->fs_cpc == 0) {
                /*
                 * Block layout info is not available, so just
                 * have to take any block in this cylinder.
                 */
                bpref = howmany(fs->fs_spc * cylno, NSPF(fs));
                goto norot;
        }
        /*
         * Check the summary information to see if a block is
         * available in the requested cylinder starting at the
         * requested rotational position and proceeding around.
         */
        cylbp = cg_blks(ufsvfsp, cgp, cylno);
        pos = cbtorpos(ufsvfsp, bpref);
        for (i = pos; i < ufsvfsp->vfs_nrpos; i++)
                if (cylbp[i] > 0)
                        break;
        if (i == ufsvfsp->vfs_nrpos)
                for (i = 0; i < pos; i++)
                        if (cylbp[i] > 0)
                                break;
        if (cylbp[i] > 0) {
                /*
                 * Found a rotational position, now find the actual
                 * block.  A "panic" if none is actually there.
                 */

                /*
                 * Up to this point, "pos" has referred to the rotational
                 * position of the desired block.  From now on, it holds
                 * the offset of the current cylinder within a cylinder
                 * cycle.  (A cylinder cycle refers to a set of cylinders
                 * which are described by a single rotational table; the
                 * size of the cycle is fs_cpc.)
                 *
                 * bno is set to the block number of the first block within
                 * the current cylinder cycle.
                 */

                pos = cylno % fs->fs_cpc;
                bno = (cylno - pos) * fs->fs_spc / NSPB(fs);

                /*
                 * The blocks within a cylinder are grouped into equivalence
                 * classes according to their "rotational position."  There
                 * are two tables used to determine these classes.
                 *
                 * The positional offset table (fs_postbl) has an entry for
                 * each rotational position of each cylinder in a cylinder
                 * cycle.  This entry contains the relative block number
                 * (counting from the start of the cylinder cycle) of the
                 * first block in the equivalence class for that position
                 * and that cylinder.  Positions for which no blocks exist
                 * are indicated by a -1.
                 *
                 * The rotational delta table (fs_rotbl) has an entry for
                 * each block in a cylinder cycle.  This entry contains
                 * the offset from that block to the next block in the
                 * same equivalence class.  The last block in the class
                 * is indicated by a zero in the table.
                 *
                 * The following code, then, walks through all of the blocks
                 * in the cylinder (cylno) which we're allocating within
                 * which are in the equivalence class for the rotational
                 * position (i) which we're allocating within.
                 */

                if (fs_postbl(ufsvfsp, pos)[i] == -1) {
                        (void) ufs_fault(ufsvfsp->vfs_root,
                            "alloccgblk: cyl groups corrupted, pos = %d, "
                            "i = %d, fs = %s\n", pos, i, fs->fs_fsmnt);
                        return (0);
                }

                /*
                 * There is one entry in the rotational table for each block
                 * in the cylinder cycle.  These are whole blocks, not frags.
                 */

                rotbl_size = (fs->fs_cpc * fs->fs_spc) >>
                    (fs->fs_fragshift + fs->fs_fsbtodb);

                /*
                 * As we start, "i" is the rotational position within which
                 * we're searching.  After the next line, it will be a block
                 * number (relative to the start of the cylinder cycle)
                 * within the equivalence class of that rotational position.
                 */

                i = fs_postbl(ufsvfsp, pos)[i];

                for (;;) {
                        if (isblock(fs, blksfree, (daddr_t)(bno + i))) {
                                bno = blkstofrags(fs, (bno + i));
                                goto gotit;
                        }
                        delta = fs_rotbl(fs)[i];
                        if (delta <= 0 ||               /* End of chain, or */
                            delta + i > rotbl_size)     /* end of table? */
                                break;                  /* If so, panic. */
                        i += delta;
                }
                (void) ufs_fault(ufsvfsp->vfs_root,
                    "alloccgblk: can't find blk in cyl, pos:%d, i:%d, "
                    "fs:%s bno: %x\n", pos, i, fs->fs_fsmnt, (int)bno);
                return (0);
        }
norot:
        /*
         * No blocks in the requested cylinder, so take
         * next available one in this cylinder group.
         */
        bno = mapsearch(ufsvfsp, cgp, bpref, (int)fs->fs_frag);
        if (bno < 0)
                return (0);
        cgp->cg_rotor = bno;
gotit:
        blkno = fragstoblks(fs, bno);
        frag = (cgp->cg_cgx * fs->fs_fpg) + bno;
        if (TRANS_ISCANCEL(ufsvfsp, ldbtob(fsbtodb(fs, frag)), fs->fs_bsize))
                goto norot;
        clrblock(fs, blksfree, (long)blkno);
        /*
         * the other cg/sb/si fields are TRANS'ed by the caller
         */
        cgp->cg_cs.cs_nbfree--;
        fs->fs_cstotal.cs_nbfree--;
        fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;
        cylno = cbtocylno(fs, bno);
        blks = cg_blks(ufsvfsp, cgp, cylno);
        rpos = cbtorpos(ufsvfsp, bno);
        blktot = cg_blktot(cgp);
        blks[rpos]--;
        blktot[cylno]--;
        TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
        fs->fs_fmod = 1;
        return (frag);
}

/*
 * Determine whether an inode can be allocated.
 *
 * Check to see if an inode is available, and if it is,
 * allocate it using the following policy:
 *   1) allocate the requested inode.
 *   2) allocate the next available inode after the requested
 *      inode in the specified cylinder group.
 */
static ino_t
ialloccg(struct inode *ip, int cg, daddr_t ipref, int mode)
{
        struct ufsvfs *ufsvfsp = ip->i_ufsvfs;
        struct fs *fs = ip->i_fs;
        struct cg *cgp;
        struct buf *bp;
        int start, len, loc, map, i;
        char *iused;

        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (0);
        bp = UFS_BREAD(ufsvfsp, ip->i_dev, (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
            (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || !cg_chkmagic(cgp) ||
            cgp->cg_cs.cs_nifree == 0) {
                brelse(bp);
                return (0);
        }
        iused = cg_inosused(cgp);
        mutex_enter(&ufsvfsp->vfs_lock);
        /*
         * While we are waiting for the mutex, someone may have taken
         * the last available inode.  Need to recheck.
         */
        if (cgp->cg_cs.cs_nifree == 0) {
                mutex_exit(&ufsvfsp->vfs_lock);
                brelse(bp);
                return (0);
        }

        cgp->cg_time = gethrestime_sec();
        if (ipref) {
                ipref %= fs->fs_ipg;
                if (isclr(iused, ipref))
                        goto gotit;
        }
        start = cgp->cg_irotor / NBBY;
        len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);
        loc = skpc(0xff, (uint_t)len, &iused[start]);
        if (loc == 0) {
                len = start + 1;
                start = 0;
                loc = skpc(0xff, (uint_t)len, &iused[0]);
                if (loc == 0) {
                        mutex_exit(&ufsvfsp->vfs_lock);
                        (void) ufs_fault(ITOV(ip),
                            "ialloccg: map corrupted, cg = %d, irotor = %d, "
                            "fs = %s\n", cg, (int)cgp->cg_irotor, fs->fs_fsmnt);
                        return (0);
                }
        }
        i = start + len - loc;
        map = iused[i];
        ipref = i * NBBY;
        for (i = 1; i < (1 << NBBY); i <<= 1, ipref++) {
                if ((map & i) == 0) {
                        cgp->cg_irotor = ipref;
                        goto gotit;
                }
        }

        mutex_exit(&ufsvfsp->vfs_lock);
        (void) ufs_fault(ITOV(ip), "ialloccg: block not in mapfs = %s",
            fs->fs_fsmnt);
        return (0);
gotit:
        setbit(iused, ipref);
        cgp->cg_cs.cs_nifree--;
        fs->fs_cstotal.cs_nifree--;
        fs->fs_cs(fs, cg).cs_nifree--;
        if (((mode & IFMT) == IFDIR) || ((mode & IFMT) == IFATTRDIR)) {
                cgp->cg_cs.cs_ndir++;
                fs->fs_cstotal.cs_ndir++;
                fs->fs_cs(fs, cg).cs_ndir++;
        }
        fs->fs_fmod = 1;
        ufs_notclean(ufsvfsp);
        TRANS_BUF(ufsvfsp, 0, fs->fs_cgsize, bp, DT_CG);
        TRANS_SI(ufsvfsp, fs, cg);
        bdrwrite(bp);
        return (cg * fs->fs_ipg + ipref);
}

/*
 * Find a block of the specified size in the specified cylinder group.
 *
 * It is a panic if a request is made to find a block if none are
 * available.
 */
static daddr_t
mapsearch(struct ufsvfs *ufsvfsp, struct cg *cgp, daddr_t bpref,
        int allocsiz)
{
        struct fs *fs   = ufsvfsp->vfs_fs;
        daddr_t bno, cfrag;
        int start, len, loc, i, last, first, secondtime;
        int blk, field, subfield, pos;
        int gotit;

        /*
         * ufsvfs->vfs_lock is held when calling this.
         */
        /*
         * Find the fragment by searching through the
         * free block map for an appropriate bit pattern.
         */
        if (bpref)
                start = dtogd(fs, bpref) / NBBY;
        else
                start = cgp->cg_frotor / NBBY;
        /*
         * the following loop performs two scans -- the first scan
         * searches the bottom half of the array for a match and the
         * second scan searches the top half of the array.  The loops
         * have been merged just to make things difficult.
         */
        first = start;
        last = howmany(fs->fs_fpg, NBBY);
        secondtime = 0;
        cfrag = cgp->cg_cgx * fs->fs_fpg;
        while (first < last) {
                len = last - first;
                /*
                 * search the array for a match
                 */
                loc = scanc((unsigned)len, (uchar_t *)&cg_blksfree(cgp)[first],
                    (uchar_t *)fragtbl[fs->fs_frag],
                    (int)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
                /*
                 * match found
                 */
                if (loc) {
                        bno = (last - loc) * NBBY;

                        /*
                         * Found the byte in the map, sift
                         * through the bits to find the selected frag
                         */
                        cgp->cg_frotor = bno;
                        gotit = 0;
                        for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
                                blk = blkmap(fs, cg_blksfree(cgp), bno);
                                blk <<= 1;
                                field = around[allocsiz];
                                subfield = inside[allocsiz];
                                for (pos = 0;
                                    pos <= fs->fs_frag - allocsiz;
                                    pos++) {
                                        if ((blk & field) == subfield) {
                                                gotit++;
                                                break;
                                        }
                                        field <<= 1;
                                        subfield <<= 1;
                                }
                                if (gotit)
                                        break;
                        }
                        bno += pos;

                        /*
                         * success if block is *not* being converted from
                         * metadata into userdata (harpy).  If so, ignore.
                         */
                        if (!TRANS_ISCANCEL(ufsvfsp,
                            ldbtob(fsbtodb(fs, (cfrag+bno))),
                            allocsiz * fs->fs_fsize))
                                return (bno);

                        /*
                         * keep looking -- this block is being converted
                         */
                        first = (last - loc) + 1;
                        loc = 0;
                        if (first < last)
                                continue;
                }
                /*
                 * no usable matches in bottom half -- now search the top half
                 */
                if (secondtime)
                        /*
                         * no usable matches in top half -- all done
                         */
                        break;
                secondtime = 1;
                last = start + 1;
                first = 0;
        }
        /*
         * no usable matches
         */
        return ((daddr_t)-1);
}

#define UFSNADDR (NDADDR + NIADDR)      /* NADDR applies to (obsolete) S5FS */
#define IB(i)   (NDADDR + (i))  /* index of i'th indirect block ptr */
#define SINGLE  0               /* single indirect block ptr */
#define DOUBLE  1               /* double indirect block ptr */
#define TRIPLE  2               /* triple indirect block ptr */

/*
 * Acquire a write lock, and keep trying till we get it
 */
static int
allocsp_wlockfs(struct vnode *vp, struct lockfs *lf)
{
        int err = 0;

lockagain:
        do {
                err = ufs_fiolfss(vp, lf);
                if (err)
                        return (err);
        } while (!LOCKFS_IS_ULOCK(lf));

        lf->lf_lock = LOCKFS_WLOCK;
        lf->lf_flags = 0;
        lf->lf_comment = NULL;
        err = ufs__fiolfs(vp, lf, 1, 0);

        if (err == EBUSY || err == EINVAL)
                goto lockagain;

        return (err);
}

/*
 * Release the write lock
 */
static int
allocsp_unlockfs(struct vnode *vp, struct lockfs *lf)
{
        int err = 0;

        lf->lf_lock = LOCKFS_ULOCK;
        lf->lf_flags = 0;
        err = ufs__fiolfs(vp, lf, 1, 0);
        return (err);
}

struct allocsp_undo {
        daddr_t offset;
        daddr_t blk;
        struct allocsp_undo *next;
};

/*
 * ufs_allocsp() can be used to pre-allocate blocks for a file on a given
 * file system. For direct blocks, the blocks are allocated from the offset
 * requested to the block boundary, then any full blocks are allocated,
 * and finally any remainder.
 * For indirect blocks the blocks are not initialized and are
 * only marked as allocated. These addresses are then stored as negative
 * block numbers in the inode to imply special handling. UFS has been modified
 * where necessary to understand this new notion.
 * Successfully fallocated files will have IFALLOCATE cflag set in the inode.
 */
int
ufs_allocsp(struct vnode *vp, struct flock64 *lp, cred_t *cr)
{
        struct lockfs lf;
        int berr, err, resv, issync;
        off_t istart, len; /* istart, special for idb */
        struct inode *ip;
        struct fs *fs;
        struct ufsvfs *ufsvfsp;
        u_offset_t resid, i, uoff;
        daddr32_t db_undo[NDADDR];      /* old direct blocks */
        struct allocsp_undo *ib_undo = NULL;    /* ib undo */
        struct allocsp_undo *undo = NULL;
        u_offset_t osz;                 /* old file size */
        int chunkblks = 0;              /* # of blocks in 1 allocation */
        int cnt = 0;
        daddr_t allocblk;
        daddr_t totblks = 0;
        struct ulockfs  *ulp;
        size_t done_len;
        int nbytes, offsetn;


        ASSERT(vp->v_type == VREG);

        ip = VTOI(vp);
        fs = ip->i_fs;
        if ((ufsvfsp = ip->i_ufsvfs) == NULL) {
                err = EIO;
                goto out_allocsp;
        }

        istart = blkroundup(fs, (lp->l_start));
        len = blkroundup(fs, (lp->l_len));
        chunkblks = blkroundup(fs, ufsvfsp->vfs_iotransz) / fs->fs_bsize;
        ulp = &ufsvfsp->vfs_ulockfs;

        if (lp->l_start < 0 || lp->l_len <= 0)
                return (EINVAL);

        /* Quickly check to make sure we have space before we proceed */
        if (lblkno(fs, len) > fs->fs_cstotal.cs_nbfree) {
                if (TRANS_ISTRANS(ufsvfsp)) {
                        ufs_delete_drain_wait(ufsvfsp, 1);
                        if (lblkno(fs, len) > fs->fs_cstotal.cs_nbfree)
                                return (ENOSPC);
                } else
                        return (ENOSPC);
        }

        /*
         * We will keep i_rwlock locked as WRITER through out the function
         * since we don't want anyone else reading or writing to the inode
         * while we are in the middle of fallocating the file.
         */
        rw_enter(&ip->i_rwlock, RW_WRITER);

        /* Back up the direct block list, used for undo later if necessary */
        rw_enter(&ip->i_contents, RW_READER);
        for (i = 0; i < NDADDR; i++)
                db_undo[i] = ip->i_db[i];
        osz = ip->i_size;
        rw_exit(&ip->i_contents);

        /* Write lock the file system */
        if (err = allocsp_wlockfs(vp, &lf))
                goto exit;

        /*
         * Allocate any direct blocks now.
         * Blocks are allocated from the offset requested to the block
         * boundary, then any full blocks are allocated, and finally any
         * remainder.
         */
        if (lblkno(fs, lp->l_start) < NDADDR) {
                ufs_trans_trunc_resv(ip, ip->i_size + (NDADDR * fs->fs_bsize),
                    &resv, &resid);
                TRANS_BEGIN_CSYNC(ufsvfsp, issync, TOP_ALLOCSP, resv);

                rw_enter(&ufsvfsp->vfs_dqrwlock, RW_READER);
                rw_enter(&ip->i_contents, RW_WRITER);

                done_len = 0;
                while ((done_len < lp->l_len) &&
                    (lblkno(fs, lp->l_start + done_len) < NDADDR)) {
                        uoff = (offset_t)(lp->l_start + done_len);
                        offsetn = (int)blkoff(fs, uoff);
                        nbytes = (int)MIN(fs->fs_bsize - offsetn,
                            lp->l_len - done_len);

                        berr = bmap_write(ip, uoff, offsetn + nbytes,
                            BI_FALLOCATE, &allocblk, cr);
                        /* Yikes error, quit */
                        if (berr) {
                                TRANS_INODE(ufsvfsp, ip);
                                rw_exit(&ip->i_contents);
                                rw_exit(&ufsvfsp->vfs_dqrwlock);
                                TRANS_END_CSYNC(ufsvfsp, err, issync,
                                    TOP_ALLOCSP, resv);
                                err = allocsp_unlockfs(vp, &lf);
                                goto exit;
                        }

                        if (allocblk) {
                                totblks++;
                                if ((uoff + nbytes) > ip->i_size)
                                        ip->i_size = (uoff + nbytes);
                        }
                        done_len += nbytes;
                }

                TRANS_INODE(ufsvfsp, ip);
                rw_exit(&ip->i_contents);
                rw_exit(&ufsvfsp->vfs_dqrwlock);
                TRANS_END_CSYNC(ufsvfsp, err, issync, TOP_ALLOCSP, resv);

                /* start offset for indirect allocation */
                istart =  (uoff + nbytes);
        }

        /* Break the transactions into vfs_iotransz units */
        ufs_trans_trunc_resv(ip, ip->i_size +
            blkroundup(fs, ufsvfsp->vfs_iotransz), &resv, &resid);
        TRANS_BEGIN_CSYNC(ufsvfsp, issync, TOP_ALLOCSP, resv);

        rw_enter(&ufsvfsp->vfs_dqrwlock, RW_READER);
        rw_enter(&ip->i_contents, RW_WRITER);

        /* Now go about fallocating necessary indirect blocks */
        for (i = istart; i < (lp->l_start + lp->l_len); i += fs->fs_bsize) {
                berr = bmap_write(ip, i, fs->fs_bsize, BI_FALLOCATE,
                    &allocblk, cr);
                if (berr) {
                        TRANS_INODE(ufsvfsp, ip);
                        rw_exit(&ip->i_contents);
                        rw_exit(&ufsvfsp->vfs_dqrwlock);
                        TRANS_END_CSYNC(ufsvfsp, err, issync,
                            TOP_ALLOCSP, resv);
                        err = allocsp_unlockfs(vp, &lf);
                        goto exit;
                }

                /* Update the blk counter only if new block was added */
                if (allocblk) {
                        /* Save undo information */
                        undo = kmem_alloc(sizeof (struct allocsp_undo),
                            KM_SLEEP);
                        undo->offset = i;
                        undo->blk = allocblk;
                        undo->next = ib_undo;
                        ib_undo = undo;
                        totblks++;

                        if (i >= ip->i_size)
                                ip->i_size += fs->fs_bsize;
                }
                cnt++;

                /* Being a good UFS citizen, let others get a share */
                if (cnt == chunkblks) {
                        /*
                         * If there are waiters or the fs is hard locked,
                         * error locked, or read-only error locked,
                         * quit with EIO
                         */
                        if (ULOCKFS_IS_HLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp) ||
                            ULOCKFS_IS_ROELOCK(ulp)) {
                                ip->i_cflags |= IFALLOCATE;
                                TRANS_INODE(ufsvfsp, ip);
                                rw_exit(&ip->i_contents);
                                rw_exit(&ufsvfsp->vfs_dqrwlock);

                                TRANS_END_CSYNC(ufsvfsp, err, issync,
                                    TOP_ALLOCSP, resv);
                                rw_exit(&ip->i_rwlock);
                                (void) allocsp_unlockfs(vp, &lf);
                                return (EIO);
                        }

                        TRANS_INODE(ufsvfsp, ip);
                        rw_exit(&ip->i_contents);
                        rw_exit(&ufsvfsp->vfs_dqrwlock);

                        /* End the current transaction */
                        TRANS_END_CSYNC(ufsvfsp, err, issync,
                            TOP_ALLOCSP, resv);

                        if (CV_HAS_WAITERS(&ulp->ul_cv)) {
                                /* Release the write lock */
                                if (err = allocsp_unlockfs(vp, &lf))
                                        goto exit;

                                /* Wake up others waiting to do operations */
                                mutex_enter(&ulp->ul_lock);
                                cv_broadcast(&ulp->ul_cv);
                                mutex_exit(&ulp->ul_lock);

                                /* Grab the write lock again */
                                if (err = allocsp_wlockfs(vp, &lf))
                                        goto exit;
                        } /* end of CV_HAS_WAITERS(&ulp->ul_cv) */

                        /* Reserve more space in log for this file */
                        ufs_trans_trunc_resv(ip,
                            ip->i_size + blkroundup(fs, ufsvfsp->vfs_iotransz),
                            &resv, &resid);
                        TRANS_BEGIN_CSYNC(ufsvfsp, issync, TOP_ALLOCSP, resv);

                        rw_enter(&ufsvfsp->vfs_dqrwlock, RW_READER);
                        rw_enter(&ip->i_contents, RW_WRITER);

                        cnt = 0;        /* reset cnt b/c of new transaction */
                }
        }

        if (!err && !berr)
                ip->i_cflags |= IFALLOCATE;

        /* If the file has grown then correct the file size */
        if (osz < (lp->l_start + lp->l_len))
                ip->i_size = (lp->l_start + lp->l_len);

        /* Release locks, end log transaction and unlock fs */
        TRANS_INODE(ufsvfsp, ip);
        rw_exit(&ip->i_contents);
        rw_exit(&ufsvfsp->vfs_dqrwlock);

        TRANS_END_CSYNC(ufsvfsp, err, issync, TOP_ALLOCSP, resv);
        err = allocsp_unlockfs(vp, &lf);

        /*
         * @ exit label, we should no longer be holding the fs write lock, and
         * all logging transactions should have been ended. We still hold
         * ip->i_rwlock.
         */
exit:
        /*
         * File has grown larger than 2GB. Set flag
         * in superblock to indicate this, if it
         * is not already set.
         */
        if ((ip->i_size > MAXOFF32_T) &&
            !(fs->fs_flags & FSLARGEFILES)) {
                ASSERT(ufsvfsp->vfs_lfflags & UFS_LARGEFILES);
                mutex_enter(&ufsvfsp->vfs_lock);
                fs->fs_flags |= FSLARGEFILES;
                ufs_sbwrite(ufsvfsp);
                mutex_exit(&ufsvfsp->vfs_lock);
        }

        /*
         * Since we couldn't allocate completely, we will undo the allocations.
         */
        if (berr) {
                ufs_trans_trunc_resv(ip, totblks * fs->fs_bsize, &resv, &resid);
                TRANS_BEGIN_CSYNC(ufsvfsp, issync, TOP_ALLOCSP, resv);

                rw_enter(&ufsvfsp->vfs_dqrwlock, RW_READER);
                rw_enter(&ip->i_contents, RW_WRITER);

                /* Direct blocks */
                for (i = 0; i < NDADDR; i++) {
                        /*
                         * Only free the block if they are not same, and
                         * the old one isn't zero (the fragment was
                         * re-allocated).
                         */
                        if (db_undo[i] != ip->i_db[i] && db_undo[i] == 0) {
                                free(ip, ip->i_db[i], fs->fs_bsize, 0);
                                ip->i_db[i] = 0;
                        }
                }

                /* Undo the indirect blocks */
                while (ib_undo != NULL) {
                        undo = ib_undo;
                        err = bmap_set_bn(vp, undo->offset, 0);
                        if (err)
                                cmn_err(CE_PANIC, "ufs_allocsp(): failed to "
                                    "undo allocation of block %ld",
                                    undo->offset);
                        free(ip, undo->blk, fs->fs_bsize, I_IBLK);
                        ib_undo = undo->next;
                        kmem_free(undo, sizeof (struct allocsp_undo));
                }

                ip->i_size = osz;
                TRANS_INODE(ufsvfsp, ip);

                rw_exit(&ip->i_contents);
                rw_exit(&ufsvfsp->vfs_dqrwlock);

                TRANS_END_CSYNC(ufsvfsp, err, issync, TOP_ALLOCSP, resv);

                rw_exit(&ip->i_rwlock);
                return (berr);
        }

        /*
         * Don't forget to free the undo chain :)
         */
        while (ib_undo != NULL) {
                undo = ib_undo;
                ib_undo = undo->next;
                kmem_free(undo, sizeof (struct allocsp_undo));
        }

        rw_exit(&ip->i_rwlock);

out_allocsp:
        return (err);
}

/*
 * Free storage space associated with the specified inode.  The portion
 * to be freed is specified by lp->l_start and lp->l_len (already
 * normalized to a "whence" of 0).
 *
 * This is an experimental facility whose continued existence is not
 * guaranteed.  Currently, we only support the special case
 * of l_len == 0, meaning free to end of file.
 *
 * Blocks are freed in reverse order.  This FILO algorithm will tend to
 * maintain a contiguous free list much longer than FIFO.
 * See also ufs_itrunc() in ufs_inode.c.
 *
 * Bug: unused bytes in the last retained block are not cleared.
 * This may result in a "hole" in the file that does not read as zeroes.
 */
/* ARGSUSED */
int
ufs_freesp(struct vnode *vp, struct flock64 *lp, int flag, cred_t *cr)
{
        int i;
        struct inode *ip = VTOI(vp);
        int error;

        ASSERT(vp->v_type == VREG);
        ASSERT(lp->l_start >= 0);       /* checked by convoff */

        if (lp->l_len != 0)
                return (EINVAL);

        rw_enter(&ip->i_contents, RW_READER);
        if (ip->i_size == (u_offset_t)lp->l_start) {
                rw_exit(&ip->i_contents);
                return (0);
        }

        /*
         * Check if there is any active mandatory lock on the
         * range that will be truncated/expanded.
         */
        if (MANDLOCK(vp, ip->i_mode)) {
                offset_t save_start;

                save_start = lp->l_start;

                if (ip->i_size < lp->l_start) {
                        /*
                         * "Truncate up" case: need to make sure there
                         * is no lock beyond current end-of-file. To
                         * do so, we need to set l_start to the size
                         * of the file temporarily.
                         */
                        lp->l_start = ip->i_size;
                }
                lp->l_type = F_WRLCK;
                lp->l_sysid = 0;
                lp->l_pid = ttoproc(curthread)->p_pid;
                i = (flag & (FNDELAY|FNONBLOCK)) ? 0 : SLPFLCK;
                rw_exit(&ip->i_contents);
                if ((i = reclock(vp, lp, i, 0, lp->l_start, NULL)) != 0 ||
                    lp->l_type != F_UNLCK) {
                        return (i ? i : EAGAIN);
                }
                rw_enter(&ip->i_contents, RW_READER);

                lp->l_start = save_start;
        }

        /*
         * Make sure a write isn't in progress (allocating blocks)
         * by acquiring i_rwlock (we promised ufs_bmap we wouldn't
         * truncate while it was allocating blocks).
         * Grab the locks in the right order.
         */
        rw_exit(&ip->i_contents);
        rw_enter(&ip->i_rwlock, RW_WRITER);
        error = TRANS_ITRUNC(ip, (u_offset_t)lp->l_start, 0, cr);
        rw_exit(&ip->i_rwlock);
        return (error);
}

/*
 * Find a cg with as close to nb contiguous bytes as possible
 *      THIS MAY TAKE MANY DISK READS!
 *
 * Implemented in an attempt to allocate contiguous blocks for
 * writing the ufs log file to, minimizing future disk head seeking
 */
daddr_t
contigpref(ufsvfs_t *ufsvfsp, size_t nb, size_t minb)
{
        struct fs       *fs     = ufsvfsp->vfs_fs;
        daddr_t         nblk    = lblkno(fs, blkroundup(fs, nb));
        daddr_t         minblk  = lblkno(fs, blkroundup(fs, minb));
        daddr_t         savebno, curbno, cgbno;
        int             cg, cgblks, savecg, savenblk, curnblk, startcg;
        uchar_t         *blksfree;
        buf_t           *bp;
        struct cg       *cgp;

        savenblk = 0;
        savecg = 0;
        savebno = 0;

        if ((startcg = findlogstartcg(fs, nblk, minblk)) == -1)
                cg = 0; /* Nothing suitable found */
        else
                cg = startcg;

        for (; cg < fs->fs_ncg; ++cg) {
                /*
                 * find the largest contiguous range in this cg
                 */
                bp = UFS_BREAD(ufsvfsp, ufsvfsp->vfs_dev,
                    (daddr_t)fsbtodb(fs, cgtod(fs, cg)),
                    (int)fs->fs_cgsize);
                cgp = bp->b_un.b_cg;
                if (bp->b_flags & B_ERROR || !cg_chkmagic(cgp)) {
                        brelse(bp);
                        continue;
                }
                blksfree = cg_blksfree(cgp);        /* free array */
                cgblks = fragstoblks(fs, fs->fs_fpg); /* blks in free array */
                cgbno = 0;
                while (cgbno < cgblks && savenblk < nblk) {
                        /* find a free block */
                        for (; cgbno < cgblks; ++cgbno) {
                                if (isblock(fs, blksfree, cgbno)) {
                                        if (startcg != -1) {
                                                brelse(bp);
                                                savecg = startcg;
                                                savebno = cgbno;
                                                goto done;
                                        } else
                                                break;
                                }
                        }
                        curbno = cgbno;
                        /* count the number of free blocks */
                        for (curnblk = 0; cgbno < cgblks; ++cgbno) {
                                if (!isblock(fs, blksfree, cgbno))
                                        break;
                                if (++curnblk >= nblk)
                                        break;
                        }
                        if (curnblk > savenblk) {
                                savecg = cg;
                                savenblk = curnblk;
                                savebno = curbno;
                        }
                }
                brelse(bp);
                if (savenblk >= nblk)
                        break;
        }

done:

        /* convert block offset in cg to frag offset in cg */
        savebno = blkstofrags(fs, savebno);

        /* convert frag offset in cg to frag offset in fs */
        savebno += (savecg * fs->fs_fpg);

        return (savebno);
}

/*
 * The object of this routine is to find a start point for the UFS log.
 * Ideally the space should be allocated from the smallest possible number
 * of contiguous cylinder groups. This is found by using a sliding window
 * technique. The smallest window of contiguous cylinder groups, which is
 * still able to accommodate the target, is found by moving the window
 * through the cylinder groups in a single pass. The end of the window is
 * advanced until the space is accommodated, then the start is advanced until
 * it no longer fits, the end is then advanced again and so on until the
 * final cylinder group is reached. The first suitable instance is recorded
 * and its starting cg number is returned.
 *
 * If we are not able to find a minimum amount of space, represented by
 * minblk, or to do so uses more than the available extents, then return -1.
 */

int
findlogstartcg(struct fs *fs, daddr_t requested, daddr_t minblk)
{
        int      ncgs;           /* number of cylinder groups */
        daddr_t target;          /* amount of space sought */
        int      cwidth, ctotal; /* current window width and total */
        int      bwidth, btotal; /* best window width and total so far */
        int      s;     /* index of the first element in the current window */
        int      e;     /* index of the first element + the width */
                        /*  (i.e. 1 + index of last element) */
        int      bs; /* index of the first element in the best window so far */
        int      header, max_extents;

        target = requested;
        ncgs = fs->fs_ncg;

        header = sizeof (extent_block_t) - sizeof (extent_t);
        max_extents = ((fs->fs_bsize)-header) / sizeof (extent_t);
        cwidth = ctotal = 0;
        btotal = -1;
        bwidth = ncgs;
        s = e = 0;
        while (e < ncgs) {
        /* Advance the end of the window until it accommodates the target. */
                while (ctotal < target && e < ncgs) {
                        ctotal += fs->fs_cs(fs, e).cs_nbfree;
                        e++;
                }

                /*
                 * Advance the start of the window until it no longer
                 * accommodates the target.
                 */
                while (ctotal >= target && s < e) {
                        /* See if this is the smallest window so far. */
                        cwidth = e - s;
                        if (cwidth <= bwidth) {
                                if (cwidth == bwidth && ctotal <= btotal)
                                        goto more;
                                bwidth = cwidth;
                                btotal = ctotal;
                                bs = s;
                        }
more:
                        ctotal -= fs->fs_cs(fs, s).cs_nbfree;
                        s++;
                }
        }

        /*
         * If we cannot allocate the minimum required or we use too many
         * extents to do so, return -1.
         */
        if (btotal < minblk || bwidth > max_extents)
                bs = -1;

        return (bs);
}