7712 mandoc -Tlint does always exit with error code 0

[unleashed.git] / usr / src / uts / common / io / lvm / raid / raid_resync.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * NAME:        raid_resync.c
 * DESCRIPTION: RAID driver source file containing routines related to resync
 *              operation.
 * ROUTINES PROVIDED FOR EXTERNAL USE:
 *         resync_request() - get resync lock if available
 *         release_resync_request() - relinquish resync lock
 *         erred_check_line() - provide write instruction for erred column
 *           init_pw_area() - initialize pre-write area
 *           copy_pw_area() - copy pre-write area from one device to another
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/user.h>
#include <sys/uio.h>
#include <sys/t_lock.h>
#include <sys/buf.h>
#include <sys/dkio.h>
#include <sys/vtoc.h>
#include <sys/kmem.h>
#include <vm/page.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/mkdev.h>
#include <sys/stat.h>
#include <sys/open.h>
#include <sys/disp.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/lvm/md_raid.h>

#include <sys/sysevent/eventdefs.h>
#include <sys/sysevent/svm.h>

#define NOCOLUMN        (-1)

extern md_set_t         md_set[];
extern kmem_cache_t     *raid_child_cache;
extern kmem_cache_t     *raid_parent_cache;
extern md_resync_t      md_cpr_resync;
extern major_t          md_major;
extern void             raid_parent_init(md_raidps_t *ps);
extern void             raid_child_init(md_raidcs_t *ps);

/*
 * NAMES:       xor
 * DESCRIPTION: Xor two chunks of data together.  The data referenced by
 *              addr1 and addr2 are xor'd together for size and written into
 *              addr1.
 * PARAMETERS:  caddr_t addr1 - address of first chunk of data and destination
 *              caddr_t addr2 - address of second chunk of data
 *              u_int    size - number to xor
 */
static void
xor(caddr_t addr1, caddr_t addr2, size_t size)
{
        while (size--) {
                *addr1++ ^= *addr2++;
        }
}

/*
 * NAME:        release_resync_request
 *
 * DESCRIPTION: Release resync active flag and reset unit values accordingly.
 *
 * PARAMETERS:  minor_t     mnum - minor number identity of metadevice
 *
 * LOCKS:       Expects Unit Writer Lock to be held across call.
 */
void
release_resync_request(
        minor_t         mnum
)
{
        mr_unit_t       *un;

        un = MD_UNIT(mnum);
        ASSERT(un != NULL);

        un->c.un_status &= ~MD_UN_RESYNC_ACTIVE;

        un->un_column[un->un_resync_index].un_devflags &= ~MD_RAID_RESYNC;
        un->un_column[un->un_resync_index].un_devflags &= ~MD_RAID_RESYNC_ERRED;
        un->un_column[un->un_resync_index].un_devflags &=
            ~(MD_RAID_COPY_RESYNC | MD_RAID_REGEN_RESYNC);

        un->un_resync_line_index = 0;
        un->un_resync_index = NOCOLUMN;
}

/*
 * NAME:        resync_request
 *
 * DESCRIPTION: Request resync.  If resync is available (no current active
 *              resync), mark unit as resync active and initialize.
 *
 * PARAMETERS:  minor_t     mnum - minor number identity of metadevice
 *              int column_index - index of column to resync
 *              int     copysize - copysize of ioctl request
 *              md_error_t   *ep - error output parameter
 *
 * RETURN:      0 if resync is available, 1 otherwise.
 *
 * LOCKS:       Expects Unit Writer Lock to be held across call.
 *
 * NOTE:        Sets un_resync_copysize to the input value in copysize, the
 *              existing value from an incomplete previous resync with an
 *              input value in copysize, or the lesser of the unit segment
 *              size or maxio.
 */
/* ARGSUSED */
int
resync_request(
        minor_t         mnum,
        int             column_index,
        size_t          copysize,
        md_error_t      *mde
)
{
        mr_unit_t       *un;

        un = MD_UNIT(mnum);
        ASSERT(un != NULL);

        /* if resync or grow not already active, set resync active for unit */
        if (! (un->un_column[column_index].un_devflags & MD_RAID_RESYNC) &&
            ((un->c.un_status & MD_UN_RESYNC_ACTIVE) ||
            (un->c.un_status & MD_UN_GROW_PENDING) ||
            (un->un_column[column_index].un_devstate & RCS_RESYNC))) {
                if (mde)
                        return (mdmderror(mde, MDE_GROW_DELAYED, mnum));
                return (1);
        }

        if (un->un_column[column_index].un_devstate &
            (RCS_ERRED | RCS_LAST_ERRED))
                un->un_column[column_index].un_devflags |= MD_RAID_DEV_ERRED;
        else
                un->un_column[column_index].un_devflags &= ~MD_RAID_DEV_ERRED;
        un->c.un_status |= MD_UN_RESYNC_ACTIVE;
        un->un_resync_index = column_index;
        un->un_resync_line_index = 0;
        raid_set_state(un, column_index, RCS_RESYNC, 0);

        return (0);
}

