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