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);
}
static int
stripe_grow(void *d, int mode, IOLOCK *lockp)
{
minor_t mnum;
ms_unit_t *un, *new_un;
mdi_unit_t *ui;
minor_t *par = NULL;
IOLOCK *plock = NULL;
ms_comp_t *mdcomp, *new_comp;
int row, i, c;
mddb_recid_t ms_recid;
mddb_recid_t old_vtoc = 0;
mddb_recid_t *recids;
md_create_rec_option_t options;
mddb_type_t typ1;
int err;
int64_t tb, atb;
uint_t nr, oc;
int opened;
int rval = 0;
set_t setno;
md_error_t *mdep;
int npar;
int rid;
int num_recs;
u_longlong_t rev;
md_grow_params_t *mgp = d;
mnum = mgp->mnum;
mdep = &mgp->mde;
setno = MD_MIN2SET(mnum);
npar = mgp->npar;
mdclrerror(mdep);
if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
if (md_get_setstatus(setno) & MD_SET_STALE)
return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));
ui = MDI_UNIT(mnum);
if (ui == NULL) {
return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));
}
if (npar >= 1) {
ASSERT((minor_t *)(uintptr_t)mgp->par != NULL);
par = kmem_alloc(npar * sizeof (*par), KM_SLEEP);
plock = kmem_alloc(npar * sizeof (*plock), KM_SLEEP);
if (ddi_copyin((caddr_t)(uintptr_t)mgp->par, (caddr_t)par,
(npar * sizeof (*par)), mode) != 0) {
kmem_free(par, npar * sizeof (*par));
kmem_free(plock, npar * sizeof (*plock));
return (EFAULT);
}
}
/*
* we grab unit reader/writer first, then parent locks,
* then our own.
* we expect parent units to be sorted to avoid deadlock
*/
rw_enter(&md_unit_array_rw.lock, RW_WRITER);
for (i = 0; i < npar; ++i) {
(void) md_ioctl_writerlock(&plock[i],
MDI_UNIT(par[i]));
}
un = (ms_unit_t *)md_ioctl_writerlock(lockp, ui);
if (un->un_nrows != mgp->nrows) {
rval = EINVAL;
goto out;
}
typ1 = (mddb_type_t)md_getshared_key(setno,
stripe_md_ops.md_driver.md_drivername);
/*
* Preserve the friendly name nature of growing device.
*/
options = MD_CRO_STRIPE;
if (un->c.un_revision & MD_FN_META_DEV)
options |= MD_CRO_FN;
if (mgp->options & MD_CRO_64BIT) {
#if defined(_ILP32)
rval = mdmderror(mdep, MDE_UNIT_TOO_LARGE, mnum);
goto out;
#else
ms_recid = mddb_createrec((size_t)mgp->size, typ1, 0,
MD_CRO_64BIT | options, setno);
#endif
} else {
ms_recid = mddb_createrec((size_t)mgp->size, typ1, 0,
MD_CRO_32BIT | options, setno);
}
if (ms_recid < 0) {
rval = mddbstatus2error(mdep, (int)ms_recid, mnum, setno);
goto out;
}
/* get the address of the new unit */
new_un = (ms_unit_t *)mddb_getrecaddr(ms_recid);
/*
* It is okay that we muck with the new unit here,
* since no one else will know about the unit struct
* until we commit it. If we crash, the record will
* be automatically purged, since we haven't
* committed it yet and the old unit struct will be found.
*/
/* copy in the user's unit struct */
err = ddi_copyin((caddr_t)(uintptr_t)mgp->mdp, (caddr_t)new_un,
(size_t)mgp->size, mode);
if (err) {
mddb_deleterec_wrapper(ms_recid);
rval = EFAULT;
goto out;
}
if (options & MD_CRO_FN)
new_un->c.un_revision |= MD_FN_META_DEV;
/*
* allocate the real recids array. since we may have to
* commit underlying metadevice records, we need an
* array of size: total number of new components being
* attached + 2 (one for the stripe itself, one for the
* end marker).
*/
num_recs = 2;
rid = 0;
for (row = 0; row < new_un->un_nrows; row++) {
struct ms_row *mdr = &new_un->un_row[row];
num_recs += mdr->un_ncomp;
}
recids = kmem_alloc(num_recs * sizeof (mddb_recid_t), KM_SLEEP);
recids[rid++] = ms_recid;
/*
* Save a few of the new unit structs fields.
* Before they get clobbered.
*/
tb = new_un->c.un_total_blocks;
atb = new_un->c.un_actual_tb;
nr = new_un->un_nrows;
oc = new_un->un_ocomp;
rev = new_un->c.un_revision;
/*
* Copy the old unit struct (static stuff)
* into new unit struct
*/
bcopy((caddr_t)un, (caddr_t)new_un,
sizeof (ms_unit_t) + ((nr - 2) * (sizeof (struct ms_row))));
/*
* Restore the saved stuff.
*/
new_un->c.un_total_blocks = tb;
md_nblocks_set(mnum, new_un->c.un_total_blocks);
new_un->c.un_actual_tb = atb;
new_un->un_nrows = nr;
new_un->un_ocomp = oc;
new_un->c.un_revision = rev;
new_un->c.un_record_id = ms_recid;
new_un->c.un_size = mgp->size;
/* All 64 bit metadevices only support EFI labels. */
if (mgp->options & MD_CRO_64BIT) {
new_un->c.un_flag |= MD_EFILABEL;
/*
* If the device was previously smaller than a terabyte,
* and had a vtoc record attached to it, we remove the
* vtoc record, because the layout has changed completely.
*/
if (((un->c.un_revision & MD_64BIT_META_DEV) == 0) &&
(un->c.un_vtoc_id != 0)) {
old_vtoc = un->c.un_vtoc_id;
new_un->c.un_vtoc_id =
md_vtoc_to_efi_record(old_vtoc, setno);
}
}
/*
* Copy the old component structs into the new unit struct.
*/
mdcomp = (ms_comp_t *)((void *)&((char *)un)[un->un_ocomp]);
new_comp = (ms_comp_t *)((void *)&((char *)new_un)[new_un->un_ocomp]);
for (row = 0; row < un->un_nrows; row++) {
struct ms_row *mdr = &un->un_row[row];
for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++, c++) {
bcopy((caddr_t)&mdcomp[c], (caddr_t)&new_comp[c],
sizeof (ms_comp_t));
}
}
opened = md_unit_isopen(ui);
/*
* Set parent on metadevices being added.
* Open the new devices being added.
* NOTE: currently soft partitions are the only metadevices
* which can appear within a stripe.
*/
for (row = un->un_nrows; row < new_un->un_nrows; row++) {
struct ms_row *mdr = &new_un->un_row[row];
for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++) {
struct ms_comp *mdc = &new_comp[c++];
md_dev64_t comp_dev;
md_unit_t *comp_un;
comp_dev = mdc->un_dev;
/* set parent on any metadevices */
if (md_getmajor(comp_dev) == md_major) {
comp_un = MD_UNIT(md_getminor(comp_dev));
recids[rid++] = MD_RECID(comp_un);
md_set_parent(comp_dev, MD_SID(new_un));
}
if (opened) {
md_dev64_t tmpdev = mdc->un_dev;
/*
* Open by device id
* Check if this comp is hotspared and
* if it is then use the key for hotspare
*/
tmpdev = md_resolve_bydevid(mnum, tmpdev,
mdc->un_mirror.ms_hs_id ?
mdc->un_mirror.ms_hs_key : mdc->un_key);
(void) md_layered_open(mnum, &tmpdev,
MD_OFLG_NULL);
mdc->un_dev = tmpdev;
mdc->un_mirror.ms_flags |= MDM_S_ISOPEN;
}
}
}
/* set end marker */
recids[rid] = 0;
/* commit new unit struct */
mddb_commitrecs_wrapper(recids);
/* delete old unit struct */
mddb_deleterec_wrapper(un->c.un_record_id);
/* place new unit in in-core array */
md_nblocks_set(mnum, new_un->c.un_total_blocks);
MD_UNIT(mnum) = new_un;
/*
* If old_vtoc has a non zero value, we know:
* - This unit crossed the border from smaller to larger one TB
* - There was a vtoc record for the unit,
* - This vtoc record is no longer needed, because
* a new efi record has been created for this un.
*/
if (old_vtoc != 0) {
mddb_deleterec_wrapper(old_vtoc);
}
/* free recids array */
kmem_free(recids, num_recs * sizeof (mddb_recid_t));
SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_GROW, SVM_TAG_METADEVICE,
MD_UN2SET(new_un), MD_SID(new_un));
/* release locks, return success */
out:
for (i = npar - 1; (i >= 0); --i)
md_ioctl_writerexit(&plock[i]);
rw_exit(&md_unit_array_rw.lock);
if (plock != NULL)
kmem_free(plock, npar * sizeof (*plock));
if (par != NULL)
kmem_free(par, npar * sizeof (*par));
return (rval);
}
/*
* NAME: check_comp_4_hs
*
* DESCRIPTION: Check whether the input component has an error and can be
* backed with a hot spare (RCS_ERRED state), and initiate
* a resync if so.
*
* PARAMETERS: mr_unit_t *un - raid unit
* int hs_index - component to check
*
* LOCKS: Expects Unit Writer Lock to be held upon entrance. Releases
* the lock prior to calling raid_resync_unit, then reacquires
* it before returning.
*/
static void
check_comp_4_hs(
mr_unit_t *un,
int hs_index
)
{
mddb_recid_t recids[3];
minor_t mnum = MD_SID(un);
mdi_unit_t *ui;
rcs_state_t state;
diskaddr_t size;
int err;
mr_column_t *col;
md_error_t mde = mdnullerror;
char devname[MD_MAX_CTDLEN];
char hs_devname[MD_MAX_CTDLEN];
set_t setno;
md_dev64_t tmpdev;
diskaddr_t tmpdaddr;
/* initialize */
setno = MD_UN2SET(un);
ui = MDI_UNIT(mnum);
md_unit_readerexit(ui);
(void) md_io_writerlock(ui);
un = (mr_unit_t *)md_unit_writerlock(ui);
col = &un->un_column[hs_index];
/*
* add a hotspare for erred column only if not resyncing
*/
if ((!(COLUMN_STATE(un, hs_index) & RCS_ERRED)) ||
(raid_state_cnt(un, (RCS_ERRED | RCS_LAST_ERRED)) != 1) ||
(raid_state_cnt(un, RCS_RESYNC) > 0)) {
goto errout;
}
recids[0] = 0;
recids[1] = 0;
/* if there is already a hotspare then just return */
if (HOTSPARED(un, hs_index) && (col->un_devstate & RCS_ERRED)) {
raid_hs_release(HS_BAD, un, &recids[0], hs_index);
cmn_err(CE_WARN, "md: %s: %s hotspare errored and released",
md_shortname(mnum),
md_devname(MD_MIN2SET(mnum), col->un_dev, NULL, 0));
col->un_dev = col->un_orig_dev;
col->un_pwstart = col->un_orig_pwstart;
col->un_devstart = col->un_orig_devstart;
raid_commit(un, recids);
SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HS_FREED, SVM_TAG_METADEVICE,
setno, MD_SID(un));
}
ASSERT(!HOTSPARED(un, hs_index));
state = col->un_devstate;
size = col->un_pwstart + un->un_pwsize +
(un->un_segsize * un->un_segsincolumn);
again:
/* quit if resync is already active */
col->un_devflags |= MD_RAID_REGEN_RESYNC;
if (resync_request(mnum, hs_index, 0, NULL))
goto errout;
recids[0] = 0;
recids[1] = 0;
tmpdev = col->un_dev;
tmpdaddr = col->un_hs_pwstart;
/* get a hotspare */
if (md_hot_spare_ifc(HS_GET, un->un_hsp_id, size,
((col->un_orig_pwstart >= 1) &&
(col->un_orig_pwstart != MD_DISKADDR_ERROR)),
&col->un_hs_id, &col->un_hs_key, &tmpdev, &tmpdaddr) != 0) {
col->un_dev = tmpdev;
col->un_hs_pwstart = tmpdaddr;
release_resync_request(mnum);
raid_set_state(un, hs_index, state, 1);
goto errout;
}
col->un_hs_pwstart = tmpdaddr;
/*
* record id is filled in by raid_commit, recids[0] filled in by
* md_hot_spare_ifc if needed
*/
recids[0] = col->un_hs_id;
recids[1] = 0;
/*
* close the device and open the hot spare. The device should
* never be a hotspare here.
*/
if (col->un_devflags & MD_RAID_DEV_ISOPEN) {
md_layered_close(col->un_orig_dev, MD_OFLG_NULL);
col->un_devflags &= ~MD_RAID_DEV_ISOPEN;
}
/*
* Try open by device id
*/
tmpdev = md_resolve_bydevid(mnum, tmpdev, col->un_hs_key);
if (md_layered_open(mnum, &tmpdev, MD_OFLG_NULL)) {
md_dev64_t hs_dev = tmpdev;
/* cannot open return to orig */
raid_hs_release(HS_BAD, un, &recids[0], hs_index);
release_resync_request(mnum);
raid_set_state(un, hs_index, state, 1);
col->un_dev = col->un_orig_dev;
col->un_devstart = col->un_orig_devstart;
col->un_pwstart = col->un_orig_pwstart;
col->un_devflags &= ~MD_RAID_DEV_ISOPEN;
raid_commit(un, recids);
cmn_err(CE_WARN, "md: %s: open error of hotspare %s",
md_shortname(mnum),
md_devname(MD_MIN2SET(mnum), hs_dev, NULL, 0));
SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HS_FREED, SVM_TAG_HS, setno,
MD_SID(un));
goto again;
}
col->un_dev = tmpdev;
col->un_devflags |= MD_RAID_DEV_ISOPEN;
/*
* move the values into the device fields. Since in some cases
* the pwstart is not zero this must be added into the start of
* the hotspare to avoid over writting the label
*/
col->un_hs_pwstart += col->un_orig_pwstart;
col->un_pwstart = col->un_hs_pwstart;
col->un_hs_devstart = col->un_hs_pwstart + un->un_pwsize;
col->un_devstart = col->un_hs_devstart;
/* commit unit and hotspare records and release lock */
raid_commit(un, recids);
md_unit_writerexit(ui);
md_io_writerexit(ui);
err = raid_resync_unit(mnum, &mde);
/* if resync fails, transition back to erred state and reset */
if (err) {
/* reaquire unit writerr lock */
un = (mr_unit_t *)md_unit_writerlock(ui);
raid_set_state(un, hs_index, RCS_ERRED, 0);
/*
* close the hotspare and return it. Then restore the
* original device back to the original state
*/
raid_hs_release(HS_FREE, un, &recids[0], hs_index);
col->un_dev = col->un_orig_dev;
col->un_devstart = col->un_orig_devstart;
col->un_pwstart = col->un_orig_pwstart;
raid_commit(un, recids);
md_unit_writerexit(ui);
un = (mr_unit_t *)md_unit_readerlock(ui);
return;
}
setno = MD_MIN2SET(mnum);
(void) md_devname(setno, col->un_orig_dev, devname,
sizeof (devname));
(void) md_devname(setno, col->un_dev, hs_devname,
sizeof (hs_devname));
cmn_err(CE_NOTE, "md: %s: hotspared device %s with %s",
md_shortname(mnum), devname, hs_devname);
SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HOTSPARED, SVM_TAG_HS, setno,
MD_SID(un));
(void) md_unit_readerlock(ui);
return;
errout:
md_unit_writerexit(ui);
md_io_writerexit(ui);
un = (mr_unit_t *)md_unit_readerlock(ui);
}
static int
stripe_open_all_devs(ms_unit_t *un, int md_oflags)
{
minor_t mnum = MD_SID(un);
int row;
int i;
int c;
struct ms_comp *mdcomp;
int err;
int cont_on_errors = (md_oflags & MD_OFLG_CONT_ERRS);
int probe_err_cnt = 0;
int total_comp_cnt = 0;
set_t setno = MD_MIN2SET(MD_SID(un));
side_t side = mddb_getsidenum(setno);
mdkey_t key;
mdcomp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);
/*
* For a probe call, if any component of a stripe or a concat
* can be opened, it is considered to be a success. The total number
* of components in a stripe are computed prior to starting a probe.
* This number is then compared against the number of components
* that could be be successfully opened. If none of the components
* in a stripe can be opened, only then an ENXIO is returned for a
* probe type open.
*/
for (row = 0; row < un->un_nrows; row++) {
struct ms_row *mdr = &un->un_row[row];
if (md_oflags & MD_OFLG_PROBEDEV)
total_comp_cnt += mdr->un_ncomp;
for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++) {
struct ms_comp *mdc;
md_dev64_t tmpdev;
mdc = &mdcomp[c++];
tmpdev = mdc->un_dev;
/*
* Do the open by device id
* Check if this comp is hotspared and
* if it is then use the key for hotspare.
* MN disksets don't use devids, so we better don't use
* md_devid_found/md_resolve_bydevid there. Rather do,
* what's done in stripe_build_incore()
*/
if (MD_MNSET_SETNO(setno)) {
if (mdc->un_mirror.ms_hs_id != 0) {
(void) md_hot_spare_ifc(HS_MKDEV, 0, 0,
0, &mdc->un_mirror.ms_hs_id, NULL,
&tmpdev, NULL);
}
} else {
key = mdc->un_mirror.ms_hs_id ?
mdc->un_mirror.ms_hs_key : mdc->un_key;
if ((md_getmajor(tmpdev) != md_major) &&
md_devid_found(setno, side, key) == 1) {
tmpdev = md_resolve_bydevid(mnum,
tmpdev, key);
}
}
/*
* For a submirror, we only want to open those devices
* that are not errored. If the device is errored then
* then there is no reason to open it and leaving it
* closed allows the RCM/DR code to work so that the
* errored device can be replaced.
*/
if ((md_oflags & MD_OFLG_PROBEDEV) ||
! (mdc->un_mirror.ms_state & CS_ERRED)) {
err = md_layered_open(mnum, &tmpdev, md_oflags);
} else {
err = ENXIO;
}
/*
* Only set the un_dev if the tmpdev != NODEV64. If
* it is NODEV64 then the md_layered_open() will have
* failed in some manner.
*/
if (tmpdev != NODEV64)
mdc->un_dev = tmpdev;
if (err) {
if (!cont_on_errors) {
stripe_close_all_devs(un, md_oflags);
return (ENXIO);
}
if (md_oflags & MD_OFLG_PROBEDEV)
probe_err_cnt++;
} else {
if (md_oflags & MD_OFLG_PROBEDEV) {
mdc->un_mirror.ms_flags |=
MDM_S_PROBEOPEN;
} else
mdc->un_mirror.ms_flags |= MDM_S_ISOPEN;
}
}
}
/* If every component in a stripe could not be opened fail */
if ((md_oflags & MD_OFLG_PROBEDEV) &&
(probe_err_cnt == total_comp_cnt))
return (ENXIO);
else
return (0);
}