/*
 * Name:        alloc_bufs
 *
 * DESCRIPTION: Initialize resync_comp buffers.
 *
 * PARAMETERS:  size_t     bsize - size of buffer
 *              buf_t *read_buf1 - first read buf
 *              buf_t *read_buf2 - second read buf
 *              buf_t *write_buf - write buf
 */
static void
alloc_bufs(md_raidcs_t *cs, size_t bsize)
{
        /* allocate buffers, write uses the read_buf1 buffer */
        cs->cs_dbuffer = kmem_zalloc(bsize, KM_SLEEP);
        cs->cs_pbuffer = kmem_zalloc(bsize, KM_SLEEP);
}

void
init_buf(buf_t *bp, int flags, size_t size)
{
        /* zero buf */
        bzero((caddr_t)bp, sizeof (buf_t));

        /* set b_back and b_forw to point back to buf */
        bp->b_back = bp;
        bp->b_forw = bp;

        /* set flags size */
        bp->b_flags = flags;
        bp->b_bufsize = size;
        bp->b_offset = -1;

        /* setup semaphores */
        sema_init(&bp->b_io, 0, NULL, SEMA_DEFAULT, NULL);
        sema_init(&bp->b_sem, 0, NULL, SEMA_DEFAULT, NULL);
}

void
destroy_buf(buf_t *bp)
{
        sema_destroy(&bp->b_io);
        sema_destroy(&bp->b_sem);
}

void
reset_buf(buf_t *bp, int flags, size_t size)
{
        destroy_buf(bp);
        init_buf(bp, flags, size);
}

/*
 * NAME:        free_bufs
 *
 * DESCRIPTION: Free up buffers.
 *
 * PARAMETERS:  size_t     bsize - size of buffer
 *              buf_t *read_buf1 - first read buf
 *              buf_t *read_buf2 - second read buf
 *              buf_t *write_buf - write buf
 */
static void
free_bufs(size_t bsize, md_raidcs_t *cs)
{
        kmem_free(cs->cs_dbuffer, bsize);
        kmem_free(cs->cs_pbuffer, bsize);
}

/*
 * NAME:        init_pw_area
 *
 * DESCRIPTION: Initialize pre-write area to all zeros.
 *
 * PARAMETERS:  minor_t       mnum      - minor number identity of metadevice
 *              md_dev64_t dev_to_write - index of column to resync
 *              int   column_index      - index of column to resync
 *
 * RETURN:      1 if write error on resync device, otherwise 0
 *
 * LOCKS:       Expects Unit Reader Lock to be held across call.
 */
int
init_pw_area(
        mr_unit_t *un,
        md_dev64_t dev_to_write,
        diskaddr_t pwstart,
        uint_t  col
)
{
        buf_t   buf;
        caddr_t databuffer;
        size_t  copysize;
        size_t  bsize;
        int     error = 0;
        int     i;

        ASSERT(un != NULL);
        ASSERT(un->un_column[col].un_devflags & MD_RAID_DEV_ISOPEN);

        bsize = un->un_iosize;
        copysize = dbtob(bsize);
        databuffer = kmem_zalloc(copysize, KM_SLEEP);
        init_buf(&buf, (B_BUSY | B_WRITE), copysize);

        for (i = 0; i < un->un_pwcnt; i++) {
                /* magic field is 0 for 4.0 compatability */
                RAID_FILLIN_RPW(databuffer, un, 0, 0,
                                0, 0, 0,
                                0, col, 0);
                buf.b_un.b_addr = (caddr_t)databuffer;
                buf.b_edev = md_dev64_to_dev(dev_to_write);
                buf.b_bcount = dbtob(bsize);
                buf.b_lblkno = pwstart + (i * un->un_iosize);

                /* write buf */
                (void) md_call_strategy(&buf, MD_STR_NOTTOP, NULL);

                if (biowait(&buf)) {
                        error = 1;
                        break;
                }
                reset_buf(&buf, (B_BUSY | B_WRITE), copysize);
        } /* for */

        destroy_buf(&buf);
        kmem_free(databuffer, copysize);

        return (error);
}

