1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
  25  */
  26 
  27 #include <sys/param.h>
  28 #include <sys/systm.h>
  29 #include <sys/conf.h>
  30 #include <sys/file.h>
  31 #include <sys/user.h>
  32 #include <sys/uio.h>
  33 #include <sys/t_lock.h>
  34 #include <sys/buf.h>
  35 #include <sys/dkio.h>
  36 #include <sys/vtoc.h>
  37 #include <sys/kmem.h>
  38 #include <vm/page.h>
  39 #include <sys/cmn_err.h>
  40 #include <sys/sysmacros.h>
  41 #include <sys/types.h>
  42 #include <sys/mkdev.h>
  43 #include <sys/stat.h>
  44 #include <sys/open.h>
  45 #include <sys/modctl.h>
  46 #include <sys/ddi.h>
  47 #include <sys/sunddi.h>
  48 #include <sys/debug.h>
  49 #include <sys/dklabel.h>
  50 #include <vm/hat.h>
  51 #include <sys/lvm/mdvar.h>
  52 #include <sys/lvm/md_mirror.h>
  53 #include <sys/lvm/md_convert.h>
  54 #include <sys/lvm/md_mddb.h>
  55 #include <sys/esunddi.h>
  56 
  57 #include <sys/sysevent/eventdefs.h>
  58 #include <sys/sysevent/svm.h>
  59 #include <sys/lvm/mdmn_commd.h>
  60 #include <sys/avl.h>
  61 
  62 md_ops_t                mirror_md_ops;
  63 #ifndef lint
  64 md_ops_t                *md_interface_ops = &mirror_md_ops;
  65 #endif
  66 
  67 extern mdq_anchor_t     md_done_daemon;
  68 extern mdq_anchor_t     md_mstr_daemon;
  69 extern mdq_anchor_t     md_mirror_daemon;
  70 extern mdq_anchor_t     md_mirror_io_daemon;
  71 extern mdq_anchor_t     md_mirror_rs_daemon;
  72 extern mdq_anchor_t     md_mhs_daemon;
  73 
  74 extern unit_t           md_nunits;
  75 extern set_t            md_nsets;
  76 extern md_set_t         md_set[];
  77 
  78 extern int              md_status;
  79 extern clock_t          md_hz;
  80 
  81 extern md_krwlock_t     md_unit_array_rw;
  82 extern kmutex_t         md_mx;
  83 extern kcondvar_t       md_cv;
  84 extern int              md_mtioctl_cnt;
  85 
  86 daemon_request_t        mirror_timeout;
  87 static daemon_request_t hotspare_request;
  88 static daemon_request_t mn_hs_request[MD_MAXSETS];      /* Multinode hs req */
  89 
  90 int     md_mirror_mcs_buf_off;
  91 
  92 /* Flags for mdmn_ksend_message to allow debugging */
  93 int     md_mirror_msg_flags;
  94 
  95 #ifdef DEBUG
  96 /* Flag to switch on debug messages */
  97 int     mirror_debug_flag = 0;
  98 #endif
  99 
 100 /*
 101  * Struct used to hold count of DMR reads and the timestamp of last DMR read
 102  * It is used to verify, using a debugger, that the DMR read ioctl has been
 103  * executed.
 104  */
 105 dmr_stats_t     mirror_dmr_stats = {0};
 106 
 107 /*
 108  * Mutex protecting list of non-failfast drivers.
 109  */
 110 static kmutex_t non_ff_drv_mutex;
 111 extern char     **non_ff_drivers;
 112 
 113 extern major_t  md_major;
 114 
 115 /*
 116  * Write-On-Write memory pool.
 117  */
 118 static void             copy_write_cont(wowhdr_t *wowhdr);
 119 static kmem_cache_t     *mirror_wowblk_cache = NULL;
 120 static int              md_wowbuf_size = 16384;
 121 static size_t           md_wowblk_size;
 122 
 123 /*
 124  * This is a flag that allows:
 125  *      - disabling the write-on-write mechanism.
 126  *      - logging occurrences of write-on-write
 127  *      - switching wow handling procedure processing
 128  * Counter for occurences of WOW.
 129  */
 130 static uint_t   md_mirror_wow_flg = 0;
 131 static int      md_mirror_wow_cnt = 0;
 132 
 133 /*
 134  * Tunable to enable/disable dirty region
 135  * processing when closing down a mirror.
 136  */
 137 static int      new_resync = 1;
 138 kmem_cache_t    *mirror_parent_cache = NULL;
 139 kmem_cache_t    *mirror_child_cache = NULL;
 140 
 141 extern int      md_ff_disable;          /* disable failfast */
 142 
 143 static int      mirror_map_write(mm_unit_t *, md_mcs_t *, md_mps_t *, int);
 144 static void     mirror_read_strategy(buf_t *, int, void *);
 145 static void     mirror_write_strategy(buf_t *, int, void *);
 146 static void     become_owner(daemon_queue_t *);
 147 static int      mirror_done(struct buf *cb);
 148 static int      mirror_done_common(struct buf *cb);
 149 static void     clear_retry_error(struct buf *cb);
 150 
 151 /*
 152  * patchables
 153  */
 154 int     md_min_rr_size  = 200;  /* 2000 blocks, or 100k */
 155 int     md_def_num_rr   = 1000; /* Default number of dirty regions */
 156 
 157 /*
 158  * patchable to change delay before rescheduling mirror ownership request.
 159  * Value is clock ticks, default 0.5 seconds
 160  */
 161 clock_t md_mirror_owner_to = 500000;
 162 
 163 /*ARGSUSED1*/
 164 static int
 165 mirror_parent_constructor(void *p, void *d1, int d2)
 166 {
 167         mutex_init(&((md_mps_t *)p)->ps_mx, NULL, MUTEX_DEFAULT, NULL);
 168         return (0);
 169 }
 170 
 171 static void
 172 mirror_parent_init(md_mps_t *ps)
 173 {
 174         bzero(ps, offsetof(md_mps_t, ps_mx));
 175         bzero(&ps->ps_overlap_node, sizeof (avl_node_t));
 176 }
 177 
 178 /*ARGSUSED1*/
 179 static void
 180 mirror_parent_destructor(void *p, void *d)
 181 {
 182         mutex_destroy(&((md_mps_t *)p)->ps_mx);
 183 }
 184 
 185 /*ARGSUSED1*/
 186 static int
 187 mirror_child_constructor(void *p, void *d1, int d2)
 188 {
 189         bioinit(&((md_mcs_t *)p)->cs_buf);
 190         return (0);
 191 }
 192 
 193 void
 194 mirror_child_init(md_mcs_t *cs)
 195 {
 196         cs->cs_ps = NULL;
 197         cs->cs_mdunit = 0;
 198         md_bioreset(&cs->cs_buf);
 199 }
 200 
 201 /*ARGSUSED1*/
 202 static void
 203 mirror_child_destructor(void *p, void *d)
 204 {
 205         biofini(&((md_mcs_t *)p)->cs_buf);
 206 }
 207 
 208 static void
 209 mirror_wowblk_init(wowhdr_t *p)
 210 {
 211         bzero(p, md_wowblk_size);
 212 }
 213 
 214 static void
 215 send_poke_hotspares_msg(daemon_request_t *drq)
 216 {
 217         int                     rval;
 218         int                     nretries = 0;
 219         md_mn_msg_pokehsp_t     pokehsp;
 220         md_mn_kresult_t         *kresult;
 221         set_t                   setno = (set_t)drq->dq.qlen;
 222 
 223         pokehsp.pokehsp_setno = setno;
 224 
 225         kresult = kmem_alloc(sizeof (md_mn_kresult_t), KM_SLEEP);
 226 
 227 retry_sphmsg:
 228         rval = mdmn_ksend_message(setno, MD_MN_MSG_POKE_HOTSPARES,
 229             MD_MSGF_NO_LOG | MD_MSGF_NO_BCAST, 0, (char *)&pokehsp,
 230             sizeof (pokehsp), kresult);
 231 
 232         if (!MDMN_KSEND_MSG_OK(rval, kresult)) {
 233                 mdmn_ksend_show_error(rval, kresult, "POKE_HOTSPARES");
 234                 /* If we're shutting down already, pause things here. */
 235                 if (kresult->kmmr_comm_state == MDMNE_RPC_FAIL) {
 236                         while (!md_mn_is_commd_present()) {
 237                                 delay(md_hz);
 238                         }
 239                         /*
 240                          * commd has become reachable again, so retry once.
 241                          * If this fails we'll panic as the system is in an
 242                          * unexpected state.
 243                          */
 244                         if (nretries++ == 0)
 245                                 goto retry_sphmsg;
 246                 }
 247                 cmn_err(CE_PANIC,
 248                     "ksend_message failure: POKE_HOTSPARES");
 249         }
 250         kmem_free(kresult, sizeof (md_mn_kresult_t));
 251 
 252         /* Allow further requests to use this set's queue structure */
 253         mutex_enter(&drq->dr_mx);
 254         drq->dr_pending = 0;
 255         mutex_exit(&drq->dr_mx);
 256 }
 257 
 258 /*
 259  * Send a poke_hotspares message to the master node. To avoid swamping the
 260  * commd handler with requests we only send a message if there is not one
 261  * already outstanding. We punt the request to a separate thread context as
 262  * cannot afford to block waiting on the request to be serviced. This is
 263  * essential when a reconfig cycle is in progress as any open() of a multinode
 264  * metadevice may result in a livelock.
 265  */
 266 static void
 267 send_poke_hotspares(set_t setno)
 268 {
 269         daemon_request_t        *drq = &mn_hs_request[setno];
 270 
 271         mutex_enter(&drq->dr_mx);
 272         if (drq->dr_pending == 0) {
 273                 drq->dr_pending = 1;
 274                 drq->dq.qlen = (int)setno;
 275                 daemon_request(&md_mhs_daemon,
 276                     send_poke_hotspares_msg, (daemon_queue_t *)drq, REQ_OLD);
 277         }
 278         mutex_exit(&drq->dr_mx);
 279 }
 280 
 281 void
 282 mirror_set_sm_state(
 283         mm_submirror_t          *sm,
 284         mm_submirror_ic_t       *smic,
 285         sm_state_t              newstate,
 286         int                     force)
 287 {
 288         int                     compcnt;
 289         int                     i;
 290         int                     errcnt;
 291         sm_state_t              origstate;
 292         md_m_shared_t           *shared;
 293 
 294         if (force) {
 295                 sm->sm_state = newstate;
 296                 uniqtime32(&sm->sm_timestamp);
 297                 return;
 298         }
 299 
 300         origstate = newstate;
 301 
 302         compcnt = (*(smic->sm_get_component_count))(sm->sm_dev, sm);
 303         for (i = 0, errcnt = 0; i < compcnt; i++) {
 304                 shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
 305                     (sm->sm_dev, sm, i);
 306                 if (shared->ms_state & (CS_ERRED | CS_LAST_ERRED))
 307                         newstate |= SMS_COMP_ERRED;
 308                 if (shared->ms_state & (CS_RESYNC))
 309                         newstate |= SMS_COMP_RESYNC;
 310                 if (shared->ms_state & CS_ERRED)
 311                         errcnt++;
 312         }
 313 
 314         if ((newstate & (SMS_COMP_ERRED | SMS_COMP_RESYNC)) != 0)
 315                 newstate &= ~origstate;
 316 
 317         if (errcnt == compcnt)
 318                 newstate |= SMS_ALL_ERRED;
 319         else
 320                 newstate &= ~SMS_ALL_ERRED;
 321 
 322         sm->sm_state = newstate;
 323         uniqtime32(&sm->sm_timestamp);
 324 }
 325 
 326 static int
 327 mirror_geterror(mm_unit_t *un, int *smi, int *cip, int clr_error,
 328                                                         int frm_probe)
 329 {
 330         mm_submirror_t          *sm;
 331         mm_submirror_ic_t       *smic;
 332         md_m_shared_t           *shared;
 333         int                     ci;
 334         int                     i;
 335         int                     compcnt;
 336         int                     open_comp; /* flag for open component */
 337 
 338         for (i = *smi; i < NMIRROR; i++) {
 339                 sm = &un->un_sm[i];
 340                 smic = &un->un_smic[i];
 341 
 342                 if (!SMS_IS(sm, SMS_INUSE))
 343                         continue;
 344 
 345                 compcnt = (*(smic->sm_get_component_count)) (sm->sm_dev, un);
 346                 for (ci = *cip; ci < compcnt; ci++) {
 347                         shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
 348                             (sm->sm_dev, sm, ci);
 349                         /*
 350                          * if called from any routine but probe, we check for
 351                          * MDM_S_ISOPEN flag. Since probe does a pseduo open,
 352                          * it sets MDM_S_PROBEOPEN flag and we test for this
 353                          * flag. They are both exclusive tests.
 354                          */
 355                         open_comp = (frm_probe) ?
 356                             (shared->ms_flags & MDM_S_PROBEOPEN):
 357                             (shared->ms_flags & MDM_S_ISOPEN);
 358                         if (((shared->ms_flags & MDM_S_IOERR || !open_comp) &&
 359                             ((shared->ms_state == CS_OKAY) ||
 360                             (shared->ms_state == CS_RESYNC))) ||
 361                             (!open_comp &&
 362                             (shared->ms_state == CS_LAST_ERRED))) {
 363                                 if (clr_error) {
 364                                         shared->ms_flags &= ~MDM_S_IOERR;
 365                                 }
 366                                 *cip = ci;
 367                                 *smi = i;
 368                                 return (1);
 369                         }
 370 
 371                         if (clr_error && (shared->ms_flags & MDM_S_IOERR)) {
 372                                 shared->ms_flags &= ~MDM_S_IOERR;
 373                         }
 374                 }
 375 
 376                 *cip = 0;
 377         }
 378         return (0);
 379 }
 380 
 381 /*ARGSUSED*/
 382 static void
 383 mirror_run_queue(void *d)
 384 {
 385         if (!(md_status & MD_GBL_DAEMONS_LIVE))
 386                 md_daemon(1, &md_done_daemon);
 387 }
 388 /*
 389  * check_comp_4_hotspares
 390  *
 391  * This function attempts to allocate a hotspare for this component if the
 392  * component is in error. In a MN set, the function can be called in 2 modes.
 393  * It can be called either when a component error has been detected or when a
 394  * new hotspare has been allocated. In this case, MD_HOTSPARE_XMIT is set
 395  * in flags and the request is sent to all nodes.
 396  * The handler on each of the nodes then calls this function with
 397  * MD_HOTSPARE_XMIT unset and the hotspare allocation is then performed.
 398  *
 399  * For non-MN sets the function simply attempts to allocate a hotspare.
 400  *
 401  * On entry, the following locks are held
 402  *      mirror_md_ops.md_link_rw (if flags has MD_HOTSPARE_LINKHELD set)
 403  *      md_unit_writerlock
 404  *
 405  * Returns      0 if ok
 406  *              1 if the unit containing the component has been cleared while
 407  *                the mdmn_ksend_message() was being executed
 408  */
 409 extern int
 410 check_comp_4_hotspares(
 411         mm_unit_t       *un,
 412         int             smi,
 413         int             ci,
 414         uint_t          flags,
 415         mddb_recid_t    hs_id,  /* Only used by MN disksets */
 416         IOLOCK          *lockp  /* can be NULL */
 417 )
 418 {
 419         mm_submirror_t          *sm;
 420         mm_submirror_ic_t       *smic;
 421         md_m_shared_t           *shared;
 422         mddb_recid_t            recids[6];
 423         minor_t                 mnum;
 424         intptr_t                (*hs_dev)();
 425         void                    (*hs_done)();
 426         void                    *hs_data;
 427         md_error_t              mde = mdnullerror;
 428         set_t                   setno;
 429         md_mn_msg_allochsp_t    allochspmsg;
 430         md_mn_kresult_t         *kresult;
 431         mm_unit_t               *new_un;
 432         int                     rval;
 433         int                     nretries = 0;
 434 
 435         mnum = MD_SID(un);
 436         setno = MD_UN2SET(un);
 437         sm = &un->un_sm[smi];
 438         smic = &un->un_smic[smi];
 439         shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
 440             (sm->sm_dev, sm, ci);
 441 
 442         if (shared->ms_state != CS_ERRED)
 443                 return (0);
 444 
 445         /* Don't start a new component resync if a resync is already running. */
 446         if (MD_STATUS(un) & MD_UN_RESYNC_ACTIVE)
 447                 return (0);
 448 
 449         if (MD_MNSET_SETNO(setno) && (flags & MD_HOTSPARE_XMIT)) {
 450                 uint_t          msgflags;
 451                 md_mn_msgtype_t msgtype;
 452 
 453                 /* Send allocate hotspare message to all nodes */
 454 
 455                 allochspmsg.msg_allochsp_mnum = un->c.un_self_id;
 456                 allochspmsg.msg_allochsp_sm = smi;
 457                 allochspmsg.msg_allochsp_comp = ci;
 458                 allochspmsg.msg_allochsp_hs_id = shared->ms_hs_id;
 459 
 460                 /*
 461                  * Before calling mdmn_ksend_message(), release locks
 462                  * Can never be in the context of an ioctl.
 463                  */
 464                 md_unit_writerexit(MDI_UNIT(mnum));
 465                 if (flags & MD_HOTSPARE_LINKHELD)
 466                         rw_exit(&mirror_md_ops.md_link_rw.lock);
 467 #ifdef DEBUG
 468                 if (mirror_debug_flag)
 469                         printf("send alloc hotspare, flags="
 470                             "0x%x %x, %x, %x, %x\n", flags,
 471                             allochspmsg.msg_allochsp_mnum,
 472                             allochspmsg.msg_allochsp_sm,
 473                             allochspmsg.msg_allochsp_comp,
 474                             allochspmsg.msg_allochsp_hs_id);
 475 #endif
 476                 if (flags & MD_HOTSPARE_WMUPDATE) {
 477                         msgtype  = MD_MN_MSG_ALLOCATE_HOTSPARE2;
 478                         /*
 479                          * When coming from an update of watermarks, there
 480                          * must already be a message logged that triggered
 481                          * this action. So, no need to log this message, too.
 482                          */
 483                         msgflags = MD_MSGF_NO_LOG;
 484                 } else {
 485                         msgtype  = MD_MN_MSG_ALLOCATE_HOTSPARE;
 486                         msgflags = MD_MSGF_DEFAULT_FLAGS;
 487                 }
 488 
 489                 kresult = kmem_alloc(sizeof (md_mn_kresult_t), KM_SLEEP);
 490 
 491 cc4hs_msg:
 492                 rval = mdmn_ksend_message(setno, msgtype, msgflags, 0,
 493                     (char *)&allochspmsg, sizeof (allochspmsg),
 494                     kresult);
 495 
 496                 if (!MDMN_KSEND_MSG_OK(rval, kresult)) {
 497 #ifdef DEBUG
 498                         if (mirror_debug_flag)
 499                                 mdmn_ksend_show_error(rval, kresult,
 500                                     "ALLOCATE HOTSPARE");
 501 #endif
 502                         /*
 503                          * If message is sent ok but exitval indicates an error
 504                          * it must be because the mirror has been cleared. In
 505                          * this case re-obtain lock and return an error
 506                          */
 507                         if ((rval == 0) && (kresult->kmmr_exitval != 0)) {
 508                                 if (flags & MD_HOTSPARE_LINKHELD) {
 509                                         rw_enter(&mirror_md_ops.md_link_rw.lock,
 510                                             RW_READER);
 511                                 }
 512                                 kmem_free(kresult, sizeof (md_mn_kresult_t));
 513                                 return (1);
 514                         }
 515                         /* If we're shutting down already, pause things here. */
 516                         if (kresult->kmmr_comm_state == MDMNE_RPC_FAIL) {
 517                                 while (!md_mn_is_commd_present()) {
 518                                         delay(md_hz);
 519                                 }
 520                                 /*
 521                                  * commd has become reachable again, so retry
 522                                  * once. If this fails we'll panic as the
 523                                  * system is in an unexpected state.
 524                                  */
 525                                 if (nretries++ == 0)
 526                                         goto cc4hs_msg;
 527                         }
 528                         cmn_err(CE_PANIC,
 529                             "ksend_message failure: ALLOCATE_HOTSPARE");
 530                 }
 531                 kmem_free(kresult, sizeof (md_mn_kresult_t));
 532 
 533                 /*
 534                  * re-obtain the locks
 535                  */
 536                 if (flags & MD_HOTSPARE_LINKHELD)
 537                         rw_enter(&mirror_md_ops.md_link_rw.lock, RW_READER);
 538                 new_un = md_unit_writerlock(MDI_UNIT(mnum));
 539 
 540                 /*
 541                  * As we had to release the locks in order to send the
 542                  * message to all nodes, we need to check to see if the
 543                  * unit has changed. If it has we release the writerlock
 544                  * and return fail.
 545                  */
 546                 if ((new_un != un) || (un->c.un_type != MD_METAMIRROR)) {
 547                         md_unit_writerexit(MDI_UNIT(mnum));
 548                         return (1);
 549                 }
 550         } else {
 551                 if (MD_MNSET_SETNO(setno)) {
 552                         /*
 553                          * If 2 or more nodes simultaneously see a
 554                          * component failure, these nodes will each
 555                          * send an ALLOCATE_HOTSPARE[2] message.
 556                          * The first message will allocate the hotspare
 557                          * and the subsequent messages should do nothing.
 558                          *
 559                          * If a slave node doesn't have a hotspare allocated
 560                          * at the time the message is initiated, then the
 561                          * passed in hs_id will be 0.  If the node
 562                          * executing this routine has a component shared
 563                          * ms_hs_id of non-zero, but the message shows a
 564                          * hs_id of 0, then just return since a hotspare
 565                          * has already been allocated for this failing
 566                          * component.  When the slave node returns from
 567                          * the ksend_message the hotspare will have
 568                          * already been allocated.
 569                          *
 570                          * If the slave node does send an hs_id of non-zero,
 571                          * and the slave node's hs_id matches this node's
 572                          * ms_hs_id, then the hotspare has error'd and
 573                          * should be replaced.
 574                          *
 575                          * If the slave node sends an hs_id of non-zero and
 576                          * this node has a different shared ms_hs_id, then
 577                          * just return since this hotspare has already
 578                          * been hotspared.
 579                          */
 580                         if (shared->ms_hs_id != 0) {
 581                                 if (hs_id == 0) {
 582 #ifdef DEBUG
 583                                         if (mirror_debug_flag) {
 584                                                 printf("check_comp_4_hotspares"
 585                                                     "(NOXMIT), short circuit "
 586                                                     "hs_id=0x%x, "
 587                                                     "ms_hs_id=0x%x\n",
 588                                                     hs_id, shared->ms_hs_id);
 589                                         }
 590 #endif
 591                                         return (0);
 592                                 }
 593                                 if (hs_id != shared->ms_hs_id) {
 594 #ifdef DEBUG
 595                                         if (mirror_debug_flag) {
 596                                                 printf("check_comp_4_hotspares"
 597                                                     "(NOXMIT), short circuit2 "
 598                                                     "hs_id=0x%x, "
 599                                                     "ms_hs_id=0x%x\n",
 600                                                     hs_id, shared->ms_hs_id);
 601                                         }
 602 #endif
 603                                         return (0);
 604                                 }
 605                         }
 606                 }
 607 
 608                 sm = &un->un_sm[smi];
 609                 hs_dev = md_get_named_service(sm->sm_dev, 0,
 610                     "hotspare device", 0);
 611                 if ((*hs_dev)(sm->sm_dev, 0, ci, recids, 6, &hs_done,
 612                     &hs_data) != 0)
 613                         return (0);
 614 
 615                 /*
 616                  * set_sm_comp_state() commits the modified records.
 617                  * As we don't transmit the changes, no need to drop the lock.
 618                  */
 619                 set_sm_comp_state(un, smi, ci, CS_RESYNC, recids,
 620                     MD_STATE_NO_XMIT, (IOLOCK *)NULL);
 621 
 622                 (*hs_done)(sm->sm_dev, hs_data);
 623 
 624                 mirror_check_failfast(mnum);
 625 
 626                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HOTSPARED, SVM_TAG_METADEVICE,
 627                     setno, MD_SID(un));
 628 
 629                 /*
 630                  * For a multi-node set we need to reset the un_rs_type,
 631                  * un_rs_resync_done and un_rs_resync_2_do fields as the
 632                  * hot-spare resync must copy all applicable data.
 633                  */
 634                 if (MD_MNSET_SETNO(setno)) {
 635                         un->un_rs_type = MD_RS_NONE;
 636                         un->un_rs_resync_done = 0;
 637                         un->un_rs_resync_2_do = 0;
 638                 }
 639 
 640                 /*
 641                  * Must drop writer lock since mirror_resync_unit will
 642                  * open devices and must be able to grab readerlock.
 643                  * Don't need to drop IOLOCK since any descendent routines
 644                  * calling ksend_messages will drop the IOLOCK as needed.
 645                  *
 646                  */
 647                 if (lockp) {
 648                         md_ioctl_writerexit(lockp);
 649                 } else {
 650                         md_unit_writerexit(MDI_UNIT(mnum));
 651                 }
 652 
 653                 /* start resync */
 654                 (void) mirror_resync_unit(mnum, NULL, &mde, lockp);
 655 
 656                 if (lockp) {
 657                         new_un = md_ioctl_writerlock(lockp, MDI_UNIT(mnum));
 658                 } else {
 659                         new_un = md_unit_writerlock(MDI_UNIT(mnum));
 660                 }
 661         }
 662         return (0);
 663 }
 664 
 665 /*
 666  * check_unit_4_hotspares
 667  *
 668  * For a given mirror, allocate hotspares, if available for any components
 669  * that are in error
 670  *
 671  * Returns      0 if ok
 672  *              1 if check_comp_4_hotspares returns non-zero. This will only
 673  *                happen for a MN unit where the unit has been cleared while
 674  *                the allocate hotspare message is sent to all nodes.
 675  */
 676 static int
 677 check_unit_4_hotspares(mm_unit_t *un, int flags)
 678 {
 679         mm_submirror_t          *sm;
 680         mm_submirror_ic_t       *smic;
 681         int                     ci;
 682         int                     i;
 683         int                     compcnt;
 684 
 685         if (MD_STATUS(un) & MD_UN_RESYNC_ACTIVE)
 686                 return (0);
 687 
 688         for (i = 0; i < NMIRROR; i++) {
 689                 sm = &un->un_sm[i];
 690                 smic = &un->un_smic[i];
 691                 if (!SMS_IS(sm, SMS_INUSE))
 692                         continue;
 693                 compcnt = (*(smic->sm_get_component_count)) (sm->sm_dev, sm);
 694                 for (ci = 0; ci < compcnt; ci++) {
 695                         md_m_shared_t           *shared;
 696 
 697                         shared = (md_m_shared_t *)
 698                             (*(smic->sm_shared_by_indx))(sm->sm_dev, sm, ci);
 699                         /*
 700                          * Never called from ioctl context, so pass in
 701                          * (IOLOCK *)NULL.  Pass through flags from calling
 702                          * routine, also setting XMIT flag.
 703                          */
 704                         if (check_comp_4_hotspares(un, i, ci,
 705                             (MD_HOTSPARE_XMIT | flags),
 706                             shared->ms_hs_id, (IOLOCK *)NULL) != 0)
 707                                 return (1);
 708                 }
 709         }
 710         return (0);
 711 }
 712 
 713 static void
 714 check_4_hotspares(daemon_request_t *drq)
 715 {
 716         mdi_unit_t      *ui;
 717         mm_unit_t       *un;
 718         md_link_t       *next;
 719         int             x;
 720 
 721         mutex_enter(&drq->dr_mx);        /* clear up front so can poke */
 722         drq->dr_pending = 0;         /* again in low level routine if */
 723         mutex_exit(&drq->dr_mx); /* something found to do        */
 724 
 725         /*
 726          * Used to have a problem here. The disksets weren't marked as being
 727          * MNHOLD. This opened a window where we could be searching for
 728          * hotspares and have the disk set unloaded (released) from under
 729          * us causing a panic in stripe_component_count().
 730          * The way to prevent that is to mark the set MNHOLD which prevents
 731          * any diskset from being released while we are scanning the mirrors,
 732          * submirrors and components.
 733          */
 734 
 735         for (x = 0; x < md_nsets; x++)
 736                 md_holdset_enter(x);
 737 
 738         rw_enter(&mirror_md_ops.md_link_rw.lock, RW_READER);
 739         for (next = mirror_md_ops.md_head; next != NULL; next = next->ln_next) {
 740                 ui = MDI_UNIT(next->ln_id);
 741 
 742                 un = (mm_unit_t *)md_unit_readerlock(ui);
 743 
 744                 /*
 745                  * Only check the unit if we are the master for this set
 746                  * For an MN set, poke_hotspares() is only effective on the
 747                  * master
 748                  */
 749                 if (MD_MNSET_SETNO(MD_UN2SET(un)) &&
 750                     md_set[MD_UN2SET(un)].s_am_i_master == 0) {
 751                         md_unit_readerexit(ui);
 752                         continue;
 753                 }
 754                 if (MD_STATUS(un) & MD_UN_RESYNC_ACTIVE) {
 755                         md_unit_readerexit(ui);
 756                         continue;
 757                 }
 758                 md_unit_readerexit(ui);
 759 
 760                 un = (mm_unit_t *)md_unit_writerlock(ui);
 761                 /*
 762                  * check_unit_4_hotspares will exit 1 if the unit has been
 763                  * removed during the process of allocating the hotspare.
 764                  * This can only happen for a MN metadevice. If unit no longer
 765                  * exists, no need to release writerlock
 766                  */
 767                 if (check_unit_4_hotspares(un, MD_HOTSPARE_LINKHELD) == 0)
 768                         md_unit_writerexit(ui);
 769                 else {
 770                         /*
 771                          * If check_unit_4_hotspares failed, queue another
 772                          * request and break out of this one
 773                          */
 774                         (void) poke_hotspares();
 775                         break;
 776                 }
 777         }
 778         rw_exit(&mirror_md_ops.md_link_rw.lock);
 779 
 780         for (x = 0; x < md_nsets; x++)
 781                 md_holdset_exit(x);
 782 }
 783 
 784 /*
 785  * poke_hotspares
 786  *
 787  * If there is not a pending poke_hotspares request pending, queue a requent
 788  * to call check_4_hotspares(). This will scan all mirrors and attempt to
 789  * allocate hotspares for all components in error.
 790  */
 791 int
 792 poke_hotspares()
 793 {
 794         mutex_enter(&hotspare_request.dr_mx);
 795         if (hotspare_request.dr_pending == 0) {
 796                 hotspare_request.dr_pending = 1;
 797                 daemon_request(&md_mhs_daemon,
 798                     check_4_hotspares, (daemon_queue_t *)&hotspare_request,
 799                     REQ_OLD);
 800         }
 801         mutex_exit(&hotspare_request.dr_mx);
 802         return (0);
 803 }
 804 
 805 static void
 806 free_all_ecomps(err_comp_t *ecomp)
 807 {
 808         err_comp_t      *d;
 809 
 810         while (ecomp != NULL) {
 811                 d = ecomp;
 812                 ecomp = ecomp->ec_next;
 813                 kmem_free(d, sizeof (err_comp_t));
 814         }
 815 }
 816 
 817 /*
 818  * NAME: mirror_openfail_console_info
 819  *
 820  * DESCRIPTION: Prints a informative message to the console when mirror
 821  *              cannot be opened.
 822  *
 823  * PARAMETERS: mm_unit_t        un - pointer to mirror unit structure
 824  *             int              smi - submirror index
 825  *             int              ci - component index
 826  */
 827 
 828 void
 829 mirror_openfail_console_info(mm_unit_t *un, int smi, int ci)
 830 {
 831         void (*get_dev)();
 832         ms_cd_info_t cd;
 833         md_dev64_t tmpdev;
 834 
 835         tmpdev = un->un_sm[smi].sm_dev;
 836         get_dev = (void (*)())md_get_named_service(tmpdev, 0, "get device", 0);
 837         if (get_dev != NULL) {
 838                 (void) (*get_dev)(tmpdev, smi, ci, &cd);
 839                 cmn_err(CE_WARN, "md %s: open error on %s",
 840                     md_shortname(MD_SID(un)), md_devname(MD_UN2SET(un),
 841                     cd.cd_dev, NULL, 0));
 842         } else {
 843                 cmn_err(CE_WARN, "md %s: open error",
 844                     md_shortname(MD_SID(un)));
 845         }
 846 }
 847 
 848 static int
 849 mirror_close_all_devs(mm_unit_t *un, int md_cflags)
 850 {
 851         int i;
 852         md_dev64_t dev;
 853 
 854         for (i = 0; i < NMIRROR; i++) {
 855                 if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE))
 856                         continue;
 857                 dev = un->un_sm[i].sm_dev;
 858                 md_layered_close(dev, md_cflags);
 859         }
 860         return (0);
 861 }
 862 
 863 /*
 864  * Keep track of drivers that don't support failfast.  We use this so that
 865  * we only log one diagnostic message for each of these drivers, no matter
 866  * how many times we run the mirror_check_failfast function.
 867  * Return 1 if this is a new driver that does not support failfast,
 868  * return 0 if we have already seen this non-failfast driver.
 869  */
 870 static int
 871 new_non_ff_driver(const char *s)
 872 {
 873         mutex_enter(&non_ff_drv_mutex);
 874         if (non_ff_drivers == NULL) {
 875                 non_ff_drivers = (char **)kmem_alloc(2 * sizeof (char *),
 876                     KM_NOSLEEP);
 877                 if (non_ff_drivers == NULL) {
 878                         mutex_exit(&non_ff_drv_mutex);
 879                         return (1);
 880                 }
 881 
 882                 non_ff_drivers[0] = (char *)kmem_alloc(strlen(s) + 1,
 883                     KM_NOSLEEP);
 884                 if (non_ff_drivers[0] == NULL) {
 885                         kmem_free(non_ff_drivers, 2 * sizeof (char *));
 886                         non_ff_drivers = NULL;
 887                         mutex_exit(&non_ff_drv_mutex);
 888                         return (1);
 889                 }
 890 
 891                 (void) strcpy(non_ff_drivers[0], s);
 892                 non_ff_drivers[1] = NULL;
 893 
 894         } else {
 895                 int i;
 896                 char **tnames;
 897                 char **tmp;
 898 
 899                 for (i = 0; non_ff_drivers[i] != NULL; i++) {
 900                         if (strcmp(s, non_ff_drivers[i]) == 0) {
 901                                 mutex_exit(&non_ff_drv_mutex);
 902                                 return (0);
 903                         }
 904                 }
 905 
 906                 /* allow for new element and null */
 907                 i += 2;
 908                 tnames = (char **)kmem_alloc(i * sizeof (char *), KM_NOSLEEP);
 909                 if (tnames == NULL) {
 910                         mutex_exit(&non_ff_drv_mutex);
 911                         return (1);
 912                 }
 913 
 914                 for (i = 0; non_ff_drivers[i] != NULL; i++)
 915                         tnames[i] = non_ff_drivers[i];
 916 
 917                 tnames[i] = (char *)kmem_alloc(strlen(s) + 1, KM_NOSLEEP);
 918                 if (tnames[i] == NULL) {
 919                         /* adjust i so that it is the right count to free */
 920                         kmem_free(tnames, (i + 2) * sizeof (char *));
 921                         mutex_exit(&non_ff_drv_mutex);
 922                         return (1);
 923                 }
 924 
 925                 (void) strcpy(tnames[i++], s);
 926                 tnames[i] = NULL;
 927 
 928                 tmp = non_ff_drivers;
 929                 non_ff_drivers = tnames;
 930                 /* i now represents the count we previously alloced */
 931                 kmem_free(tmp, i * sizeof (char *));
 932         }
 933         mutex_exit(&non_ff_drv_mutex);
 934 
 935         return (1);
 936 }
 937 
 938 /*
 939  * Check for the "ddi-failfast-supported" devtree property on each submirror
 940  * component to indicate if we should do I/O to that submirror with the
 941  * B_FAILFAST flag set or not.  This check is made at various state transitions
 942  * in the mirror code (e.g. open, enable, hotspare, etc.).  Sometimes we
 943  * only need to check one drive (e.g. hotspare) but since the check is
 944  * fast and infrequent and sometimes needs to be done on all components we
 945  * just check all components on each call.
 946  */
 947 void
 948 mirror_check_failfast(minor_t mnum)
 949 {
 950         int             i;
 951         mm_unit_t       *un;
 952 
 953         if (md_ff_disable)
 954                 return;
 955 
 956         un = MD_UNIT(mnum);
 957 
 958         for (i = 0; i < NMIRROR; i++) {
 959                 int                     ci;
 960                 int                     cnt;
 961                 int                     ff = 1;
 962                 mm_submirror_t          *sm;
 963                 mm_submirror_ic_t       *smic;
 964                 void                    (*get_dev)();
 965 
 966                 if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE))
 967                         continue;
 968 
 969                 sm = &un->un_sm[i];
 970                 smic = &un->un_smic[i];
 971 
 972                 get_dev = (void (*)())md_get_named_service(sm->sm_dev, 0,
 973                     "get device", 0);
 974 
 975                 cnt = (*(smic->sm_get_component_count))(sm->sm_dev, sm);
 976                 for (ci = 0; ci < cnt; ci++) {
 977                         int             found = 0;
 978                         dev_t           ci_dev;
 979                         major_t         major;
 980                         dev_info_t      *devi;
 981                         ms_cd_info_t    cd;
 982 
 983                         /*
 984                          * this already returns the hs
 985                          * dev if the device is spared
 986                          */
 987                         (void) (*get_dev)(sm->sm_dev, sm, ci, &cd);
 988 
 989                         ci_dev = md_dev64_to_dev(cd.cd_dev);
 990                         major = getmajor(ci_dev);
 991 
 992                         if (major == md_major) {
 993                                 /*
 994                                  * this component must be a soft
 995                                  * partition; get the real dev
 996                                  */
 997                                 minor_t dev_mnum;
 998                                 mdi_unit_t      *ui;
 999                                 mp_unit_t       *un;
1000                                 set_t   setno;
1001                                 side_t  side;
1002                                 md_dev64_t      tmpdev;
1003 
1004                                 ui = MDI_UNIT(getminor(ci_dev));
1005 
1006                                 /* grab necessary lock */
1007                                 un = (mp_unit_t *)md_unit_readerlock(ui);
1008 
1009                                 dev_mnum = MD_SID(un);
1010                                 setno = MD_MIN2SET(dev_mnum);
1011                                 side = mddb_getsidenum(setno);
1012 
1013                                 tmpdev = un->un_dev;
1014 
1015                                 /* Get dev by device id */
1016                                 if (md_devid_found(setno, side,
1017                                     un->un_key) == 1) {
1018                                         tmpdev = md_resolve_bydevid(dev_mnum,
1019                                             tmpdev, un->un_key);
1020                                 }
1021 
1022                                 md_unit_readerexit(ui);
1023 
1024                                 ci_dev = md_dev64_to_dev(tmpdev);
1025                                 major = getmajor(ci_dev);
1026                         }
1027 
1028                         if (ci_dev != NODEV32 &&
1029                             (devi = e_ddi_hold_devi_by_dev(ci_dev, 0))
1030                             != NULL) {
1031                                 ddi_prop_op_t   prop_op = PROP_LEN_AND_VAL_BUF;
1032                                 int             propvalue = 0;
1033                                 int             proplength = sizeof (int);
1034                                 int             error;
1035                                 struct cb_ops   *cb;
1036 
1037                                 if ((cb = devopsp[major]->devo_cb_ops) !=
1038                                     NULL) {
1039                                         error = (*cb->cb_prop_op)
1040                                             (DDI_DEV_T_ANY, devi, prop_op,
1041                                             DDI_PROP_NOTPROM|DDI_PROP_DONTPASS,
1042                                             "ddi-failfast-supported",
1043                                             (caddr_t)&propvalue, &proplength);
1044 
1045                                         if (error == DDI_PROP_SUCCESS)
1046                                                 found = 1;
1047                                 }
1048 
1049                                 if (!found && new_non_ff_driver(
1050                                     ddi_driver_name(devi))) {
1051                                         cmn_err(CE_NOTE, "!md: B_FAILFAST I/O"
1052                                             "disabled on %s",
1053                                             ddi_driver_name(devi));
1054                                 }
1055 
1056                                 ddi_release_devi(devi);
1057                         }
1058 
1059                         /*
1060                          * All components must support
1061                          * failfast in the submirror.
1062                          */
1063                         if (!found) {
1064                                 ff = 0;
1065                                 break;
1066                         }
1067                 }
1068 
1069                 if (ff) {
1070                         sm->sm_flags |= MD_SM_FAILFAST;
1071                 } else {
1072                         sm->sm_flags &= ~MD_SM_FAILFAST;
1073                 }
1074         }
1075 }
1076 
1077 /*
1078  * Return true if the submirror is unavailable.
1079  * If any of the submirror components are opened then the submirror cannot
1080  * be unavailable (MD_INACCESSIBLE).
1081  * If any of the components are already in the errored state, then the submirror
1082  * cannot be unavailable (MD_INACCESSIBLE).
1083  */
1084 static bool_t
1085 submirror_unavailable(mm_unit_t *un, int smi, int from_probe)
1086 {
1087         mm_submirror_t          *sm;
1088         mm_submirror_ic_t       *smic;
1089         md_m_shared_t           *shared;
1090         int                     ci;
1091         int                     compcnt;
1092 
1093         sm = &un->un_sm[smi];
1094         smic = &un->un_smic[smi];
1095 
1096         compcnt = (*(smic->sm_get_component_count)) (sm->sm_dev, un);
1097         for (ci = 0; ci < compcnt; ci++) {
1098                 shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
1099                     (sm->sm_dev, sm, ci);
1100                 if (from_probe) {
1101                         if (shared->ms_flags & MDM_S_PROBEOPEN)
1102                                 return (B_FALSE);
1103                 } else {
1104                         if (shared->ms_flags & MDM_S_ISOPEN)
1105                                 return (B_FALSE);
1106                 }
1107                 if (shared->ms_state == CS_ERRED ||
1108                     shared->ms_state == CS_LAST_ERRED)
1109                         return (B_FALSE);
1110         }
1111 
1112         return (B_TRUE);
1113 }
1114 
1115 static int
1116 mirror_open_all_devs(minor_t mnum, int md_oflags, IOLOCK *lockp)
1117 {
1118         int             i;
1119         mm_unit_t       *un;
1120         mdi_unit_t      *ui;
1121         int             err;
1122         int             smi;
1123         int             ci;
1124         err_comp_t      *c;
1125         err_comp_t      *ecomps = NULL;
1126         int             smmask = 0;
1127         set_t           setno;
1128         int             sm_cnt;
1129         int             sm_unavail_cnt;
1130 
1131         mirror_check_failfast(mnum);
1132 
1133         un = MD_UNIT(mnum);
1134         ui = MDI_UNIT(mnum);
1135         setno = MD_UN2SET(un);
1136 
1137         for (i = 0; i < NMIRROR; i++) {
1138                 md_dev64_t tmpdev = un->un_sm[i].sm_dev;
1139 
1140                 if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE))
1141                         continue;
1142                 if (md_layered_open(mnum, &tmpdev, md_oflags))
1143                         smmask |= SMI2BIT(i);
1144                 un->un_sm[i].sm_dev = tmpdev;
1145         }
1146 
1147         /*
1148          * If smmask is clear, all submirrors are accessible. Clear the
1149          * MD_INACCESSIBLE bit in this case.  This bit is also cleared for the
1150          * mirror device.   If smmask is set, we have to determine which of the
1151          * submirrors are in error. If no submirror is accessible we mark the
1152          * whole mirror as MD_INACCESSIBLE.
1153          */
1154         if (smmask == 0) {
1155                 if (lockp) {
1156                         md_ioctl_readerexit(lockp);
1157                         (void) md_ioctl_writerlock(lockp, ui);
1158                 } else {
1159                         md_unit_readerexit(ui);
1160                         (void) md_unit_writerlock(ui);
1161                 }
1162                 ui->ui_tstate &= ~MD_INACCESSIBLE;
1163                 if (lockp) {
1164                         md_ioctl_writerexit(lockp);
1165                         (void) md_ioctl_readerlock(lockp, ui);
1166                 } else {
1167                         md_unit_writerexit(ui);
1168                         (void) md_unit_readerlock(ui);
1169                 }
1170 
1171                 for (i = 0; i < NMIRROR; i++) {
1172                         md_dev64_t      tmpdev;
1173                         mdi_unit_t      *sm_ui;
1174 
1175                         if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE))
1176                                 continue;
1177 
1178                         tmpdev = un->un_sm[i].sm_dev;
1179                         sm_ui = MDI_UNIT(getminor(md_dev64_to_dev(tmpdev)));
1180                         (void) md_unit_writerlock(sm_ui);
1181                         sm_ui->ui_tstate &= ~MD_INACCESSIBLE;
1182                         md_unit_writerexit(sm_ui);
1183                 }
1184 
1185                 return (0);
1186         }
1187 
1188         for (i = 0; i < NMIRROR; i++) {
1189                 md_dev64_t tmpdev;
1190 
1191                 if (!(smmask & SMI2BIT(i)))
1192                         continue;
1193 
1194                 tmpdev = un->un_sm[i].sm_dev;
1195                 err = md_layered_open(mnum, &tmpdev, MD_OFLG_CONT_ERRS);
1196                 un->un_sm[i].sm_dev = tmpdev;
1197                 ASSERT(err == 0);
1198         }
1199 
1200         if (lockp) {
1201                 md_ioctl_readerexit(lockp);
1202                 un = (mm_unit_t *)md_ioctl_writerlock(lockp, ui);
1203         } else {
1204                 md_unit_readerexit(ui);
1205                 un = (mm_unit_t *)md_unit_writerlock(ui);
1206         }
1207 
1208         /*
1209          * We want to make sure the unavailable flag is not masking a real
1210          * error on the submirror.
1211          * For each submirror,
1212          *    if all of the submirror components couldn't be opened and there
1213          *    are no errors on the submirror, then set the unavailable flag
1214          *    otherwise, clear unavailable.
1215          */
1216         sm_cnt = 0;
1217         sm_unavail_cnt = 0;
1218         for (i = 0; i < NMIRROR; i++) {
1219                 md_dev64_t      tmpdev;
1220                 mdi_unit_t      *sm_ui;
1221 
1222                 if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE))
1223                         continue;
1224 
1225                 sm_cnt++;
1226                 tmpdev = un->un_sm[i].sm_dev;
1227                 sm_ui = MDI_UNIT(getminor(md_dev64_to_dev(tmpdev)));
1228 
1229                 (void) md_unit_writerlock(sm_ui);
1230                 if (submirror_unavailable(un, i, 0)) {
1231                         sm_ui->ui_tstate |= MD_INACCESSIBLE;
1232                         sm_unavail_cnt++;
1233                 } else {
1234                         sm_ui->ui_tstate &= ~MD_INACCESSIBLE;
1235                 }
1236                 md_unit_writerexit(sm_ui);
1237         }
1238 
1239         /*
1240          * If all of the submirrors are unavailable, the mirror is also
1241          * unavailable.
1242          */
1243         if (sm_cnt == sm_unavail_cnt) {
1244                 ui->ui_tstate |= MD_INACCESSIBLE;
1245         } else {
1246                 ui->ui_tstate &= ~MD_INACCESSIBLE;
1247         }
1248 
1249         smi = 0;
1250         ci = 0;
1251         while (mirror_geterror(un, &smi, &ci, 1, 0) != 0) {
1252                 if (mirror_other_sources(un, smi, ci, 1) == 1) {
1253 
1254                         free_all_ecomps(ecomps);
1255                         (void) mirror_close_all_devs(un, md_oflags);
1256                         SE_NOTIFY(EC_SVM_STATE, ESC_SVM_OPEN_FAIL,
1257                             SVM_TAG_METADEVICE, setno, MD_SID(un));
1258                         mirror_openfail_console_info(un, smi, ci);
1259                         if (lockp) {
1260                                 md_ioctl_writerexit(lockp);
1261                                 (void) md_ioctl_readerlock(lockp, ui);
1262                         } else {
1263                                 md_unit_writerexit(ui);
1264                                 (void) md_unit_readerlock(ui);
1265                         }
1266                         return (ENXIO);
1267                 }
1268 
1269                 /* track all component states that need changing */
1270                 c = (err_comp_t *)kmem_alloc(sizeof (err_comp_t), KM_SLEEP);
1271                 c->ec_next = ecomps;
1272                 c->ec_smi = smi;
1273                 c->ec_ci = ci;
1274                 ecomps = c;
1275                 ci++;
1276         }
1277 
1278         /* Make all state changes and commit them */
1279         for (c = ecomps; c != NULL; c = c->ec_next) {
1280                 /*
1281                  * If lockp is set, then entering kernel through ioctl.
1282                  * For a MN set, the only ioctl path is via a commd message
1283                  * (ALLOCATE_HOTSPARE or *RESYNC* messages) that is already
1284                  * being sent to each node.
1285                  * In this case, set NO_XMIT so that set_sm_comp_state
1286                  * won't attempt to send a message on a message.
1287                  *
1288                  * In !MN sets, the xmit flag is ignored, so it doesn't matter
1289                  * which flag is passed.
1290                  */
1291                 if (lockp) {
1292                         set_sm_comp_state(un, c->ec_smi, c->ec_ci, CS_ERRED, 0,
1293                             MD_STATE_NO_XMIT, lockp);
1294                 } else {
1295                         set_sm_comp_state(un, c->ec_smi, c->ec_ci, CS_ERRED, 0,
1296                             (MD_STATE_XMIT | MD_STATE_OCHELD), lockp);
1297                 }
1298                 /*
1299                  * For a MN set, the NOTIFY is done when the state change is
1300                  * processed on each node
1301                  */
1302                 if (!MD_MNSET_SETNO(setno)) {
1303                         SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED,
1304                             SVM_TAG_METADEVICE, setno, MD_SID(un));
1305                 }
1306         }
1307 
1308         if (lockp) {
1309                 md_ioctl_writerexit(lockp);
1310                 (void) md_ioctl_readerlock(lockp, ui);
1311         } else {
1312                 md_unit_writerexit(ui);
1313                 (void) md_unit_readerlock(ui);
1314         }
1315 
1316         free_all_ecomps(ecomps);
1317 
1318         /* allocate hotspares for all errored components */
1319         if (MD_MNSET_SETNO(setno)) {
1320                 /*
1321                  * If we're called from an ioctl (lockp set) then we cannot
1322                  * directly call send_poke_hotspares as this will block until
1323                  * the message gets despatched to all nodes. If the cluster is
1324                  * going through a reconfig cycle then the message will block
1325                  * until the cycle is complete, and as we originate from a
1326                  * service call from commd we will livelock.
1327                  */
1328                 if (lockp == NULL) {
1329                         md_unit_readerexit(ui);
1330                         send_poke_hotspares(setno);
1331                         (void) md_unit_readerlock(ui);
1332                 }
1333         } else {
1334                 (void) poke_hotspares();
1335         }
1336         return (0);
1337 }
1338 
1339 void
1340 mirror_overlap_tree_remove(md_mps_t *ps)
1341 {
1342         mm_unit_t       *un;
1343 
1344         if (panicstr)
1345                 return;
1346 
1347         VERIFY(ps->ps_flags & MD_MPS_ON_OVERLAP);
1348         un = ps->ps_un;
1349 
1350         mutex_enter(&un->un_overlap_tree_mx);
1351         avl_remove(&un->un_overlap_root, ps);
1352         ps->ps_flags &= ~MD_MPS_ON_OVERLAP;
1353         if (un->un_overlap_tree_flag != 0) {
1354                 un->un_overlap_tree_flag = 0;
1355                 cv_broadcast(&un->un_overlap_tree_cv);
1356         }
1357         mutex_exit(&un->un_overlap_tree_mx);
1358 }
1359 
1360 
1361 /*
1362  * wait_for_overlaps:
1363  * -----------------
1364  * Check that given i/o request does not cause an overlap with already pending
1365  * i/o. If it does, block until the overlapped i/o completes.
1366  *
1367  * The flag argument has MD_OVERLAP_ALLOW_REPEAT set if it is ok for the parent
1368  * structure to be already in the overlap tree and MD_OVERLAP_NO_REPEAT if
1369  * it must not already be in the tree.
1370  */
1371 static void
1372 wait_for_overlaps(md_mps_t *ps, int flags)
1373 {
1374         mm_unit_t       *un;
1375         avl_index_t     where;
1376         md_mps_t        *ps1;
1377 
1378         if (panicstr)
1379                 return;
1380 
1381         un = ps->ps_un;
1382         mutex_enter(&un->un_overlap_tree_mx);
1383         if ((flags & MD_OVERLAP_ALLOW_REPEAT) &&
1384             (ps->ps_flags & MD_MPS_ON_OVERLAP)) {
1385                 mutex_exit(&un->un_overlap_tree_mx);
1386                 return;
1387         }
1388 
1389         VERIFY(!(ps->ps_flags & MD_MPS_ON_OVERLAP));
1390 
1391         do {
1392                 ps1 = avl_find(&un->un_overlap_root, ps, &where);
1393                 if (ps1 == NULL) {
1394                         /*
1395                          * The candidate range does not overlap with any
1396                          * range in the tree.  Insert it and be done.
1397                          */
1398                         avl_insert(&un->un_overlap_root, ps, where);
1399                         ps->ps_flags |= MD_MPS_ON_OVERLAP;
1400                 } else {
1401                         /*
1402                          * The candidate range would overlap.  Set the flag
1403                          * indicating we need to be woken up, and sleep
1404                          * until another thread removes a range.  If upon
1405                          * waking up we find this mps was put on the tree
1406                          * by another thread, the loop terminates.
1407                          */
1408                         un->un_overlap_tree_flag = 1;
1409                         cv_wait(&un->un_overlap_tree_cv,
1410                             &un->un_overlap_tree_mx);
1411                 }
1412         } while (!(ps->ps_flags & MD_MPS_ON_OVERLAP));
1413         mutex_exit(&un->un_overlap_tree_mx);
1414 }
1415 
1416 /*
1417  * This function is called from mirror_done to check whether any pages have
1418  * been modified while a mirrored write was in progress.  Returns 0 if
1419  * all pages associated with bp are clean, 1 otherwise.
1420  */
1421 static int
1422 any_pages_dirty(struct buf *bp)
1423 {
1424         int     rval;
1425 
1426         rval = biomodified(bp);
1427         if (rval == -1)
1428                 rval = 0;
1429 
1430         return (rval);
1431 }
1432 
1433 #define MAX_EXTRAS 10
1434 
1435 void
1436 mirror_commit(
1437         mm_unit_t       *un,
1438         int             smmask,
1439         mddb_recid_t    *extras
1440 )
1441 {
1442         mm_submirror_t          *sm;
1443         md_unit_t               *su;
1444         int                     i;
1445 
1446         /* 2=mirror,null id */
1447         mddb_recid_t            recids[NMIRROR+2+MAX_EXTRAS];
1448 
1449         int                     ri = 0;
1450 
1451         if (md_get_setstatus(MD_UN2SET(un)) & MD_SET_STALE)
1452                 return;
1453 
1454         /* Add two, this includes the mirror unit and the null recid */
1455         if (extras != NULL) {
1456                 int     nrecids = 0;
1457                 while (extras[nrecids] != 0) {
1458                         nrecids++;
1459                 }
1460                 ASSERT(nrecids <= MAX_EXTRAS);
1461         }
1462 
1463         if (un != NULL)
1464                 recids[ri++] = un->c.un_record_id;
1465         for (i = 0;  i < NMIRROR; i++) {
1466                 if (!(smmask & SMI2BIT(i)))
1467                         continue;
1468                 sm = &un->un_sm[i];
1469                 if (!SMS_IS(sm, SMS_INUSE))
1470                         continue;
1471                 if (md_getmajor(sm->sm_dev) != md_major)
1472                         continue;
1473                 su =  MD_UNIT(md_getminor(sm->sm_dev));
1474                 recids[ri++] = su->c.un_record_id;
1475         }
1476 
1477         if (extras != NULL)
1478                 while (*extras != 0) {
1479                         recids[ri++] = *extras;
1480                         extras++;
1481                 }
1482 
1483         if (ri == 0)
1484                 return;
1485         recids[ri] = 0;
1486 
1487         /*
1488          * Ok to hold ioctl lock across record commit to mddb as
1489          * long as the record(s) being committed aren't resync records.
1490          */
1491         mddb_commitrecs_wrapper(recids);
1492 }
1493 
1494 
1495 /*
1496  * This routine is used to set a bit in the writable_bm bitmap
1497  * which represents each submirror in a metamirror which
1498  * is writable. The first writable submirror index is assigned
1499  * to the sm_index.  The number of writable submirrors are returned in nunits.
1500  *
1501  * This routine returns the submirror's unit number.
1502  */
1503 
1504 static void
1505 select_write_units(struct mm_unit *un, md_mps_t *ps)
1506 {
1507 
1508         int             i;
1509         unsigned        writable_bm = 0;
1510         unsigned        nunits = 0;
1511 
1512         for (i = 0; i < NMIRROR; i++) {
1513                 if (SUBMIRROR_IS_WRITEABLE(un, i)) {
1514                         /* set bit of all writable units */
1515                         writable_bm |= SMI2BIT(i);
1516                         nunits++;
1517                 }
1518         }
1519         ps->ps_writable_sm = writable_bm;
1520         ps->ps_active_cnt = nunits;
1521         ps->ps_current_sm = 0;
1522 }
1523 
1524 static
1525 unsigned
1526 select_write_after_read_units(struct mm_unit *un, md_mps_t *ps)
1527 {
1528 
1529         int             i;
1530         unsigned        writable_bm = 0;
1531         unsigned        nunits = 0;
1532 
1533         for (i = 0; i < NMIRROR; i++) {
1534                 if (SUBMIRROR_IS_WRITEABLE(un, i) &&
1535                     un->un_sm[i].sm_flags & MD_SM_RESYNC_TARGET) {
1536                         writable_bm |= SMI2BIT(i);
1537                         nunits++;
1538                 }
1539         }
1540         if ((writable_bm & ps->ps_allfrom_sm) != 0) {
1541                 writable_bm &= ~ps->ps_allfrom_sm;
1542                 nunits--;
1543         }
1544         ps->ps_writable_sm = writable_bm;
1545         ps->ps_active_cnt = nunits;
1546         ps->ps_current_sm = 0;
1547         return (nunits);
1548 }
1549 
1550 static md_dev64_t
1551 select_read_unit(
1552         mm_unit_t       *un,
1553         diskaddr_t      blkno,
1554         u_longlong_t    reqcount,
1555         u_longlong_t    *cando,
1556         int             must_be_opened,
1557         md_m_shared_t   **shared,
1558         md_mcs_t        *cs)
1559 {
1560         int                     i;
1561         md_m_shared_t           *s;
1562         uint_t                  lasterrcnt = 0;
1563         md_dev64_t              dev = 0;
1564         u_longlong_t            cnt;
1565         u_longlong_t            mincnt;
1566         mm_submirror_t          *sm;
1567         mm_submirror_ic_t       *smic;
1568         mdi_unit_t              *ui;
1569 
1570         mincnt = reqcount;
1571         for (i = 0; i < NMIRROR; i++) {
1572                 if (!SUBMIRROR_IS_READABLE(un, i))
1573                         continue;
1574                 sm = &un->un_sm[i];
1575                 smic = &un->un_smic[i];
1576                 cnt = reqcount;
1577 
1578                 /*
1579                  * If the current submirror is marked as inaccessible, do not
1580                  * try to access it.
1581                  */
1582                 ui = MDI_UNIT(getminor(expldev(sm->sm_dev)));
1583                 (void) md_unit_readerlock(ui);
1584                 if (ui->ui_tstate & MD_INACCESSIBLE) {
1585                         md_unit_readerexit(ui);
1586                         continue;
1587                 }
1588                 md_unit_readerexit(ui);
1589 
1590                 s = (md_m_shared_t *)(*(smic->sm_shared_by_blk))
1591                     (sm->sm_dev, sm, blkno, &cnt);
1592 
1593                 if (must_be_opened && !(s->ms_flags & MDM_S_ISOPEN))
1594                         continue;
1595                 if (s->ms_state == CS_OKAY) {
1596                         *cando = cnt;
1597                         if (shared != NULL)
1598                                 *shared = s;
1599 
1600                         if (un->un_sm[i].sm_flags & MD_SM_FAILFAST &&
1601                             cs != NULL) {
1602                                 cs->cs_buf.b_flags |= B_FAILFAST;
1603                         }
1604 
1605                         return (un->un_sm[i].sm_dev);
1606                 }
1607                 if (s->ms_state != CS_LAST_ERRED)
1608                         continue;
1609 
1610                 /* don't use B_FAILFAST since we're Last Erred */
1611 
1612                 if (mincnt > cnt)
1613                         mincnt = cnt;
1614                 if (s->ms_lasterrcnt > lasterrcnt) {
1615                         lasterrcnt = s->ms_lasterrcnt;
1616                         if (shared != NULL)
1617                                 *shared = s;
1618                         dev = un->un_sm[i].sm_dev;
1619                 }
1620         }
1621         *cando = mincnt;
1622         return (dev);
1623 }
1624 
1625 /*
1626  * Given a 32-bit bitmap, this routine will return the bit number
1627  * of the nth bit set.  The nth bit set is passed via the index integer.
1628  *
1629  * This routine is used to run through the writable submirror bitmap
1630  * and starting all of the writes.  See the value returned is the
1631  * index to appropriate submirror structure, in the md_sm
1632  * array for metamirrors.
1633  */
1634 static int
1635 md_find_nth_unit(uint_t mask, int index)
1636 {
1637         int     bit, nfound;
1638 
1639         for (bit = -1, nfound = -1; nfound != index; bit++) {
1640                 ASSERT(mask != 0);
1641                 nfound += (mask & 1);
1642                 mask >>= 1;
1643         }
1644         return (bit);
1645 }
1646 
1647 static int
1648 fast_select_read_unit(md_mps_t *ps, md_mcs_t *cs)
1649 {
1650         mm_unit_t       *un;
1651         buf_t           *bp;
1652         int             i;
1653         unsigned        nunits = 0;
1654         int             iunit;
1655         uint_t          running_bm = 0;
1656         uint_t          sm_index;
1657 
1658         bp = &cs->cs_buf;
1659         un = ps->ps_un;
1660 
1661         for (i = 0; i < NMIRROR; i++) {
1662                 if (!SMS_BY_INDEX_IS(un, i, SMS_RUNNING))
1663                         continue;
1664                 running_bm |= SMI2BIT(i);
1665                 nunits++;
1666         }
1667         if (nunits == 0)
1668                 return (1);
1669 
1670         /*
1671          * For directed mirror read (DMR) we only use the specified side and
1672          * do not compute the source of the read.
1673          * If we're running with MD_MPS_DIRTY_RD set we always return the
1674          * first mirror side (this prevents unnecessary ownership switching).
1675          * Otherwise we return the submirror according to the mirror read option
1676          */
1677         if (ps->ps_flags & MD_MPS_DMR) {
1678                 sm_index = un->un_dmr_last_read;
1679         } else if (ps->ps_flags & MD_MPS_DIRTY_RD) {
1680                 sm_index = md_find_nth_unit(running_bm, 0);
1681         } else {
1682                 /* Normal (non-DMR) operation */
1683                 switch (un->un_read_option) {
1684                 case RD_GEOMETRY:
1685                         iunit = (int)(bp->b_lblkno /
1686                             howmany(un->c.un_total_blocks, nunits));
1687                         sm_index = md_find_nth_unit(running_bm, iunit);
1688                         break;
1689                 case RD_FIRST:
1690                         sm_index = md_find_nth_unit(running_bm, 0);
1691                         break;
1692                 case RD_LOAD_BAL:
1693                         /* this is intentional to fall into the default */
1694                 default:
1695                         un->un_last_read = (un->un_last_read + 1) % nunits;
1696                         sm_index = md_find_nth_unit(running_bm,
1697                             un->un_last_read);
1698                         break;
1699                 }
1700         }
1701         bp->b_edev = md_dev64_to_dev(un->un_sm[sm_index].sm_dev);
1702         ps->ps_allfrom_sm = SMI2BIT(sm_index);
1703 
1704         if (un->un_sm[sm_index].sm_flags & MD_SM_FAILFAST) {
1705                 bp->b_flags |= B_FAILFAST;
1706         }
1707 
1708         return (0);
1709 }
1710 
1711 static
1712 int
1713 mirror_are_submirrors_available(mm_unit_t *un)
1714 {
1715         int i;
1716         for (i = 0; i < NMIRROR; i++) {
1717                 md_dev64_t tmpdev = un->un_sm[i].sm_dev;
1718 
1719                 if ((!SMS_BY_INDEX_IS(un, i, SMS_INUSE)) ||
1720                     md_getmajor(tmpdev) != md_major)
1721                         continue;
1722 
1723                 if ((MD_MIN2SET(md_getminor(tmpdev)) >= md_nsets) ||
1724                     (MD_MIN2UNIT(md_getminor(tmpdev)) >= md_nunits))
1725                         return (0);
1726 
1727                 if (MDI_UNIT(md_getminor(tmpdev)) == NULL)
1728                         return (0);
1729         }
1730         return (1);
1731 }
1732 
1733 void
1734 build_submirror(mm_unit_t *un, int i, int snarfing)
1735 {
1736         struct mm_submirror     *sm;
1737         struct mm_submirror_ic  *smic;
1738         md_unit_t               *su;
1739         set_t                   setno;
1740 
1741         sm = &un->un_sm[i];
1742         smic = &un->un_smic[i];
1743 
1744         sm->sm_flags = 0; /* sometime we may need to do more here */
1745 
1746         setno = MD_UN2SET(un);
1747 
1748         if (!SMS_IS(sm, SMS_INUSE))
1749                 return;
1750         if (snarfing) {
1751                 sm->sm_dev = md_getdevnum(setno, mddb_getsidenum(setno),
1752                     sm->sm_key, MD_NOTRUST_DEVT);
1753         } else {
1754                 if (md_getmajor(sm->sm_dev) == md_major) {
1755                         su = MD_UNIT(md_getminor(sm->sm_dev));
1756                         un->c.un_flag |= (su->c.un_flag & MD_LABELED);
1757                         /* submirror can no longer be soft partitioned */
1758                         MD_CAPAB(su) &= (~MD_CAN_SP);
1759                 }
1760         }
1761         smic->sm_shared_by_blk = md_get_named_service(sm->sm_dev,
1762             0, "shared by blk", 0);
1763         smic->sm_shared_by_indx = md_get_named_service(sm->sm_dev,
1764             0, "shared by indx", 0);
1765         smic->sm_get_component_count = (int (*)())md_get_named_service(
1766             sm->sm_dev, 0, "get component count", 0);
1767         smic->sm_get_bcss = (int (*)())md_get_named_service(sm->sm_dev, 0,
1768             "get block count skip size", 0);
1769         sm->sm_state &= ~SMS_IGNORE;
1770         if (SMS_IS(sm, SMS_OFFLINE))
1771                 MD_STATUS(un) |= MD_UN_OFFLINE_SM;
1772         md_set_parent(sm->sm_dev, MD_SID(un));
1773 }
1774 
1775 static void
1776 mirror_cleanup(mm_unit_t *un)
1777 {
1778         mddb_recid_t    recid;
1779         int             smi;
1780         sv_dev_t        sv[NMIRROR];
1781         int             nsv = 0;
1782 
1783         /*
1784          * If a MN diskset and this node is not the master, do
1785          * not delete any records on snarf of the mirror records.
1786          */
1787         if (MD_MNSET_SETNO(MD_UN2SET(un)) &&
1788             md_set[MD_UN2SET(un)].s_am_i_master == 0) {
1789                 return;
1790         }
1791 
1792         for (smi = 0; smi < NMIRROR; smi++) {
1793                 if (!SMS_BY_INDEX_IS(un, smi, SMS_INUSE))
1794                         continue;
1795                 sv[nsv].setno = MD_UN2SET(un);
1796                 sv[nsv++].key = un->un_sm[smi].sm_key;
1797         }
1798 
1799         recid = un->un_rr_dirty_recid;
1800         mddb_deleterec_wrapper(un->c.un_record_id);
1801         if (recid > 0)
1802                 mddb_deleterec_wrapper(recid);
1803 
1804         md_rem_names(sv, nsv);
1805 }
1806 
1807 /*
1808  * Comparison function for the avl tree which tracks
1809  * outstanding writes on submirrors.
1810  *
1811  * Returns:
1812  *      -1: ps1 < ps2
1813  *       0: ps1 and ps2 overlap
1814  *       1: ps1 > ps2
1815  */
1816 static int
1817 mirror_overlap_compare(const void *p1, const void *p2)
1818 {
1819         const md_mps_t *ps1 = (md_mps_t *)p1;
1820         const md_mps_t *ps2 = (md_mps_t *)p2;
1821 
1822         if (ps1->ps_firstblk < ps2->ps_firstblk) {
1823                 if (ps1->ps_lastblk >= ps2->ps_firstblk)
1824                         return (0);
1825                 return (-1);
1826         }
1827 
1828         if (ps1->ps_firstblk > ps2->ps_firstblk) {
1829                 if (ps1->ps_firstblk <= ps2->ps_lastblk)
1830                         return (0);
1831                 return (1);
1832         }
1833 
1834         return (0);
1835 }
1836 
1837 /*
1838  * Collapse any sparse submirror entries snarfed from the on-disk replica.
1839  * Only the in-core entries are updated. The replica will be updated on-disk
1840  * when the in-core replica is committed on shutdown of the SVM subsystem.
1841  */
1842 static void
1843 collapse_submirrors(mm_unit_t *un)
1844 {
1845         int                     smi, nremovals, smiremove;
1846         mm_submirror_t          *sm, *new_sm, *old_sm;
1847         mm_submirror_ic_t       *smic;
1848         int                     nsmidx = un->un_nsm - 1;
1849 
1850 rescan:
1851         nremovals = 0;
1852         smiremove = -1;
1853 
1854         for (smi = 0; smi <= nsmidx; smi++) {
1855                 sm = &un->un_sm[smi];
1856 
1857                 /*
1858                  * Check to see if this submirror is marked as in-use.
1859                  * If it isn't then it is a potential sparse entry and
1860                  * may need to be cleared from the configuration.
1861                  * The records should _already_ have been cleared by the
1862                  * original mirror_detach() code, but we need to shuffle
1863                  * any NULL entries in un_sm[] to the end of the array.
1864                  * Any NULL un_smic[] entries need to be reset to the underlying
1865                  * submirror/slice accessor functions.
1866                  */
1867                 if (!SMS_BY_INDEX_IS(un, smi, SMS_INUSE)) {
1868                         nremovals++;
1869                         smiremove = smi;
1870                         break;
1871                 }
1872         }
1873 
1874         if (nremovals == 0) {
1875                 /*
1876                  * Ensure that we have a matching contiguous set of un_smic[]
1877                  * entries for the corresponding un_sm[] entries
1878                  */
1879                 for (smi = 0; smi <= nsmidx; smi++) {
1880                         smic = &un->un_smic[smi];
1881                         sm = &un->un_sm[smi];
1882 
1883                         smic->sm_shared_by_blk =
1884                             md_get_named_service(sm->sm_dev, 0,
1885                             "shared by_blk", 0);
1886                         smic->sm_shared_by_indx =
1887                             md_get_named_service(sm->sm_dev, 0,
1888                             "shared by indx", 0);
1889                         smic->sm_get_component_count =
1890                             (int (*)())md_get_named_service(sm->sm_dev, 0,
1891                             "get component count", 0);
1892                         smic->sm_get_bcss =
1893                             (int (*)())md_get_named_service(sm->sm_dev, 0,
1894                             "get block count skip size", 0);
1895                 }
1896                 return;
1897         }
1898 
1899         /*
1900          * Reshuffle the submirror devices so that we do not have a dead record
1901          * in the middle of the array. Once we've done this we need to rescan
1902          * the mirror to check for any other holes.
1903          */
1904         for (smi = 0; smi < NMIRROR; smi++) {
1905                 if (smi < smiremove)
1906                         continue;
1907                 if (smi > smiremove) {
1908                         old_sm = &un->un_sm[smi];
1909                         new_sm = &un->un_sm[smi - 1];
1910                         bcopy(old_sm, new_sm, sizeof (mm_submirror_t));
1911                         bzero(old_sm, sizeof (mm_submirror_t));
1912                 }
1913         }
1914 
1915         /*
1916          * Now we need to rescan the array to find the next potential dead
1917          * entry.
1918          */
1919         goto rescan;
1920 }
1921 
1922 /* Return a -1 if optimized record unavailable and set should be released */
1923 int
1924 mirror_build_incore(mm_unit_t *un, int snarfing)
1925 {
1926         int             i;
1927 
1928         if (MD_STATUS(un) & MD_UN_BEING_RESET) {
1929                 mddb_setrecprivate(un->c.un_record_id, MD_PRV_PENDCLEAN);
1930                 return (1);
1931         }
1932 
1933         if (mirror_are_submirrors_available(un) == 0)
1934                 return (1);
1935 
1936         if (MD_UNIT(MD_SID(un)) != NULL)
1937                 return (0);
1938 
1939         MD_STATUS(un) = 0;
1940 
1941         /* pre-4.1 didn't define CAN_META_CHILD capability */
1942         MD_CAPAB(un) = MD_CAN_META_CHILD | MD_CAN_PARENT | MD_CAN_SP;
1943 
1944         un->un_overlap_tree_flag = 0;
1945         avl_create(&un->un_overlap_root, mirror_overlap_compare,
1946             sizeof (md_mps_t), offsetof(md_mps_t, ps_overlap_node));
1947 
1948         /*
1949          * We need to collapse any sparse submirror entries into a non-sparse
1950          * array. This is to cover the case where we have an old replica image
1951          * which has not been updated (i.e. snarfed) since being modified.
1952          * The new code expects all submirror access to be sequential (i.e.
1953          * both the un_sm[] and un_smic[] entries correspond to non-empty
1954          * submirrors.
1955          */
1956 
1957         collapse_submirrors(un);
1958 
1959         for (i = 0; i < NMIRROR; i++)
1960                 build_submirror(un, i, snarfing);
1961 
1962         if (unit_setup_resync(un, snarfing) != 0) {
1963                 if (snarfing) {
1964                         mddb_setrecprivate(un->c.un_record_id, MD_PRV_GOTIT);
1965                         /*
1966                          * If a MN set and set is not stale, then return -1
1967                          * which will force the caller to unload the set.
1968                          * The MN diskset nodes will return failure if
1969                          * unit_setup_resync fails so that nodes won't
1970                          * get out of sync.
1971                          *
1972                          * If set is STALE, the master node can't allocate
1973                          * a resync record (if needed), but node needs to
1974                          * join the set so that user can delete broken mddbs.
1975                          * So, if set is STALE, just continue on.
1976                          */
1977                         if (MD_MNSET_SETNO(MD_UN2SET(un)) &&
1978                             !(md_get_setstatus(MD_UN2SET(un)) & MD_SET_STALE)) {
1979                                 return (-1);
1980                         }
1981                 } else
1982                         return (1);
1983         }
1984 
1985         mutex_init(&un->un_overlap_tree_mx, NULL, MUTEX_DEFAULT, NULL);
1986         cv_init(&un->un_overlap_tree_cv, NULL, CV_DEFAULT, NULL);
1987 
1988         un->un_suspend_wr_flag = 0;
1989         mutex_init(&un->un_suspend_wr_mx, NULL, MUTEX_DEFAULT, NULL);
1990         cv_init(&un->un_suspend_wr_cv, NULL, CV_DEFAULT, NULL);
1991 
1992         /*
1993          * Allocate mutexes for mirror-owner and resync-owner changes.
1994          * All references to the owner message state field must be guarded
1995          * by this mutex.
1996          */
1997         mutex_init(&un->un_owner_mx, NULL, MUTEX_DEFAULT, NULL);
1998 
1999         /*
2000          * Allocate mutex and condvar for resync thread manipulation. These
2001          * will be used by mirror_resync_unit/mirror_ioctl_resync
2002          */
2003         mutex_init(&un->un_rs_thread_mx, NULL, MUTEX_DEFAULT, NULL);
2004         cv_init(&un->un_rs_thread_cv, NULL, CV_DEFAULT, NULL);
2005 
2006         /*
2007          * Allocate mutex and condvar for resync progress thread manipulation.
2008          * This allows resyncs to be continued across an intervening reboot.
2009          */
2010         mutex_init(&un->un_rs_progress_mx, NULL, MUTEX_DEFAULT, NULL);
2011         cv_init(&un->un_rs_progress_cv, NULL, CV_DEFAULT, NULL);
2012 
2013         /*
2014          * Allocate mutex and condvar for Directed Mirror Reads (DMR). This
2015          * provides synchronization between a user-ioctl and the resulting
2016          * strategy() call that performs the read().
2017          */
2018         mutex_init(&un->un_dmr_mx, NULL, MUTEX_DEFAULT, NULL);
2019         cv_init(&un->un_dmr_cv, NULL, CV_DEFAULT, NULL);
2020 
2021         /*
2022          * Allocate rwlocks for un_pernode_dirty_bm accessing.
2023          */
2024         for (i = 0; i < MD_MNMAXSIDES; i++) {
2025                 rw_init(&un->un_pernode_dirty_mx[i], NULL, RW_DEFAULT, NULL);
2026         }
2027 
2028         /* place various information in the in-core data structures */
2029         md_nblocks_set(MD_SID(un), un->c.un_total_blocks);
2030         MD_UNIT(MD_SID(un)) = un;
2031 
2032         return (0);
2033 }
2034 
2035 
2036 void
2037 reset_mirror(struct mm_unit *un, minor_t mnum, int removing)
2038 {
2039         mddb_recid_t    recid, vtoc_id;
2040         size_t          bitcnt;
2041         size_t          shortcnt;
2042         int             smi;
2043         sv_dev_t        sv[NMIRROR];
2044         int             nsv = 0;
2045         uint_t          bits = 0;
2046         minor_t         selfid;
2047         md_unit_t       *su;
2048         int             i;
2049 
2050         md_destroy_unit_incore(mnum, &mirror_md_ops);
2051 
2052         shortcnt = un->un_rrd_num * sizeof (short);
2053         bitcnt = howmany(un->un_rrd_num, NBBY);
2054 
2055         if (un->un_outstanding_writes)
2056                 kmem_free((caddr_t)un->un_outstanding_writes, shortcnt);
2057         if (un->un_goingclean_bm)
2058                 kmem_free((caddr_t)un->un_goingclean_bm, bitcnt);
2059         if (un->un_goingdirty_bm)
2060                 kmem_free((caddr_t)un->un_goingdirty_bm, bitcnt);
2061         if (un->un_resync_bm)
2062                 kmem_free((caddr_t)un->un_resync_bm, bitcnt);
2063         if (un->un_pernode_dirty_sum)
2064                 kmem_free((caddr_t)un->un_pernode_dirty_sum, un->un_rrd_num);
2065 
2066         /*
2067          * Destroy the taskq for deferred processing of DRL clean requests.
2068          * This taskq will only be present for Multi Owner mirrors.
2069          */
2070         if (un->un_drl_task != NULL)
2071                 ddi_taskq_destroy(un->un_drl_task);
2072 
2073         md_nblocks_set(mnum, -1ULL);
2074         MD_UNIT(mnum) = NULL;
2075 
2076         /*
2077          * Attempt release of its minor node
2078          */
2079         md_remove_minor_node(mnum);
2080 
2081         if (!removing)
2082                 return;
2083 
2084         for (smi = 0; smi < NMIRROR; smi++) {
2085                 if (!SMS_BY_INDEX_IS(un, smi, SMS_INUSE))
2086                         continue;
2087                 /* reallow soft partitioning of submirror and reset parent */
2088                 su = MD_UNIT(md_getminor(un->un_sm[smi].sm_dev));
2089                 MD_CAPAB(su) |= MD_CAN_SP;
2090                 md_reset_parent(un->un_sm[smi].sm_dev);
2091                 reset_comp_states(&un->un_sm[smi], &un->un_smic[smi]);
2092 
2093                 sv[nsv].setno = MD_MIN2SET(mnum);
2094                 sv[nsv++].key = un->un_sm[smi].sm_key;
2095                 bits |= SMI2BIT(smi);
2096         }
2097 
2098         MD_STATUS(un) |= MD_UN_BEING_RESET;
2099         recid = un->un_rr_dirty_recid;
2100         vtoc_id = un->c.un_vtoc_id;
2101         selfid = MD_SID(un);
2102 
2103         mirror_commit(un, bits, 0);
2104 
2105         avl_destroy(&un->un_overlap_root);
2106 
2107         /* Destroy all mutexes and condvars before returning. */
2108         mutex_destroy(&un->un_suspend_wr_mx);
2109         cv_destroy(&un->un_suspend_wr_cv);
2110         mutex_destroy(&un->un_overlap_tree_mx);
2111         cv_destroy(&un->un_overlap_tree_cv);
2112         mutex_destroy(&un->un_owner_mx);
2113         mutex_destroy(&un->un_rs_thread_mx);
2114         cv_destroy(&un->un_rs_thread_cv);
2115         mutex_destroy(&un->un_rs_progress_mx);
2116         cv_destroy(&un->un_rs_progress_cv);
2117         mutex_destroy(&un->un_dmr_mx);
2118         cv_destroy(&un->un_dmr_cv);
2119 
2120         for (i = 0; i < MD_MNMAXSIDES; i++) {
2121                 rw_destroy(&un->un_pernode_dirty_mx[i]);
2122                 if (un->un_pernode_dirty_bm[i])
2123                         kmem_free((caddr_t)un->un_pernode_dirty_bm[i], bitcnt);
2124         }
2125 
2126         /*
2127          * Remove self from the namespace
2128          */
2129         if (un->c.un_revision & MD_FN_META_DEV) {
2130                 (void) md_rem_selfname(un->c.un_self_id);
2131         }
2132 
2133         /* This frees the unit structure. */
2134         mddb_deleterec_wrapper(un->c.un_record_id);
2135 
2136         if (recid != 0)
2137                 mddb_deleterec_wrapper(recid);
2138 
2139         /* Remove the vtoc, if present */
2140         if (vtoc_id)
2141                 mddb_deleterec_wrapper(vtoc_id);
2142 
2143         md_rem_names(sv, nsv);
2144 
2145         SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_DELETE, SVM_TAG_METADEVICE,
2146             MD_MIN2SET(selfid), selfid);
2147 }
2148 
2149 int
2150 mirror_internal_open(
2151         minor_t         mnum,
2152         int             flag,
2153         int             otyp,
2154         int             md_oflags,
2155         IOLOCK          *lockp          /* can be NULL */
2156 )
2157 {
2158         mdi_unit_t      *ui = MDI_UNIT(mnum);
2159         int             err = 0;
2160 
2161 tryagain:
2162         /* single thread */
2163         if (lockp) {
2164                 /*
2165                  * If ioctl lock is held, use openclose_enter
2166                  * routine that will set the ioctl flag when
2167                  * grabbing the readerlock.
2168                  */
2169                 (void) md_ioctl_openclose_enter(lockp, ui);
2170         } else {
2171                 (void) md_unit_openclose_enter(ui);
2172         }
2173 
2174         /*
2175          * The mirror_open_all_devs routine may end up sending a STATE_UPDATE
2176          * message in a MN diskset and this requires that the openclose
2177          * lock is dropped in order to send this message.  So, another
2178          * flag (MD_UL_OPENINPROGRESS) is used to keep another thread from
2179          * attempting an open while this thread has an open in progress.
2180          * Call the *_lh version of the lock exit routines since the ui_mx
2181          * mutex must be held from checking for OPENINPROGRESS until
2182          * after the cv_wait call.
2183          */
2184         mutex_enter(&ui->ui_mx);
2185         if (ui->ui_lock & MD_UL_OPENINPROGRESS) {
2186                 if (lockp) {
2187                         (void) md_ioctl_openclose_exit_lh(lockp);
2188                 } else {
2189                         md_unit_openclose_exit_lh(ui);
2190                 }
2191                 cv_wait(&ui->ui_cv, &ui->ui_mx);
2192                 mutex_exit(&ui->ui_mx);
2193                 goto tryagain;
2194         }
2195 
2196         ui->ui_lock |= MD_UL_OPENINPROGRESS;
2197         mutex_exit(&ui->ui_mx);
2198 
2199         /* open devices, if necessary */
2200         if (! md_unit_isopen(ui) || (ui->ui_tstate & MD_INACCESSIBLE)) {
2201                 if ((err = mirror_open_all_devs(mnum, md_oflags, lockp)) != 0)
2202                         goto out;
2203         }
2204 
2205         /* count open */
2206         if ((err = md_unit_incopen(mnum, flag, otyp)) != 0)
2207                 goto out;
2208 
2209         /* unlock, return success */
2210 out:
2211         mutex_enter(&ui->ui_mx);
2212         ui->ui_lock &= ~MD_UL_OPENINPROGRESS;
2213         mutex_exit(&ui->ui_mx);
2214 
2215         if (lockp) {
2216                 /*
2217                  * If ioctl lock is held, use openclose_exit
2218                  * routine that will clear the lockp reader flag.
2219                  */
2220                 (void) md_ioctl_openclose_exit(lockp);
2221         } else {
2222                 md_unit_openclose_exit(ui);
2223         }
2224         return (err);
2225 }
2226 
2227 int
2228 mirror_internal_close(
2229         minor_t         mnum,
2230         int             otyp,
2231         int             md_cflags,
2232         IOLOCK          *lockp          /* can be NULL */
2233 )
2234 {
2235         mdi_unit_t      *ui = MDI_UNIT(mnum);
2236         mm_unit_t       *un;
2237         int             err = 0;
2238 
2239         /* single thread */
2240         if (lockp) {
2241                 /*
2242                  * If ioctl lock is held, use openclose_enter
2243                  * routine that will set the ioctl flag when
2244                  * grabbing the readerlock.
2245                  */
2246                 un = (mm_unit_t *)md_ioctl_openclose_enter(lockp, ui);
2247         } else {
2248                 un = (mm_unit_t *)md_unit_openclose_enter(ui);
2249         }
2250 
2251         /* count closed */
2252         if ((err = md_unit_decopen(mnum, otyp)) != 0)
2253                 goto out;
2254 
2255         /* close devices, if necessary */
2256         if (! md_unit_isopen(ui) || (md_cflags & MD_OFLG_PROBEDEV)) {
2257                 /*
2258                  * Clean up dirty bitmap for this unit. Do this
2259                  * before closing the underlying devices to avoid
2260                  * race conditions with reset_mirror() as a
2261                  * result of a 'metaset -r' command running in
2262                  * parallel. This might cause deallocation of
2263                  * dirty region bitmaps; with underlying metadevices
2264                  * in place this can't happen.
2265                  * Don't do this if a MN set and ABR not set
2266                  */
2267                 if (new_resync && !(MD_STATUS(un) & MD_UN_KEEP_DIRTY)) {
2268                         if (!MD_MNSET_SETNO(MD_UN2SET(un)) ||
2269                             !(ui->ui_tstate & MD_ABR_CAP))
2270                                 mirror_process_unit_resync(un);
2271                 }
2272                 (void) mirror_close_all_devs(un, md_cflags);
2273 
2274                 /*
2275                  * For a MN set with transient capabilities (eg ABR/DMR) set,
2276                  * clear these capabilities on the last open in the cluster.
2277                  * To do this we send a message to all nodes to see of the
2278                  * device is open.
2279                  */
2280                 if (MD_MNSET_SETNO(MD_UN2SET(un)) &&
2281                     (ui->ui_tstate & (MD_ABR_CAP|MD_DMR_CAP))) {
2282                         if (lockp) {
2283                                 (void) md_ioctl_openclose_exit(lockp);
2284                         } else {
2285                                 md_unit_openclose_exit(ui);
2286                         }
2287 
2288                         /*
2289                          * if we are in the context of an ioctl, drop the
2290                          * ioctl lock.
2291                          * Otherwise, no other locks should be held.
2292                          */
2293                         if (lockp) {
2294                                 IOLOCK_RETURN_RELEASE(0, lockp);
2295                         }
2296 
2297                         mdmn_clear_all_capabilities(mnum);
2298 
2299                         /* if dropped the lock previously, regain it */
2300                         if (lockp) {
2301                                 IOLOCK_RETURN_REACQUIRE(lockp);
2302                         }
2303                         return (0);
2304                 }
2305                 /* unlock and return success */
2306         }
2307 out:
2308         /* Call whether lockp is NULL or not. */
2309         if (lockp) {
2310                 md_ioctl_openclose_exit(lockp);
2311         } else {
2312                 md_unit_openclose_exit(ui);
2313         }
2314         return (err);
2315 }
2316 
2317 /*
2318  * When a component has completed resyncing and is now ok, check if the
2319  * corresponding component in the other submirrors is in the Last Erred
2320  * state.  If it is, we want to change that to the Erred state so we stop
2321  * using that component and start using this good component instead.
2322  *
2323  * This is called from set_sm_comp_state and recursively calls
2324  * set_sm_comp_state if it needs to change the Last Erred state.
2325  */
2326 static void
2327 reset_lasterred(mm_unit_t *un, int smi, mddb_recid_t *extras, uint_t flags,
2328         IOLOCK *lockp)
2329 {
2330         mm_submirror_t          *sm;
2331         mm_submirror_ic_t       *smic;
2332         int                     ci;
2333         int                     i;
2334         int                     compcnt;
2335         int                     changed = 0;
2336 
2337         for (i = 0; i < NMIRROR; i++) {
2338                 sm = &un->un_sm[i];
2339                 smic = &un->un_smic[i];
2340 
2341                 if (!SMS_IS(sm, SMS_INUSE))
2342                         continue;
2343 
2344                 /* ignore the submirror that we just made ok */
2345                 if (i == smi)
2346                         continue;
2347 
2348                 compcnt = (*(smic->sm_get_component_count)) (sm->sm_dev, un);
2349                 for (ci = 0; ci < compcnt; ci++) {
2350                         md_m_shared_t   *shared;
2351 
2352                         shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
2353                             (sm->sm_dev, sm, ci);
2354 
2355                         if ((shared->ms_state & CS_LAST_ERRED) &&
2356                             !mirror_other_sources(un, i, ci, 1)) {
2357 
2358                                 set_sm_comp_state(un, i, ci, CS_ERRED, extras,
2359                                     flags, lockp);
2360                                 changed = 1;
2361                         }
2362                 }
2363         }
2364 
2365         /* maybe there is a hotspare for this newly erred component */
2366         if (changed) {
2367                 set_t   setno;
2368 
2369                 setno = MD_UN2SET(un);
2370                 if (MD_MNSET_SETNO(setno)) {
2371                         send_poke_hotspares(setno);
2372                 } else {
2373                         (void) poke_hotspares();
2374                 }
2375         }
2376 }
2377 
2378 /*
2379  * set_sm_comp_state
2380  *
2381  * Set the state of a submirror component to the specified new state.
2382  * If the mirror is in a multi-node set, send messages to all nodes to
2383  * block all writes to the mirror and then update the state and release the
2384  * writes. These messages are only sent if MD_STATE_XMIT is set in flags.
2385  * MD_STATE_XMIT will be unset in 2 cases:
2386  * 1. When the state is changed to CS_RESYNC as this state change
2387  * will already have been updated on each node by the processing of the
2388  * distributed metasync command, hence no need to xmit.
2389  * 2. When the state is change to CS_OKAY after a resync has completed. Again
2390  * the resync completion will already have been processed on each node by
2391  * the processing of the MD_MN_MSG_RESYNC_PHASE_DONE message for a component
2392  * resync, hence no need to xmit.
2393  *
2394  * In case we are called from the updates of a watermark,
2395  * (then MD_STATE_WMUPDATE will be set in the ps->flags) this is due to
2396  * a metainit or similar. In this case the message that we sent to propagate
2397  * the state change must not be a class1 message as that would deadlock with
2398  * the metainit command that is still being processed.
2399  * This we achieve by creating a class2 message MD_MN_MSG_STATE_UPDATE2
2400  * instead. This also makes the submessage generator to create a class2
2401  * submessage rather than a class1 (which would also block)
2402  *
2403  * On entry, unit_writerlock is held
2404  * If MD_STATE_OCHELD is set in flags, then unit_openclose lock is
2405  * also held.
2406  */
2407 void
2408 set_sm_comp_state(
2409         mm_unit_t       *un,
2410         int             smi,
2411         int             ci,
2412         int             newstate,
2413         mddb_recid_t    *extras,
2414         uint_t          flags,
2415         IOLOCK          *lockp
2416 )
2417 {
2418         mm_submirror_t          *sm;
2419         mm_submirror_ic_t       *smic;
2420         md_m_shared_t           *shared;
2421         int                     origstate;
2422         void                    (*get_dev)();
2423         ms_cd_info_t            cd;
2424         char                    devname[MD_MAX_CTDLEN];
2425         int                     err;
2426         set_t                   setno = MD_UN2SET(un);
2427         md_mn_msg_stch_t        stchmsg;
2428         mdi_unit_t              *ui = MDI_UNIT(MD_SID(un));
2429         md_mn_kresult_t         *kresult;
2430         int                     rval;
2431         uint_t                  msgflags;
2432         md_mn_msgtype_t         msgtype;
2433         int                     save_lock = 0;
2434         mdi_unit_t              *ui_sm;
2435         int                     nretries = 0;
2436 
2437         sm = &un->un_sm[smi];
2438         smic = &un->un_smic[smi];
2439 
2440         /* If we have a real error status then turn off MD_INACCESSIBLE. */
2441         ui_sm = MDI_UNIT(getminor(md_dev64_to_dev(sm->sm_dev)));
2442         if (newstate & (CS_ERRED | CS_RESYNC | CS_LAST_ERRED) &&
2443             ui_sm->ui_tstate & MD_INACCESSIBLE) {
2444                 ui_sm->ui_tstate &= ~MD_INACCESSIBLE;
2445         }
2446 
2447         shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
2448             (sm->sm_dev, sm, ci);
2449         origstate = shared->ms_state;
2450 
2451         /*
2452          * If the new state is an error and the old one wasn't, generate
2453          * a console message. We do this before we send the state to other
2454          * nodes in a MN set because the state change may change the component
2455          * name  if a hotspare is allocated.
2456          */
2457         if ((! (origstate & (CS_ERRED|CS_LAST_ERRED))) &&
2458             (newstate & (CS_ERRED|CS_LAST_ERRED))) {
2459 
2460                 get_dev = (void (*)())md_get_named_service(sm->sm_dev, 0,
2461                     "get device", 0);
2462                 (void) (*get_dev)(sm->sm_dev, sm, ci, &cd);
2463 
2464                 err = md_getdevname(setno, mddb_getsidenum(setno), 0,
2465                     cd.cd_dev, devname, sizeof (devname));
2466 
2467                 if (err == ENOENT) {
2468                         (void) md_devname(setno, cd.cd_dev, devname,
2469                             sizeof (devname));
2470                 }
2471 
2472                 cmn_err(CE_WARN, "md: %s: %s needs maintenance",
2473                     md_shortname(md_getminor(sm->sm_dev)), devname);
2474 
2475                 if (newstate & CS_LAST_ERRED) {
2476                         cmn_err(CE_WARN, "md: %s: %s last erred",
2477                             md_shortname(md_getminor(sm->sm_dev)),
2478                             devname);
2479 
2480                 } else if (shared->ms_flags & MDM_S_ISOPEN) {
2481                         /*
2482                          * Close the broken device and clear the open flag on
2483                          * it.  Closing the device means the RCM framework will
2484                          * be able to unconfigure the device if required.
2485                          *
2486                          * We have to check that the device is open, otherwise
2487                          * the first open on it has resulted in the error that
2488                          * is being processed and the actual cd.cd_dev will be
2489                          * NODEV64.
2490                          *
2491                          * If this is a multi-node mirror, then the multinode
2492                          * state checks following this code will cause the
2493                          * slave nodes to close the mirror in the function
2494                          * mirror_set_state().
2495                          */
2496                         md_layered_close(cd.cd_dev, MD_OFLG_NULL);
2497                         shared->ms_flags &= ~MDM_S_ISOPEN;
2498                 }
2499 
2500         } else if ((origstate & CS_LAST_ERRED) && (newstate & CS_ERRED) &&
2501             (shared->ms_flags & MDM_S_ISOPEN)) {
2502                 /*
2503                  * Similar to logic above except no log messages since we
2504                  * are just transitioning from Last Erred to Erred.
2505                  */
2506                 get_dev = (void (*)())md_get_named_service(sm->sm_dev, 0,
2507                     "get device", 0);
2508                 (void) (*get_dev)(sm->sm_dev, sm, ci, &cd);
2509 
2510                 md_layered_close(cd.cd_dev, MD_OFLG_NULL);
2511                 shared->ms_flags &= ~MDM_S_ISOPEN;
2512         }
2513 
2514         if ((MD_MNSET_SETNO(setno)) && (origstate != newstate) &&
2515             (flags & MD_STATE_XMIT) && !(ui->ui_tstate & MD_ERR_PENDING)) {
2516                 /*
2517                  * For a multi-node mirror, send the state change to the
2518                  * master, which broadcasts to all nodes, including this
2519                  * one. Once the message is received, the state is set
2520                  * in-core and the master commits the change to disk.
2521                  * There is a case, comp_replace,  where this function
2522                  * can be called from within an ioctl and therefore in this
2523                  * case, as the ioctl will already be called on each node,
2524                  * there is no need to xmit the state change to the master for
2525                  * distribution to the other nodes. MD_STATE_XMIT flag is used
2526                  * to indicate whether a xmit is required. The mirror's
2527                  * transient state is set to MD_ERR_PENDING to avoid sending
2528                  * multiple messages.
2529                  */
2530                 if (newstate & (CS_ERRED|CS_LAST_ERRED))
2531                         ui->ui_tstate |= MD_ERR_PENDING;
2532 
2533                 /*
2534                  * Send a state update message to all nodes. This message
2535                  * will generate 2 submessages, the first one to suspend
2536                  * all writes to the mirror and the second to update the
2537                  * state and resume writes.
2538                  */
2539                 stchmsg.msg_stch_mnum = un->c.un_self_id;
2540                 stchmsg.msg_stch_sm = smi;
2541                 stchmsg.msg_stch_comp = ci;
2542                 stchmsg.msg_stch_new_state = newstate;
2543                 stchmsg.msg_stch_hs_id = shared->ms_hs_id;
2544 #ifdef DEBUG
2545                 if (mirror_debug_flag)
2546                         printf("send set state, %x, %x, %x, %x, %x\n",
2547                             stchmsg.msg_stch_mnum, stchmsg.msg_stch_sm,
2548                             stchmsg.msg_stch_comp, stchmsg.msg_stch_new_state,
2549                             stchmsg.msg_stch_hs_id);
2550 #endif
2551                 if (flags & MD_STATE_WMUPDATE) {
2552                         msgtype  = MD_MN_MSG_STATE_UPDATE2;
2553                         /*
2554                          * When coming from an update of watermarks, there
2555                          * must already be a message logged that triggered
2556                          * this action. So, no need to log this message, too.
2557                          */
2558                         msgflags = MD_MSGF_NO_LOG;
2559                 } else {
2560                         msgtype  = MD_MN_MSG_STATE_UPDATE;
2561                         msgflags = MD_MSGF_DEFAULT_FLAGS;
2562                 }
2563 
2564                 /*
2565                  * If we are in the context of an ioctl, drop the ioctl lock.
2566                  * lockp holds the list of locks held.
2567                  *
2568                  * Otherwise, increment the appropriate reacquire counters.
2569                  * If openclose lock is *held, then must reacquire reader
2570                  * lock before releasing the openclose lock.
2571                  * Do not drop the ARRAY_WRITER lock as we may not be able
2572                  * to reacquire it.
2573                  */
2574                 if (lockp) {
2575                         if (lockp->l_flags & MD_ARRAY_WRITER) {
2576                                 save_lock = MD_ARRAY_WRITER;
2577                                 lockp->l_flags &= ~MD_ARRAY_WRITER;
2578                         } else if (lockp->l_flags & MD_ARRAY_READER) {
2579                                 save_lock = MD_ARRAY_READER;
2580                                 lockp->l_flags &= ~MD_ARRAY_READER;
2581                         }
2582                         IOLOCK_RETURN_RELEASE(0, lockp);
2583                 } else {
2584                         if (flags & MD_STATE_OCHELD) {
2585                                 md_unit_writerexit(ui);
2586                                 (void) md_unit_readerlock(ui);
2587                                 md_unit_openclose_exit(ui);
2588                         } else {
2589                                 md_unit_writerexit(ui);
2590                         }
2591                 }
2592 
2593                 kresult = kmem_alloc(sizeof (md_mn_kresult_t), KM_SLEEP);
2594 sscs_msg:
2595                 rval = mdmn_ksend_message(setno, msgtype, msgflags, 0,
2596                     (char *)&stchmsg, sizeof (stchmsg), kresult);
2597 
2598                 if (!MDMN_KSEND_MSG_OK(rval, kresult)) {
2599                         mdmn_ksend_show_error(rval, kresult, "STATE UPDATE");
2600                         /* If we're shutting down already, pause things here. */
2601                         if (kresult->kmmr_comm_state == MDMNE_RPC_FAIL) {
2602                                 while (!md_mn_is_commd_present()) {
2603                                         delay(md_hz);
2604                                 }
2605                                 /*
2606                                  * commd is now available; retry the message
2607                                  * one time. If that fails we fall through and
2608                                  * panic as the system is in an unexpected state
2609                                  */
2610                                 if (nretries++ == 0)
2611                                         goto sscs_msg;
2612                         }
2613                         cmn_err(CE_PANIC,
2614                             "ksend_message failure: STATE_UPDATE");
2615                 }
2616                 kmem_free(kresult, sizeof (md_mn_kresult_t));
2617 
2618                 /* if dropped the lock previously, regain it */
2619                 if (lockp) {
2620                         IOLOCK_RETURN_REACQUIRE(lockp);
2621                         lockp->l_flags |= save_lock;
2622                 } else {
2623                         /*
2624                          * Reacquire dropped locks and update acquirecnts
2625                          * appropriately.
2626                          */
2627                         if (flags & MD_STATE_OCHELD) {
2628                                 /*
2629                                  * openclose also grabs readerlock.
2630                                  */
2631                                 (void) md_unit_openclose_enter(ui);
2632                                 md_unit_readerexit(ui);
2633                                 (void) md_unit_writerlock(ui);
2634                         } else {
2635                                 (void) md_unit_writerlock(ui);
2636                         }
2637                 }
2638 
2639                 ui->ui_tstate &= ~MD_ERR_PENDING;
2640         } else {
2641                 shared->ms_state = newstate;
2642                 uniqtime32(&shared->ms_timestamp);
2643 
2644                 if (newstate == CS_ERRED)
2645                         shared->ms_flags |= MDM_S_NOWRITE;
2646                 else
2647                         shared->ms_flags &= ~MDM_S_NOWRITE;
2648 
2649                 shared->ms_flags &= ~MDM_S_IOERR;
2650                 un->un_changecnt++;
2651                 shared->ms_lasterrcnt = un->un_changecnt;
2652 
2653                 mirror_set_sm_state(sm, smic, SMS_RUNNING, 0);
2654                 mirror_commit(un, SMI2BIT(smi), extras);
2655         }
2656 
2657         if ((origstate & CS_RESYNC) && (newstate & CS_OKAY)) {
2658                 /*
2659                  * Resetting the Last Erred state will recursively call back
2660                  * into this function (set_sm_comp_state) to update the state.
2661                  */
2662                 reset_lasterred(un, smi, extras, flags, lockp);
2663         }
2664 }
2665 
2666 static int
2667 find_another_logical(
2668         mm_unit_t               *un,
2669         mm_submirror_t          *esm,
2670         diskaddr_t              blk,
2671         u_longlong_t            cnt,
2672         int                     must_be_open,
2673         int                     state,
2674         int                     err_cnt)
2675 {
2676         u_longlong_t    cando;
2677         md_dev64_t      dev;
2678         md_m_shared_t   *s;
2679 
2680         esm->sm_state |= SMS_IGNORE;
2681         while (cnt != 0) {
2682                 u_longlong_t     mcnt;
2683 
2684                 mcnt = MIN(cnt, lbtodb(1024 * 1024 * 1024));    /* 1 Gig Blks */
2685 
2686                 dev = select_read_unit(un, blk, mcnt, &cando,
2687                     must_be_open, &s, NULL);
2688                 if (dev == (md_dev64_t)0)
2689                         break;
2690 
2691                 if ((state == CS_LAST_ERRED) &&
2692                     (s->ms_state == CS_LAST_ERRED) &&
2693                     (err_cnt > s->ms_lasterrcnt))
2694                         break;
2695 
2696                 cnt -= cando;
2697                 blk += cando;
2698         }
2699         esm->sm_state &= ~SMS_IGNORE;
2700         return (cnt != 0);
2701 }
2702 
2703 int
2704 mirror_other_sources(mm_unit_t *un, int smi, int ci, int must_be_open)
2705 {
2706         mm_submirror_t          *sm;
2707         mm_submirror_ic_t       *smic;
2708         size_t                  count;
2709         diskaddr_t              block;
2710         u_longlong_t            skip;
2711         u_longlong_t            size;
2712         md_dev64_t              dev;
2713         int                     cnt;
2714         md_m_shared_t           *s;
2715         int                     not_found;
2716 
2717         sm = &un->un_sm[smi];
2718         smic = &un->un_smic[smi];
2719         dev = sm->sm_dev;
2720 
2721         /*
2722          * Make sure every component of the submirror
2723          * has other sources.
2724          */
2725         if (ci < 0) {
2726                 /* Find the highest lasterrcnt */
2727                 cnt = (*(smic->sm_get_component_count))(dev, sm);
2728                 for (ci = 0; ci < cnt; ci++) {
2729                         not_found = mirror_other_sources(un, smi, ci,
2730                             must_be_open);
2731                         if (not_found)
2732                                 return (1);
2733                 }
2734                 return (0);
2735         }
2736 
2737         /*
2738          * Make sure this component has other sources
2739          */
2740         (void) (*(smic->sm_get_bcss))
2741             (dev, sm, ci, &block, &count, &skip, &size);
2742 
2743         if (count == 0)
2744                 return (1);
2745 
2746         s = (md_m_shared_t *)(*(smic->sm_shared_by_indx))(dev, sm, ci);
2747 
2748         while (count--) {
2749                 if (block >= un->c.un_total_blocks)
2750                         return (0);
2751 
2752                 if ((block + size) > un->c.un_total_blocks)
2753                         size = un->c.un_total_blocks - block;
2754 
2755                 not_found = find_another_logical(un, sm, block, size,
2756                     must_be_open, s->ms_state, s->ms_lasterrcnt);
2757                 if (not_found)
2758                         return (1);
2759 
2760                 block += size + skip;
2761         }
2762         return (0);
2763 }
2764 
2765 static void
2766 finish_error(md_mps_t *ps)
2767 {
2768         struct buf      *pb;
2769         mm_unit_t       *un;
2770         mdi_unit_t      *ui;
2771         uint_t          new_str_flags;
2772 
2773         pb = ps->ps_bp;
2774         un = ps->ps_un;
2775         ui = ps->ps_ui;
2776 
2777         /*
2778          * Must flag any error to the resync originator if we're performing
2779          * a Write-after-Read. This corresponds to an i/o error on a resync
2780          * target device and in this case we ought to abort the resync as there
2781          * is nothing that can be done to recover from this without operator
2782          * intervention. If we don't set the B_ERROR flag we will continue
2783          * reading from the mirror but won't write to the target (as it will
2784          * have been placed into an errored state).
2785          * To handle the case of multiple components within a submirror we only
2786          * set the B_ERROR bit if explicitly requested to via MD_MPS_FLAG_ERROR.
2787          * The originator of the resync read will cause this bit to be set if
2788          * the underlying component count is one for a submirror resync. All
2789          * other resync types will have the flag set as there is no underlying
2790          * resync which can be performed on a contained metadevice for these
2791          * resync types (optimized or component).
2792          */
2793 
2794         if (ps->ps_flags & MD_MPS_WRITE_AFTER_READ) {
2795                 if (ps->ps_flags & MD_MPS_FLAG_ERROR)
2796                         pb->b_flags |= B_ERROR;
2797                 md_kstat_done(ui, pb, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
2798                 MPS_FREE(mirror_parent_cache, ps);
2799                 md_unit_readerexit(ui);
2800                 md_biodone(pb);
2801                 return;
2802         }
2803         /*
2804          * Set the MD_IO_COUNTED flag as we are retrying the same I/O
2805          * operation therefore this I/O request has already been counted,
2806          * the I/O count variable will be decremented by mirror_done()'s
2807          * call to md_biodone().
2808          */
2809         if (ps->ps_changecnt != un->un_changecnt) {
2810                 new_str_flags = MD_STR_NOTTOP | MD_IO_COUNTED;
2811                 if (ps->ps_flags & MD_MPS_WOW)
2812                         new_str_flags |= MD_STR_WOW;
2813                 if (ps->ps_flags & MD_MPS_MAPPED)
2814                         new_str_flags |= MD_STR_MAPPED;
2815                 /*
2816                  * If this I/O request was a read that was part of a resync,
2817                  * set MD_STR_WAR for the retried read to ensure that the
2818                  * resync write (i.e. write-after-read) will be performed
2819                  */
2820                 if (ps->ps_flags & MD_MPS_RESYNC_READ)
2821                         new_str_flags |= MD_STR_WAR;
2822                 md_kstat_done(ui, pb, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
2823                 MPS_FREE(mirror_parent_cache, ps);
2824                 md_unit_readerexit(ui);
2825                 (void) md_mirror_strategy(pb, new_str_flags, NULL);
2826                 return;
2827         }
2828 
2829         pb->b_flags |= B_ERROR;
2830         md_kstat_done(ui, pb, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
2831         MPS_FREE(mirror_parent_cache, ps);
2832         md_unit_readerexit(ui);
2833         md_biodone(pb);
2834 }
2835 
2836 static void
2837 error_update_unit(md_mps_t *ps)
2838 {
2839         mm_unit_t               *un;
2840         mdi_unit_t              *ui;
2841         int                     smi;    /* sub mirror index */
2842         int                     ci;     /* errored component */
2843         set_t                   setno;
2844         uint_t                  flags;  /* for set_sm_comp_state() */
2845         uint_t                  hspflags; /* for check_comp_4_hotspares() */
2846 
2847         ui = ps->ps_ui;
2848         un = (mm_unit_t *)md_unit_writerlock(ui);
2849         setno = MD_UN2SET(un);
2850 
2851         /* All of these updates have to propagated in case of MN set */
2852         flags = MD_STATE_XMIT;
2853         hspflags = MD_HOTSPARE_XMIT;
2854 
2855         /* special treatment if we are called during updating watermarks */
2856         if (ps->ps_flags & MD_MPS_WMUPDATE) {
2857                 flags |= MD_STATE_WMUPDATE;
2858                 hspflags |= MD_HOTSPARE_WMUPDATE;
2859         }
2860         smi = 0;
2861         ci = 0;
2862         while (mirror_geterror(un, &smi, &ci, 1, 0) != 0) {
2863                 if (mirror_other_sources(un, smi, ci, 0) == 1) {
2864 
2865                         /* Never called from ioctl context, so (IOLOCK *)NULL */
2866                         set_sm_comp_state(un, smi, ci, CS_LAST_ERRED, 0, flags,
2867                             (IOLOCK *)NULL);
2868                         /*
2869                          * For a MN set, the NOTIFY is done when the state
2870                          * change is processed on each node
2871                          */
2872                         if (!MD_MNSET_SETNO(MD_UN2SET(un))) {
2873                                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_LASTERRED,
2874                                     SVM_TAG_METADEVICE, setno, MD_SID(un));
2875                         }
2876                         continue;
2877                 }
2878                 /* Never called from ioctl context, so (IOLOCK *)NULL */
2879                 set_sm_comp_state(un, smi, ci, CS_ERRED, 0, flags,
2880                     (IOLOCK *)NULL);
2881                 /*
2882                  * For a MN set, the NOTIFY is done when the state
2883                  * change is processed on each node
2884                  */
2885                 if (!MD_MNSET_SETNO(MD_UN2SET(un))) {
2886                         SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED,
2887                             SVM_TAG_METADEVICE, setno, MD_SID(un));
2888                 }
2889                 smi = 0;
2890                 ci = 0;
2891         }
2892 
2893         md_unit_writerexit(ui);
2894         if (MD_MNSET_SETNO(setno)) {
2895                 send_poke_hotspares(setno);
2896         } else {
2897                 (void) poke_hotspares();
2898         }
2899         (void) md_unit_readerlock(ui);
2900 
2901         finish_error(ps);
2902 }
2903 
2904 /*
2905  * When we have a B_FAILFAST IO error on a Last Erred component we need to
2906  * retry the IO without B_FAILFAST set so that we try to ensure that the
2907  * component "sees" each IO.
2908  */
2909 static void
2910 last_err_retry(md_mcs_t *cs)
2911 {
2912         struct buf      *cb;
2913         md_mps_t        *ps;
2914         uint_t          flags;
2915 
2916         cb = &cs->cs_buf;
2917         cb->b_flags &= ~B_FAILFAST;
2918 
2919         /* if we're panicing just let this I/O error out */
2920         if (panicstr) {
2921                 (void) mirror_done(cb);
2922                 return;
2923         }
2924 
2925         /* reissue the I/O */
2926 
2927         ps = cs->cs_ps;
2928 
2929         bioerror(cb, 0);
2930 
2931         mutex_enter(&ps->ps_mx);
2932 
2933         flags = MD_STR_NOTTOP;
2934         if (ps->ps_flags & MD_MPS_MAPPED)
2935                 flags |= MD_STR_MAPPED;
2936         if (ps->ps_flags & MD_MPS_NOBLOCK)
2937                 flags |= MD_NOBLOCK;
2938 
2939         mutex_exit(&ps->ps_mx);
2940 
2941         clear_retry_error(cb);
2942 
2943         cmn_err(CE_NOTE, "!md: %s: Last Erred, retry I/O without B_FAILFAST",
2944             md_shortname(getminor(cb->b_edev)));
2945 
2946         md_call_strategy(cb, flags, NULL);
2947 }
2948 
2949 static void
2950 mirror_error(md_mps_t *ps)
2951 {
2952         int             smi;    /* sub mirror index */
2953         int             ci;     /* errored component */
2954 
2955         if (panicstr) {
2956                 finish_error(ps);
2957                 return;
2958         }
2959 
2960         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
2961                 mirror_overlap_tree_remove(ps);
2962 
2963         smi = 0;
2964         ci = 0;
2965         if (mirror_geterror(ps->ps_un, &smi, &ci, 0, 0) != 0) {
2966                 md_unit_readerexit(ps->ps_ui);
2967                 daemon_request(&md_mstr_daemon, error_update_unit,
2968                     (daemon_queue_t *)ps, REQ_OLD);
2969                 return;
2970         }
2971 
2972         finish_error(ps);
2973 }
2974 
2975 static int
2976 copy_write_done(struct buf *cb)
2977 {
2978         md_mps_t        *ps;
2979         buf_t           *pb;
2980         char            *wowbuf;
2981         wowhdr_t        *wowhdr;
2982         ssize_t         wow_resid;
2983 
2984         /* get wowbuf ans save structure */
2985         wowbuf = cb->b_un.b_addr;
2986         wowhdr = WOWBUF_HDR(wowbuf);
2987         ps = wowhdr->wow_ps;
2988         pb = ps->ps_bp;
2989 
2990         /* Save error information, then free cb */
2991         if (cb->b_flags & B_ERROR)
2992                 pb->b_flags |= B_ERROR;
2993 
2994         if (cb->b_flags & B_REMAPPED)
2995                 bp_mapout(cb);
2996 
2997         freerbuf(cb);
2998 
2999         /* update residual and continue if needed */
3000         if ((pb->b_flags & B_ERROR) == 0) {
3001                 wow_resid = pb->b_bcount - wowhdr->wow_offset;
3002                 pb->b_resid = wow_resid;
3003                 if (wow_resid > 0)  {
3004                         daemon_request(&md_mstr_daemon, copy_write_cont,
3005                             (daemon_queue_t *)wowhdr, REQ_OLD);
3006                         return (1);
3007                 }
3008         }
3009 
3010         /* Write is complete, release resources. */
3011         kmem_cache_free(mirror_wowblk_cache, wowhdr);
3012         ASSERT(!(ps->ps_flags & MD_MPS_ON_OVERLAP));
3013         md_kstat_done(ps->ps_ui, pb, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
3014         MPS_FREE(mirror_parent_cache, ps);
3015         md_biodone(pb);
3016         return (0);
3017 }
3018 
3019 static void
3020 copy_write_cont(wowhdr_t *wowhdr)
3021 {
3022         buf_t           *pb;
3023         buf_t           *cb;
3024         char            *wowbuf;
3025         int             wow_offset;
3026         size_t          wow_resid;
3027         diskaddr_t      wow_blkno;
3028 
3029         wowbuf = WOWHDR_BUF(wowhdr);
3030         pb = wowhdr->wow_ps->ps_bp;
3031 
3032         /* get data on current location */
3033         wow_offset = wowhdr->wow_offset;
3034         wow_resid = pb->b_bcount - wow_offset;
3035         wow_blkno = pb->b_lblkno + lbtodb(wow_offset);
3036 
3037         /* setup child buffer */
3038         cb = getrbuf(KM_SLEEP);
3039         cb->b_flags = B_WRITE;
3040         cb->b_edev = pb->b_edev;
3041         cb->b_un.b_addr = wowbuf;    /* change to point at WOWBUF */
3042         cb->b_bufsize = md_wowbuf_size; /* change to wowbuf_size */
3043         cb->b_iodone = copy_write_done;
3044         cb->b_bcount = MIN(md_wowbuf_size, wow_resid);
3045         cb->b_lblkno = wow_blkno;
3046 
3047         /* move offset to next section */
3048         wowhdr->wow_offset += cb->b_bcount;
3049 
3050         /* copy and setup write for current section */
3051         bcopy(&pb->b_un.b_addr[wow_offset], wowbuf, cb->b_bcount);
3052 
3053         /* do it */
3054         /*
3055          * Do not set the MD_IO_COUNTED flag as this is a new I/O request
3056          * that handles the WOW condition. The resultant increment on the
3057          * I/O count variable is cleared by copy_write_done()'s call to
3058          * md_biodone().
3059          */
3060         (void) md_mirror_strategy(cb, MD_STR_NOTTOP | MD_STR_WOW
3061             | MD_STR_MAPPED, NULL);
3062 }
3063 
3064 static void
3065 md_mirror_copy_write(md_mps_t *ps)
3066 {
3067         wowhdr_t        *wowhdr;
3068 
3069         wowhdr = kmem_cache_alloc(mirror_wowblk_cache, MD_ALLOCFLAGS);
3070         mirror_wowblk_init(wowhdr);
3071         wowhdr->wow_ps = ps;
3072         wowhdr->wow_offset = 0;
3073         copy_write_cont(wowhdr);
3074 }
3075 
3076 static void
3077 handle_wow(md_mps_t *ps)
3078 {
3079         buf_t           *pb;
3080 
3081         pb = ps->ps_bp;
3082 
3083         bp_mapin(pb);
3084 
3085         md_mirror_wow_cnt++;
3086         if (!(pb->b_flags & B_PHYS) && (md_mirror_wow_flg & WOW_LOGIT)) {
3087                 cmn_err(CE_NOTE,
3088                     "md: %s, blk %lld, cnt %ld: Write on write %d occurred",
3089                     md_shortname(getminor(pb->b_edev)),
3090                     (longlong_t)pb->b_lblkno, pb->b_bcount, md_mirror_wow_cnt);
3091         }
3092 
3093         /*
3094          * Set the MD_IO_COUNTED flag as we are retrying the same I/O
3095          * operation therefore this I/O request has already been counted,
3096          * the I/O count variable will be decremented by mirror_done()'s
3097          * call to md_biodone().
3098          */
3099         if (md_mirror_wow_flg & WOW_NOCOPY)
3100                 (void) md_mirror_strategy(pb, MD_STR_NOTTOP | MD_STR_WOW |
3101                     MD_STR_MAPPED | MD_IO_COUNTED, ps);
3102         else
3103                 md_mirror_copy_write(ps);
3104 }
3105 
3106 /*
3107  * Return true if the specified submirror is either in the Last Erred
3108  * state or is transitioning into the Last Erred state.
3109  */
3110 static bool_t
3111 submirror_is_lasterred(mm_unit_t *un, int smi)
3112 {
3113         mm_submirror_t          *sm;
3114         mm_submirror_ic_t       *smic;
3115         md_m_shared_t           *shared;
3116         int                     ci;
3117         int                     compcnt;
3118 
3119         sm = &un->un_sm[smi];
3120         smic = &un->un_smic[smi];
3121 
3122         compcnt = (*(smic->sm_get_component_count)) (sm->sm_dev, un);
3123         for (ci = 0; ci < compcnt; ci++) {
3124                 shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
3125                     (sm->sm_dev, sm, ci);
3126 
3127                 if (shared->ms_state == CS_LAST_ERRED)
3128                         return (B_TRUE);
3129 
3130                 /*
3131                  * It is not currently Last Erred, check if entering Last Erred.
3132                  */
3133                 if ((shared->ms_flags & MDM_S_IOERR) &&
3134                     ((shared->ms_state == CS_OKAY) ||
3135                     (shared->ms_state == CS_RESYNC))) {
3136                         if (mirror_other_sources(un, smi, ci, 0) == 1)
3137                                 return (B_TRUE);
3138                 }
3139         }
3140 
3141         return (B_FALSE);
3142 }
3143 
3144 
3145 static int
3146 mirror_done(struct buf *cb)
3147 {
3148         md_mps_t        *ps;
3149         md_mcs_t        *cs;
3150 
3151         /*LINTED*/
3152         cs = (md_mcs_t *)((caddr_t)cb - md_mirror_mcs_buf_off);
3153         ps = cs->cs_ps;
3154 
3155         mutex_enter(&ps->ps_mx);
3156 
3157         /* check if we need to retry an errored failfast I/O */
3158         if (cb->b_flags & B_ERROR) {
3159                 struct buf *pb = ps->ps_bp;
3160 
3161                 if (cb->b_flags & B_FAILFAST) {
3162                         int             i;
3163                         mm_unit_t       *un = ps->ps_un;
3164 
3165                         for (i = 0; i < NMIRROR; i++) {
3166                                 if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE))
3167                                         continue;
3168 
3169                                 if (cb->b_edev ==
3170                                     md_dev64_to_dev(un->un_sm[i].sm_dev)) {
3171 
3172                                         /*
3173                                          * This is the submirror that had the
3174                                          * error.  Check if it is Last Erred.
3175                                          */
3176                                         if (submirror_is_lasterred(un, i)) {
3177                                                 daemon_queue_t *dqp;
3178 
3179                                                 mutex_exit(&ps->ps_mx);
3180                                                 dqp = (daemon_queue_t *)cs;
3181                                                 dqp->dq_prev = NULL;
3182                                                 dqp->dq_next = NULL;
3183                                                 daemon_request(&md_done_daemon,
3184                                                     last_err_retry, dqp,
3185                                                     REQ_OLD);
3186                                                 return (1);
3187                                         }
3188                                         break;
3189                                 }
3190                         }
3191                 }
3192 
3193                 /* continue to process the buf without doing a retry */
3194                 ps->ps_flags |= MD_MPS_ERROR;
3195                 pb->b_error = cb->b_error;
3196         }
3197 
3198         return (mirror_done_common(cb));
3199 }
3200 
3201 /*
3202  * Split from the original mirror_done function so we can handle bufs after a
3203  * retry.
3204  * ps->ps_mx is already held in the caller of this function and the cb error
3205  * has already been checked and handled in the caller.
3206  */
3207 static int
3208 mirror_done_common(struct buf *cb)
3209 {
3210         struct buf      *pb;
3211         mm_unit_t       *un;
3212         mdi_unit_t      *ui;
3213         md_mps_t        *ps;
3214         md_mcs_t        *cs;
3215         size_t          end_rr, start_rr, current_rr;
3216 
3217         /*LINTED*/
3218         cs = (md_mcs_t *)((caddr_t)cb - md_mirror_mcs_buf_off);
3219         ps = cs->cs_ps;
3220         pb = ps->ps_bp;
3221 
3222         if (cb->b_flags & B_REMAPPED)
3223                 bp_mapout(cb);
3224 
3225         ps->ps_frags--;
3226         if (ps->ps_frags != 0) {
3227                 mutex_exit(&ps->ps_mx);
3228                 kmem_cache_free(mirror_child_cache, cs);
3229                 return (1);
3230         }
3231         un = ps->ps_un;
3232         ui = ps->ps_ui;
3233 
3234         /*
3235          * Do not update outstanding_writes if we're running with ABR
3236          * set for this mirror or the write() was issued with MD_STR_ABR set.
3237          * Also a resync initiated write() has no outstanding_writes update
3238          * either.
3239          */
3240         if (((cb->b_flags & B_READ) == 0) &&
3241             (un->un_nsm >= 2) &&
3242             (ps->ps_call == NULL) &&
3243             !((ui->ui_tstate & MD_ABR_CAP) || (ps->ps_flags & MD_MPS_ABR)) &&
3244             !(ps->ps_flags & MD_MPS_WRITE_AFTER_READ)) {
3245                 BLK_TO_RR(end_rr, ps->ps_lastblk, un);
3246                 BLK_TO_RR(start_rr, ps->ps_firstblk, un);
3247                 mutex_enter(&un->un_resync_mx);
3248                 for (current_rr = start_rr; current_rr <= end_rr; current_rr++)
3249                         un->un_outstanding_writes[current_rr]--;
3250                 mutex_exit(&un->un_resync_mx);
3251         }
3252         kmem_cache_free(mirror_child_cache, cs);
3253         mutex_exit(&ps->ps_mx);
3254 
3255         if (ps->ps_call != NULL) {
3256                 daemon_request(&md_done_daemon, ps->ps_call,
3257                     (daemon_queue_t *)ps, REQ_OLD);
3258                 return (1);
3259         }
3260 
3261         if ((ps->ps_flags & MD_MPS_ERROR)) {
3262                 daemon_request(&md_done_daemon, mirror_error,
3263                     (daemon_queue_t *)ps, REQ_OLD);
3264                 return (1);
3265         }
3266 
3267         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
3268                 mirror_overlap_tree_remove(ps);
3269 
3270         /*
3271          * Handle Write-on-Write problem.
3272          * Skip In case of Raw and Direct I/O as they are
3273          * handled earlier.
3274          *
3275          */
3276         if (!(md_mirror_wow_flg & WOW_DISABLE) &&
3277             !(pb->b_flags & B_READ) &&
3278             !(ps->ps_flags & MD_MPS_WOW) &&
3279             !(pb->b_flags & B_PHYS) &&
3280             any_pages_dirty(pb)) {
3281                 md_unit_readerexit(ps->ps_ui);
3282                 daemon_request(&md_mstr_daemon, handle_wow,
3283                     (daemon_queue_t *)ps, REQ_OLD);
3284                 return (1);
3285         }
3286 
3287         md_kstat_done(ui, pb, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
3288         MPS_FREE(mirror_parent_cache, ps);
3289         md_unit_readerexit(ui);
3290         md_biodone(pb);
3291         return (0);
3292 }
3293 
3294 /*
3295  * Clear error state in submirror component if the retry worked after
3296  * a failfast error.
3297  */
3298 static void
3299 clear_retry_error(struct buf *cb)
3300 {
3301         int                     smi;
3302         md_mcs_t                *cs;
3303         mm_unit_t               *un;
3304         mdi_unit_t              *ui_sm;
3305         mm_submirror_t          *sm;
3306         mm_submirror_ic_t       *smic;
3307         u_longlong_t            cnt;
3308         md_m_shared_t           *shared;
3309 
3310         /*LINTED*/
3311         cs = (md_mcs_t *)((caddr_t)cb - md_mirror_mcs_buf_off);
3312         un = cs->cs_ps->ps_un;
3313 
3314         for (smi = 0; smi < NMIRROR; smi++) {
3315                 if (!SMS_BY_INDEX_IS(un, smi, SMS_INUSE))
3316                         continue;
3317 
3318                 if (cb->b_edev == md_dev64_to_dev(un->un_sm[smi].sm_dev))
3319                         break;
3320         }
3321 
3322         if (smi >= NMIRROR)
3323                 return;
3324 
3325         sm = &un->un_sm[smi];
3326         smic = &un->un_smic[smi];
3327         cnt = cb->b_bcount;
3328 
3329         ui_sm = MDI_UNIT(getminor(cb->b_edev));
3330         (void) md_unit_writerlock(ui_sm);
3331 
3332         shared = (md_m_shared_t *)(*(smic->sm_shared_by_blk))(sm->sm_dev, sm,
3333             cb->b_blkno, &cnt);
3334 
3335         if (shared->ms_flags & MDM_S_IOERR) {
3336                 shared->ms_flags &= ~MDM_S_IOERR;
3337 
3338         } else {
3339                 /* the buf spans components and the first one is not erred */
3340                 int     cnt;
3341                 int     i;
3342 
3343                 cnt = (*(smic->sm_get_component_count))(sm->sm_dev, un);
3344                 for (i = 0; i < cnt; i++) {
3345                         shared = (md_m_shared_t *)(*(smic->sm_shared_by_indx))
3346                             (sm->sm_dev, sm, i);
3347 
3348                         if (shared->ms_flags & MDM_S_IOERR &&
3349                             shared->ms_state == CS_OKAY) {
3350 
3351                                 shared->ms_flags &= ~MDM_S_IOERR;
3352                                 break;
3353                         }
3354                 }
3355         }
3356 
3357         md_unit_writerexit(ui_sm);
3358 }
3359 
3360 static size_t
3361 mirror_map_read(
3362         md_mps_t *ps,
3363         md_mcs_t *cs,
3364         diskaddr_t blkno,
3365         u_longlong_t    count
3366 )
3367 {
3368         mm_unit_t       *un;
3369         buf_t           *bp;
3370         u_longlong_t    cando;
3371 
3372         bp = &cs->cs_buf;
3373         un = ps->ps_un;
3374 
3375         bp->b_lblkno = blkno;
3376         if (fast_select_read_unit(ps, cs) == 0) {
3377                 bp->b_bcount = ldbtob(count);
3378                 return (0);
3379         }
3380         bp->b_edev = md_dev64_to_dev(select_read_unit(un, blkno,
3381             count, &cando, 0, NULL, cs));
3382         bp->b_bcount = ldbtob(cando);
3383         if (count != cando)
3384                 return (cando);
3385         return (0);
3386 }
3387 
3388 static void
3389 write_after_read(md_mps_t *ps)
3390 {
3391         struct buf      *pb;
3392         int             flags;
3393 
3394         if (ps->ps_flags & MD_MPS_ERROR) {
3395                 mirror_error(ps);
3396                 return;
3397         }
3398 
3399         pb = ps->ps_bp;
3400         md_kstat_done(ps->ps_ui, pb, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
3401         ps->ps_call = NULL;
3402         ps->ps_flags |= MD_MPS_WRITE_AFTER_READ;
3403         flags = MD_STR_NOTTOP | MD_STR_WAR;
3404         if (ps->ps_flags & MD_MPS_MAPPED)
3405                 flags |= MD_STR_MAPPED;
3406         if (ps->ps_flags & MD_MPS_NOBLOCK)
3407                 flags |= MD_NOBLOCK;
3408         if (ps->ps_flags & MD_MPS_DIRTY_RD)
3409                 flags |= MD_STR_DIRTY_RD;
3410         (void) mirror_write_strategy(pb, flags, ps);
3411 }
3412 
3413 static void
3414 continue_serial(md_mps_t *ps)
3415 {
3416         md_mcs_t        *cs;
3417         buf_t           *cb;
3418         mm_unit_t       *un;
3419         int             flags;
3420 
3421         un = ps->ps_un;
3422         cs = kmem_cache_alloc(mirror_child_cache, MD_ALLOCFLAGS);
3423         mirror_child_init(cs);
3424         cb = &cs->cs_buf;
3425         ps->ps_call = NULL;
3426         ps->ps_frags = 1;
3427         (void) mirror_map_write(un, cs, ps, 0);
3428         flags = MD_STR_NOTTOP;
3429         if (ps->ps_flags & MD_MPS_MAPPED)
3430                 flags |= MD_STR_MAPPED;
3431         md_call_strategy(cb, flags, NULL);
3432 }
3433 
3434 static int
3435 mirror_map_write(mm_unit_t *un, md_mcs_t *cs, md_mps_t *ps, int war)
3436 {
3437         int i;
3438         dev_t           dev;    /* needed for bioclone, so not md_dev64_t */
3439         buf_t           *cb;
3440         buf_t           *pb;
3441         diskaddr_t      blkno;
3442         size_t          bcount;
3443         off_t           offset;
3444 
3445         pb = ps->ps_bp;
3446         cb = &cs->cs_buf;
3447         cs->cs_ps = ps;
3448 
3449         i = md_find_nth_unit(ps->ps_writable_sm, ps->ps_current_sm);
3450 
3451         dev = md_dev64_to_dev(un->un_sm[i].sm_dev);
3452 
3453         blkno = pb->b_lblkno;
3454         bcount = pb->b_bcount;
3455         offset = 0;
3456         if (war && (blkno == 0) && (un->c.un_flag & MD_LABELED)) {
3457                 blkno = DK_LABEL_LOC + 1;
3458                 /*
3459                  * This handles the case where we're requesting
3460                  * a write to block 0 on a label partition
3461                  * and the request size was smaller than the
3462                  * size of the label.  If this is the case
3463                  * then we'll return -1.  Failure to do so will
3464                  * either cause the calling thread to hang due to
3465                  * an ssd bug, or worse if the bcount were allowed
3466                  * to go negative (ie large).
3467                  */
3468                 if (bcount <= DEV_BSIZE*(DK_LABEL_LOC + 1))
3469                         return (-1);
3470                 bcount -= (DEV_BSIZE*(DK_LABEL_LOC + 1));
3471                 offset = (DEV_BSIZE*(DK_LABEL_LOC + 1));
3472         }
3473 
3474         cb = md_bioclone(pb, offset, bcount, dev, blkno, mirror_done,
3475             cb, KM_NOSLEEP);
3476         if (war)
3477                 cb->b_flags = (cb->b_flags & ~B_READ) | B_WRITE;
3478 
3479         /*
3480          * If the submirror is in the erred stated, check if any component is
3481          * in the Last Erred state.  If so, we don't want to use the B_FAILFAST
3482          * flag on the IO.
3483          *
3484          * Provide a fast path for the non-erred case (which should be the
3485          * normal case).
3486          */
3487         if (un->un_sm[i].sm_flags & MD_SM_FAILFAST) {
3488                 if (un->un_sm[i].sm_state & SMS_COMP_ERRED) {
3489                         mm_submirror_t          *sm;
3490                         mm_submirror_ic_t       *smic;
3491                         int                     ci;
3492                         int                     compcnt;
3493 
3494                         sm = &un->un_sm[i];
3495                         smic = &un->un_smic[i];
3496 
3497                         compcnt = (*(smic->sm_get_component_count))
3498                             (sm->sm_dev, un);
3499                         for (ci = 0; ci < compcnt; ci++) {
3500                                 md_m_shared_t   *shared;
3501 
3502                                 shared = (md_m_shared_t *)
3503                                     (*(smic->sm_shared_by_indx))(sm->sm_dev,
3504                                     sm, ci);
3505 
3506                                 if (shared->ms_state == CS_LAST_ERRED)
3507                                         break;
3508                         }
3509                         if (ci >= compcnt)
3510                                 cb->b_flags |= B_FAILFAST;
3511 
3512                 } else {
3513                         cb->b_flags |= B_FAILFAST;
3514                 }
3515         }
3516 
3517         ps->ps_current_sm++;
3518         if (ps->ps_current_sm != ps->ps_active_cnt) {
3519                 if (un->un_write_option == WR_SERIAL) {
3520                         ps->ps_call = continue_serial;
3521                         return (0);
3522                 }
3523                 return (1);
3524         }
3525         return (0);
3526 }
3527 
3528 /*
3529  * directed_read_done:
3530  * ------------------
3531  * Completion routine called when a DMR request has been returned from the
3532  * underlying driver. Wake-up the original ioctl() and return the data to
3533  * the user.
3534  */
3535 static void
3536 directed_read_done(md_mps_t *ps)
3537 {
3538         mm_unit_t       *un;
3539         mdi_unit_t      *ui;
3540 
3541         un = ps->ps_un;
3542         ui = ps->ps_ui;
3543 
3544         md_unit_readerexit(ui);
3545         md_kstat_done(ui, ps->ps_bp, (ps->ps_flags & MD_MPS_WRITE_AFTER_READ));
3546         ps->ps_call = NULL;
3547 
3548         mutex_enter(&un->un_dmr_mx);
3549         cv_signal(&un->un_dmr_cv);
3550         mutex_exit(&un->un_dmr_mx);
3551 
3552         /* release the parent structure */
3553         kmem_cache_free(mirror_parent_cache, ps);
3554 }
3555 
3556 /*
3557  * daemon_io:
3558  * ------------
3559  * Called to issue a mirror_write_strategy() or mirror_read_strategy
3560  * call from a blockable context. NOTE: no mutex can be held on entry to this
3561  * routine
3562  */
3563 static void
3564 daemon_io(daemon_queue_t *dq)
3565 {
3566         md_mps_t        *ps = (md_mps_t *)dq;
3567         int             flag = MD_STR_NOTTOP;
3568         buf_t           *pb = ps->ps_bp;
3569 
3570         if (ps->ps_flags & MD_MPS_MAPPED)
3571                 flag |= MD_STR_MAPPED;
3572         if (ps->ps_flags & MD_MPS_WOW)
3573                 flag |= MD_STR_WOW;
3574         if (ps->ps_flags & MD_MPS_WRITE_AFTER_READ)
3575                 flag |= MD_STR_WAR;
3576         if (ps->ps_flags & MD_MPS_ABR)
3577                 flag |= MD_STR_ABR;
3578         if (ps->ps_flags & MD_MPS_BLOCKABLE_IO)
3579                 flag |= MD_STR_BLOCK_OK;
3580 
3581         /*
3582          * If this is a resync read, ie MD_STR_DIRTY_RD not set, set
3583          * MD_STR_WAR before calling mirror_read_strategy
3584          */
3585         if (pb->b_flags & B_READ) {
3586                 if (!(ps->ps_flags & MD_MPS_DIRTY_RD))
3587                         flag |= MD_STR_WAR;
3588                 mirror_read_strategy(pb, flag, ps);
3589         } else
3590                 mirror_write_strategy(pb, flag, ps);
3591 }
3592 
3593 /*
3594  * update_resync:
3595  * -------------
3596  * Called to update the in-core version of the resync record with the latest
3597  * version that was committed to disk when the previous mirror owner
3598  * relinquished ownership. This call is likely to block as we must hold-off
3599  * any current resync processing that may be occurring.
3600  * On completion of the resync record update we issue the mirror_write_strategy
3601  * call to complete the i/o that first started this sequence. To remove a race
3602  * condition between a new write() request which is submitted and the resync
3603  * record update we acquire the writerlock. This will hold off all i/o to the
3604  * mirror until the resync update has completed.
3605  * NOTE: no mutex can be held on entry to this routine
3606  */
3607 static void
3608 update_resync(daemon_queue_t *dq)
3609 {
3610         md_mps_t        *ps = (md_mps_t *)dq;
3611         buf_t           *pb = ps->ps_bp;
3612         mdi_unit_t      *ui = ps->ps_ui;
3613         mm_unit_t       *un = MD_UNIT(ui->ui_link.ln_id);
3614         set_t           setno;
3615         int             restart_resync;
3616 
3617         mutex_enter(&un->un_rrp_inflight_mx);
3618         (void) md_unit_writerlock(ui);
3619         ps->ps_un = un;
3620         setno = MD_MIN2SET(getminor(pb->b_edev));
3621         if (mddb_reread_rr(setno, un->un_rr_dirty_recid) == 0) {
3622                 /*
3623                  * Synchronize our in-core view of what regions need to be
3624                  * resync'd with the on-disk version.
3625                  */
3626                 mirror_copy_rr(howmany(un->un_rrd_num, NBBY), un->un_resync_bm,
3627                     un->un_dirty_bm);
3628 
3629                 /* Region dirty map is now up to date */
3630         }
3631         restart_resync = (un->un_rs_thread_flags & MD_RI_BLOCK_OWNER) ? 1 : 0;
3632         md_unit_writerexit(ui);
3633         mutex_exit(&un->un_rrp_inflight_mx);
3634 
3635         /* Restart the resync thread if it was previously blocked */
3636         if (restart_resync) {
3637                 mutex_enter(&un->un_rs_thread_mx);
3638                 un->un_rs_thread_flags &= ~MD_RI_BLOCK_OWNER;
3639                 cv_signal(&un->un_rs_thread_cv);
3640                 mutex_exit(&un->un_rs_thread_mx);
3641         }
3642         /* Continue with original deferred i/o */
3643         daemon_io(dq);
3644 }
3645 
3646 /*
3647  * owner_timeout:
3648  * -------------
3649  * Called if the original mdmn_ksend_message() failed and the request is to be
3650  * retried. Reattempt the original ownership change.
3651  *
3652  * NOTE: called at interrupt context (see timeout(9f)).
3653  */
3654 static void
3655 owner_timeout(void *arg)
3656 {
3657         daemon_queue_t  *dq = (daemon_queue_t *)arg;
3658 
3659         daemon_request(&md_mirror_daemon, become_owner, dq, REQ_OLD);
3660 }
3661 
3662 /*
3663  * become_owner:
3664  * ------------
3665  * Called to issue RPC request to become the owner of the mirror
3666  * associated with this i/o request. We assume that the ownership request
3667  * is synchronous, so if it succeeds we will issue the request via
3668  * mirror_write_strategy().
3669  * If multiple i/o's are outstanding we will be called from the mirror_daemon
3670  * service thread.
3671  * NOTE: no mutex should be held on entry to this routine.
3672  */
3673 static void
3674 become_owner(daemon_queue_t *dq)
3675 {
3676         md_mps_t        *ps = (md_mps_t *)dq;
3677         mm_unit_t       *un = ps->ps_un;
3678         buf_t           *pb = ps->ps_bp;
3679         set_t           setno;
3680         md_mn_kresult_t *kres;
3681         int             msg_flags = md_mirror_msg_flags;
3682         md_mps_t        *ps1;
3683 
3684         ASSERT(dq->dq_next == NULL && dq->dq_prev == NULL);
3685 
3686         /*
3687          * If we're already the mirror owner we do not need to send a message
3688          * but can simply process the i/o request immediately.
3689          * If we've already sent the request to become owner we requeue the
3690          * request as we're waiting for the synchronous ownership message to
3691          * be processed.
3692          */
3693         if (MD_MN_MIRROR_OWNER(un)) {
3694                 /*
3695                  * As the strategy() call will potentially block we need to
3696                  * punt this to a separate thread and complete this request
3697                  * as quickly as possible. Note: if we're a read request
3698                  * this must be a resync, we cannot afford to be queued
3699                  * behind any intervening i/o requests. In this case we put the
3700                  * request on the md_mirror_rs_daemon queue.
3701                  */
3702                 if (pb->b_flags & B_READ) {
3703                         daemon_request(&md_mirror_rs_daemon, daemon_io, dq,
3704                             REQ_OLD);
3705                 } else {
3706                         daemon_request(&md_mirror_io_daemon, daemon_io, dq,
3707                             REQ_OLD);
3708                 }
3709         } else {
3710                 mutex_enter(&un->un_owner_mx);
3711                 if ((un->un_owner_state & MM_MN_OWNER_SENT) == 0) {
3712                         md_mn_req_owner_t       *msg;
3713                         int                     rval = 0;
3714 
3715                         /*
3716                          * Check to see that we haven't exceeded the maximum
3717                          * retry count. If we have we fail the i/o as the
3718                          * comms mechanism has become wedged beyond recovery.
3719                          */
3720                         if (dq->qlen++ >= MD_OWNER_RETRIES) {
3721                                 mutex_exit(&un->un_owner_mx);
3722                                 cmn_err(CE_WARN,
3723                                     "md_mirror: Request exhausted ownership "
3724                                     "retry limit of %d attempts", dq->qlen);
3725                                 pb->b_error = EIO;
3726                                 pb->b_flags |= B_ERROR;
3727                                 pb->b_resid = pb->b_bcount;
3728                                 kmem_cache_free(mirror_parent_cache, ps);
3729                                 md_biodone(pb);
3730                                 return;
3731                         }
3732 
3733                         /*
3734                          * Issue request to change ownership. The call is
3735                          * synchronous so when it returns we can complete the
3736                          * i/o (if successful), or enqueue it again so that
3737                          * the operation will be retried.
3738                          */
3739                         un->un_owner_state |= MM_MN_OWNER_SENT;
3740                         mutex_exit(&un->un_owner_mx);
3741 
3742                         msg = kmem_zalloc(sizeof (md_mn_req_owner_t), KM_SLEEP);
3743                         setno = MD_MIN2SET(getminor(pb->b_edev));
3744                         msg->mnum = MD_SID(un);
3745                         msg->owner = md_mn_mynode_id;
3746                         msg_flags |= MD_MSGF_NO_LOG;
3747                         /*
3748                          * If this IO is triggered by updating a watermark,
3749                          * it might be issued by the creation of a softpartition
3750                          * while the commd subsystem is suspended.
3751                          * We don't want this message to block.
3752                          */
3753                         if (ps->ps_flags & MD_MPS_WMUPDATE) {
3754                                 msg_flags |= MD_MSGF_OVERRIDE_SUSPEND;
3755                         }
3756 
3757                         kres = kmem_alloc(sizeof (md_mn_kresult_t), KM_SLEEP);
3758                         rval = mdmn_ksend_message(setno,
3759                             MD_MN_MSG_REQUIRE_OWNER, msg_flags, 0,
3760                             (char *)msg, sizeof (md_mn_req_owner_t), kres);
3761 
3762                         kmem_free(msg, sizeof (md_mn_req_owner_t));
3763 
3764                         if (MDMN_KSEND_MSG_OK(rval, kres)) {
3765                                 dq->qlen = 0;
3766                                 /*
3767                                  * Successfully changed owner, reread the
3768                                  * resync record so that we have a valid idea of
3769                                  * any previously committed incomplete write()s.
3770                                  * NOTE: As we need to acquire the resync mutex
3771                                  * this may block, so we defer it to a separate
3772                                  * thread handler. This makes us (effectively)
3773                                  * non-blocking once the ownership message
3774                                  * handling has completed.
3775                                  */
3776                                 mutex_enter(&un->un_owner_mx);
3777                                 if (un->un_owner_state & MM_MN_BECOME_OWNER) {
3778                                         un->un_mirror_owner = md_mn_mynode_id;
3779                                         /* Sets owner of un_rr_dirty record */
3780                                         if (un->un_rr_dirty_recid)
3781                                                 (void) mddb_setowner(
3782                                                     un->un_rr_dirty_recid,
3783                                                     md_mn_mynode_id);
3784                                         un->un_owner_state &=
3785                                             ~MM_MN_BECOME_OWNER;
3786                                         /*
3787                                          * Release the block on the current
3788                                          * resync region if it is blocked
3789                                          */
3790                                         ps1 = un->un_rs_prev_overlap;
3791                                         if ((ps1 != NULL) &&
3792                                             (ps1->ps_flags & MD_MPS_ON_OVERLAP))
3793                                                 mirror_overlap_tree_remove(ps1);
3794                                         mutex_exit(&un->un_owner_mx);
3795 
3796                                         /*
3797                                          * If we're a read, this must be a
3798                                          * resync request, issue
3799                                          * the i/o request on the
3800                                          * md_mirror_rs_daemon queue. This is
3801                                          * to avoid a deadlock between the
3802                                          * resync_unit thread and
3803                                          * subsequent i/o requests that may
3804                                          * block on the resync region.
3805                                          */
3806                                         if (pb->b_flags & B_READ) {
3807                                                 daemon_request(
3808                                                     &md_mirror_rs_daemon,
3809                                                     update_resync, dq, REQ_OLD);
3810                                         } else {
3811                                                 daemon_request(
3812                                                     &md_mirror_io_daemon,
3813                                                     update_resync, dq, REQ_OLD);
3814                                         }
3815                                         kmem_free(kres,
3816                                             sizeof (md_mn_kresult_t));
3817                                         return;
3818                                 } else {
3819                                         /*
3820                                          * Some other node has beaten us to
3821                                          * obtain ownership. We need to
3822                                          * reschedule our ownership request
3823                                          */
3824                                         mutex_exit(&un->un_owner_mx);
3825                                 }
3826                         } else {
3827                                 mdmn_ksend_show_error(rval, kres,
3828                                     "MD_MN_MSG_REQUIRE_OWNER");
3829                                 /*
3830                                  * Message transport failure is handled by the
3831                                  * comms layer. If the ownership change request
3832                                  * does not succeed we need to flag the error to
3833                                  * the initiator of the i/o. This is handled by
3834                                  * the retry logic above. As the request failed
3835                                  * we do not know _who_ the owner of the mirror
3836                                  * currently is. We reset our idea of the owner
3837                                  * to None so that any further write()s will
3838                                  * attempt to become the owner again. This stops
3839                                  * multiple nodes writing to the same mirror
3840                                  * simultaneously.
3841                                  */
3842                                 mutex_enter(&un->un_owner_mx);
3843                                 un->un_owner_state &=
3844                                     ~(MM_MN_OWNER_SENT|MM_MN_BECOME_OWNER);
3845                                 un->un_mirror_owner = MD_MN_MIRROR_UNOWNED;
3846                                 mutex_exit(&un->un_owner_mx);
3847                         }
3848                         kmem_free(kres, sizeof (md_mn_kresult_t));
3849                 } else
3850                         mutex_exit(&un->un_owner_mx);
3851 
3852                 /*
3853                  * Re-enqueue this request on the deferred i/o list. Delay the
3854                  * request for md_mirror_owner_to usecs to stop thrashing.
3855                  */
3856                 (void) timeout(owner_timeout, dq,
3857                     drv_usectohz(md_mirror_owner_to));
3858         }
3859 }
3860 
3861 static void
3862 mirror_write_strategy(buf_t *pb, int flag, void *private)
3863 {
3864         md_mps_t        *ps;
3865         md_mcs_t        *cs;
3866         int             more;
3867         mm_unit_t       *un;
3868         mdi_unit_t      *ui;
3869         buf_t           *cb;            /* child buf pointer */
3870         set_t           setno;
3871         int             rs_on_overlap = 0;
3872 
3873         ui = MDI_UNIT(getminor(pb->b_edev));
3874         un = (mm_unit_t *)MD_UNIT(getminor(pb->b_edev));
3875 
3876 
3877         md_kstat_waitq_enter(ui);
3878 
3879         /*
3880          * If a state change is in progress for this mirror in a MN set,
3881          * suspend all non-resync writes until the state change is complete.
3882          * The objective of this suspend is to ensure that it is not
3883          * possible for one node to read data from a submirror that another node
3884          * has not written to because of the state change. Therefore we
3885          * suspend all writes until the state change has been made. As it is
3886          * not possible to read from the target of a resync, there is no need
3887          * to suspend resync writes.
3888          * Note that we only block here if the caller can handle a busy-wait.
3889          * The MD_STR_BLOCK_OK flag is set for daemon_io originated i/o only.
3890          */
3891 
3892         if (!(flag & MD_STR_WAR)) {
3893                 if (flag & MD_STR_BLOCK_OK) {
3894                         mutex_enter(&un->un_suspend_wr_mx);
3895                         while (un->un_suspend_wr_flag) {
3896                                 cv_wait(&un->un_suspend_wr_cv,
3897                                     &un->un_suspend_wr_mx);
3898                         }
3899                         mutex_exit(&un->un_suspend_wr_mx);
3900                 }
3901                 (void) md_unit_readerlock(ui);
3902         }
3903 
3904         if (!(flag & MD_STR_NOTTOP)) {
3905                 if (md_checkbuf(ui, (md_unit_t *)un, pb)) {
3906                         md_kstat_waitq_exit(ui);
3907                         return;
3908                 }
3909         }
3910 
3911         setno = MD_MIN2SET(getminor(pb->b_edev));
3912 
3913         /* If an ABR write has been requested, set MD_STR_ABR flag */
3914         if (MD_MNSET_SETNO(setno) && (pb->b_flags & B_ABRWRITE))
3915                 flag |= MD_STR_ABR;
3916 
3917         if (private == NULL) {
3918                 ps = kmem_cache_alloc(mirror_parent_cache, MD_ALLOCFLAGS);
3919                 mirror_parent_init(ps);
3920         } else {
3921                 ps = private;
3922                 private = NULL;
3923         }
3924         if (flag & MD_STR_MAPPED)
3925                 ps->ps_flags |= MD_MPS_MAPPED;
3926 
3927         if (flag & MD_STR_WOW)
3928                 ps->ps_flags |= MD_MPS_WOW;
3929 
3930         if (flag & MD_STR_ABR)
3931                 ps->ps_flags |= MD_MPS_ABR;
3932 
3933         if (flag & MD_STR_WMUPDATE)
3934                 ps->ps_flags |= MD_MPS_WMUPDATE;
3935 
3936         /*
3937          * Save essential information from the original buffhdr
3938          * in the md_save structure.
3939          */
3940         ps->ps_un = un;
3941         ps->ps_ui = ui;
3942         ps->ps_bp = pb;
3943         ps->ps_addr = pb->b_un.b_addr;
3944         ps->ps_firstblk = pb->b_lblkno;
3945         ps->ps_lastblk = pb->b_lblkno + lbtodb(pb->b_bcount) - 1;
3946         ps->ps_changecnt = un->un_changecnt;
3947 
3948         /*
3949          * Check for suspended writes here. This is where we can defer the
3950          * write request to the daemon_io queue which will then call us with
3951          * the MD_STR_BLOCK_OK flag set and we'll busy-wait (if necessary) at
3952          * the top of this routine.
3953          */
3954         if (!(flag & MD_STR_WAR) && !(flag & MD_STR_BLOCK_OK)) {
3955                 mutex_enter(&un->un_suspend_wr_mx);
3956                 if (un->un_suspend_wr_flag) {
3957                         ps->ps_flags |= MD_MPS_BLOCKABLE_IO;
3958                         mutex_exit(&un->un_suspend_wr_mx);
3959                         md_unit_readerexit(ui);
3960                         daemon_request(&md_mirror_daemon, daemon_io,
3961                             (daemon_queue_t *)ps, REQ_OLD);
3962                         return;
3963                 }
3964                 mutex_exit(&un->un_suspend_wr_mx);
3965         }
3966 
3967         /*
3968          * If not MN owner and this is an ABR write, make sure the current
3969          * resync region is in the overlaps tree
3970          */
3971         mutex_enter(&un->un_owner_mx);
3972         if (MD_MNSET_SETNO(setno) && (!(MD_MN_MIRROR_OWNER(un))) &&
3973             ((ui->ui_tstate & MD_ABR_CAP) || (flag & MD_STR_ABR))) {
3974                 md_mps_t        *ps1;
3975                 /* Block the current resync region, if not already blocked */
3976                 ps1 = un->un_rs_prev_overlap;
3977 
3978                 if ((ps1 != NULL) && ((ps1->ps_firstblk != 0) ||
3979                     (ps1->ps_lastblk != 0))) {
3980                         /* Drop locks to avoid deadlock */
3981                         mutex_exit(&un->un_owner_mx);
3982                         md_unit_readerexit(ui);
3983                         wait_for_overlaps(ps1, MD_OVERLAP_ALLOW_REPEAT);
3984                         rs_on_overlap = 1;
3985                         (void) md_unit_readerlock(ui);
3986                         mutex_enter(&un->un_owner_mx);
3987                         /*
3988                          * Check to see if we have obtained ownership
3989                          * while waiting for overlaps. If we have, remove
3990                          * the resync_region entry from the overlap tree
3991                          */
3992                         if (MD_MN_MIRROR_OWNER(un) &&
3993                             (ps1->ps_flags & MD_MPS_ON_OVERLAP)) {
3994                                 mirror_overlap_tree_remove(ps1);
3995                                 rs_on_overlap = 0;
3996                         }
3997                 }
3998         }
3999         mutex_exit(&un->un_owner_mx);
4000 
4001 
4002         /*
4003          * following keep write after read from writing to the
4004          * source in the case where it all came from one place
4005          */
4006         if (flag & MD_STR_WAR) {
4007                 int     abort_write = 0;
4008                 /*
4009                  * We are perfoming a write-after-read. This is either as a
4010                  * result of a resync read or as a result of a read in a
4011                  * dirty resync region when the optimized resync is not
4012                  * complete. If in a MN set and a resync generated i/o,
4013                  * if the current block is not in the current
4014                  * resync region terminate the write as another node must have
4015                  * completed this resync region
4016                  */
4017                 if ((MD_MNSET_SETNO(MD_UN2SET(un))) &&
4018                     (!(flag & MD_STR_DIRTY_RD))) {
4019                         if (!IN_RESYNC_REGION(un, ps))
4020                                 abort_write = 1;
4021                 }
4022                 if ((select_write_after_read_units(un, ps) == 0) ||
4023                     (abort_write)) {
4024 #ifdef DEBUG
4025                         if (mirror_debug_flag)
4026                                 printf("Abort resync write on %x, block %lld\n",
4027                                     MD_SID(un), ps->ps_firstblk);
4028 #endif
4029                         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4030                                 mirror_overlap_tree_remove(ps);
4031                         kmem_cache_free(mirror_parent_cache, ps);
4032                         md_kstat_waitq_exit(ui);
4033                         md_unit_readerexit(ui);
4034                         md_biodone(pb);
4035                         return;
4036                 }
4037         } else {
4038                 select_write_units(un, ps);
4039 
4040                 /* Drop readerlock to avoid deadlock */
4041                 md_unit_readerexit(ui);
4042                 wait_for_overlaps(ps, MD_OVERLAP_NO_REPEAT);
4043                 un = md_unit_readerlock(ui);
4044                 /*
4045                  * For a MN set with an ABR write, if we are now the
4046                  * owner and we have a resync region in the overlap
4047                  * tree, remove the entry from overlaps and retry the write.
4048                  */
4049 
4050                 if (MD_MNSET_SETNO(setno) &&
4051                     ((ui->ui_tstate & MD_ABR_CAP) || (flag & MD_STR_ABR))) {
4052                         mutex_enter(&un->un_owner_mx);
4053                         if (((MD_MN_MIRROR_OWNER(un))) && rs_on_overlap) {
4054                                 mirror_overlap_tree_remove(ps);
4055                                 md_kstat_waitq_exit(ui);
4056                                 mutex_exit(&un->un_owner_mx);
4057                                 md_unit_readerexit(ui);
4058                                 daemon_request(&md_mirror_daemon, daemon_io,
4059                                     (daemon_queue_t *)ps, REQ_OLD);
4060                                 return;
4061                         }
4062                         mutex_exit(&un->un_owner_mx);
4063                 }
4064         }
4065 
4066         /*
4067          * For Multinode mirrors with no owner and a Resync Region (not ABR)
4068          * we need to become the mirror owner before continuing with the
4069          * write(). For ABR mirrors we check that we 'own' the resync if
4070          * we're in write-after-read mode. We do this _after_ ensuring that
4071          * there are no overlaps to ensure that once we know that we are
4072          * the owner, the readerlock will not be released until the write is
4073          * complete. As a change of ownership in a MN set requires the
4074          * writerlock, this ensures that ownership cannot be changed until
4075          * the write is complete.
4076          */
4077         if (MD_MNSET_SETNO(setno) && (!((ui->ui_tstate & MD_ABR_CAP) ||
4078             (flag & MD_STR_ABR)) || (flag & MD_STR_WAR))) {
4079                 if (MD_MN_NO_MIRROR_OWNER(un))  {
4080                         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4081                                 mirror_overlap_tree_remove(ps);
4082                         md_kstat_waitq_exit(ui);
4083                         ASSERT(!(flag & MD_STR_WAR));
4084                         md_unit_readerexit(ui);
4085                         daemon_request(&md_mirror_daemon, become_owner,
4086                             (daemon_queue_t *)ps, REQ_OLD);
4087                         return;
4088                 }
4089         }
4090 
4091         /*
4092          * Mark resync region if mirror has a Resync Region _and_ we are not
4093          * a resync initiated write(). Don't mark region if we're flagged as
4094          * an ABR write.
4095          */
4096         if (!((ui->ui_tstate & MD_ABR_CAP) || (flag & MD_STR_ABR)) &&
4097             !(flag & MD_STR_WAR)) {
4098                 if (mirror_mark_resync_region(un, ps->ps_firstblk,
4099                     ps->ps_lastblk, md_mn_mynode_id)) {
4100                         pb->b_flags |= B_ERROR;
4101                         pb->b_resid = pb->b_bcount;
4102                         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4103                                 mirror_overlap_tree_remove(ps);
4104                         kmem_cache_free(mirror_parent_cache, ps);
4105                         md_kstat_waitq_exit(ui);
4106                         md_unit_readerexit(ui);
4107                         md_biodone(pb);
4108                         return;
4109                 }
4110         }
4111 
4112         ps->ps_childbflags = pb->b_flags | B_WRITE;
4113         ps->ps_childbflags &= ~B_READ;
4114         if (flag & MD_STR_MAPPED)
4115                 ps->ps_childbflags &= ~B_PAGEIO;
4116 
4117         if (!(flag & MD_STR_NOTTOP) && panicstr)
4118                 /* Disable WOW and don't free ps */
4119                 ps->ps_flags |= (MD_MPS_WOW|MD_MPS_DONTFREE);
4120 
4121         md_kstat_waitq_to_runq(ui);
4122 
4123         /*
4124          * Treat Raw and Direct I/O as Write-on-Write always
4125          */
4126 
4127         if (!(md_mirror_wow_flg & WOW_DISABLE) &&
4128             (md_mirror_wow_flg & WOW_PHYS_ENABLE) &&
4129             (pb->b_flags & B_PHYS) &&
4130             !(ps->ps_flags & MD_MPS_WOW)) {
4131                 if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4132                         mirror_overlap_tree_remove(ps);
4133                 md_unit_readerexit(ui);
4134                 daemon_request(&md_mstr_daemon, handle_wow,
4135                     (daemon_queue_t *)ps, REQ_OLD);
4136                 return;
4137         }
4138 
4139         ps->ps_frags = 1;
4140         do {
4141                 cs = kmem_cache_alloc(mirror_child_cache, MD_ALLOCFLAGS);
4142                 mirror_child_init(cs);
4143                 cb = &cs->cs_buf;
4144                 more = mirror_map_write(un, cs, ps, (flag & MD_STR_WAR));
4145 
4146                 /*
4147                  * This handles the case where we're requesting
4148                  * a write to block 0 on a label partition.  (more < 0)
4149                  * means that the request size was smaller than the
4150                  * size of the label.  If so this request is done.
4151                  */
4152                 if (more < 0) {
4153                         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4154                                 mirror_overlap_tree_remove(ps);
4155                         md_kstat_runq_exit(ui);
4156                         kmem_cache_free(mirror_child_cache, cs);
4157                         kmem_cache_free(mirror_parent_cache, ps);
4158                         md_unit_readerexit(ui);
4159                         md_biodone(pb);
4160                         return;
4161                 }
4162                 if (more) {
4163                         mutex_enter(&ps->ps_mx);
4164                         ps->ps_frags++;
4165                         mutex_exit(&ps->ps_mx);
4166                 }
4167                 md_call_strategy(cb, flag, private);
4168         } while (more);
4169 
4170         if (!(flag & MD_STR_NOTTOP) && panicstr) {
4171                 while (!(ps->ps_flags & MD_MPS_DONE)) {
4172                         md_daemon(1, &md_done_daemon);
4173                         drv_usecwait(10);
4174                 }
4175                 kmem_cache_free(mirror_parent_cache, ps);
4176         }
4177 }
4178 
4179 static void
4180 mirror_read_strategy(buf_t *pb, int flag, void *private)
4181 {
4182         md_mps_t        *ps;
4183         md_mcs_t        *cs;
4184         size_t          more;
4185         mm_unit_t       *un;
4186         mdi_unit_t      *ui;
4187         size_t          current_count;
4188         diskaddr_t      current_blkno;
4189         off_t           current_offset;
4190         buf_t           *cb;            /* child buf pointer */
4191         set_t           setno;
4192 
4193         ui = MDI_UNIT(getminor(pb->b_edev));
4194 
4195         md_kstat_waitq_enter(ui);
4196 
4197         un = (mm_unit_t *)md_unit_readerlock(ui);
4198 
4199         if (!(flag & MD_STR_NOTTOP)) {
4200                 if (md_checkbuf(ui, (md_unit_t *)un, pb)) {
4201                         md_kstat_waitq_exit(ui);
4202                         return;
4203                 }
4204         }
4205 
4206         if (private == NULL) {
4207                 ps = kmem_cache_alloc(mirror_parent_cache, MD_ALLOCFLAGS);
4208                 mirror_parent_init(ps);
4209         } else {
4210                 ps = private;
4211                 private = NULL;
4212         }
4213 
4214         if (flag & MD_STR_MAPPED)
4215                 ps->ps_flags |= MD_MPS_MAPPED;
4216         if (flag & MD_NOBLOCK)
4217                 ps->ps_flags |= MD_MPS_NOBLOCK;
4218         if (flag & MD_STR_WMUPDATE)
4219                 ps->ps_flags |= MD_MPS_WMUPDATE;
4220 
4221         /*
4222          * Check to see if this is a DMR driven read. If so we need to use the
4223          * specified side (in un->un_dmr_last_read) for the source of the data.
4224          */
4225         if (flag & MD_STR_DMR)
4226                 ps->ps_flags |= MD_MPS_DMR;
4227 
4228         /*
4229          * Save essential information from the original buffhdr
4230          * in the md_save structure.
4231          */
4232         ps->ps_un = un;
4233         ps->ps_ui = ui;
4234         ps->ps_bp = pb;
4235         ps->ps_addr = pb->b_un.b_addr;
4236         ps->ps_firstblk = pb->b_lblkno;
4237         ps->ps_lastblk = pb->b_lblkno + lbtodb(pb->b_bcount) - 1;
4238         ps->ps_changecnt = un->un_changecnt;
4239 
4240         current_count = btodb(pb->b_bcount);
4241         current_blkno = pb->b_lblkno;
4242         current_offset = 0;
4243 
4244         /*
4245          * If flag has MD_STR_WAR set this means that the read is issued by a
4246          * resync thread which may or may not be an optimised resync.
4247          *
4248          * If MD_UN_OPT_NOT_DONE is set this means that the optimized resync
4249          * code has not completed; either a resync has not started since snarf,
4250          * or there is an optimized resync in progress.
4251          *
4252          * We need to generate a write after this read in the following two
4253          * cases,
4254          *
4255          * 1. Any Resync-Generated read
4256          *
4257          * 2. Any read to a DIRTY REGION if there is an optimized resync
4258          *    pending or in progress.
4259          *
4260          * The write after read is done in these cases to ensure that all sides
4261          * of the mirror are in sync with the read data and that it is not
4262          * possible for an application to read the same block multiple times
4263          * and get different data.
4264          *
4265          * This would be possible if the block was in a dirty region.
4266          *
4267          * If we're performing a directed read we don't write the data out as
4268          * the application is responsible for restoring the mirror to a known
4269          * state.
4270          */
4271         if (((MD_STATUS(un) & MD_UN_OPT_NOT_DONE) || (flag & MD_STR_WAR)) &&
4272             !(flag & MD_STR_DMR)) {
4273                 size_t  start_rr, i, end_rr;
4274                 int     region_dirty = 1;
4275 
4276                 /*
4277                  * We enter here under three circumstances,
4278                  *
4279                  * MD_UN_OPT_NOT_DONE   MD_STR_WAR
4280                  * 0                    1
4281                  * 1                    0
4282                  * 1                    1
4283                  *
4284                  * To be optimal we only care to explicitly check for dirty
4285                  * regions in the second case since if MD_STR_WAR is set we
4286                  * always do the write after read.
4287                  */
4288                 if (!(flag & MD_STR_WAR)) {
4289                         BLK_TO_RR(end_rr, ps->ps_lastblk, un);
4290                         BLK_TO_RR(start_rr, ps->ps_firstblk, un);
4291 
4292                         for (i = start_rr; i <= end_rr; i++)
4293                                 if ((region_dirty = IS_KEEPDIRTY(i, un)) != 0)
4294                                         break;
4295                 }
4296 
4297                 if ((region_dirty) &&
4298                     !(md_get_setstatus(MD_UN2SET(un)) & MD_SET_STALE)) {
4299                         ps->ps_call = write_after_read;
4300                         /*
4301                          * Mark this as a RESYNC_READ in ps_flags.
4302                          * This is used if the read fails during a
4303                          * resync of a 3-way mirror to ensure that
4304                          * the retried read to the remaining
4305                          * good submirror has MD_STR_WAR set. This
4306                          * is needed to ensure that the resync write
4307                          * (write-after-read) takes place.
4308                          */
4309                         ps->ps_flags |= MD_MPS_RESYNC_READ;
4310 
4311                         /*
4312                          * If MD_STR_FLAG_ERR is set in the flags we
4313                          * set MD_MPS_FLAG_ERROR so that an error on the resync
4314                          * write (issued by write_after_read) will be flagged
4315                          * to the biowait'ing resync thread. This allows us to
4316                          * avoid issuing further resync requests to a device
4317                          * that has had a write failure.
4318                          */
4319                         if (flag & MD_STR_FLAG_ERR)
4320                                 ps->ps_flags |= MD_MPS_FLAG_ERROR;
4321 
4322                         setno = MD_UN2SET(un);
4323                         /*
4324                          * Drop the readerlock to avoid
4325                          * deadlock
4326                          */
4327                         md_unit_readerexit(ui);
4328                         wait_for_overlaps(ps, MD_OVERLAP_NO_REPEAT);
4329                         un = md_unit_readerlock(ui);
4330                         /*
4331                          * Ensure that we are owner
4332                          */
4333                         if (MD_MNSET_SETNO(setno)) {
4334                                 /*
4335                                  * For a non-resync read that requires a
4336                                  * write-after-read to be done, set a flag
4337                                  * in the parent structure, so that the
4338                                  * write_strategy routine can omit the
4339                                  * test that the write is still within the
4340                                  * resync region
4341                                  */
4342                                 if (!(flag & MD_STR_WAR))
4343                                         ps->ps_flags |= MD_MPS_DIRTY_RD;
4344 
4345                                 /*
4346                                  * Before reading the buffer, see if
4347                                  * there is an owner.
4348                                  */
4349                                 if (MD_MN_NO_MIRROR_OWNER(un))  {
4350                                         ps->ps_call = NULL;
4351                                         mirror_overlap_tree_remove(ps);
4352                                         md_kstat_waitq_exit(ui);
4353                                         md_unit_readerexit(ui);
4354                                         daemon_request(
4355                                             &md_mirror_daemon,
4356                                             become_owner,
4357                                             (daemon_queue_t *)ps,
4358                                             REQ_OLD);
4359                                         return;
4360                                 }
4361                                 /*
4362                                  * For a resync read, check to see if I/O is
4363                                  * outside of the current resync region, or
4364                                  * the resync has finished. If so
4365                                  * just terminate the I/O
4366                                  */
4367                                 if ((flag & MD_STR_WAR) &&
4368                                     (!(un->c.un_status & MD_UN_WAR) ||
4369                                     (!IN_RESYNC_REGION(un, ps)))) {
4370 #ifdef DEBUG
4371                                         if (mirror_debug_flag)
4372                                                 printf("Abort resync read "
4373                                                     "%x: %lld\n",
4374                                                     MD_SID(un),
4375                                                     ps->ps_firstblk);
4376 #endif
4377                                         mirror_overlap_tree_remove(ps);
4378                                         kmem_cache_free(mirror_parent_cache,
4379                                             ps);
4380                                         md_kstat_waitq_exit(ui);
4381                                         md_unit_readerexit(ui);
4382                                         md_biodone(pb);
4383                                         return;
4384                                 }
4385                         }
4386                 }
4387         }
4388 
4389         if (flag & MD_STR_DMR) {
4390                 ps->ps_call = directed_read_done;
4391         }
4392 
4393         if (!(flag & MD_STR_NOTTOP) && panicstr)
4394                 ps->ps_flags |= MD_MPS_DONTFREE;
4395 
4396         md_kstat_waitq_to_runq(ui);
4397 
4398         ps->ps_frags++;
4399         do {
4400                 cs = kmem_cache_alloc(mirror_child_cache, MD_ALLOCFLAGS);
4401                 mirror_child_init(cs);
4402                 cb = &cs->cs_buf;
4403                 cs->cs_ps = ps;
4404 
4405                 cb = md_bioclone(pb, current_offset, current_count, NODEV,
4406                     current_blkno, mirror_done, cb, KM_NOSLEEP);
4407 
4408                 more = mirror_map_read(ps, cs, current_blkno,
4409                     (u_longlong_t)current_count);
4410                 if (more) {
4411                         mutex_enter(&ps->ps_mx);
4412                         ps->ps_frags++;
4413                         mutex_exit(&ps->ps_mx);
4414                 }
4415 
4416                 /*
4417                  * Do these calculations now,
4418                  *  so that we pickup a valid b_bcount from the chld_bp.
4419                  */
4420                 current_count -= more;
4421                 current_offset += cb->b_bcount;
4422                 current_blkno +=  more;
4423                 md_call_strategy(cb, flag, private);
4424         } while (more);
4425 
4426         if (!(flag & MD_STR_NOTTOP) && panicstr) {
4427                 while (!(ps->ps_flags & MD_MPS_DONE)) {
4428                         md_daemon(1, &md_done_daemon);
4429                         drv_usecwait(10);
4430                 }
4431                 kmem_cache_free(mirror_parent_cache, ps);
4432         }
4433 }
4434 
4435 void
4436 md_mirror_strategy(buf_t *bp, int flag, void *private)
4437 {
4438         set_t   setno = MD_MIN2SET(getminor(bp->b_edev));
4439 
4440         /*
4441          * When doing IO to a multi owner meta device, check if set is halted.
4442          * We do this check without the needed lock held, for performance
4443          * reasons.
4444          * If an IO just slips through while the set is locked via an
4445          * MD_MN_SUSPEND_SET, we don't care about it.
4446          * Only check for suspension if we are a top-level i/o request
4447          * (MD_STR_NOTTOP is cleared in 'flag').
4448          */
4449         if ((md_set[setno].s_status & (MD_SET_HALTED | MD_SET_MNSET)) ==
4450             (MD_SET_HALTED | MD_SET_MNSET)) {
4451                 if ((flag & MD_STR_NOTTOP) == 0) {
4452                         mutex_enter(&md_mx);
4453                         /* Here we loop until the set is no longer halted */
4454                         while (md_set[setno].s_status & MD_SET_HALTED) {
4455                                 cv_wait(&md_cv, &md_mx);
4456                         }
4457                         mutex_exit(&md_mx);
4458                 }
4459         }
4460 
4461         if ((flag & MD_IO_COUNTED) == 0) {
4462                 if ((flag & MD_NOBLOCK) == 0) {
4463                         if (md_inc_iocount(setno) != 0) {
4464                                 bp->b_flags |= B_ERROR;
4465                                 bp->b_error = ENXIO;
4466                                 bp->b_resid = bp->b_bcount;
4467                                 biodone(bp);
4468                                 return;
4469                         }
4470                 } else {
4471                         md_inc_iocount_noblock(setno);
4472                 }
4473         }
4474 
4475         if (bp->b_flags & B_READ)
4476                 mirror_read_strategy(bp, flag, private);
4477         else
4478                 mirror_write_strategy(bp, flag, private);
4479 }
4480 
4481 /*
4482  * mirror_directed_read:
4483  * --------------------
4484  * Entry-point for the DKIOCDMR ioctl. We issue a read to a specified sub-mirror
4485  * so that the application can determine what (if any) resync needs to be
4486  * performed. The data is copied out to the user-supplied buffer.
4487  *
4488  * Parameters:
4489  *      mdev    - dev_t for the mirror device
4490  *      vdr     - directed read parameters specifying location and submirror
4491  *                to perform the read from
4492  *      mode    - used to ddi_copyout() any resulting data from the read
4493  *
4494  * Returns:
4495  *      0       success
4496  *      !0      error code
4497  *              EINVAL - invalid request format
4498  */
4499 int
4500 mirror_directed_read(dev_t mdev, vol_directed_rd_t *vdr, int mode)
4501 {
4502         buf_t           *bp;
4503         minor_t         mnum = getminor(mdev);
4504         mdi_unit_t      *ui = MDI_UNIT(mnum);
4505         mm_unit_t       *un;
4506         mm_submirror_t  *sm;
4507         char            *sm_nm;
4508         uint_t          next_side;
4509         void            *kbuffer;
4510 
4511         if (ui == NULL)
4512                 return (ENXIO);
4513 
4514         if (!(vdr->vdr_flags & DKV_DMR_NEXT_SIDE)) {
4515                 return (EINVAL);
4516         }
4517 
4518         /* Check for aligned block access. We disallow non-aligned requests. */
4519         if (vdr->vdr_offset % DEV_BSIZE) {
4520                 return (EINVAL);
4521         }
4522 
4523         /*
4524          * Allocate kernel buffer for target of read(). If we had a reliable
4525          * (sorry functional) DDI this wouldn't be needed.
4526          */
4527         kbuffer = kmem_alloc(vdr->vdr_nbytes, KM_NOSLEEP);
4528         if (kbuffer == NULL) {
4529                 cmn_err(CE_WARN, "mirror_directed_read: couldn't allocate %lx"
4530                     " bytes\n", vdr->vdr_nbytes);
4531                 return (ENOMEM);
4532         }
4533 
4534         bp = getrbuf(KM_SLEEP);
4535 
4536         bp->b_un.b_addr = kbuffer;
4537         bp->b_flags = B_READ;
4538         bp->b_bcount = vdr->vdr_nbytes;
4539         bp->b_lblkno = lbtodb(vdr->vdr_offset);
4540         bp->b_edev = mdev;
4541 
4542         un = md_unit_readerlock(ui);
4543 
4544         /*
4545          * If DKV_SIDE_INIT is set we need to determine the first available
4546          * side to start reading from. If it isn't set we increment to the
4547          * next readable submirror.
4548          * If there are no readable submirrors we error out with DKV_DMR_ERROR.
4549          * Note: we check for a readable submirror on completion of the i/o so
4550          * we should _always_ have one available. If this becomes unavailable
4551          * we have missed the 'DKV_DMR_DONE' opportunity. This could happen if
4552          * a metadetach is made between the completion of one DKIOCDMR ioctl
4553          * and the start of the next (i.e. a sys-admin 'accident' occurred).
4554          * The chance of this is small, but not non-existent.
4555          */
4556         if (vdr->vdr_side == DKV_SIDE_INIT) {
4557                 next_side = 0;
4558         } else {
4559                 next_side = vdr->vdr_side + 1;
4560         }
4561         while ((next_side < NMIRROR) &&
4562             !SUBMIRROR_IS_READABLE(un, next_side))
4563                 next_side++;
4564         if (next_side >= NMIRROR) {
4565                 vdr->vdr_flags |= DKV_DMR_ERROR;
4566                 freerbuf(bp);
4567                 vdr->vdr_bytesread = 0;
4568                 md_unit_readerexit(ui);
4569                 return (0);
4570         }
4571 
4572         /* Set the side to read from */
4573         un->un_dmr_last_read = next_side;
4574 
4575         md_unit_readerexit(ui);
4576 
4577         /*
4578          * Save timestamp for verification purposes. Can be read by debugger
4579          * to verify that this ioctl has been executed and to find the number
4580          * of DMR reads and the time of the last DMR read.
4581          */
4582         uniqtime(&mirror_dmr_stats.dmr_timestamp);
4583         mirror_dmr_stats.dmr_count++;
4584 
4585         /* Issue READ request and wait for completion */
4586         mirror_read_strategy(bp, MD_STR_DMR|MD_NOBLOCK|MD_STR_NOTTOP, NULL);
4587 
4588         mutex_enter(&un->un_dmr_mx);
4589         cv_wait(&un->un_dmr_cv, &un->un_dmr_mx);
4590         mutex_exit(&un->un_dmr_mx);
4591 
4592         /*
4593          * Check to see if we encountered an error during the read. If so we
4594          * can make no guarantee about any possibly returned data.
4595          */
4596         if ((bp->b_flags & B_ERROR) == 0) {
4597                 vdr->vdr_flags &= ~DKV_DMR_ERROR;
4598                 if (bp->b_resid) {
4599                         vdr->vdr_flags |= DKV_DMR_SHORT;
4600                         vdr->vdr_bytesread = vdr->vdr_nbytes - bp->b_resid;
4601                 } else {
4602                         vdr->vdr_flags |= DKV_DMR_SUCCESS;
4603                         vdr->vdr_bytesread = vdr->vdr_nbytes;
4604                 }
4605                 /* Copy the data read back out to the user supplied buffer */
4606                 if (ddi_copyout(kbuffer, vdr->vdr_data, vdr->vdr_bytesread,
4607                     mode)) {
4608                         kmem_free(kbuffer, vdr->vdr_nbytes);
4609                         return (EFAULT);
4610                 }
4611 
4612         } else {
4613                 /* Error out with DKV_DMR_ERROR */
4614                 vdr->vdr_flags |= DKV_DMR_ERROR;
4615                 vdr->vdr_flags &= ~(DKV_DMR_SUCCESS|DKV_DMR_SHORT|DKV_DMR_DONE);
4616         }
4617         /*
4618          * Update the DMR parameters with the side and name of submirror that
4619          * we have just read from (un->un_dmr_last_read)
4620          */
4621         un = md_unit_readerlock(ui);
4622 
4623         vdr->vdr_side = un->un_dmr_last_read;
4624         sm = &un->un_sm[un->un_dmr_last_read];
4625         sm_nm = md_shortname(md_getminor(sm->sm_dev));
4626 
4627         (void) strncpy(vdr->vdr_side_name, sm_nm, sizeof (vdr->vdr_side_name));
4628 
4629         /*
4630          * Determine if we've completed the read cycle. This is true iff the
4631          * next computed submirror (side) equals or exceeds NMIRROR. We cannot
4632          * use un_nsm as we need to handle a sparse array of submirrors (which
4633          * can occur if a submirror is metadetached).
4634          */
4635         next_side = un->un_dmr_last_read + 1;
4636         while ((next_side < NMIRROR) &&
4637             !SUBMIRROR_IS_READABLE(un, next_side))
4638                 next_side++;
4639         if (next_side >= NMIRROR) {
4640                 /* We've finished */
4641                 vdr->vdr_flags |= DKV_DMR_DONE;
4642         }
4643 
4644         md_unit_readerexit(ui);
4645         freerbuf(bp);
4646         kmem_free(kbuffer, vdr->vdr_nbytes);
4647 
4648         return (0);
4649 }
4650 
4651 /*
4652  * mirror_resync_message:
4653  * ---------------------
4654  * Handle the multi-node resync messages that keep all nodes within a given
4655  * disk-set in sync with their view of a mirror's resync status.
4656  *
4657  * The message types dealt with are:
4658  * MD_MN_MSG_RESYNC_STARTING    - start a resync thread for a unit
4659  * MD_MN_MSG_RESYNC_NEXT        - specified next region to be resynced
4660  * MD_MN_MSG_RESYNC_FINISH      - stop the resync thread for a unit
4661  * MD_MN_MSG_RESYNC_PHASE_DONE  - end of a resync phase, opt, submirror or comp
4662  *
4663  * Returns:
4664  *      0       Success
4665  *      >0   Failure error number
4666  */
4667 int
4668 mirror_resync_message(md_mn_rs_params_t *p, IOLOCK *lockp)
4669 {
4670         mdi_unit_t              *ui;
4671         mm_unit_t               *un;
4672         set_t                   setno;
4673         int                     is_ABR;
4674         int                     smi;
4675         int                     ci;
4676         sm_state_t              state;
4677         int                     broke_out;
4678         mm_submirror_t          *sm;
4679         mm_submirror_ic_t       *smic;
4680         md_m_shared_t           *shared;
4681         md_error_t              mde = mdnullerror;
4682         md_mps_t                *ps;
4683         int                     rs_active;
4684         int                     rr, rr_start, rr_end;
4685 
4686         /* Check that the given device is part of a multi-node set */
4687         setno = MD_MIN2SET(p->mnum);
4688         if (setno >= md_nsets) {
4689                 return (ENXIO);
4690         }
4691         if (!MD_MNSET_SETNO(setno)) {
4692                 return (EINVAL);
4693         }
4694 
4695         if ((un = mirror_getun(p->mnum, &p->mde, NO_LOCK, NULL)) == NULL)
4696                 return (EINVAL);
4697         if ((ui = MDI_UNIT(p->mnum)) == NULL)
4698                 return (EINVAL);
4699         is_ABR = (ui->ui_tstate & MD_ABR_CAP);
4700 
4701         /* Obtain the current resync status */
4702         (void) md_ioctl_readerlock(lockp, ui);
4703         rs_active = (MD_STATUS(un) & MD_UN_RESYNC_ACTIVE) ? 1 : 0;
4704         md_ioctl_readerexit(lockp);
4705 
4706         switch ((md_mn_msgtype_t)p->msg_type) {
4707         case MD_MN_MSG_RESYNC_STARTING:
4708                 /* Start the resync thread for the mirror */
4709                 (void) mirror_resync_unit(p->mnum, NULL, &p->mde, lockp);
4710                 break;
4711 
4712         case MD_MN_MSG_RESYNC_NEXT:
4713                 /*
4714                  * We have to release any previously marked overlap regions
4715                  * so that i/o can resume. Then we need to block the region
4716                  * from [rs_start..rs_start+rs_size) * so that no i/o is issued.
4717                  * Update un_rs_resync_done and un_rs_resync_2_do.
4718                  */
4719                 (void) md_ioctl_readerlock(lockp, ui);
4720                 /*
4721                  * Ignore the message if there is no active resync thread or
4722                  * if it is for a resync type that we have already completed.
4723                  * un_resync_completed is set to the last resync completed
4724                  * when processing a PHASE_DONE message.
4725                  */
4726                 if (!rs_active || (p->rs_type == un->un_resync_completed))
4727                         break;
4728                 /*
4729                  * If this message is for the same resync and is for an earlier
4730                  * resync region, just ignore it. This can only occur if this
4731                  * node has progressed on to the next resync region before
4732                  * we receive this message. This can occur if the class for
4733                  * this message is busy and the originator has to retry thus
4734                  * allowing this node to move onto the next resync_region.
4735                  */
4736                 if ((p->rs_type == un->un_rs_type) &&
4737                     (p->rs_start < un->un_resync_startbl))
4738                         break;
4739                 ps = un->un_rs_prev_overlap;
4740 
4741                 /* Allocate previous overlap reference if needed */
4742                 if (ps == NULL) {
4743                         ps = kmem_cache_alloc(mirror_parent_cache,
4744                             MD_ALLOCFLAGS);
4745                         ps->ps_un = un;
4746                         ps->ps_ui = ui;
4747                         ps->ps_firstblk = 0;
4748                         ps->ps_lastblk = 0;
4749                         ps->ps_flags = 0;
4750                         md_ioctl_readerexit(lockp);
4751                         (void) md_ioctl_writerlock(lockp, ui);
4752                         un->un_rs_prev_overlap = ps;
4753                         md_ioctl_writerexit(lockp);
4754                 } else
4755                         md_ioctl_readerexit(lockp);
4756 
4757                 if (p->rs_originator != md_mn_mynode_id) {
4758                         /*
4759                          * Clear our un_resync_bm for the regions completed.
4760                          * The owner (originator) will take care of itself.
4761                          */
4762                         BLK_TO_RR(rr_end, ps->ps_lastblk, un);
4763                         BLK_TO_RR(rr_start, p->rs_start, un);
4764                         if (ps->ps_lastblk && rr_end < rr_start) {
4765                                 BLK_TO_RR(rr_start, ps->ps_firstblk, un);
4766                                 mutex_enter(&un->un_resync_mx);
4767                                 /*
4768                                  * Update our resync bitmap to reflect that
4769                                  * another node has synchronized this range.
4770                                  */
4771                                 for (rr = rr_start; rr <= rr_end; rr++) {
4772                                         CLR_KEEPDIRTY(rr, un);
4773                                 }
4774                                 mutex_exit(&un->un_resync_mx);
4775                         }
4776 
4777                         /*
4778                          * On all but the originating node, first update
4779                          * the resync state, then unblock the previous
4780                          * region and block the next one. No need
4781                          * to do this if the region is already blocked.
4782                          * Update the submirror state and flags from the
4783                          * originator. This keeps the cluster in sync with
4784                          * regards to the resync status.
4785                          */
4786 
4787                         (void) md_ioctl_writerlock(lockp, ui);
4788                         un->un_rs_resync_done = p->rs_done;
4789                         un->un_rs_resync_2_do = p->rs_2_do;
4790                         un->un_rs_type = p->rs_type;
4791                         un->un_resync_startbl = p->rs_start;
4792                         md_ioctl_writerexit(lockp);
4793                         /*
4794                          * Use un_owner_mx to ensure that an ownership change
4795                          * cannot happen at the same time as this message
4796                          */
4797                         mutex_enter(&un->un_owner_mx);
4798                         if (MD_MN_MIRROR_OWNER(un)) {
4799                                 ps->ps_firstblk = p->rs_start;
4800                                 ps->ps_lastblk = ps->ps_firstblk +
4801                                     p->rs_size - 1;
4802                         } else {
4803                                 if ((ps->ps_firstblk != p->rs_start) ||
4804                                     (ps->ps_lastblk != p->rs_start +
4805                                     p->rs_size - 1)) {
4806                                         /* Remove previous overlap range */
4807                                         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4808                                                 mirror_overlap_tree_remove(ps);
4809 
4810                                         ps->ps_firstblk = p->rs_start;
4811                                         ps->ps_lastblk = ps->ps_firstblk +
4812                                             p->rs_size - 1;
4813 
4814                                         mutex_exit(&un->un_owner_mx);
4815                                         /* Block this range from all i/o. */
4816                                         if (ps->ps_firstblk != 0 ||
4817                                             ps->ps_lastblk != 0)
4818                                                 wait_for_overlaps(ps,
4819                                                     MD_OVERLAP_ALLOW_REPEAT);
4820                                         mutex_enter(&un->un_owner_mx);
4821                                         /*
4822                                          * Check to see if we have obtained
4823                                          * ownership while waiting for
4824                                          * overlaps. If we have, remove
4825                                          * the resync_region entry from the
4826                                          * overlap tree
4827                                          */
4828                                         if (MD_MN_MIRROR_OWNER(un) &&
4829                                             (ps->ps_flags & MD_MPS_ON_OVERLAP))
4830                                                 mirror_overlap_tree_remove(ps);
4831                                 }
4832                         }
4833                         mutex_exit(&un->un_owner_mx);
4834 
4835                         /*
4836                          * If this is the first RESYNC_NEXT message (i.e.
4837                          * MD_MN_RS_FIRST_RESYNC_NEXT set in p->rs_flags),
4838                          * issue RESYNC_START NOTIFY event
4839                          */
4840                         if (p->rs_flags & MD_MN_RS_FIRST_RESYNC_NEXT) {
4841                                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_START,
4842                                     SVM_TAG_METADEVICE, MD_UN2SET(un),
4843                                     MD_SID(un));
4844                         }
4845 
4846                         /* Ensure that our local resync thread is running */
4847                         if (un->un_rs_thread == NULL) {
4848                                 (void) mirror_resync_unit(p->mnum, NULL,
4849                                     &p->mde, lockp);
4850                         }
4851                 }
4852 
4853                 break;
4854         case MD_MN_MSG_RESYNC_FINISH:
4855                 /*
4856                  * Complete the resync by stopping the resync thread.
4857                  * Also release the previous overlap region field.
4858                  * Update the resync_progress_thread by cv_signal'ing it so
4859                  * that we mark the end of the resync as soon as possible. This
4860                  * stops an unnecessary delay should be panic after resync
4861                  * completion.
4862                  */
4863 #ifdef DEBUG
4864                 if (!rs_active) {
4865                         if (mirror_debug_flag)
4866                                 printf("RESYNC_FINISH (mnum = %x), "
4867                                     "Resync *NOT* active",
4868                                     p->mnum);
4869                 }
4870 #endif
4871 
4872                 if ((un->c.un_status & MD_UN_RESYNC_ACTIVE) &&
4873                     (p->rs_originator != md_mn_mynode_id)) {
4874                         mutex_enter(&un->un_rs_thread_mx);
4875                         un->c.un_status &= ~MD_UN_RESYNC_CANCEL;
4876                         un->un_rs_thread_flags |= MD_RI_SHUTDOWN;
4877                         un->un_rs_thread_flags &=
4878                             ~(MD_RI_BLOCK|MD_RI_BLOCK_OWNER);
4879                         cv_signal(&un->un_rs_thread_cv);
4880                         mutex_exit(&un->un_rs_thread_mx);
4881                 }
4882                 if (is_ABR) {
4883                         /* Resync finished, if ABR set owner to NULL */
4884                         mutex_enter(&un->un_owner_mx);
4885                         un->un_mirror_owner = 0;
4886                         mutex_exit(&un->un_owner_mx);
4887                 }
4888                 (void) md_ioctl_writerlock(lockp, ui);
4889                 ps = un->un_rs_prev_overlap;
4890                 if (ps != NULL) {
4891                         /* Remove previous overlap range */
4892                         if (ps->ps_flags & MD_MPS_ON_OVERLAP)
4893                                 mirror_overlap_tree_remove(ps);
4894                         /*
4895                          * Release the overlap range reference
4896                          */
4897                         un->un_rs_prev_overlap = NULL;
4898                         kmem_cache_free(mirror_parent_cache,
4899                             ps);
4900                 }
4901                 md_ioctl_writerexit(lockp);
4902 
4903                 /* Mark the resync as complete in the metadb */
4904                 un->un_rs_resync_done = p->rs_done;
4905                 un->un_rs_resync_2_do = p->rs_2_do;
4906                 un->un_rs_type = p->rs_type;
4907                 mutex_enter(&un->un_rs_progress_mx);
4908                 cv_signal(&un->un_rs_progress_cv);
4909                 mutex_exit(&un->un_rs_progress_mx);
4910 
4911                 un = md_ioctl_writerlock(lockp, ui);
4912                 un->c.un_status &= ~MD_UN_RESYNC_ACTIVE;
4913                 /* Deal with any pending grow_unit */
4914                 if (un->c.un_status & MD_UN_GROW_PENDING) {
4915                         if ((mirror_grow_unit(un, &mde) != 0) ||
4916                             (! mdismderror(&mde, MDE_GROW_DELAYED))) {
4917                                 un->c.un_status &= ~MD_UN_GROW_PENDING;
4918                         }
4919                 }
4920                 md_ioctl_writerexit(lockp);
4921                 break;
4922 
4923         case MD_MN_MSG_RESYNC_PHASE_DONE:
4924                 /*
4925                  * A phase of the resync, optimized. component or
4926                  * submirror is complete. Update mirror status.
4927                  * If the flag CLEAR_OPT_NOT_DONE is set, it means that the
4928                  * mirror owner is peforming a resync. If we have just snarfed
4929                  * this set, then we must clear any of the flags set at snarf
4930                  * time by unit_setup_resync().
4931                  * Note that unit_setup_resync() sets up these flags to
4932                  * indicate that an optimized resync is required. These flags
4933                  * need to be reset because if we get here,  the mirror owner
4934                  * will have handled the optimized resync.
4935                  * The flags that must be cleared are MD_UN_OPT_NOT_DONE and
4936                  * MD_UN_WAR. In addition, for each submirror,
4937                  * MD_SM_RESYNC_TARGET must be cleared and SMS_OFFLINE_RESYNC
4938                  * set to SMS_OFFLINE.
4939                  */
4940 #ifdef DEBUG
4941                 if (mirror_debug_flag)
4942                         printf("phase done mess received from %d, mnum=%x,"
4943                             "type=%x, flags=%x\n", p->rs_originator, p->mnum,
4944                             p->rs_type, p->rs_flags);
4945 #endif
4946                 /*
4947                  * Ignore the message if there is no active resync thread.
4948                  */
4949                 if (!rs_active)
4950                         break;
4951 
4952                 broke_out = p->rs_flags & MD_MN_RS_ERR;
4953                 switch (RS_TYPE(p->rs_type)) {
4954                 case MD_RS_OPTIMIZED:
4955                         un = md_ioctl_writerlock(lockp, ui);
4956                         if (p->rs_flags & MD_MN_RS_CLEAR_OPT_NOT_DONE) {
4957                                 /* If we are originator, just clear rs_type */
4958                                 if (p->rs_originator == md_mn_mynode_id) {
4959                                         SET_RS_TYPE_NONE(un->un_rs_type);
4960                                         md_ioctl_writerexit(lockp);
4961                                         break;
4962                                 }
4963                                 /*
4964                                  * If CLEAR_OPT_NOT_DONE is set, only clear the
4965                                  * flags if OPT_NOT_DONE is set *and* rs_type
4966                                  * is MD_RS_NONE.
4967                                  */
4968                                 if ((un->c.un_status & MD_UN_OPT_NOT_DONE) &&
4969                                     (RS_TYPE(un->un_rs_type) == MD_RS_NONE)) {
4970                                         /* No resync in progress */
4971                                         un->c.un_status &= ~MD_UN_OPT_NOT_DONE;
4972                                         un->c.un_status &= ~MD_UN_WAR;
4973                                 } else {
4974                                         /*
4975                                          * We are in the middle of an
4976                                          * optimized resync and this message
4977                                          * should be ignored.
4978                                          */
4979                                         md_ioctl_writerexit(lockp);
4980                                         break;
4981                                 }
4982                         } else {
4983                                 /*
4984                                  * This is the end of an optimized resync,
4985                                  * clear the OPT_NOT_DONE and OFFLINE_SM flags
4986                                  */
4987 
4988                                 un->c.un_status &= ~MD_UN_KEEP_DIRTY;
4989                                 if (!broke_out)
4990                                         un->c.un_status &= ~MD_UN_WAR;
4991 
4992                                 /*
4993                                  * Clear our un_resync_bm for the regions
4994                                  * completed.  The owner (originator) will
4995                                  * take care of itself.
4996                                  */
4997                                 if (p->rs_originator != md_mn_mynode_id &&
4998                                     (ps = un->un_rs_prev_overlap) != NULL) {
4999                                         BLK_TO_RR(rr_start, ps->ps_firstblk,
5000                                             un);
5001                                         BLK_TO_RR(rr_end, ps->ps_lastblk, un);
5002                                         mutex_enter(&un->un_resync_mx);
5003                                         for (rr = rr_start; rr <= rr_end;
5004                                             rr++) {
5005                                                 CLR_KEEPDIRTY(rr, un);
5006                                         }
5007                                         mutex_exit(&un->un_resync_mx);
5008                                 }
5009                         }
5010 
5011                         /*
5012                          * Set resync_completed to last resync type and then
5013                          * clear resync_type to indicate no resync in progress
5014                          */
5015                         un->un_resync_completed = un->un_rs_type;
5016                         SET_RS_TYPE_NONE(un->un_rs_type);
5017 
5018                         /*
5019                          * If resync is as a result of a submirror ONLINE,
5020                          * reset the submirror state to SMS_RUNNING if the
5021                          * resync was ok else set back to SMS_OFFLINE.
5022                          */
5023                         for (smi = 0; smi < NMIRROR; smi++) {
5024                                 un->un_sm[smi].sm_flags &=
5025                                     ~MD_SM_RESYNC_TARGET;
5026                                 if (SMS_BY_INDEX_IS(un, smi,
5027                                     SMS_OFFLINE_RESYNC)) {
5028                                         if (p->rs_flags &
5029                                             MD_MN_RS_CLEAR_OPT_NOT_DONE) {
5030                                                 state = SMS_OFFLINE;
5031                                         } else {
5032                                                 state = (broke_out ?
5033                                                     SMS_OFFLINE : SMS_RUNNING);
5034                                         }
5035                                         mirror_set_sm_state(
5036                                             &un->un_sm[smi],
5037                                             &un->un_smic[smi], state,
5038                                             broke_out);
5039                                         mirror_commit(un, NO_SUBMIRRORS,
5040                                             0);
5041                                 }
5042                                 /*
5043                                  * If we still have an offline submirror, reset
5044                                  * the OFFLINE_SM flag in the mirror status
5045                                  */
5046                                 if (SMS_BY_INDEX_IS(un, smi,
5047                                     SMS_OFFLINE))
5048                                         un->c.un_status |=
5049                                             MD_UN_OFFLINE_SM;
5050                         }
5051                         md_ioctl_writerexit(lockp);
5052                         break;
5053                 case MD_RS_SUBMIRROR:
5054                         un = md_ioctl_writerlock(lockp, ui);
5055                         smi = RS_SMI(p->rs_type);
5056                         sm = &un->un_sm[smi];
5057                         smic = &un->un_smic[smi];
5058                         /* Clear RESYNC target */
5059                         un->un_sm[smi].sm_flags &= ~MD_SM_RESYNC_TARGET;
5060                         /*
5061                          * Set resync_completed to last resync type and then
5062                          * clear resync_type to indicate no resync in progress
5063                          */
5064                         un->un_resync_completed = un->un_rs_type;
5065                         SET_RS_TYPE_NONE(un->un_rs_type);
5066                         /*
5067                          * If the resync completed ok reset the submirror
5068                          * state to SMS_RUNNING else reset it to SMS_ATTACHED
5069                          */
5070                         state = (broke_out ?
5071                             SMS_ATTACHED : SMS_RUNNING);
5072                         mirror_set_sm_state(sm, smic, state, broke_out);
5073                         un->c.un_status &= ~MD_UN_WAR;
5074                         mirror_commit(un, SMI2BIT(smi), 0);
5075                         md_ioctl_writerexit(lockp);
5076                         break;
5077                 case MD_RS_COMPONENT:
5078                         un = md_ioctl_writerlock(lockp, ui);
5079                         smi = RS_SMI(p->rs_type);
5080                         ci = RS_CI(p->rs_type);
5081                         sm = &un->un_sm[smi];
5082                         smic = &un->un_smic[smi];
5083                         shared = (md_m_shared_t *)
5084                             (*(smic->sm_shared_by_indx))
5085                             (sm->sm_dev, sm, ci);
5086                         un->c.un_status &= ~MD_UN_WAR;
5087                         /* Clear RESYNC target */
5088                         un->un_sm[smi].sm_flags &= ~MD_SM_RESYNC_TARGET;
5089                         /*
5090                          * Set resync_completed to last resync type and then
5091                          * clear resync_type to indicate no resync in progress
5092                          */
5093                         un->un_resync_completed = un->un_rs_type;
5094                         SET_RS_TYPE_NONE(un->un_rs_type);
5095 
5096                         /*
5097                          * If the resync completed ok, set the component state
5098                          * to CS_OKAY.
5099                          */
5100                         if (broke_out)
5101                                 shared->ms_flags |= MDM_S_RS_TRIED;
5102                         else {
5103                                 /*
5104                                  * As we don't transmit the changes,
5105                                  * no need to drop the lock.
5106                                  */
5107                                 set_sm_comp_state(un, smi, ci, CS_OKAY, 0,
5108                                     MD_STATE_NO_XMIT, (IOLOCK *)NULL);
5109                         }
5110                         md_ioctl_writerexit(lockp);
5111                 default:
5112                         break;
5113                 }
5114                 /*
5115                  * If the purpose of this PHASE_DONE message is just to
5116                  * indicate to all other nodes that the optimized resync
5117                  * required (OPT_NOT_DONE) flag is to be cleared, there is
5118                  * no need to generate a notify event as there has not
5119                  * actually been a resync.
5120                  */
5121                 if (!(p->rs_flags & MD_MN_RS_CLEAR_OPT_NOT_DONE)) {
5122                         if (broke_out) {
5123                                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_FAILED,
5124                                     SVM_TAG_METADEVICE, MD_UN2SET(un),
5125                                     MD_SID(un));
5126                         } else {
5127                                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_RESYNC_DONE,
5128                                     SVM_TAG_METADEVICE, MD_UN2SET(un),
5129                                     MD_SID(un));
5130                         }
5131                 }
5132                 break;
5133 
5134         default:
5135 #ifdef DEBUG
5136                 cmn_err(CE_PANIC, "mirror_resync_message: Unknown message type"
5137                     " %x\n", p->msg_type);
5138 #endif
5139                 return (EINVAL);
5140         }
5141         return (0);
5142 }
5143 
5144 /* Return a -1 if snarf of optimized record failed and set should be released */
5145 static int
5146 mirror_snarf(md_snarfcmd_t cmd, set_t setno)
5147 {
5148         mddb_recid_t    recid;
5149         int             gotsomething;
5150         int             all_mirrors_gotten;
5151         mm_unit_t       *un;
5152         mddb_type_t     typ1;
5153         mddb_de_ic_t    *dep;
5154         mddb_rb32_t     *rbp;
5155         size_t          newreqsize;
5156         mm_unit_t       *big_un;
5157         mm_unit32_od_t  *small_un;
5158         int             retval;
5159         mdi_unit_t      *ui;
5160 
5161         if (cmd == MD_SNARF_CLEANUP) {
5162                 if (md_get_setstatus(setno) & MD_SET_STALE)
5163                         return (0);
5164 
5165                 recid = mddb_makerecid(setno, 0);
5166                 typ1 = (mddb_type_t)md_getshared_key(setno,
5167                     mirror_md_ops.md_driver.md_drivername);
5168                 while ((recid = mddb_getnextrec(recid, typ1, MIRROR_REC)) > 0) {
5169                         if (mddb_getrecprivate(recid) & MD_PRV_CLEANUP) {
5170                                 un = (mm_unit_t *)mddb_getrecaddr(recid);
5171                                 mirror_cleanup(un);
5172                                 recid = mddb_makerecid(setno, 0);
5173                         }
5174                 }
5175                 return (0);
5176         }
5177 
5178         all_mirrors_gotten = 1;
5179         gotsomething = 0;
5180 
5181         recid = mddb_makerecid(setno, 0);
5182         typ1 = (mddb_type_t)md_getshared_key(setno,
5183             mirror_md_ops.md_driver.md_drivername);
5184 
5185         while ((recid = mddb_getnextrec(recid, typ1, MIRROR_REC)) > 0) {
5186                 if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
5187                         continue;
5188 
5189                 dep = mddb_getrecdep(recid);
5190                 dep->de_flags = MDDB_F_MIRROR;
5191                 rbp = dep->de_rb;
5192 
5193                 switch (rbp->rb_revision) {
5194                 case MDDB_REV_RB:
5195                 case MDDB_REV_RBFN:
5196                         if ((rbp->rb_private & MD_PRV_CONVD) == 0) {
5197                                 /*
5198                                  * This means, we have an old and small
5199                                  * record and this record hasn't already
5200                                  * been converted.  Before we create an
5201                                  * incore metadevice from this we have to
5202                                  * convert it to a big record.
5203                                  */
5204                                 small_un =
5205                                     (mm_unit32_od_t *)mddb_getrecaddr(recid);
5206                                 newreqsize = sizeof (mm_unit_t);
5207                                 big_un = (mm_unit_t *)kmem_zalloc(newreqsize,
5208                                     KM_SLEEP);
5209                                 mirror_convert((caddr_t)small_un,
5210                                     (caddr_t)big_un, SMALL_2_BIG);
5211                                 kmem_free(small_un, dep->de_reqsize);
5212 
5213                                 /*
5214                                  * Update userdata and incore userdata
5215                                  * incores are at the end of un
5216                                  */
5217                                 dep->de_rb_userdata_ic = big_un;
5218                                 dep->de_rb_userdata = big_un;
5219                                 dep->de_icreqsize = newreqsize;
5220                                 un = big_un;
5221                                 rbp->rb_private |= MD_PRV_CONVD;
5222                         } else {
5223                                 /*
5224                                  * Unit already converted, just get the
5225                                  * record address.
5226                                  */
5227                                 un = (mm_unit_t *)mddb_getrecaddr_resize(recid,
5228                                     sizeof (*un), 0);
5229                         }
5230                         un->c.un_revision &= ~MD_64BIT_META_DEV;
5231                         break;
5232                 case MDDB_REV_RB64:
5233                 case MDDB_REV_RB64FN:
5234                         /* Big device */
5235                         un = (mm_unit_t *)mddb_getrecaddr_resize(recid,
5236                             sizeof (*un), 0);
5237                         un->c.un_revision |= MD_64BIT_META_DEV;
5238                         un->c.un_flag |= MD_EFILABEL;
5239                         break;
5240                 }
5241                 MDDB_NOTE_FN(rbp->rb_revision, un->c.un_revision);
5242 
5243                 /*
5244                  * Create minor device node for snarfed entry.
5245                  */
5246                 (void) md_create_minor_node(setno, MD_SID(un));
5247 
5248                 if (MD_UNIT(MD_SID(un)) != NULL) {
5249                         mddb_setrecprivate(recid, MD_PRV_PENDDEL);
5250                         continue;
5251                 }
5252                 all_mirrors_gotten = 0;
5253                 retval = mirror_build_incore(un, 1);
5254                 if (retval == 0) {
5255                         mddb_setrecprivate(recid, MD_PRV_GOTIT);
5256                         md_create_unit_incore(MD_SID(un), &mirror_md_ops, 0);
5257                         resync_start_timeout(setno);
5258                         gotsomething = 1;
5259                 } else {
5260                         return (retval);
5261                 }
5262                 /*
5263                  * Set flag to indicate that the mirror has not yet
5264                  * been through a reconfig. This flag is used for MN sets
5265                  * when determining whether to update the mirror state from
5266                  * the Master node.
5267                  */
5268                 if (MD_MNSET_SETNO(setno)) {
5269                         ui = MDI_UNIT(MD_SID(un));
5270                         ui->ui_tstate |= MD_RESYNC_NOT_DONE;
5271                 }
5272         }
5273 
5274         if (!all_mirrors_gotten)
5275                 return (gotsomething);
5276 
5277         recid = mddb_makerecid(setno, 0);
5278         while ((recid = mddb_getnextrec(recid, typ1, RESYNC_REC)) > 0)
5279                 if (!(mddb_getrecprivate(recid) & MD_PRV_GOTIT))
5280                         mddb_setrecprivate(recid, MD_PRV_PENDDEL);
5281 
5282         return (0);
5283 }
5284 
5285 static int
5286 mirror_halt(md_haltcmd_t cmd, set_t setno)
5287 {
5288         unit_t          i;
5289         mdi_unit_t      *ui;
5290         minor_t         mnum;
5291         int             reset_mirror_flag = 0;
5292 
5293         if (cmd == MD_HALT_CLOSE)
5294                 return (0);
5295 
5296         if (cmd == MD_HALT_OPEN)
5297                 return (0);
5298 
5299         if (cmd == MD_HALT_UNLOAD)
5300                 return (0);
5301 
5302         if (cmd == MD_HALT_CHECK) {
5303                 for (i = 0; i < md_nunits; i++) {
5304                         mnum = MD_MKMIN(setno, i);
5305                         if ((ui = MDI_UNIT(mnum)) == NULL)
5306                                 continue;
5307                         if (ui->ui_opsindex != mirror_md_ops.md_selfindex)
5308                                 continue;
5309                         if (md_unit_isopen(ui))
5310                                 return (1);
5311                 }
5312                 return (0);
5313         }
5314 
5315         if (cmd != MD_HALT_DOIT)
5316                 return (1);
5317 
5318         for (i = 0; i < md_nunits; i++) {
5319                 mnum = MD_MKMIN(setno, i);
5320                 if ((ui = MDI_UNIT(mnum)) == NULL)
5321                         continue;
5322                 if (ui->ui_opsindex != mirror_md_ops.md_selfindex)
5323                         continue;
5324                 reset_mirror((mm_unit_t *)MD_UNIT(mnum), mnum, 0);
5325 
5326                 /* Set a flag if there is at least one mirror metadevice. */
5327                 reset_mirror_flag = 1;
5328         }
5329 
5330         /*
5331          * Only wait for the global dr_timeout to finish
5332          *  - if there are mirror metadevices in this diskset or
5333          *  - if this is the local set since an unload of the md_mirror
5334          *    driver could follow a successful mirror halt in the local set.
5335          */
5336         if ((reset_mirror_flag != 0) || (setno == MD_LOCAL_SET)) {
5337                 while ((mirror_md_ops.md_head == NULL) &&
5338                     (mirror_timeout.dr_timeout_id != 0))
5339                         delay(md_hz);
5340         }
5341 
5342         return (0);
5343 }
5344 
5345 /*ARGSUSED3*/
5346 static int
5347 mirror_open(dev_t *dev, int flag, int otyp, cred_t *cred_p, int md_oflags)
5348 {
5349         IOLOCK  lock;
5350         minor_t         mnum = getminor(*dev);
5351         set_t           setno;
5352 
5353         /*
5354          * When doing an open of a multi owner metadevice, check to see if this
5355          * node is a starting node and if a reconfig cycle is underway.
5356          * If so, the system isn't sufficiently set up enough to handle the
5357          * open (which involves I/O during sp_validate), so fail with ENXIO.
5358          */
5359         setno = MD_MIN2SET(mnum);
5360         if ((md_set[setno].s_status & (MD_SET_MNSET | MD_SET_MN_START_RC)) ==
5361             (MD_SET_MNSET | MD_SET_MN_START_RC)) {
5362                         return (ENXIO);
5363         }
5364 
5365         if (md_oflags & MD_OFLG_FROMIOCTL) {
5366                 /*
5367                  * This indicates that the caller is an ioctl service routine.
5368                  * In this case we initialise our stack-based IOLOCK and pass
5369                  * this into the internal open routine. This allows multi-owner
5370                  * metadevices to avoid deadlocking if an error is encountered
5371                  * during the open() attempt. The failure case is:
5372                  * s-p -> mirror -> s-p (with error). Attempting to metaclear
5373                  * this configuration would deadlock as the mirror code has to
5374                  * send a state-update to the other nodes when it detects the
5375                  * failure of the underlying submirror with an errored soft-part
5376                  * on it. As there is a class1 message in progress (metaclear)
5377                  * set_sm_comp_state() cannot send another class1 message;
5378                  * instead we do not send a state_update message as the
5379                  * metaclear is distributed and the failed submirror will be
5380                  * cleared from the configuration by the metaclear.
5381                  */
5382                 IOLOCK_INIT(&lock);
5383                 return (mirror_internal_open(getminor(*dev), flag, otyp,
5384                     md_oflags, &lock));
5385         } else {
5386                 return (mirror_internal_open(getminor(*dev), flag, otyp,
5387                     md_oflags, (IOLOCK *)NULL));
5388         }
5389 }
5390 
5391 
5392 /*ARGSUSED1*/
5393 static int
5394 mirror_close(dev_t dev, int flag, int otyp, cred_t *cred_p, int md_cflags)
5395 {
5396         return (mirror_internal_close(getminor(dev), otyp, md_cflags,
5397             (IOLOCK *)NULL));
5398 }
5399 
5400 
5401 /*
5402  * This routine dumps memory to the disk.  It assumes that the memory has
5403  * already been mapped into mainbus space.  It is called at disk interrupt
5404  * priority when the system is in trouble.
5405  *
5406  */
5407 static int
5408 mirror_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
5409 {
5410         mm_unit_t       *un;
5411         dev_t           mapdev;
5412         int             result;
5413         int             smi;
5414         int             any_succeed = 0;
5415         int             save_result = 0;
5416 
5417         /*
5418          * Don't need to grab the unit lock.
5419          * Cause nothing else is suppose to be happenning.
5420          * Also dump is not suppose to sleep.
5421          */
5422         un = (mm_unit_t *)MD_UNIT(getminor(dev));
5423 
5424         if ((diskaddr_t)blkno >= un->c.un_total_blocks)
5425                 return (EINVAL);
5426 
5427         if ((diskaddr_t)blkno + nblk > un->c.un_total_blocks)
5428                 return (EINVAL);
5429 
5430         for (smi = 0; smi < NMIRROR; smi++) {
5431                 if (!SUBMIRROR_IS_WRITEABLE(un, smi))
5432                         continue;
5433                 mapdev = md_dev64_to_dev(un->un_sm[smi].sm_dev);
5434                 result = bdev_dump(mapdev, addr, blkno, nblk);
5435                 if (result)
5436                         save_result = result;
5437 
5438                 if (result == 0)
5439                         any_succeed++;
5440         }
5441 
5442         if (any_succeed)
5443                 return (0);
5444 
5445         return (save_result);
5446 }
5447 
5448 /*
5449  * NAME: mirror_probe_dev
5450  *
5451  * DESCRITPION: force opens every component of a mirror.
5452  *
5453  * On entry the unit writerlock is held
5454  */
5455 static int
5456 mirror_probe_dev(mdi_unit_t *ui, minor_t mnum)
5457 {
5458         int             i;
5459         int             smi;
5460         int             ci;
5461         mm_unit_t       *un;
5462         int             md_devopen = 0;
5463         set_t           setno;
5464         int             sm_cnt;
5465         int             sm_unavail_cnt;
5466 
5467         if (md_unit_isopen(ui))
5468                 md_devopen++;
5469 
5470         un = MD_UNIT(mnum);
5471         setno = MD_UN2SET(un);
5472 
5473         sm_cnt = 0;
5474         sm_unavail_cnt = 0;
5475         for (i = 0; i < NMIRROR; i++) {
5476                 md_dev64_t tmpdev;
5477                 mdi_unit_t      *sm_ui;
5478 
5479                 if (!SMS_BY_INDEX_IS(un, i, SMS_INUSE)) {
5480                         continue;
5481                 }
5482 
5483                 sm_cnt++;
5484                 tmpdev = un->un_sm[i].sm_dev;
5485                 (void) md_layered_open(mnum, &tmpdev,
5486                     MD_OFLG_CONT_ERRS | MD_OFLG_PROBEDEV);
5487                 un->un_sm[i].sm_dev = tmpdev;
5488 
5489                 sm_ui = MDI_UNIT(getminor(md_dev64_to_dev(tmpdev)));
5490 
5491                 /*
5492                  * Logic similar to that in mirror_open_all_devs.  We set or
5493                  * clear the submirror Unavailable bit.
5494                  */
5495                 (void) md_unit_writerlock(sm_ui);
5496                 if (submirror_unavailable(un, i, 1)) {
5497                         sm_ui->ui_tstate |= MD_INACCESSIBLE;
5498                         sm_unavail_cnt++;
5499                 } else {
5500                         sm_ui->ui_tstate &= ~MD_INACCESSIBLE;
5501                 }
5502                 md_unit_writerexit(sm_ui);
5503         }
5504 
5505         /*
5506          * If all of the submirrors are unavailable, the mirror is also
5507          * unavailable.
5508          */
5509         if (sm_cnt == sm_unavail_cnt) {
5510                 ui->ui_tstate |= MD_INACCESSIBLE;
5511         } else {
5512                 ui->ui_tstate &= ~MD_INACCESSIBLE;
5513         }
5514 
5515         /*
5516          * Start checking from probe failures. If failures occur we
5517          * set the appropriate erred state only if the metadevice is in
5518          * use. This is specifically to prevent unnecessary resyncs.
5519          * For instance if the disks were accidentally disconnected when
5520          * the system booted up then until the metadevice is accessed
5521          * (like file system mount) the user can shutdown, recable and
5522          * reboot w/o incurring a potentially huge resync.
5523          */
5524 
5525         smi = 0;
5526         ci = 0;
5527         while (mirror_geterror(un, &smi, &ci, 1, 1) != 0) {
5528 
5529                 if (mirror_other_sources(un, smi, ci, 0) == 1) {
5530                         /*
5531                          * Note that for a MN set, there is no need to call
5532                          * SE_NOTIFY as that is done when processing the
5533                          * state change
5534                          */
5535                         if (md_devopen) {
5536                                 /*
5537                                  * Never called from ioctl context,
5538                                  * so (IOLOCK *)NULL
5539                                  */
5540                                 set_sm_comp_state(un, smi, ci, CS_LAST_ERRED,
5541                                     0, MD_STATE_XMIT, (IOLOCK *)NULL);
5542                                 if (!MD_MNSET_SETNO(setno)) {
5543                                         SE_NOTIFY(EC_SVM_STATE,
5544                                             ESC_SVM_LASTERRED,
5545                                             SVM_TAG_METADEVICE, setno,
5546                                             MD_SID(un));
5547                                 }
5548                                 continue;
5549                         } else {
5550                                 (void) mirror_close_all_devs(un,
5551                                     MD_OFLG_PROBEDEV);
5552                                 if (!MD_MNSET_SETNO(setno)) {
5553                                         SE_NOTIFY(EC_SVM_STATE,
5554                                             ESC_SVM_OPEN_FAIL,
5555                                             SVM_TAG_METADEVICE, setno,
5556                                             MD_SID(un));
5557                                 }
5558                                 mirror_openfail_console_info(un, smi, ci);
5559                                 return (ENXIO);
5560                         }
5561                 }
5562 
5563                 /*
5564                  * Note that for a MN set, there is no need to call
5565                  * SE_NOTIFY as that is done when processing the
5566                  * state change
5567                  */
5568                 if (md_devopen) {
5569                         /* Never called from ioctl context, so (IOLOCK *)NULL */
5570                         set_sm_comp_state(un, smi, ci, CS_ERRED, 0,
5571                             MD_STATE_XMIT, (IOLOCK *)NULL);
5572                         if (!MD_MNSET_SETNO(setno)) {
5573                                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_ERRED,
5574                                     SVM_TAG_METADEVICE, setno,
5575                                     MD_SID(un));
5576                         }
5577                 }
5578                 mirror_openfail_console_info(un, smi, ci);
5579                 ci++;
5580         }
5581 
5582         if (MD_MNSET_SETNO(setno)) {
5583                 send_poke_hotspares(setno);
5584         } else {
5585                 (void) poke_hotspares();
5586         }
5587         (void) mirror_close_all_devs(un, MD_OFLG_PROBEDEV);
5588 
5589         return (0);
5590 }
5591 
5592 
5593 static int
5594 mirror_imp_set(
5595         set_t   setno
5596 )
5597 {
5598 
5599         mddb_recid_t    recid;
5600         int             gotsomething, i;
5601         mddb_type_t     typ1;
5602         mddb_de_ic_t    *dep;
5603         mddb_rb32_t     *rbp;
5604         mm_unit32_od_t  *un32;
5605         mm_unit_t       *un64;
5606         md_dev64_t      self_devt;
5607         minor_t         *self_id;       /* minor needs to be updated */
5608         md_parent_t     *parent_id;     /* parent needs to be updated */
5609         mddb_recid_t    *record_id;     /* record id needs to be updated */
5610         mddb_recid_t    *optrec_id;
5611         md_dev64_t      tmpdev;
5612 
5613 
5614         gotsomething = 0;
5615 
5616         typ1 = (mddb_type_t)md_getshared_key(setno,
5617             mirror_md_ops.md_driver.md_drivername);
5618         recid = mddb_makerecid(setno, 0);
5619 
5620         while ((recid = mddb_getnextrec(recid, typ1, MIRROR_REC)) > 0) {
5621                 if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
5622                         continue;
5623 
5624                 dep = mddb_getrecdep(recid);
5625                 rbp = dep->de_rb;
5626 
5627                 switch (rbp->rb_revision) {
5628                 case MDDB_REV_RB:
5629                 case MDDB_REV_RBFN:
5630                         /*
5631                          * Small device
5632                          */
5633                         un32 = (mm_unit32_od_t *)mddb_getrecaddr(recid);
5634                         self_id = &(un32->c.un_self_id);
5635                         parent_id = &(un32->c.un_parent);
5636                         record_id = &(un32->c.un_record_id);
5637                         optrec_id = &(un32->un_rr_dirty_recid);
5638 
5639                         for (i = 0; i < un32->un_nsm; i++) {
5640                                 tmpdev = md_expldev(un32->un_sm[i].sm_dev);
5641                                 un32->un_sm[i].sm_dev = md_cmpldev
5642                                     (md_makedevice(md_major, MD_MKMIN(setno,
5643                                     MD_MIN2UNIT(md_getminor(tmpdev)))));
5644 
5645                                 if (!md_update_minor(setno, mddb_getsidenum
5646                                     (setno), un32->un_sm[i].sm_key))
5647                                 goto out;
5648                         }
5649                         break;
5650                 case MDDB_REV_RB64:
5651                 case MDDB_REV_RB64FN:
5652                         un64 = (mm_unit_t *)mddb_getrecaddr(recid);
5653                         self_id = &(un64->c.un_self_id);
5654                         parent_id = &(un64->c.un_parent);
5655                         record_id = &(un64->c.un_record_id);
5656                         optrec_id = &(un64->un_rr_dirty_recid);
5657 
5658                         for (i = 0; i < un64->un_nsm; i++) {
5659                                 tmpdev = un64->un_sm[i].sm_dev;
5660                                 un64->un_sm[i].sm_dev = md_makedevice
5661                                     (md_major, MD_MKMIN(setno, MD_MIN2UNIT
5662                                     (md_getminor(tmpdev))));
5663 
5664                                 if (!md_update_minor(setno, mddb_getsidenum
5665                                     (setno), un64->un_sm[i].sm_key))
5666                                 goto out;
5667                         }
5668                         break;
5669                 }
5670 
5671                 /*
5672                  * If this is a top level and a friendly name metadevice,
5673                  * update its minor in the namespace.
5674                  */
5675                 if ((*parent_id == MD_NO_PARENT) &&
5676                     ((rbp->rb_revision == MDDB_REV_RBFN) ||
5677                     (rbp->rb_revision == MDDB_REV_RB64FN))) {
5678 
5679                         self_devt = md_makedevice(md_major, *self_id);
5680                         if (!md_update_top_device_minor(setno,
5681                             mddb_getsidenum(setno), self_devt))
5682                                 goto out;
5683                 }
5684 
5685                 /*
5686                  * Update unit with the imported setno
5687                  *
5688                  */
5689                 mddb_setrecprivate(recid, MD_PRV_GOTIT);
5690 
5691                 *self_id = MD_MKMIN(setno, MD_MIN2UNIT(*self_id));
5692                 if (*parent_id != MD_NO_PARENT)
5693                         *parent_id = MD_MKMIN(setno, MD_MIN2UNIT(*parent_id));
5694                 *record_id = MAKERECID(setno, DBID(*record_id));
5695                 *optrec_id = MAKERECID(setno, DBID(*optrec_id));
5696 
5697                 gotsomething = 1;
5698         }
5699 
5700 out:
5701         return (gotsomething);
5702 }
5703 
5704 /*
5705  * NAME: mirror_check_offline
5706  *
5707  * DESCRIPTION: return offline_status = 1 if any submirrors are offline
5708  *
5709  * Called from ioctl, so access to MD_UN_OFFLINE_SM in un_status is
5710  * protected by the global ioctl lock as it is only set by the MD_IOCOFFLINE
5711  * ioctl.
5712  */
5713 int
5714 mirror_check_offline(md_dev64_t dev, int *offline_status)
5715 {
5716         mm_unit_t               *un;
5717         md_error_t              mde = mdnullerror;
5718 
5719         if ((un = mirror_getun(getminor(dev), &mde, NO_LOCK, NULL)) == NULL)
5720                 return (EINVAL);
5721         *offline_status = 0;
5722         if (un->c.un_status & MD_UN_OFFLINE_SM)
5723                 *offline_status = 1;
5724         return (0);
5725 }
5726 
5727 /*
5728  * NAME: mirror_inc_abr_count
5729  *
5730  * DESCRIPTION: increment the count of layered soft parts with ABR set
5731  *
5732  * Called from ioctl, so access to un_abr_count is protected by the global
5733  * ioctl lock. It is only referenced in the MD_IOCOFFLINE ioctl.
5734  */
5735 int
5736 mirror_inc_abr_count(md_dev64_t dev)
5737 {
5738         mm_unit_t               *un;
5739         md_error_t              mde = mdnullerror;
5740 
5741         if ((un = mirror_getun(getminor(dev), &mde, NO_LOCK, NULL)) == NULL)
5742                 return (EINVAL);
5743         un->un_abr_count++;
5744         return (0);
5745 }
5746 
5747 /*
5748  * NAME: mirror_dec_abr_count
5749  *
5750  * DESCRIPTION: decrement the count of layered soft parts with ABR set
5751  *
5752  * Called from ioctl, so access to un_abr_count is protected by the global
5753  * ioctl lock. It is only referenced in the MD_IOCOFFLINE ioctl.
5754  */
5755 int
5756 mirror_dec_abr_count(md_dev64_t dev)
5757 {
5758         mm_unit_t               *un;
5759         md_error_t              mde = mdnullerror;
5760 
5761         if ((un = mirror_getun(getminor(dev), &mde, NO_LOCK, NULL)) == NULL)
5762                 return (EINVAL);
5763         un->un_abr_count--;
5764         return (0);
5765 }
5766 
5767 static md_named_services_t mirror_named_services[] = {
5768         {(intptr_t (*)()) poke_hotspares,               "poke hotspares"    },
5769         {(intptr_t (*)()) mirror_rename_listkids,       MDRNM_LIST_URKIDS   },
5770         {mirror_rename_check,                           MDRNM_CHECK         },
5771         {(intptr_t (*)()) mirror_renexch_update_kids,   MDRNM_UPDATE_KIDS   },
5772         {(intptr_t (*)()) mirror_exchange_parent_update_to,
5773                         MDRNM_PARENT_UPDATE_TO},
5774         {(intptr_t (*)()) mirror_exchange_self_update_from_down,
5775                         MDRNM_SELF_UPDATE_FROM_DOWN },
5776         {(intptr_t (*)())mirror_probe_dev,              "probe open test" },
5777         {(intptr_t (*)())mirror_check_offline,          MD_CHECK_OFFLINE },
5778         {(intptr_t (*)())mirror_inc_abr_count,          MD_INC_ABR_COUNT },
5779         {(intptr_t (*)())mirror_dec_abr_count,          MD_DEC_ABR_COUNT },
5780         { NULL,                                         0                   }
5781 };
5782 
5783 md_ops_t mirror_md_ops = {
5784         mirror_open,            /* open */
5785         mirror_close,           /* close */
5786         md_mirror_strategy,     /* strategy */
5787         NULL,                   /* print */
5788         mirror_dump,            /* dump */
5789         NULL,                   /* read */
5790         NULL,                   /* write */
5791         md_mirror_ioctl,        /* mirror_ioctl, */
5792         mirror_snarf,           /* mirror_snarf */
5793         mirror_halt,            /* mirror_halt */
5794         NULL,                   /* aread */
5795         NULL,                   /* awrite */
5796         mirror_imp_set,         /* import set */
5797         mirror_named_services
5798 };
5799 
5800 /* module specific initilization */
5801 static void
5802 init_init()
5803 {
5804         md_mirror_mcs_buf_off = sizeof (md_mcs_t) - sizeof (buf_t);
5805 
5806         /* Initialize the parent and child save memory pools */
5807         mirror_parent_cache = kmem_cache_create("md_mirror_parent",
5808             sizeof (md_mps_t), 0, mirror_parent_constructor,
5809             mirror_parent_destructor, mirror_run_queue, NULL, NULL,
5810             0);
5811 
5812         mirror_child_cache = kmem_cache_create("md_mirror_child",
5813             sizeof (md_mcs_t) - sizeof (buf_t) + biosize(), 0,
5814             mirror_child_constructor, mirror_child_destructor,
5815             mirror_run_queue, NULL, NULL, 0);
5816 
5817         /*
5818          * Insure wowbuf_size is a multiple of DEV_BSIZE,
5819          * then initialize wowbuf memory pool.
5820          */
5821         md_wowbuf_size = roundup(md_wowbuf_size, DEV_BSIZE);
5822         if (md_wowbuf_size <= 0)
5823                 md_wowbuf_size = 2 * DEV_BSIZE;
5824         if (md_wowbuf_size > (32 * DEV_BSIZE))
5825                 md_wowbuf_size = (32 * DEV_BSIZE);
5826 
5827         md_wowblk_size = md_wowbuf_size + sizeof (wowhdr_t);
5828         mirror_wowblk_cache = kmem_cache_create("md_mirror_wow",
5829             md_wowblk_size, 0, NULL, NULL, NULL, NULL, NULL, 0);
5830 
5831         mutex_init(&mirror_timeout.dr_mx, NULL, MUTEX_DEFAULT, NULL);
5832         mutex_init(&hotspare_request.dr_mx, NULL, MUTEX_DEFAULT, NULL);
5833 
5834         mutex_init(&non_ff_drv_mutex, NULL, MUTEX_DEFAULT, NULL);
5835 }
5836 
5837 /* module specific uninitilization (undo init_init()) */
5838 static void
5839 fini_uninit()
5840 {
5841         kmem_cache_destroy(mirror_parent_cache);
5842         kmem_cache_destroy(mirror_child_cache);
5843         kmem_cache_destroy(mirror_wowblk_cache);
5844         mirror_parent_cache = mirror_child_cache =
5845             mirror_wowblk_cache = NULL;
5846 
5847         mutex_destroy(&mirror_timeout.dr_mx);
5848         mutex_destroy(&hotspare_request.dr_mx);
5849         mutex_destroy(&non_ff_drv_mutex);
5850 }
5851 
5852 /* define the module linkage */
5853 MD_PLUGIN_MISC_MODULE("mirrors module", init_init(), fini_uninit())