usr/src/uts/common/io/lvm/raid/raid_hotspare.c

   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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 #pragma ident   "%Z%%M% %I%     %E% SMI"
  23
  24 /*
  25  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  26  * Use is subject to license terms.
  27  */
  28
  29 /*
  30  * NAME:        raid_hotspare.c
  31  * DESCRIPTION: RAID driver source file containing routines related to
  32  *              hospare operation.
  33  * ROUTINES PROVIDED FOR EXTERNAL USE:
  34  * raid_hs_release() - release a hotspare device
  35  *  raid_hotspares() - prompt the hospare daemon to attempt needed hotspare work
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/conf.h>
  41 #include <sys/file.h>
  42 #include <sys/user.h>
  43 #include <sys/uio.h>
  44 #include <sys/t_lock.h>
  45 #include <sys/buf.h>
  46 #include <sys/dkio.h>
  47 #include <sys/vtoc.h>
  48 #include <sys/kmem.h>
  49 #include <vm/page.h>
  50 #include <sys/sysmacros.h>
  51 #include <sys/types.h>
  52 #include <sys/mkdev.h>
  53 #include <sys/stat.h>
  54 #include <sys/open.h>
  55 #include <sys/lvm/md_raid.h>
  56 #include <sys/modctl.h>
  57 #include <sys/ddi.h>
  58 #include <sys/sunddi.h>
  59 #include <sys/debug.h>
  60
  61 #include <sys/sysevent/eventdefs.h>
  62 #include <sys/sysevent/svm.h>
  63
  64 extern mdq_anchor_t     md_hs_daemon;
  65 static daemon_request_t hotspare_request;
  66
  67 extern md_set_t         md_set[];
  68 extern md_ops_t         raid_md_ops;
  69
  70 /*
  71  * NAME:        raid_hs_release
  72  *
  73  * DESCRIPTION: Release the hotspare.
  74  *
  75  * PARAMETERS:  int error - indication of error on hotspare
  76  *              mr_unit_t  *un - raid unit
  77  *              mddb_recid_t  *recids - output records to commit revised hs info
  78  *              int hs_index - component to release
  79  *
  80  * LOCKS:       Expects Unit Writer Lock to be held across call.
  81  */
  82 void
  83 raid_hs_release(
  84         hs_cmds_t       cmd,
  85         mr_unit_t       *un,
  86         mddb_recid_t    *recids,
  87         int             hs_index
  88 )
  89 {
  90         mr_column_t     *col;
  91
  92         col = &un->un_column[hs_index];
  93
  94         /* close the hotspare device */
  95         if (col->un_devflags & MD_RAID_DEV_ISOPEN) {
  96                 md_layered_close(col->un_dev, MD_OFLG_NULL);
  97                 col->un_devflags &= ~MD_RAID_DEV_ISOPEN;
  98         }
  99
 100         /* return the hotspare to the pool */
 101         (void) md_hot_spare_ifc(cmd, un->un_hsp_id, 0, 0, recids,
 102             &col->un_hs_key, NULL, NULL);
 103
 104         col->un_hs_pwstart = 0;
 105         col->un_hs_devstart = 0;
 106         col->un_hs_id = (mddb_recid_t)0;
 107         col->un_hs_key = 0;
 108 }
 109
 110
 111 /*
 112  * NAME:        check_comp_4_hs
 113  *
 114  * DESCRIPTION: Check whether the input component has an error and can be
 115  *              backed with a hot spare (RCS_ERRED state), and initiate
 116  *              a resync if so.
 117  *
 118  * PARAMETERS:  mr_unit_t *un - raid unit
 119  *              int hs_index    - component to check
 120  *
 121  * LOCKS:       Expects Unit Writer Lock to be held upon entrance.  Releases
 122  *              the lock prior to calling raid_resync_unit, then reacquires
 123  *              it before returning.
 124  */
 125 static void
 126 check_comp_4_hs(
 127         mr_unit_t *un,
 128         int hs_index
 129 )
 130 {
 131         mddb_recid_t    recids[3];
 132         minor_t         mnum = MD_SID(un);
 133         mdi_unit_t      *ui;
 134         rcs_state_t     state;
 135         diskaddr_t      size;
 136         int             err;
 137         mr_column_t     *col;
 138         md_error_t      mde = mdnullerror;
 139         char            devname[MD_MAX_CTDLEN];
 140         char            hs_devname[MD_MAX_CTDLEN];
 141         set_t           setno;
 142         md_dev64_t      tmpdev;
 143         diskaddr_t      tmpdaddr;
 144
 145
 146         /* initialize */
 147         setno = MD_UN2SET(un);
 148         ui = MDI_UNIT(mnum);
 149         md_unit_readerexit(ui);
 150         (void) md_io_writerlock(ui);
 151         un = (mr_unit_t *)md_unit_writerlock(ui);
 152         col = &un->un_column[hs_index];
 153
 154         /*
 155          * add a hotspare for erred column only if not resyncing
 156          */
 157         if ((!(COLUMN_STATE(un, hs_index) & RCS_ERRED)) ||
 158             (raid_state_cnt(un, (RCS_ERRED | RCS_LAST_ERRED)) != 1) ||
 159             (raid_state_cnt(un, RCS_RESYNC) > 0)) {
 160                 goto errout;
 161         }
 162
 163         recids[0] = 0;
 164         recids[1] = 0;
 165         /* if there is already a hotspare then just return */
 166         if (HOTSPARED(un, hs_index) && (col->un_devstate & RCS_ERRED)) {
 167                 raid_hs_release(HS_BAD, un, &recids[0], hs_index);
 168                 cmn_err(CE_WARN, "md: %s: %s hotspare errored and released",
 169                     md_shortname(mnum),
 170                     md_devname(MD_MIN2SET(mnum), col->un_dev, NULL, 0));
 171                 col->un_dev = col->un_orig_dev;
 172                 col->un_pwstart = col->un_orig_pwstart;
 173                 col->un_devstart = col->un_orig_devstart;
 174                 raid_commit(un, recids);
 175
 176                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HS_FREED, SVM_TAG_METADEVICE,
 177                     setno, MD_SID(un));
 178         }
 179         ASSERT(!HOTSPARED(un, hs_index));
 180
 181         state = col->un_devstate;
 182         size = col->un_pwstart + un->un_pwsize +
 183             (un->un_segsize * un->un_segsincolumn);
 184
 185 again:
 186         /* quit if resync is already active */
 187         col->un_devflags |= MD_RAID_REGEN_RESYNC;
 188         if (resync_request(mnum, hs_index, 0, NULL))
 189                 goto errout;
 190
 191         recids[0] = 0;
 192         recids[1] = 0;
 193
 194         tmpdev = col->un_dev;
 195         tmpdaddr = col->un_hs_pwstart;
 196
 197         /* get a hotspare */
 198         if (md_hot_spare_ifc(HS_GET, un->un_hsp_id, size,
 199             ((col->un_orig_pwstart >= 1) &&
 200             (col->un_orig_pwstart != MD_DISKADDR_ERROR)),
 201             &col->un_hs_id, &col->un_hs_key, &tmpdev, &tmpdaddr) != 0) {
 202                 col->un_dev = tmpdev;
 203                 col->un_hs_pwstart = tmpdaddr;
 204                 release_resync_request(mnum);
 205                 raid_set_state(un, hs_index, state, 1);
 206                 goto errout;
 207         }
 208
 209         col->un_hs_pwstart = tmpdaddr;
 210
 211         /*
 212          * record id is filled in by raid_commit, recids[0] filled in by
 213          * md_hot_spare_ifc if needed
 214          */
 215         recids[0] = col->un_hs_id;
 216         recids[1] = 0;
 217
 218         /*
 219          * close the device and open the hot spare.  The device should
 220          * never be a hotspare here.
 221          */
 222         if (col->un_devflags & MD_RAID_DEV_ISOPEN) {
 223                 md_layered_close(col->un_orig_dev, MD_OFLG_NULL);
 224                 col->un_devflags &= ~MD_RAID_DEV_ISOPEN;
 225         }
 226         /*
 227          * Try open by device id
 228          */
 229         tmpdev = md_resolve_bydevid(mnum, tmpdev, col->un_hs_key);
 230         if (md_layered_open(mnum, &tmpdev, MD_OFLG_NULL)) {
 231                 md_dev64_t hs_dev = tmpdev;
 232                 /* cannot open return to orig */
 233                 raid_hs_release(HS_BAD, un, &recids[0], hs_index);
 234                 release_resync_request(mnum);
 235                 raid_set_state(un, hs_index, state, 1);
 236                 col->un_dev = col->un_orig_dev;
 237                 col->un_devstart = col->un_orig_devstart;
 238                 col->un_pwstart = col->un_orig_pwstart;
 239                 col->un_devflags &= ~MD_RAID_DEV_ISOPEN;
 240                 raid_commit(un, recids);
 241                 cmn_err(CE_WARN, "md: %s: open error of hotspare %s",
 242                     md_shortname(mnum),
 243                     md_devname(MD_MIN2SET(mnum), hs_dev, NULL, 0));
 244                 SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HS_FREED, SVM_TAG_HS, setno,
 245                     MD_SID(un));
 246                 goto again;
 247         }
 248
 249         col->un_dev = tmpdev;
 250
 251         col->un_devflags |= MD_RAID_DEV_ISOPEN;
 252
 253         /*
 254          * move the values into the device fields.  Since in some cases
 255          * the pwstart is not zero this must be added into the start of
 256          * the hotspare to avoid over writting the label
 257          */
 258         col->un_hs_pwstart += col->un_orig_pwstart;
 259         col->un_pwstart = col->un_hs_pwstart;
 260         col->un_hs_devstart = col->un_hs_pwstart + un->un_pwsize;
 261         col->un_devstart = col->un_hs_devstart;
 262
 263         /* commit unit and hotspare records and release lock */
 264         raid_commit(un, recids);
 265         md_unit_writerexit(ui);
 266         md_io_writerexit(ui);
 267
 268         err = raid_resync_unit(mnum, &mde);
 269
 270         /* if resync fails, transition back to erred state and reset */
 271         if (err) {
 272                 /* reaquire unit writerr lock */
 273                 un = (mr_unit_t *)md_unit_writerlock(ui);
 274
 275                 raid_set_state(un, hs_index, RCS_ERRED, 0);
 276
 277                 /*
 278                  * close the hotspare and return it.  Then restore the
 279                  * original device back to the original state
 280                  */
 281                 raid_hs_release(HS_FREE, un, &recids[0], hs_index);
 282                 col->un_dev = col->un_orig_dev;
 283                 col->un_devstart = col->un_orig_devstart;
 284                 col->un_pwstart = col->un_orig_pwstart;
 285                 raid_commit(un, recids);
 286                 md_unit_writerexit(ui);
 287                 un = (mr_unit_t *)md_unit_readerlock(ui);
 288                 return;
 289         }
 290
 291         setno = MD_MIN2SET(mnum);
 292
 293         (void) md_devname(setno, col->un_orig_dev, devname,
 294                 sizeof (devname));
 295         (void) md_devname(setno, col->un_dev, hs_devname,
 296                 sizeof (hs_devname));
 297
 298         cmn_err(CE_NOTE, "md: %s: hotspared device %s with %s",
 299             md_shortname(mnum), devname, hs_devname);
 300         SE_NOTIFY(EC_SVM_STATE, ESC_SVM_HOTSPARED, SVM_TAG_HS, setno,
 301             MD_SID(un));
 302         (void) md_unit_readerlock(ui);
 303         return;
 304
 305 errout:
 306         md_unit_writerexit(ui);
 307         md_io_writerexit(ui);
 308         un = (mr_unit_t *)md_unit_readerlock(ui);
 309 }
 310
 311 /*
 312  * NAME:        check_4_hs
 313  *
 314  * DESCRIPTION: Check every component of every raid unit for any device which
 315  *              needs to be backed with a hot spare.
 316  *
 317  * PARAMETERS:  daemon_request_t *dr - hotspare request daemon
 318  *
 319  * LOCKS:       Acquires and releases the Hotspare Request Lock and the RAID
 320  *              Driver Lock. Acquires the Unit Writer Lock which is released
 321  *              in check_comp_4_hs.
 322  */
 323 static void
 324 check_4_hs(daemon_request_t *dr)
 325 {
 326         mdi_unit_t      *ui;
 327         mr_unit_t       *un;
 328         md_link_t       *next;
 329         int             i;
 330
 331         mutex_enter(&dr->dr_mx);        /* clear up front so can poke */
 332         dr->dr_pending = 0;             /* again in low level routine if */
 333         mutex_exit(&dr->dr_mx);         /* something found to do        */
 334
 335         /*
 336          * Scan raid unit list and call component hotspare check routine for
 337          * each component of each unit where resync is inactive.
 338          */
 339         rw_enter(&raid_md_ops.md_link_rw.lock, RW_READER);
 340         for (next = raid_md_ops.md_head; next != NULL; next = next->ln_next) {
 341                 ui = MDI_UNIT(next->ln_id);
 342                 un = (mr_unit_t *)md_unit_readerlock(ui);
 343                 if (!(un->c.un_status & MD_UN_RESYNC_ACTIVE) &&
 344                     (raid_state_cnt(un, RCS_RESYNC) == 0) &&
 345                     (UNIT_STATE(un) & RUS_ERRED) &&
 346                     (un->un_hsp_id != -1) &&
 347                     (raid_state_cnt(un, RCS_ERRED) == 1)) {
 348                         for (i = 0; i < un->un_totalcolumncnt; i++)
 349                                 if (un->un_column[i].un_devstate == RCS_ERRED)
 350                                         check_comp_4_hs(un, i);
 351                 }
 352                 md_unit_readerexit(ui);
 353         }
 354         rw_exit(&raid_md_ops.md_link_rw.lock);
 355 }
 356
 357 /*
 358  * NAME:        raid_hotspares
 359  *
 360  * DESCRIPTION: Initiate a check of all RAID devices for components which
 361  *              may require a hot spare, if it is not already running.
 362  *
 363  * PARAMETERS:  NONE
 364  *
 365  * LOCKS:       Acquires and releases the Hotspare Request Lock.
 366  */
 367 intptr_t
 368 raid_hotspares()
 369 {
 370         /* if available, make request for hotspare to master daemon */
 371         mutex_enter(&hotspare_request.dr_mx);
 372         if (hotspare_request.dr_pending == 0) {
 373                 hotspare_request.dr_pending = 1;
 374                 daemon_request(&md_hs_daemon,
 375                     check_4_hs, (daemon_queue_t *)&hotspare_request, REQ_OLD);
 376         }
 377         mutex_exit(&hotspare_request.dr_mx);
 378         return (0);
 379 }