/*
 * NAME:        raid_open_alt
 *
 * DESCRIPTION: opens the alt device used during resync.
 *
 * PARAMETERS:  un
 *
 * RETURN:      0 - successfull
 *              1 - failed
 *
 * LOCKS:       requires unit writer lock
 */

static int
raid_open_alt(mr_unit_t *un, int index)
{
        mr_column_t     *column = &un->un_column[index];
        set_t           setno = MD_MIN2SET(MD_SID(un));
        side_t          side = mddb_getsidenum(setno);
        md_dev64_t      tmpdev = column->un_alt_dev;

        /* correct locks */
        ASSERT(UNIT_WRITER_HELD(un));
        /* not already writing to */
        ASSERT(! (column->un_devflags & MD_RAID_WRITE_ALT));
        /* not already open */
        ASSERT(! (column->un_devflags & MD_RAID_ALT_ISOPEN));

        if (tmpdev != NODEV64) {
                /*
                 * Open by device id. We use orig_key since alt_dev
                 * has been set by the caller to be the same as orig_dev.
                 */
                if ((md_getmajor(tmpdev) != md_major) &&
                        md_devid_found(setno, side, column->un_orig_key) == 1) {
                        tmpdev = md_resolve_bydevid(MD_SID(un), tmpdev,
                                column->un_orig_key);
                }
                if (md_layered_open(MD_SID(un), &tmpdev, MD_OFLG_NULL)) {
                        /* failed open */
                        column->un_alt_dev = tmpdev;
                        return (1);
                } else {
                        /* open suceeded */
                        column->un_alt_dev = tmpdev;
                        column->un_devflags |= MD_RAID_ALT_ISOPEN;
                        return (0);
                }
        } else
                /* no alt device to open */
                return (1);
}


/*
 * NAME:        raid_close_alt
 *
 * DESCRIPTION: closes the alt device used during resync.
 *
 * PARAMETERS:  un - raid unit structure
 *              indes - raid column
 *
 * RETURN:      none
 *
 * LOCKS:       requires unit writer lock
 */

static void
raid_close_alt(mr_unit_t *un, int index)
{
        mr_column_t     *column = &un->un_column[index];
        md_dev64_t      tmpdev = column->un_alt_dev;

        ASSERT(UNIT_WRITER_HELD(un));   /* correct locks */
        ASSERT(! (column->un_devflags & MD_RAID_WRITE_ALT)); /* not writing */
        ASSERT(column->un_devflags & MD_RAID_ALT_ISOPEN); /* already open */
        ASSERT(tmpdev != NODEV64); /* is a device */

        md_layered_close(column->un_alt_dev, MD_OFLG_NULL);
        column->un_devflags &= ~MD_RAID_ALT_ISOPEN;
        column->un_alt_dev = NODEV64;
}

static diskaddr_t
raid_resync_fillin_cs(diskaddr_t line, uint_t line_count, md_raidcs_t *cs)
{
        mr_unit_t       *un = cs->cs_un;

        ASSERT(line < un->un_segsincolumn);

        cs->cs_line = line;
        cs->cs_blkno = line * un->un_segsize;
        cs->cs_blkcnt = un->un_segsize * line_count;
        cs->cs_lastblk = cs->cs_blkno + cs->cs_blkcnt - 1;
        raid_line_reader_lock(cs, 1);

        return (line + line_count);
}

/* states returned by raid_resync_line */

#define RAID_RESYNC_OKAY        0
#define RAID_RESYNC_RDERROR     2
#define RAID_RESYNC_WRERROR     3
#define RAID_RESYNC_STATE       4

