Lines Matching defs:meta
220 g_raid_md_ddf_print(struct ddf_meta *meta)
235 print_guid(meta->hdr->DDF_Header_GUID);
237 printf("DDF_rev %8.8s\n", (char *)&meta->hdr->DDF_rev[0]);
238 printf("Sequence_Number 0x%08x\n", GET32(meta, hdr->Sequence_Number));
239 printf("TimeStamp 0x%08x\n", GET32(meta, hdr->TimeStamp));
240 printf("Open_Flag 0x%02x\n", GET16(meta, hdr->Open_Flag));
241 printf("Foreign_Flag 0x%02x\n", GET16(meta, hdr->Foreign_Flag));
242 printf("Diskgrouping 0x%02x\n", GET16(meta, hdr->Diskgrouping));
243 printf("Primary_Header_LBA %ju\n", GET64(meta, hdr->Primary_Header_LBA));
244 printf("Secondary_Header_LBA %ju\n", GET64(meta, hdr->Secondary_Header_LBA));
245 printf("WorkSpace_Length %u\n", GET32(meta, hdr->WorkSpace_Length));
246 printf("WorkSpace_LBA %ju\n", GET64(meta, hdr->WorkSpace_LBA));
247 printf("Max_PD_Entries %u\n", GET16(meta, hdr->Max_PD_Entries));
248 printf("Max_VD_Entries %u\n", GET16(meta, hdr->Max_VD_Entries));
249 printf("Max_Partitions %u\n", GET16(meta, hdr->Max_Partitions));
250 printf("Configuration_Record_Length %u\n", GET16(meta, hdr->Configuration_Record_Length));
251 printf("Max_Primary_Element_Entries %u\n", GET16(meta, hdr->Max_Primary_Element_Entries));
252 printf("Controller Data %u:%u\n", GET32(meta, hdr->cd_section), GET32(meta, hdr->cd_length));
253 printf("Physical Disk %u:%u\n", GET32(meta, hdr->pdr_section), GET32(meta, hdr->pdr_length));
254 printf("Virtual Disk %u:%u\n", GET32(meta, hdr->vdr_section), GET32(meta, hdr->vdr_length));
255 printf("Configuration Recs %u:%u\n", GET32(meta, hdr->cr_section), GET32(meta, hdr->cr_length));
256 printf("Physical Disk Recs %u:%u\n", GET32(meta, hdr->pdd_section), GET32(meta, hdr->pdd_length));
257 printf("BBM Log %u:%u\n", GET32(meta, hdr->bbmlog_section), GET32(meta, hdr->bbmlog_length));
258 printf("Diagnostic Space %u:%u\n", GET32(meta, hdr->Diagnostic_Space), GET32(meta, hdr->Diagnostic_Space_Length));
259 printf("Vendor_Specific_Logs %u:%u\n", GET32(meta, hdr->Vendor_Specific_Logs), GET32(meta, hdr->Vendor_Specific_Logs_Length));
262 print_guid(meta->cdr->Controller_GUID);
265 GET16(meta, cdr->Controller_Type.Vendor_ID),
266 GET16(meta, cdr->Controller_Type.Device_ID),
267 GET16(meta, cdr->Controller_Type.SubVendor_ID),
268 GET16(meta, cdr->Controller_Type.SubDevice_ID));
269 printf("Product_ID '%.16s'\n", (char *)&meta->cdr->Product_ID[0]);
271 printf("Populated_PDEs %u\n", GET16(meta, pdr->Populated_PDEs));
272 printf("Max_PDE_Supported %u\n", GET16(meta, pdr->Max_PDE_Supported));
273 for (j = 0; j < GET16(meta, pdr->Populated_PDEs); j++) {
274 if (isff(meta->pdr->entry[j].PD_GUID, 24))
276 if (GET32(meta, pdr->entry[j].PD_Reference) == 0xffffffff)
279 print_guid(meta->pdr->entry[j].PD_GUID);
282 GET32(meta, pdr->entry[j].PD_Reference));
284 GET16(meta, pdr->entry[j].PD_Type));
286 GET16(meta, pdr->entry[j].PD_State));
288 GET64(meta, pdr->entry[j].Configured_Size));
290 GET16(meta, pdr->entry[j].Block_Size));
293 printf("Populated_VDEs %u\n", GET16(meta, vdr->Populated_VDEs));
294 printf("Max_VDE_Supported %u\n", GET16(meta, vdr->Max_VDE_Supported));
295 for (j = 0; j < GET16(meta, vdr->Populated_VDEs); j++) {
296 if (isff(meta->vdr->entry[j].VD_GUID, 24))
299 print_guid(meta->vdr->entry[j].VD_GUID);
302 GET16(meta, vdr->entry[j].VD_Number));
304 GET16(meta, vdr->entry[j].VD_Type));
306 GET8(meta, vdr->entry[j].VD_State));
308 GET8(meta, vdr->entry[j].Init_State));
310 GET8(meta, vdr->entry[j].Drive_Failures_Remaining));
312 (char *)&meta->vdr->entry[j].VD_Name);
315 num = GETCRNUM(meta);
317 vdc = GETVDCPTR(meta, j);
318 val = GET32D(meta, vdc->Signature);
326 GET32D(meta, vdc->Timestamp));
328 GET32D(meta, vdc->Sequence_Number));
330 GET16D(meta, vdc->Primary_Element_Count));
332 GET8D(meta, vdc->Stripe_Size));
334 GET8D(meta, vdc->Primary_RAID_Level));
336 GET8D(meta, vdc->RLQ));
338 GET8D(meta, vdc->Secondary_Element_Count));
340 GET8D(meta, vdc->Secondary_Element_Seq));
342 GET8D(meta, vdc->Secondary_RAID_Level));
344 GET64D(meta, vdc->Block_Count));
346 GET64D(meta, vdc->VD_Size));
348 GET16D(meta, vdc->Block_Size));
350 GET8D(meta, vdc->Rotate_Parity_count));
353 if (GET32D(meta, vdc->Associated_Spares[i]) != 0xffffffff)
354 printf(" 0x%08x", GET32D(meta, vdc->Associated_Spares[i]));
358 GET64D(meta, vdc->Cache_Flags));
360 GET8D(meta, vdc->BG_Rate));
362 GET8D(meta, vdc->MDF_Parity_Disks));
364 GET16D(meta, vdc->MDF_Parity_Generator_Polynomial));
366 GET8D(meta, vdc->MDF_Constant_Generation_Method));
368 num2 = GET16D(meta, vdc->Primary_Element_Count);
369 val2 = (uint64_t *)&(vdc->Physical_Disk_Sequence[GET16(meta, hdr->Max_Primary_Element_Entries)]);
372 GET32D(meta, vdc->Physical_Disk_Sequence[i]),
373 GET64P(meta, val2 + i));
387 GET32D(meta, sa->Timestamp));
389 GET8D(meta, sa->Spare_Type));
391 GET16D(meta, sa->Populated_SAEs));
393 GET16D(meta, sa->MAX_SAE_Supported));
394 for (i = 0; i < GET16D(meta, sa->Populated_SAEs); i++) {
402 GET16D(meta, sa->entry[i].Secondary_Element));
415 print_guid(meta->pdd->PD_GUID);
418 GET32(meta, pdd->PD_Reference));
420 GET8(meta, pdd->Forced_Ref_Flag));
422 GET8(meta, pdd->Forced_PD_GUID_Flag));
426 ddf_meta_find_pd(struct ddf_meta *meta, uint8_t *GUID, uint32_t PD_Reference)
430 for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
432 if (memcmp(meta->pdr->entry[i].PD_GUID, GUID, 24) == 0)
435 if (GET32(meta, pdr->entry[i].PD_Reference) == PD_Reference)
438 if (isff(meta->pdr->entry[i].PD_GUID, 24))
442 if (i >= GET16(meta, pdr->Max_PDE_Supported))
444 SET16(meta, pdr->Populated_PDEs, i + 1);
451 ddf_meta_find_vd(struct ddf_meta *meta, uint8_t *GUID)
455 for (i = 0; i < GET16(meta, vdr->Populated_VDEs); i++) {
457 if (memcmp(meta->vdr->entry[i].VD_GUID, GUID, 24) == 0)
460 if (isff(meta->vdr->entry[i].VD_GUID, 24))
464 if (i >= GET16(meta, vdr->Max_VDE_Supported))
466 SET16(meta, vdr->Populated_VDEs, i + 1);
473 ddf_meta_find_vdc(struct ddf_meta *meta, uint8_t *GUID)
478 num = GETCRNUM(meta);
480 vdc = GETVDCPTR(meta, i);
482 if (GET32D(meta, vdc->Signature) == DDF_VDCR_SIGNATURE &&
486 if (GET32D(meta, vdc->Signature) == 0xffffffff ||
487 GET32D(meta, vdc->Signature) == 0)
494 ddf_meta_count_vdc(struct ddf_meta *meta, uint8_t *GUID)
500 num = GETCRNUM(meta);
502 vdc = GETVDCPTR(meta, i);
503 if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
539 ddf_meta_find_sa(struct ddf_meta *meta, int create)
544 num = GETCRNUM(meta);
546 sa = GETSAPTR(meta, i);
547 if (GET32D(meta, sa->Signature) == DDF_SA_SIGNATURE)
552 sa = GETSAPTR(meta, i);
553 if (GET32D(meta, sa->Signature) == 0xffffffff ||
554 GET32D(meta, sa->Signature) == 0)
568 struct ddf_meta *meta;
580 meta = &pd->pd_meta;
584 meta->sectorsize = ss;
585 meta->bigendian = sample ? sample->bigendian : mdi->mdio_bigendian;
590 meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
591 memset(meta->hdr, 0xff, ss);
593 memcpy(meta->hdr, sample->hdr, sizeof(struct ddf_header));
595 SET32(meta, hdr->WorkSpace_Length,
598 SET16(meta, hdr->Configuration_Record_Length,
601 SET32(meta, hdr->cd_length,
604 SET32(meta, hdr->pdr_length,
607 SET32(meta, hdr->vdr_length,
610 SET32(meta, hdr->cr_length,
613 SET32(meta, hdr->pdd_length,
616 SET32(meta, hdr->bbmlog_length,
619 SET32(meta, hdr->Diagnostic_Space,
622 SET32(meta, hdr->Vendor_Specific_Logs,
627 SET32(meta, hdr->Signature, DDF_HEADER_SIGNATURE);
628 snprintf(meta->hdr->DDF_Header_GUID, 25, "FreeBSD %08x%08x",
630 memcpy(meta->hdr->DDF_rev, "02.00.00", 8);
631 SET32(meta, hdr->TimeStamp, (ts.tv_sec - DECADE));
632 SET32(meta, hdr->WorkSpace_Length, 16 * 1024 * 1024 / ss);
633 SET16(meta, hdr->Max_PD_Entries, DDF_MAX_DISKS - 1);
634 SET16(meta, hdr->Max_VD_Entries, DDF_MAX_VDISKS);
635 SET16(meta, hdr->Max_Partitions, DDF_MAX_PARTITIONS);
636 SET16(meta, hdr->Max_Primary_Element_Entries, DDF_MAX_DISKS);
637 SET16(meta, hdr->Configuration_Record_Length,
639 (4 + 8) * GET16(meta, hdr->Max_Primary_Element_Entries) +
641 SET32(meta, hdr->cd_length,
643 SET32(meta, hdr->pdr_length,
646 GET16(meta, hdr->Max_PD_Entries) + ss - 1) / ss);
647 SET32(meta, hdr->vdr_length,
650 GET16(meta, hdr->Max_VD_Entries) + ss - 1) / ss);
651 SET32(meta, hdr->cr_length,
652 GET16(meta, hdr->Configuration_Record_Length) *
653 (GET16(meta, hdr->Max_Partitions) + 1));
654 SET32(meta, hdr->pdd_length,
656 SET32(meta, hdr->bbmlog_length, 0);
657 SET32(meta, hdr->Diagnostic_Space_Length, 0);
658 SET32(meta, hdr->Vendor_Specific_Logs_Length, 0);
661 SET32(meta, hdr->cd_section, pos);
662 pos += GET32(meta, hdr->cd_length);
663 SET32(meta, hdr->pdr_section, pos);
664 pos += GET32(meta, hdr->pdr_length);
665 SET32(meta, hdr->vdr_section, pos);
666 pos += GET32(meta, hdr->vdr_length);
667 SET32(meta, hdr->cr_section, pos);
668 pos += GET32(meta, hdr->cr_length);
669 SET32(meta, hdr->pdd_section, pos);
670 pos += GET32(meta, hdr->pdd_length);
671 SET32(meta, hdr->bbmlog_section,
672 GET32(meta, hdr->bbmlog_length) != 0 ? pos : 0xffffffff);
673 pos += GET32(meta, hdr->bbmlog_length);
674 SET32(meta, hdr->Diagnostic_Space,
675 GET32(meta, hdr->Diagnostic_Space_Length) != 0 ? pos : 0xffffffff);
676 pos += GET32(meta, hdr->Diagnostic_Space_Length);
677 SET32(meta, hdr->Vendor_Specific_Logs,
678 GET32(meta, hdr->Vendor_Specific_Logs_Length) != 0 ? pos : 0xffffffff);
679 pos += min(GET32(meta, hdr->Vendor_Specific_Logs_Length), 1);
680 SET64(meta, hdr->Primary_Header_LBA,
682 SET64(meta, hdr->Secondary_Header_LBA,
684 SET64(meta, hdr->WorkSpace_LBA,
688 size = GET32(meta, hdr->cd_length) * ss;
689 meta->cdr = malloc(size, M_MD_DDF, M_WAITOK);
690 memset(meta->cdr, 0xff, size);
691 SET32(meta, cdr->Signature, DDF_CONTROLLER_DATA_SIGNATURE);
692 memcpy(meta->cdr->Controller_GUID, "FreeBSD GEOM RAID SERIAL", 24);
693 memcpy(meta->cdr->Product_ID, "FreeBSD GEOMRAID", 16);
696 size = GET32(meta, hdr->pdr_length) * ss;
697 meta->pdr = malloc(size, M_MD_DDF, M_WAITOK);
698 memset(meta->pdr, 0xff, size);
699 SET32(meta, pdr->Signature, DDF_PDR_SIGNATURE);
700 SET16(meta, pdr->Populated_PDEs, 1);
701 SET16(meta, pdr->Max_PDE_Supported,
702 GET16(meta, hdr->Max_PD_Entries));
704 pde = &meta->pdr->entry[0];
713 SET32D(meta, pde->PD_Reference, arc4random());
714 SET16D(meta, pde->PD_Type, DDF_PDE_GUID_FORCE);
715 SET16D(meta, pde->PD_State, 0);
716 SET64D(meta, pde->Configured_Size,
718 SET16D(meta, pde->Block_Size, ss);
721 size = GET32(meta, hdr->vdr_length) * ss;
722 meta->vdr = malloc(size, M_MD_DDF, M_WAITOK);
723 memset(meta->vdr, 0xff, size);
724 SET32(meta, vdr->Signature, DDF_VD_RECORD_SIGNATURE);
725 SET32(meta, vdr->Populated_VDEs, 0);
726 SET16(meta, vdr->Max_VDE_Supported,
727 GET16(meta, hdr->Max_VD_Entries));
730 size = GET32(meta, hdr->cr_length) * ss;
731 meta->cr = malloc(size, M_MD_DDF, M_WAITOK);
732 memset(meta->cr, 0xff, size);
735 size = GET32(meta, hdr->pdd_length) * ss;
736 meta->pdd = malloc(size, M_MD_DDF, M_WAITOK);
737 memset(meta->pdd, 0xff, size);
738 SET32(meta, pdd->Signature, DDF_PDD_SIGNATURE);
739 memcpy(meta->pdd->PD_GUID, pde->PD_GUID, 24);
740 SET32(meta, pdd->PD_Reference, GET32D(meta, pde->PD_Reference));
741 SET8(meta, pdd->Forced_Ref_Flag, DDF_PDD_FORCED_REF);
742 SET8(meta, pdd->Forced_PD_GUID_Flag, DDF_PDD_FORCED_GUID);
745 if (GET32(meta, hdr->bbmlog_length) != 0) {
746 size = GET32(meta, hdr->bbmlog_length) * ss;
747 meta->bbm = malloc(size, M_MD_DDF, M_WAITOK);
748 memset(meta->bbm, 0xff, size);
749 SET32(meta, bbm->Signature, DDF_BBML_SIGNATURE);
750 SET32(meta, bbm->Entry_Count, 0);
751 SET32(meta, bbm->Spare_Block_Count, 0);
783 ddf_meta_update(struct ddf_meta *meta, struct ddf_meta *src)
792 j = ddf_meta_find_pd(meta, NULL,
795 j = ddf_meta_find_pd(meta, NULL, 0xffffffff);
796 pde = &meta->pdr->entry[j];
799 pde = &meta->pdr->entry[j];
800 SET16D(meta, pde->PD_State,
801 GET16D(meta, pde->PD_State) |
808 ddf_meta_free(struct ddf_meta *meta)
811 if (meta->hdr != NULL) {
812 free(meta->hdr, M_MD_DDF);
813 meta->hdr = NULL;
815 if (meta->cdr != NULL) {
816 free(meta->cdr, M_MD_DDF);
817 meta->cdr = NULL;
819 if (meta->pdr != NULL) {
820 free(meta->pdr, M_MD_DDF);
821 meta->pdr = NULL;
823 if (meta->vdr != NULL) {
824 free(meta->vdr, M_MD_DDF);
825 meta->vdr = NULL;
827 if (meta->cr != NULL) {
828 free(meta->cr, M_MD_DDF);
829 meta->cr = NULL;
831 if (meta->pdd != NULL) {
832 free(meta->pdd, M_MD_DDF);
833 meta->pdd = NULL;
835 if (meta->bbm != NULL) {
836 free(meta->bbm, M_MD_DDF);
837 meta->bbm = NULL;
842 ddf_vol_meta_create(struct ddf_vol_meta *meta, struct ddf_meta *sample)
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));
860 snprintf(meta->vde->VD_GUID, 25, "FreeBSD%04d%02d%02d%08x%01x",
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);
933 ddf_vol_meta_free(struct ddf_vol_meta *meta)
937 if (meta->hdr != NULL) {
938 free(meta->hdr, M_MD_DDF);
939 meta->hdr = NULL;
941 if (meta->cdr != NULL) {
942 free(meta->cdr, M_MD_DDF);
943 meta->cdr = NULL;
945 if (meta->vde != NULL) {
946 free(meta->vde, M_MD_DDF);
947 meta->vde = NULL;
949 if (meta->vdc != NULL) {
950 free(meta->vdc, M_MD_DDF);
951 meta->vdc = NULL;
954 if (meta->bvdc[i] != NULL) {
955 free(meta->bvdc[i], M_MD_DDF);
956 meta->bvdc[i] = NULL;
962 ddf_meta_unused_range(struct ddf_meta *meta, off_t *off, off_t *size)
972 ref = GET32(meta, pdd->PD_Reference);
973 pos = ddf_meta_find_pd(meta, NULL, ref);
975 end[0] = GET64(meta, pdr->entry[pos].Configured_Size);
977 num = GETCRNUM(meta);
979 vdc = GETVDCPTR(meta, i);
980 if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
982 for (pos = 0; pos < GET16D(meta, vdc->Primary_Element_Count); pos++)
983 if (GET32D(meta, vdc->Physical_Disk_Sequence[pos]) == ref)
985 if (pos == GET16D(meta, vdc->Primary_Element_Count))
988 GET16(meta, hdr->Max_Primary_Element_Entries)]);
989 beg1 = GET64P(meta, offp + pos);
990 end1 = beg1 + GET64D(meta, vdc->Block_Count);
1015 ddf_meta_get_name(struct ddf_meta *meta, int num, char *buf)
1020 b = meta->vdr->entry[num].VD_Name;
1029 ddf_meta_put_name(struct ddf_vol_meta *meta, char *buf)
1034 memset(meta->vde->VD_Name, 0x20, 16);
1035 memcpy(meta->vde->VD_Name, buf, len);
1039 ddf_meta_read(struct g_consumer *cp, struct ddf_meta *meta)
1049 ddf_meta_free(meta);
1051 ss = meta->sectorsize = pp->sectorsize;
1063 meta->bigendian = 1;
1065 meta->bigendian = 0;
1076 meta->hdr = ahdr;
1077 plba = GET64(meta, hdr->Primary_Header_LBA);
1078 slba = GET64(meta, hdr->Secondary_Header_LBA);
1079 val = GET32(meta, hdr->CRC);
1080 SET32(meta, hdr->CRC, 0xffffffff);
1081 meta->hdr = NULL;
1101 ddf_meta_free(meta);
1116 meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
1117 memcpy(meta->hdr, buf, ss);
1119 hdr = meta->hdr;
1120 val = GET32(meta, hdr->CRC);
1121 SET32(meta, hdr->CRC, 0xffffffff);
1123 crc32(meta->hdr, ss) != val ||
1125 GET64(meta, hdr->Primary_Header_LBA) != plba ||
1126 GET64(meta, hdr->Secondary_Header_LBA) != slba) {
1142 len = max(len, GET32(meta, hdr->cd_section) + GET32(meta, hdr->cd_length));
1143 len = max(len, GET32(meta, hdr->pdr_section) + GET32(meta, hdr->pdr_length));
1144 len = max(len, GET32(meta, hdr->vdr_section) + GET32(meta, hdr->vdr_length));
1145 len = max(len, GET32(meta, hdr->cr_section) + GET32(meta, hdr->cr_length));
1146 len = max(len, GET32(meta, hdr->pdd_section) + GET32(meta, hdr->pdd_length));
1147 if ((val = GET32(meta, hdr->bbmlog_section)) != 0xffffffff)
1148 len = max(len, val + GET32(meta, hdr->bbmlog_length));
1149 if ((val = GET32(meta, hdr->Diagnostic_Space)) != 0xffffffff)
1150 len = max(len, val + GET32(meta, hdr->Diagnostic_Space_Length));
1151 if ((val = GET32(meta, hdr->Vendor_Specific_Logs)) != 0xffffffff)
1152 len = max(len, val + GET32(meta, hdr->Vendor_Specific_Logs_Length));
1158 if (GET16(meta, hdr->Max_Primary_Element_Entries) == 0xffff) {
1159 SET16(meta, hdr->Max_Primary_Element_Entries,
1160 min(GET16(meta, hdr->Max_PD_Entries),
1161 (GET16(meta, hdr->Configuration_Record_Length) * ss - 512) / 12));
1165 buf = g_read_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
1166 GET32(meta, hdr->cd_length) * ss, &error);
1169 meta->cdr = malloc(GET32(meta, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
1170 memcpy(meta->cdr, buf, GET32(meta, hdr->cd_length) * ss);
1172 if (GET32(meta, cdr->Signature) != DDF_CONTROLLER_DATA_SIGNATURE)
1176 buf = g_read_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
1177 GET32(meta, hdr->pdr_length) * ss, &error);
1180 meta->pdr = malloc(GET32(meta, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
1181 memcpy(meta->pdr, buf, GET32(meta, hdr->pdr_length) * ss);
1183 if (GET32(meta, pdr->Signature) != DDF_PDR_SIGNATURE)
1189 if (meta->bigendian) {
1190 for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
1191 if (isff(meta->pdr->entry[i].PD_GUID, 24))
1193 if (GET32(meta, pdr->entry[i].PD_Reference) ==
1196 if (GET64(meta, pdr->entry[i].Configured_Size) >=
1198 SET16(meta, pdr->entry[i].PD_State,
1199 GET16(meta, pdr->entry[i].PD_State) &
1201 SET64(meta, pdr->entry[i].Configured_Size,
1202 GET64(meta, pdr->entry[i].Configured_Size) &
1209 buf = g_read_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
1210 GET32(meta, hdr->vdr_length) * ss, &error);
1213 meta->vdr = malloc(GET32(meta, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
1214 memcpy(meta->vdr, buf, GET32(meta, hdr->vdr_length) * ss);
1216 if (GET32(meta, vdr->Signature) != DDF_VD_RECORD_SIGNATURE)
1220 buf = g_read_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
1221 GET32(meta, hdr->cr_length) * ss, &error);
1224 meta->cr = malloc(GET32(meta, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
1225 memcpy(meta->cr, buf, GET32(meta, hdr->cr_length) * ss);
1229 buf = g_read_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
1230 GET32(meta, hdr->pdd_length) * ss, &error);
1233 meta->pdd = malloc(GET32(meta, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
1234 memcpy(meta->pdd, buf, GET32(meta, hdr->pdd_length) * ss);
1236 if (GET32(meta, pdd->Signature) != DDF_PDD_SIGNATURE)
1238 i = ddf_meta_find_pd(meta, NULL, GET32(meta, pdd->PD_Reference));
1243 if (GET32(meta, hdr->bbmlog_section) != 0xffffffff &&
1244 GET32(meta, hdr->bbmlog_length) != 0) {
1245 buf = g_read_data(cp, (lba + GET32(meta, hdr->bbmlog_section)) * ss,
1246 GET32(meta, hdr->bbmlog_length) * ss, &error);
1249 meta->bbm = malloc(GET32(meta, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
1250 memcpy(meta->bbm, buf, GET32(meta, hdr->bbmlog_length) * ss);
1252 if (GET32(meta, bbm->Signature) != DDF_BBML_SIGNATURE)
1259 ddf_meta_free(meta);
1264 ddf_meta_write(struct g_consumer *cp, struct ddf_meta *meta)
1275 plba = GET64(meta, hdr->Primary_Header_LBA);
1276 slba = GET64(meta, hdr->Secondary_Header_LBA);
1279 SET8(meta, hdr->Header_Type, (lba == alba) ? DDF_HEADER_ANCHOR :
1281 SET32(meta, hdr->CRC, 0xffffffff);
1282 SET32(meta, hdr->CRC, crc32(meta->hdr, ss));
1283 error = g_write_data(cp, lba * ss, meta->hdr, ss);
1296 size = GET32(meta, hdr->cd_length) * ss;
1297 SET32(meta, cdr->CRC, 0xffffffff);
1298 SET32(meta, cdr->CRC, crc32(meta->cdr, size));
1299 error = g_write_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
1300 meta->cdr, size);
1304 size = GET32(meta, hdr->pdr_length) * ss;
1305 SET32(meta, pdr->CRC, 0xffffffff);
1306 SET32(meta, pdr->CRC, crc32(meta->pdr, size));
1307 error = g_write_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
1308 meta->pdr, size);
1312 size = GET32(meta, hdr->vdr_length) * ss;
1313 SET32(meta, vdr->CRC, 0xffffffff);
1314 SET32(meta, vdr->CRC, crc32(meta->vdr, size));
1315 error = g_write_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
1316 meta->vdr, size);
1320 size = GET16(meta, hdr->Configuration_Record_Length) * ss;
1321 num = GETCRNUM(meta);
1323 vdc = GETVDCPTR(meta, i);
1324 SET32D(meta, vdc->CRC, 0xffffffff);
1325 SET32D(meta, vdc->CRC, crc32(vdc, size));
1327 error = g_write_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
1328 meta->cr, size * num);
1332 size = GET32(meta, hdr->pdd_length) * ss;
1333 SET32(meta, pdd->CRC, 0xffffffff);
1334 SET32(meta, pdd->CRC, crc32(meta->pdd, size));
1335 error = g_write_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
1336 meta->pdd, size);
1340 if (GET32(meta, hdr->bbmlog_length) != 0) {
1341 size = GET32(meta, hdr->bbmlog_length) * ss;
1342 SET32(meta, bbm->CRC, 0xffffffff);
1343 SET32(meta, bbm->CRC, crc32(meta->bbm, size));
1345 (lba + GET32(meta, hdr->bbmlog_section)) * ss,
1346 meta->bbm, size);
1398 struct ddf_meta *meta;
1402 meta = &pd->pd_meta;
1404 if (memcmp(meta->pdd->PD_GUID, GUID, 24) == 0)
1407 if (GET32(meta, pdd->PD_Reference) == id)
2111 struct ddf_meta meta;
2124 bzero(&meta, sizeof(meta));
2125 error = ddf_meta_read(cp, &meta);
2129 be = meta.bigendian;
2132 g_raid_md_ddf_print(&meta);
2177 pd->pd_meta = meta;