sys/geom/vinum/geom_vinum_events.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  *  Copyright (c) 2007 Lukas Ertl
   5  *  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/kernel.h>
  35 #include <sys/lock.h>
  36 #include <sys/malloc.h>
  37 #include <sys/mutex.h>
  38 #include <sys/systm.h>
  39
  40 #include <geom/geom.h>
  41 #include <geom/geom_dbg.h>
  42 #include <geom/vinum/geom_vinum_var.h>
  43 #include <geom/vinum/geom_vinum.h>
  44
  45 void
  46 gv_post_event(struct gv_softc *sc, int event, void *arg1, void *arg2,
  47     intmax_t arg3, intmax_t arg4)
  48 {
  49         struct gv_event *ev;
  50
  51         ev = g_malloc(sizeof(*ev), M_WAITOK | M_ZERO);
  52         ev->type = event;
  53         ev->arg1 = arg1;
  54         ev->arg2 = arg2;
  55         ev->arg3 = arg3;
  56         ev->arg4 = arg4;
  57
  58         mtx_lock(&sc->equeue_mtx);
  59         TAILQ_INSERT_TAIL(&sc->equeue, ev, events);
  60         wakeup(sc);
  61         mtx_unlock(&sc->equeue_mtx);
  62 }
  63
  64 void
  65 gv_worker_exit(struct gv_softc *sc)
  66 {
  67         struct gv_event *ev;
  68
  69         ev = g_malloc(sizeof(*ev), M_WAITOK | M_ZERO);
  70         ev->type = GV_EVENT_THREAD_EXIT;
  71
  72         mtx_lock(&sc->equeue_mtx);
  73         TAILQ_INSERT_TAIL(&sc->equeue, ev, events);
  74         wakeup(sc);
  75         msleep(sc->worker, &sc->equeue_mtx, PDROP, "gv_wor", 0);
  76 }
  77
  78 struct gv_event *
  79 gv_get_event(struct gv_softc *sc)
  80 {
  81         struct gv_event *ev;
  82
  83         KASSERT(sc != NULL, ("NULL sc"));
  84         mtx_lock(&sc->equeue_mtx);
  85         ev = TAILQ_FIRST(&sc->equeue);
  86         mtx_unlock(&sc->equeue_mtx);
  87         return (ev);
  88 }
  89
  90 void
  91 gv_remove_event(struct gv_softc *sc, struct gv_event *ev)
  92 {
  93
  94         KASSERT(sc != NULL, ("NULL sc"));
  95         KASSERT(ev != NULL, ("NULL ev"));
  96         mtx_lock(&sc->equeue_mtx);
  97         TAILQ_REMOVE(&sc->equeue, ev, events);
  98         mtx_unlock(&sc->equeue_mtx);
  99 }
 100
 101 void
 102 gv_drive_tasted(struct gv_softc *sc, struct g_provider *pp)
 103 {
 104         struct g_geom *gp;
 105         struct g_consumer *cp;
 106         struct gv_hdr *hdr;
 107         struct gv_drive *d;
 108         char *buf;
 109         int error;
 110
 111         hdr = NULL;
 112         buf = NULL;
 113
 114         G_VINUM_DEBUG(2, "tasted drive on '%s'", pp->name);
 115         if ((GV_CFG_OFFSET % pp->sectorsize) != 0 ||
 116             (GV_CFG_LEN % pp->sectorsize) != 0) {
 117                 G_VINUM_DEBUG(0, "provider %s has unsupported sectorsize.",
 118                     pp->name);
 119                 return;
 120         }
 121
 122         gp = sc->geom;
 123         g_topology_lock();
 124         cp = g_new_consumer(gp);
 125         if (g_attach(cp, pp) != 0) {
 126                 g_destroy_consumer(cp);
 127                 g_topology_unlock();
 128                 G_VINUM_DEBUG(0, "failed to attach to provider on taste event");
 129                 return;
 130         }
 131         if (g_access(cp, 1, 0, 0) != 0) {
 132                 g_detach(cp);
 133                 g_destroy_consumer(cp);
 134                 g_topology_unlock();
 135                 G_VINUM_DEBUG(0, "failed to access consumer on taste event");
 136                 return;
 137         }
 138         g_topology_unlock();
 139
 140         hdr = g_malloc(GV_HDR_LEN, M_WAITOK | M_ZERO);
 141         /* Read header and on-disk configuration. */
 142         error = gv_read_header(cp, hdr);
 143         if (error) {
 144                 G_VINUM_DEBUG(0, "failed to read header during taste");
 145                 goto failed;
 146         }
 147
 148         /*
 149          * Setup the drive before we parse the on-disk configuration, so that
 150          * we already know about the drive then.
 151          */
 152         d = gv_find_drive(sc, hdr->label.name);
 153         if (d == NULL) {
 154                 d = g_malloc(sizeof(*d), M_WAITOK | M_ZERO);
 155                 strlcpy(d->name, hdr->label.name, sizeof(d->name));
 156                 strlcpy(d->device, pp->name, sizeof(d->device));
 157         } else if (d->flags & GV_DRIVE_REFERENCED) {
 158                 strlcpy(d->device, pp->name, sizeof(d->device));
 159                 d->flags &= ~GV_DRIVE_REFERENCED;
 160         } else {
 161                 G_VINUM_DEBUG(2, "drive '%s' is already known", d->name);
 162                 goto failed;
 163         }
 164
 165         /* Add the consumer and header to the new drive. */
 166         d->consumer = cp;
 167         d->hdr = hdr;
 168         gv_create_drive(sc, d);
 169
 170         buf = g_read_data(cp, GV_CFG_OFFSET, GV_CFG_LEN, NULL);
 171         if (buf == NULL) {
 172                 G_VINUM_DEBUG(0, "failed to read config during taste");
 173                 goto failed;
 174         }
 175         gv_parse_config(sc, buf, d);
 176         g_free(buf);
 177
 178         g_topology_lock();
 179         g_access(cp, -1, 0, 0);
 180         g_topology_unlock();
 181
 182         gv_setup_objects(sc);
 183         gv_set_drive_state(d, GV_DRIVE_UP, 0);
 184
 185         return;
 186
 187 failed:
 188         if (hdr != NULL)
 189                 g_free(hdr);
 190         g_topology_lock();
 191         g_access(cp, -1, 0, 0);
 192         g_detach(cp);
 193         g_destroy_consumer(cp);
 194         g_topology_unlock();
 195 }
 196
 197 /*
 198  * Count completed BIOs and handle orphanization when all are done.
 199  */
 200 void
 201 gv_drive_done(struct gv_drive *d)
 202 {
 203
 204         KASSERT(d->active >= 0, ("Negative number of BIOs (%d)", d->active));
 205         if (--d->active == 0 && (d->flags & GV_DRIVE_ORPHANED)) {
 206                 d->flags &= ~GV_DRIVE_ORPHANED;
 207                 gv_post_event(d->vinumconf, GV_EVENT_DRIVE_LOST, d, NULL, 0, 0);
 208         }
 209 }
 210
 211 /*
 212  * When losing a drive (e.g. hardware failure), we cut down the consumer
 213  * attached to the underlying device and bring the drive itself to a
 214  * "referenced" state so that normal tasting could bring it up cleanly if it
 215  * possibly arrives again.
 216  */
 217 void
 218 gv_drive_lost(struct gv_softc *sc, struct gv_drive *d)
 219 {
 220         struct g_consumer *cp;
 221         struct gv_drive *d2;
 222         struct gv_sd *s, *s2;
 223         struct gv_freelist *fl, *fl2;
 224
 225         gv_set_drive_state(d, GV_DRIVE_DOWN,
 226             GV_SETSTATE_FORCE | GV_SETSTATE_CONFIG);
 227
 228         cp = d->consumer;
 229
 230         if (cp != NULL) {
 231                 if (d->active > 0) {
 232                         G_VINUM_DEBUG(2, "dead drive '%s' has still active "
 233                             "requests, unable to detach consumer", d->name);
 234                         d->flags |= GV_DRIVE_ORPHANED;
 235                         return;
 236                 }
 237                 g_topology_lock();
 238                 if (cp->acr != 0 || cp->acw != 0 || cp->ace != 0)
 239                         g_access(cp, -cp->acr, -cp->acw, -cp->ace);
 240                 g_detach(cp);
 241                 g_destroy_consumer(cp);
 242                 g_topology_unlock();
 243         }
 244
 245         LIST_FOREACH_SAFE(fl, &d->freelist, freelist, fl2) {
 246                 LIST_REMOVE(fl, freelist);
 247                 g_free(fl);
 248         }
 249
 250         d->consumer = NULL;
 251         g_free(d->hdr);
 252         d->hdr = NULL;
 253         d->flags |= GV_DRIVE_REFERENCED;
 254         snprintf(d->device, sizeof(d->device), "???");
 255         d->size = 0;
 256         d->avail = 0;
 257         d->freelist_entries = 0;
 258         d->sdcount = 0;
 259
 260         /* Put the subdisk in tasted mode, and remove from drive list. */
 261         LIST_FOREACH_SAFE(s, &d->subdisks, from_drive, s2) {
 262                 LIST_REMOVE(s, from_drive);
 263                 s->flags |= GV_SD_TASTED;
 264         }
 265
 266         /*
 267          * Don't forget that gv_is_newer wants a "real" drive at the beginning
 268          * of the list, so, just to be safe, we shuffle around.
 269          */
 270         LIST_REMOVE(d, drive);
 271         d2 = LIST_FIRST(&sc->drives);
 272         if (d2 == NULL)
 273                 LIST_INSERT_HEAD(&sc->drives, d, drive);
 274         else
 275                 LIST_INSERT_AFTER(d2, d, drive);
 276         gv_save_config(sc);
 277 }