int
raid_resync_region(
        md_raidcs_t     *cs,
        diskaddr_t      line,
        uint_t          line_count,
        int             *single_read,
        hs_cmds_t       *hs_state,
        int             *err_col,
        md_dev64_t      dev_to_write,
        diskaddr_t      write_dev_start)
{
        mr_unit_t       *un = cs->cs_un;
        buf_t           *readb1 = &cs->cs_pbuf;
        buf_t           *readb2 = &cs->cs_dbuf;
        buf_t           *writeb = &cs->cs_hbuf;
        diskaddr_t      off;
        size_t          tcopysize;
        size_t          copysize;
        int             resync;
        int             quit = 0;
        size_t          leftinseg;
        int             i;

        resync = un->un_resync_index;
        off = line * un->un_segsize;
        copysize = un->un_resync_copysize;

        /* find first column to read, skip resync column */

        leftinseg = un->un_segsize * line_count;
        while (leftinseg) {

                /* truncate last chunk to end if needed */
                if (copysize > leftinseg)
                        tcopysize = leftinseg;
                else
                        tcopysize = copysize;
                leftinseg -= tcopysize;

                /*
                 * One of two scenarios:
                 * 1) resync device with hotspare ok.  This implies that
                 *    we are copying from a good hotspare to a new good original
                 *    device.  In this case readb1 is used as the buf for
                 *    the read from the hotspare device.
                 * 2) For all other cases, including when in case 1) and an
                 *    error is detected on the (formerly good) hotspare device,
                 *    readb1 is used for the initial read.  readb2 is used for
                 *    all other reads.  Each readb2 buffer is xor'd into the
                 *    readb1 buffer.
                 *
                 * In both cases, writeb is used for the write, using readb1's
                 * buffer.
                 *
                 * For case 2, we could alternatively perform the read for all
                 * devices concurrently to improve performance.  However,
                 * this could diminish performance for concurrent reads and
                 * writes if low on memory.
                 */

                /* read first buffer */

                /* switch to read from good columns if single_read */
                if (*single_read) {
                        if (un->un_column[resync].un_dev == NODEV64)
                                return (RAID_RESYNC_RDERROR);

                        reset_buf(readb1, B_READ | B_BUSY,
                            dbtob(copysize));
                        readb1->b_bcount = dbtob(tcopysize);
                        readb1->b_un.b_addr = cs->cs_pbuffer;
                        readb1->b_edev = md_dev64_to_dev(
                                                un->un_column[resync].un_dev);
                        readb1->b_lblkno =
                            un->un_column[resync].un_devstart + off;
                        (void) md_call_strategy(readb1, MD_STR_NOTTOP, NULL);
                        if (biowait(readb1)) {
                                /*
                                 * at this point just start rebuilding the
                                 * data and go on since the other column
                                 * are ok.
                                 */
                                *single_read = 0;
                                *hs_state = HS_BAD;
                                un->un_column[resync].un_devflags &=
                                    ~MD_RAID_COPY_RESYNC;
                                un->un_column[resync].un_devflags |=
                                    MD_RAID_REGEN_RESYNC;
                        }
                }

                /* if reading from all non-resync columns */
                if (!*single_read) {
                        /* for each column, read line and xor into write buf */
                        bzero(cs->cs_pbuffer, dbtob(tcopysize));
                        for (i = 0; i < un->un_totalcolumncnt; i++) {

                                if (un->un_column[i].un_dev == NODEV64)
                                        return (RAID_RESYNC_RDERROR);

                                /* skip column getting resync'ed */
                                if (i == resync) {
                                        continue;
                                }
                                reset_buf(readb1, B_READ | B_BUSY,
                                    dbtob(copysize));
                                readb1->b_bcount = dbtob(tcopysize);
                                readb1->b_un.b_addr = cs->cs_dbuffer;
                                readb1->b_edev = md_dev64_to_dev(
                                                un->un_column[i].un_dev);
                                readb1->b_lblkno =
                                    un->un_column[i].un_devstart + off;

                                (void) md_call_strategy(readb1, MD_STR_NOTTOP,
                                        NULL);
                                if (biowait(readb1)) {
                                        *err_col = i;
                                        quit = RAID_RESYNC_RDERROR;
                                }

                                if (quit)
                                        return (quit);

                                /* xor readb2 data into readb1 */
                                xor(cs->cs_pbuffer, readb1->b_un.b_addr,
                                    dbtob(tcopysize));
                        } /* for */
                }

                reset_buf(writeb, B_WRITE | B_BUSY,
                    dbtob(copysize));
                writeb->b_bcount = dbtob(tcopysize);
                writeb->b_un.b_addr = cs->cs_pbuffer;
                writeb->b_lblkno = off + write_dev_start;
                writeb->b_edev = md_dev64_to_dev(dev_to_write);

                /* set write block number and perform the write */
                (void) md_call_strategy(writeb, MD_STR_NOTTOP, NULL);
                if (biowait(writeb)) {
                        if (*single_read == 0) {
                                *hs_state = HS_BAD;
                        }
                        return (RAID_RESYNC_WRERROR);
                }
                writeb->b_blkno += tcopysize;
                off += tcopysize;
        } /* while */
        sema_destroy(&readb1->b_io);
        sema_destroy(&readb1->b_sem);
        sema_destroy(&readb2->b_io);
        sema_destroy(&readb2->b_sem);
        sema_destroy(&writeb->b_io);
        sema_destroy(&writeb->b_sem);
        return (RAID_RESYNC_OKAY);
}

