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