sys/geom/raid/tr_concat.c

   1 /*-
   2  * Copyright (c) 2010 Alexander Motin <mav@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/bio.h>
  32 #include <sys/endian.h>
  33 #include <sys/kernel.h>
  34 #include <sys/kobj.h>
  35 #include <sys/lock.h>
  36 #include <sys/malloc.h>
  37 #include <sys/mutex.h>
  38 #include <sys/systm.h>
  39 #include <geom/geom.h>
  40 #include "geom/raid/g_raid.h"
  41 #include "g_raid_tr_if.h"
  42
  43 static MALLOC_DEFINE(M_TR_CONCAT, "tr_concat_data", "GEOM_RAID CONCAT data");
  44
  45 struct g_raid_tr_concat_object {
  46         struct g_raid_tr_object  trso_base;
  47         int                      trso_starting;
  48         int                      trso_stopped;
  49 };
  50
  51 static g_raid_tr_taste_t g_raid_tr_taste_concat;
  52 static g_raid_tr_event_t g_raid_tr_event_concat;
  53 static g_raid_tr_start_t g_raid_tr_start_concat;
  54 static g_raid_tr_stop_t g_raid_tr_stop_concat;
  55 static g_raid_tr_iostart_t g_raid_tr_iostart_concat;
  56 static g_raid_tr_iodone_t g_raid_tr_iodone_concat;
  57 static g_raid_tr_kerneldump_t g_raid_tr_kerneldump_concat;
  58 static g_raid_tr_free_t g_raid_tr_free_concat;
  59
  60 static kobj_method_t g_raid_tr_concat_methods[] = {
  61         KOBJMETHOD(g_raid_tr_taste,     g_raid_tr_taste_concat),
  62         KOBJMETHOD(g_raid_tr_event,     g_raid_tr_event_concat),
  63         KOBJMETHOD(g_raid_tr_start,     g_raid_tr_start_concat),
  64         KOBJMETHOD(g_raid_tr_stop,      g_raid_tr_stop_concat),
  65         KOBJMETHOD(g_raid_tr_iostart,   g_raid_tr_iostart_concat),
  66         KOBJMETHOD(g_raid_tr_iodone,    g_raid_tr_iodone_concat),
  67         KOBJMETHOD(g_raid_tr_kerneldump,        g_raid_tr_kerneldump_concat),
  68         KOBJMETHOD(g_raid_tr_free,      g_raid_tr_free_concat),
  69         { 0, 0 }
  70 };
  71
  72 static struct g_raid_tr_class g_raid_tr_concat_class = {
  73         "CONCAT",
  74         g_raid_tr_concat_methods,
  75         sizeof(struct g_raid_tr_concat_object),
  76         .trc_enable = 1,
  77         .trc_priority = 50
  78 };
  79
  80 static int
  81 g_raid_tr_taste_concat(struct g_raid_tr_object *tr, struct g_raid_volume *volume)
  82 {
  83         struct g_raid_tr_concat_object *trs;
  84
  85         trs = (struct g_raid_tr_concat_object *)tr;
  86         if (tr->tro_volume->v_raid_level != G_RAID_VOLUME_RL_SINGLE &&
  87             tr->tro_volume->v_raid_level != G_RAID_VOLUME_RL_CONCAT &&
  88             !(tr->tro_volume->v_disks_count == 1 &&
  89               tr->tro_volume->v_raid_level != G_RAID_VOLUME_RL_UNKNOWN))
  90                 return (G_RAID_TR_TASTE_FAIL);
  91         trs->trso_starting = 1;
  92         return (G_RAID_TR_TASTE_SUCCEED);
  93 }
  94
  95 static int
  96 g_raid_tr_update_state_concat(struct g_raid_volume *vol)
  97 {
  98         struct g_raid_tr_concat_object *trs;
  99         struct g_raid_softc *sc;
 100         off_t size;
 101         u_int s;
 102         int i, n, f;
 103
 104         sc = vol->v_softc;
 105         trs = (struct g_raid_tr_concat_object *)vol->v_tr;
 106         if (trs->trso_stopped)
 107                 s = G_RAID_VOLUME_S_STOPPED;
 108         else if (trs->trso_starting)
 109                 s = G_RAID_VOLUME_S_STARTING;
 110         else {
 111                 n = g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_ACTIVE);
 112                 f = g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_FAILED);
 113                 if (n + f == vol->v_disks_count) {
 114                         if (f == 0)
 115                                 s = G_RAID_VOLUME_S_OPTIMAL;
 116                         else
 117                                 s = G_RAID_VOLUME_S_SUBOPTIMAL;
 118                 } else
 119                         s = G_RAID_VOLUME_S_BROKEN;
 120         }
 121         if (s != vol->v_state) {
 122
 123                 /*
 124                  * Some metadata modules may not know CONCAT volume
 125                  * mediasize until all disks connected. Recalculate.
 126                  */
 127                 if (vol->v_raid_level == G_RAID_VOLUME_RL_CONCAT &&
 128                     G_RAID_VOLUME_S_ALIVE(s) &&
 129                     !G_RAID_VOLUME_S_ALIVE(vol->v_state)) {
 130                         size = 0;
 131                         for (i = 0; i < vol->v_disks_count; i++) {
 132                                 if (vol->v_subdisks[i].sd_state !=
 133                                     G_RAID_SUBDISK_S_NONE)
 134                                         size += vol->v_subdisks[i].sd_size;
 135                         }
 136                         vol->v_mediasize = size;
 137                 }
 138
 139                 g_raid_event_send(vol, G_RAID_VOLUME_S_ALIVE(s) ?
 140                     G_RAID_VOLUME_E_UP : G_RAID_VOLUME_E_DOWN,
 141                     G_RAID_EVENT_VOLUME);
 142                 g_raid_change_volume_state(vol, s);
 143                 if (!trs->trso_starting && !trs->trso_stopped)
 144                         g_raid_write_metadata(sc, vol, NULL, NULL);
 145         }
 146         return (0);
 147 }
 148
 149 static int
 150 g_raid_tr_event_concat(struct g_raid_tr_object *tr,
 151     struct g_raid_subdisk *sd, u_int event)
 152 {
 153         struct g_raid_tr_concat_object *trs;
 154         struct g_raid_softc *sc;
 155         struct g_raid_volume *vol;
 156         int state;
 157
 158         trs = (struct g_raid_tr_concat_object *)tr;
 159         vol = tr->tro_volume;
 160         sc = vol->v_softc;
 161
 162         state = sd->sd_state;
 163         if (state != G_RAID_SUBDISK_S_NONE &&
 164             state != G_RAID_SUBDISK_S_FAILED &&
 165             state != G_RAID_SUBDISK_S_ACTIVE) {
 166                 G_RAID_DEBUG1(1, sc,
 167                     "Promote subdisk %s:%d from %s to ACTIVE.",
 168                     vol->v_name, sd->sd_pos,
 169                     g_raid_subdisk_state2str(sd->sd_state));
 170                 g_raid_change_subdisk_state(sd, G_RAID_SUBDISK_S_ACTIVE);
 171         }
 172         if (state != sd->sd_state &&
 173             !trs->trso_starting && !trs->trso_stopped)
 174                 g_raid_write_metadata(sc, vol, sd, NULL);
 175         g_raid_tr_update_state_concat(vol);
 176         return (0);
 177 }
 178
 179 static int
 180 g_raid_tr_start_concat(struct g_raid_tr_object *tr)
 181 {
 182         struct g_raid_tr_concat_object *trs;
 183         struct g_raid_volume *vol;
 184
 185         trs = (struct g_raid_tr_concat_object *)tr;
 186         vol = tr->tro_volume;
 187         trs->trso_starting = 0;
 188         g_raid_tr_update_state_concat(vol);
 189         return (0);
 190 }
 191
 192 static int
 193 g_raid_tr_stop_concat(struct g_raid_tr_object *tr)
 194 {
 195         struct g_raid_tr_concat_object *trs;
 196         struct g_raid_volume *vol;
 197
 198         trs = (struct g_raid_tr_concat_object *)tr;
 199         vol = tr->tro_volume;
 200         trs->trso_starting = 0;
 201         trs->trso_stopped = 1;
 202         g_raid_tr_update_state_concat(vol);
 203         return (0);
 204 }
 205
 206 static void
 207 g_raid_tr_iostart_concat(struct g_raid_tr_object *tr, struct bio *bp)
 208 {
 209         struct g_raid_volume *vol;
 210         struct g_raid_subdisk *sd;
 211         struct bio_queue_head queue;
 212         struct bio *cbp;
 213         char *addr;
 214         off_t offset, length, remain;
 215         u_int no;
 216
 217         vol = tr->tro_volume;
 218         if (vol->v_state != G_RAID_VOLUME_S_OPTIMAL &&
 219             vol->v_state != G_RAID_VOLUME_S_SUBOPTIMAL) {
 220                 g_raid_iodone(bp, EIO);
 221                 return;
 222         }
 223         if (bp->bio_cmd == BIO_FLUSH) {
 224                 g_raid_tr_flush_common(tr, bp);
 225                 return;
 226         }
 227
 228         offset = bp->bio_offset;
 229         remain = bp->bio_length;
 230         addr = bp->bio_data;
 231         no = 0;
 232         while (no < vol->v_disks_count &&
 233             offset >= vol->v_subdisks[no].sd_size) {
 234                 offset -= vol->v_subdisks[no].sd_size;
 235                 no++;
 236         }
 237         KASSERT(no < vol->v_disks_count,
 238             ("Request starts after volume end (%ju)", bp->bio_offset));
 239         bioq_init(&queue);
 240         do {
 241                 sd = &vol->v_subdisks[no];
 242                 length = MIN(sd->sd_size - offset, remain);
 243                 cbp = g_clone_bio(bp);
 244                 if (cbp == NULL)
 245                         goto failure;
 246                 cbp->bio_offset = offset;
 247                 cbp->bio_data = addr;
 248                 cbp->bio_length = length;
 249                 cbp->bio_caller1 = sd;
 250                 bioq_insert_tail(&queue, cbp);
 251                 remain -= length;
 252                 if (bp->bio_cmd != BIO_DELETE)
 253                         addr += length;
 254                 offset = 0;
 255                 no++;
 256                 KASSERT(no < vol->v_disks_count || remain == 0,
 257                     ("Request ends after volume end (%ju, %ju)",
 258                         bp->bio_offset, bp->bio_length));
 259         } while (remain > 0);
 260         for (cbp = bioq_first(&queue); cbp != NULL;
 261             cbp = bioq_first(&queue)) {
 262                 bioq_remove(&queue, cbp);
 263                 sd = cbp->bio_caller1;
 264                 cbp->bio_caller1 = NULL;
 265                 g_raid_subdisk_iostart(sd, cbp);
 266         }
 267         return;
 268 failure:
 269         for (cbp = bioq_first(&queue); cbp != NULL;
 270             cbp = bioq_first(&queue)) {
 271                 bioq_remove(&queue, cbp);
 272                 g_destroy_bio(cbp);
 273         }
 274         if (bp->bio_error == 0)
 275                 bp->bio_error = ENOMEM;
 276         g_raid_iodone(bp, bp->bio_error);
 277 }
 278
 279 static int
 280 g_raid_tr_kerneldump_concat(struct g_raid_tr_object *tr,
 281     void *virtual, vm_offset_t physical, off_t boffset, size_t blength)
 282 {
 283         struct g_raid_volume *vol;
 284         struct g_raid_subdisk *sd;
 285         char *addr;
 286         off_t offset, length, remain;
 287         int error, no;
 288
 289         vol = tr->tro_volume;
 290         if (vol->v_state != G_RAID_VOLUME_S_OPTIMAL)
 291                 return (ENXIO);
 292
 293         offset = boffset;
 294         remain = blength;
 295         addr = virtual;
 296         no = 0;
 297         while (no < vol->v_disks_count &&
 298             offset >= vol->v_subdisks[no].sd_size) {
 299                 offset -= vol->v_subdisks[no].sd_size;
 300                 no++;
 301         }
 302         KASSERT(no < vol->v_disks_count,
 303             ("Request starts after volume end (%ju)", boffset));
 304         do {
 305                 sd = &vol->v_subdisks[no];
 306                 length = MIN(sd->sd_size - offset, remain);
 307                 error = g_raid_subdisk_kerneldump(&vol->v_subdisks[no],
 308                     addr, 0, offset, length);
 309                 if (error != 0)
 310                         return (error);
 311                 remain -= length;
 312                 addr += length;
 313                 offset = 0;
 314                 no++;
 315                 KASSERT(no < vol->v_disks_count || remain == 0,
 316                     ("Request ends after volume end (%ju, %zu)",
 317                         boffset, blength));
 318         } while (remain > 0);
 319         return (0);
 320 }
 321
 322 static void
 323 g_raid_tr_iodone_concat(struct g_raid_tr_object *tr,
 324     struct g_raid_subdisk *sd,struct bio *bp)
 325 {
 326         struct bio *pbp;
 327
 328         pbp = bp->bio_parent;
 329         if (pbp->bio_error == 0)
 330                 pbp->bio_error = bp->bio_error;
 331         g_destroy_bio(bp);
 332         pbp->bio_inbed++;
 333         if (pbp->bio_children == pbp->bio_inbed) {
 334                 pbp->bio_completed = pbp->bio_length;
 335                 g_raid_iodone(pbp, bp->bio_error);
 336         }
 337 }
 338
 339 static int
 340 g_raid_tr_free_concat(struct g_raid_tr_object *tr)
 341 {
 342
 343         return (0);
 344 }
 345
 346 G_RAID_TR_DECLARE(concat, "CONCAT");