/*
 * NAME:        resync_comp
 *
 * DESCRIPTION: Resync the component.  Iterate through the raid unit a line at
 *              a time, read from the good device(s) and write the resync
 *              device.
 *
 * PARAMETERS:  minor_t    mnum - minor number identity of metadevice
 *              md_raidcs_t *cs - child save struct
 *
 * RETURN:       0 - successfull
 *               1 - failed
 *              -1 - aborted
 *
 * LOCKS:       Expects Unit Reader Lock to be held across call.  Acquires and
 *              releases Line Reader Lock for per-line I/O.
 */
static void
resync_comp(
        minor_t         mnum,
        md_raidcs_t     *cs
)
{
        mdi_unit_t      *ui;
        mr_unit_t       *un;
        mddb_recid_t    recids[2];
        rcs_state_t     state;
        md_dev64_t      dev_to_write;
        diskaddr_t      write_pwstart;
        diskaddr_t      write_devstart;
        md_dev64_t      dev;
        int             resync;
        int             i;
        int             single_read = 0;
        int             err;
        int             err_cnt;
        int             last_err;
        diskaddr_t      line;
        diskaddr_t      segsincolumn;
        size_t          bsize;
        uint_t          line_count;

        /*
         * hs_state is the state of the hotspare on the column being resynced
         * dev_state is the state of the resync target
         */
        hs_cmds_t       hs_state;
        int             err_col = -1;
        diskaddr_t      resync_end_pos;

        ui = MDI_UNIT(mnum);
        ASSERT(ui != NULL);

        un = cs->cs_un;

        md_unit_readerexit(ui);
        un = (mr_unit_t *)md_io_writerlock(ui);
        un = (mr_unit_t *)md_unit_writerlock(ui);
        resync = un->un_resync_index;
        state = un->un_column[resync].un_devstate;
        line_count = un->un_maxio / un->un_segsize;
        if (line_count == 0) { /* handle the case of segsize > maxio */
                line_count = 1;
                bsize = un->un_maxio;
        } else
                bsize = line_count * un->un_segsize;

        un->un_resync_copysize = (uint_t)bsize;

        ASSERT(un->c.un_status & MD_UN_RESYNC_ACTIVE);
        ASSERT(un->un_column[resync].un_devflags &
            (MD_RAID_COPY_RESYNC | MD_RAID_REGEN_RESYNC));

        /*
         * if the column is not in resync then just bail out.
         */
        if (! (un->un_column[resync].un_devstate & RCS_RESYNC)) {
                md_unit_writerexit(ui);
                md_io_writerexit(ui);
                un = (mr_unit_t *)md_unit_readerlock(ui);
                return;
        }
        SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_START, SVM_TAG_METADEVICE,
            MD_UN2SET(un), MD_SID(un));

        /* identify device to write and its start block */

        if (un->un_column[resync].un_alt_dev != NODEV64) {
                if (raid_open_alt(un, resync)) {
                        raid_set_state(un, resync, state, 0);
                        md_unit_writerexit(ui);
                        md_io_writerexit(ui);
                        un = (mr_unit_t *)md_unit_readerlock(ui);
                        cmn_err(CE_WARN, "md: %s: %s open failed replace "
                                "terminated", md_shortname(MD_SID(un)),
                                md_devname(MD_UN2SET(un),
                                        un->un_column[resync].un_alt_dev,
                                        NULL, 0));
                        SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_FAILED,
                            SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
                        return;
                }
                ASSERT(un->un_column[resync].un_devflags & MD_RAID_COPY_RESYNC);
                dev_to_write = un->un_column[resync].un_alt_dev;
                write_devstart = un->un_column[resync].un_alt_devstart;
                write_pwstart = un->un_column[resync].un_alt_pwstart;
                if (un->un_column[resync].un_devflags & MD_RAID_DEV_ERRED) {
                        single_read = 0;
                        hs_state = HS_BAD;
                } else {
                        hs_state = HS_FREE;
                        single_read = 1;
                }
                un->un_column[resync].un_devflags |= MD_RAID_WRITE_ALT;
        } else {
                dev_to_write = un->un_column[resync].un_dev;
                write_devstart = un->un_column[resync].un_devstart;
                write_pwstart = un->un_column[resync].un_pwstart;
                single_read = 0;
                hs_state = HS_FREE;
                ASSERT(un->un_column[resync].un_devflags &
                    MD_RAID_REGEN_RESYNC);
        }

        alloc_bufs(cs, dbtob(bsize));
        /* initialize pre-write area */
        if (init_pw_area(un, dev_to_write, write_pwstart, resync)) {
                un->un_column[resync].un_devflags &= ~MD_RAID_WRITE_ALT;
                if (un->un_column[resync].un_alt_dev != NODEV64) {
                        raid_close_alt(un, resync);
                }
                md_unit_writerexit(ui);
                md_io_writerexit(ui);
                if (dev_to_write == un->un_column[resync].un_dev)
                        hs_state = HS_BAD;
                err = RAID_RESYNC_WRERROR;
                goto resync_comp_error;
        }

        un->c.un_status &= ~MD_UN_RESYNC_CANCEL;
        segsincolumn = un->un_segsincolumn;
        err_cnt = raid_state_cnt(un, RCS_ERRED | RCS_LAST_ERRED);

        /* commit the record */

        md_unit_writerexit(ui);
        md_io_writerexit(ui);


        /* resync each line of the unit */
        for (line = 0; line <  segsincolumn; line += line_count) {
                /*
                 * Update address range in child struct and lock the line.
                 *
                 * The reader version of the line lock is used since only
                 * resync will use data beyond un_resync_line_index on the
                 * resync device.
                 */
                un = (mr_unit_t *)md_io_readerlock(ui);
                if (line + line_count > segsincolumn)
                        line_count = segsincolumn - line;
                resync_end_pos = raid_resync_fillin_cs(line, line_count, cs);
                (void) md_unit_readerlock(ui);
                ASSERT(un->un_resync_line_index == resync_end_pos);
                err = raid_resync_region(cs, line, (int)line_count,
                    &single_read, &hs_state, &err_col, dev_to_write,
                    write_devstart);

                /*
                 * if the column failed to resync then stop writing directly
                 * to the column.
                 */
                if (err)
                        un->un_resync_line_index = 0;

                md_unit_readerexit(ui);
                raid_line_exit(cs);
                md_io_readerexit(ui);

                if (err)
                        break;

                un = (mr_unit_t *)md_unit_writerlock(ui);

                if (raid_state_cnt(un, RCS_ERRED | RCS_LAST_ERRED) != err_cnt) {
                        err = RAID_RESYNC_STATE;
                        md_unit_writerexit(ui);
                        break;
                }
                md_unit_writerexit(ui);
        } /* for */

