xref: /freebsd/sys/geom/raid/md_promise.c (revision e26083ca6987f5f7e8e3b974158eadab7edcc679)
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