/*
* 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
* 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 (c) 2011 Bayard G. Bell. All rights reserved.
*/
#include <sys/sysmacros.h>
#ifndef lint
#endif
extern mdq_anchor_t md_done_daemon;
extern mdq_anchor_t md_mstr_daemon;
extern mdq_anchor_t md_mirror_daemon;
extern mdq_anchor_t md_mirror_io_daemon;
extern mdq_anchor_t md_mirror_rs_daemon;
extern mdq_anchor_t md_mhs_daemon;
extern int md_status;
extern md_krwlock_t md_unit_array_rw;
extern kcondvar_t md_cv;
extern int md_mtioctl_cnt;
/* Flags for mdmn_ksend_message to allow debugging */
int md_mirror_msg_flags;
#ifdef DEBUG
/* Flag to switch on debug messages */
int mirror_debug_flag = 0;
#endif
/*
* Struct used to hold count of DMR reads and the timestamp of last DMR read
* It is used to verify, using a debugger, that the DMR read ioctl has been
* executed.
*/
/*
* Mutex protecting list of non-failfast drivers.
*/
extern char **non_ff_drivers;
/*
* Write-On-Write memory pool.
*/
/*
* This is a flag that allows:
* - disabling the write-on-write mechanism.
* - logging occurrences of write-on-write
* - switching wow handling procedure processing
* Counter for occurences of WOW.
*/
static int md_mirror_wow_cnt = 0;
/*
* processing when closing down a mirror.
*/
extern int md_ff_disable; /* disable failfast */
static void mirror_read_strategy(buf_t *, int, void *);
static void mirror_write_strategy(buf_t *, int, void *);
static void become_owner(daemon_queue_t *);
/*
* patchables
*/
/*
* patchable to change delay before rescheduling mirror ownership request.
* Value is clock ticks, default 0.5 seconds
*/
/*ARGSUSED1*/
static int
{
return (0);
}
static void
{
}
/*ARGSUSED1*/
static void
mirror_parent_destructor(void *p, void *d)
{
}
/*ARGSUSED1*/
static int
{
return (0);
}
void
{
}
/*ARGSUSED1*/
static void
mirror_child_destructor(void *p, void *d)
{
}
static void
{
bzero(p, md_wowblk_size);
}
static void
{
int rval;
int nretries = 0;
/* If we're shutting down already, pause things here. */
while (!md_mn_is_commd_present()) {
}
/*
* commd has become reachable again, so retry once.
* If this fails we'll panic as the system is in an
* unexpected state.
*/
if (nretries++ == 0)
goto retry_sphmsg;
}
"ksend_message failure: POKE_HOTSPARES");
}
/* Allow further requests to use this set's queue structure */
drq->dr_pending = 0;
}
/*
* Send a poke_hotspares message to the master node. To avoid swamping the
* commd handler with requests we only send a message if there is not one
* already outstanding. We punt the request to a separate thread context as
* cannot afford to block waiting on the request to be serviced. This is
* essential when a reconfig cycle is in progress as any open() of a multinode
* metadevice may result in a livelock.
*/
static void
{
if (drq->dr_pending == 0) {
}
}
void
int force)
{
int compcnt;
int i;
int errcnt;
if (force) {
return;
}
errcnt++;
}
else
newstate &= ~SMS_ALL_ERRED;
}
static int
int frm_probe)
{
int ci;
int i;
int compcnt;
continue;
/*
* if called from any routine but probe, we check for
* MDM_S_ISOPEN flag. Since probe does a pseduo open,
* it sets MDM_S_PROBEOPEN flag and we test for this
* flag. They are both exclusive tests.
*/
(!open_comp &&
if (clr_error) {
}
*smi = i;
return (1);
}
}
}
*cip = 0;
}
return (0);
}
/*ARGSUSED*/
static void
mirror_run_queue(void *d)
{
if (!(md_status & MD_GBL_DAEMONS_LIVE))
}
/*
* check_comp_4_hotspares
*
* This function attempts to allocate a hotspare for this component if the
* component is in error. In a MN set, the function can be called in 2 modes.
* It can be called either when a component error has been detected or when a
* new hotspare has been allocated. In this case, MD_HOTSPARE_XMIT is set
* in flags and the request is sent to all nodes.
* The handler on each of the nodes then calls this function with
* MD_HOTSPARE_XMIT unset and the hotspare allocation is then performed.
*
* For non-MN sets the function simply attempts to allocate a hotspare.
*
* On entry, the following locks are held
* mirror_md_ops.md_link_rw (if flags has MD_HOTSPARE_LINKHELD set)
* md_unit_writerlock
*
* Returns 0 if ok
* 1 if the unit containing the component has been cleared while
* the mdmn_ksend_message() was being executed
*/
extern int
int smi,
int ci,
)
{
void (*hs_done)();
void *hs_data;
int rval;
int nretries = 0;
return (0);
/* Don't start a new component resync if a resync is already running. */
return (0);
/* Send allocate hotspare message to all nodes */
/*
* Before calling mdmn_ksend_message(), release locks
* Can never be in the context of an ioctl.
*/
if (flags & MD_HOTSPARE_LINKHELD)
#ifdef DEBUG
if (mirror_debug_flag)
printf("send alloc hotspare, flags="
"0x%x %x, %x, %x, %x\n", flags,
#endif
if (flags & MD_HOTSPARE_WMUPDATE) {
/*
* When coming from an update of watermarks, there
* must already be a message logged that triggered
* this action. So, no need to log this message, too.
*/
} else {
}
(char *)&allochspmsg, sizeof (allochspmsg),
kresult);
#ifdef DEBUG
if (mirror_debug_flag)
"ALLOCATE HOTSPARE");
#endif
/*
* If message is sent ok but exitval indicates an error
* it must be because the mirror has been cleared. In
* this case re-obtain lock and return an error
*/
if (flags & MD_HOTSPARE_LINKHELD) {
}
return (1);
}
/* If we're shutting down already, pause things here. */
while (!md_mn_is_commd_present()) {
}
/*
* commd has become reachable again, so retry
* once. If this fails we'll panic as the
* system is in an unexpected state.
*/
if (nretries++ == 0)
goto cc4hs_msg;
}
"ksend_message failure: ALLOCATE_HOTSPARE");
}
/*
* re-obtain the locks
*/
if (flags & MD_HOTSPARE_LINKHELD)
/*
* As we had to release the locks in order to send the
* message to all nodes, we need to check to see if the
* unit has changed. If it has we release the writerlock
* and return fail.
*/
return (1);
}
} else {
if (MD_MNSET_SETNO(setno)) {
/*
* If 2 or more nodes simultaneously see a
* component failure, these nodes will each
* send an ALLOCATE_HOTSPARE[2] message.
* The first message will allocate the hotspare
* and the subsequent messages should do nothing.
*
* If a slave node doesn't have a hotspare allocated
* at the time the message is initiated, then the
* passed in hs_id will be 0. If the node
* executing this routine has a component shared
* ms_hs_id of non-zero, but the message shows a
* hs_id of 0, then just return since a hotspare
* has already been allocated for this failing
* component. When the slave node returns from
* the ksend_message the hotspare will have
* already been allocated.
*
* If the slave node does send an hs_id of non-zero,
* and the slave node's hs_id matches this node's
* ms_hs_id, then the hotspare has error'd and
* should be replaced.
*
* If the slave node sends an hs_id of non-zero and
* this node has a different shared ms_hs_id, then
* just return since this hotspare has already
* been hotspared.
*/
if (hs_id == 0) {
#ifdef DEBUG
if (mirror_debug_flag) {
printf("check_comp_4_hotspares"
"(NOXMIT), short circuit "
"hs_id=0x%x, "
"ms_hs_id=0x%x\n",
}
#endif
return (0);
}
#ifdef DEBUG
if (mirror_debug_flag) {
printf("check_comp_4_hotspares"
"(NOXMIT), short circuit2 "
"hs_id=0x%x, "
"ms_hs_id=0x%x\n",
}
#endif
return (0);
}
}
}
"hotspare device", 0);
&hs_data) != 0)
return (0);
/*
* set_sm_comp_state() commits the modified records.
* As we don't transmit the changes, no need to drop the lock.
*/
/*
* For a multi-node set we need to reset the un_rs_type,
* un_rs_resync_done and un_rs_resync_2_do fields as the
* hot-spare resync must copy all applicable data.
*/
if (MD_MNSET_SETNO(setno)) {
un->un_rs_resync_done = 0;
un->un_rs_resync_2_do = 0;
}
/*
* Must drop writer lock since mirror_resync_unit will
* open devices and must be able to grab readerlock.
* Don't need to drop IOLOCK since any descendent routines
* calling ksend_messages will drop the IOLOCK as needed.
*
*/
if (lockp) {
} else {
}
/* start resync */
if (lockp) {
} else {
}
}
return (0);
}
/*
* check_unit_4_hotspares
*
* For a given mirror, allocate hotspares, if available for any components
* that are in error
*
* Returns 0 if ok
* 1 if check_comp_4_hotspares returns non-zero. This will only
* happen for a MN unit where the unit has been cleared while
* the allocate hotspare message is sent to all nodes.
*/
static int
{
int ci;
int i;
int compcnt;
return (0);
for (i = 0; i < NMIRROR; i++) {
continue;
shared = (md_m_shared_t *)
/*
* Never called from ioctl context, so pass in
* (IOLOCK *)NULL. Pass through flags from calling
* routine, also setting XMIT flag.
*/
(MD_HOTSPARE_XMIT | flags),
return (1);
}
}
return (0);
}
static void
{
int x;
/*
* Used to have a problem here. The disksets weren't marked as being
* MNHOLD. This opened a window where we could be searching for
* hotspares and have the disk set unloaded (released) from under
* us causing a panic in stripe_component_count().
* The way to prevent that is to mark the set MNHOLD which prevents
* any diskset from being released while we are scanning the mirrors,
* submirrors and components.
*/
for (x = 0; x < md_nsets; x++)
md_holdset_enter(x);
/*
* Only check the unit if we are the master for this set
* For an MN set, poke_hotspares() is only effective on the
* master
*/
continue;
}
continue;
}
/*
* check_unit_4_hotspares will exit 1 if the unit has been
* removed during the process of allocating the hotspare.
* This can only happen for a MN metadevice. If unit no longer
* exists, no need to release writerlock
*/
else {
/*
* If check_unit_4_hotspares failed, queue another
* request and break out of this one
*/
(void) poke_hotspares();
break;
}
}
for (x = 0; x < md_nsets; x++)
md_holdset_exit(x);
}
/*
* poke_hotspares
*
* If there is not a pending poke_hotspares request pending, queue a requent
* to call check_4_hotspares(). This will scan all mirrors and attempt to
* allocate hotspares for all components in error.
*/
int
{
if (hotspare_request.dr_pending == 0) {
REQ_OLD);
}
return (0);
}
static void
{
err_comp_t *d;
d = ecomp;
kmem_free(d, sizeof (err_comp_t));
}
}
/*
* NAME: mirror_openfail_console_info
*
* DESCRIPTION: Prints a informative message to the console when mirror
* cannot be opened.
*
* PARAMETERS: mm_unit_t un - pointer to mirror unit structure
* int smi - submirror index
* int ci - component index
*/
void
{
void (*get_dev)();
} else {
}
}
static int
{
int i;
for (i = 0; i < NMIRROR; i++) {
continue;
}
return (0);
}
/*
* Keep track of drivers that don't support failfast. We use this so that
* we only log one diagnostic message for each of these drivers, no matter
* how many times we run the mirror_check_failfast function.
* Return 1 if this is a new driver that does not support failfast,
* return 0 if we have already seen this non-failfast driver.
*/
static int
new_non_ff_driver(const char *s)
{
if (non_ff_drivers == NULL) {
if (non_ff_drivers == NULL) {
return (1);
}
if (non_ff_drivers[0] == NULL) {
return (1);
}
(void) strcpy(non_ff_drivers[0], s);
} else {
int i;
char **tnames;
char **tmp;
for (i = 0; non_ff_drivers[i] != NULL; i++) {
if (strcmp(s, non_ff_drivers[i]) == 0) {
return (0);
}
}
/* allow for new element and null */
i += 2;
return (1);
}
for (i = 0; non_ff_drivers[i] != NULL; i++)
tnames[i] = non_ff_drivers[i];
/* adjust i so that it is the right count to free */
return (1);
}
/* i now represents the count we previously alloced */
}
return (1);
}
/*
* Check for the "ddi-failfast-supported" devtree property on each submirror
* component to indicate if we should do I/O to that submirror with the
* B_FAILFAST flag set or not. This check is made at various state transitions
* in the mirror code (e.g. open, enable, hotspare, etc.). Sometimes we
* only need to check one drive (e.g. hotspare) but since the check is
* fast and infrequent and sometimes needs to be done on all components we
* just check all components on each call.
*/
void
{
int i;
if (md_ff_disable)
return;
for (i = 0; i < NMIRROR; i++) {
int ci;
int cnt;
void (*get_dev)();
continue;
"get device", 0);
int found = 0;
/*
* this already returns the hs
* dev if the device is spared
*/
/*
* this component must be a soft
* partition; get the real dev
*/
/* grab necessary lock */
/* Get dev by device id */
}
}
!= NULL) {
int propvalue = 0;
int proplength = sizeof (int);
int error;
NULL) {
"ddi-failfast-supported",
if (error == DDI_PROP_SUCCESS)
found = 1;
}
if (!found && new_non_ff_driver(
ddi_driver_name(devi))) {
"disabled on %s",
}
}
/*
* All components must support
* failfast in the submirror.
*/
if (!found) {
ff = 0;
break;
}
}
if (ff) {
} else {
}
}
}
/*
* Return true if the submirror is unavailable.
* If any of the submirror components are opened then the submirror cannot
* be unavailable (MD_INACCESSIBLE).
* If any of the components are already in the errored state, then the submirror
* cannot be unavailable (MD_INACCESSIBLE).
*/
static bool_t
{
int ci;
int compcnt;
if (from_probe) {
return (B_FALSE);
} else {
return (B_FALSE);
}
return (B_FALSE);
}
return (B_TRUE);
}
static int
{
int i;
int err;
int smi;
int ci;
err_comp_t *c;
int smmask = 0;
int sm_cnt;
int sm_unavail_cnt;
for (i = 0; i < NMIRROR; i++) {
continue;
}
/*
* If smmask is clear, all submirrors are accessible. Clear the
* MD_INACCESSIBLE bit in this case. This bit is also cleared for the
* mirror device. If smmask is set, we have to determine which of the
* submirrors are in error. If no submirror is accessible we mark the
* whole mirror as MD_INACCESSIBLE.
*/
if (smmask == 0) {
if (lockp) {
} else {
(void) md_unit_writerlock(ui);
}
if (lockp) {
} else {
(void) md_unit_readerlock(ui);
}
for (i = 0; i < NMIRROR; i++) {
continue;
(void) md_unit_writerlock(sm_ui);
}
return (0);
}
for (i = 0; i < NMIRROR; i++) {
continue;
}
if (lockp) {
} else {
}
/*
* We want to make sure the unavailable flag is not masking a real
* error on the submirror.
* For each submirror,
* if all of the submirror components couldn't be opened and there
* are no errors on the submirror, then set the unavailable flag
* otherwise, clear unavailable.
*/
sm_cnt = 0;
sm_unavail_cnt = 0;
for (i = 0; i < NMIRROR; i++) {
continue;
sm_cnt++;
(void) md_unit_writerlock(sm_ui);
if (submirror_unavailable(un, i, 0)) {
} else {
}
}
/*
* If all of the submirrors are unavailable, the mirror is also
* unavailable.
*/
if (sm_cnt == sm_unavail_cnt) {
} else {
}
smi = 0;
ci = 0;
if (lockp) {
} else {
(void) md_unit_readerlock(ui);
}
return (ENXIO);
}
/* track all component states that need changing */
ecomps = c;
ci++;
}
/* Make all state changes and commit them */
/*
* If lockp is set, then entering kernel through ioctl.
* For a MN set, the only ioctl path is via a commd message
* (ALLOCATE_HOTSPARE or *RESYNC* messages) that is already
* being sent to each node.
* In this case, set NO_XMIT so that set_sm_comp_state
* won't attempt to send a message on a message.
*
* In !MN sets, the xmit flag is ignored, so it doesn't matter
* which flag is passed.
*/
if (lockp) {
} else {
}
/*
* For a MN set, the NOTIFY is done when the state change is
* processed on each node
*/
if (!MD_MNSET_SETNO(setno)) {
}
}
if (lockp) {
} else {
(void) md_unit_readerlock(ui);
}
/* allocate hotspares for all errored components */
if (MD_MNSET_SETNO(setno)) {
/*
* If we're called from an ioctl (lockp set) then we cannot
* directly call send_poke_hotspares as this will block until
* the message gets despatched to all nodes. If the cluster is
* going through a reconfig cycle then the message will block
* until the cycle is complete, and as we originate from a
* service call from commd we will livelock.
*/
(void) md_unit_readerlock(ui);
}
} else {
(void) poke_hotspares();
}
return (0);
}
void
{
if (panicstr)
return;
if (un->un_overlap_tree_flag != 0) {
un->un_overlap_tree_flag = 0;
}
}
/*
* wait_for_overlaps:
* -----------------
* Check that given i/o request does not cause an overlap with already pending
* i/o. If it does, block until the overlapped i/o completes.
*
* The flag argument has MD_OVERLAP_ALLOW_REPEAT set if it is ok for the parent
* structure to be already in the overlap tree and MD_OVERLAP_NO_REPEAT if
* it must not already be in the tree.
*/
static void
{
if (panicstr)
return;
if ((flags & MD_OVERLAP_ALLOW_REPEAT) &&
return;
}
do {
/*
* The candidate range does not overlap with any
* range in the tree. Insert it and be done.
*/
} else {
/*
* The candidate range would overlap. Set the flag
* indicating we need to be woken up, and sleep
* until another thread removes a range. If upon
* waking up we find this mps was put on the tree
* by another thread, the loop terminates.
*/
&un->un_overlap_tree_mx);
}
}
/*
* This function is called from mirror_done to check whether any pages have
* been modified while a mirrored write was in progress. Returns 0 if
* all pages associated with bp are clean, 1 otherwise.
*/
static int
{
int rval;
if (rval == -1)
rval = 0;
return (rval);
}
void
int smmask,
)
{
int i;
/* 2=mirror,null id */
int ri = 0;
return;
/* Add two, this includes the mirror unit and the null recid */
int nrecids = 0;
nrecids++;
}
}
for (i = 0; i < NMIRROR; i++) {
continue;
continue;
continue;
}
while (*extras != 0) {
extras++;
}
if (ri == 0)
return;
/*
* Ok to hold ioctl lock across record commit to mddb as
* long as the record(s) being committed aren't resync records.
*/
}
/*
* This routine is used to set a bit in the writable_bm bitmap
* which represents each submirror in a metamirror which
* is writable. The first writable submirror index is assigned
* to the sm_index. The number of writable submirrors are returned in nunits.
*
* This routine returns the submirror's unit number.
*/
static void
{
int i;
unsigned writable_bm = 0;
unsigned nunits = 0;
for (i = 0; i < NMIRROR; i++) {
if (SUBMIRROR_IS_WRITEABLE(un, i)) {
/* set bit of all writable units */
writable_bm |= SMI2BIT(i);
nunits++;
}
}
ps->ps_current_sm = 0;
}
static
unsigned
{
int i;
unsigned writable_bm = 0;
unsigned nunits = 0;
for (i = 0; i < NMIRROR; i++) {
if (SUBMIRROR_IS_WRITEABLE(un, i) &&
writable_bm |= SMI2BIT(i);
nunits++;
}
}
nunits--;
}
ps->ps_current_sm = 0;
return (nunits);
}
static md_dev64_t
int must_be_opened,
{
int i;
md_m_shared_t *s;
for (i = 0; i < NMIRROR; i++) {
if (!SUBMIRROR_IS_READABLE(un, i))
continue;
/*
* If the current submirror is marked as inaccessible, do not
* try to access it.
*/
(void) md_unit_readerlock(ui);
continue;
}
continue;
*shared = s;
}
}
if (s->ms_state != CS_LAST_ERRED)
continue;
/* don't use B_FAILFAST since we're Last Erred */
if (s->ms_lasterrcnt > lasterrcnt) {
lasterrcnt = s->ms_lasterrcnt;
*shared = s;
}
}
return (dev);
}
/*
* Given a 32-bit bitmap, this routine will return the bit number
* of the nth bit set. The nth bit set is passed via the index integer.
*
* This routine is used to run through the writable submirror bitmap
* and starting all of the writes. See the value returned is the
* index to appropriate submirror structure, in the md_sm
* array for metamirrors.
*/
static int
{
mask >>= 1;
}
return (bit);
}
static int
{
int i;
unsigned nunits = 0;
int iunit;
for (i = 0; i < NMIRROR; i++) {
continue;
running_bm |= SMI2BIT(i);
nunits++;
}
if (nunits == 0)
return (1);
/*
* For directed mirror read (DMR) we only use the specified side and
* do not compute the source of the read.
* If we're running with MD_MPS_DIRTY_RD set we always return the
* first mirror side (this prevents unnecessary ownership switching).
* Otherwise we return the submirror according to the mirror read option
*/
} else {
/* Normal (non-DMR) operation */
switch (un->un_read_option) {
case RD_GEOMETRY:
break;
case RD_FIRST:
break;
case RD_LOAD_BAL:
/* this is intentional to fall into the default */
default:
un->un_last_read);
break;
}
}
}
return (0);
}
static
int
{
int i;
for (i = 0; i < NMIRROR; i++) {
continue;
return (0);
return (0);
}
return (1);
}
void
{
return;
if (snarfing) {
} else {
/* submirror can no longer be soft partitioned */
}
}
0, "shared by blk", 0);
0, "shared by indx", 0);
"get block count skip size", 0);
}
static void
{
int smi;
int nsv = 0;
/*
* If a MN diskset and this node is not the master, do
* not delete any records on snarf of the mirror records.
*/
return;
}
continue;
}
if (recid > 0)
}
/*
* Comparison function for the avl tree which tracks
* outstanding writes on submirrors.
*
* Returns:
* -1: ps1 < ps2
* 0: ps1 and ps2 overlap
* 1: ps1 > ps2
*/
static int
{
return (0);
return (-1);
}
return (0);
return (1);
}
return (0);
}
/*
* Collapse any sparse submirror entries snarfed from the on-disk replica.
* Only the in-core entries are updated. The replica will be updated on-disk
* when the in-core replica is committed on shutdown of the SVM subsystem.
*/
static void
{
nremovals = 0;
smiremove = -1;
/*
* Check to see if this submirror is marked as in-use.
* If it isn't then it is a potential sparse entry and
* may need to be cleared from the configuration.
* The records should _already_ have been cleared by the
* original mirror_detach() code, but we need to shuffle
* any NULL entries in un_sm[] to the end of the array.
* Any NULL un_smic[] entries need to be reset to the underlying
*/
nremovals++;
break;
}
}
if (nremovals == 0) {
/*
* Ensure that we have a matching contiguous set of un_smic[]
* entries for the corresponding un_sm[] entries
*/
"shared by_blk", 0);
"shared by indx", 0);
"get component count", 0);
smic->sm_get_bcss =
"get block count skip size", 0);
}
return;
}
/*
* Reshuffle the submirror devices so that we do not have a dead record
* in the middle of the array. Once we've done this we need to rescan
* the mirror to check for any other holes.
*/
continue;
}
}
/*
* Now we need to rescan the array to find the next potential dead
* entry.
*/
goto rescan;
}
/* Return a -1 if optimized record unavailable and set should be released */
int
{
int i;
return (1);
}
if (mirror_are_submirrors_available(un) == 0)
return (1);
return (0);
/* pre-4.1 didn't define CAN_META_CHILD capability */
un->un_overlap_tree_flag = 0;
/*
* We need to collapse any sparse submirror entries into a non-sparse
* array. This is to cover the case where we have an old replica image
* which has not been updated (i.e. snarfed) since being modified.
* The new code expects all submirror access to be sequential (i.e.
* both the un_sm[] and un_smic[] entries correspond to non-empty
* submirrors.
*/
for (i = 0; i < NMIRROR; i++)
if (snarfing) {
/*
* If a MN set and set is not stale, then return -1
* which will force the caller to unload the set.
* The MN diskset nodes will return failure if
* unit_setup_resync fails so that nodes won't
* get out of sync.
*
* If set is STALE, the master node can't allocate
* a resync record (if needed), but node needs to
* join the set so that user can delete broken mddbs.
* So, if set is STALE, just continue on.
*/
return (-1);
}
} else
return (1);
}
un->un_suspend_wr_flag = 0;
/*
* Allocate mutexes for mirror-owner and resync-owner changes.
* All references to the owner message state field must be guarded
* by this mutex.
*/
/*
* Allocate mutex and condvar for resync thread manipulation. These
* will be used by mirror_resync_unit/mirror_ioctl_resync
*/
/*
* Allocate mutex and condvar for resync progress thread manipulation.
* This allows resyncs to be continued across an intervening reboot.
*/
/*
* Allocate mutex and condvar for Directed Mirror Reads (DMR). This
* provides synchronization between a user-ioctl and the resulting
* strategy() call that performs the read().
*/
/*
* Allocate rwlocks for un_pernode_dirty_bm accessing.
*/
for (i = 0; i < MD_MNMAXSIDES; i++) {
}
/* place various information in the in-core data structures */
return (0);
}
void
{
int smi;
int nsv = 0;
int i;
if (un->un_outstanding_writes)
if (un->un_goingclean_bm)
if (un->un_goingdirty_bm)
if (un->un_resync_bm)
if (un->un_pernode_dirty_sum)
/*
* Destroy the taskq for deferred processing of DRL clean requests.
* This taskq will only be present for Multi Owner mirrors.
*/
/*
* Attempt release of its minor node
*/
if (!removing)
return;
continue;
/* reallow soft partitioning of submirror and reset parent */
}
/* Destroy all mutexes and condvars before returning. */
for (i = 0; i < MD_MNMAXSIDES; i++) {
if (un->un_pernode_dirty_bm[i])
}
/*
* Remove self from the namespace
*/
}
/* This frees the unit structure. */
if (recid != 0)
/* Remove the vtoc, if present */
if (vtoc_id)
}
int
int flag,
int otyp,
int md_oflags,
)
{
int err = 0;
/* single thread */
if (lockp) {
/*
* If ioctl lock is held, use openclose_enter
* routine that will set the ioctl flag when
* grabbing the readerlock.
*/
} else {
(void) md_unit_openclose_enter(ui);
}
/*
* The mirror_open_all_devs routine may end up sending a STATE_UPDATE
* message in a MN diskset and this requires that the openclose
* lock is dropped in order to send this message. So, another
* flag (MD_UL_OPENINPROGRESS) is used to keep another thread from
* attempting an open while this thread has an open in progress.
* Call the *_lh version of the lock exit routines since the ui_mx
* mutex must be held from checking for OPENINPROGRESS until
* after the cv_wait call.
*/
if (lockp) {
(void) md_ioctl_openclose_exit_lh(lockp);
} else {
}
goto tryagain;
}
/* open devices, if necessary */
goto out;
}
/* count open */
goto out;
/* unlock, return success */
out:
if (lockp) {
/*
* If ioctl lock is held, use openclose_exit
* routine that will clear the lockp reader flag.
*/
(void) md_ioctl_openclose_exit(lockp);
} else {
}
return (err);
}
int
int otyp,
int md_cflags,
)
{
int err = 0;
/* single thread */
if (lockp) {
/*
* If ioctl lock is held, use openclose_enter
* routine that will set the ioctl flag when
* grabbing the readerlock.
*/
} else {
}
/* count closed */
goto out;
/* close devices, if necessary */
/*
* Clean up dirty bitmap for this unit. Do this
* before closing the underlying devices to avoid
* race conditions with reset_mirror() as a
* result of a 'metaset -r' command running in
* parallel. This might cause deallocation of
* dirty region bitmaps; with underlying metadevices
* in place this can't happen.
* Don't do this if a MN set and ABR not set
*/
}
/*
* clear these capabilities on the last open in the cluster.
* To do this we send a message to all nodes to see of the
* device is open.
*/
if (lockp) {
(void) md_ioctl_openclose_exit(lockp);
} else {
}
/*
* if we are in the context of an ioctl, drop the
* ioctl lock.
* Otherwise, no other locks should be held.
*/
if (lockp) {
}
/* if dropped the lock previously, regain it */
if (lockp) {
}
return (0);
}
/* unlock and return success */
}
out:
/* Call whether lockp is NULL or not. */
if (lockp) {
} else {
}
return (err);
}
/*
* When a component has completed resyncing and is now ok, check if the
* corresponding component in the other submirrors is in the Last Erred
* state. If it is, we want to change that to the Erred state so we stop
* using that component and start using this good component instead.
*
* This is called from set_sm_comp_state and recursively calls
* set_sm_comp_state if it needs to change the Last Erred state.
*/
static void
{
int ci;
int i;
int compcnt;
int changed = 0;
for (i = 0; i < NMIRROR; i++) {
continue;
/* ignore the submirror that we just made ok */
if (i == smi)
continue;
changed = 1;
}
}
}
/* maybe there is a hotspare for this newly erred component */
if (changed) {
if (MD_MNSET_SETNO(setno)) {
} else {
(void) poke_hotspares();
}
}
}
/*
* set_sm_comp_state
*
* Set the state of a submirror component to the specified new state.
* If the mirror is in a multi-node set, send messages to all nodes to
* block all writes to the mirror and then update the state and release the
* writes. These messages are only sent if MD_STATE_XMIT is set in flags.
* MD_STATE_XMIT will be unset in 2 cases:
* 1. When the state is changed to CS_RESYNC as this state change
* will already have been updated on each node by the processing of the
* distributed metasync command, hence no need to xmit.
* 2. When the state is change to CS_OKAY after a resync has completed. Again
* the resync completion will already have been processed on each node by
* the processing of the MD_MN_MSG_RESYNC_PHASE_DONE message for a component
* resync, hence no need to xmit.
*
* In case we are called from the updates of a watermark,
* (then MD_STATE_WMUPDATE will be set in the ps->flags) this is due to
* a metainit or similar. In this case the message that we sent to propagate
* the state change must not be a class1 message as that would deadlock with
* the metainit command that is still being processed.
* This we achieve by creating a class2 message MD_MN_MSG_STATE_UPDATE2
* instead. This also makes the submessage generator to create a class2
* submessage rather than a class1 (which would also block)
*
* On entry, unit_writerlock is held
* If MD_STATE_OCHELD is set in flags, then unit_openclose lock is
* also held.
*/
void
int smi,
int ci,
int newstate,
)
{
int origstate;
void (*get_dev)();
int err;
int rval;
int save_lock = 0;
int nretries = 0;
/* If we have a real error status then turn off MD_INACCESSIBLE. */
}
/*
* If the new state is an error and the old one wasn't, generate
* a console message. We do this before we send the state to other
* nodes in a MN set because the state change may change the component
* name if a hotspare is allocated.
*/
"get device", 0);
sizeof (devname));
}
if (newstate & CS_LAST_ERRED) {
devname);
/*
* Close the broken device and clear the open flag on
* it. Closing the device means the RCM framework will
* be able to unconfigure the device if required.
*
* We have to check that the device is open, otherwise
* the first open on it has resulted in the error that
* is being processed and the actual cd.cd_dev will be
* NODEV64.
*
* If this is a multi-node mirror, then the multinode
* state checks following this code will cause the
* slave nodes to close the mirror in the function
* mirror_set_state().
*/
}
/*
* Similar to logic above except no log messages since we
* are just transitioning from Last Erred to Erred.
*/
"get device", 0);
}
/*
* For a multi-node mirror, send the state change to the
* master, which broadcasts to all nodes, including this
* one. Once the message is received, the state is set
* in-core and the master commits the change to disk.
* There is a case, comp_replace, where this function
* can be called from within an ioctl and therefore in this
* case, as the ioctl will already be called on each node,
* there is no need to xmit the state change to the master for
* distribution to the other nodes. MD_STATE_XMIT flag is used
* to indicate whether a xmit is required. The mirror's
* transient state is set to MD_ERR_PENDING to avoid sending
* multiple messages.
*/
/*
* Send a state update message to all nodes. This message
* will generate 2 submessages, the first one to suspend
* all writes to the mirror and the second to update the
* state and resume writes.
*/
#ifdef DEBUG
if (mirror_debug_flag)
printf("send set state, %x, %x, %x, %x, %x\n",
#endif
if (flags & MD_STATE_WMUPDATE) {
/*
* When coming from an update of watermarks, there
* must already be a message logged that triggered
* this action. So, no need to log this message, too.
*/
} else {
}
/*
* If we are in the context of an ioctl, drop the ioctl lock.
* lockp holds the list of locks held.
*
* Otherwise, increment the appropriate reacquire counters.
* If openclose lock is *held, then must reacquire reader
* lock before releasing the openclose lock.
* Do not drop the ARRAY_WRITER lock as we may not be able
* to reacquire it.
*/
if (lockp) {
}
} else {
if (flags & MD_STATE_OCHELD) {
(void) md_unit_readerlock(ui);
} else {
}
}
/* If we're shutting down already, pause things here. */
while (!md_mn_is_commd_present()) {
}
/*
* commd is now available; retry the message
* one time. If that fails we fall through and
* panic as the system is in an unexpected state
*/
if (nretries++ == 0)
goto sscs_msg;
}
"ksend_message failure: STATE_UPDATE");
}
/* if dropped the lock previously, regain it */
if (lockp) {
} else {
/*
* Reacquire dropped locks and update acquirecnts
* appropriately.
*/
if (flags & MD_STATE_OCHELD) {
/*
* openclose also grabs readerlock.
*/
(void) md_unit_openclose_enter(ui);
(void) md_unit_writerlock(ui);
} else {
(void) md_unit_writerlock(ui);
}
}
} else {
else
un->un_changecnt++;
}
/*
* Resetting the Last Erred state will recursively call back
* into this function (set_sm_comp_state) to update the state.
*/
}
}
static int
int must_be_open,
int state,
int err_cnt)
{
md_m_shared_t *s;
while (cnt != 0) {
must_be_open, &s, NULL);
if (dev == (md_dev64_t)0)
break;
if ((state == CS_LAST_ERRED) &&
(s->ms_state == CS_LAST_ERRED) &&
(err_cnt > s->ms_lasterrcnt))
break;
}
return (cnt != 0);
}
int
{
int cnt;
md_m_shared_t *s;
int not_found;
/*
* Make sure every component of the submirror
* has other sources.
*/
if (ci < 0) {
/* Find the highest lasterrcnt */
if (not_found)
return (1);
}
return (0);
}
/*
* Make sure this component has other sources
*/
(void) (*(smic->sm_get_bcss))
if (count == 0)
return (1);
while (count--) {
return (0);
if (not_found)
return (1);
}
return (0);
}
static void
{
/*
* Must flag any error to the resync originator if we're performing
* a Write-after-Read. This corresponds to an i/o error on a resync
* target device and in this case we ought to abort the resync as there
* is nothing that can be done to recover from this without operator
* intervention. If we don't set the B_ERROR flag we will continue
* reading from the mirror but won't write to the target (as it will
* have been placed into an errored state).
* To handle the case of multiple components within a submirror we only
* set the B_ERROR bit if explicitly requested to via MD_MPS_FLAG_ERROR.
* The originator of the resync read will cause this bit to be set if
* the underlying component count is one for a submirror resync. All
* other resync types will have the flag set as there is no underlying
* resync which can be performed on a contained metadevice for these
* resync types (optimized or component).
*/
md_biodone(pb);
return;
}
/*
* Set the MD_IO_COUNTED flag as we are retrying the same I/O
* operation therefore this I/O request has already been counted,
* the I/O count variable will be decremented by mirror_done()'s
* call to md_biodone().
*/
/*
* If this I/O request was a read that was part of a resync,
* set MD_STR_WAR for the retried read to ensure that the
* resync write (i.e. write-after-read) will be performed
*/
return;
}
md_biodone(pb);
}
static void
{
/* All of these updates have to propagated in case of MN set */
/* special treatment if we are called during updating watermarks */
}
smi = 0;
ci = 0;
/* Never called from ioctl context, so (IOLOCK *)NULL */
/*
* For a MN set, the NOTIFY is done when the state
* change is processed on each node
*/
}
continue;
}
/* Never called from ioctl context, so (IOLOCK *)NULL */
/*
* For a MN set, the NOTIFY is done when the state
* change is processed on each node
*/
}
smi = 0;
ci = 0;
}
if (MD_MNSET_SETNO(setno)) {
} else {
(void) poke_hotspares();
}
(void) md_unit_readerlock(ui);
}
/*
* When we have a B_FAILFAST IO error on a Last Erred component we need to
* retry the IO without B_FAILFAST set so that we try to ensure that the
* component "sees" each IO.
*/
static void
{
/* if we're panicing just let this I/O error out */
if (panicstr) {
(void) mirror_done(cb);
return;
}
/* reissue the I/O */
flags |= MD_STR_MAPPED;
flags |= MD_NOBLOCK;
}
static void
{
if (panicstr) {
return;
}
smi = 0;
ci = 0;
return;
}
}
static int
{
char *wowbuf;
/* get wowbuf ans save structure */
/* Save error information, then free cb */
/* update residual and continue if needed */
if (wow_resid > 0) {
return (1);
}
}
/* Write is complete, release resources. */
md_biodone(pb);
return (0);
}
static void
{
char *wowbuf;
int wow_offset;
/* get data on current location */
/* setup child buffer */
/* move offset to next section */
/* copy and setup write for current section */
/* do it */
/*
* Do not set the MD_IO_COUNTED flag as this is a new I/O request
* that handles the WOW condition. The resultant increment on the
* I/O count variable is cleared by copy_write_done()'s call to
* md_biodone().
*/
| MD_STR_MAPPED, NULL);
}
static void
{
wowhdr->wow_offset = 0;
}
static void
{
"md: %s, blk %lld, cnt %ld: Write on write %d occurred",
}
/*
* Set the MD_IO_COUNTED flag as we are retrying the same I/O
* operation therefore this I/O request has already been counted,
* the I/O count variable will be decremented by mirror_done()'s
* call to md_biodone().
*/
if (md_mirror_wow_flg & WOW_NOCOPY)
else
}
/*
* Return true if the specified submirror is either in the Last Erred
* state or is transitioning into the Last Erred state.
*/
static bool_t
{
int ci;
int compcnt;
return (B_TRUE);
/*
* It is not currently Last Erred, check if entering Last Erred.
*/
return (B_TRUE);
}
}
return (B_FALSE);
}
static int
{
/*LINTED*/
/* check if we need to retry an errored failfast I/O */
int i;
for (i = 0; i < NMIRROR; i++) {
continue;
/*
* This is the submirror that had the
* error. Check if it is Last Erred.
*/
if (submirror_is_lasterred(un, i)) {
REQ_OLD);
return (1);
}
break;
}
}
}
/* continue to process the buf without doing a retry */
}
return (mirror_done_common(cb));
}
/*
* Split from the original mirror_done function so we can handle bufs after a
* retry.
* ps->ps_mx is already held in the caller of this function and the cb error
* has already been checked and handled in the caller.
*/
static int
{
/*LINTED*/
return (1);
}
/*
* Do not update outstanding_writes if we're running with ABR
* set for this mirror or the write() was issued with MD_STR_ABR set.
* Also a resync initiated write() has no outstanding_writes update
* either.
*/
}
return (1);
}
return (1);
}
/*
* Handle Write-on-Write problem.
* Skip In case of Raw and Direct I/O as they are
* handled earlier.
*
*/
if (!(md_mirror_wow_flg & WOW_DISABLE) &&
any_pages_dirty(pb)) {
return (1);
}
md_biodone(pb);
return (0);
}
/*
* Clear error state in submirror component if the retry worked after
* a failfast error.
*/
static void
{
int smi;
/*LINTED*/
continue;
break;
}
return;
(void) md_unit_writerlock(ui_sm);
} else {
/* the buf spans components and the first one is not erred */
int cnt;
int i;
for (i = 0; i < cnt; i++) {
break;
}
}
}
}
static size_t
)
{
return (0);
}
return (cando);
return (0);
}
static void
{
int flags;
return;
}
flags |= MD_STR_MAPPED;
flags |= MD_NOBLOCK;
flags |= MD_STR_DIRTY_RD;
}
static void
{
int flags;
flags |= MD_STR_MAPPED;
}
static int
{
int i;
offset = 0;
/*
* This handles the case where we're requesting
* a write to block 0 on a label partition
* and the request size was smaller than the
* size of the label. If this is the case
* then we'll return -1. Failure to do so will
* either cause the calling thread to hang due to
* an ssd bug, or worse if the bcount were allowed
* to go negative (ie large).
*/
return (-1);
}
cb, KM_NOSLEEP);
if (war)
/*
* If the submirror is in the erred stated, check if any component is
* in the Last Erred state. If so, we don't want to use the B_FAILFAST
* flag on the IO.
*
* Provide a fast path for the non-erred case (which should be the
* normal case).
*/
int ci;
int compcnt;
shared = (md_m_shared_t *)
break;
}
} else {
}
}
ps->ps_current_sm++;
return (0);
}
return (1);
}
return (0);
}
/*
* directed_read_done:
* ------------------
* Completion routine called when a DMR request has been returned from the
* underlying driver. Wake-up the original ioctl() and return the data to
* the user.
*/
static void
{
/* release the parent structure */
}
/*
* daemon_io:
* ------------
* Called to issue a mirror_write_strategy() or mirror_read_strategy
* call from a blockable context. NOTE: no mutex can be held on entry to this
* routine
*/
static void
{
flag |= MD_STR_MAPPED;
flag |= MD_STR_WOW;
flag |= MD_STR_WAR;
flag |= MD_STR_ABR;
flag |= MD_STR_BLOCK_OK;
/*
* If this is a resync read, ie MD_STR_DIRTY_RD not set, set
* MD_STR_WAR before calling mirror_read_strategy
*/
flag |= MD_STR_WAR;
} else
}
/*
* update_resync:
* -------------
* Called to update the in-core version of the resync record with the latest
* version that was committed to disk when the previous mirror owner
* relinquished ownership. This call is likely to block as we must hold-off
* any current resync processing that may be occurring.
* On completion of the resync record update we issue the mirror_write_strategy
* call to complete the i/o that first started this sequence. To remove a race
* condition between a new write() request which is submitted and the resync
* record update we acquire the writerlock. This will hold off all i/o to the
* mirror until the resync update has completed.
* NOTE: no mutex can be held on entry to this routine
*/
static void
{
int restart_resync;
(void) md_unit_writerlock(ui);
/*
* Synchronize our in-core view of what regions need to be
* resync'd with the on-disk version.
*/
un->un_dirty_bm);
/* Region dirty map is now up to date */
}
/* Restart the resync thread if it was previously blocked */
if (restart_resync) {
}
/* Continue with original deferred i/o */
}
/*
* owner_timeout:
* -------------
* Called if the original mdmn_ksend_message() failed and the request is to be
* retried. Reattempt the original ownership change.
*
* NOTE: called at interrupt context (see timeout(9f)).
*/
static void
{
}
/*
* become_owner:
* ------------
* Called to issue RPC request to become the owner of the mirror
* associated with this i/o request. We assume that the ownership request
* is synchronous, so if it succeeds we will issue the request via
* mirror_write_strategy().
* If multiple i/o's are outstanding we will be called from the mirror_daemon
* service thread.
* NOTE: no mutex should be held on entry to this routine.
*/
static void
{
/*
* If we're already the mirror owner we do not need to send a message
* but can simply process the i/o request immediately.
* If we've already sent the request to become owner we requeue the
* request as we're waiting for the synchronous ownership message to
* be processed.
*/
if (MD_MN_MIRROR_OWNER(un)) {
/*
* As the strategy() call will potentially block we need to
* punt this to a separate thread and complete this request
* as quickly as possible. Note: if we're a read request
* this must be a resync, we cannot afford to be queued
* behind any intervening i/o requests. In this case we put the
* request on the md_mirror_rs_daemon queue.
*/
REQ_OLD);
} else {
REQ_OLD);
}
} else {
int rval = 0;
/*
* Check to see that we haven't exceeded the maximum
* retry count. If we have we fail the i/o as the
* comms mechanism has become wedged beyond recovery.
*/
"md_mirror: Request exhausted ownership "
md_biodone(pb);
return;
}
/*
* Issue request to change ownership. The call is
* synchronous so when it returns we can complete the
* i/o (if successful), or enqueue it again so that
* the operation will be retried.
*/
/*
* If this IO is triggered by updating a watermark,
* it might be issued by the creation of a softpartition
* while the commd subsystem is suspended.
* We don't want this message to block.
*/
}
/*
* Successfully changed owner, reread the
* resync record so that we have a valid idea of
* any previously committed incomplete write()s.
* NOTE: As we need to acquire the resync mutex
* this may block, so we defer it to a separate
* thread handler. This makes us (effectively)
* non-blocking once the ownership message
* handling has completed.
*/
/* Sets owner of un_rr_dirty record */
if (un->un_rr_dirty_recid)
(void) mddb_setowner(
un->un_owner_state &=
/*
* Release the block on the current
* resync region if it is blocked
*/
/*
* If we're a read, this must be a
* resync request, issue
* the i/o request on the
* md_mirror_rs_daemon queue. This is
* to avoid a deadlock between the
* resync_unit thread and
* subsequent i/o requests that may
* block on the resync region.
*/
} else {
}
sizeof (md_mn_kresult_t));
return;
} else {
/*
* Some other node has beaten us to
* obtain ownership. We need to
* reschedule our ownership request
*/
}
} else {
"MD_MN_MSG_REQUIRE_OWNER");
/*
* Message transport failure is handled by the
* comms layer. If the ownership change request
* does not succeed we need to flag the error to
* the initiator of the i/o. This is handled by
* the retry logic above. As the request failed
* we do not know _who_ the owner of the mirror
* currently is. We reset our idea of the owner
* to None so that any further write()s will
* attempt to become the owner again. This stops
* multiple nodes writing to the same mirror
* simultaneously.
*/
un->un_owner_state &=
}
} else
/*
* Re-enqueue this request on the deferred i/o list. Delay the
* request for md_mirror_owner_to usecs to stop thrashing.
*/
}
}
static void
{
int more;
int rs_on_overlap = 0;
/*
* If a state change is in progress for this mirror in a MN set,
* suspend all non-resync writes until the state change is complete.
* The objective of this suspend is to ensure that it is not
* possible for one node to read data from a submirror that another node
* has not written to because of the state change. Therefore we
* suspend all writes until the state change has been made. As it is
* not possible to read from the target of a resync, there is no need
* to suspend resync writes.
* Note that we only block here if the caller can handle a busy-wait.
* The MD_STR_BLOCK_OK flag is set for daemon_io originated i/o only.
*/
if (!(flag & MD_STR_WAR)) {
if (flag & MD_STR_BLOCK_OK) {
while (un->un_suspend_wr_flag) {
&un->un_suspend_wr_mx);
}
}
(void) md_unit_readerlock(ui);
}
if (!(flag & MD_STR_NOTTOP)) {
return;
}
}
/* If an ABR write has been requested, set MD_STR_ABR flag */
flag |= MD_STR_ABR;
} else {
}
if (flag & MD_STR_MAPPED)
if (flag & MD_STR_WOW)
if (flag & MD_STR_ABR)
if (flag & MD_STR_WMUPDATE)
/*
* Save essential information from the original buffhdr
* in the md_save structure.
*/
/*
* Check for suspended writes here. This is where we can defer the
* write request to the daemon_io queue which will then call us with
* the MD_STR_BLOCK_OK flag set and we'll busy-wait (if necessary) at
* the top of this routine.
*/
if (un->un_suspend_wr_flag) {
return;
}
}
/*
* If not MN owner and this is an ABR write, make sure the current
* resync region is in the overlaps tree
*/
/* Block the current resync region, if not already blocked */
(ps1->ps_lastblk != 0))) {
/* Drop locks to avoid deadlock */
rs_on_overlap = 1;
(void) md_unit_readerlock(ui);
/*
* Check to see if we have obtained ownership
* while waiting for overlaps. If we have, remove
* the resync_region entry from the overlap tree
*/
if (MD_MN_MIRROR_OWNER(un) &&
rs_on_overlap = 0;
}
}
}
/*
* following keep write after read from writing to the
* source in the case where it all came from one place
*/
if (flag & MD_STR_WAR) {
int abort_write = 0;
/*
* We are perfoming a write-after-read. This is either as a
* result of a resync read or as a result of a read in a
* dirty resync region when the optimized resync is not
* complete. If in a MN set and a resync generated i/o,
* if the current block is not in the current
* resync region terminate the write as another node must have
* completed this resync region
*/
(!(flag & MD_STR_DIRTY_RD))) {
abort_write = 1;
}
(abort_write)) {
#ifdef DEBUG
if (mirror_debug_flag)
printf("Abort resync write on %x, block %lld\n",
#endif
md_biodone(pb);
return;
}
} else {
/* Drop readerlock to avoid deadlock */
/*
* For a MN set with an ABR write, if we are now the
* owner and we have a resync region in the overlap
* tree, remove the entry from overlaps and retry the write.
*/
if (MD_MNSET_SETNO(setno) &&
return;
}
}
}
/*
* For Multinode mirrors with no owner and a Resync Region (not ABR)
* we need to become the mirror owner before continuing with the
* write(). For ABR mirrors we check that we 'own' the resync if
* we're in write-after-read mode. We do this _after_ ensuring that
* there are no overlaps to ensure that once we know that we are
* the owner, the readerlock will not be released until the write is
* complete. As a change of ownership in a MN set requires the
* writerlock, this ensures that ownership cannot be changed until
* the write is complete.
*/
if (MD_MN_NO_MIRROR_OWNER(un)) {
return;
}
}
/*
* Mark resync region if mirror has a Resync Region _and_ we are not
* a resync initiated write(). Don't mark region if we're flagged as
* an ABR write.
*/
!(flag & MD_STR_WAR)) {
md_biodone(pb);
return;
}
}
if (flag & MD_STR_MAPPED)
/* Disable WOW and don't free ps */
/*
* Treat Raw and Direct I/O as Write-on-Write always
*/
if (!(md_mirror_wow_flg & WOW_DISABLE) &&
(md_mirror_wow_flg & WOW_PHYS_ENABLE) &&
return;
}
do {
/*
* This handles the case where we're requesting
* a write to block 0 on a label partition. (more < 0)
* means that the request size was smaller than the
* size of the label. If so this request is done.
*/
if (more < 0) {
md_biodone(pb);
return;
}
if (more) {
}
} while (more);
drv_usecwait(10);
}
}
}
static void
{
if (!(flag & MD_STR_NOTTOP)) {
return;
}
}
} else {
}
if (flag & MD_STR_MAPPED)
if (flag & MD_NOBLOCK)
if (flag & MD_STR_WMUPDATE)
/*
* Check to see if this is a DMR driven read. If so we need to use the
* specified side (in un->un_dmr_last_read) for the source of the data.
*/
if (flag & MD_STR_DMR)
/*
* Save essential information from the original buffhdr
* in the md_save structure.
*/
current_offset = 0;
/*
* If flag has MD_STR_WAR set this means that the read is issued by a
* resync thread which may or may not be an optimised resync.
*
* If MD_UN_OPT_NOT_DONE is set this means that the optimized resync
* code has not completed; either a resync has not started since snarf,
* or there is an optimized resync in progress.
*
* We need to generate a write after this read in the following two
* cases,
*
* 1. Any Resync-Generated read
*
* 2. Any read to a DIRTY REGION if there is an optimized resync
* pending or in progress.
*
* The write after read is done in these cases to ensure that all sides
* of the mirror are in sync with the read data and that it is not
* possible for an application to read the same block multiple times
* and get different data.
*
* This would be possible if the block was in a dirty region.
*
* If we're performing a directed read we don't write the data out as
* the application is responsible for restoring the mirror to a known
* state.
*/
!(flag & MD_STR_DMR)) {
/*
* We enter here under three circumstances,
*
* MD_UN_OPT_NOT_DONE MD_STR_WAR
* 0 1
* 1 0
* 1 1
*
* To be optimal we only care to explicitly check for dirty
* regions in the second case since if MD_STR_WAR is set we
* always do the write after read.
*/
if (!(flag & MD_STR_WAR)) {
break;
}
if ((region_dirty) &&
/*
* Mark this as a RESYNC_READ in ps_flags.
* This is used if the read fails during a
* resync of a 3-way mirror to ensure that
* the retried read to the remaining
* good submirror has MD_STR_WAR set. This
* is needed to ensure that the resync write
* (write-after-read) takes place.
*/
/*
* If MD_STR_FLAG_ERR is set in the flags we
* set MD_MPS_FLAG_ERROR so that an error on the resync
* write (issued by write_after_read) will be flagged
* to the biowait'ing resync thread. This allows us to
* avoid issuing further resync requests to a device
* that has had a write failure.
*/
if (flag & MD_STR_FLAG_ERR)
/*
* Drop the readerlock to avoid
* deadlock
*/
/*
* Ensure that we are owner
*/
if (MD_MNSET_SETNO(setno)) {
/*
* For a non-resync read that requires a
* write-after-read to be done, set a flag
* in the parent structure, so that the
* write_strategy routine can omit the
* test that the write is still within the
* resync region
*/
if (!(flag & MD_STR_WAR))
/*
* Before reading the buffer, see if
* there is an owner.
*/
if (MD_MN_NO_MIRROR_OWNER(un)) {
(daemon_queue_t *)ps,
REQ_OLD);
return;
}
/*
* For a resync read, check to see if I/O is
* outside of the current resync region, or
* the resync has finished. If so
* just terminate the I/O
*/
if ((flag & MD_STR_WAR) &&
#ifdef DEBUG
if (mirror_debug_flag)
printf("Abort resync read "
"%x: %lld\n",
ps->ps_firstblk);
#endif
ps);
md_biodone(pb);
return;
}
}
}
}
if (flag & MD_STR_DMR) {
}
do {
if (more) {
}
/*
* Do these calculations now,
* so that we pickup a valid b_bcount from the chld_bp.
*/
current_count -= more;
current_blkno += more;
} while (more);
drv_usecwait(10);
}
}
}
void
{
/*
* When doing IO to a multi owner meta device, check if set is halted.
* We do this check without the needed lock held, for performance
* reasons.
* If an IO just slips through while the set is locked via an
* MD_MN_SUSPEND_SET, we don't care about it.
* Only check for suspension if we are a top-level i/o request
* (MD_STR_NOTTOP is cleared in 'flag').
*/
(MD_SET_HALTED | MD_SET_MNSET)) {
if ((flag & MD_STR_NOTTOP) == 0) {
mutex_enter(&md_mx);
/* Here we loop until the set is no longer halted */
}
mutex_exit(&md_mx);
}
}
if ((flag & MD_IO_COUNTED) == 0) {
if ((flag & MD_NOBLOCK) == 0) {
if (md_inc_iocount(setno) != 0) {
return;
}
} else {
}
}
else
}
/*
* mirror_directed_read:
* --------------------
* Entry-point for the DKIOCDMR ioctl. We issue a read to a specified sub-mirror
* so that the application can determine what (if any) resync needs to be
* performed. The data is copied out to the user-supplied buffer.
*
* Parameters:
* mdev - dev_t for the mirror device
* vdr - directed read parameters specifying location and submirror
* to perform the read from
* mode - used to ddi_copyout() any resulting data from the read
*
* Returns:
* 0 success
* !0 error code
* EINVAL - invalid request format
*/
int
{
char *sm_nm;
void *kbuffer;
return (ENXIO);
return (EINVAL);
}
/* Check for aligned block access. We disallow non-aligned requests. */
return (EINVAL);
}
/*
* Allocate kernel buffer for target of read(). If we had a reliable
* (sorry functional) DDI this wouldn't be needed.
*/
return (ENOMEM);
}
/*
* If DKV_SIDE_INIT is set we need to determine the first available
* side to start reading from. If it isn't set we increment to the
* next readable submirror.
* If there are no readable submirrors we error out with DKV_DMR_ERROR.
* Note: we check for a readable submirror on completion of the i/o so
* we should _always_ have one available. If this becomes unavailable
* we have missed the 'DKV_DMR_DONE' opportunity. This could happen if
* a metadetach is made between the completion of one DKIOCDMR ioctl
* and the start of the next (i.e. a sys-admin 'accident' occurred).
* The chance of this is small, but not non-existent.
*/
next_side = 0;
} else {
}
next_side++;
vdr->vdr_bytesread = 0;
return (0);
}
/* Set the side to read from */
/*
* Save timestamp for verification purposes. Can be read by debugger
* to verify that this ioctl has been executed and to find the number
* of DMR reads and the time of the last DMR read.
*/
/* Issue READ request and wait for completion */
/*
* Check to see if we encountered an error during the read. If so we
* can make no guarantee about any possibly returned data.
*/
} else {
}
/* Copy the data read back out to the user supplied buffer */
mode)) {
return (EFAULT);
}
} else {
/* Error out with DKV_DMR_ERROR */
}
/*
* Update the DMR parameters with the side and name of submirror that
* we have just read from (un->un_dmr_last_read)
*/
/*
* Determine if we've completed the read cycle. This is true iff the
* next computed submirror (side) equals or exceeds NMIRROR. We cannot
* use un_nsm as we need to handle a sparse array of submirrors (which
* can occur if a submirror is metadetached).
*/
next_side++;
/* We've finished */
}
return (0);
}
/*
* mirror_resync_message:
* ---------------------
* Handle the multi-node resync messages that keep all nodes within a given
* disk-set in sync with their view of a mirror's resync status.
*
* The message types dealt with are:
* MD_MN_MSG_RESYNC_STARTING - start a resync thread for a unit
* MD_MN_MSG_RESYNC_NEXT - specified next region to be resynced
* MD_MN_MSG_RESYNC_FINISH - stop the resync thread for a unit
* MD_MN_MSG_RESYNC_PHASE_DONE - end of a resync phase, opt, submirror or comp
*
* Returns:
* 0 Success
* >0 Failure error number
*/
int
{
int is_ABR;
int smi;
int ci;
int broke_out;
int rs_active;
/* Check that the given device is part of a multi-node set */
return (ENXIO);
}
if (!MD_MNSET_SETNO(setno)) {
return (EINVAL);
}
return (EINVAL);
return (EINVAL);
/* Obtain the current resync status */
switch ((md_mn_msgtype_t)p->msg_type) {
/* Start the resync thread for the mirror */
break;
case MD_MN_MSG_RESYNC_NEXT:
/*
* We have to release any previously marked overlap regions
* so that i/o can resume. Then we need to block the region
* from [rs_start..rs_start+rs_size) * so that no i/o is issued.
* Update un_rs_resync_done and un_rs_resync_2_do.
*/
/*
* Ignore the message if there is no active resync thread or
* if it is for a resync type that we have already completed.
* un_resync_completed is set to the last resync completed
* when processing a PHASE_DONE message.
*/
break;
/*
* If this message is for the same resync and is for an earlier
* resync region, just ignore it. This can only occur if this
* node has progressed on to the next resync region before
* we receive this message. This can occur if the class for
* this message is busy and the originator has to retry thus
* allowing this node to move onto the next resync_region.
*/
break;
/* Allocate previous overlap reference if needed */
ps->ps_firstblk = 0;
ps->ps_lastblk = 0;
} else
if (p->rs_originator != md_mn_mynode_id) {
/*
* Clear our un_resync_bm for the regions completed.
* The owner (originator) will take care of itself.
*/
/*
* Update our resync bitmap to reflect that
* another node has synchronized this range.
*/
}
}
/*
* On all but the originating node, first update
* the resync state, then unblock the previous
* region and block the next one. No need
* to do this if the region is already blocked.
* Update the submirror state and flags from the
* originator. This keeps the cluster in sync with
* regards to the resync status.
*/
/*
* Use un_owner_mx to ensure that an ownership change
* cannot happen at the same time as this message
*/
if (MD_MN_MIRROR_OWNER(un)) {
p->rs_size - 1;
} else {
p->rs_size - 1)) {
/* Remove previous overlap range */
p->rs_size - 1;
/* Block this range from all i/o. */
if (ps->ps_firstblk != 0 ||
ps->ps_lastblk != 0)
/*
* Check to see if we have obtained
* ownership while waiting for
* overlaps. If we have, remove
* the resync_region entry from the
* overlap tree
*/
if (MD_MN_MIRROR_OWNER(un) &&
}
}
/*
* If this is the first RESYNC_NEXT message (i.e.
* MD_MN_RS_FIRST_RESYNC_NEXT set in p->rs_flags),
* issue RESYNC_START NOTIFY event
*/
if (p->rs_flags & MD_MN_RS_FIRST_RESYNC_NEXT) {
}
/* Ensure that our local resync thread is running */
}
}
break;
case MD_MN_MSG_RESYNC_FINISH:
/*
* Complete the resync by stopping the resync thread.
* Also release the previous overlap region field.
* Update the resync_progress_thread by cv_signal'ing it so
* that we mark the end of the resync as soon as possible. This
* stops an unnecessary delay should be panic after resync
* completion.
*/
#ifdef DEBUG
if (!rs_active) {
if (mirror_debug_flag)
printf("RESYNC_FINISH (mnum = %x), "
"Resync *NOT* active",
p->mnum);
}
#endif
(p->rs_originator != md_mn_mynode_id)) {
un->un_rs_thread_flags &=
}
if (is_ABR) {
/* Resync finished, if ABR set owner to NULL */
un->un_mirror_owner = 0;
}
/* Remove previous overlap range */
/*
* Release the overlap range reference
*/
ps);
}
/* Mark the resync as complete in the metadb */
/* Deal with any pending grow_unit */
}
}
break;
/*
* A phase of the resync, optimized. component or
* submirror is complete. Update mirror status.
* If the flag CLEAR_OPT_NOT_DONE is set, it means that the
* mirror owner is peforming a resync. If we have just snarfed
* this set, then we must clear any of the flags set at snarf
* time by unit_setup_resync().
* Note that unit_setup_resync() sets up these flags to
* indicate that an optimized resync is required. These flags
* need to be reset because if we get here, the mirror owner
* will have handled the optimized resync.
* The flags that must be cleared are MD_UN_OPT_NOT_DONE and
* MD_UN_WAR. In addition, for each submirror,
* MD_SM_RESYNC_TARGET must be cleared and SMS_OFFLINE_RESYNC
* set to SMS_OFFLINE.
*/
#ifdef DEBUG
if (mirror_debug_flag)
printf("phase done mess received from %d, mnum=%x,"
#endif
/*
* Ignore the message if there is no active resync thread.
*/
if (!rs_active)
break;
case MD_RS_OPTIMIZED:
if (p->rs_flags & MD_MN_RS_CLEAR_OPT_NOT_DONE) {
/* If we are originator, just clear rs_type */
if (p->rs_originator == md_mn_mynode_id) {
break;
}
/*
* If CLEAR_OPT_NOT_DONE is set, only clear the
* flags if OPT_NOT_DONE is set *and* rs_type
* is MD_RS_NONE.
*/
/* No resync in progress */
} else {
/*
* We are in the middle of an
* optimized resync and this message
* should be ignored.
*/
break;
}
} else {
/*
* This is the end of an optimized resync,
* clear the OPT_NOT_DONE and OFFLINE_SM flags
*/
if (!broke_out)
/*
* Clear our un_resync_bm for the regions
* completed. The owner (originator) will
* take care of itself.
*/
if (p->rs_originator != md_mn_mynode_id &&
un);
rr++) {
}
}
}
/*
* Set resync_completed to last resync type and then
* clear resync_type to indicate no resync in progress
*/
/*
* If resync is as a result of a submirror ONLINE,
* reset the submirror state to SMS_RUNNING if the
* resync was ok else set back to SMS_OFFLINE.
*/
if (p->rs_flags &
state = SMS_OFFLINE;
} else {
}
0);
}
/*
* If we still have an offline submirror, reset
* the OFFLINE_SM flag in the mirror status
*/
}
break;
case MD_RS_SUBMIRROR:
/* Clear RESYNC target */
/*
* Set resync_completed to last resync type and then
* clear resync_type to indicate no resync in progress
*/
/*
* If the resync completed ok reset the submirror
* state to SMS_RUNNING else reset it to SMS_ATTACHED
*/
break;
case MD_RS_COMPONENT:
shared = (md_m_shared_t *)
(*(smic->sm_shared_by_indx))
/* Clear RESYNC target */
/*
* Set resync_completed to last resync type and then
* clear resync_type to indicate no resync in progress
*/
/*
* If the resync completed ok, set the component state
* to CS_OKAY.
*/
if (broke_out)
else {
/*
* As we don't transmit the changes,
* no need to drop the lock.
*/
}
default:
break;
}
/*
* If the purpose of this PHASE_DONE message is just to
* indicate to all other nodes that the optimized resync
* required (OPT_NOT_DONE) flag is to be cleared, there is
* no need to generate a notify event as there has not
* actually been a resync.
*/
if (!(p->rs_flags & MD_MN_RS_CLEAR_OPT_NOT_DONE)) {
if (broke_out) {
} else {
}
}
break;
default:
#ifdef DEBUG
" %x\n", p->msg_type);
#endif
return (EINVAL);
}
return (0);
}
/* Return a -1 if snarf of optimized record failed and set should be released */
static int
{
int gotsomething;
int all_mirrors_gotten;
int retval;
if (cmd == MD_SNARF_CLEANUP) {
return (0);
}
}
return (0);
}
all_mirrors_gotten = 1;
gotsomething = 0;
continue;
switch (rbp->rb_revision) {
case MDDB_REV_RB:
case MDDB_REV_RBFN:
/*
* This means, we have an old and small
* record and this record hasn't already
* been converted. Before we create an
* incore metadevice from this we have to
* convert it to a big record.
*/
small_un =
newreqsize = sizeof (mm_unit_t);
KM_SLEEP);
/*
* Update userdata and incore userdata
* incores are at the end of un
*/
} else {
/*
* Unit already converted, just get the
* record address.
*/
sizeof (*un), 0);
}
break;
case MDDB_REV_RB64:
case MDDB_REV_RB64FN:
/* Big device */
sizeof (*un), 0);
break;
}
/*
* Create minor device node for snarfed entry.
*/
continue;
}
all_mirrors_gotten = 0;
if (retval == 0) {
gotsomething = 1;
} else {
return (retval);
}
/*
* Set flag to indicate that the mirror has not yet
* been through a reconfig. This flag is used for MN sets
* when determining whether to update the mirror state from
* the Master node.
*/
if (MD_MNSET_SETNO(setno)) {
}
}
if (!all_mirrors_gotten)
return (gotsomething);
return (0);
}
static int
{
unit_t i;
int reset_mirror_flag = 0;
if (cmd == MD_HALT_CLOSE)
return (0);
if (cmd == MD_HALT_OPEN)
return (0);
if (cmd == MD_HALT_UNLOAD)
return (0);
if (cmd == MD_HALT_CHECK) {
for (i = 0; i < md_nunits; i++) {
continue;
continue;
if (md_unit_isopen(ui))
return (1);
}
return (0);
}
if (cmd != MD_HALT_DOIT)
return (1);
for (i = 0; i < md_nunits; i++) {
continue;
continue;
/* Set a flag if there is at least one mirror metadevice. */
reset_mirror_flag = 1;
}
/*
* Only wait for the global dr_timeout to finish
* - if there are mirror metadevices in this diskset or
* - if this is the local set since an unload of the md_mirror
* driver could follow a successful mirror halt in the local set.
*/
(mirror_timeout.dr_timeout_id != 0))
}
return (0);
}
/*ARGSUSED3*/
static int
{
/*
* When doing an open of a multi owner metadevice, check to see if this
* node is a starting node and if a reconfig cycle is underway.
* If so, the system isn't sufficiently set up enough to handle the
* open (which involves I/O during sp_validate), so fail with ENXIO.
*/
(MD_SET_MNSET | MD_SET_MN_START_RC)) {
return (ENXIO);
}
if (md_oflags & MD_OFLG_FROMIOCTL) {
/*
* This indicates that the caller is an ioctl service routine.
* In this case we initialise our stack-based IOLOCK and pass
* this into the internal open routine. This allows multi-owner
* metadevices to avoid deadlocking if an error is encountered
* during the open() attempt. The failure case is:
* s-p -> mirror -> s-p (with error). Attempting to metaclear
* this configuration would deadlock as the mirror code has to
* send a state-update to the other nodes when it detects the
* failure of the underlying submirror with an errored soft-part
* on it. As there is a class1 message in progress (metaclear)
* set_sm_comp_state() cannot send another class1 message;
* instead we do not send a state_update message as the
* metaclear is distributed and the failed submirror will be
* cleared from the configuration by the metaclear.
*/
IOLOCK_INIT(&lock);
} else {
}
}
/*ARGSUSED1*/
static int
{
}
/*
* This routine dumps memory to the disk. It assumes that the memory has
* already been mapped into mainbus space. It is called at disk interrupt
* priority when the system is in trouble.
*
*/
static int
{
int result;
int smi;
int any_succeed = 0;
int save_result = 0;
/*
* Don't need to grab the unit lock.
* Cause nothing else is suppose to be happenning.
* Also dump is not suppose to sleep.
*/
return (EINVAL);
return (EINVAL);
continue;
if (result)
if (result == 0)
any_succeed++;
}
if (any_succeed)
return (0);
return (save_result);
}
/*
* NAME: mirror_probe_dev
*
* DESCRITPION: force opens every component of a mirror.
*
* On entry the unit writerlock is held
*/
static int
{
int i;
int smi;
int ci;
int md_devopen = 0;
int sm_cnt;
int sm_unavail_cnt;
if (md_unit_isopen(ui))
md_devopen++;
sm_cnt = 0;
sm_unavail_cnt = 0;
for (i = 0; i < NMIRROR; i++) {
continue;
}
sm_cnt++;
/*
* Logic similar to that in mirror_open_all_devs. We set or
* clear the submirror Unavailable bit.
*/
(void) md_unit_writerlock(sm_ui);
} else {
}
}
/*
* If all of the submirrors are unavailable, the mirror is also
* unavailable.
*/
if (sm_cnt == sm_unavail_cnt) {
} else {
}
/*
* Start checking from probe failures. If failures occur we
* set the appropriate erred state only if the metadevice is in
* use. This is specifically to prevent unnecessary resyncs.
* For instance if the disks were accidentally disconnected when
* the system booted up then until the metadevice is accessed
* (like file system mount) the user can shutdown, recable and
* reboot w/o incurring a potentially huge resync.
*/
smi = 0;
ci = 0;
/*
* Note that for a MN set, there is no need to call
* SE_NOTIFY as that is done when processing the
* state change
*/
if (md_devopen) {
/*
* Never called from ioctl context,
* so (IOLOCK *)NULL
*/
if (!MD_MNSET_SETNO(setno)) {
}
continue;
} else {
(void) mirror_close_all_devs(un,
if (!MD_MNSET_SETNO(setno)) {
}
return (ENXIO);
}
}
/*
* Note that for a MN set, there is no need to call
* SE_NOTIFY as that is done when processing the
* state change
*/
if (md_devopen) {
/* Never called from ioctl context, so (IOLOCK *)NULL */
if (!MD_MNSET_SETNO(setno)) {
}
}
ci++;
}
if (MD_MNSET_SETNO(setno)) {
} else {
(void) poke_hotspares();
}
return (0);
}
static int
)
{
int gotsomething, i;
gotsomething = 0;
continue;
switch (rbp->rb_revision) {
case MDDB_REV_RB:
case MDDB_REV_RBFN:
/*
* Small device
*/
goto out;
}
break;
case MDDB_REV_RB64:
case MDDB_REV_RB64FN:
(md_getminor(tmpdev))));
goto out;
}
break;
}
/*
* If this is a top level and a friendly name metadevice,
* update its minor in the namespace.
*/
if ((*parent_id == MD_NO_PARENT) &&
goto out;
}
/*
* Update unit with the imported setno
*
*/
if (*parent_id != MD_NO_PARENT)
gotsomething = 1;
}
out:
return (gotsomething);
}
/*
* NAME: mirror_check_offline
*
* DESCRIPTION: return offline_status = 1 if any submirrors are offline
*
* Called from ioctl, so access to MD_UN_OFFLINE_SM in un_status is
* protected by the global ioctl lock as it is only set by the MD_IOCOFFLINE
* ioctl.
*/
int
{
return (EINVAL);
*offline_status = 0;
*offline_status = 1;
return (0);
}
/*
* NAME: mirror_inc_abr_count
*
* DESCRIPTION: increment the count of layered soft parts with ABR set
*
* Called from ioctl, so access to un_abr_count is protected by the global
* ioctl lock. It is only referenced in the MD_IOCOFFLINE ioctl.
*/
int
{
return (EINVAL);
un->un_abr_count++;
return (0);
}
/*
* NAME: mirror_dec_abr_count
*
* DESCRIPTION: decrement the count of layered soft parts with ABR set
*
* Called from ioctl, so access to un_abr_count is protected by the global
* ioctl lock. It is only referenced in the MD_IOCOFFLINE ioctl.
*/
int
{
return (EINVAL);
un->un_abr_count--;
return (0);
}
{(intptr_t (*)()) mirror_exchange_parent_update_to,
{ NULL, 0 }
};
mirror_open, /* open */
mirror_close, /* close */
md_mirror_strategy, /* strategy */
NULL, /* print */
mirror_dump, /* dump */
NULL, /* read */
NULL, /* write */
md_mirror_ioctl, /* mirror_ioctl, */
mirror_snarf, /* mirror_snarf */
mirror_halt, /* mirror_halt */
NULL, /* aread */
NULL, /* awrite */
mirror_imp_set, /* import set */
};
/* module specific initilization */
static void
{
/* Initialize the parent and child save memory pools */
sizeof (md_mps_t), 0, mirror_parent_constructor,
0);
/*
* Insure wowbuf_size is a multiple of DEV_BSIZE,
* then initialize wowbuf memory pool.
*/
if (md_wowbuf_size <= 0)
}
/* module specific uninitilization (undo init_init()) */
static void
{
}
/* define the module linkage */