resync_comp_error:
        un = (mr_unit_t *)md_io_writerlock(ui);
        (void) md_unit_writerlock(ui);
        un->un_column[resync].un_devflags &= ~MD_RAID_WRITE_ALT;

        recids[0] = 0;
        recids[1] = 0;
        switch (err) {
                /*
                 * successful resync
                 */
            case RAID_RESYNC_OKAY:
                /* initialize pre-write area */
                if ((un->un_column[resync].un_orig_dev != NODEV64) &&
                    (un->un_column[resync].un_orig_dev ==
                    un->un_column[resync].un_alt_dev)) {
                        /*
                         * replacing a hot spare
                         * release the hot spare, which will close the hotspare
                         * and mark it closed.
                         */
                        raid_hs_release(hs_state, un, &recids[0], resync);
                        /*
                         * make the resync target the main device and
                         * mark open
                         */
                        un->un_column[resync].un_hs_id = 0;
                        un->un_column[resync].un_dev =
                            un->un_column[resync].un_orig_dev;
                        un->un_column[resync].un_devstart =
                            un->un_column[resync].un_orig_devstart;
                        un->un_column[resync].un_pwstart =
                            un->un_column[resync].un_orig_pwstart;
                        un->un_column[resync].un_devflags |= MD_RAID_DEV_ISOPEN;
                        /* alt becomes the device so don't close it */
                        un->un_column[resync].un_devflags &= ~MD_RAID_WRITE_ALT;
                        un->un_column[resync].un_devflags &=
                            ~MD_RAID_ALT_ISOPEN;
                        un->un_column[resync].un_alt_dev = NODEV64;
                }
                raid_set_state(un, resync, RCS_OKAY, 0);
                break;

            case RAID_RESYNC_WRERROR:
                if (HOTSPARED(un, resync) && single_read &&
                    (un->un_column[resync].un_devflags & MD_RAID_COPY_RESYNC)) {
                        /*
                         * this is the case where the resync target is
                         * bad but there is a good hotspare.  In this
                         * case keep the hotspare, and go back to okay.
                         */
                        raid_set_state(un, resync, RCS_OKAY, 0);
                        cmn_err(CE_WARN, "md: %s: %s write error, replace "
                                "terminated", md_shortname(MD_SID(un)),
                                md_devname(MD_UN2SET(un),
                                        un->un_column[resync].un_orig_dev,
                                        NULL, 0));
                        break;
                }
                if (HOTSPARED(un, resync)) {
                        raid_hs_release(hs_state, un, &recids[0], resync);
                        un->un_column[resync].un_dev =
                            un->un_column[resync].un_orig_dev;
                        un->un_column[resync].un_devstart =
                            un->un_column[resync].un_orig_devstart;
                        un->un_column[resync].un_pwstart =
                            un->un_column[resync].un_orig_pwstart;
                }
                raid_set_state(un, resync, RCS_ERRED, 0);
                if (un->un_column[resync].un_devflags & MD_RAID_REGEN_RESYNC)
                        dev = un->un_column[resync].un_dev;
                else
                        dev = un->un_column[resync].un_alt_dev;
                cmn_err(CE_WARN, "md: %s: %s write error replace terminated",
                    md_shortname(MD_SID(un)), md_devname(MD_UN2SET(un), dev,
                    NULL, 0));
                break;

            case RAID_RESYNC_STATE:
                if (HOTSPARED(un, resync) && single_read &&
                    (un->un_column[resync].un_devflags & MD_RAID_COPY_RESYNC)) {
                        /*
                         * this is the case where the resync target is
                         * bad but there is a good hotspare.  In this
                         * case keep the hotspare, and go back to okay.
                         */
                        raid_set_state(un, resync, RCS_OKAY, 0);
                        cmn_err(CE_WARN, "md: %s: needs maintenance, replace "
                            "terminated", md_shortname(MD_SID(un)));
                        break;
                }
                if (HOTSPARED(un, resync)) {
                        raid_hs_release(hs_state, un, &recids[0], resync);
                        un->un_column[resync].un_dev =
                            un->un_column[resync].un_orig_dev;
                        un->un_column[resync].un_devstart =
                            un->un_column[resync].un_orig_devstart;
                        un->un_column[resync].un_pwstart =
                            un->un_column[resync].un_orig_pwstart;
                }
                break;
            case RAID_RESYNC_RDERROR:
                if (HOTSPARED(un, resync)) {
                        raid_hs_release(hs_state, un, &recids[0], resync);
                        un->un_column[resync].un_dev =
                            un->un_column[resync].un_orig_dev;
                        un->un_column[resync].un_devstart =
                            un->un_column[resync].un_orig_devstart;
                        un->un_column[resync].un_pwstart =
                            un->un_column[resync].un_orig_pwstart;
                }

                if ((resync != err_col) && (err_col != NOCOLUMN))
                        raid_set_state(un, err_col, RCS_ERRED, 0);
                break;

            default:
                ASSERT(0);
        }
        if (un->un_column[resync].un_alt_dev != NODEV64) {
                raid_close_alt(un, resync);
        }

        /*
         * an io operation may have gotten an error and placed a
         * column in erred state.  This will abort the resync, which
         * will end up in last erred.  This is ugly so go through
         * the columns and do cleanup
         */
        err_cnt = 0;
        last_err = 0;
        for (i = 0; i < un->un_totalcolumncnt; i++) {
                if (un->un_column[i].un_devstate & RCS_OKAY)
                        continue;
                if (i == resync) {
                        raid_set_state(un, i, RCS_ERRED, 1);
                        err_cnt++;
                } else if (err == RAID_RESYNC_OKAY) {
                        err_cnt++;
                } else {
                        raid_set_state(un, i, RCS_LAST_ERRED, 1);
                        last_err++;
                }
        }
        if ((err_cnt == 0) && (last_err == 0))
                un->un_state = RUS_OKAY;
        else if (last_err == 0) {
                un->un_state = RUS_ERRED;
                ASSERT(err_cnt == 1);
        } else if (last_err > 0) {
                un->un_state = RUS_LAST_ERRED;
        }

        uniqtime32(&un->un_column[resync].un_devtimestamp);
        un->un_resync_copysize = 0;
        un->un_column[resync].un_devflags &=
            ~(MD_RAID_REGEN_RESYNC | MD_RAID_COPY_RESYNC);
        raid_commit(un, recids);
        /* release unit writer lock and acquire unit reader lock */
        md_unit_writerexit(ui);
        md_io_writerexit(ui);
        (void) md_unit_readerlock(ui);
        if (err == RAID_RESYNC_OKAY) {
                SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_DONE,
                    SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
        } else {
                SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_FAILED,
                    SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
                if (raid_state_cnt(un, RCS_ERRED |
                        RCS_LAST_ERRED) > 1) {
                        SE_NOTIFY(EC_SVM_STATE, ESC_SVM_LASTERRED,
                            SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
                } else {
                        SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED,
                            SVM_TAG_METADEVICE, MD_UN2SET(un), MD_SID(un));
                }
        }

        free_bufs(dbtob(bsize), cs);
}

