189b17223SAlexander Motin /*- 289b17223SAlexander Motin * Copyright (c) 2011 Alexander Motin <mav@FreeBSD.org> 3*e26083caSAlexander Motin * Copyright (c) 2000 - 2008 Søren Schmidt <sos@FreeBSD.org> 489b17223SAlexander Motin * All rights reserved. 589b17223SAlexander Motin * 689b17223SAlexander Motin * Redistribution and use in source and binary forms, with or without 789b17223SAlexander Motin * modification, are permitted provided that the following conditions 889b17223SAlexander Motin * are met: 989b17223SAlexander Motin * 1. Redistributions of source code must retain the above copyright 1089b17223SAlexander Motin * notice, this list of conditions and the following disclaimer. 1189b17223SAlexander Motin * 2. Redistributions in binary form must reproduce the above copyright 1289b17223SAlexander Motin * notice, this list of conditions and the following disclaimer in the 1389b17223SAlexander Motin * documentation and/or other materials provided with the distribution. 1489b17223SAlexander Motin * 1589b17223SAlexander Motin * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 1689b17223SAlexander Motin * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1789b17223SAlexander Motin * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1889b17223SAlexander Motin * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 1989b17223SAlexander Motin * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2089b17223SAlexander Motin * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2189b17223SAlexander Motin * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2289b17223SAlexander Motin * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2389b17223SAlexander Motin * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2489b17223SAlexander Motin * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2589b17223SAlexander Motin * SUCH DAMAGE. 2689b17223SAlexander Motin */ 2789b17223SAlexander Motin 2889b17223SAlexander Motin #include <sys/cdefs.h> 2989b17223SAlexander Motin __FBSDID("$FreeBSD$"); 3089b17223SAlexander Motin 3189b17223SAlexander Motin #include <sys/param.h> 3289b17223SAlexander Motin #include <sys/bio.h> 3389b17223SAlexander Motin #include <sys/endian.h> 3489b17223SAlexander Motin #include <sys/kernel.h> 3589b17223SAlexander Motin #include <sys/kobj.h> 3689b17223SAlexander Motin #include <sys/limits.h> 3789b17223SAlexander Motin #include <sys/lock.h> 3889b17223SAlexander Motin #include <sys/malloc.h> 3989b17223SAlexander Motin #include <sys/mutex.h> 4089b17223SAlexander Motin #include <sys/systm.h> 4189b17223SAlexander Motin #include <geom/geom.h> 4289b17223SAlexander Motin #include "geom/raid/g_raid.h" 4389b17223SAlexander Motin #include "g_raid_md_if.h" 4489b17223SAlexander Motin 4589b17223SAlexander Motin static MALLOC_DEFINE(M_MD_PROMISE, "md_promise_data", "GEOM_RAID Promise metadata"); 4689b17223SAlexander Motin 4789b17223SAlexander Motin #define PROMISE_MAX_DISKS 8 4889b17223SAlexander Motin #define PROMISE_MAX_SUBDISKS 2 4989b17223SAlexander Motin #define PROMISE_META_OFFSET 14 5089b17223SAlexander Motin 5189b17223SAlexander Motin struct promise_raid_disk { 5289b17223SAlexander Motin uint8_t flags; /* Subdisk status. */ 5389b17223SAlexander Motin #define PROMISE_F_VALID 0x01 5489b17223SAlexander Motin #define PROMISE_F_ONLINE 0x02 5589b17223SAlexander Motin #define PROMISE_F_ASSIGNED 0x04 5689b17223SAlexander Motin #define PROMISE_F_SPARE 0x08 5789b17223SAlexander Motin #define PROMISE_F_DUPLICATE 0x10 5889b17223SAlexander Motin #define PROMISE_F_REDIR 0x20 5989b17223SAlexander Motin #define PROMISE_F_DOWN 0x40 6089b17223SAlexander Motin #define PROMISE_F_READY 0x80 6189b17223SAlexander Motin 6289b17223SAlexander Motin uint8_t number; /* Position in a volume. */ 6389b17223SAlexander Motin uint8_t channel; /* ATA channel number. */ 6489b17223SAlexander Motin uint8_t device; /* ATA device number. */ 6589b17223SAlexander Motin uint64_t id __packed; /* Subdisk ID. */ 6689b17223SAlexander Motin } __packed; 6789b17223SAlexander Motin 6889b17223SAlexander Motin struct promise_raid_conf { 6989b17223SAlexander Motin char promise_id[24]; 7089b17223SAlexander Motin #define PROMISE_MAGIC "Promise Technology, Inc." 7189b17223SAlexander Motin #define FREEBSD_MAGIC "FreeBSD ATA driver RAID " 7289b17223SAlexander Motin 7389b17223SAlexander Motin uint32_t dummy_0; 7489b17223SAlexander Motin uint64_t magic_0; 7589b17223SAlexander Motin #define PROMISE_MAGIC0(x) (((uint64_t)(x.channel) << 48) | \ 7689b17223SAlexander Motin ((uint64_t)(x.device != 0) << 56)) 7789b17223SAlexander Motin uint16_t magic_1; 7889b17223SAlexander Motin uint32_t magic_2; 7989b17223SAlexander Motin uint8_t filler1[470]; 8089b17223SAlexander Motin 8189b17223SAlexander Motin uint32_t integrity; 8289b17223SAlexander Motin #define PROMISE_I_VALID 0x00000080 8389b17223SAlexander Motin 8489b17223SAlexander Motin struct promise_raid_disk disk; /* This subdisk info. */ 8589b17223SAlexander Motin uint32_t disk_offset; /* Subdisk offset. */ 8689b17223SAlexander Motin uint32_t disk_sectors; /* Subdisk size */ 8789b17223SAlexander Motin uint32_t rebuild_lba; /* Rebuild position. */ 8889b17223SAlexander Motin uint16_t generation; /* Generation number. */ 8989b17223SAlexander Motin uint8_t status; /* Volume status. */ 9089b17223SAlexander Motin #define PROMISE_S_VALID 0x01 9189b17223SAlexander Motin #define PROMISE_S_ONLINE 0x02 9289b17223SAlexander Motin #define PROMISE_S_INITED 0x04 9389b17223SAlexander Motin #define PROMISE_S_READY 0x08 9489b17223SAlexander Motin #define PROMISE_S_DEGRADED 0x10 9589b17223SAlexander Motin #define PROMISE_S_MARKED 0x20 9689b17223SAlexander Motin #define PROMISE_S_MIGRATING 0x40 9789b17223SAlexander Motin #define PROMISE_S_FUNCTIONAL 0x80 9889b17223SAlexander Motin 9989b17223SAlexander Motin uint8_t type; /* Voluem type. */ 10089b17223SAlexander Motin #define PROMISE_T_RAID0 0x00 10189b17223SAlexander Motin #define PROMISE_T_RAID1 0x01 10289b17223SAlexander Motin #define PROMISE_T_RAID3 0x02 10389b17223SAlexander Motin #define PROMISE_T_RAID5 0x04 10489b17223SAlexander Motin #define PROMISE_T_SPAN 0x08 10589b17223SAlexander Motin #define PROMISE_T_JBOD 0x10 10689b17223SAlexander Motin 10789b17223SAlexander Motin uint8_t total_disks; /* Disks in this volume. */ 10889b17223SAlexander Motin uint8_t stripe_shift; /* Strip size. */ 10989b17223SAlexander Motin uint8_t array_width; /* Number of RAID0 stripes. */ 11089b17223SAlexander Motin uint8_t array_number; /* Global volume number. */ 11189b17223SAlexander Motin uint32_t total_sectors; /* Volume size. */ 11289b17223SAlexander Motin uint16_t cylinders; /* Volume geometry: C. */ 11389b17223SAlexander Motin uint8_t heads; /* Volume geometry: H. */ 11489b17223SAlexander Motin uint8_t sectors; /* Volume geometry: S. */ 11589b17223SAlexander Motin uint64_t volume_id __packed; /* Volume ID, */ 11689b17223SAlexander Motin struct promise_raid_disk disks[PROMISE_MAX_DISKS]; 11789b17223SAlexander Motin /* Subdisks in this volume. */ 11889b17223SAlexander Motin char name[32]; /* Volume label. */ 11989b17223SAlexander Motin 12089b17223SAlexander Motin uint32_t filler2[8]; 12189b17223SAlexander Motin uint32_t magic_3; /* Something related to rebuild. */ 12289b17223SAlexander Motin uint64_t rebuild_lba64; /* Per-volume rebuild position. */ 12389b17223SAlexander Motin uint32_t magic_4; 12489b17223SAlexander Motin uint32_t magic_5; 125733a1f3fSAlexander Motin uint32_t total_sectors_high; 126733a1f3fSAlexander Motin uint32_t filler3[324]; 12789b17223SAlexander Motin uint32_t checksum; 12889b17223SAlexander Motin } __packed; 12989b17223SAlexander Motin 13089b17223SAlexander Motin struct g_raid_md_promise_perdisk { 13189b17223SAlexander Motin int pd_updated; 13289b17223SAlexander Motin int pd_subdisks; 13389b17223SAlexander Motin struct promise_raid_conf *pd_meta[PROMISE_MAX_SUBDISKS]; 13489b17223SAlexander Motin }; 13589b17223SAlexander Motin 13689b17223SAlexander Motin struct g_raid_md_promise_pervolume { 13789b17223SAlexander Motin struct promise_raid_conf *pv_meta; 13889b17223SAlexander Motin uint64_t pv_id; 13989b17223SAlexander Motin uint16_t pv_generation; 14089b17223SAlexander Motin int pv_disks_present; 14189b17223SAlexander Motin int pv_started; 14289b17223SAlexander Motin struct callout pv_start_co; /* STARTING state timer. */ 14389b17223SAlexander Motin }; 14489b17223SAlexander Motin 14589b17223SAlexander Motin static g_raid_md_create_t g_raid_md_create_promise; 14689b17223SAlexander Motin static g_raid_md_taste_t g_raid_md_taste_promise; 14789b17223SAlexander Motin static g_raid_md_event_t g_raid_md_event_promise; 14889b17223SAlexander Motin static g_raid_md_volume_event_t g_raid_md_volume_event_promise; 14989b17223SAlexander Motin static g_raid_md_ctl_t g_raid_md_ctl_promise; 15089b17223SAlexander Motin static g_raid_md_write_t g_raid_md_write_promise; 15189b17223SAlexander Motin static g_raid_md_fail_disk_t g_raid_md_fail_disk_promise; 15289b17223SAlexander Motin static g_raid_md_free_disk_t g_raid_md_free_disk_promise; 15389b17223SAlexander Motin static g_raid_md_free_volume_t g_raid_md_free_volume_promise; 15489b17223SAlexander Motin static g_raid_md_free_t g_raid_md_free_promise; 15589b17223SAlexander Motin 15689b17223SAlexander Motin static kobj_method_t g_raid_md_promise_methods[] = { 15789b17223SAlexander Motin KOBJMETHOD(g_raid_md_create, g_raid_md_create_promise), 15889b17223SAlexander Motin KOBJMETHOD(g_raid_md_taste, g_raid_md_taste_promise), 15989b17223SAlexander Motin KOBJMETHOD(g_raid_md_event, g_raid_md_event_promise), 16089b17223SAlexander Motin KOBJMETHOD(g_raid_md_volume_event, g_raid_md_volume_event_promise), 16189b17223SAlexander Motin KOBJMETHOD(g_raid_md_ctl, g_raid_md_ctl_promise), 16289b17223SAlexander Motin KOBJMETHOD(g_raid_md_write, g_raid_md_write_promise), 16389b17223SAlexander Motin KOBJMETHOD(g_raid_md_fail_disk, g_raid_md_fail_disk_promise), 16489b17223SAlexander Motin KOBJMETHOD(g_raid_md_free_disk, g_raid_md_free_disk_promise), 16589b17223SAlexander Motin KOBJMETHOD(g_raid_md_free_volume, g_raid_md_free_volume_promise), 16689b17223SAlexander Motin KOBJMETHOD(g_raid_md_free, g_raid_md_free_promise), 16789b17223SAlexander Motin { 0, 0 } 16889b17223SAlexander Motin }; 16989b17223SAlexander Motin 17089b17223SAlexander Motin static struct g_raid_md_class g_raid_md_promise_class = { 17189b17223SAlexander Motin "Promise", 17289b17223SAlexander Motin g_raid_md_promise_methods, 17389b17223SAlexander Motin sizeof(struct g_raid_md_object), 17489b17223SAlexander Motin .mdc_priority = 100 17589b17223SAlexander Motin }; 17689b17223SAlexander Motin 17789b17223SAlexander Motin 17889b17223SAlexander Motin static void 17989b17223SAlexander Motin g_raid_md_promise_print(struct promise_raid_conf *meta) 18089b17223SAlexander Motin { 18189b17223SAlexander Motin int i; 18289b17223SAlexander Motin 18389b17223SAlexander Motin if (g_raid_debug < 1) 18489b17223SAlexander Motin return; 18589b17223SAlexander Motin 18689b17223SAlexander Motin printf("********* ATA Promise Metadata *********\n"); 18789b17223SAlexander Motin printf("promise_id <%.24s>\n", meta->promise_id); 18889b17223SAlexander Motin printf("disk %02x %02x %02x %02x %016jx\n", 18989b17223SAlexander Motin meta->disk.flags, meta->disk.number, meta->disk.channel, 19089b17223SAlexander Motin meta->disk.device, meta->disk.id); 19189b17223SAlexander Motin printf("disk_offset %u\n", meta->disk_offset); 19289b17223SAlexander Motin printf("disk_sectors %u\n", meta->disk_sectors); 19389b17223SAlexander Motin printf("rebuild_lba %u\n", meta->rebuild_lba); 19489b17223SAlexander Motin printf("generation %u\n", meta->generation); 19589b17223SAlexander Motin printf("status 0x%02x\n", meta->status); 19689b17223SAlexander Motin printf("type %u\n", meta->type); 19789b17223SAlexander Motin printf("total_disks %u\n", meta->total_disks); 19889b17223SAlexander Motin printf("stripe_shift %u\n", meta->stripe_shift); 19989b17223SAlexander Motin printf("array_width %u\n", meta->array_width); 20089b17223SAlexander Motin printf("array_number %u\n", meta->array_number); 20189b17223SAlexander Motin printf("total_sectors %u\n", meta->total_sectors); 20289b17223SAlexander Motin printf("cylinders %u\n", meta->cylinders); 20389b17223SAlexander Motin printf("heads %u\n", meta->heads); 20489b17223SAlexander Motin printf("sectors %u\n", meta->sectors); 20589b17223SAlexander Motin printf("volume_id 0x%016jx\n", meta->volume_id); 20689b17223SAlexander Motin printf("disks:\n"); 20789b17223SAlexander Motin for (i = 0; i < PROMISE_MAX_DISKS; i++ ) { 20889b17223SAlexander Motin printf(" %02x %02x %02x %02x %016jx\n", 20989b17223SAlexander Motin meta->disks[i].flags, meta->disks[i].number, 21089b17223SAlexander Motin meta->disks[i].channel, meta->disks[i].device, 21189b17223SAlexander Motin meta->disks[i].id); 21289b17223SAlexander Motin } 21389b17223SAlexander Motin printf("name <%.32s>\n", meta->name); 21489b17223SAlexander Motin printf("magic_3 0x%08x\n", meta->magic_3); 21589b17223SAlexander Motin printf("rebuild_lba64 %ju\n", meta->rebuild_lba64); 21689b17223SAlexander Motin printf("magic_4 0x%08x\n", meta->magic_4); 21789b17223SAlexander Motin printf("magic_5 0x%08x\n", meta->magic_5); 218733a1f3fSAlexander Motin printf("total_sectors_high 0x%08x\n", meta->total_sectors_high); 21989b17223SAlexander Motin printf("=================================================\n"); 22089b17223SAlexander Motin } 22189b17223SAlexander Motin 22289b17223SAlexander Motin static struct promise_raid_conf * 22389b17223SAlexander Motin promise_meta_copy(struct promise_raid_conf *meta) 22489b17223SAlexander Motin { 22589b17223SAlexander Motin struct promise_raid_conf *nmeta; 22689b17223SAlexander Motin 22789b17223SAlexander Motin nmeta = malloc(sizeof(*nmeta), M_MD_PROMISE, M_WAITOK); 22889b17223SAlexander Motin memcpy(nmeta, meta, sizeof(*nmeta)); 22989b17223SAlexander Motin return (nmeta); 23089b17223SAlexander Motin } 23189b17223SAlexander Motin 23289b17223SAlexander Motin static int 23389b17223SAlexander Motin promise_meta_find_disk(struct promise_raid_conf *meta, uint64_t id) 23489b17223SAlexander Motin { 23589b17223SAlexander Motin int pos; 23689b17223SAlexander Motin 23789b17223SAlexander Motin for (pos = 0; pos < meta->total_disks; pos++) { 23889b17223SAlexander Motin if (meta->disks[pos].id == id) 23989b17223SAlexander Motin return (pos); 24089b17223SAlexander Motin } 24189b17223SAlexander Motin return (-1); 24289b17223SAlexander Motin } 24389b17223SAlexander Motin 24489b17223SAlexander Motin static int 24589b17223SAlexander Motin promise_meta_unused_range(struct promise_raid_conf **metaarr, int nsd, 24689b17223SAlexander Motin uint32_t sectors, uint32_t *off, uint32_t *size) 24789b17223SAlexander Motin { 24889b17223SAlexander Motin uint32_t coff, csize; 24989b17223SAlexander Motin int i, j; 25089b17223SAlexander Motin 25189b17223SAlexander Motin sectors -= 131072; 25289b17223SAlexander Motin *off = 0; 25389b17223SAlexander Motin *size = 0; 25489b17223SAlexander Motin coff = 0; 25589b17223SAlexander Motin csize = sectors; 25689b17223SAlexander Motin i = 0; 25789b17223SAlexander Motin while (1) { 25889b17223SAlexander Motin for (j = 0; j < nsd; j++) { 25989b17223SAlexander Motin if (metaarr[j]->disk_offset >= coff) { 26089b17223SAlexander Motin csize = MIN(csize, 26189b17223SAlexander Motin metaarr[j]->disk_offset - coff); 26289b17223SAlexander Motin } 26389b17223SAlexander Motin } 26489b17223SAlexander Motin if (csize > *size) { 26589b17223SAlexander Motin *off = coff; 26689b17223SAlexander Motin *size = csize; 26789b17223SAlexander Motin } 26889b17223SAlexander Motin if (i >= nsd) 26989b17223SAlexander Motin break; 27089b17223SAlexander Motin coff = metaarr[i]->disk_offset + metaarr[i]->disk_sectors; 27189b17223SAlexander Motin csize = sectors - coff; 27289b17223SAlexander Motin i++; 27389b17223SAlexander Motin }; 27489b17223SAlexander Motin return ((*size > 0) ? 1 : 0); 27589b17223SAlexander Motin } 27689b17223SAlexander Motin 27789b17223SAlexander Motin static int 27889b17223SAlexander Motin promise_meta_translate_disk(struct g_raid_volume *vol, int md_disk_pos) 27989b17223SAlexander Motin { 28089b17223SAlexander Motin int disk_pos, width; 28189b17223SAlexander Motin 28289b17223SAlexander Motin if (md_disk_pos >= 0 && vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) { 28389b17223SAlexander Motin width = vol->v_disks_count / 2; 28489b17223SAlexander Motin disk_pos = (md_disk_pos / width) + 28589b17223SAlexander Motin (md_disk_pos % width) * width; 28689b17223SAlexander Motin } else 28789b17223SAlexander Motin disk_pos = md_disk_pos; 28889b17223SAlexander Motin return (disk_pos); 28989b17223SAlexander Motin } 29089b17223SAlexander Motin 29189b17223SAlexander Motin static void 29289b17223SAlexander Motin promise_meta_get_name(struct promise_raid_conf *meta, char *buf) 29389b17223SAlexander Motin { 29489b17223SAlexander Motin int i; 29589b17223SAlexander Motin 29689b17223SAlexander Motin strncpy(buf, meta->name, 32); 29789b17223SAlexander Motin buf[32] = 0; 29889b17223SAlexander Motin for (i = 31; i >= 0; i--) { 29989b17223SAlexander Motin if (buf[i] > 0x20) 30089b17223SAlexander Motin break; 30189b17223SAlexander Motin buf[i] = 0; 30289b17223SAlexander Motin } 30389b17223SAlexander Motin } 30489b17223SAlexander Motin 30589b17223SAlexander Motin static void 30689b17223SAlexander Motin promise_meta_put_name(struct promise_raid_conf *meta, char *buf) 30789b17223SAlexander Motin { 30889b17223SAlexander Motin 30989b17223SAlexander Motin memset(meta->name, 0x20, 32); 31089b17223SAlexander Motin memcpy(meta->name, buf, MIN(strlen(buf), 32)); 31189b17223SAlexander Motin } 31289b17223SAlexander Motin 31389b17223SAlexander Motin static int 31489b17223SAlexander Motin promise_meta_read(struct g_consumer *cp, struct promise_raid_conf **metaarr) 31589b17223SAlexander Motin { 31689b17223SAlexander Motin struct g_provider *pp; 31789b17223SAlexander Motin struct promise_raid_conf *meta; 31889b17223SAlexander Motin char *buf; 31989b17223SAlexander Motin int error, i, subdisks; 32089b17223SAlexander Motin uint32_t checksum, *ptr; 32189b17223SAlexander Motin 32289b17223SAlexander Motin pp = cp->provider; 32389b17223SAlexander Motin subdisks = 0; 32489b17223SAlexander Motin next: 32589b17223SAlexander Motin /* Read metadata block. */ 32689b17223SAlexander Motin buf = g_read_data(cp, pp->mediasize - pp->sectorsize * 32789b17223SAlexander Motin (63 - subdisks * PROMISE_META_OFFSET), 32889b17223SAlexander Motin pp->sectorsize * 4, &error); 32989b17223SAlexander Motin if (buf == NULL) { 33089b17223SAlexander Motin G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).", 33189b17223SAlexander Motin pp->name, error); 33289b17223SAlexander Motin return (subdisks); 33389b17223SAlexander Motin } 33489b17223SAlexander Motin meta = (struct promise_raid_conf *)buf; 33589b17223SAlexander Motin 33689b17223SAlexander Motin /* Check if this is an Promise RAID struct */ 33789b17223SAlexander Motin if (strncmp(meta->promise_id, PROMISE_MAGIC, strlen(PROMISE_MAGIC)) && 33889b17223SAlexander Motin strncmp(meta->promise_id, FREEBSD_MAGIC, strlen(FREEBSD_MAGIC))) { 33989b17223SAlexander Motin if (subdisks == 0) 34089b17223SAlexander Motin G_RAID_DEBUG(1, 34189b17223SAlexander Motin "Promise signature check failed on %s", pp->name); 34289b17223SAlexander Motin g_free(buf); 34389b17223SAlexander Motin return (subdisks); 34489b17223SAlexander Motin } 34589b17223SAlexander Motin meta = malloc(sizeof(*meta), M_MD_PROMISE, M_WAITOK); 34689b17223SAlexander Motin memcpy(meta, buf, MIN(sizeof(*meta), pp->sectorsize * 4)); 34789b17223SAlexander Motin g_free(buf); 34889b17223SAlexander Motin 34989b17223SAlexander Motin /* Check metadata checksum. */ 35089b17223SAlexander Motin for (checksum = 0, ptr = (uint32_t *)meta, i = 0; i < 511; i++) 35189b17223SAlexander Motin checksum += *ptr++; 35289b17223SAlexander Motin if (checksum != meta->checksum) { 35389b17223SAlexander Motin G_RAID_DEBUG(1, "Promise checksum check failed on %s", pp->name); 35489b17223SAlexander Motin free(meta, M_MD_PROMISE); 35589b17223SAlexander Motin return (subdisks); 35689b17223SAlexander Motin } 35789b17223SAlexander Motin 35889b17223SAlexander Motin if ((meta->integrity & PROMISE_I_VALID) == 0) { 35989b17223SAlexander Motin G_RAID_DEBUG(1, "Promise metadata is invalid on %s", pp->name); 36089b17223SAlexander Motin free(meta, M_MD_PROMISE); 36189b17223SAlexander Motin return (subdisks); 36289b17223SAlexander Motin } 36389b17223SAlexander Motin 36489b17223SAlexander Motin if (meta->total_disks > PROMISE_MAX_DISKS) { 36589b17223SAlexander Motin G_RAID_DEBUG(1, "Wrong number of disks on %s (%d)", 36689b17223SAlexander Motin pp->name, meta->total_disks); 36789b17223SAlexander Motin free(meta, M_MD_PROMISE); 36889b17223SAlexander Motin return (subdisks); 36989b17223SAlexander Motin } 37089b17223SAlexander Motin 37189b17223SAlexander Motin /* Save this part and look for next. */ 37289b17223SAlexander Motin *metaarr = meta; 37389b17223SAlexander Motin metaarr++; 37489b17223SAlexander Motin subdisks++; 37589b17223SAlexander Motin if (subdisks < PROMISE_MAX_SUBDISKS) 37689b17223SAlexander Motin goto next; 37789b17223SAlexander Motin 37889b17223SAlexander Motin return (subdisks); 37989b17223SAlexander Motin } 38089b17223SAlexander Motin 38189b17223SAlexander Motin static int 38289b17223SAlexander Motin promise_meta_write(struct g_consumer *cp, 38389b17223SAlexander Motin struct promise_raid_conf **metaarr, int nsd) 38489b17223SAlexander Motin { 38589b17223SAlexander Motin struct g_provider *pp; 38689b17223SAlexander Motin struct promise_raid_conf *meta; 38789b17223SAlexander Motin char *buf; 38889b17223SAlexander Motin int error, i, subdisk, fake; 38989b17223SAlexander Motin uint32_t checksum, *ptr, off, size; 39089b17223SAlexander Motin 39189b17223SAlexander Motin pp = cp->provider; 39289b17223SAlexander Motin subdisk = 0; 39389b17223SAlexander Motin fake = 0; 39489b17223SAlexander Motin next: 39589b17223SAlexander Motin buf = malloc(pp->sectorsize * 4, M_MD_PROMISE, M_WAITOK | M_ZERO); 39689b17223SAlexander Motin meta = NULL; 39789b17223SAlexander Motin if (subdisk < nsd) { 39889b17223SAlexander Motin meta = metaarr[subdisk]; 39989b17223SAlexander Motin } else if (!fake && promise_meta_unused_range(metaarr, nsd, 40089b17223SAlexander Motin cp->provider->mediasize / cp->provider->sectorsize, 40189b17223SAlexander Motin &off, &size)) { 40289b17223SAlexander Motin /* Optionally add record for unused space. */ 40389b17223SAlexander Motin meta = (struct promise_raid_conf *)buf; 40463607675SAlexander Motin memcpy(&meta->promise_id[0], PROMISE_MAGIC, 40563607675SAlexander Motin sizeof(PROMISE_MAGIC) - 1); 40689b17223SAlexander Motin meta->dummy_0 = 0x00020000; 40789b17223SAlexander Motin meta->integrity = PROMISE_I_VALID; 40889b17223SAlexander Motin meta->disk.flags = PROMISE_F_ONLINE | PROMISE_F_VALID; 40989b17223SAlexander Motin meta->disk.number = 0xff; 41089b17223SAlexander Motin arc4rand(&meta->disk.id, sizeof(meta->disk.id), 0); 41189b17223SAlexander Motin meta->disk_offset = off; 41289b17223SAlexander Motin meta->disk_sectors = size; 41389b17223SAlexander Motin meta->rebuild_lba = UINT32_MAX; 41489b17223SAlexander Motin fake = 1; 41589b17223SAlexander Motin } 41689b17223SAlexander Motin if (meta != NULL) { 41789b17223SAlexander Motin /* Recalculate checksum for case if metadata were changed. */ 41889b17223SAlexander Motin meta->checksum = 0; 41989b17223SAlexander Motin for (checksum = 0, ptr = (uint32_t *)meta, i = 0; i < 511; i++) 42089b17223SAlexander Motin checksum += *ptr++; 42189b17223SAlexander Motin meta->checksum = checksum; 42289b17223SAlexander Motin memcpy(buf, meta, MIN(pp->sectorsize * 4, sizeof(*meta))); 42389b17223SAlexander Motin } 42489b17223SAlexander Motin error = g_write_data(cp, pp->mediasize - pp->sectorsize * 42589b17223SAlexander Motin (63 - subdisk * PROMISE_META_OFFSET), 42689b17223SAlexander Motin buf, pp->sectorsize * 4); 42789b17223SAlexander Motin if (error != 0) { 42889b17223SAlexander Motin G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).", 42989b17223SAlexander Motin pp->name, error); 43089b17223SAlexander Motin } 43189b17223SAlexander Motin free(buf, M_MD_PROMISE); 43289b17223SAlexander Motin 43389b17223SAlexander Motin subdisk++; 43489b17223SAlexander Motin if (subdisk < PROMISE_MAX_SUBDISKS) 43589b17223SAlexander Motin goto next; 43689b17223SAlexander Motin 43789b17223SAlexander Motin return (error); 43889b17223SAlexander Motin } 43989b17223SAlexander Motin 44089b17223SAlexander Motin static int 44189b17223SAlexander Motin promise_meta_erase(struct g_consumer *cp) 44289b17223SAlexander Motin { 44389b17223SAlexander Motin struct g_provider *pp; 44489b17223SAlexander Motin char *buf; 44589b17223SAlexander Motin int error, subdisk; 44689b17223SAlexander Motin 44789b17223SAlexander Motin pp = cp->provider; 44889b17223SAlexander Motin buf = malloc(4 * pp->sectorsize, M_MD_PROMISE, M_WAITOK | M_ZERO); 44989b17223SAlexander Motin for (subdisk = 0; subdisk < PROMISE_MAX_SUBDISKS; subdisk++) { 45089b17223SAlexander Motin error = g_write_data(cp, pp->mediasize - pp->sectorsize * 45189b17223SAlexander Motin (63 - subdisk * PROMISE_META_OFFSET), 45289b17223SAlexander Motin buf, 4 * pp->sectorsize); 45389b17223SAlexander Motin if (error != 0) { 45489b17223SAlexander Motin G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).", 45589b17223SAlexander Motin pp->name, error); 45689b17223SAlexander Motin } 45789b17223SAlexander Motin } 45889b17223SAlexander Motin free(buf, M_MD_PROMISE); 45989b17223SAlexander Motin return (error); 46089b17223SAlexander Motin } 46189b17223SAlexander Motin 46289b17223SAlexander Motin static int 46389b17223SAlexander Motin promise_meta_write_spare(struct g_consumer *cp) 46489b17223SAlexander Motin { 46589b17223SAlexander Motin struct promise_raid_conf *meta; 46689b17223SAlexander Motin int error; 46789b17223SAlexander Motin 46889b17223SAlexander Motin meta = malloc(sizeof(*meta), M_MD_PROMISE, M_WAITOK | M_ZERO); 46963607675SAlexander Motin memcpy(&meta->promise_id[0], PROMISE_MAGIC, sizeof(PROMISE_MAGIC) - 1); 47089b17223SAlexander Motin meta->dummy_0 = 0x00020000; 47189b17223SAlexander Motin meta->integrity = PROMISE_I_VALID; 47289b17223SAlexander Motin meta->disk.flags = PROMISE_F_SPARE | PROMISE_F_ONLINE | PROMISE_F_VALID; 47389b17223SAlexander Motin meta->disk.number = 0xff; 47489b17223SAlexander Motin arc4rand(&meta->disk.id, sizeof(meta->disk.id), 0); 47589b17223SAlexander Motin meta->disk_sectors = cp->provider->mediasize / cp->provider->sectorsize; 47689b17223SAlexander Motin meta->disk_sectors -= 131072; 47789b17223SAlexander Motin meta->rebuild_lba = UINT32_MAX; 47889b17223SAlexander Motin error = promise_meta_write(cp, &meta, 1); 47989b17223SAlexander Motin free(meta, M_MD_PROMISE); 48089b17223SAlexander Motin return (error); 48189b17223SAlexander Motin } 48289b17223SAlexander Motin 48389b17223SAlexander Motin static struct g_raid_volume * 48489b17223SAlexander Motin g_raid_md_promise_get_volume(struct g_raid_softc *sc, uint64_t id) 48589b17223SAlexander Motin { 48689b17223SAlexander Motin struct g_raid_volume *vol; 48789b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 48889b17223SAlexander Motin 48989b17223SAlexander Motin TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 49089b17223SAlexander Motin pv = vol->v_md_data; 49189b17223SAlexander Motin if (pv->pv_id == id) 49289b17223SAlexander Motin break; 49389b17223SAlexander Motin } 49489b17223SAlexander Motin return (vol); 49589b17223SAlexander Motin } 49689b17223SAlexander Motin 49789b17223SAlexander Motin static int 49889b17223SAlexander Motin g_raid_md_promise_purge_volumes(struct g_raid_softc *sc) 49989b17223SAlexander Motin { 50089b17223SAlexander Motin struct g_raid_volume *vol, *tvol; 50189b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 50289b17223SAlexander Motin int i, res; 50389b17223SAlexander Motin 50489b17223SAlexander Motin res = 0; 50589b17223SAlexander Motin TAILQ_FOREACH_SAFE(vol, &sc->sc_volumes, v_next, tvol) { 50689b17223SAlexander Motin pv = vol->v_md_data; 50789b17223SAlexander Motin if (!pv->pv_started || vol->v_stopping) 50889b17223SAlexander Motin continue; 50989b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 51089b17223SAlexander Motin if (vol->v_subdisks[i].sd_state != G_RAID_SUBDISK_S_NONE) 51189b17223SAlexander Motin break; 51289b17223SAlexander Motin } 51389b17223SAlexander Motin if (i >= vol->v_disks_count) { 51489b17223SAlexander Motin g_raid_destroy_volume(vol); 51589b17223SAlexander Motin res = 1; 51689b17223SAlexander Motin } 51789b17223SAlexander Motin } 51889b17223SAlexander Motin return (res); 51989b17223SAlexander Motin } 52089b17223SAlexander Motin 52189b17223SAlexander Motin static int 52289b17223SAlexander Motin g_raid_md_promise_purge_disks(struct g_raid_softc *sc) 52389b17223SAlexander Motin { 52489b17223SAlexander Motin struct g_raid_disk *disk, *tdisk; 52589b17223SAlexander Motin struct g_raid_volume *vol; 52689b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 52789b17223SAlexander Motin int i, j, res; 52889b17223SAlexander Motin 52989b17223SAlexander Motin res = 0; 53089b17223SAlexander Motin TAILQ_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) { 53189b17223SAlexander Motin if (disk->d_state == G_RAID_DISK_S_SPARE) 53289b17223SAlexander Motin continue; 53389b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 53489b17223SAlexander Motin 53589b17223SAlexander Motin /* Scan for deleted volumes. */ 53689b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; ) { 53789b17223SAlexander Motin vol = g_raid_md_promise_get_volume(sc, 53889b17223SAlexander Motin pd->pd_meta[i]->volume_id); 53989b17223SAlexander Motin if (vol != NULL && !vol->v_stopping) { 54089b17223SAlexander Motin i++; 54189b17223SAlexander Motin continue; 54289b17223SAlexander Motin } 54389b17223SAlexander Motin free(pd->pd_meta[i], M_MD_PROMISE); 54489b17223SAlexander Motin for (j = i; j < pd->pd_subdisks - 1; j++) 54589b17223SAlexander Motin pd->pd_meta[j] = pd->pd_meta[j + 1]; 54689b17223SAlexander Motin pd->pd_meta[PROMISE_MAX_SUBDISKS - 1] = NULL; 54789b17223SAlexander Motin pd->pd_subdisks--; 54889b17223SAlexander Motin pd->pd_updated = 1; 54989b17223SAlexander Motin } 55089b17223SAlexander Motin 55189b17223SAlexander Motin /* If there is no metadata left - erase and delete disk. */ 55289b17223SAlexander Motin if (pd->pd_subdisks == 0) { 55389b17223SAlexander Motin promise_meta_erase(disk->d_consumer); 55489b17223SAlexander Motin g_raid_destroy_disk(disk); 55589b17223SAlexander Motin res = 1; 55689b17223SAlexander Motin } 55789b17223SAlexander Motin } 55889b17223SAlexander Motin return (res); 55989b17223SAlexander Motin } 56089b17223SAlexander Motin 56189b17223SAlexander Motin static int 56289b17223SAlexander Motin g_raid_md_promise_supported(int level, int qual, int disks, int force) 56389b17223SAlexander Motin { 56489b17223SAlexander Motin 56589b17223SAlexander Motin if (disks > PROMISE_MAX_DISKS) 56689b17223SAlexander Motin return (0); 56789b17223SAlexander Motin switch (level) { 56889b17223SAlexander Motin case G_RAID_VOLUME_RL_RAID0: 56989b17223SAlexander Motin if (disks < 1) 57089b17223SAlexander Motin return (0); 57189b17223SAlexander Motin if (!force && disks < 2) 57289b17223SAlexander Motin return (0); 57389b17223SAlexander Motin break; 57489b17223SAlexander Motin case G_RAID_VOLUME_RL_RAID1: 57589b17223SAlexander Motin if (disks < 1) 57689b17223SAlexander Motin return (0); 57789b17223SAlexander Motin if (!force && (disks != 2)) 57889b17223SAlexander Motin return (0); 57989b17223SAlexander Motin break; 58089b17223SAlexander Motin case G_RAID_VOLUME_RL_RAID1E: 58189b17223SAlexander Motin if (disks < 2) 58289b17223SAlexander Motin return (0); 58389b17223SAlexander Motin if (disks % 2 != 0) 58489b17223SAlexander Motin return (0); 58589b17223SAlexander Motin if (!force && (disks != 4)) 58689b17223SAlexander Motin return (0); 58789b17223SAlexander Motin break; 58889b17223SAlexander Motin case G_RAID_VOLUME_RL_SINGLE: 58989b17223SAlexander Motin if (disks != 1) 59089b17223SAlexander Motin return (0); 59189b17223SAlexander Motin break; 59289b17223SAlexander Motin case G_RAID_VOLUME_RL_CONCAT: 59389b17223SAlexander Motin if (disks < 2) 59489b17223SAlexander Motin return (0); 59589b17223SAlexander Motin break; 59689b17223SAlexander Motin case G_RAID_VOLUME_RL_RAID5: 59789b17223SAlexander Motin if (disks < 3) 59889b17223SAlexander Motin return (0); 599fc1de960SAlexander Motin if (qual != G_RAID_VOLUME_RLQ_R5LA) 600fc1de960SAlexander Motin return (0); 60189b17223SAlexander Motin break; 60289b17223SAlexander Motin default: 60389b17223SAlexander Motin return (0); 60489b17223SAlexander Motin } 605fc1de960SAlexander Motin if (level != G_RAID_VOLUME_RL_RAID5 && qual != G_RAID_VOLUME_RLQ_NONE) 60689b17223SAlexander Motin return (0); 60789b17223SAlexander Motin return (1); 60889b17223SAlexander Motin } 60989b17223SAlexander Motin 61089b17223SAlexander Motin static int 61189b17223SAlexander Motin g_raid_md_promise_start_disk(struct g_raid_disk *disk, int sdn, 61289b17223SAlexander Motin struct g_raid_volume *vol) 61389b17223SAlexander Motin { 61489b17223SAlexander Motin struct g_raid_softc *sc; 61589b17223SAlexander Motin struct g_raid_subdisk *sd; 61689b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 61789b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 61889b17223SAlexander Motin struct promise_raid_conf *meta; 61989b17223SAlexander Motin off_t size; 62089b17223SAlexander Motin int disk_pos, md_disk_pos, i, resurrection = 0; 62189b17223SAlexander Motin uint32_t eoff, esize; 62289b17223SAlexander Motin 62389b17223SAlexander Motin sc = disk->d_softc; 62489b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 62589b17223SAlexander Motin 62689b17223SAlexander Motin pv = vol->v_md_data; 62789b17223SAlexander Motin meta = pv->pv_meta; 62889b17223SAlexander Motin 62989b17223SAlexander Motin if (sdn >= 0) { 63089b17223SAlexander Motin /* Find disk position in metadata by it's serial. */ 63189b17223SAlexander Motin md_disk_pos = promise_meta_find_disk(meta, pd->pd_meta[sdn]->disk.id); 63289b17223SAlexander Motin /* For RAID0+1 we need to translate order. */ 63389b17223SAlexander Motin disk_pos = promise_meta_translate_disk(vol, md_disk_pos); 63489b17223SAlexander Motin } else { 63589b17223SAlexander Motin md_disk_pos = -1; 63689b17223SAlexander Motin disk_pos = -1; 63789b17223SAlexander Motin } 63889b17223SAlexander Motin if (disk_pos < 0) { 63989b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Disk %s is not part of the volume %s", 64089b17223SAlexander Motin g_raid_get_diskname(disk), vol->v_name); 64189b17223SAlexander Motin /* Failed stale disk is useless for us. */ 64289b17223SAlexander Motin if (sdn >= 0 && 64389b17223SAlexander Motin pd->pd_meta[sdn]->disk.flags & PROMISE_F_DOWN) { 64489b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED); 64589b17223SAlexander Motin return (0); 64689b17223SAlexander Motin } 64789b17223SAlexander Motin /* If we were given specific metadata subdisk - erase it. */ 64889b17223SAlexander Motin if (sdn >= 0) { 64989b17223SAlexander Motin free(pd->pd_meta[sdn], M_MD_PROMISE); 65089b17223SAlexander Motin for (i = sdn; i < pd->pd_subdisks - 1; i++) 65189b17223SAlexander Motin pd->pd_meta[i] = pd->pd_meta[i + 1]; 65289b17223SAlexander Motin pd->pd_meta[PROMISE_MAX_SUBDISKS - 1] = NULL; 65389b17223SAlexander Motin pd->pd_subdisks--; 65489b17223SAlexander Motin } 65589b17223SAlexander Motin /* If we are in the start process, that's all for now. */ 65689b17223SAlexander Motin if (!pv->pv_started) 65789b17223SAlexander Motin goto nofit; 65889b17223SAlexander Motin /* 65989b17223SAlexander Motin * If we have already started - try to get use of the disk. 66089b17223SAlexander Motin * Try to replace OFFLINE disks first, then FAILED. 66189b17223SAlexander Motin */ 66289b17223SAlexander Motin promise_meta_unused_range(pd->pd_meta, pd->pd_subdisks, 66389b17223SAlexander Motin disk->d_consumer->provider->mediasize / 66489b17223SAlexander Motin disk->d_consumer->provider->sectorsize, 66589b17223SAlexander Motin &eoff, &esize); 66689b17223SAlexander Motin if (esize == 0) { 66789b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "No free space on disk %s", 66889b17223SAlexander Motin g_raid_get_diskname(disk)); 66989b17223SAlexander Motin goto nofit; 67089b17223SAlexander Motin } 67189b17223SAlexander Motin size = INT64_MAX; 67289b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 67389b17223SAlexander Motin sd = &vol->v_subdisks[i]; 67489b17223SAlexander Motin if (sd->sd_state != G_RAID_SUBDISK_S_NONE) 67589b17223SAlexander Motin size = sd->sd_size; 67689b17223SAlexander Motin if (sd->sd_state <= G_RAID_SUBDISK_S_FAILED && 67789b17223SAlexander Motin (disk_pos < 0 || 67889b17223SAlexander Motin vol->v_subdisks[i].sd_state < sd->sd_state)) 67989b17223SAlexander Motin disk_pos = i; 68089b17223SAlexander Motin } 68189b17223SAlexander Motin if (disk_pos >= 0 && 68289b17223SAlexander Motin vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT && 68389b17223SAlexander Motin (off_t)esize * 512 < size) { 68489b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Disk %s free space " 68589b17223SAlexander Motin "is too small (%ju < %ju)", 68689b17223SAlexander Motin g_raid_get_diskname(disk), 68789b17223SAlexander Motin (off_t)esize * 512, size); 68889b17223SAlexander Motin disk_pos = -1; 68989b17223SAlexander Motin } 69089b17223SAlexander Motin if (disk_pos >= 0) { 69189b17223SAlexander Motin if (vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT) 69289b17223SAlexander Motin esize = size / 512; 69389b17223SAlexander Motin /* For RAID0+1 we need to translate order. */ 69489b17223SAlexander Motin md_disk_pos = promise_meta_translate_disk(vol, disk_pos); 69589b17223SAlexander Motin } else { 69689b17223SAlexander Motin nofit: 69789b17223SAlexander Motin if (pd->pd_subdisks == 0) { 69889b17223SAlexander Motin g_raid_change_disk_state(disk, 69989b17223SAlexander Motin G_RAID_DISK_S_SPARE); 70089b17223SAlexander Motin } 70189b17223SAlexander Motin return (0); 70289b17223SAlexander Motin } 70389b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Disk %s takes pos %d in the volume %s", 70489b17223SAlexander Motin g_raid_get_diskname(disk), disk_pos, vol->v_name); 70589b17223SAlexander Motin resurrection = 1; 70689b17223SAlexander Motin } 70789b17223SAlexander Motin 70889b17223SAlexander Motin sd = &vol->v_subdisks[disk_pos]; 70989b17223SAlexander Motin 71089b17223SAlexander Motin if (resurrection && sd->sd_disk != NULL) { 71189b17223SAlexander Motin g_raid_change_disk_state(sd->sd_disk, 71289b17223SAlexander Motin G_RAID_DISK_S_STALE_FAILED); 71389b17223SAlexander Motin TAILQ_REMOVE(&sd->sd_disk->d_subdisks, 71489b17223SAlexander Motin sd, sd_next); 71589b17223SAlexander Motin } 71689b17223SAlexander Motin vol->v_subdisks[disk_pos].sd_disk = disk; 71789b17223SAlexander Motin TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next); 71889b17223SAlexander Motin 71989b17223SAlexander Motin /* Welcome the new disk. */ 72089b17223SAlexander Motin if (resurrection) 72189b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE); 72289b17223SAlexander Motin else if (meta->disks[md_disk_pos].flags & PROMISE_F_DOWN) 72389b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED); 72489b17223SAlexander Motin else 72589b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE); 72689b17223SAlexander Motin 72789b17223SAlexander Motin if (resurrection) { 72889b17223SAlexander Motin sd->sd_offset = (off_t)eoff * 512; 72989b17223SAlexander Motin sd->sd_size = (off_t)esize * 512; 73089b17223SAlexander Motin } else { 73189b17223SAlexander Motin sd->sd_offset = (off_t)pd->pd_meta[sdn]->disk_offset * 512; 73289b17223SAlexander Motin sd->sd_size = (off_t)pd->pd_meta[sdn]->disk_sectors * 512; 73389b17223SAlexander Motin } 73489b17223SAlexander Motin 73589b17223SAlexander Motin if (resurrection) { 73689b17223SAlexander Motin /* Stale disk, almost same as new. */ 73789b17223SAlexander Motin g_raid_change_subdisk_state(sd, 73889b17223SAlexander Motin G_RAID_SUBDISK_S_NEW); 73989b17223SAlexander Motin } else if (meta->disks[md_disk_pos].flags & PROMISE_F_DOWN) { 74089b17223SAlexander Motin /* Failed disk. */ 74189b17223SAlexander Motin g_raid_change_subdisk_state(sd, 74289b17223SAlexander Motin G_RAID_SUBDISK_S_FAILED); 74389b17223SAlexander Motin } else if (meta->disks[md_disk_pos].flags & PROMISE_F_REDIR) { 74489b17223SAlexander Motin /* Rebuilding disk. */ 74589b17223SAlexander Motin g_raid_change_subdisk_state(sd, 74689b17223SAlexander Motin G_RAID_SUBDISK_S_REBUILD); 74789b17223SAlexander Motin if (pd->pd_meta[sdn]->generation != meta->generation) 74889b17223SAlexander Motin sd->sd_rebuild_pos = 0; 74989b17223SAlexander Motin else { 75089b17223SAlexander Motin sd->sd_rebuild_pos = 75189b17223SAlexander Motin (off_t)pd->pd_meta[sdn]->rebuild_lba * 512; 75289b17223SAlexander Motin } 75389b17223SAlexander Motin } else if (!(meta->disks[md_disk_pos].flags & PROMISE_F_ONLINE)) { 75489b17223SAlexander Motin /* Rebuilding disk. */ 75589b17223SAlexander Motin g_raid_change_subdisk_state(sd, 75689b17223SAlexander Motin G_RAID_SUBDISK_S_NEW); 75789b17223SAlexander Motin } else if (pd->pd_meta[sdn]->generation != meta->generation || 75889b17223SAlexander Motin (meta->status & PROMISE_S_MARKED)) { 75989b17223SAlexander Motin /* Stale disk or dirty volume (unclean shutdown). */ 76089b17223SAlexander Motin g_raid_change_subdisk_state(sd, 76189b17223SAlexander Motin G_RAID_SUBDISK_S_STALE); 76289b17223SAlexander Motin } else { 76389b17223SAlexander Motin /* Up to date disk. */ 76489b17223SAlexander Motin g_raid_change_subdisk_state(sd, 76589b17223SAlexander Motin G_RAID_SUBDISK_S_ACTIVE); 76689b17223SAlexander Motin } 76789b17223SAlexander Motin g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW, 76889b17223SAlexander Motin G_RAID_EVENT_SUBDISK); 76989b17223SAlexander Motin 77089b17223SAlexander Motin return (resurrection); 77189b17223SAlexander Motin } 77289b17223SAlexander Motin 77389b17223SAlexander Motin static void 77489b17223SAlexander Motin g_raid_md_promise_refill(struct g_raid_softc *sc) 77589b17223SAlexander Motin { 77689b17223SAlexander Motin struct g_raid_volume *vol; 77789b17223SAlexander Motin struct g_raid_subdisk *sd; 77889b17223SAlexander Motin struct g_raid_disk *disk; 77989b17223SAlexander Motin struct g_raid_md_object *md; 78089b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 78189b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 78289b17223SAlexander Motin int update, updated, i, bad; 78389b17223SAlexander Motin 78489b17223SAlexander Motin md = sc->sc_md; 78589b17223SAlexander Motin restart: 78689b17223SAlexander Motin updated = 0; 78789b17223SAlexander Motin TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 78889b17223SAlexander Motin pv = vol->v_md_data; 78989b17223SAlexander Motin if (!pv->pv_started || vol->v_stopping) 79089b17223SAlexander Motin continue; 79189b17223SAlexander Motin 79289b17223SAlexander Motin /* Search for subdisk that needs replacement. */ 79389b17223SAlexander Motin bad = 0; 79489b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 79589b17223SAlexander Motin sd = &vol->v_subdisks[i]; 79689b17223SAlexander Motin if (sd->sd_state == G_RAID_SUBDISK_S_NONE || 79789b17223SAlexander Motin sd->sd_state == G_RAID_SUBDISK_S_FAILED) 79889b17223SAlexander Motin bad = 1; 79989b17223SAlexander Motin } 80089b17223SAlexander Motin if (!bad) 80189b17223SAlexander Motin continue; 80289b17223SAlexander Motin 80389b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Volume %s is not complete, " 80489b17223SAlexander Motin "trying to refill.", vol->v_name); 80589b17223SAlexander Motin 80689b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 80789b17223SAlexander Motin /* Skip failed. */ 80889b17223SAlexander Motin if (disk->d_state < G_RAID_DISK_S_SPARE) 80989b17223SAlexander Motin continue; 81089b17223SAlexander Motin /* Skip already used by this volume. */ 81189b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 81289b17223SAlexander Motin sd = &vol->v_subdisks[i]; 81389b17223SAlexander Motin if (sd->sd_disk == disk) 81489b17223SAlexander Motin break; 81589b17223SAlexander Motin } 81689b17223SAlexander Motin if (i < vol->v_disks_count) 81789b17223SAlexander Motin continue; 81889b17223SAlexander Motin 81989b17223SAlexander Motin /* Try to use disk if it has empty extents. */ 82089b17223SAlexander Motin pd = disk->d_md_data; 82189b17223SAlexander Motin if (pd->pd_subdisks < PROMISE_MAX_SUBDISKS) { 82289b17223SAlexander Motin update = 82389b17223SAlexander Motin g_raid_md_promise_start_disk(disk, -1, vol); 82489b17223SAlexander Motin } else 82589b17223SAlexander Motin update = 0; 82689b17223SAlexander Motin if (update) { 82763607675SAlexander Motin updated = 1; 82889b17223SAlexander Motin g_raid_md_write_promise(md, vol, NULL, disk); 82989b17223SAlexander Motin break; 83089b17223SAlexander Motin } 83189b17223SAlexander Motin } 83289b17223SAlexander Motin } 83389b17223SAlexander Motin if (updated) 83489b17223SAlexander Motin goto restart; 83589b17223SAlexander Motin } 83689b17223SAlexander Motin 83789b17223SAlexander Motin static void 83889b17223SAlexander Motin g_raid_md_promise_start(struct g_raid_volume *vol) 83989b17223SAlexander Motin { 84089b17223SAlexander Motin struct g_raid_softc *sc; 84189b17223SAlexander Motin struct g_raid_subdisk *sd; 84289b17223SAlexander Motin struct g_raid_disk *disk; 84389b17223SAlexander Motin struct g_raid_md_object *md; 84489b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 84589b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 84689b17223SAlexander Motin struct promise_raid_conf *meta; 84789b17223SAlexander Motin int i; 84889b17223SAlexander Motin 84989b17223SAlexander Motin sc = vol->v_softc; 85089b17223SAlexander Motin md = sc->sc_md; 85189b17223SAlexander Motin pv = vol->v_md_data; 85289b17223SAlexander Motin meta = pv->pv_meta; 85389b17223SAlexander Motin 854fc1de960SAlexander Motin vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_NONE; 85589b17223SAlexander Motin if (meta->type == PROMISE_T_RAID0) 85689b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_RAID0; 85789b17223SAlexander Motin else if (meta->type == PROMISE_T_RAID1) { 85889b17223SAlexander Motin if (meta->array_width == 1) 85989b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_RAID1; 86089b17223SAlexander Motin else 86189b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E; 86289b17223SAlexander Motin } else if (meta->type == PROMISE_T_RAID3) 86389b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_RAID3; 864fc1de960SAlexander Motin else if (meta->type == PROMISE_T_RAID5) { 86589b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_RAID5; 866fc1de960SAlexander Motin vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_R5LA; 867fc1de960SAlexander Motin } else if (meta->type == PROMISE_T_SPAN) 86889b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_CONCAT; 86989b17223SAlexander Motin else if (meta->type == PROMISE_T_JBOD) 87089b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_SINGLE; 87189b17223SAlexander Motin else 87289b17223SAlexander Motin vol->v_raid_level = G_RAID_VOLUME_RL_UNKNOWN; 87389b17223SAlexander Motin vol->v_strip_size = 512 << meta->stripe_shift; //ZZZ 87489b17223SAlexander Motin vol->v_disks_count = meta->total_disks; 87589b17223SAlexander Motin vol->v_mediasize = (off_t)meta->total_sectors * 512; //ZZZ 876733a1f3fSAlexander Motin if (meta->total_sectors_high < 256) /* If value looks sane. */ 877733a1f3fSAlexander Motin vol->v_mediasize |= 878733a1f3fSAlexander Motin ((off_t)meta->total_sectors_high << 32) * 512; //ZZZ 87989b17223SAlexander Motin vol->v_sectorsize = 512; //ZZZ 88089b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 88189b17223SAlexander Motin sd = &vol->v_subdisks[i]; 88289b17223SAlexander Motin sd->sd_offset = (off_t)meta->disk_offset * 512; //ZZZ 88389b17223SAlexander Motin sd->sd_size = (off_t)meta->disk_sectors * 512; //ZZZ 88489b17223SAlexander Motin } 88589b17223SAlexander Motin g_raid_start_volume(vol); 88689b17223SAlexander Motin 88789b17223SAlexander Motin /* Make all disks found till the moment take their places. */ 88889b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 88989b17223SAlexander Motin pd = disk->d_md_data; 89089b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; i++) { 89189b17223SAlexander Motin if (pd->pd_meta[i]->volume_id == meta->volume_id) 89289b17223SAlexander Motin g_raid_md_promise_start_disk(disk, i, vol); 89389b17223SAlexander Motin } 89489b17223SAlexander Motin } 89589b17223SAlexander Motin 89689b17223SAlexander Motin pv->pv_started = 1; 89789b17223SAlexander Motin callout_stop(&pv->pv_start_co); 89889b17223SAlexander Motin G_RAID_DEBUG1(0, sc, "Volume started."); 89989b17223SAlexander Motin g_raid_md_write_promise(md, vol, NULL, NULL); 90089b17223SAlexander Motin 90189b17223SAlexander Motin /* Pickup any STALE/SPARE disks to refill array if needed. */ 90289b17223SAlexander Motin g_raid_md_promise_refill(sc); 90389b17223SAlexander Motin 90489b17223SAlexander Motin g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME); 90589b17223SAlexander Motin } 90689b17223SAlexander Motin 90789b17223SAlexander Motin static void 90889b17223SAlexander Motin g_raid_promise_go(void *arg) 90989b17223SAlexander Motin { 91089b17223SAlexander Motin struct g_raid_volume *vol; 91189b17223SAlexander Motin struct g_raid_softc *sc; 91289b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 91389b17223SAlexander Motin 91489b17223SAlexander Motin vol = arg; 91589b17223SAlexander Motin pv = vol->v_md_data; 91689b17223SAlexander Motin sc = vol->v_softc; 91789b17223SAlexander Motin if (!pv->pv_started) { 91889b17223SAlexander Motin G_RAID_DEBUG1(0, sc, "Force volume start due to timeout."); 91989b17223SAlexander Motin g_raid_event_send(vol, G_RAID_VOLUME_E_STARTMD, 92089b17223SAlexander Motin G_RAID_EVENT_VOLUME); 92189b17223SAlexander Motin } 92289b17223SAlexander Motin } 92389b17223SAlexander Motin 92489b17223SAlexander Motin static void 92589b17223SAlexander Motin g_raid_md_promise_new_disk(struct g_raid_disk *disk) 92689b17223SAlexander Motin { 92789b17223SAlexander Motin struct g_raid_softc *sc; 92889b17223SAlexander Motin struct g_raid_md_object *md; 92989b17223SAlexander Motin struct promise_raid_conf *pdmeta; 93089b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 93189b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 93289b17223SAlexander Motin struct g_raid_volume *vol; 93389b17223SAlexander Motin int i; 93489b17223SAlexander Motin char buf[33]; 93589b17223SAlexander Motin 93689b17223SAlexander Motin sc = disk->d_softc; 93789b17223SAlexander Motin md = sc->sc_md; 93889b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 93989b17223SAlexander Motin 94089b17223SAlexander Motin if (pd->pd_subdisks == 0) { 94189b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE); 94289b17223SAlexander Motin g_raid_md_promise_refill(sc); 94389b17223SAlexander Motin return; 94489b17223SAlexander Motin } 94589b17223SAlexander Motin 94689b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; i++) { 94789b17223SAlexander Motin pdmeta = pd->pd_meta[i]; 94889b17223SAlexander Motin 94989b17223SAlexander Motin /* Look for volume with matching ID. */ 95089b17223SAlexander Motin vol = g_raid_md_promise_get_volume(sc, pdmeta->volume_id); 95189b17223SAlexander Motin if (vol == NULL) { 95289b17223SAlexander Motin promise_meta_get_name(pdmeta, buf); 95389b17223SAlexander Motin vol = g_raid_create_volume(sc, buf, pdmeta->array_number); 95489b17223SAlexander Motin pv = malloc(sizeof(*pv), M_MD_PROMISE, M_WAITOK | M_ZERO); 95589b17223SAlexander Motin pv->pv_id = pdmeta->volume_id; 95689b17223SAlexander Motin vol->v_md_data = pv; 95789b17223SAlexander Motin callout_init(&pv->pv_start_co, 1); 95889b17223SAlexander Motin callout_reset(&pv->pv_start_co, 95989b17223SAlexander Motin g_raid_start_timeout * hz, 96089b17223SAlexander Motin g_raid_promise_go, vol); 96189b17223SAlexander Motin } else 96289b17223SAlexander Motin pv = vol->v_md_data; 96389b17223SAlexander Motin 96489b17223SAlexander Motin /* If we haven't started yet - check metadata freshness. */ 96589b17223SAlexander Motin if (pv->pv_meta == NULL || !pv->pv_started) { 96689b17223SAlexander Motin if (pv->pv_meta == NULL || 96789b17223SAlexander Motin ((int16_t)(pdmeta->generation - pv->pv_generation)) > 0) { 96889b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Newer disk"); 96989b17223SAlexander Motin if (pv->pv_meta != NULL) 97089b17223SAlexander Motin free(pv->pv_meta, M_MD_PROMISE); 97189b17223SAlexander Motin pv->pv_meta = promise_meta_copy(pdmeta); 97289b17223SAlexander Motin pv->pv_generation = pv->pv_meta->generation; 97389b17223SAlexander Motin pv->pv_disks_present = 1; 97489b17223SAlexander Motin } else if (pdmeta->generation == pv->pv_generation) { 97589b17223SAlexander Motin pv->pv_disks_present++; 97689b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Matching disk (%d of %d up)", 97789b17223SAlexander Motin pv->pv_disks_present, 97889b17223SAlexander Motin pv->pv_meta->total_disks); 97989b17223SAlexander Motin } else { 98089b17223SAlexander Motin G_RAID_DEBUG1(1, sc, "Older disk"); 98189b17223SAlexander Motin } 98289b17223SAlexander Motin } 98389b17223SAlexander Motin } 98489b17223SAlexander Motin 98589b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; i++) { 98689b17223SAlexander Motin pdmeta = pd->pd_meta[i]; 98789b17223SAlexander Motin 98889b17223SAlexander Motin /* Look for volume with matching ID. */ 98989b17223SAlexander Motin vol = g_raid_md_promise_get_volume(sc, pdmeta->volume_id); 99089b17223SAlexander Motin if (vol == NULL) 99189b17223SAlexander Motin continue; 99289b17223SAlexander Motin pv = vol->v_md_data; 99389b17223SAlexander Motin 99489b17223SAlexander Motin if (pv->pv_started) { 99589b17223SAlexander Motin if (g_raid_md_promise_start_disk(disk, i, vol)) 99689b17223SAlexander Motin g_raid_md_write_promise(md, vol, NULL, NULL); 99789b17223SAlexander Motin } else { 99889b17223SAlexander Motin /* If we collected all needed disks - start array. */ 99989b17223SAlexander Motin if (pv->pv_disks_present == pv->pv_meta->total_disks) 100089b17223SAlexander Motin g_raid_md_promise_start(vol); 100189b17223SAlexander Motin } 100289b17223SAlexander Motin } 100389b17223SAlexander Motin } 100489b17223SAlexander Motin 100589b17223SAlexander Motin static int 100689b17223SAlexander Motin g_raid_md_create_promise(struct g_raid_md_object *md, struct g_class *mp, 100789b17223SAlexander Motin struct g_geom **gp) 100889b17223SAlexander Motin { 100989b17223SAlexander Motin struct g_geom *geom; 101089b17223SAlexander Motin struct g_raid_softc *sc; 101189b17223SAlexander Motin 101289b17223SAlexander Motin /* Search for existing node. */ 101389b17223SAlexander Motin LIST_FOREACH(geom, &mp->geom, geom) { 101489b17223SAlexander Motin sc = geom->softc; 101589b17223SAlexander Motin if (sc == NULL) 101689b17223SAlexander Motin continue; 101789b17223SAlexander Motin if (sc->sc_stopping != 0) 101889b17223SAlexander Motin continue; 101989b17223SAlexander Motin if (sc->sc_md->mdo_class != md->mdo_class) 102089b17223SAlexander Motin continue; 102189b17223SAlexander Motin break; 102289b17223SAlexander Motin } 102389b17223SAlexander Motin if (geom != NULL) { 102489b17223SAlexander Motin *gp = geom; 102589b17223SAlexander Motin return (G_RAID_MD_TASTE_EXISTING); 102689b17223SAlexander Motin } 102789b17223SAlexander Motin 102889b17223SAlexander Motin /* Create new one if not found. */ 102989b17223SAlexander Motin sc = g_raid_create_node(mp, "Promise", md); 103089b17223SAlexander Motin if (sc == NULL) 103189b17223SAlexander Motin return (G_RAID_MD_TASTE_FAIL); 103289b17223SAlexander Motin md->mdo_softc = sc; 103389b17223SAlexander Motin *gp = sc->sc_geom; 103489b17223SAlexander Motin return (G_RAID_MD_TASTE_NEW); 103589b17223SAlexander Motin } 103689b17223SAlexander Motin 103789b17223SAlexander Motin static int 103889b17223SAlexander Motin g_raid_md_taste_promise(struct g_raid_md_object *md, struct g_class *mp, 103989b17223SAlexander Motin struct g_consumer *cp, struct g_geom **gp) 104089b17223SAlexander Motin { 104189b17223SAlexander Motin struct g_consumer *rcp; 104289b17223SAlexander Motin struct g_provider *pp; 104389b17223SAlexander Motin struct g_raid_softc *sc; 104489b17223SAlexander Motin struct g_raid_disk *disk; 104589b17223SAlexander Motin struct promise_raid_conf *meta, *metaarr[4]; 104689b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 104789b17223SAlexander Motin struct g_geom *geom; 104889b17223SAlexander Motin int error, i, j, result, len, subdisks; 104989b17223SAlexander Motin char name[16]; 105089b17223SAlexander Motin uint16_t vendor; 105189b17223SAlexander Motin 105289b17223SAlexander Motin G_RAID_DEBUG(1, "Tasting Promise on %s", cp->provider->name); 105389b17223SAlexander Motin pp = cp->provider; 105489b17223SAlexander Motin 105589b17223SAlexander Motin /* Read metadata from device. */ 105689b17223SAlexander Motin meta = NULL; 105789b17223SAlexander Motin vendor = 0xffff; 105889b17223SAlexander Motin if (g_access(cp, 1, 0, 0) != 0) 105989b17223SAlexander Motin return (G_RAID_MD_TASTE_FAIL); 106089b17223SAlexander Motin g_topology_unlock(); 106189b17223SAlexander Motin len = 2; 106289b17223SAlexander Motin if (pp->geom->rank == 1) 106389b17223SAlexander Motin g_io_getattr("GEOM::hba_vendor", cp, &len, &vendor); 106489b17223SAlexander Motin subdisks = promise_meta_read(cp, metaarr); 106589b17223SAlexander Motin g_topology_lock(); 106689b17223SAlexander Motin g_access(cp, -1, 0, 0); 106789b17223SAlexander Motin if (subdisks == 0) { 106889b17223SAlexander Motin if (g_raid_aggressive_spare) { 106989b17223SAlexander Motin if (vendor == 0x105a || vendor == 0x1002) { 107089b17223SAlexander Motin G_RAID_DEBUG(1, 107189b17223SAlexander Motin "No Promise metadata, forcing spare."); 107289b17223SAlexander Motin goto search; 107389b17223SAlexander Motin } else { 107489b17223SAlexander Motin G_RAID_DEBUG(1, 107589b17223SAlexander Motin "Promise/ATI vendor mismatch " 107689b17223SAlexander Motin "0x%04x != 0x105a/0x1002", 107789b17223SAlexander Motin vendor); 107889b17223SAlexander Motin } 107989b17223SAlexander Motin } 108089b17223SAlexander Motin return (G_RAID_MD_TASTE_FAIL); 108189b17223SAlexander Motin } 108289b17223SAlexander Motin 108389b17223SAlexander Motin /* Metadata valid. Print it. */ 108489b17223SAlexander Motin for (i = 0; i < subdisks; i++) 108589b17223SAlexander Motin g_raid_md_promise_print(metaarr[i]); 108689b17223SAlexander Motin 108789b17223SAlexander Motin /* Purge meaningless (empty/spare) records. */ 108889b17223SAlexander Motin for (i = 0; i < subdisks; ) { 108989b17223SAlexander Motin if (metaarr[i]->disk.flags & PROMISE_F_ASSIGNED) { 109089b17223SAlexander Motin i++; 109189b17223SAlexander Motin continue; 109289b17223SAlexander Motin } 109389b17223SAlexander Motin free(metaarr[i], M_MD_PROMISE); 109489b17223SAlexander Motin for (j = i; j < subdisks - 1; j++) 109589b17223SAlexander Motin metaarr[i] = metaarr[j + 1]; 109689b17223SAlexander Motin metaarr[PROMISE_MAX_SUBDISKS - 1] = NULL; 109789b17223SAlexander Motin subdisks--; 109889b17223SAlexander Motin } 109989b17223SAlexander Motin 110089b17223SAlexander Motin search: 110189b17223SAlexander Motin /* Search for matching node. */ 110289b17223SAlexander Motin sc = NULL; 110389b17223SAlexander Motin LIST_FOREACH(geom, &mp->geom, geom) { 110489b17223SAlexander Motin sc = geom->softc; 110589b17223SAlexander Motin if (sc == NULL) 110689b17223SAlexander Motin continue; 110789b17223SAlexander Motin if (sc->sc_stopping != 0) 110889b17223SAlexander Motin continue; 110989b17223SAlexander Motin if (sc->sc_md->mdo_class != md->mdo_class) 111089b17223SAlexander Motin continue; 111189b17223SAlexander Motin break; 111289b17223SAlexander Motin } 111389b17223SAlexander Motin 111489b17223SAlexander Motin /* Found matching node. */ 111589b17223SAlexander Motin if (geom != NULL) { 111689b17223SAlexander Motin G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name); 111789b17223SAlexander Motin result = G_RAID_MD_TASTE_EXISTING; 111889b17223SAlexander Motin 111989b17223SAlexander Motin } else { /* Not found matching node -- create one. */ 112089b17223SAlexander Motin result = G_RAID_MD_TASTE_NEW; 112189b17223SAlexander Motin snprintf(name, sizeof(name), "Promise"); 112289b17223SAlexander Motin sc = g_raid_create_node(mp, name, md); 112389b17223SAlexander Motin md->mdo_softc = sc; 112489b17223SAlexander Motin geom = sc->sc_geom; 112589b17223SAlexander Motin } 112689b17223SAlexander Motin 112789b17223SAlexander Motin rcp = g_new_consumer(geom); 112889b17223SAlexander Motin g_attach(rcp, pp); 112989b17223SAlexander Motin if (g_access(rcp, 1, 1, 1) != 0) 113089b17223SAlexander Motin ; //goto fail1; 113189b17223SAlexander Motin 113289b17223SAlexander Motin g_topology_unlock(); 113389b17223SAlexander Motin sx_xlock(&sc->sc_lock); 113489b17223SAlexander Motin 113589b17223SAlexander Motin pd = malloc(sizeof(*pd), M_MD_PROMISE, M_WAITOK | M_ZERO); 113689b17223SAlexander Motin pd->pd_subdisks = subdisks; 113789b17223SAlexander Motin for (i = 0; i < subdisks; i++) 113889b17223SAlexander Motin pd->pd_meta[i] = metaarr[i]; 113989b17223SAlexander Motin disk = g_raid_create_disk(sc); 114089b17223SAlexander Motin disk->d_md_data = (void *)pd; 114189b17223SAlexander Motin disk->d_consumer = rcp; 114289b17223SAlexander Motin rcp->private = disk; 114389b17223SAlexander Motin 114489b17223SAlexander Motin /* Read kernel dumping information. */ 114589b17223SAlexander Motin disk->d_kd.offset = 0; 114689b17223SAlexander Motin disk->d_kd.length = OFF_MAX; 114789b17223SAlexander Motin len = sizeof(disk->d_kd); 114889b17223SAlexander Motin error = g_io_getattr("GEOM::kerneldump", rcp, &len, &disk->d_kd); 114989b17223SAlexander Motin if (disk->d_kd.di.dumper == NULL) 115089b17223SAlexander Motin G_RAID_DEBUG1(2, sc, "Dumping not supported by %s: %d.", 115189b17223SAlexander Motin rcp->provider->name, error); 115289b17223SAlexander Motin 115389b17223SAlexander Motin g_raid_md_promise_new_disk(disk); 115489b17223SAlexander Motin 115589b17223SAlexander Motin sx_xunlock(&sc->sc_lock); 115689b17223SAlexander Motin g_topology_lock(); 115789b17223SAlexander Motin *gp = geom; 115889b17223SAlexander Motin return (result); 115989b17223SAlexander Motin } 116089b17223SAlexander Motin 116189b17223SAlexander Motin static int 116289b17223SAlexander Motin g_raid_md_event_promise(struct g_raid_md_object *md, 116389b17223SAlexander Motin struct g_raid_disk *disk, u_int event) 116489b17223SAlexander Motin { 116589b17223SAlexander Motin struct g_raid_softc *sc; 116689b17223SAlexander Motin 116789b17223SAlexander Motin sc = md->mdo_softc; 116889b17223SAlexander Motin if (disk == NULL) 116989b17223SAlexander Motin return (-1); 117089b17223SAlexander Motin switch (event) { 117189b17223SAlexander Motin case G_RAID_DISK_E_DISCONNECTED: 117289b17223SAlexander Motin /* Delete disk. */ 117389b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE); 117489b17223SAlexander Motin g_raid_destroy_disk(disk); 117589b17223SAlexander Motin g_raid_md_promise_purge_volumes(sc); 117689b17223SAlexander Motin 117789b17223SAlexander Motin /* Write updated metadata to all disks. */ 117889b17223SAlexander Motin g_raid_md_write_promise(md, NULL, NULL, NULL); 117989b17223SAlexander Motin 118089b17223SAlexander Motin /* Check if anything left. */ 118189b17223SAlexander Motin if (g_raid_ndisks(sc, -1) == 0) 118289b17223SAlexander Motin g_raid_destroy_node(sc, 0); 118389b17223SAlexander Motin else 118489b17223SAlexander Motin g_raid_md_promise_refill(sc); 118589b17223SAlexander Motin return (0); 118689b17223SAlexander Motin } 118789b17223SAlexander Motin return (-2); 118889b17223SAlexander Motin } 118989b17223SAlexander Motin 119089b17223SAlexander Motin static int 119189b17223SAlexander Motin g_raid_md_volume_event_promise(struct g_raid_md_object *md, 119289b17223SAlexander Motin struct g_raid_volume *vol, u_int event) 119389b17223SAlexander Motin { 119489b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 119589b17223SAlexander Motin 119689b17223SAlexander Motin pv = (struct g_raid_md_promise_pervolume *)vol->v_md_data; 119789b17223SAlexander Motin switch (event) { 119889b17223SAlexander Motin case G_RAID_VOLUME_E_STARTMD: 119989b17223SAlexander Motin if (!pv->pv_started) 120089b17223SAlexander Motin g_raid_md_promise_start(vol); 120189b17223SAlexander Motin return (0); 120289b17223SAlexander Motin } 120389b17223SAlexander Motin return (-2); 120489b17223SAlexander Motin } 120589b17223SAlexander Motin 120689b17223SAlexander Motin static int 120789b17223SAlexander Motin g_raid_md_ctl_promise(struct g_raid_md_object *md, 120889b17223SAlexander Motin struct gctl_req *req) 120989b17223SAlexander Motin { 121089b17223SAlexander Motin struct g_raid_softc *sc; 121189b17223SAlexander Motin struct g_raid_volume *vol, *vol1; 121289b17223SAlexander Motin struct g_raid_subdisk *sd; 121389b17223SAlexander Motin struct g_raid_disk *disk, *disks[PROMISE_MAX_DISKS]; 121489b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 121589b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 121689b17223SAlexander Motin struct g_consumer *cp; 121789b17223SAlexander Motin struct g_provider *pp; 121889b17223SAlexander Motin char arg[16]; 121989b17223SAlexander Motin const char *verb, *volname, *levelname, *diskname; 122089b17223SAlexander Motin char *tmp; 122189b17223SAlexander Motin int *nargs, *force; 122289b17223SAlexander Motin off_t size, sectorsize, strip; 122389b17223SAlexander Motin intmax_t *sizearg, *striparg; 122489b17223SAlexander Motin uint32_t offs[PROMISE_MAX_DISKS], esize; 122589b17223SAlexander Motin int numdisks, i, len, level, qual; 122689b17223SAlexander Motin int error; 122789b17223SAlexander Motin 122889b17223SAlexander Motin sc = md->mdo_softc; 122989b17223SAlexander Motin verb = gctl_get_param(req, "verb", NULL); 123089b17223SAlexander Motin nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs)); 123189b17223SAlexander Motin error = 0; 123289b17223SAlexander Motin if (strcmp(verb, "label") == 0) { 123389b17223SAlexander Motin 123489b17223SAlexander Motin if (*nargs < 4) { 123589b17223SAlexander Motin gctl_error(req, "Invalid number of arguments."); 123689b17223SAlexander Motin return (-1); 123789b17223SAlexander Motin } 123889b17223SAlexander Motin volname = gctl_get_asciiparam(req, "arg1"); 123989b17223SAlexander Motin if (volname == NULL) { 124089b17223SAlexander Motin gctl_error(req, "No volume name."); 124189b17223SAlexander Motin return (-2); 124289b17223SAlexander Motin } 124389b17223SAlexander Motin levelname = gctl_get_asciiparam(req, "arg2"); 124489b17223SAlexander Motin if (levelname == NULL) { 124589b17223SAlexander Motin gctl_error(req, "No RAID level."); 124689b17223SAlexander Motin return (-3); 124789b17223SAlexander Motin } 1248fc1de960SAlexander Motin if (strcasecmp(levelname, "RAID5") == 0) 1249fc1de960SAlexander Motin levelname = "RAID5LA"; 125089b17223SAlexander Motin if (g_raid_volume_str2level(levelname, &level, &qual)) { 125189b17223SAlexander Motin gctl_error(req, "Unknown RAID level '%s'.", levelname); 125289b17223SAlexander Motin return (-4); 125389b17223SAlexander Motin } 125489b17223SAlexander Motin numdisks = *nargs - 3; 125589b17223SAlexander Motin force = gctl_get_paraml(req, "force", sizeof(*force)); 125689b17223SAlexander Motin if (!g_raid_md_promise_supported(level, qual, numdisks, 125789b17223SAlexander Motin force ? *force : 0)) { 125889b17223SAlexander Motin gctl_error(req, "Unsupported RAID level " 125989b17223SAlexander Motin "(0x%02x/0x%02x), or number of disks (%d).", 126089b17223SAlexander Motin level, qual, numdisks); 126189b17223SAlexander Motin return (-5); 126289b17223SAlexander Motin } 126389b17223SAlexander Motin 126489b17223SAlexander Motin /* Search for disks, connect them and probe. */ 126589b17223SAlexander Motin size = INT64_MAX; 126689b17223SAlexander Motin sectorsize = 0; 126789b17223SAlexander Motin bzero(disks, sizeof(disks)); 126889b17223SAlexander Motin bzero(offs, sizeof(offs)); 126989b17223SAlexander Motin for (i = 0; i < numdisks; i++) { 127089b17223SAlexander Motin snprintf(arg, sizeof(arg), "arg%d", i + 3); 127189b17223SAlexander Motin diskname = gctl_get_asciiparam(req, arg); 127289b17223SAlexander Motin if (diskname == NULL) { 127389b17223SAlexander Motin gctl_error(req, "No disk name (%s).", arg); 127489b17223SAlexander Motin error = -6; 127589b17223SAlexander Motin break; 127689b17223SAlexander Motin } 127789b17223SAlexander Motin if (strcmp(diskname, "NONE") == 0) 127889b17223SAlexander Motin continue; 127989b17223SAlexander Motin 128089b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 128189b17223SAlexander Motin if (disk->d_consumer != NULL && 128289b17223SAlexander Motin disk->d_consumer->provider != NULL && 128389b17223SAlexander Motin strcmp(disk->d_consumer->provider->name, 128489b17223SAlexander Motin diskname) == 0) 128589b17223SAlexander Motin break; 128689b17223SAlexander Motin } 128789b17223SAlexander Motin if (disk != NULL) { 128889b17223SAlexander Motin if (disk->d_state != G_RAID_DISK_S_ACTIVE) { 128989b17223SAlexander Motin gctl_error(req, "Disk '%s' is in a " 129089b17223SAlexander Motin "wrong state (%s).", diskname, 129189b17223SAlexander Motin g_raid_disk_state2str(disk->d_state)); 129289b17223SAlexander Motin error = -7; 129389b17223SAlexander Motin break; 129489b17223SAlexander Motin } 129589b17223SAlexander Motin pd = disk->d_md_data; 129689b17223SAlexander Motin if (pd->pd_subdisks >= PROMISE_MAX_SUBDISKS) { 129789b17223SAlexander Motin gctl_error(req, "Disk '%s' already " 129889b17223SAlexander Motin "used by %d volumes.", 129989b17223SAlexander Motin diskname, pd->pd_subdisks); 130089b17223SAlexander Motin error = -7; 130189b17223SAlexander Motin break; 130289b17223SAlexander Motin } 130389b17223SAlexander Motin pp = disk->d_consumer->provider; 130489b17223SAlexander Motin disks[i] = disk; 130589b17223SAlexander Motin promise_meta_unused_range(pd->pd_meta, 130689b17223SAlexander Motin pd->pd_subdisks, 130789b17223SAlexander Motin pp->mediasize / pp->sectorsize, 130889b17223SAlexander Motin &offs[i], &esize); 130989b17223SAlexander Motin size = MIN(size, (off_t)esize * pp->sectorsize); 131089b17223SAlexander Motin sectorsize = MAX(sectorsize, pp->sectorsize); 131189b17223SAlexander Motin continue; 131289b17223SAlexander Motin } 131389b17223SAlexander Motin 131489b17223SAlexander Motin g_topology_lock(); 131589b17223SAlexander Motin cp = g_raid_open_consumer(sc, diskname); 131689b17223SAlexander Motin if (cp == NULL) { 131789b17223SAlexander Motin gctl_error(req, "Can't open disk '%s'.", 131889b17223SAlexander Motin diskname); 131989b17223SAlexander Motin g_topology_unlock(); 132089b17223SAlexander Motin error = -8; 132189b17223SAlexander Motin break; 132289b17223SAlexander Motin } 132389b17223SAlexander Motin pp = cp->provider; 132489b17223SAlexander Motin pd = malloc(sizeof(*pd), M_MD_PROMISE, M_WAITOK | M_ZERO); 132589b17223SAlexander Motin disk = g_raid_create_disk(sc); 132689b17223SAlexander Motin disk->d_md_data = (void *)pd; 132789b17223SAlexander Motin disk->d_consumer = cp; 132889b17223SAlexander Motin disks[i] = disk; 132989b17223SAlexander Motin cp->private = disk; 133089b17223SAlexander Motin g_topology_unlock(); 133189b17223SAlexander Motin 1332733a1f3fSAlexander Motin if (pp->mediasize / pp->sectorsize > UINT32_MAX) { 1333733a1f3fSAlexander Motin gctl_error(req, 1334733a1f3fSAlexander Motin "Disk '%s' is too big.", diskname); 1335733a1f3fSAlexander Motin error = -8; 1336733a1f3fSAlexander Motin break; 1337733a1f3fSAlexander Motin } 1338733a1f3fSAlexander Motin 133989b17223SAlexander Motin /* Read kernel dumping information. */ 134089b17223SAlexander Motin disk->d_kd.offset = 0; 134189b17223SAlexander Motin disk->d_kd.length = OFF_MAX; 134289b17223SAlexander Motin len = sizeof(disk->d_kd); 134389b17223SAlexander Motin g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd); 134489b17223SAlexander Motin if (disk->d_kd.di.dumper == NULL) 134589b17223SAlexander Motin G_RAID_DEBUG1(2, sc, 134689b17223SAlexander Motin "Dumping not supported by %s.", 134789b17223SAlexander Motin cp->provider->name); 134889b17223SAlexander Motin 134989b17223SAlexander Motin /* Reserve some space for metadata. */ 135089b17223SAlexander Motin size = MIN(size, pp->mediasize - 131072llu * pp->sectorsize); 135189b17223SAlexander Motin sectorsize = MAX(sectorsize, pp->sectorsize); 135289b17223SAlexander Motin } 135389b17223SAlexander Motin if (error != 0) { 135489b17223SAlexander Motin for (i = 0; i < numdisks; i++) { 135589b17223SAlexander Motin if (disks[i] != NULL && 135689b17223SAlexander Motin disks[i]->d_state == G_RAID_DISK_S_NONE) 135789b17223SAlexander Motin g_raid_destroy_disk(disks[i]); 135889b17223SAlexander Motin } 135989b17223SAlexander Motin return (error); 136089b17223SAlexander Motin } 136189b17223SAlexander Motin 136214e2cd0aSAlexander Motin if (sectorsize <= 0) { 136314e2cd0aSAlexander Motin gctl_error(req, "Can't get sector size."); 136414e2cd0aSAlexander Motin return (-8); 136514e2cd0aSAlexander Motin } 136614e2cd0aSAlexander Motin 136789b17223SAlexander Motin /* Handle size argument. */ 136889b17223SAlexander Motin len = sizeof(*sizearg); 136989b17223SAlexander Motin sizearg = gctl_get_param(req, "size", &len); 137089b17223SAlexander Motin if (sizearg != NULL && len == sizeof(*sizearg) && 137189b17223SAlexander Motin *sizearg > 0) { 137289b17223SAlexander Motin if (*sizearg > size) { 137389b17223SAlexander Motin gctl_error(req, "Size too big %lld > %lld.", 137489b17223SAlexander Motin (long long)*sizearg, (long long)size); 137589b17223SAlexander Motin return (-9); 137689b17223SAlexander Motin } 137789b17223SAlexander Motin size = *sizearg; 137889b17223SAlexander Motin } 137989b17223SAlexander Motin 138089b17223SAlexander Motin /* Handle strip argument. */ 138189b17223SAlexander Motin strip = 131072; 138289b17223SAlexander Motin len = sizeof(*striparg); 138389b17223SAlexander Motin striparg = gctl_get_param(req, "strip", &len); 138489b17223SAlexander Motin if (striparg != NULL && len == sizeof(*striparg) && 138589b17223SAlexander Motin *striparg > 0) { 138689b17223SAlexander Motin if (*striparg < sectorsize) { 138789b17223SAlexander Motin gctl_error(req, "Strip size too small."); 138889b17223SAlexander Motin return (-10); 138989b17223SAlexander Motin } 139089b17223SAlexander Motin if (*striparg % sectorsize != 0) { 139189b17223SAlexander Motin gctl_error(req, "Incorrect strip size."); 139289b17223SAlexander Motin return (-11); 139389b17223SAlexander Motin } 139489b17223SAlexander Motin strip = *striparg; 139589b17223SAlexander Motin } 139689b17223SAlexander Motin 139789b17223SAlexander Motin /* Round size down to strip or sector. */ 139889b17223SAlexander Motin if (level == G_RAID_VOLUME_RL_RAID1 || 139989b17223SAlexander Motin level == G_RAID_VOLUME_RL_SINGLE || 140089b17223SAlexander Motin level == G_RAID_VOLUME_RL_CONCAT) 140189b17223SAlexander Motin size -= (size % sectorsize); 140289b17223SAlexander Motin else if (level == G_RAID_VOLUME_RL_RAID1E && 140389b17223SAlexander Motin (numdisks & 1) != 0) 140489b17223SAlexander Motin size -= (size % (2 * strip)); 140589b17223SAlexander Motin else 140689b17223SAlexander Motin size -= (size % strip); 140789b17223SAlexander Motin if (size <= 0) { 140889b17223SAlexander Motin gctl_error(req, "Size too small."); 140989b17223SAlexander Motin return (-13); 141089b17223SAlexander Motin } 141189b17223SAlexander Motin if (size > 0xffffffffllu * sectorsize) { 141289b17223SAlexander Motin gctl_error(req, "Size too big."); 141389b17223SAlexander Motin return (-14); 141489b17223SAlexander Motin } 141589b17223SAlexander Motin 141689b17223SAlexander Motin /* We have all we need, create things: volume, ... */ 141789b17223SAlexander Motin pv = malloc(sizeof(*pv), M_MD_PROMISE, M_WAITOK | M_ZERO); 141889b17223SAlexander Motin arc4rand(&pv->pv_id, sizeof(pv->pv_id), 0); 141989b17223SAlexander Motin pv->pv_generation = 0; 142089b17223SAlexander Motin pv->pv_started = 1; 142189b17223SAlexander Motin vol = g_raid_create_volume(sc, volname, -1); 142289b17223SAlexander Motin vol->v_md_data = pv; 142389b17223SAlexander Motin vol->v_raid_level = level; 1424fc1de960SAlexander Motin vol->v_raid_level_qualifier = qual; 142589b17223SAlexander Motin vol->v_strip_size = strip; 142689b17223SAlexander Motin vol->v_disks_count = numdisks; 142789b17223SAlexander Motin if (level == G_RAID_VOLUME_RL_RAID0 || 142889b17223SAlexander Motin level == G_RAID_VOLUME_RL_CONCAT || 142989b17223SAlexander Motin level == G_RAID_VOLUME_RL_SINGLE) 143089b17223SAlexander Motin vol->v_mediasize = size * numdisks; 143189b17223SAlexander Motin else if (level == G_RAID_VOLUME_RL_RAID1) 143289b17223SAlexander Motin vol->v_mediasize = size; 143389b17223SAlexander Motin else if (level == G_RAID_VOLUME_RL_RAID3 || 143489b17223SAlexander Motin level == G_RAID_VOLUME_RL_RAID5) 143589b17223SAlexander Motin vol->v_mediasize = size * (numdisks - 1); 143689b17223SAlexander Motin else { /* RAID1E */ 143789b17223SAlexander Motin vol->v_mediasize = ((size * numdisks) / strip / 2) * 143889b17223SAlexander Motin strip; 143989b17223SAlexander Motin } 144089b17223SAlexander Motin vol->v_sectorsize = sectorsize; 144189b17223SAlexander Motin g_raid_start_volume(vol); 144289b17223SAlexander Motin 144389b17223SAlexander Motin /* , and subdisks. */ 144489b17223SAlexander Motin for (i = 0; i < numdisks; i++) { 144589b17223SAlexander Motin disk = disks[i]; 144689b17223SAlexander Motin sd = &vol->v_subdisks[i]; 144789b17223SAlexander Motin sd->sd_disk = disk; 144889b17223SAlexander Motin sd->sd_offset = (off_t)offs[i] * 512; 144989b17223SAlexander Motin sd->sd_size = size; 145089b17223SAlexander Motin if (disk == NULL) 145189b17223SAlexander Motin continue; 145289b17223SAlexander Motin TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next); 145389b17223SAlexander Motin g_raid_change_disk_state(disk, 145489b17223SAlexander Motin G_RAID_DISK_S_ACTIVE); 145589b17223SAlexander Motin g_raid_change_subdisk_state(sd, 145689b17223SAlexander Motin G_RAID_SUBDISK_S_ACTIVE); 145789b17223SAlexander Motin g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW, 145889b17223SAlexander Motin G_RAID_EVENT_SUBDISK); 145989b17223SAlexander Motin } 146089b17223SAlexander Motin 146189b17223SAlexander Motin /* Write metadata based on created entities. */ 146289b17223SAlexander Motin G_RAID_DEBUG1(0, sc, "Array started."); 146389b17223SAlexander Motin g_raid_md_write_promise(md, vol, NULL, NULL); 146489b17223SAlexander Motin 146589b17223SAlexander Motin /* Pickup any STALE/SPARE disks to refill array if needed. */ 146689b17223SAlexander Motin g_raid_md_promise_refill(sc); 146789b17223SAlexander Motin 146889b17223SAlexander Motin g_raid_event_send(vol, G_RAID_VOLUME_E_START, 146989b17223SAlexander Motin G_RAID_EVENT_VOLUME); 147089b17223SAlexander Motin return (0); 147189b17223SAlexander Motin } 147289b17223SAlexander Motin if (strcmp(verb, "add") == 0) { 147389b17223SAlexander Motin 147489b17223SAlexander Motin gctl_error(req, "`add` command is not applicable, " 147589b17223SAlexander Motin "use `label` instead."); 147689b17223SAlexander Motin return (-99); 147789b17223SAlexander Motin } 147889b17223SAlexander Motin if (strcmp(verb, "delete") == 0) { 147989b17223SAlexander Motin 148089b17223SAlexander Motin /* Full node destruction. */ 148189b17223SAlexander Motin if (*nargs == 1) { 148289b17223SAlexander Motin /* Check if some volume is still open. */ 148389b17223SAlexander Motin force = gctl_get_paraml(req, "force", sizeof(*force)); 148489b17223SAlexander Motin if (force != NULL && *force == 0 && 148589b17223SAlexander Motin g_raid_nopens(sc) != 0) { 148689b17223SAlexander Motin gctl_error(req, "Some volume is still open."); 148789b17223SAlexander Motin return (-4); 148889b17223SAlexander Motin } 148989b17223SAlexander Motin 149089b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 149189b17223SAlexander Motin if (disk->d_consumer) 149289b17223SAlexander Motin promise_meta_erase(disk->d_consumer); 149389b17223SAlexander Motin } 149489b17223SAlexander Motin g_raid_destroy_node(sc, 0); 149589b17223SAlexander Motin return (0); 149689b17223SAlexander Motin } 149789b17223SAlexander Motin 149889b17223SAlexander Motin /* Destroy specified volume. If it was last - all node. */ 149989b17223SAlexander Motin if (*nargs != 2) { 150089b17223SAlexander Motin gctl_error(req, "Invalid number of arguments."); 150189b17223SAlexander Motin return (-1); 150289b17223SAlexander Motin } 150389b17223SAlexander Motin volname = gctl_get_asciiparam(req, "arg1"); 150489b17223SAlexander Motin if (volname == NULL) { 150589b17223SAlexander Motin gctl_error(req, "No volume name."); 150689b17223SAlexander Motin return (-2); 150789b17223SAlexander Motin } 150889b17223SAlexander Motin 150989b17223SAlexander Motin /* Search for volume. */ 151089b17223SAlexander Motin TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 151189b17223SAlexander Motin if (strcmp(vol->v_name, volname) == 0) 151289b17223SAlexander Motin break; 151389b17223SAlexander Motin } 151489b17223SAlexander Motin if (vol == NULL) { 151589b17223SAlexander Motin i = strtol(volname, &tmp, 10); 151689b17223SAlexander Motin if (verb != volname && tmp[0] == 0) { 151789b17223SAlexander Motin TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 151889b17223SAlexander Motin if (vol->v_global_id == i) 151989b17223SAlexander Motin break; 152089b17223SAlexander Motin } 152189b17223SAlexander Motin } 152289b17223SAlexander Motin } 152389b17223SAlexander Motin if (vol == NULL) { 152489b17223SAlexander Motin gctl_error(req, "Volume '%s' not found.", volname); 152589b17223SAlexander Motin return (-3); 152689b17223SAlexander Motin } 152789b17223SAlexander Motin 152889b17223SAlexander Motin /* Check if volume is still open. */ 152989b17223SAlexander Motin force = gctl_get_paraml(req, "force", sizeof(*force)); 153089b17223SAlexander Motin if (force != NULL && *force == 0 && 153189b17223SAlexander Motin vol->v_provider_open != 0) { 153289b17223SAlexander Motin gctl_error(req, "Volume is still open."); 153389b17223SAlexander Motin return (-4); 153489b17223SAlexander Motin } 153589b17223SAlexander Motin 153689b17223SAlexander Motin /* Destroy volume and potentially node. */ 153789b17223SAlexander Motin i = 0; 153889b17223SAlexander Motin TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next) 153989b17223SAlexander Motin i++; 154089b17223SAlexander Motin if (i >= 2) { 154189b17223SAlexander Motin g_raid_destroy_volume(vol); 154289b17223SAlexander Motin g_raid_md_promise_purge_disks(sc); 154389b17223SAlexander Motin g_raid_md_write_promise(md, NULL, NULL, NULL); 154489b17223SAlexander Motin } else { 154589b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 154689b17223SAlexander Motin if (disk->d_consumer) 154789b17223SAlexander Motin promise_meta_erase(disk->d_consumer); 154889b17223SAlexander Motin } 154989b17223SAlexander Motin g_raid_destroy_node(sc, 0); 155089b17223SAlexander Motin } 155189b17223SAlexander Motin return (0); 155289b17223SAlexander Motin } 155389b17223SAlexander Motin if (strcmp(verb, "remove") == 0 || 155489b17223SAlexander Motin strcmp(verb, "fail") == 0) { 155589b17223SAlexander Motin if (*nargs < 2) { 155689b17223SAlexander Motin gctl_error(req, "Invalid number of arguments."); 155789b17223SAlexander Motin return (-1); 155889b17223SAlexander Motin } 155989b17223SAlexander Motin for (i = 1; i < *nargs; i++) { 156089b17223SAlexander Motin snprintf(arg, sizeof(arg), "arg%d", i); 156189b17223SAlexander Motin diskname = gctl_get_asciiparam(req, arg); 156289b17223SAlexander Motin if (diskname == NULL) { 156389b17223SAlexander Motin gctl_error(req, "No disk name (%s).", arg); 156489b17223SAlexander Motin error = -2; 156589b17223SAlexander Motin break; 156689b17223SAlexander Motin } 156789b17223SAlexander Motin if (strncmp(diskname, "/dev/", 5) == 0) 156889b17223SAlexander Motin diskname += 5; 156989b17223SAlexander Motin 157089b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 157189b17223SAlexander Motin if (disk->d_consumer != NULL && 157289b17223SAlexander Motin disk->d_consumer->provider != NULL && 157389b17223SAlexander Motin strcmp(disk->d_consumer->provider->name, 157489b17223SAlexander Motin diskname) == 0) 157589b17223SAlexander Motin break; 157689b17223SAlexander Motin } 157789b17223SAlexander Motin if (disk == NULL) { 157889b17223SAlexander Motin gctl_error(req, "Disk '%s' not found.", 157989b17223SAlexander Motin diskname); 158089b17223SAlexander Motin error = -3; 158189b17223SAlexander Motin break; 158289b17223SAlexander Motin } 158389b17223SAlexander Motin 158489b17223SAlexander Motin if (strcmp(verb, "fail") == 0) { 158589b17223SAlexander Motin g_raid_md_fail_disk_promise(md, NULL, disk); 158689b17223SAlexander Motin continue; 158789b17223SAlexander Motin } 158889b17223SAlexander Motin 158989b17223SAlexander Motin /* Erase metadata on deleting disk and destroy it. */ 159089b17223SAlexander Motin promise_meta_erase(disk->d_consumer); 159189b17223SAlexander Motin g_raid_destroy_disk(disk); 159289b17223SAlexander Motin } 159389b17223SAlexander Motin g_raid_md_promise_purge_volumes(sc); 159489b17223SAlexander Motin 159589b17223SAlexander Motin /* Write updated metadata to remaining disks. */ 159689b17223SAlexander Motin g_raid_md_write_promise(md, NULL, NULL, NULL); 159789b17223SAlexander Motin 159889b17223SAlexander Motin /* Check if anything left. */ 159989b17223SAlexander Motin if (g_raid_ndisks(sc, -1) == 0) 160089b17223SAlexander Motin g_raid_destroy_node(sc, 0); 160189b17223SAlexander Motin else 160289b17223SAlexander Motin g_raid_md_promise_refill(sc); 160389b17223SAlexander Motin return (error); 160489b17223SAlexander Motin } 160589b17223SAlexander Motin if (strcmp(verb, "insert") == 0) { 160689b17223SAlexander Motin if (*nargs < 2) { 160789b17223SAlexander Motin gctl_error(req, "Invalid number of arguments."); 160889b17223SAlexander Motin return (-1); 160989b17223SAlexander Motin } 161089b17223SAlexander Motin for (i = 1; i < *nargs; i++) { 161189b17223SAlexander Motin /* Get disk name. */ 161289b17223SAlexander Motin snprintf(arg, sizeof(arg), "arg%d", i); 161389b17223SAlexander Motin diskname = gctl_get_asciiparam(req, arg); 161489b17223SAlexander Motin if (diskname == NULL) { 161589b17223SAlexander Motin gctl_error(req, "No disk name (%s).", arg); 161689b17223SAlexander Motin error = -3; 161789b17223SAlexander Motin break; 161889b17223SAlexander Motin } 161989b17223SAlexander Motin 162089b17223SAlexander Motin /* Try to find provider with specified name. */ 162189b17223SAlexander Motin g_topology_lock(); 162289b17223SAlexander Motin cp = g_raid_open_consumer(sc, diskname); 162389b17223SAlexander Motin if (cp == NULL) { 162489b17223SAlexander Motin gctl_error(req, "Can't open disk '%s'.", 162589b17223SAlexander Motin diskname); 162689b17223SAlexander Motin g_topology_unlock(); 162789b17223SAlexander Motin error = -4; 162889b17223SAlexander Motin break; 162989b17223SAlexander Motin } 1630733a1f3fSAlexander Motin pp = cp->provider; 163189b17223SAlexander Motin g_topology_unlock(); 163289b17223SAlexander Motin 1633733a1f3fSAlexander Motin if (pp->mediasize / pp->sectorsize > UINT32_MAX) { 1634733a1f3fSAlexander Motin gctl_error(req, 1635733a1f3fSAlexander Motin "Disk '%s' is too big.", diskname); 1636733a1f3fSAlexander Motin g_raid_kill_consumer(sc, cp); 1637733a1f3fSAlexander Motin error = -8; 1638733a1f3fSAlexander Motin break; 1639733a1f3fSAlexander Motin } 1640733a1f3fSAlexander Motin 164189b17223SAlexander Motin pd = malloc(sizeof(*pd), M_MD_PROMISE, M_WAITOK | M_ZERO); 164289b17223SAlexander Motin 164389b17223SAlexander Motin disk = g_raid_create_disk(sc); 164489b17223SAlexander Motin disk->d_consumer = cp; 164589b17223SAlexander Motin disk->d_md_data = (void *)pd; 164689b17223SAlexander Motin cp->private = disk; 164789b17223SAlexander Motin 164889b17223SAlexander Motin /* Read kernel dumping information. */ 164989b17223SAlexander Motin disk->d_kd.offset = 0; 165089b17223SAlexander Motin disk->d_kd.length = OFF_MAX; 165189b17223SAlexander Motin len = sizeof(disk->d_kd); 165289b17223SAlexander Motin g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd); 165389b17223SAlexander Motin if (disk->d_kd.di.dumper == NULL) 165489b17223SAlexander Motin G_RAID_DEBUG1(2, sc, 165589b17223SAlexander Motin "Dumping not supported by %s.", 165689b17223SAlexander Motin cp->provider->name); 165789b17223SAlexander Motin 165889b17223SAlexander Motin /* Welcome the "new" disk. */ 165989b17223SAlexander Motin g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE); 166089b17223SAlexander Motin promise_meta_write_spare(cp); 166189b17223SAlexander Motin g_raid_md_promise_refill(sc); 166289b17223SAlexander Motin } 166389b17223SAlexander Motin return (error); 166489b17223SAlexander Motin } 166589b17223SAlexander Motin return (-100); 166689b17223SAlexander Motin } 166789b17223SAlexander Motin 166889b17223SAlexander Motin static int 166989b17223SAlexander Motin g_raid_md_write_promise(struct g_raid_md_object *md, struct g_raid_volume *tvol, 167089b17223SAlexander Motin struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk) 167189b17223SAlexander Motin { 167289b17223SAlexander Motin struct g_raid_softc *sc; 167389b17223SAlexander Motin struct g_raid_volume *vol; 167489b17223SAlexander Motin struct g_raid_subdisk *sd; 167589b17223SAlexander Motin struct g_raid_disk *disk; 167689b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 167789b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 167889b17223SAlexander Motin struct promise_raid_conf *meta; 167989b17223SAlexander Motin off_t rebuild_lba64; 168089b17223SAlexander Motin int i, j, pos, rebuild; 168189b17223SAlexander Motin 168289b17223SAlexander Motin sc = md->mdo_softc; 168389b17223SAlexander Motin 168489b17223SAlexander Motin if (sc->sc_stopping == G_RAID_DESTROY_HARD) 168589b17223SAlexander Motin return (0); 168689b17223SAlexander Motin 168789b17223SAlexander Motin /* Generate new per-volume metadata for affected volumes. */ 168889b17223SAlexander Motin TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 168989b17223SAlexander Motin if (vol->v_stopping) 169089b17223SAlexander Motin continue; 169189b17223SAlexander Motin 169289b17223SAlexander Motin /* Skip volumes not related to specified targets. */ 169389b17223SAlexander Motin if (tvol != NULL && vol != tvol) 169489b17223SAlexander Motin continue; 169589b17223SAlexander Motin if (tsd != NULL && vol != tsd->sd_volume) 169689b17223SAlexander Motin continue; 169789b17223SAlexander Motin if (tdisk != NULL) { 169889b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 169989b17223SAlexander Motin if (vol->v_subdisks[i].sd_disk == tdisk) 170089b17223SAlexander Motin break; 170189b17223SAlexander Motin } 170289b17223SAlexander Motin if (i >= vol->v_disks_count) 170389b17223SAlexander Motin continue; 170489b17223SAlexander Motin } 170589b17223SAlexander Motin 170689b17223SAlexander Motin pv = (struct g_raid_md_promise_pervolume *)vol->v_md_data; 170789b17223SAlexander Motin pv->pv_generation++; 170889b17223SAlexander Motin 170989b17223SAlexander Motin meta = malloc(sizeof(*meta), M_MD_PROMISE, M_WAITOK | M_ZERO); 171089b17223SAlexander Motin if (pv->pv_meta != NULL) 171189b17223SAlexander Motin memcpy(meta, pv->pv_meta, sizeof(*meta)); 171263607675SAlexander Motin memcpy(meta->promise_id, PROMISE_MAGIC, 171363607675SAlexander Motin sizeof(PROMISE_MAGIC) - 1); 171489b17223SAlexander Motin meta->dummy_0 = 0x00020000; 171589b17223SAlexander Motin meta->integrity = PROMISE_I_VALID; 171689b17223SAlexander Motin 171789b17223SAlexander Motin meta->generation = pv->pv_generation; 171889b17223SAlexander Motin meta->status = PROMISE_S_VALID | PROMISE_S_ONLINE | 171989b17223SAlexander Motin PROMISE_S_INITED | PROMISE_S_READY; 172089b17223SAlexander Motin if (vol->v_state <= G_RAID_VOLUME_S_DEGRADED) 172189b17223SAlexander Motin meta->status |= PROMISE_S_DEGRADED; 172289b17223SAlexander Motin if (vol->v_dirty) 172389b17223SAlexander Motin meta->status |= PROMISE_S_MARKED; /* XXX: INVENTED! */ 172489b17223SAlexander Motin if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID0 || 172589b17223SAlexander Motin vol->v_raid_level == G_RAID_VOLUME_RL_SINGLE) 172689b17223SAlexander Motin meta->type = PROMISE_T_RAID0; 172789b17223SAlexander Motin else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 || 172889b17223SAlexander Motin vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) 172989b17223SAlexander Motin meta->type = PROMISE_T_RAID1; 173089b17223SAlexander Motin else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID3) 173189b17223SAlexander Motin meta->type = PROMISE_T_RAID3; 173289b17223SAlexander Motin else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID5) 173389b17223SAlexander Motin meta->type = PROMISE_T_RAID5; 173489b17223SAlexander Motin else if (vol->v_raid_level == G_RAID_VOLUME_RL_CONCAT) 173589b17223SAlexander Motin meta->type = PROMISE_T_SPAN; 173689b17223SAlexander Motin else 173789b17223SAlexander Motin meta->type = PROMISE_T_JBOD; 173889b17223SAlexander Motin meta->total_disks = vol->v_disks_count; 173989b17223SAlexander Motin meta->stripe_shift = ffs(vol->v_strip_size / 1024); 174089b17223SAlexander Motin meta->array_width = vol->v_disks_count; 174189b17223SAlexander Motin if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 || 174289b17223SAlexander Motin vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) 174389b17223SAlexander Motin meta->array_width /= 2; 174489b17223SAlexander Motin meta->array_number = vol->v_global_id; 174589b17223SAlexander Motin meta->total_sectors = vol->v_mediasize / vol->v_sectorsize; 1746733a1f3fSAlexander Motin meta->total_sectors_high = 1747733a1f3fSAlexander Motin (vol->v_mediasize / vol->v_sectorsize) >> 32; 174889b17223SAlexander Motin meta->cylinders = meta->total_sectors / (255 * 63) - 1; 174989b17223SAlexander Motin meta->heads = 254; 175089b17223SAlexander Motin meta->sectors = 63; 175189b17223SAlexander Motin meta->volume_id = pv->pv_id; 175289b17223SAlexander Motin rebuild_lba64 = UINT64_MAX; 175389b17223SAlexander Motin rebuild = 0; 175489b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 175589b17223SAlexander Motin sd = &vol->v_subdisks[i]; 175689b17223SAlexander Motin /* For RAID0+1 we need to translate order. */ 175789b17223SAlexander Motin pos = promise_meta_translate_disk(vol, i); 175889b17223SAlexander Motin meta->disks[pos].flags = PROMISE_F_VALID | 175989b17223SAlexander Motin PROMISE_F_ASSIGNED; 176089b17223SAlexander Motin if (sd->sd_state == G_RAID_SUBDISK_S_NONE) { 176189b17223SAlexander Motin meta->disks[pos].flags |= 0; 176289b17223SAlexander Motin } else if (sd->sd_state == G_RAID_SUBDISK_S_FAILED) { 176389b17223SAlexander Motin meta->disks[pos].flags |= 176489b17223SAlexander Motin PROMISE_F_DOWN | PROMISE_F_REDIR; 176589b17223SAlexander Motin } else if (sd->sd_state <= G_RAID_SUBDISK_S_REBUILD) { 176689b17223SAlexander Motin meta->disks[pos].flags |= 176789b17223SAlexander Motin PROMISE_F_ONLINE | PROMISE_F_REDIR; 176889b17223SAlexander Motin if (sd->sd_state == G_RAID_SUBDISK_S_REBUILD) { 176989b17223SAlexander Motin rebuild_lba64 = MIN(rebuild_lba64, 177089b17223SAlexander Motin sd->sd_rebuild_pos / 512); 177189b17223SAlexander Motin } else 177289b17223SAlexander Motin rebuild_lba64 = 0; 177389b17223SAlexander Motin rebuild = 1; 177489b17223SAlexander Motin } else { 177589b17223SAlexander Motin meta->disks[pos].flags |= PROMISE_F_ONLINE; 177689b17223SAlexander Motin if (sd->sd_state < G_RAID_SUBDISK_S_ACTIVE) { 177789b17223SAlexander Motin meta->status |= PROMISE_S_MARKED; 177889b17223SAlexander Motin if (sd->sd_state == G_RAID_SUBDISK_S_RESYNC) { 177989b17223SAlexander Motin rebuild_lba64 = MIN(rebuild_lba64, 178089b17223SAlexander Motin sd->sd_rebuild_pos / 512); 178189b17223SAlexander Motin } else 178289b17223SAlexander Motin rebuild_lba64 = 0; 178389b17223SAlexander Motin } 178489b17223SAlexander Motin } 178589b17223SAlexander Motin if (pv->pv_meta != NULL) { 178689b17223SAlexander Motin meta->disks[pos].id = pv->pv_meta->disks[pos].id; 178789b17223SAlexander Motin } else { 178889b17223SAlexander Motin meta->disks[pos].number = i * 2; 178989b17223SAlexander Motin arc4rand(&meta->disks[pos].id, 179089b17223SAlexander Motin sizeof(meta->disks[pos].id), 0); 179189b17223SAlexander Motin } 179289b17223SAlexander Motin } 179389b17223SAlexander Motin promise_meta_put_name(meta, vol->v_name); 179489b17223SAlexander Motin 179589b17223SAlexander Motin /* Try to mimic AMD BIOS rebuild/resync behavior. */ 179689b17223SAlexander Motin if (rebuild_lba64 != UINT64_MAX) { 179789b17223SAlexander Motin if (rebuild) 179889b17223SAlexander Motin meta->magic_3 = 0x03040010UL; /* Rebuild? */ 179989b17223SAlexander Motin else 180089b17223SAlexander Motin meta->magic_3 = 0x03040008UL; /* Resync? */ 180189b17223SAlexander Motin /* Translate from per-disk to per-volume LBA. */ 180289b17223SAlexander Motin if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 || 180389b17223SAlexander Motin vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) { 180489b17223SAlexander Motin rebuild_lba64 *= meta->array_width; 180589b17223SAlexander Motin } else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID3 || 180689b17223SAlexander Motin vol->v_raid_level == G_RAID_VOLUME_RL_RAID5) { 180789b17223SAlexander Motin rebuild_lba64 *= meta->array_width - 1; 180889b17223SAlexander Motin } else 180989b17223SAlexander Motin rebuild_lba64 = 0; 181089b17223SAlexander Motin } else 181189b17223SAlexander Motin meta->magic_3 = 0x03000000UL; 181289b17223SAlexander Motin meta->rebuild_lba64 = rebuild_lba64; 181389b17223SAlexander Motin meta->magic_4 = 0x04010101UL; 181489b17223SAlexander Motin 181589b17223SAlexander Motin /* Replace per-volume metadata with new. */ 181689b17223SAlexander Motin if (pv->pv_meta != NULL) 181789b17223SAlexander Motin free(pv->pv_meta, M_MD_PROMISE); 181889b17223SAlexander Motin pv->pv_meta = meta; 181989b17223SAlexander Motin 182089b17223SAlexander Motin /* Copy new metadata to the disks, adding or replacing old. */ 182189b17223SAlexander Motin for (i = 0; i < vol->v_disks_count; i++) { 182289b17223SAlexander Motin sd = &vol->v_subdisks[i]; 182389b17223SAlexander Motin disk = sd->sd_disk; 182489b17223SAlexander Motin if (disk == NULL) 182589b17223SAlexander Motin continue; 182689b17223SAlexander Motin /* For RAID0+1 we need to translate order. */ 182789b17223SAlexander Motin pos = promise_meta_translate_disk(vol, i); 182889b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 182989b17223SAlexander Motin for (j = 0; j < pd->pd_subdisks; j++) { 183089b17223SAlexander Motin if (pd->pd_meta[j]->volume_id == meta->volume_id) 183189b17223SAlexander Motin break; 183289b17223SAlexander Motin } 183389b17223SAlexander Motin if (j == pd->pd_subdisks) 183489b17223SAlexander Motin pd->pd_subdisks++; 183589b17223SAlexander Motin if (pd->pd_meta[j] != NULL) 183689b17223SAlexander Motin free(pd->pd_meta[j], M_MD_PROMISE); 183789b17223SAlexander Motin pd->pd_meta[j] = promise_meta_copy(meta); 183889b17223SAlexander Motin pd->pd_meta[j]->disk = meta->disks[pos]; 183989b17223SAlexander Motin pd->pd_meta[j]->disk.number = pos; 184089b17223SAlexander Motin pd->pd_meta[j]->disk_offset = sd->sd_offset / 512; 184189b17223SAlexander Motin pd->pd_meta[j]->disk_sectors = sd->sd_size / 512; 184289b17223SAlexander Motin if (sd->sd_state == G_RAID_SUBDISK_S_REBUILD) { 184389b17223SAlexander Motin pd->pd_meta[j]->rebuild_lba = 184489b17223SAlexander Motin sd->sd_rebuild_pos / 512; 184589b17223SAlexander Motin } else if (sd->sd_state < G_RAID_SUBDISK_S_REBUILD) 184689b17223SAlexander Motin pd->pd_meta[j]->rebuild_lba = 0; 184789b17223SAlexander Motin else 184889b17223SAlexander Motin pd->pd_meta[j]->rebuild_lba = UINT32_MAX; 184989b17223SAlexander Motin pd->pd_updated = 1; 185089b17223SAlexander Motin } 185189b17223SAlexander Motin } 185289b17223SAlexander Motin 185389b17223SAlexander Motin TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 185489b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 185589b17223SAlexander Motin if (disk->d_state != G_RAID_DISK_S_ACTIVE) 185689b17223SAlexander Motin continue; 185789b17223SAlexander Motin if (!pd->pd_updated) 185889b17223SAlexander Motin continue; 185989b17223SAlexander Motin G_RAID_DEBUG(1, "Writing Promise metadata to %s", 186089b17223SAlexander Motin g_raid_get_diskname(disk)); 186189b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; i++) 186289b17223SAlexander Motin g_raid_md_promise_print(pd->pd_meta[i]); 186389b17223SAlexander Motin promise_meta_write(disk->d_consumer, 186489b17223SAlexander Motin pd->pd_meta, pd->pd_subdisks); 186589b17223SAlexander Motin pd->pd_updated = 0; 186689b17223SAlexander Motin } 186789b17223SAlexander Motin 186889b17223SAlexander Motin return (0); 186989b17223SAlexander Motin } 187089b17223SAlexander Motin 187189b17223SAlexander Motin static int 187289b17223SAlexander Motin g_raid_md_fail_disk_promise(struct g_raid_md_object *md, 187389b17223SAlexander Motin struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk) 187489b17223SAlexander Motin { 187589b17223SAlexander Motin struct g_raid_softc *sc; 187689b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 187789b17223SAlexander Motin struct g_raid_subdisk *sd; 187889b17223SAlexander Motin int i, pos; 187989b17223SAlexander Motin 188089b17223SAlexander Motin sc = md->mdo_softc; 188189b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)tdisk->d_md_data; 188289b17223SAlexander Motin 188389b17223SAlexander Motin /* We can't fail disk that is not a part of array now. */ 188489b17223SAlexander Motin if (tdisk->d_state != G_RAID_DISK_S_ACTIVE) 188589b17223SAlexander Motin return (-1); 188689b17223SAlexander Motin 188789b17223SAlexander Motin /* 188889b17223SAlexander Motin * Mark disk as failed in metadata and try to write that metadata 188989b17223SAlexander Motin * to the disk itself to prevent it's later resurrection as STALE. 189089b17223SAlexander Motin */ 189189b17223SAlexander Motin if (pd->pd_subdisks > 0 && tdisk->d_consumer != NULL) 189289b17223SAlexander Motin G_RAID_DEBUG(1, "Writing Promise metadata to %s", 189389b17223SAlexander Motin g_raid_get_diskname(tdisk)); 189489b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; i++) { 189589b17223SAlexander Motin pd->pd_meta[i]->disk.flags |= 189689b17223SAlexander Motin PROMISE_F_DOWN | PROMISE_F_REDIR; 189789b17223SAlexander Motin pos = pd->pd_meta[i]->disk.number; 189889b17223SAlexander Motin if (pos >= 0 && pos < PROMISE_MAX_DISKS) { 189989b17223SAlexander Motin pd->pd_meta[i]->disks[pos].flags |= 190089b17223SAlexander Motin PROMISE_F_DOWN | PROMISE_F_REDIR; 190189b17223SAlexander Motin } 190289b17223SAlexander Motin g_raid_md_promise_print(pd->pd_meta[i]); 190389b17223SAlexander Motin } 190489b17223SAlexander Motin if (tdisk->d_consumer != NULL) 190589b17223SAlexander Motin promise_meta_write(tdisk->d_consumer, 190689b17223SAlexander Motin pd->pd_meta, pd->pd_subdisks); 190789b17223SAlexander Motin 190889b17223SAlexander Motin /* Change states. */ 190989b17223SAlexander Motin g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED); 191089b17223SAlexander Motin TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) { 191189b17223SAlexander Motin g_raid_change_subdisk_state(sd, 191289b17223SAlexander Motin G_RAID_SUBDISK_S_FAILED); 191389b17223SAlexander Motin g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED, 191489b17223SAlexander Motin G_RAID_EVENT_SUBDISK); 191589b17223SAlexander Motin } 191689b17223SAlexander Motin 191789b17223SAlexander Motin /* Write updated metadata to remaining disks. */ 191889b17223SAlexander Motin g_raid_md_write_promise(md, NULL, NULL, tdisk); 191989b17223SAlexander Motin 192089b17223SAlexander Motin g_raid_md_promise_refill(sc); 192189b17223SAlexander Motin return (0); 192289b17223SAlexander Motin } 192389b17223SAlexander Motin 192489b17223SAlexander Motin static int 192589b17223SAlexander Motin g_raid_md_free_disk_promise(struct g_raid_md_object *md, 192689b17223SAlexander Motin struct g_raid_disk *disk) 192789b17223SAlexander Motin { 192889b17223SAlexander Motin struct g_raid_md_promise_perdisk *pd; 192989b17223SAlexander Motin int i; 193089b17223SAlexander Motin 193189b17223SAlexander Motin pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 193289b17223SAlexander Motin for (i = 0; i < pd->pd_subdisks; i++) { 193389b17223SAlexander Motin if (pd->pd_meta[i] != NULL) { 193489b17223SAlexander Motin free(pd->pd_meta[i], M_MD_PROMISE); 193589b17223SAlexander Motin pd->pd_meta[i] = NULL; 193689b17223SAlexander Motin } 193789b17223SAlexander Motin } 193889b17223SAlexander Motin free(pd, M_MD_PROMISE); 193989b17223SAlexander Motin disk->d_md_data = NULL; 194089b17223SAlexander Motin return (0); 194189b17223SAlexander Motin } 194289b17223SAlexander Motin 194389b17223SAlexander Motin static int 194489b17223SAlexander Motin g_raid_md_free_volume_promise(struct g_raid_md_object *md, 194589b17223SAlexander Motin struct g_raid_volume *vol) 194689b17223SAlexander Motin { 194789b17223SAlexander Motin struct g_raid_md_promise_pervolume *pv; 194889b17223SAlexander Motin 194989b17223SAlexander Motin pv = (struct g_raid_md_promise_pervolume *)vol->v_md_data; 195089b17223SAlexander Motin if (pv && pv->pv_meta != NULL) { 195189b17223SAlexander Motin free(pv->pv_meta, M_MD_PROMISE); 195289b17223SAlexander Motin pv->pv_meta = NULL; 195389b17223SAlexander Motin } 195489b17223SAlexander Motin if (pv && !pv->pv_started) { 195589b17223SAlexander Motin pv->pv_started = 1; 195689b17223SAlexander Motin callout_stop(&pv->pv_start_co); 195789b17223SAlexander Motin } 195889b17223SAlexander Motin return (0); 195989b17223SAlexander Motin } 196089b17223SAlexander Motin 196189b17223SAlexander Motin static int 196289b17223SAlexander Motin g_raid_md_free_promise(struct g_raid_md_object *md) 196389b17223SAlexander Motin { 196489b17223SAlexander Motin 196589b17223SAlexander Motin return (0); 196689b17223SAlexander Motin } 196789b17223SAlexander Motin 196889b17223SAlexander Motin G_RAID_MD_DECLARE(g_raid_md_promise); 1969