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