/*
 * NAME:        resync_unit
 *
 * DESCRIPTION: Start of RAID resync thread.  Perform up front allocations,
 *              initializations and consistency checking, then call
 *              resync_comp to resync the component.
 *
 * PARAMETERS:  minor_t mnum - minor number identity of metadevice
 *
 * LOCKS:       Acquires and releases Unit Reader Lock to maintain unit
 *              existence during resync.
 *              Acquires and releases the resync count lock for cpr.
 */
static void
resync_unit(
        minor_t mnum
)
{
        mdi_unit_t      *ui;
        mr_unit_t       *un;
        md_raidps_t     *ps = NULL;
        md_raidcs_t     *cs = NULL;
        int             resync;

        /*
         * Increment the raid resync count for cpr
         */
        mutex_enter(&md_cpr_resync.md_resync_mutex);
        md_cpr_resync.md_raid_resync++;
        mutex_exit(&md_cpr_resync.md_resync_mutex);

        ui = MDI_UNIT(mnum);
        ASSERT(ui != NULL);

        un = (mr_unit_t *)md_unit_readerlock(ui);

        /*
         * Allocate parent and child memory pool structures.  These are
         * only needed to lock raid lines, so only the minimal
         * required fields for this purpose are initialized.
         *
         * Do not use the reserve pool for resync.
         */
        ps = kmem_cache_alloc(raid_parent_cache, MD_ALLOCFLAGS);
        raid_parent_init(ps);
        cs = kmem_cache_alloc(raid_child_cache, MD_ALLOCFLAGS);
        raid_child_init(cs);
        resync = un->un_resync_index;
        ps->ps_un = un;
        ps->ps_ui = ui;
        ps->ps_flags = MD_RPS_INUSE;
        cs->cs_ps = ps;
        cs->cs_un = un;

        ASSERT(!(un->un_column[resync].un_devflags & MD_RAID_WRITE_ALT));

        resync_comp(mnum, cs);
        release_resync_request(mnum);

        kmem_cache_free(raid_child_cache, cs);
        kmem_cache_free(raid_parent_cache, ps);

        md_unit_readerexit(ui);

        /* close raid unit */
        (void) raid_internal_close(mnum, OTYP_LYR, 0, 0);

        /* poke hot spare daemon */
        (void) raid_hotspares();

        /*
         * Decrement the raid resync count for cpr
         */
        mutex_enter(&md_cpr_resync.md_resync_mutex);
        md_cpr_resync.md_raid_resync--;
        mutex_exit(&md_cpr_resync.md_resync_mutex);

        thread_exit();
}

