1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2012 Alexander Motin <mav@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD$");
31
32#include <sys/param.h>
33#include <sys/bio.h>
34#include <sys/gsb_crc32.h>
35#include <sys/endian.h>
36#include <sys/kernel.h>
37#include <sys/kobj.h>
38#include <sys/limits.h>
39#include <sys/lock.h>
40#include <sys/malloc.h>
41#include <sys/mutex.h>
42#include <sys/systm.h>
43#include <sys/time.h>
44#include <sys/clock.h>
45#include <sys/disk.h>
46#include <geom/geom.h>
47#include <geom/geom_dbg.h>
48#include "geom/raid/g_raid.h"
49#include "geom/raid/md_ddf.h"
50#include "g_raid_md_if.h"
51
52static MALLOC_DEFINE(M_MD_DDF, "md_ddf_data", "GEOM_RAID DDF metadata");
53
54#define	DDF_MAX_DISKS_HARD	128
55
56#define	DDF_MAX_DISKS	16
57#define	DDF_MAX_VDISKS	7
58#define	DDF_MAX_PARTITIONS	1
59
60#define DECADE (3600*24*(365*10+2))	/* 10 years in seconds. */
61
62struct ddf_meta {
63	u_int	sectorsize;
64	u_int	bigendian;
65	struct ddf_header *hdr;
66	struct ddf_cd_record *cdr;
67	struct ddf_pd_record *pdr;
68	struct ddf_vd_record *vdr;
69	void *cr;
70	struct ddf_pdd_record *pdd;
71	struct ddf_bbm_log *bbm;
72};
73
74struct ddf_vol_meta {
75	u_int	sectorsize;
76	u_int	bigendian;
77	struct ddf_header *hdr;
78	struct ddf_cd_record *cdr;
79	struct ddf_vd_entry *vde;
80	struct ddf_vdc_record *vdc;
81	struct ddf_vdc_record *bvdc[DDF_MAX_DISKS_HARD];
82};
83
84struct g_raid_md_ddf_perdisk {
85	struct ddf_meta	 pd_meta;
86};
87
88struct g_raid_md_ddf_pervolume {
89	struct ddf_vol_meta		 pv_meta;
90	int				 pv_started;
91	struct callout			 pv_start_co;	/* STARTING state timer. */
92};
93
94struct g_raid_md_ddf_object {
95	struct g_raid_md_object	 mdio_base;
96	u_int			 mdio_bigendian;
97	struct ddf_meta		 mdio_meta;
98	int			 mdio_starting;
99	struct callout		 mdio_start_co;	/* STARTING state timer. */
100	int			 mdio_started;
101	struct root_hold_token	*mdio_rootmount; /* Root mount delay token. */
102};
103
104static g_raid_md_create_req_t g_raid_md_create_req_ddf;
105static g_raid_md_taste_t g_raid_md_taste_ddf;
106static g_raid_md_event_t g_raid_md_event_ddf;
107static g_raid_md_volume_event_t g_raid_md_volume_event_ddf;
108static g_raid_md_ctl_t g_raid_md_ctl_ddf;
109static g_raid_md_write_t g_raid_md_write_ddf;
110static g_raid_md_fail_disk_t g_raid_md_fail_disk_ddf;
111static g_raid_md_free_disk_t g_raid_md_free_disk_ddf;
112static g_raid_md_free_volume_t g_raid_md_free_volume_ddf;
113static g_raid_md_free_t g_raid_md_free_ddf;
114
115static kobj_method_t g_raid_md_ddf_methods[] = {
116	KOBJMETHOD(g_raid_md_create_req,	g_raid_md_create_req_ddf),
117	KOBJMETHOD(g_raid_md_taste,	g_raid_md_taste_ddf),
118	KOBJMETHOD(g_raid_md_event,	g_raid_md_event_ddf),
119	KOBJMETHOD(g_raid_md_volume_event,	g_raid_md_volume_event_ddf),
120	KOBJMETHOD(g_raid_md_ctl,	g_raid_md_ctl_ddf),
121	KOBJMETHOD(g_raid_md_write,	g_raid_md_write_ddf),
122	KOBJMETHOD(g_raid_md_fail_disk,	g_raid_md_fail_disk_ddf),
123	KOBJMETHOD(g_raid_md_free_disk,	g_raid_md_free_disk_ddf),
124	KOBJMETHOD(g_raid_md_free_volume,	g_raid_md_free_volume_ddf),
125	KOBJMETHOD(g_raid_md_free,	g_raid_md_free_ddf),
126	{ 0, 0 }
127};
128
129static struct g_raid_md_class g_raid_md_ddf_class = {
130	"DDF",
131	g_raid_md_ddf_methods,
132	sizeof(struct g_raid_md_ddf_object),
133	.mdc_enable = 1,
134	.mdc_priority = 100
135};
136
137#define GET8(m, f)	((m)->f)
138#define GET16(m, f)	((m)->bigendian ? be16dec(&(m)->f) : le16dec(&(m)->f))
139#define GET32(m, f)	((m)->bigendian ? be32dec(&(m)->f) : le32dec(&(m)->f))
140#define GET64(m, f)	((m)->bigendian ? be64dec(&(m)->f) : le64dec(&(m)->f))
141#define GET8D(m, f)	(f)
142#define GET16D(m, f)	((m)->bigendian ? be16dec(&f) : le16dec(&f))
143#define GET32D(m, f)	((m)->bigendian ? be32dec(&f) : le32dec(&f))
144#define GET64D(m, f)	((m)->bigendian ? be64dec(&f) : le64dec(&f))
145#define GET8P(m, f)	(*(f))
146#define GET16P(m, f)	((m)->bigendian ? be16dec(f) : le16dec(f))
147#define GET32P(m, f)	((m)->bigendian ? be32dec(f) : le32dec(f))
148#define GET64P(m, f)	((m)->bigendian ? be64dec(f) : le64dec(f))
149
150#define SET8P(m, f, v)							\
151	(*(f) = (v))
152#define SET16P(m, f, v)							\
153	do {								\
154		if ((m)->bigendian)					\
155			be16enc((f), (v));				\
156		else							\
157			le16enc((f), (v));				\
158	} while (0)
159#define SET32P(m, f, v)							\
160	do {								\
161		if ((m)->bigendian)					\
162			be32enc((f), (v));				\
163		else							\
164			le32enc((f), (v));				\
165	} while (0)
166#define SET64P(m, f, v)							\
167	do {								\
168		if ((m)->bigendian)					\
169			be64enc((f), (v));				\
170		else							\
171			le64enc((f), (v));				\
172	} while (0)
173#define SET8(m, f, v)	SET8P((m), &((m)->f), (v))
174#define SET16(m, f, v)	SET16P((m), &((m)->f), (v))
175#define SET32(m, f, v)	SET32P((m), &((m)->f), (v))
176#define SET64(m, f, v)	SET64P((m), &((m)->f), (v))
177#define SET8D(m, f, v)	SET8P((m), &(f), (v))
178#define SET16D(m, f, v)	SET16P((m), &(f), (v))
179#define SET32D(m, f, v)	SET32P((m), &(f), (v))
180#define SET64D(m, f, v)	SET64P((m), &(f), (v))
181
182#define GETCRNUM(m)	(GET32((m), hdr->cr_length) /			\
183	GET16((m), hdr->Configuration_Record_Length))
184
185#define GETVDCPTR(m, n)	((struct ddf_vdc_record *)((uint8_t *)(m)->cr +	\
186	(n) * GET16((m), hdr->Configuration_Record_Length) *		\
187	(m)->sectorsize))
188
189#define GETSAPTR(m, n)	((struct ddf_sa_record *)((uint8_t *)(m)->cr +	\
190	(n) * GET16((m), hdr->Configuration_Record_Length) *		\
191	(m)->sectorsize))
192
193static int
194isff(uint8_t *buf, int size)
195{
196	int i;
197
198	for (i = 0; i < size; i++)
199		if (buf[i] != 0xff)
200			return (0);
201	return (1);
202}
203
204static void
205print_guid(uint8_t *buf)
206{
207	int i, ascii;
208
209	ascii = 1;
210	for (i = 0; i < 24; i++) {
211		if (buf[i] != 0 && (buf[i] < ' ' || buf[i] > 127)) {
212			ascii = 0;
213			break;
214		}
215	}
216	if (ascii) {
217		printf("'%.24s'", buf);
218	} else {
219		for (i = 0; i < 24; i++)
220			printf("%02x", buf[i]);
221	}
222}
223
224static void
225g_raid_md_ddf_print(struct ddf_meta *meta)
226{
227	struct ddf_vdc_record *vdc;
228	struct ddf_vuc_record *vuc;
229	struct ddf_sa_record *sa;
230	uint64_t *val2;
231	uint32_t val;
232	int i, j, k, num, num2;
233
234	if (g_raid_debug < 1)
235		return;
236
237	printf("********* DDF Metadata *********\n");
238	printf("**** Header ****\n");
239	printf("DDF_Header_GUID      ");
240	print_guid(meta->hdr->DDF_Header_GUID);
241	printf("\n");
242	printf("DDF_rev              %8.8s\n", (char *)&meta->hdr->DDF_rev[0]);
243	printf("Sequence_Number      0x%08x\n", GET32(meta, hdr->Sequence_Number));
244	printf("TimeStamp            0x%08x\n", GET32(meta, hdr->TimeStamp));
245	printf("Open_Flag            0x%02x\n", GET16(meta, hdr->Open_Flag));
246	printf("Foreign_Flag         0x%02x\n", GET16(meta, hdr->Foreign_Flag));
247	printf("Diskgrouping         0x%02x\n", GET16(meta, hdr->Diskgrouping));
248	printf("Primary_Header_LBA   %ju\n", GET64(meta, hdr->Primary_Header_LBA));
249	printf("Secondary_Header_LBA %ju\n", GET64(meta, hdr->Secondary_Header_LBA));
250	printf("WorkSpace_Length     %u\n", GET32(meta, hdr->WorkSpace_Length));
251	printf("WorkSpace_LBA        %ju\n", GET64(meta, hdr->WorkSpace_LBA));
252	printf("Max_PD_Entries       %u\n", GET16(meta, hdr->Max_PD_Entries));
253	printf("Max_VD_Entries       %u\n", GET16(meta, hdr->Max_VD_Entries));
254	printf("Max_Partitions       %u\n", GET16(meta, hdr->Max_Partitions));
255	printf("Configuration_Record_Length %u\n", GET16(meta, hdr->Configuration_Record_Length));
256	printf("Max_Primary_Element_Entries %u\n", GET16(meta, hdr->Max_Primary_Element_Entries));
257	printf("Controller Data      %u:%u\n", GET32(meta, hdr->cd_section), GET32(meta, hdr->cd_length));
258	printf("Physical Disk        %u:%u\n", GET32(meta, hdr->pdr_section), GET32(meta, hdr->pdr_length));
259	printf("Virtual Disk         %u:%u\n", GET32(meta, hdr->vdr_section), GET32(meta, hdr->vdr_length));
260	printf("Configuration Recs   %u:%u\n", GET32(meta, hdr->cr_section), GET32(meta, hdr->cr_length));
261	printf("Physical Disk Recs   %u:%u\n", GET32(meta, hdr->pdd_section), GET32(meta, hdr->pdd_length));
262	printf("BBM Log              %u:%u\n", GET32(meta, hdr->bbmlog_section), GET32(meta, hdr->bbmlog_length));
263	printf("Diagnostic Space     %u:%u\n", GET32(meta, hdr->Diagnostic_Space), GET32(meta, hdr->Diagnostic_Space_Length));
264	printf("Vendor_Specific_Logs %u:%u\n", GET32(meta, hdr->Vendor_Specific_Logs), GET32(meta, hdr->Vendor_Specific_Logs_Length));
265	printf("**** Controller Data ****\n");
266	printf("Controller_GUID      ");
267	print_guid(meta->cdr->Controller_GUID);
268	printf("\n");
269	printf("Controller_Type      0x%04x%04x 0x%04x%04x\n",
270	    GET16(meta, cdr->Controller_Type.Vendor_ID),
271	    GET16(meta, cdr->Controller_Type.Device_ID),
272	    GET16(meta, cdr->Controller_Type.SubVendor_ID),
273	    GET16(meta, cdr->Controller_Type.SubDevice_ID));
274	printf("Product_ID           '%.16s'\n", (char *)&meta->cdr->Product_ID[0]);
275	printf("**** Physical Disk Records ****\n");
276	printf("Populated_PDEs       %u\n", GET16(meta, pdr->Populated_PDEs));
277	printf("Max_PDE_Supported    %u\n", GET16(meta, pdr->Max_PDE_Supported));
278	for (j = 0; j < GET16(meta, pdr->Populated_PDEs); j++) {
279		if (isff(meta->pdr->entry[j].PD_GUID, 24))
280			continue;
281		if (GET32(meta, pdr->entry[j].PD_Reference) == 0xffffffff)
282			continue;
283		printf("PD_GUID              ");
284		print_guid(meta->pdr->entry[j].PD_GUID);
285		printf("\n");
286		printf("PD_Reference         0x%08x\n",
287		    GET32(meta, pdr->entry[j].PD_Reference));
288		printf("PD_Type              0x%04x\n",
289		    GET16(meta, pdr->entry[j].PD_Type));
290		printf("PD_State             0x%04x\n",
291		    GET16(meta, pdr->entry[j].PD_State));
292		printf("Configured_Size      %ju\n",
293		    GET64(meta, pdr->entry[j].Configured_Size));
294		printf("Block_Size           %u\n",
295		    GET16(meta, pdr->entry[j].Block_Size));
296	}
297	printf("**** Virtual Disk Records ****\n");
298	printf("Populated_VDEs       %u\n", GET16(meta, vdr->Populated_VDEs));
299	printf("Max_VDE_Supported    %u\n", GET16(meta, vdr->Max_VDE_Supported));
300	for (j = 0; j < GET16(meta, vdr->Populated_VDEs); j++) {
301		if (isff(meta->vdr->entry[j].VD_GUID, 24))
302			continue;
303		printf("VD_GUID              ");
304		print_guid(meta->vdr->entry[j].VD_GUID);
305		printf("\n");
306		printf("VD_Number            0x%04x\n",
307		    GET16(meta, vdr->entry[j].VD_Number));
308		printf("VD_Type              0x%04x\n",
309		    GET16(meta, vdr->entry[j].VD_Type));
310		printf("VD_State             0x%02x\n",
311		    GET8(meta, vdr->entry[j].VD_State));
312		printf("Init_State           0x%02x\n",
313		    GET8(meta, vdr->entry[j].Init_State));
314		printf("Drive_Failures_Remaining %u\n",
315		    GET8(meta, vdr->entry[j].Drive_Failures_Remaining));
316		printf("VD_Name              '%.16s'\n",
317		    (char *)&meta->vdr->entry[j].VD_Name);
318	}
319	printf("**** Configuration Records ****\n");
320	num = GETCRNUM(meta);
321	for (j = 0; j < num; j++) {
322		vdc = GETVDCPTR(meta, j);
323		val = GET32D(meta, vdc->Signature);
324		switch (val) {
325		case DDF_VDCR_SIGNATURE:
326			printf("** Virtual Disk Configuration **\n");
327			printf("VD_GUID              ");
328			print_guid(vdc->VD_GUID);
329			printf("\n");
330			printf("Timestamp            0x%08x\n",
331			    GET32D(meta, vdc->Timestamp));
332			printf("Sequence_Number      0x%08x\n",
333			    GET32D(meta, vdc->Sequence_Number));
334			printf("Primary_Element_Count %u\n",
335			    GET16D(meta, vdc->Primary_Element_Count));
336			printf("Stripe_Size          %u\n",
337			    GET8D(meta, vdc->Stripe_Size));
338			printf("Primary_RAID_Level   0x%02x\n",
339			    GET8D(meta, vdc->Primary_RAID_Level));
340			printf("RLQ                  0x%02x\n",
341			    GET8D(meta, vdc->RLQ));
342			printf("Secondary_Element_Count %u\n",
343			    GET8D(meta, vdc->Secondary_Element_Count));
344			printf("Secondary_Element_Seq %u\n",
345			    GET8D(meta, vdc->Secondary_Element_Seq));
346			printf("Secondary_RAID_Level 0x%02x\n",
347			    GET8D(meta, vdc->Secondary_RAID_Level));
348			printf("Block_Count          %ju\n",
349			    GET64D(meta, vdc->Block_Count));
350			printf("VD_Size              %ju\n",
351			    GET64D(meta, vdc->VD_Size));
352			printf("Block_Size           %u\n",
353			    GET16D(meta, vdc->Block_Size));
354			printf("Rotate_Parity_count  %u\n",
355			    GET8D(meta, vdc->Rotate_Parity_count));
356			printf("Associated_Spare_Disks");
357			for (i = 0; i < 8; i++) {
358				if (GET32D(meta, vdc->Associated_Spares[i]) != 0xffffffff)
359					printf(" 0x%08x", GET32D(meta, vdc->Associated_Spares[i]));
360			}
361			printf("\n");
362			printf("Cache_Flags          %016jx\n",
363			    GET64D(meta, vdc->Cache_Flags));
364			printf("BG_Rate              %u\n",
365			    GET8D(meta, vdc->BG_Rate));
366			printf("MDF_Parity_Disks     %u\n",
367			    GET8D(meta, vdc->MDF_Parity_Disks));
368			printf("MDF_Parity_Generator_Polynomial 0x%04x\n",
369			    GET16D(meta, vdc->MDF_Parity_Generator_Polynomial));
370			printf("MDF_Constant_Generation_Method 0x%02x\n",
371			    GET8D(meta, vdc->MDF_Constant_Generation_Method));
372			printf("Physical_Disks      ");
373			num2 = GET16D(meta, vdc->Primary_Element_Count);
374			val2 = (uint64_t *)&(vdc->Physical_Disk_Sequence[GET16(meta, hdr->Max_Primary_Element_Entries)]);
375			for (i = 0; i < num2; i++)
376				printf(" 0x%08x @ %ju",
377				    GET32D(meta, vdc->Physical_Disk_Sequence[i]),
378				    GET64P(meta, val2 + i));
379			printf("\n");
380			break;
381		case DDF_VUCR_SIGNATURE:
382			printf("** Vendor Unique Configuration **\n");
383			vuc = (struct ddf_vuc_record *)vdc;
384			printf("VD_GUID              ");
385			print_guid(vuc->VD_GUID);
386			printf("\n");
387			break;
388		case DDF_SA_SIGNATURE:
389			printf("** Spare Assignment Configuration **\n");
390			sa = (struct ddf_sa_record *)vdc;
391			printf("Timestamp            0x%08x\n",
392			    GET32D(meta, sa->Timestamp));
393			printf("Spare_Type           0x%02x\n",
394			    GET8D(meta, sa->Spare_Type));
395			printf("Populated_SAEs       %u\n",
396			    GET16D(meta, sa->Populated_SAEs));
397			printf("MAX_SAE_Supported    %u\n",
398			    GET16D(meta, sa->MAX_SAE_Supported));
399			for (i = 0; i < GET16D(meta, sa->Populated_SAEs); i++) {
400				if (isff(sa->entry[i].VD_GUID, 24))
401					continue;
402				printf("VD_GUID             ");
403				for (k = 0; k < 24; k++)
404					printf("%02x", sa->entry[i].VD_GUID[k]);
405				printf("\n");
406				printf("Secondary_Element   %u\n",
407				    GET16D(meta, sa->entry[i].Secondary_Element));
408			}
409			break;
410		case 0x00000000:
411		case 0xFFFFFFFF:
412			break;
413		default:
414			printf("Unknown configuration signature %08x\n", val);
415			break;
416		}
417	}
418	printf("**** Physical Disk Data ****\n");
419	printf("PD_GUID              ");
420	print_guid(meta->pdd->PD_GUID);
421	printf("\n");
422	printf("PD_Reference         0x%08x\n",
423	    GET32(meta, pdd->PD_Reference));
424	printf("Forced_Ref_Flag      0x%02x\n",
425	    GET8(meta, pdd->Forced_Ref_Flag));
426	printf("Forced_PD_GUID_Flag  0x%02x\n",
427	    GET8(meta, pdd->Forced_PD_GUID_Flag));
428}
429
430static int
431ddf_meta_find_pd(struct ddf_meta *meta, uint8_t *GUID, uint32_t PD_Reference)
432{
433	int i;
434
435	for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
436		if (GUID != NULL) {
437			if (memcmp(meta->pdr->entry[i].PD_GUID, GUID, 24) == 0)
438				return (i);
439		} else if (PD_Reference != 0xffffffff) {
440			if (GET32(meta, pdr->entry[i].PD_Reference) == PD_Reference)
441				return (i);
442		} else
443			if (isff(meta->pdr->entry[i].PD_GUID, 24))
444				return (i);
445	}
446	if (GUID == NULL && PD_Reference == 0xffffffff) {
447		if (i >= GET16(meta, pdr->Max_PDE_Supported))
448			return (-1);
449		SET16(meta, pdr->Populated_PDEs, i + 1);
450		return (i);
451	}
452	return (-1);
453}
454
455static int
456ddf_meta_find_vd(struct ddf_meta *meta, uint8_t *GUID)
457{
458	int i;
459
460	for (i = 0; i < GET16(meta, vdr->Populated_VDEs); i++) {
461		if (GUID != NULL) {
462			if (memcmp(meta->vdr->entry[i].VD_GUID, GUID, 24) == 0)
463				return (i);
464		} else
465			if (isff(meta->vdr->entry[i].VD_GUID, 24))
466				return (i);
467	}
468	if (GUID == NULL) {
469		if (i >= GET16(meta, vdr->Max_VDE_Supported))
470			return (-1);
471		SET16(meta, vdr->Populated_VDEs, i + 1);
472		return (i);
473	}
474	return (-1);
475}
476
477static struct ddf_vdc_record *
478ddf_meta_find_vdc(struct ddf_meta *meta, uint8_t *GUID)
479{
480	struct ddf_vdc_record *vdc;
481	int i, num;
482
483	num = GETCRNUM(meta);
484	for (i = 0; i < num; i++) {
485		vdc = GETVDCPTR(meta, i);
486		if (GUID != NULL) {
487			if (GET32D(meta, vdc->Signature) == DDF_VDCR_SIGNATURE &&
488			    memcmp(vdc->VD_GUID, GUID, 24) == 0)
489				return (vdc);
490		} else
491			if (GET32D(meta, vdc->Signature) == 0xffffffff ||
492			    GET32D(meta, vdc->Signature) == 0)
493				return (vdc);
494	}
495	return (NULL);
496}
497
498static int
499ddf_meta_count_vdc(struct ddf_meta *meta, uint8_t *GUID)
500{
501	struct ddf_vdc_record *vdc;
502	int i, num, cnt;
503
504	cnt = 0;
505	num = GETCRNUM(meta);
506	for (i = 0; i < num; i++) {
507		vdc = GETVDCPTR(meta, i);
508		if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
509			continue;
510		if (GUID == NULL || memcmp(vdc->VD_GUID, GUID, 24) == 0)
511			cnt++;
512	}
513	return (cnt);
514}
515
516static int
517ddf_meta_find_disk(struct ddf_vol_meta *vmeta, uint32_t PD_Reference,
518    int *bvdp, int *posp)
519{
520	int i, bvd, pos;
521
522	i = 0;
523	for (bvd = 0; bvd < GET8(vmeta, vdc->Secondary_Element_Count); bvd++) {
524		if (vmeta->bvdc[bvd] == NULL) {
525			i += GET16(vmeta, vdc->Primary_Element_Count); // XXX
526			continue;
527		}
528		for (pos = 0; pos < GET16(vmeta, bvdc[bvd]->Primary_Element_Count);
529		    pos++, i++) {
530			if (GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos]) ==
531			    PD_Reference) {
532				if (bvdp != NULL)
533					*bvdp = bvd;
534				if (posp != NULL)
535					*posp = pos;
536				return (i);
537			}
538		}
539	}
540	return (-1);
541}
542
543static struct ddf_sa_record *
544ddf_meta_find_sa(struct ddf_meta *meta, int create)
545{
546	struct ddf_sa_record *sa;
547	int i, num;
548
549	num = GETCRNUM(meta);
550	for (i = 0; i < num; i++) {
551		sa = GETSAPTR(meta, i);
552		if (GET32D(meta, sa->Signature) == DDF_SA_SIGNATURE)
553			return (sa);
554	}
555	if (create) {
556		for (i = 0; i < num; i++) {
557			sa = GETSAPTR(meta, i);
558			if (GET32D(meta, sa->Signature) == 0xffffffff ||
559			    GET32D(meta, sa->Signature) == 0)
560				return (sa);
561		}
562	}
563	return (NULL);
564}
565
566static void
567ddf_meta_create(struct g_raid_disk *disk, struct ddf_meta *sample)
568{
569	struct timespec ts;
570	struct clocktime ct;
571	struct g_raid_md_ddf_perdisk *pd;
572	struct g_raid_md_ddf_object *mdi;
573	struct ddf_meta *meta;
574	struct ddf_pd_entry *pde;
575	off_t anchorlba;
576	u_int ss, pos, size;
577	int len, error;
578	char serial_buffer[DISK_IDENT_SIZE];
579
580	if (sample->hdr == NULL)
581		sample = NULL;
582
583	mdi = (struct g_raid_md_ddf_object *)disk->d_softc->sc_md;
584	pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
585	meta = &pd->pd_meta;
586	ss = disk->d_consumer->provider->sectorsize;
587	anchorlba = disk->d_consumer->provider->mediasize / ss - 1;
588
589	meta->sectorsize = ss;
590	meta->bigendian = sample ? sample->bigendian : mdi->mdio_bigendian;
591	getnanotime(&ts);
592	clock_ts_to_ct(&ts, &ct);
593
594	/* Header */
595	meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
596	memset(meta->hdr, 0xff, ss);
597	if (sample) {
598		memcpy(meta->hdr, sample->hdr, sizeof(struct ddf_header));
599		if (ss != sample->sectorsize) {
600			SET32(meta, hdr->WorkSpace_Length,
601			    howmany(GET32(sample, hdr->WorkSpace_Length) *
602			        sample->sectorsize, ss));
603			SET16(meta, hdr->Configuration_Record_Length,
604			    howmany(GET16(sample,
605			        hdr->Configuration_Record_Length) *
606				sample->sectorsize, ss));
607			SET32(meta, hdr->cd_length,
608			    howmany(GET32(sample, hdr->cd_length) *
609			        sample->sectorsize, ss));
610			SET32(meta, hdr->pdr_length,
611			    howmany(GET32(sample, hdr->pdr_length) *
612			        sample->sectorsize, ss));
613			SET32(meta, hdr->vdr_length,
614			    howmany(GET32(sample, hdr->vdr_length) *
615			        sample->sectorsize, ss));
616			SET32(meta, hdr->cr_length,
617			    howmany(GET32(sample, hdr->cr_length) *
618			        sample->sectorsize, ss));
619			SET32(meta, hdr->pdd_length,
620			    howmany(GET32(sample, hdr->pdd_length) *
621			        sample->sectorsize, ss));
622			SET32(meta, hdr->bbmlog_length,
623			    howmany(GET32(sample, hdr->bbmlog_length) *
624			        sample->sectorsize, ss));
625			SET32(meta, hdr->Diagnostic_Space,
626			    howmany(GET32(sample, hdr->bbmlog_length) *
627			        sample->sectorsize, ss));
628			SET32(meta, hdr->Vendor_Specific_Logs,
629			    howmany(GET32(sample, hdr->bbmlog_length) *
630			        sample->sectorsize, ss));
631		}
632	} else {
633		SET32(meta, hdr->Signature, DDF_HEADER_SIGNATURE);
634		snprintf(meta->hdr->DDF_Header_GUID, 25, "FreeBSD %08x%08x",
635		    (u_int)(ts.tv_sec - DECADE), arc4random());
636		memcpy(meta->hdr->DDF_rev, "02.00.00", 8);
637		SET32(meta, hdr->TimeStamp, (ts.tv_sec - DECADE));
638		SET32(meta, hdr->WorkSpace_Length, 16 * 1024 * 1024 / ss);
639		SET16(meta, hdr->Max_PD_Entries, DDF_MAX_DISKS - 1);
640		SET16(meta, hdr->Max_VD_Entries, DDF_MAX_VDISKS);
641		SET16(meta, hdr->Max_Partitions, DDF_MAX_PARTITIONS);
642		SET16(meta, hdr->Max_Primary_Element_Entries, DDF_MAX_DISKS);
643		SET16(meta, hdr->Configuration_Record_Length,
644		    howmany(sizeof(struct ddf_vdc_record) + (4 + 8) *
645		        GET16(meta, hdr->Max_Primary_Element_Entries), ss));
646		SET32(meta, hdr->cd_length,
647		    howmany(sizeof(struct ddf_cd_record), ss));
648		SET32(meta, hdr->pdr_length,
649		    howmany(sizeof(struct ddf_pd_record) +
650		        sizeof(struct ddf_pd_entry) * GET16(meta,
651			hdr->Max_PD_Entries), ss));
652		SET32(meta, hdr->vdr_length,
653		    howmany(sizeof(struct ddf_vd_record) +
654		        sizeof(struct ddf_vd_entry) *
655			GET16(meta, hdr->Max_VD_Entries), ss));
656		SET32(meta, hdr->cr_length,
657		    GET16(meta, hdr->Configuration_Record_Length) *
658		    (GET16(meta, hdr->Max_Partitions) + 1));
659		SET32(meta, hdr->pdd_length,
660		    howmany(sizeof(struct ddf_pdd_record), ss));
661		SET32(meta, hdr->bbmlog_length, 0);
662		SET32(meta, hdr->Diagnostic_Space_Length, 0);
663		SET32(meta, hdr->Vendor_Specific_Logs_Length, 0);
664	}
665	pos = 1;
666	SET32(meta, hdr->cd_section, pos);
667	pos += GET32(meta, hdr->cd_length);
668	SET32(meta, hdr->pdr_section, pos);
669	pos += GET32(meta, hdr->pdr_length);
670	SET32(meta, hdr->vdr_section, pos);
671	pos += GET32(meta, hdr->vdr_length);
672	SET32(meta, hdr->cr_section, pos);
673	pos += GET32(meta, hdr->cr_length);
674	SET32(meta, hdr->pdd_section, pos);
675	pos += GET32(meta, hdr->pdd_length);
676	SET32(meta, hdr->bbmlog_section,
677	    GET32(meta, hdr->bbmlog_length) != 0 ? pos : 0xffffffff);
678	pos += GET32(meta, hdr->bbmlog_length);
679	SET32(meta, hdr->Diagnostic_Space,
680	    GET32(meta, hdr->Diagnostic_Space_Length) != 0 ? pos : 0xffffffff);
681	pos += GET32(meta, hdr->Diagnostic_Space_Length);
682	SET32(meta, hdr->Vendor_Specific_Logs,
683	    GET32(meta, hdr->Vendor_Specific_Logs_Length) != 0 ? pos : 0xffffffff);
684	pos += min(GET32(meta, hdr->Vendor_Specific_Logs_Length), 1);
685	SET64(meta, hdr->Primary_Header_LBA,
686	    anchorlba - pos);
687	SET64(meta, hdr->Secondary_Header_LBA,
688	    0xffffffffffffffffULL);
689	SET64(meta, hdr->WorkSpace_LBA,
690	    anchorlba + 1 - 32 * 1024 * 1024 / ss);
691
692	/* Controller Data */
693	size = GET32(meta, hdr->cd_length) * ss;
694	meta->cdr = malloc(size, M_MD_DDF, M_WAITOK);
695	memset(meta->cdr, 0xff, size);
696	SET32(meta, cdr->Signature, DDF_CONTROLLER_DATA_SIGNATURE);
697	memcpy(meta->cdr->Controller_GUID, "FreeBSD GEOM RAID SERIAL", 24);
698	memcpy(meta->cdr->Product_ID, "FreeBSD GEOMRAID", 16);
699
700	/* Physical Drive Records. */
701	size = GET32(meta, hdr->pdr_length) * ss;
702	meta->pdr = malloc(size, M_MD_DDF, M_WAITOK);
703	memset(meta->pdr, 0xff, size);
704	SET32(meta, pdr->Signature, DDF_PDR_SIGNATURE);
705	SET16(meta, pdr->Populated_PDEs, 1);
706	SET16(meta, pdr->Max_PDE_Supported,
707	    GET16(meta, hdr->Max_PD_Entries));
708
709	pde = &meta->pdr->entry[0];
710	len = sizeof(serial_buffer);
711	error = g_io_getattr("GEOM::ident", disk->d_consumer, &len, serial_buffer);
712	if (error == 0 && (len = strlen (serial_buffer)) >= 6 && len <= 20)
713		snprintf(pde->PD_GUID, 25, "DISK%20s", serial_buffer);
714	else
715		snprintf(pde->PD_GUID, 25, "DISK%04d%02d%02d%08x%04x",
716		    ct.year, ct.mon, ct.day,
717		    arc4random(), arc4random() & 0xffff);
718	SET32D(meta, pde->PD_Reference, arc4random());
719	SET16D(meta, pde->PD_Type, DDF_PDE_GUID_FORCE);
720	SET16D(meta, pde->PD_State, 0);
721	SET64D(meta, pde->Configured_Size,
722	    anchorlba + 1 - 32 * 1024 * 1024 / ss);
723	SET16D(meta, pde->Block_Size, ss);
724
725	/* Virtual Drive Records. */
726	size = GET32(meta, hdr->vdr_length) * ss;
727	meta->vdr = malloc(size, M_MD_DDF, M_WAITOK);
728	memset(meta->vdr, 0xff, size);
729	SET32(meta, vdr->Signature, DDF_VD_RECORD_SIGNATURE);
730	SET32(meta, vdr->Populated_VDEs, 0);
731	SET16(meta, vdr->Max_VDE_Supported,
732	    GET16(meta, hdr->Max_VD_Entries));
733
734	/* Configuration Records. */
735	size = GET32(meta, hdr->cr_length) * ss;
736	meta->cr = malloc(size, M_MD_DDF, M_WAITOK);
737	memset(meta->cr, 0xff, size);
738
739	/* Physical Disk Data. */
740	size = GET32(meta, hdr->pdd_length) * ss;
741	meta->pdd = malloc(size, M_MD_DDF, M_WAITOK);
742	memset(meta->pdd, 0xff, size);
743	SET32(meta, pdd->Signature, DDF_PDD_SIGNATURE);
744	memcpy(meta->pdd->PD_GUID, pde->PD_GUID, 24);
745	SET32(meta, pdd->PD_Reference, GET32D(meta, pde->PD_Reference));
746	SET8(meta, pdd->Forced_Ref_Flag, DDF_PDD_FORCED_REF);
747	SET8(meta, pdd->Forced_PD_GUID_Flag, DDF_PDD_FORCED_GUID);
748
749	/* Bad Block Management Log. */
750	if (GET32(meta, hdr->bbmlog_length) != 0) {
751		size = GET32(meta, hdr->bbmlog_length) * ss;
752		meta->bbm = malloc(size, M_MD_DDF, M_WAITOK);
753		memset(meta->bbm, 0xff, size);
754		SET32(meta, bbm->Signature, DDF_BBML_SIGNATURE);
755		SET32(meta, bbm->Entry_Count, 0);
756		SET32(meta, bbm->Spare_Block_Count, 0);
757	}
758}
759
760static void
761ddf_meta_copy(struct ddf_meta *dst, struct ddf_meta *src)
762{
763	u_int ss;
764
765	dst->bigendian = src->bigendian;
766	ss = dst->sectorsize = src->sectorsize;
767	dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
768	memcpy(dst->hdr, src->hdr, ss);
769	dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
770	memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss);
771	dst->pdr = malloc(GET32(src, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
772	memcpy(dst->pdr, src->pdr, GET32(src, hdr->pdr_length) * ss);
773	dst->vdr = malloc(GET32(src, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
774	memcpy(dst->vdr, src->vdr, GET32(src, hdr->vdr_length) * ss);
775	dst->cr = malloc(GET32(src, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
776	memcpy(dst->cr, src->cr, GET32(src, hdr->cr_length) * ss);
777	dst->pdd = malloc(GET32(src, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
778	memcpy(dst->pdd, src->pdd, GET32(src, hdr->pdd_length) * ss);
779	if (src->bbm != NULL) {
780		dst->bbm = malloc(GET32(src, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
781		memcpy(dst->bbm, src->bbm, GET32(src, hdr->bbmlog_length) * ss);
782	}
783}
784
785static void
786ddf_meta_update(struct ddf_meta *meta, struct ddf_meta *src)
787{
788	struct ddf_pd_entry *pde, *spde;
789	int i, j;
790
791	for (i = 0; i < GET16(src, pdr->Populated_PDEs); i++) {
792		spde = &src->pdr->entry[i];
793		if (isff(spde->PD_GUID, 24))
794			continue;
795		j = ddf_meta_find_pd(meta, NULL,
796		    GET32(src, pdr->entry[i].PD_Reference));
797		if (j < 0) {
798			j = ddf_meta_find_pd(meta, NULL, 0xffffffff);
799			pde = &meta->pdr->entry[j];
800			memcpy(pde, spde, sizeof(*pde));
801		} else {
802			pde = &meta->pdr->entry[j];
803			SET16D(meta, pde->PD_State,
804			    GET16D(meta, pde->PD_State) |
805			    GET16D(src, pde->PD_State));
806		}
807	}
808}
809
810static void
811ddf_meta_free(struct ddf_meta *meta)
812{
813
814	if (meta->hdr != NULL) {
815		free(meta->hdr, M_MD_DDF);
816		meta->hdr = NULL;
817	}
818	if (meta->cdr != NULL) {
819		free(meta->cdr, M_MD_DDF);
820		meta->cdr = NULL;
821	}
822	if (meta->pdr != NULL) {
823		free(meta->pdr, M_MD_DDF);
824		meta->pdr = NULL;
825	}
826	if (meta->vdr != NULL) {
827		free(meta->vdr, M_MD_DDF);
828		meta->vdr = NULL;
829	}
830	if (meta->cr != NULL) {
831		free(meta->cr, M_MD_DDF);
832		meta->cr = NULL;
833	}
834	if (meta->pdd != NULL) {
835		free(meta->pdd, M_MD_DDF);
836		meta->pdd = NULL;
837	}
838	if (meta->bbm != NULL) {
839		free(meta->bbm, M_MD_DDF);
840		meta->bbm = NULL;
841	}
842}
843
844static void
845ddf_vol_meta_create(struct ddf_vol_meta *meta, struct ddf_meta *sample)
846{
847	struct timespec ts;
848	struct clocktime ct;
849	u_int ss, size;
850
851	meta->bigendian = sample->bigendian;
852	ss = meta->sectorsize = sample->sectorsize;
853	meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
854	memcpy(meta->hdr, sample->hdr, ss);
855	meta->cdr = malloc(GET32(sample, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
856	memcpy(meta->cdr, sample->cdr, GET32(sample, hdr->cd_length) * ss);
857	meta->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK);
858	memset(meta->vde, 0xff, sizeof(struct ddf_vd_entry));
859	getnanotime(&ts);
860	clock_ts_to_ct(&ts, &ct);
861	snprintf(meta->vde->VD_GUID, 25, "FreeBSD%04d%02d%02d%08x%01x",
862	    ct.year, ct.mon, ct.day,
863	    arc4random(), arc4random() & 0xf);
864	size = GET16(sample, hdr->Configuration_Record_Length) * ss;
865	meta->vdc = malloc(size, M_MD_DDF, M_WAITOK);
866	memset(meta->vdc, 0xff, size);
867	SET32(meta, vdc->Signature, DDF_VDCR_SIGNATURE);
868	memcpy(meta->vdc->VD_GUID, meta->vde->VD_GUID, 24);
869	SET32(meta, vdc->Sequence_Number, 0);
870}
871
872static void
873ddf_vol_meta_update(struct ddf_vol_meta *dst, struct ddf_meta *src,
874    uint8_t *GUID, int started)
875{
876	struct ddf_vd_entry *vde;
877	struct ddf_vdc_record *vdc;
878	int vnew, bvnew, bvd, size;
879	u_int ss;
880
881	vde = &src->vdr->entry[ddf_meta_find_vd(src, GUID)];
882	vdc = ddf_meta_find_vdc(src, GUID);
883	if (GET8D(src, vdc->Secondary_Element_Count) == 1)
884		bvd = 0;
885	else
886		bvd = GET8D(src, vdc->Secondary_Element_Seq);
887	size = GET16(src, hdr->Configuration_Record_Length) * src->sectorsize;
888
889	if (dst->vdc == NULL ||
890	    (!started && ((int32_t)(GET32D(src, vdc->Sequence_Number) -
891	    GET32(dst, vdc->Sequence_Number))) > 0))
892		vnew = 1;
893	else
894		vnew = 0;
895
896	if (dst->bvdc[bvd] == NULL ||
897	    (!started && ((int32_t)(GET32D(src, vdc->Sequence_Number) -
898	    GET32(dst, bvdc[bvd]->Sequence_Number))) > 0))
899		bvnew = 1;
900	else
901		bvnew = 0;
902
903	if (vnew) {
904		dst->bigendian = src->bigendian;
905		ss = dst->sectorsize = src->sectorsize;
906		if (dst->hdr != NULL)
907			free(dst->hdr, M_MD_DDF);
908		dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
909		memcpy(dst->hdr, src->hdr, ss);
910		if (dst->cdr != NULL)
911			free(dst->cdr, M_MD_DDF);
912		dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
913		memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss);
914		if (dst->vde != NULL)
915			free(dst->vde, M_MD_DDF);
916		dst->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK);
917		memcpy(dst->vde, vde, sizeof(struct ddf_vd_entry));
918		if (dst->vdc != NULL)
919			free(dst->vdc, M_MD_DDF);
920		dst->vdc = malloc(size, M_MD_DDF, M_WAITOK);
921		memcpy(dst->vdc, vdc, size);
922	}
923	if (bvnew) {
924		if (dst->bvdc[bvd] != NULL)
925			free(dst->bvdc[bvd], M_MD_DDF);
926		dst->bvdc[bvd] = malloc(size, M_MD_DDF, M_WAITOK);
927		memcpy(dst->bvdc[bvd], vdc, size);
928	}
929}
930
931static void
932ddf_vol_meta_free(struct ddf_vol_meta *meta)
933{
934	int i;
935
936	if (meta->hdr != NULL) {
937		free(meta->hdr, M_MD_DDF);
938		meta->hdr = NULL;
939	}
940	if (meta->cdr != NULL) {
941		free(meta->cdr, M_MD_DDF);
942		meta->cdr = NULL;
943	}
944	if (meta->vde != NULL) {
945		free(meta->vde, M_MD_DDF);
946		meta->vde = NULL;
947	}
948	if (meta->vdc != NULL) {
949		free(meta->vdc, M_MD_DDF);
950		meta->vdc = NULL;
951	}
952	for (i = 0; i < DDF_MAX_DISKS_HARD; i++) {
953		if (meta->bvdc[i] != NULL) {
954			free(meta->bvdc[i], M_MD_DDF);
955			meta->bvdc[i] = NULL;
956		}
957	}
958}
959
960static int
961ddf_meta_unused_range(struct ddf_meta *meta, off_t *off, off_t *size)
962{
963	struct ddf_vdc_record *vdc;
964	off_t beg[32], end[32], beg1, end1;
965	uint64_t *offp;
966	int i, j, n, num, pos;
967	uint32_t ref;
968
969	*off = 0;
970	*size = 0;
971	ref = GET32(meta, pdd->PD_Reference);
972	pos = ddf_meta_find_pd(meta, NULL, ref);
973	beg[0] = 0;
974	end[0] = GET64(meta, pdr->entry[pos].Configured_Size);
975	n = 1;
976	num = GETCRNUM(meta);
977	for (i = 0; i < num; i++) {
978		vdc = GETVDCPTR(meta, i);
979		if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
980			continue;
981		for (pos = 0; pos < GET16D(meta, vdc->Primary_Element_Count); pos++)
982			if (GET32D(meta, vdc->Physical_Disk_Sequence[pos]) == ref)
983				break;
984		if (pos == GET16D(meta, vdc->Primary_Element_Count))
985			continue;
986		offp = (uint64_t *)&(vdc->Physical_Disk_Sequence[
987		    GET16(meta, hdr->Max_Primary_Element_Entries)]);
988		beg1 = GET64P(meta, offp + pos);
989		end1 = beg1 + GET64D(meta, vdc->Block_Count);
990		for (j = 0; j < n; j++) {
991			if (beg[j] >= end1 || end[j] <= beg1 )
992				continue;
993			if (beg[j] < beg1 && end[j] > end1) {
994				beg[n] = end1;
995				end[n] = end[j];
996				end[j] = beg1;
997				n++;
998			} else if (beg[j] < beg1)
999				end[j] = beg1;
1000			else
1001				beg[j] = end1;
1002		}
1003	}
1004	for (j = 0; j < n; j++) {
1005		if (end[j] - beg[j] > *size) {
1006			*off = beg[j];
1007			*size = end[j] - beg[j];
1008		}
1009	}
1010	return ((*size > 0) ? 1 : 0);
1011}
1012
1013static void
1014ddf_meta_get_name(struct ddf_meta *meta, int num, char *buf)
1015{
1016	const char *b;
1017	int i;
1018
1019	b = meta->vdr->entry[num].VD_Name;
1020	for (i = 15; i >= 0; i--)
1021		if (b[i] != 0x20)
1022			break;
1023	memcpy(buf, b, i + 1);
1024	buf[i + 1] = 0;
1025}
1026
1027static void
1028ddf_meta_put_name(struct ddf_vol_meta *meta, char *buf)
1029{
1030	int len;
1031
1032	len = min(strlen(buf), 16);
1033	memset(meta->vde->VD_Name, 0x20, 16);
1034	memcpy(meta->vde->VD_Name, buf, len);
1035}
1036
1037static int
1038ddf_meta_read(struct g_consumer *cp, struct ddf_meta *meta)
1039{
1040	struct g_provider *pp;
1041	struct ddf_header *ahdr, *hdr;
1042	char *abuf, *buf;
1043	off_t plba, slba, lba;
1044	int error, len, i;
1045	u_int ss;
1046	uint32_t val;
1047
1048	ddf_meta_free(meta);
1049	pp = cp->provider;
1050	ss = meta->sectorsize = pp->sectorsize;
1051	/* Read anchor block. */
1052	abuf = g_read_data(cp, pp->mediasize - ss, ss, &error);
1053	if (abuf == NULL) {
1054		G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).",
1055		    pp->name, error);
1056		return (error);
1057	}
1058	ahdr = (struct ddf_header *)abuf;
1059
1060	/* Check if this is an DDF RAID struct */
1061	if (be32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE)
1062		meta->bigendian = 1;
1063	else if (le32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE)
1064		meta->bigendian = 0;
1065	else {
1066		G_RAID_DEBUG(1, "DDF signature check failed on %s", pp->name);
1067		error = EINVAL;
1068		goto done;
1069	}
1070	if (ahdr->Header_Type != DDF_HEADER_ANCHOR) {
1071		G_RAID_DEBUG(1, "DDF header type check failed on %s", pp->name);
1072		error = EINVAL;
1073		goto done;
1074	}
1075	meta->hdr = ahdr;
1076	plba = GET64(meta, hdr->Primary_Header_LBA);
1077	slba = GET64(meta, hdr->Secondary_Header_LBA);
1078	val = GET32(meta, hdr->CRC);
1079	SET32(meta, hdr->CRC, 0xffffffff);
1080	meta->hdr = NULL;
1081	if (crc32(ahdr, ss) != val) {
1082		G_RAID_DEBUG(1, "DDF CRC mismatch on %s", pp->name);
1083		error = EINVAL;
1084		goto done;
1085	}
1086	if ((plba + 6) * ss >= pp->mediasize) {
1087		G_RAID_DEBUG(1, "DDF primary header LBA is wrong on %s", pp->name);
1088		error = EINVAL;
1089		goto done;
1090	}
1091	if (slba != -1 && (slba + 6) * ss >= pp->mediasize) {
1092		G_RAID_DEBUG(1, "DDF secondary header LBA is wrong on %s", pp->name);
1093		error = EINVAL;
1094		goto done;
1095	}
1096	lba = plba;
1097
1098doread:
1099	error = 0;
1100	ddf_meta_free(meta);
1101
1102	/* Read header block. */
1103	buf = g_read_data(cp, lba * ss, ss, &error);
1104	if (buf == NULL) {
1105readerror:
1106		G_RAID_DEBUG(1, "DDF %s metadata read error on %s (error=%d).",
1107		    (lba == plba) ? "primary" : "secondary", pp->name, error);
1108		if (lba == plba && slba != -1) {
1109			lba = slba;
1110			goto doread;
1111		}
1112		G_RAID_DEBUG(1, "DDF metadata read error on %s.", pp->name);
1113		goto done;
1114	}
1115	meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
1116	memcpy(meta->hdr, buf, ss);
1117	g_free(buf);
1118	hdr = meta->hdr;
1119	val = GET32(meta, hdr->CRC);
1120	SET32(meta, hdr->CRC, 0xffffffff);
1121	if (hdr->Signature != ahdr->Signature ||
1122	    crc32(meta->hdr, ss) != val ||
1123	    memcmp(hdr->DDF_Header_GUID, ahdr->DDF_Header_GUID, 24) ||
1124	    GET64(meta, hdr->Primary_Header_LBA) != plba ||
1125	    GET64(meta, hdr->Secondary_Header_LBA) != slba) {
1126hdrerror:
1127		G_RAID_DEBUG(1, "DDF %s metadata check failed on %s",
1128		    (lba == plba) ? "primary" : "secondary", pp->name);
1129		if (lba == plba && slba != -1) {
1130			lba = slba;
1131			goto doread;
1132		}
1133		G_RAID_DEBUG(1, "DDF metadata check failed on %s", pp->name);
1134		error = EINVAL;
1135		goto done;
1136	}
1137	if ((lba == plba && hdr->Header_Type != DDF_HEADER_PRIMARY) ||
1138	    (lba == slba && hdr->Header_Type != DDF_HEADER_SECONDARY))
1139		goto hdrerror;
1140	len = 1;
1141	len = max(len, GET32(meta, hdr->cd_section) + GET32(meta, hdr->cd_length));
1142	len = max(len, GET32(meta, hdr->pdr_section) + GET32(meta, hdr->pdr_length));
1143	len = max(len, GET32(meta, hdr->vdr_section) + GET32(meta, hdr->vdr_length));
1144	len = max(len, GET32(meta, hdr->cr_section) + GET32(meta, hdr->cr_length));
1145	len = max(len, GET32(meta, hdr->pdd_section) + GET32(meta, hdr->pdd_length));
1146	if ((val = GET32(meta, hdr->bbmlog_section)) != 0xffffffff)
1147		len = max(len, val + GET32(meta, hdr->bbmlog_length));
1148	if ((val = GET32(meta, hdr->Diagnostic_Space)) != 0xffffffff)
1149		len = max(len, val + GET32(meta, hdr->Diagnostic_Space_Length));
1150	if ((val = GET32(meta, hdr->Vendor_Specific_Logs)) != 0xffffffff)
1151		len = max(len, val + GET32(meta, hdr->Vendor_Specific_Logs_Length));
1152	if ((plba + len) * ss >= pp->mediasize)
1153		goto hdrerror;
1154	if (slba != -1 && (slba + len) * ss >= pp->mediasize)
1155		goto hdrerror;
1156	/* Workaround for Adaptec implementation. */
1157	if (GET16(meta, hdr->Max_Primary_Element_Entries) == 0xffff) {
1158		SET16(meta, hdr->Max_Primary_Element_Entries,
1159		    min(GET16(meta, hdr->Max_PD_Entries),
1160		    (GET16(meta, hdr->Configuration_Record_Length) * ss - 512) / 12));
1161	}
1162
1163	if (GET32(meta, hdr->cd_length) * ss >= MAXPHYS ||
1164	    GET32(meta, hdr->pdr_length) * ss >= MAXPHYS ||
1165	    GET32(meta, hdr->vdr_length) * ss >= MAXPHYS ||
1166	    GET32(meta, hdr->cr_length) * ss >= MAXPHYS ||
1167	    GET32(meta, hdr->pdd_length) * ss >= MAXPHYS ||
1168	    GET32(meta, hdr->bbmlog_length) * ss >= MAXPHYS) {
1169		G_RAID_DEBUG(1, "%s: Blocksize is too big.", pp->name);
1170		goto hdrerror;
1171	}
1172
1173	/* Read controller data. */
1174	buf = g_read_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
1175	    GET32(meta, hdr->cd_length) * ss, &error);
1176	if (buf == NULL)
1177		goto readerror;
1178	meta->cdr = malloc(GET32(meta, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
1179	memcpy(meta->cdr, buf, GET32(meta, hdr->cd_length) * ss);
1180	g_free(buf);
1181	if (GET32(meta, cdr->Signature) != DDF_CONTROLLER_DATA_SIGNATURE)
1182		goto hdrerror;
1183
1184	/* Read physical disk records. */
1185	buf = g_read_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
1186	    GET32(meta, hdr->pdr_length) * ss, &error);
1187	if (buf == NULL)
1188		goto readerror;
1189	meta->pdr = malloc(GET32(meta, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
1190	memcpy(meta->pdr, buf, GET32(meta, hdr->pdr_length) * ss);
1191	g_free(buf);
1192	if (GET32(meta, pdr->Signature) != DDF_PDR_SIGNATURE)
1193		goto hdrerror;
1194	/*
1195	 * Workaround for reading metadata corrupted due to graid bug.
1196	 * XXX: Remove this before we have disks above 128PB. :)
1197	 */
1198	if (meta->bigendian) {
1199		for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
1200			if (isff(meta->pdr->entry[i].PD_GUID, 24))
1201				continue;
1202			if (GET32(meta, pdr->entry[i].PD_Reference) ==
1203			    0xffffffff)
1204				continue;
1205			if (GET64(meta, pdr->entry[i].Configured_Size) >=
1206			     (1ULL << 48)) {
1207				SET16(meta, pdr->entry[i].PD_State,
1208				    GET16(meta, pdr->entry[i].PD_State) &
1209				    ~DDF_PDE_FAILED);
1210				SET64(meta, pdr->entry[i].Configured_Size,
1211				    GET64(meta, pdr->entry[i].Configured_Size) &
1212				    ((1ULL << 48) - 1));
1213			}
1214		}
1215	}
1216
1217	/* Read virtual disk records. */
1218	buf = g_read_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
1219	    GET32(meta, hdr->vdr_length) * ss, &error);
1220	if (buf == NULL)
1221		goto readerror;
1222	meta->vdr = malloc(GET32(meta, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
1223	memcpy(meta->vdr, buf, GET32(meta, hdr->vdr_length) * ss);
1224	g_free(buf);
1225	if (GET32(meta, vdr->Signature) != DDF_VD_RECORD_SIGNATURE)
1226		goto hdrerror;
1227
1228	/* Read configuration records. */
1229	buf = g_read_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
1230	    GET32(meta, hdr->cr_length) * ss, &error);
1231	if (buf == NULL)
1232		goto readerror;
1233	meta->cr = malloc(GET32(meta, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
1234	memcpy(meta->cr, buf, GET32(meta, hdr->cr_length) * ss);
1235	g_free(buf);
1236
1237	/* Read physical disk data. */
1238	buf = g_read_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
1239	    GET32(meta, hdr->pdd_length) * ss, &error);
1240	if (buf == NULL)
1241		goto readerror;
1242	meta->pdd = malloc(GET32(meta, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
1243	memcpy(meta->pdd, buf, GET32(meta, hdr->pdd_length) * ss);
1244	g_free(buf);
1245	if (GET32(meta, pdd->Signature) != DDF_PDD_SIGNATURE)
1246		goto hdrerror;
1247	i = ddf_meta_find_pd(meta, NULL, GET32(meta, pdd->PD_Reference));
1248	if (i < 0)
1249		goto hdrerror;
1250
1251	/* Read BBM Log. */
1252	if (GET32(meta, hdr->bbmlog_section) != 0xffffffff &&
1253	    GET32(meta, hdr->bbmlog_length) != 0) {
1254		buf = g_read_data(cp, (lba + GET32(meta, hdr->bbmlog_section)) * ss,
1255		    GET32(meta, hdr->bbmlog_length) * ss, &error);
1256		if (buf == NULL)
1257			goto readerror;
1258		meta->bbm = malloc(GET32(meta, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
1259		memcpy(meta->bbm, buf, GET32(meta, hdr->bbmlog_length) * ss);
1260		g_free(buf);
1261		if (GET32(meta, bbm->Signature) != DDF_BBML_SIGNATURE)
1262			goto hdrerror;
1263	}
1264
1265done:
1266	g_free(abuf);
1267	if (error != 0)
1268		ddf_meta_free(meta);
1269	return (error);
1270}
1271
1272static int
1273ddf_meta_write(struct g_consumer *cp, struct ddf_meta *meta)
1274{
1275	struct g_provider *pp;
1276	struct ddf_vdc_record *vdc;
1277	off_t alba, plba, slba, lba;
1278	u_int ss, size;
1279	int error, i, num;
1280
1281	pp = cp->provider;
1282	ss = pp->sectorsize;
1283	lba = alba = pp->mediasize / ss - 1;
1284	plba = GET64(meta, hdr->Primary_Header_LBA);
1285	slba = GET64(meta, hdr->Secondary_Header_LBA);
1286
1287next:
1288	SET8(meta, hdr->Header_Type, (lba == alba) ? DDF_HEADER_ANCHOR :
1289	    (lba == plba) ? DDF_HEADER_PRIMARY : DDF_HEADER_SECONDARY);
1290	SET32(meta, hdr->CRC, 0xffffffff);
1291	SET32(meta, hdr->CRC, crc32(meta->hdr, ss));
1292	error = g_write_data(cp, lba * ss, meta->hdr, ss);
1293	if (error != 0) {
1294err:
1295		G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).",
1296		    pp->name, error);
1297		if (lba != alba)
1298			goto done;
1299	}
1300	if (lba == alba) {
1301		lba = plba;
1302		goto next;
1303	}
1304
1305	size = GET32(meta, hdr->cd_length) * ss;
1306	SET32(meta, cdr->CRC, 0xffffffff);
1307	SET32(meta, cdr->CRC, crc32(meta->cdr, size));
1308	error = g_write_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
1309	    meta->cdr, size);
1310	if (error != 0)
1311		goto err;
1312
1313	size = GET32(meta, hdr->pdr_length) * ss;
1314	SET32(meta, pdr->CRC, 0xffffffff);
1315	SET32(meta, pdr->CRC, crc32(meta->pdr, size));
1316	error = g_write_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
1317	    meta->pdr, size);
1318	if (error != 0)
1319		goto err;
1320
1321	size = GET32(meta, hdr->vdr_length) * ss;
1322	SET32(meta, vdr->CRC, 0xffffffff);
1323	SET32(meta, vdr->CRC, crc32(meta->vdr, size));
1324	error = g_write_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
1325	    meta->vdr, size);
1326	if (error != 0)
1327		goto err;
1328
1329	size = GET16(meta, hdr->Configuration_Record_Length) * ss;
1330	num = GETCRNUM(meta);
1331	for (i = 0; i < num; i++) {
1332		vdc = GETVDCPTR(meta, i);
1333		SET32D(meta, vdc->CRC, 0xffffffff);
1334		SET32D(meta, vdc->CRC, crc32(vdc, size));
1335	}
1336	error = g_write_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
1337	    meta->cr, size * num);
1338	if (error != 0)
1339		goto err;
1340
1341	size = GET32(meta, hdr->pdd_length) * ss;
1342	SET32(meta, pdd->CRC, 0xffffffff);
1343	SET32(meta, pdd->CRC, crc32(meta->pdd, size));
1344	error = g_write_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
1345	    meta->pdd, size);
1346	if (error != 0)
1347		goto err;
1348
1349	if (GET32(meta, hdr->bbmlog_length) != 0) {
1350		size = GET32(meta, hdr->bbmlog_length) * ss;
1351		SET32(meta, bbm->CRC, 0xffffffff);
1352		SET32(meta, bbm->CRC, crc32(meta->bbm, size));
1353		error = g_write_data(cp,
1354		    (lba + GET32(meta, hdr->bbmlog_section)) * ss,
1355		    meta->bbm, size);
1356		if (error != 0)
1357			goto err;
1358	}
1359
1360done:
1361	if (lba == plba && slba != -1) {
1362		lba = slba;
1363		goto next;
1364	}
1365
1366	return (error);
1367}
1368
1369static int
1370ddf_meta_erase(struct g_consumer *cp)
1371{
1372	struct g_provider *pp;
1373	char *buf;
1374	int error;
1375
1376	pp = cp->provider;
1377	buf = malloc(pp->sectorsize, M_MD_DDF, M_WAITOK | M_ZERO);
1378	error = g_write_data(cp, pp->mediasize - pp->sectorsize,
1379	    buf, pp->sectorsize);
1380	if (error != 0) {
1381		G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).",
1382		    pp->name, error);
1383	}
1384	free(buf, M_MD_DDF);
1385	return (error);
1386}
1387
1388static struct g_raid_volume *
1389g_raid_md_ddf_get_volume(struct g_raid_softc *sc, uint8_t *GUID)
1390{
1391	struct g_raid_volume	*vol;
1392	struct g_raid_md_ddf_pervolume *pv;
1393
1394	TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
1395		pv = vol->v_md_data;
1396		if (memcmp(pv->pv_meta.vde->VD_GUID, GUID, 24) == 0)
1397			break;
1398	}
1399	return (vol);
1400}
1401
1402static struct g_raid_disk *
1403g_raid_md_ddf_get_disk(struct g_raid_softc *sc, uint8_t *GUID, uint32_t id)
1404{
1405	struct g_raid_disk	*disk;
1406	struct g_raid_md_ddf_perdisk *pd;
1407	struct ddf_meta *meta;
1408
1409	TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1410		pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1411		meta = &pd->pd_meta;
1412		if (GUID != NULL) {
1413			if (memcmp(meta->pdd->PD_GUID, GUID, 24) == 0)
1414				break;
1415		} else {
1416			if (GET32(meta, pdd->PD_Reference) == id)
1417				break;
1418		}
1419	}
1420	return (disk);
1421}
1422
1423static int
1424g_raid_md_ddf_purge_volumes(struct g_raid_softc *sc)
1425{
1426	struct g_raid_volume	*vol, *tvol;
1427	int i, res;
1428
1429	res = 0;
1430	TAILQ_FOREACH_SAFE(vol, &sc->sc_volumes, v_next, tvol) {
1431		if (vol->v_stopping)
1432			continue;
1433		for (i = 0; i < vol->v_disks_count; i++) {
1434			if (vol->v_subdisks[i].sd_state != G_RAID_SUBDISK_S_NONE)
1435				break;
1436		}
1437		if (i >= vol->v_disks_count) {
1438			g_raid_destroy_volume(vol);
1439			res = 1;
1440		}
1441	}
1442	return (res);
1443}
1444
1445static int
1446g_raid_md_ddf_purge_disks(struct g_raid_softc *sc)
1447{
1448#if 0
1449	struct g_raid_disk	*disk, *tdisk;
1450	struct g_raid_volume	*vol;
1451	struct g_raid_md_ddf_perdisk *pd;
1452	int i, j, res;
1453
1454	res = 0;
1455	TAILQ_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) {
1456		if (disk->d_state == G_RAID_DISK_S_SPARE)
1457			continue;
1458		pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1459
1460		/* Scan for deleted volumes. */
1461		for (i = 0; i < pd->pd_subdisks; ) {
1462			vol = g_raid_md_ddf_get_volume(sc,
1463			    pd->pd_meta[i]->volume_id);
1464			if (vol != NULL && !vol->v_stopping) {
1465				i++;
1466				continue;
1467			}
1468			free(pd->pd_meta[i], M_MD_DDF);
1469			for (j = i; j < pd->pd_subdisks - 1; j++)
1470				pd->pd_meta[j] = pd->pd_meta[j + 1];
1471			pd->pd_meta[DDF_MAX_SUBDISKS - 1] = NULL;
1472			pd->pd_subdisks--;
1473			pd->pd_updated = 1;
1474		}
1475
1476		/* If there is no metadata left - erase and delete disk. */
1477		if (pd->pd_subdisks == 0) {
1478			ddf_meta_erase(disk->d_consumer);
1479			g_raid_destroy_disk(disk);
1480			res = 1;
1481		}
1482	}
1483	return (res);
1484#endif
1485	return (0);
1486}
1487
1488static int
1489g_raid_md_ddf_supported(int level, int qual, int disks, int force)
1490{
1491
1492	if (disks > DDF_MAX_DISKS_HARD)
1493		return (0);
1494	switch (level) {
1495	case G_RAID_VOLUME_RL_RAID0:
1496		if (qual != G_RAID_VOLUME_RLQ_NONE)
1497			return (0);
1498		if (disks < 1)
1499			return (0);
1500		if (!force && disks < 2)
1501			return (0);
1502		break;
1503	case G_RAID_VOLUME_RL_RAID1:
1504		if (disks < 1)
1505			return (0);
1506		if (qual == G_RAID_VOLUME_RLQ_R1SM) {
1507			if (!force && disks != 2)
1508				return (0);
1509		} else if (qual == G_RAID_VOLUME_RLQ_R1MM) {
1510			if (!force && disks != 3)
1511				return (0);
1512		} else
1513			return (0);
1514		break;
1515	case G_RAID_VOLUME_RL_RAID3:
1516		if (qual != G_RAID_VOLUME_RLQ_R3P0 &&
1517		    qual != G_RAID_VOLUME_RLQ_R3PN)
1518			return (0);
1519		if (disks < 3)
1520			return (0);
1521		break;
1522	case G_RAID_VOLUME_RL_RAID4:
1523		if (qual != G_RAID_VOLUME_RLQ_R4P0 &&
1524		    qual != G_RAID_VOLUME_RLQ_R4PN)
1525			return (0);
1526		if (disks < 3)
1527			return (0);
1528		break;
1529	case G_RAID_VOLUME_RL_RAID5:
1530		if (qual != G_RAID_VOLUME_RLQ_R5RA &&
1531		    qual != G_RAID_VOLUME_RLQ_R5RS &&
1532		    qual != G_RAID_VOLUME_RLQ_R5LA &&
1533		    qual != G_RAID_VOLUME_RLQ_R5LS)
1534			return (0);
1535		if (disks < 3)
1536			return (0);
1537		break;
1538	case G_RAID_VOLUME_RL_RAID6:
1539		if (qual != G_RAID_VOLUME_RLQ_R6RA &&
1540		    qual != G_RAID_VOLUME_RLQ_R6RS &&
1541		    qual != G_RAID_VOLUME_RLQ_R6LA &&
1542		    qual != G_RAID_VOLUME_RLQ_R6LS)
1543			return (0);
1544		if (disks < 4)
1545			return (0);
1546		break;
1547	case G_RAID_VOLUME_RL_RAIDMDF:
1548		if (qual != G_RAID_VOLUME_RLQ_RMDFRA &&
1549		    qual != G_RAID_VOLUME_RLQ_RMDFRS &&
1550		    qual != G_RAID_VOLUME_RLQ_RMDFLA &&
1551		    qual != G_RAID_VOLUME_RLQ_RMDFLS)
1552			return (0);
1553		if (disks < 4)
1554			return (0);
1555		break;
1556	case G_RAID_VOLUME_RL_RAID1E:
1557		if (qual != G_RAID_VOLUME_RLQ_R1EA &&
1558		    qual != G_RAID_VOLUME_RLQ_R1EO)
1559			return (0);
1560		if (disks < 3)
1561			return (0);
1562		break;
1563	case G_RAID_VOLUME_RL_SINGLE:
1564		if (qual != G_RAID_VOLUME_RLQ_NONE)
1565			return (0);
1566		if (disks != 1)
1567			return (0);
1568		break;
1569	case G_RAID_VOLUME_RL_CONCAT:
1570		if (qual != G_RAID_VOLUME_RLQ_NONE)
1571			return (0);
1572		if (disks < 2)
1573			return (0);
1574		break;
1575	case G_RAID_VOLUME_RL_RAID5E:
1576		if (qual != G_RAID_VOLUME_RLQ_R5ERA &&
1577		    qual != G_RAID_VOLUME_RLQ_R5ERS &&
1578		    qual != G_RAID_VOLUME_RLQ_R5ELA &&
1579		    qual != G_RAID_VOLUME_RLQ_R5ELS)
1580			return (0);
1581		if (disks < 4)
1582			return (0);
1583		break;
1584	case G_RAID_VOLUME_RL_RAID5EE:
1585		if (qual != G_RAID_VOLUME_RLQ_R5EERA &&
1586		    qual != G_RAID_VOLUME_RLQ_R5EERS &&
1587		    qual != G_RAID_VOLUME_RLQ_R5EELA &&
1588		    qual != G_RAID_VOLUME_RLQ_R5EELS)
1589			return (0);
1590		if (disks < 4)
1591			return (0);
1592		break;
1593	case G_RAID_VOLUME_RL_RAID5R:
1594		if (qual != G_RAID_VOLUME_RLQ_R5RRA &&
1595		    qual != G_RAID_VOLUME_RLQ_R5RRS &&
1596		    qual != G_RAID_VOLUME_RLQ_R5RLA &&
1597		    qual != G_RAID_VOLUME_RLQ_R5RLS)
1598			return (0);
1599		if (disks < 3)
1600			return (0);
1601		break;
1602	default:
1603		return (0);
1604	}
1605	return (1);
1606}
1607
1608static int
1609g_raid_md_ddf_start_disk(struct g_raid_disk *disk, struct g_raid_volume *vol)
1610{
1611	struct g_raid_softc *sc;
1612	struct g_raid_subdisk *sd;
1613	struct g_raid_md_ddf_perdisk *pd;
1614	struct g_raid_md_ddf_pervolume *pv;
1615	struct g_raid_md_ddf_object *mdi;
1616	struct ddf_vol_meta *vmeta;
1617	struct ddf_meta *pdmeta, *gmeta;
1618	struct ddf_vdc_record *vdc1;
1619	struct ddf_sa_record *sa;
1620	off_t size, eoff = 0, esize = 0;
1621	uint64_t *val2;
1622	int disk_pos, md_disk_bvd = -1, md_disk_pos = -1, md_pde_pos;
1623	int i, resurrection = 0;
1624	uint32_t reference;
1625
1626	sc = disk->d_softc;
1627	mdi = (struct g_raid_md_ddf_object *)sc->sc_md;
1628	pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1629	pdmeta = &pd->pd_meta;
1630	reference = GET32(&pd->pd_meta, pdd->PD_Reference);
1631
1632	pv = vol->v_md_data;
1633	vmeta = &pv->pv_meta;
1634	gmeta = &mdi->mdio_meta;
1635
1636	/* Find disk position in metadata by its reference. */
1637	disk_pos = ddf_meta_find_disk(vmeta, reference,
1638	    &md_disk_bvd, &md_disk_pos);
1639	md_pde_pos = ddf_meta_find_pd(gmeta, NULL, reference);
1640
1641	if (disk_pos < 0) {
1642		G_RAID_DEBUG1(1, sc,
1643		    "Disk %s is not a present part of the volume %s",
1644		    g_raid_get_diskname(disk), vol->v_name);
1645
1646		/* Failed stale disk is useless for us. */
1647		if ((GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) != 0) {
1648			g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED);
1649			return (0);
1650		}
1651
1652		/* If disk has some metadata for this volume - erase. */
1653		if ((vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL)
1654			SET32D(pdmeta, vdc1->Signature, 0xffffffff);
1655
1656		/* If we are in the start process, that's all for now. */
1657		if (!pv->pv_started)
1658			goto nofit;
1659		/*
1660		 * If we have already started - try to get use of the disk.
1661		 * Try to replace OFFLINE disks first, then FAILED.
1662		 */
1663		if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >=
1664			GET16(&pd->pd_meta, hdr->Max_Partitions)) {
1665			G_RAID_DEBUG1(1, sc, "No free partitions on disk %s",
1666			    g_raid_get_diskname(disk));
1667			goto nofit;
1668		}
1669		ddf_meta_unused_range(&pd->pd_meta, &eoff, &esize);
1670		if (esize == 0) {
1671			G_RAID_DEBUG1(1, sc, "No free space on disk %s",
1672			    g_raid_get_diskname(disk));
1673			goto nofit;
1674		}
1675		eoff *= pd->pd_meta.sectorsize;
1676		esize *= pd->pd_meta.sectorsize;
1677		size = INT64_MAX;
1678		for (i = 0; i < vol->v_disks_count; i++) {
1679			sd = &vol->v_subdisks[i];
1680			if (sd->sd_state != G_RAID_SUBDISK_S_NONE)
1681				size = sd->sd_size;
1682			if (sd->sd_state <= G_RAID_SUBDISK_S_FAILED &&
1683			    (disk_pos < 0 ||
1684			     vol->v_subdisks[i].sd_state < sd->sd_state))
1685				disk_pos = i;
1686		}
1687		if (disk_pos >= 0 &&
1688		    vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT &&
1689		    esize < size) {
1690			G_RAID_DEBUG1(1, sc, "Disk %s free space "
1691			    "is too small (%ju < %ju)",
1692			    g_raid_get_diskname(disk), esize, size);
1693			disk_pos = -1;
1694		}
1695		if (disk_pos >= 0) {
1696			if (vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT)
1697				esize = size;
1698			md_disk_bvd = disk_pos / GET16(vmeta, vdc->Primary_Element_Count); // XXX
1699			md_disk_pos = disk_pos % GET16(vmeta, vdc->Primary_Element_Count); // XXX
1700		} else {
1701nofit:
1702			if (disk->d_state == G_RAID_DISK_S_NONE)
1703				g_raid_change_disk_state(disk,
1704				    G_RAID_DISK_S_STALE);
1705			return (0);
1706		}
1707
1708		/*
1709		 * If spare is committable, delete spare record.
1710		 * Othersize, mark it active and leave there.
1711		 */
1712		sa = ddf_meta_find_sa(&pd->pd_meta, 0);
1713		if (sa != NULL) {
1714			if ((GET8D(&pd->pd_meta, sa->Spare_Type) &
1715			    DDF_SAR_TYPE_REVERTIBLE) == 0) {
1716				SET32D(&pd->pd_meta, sa->Signature, 0xffffffff);
1717			} else {
1718				SET8D(&pd->pd_meta, sa->Spare_Type,
1719				    GET8D(&pd->pd_meta, sa->Spare_Type) |
1720				    DDF_SAR_TYPE_ACTIVE);
1721			}
1722		}
1723
1724		G_RAID_DEBUG1(1, sc, "Disk %s takes pos %d in the volume %s",
1725		    g_raid_get_diskname(disk), disk_pos, vol->v_name);
1726		resurrection = 1;
1727	}
1728
1729	sd = &vol->v_subdisks[disk_pos];
1730
1731	if (resurrection && sd->sd_disk != NULL) {
1732		g_raid_change_disk_state(sd->sd_disk,
1733		    G_RAID_DISK_S_STALE_FAILED);
1734		TAILQ_REMOVE(&sd->sd_disk->d_subdisks,
1735		    sd, sd_next);
1736	}
1737	vol->v_subdisks[disk_pos].sd_disk = disk;
1738	TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
1739
1740	/* Welcome the new disk. */
1741	if (resurrection)
1742		g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
1743	else if (GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA)
1744		g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED);
1745	else
1746		g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
1747
1748	if (resurrection) {
1749		sd->sd_offset = eoff;
1750		sd->sd_size = esize;
1751	} else if (pdmeta->cr != NULL &&
1752	    (vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL) {
1753		val2 = (uint64_t *)&(vdc1->Physical_Disk_Sequence[GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
1754		sd->sd_offset = (off_t)GET64P(pdmeta, val2 + md_disk_pos) * 512;
1755		sd->sd_size = (off_t)GET64D(pdmeta, vdc1->Block_Count) * 512;
1756	}
1757
1758	if (resurrection) {
1759		/* Stale disk, almost same as new. */
1760		g_raid_change_subdisk_state(sd,
1761		    G_RAID_SUBDISK_S_NEW);
1762	} else if (GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) {
1763		/* Failed disk. */
1764		g_raid_change_subdisk_state(sd,
1765		    G_RAID_SUBDISK_S_FAILED);
1766	} else if ((GET16(gmeta, pdr->entry[md_pde_pos].PD_State) &
1767	     (DDF_PDE_FAILED | DDF_PDE_REBUILD)) != 0) {
1768		/* Rebuilding disk. */
1769		g_raid_change_subdisk_state(sd,
1770		    G_RAID_SUBDISK_S_REBUILD);
1771		sd->sd_rebuild_pos = 0;
1772	} else if ((GET8(vmeta, vde->VD_State) & DDF_VDE_DIRTY) != 0 ||
1773	    (GET8(vmeta, vde->Init_State) & DDF_VDE_INIT_MASK) !=
1774	     DDF_VDE_INIT_FULL) {
1775		/* Stale disk or dirty volume (unclean shutdown). */
1776		g_raid_change_subdisk_state(sd,
1777		    G_RAID_SUBDISK_S_STALE);
1778	} else {
1779		/* Up to date disk. */
1780		g_raid_change_subdisk_state(sd,
1781		    G_RAID_SUBDISK_S_ACTIVE);
1782	}
1783	g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
1784	    G_RAID_EVENT_SUBDISK);
1785
1786	return (resurrection);
1787}
1788
1789static void
1790g_raid_md_ddf_refill(struct g_raid_softc *sc)
1791{
1792	struct g_raid_volume *vol;
1793	struct g_raid_subdisk *sd;
1794	struct g_raid_disk *disk;
1795	struct g_raid_md_object *md;
1796	struct g_raid_md_ddf_perdisk *pd;
1797	struct g_raid_md_ddf_pervolume *pv;
1798	int update, updated, i, bad;
1799
1800	md = sc->sc_md;
1801restart:
1802	updated = 0;
1803	TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
1804		pv = vol->v_md_data;
1805		if (!pv->pv_started || vol->v_stopping)
1806			continue;
1807
1808		/* Search for subdisk that needs replacement. */
1809		bad = 0;
1810		for (i = 0; i < vol->v_disks_count; i++) {
1811			sd = &vol->v_subdisks[i];
1812			if (sd->sd_state == G_RAID_SUBDISK_S_NONE ||
1813			    sd->sd_state == G_RAID_SUBDISK_S_FAILED)
1814			        bad = 1;
1815		}
1816		if (!bad)
1817			continue;
1818
1819		G_RAID_DEBUG1(1, sc, "Volume %s is not complete, "
1820		    "trying to refill.", vol->v_name);
1821
1822		TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1823			/* Skip failed. */
1824			if (disk->d_state < G_RAID_DISK_S_SPARE)
1825				continue;
1826			/* Skip already used by this volume. */
1827			for (i = 0; i < vol->v_disks_count; i++) {
1828				sd = &vol->v_subdisks[i];
1829				if (sd->sd_disk == disk)
1830					break;
1831			}
1832			if (i < vol->v_disks_count)
1833				continue;
1834
1835			/* Try to use disk if it has empty extents. */
1836			pd = disk->d_md_data;
1837			if (ddf_meta_count_vdc(&pd->pd_meta, NULL) <
1838			    GET16(&pd->pd_meta, hdr->Max_Partitions)) {
1839				update = g_raid_md_ddf_start_disk(disk, vol);
1840			} else
1841				update = 0;
1842			if (update) {
1843				updated = 1;
1844				g_raid_md_write_ddf(md, vol, NULL, disk);
1845				break;
1846			}
1847		}
1848	}
1849	if (updated)
1850		goto restart;
1851}
1852
1853static void
1854g_raid_md_ddf_start(struct g_raid_volume *vol)
1855{
1856	struct g_raid_softc *sc;
1857	struct g_raid_subdisk *sd;
1858	struct g_raid_disk *disk;
1859	struct g_raid_md_object *md;
1860	struct g_raid_md_ddf_perdisk *pd;
1861	struct g_raid_md_ddf_pervolume *pv;
1862	struct g_raid_md_ddf_object *mdi;
1863	struct ddf_vol_meta *vmeta;
1864	uint64_t *val2;
1865	int i, j, bvd;
1866
1867	sc = vol->v_softc;
1868	md = sc->sc_md;
1869	mdi = (struct g_raid_md_ddf_object *)md;
1870	pv = vol->v_md_data;
1871	vmeta = &pv->pv_meta;
1872
1873	vol->v_raid_level = GET8(vmeta, vdc->Primary_RAID_Level);
1874	vol->v_raid_level_qualifier = GET8(vmeta, vdc->RLQ);
1875	if (GET8(vmeta, vdc->Secondary_Element_Count) > 1 &&
1876	    vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 &&
1877	    GET8(vmeta, vdc->Secondary_RAID_Level) == 0)
1878		vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E;
1879	vol->v_sectorsize = GET16(vmeta, vdc->Block_Size);
1880	if (vol->v_sectorsize == 0xffff)
1881		vol->v_sectorsize = vmeta->sectorsize;
1882	vol->v_strip_size = vol->v_sectorsize << GET8(vmeta, vdc->Stripe_Size);
1883	vol->v_disks_count = GET16(vmeta, vdc->Primary_Element_Count) *
1884	    GET8(vmeta, vdc->Secondary_Element_Count);
1885	vol->v_mdf_pdisks = GET8(vmeta, vdc->MDF_Parity_Disks);
1886	vol->v_mdf_polynomial = GET16(vmeta, vdc->MDF_Parity_Generator_Polynomial);
1887	vol->v_mdf_method = GET8(vmeta, vdc->MDF_Constant_Generation_Method);
1888	if (GET8(vmeta, vdc->Rotate_Parity_count) > 31)
1889		vol->v_rotate_parity = 1;
1890	else
1891		vol->v_rotate_parity = 1 << GET8(vmeta, vdc->Rotate_Parity_count);
1892	vol->v_mediasize = GET64(vmeta, vdc->VD_Size) * vol->v_sectorsize;
1893	for (i = 0, j = 0, bvd = 0; i < vol->v_disks_count; i++, j++) {
1894		if (j == GET16(vmeta, vdc->Primary_Element_Count)) {
1895			j = 0;
1896			bvd++;
1897		}
1898		sd = &vol->v_subdisks[i];
1899		if (vmeta->bvdc[bvd] == NULL) {
1900			sd->sd_offset = 0;
1901			sd->sd_size = GET64(vmeta, vdc->Block_Count) *
1902			    vol->v_sectorsize;
1903			continue;
1904		}
1905		val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[
1906		    GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
1907		sd->sd_offset = GET64P(vmeta, val2 + j) * vol->v_sectorsize;
1908		sd->sd_size = GET64(vmeta, bvdc[bvd]->Block_Count) *
1909		    vol->v_sectorsize;
1910	}
1911	g_raid_start_volume(vol);
1912
1913	/* Make all disks found till the moment take their places. */
1914	TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1915		pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1916		if (ddf_meta_find_vdc(&pd->pd_meta, vmeta->vdc->VD_GUID) != NULL)
1917			g_raid_md_ddf_start_disk(disk, vol);
1918	}
1919
1920	pv->pv_started = 1;
1921	mdi->mdio_starting--;
1922	callout_stop(&pv->pv_start_co);
1923	G_RAID_DEBUG1(0, sc, "Volume started.");
1924	g_raid_md_write_ddf(md, vol, NULL, NULL);
1925
1926	/* Pickup any STALE/SPARE disks to refill array if needed. */
1927	g_raid_md_ddf_refill(sc);
1928
1929	g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME);
1930}
1931
1932static void
1933g_raid_ddf_go(void *arg)
1934{
1935	struct g_raid_volume *vol;
1936	struct g_raid_softc *sc;
1937	struct g_raid_md_ddf_pervolume *pv;
1938
1939	vol = arg;
1940	pv = vol->v_md_data;
1941	sc = vol->v_softc;
1942	if (!pv->pv_started) {
1943		G_RAID_DEBUG1(0, sc, "Force volume start due to timeout.");
1944		g_raid_event_send(vol, G_RAID_VOLUME_E_STARTMD,
1945		    G_RAID_EVENT_VOLUME);
1946	}
1947}
1948
1949static void
1950g_raid_md_ddf_new_disk(struct g_raid_disk *disk)
1951{
1952	struct g_raid_softc *sc;
1953	struct g_raid_md_object *md;
1954	struct g_raid_md_ddf_perdisk *pd;
1955	struct g_raid_md_ddf_pervolume *pv;
1956	struct g_raid_md_ddf_object *mdi;
1957	struct g_raid_volume *vol;
1958	struct ddf_meta *pdmeta;
1959	struct ddf_vol_meta *vmeta;
1960	struct ddf_vdc_record *vdc;
1961	struct ddf_vd_entry *vde;
1962	int i, j, k, num, have, need, cnt, spare;
1963	uint32_t val;
1964	char buf[17];
1965
1966	sc = disk->d_softc;
1967	md = sc->sc_md;
1968	mdi = (struct g_raid_md_ddf_object *)md;
1969	pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1970	pdmeta = &pd->pd_meta;
1971	spare = -1;
1972
1973	if (mdi->mdio_meta.hdr == NULL)
1974		ddf_meta_copy(&mdi->mdio_meta, pdmeta);
1975	else
1976		ddf_meta_update(&mdi->mdio_meta, pdmeta);
1977
1978	num = GETCRNUM(pdmeta);
1979	for (j = 0; j < num; j++) {
1980		vdc = GETVDCPTR(pdmeta, j);
1981		val = GET32D(pdmeta, vdc->Signature);
1982
1983		if (val == DDF_SA_SIGNATURE && spare == -1)
1984			spare = 1;
1985
1986		if (val != DDF_VDCR_SIGNATURE)
1987			continue;
1988		spare = 0;
1989		k = ddf_meta_find_vd(pdmeta, vdc->VD_GUID);
1990		if (k < 0)
1991			continue;
1992		vde = &pdmeta->vdr->entry[k];
1993
1994		/* Look for volume with matching ID. */
1995		vol = g_raid_md_ddf_get_volume(sc, vdc->VD_GUID);
1996		if (vol == NULL) {
1997			ddf_meta_get_name(pdmeta, k, buf);
1998			vol = g_raid_create_volume(sc, buf,
1999			    GET16D(pdmeta, vde->VD_Number));
2000			pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO);
2001			vol->v_md_data = pv;
2002			callout_init(&pv->pv_start_co, 1);
2003			callout_reset(&pv->pv_start_co,
2004			    g_raid_start_timeout * hz,
2005			    g_raid_ddf_go, vol);
2006			mdi->mdio_starting++;
2007		} else
2008			pv = vol->v_md_data;
2009
2010		/* If we haven't started yet - check metadata freshness. */
2011		vmeta = &pv->pv_meta;
2012		ddf_vol_meta_update(vmeta, pdmeta, vdc->VD_GUID, pv->pv_started);
2013	}
2014
2015	if (spare == 1) {
2016		g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
2017		g_raid_md_ddf_refill(sc);
2018	}
2019
2020	TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2021		pv = vol->v_md_data;
2022		vmeta = &pv->pv_meta;
2023
2024		if (ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID) == NULL)
2025			continue;
2026
2027		if (pv->pv_started) {
2028			if (g_raid_md_ddf_start_disk(disk, vol))
2029				g_raid_md_write_ddf(md, vol, NULL, NULL);
2030			continue;
2031		}
2032
2033		/* If we collected all needed disks - start array. */
2034		need = 0;
2035		have = 0;
2036		for (k = 0; k < GET8(vmeta, vdc->Secondary_Element_Count); k++) {
2037			if (vmeta->bvdc[k] == NULL) {
2038				need += GET16(vmeta, vdc->Primary_Element_Count);
2039				continue;
2040			}
2041			cnt = GET16(vmeta, bvdc[k]->Primary_Element_Count);
2042			need += cnt;
2043			for (i = 0; i < cnt; i++) {
2044				val = GET32(vmeta, bvdc[k]->Physical_Disk_Sequence[i]);
2045				if (g_raid_md_ddf_get_disk(sc, NULL, val) != NULL)
2046					have++;
2047			}
2048		}
2049		G_RAID_DEBUG1(1, sc, "Volume %s now has %d of %d disks",
2050		    vol->v_name, have, need);
2051		if (have == need)
2052			g_raid_md_ddf_start(vol);
2053	}
2054}
2055
2056static int
2057g_raid_md_create_req_ddf(struct g_raid_md_object *md, struct g_class *mp,
2058    struct gctl_req *req, struct g_geom **gp)
2059{
2060	struct g_geom *geom;
2061	struct g_raid_softc *sc;
2062	struct g_raid_md_ddf_object *mdi, *mdi1;
2063	char name[16];
2064	const char *fmtopt;
2065	int be = 1;
2066
2067	mdi = (struct g_raid_md_ddf_object *)md;
2068	fmtopt = gctl_get_asciiparam(req, "fmtopt");
2069	if (fmtopt == NULL || strcasecmp(fmtopt, "BE") == 0)
2070		be = 1;
2071	else if (strcasecmp(fmtopt, "LE") == 0)
2072		be = 0;
2073	else {
2074		gctl_error(req, "Incorrect fmtopt argument.");
2075		return (G_RAID_MD_TASTE_FAIL);
2076	}
2077
2078	/* Search for existing node. */
2079	LIST_FOREACH(geom, &mp->geom, geom) {
2080		sc = geom->softc;
2081		if (sc == NULL)
2082			continue;
2083		if (sc->sc_stopping != 0)
2084			continue;
2085		if (sc->sc_md->mdo_class != md->mdo_class)
2086			continue;
2087		mdi1 = (struct g_raid_md_ddf_object *)sc->sc_md;
2088		if (mdi1->mdio_bigendian != be)
2089			continue;
2090		break;
2091	}
2092	if (geom != NULL) {
2093		*gp = geom;
2094		return (G_RAID_MD_TASTE_EXISTING);
2095	}
2096
2097	/* Create new one if not found. */
2098	mdi->mdio_bigendian = be;
2099	snprintf(name, sizeof(name), "DDF%s", be ? "" : "-LE");
2100	sc = g_raid_create_node(mp, name, md);
2101	if (sc == NULL)
2102		return (G_RAID_MD_TASTE_FAIL);
2103	md->mdo_softc = sc;
2104	*gp = sc->sc_geom;
2105	return (G_RAID_MD_TASTE_NEW);
2106}
2107
2108static int
2109g_raid_md_taste_ddf(struct g_raid_md_object *md, struct g_class *mp,
2110                              struct g_consumer *cp, struct g_geom **gp)
2111{
2112	struct g_consumer *rcp;
2113	struct g_provider *pp;
2114	struct g_raid_softc *sc;
2115	struct g_raid_disk *disk;
2116	struct ddf_meta meta;
2117	struct g_raid_md_ddf_perdisk *pd;
2118	struct g_raid_md_ddf_object *mdi;
2119	struct g_geom *geom;
2120	int error, result, be;
2121	char name[16];
2122
2123	G_RAID_DEBUG(1, "Tasting DDF on %s", cp->provider->name);
2124	mdi = (struct g_raid_md_ddf_object *)md;
2125	pp = cp->provider;
2126
2127	/* Read metadata from device. */
2128	g_topology_unlock();
2129	bzero(&meta, sizeof(meta));
2130	error = ddf_meta_read(cp, &meta);
2131	g_topology_lock();
2132	if (error != 0)
2133		return (G_RAID_MD_TASTE_FAIL);
2134	be = meta.bigendian;
2135
2136	/* Metadata valid. Print it. */
2137	g_raid_md_ddf_print(&meta);
2138
2139	/* Search for matching node. */
2140	sc = NULL;
2141	LIST_FOREACH(geom, &mp->geom, geom) {
2142		sc = geom->softc;
2143		if (sc == NULL)
2144			continue;
2145		if (sc->sc_stopping != 0)
2146			continue;
2147		if (sc->sc_md->mdo_class != md->mdo_class)
2148			continue;
2149		mdi = (struct g_raid_md_ddf_object *)sc->sc_md;
2150		if (mdi->mdio_bigendian != be)
2151			continue;
2152		break;
2153	}
2154
2155	/* Found matching node. */
2156	if (geom != NULL) {
2157		G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name);
2158		result = G_RAID_MD_TASTE_EXISTING;
2159
2160	} else { /* Not found matching node -- create one. */
2161		result = G_RAID_MD_TASTE_NEW;
2162		mdi->mdio_bigendian = be;
2163		snprintf(name, sizeof(name), "DDF%s", be ? "" : "-LE");
2164		sc = g_raid_create_node(mp, name, md);
2165		md->mdo_softc = sc;
2166		geom = sc->sc_geom;
2167	}
2168
2169	/* There is no return after this point, so we close passed consumer. */
2170	g_access(cp, -1, 0, 0);
2171
2172	rcp = g_new_consumer(geom);
2173	rcp->flags |= G_CF_DIRECT_RECEIVE;
2174	g_attach(rcp, pp);
2175	if (g_access(rcp, 1, 1, 1) != 0)
2176		; //goto fail1;
2177
2178	g_topology_unlock();
2179	sx_xlock(&sc->sc_lock);
2180
2181	pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
2182	pd->pd_meta = meta;
2183	disk = g_raid_create_disk(sc);
2184	disk->d_md_data = (void *)pd;
2185	disk->d_consumer = rcp;
2186	rcp->private = disk;
2187
2188	g_raid_get_disk_info(disk);
2189
2190	g_raid_md_ddf_new_disk(disk);
2191
2192	sx_xunlock(&sc->sc_lock);
2193	g_topology_lock();
2194	*gp = geom;
2195	return (result);
2196}
2197
2198static int
2199g_raid_md_event_ddf(struct g_raid_md_object *md,
2200    struct g_raid_disk *disk, u_int event)
2201{
2202	struct g_raid_softc *sc;
2203
2204	sc = md->mdo_softc;
2205	if (disk == NULL)
2206		return (-1);
2207	switch (event) {
2208	case G_RAID_DISK_E_DISCONNECTED:
2209		/* Delete disk. */
2210		g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
2211		g_raid_destroy_disk(disk);
2212		g_raid_md_ddf_purge_volumes(sc);
2213
2214		/* Write updated metadata to all disks. */
2215		g_raid_md_write_ddf(md, NULL, NULL, NULL);
2216
2217		/* Check if anything left. */
2218		if (g_raid_ndisks(sc, -1) == 0)
2219			g_raid_destroy_node(sc, 0);
2220		else
2221			g_raid_md_ddf_refill(sc);
2222		return (0);
2223	}
2224	return (-2);
2225}
2226
2227static int
2228g_raid_md_volume_event_ddf(struct g_raid_md_object *md,
2229    struct g_raid_volume *vol, u_int event)
2230{
2231	struct g_raid_md_ddf_pervolume *pv;
2232
2233	pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2234	switch (event) {
2235	case G_RAID_VOLUME_E_STARTMD:
2236		if (!pv->pv_started)
2237			g_raid_md_ddf_start(vol);
2238		return (0);
2239	}
2240	return (-2);
2241}
2242
2243static int
2244g_raid_md_ctl_ddf(struct g_raid_md_object *md,
2245    struct gctl_req *req)
2246{
2247	struct g_raid_softc *sc;
2248	struct g_raid_volume *vol, *vol1;
2249	struct g_raid_subdisk *sd;
2250	struct g_raid_disk *disk, *disks[DDF_MAX_DISKS_HARD];
2251	struct g_raid_md_ddf_perdisk *pd;
2252	struct g_raid_md_ddf_pervolume *pv;
2253	struct g_raid_md_ddf_object *mdi;
2254	struct ddf_sa_record *sa;
2255	struct g_consumer *cp;
2256	struct g_provider *pp;
2257	char arg[16];
2258	const char *nodename, *verb, *volname, *levelname, *diskname;
2259	char *tmp;
2260	int *nargs, *force;
2261	off_t size, sectorsize, strip, offs[DDF_MAX_DISKS_HARD], esize;
2262	intmax_t *sizearg, *striparg;
2263	int i, numdisks, len, level, qual;
2264	int error;
2265
2266	sc = md->mdo_softc;
2267	mdi = (struct g_raid_md_ddf_object *)md;
2268	verb = gctl_get_param(req, "verb", NULL);
2269	nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
2270	error = 0;
2271
2272	if (strcmp(verb, "label") == 0) {
2273
2274		if (*nargs < 4) {
2275			gctl_error(req, "Invalid number of arguments.");
2276			return (-1);
2277		}
2278		volname = gctl_get_asciiparam(req, "arg1");
2279		if (volname == NULL) {
2280			gctl_error(req, "No volume name.");
2281			return (-2);
2282		}
2283		levelname = gctl_get_asciiparam(req, "arg2");
2284		if (levelname == NULL) {
2285			gctl_error(req, "No RAID level.");
2286			return (-3);
2287		}
2288		if (g_raid_volume_str2level(levelname, &level, &qual)) {
2289			gctl_error(req, "Unknown RAID level '%s'.", levelname);
2290			return (-4);
2291		}
2292		numdisks = *nargs - 3;
2293		force = gctl_get_paraml(req, "force", sizeof(*force));
2294		if (!g_raid_md_ddf_supported(level, qual, numdisks,
2295		    force ? *force : 0)) {
2296			gctl_error(req, "Unsupported RAID level "
2297			    "(0x%02x/0x%02x), or number of disks (%d).",
2298			    level, qual, numdisks);
2299			return (-5);
2300		}
2301
2302		/* Search for disks, connect them and probe. */
2303		size = INT64_MAX;
2304		sectorsize = 0;
2305		bzero(disks, sizeof(disks));
2306		bzero(offs, sizeof(offs));
2307		for (i = 0; i < numdisks; i++) {
2308			snprintf(arg, sizeof(arg), "arg%d", i + 3);
2309			diskname = gctl_get_asciiparam(req, arg);
2310			if (diskname == NULL) {
2311				gctl_error(req, "No disk name (%s).", arg);
2312				error = -6;
2313				break;
2314			}
2315			if (strcmp(diskname, "NONE") == 0)
2316				continue;
2317
2318			TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2319				if (disk->d_consumer != NULL &&
2320				    disk->d_consumer->provider != NULL &&
2321				    strcmp(disk->d_consumer->provider->name,
2322				     diskname) == 0)
2323					break;
2324			}
2325			if (disk != NULL) {
2326				if (disk->d_state != G_RAID_DISK_S_ACTIVE) {
2327					gctl_error(req, "Disk '%s' is in a "
2328					    "wrong state (%s).", diskname,
2329					    g_raid_disk_state2str(disk->d_state));
2330					error = -7;
2331					break;
2332				}
2333				pd = disk->d_md_data;
2334				if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >=
2335				    GET16(&pd->pd_meta, hdr->Max_Partitions)) {
2336					gctl_error(req, "No free partitions "
2337					    "on disk '%s'.",
2338					    diskname);
2339					error = -7;
2340					break;
2341				}
2342				pp = disk->d_consumer->provider;
2343				disks[i] = disk;
2344				ddf_meta_unused_range(&pd->pd_meta,
2345				    &offs[i], &esize);
2346				offs[i] *= pp->sectorsize;
2347				size = MIN(size, (off_t)esize * pp->sectorsize);
2348				sectorsize = MAX(sectorsize, pp->sectorsize);
2349				continue;
2350			}
2351
2352			g_topology_lock();
2353			cp = g_raid_open_consumer(sc, diskname);
2354			if (cp == NULL) {
2355				gctl_error(req, "Can't open disk '%s'.",
2356				    diskname);
2357				g_topology_unlock();
2358				error = -8;
2359				break;
2360			}
2361			pp = cp->provider;
2362			pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
2363			disk = g_raid_create_disk(sc);
2364			disk->d_md_data = (void *)pd;
2365			disk->d_consumer = cp;
2366			disks[i] = disk;
2367			cp->private = disk;
2368			ddf_meta_create(disk, &mdi->mdio_meta);
2369			if (mdi->mdio_meta.hdr == NULL)
2370				ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta);
2371			else
2372				ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta);
2373			g_topology_unlock();
2374
2375			g_raid_get_disk_info(disk);
2376
2377			/* Reserve some space for metadata. */
2378			size = MIN(size, GET64(&pd->pd_meta,
2379			    pdr->entry[0].Configured_Size) * pp->sectorsize);
2380			sectorsize = MAX(sectorsize, pp->sectorsize);
2381		}
2382		if (error != 0) {
2383			for (i = 0; i < numdisks; i++) {
2384				if (disks[i] != NULL &&
2385				    disks[i]->d_state == G_RAID_DISK_S_NONE)
2386					g_raid_destroy_disk(disks[i]);
2387			}
2388			return (error);
2389		}
2390
2391		if (sectorsize <= 0) {
2392			gctl_error(req, "Can't get sector size.");
2393			return (-8);
2394		}
2395
2396		/* Handle size argument. */
2397		len = sizeof(*sizearg);
2398		sizearg = gctl_get_param(req, "size", &len);
2399		if (sizearg != NULL && len == sizeof(*sizearg) &&
2400		    *sizearg > 0) {
2401			if (*sizearg > size) {
2402				gctl_error(req, "Size too big %lld > %lld.",
2403				    (long long)*sizearg, (long long)size);
2404				return (-9);
2405			}
2406			size = *sizearg;
2407		}
2408
2409		/* Handle strip argument. */
2410		strip = 131072;
2411		len = sizeof(*striparg);
2412		striparg = gctl_get_param(req, "strip", &len);
2413		if (striparg != NULL && len == sizeof(*striparg) &&
2414		    *striparg > 0) {
2415			if (*striparg < sectorsize) {
2416				gctl_error(req, "Strip size too small.");
2417				return (-10);
2418			}
2419			if (*striparg % sectorsize != 0) {
2420				gctl_error(req, "Incorrect strip size.");
2421				return (-11);
2422			}
2423			strip = *striparg;
2424		}
2425
2426		/* Round size down to strip or sector. */
2427		if (level == G_RAID_VOLUME_RL_RAID1 ||
2428		    level == G_RAID_VOLUME_RL_RAID3 ||
2429		    level == G_RAID_VOLUME_RL_SINGLE ||
2430		    level == G_RAID_VOLUME_RL_CONCAT)
2431			size -= (size % sectorsize);
2432		else if (level == G_RAID_VOLUME_RL_RAID1E &&
2433		    (numdisks & 1) != 0)
2434			size -= (size % (2 * strip));
2435		else
2436			size -= (size % strip);
2437		if (size <= 0) {
2438			gctl_error(req, "Size too small.");
2439			return (-13);
2440		}
2441
2442		/* We have all we need, create things: volume, ... */
2443		pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO);
2444		ddf_vol_meta_create(&pv->pv_meta, &mdi->mdio_meta);
2445		pv->pv_started = 1;
2446		vol = g_raid_create_volume(sc, volname, -1);
2447		vol->v_md_data = pv;
2448		vol->v_raid_level = level;
2449		vol->v_raid_level_qualifier = qual;
2450		vol->v_strip_size = strip;
2451		vol->v_disks_count = numdisks;
2452		if (level == G_RAID_VOLUME_RL_RAID0 ||
2453		    level == G_RAID_VOLUME_RL_CONCAT ||
2454		    level == G_RAID_VOLUME_RL_SINGLE)
2455			vol->v_mediasize = size * numdisks;
2456		else if (level == G_RAID_VOLUME_RL_RAID1)
2457			vol->v_mediasize = size;
2458		else if (level == G_RAID_VOLUME_RL_RAID3 ||
2459		    level == G_RAID_VOLUME_RL_RAID4 ||
2460		    level == G_RAID_VOLUME_RL_RAID5)
2461			vol->v_mediasize = size * (numdisks - 1);
2462		else if (level == G_RAID_VOLUME_RL_RAID5R) {
2463			vol->v_mediasize = size * (numdisks - 1);
2464			vol->v_rotate_parity = 1024;
2465		} else if (level == G_RAID_VOLUME_RL_RAID6 ||
2466		    level == G_RAID_VOLUME_RL_RAID5E ||
2467		    level == G_RAID_VOLUME_RL_RAID5EE)
2468			vol->v_mediasize = size * (numdisks - 2);
2469		else if (level == G_RAID_VOLUME_RL_RAIDMDF) {
2470			if (numdisks < 5)
2471				vol->v_mdf_pdisks = 2;
2472			else
2473				vol->v_mdf_pdisks = 3;
2474			vol->v_mdf_polynomial = 0x11d;
2475			vol->v_mdf_method = 0x00;
2476			vol->v_mediasize = size * (numdisks - vol->v_mdf_pdisks);
2477		} else { /* RAID1E */
2478			vol->v_mediasize = ((size * numdisks) / strip / 2) *
2479			    strip;
2480		}
2481		vol->v_sectorsize = sectorsize;
2482		g_raid_start_volume(vol);
2483
2484		/* , and subdisks. */
2485		for (i = 0; i < numdisks; i++) {
2486			disk = disks[i];
2487			sd = &vol->v_subdisks[i];
2488			sd->sd_disk = disk;
2489			sd->sd_offset = offs[i];
2490			sd->sd_size = size;
2491			if (disk == NULL)
2492				continue;
2493			TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
2494			g_raid_change_disk_state(disk,
2495			    G_RAID_DISK_S_ACTIVE);
2496			g_raid_change_subdisk_state(sd,
2497			    G_RAID_SUBDISK_S_ACTIVE);
2498			g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
2499			    G_RAID_EVENT_SUBDISK);
2500		}
2501
2502		/* Write metadata based on created entities. */
2503		G_RAID_DEBUG1(0, sc, "Array started.");
2504		g_raid_md_write_ddf(md, vol, NULL, NULL);
2505
2506		/* Pickup any STALE/SPARE disks to refill array if needed. */
2507		g_raid_md_ddf_refill(sc);
2508
2509		g_raid_event_send(vol, G_RAID_VOLUME_E_START,
2510		    G_RAID_EVENT_VOLUME);
2511		return (0);
2512	}
2513	if (strcmp(verb, "add") == 0) {
2514
2515		gctl_error(req, "`add` command is not applicable, "
2516		    "use `label` instead.");
2517		return (-99);
2518	}
2519	if (strcmp(verb, "delete") == 0) {
2520
2521		nodename = gctl_get_asciiparam(req, "arg0");
2522		if (nodename != NULL && strcasecmp(sc->sc_name, nodename) != 0)
2523			nodename = NULL;
2524
2525		/* Full node destruction. */
2526		if (*nargs == 1 && nodename != NULL) {
2527			/* Check if some volume is still open. */
2528			force = gctl_get_paraml(req, "force", sizeof(*force));
2529			if (force != NULL && *force == 0 &&
2530			    g_raid_nopens(sc) != 0) {
2531				gctl_error(req, "Some volume is still open.");
2532				return (-4);
2533			}
2534
2535			TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2536				if (disk->d_consumer)
2537					ddf_meta_erase(disk->d_consumer);
2538			}
2539			g_raid_destroy_node(sc, 0);
2540			return (0);
2541		}
2542
2543		/* Destroy specified volume. If it was last - all node. */
2544		if (*nargs > 2) {
2545			gctl_error(req, "Invalid number of arguments.");
2546			return (-1);
2547		}
2548		volname = gctl_get_asciiparam(req,
2549		    nodename != NULL ? "arg1" : "arg0");
2550		if (volname == NULL) {
2551			gctl_error(req, "No volume name.");
2552			return (-2);
2553		}
2554
2555		/* Search for volume. */
2556		TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2557			if (strcmp(vol->v_name, volname) == 0)
2558				break;
2559			pp = vol->v_provider;
2560			if (pp == NULL)
2561				continue;
2562			if (strcmp(pp->name, volname) == 0)
2563				break;
2564			if (strncmp(pp->name, "raid/", 5) == 0 &&
2565			    strcmp(pp->name + 5, volname) == 0)
2566				break;
2567		}
2568		if (vol == NULL) {
2569			i = strtol(volname, &tmp, 10);
2570			if (verb != volname && tmp[0] == 0) {
2571				TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2572					if (vol->v_global_id == i)
2573						break;
2574				}
2575			}
2576		}
2577		if (vol == NULL) {
2578			gctl_error(req, "Volume '%s' not found.", volname);
2579			return (-3);
2580		}
2581
2582		/* Check if volume is still open. */
2583		force = gctl_get_paraml(req, "force", sizeof(*force));
2584		if (force != NULL && *force == 0 &&
2585		    vol->v_provider_open != 0) {
2586			gctl_error(req, "Volume is still open.");
2587			return (-4);
2588		}
2589
2590		/* Destroy volume and potentially node. */
2591		i = 0;
2592		TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next)
2593			i++;
2594		if (i >= 2) {
2595			g_raid_destroy_volume(vol);
2596			g_raid_md_ddf_purge_disks(sc);
2597			g_raid_md_write_ddf(md, NULL, NULL, NULL);
2598		} else {
2599			TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2600				if (disk->d_consumer)
2601					ddf_meta_erase(disk->d_consumer);
2602			}
2603			g_raid_destroy_node(sc, 0);
2604		}
2605		return (0);
2606	}
2607	if (strcmp(verb, "remove") == 0 ||
2608	    strcmp(verb, "fail") == 0) {
2609		if (*nargs < 2) {
2610			gctl_error(req, "Invalid number of arguments.");
2611			return (-1);
2612		}
2613		for (i = 1; i < *nargs; i++) {
2614			snprintf(arg, sizeof(arg), "arg%d", i);
2615			diskname = gctl_get_asciiparam(req, arg);
2616			if (diskname == NULL) {
2617				gctl_error(req, "No disk name (%s).", arg);
2618				error = -2;
2619				break;
2620			}
2621			if (strncmp(diskname, "/dev/", 5) == 0)
2622				diskname += 5;
2623
2624			TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2625				if (disk->d_consumer != NULL &&
2626				    disk->d_consumer->provider != NULL &&
2627				    strcmp(disk->d_consumer->provider->name,
2628				     diskname) == 0)
2629					break;
2630			}
2631			if (disk == NULL) {
2632				gctl_error(req, "Disk '%s' not found.",
2633				    diskname);
2634				error = -3;
2635				break;
2636			}
2637
2638			if (strcmp(verb, "fail") == 0) {
2639				g_raid_md_fail_disk_ddf(md, NULL, disk);
2640				continue;
2641			}
2642
2643			/* Erase metadata on deleting disk and destroy it. */
2644			ddf_meta_erase(disk->d_consumer);
2645			g_raid_destroy_disk(disk);
2646		}
2647		g_raid_md_ddf_purge_volumes(sc);
2648
2649		/* Write updated metadata to remaining disks. */
2650		g_raid_md_write_ddf(md, NULL, NULL, NULL);
2651
2652		/* Check if anything left. */
2653		if (g_raid_ndisks(sc, -1) == 0)
2654			g_raid_destroy_node(sc, 0);
2655		else
2656			g_raid_md_ddf_refill(sc);
2657		return (error);
2658	}
2659	if (strcmp(verb, "insert") == 0) {
2660		if (*nargs < 2) {
2661			gctl_error(req, "Invalid number of arguments.");
2662			return (-1);
2663		}
2664		for (i = 1; i < *nargs; i++) {
2665			/* Get disk name. */
2666			snprintf(arg, sizeof(arg), "arg%d", i);
2667			diskname = gctl_get_asciiparam(req, arg);
2668			if (diskname == NULL) {
2669				gctl_error(req, "No disk name (%s).", arg);
2670				error = -3;
2671				break;
2672			}
2673
2674			/* Try to find provider with specified name. */
2675			g_topology_lock();
2676			cp = g_raid_open_consumer(sc, diskname);
2677			if (cp == NULL) {
2678				gctl_error(req, "Can't open disk '%s'.",
2679				    diskname);
2680				g_topology_unlock();
2681				error = -4;
2682				break;
2683			}
2684			pp = cp->provider;
2685			g_topology_unlock();
2686
2687			pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
2688
2689			disk = g_raid_create_disk(sc);
2690			disk->d_consumer = cp;
2691			disk->d_md_data = (void *)pd;
2692			cp->private = disk;
2693
2694			g_raid_get_disk_info(disk);
2695
2696			/* Welcome the "new" disk. */
2697			g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
2698			ddf_meta_create(disk, &mdi->mdio_meta);
2699			sa = ddf_meta_find_sa(&pd->pd_meta, 1);
2700			if (sa != NULL) {
2701				SET32D(&pd->pd_meta, sa->Signature,
2702				    DDF_SA_SIGNATURE);
2703				SET8D(&pd->pd_meta, sa->Spare_Type, 0);
2704				SET16D(&pd->pd_meta, sa->Populated_SAEs, 0);
2705				SET16D(&pd->pd_meta, sa->MAX_SAE_Supported,
2706				    (GET16(&pd->pd_meta, hdr->Configuration_Record_Length) *
2707				     pd->pd_meta.sectorsize -
2708				     sizeof(struct ddf_sa_record)) /
2709				    sizeof(struct ddf_sa_entry));
2710			}
2711			if (mdi->mdio_meta.hdr == NULL)
2712				ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta);
2713			else
2714				ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta);
2715			g_raid_md_write_ddf(md, NULL, NULL, NULL);
2716			g_raid_md_ddf_refill(sc);
2717		}
2718		return (error);
2719	}
2720	return (-100);
2721}
2722
2723static int
2724g_raid_md_write_ddf(struct g_raid_md_object *md, struct g_raid_volume *tvol,
2725    struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
2726{
2727	struct g_raid_softc *sc;
2728	struct g_raid_volume *vol;
2729	struct g_raid_subdisk *sd;
2730	struct g_raid_disk *disk;
2731	struct g_raid_md_ddf_perdisk *pd;
2732	struct g_raid_md_ddf_pervolume *pv;
2733	struct g_raid_md_ddf_object *mdi;
2734	struct ddf_meta *gmeta;
2735	struct ddf_vol_meta *vmeta;
2736	struct ddf_vdc_record *vdc;
2737	struct ddf_sa_record *sa;
2738	uint64_t *val2;
2739	int i, j, pos, bvd, size;
2740
2741	sc = md->mdo_softc;
2742	mdi = (struct g_raid_md_ddf_object *)md;
2743	gmeta = &mdi->mdio_meta;
2744
2745	if (sc->sc_stopping == G_RAID_DESTROY_HARD)
2746		return (0);
2747
2748	/*
2749	 * Clear disk flags to let only really needed ones to be reset.
2750	 * Do it only if there are no volumes in starting state now,
2751	 * as they can update disk statuses yet and we may kill innocent.
2752	 */
2753	if (mdi->mdio_starting == 0) {
2754		for (i = 0; i < GET16(gmeta, pdr->Populated_PDEs); i++) {
2755			if (isff(gmeta->pdr->entry[i].PD_GUID, 24))
2756				continue;
2757			SET16(gmeta, pdr->entry[i].PD_Type,
2758			    GET16(gmeta, pdr->entry[i].PD_Type) &
2759			    ~(DDF_PDE_PARTICIPATING |
2760			      DDF_PDE_GLOBAL_SPARE | DDF_PDE_CONFIG_SPARE));
2761			if ((GET16(gmeta, pdr->entry[i].PD_State) &
2762			    DDF_PDE_PFA) == 0)
2763				SET16(gmeta, pdr->entry[i].PD_State, 0);
2764		}
2765	}
2766
2767	/* Generate/update new per-volume metadata. */
2768	TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2769		pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2770		if (vol->v_stopping || !pv->pv_started)
2771			continue;
2772		vmeta = &pv->pv_meta;
2773
2774		SET32(vmeta, vdc->Sequence_Number,
2775		    GET32(vmeta, vdc->Sequence_Number) + 1);
2776		if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E &&
2777		    vol->v_disks_count % 2 == 0)
2778			SET16(vmeta, vdc->Primary_Element_Count, 2);
2779		else
2780			SET16(vmeta, vdc->Primary_Element_Count,
2781			    vol->v_disks_count);
2782		SET8(vmeta, vdc->Stripe_Size,
2783		    ffs(vol->v_strip_size / vol->v_sectorsize) - 1);
2784		if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E &&
2785		    vol->v_disks_count % 2 == 0) {
2786			SET8(vmeta, vdc->Primary_RAID_Level,
2787			    DDF_VDCR_RAID1);
2788			SET8(vmeta, vdc->RLQ, 0);
2789			SET8(vmeta, vdc->Secondary_Element_Count,
2790			    vol->v_disks_count / 2);
2791			SET8(vmeta, vdc->Secondary_RAID_Level, 0);
2792		} else {
2793			SET8(vmeta, vdc->Primary_RAID_Level,
2794			    vol->v_raid_level);
2795			SET8(vmeta, vdc->RLQ,
2796			    vol->v_raid_level_qualifier);
2797			SET8(vmeta, vdc->Secondary_Element_Count, 1);
2798			SET8(vmeta, vdc->Secondary_RAID_Level, 0);
2799		}
2800		SET8(vmeta, vdc->Secondary_Element_Seq, 0);
2801		SET64(vmeta, vdc->Block_Count, 0);
2802		SET64(vmeta, vdc->VD_Size, vol->v_mediasize / vol->v_sectorsize);
2803		SET16(vmeta, vdc->Block_Size, vol->v_sectorsize);
2804		SET8(vmeta, vdc->Rotate_Parity_count,
2805		    fls(vol->v_rotate_parity) - 1);
2806		SET8(vmeta, vdc->MDF_Parity_Disks, vol->v_mdf_pdisks);
2807		SET16(vmeta, vdc->MDF_Parity_Generator_Polynomial,
2808		    vol->v_mdf_polynomial);
2809		SET8(vmeta, vdc->MDF_Constant_Generation_Method,
2810		    vol->v_mdf_method);
2811
2812		SET16(vmeta, vde->VD_Number, vol->v_global_id);
2813		if (vol->v_state <= G_RAID_VOLUME_S_BROKEN)
2814			SET8(vmeta, vde->VD_State, DDF_VDE_FAILED);
2815		else if (vol->v_state <= G_RAID_VOLUME_S_DEGRADED)
2816			SET8(vmeta, vde->VD_State, DDF_VDE_DEGRADED);
2817		else if (vol->v_state <= G_RAID_VOLUME_S_SUBOPTIMAL)
2818			SET8(vmeta, vde->VD_State, DDF_VDE_PARTIAL);
2819		else
2820			SET8(vmeta, vde->VD_State, DDF_VDE_OPTIMAL);
2821		if (vol->v_dirty ||
2822		    g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_STALE) > 0 ||
2823		    g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_RESYNC) > 0)
2824			SET8(vmeta, vde->VD_State,
2825			    GET8(vmeta, vde->VD_State) | DDF_VDE_DIRTY);
2826		SET8(vmeta, vde->Init_State, DDF_VDE_INIT_FULL); // XXX
2827		ddf_meta_put_name(vmeta, vol->v_name);
2828
2829		for (i = 0; i < vol->v_disks_count; i++) {
2830			sd = &vol->v_subdisks[i];
2831			bvd = i / GET16(vmeta, vdc->Primary_Element_Count);
2832			pos = i % GET16(vmeta, vdc->Primary_Element_Count);
2833			disk = sd->sd_disk;
2834			if (disk != NULL) {
2835				pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
2836				if (vmeta->bvdc[bvd] == NULL) {
2837					size = GET16(vmeta,
2838					    hdr->Configuration_Record_Length) *
2839					    vmeta->sectorsize;
2840					vmeta->bvdc[bvd] = malloc(size,
2841					    M_MD_DDF, M_WAITOK);
2842					memset(vmeta->bvdc[bvd], 0xff, size);
2843				}
2844				memcpy(vmeta->bvdc[bvd], vmeta->vdc,
2845				    sizeof(struct ddf_vdc_record));
2846				SET8(vmeta, bvdc[bvd]->Secondary_Element_Seq, bvd);
2847				SET64(vmeta, bvdc[bvd]->Block_Count,
2848				    sd->sd_size / vol->v_sectorsize);
2849				SET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos],
2850				    GET32(&pd->pd_meta, pdd->PD_Reference));
2851				val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[
2852				    GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
2853				SET64P(vmeta, val2 + pos,
2854				    sd->sd_offset / vol->v_sectorsize);
2855			}
2856			if (vmeta->bvdc[bvd] == NULL)
2857				continue;
2858
2859			j = ddf_meta_find_pd(gmeta, NULL,
2860			    GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos]));
2861			if (j < 0)
2862				continue;
2863			SET16(gmeta, pdr->entry[j].PD_Type,
2864			    GET16(gmeta, pdr->entry[j].PD_Type) |
2865			    DDF_PDE_PARTICIPATING);
2866			if (sd->sd_state == G_RAID_SUBDISK_S_NONE)
2867				SET16(gmeta, pdr->entry[j].PD_State,
2868				    GET16(gmeta, pdr->entry[j].PD_State) |
2869				    (DDF_PDE_FAILED | DDF_PDE_MISSING));
2870			else if (sd->sd_state == G_RAID_SUBDISK_S_FAILED)
2871				SET16(gmeta, pdr->entry[j].PD_State,
2872				    GET16(gmeta, pdr->entry[j].PD_State) |
2873				    (DDF_PDE_FAILED | DDF_PDE_PFA));
2874			else if (sd->sd_state <= G_RAID_SUBDISK_S_REBUILD)
2875				SET16(gmeta, pdr->entry[j].PD_State,
2876				    GET16(gmeta, pdr->entry[j].PD_State) |
2877				    DDF_PDE_REBUILD);
2878			else
2879				SET16(gmeta, pdr->entry[j].PD_State,
2880				    GET16(gmeta, pdr->entry[j].PD_State) |
2881				    DDF_PDE_ONLINE);
2882		}
2883	}
2884
2885	/* Mark spare and failed disks as such. */
2886	TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2887		pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
2888		i = ddf_meta_find_pd(gmeta, NULL,
2889		    GET32(&pd->pd_meta, pdd->PD_Reference));
2890		if (i < 0)
2891			continue;
2892		if (disk->d_state == G_RAID_DISK_S_FAILED) {
2893			SET16(gmeta, pdr->entry[i].PD_State,
2894			    GET16(gmeta, pdr->entry[i].PD_State) |
2895			    (DDF_PDE_FAILED | DDF_PDE_PFA));
2896		}
2897		if (disk->d_state != G_RAID_DISK_S_SPARE)
2898			continue;
2899		sa = ddf_meta_find_sa(&pd->pd_meta, 0);
2900		if (sa == NULL ||
2901		    (GET8D(&pd->pd_meta, sa->Spare_Type) &
2902		     DDF_SAR_TYPE_DEDICATED) == 0) {
2903			SET16(gmeta, pdr->entry[i].PD_Type,
2904			    GET16(gmeta, pdr->entry[i].PD_Type) |
2905			    DDF_PDE_GLOBAL_SPARE);
2906		} else {
2907			SET16(gmeta, pdr->entry[i].PD_Type,
2908			    GET16(gmeta, pdr->entry[i].PD_Type) |
2909			    DDF_PDE_CONFIG_SPARE);
2910		}
2911		SET16(gmeta, pdr->entry[i].PD_State,
2912		    GET16(gmeta, pdr->entry[i].PD_State) |
2913		    DDF_PDE_ONLINE);
2914	}
2915
2916	/* Remove disks without "participating" flag (unused). */
2917	for (i = 0, j = -1; i < GET16(gmeta, pdr->Populated_PDEs); i++) {
2918		if (isff(gmeta->pdr->entry[i].PD_GUID, 24))
2919			continue;
2920		if ((GET16(gmeta, pdr->entry[i].PD_Type) &
2921		    (DDF_PDE_PARTICIPATING |
2922		     DDF_PDE_GLOBAL_SPARE | DDF_PDE_CONFIG_SPARE)) != 0 ||
2923		    g_raid_md_ddf_get_disk(sc,
2924		     NULL, GET32(gmeta, pdr->entry[i].PD_Reference)) != NULL)
2925			j = i;
2926		else
2927			memset(&gmeta->pdr->entry[i], 0xff,
2928			    sizeof(struct ddf_pd_entry));
2929	}
2930	SET16(gmeta, pdr->Populated_PDEs, j + 1);
2931
2932	/* Update per-disk metadata and write them. */
2933	TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2934		pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
2935		if (disk->d_state != G_RAID_DISK_S_ACTIVE &&
2936		    disk->d_state != G_RAID_DISK_S_SPARE)
2937			continue;
2938		/* Update PDR. */
2939		memcpy(pd->pd_meta.pdr, gmeta->pdr,
2940		    GET32(&pd->pd_meta, hdr->pdr_length) *
2941		    pd->pd_meta.sectorsize);
2942		/* Update VDR. */
2943		SET16(&pd->pd_meta, vdr->Populated_VDEs, 0);
2944		TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2945			if (vol->v_stopping)
2946				continue;
2947			pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2948			i = ddf_meta_find_vd(&pd->pd_meta,
2949			    pv->pv_meta.vde->VD_GUID);
2950			if (i < 0)
2951				i = ddf_meta_find_vd(&pd->pd_meta, NULL);
2952			if (i >= 0)
2953				memcpy(&pd->pd_meta.vdr->entry[i],
2954				    pv->pv_meta.vde,
2955				    sizeof(struct ddf_vd_entry));
2956		}
2957		/* Update VDC. */
2958		if (mdi->mdio_starting == 0) {
2959			/* Remove all VDCs to restore needed later. */
2960			j = GETCRNUM(&pd->pd_meta);
2961			for (i = 0; i < j; i++) {
2962				vdc = GETVDCPTR(&pd->pd_meta, i);
2963				if (GET32D(&pd->pd_meta, vdc->Signature) !=
2964				    DDF_VDCR_SIGNATURE)
2965					continue;
2966				SET32D(&pd->pd_meta, vdc->Signature, 0xffffffff);
2967			}
2968		}
2969		TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
2970			vol = sd->sd_volume;
2971			if (vol->v_stopping)
2972				continue;
2973			pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2974			vmeta = &pv->pv_meta;
2975			vdc = ddf_meta_find_vdc(&pd->pd_meta,
2976			    vmeta->vde->VD_GUID);
2977			if (vdc == NULL)
2978				vdc = ddf_meta_find_vdc(&pd->pd_meta, NULL);
2979			if (vdc != NULL) {
2980				bvd = sd->sd_pos / GET16(vmeta,
2981				    vdc->Primary_Element_Count);
2982				memcpy(vdc, vmeta->bvdc[bvd],
2983				    GET16(&pd->pd_meta,
2984				    hdr->Configuration_Record_Length) *
2985				    pd->pd_meta.sectorsize);
2986			}
2987		}
2988		G_RAID_DEBUG(1, "Writing DDF metadata to %s",
2989		    g_raid_get_diskname(disk));
2990		g_raid_md_ddf_print(&pd->pd_meta);
2991		ddf_meta_write(disk->d_consumer, &pd->pd_meta);
2992	}
2993	return (0);
2994}
2995
2996static int
2997g_raid_md_fail_disk_ddf(struct g_raid_md_object *md,
2998    struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
2999{
3000	struct g_raid_softc *sc;
3001	struct g_raid_md_ddf_perdisk *pd;
3002	struct g_raid_subdisk *sd;
3003	int i;
3004
3005	sc = md->mdo_softc;
3006	pd = (struct g_raid_md_ddf_perdisk *)tdisk->d_md_data;
3007
3008	/* We can't fail disk that is not a part of array now. */
3009	if (tdisk->d_state != G_RAID_DISK_S_ACTIVE)
3010		return (-1);
3011
3012	/*
3013	 * Mark disk as failed in metadata and try to write that metadata
3014	 * to the disk itself to prevent it's later resurrection as STALE.
3015	 */
3016	G_RAID_DEBUG(1, "Writing DDF metadata to %s",
3017	    g_raid_get_diskname(tdisk));
3018	i = ddf_meta_find_pd(&pd->pd_meta, NULL, GET32(&pd->pd_meta, pdd->PD_Reference));
3019	SET16(&pd->pd_meta, pdr->entry[i].PD_State, DDF_PDE_FAILED | DDF_PDE_PFA);
3020	if (tdisk->d_consumer != NULL)
3021		ddf_meta_write(tdisk->d_consumer, &pd->pd_meta);
3022
3023	/* Change states. */
3024	g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED);
3025	TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) {
3026		g_raid_change_subdisk_state(sd,
3027		    G_RAID_SUBDISK_S_FAILED);
3028		g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED,
3029		    G_RAID_EVENT_SUBDISK);
3030	}
3031
3032	/* Write updated metadata to remaining disks. */
3033	g_raid_md_write_ddf(md, NULL, NULL, tdisk);
3034
3035	g_raid_md_ddf_refill(sc);
3036	return (0);
3037}
3038
3039static int
3040g_raid_md_free_disk_ddf(struct g_raid_md_object *md,
3041    struct g_raid_disk *disk)
3042{
3043	struct g_raid_md_ddf_perdisk *pd;
3044
3045	pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
3046	ddf_meta_free(&pd->pd_meta);
3047	free(pd, M_MD_DDF);
3048	disk->d_md_data = NULL;
3049	return (0);
3050}
3051
3052static int
3053g_raid_md_free_volume_ddf(struct g_raid_md_object *md,
3054    struct g_raid_volume *vol)
3055{
3056	struct g_raid_md_ddf_object *mdi;
3057	struct g_raid_md_ddf_pervolume *pv;
3058
3059	mdi = (struct g_raid_md_ddf_object *)md;
3060	pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
3061	ddf_vol_meta_free(&pv->pv_meta);
3062	if (!pv->pv_started) {
3063		pv->pv_started = 1;
3064		mdi->mdio_starting--;
3065		callout_stop(&pv->pv_start_co);
3066	}
3067	free(pv, M_MD_DDF);
3068	vol->v_md_data = NULL;
3069	return (0);
3070}
3071
3072static int
3073g_raid_md_free_ddf(struct g_raid_md_object *md)
3074{
3075	struct g_raid_md_ddf_object *mdi;
3076
3077	mdi = (struct g_raid_md_ddf_object *)md;
3078	if (!mdi->mdio_started) {
3079		mdi->mdio_started = 0;
3080		callout_stop(&mdi->mdio_start_co);
3081		G_RAID_DEBUG1(1, md->mdo_softc,
3082		    "root_mount_rel %p", mdi->mdio_rootmount);
3083		root_mount_rel(mdi->mdio_rootmount);
3084		mdi->mdio_rootmount = NULL;
3085	}
3086	ddf_meta_free(&mdi->mdio_meta);
3087	return (0);
3088}
3089
3090G_RAID_MD_DECLARE(ddf, "DDF");
3091