/*
 * NAME:        raid_resync_unit
 *
 * DESCRIPTION: RAID metadevice specific resync routine.
 *              Open the unit and start resync_unit as a separate thread.
 *
 * PARAMETERS:  minor_t   mnum - minor number identity of metadevice
 *              md_error_t *ep - output error parameter
 *
 * RETURN:      On error return 1 or set ep to nonzero, otherwise return 0.
 *
 * LOCKS:       Acquires and releases Unit Writer Lock.
 */
int
raid_resync_unit(
        minor_t                 mnum,
        md_error_t              *ep
)
{
        mdi_unit_t      *ui;
        set_t           setno = MD_MIN2SET(mnum);
        mr_unit_t       *un;

        ui = MDI_UNIT(mnum);
        un = MD_UNIT(mnum);

        if (md_get_setstatus(setno) & MD_SET_STALE)
                return (mdmddberror(ep, MDE_DB_STALE, mnum, setno));

        ASSERT(un->un_column[un->un_resync_index].un_devflags &
            (MD_RAID_COPY_RESYNC | MD_RAID_REGEN_RESYNC));

        /* Don't start a resync if the device is not available */
        if ((ui == NULL) || (ui->ui_tstate & MD_DEV_ERRORED)) {
                return (mdmderror(ep, MDE_RAID_OPEN_FAILURE, mnum));
        }

        if (raid_internal_open(mnum, FREAD | FWRITE, OTYP_LYR, 0)) {
                (void) md_unit_writerlock(ui);
                release_resync_request(mnum);
                md_unit_writerexit(ui);
                SE_NOTIFY(EC_SVM_STATE, ESC_SVM_OPEN_FAIL, SVM_TAG_METADEVICE,
                    setno, MD_SID(un));
                return (mdmderror(ep, MDE_RAID_OPEN_FAILURE, mnum));
        }

        /* start resync_unit thread */
        (void) thread_create(NULL, 0, resync_unit, (void *)(uintptr_t)mnum,
            0, &p0, TS_RUN, minclsyspri);

        return (0);
}