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 47 static 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 57 struct 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 69 struct 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 79 struct g_raid_md_ddf_perdisk { 80 struct ddf_meta pd_meta; 81 }; 82 83 struct 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 89 struct 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 99 static g_raid_md_create_req_t g_raid_md_create_req_ddf; 100 static g_raid_md_taste_t g_raid_md_taste_ddf; 101 static g_raid_md_event_t g_raid_md_event_ddf; 102 static g_raid_md_volume_event_t g_raid_md_volume_event_ddf; 103 static g_raid_md_ctl_t g_raid_md_ctl_ddf; 104 static g_raid_md_write_t g_raid_md_write_ddf; 105 static g_raid_md_fail_disk_t g_raid_md_fail_disk_ddf; 106 static g_raid_md_free_disk_t g_raid_md_free_disk_ddf; 107 static g_raid_md_free_volume_t g_raid_md_free_volume_ddf; 108 static g_raid_md_free_t g_raid_md_free_ddf; 109 110 static 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 124 static 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 188 static int 189 isff(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 199 static void 200 print_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 219 static void 220 g_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("**** Controler 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 425 static int 426 ddf_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 450 static int 451 ddf_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 472 static struct ddf_vdc_record * 473 ddf_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 493 static int 494 ddf_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 511 static int 512 ddf_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 < GET16(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 538 static struct ddf_sa_record * 539 ddf_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 561 static void 562 ddf_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 (GET32(sample, hdr->WorkSpace_Length) * 597 sample->sectorsize + ss - 1) / ss); 598 SET16(meta, hdr->Configuration_Record_Length, 599 (GET16(sample, hdr->Configuration_Record_Length) * 600 sample->sectorsize + ss - 1) / ss); 601 SET32(meta, hdr->cd_length, 602 (GET32(sample, hdr->cd_length) * 603 sample->sectorsize + ss - 1) / ss); 604 SET32(meta, hdr->pdr_length, 605 (GET32(sample, hdr->pdr_length) * 606 sample->sectorsize + ss - 1) / ss); 607 SET32(meta, hdr->vdr_length, 608 (GET32(sample, hdr->vdr_length) * 609 sample->sectorsize + ss - 1) / ss); 610 SET32(meta, hdr->cr_length, 611 (GET32(sample, hdr->cr_length) * 612 sample->sectorsize + ss - 1) / ss); 613 SET32(meta, hdr->pdd_length, 614 (GET32(sample, hdr->pdd_length) * 615 sample->sectorsize + ss - 1) / ss); 616 SET32(meta, hdr->bbmlog_length, 617 (GET32(sample, hdr->bbmlog_length) * 618 sample->sectorsize + ss - 1) / ss); 619 SET32(meta, hdr->Diagnostic_Space, 620 (GET32(sample, hdr->bbmlog_length) * 621 sample->sectorsize + ss - 1) / ss); 622 SET32(meta, hdr->Vendor_Specific_Logs, 623 (GET32(sample, hdr->bbmlog_length) * 624 sample->sectorsize + ss - 1) / ss); 625 } 626 } else { 627 SET32(meta, hdr->Signature, DDF_HEADER_SIGNATURE); 628 snprintf(meta->hdr->DDF_Header_GUID, 25, "FreeBSD %08x%08x", 629 (u_int)(ts.tv_sec - DECADE), arc4random()); 630 memcpy(meta->hdr->DDF_rev, "02.00.00", 8); 631 SET32(meta, hdr->TimeStamp, (ts.tv_sec - DECADE)); 632 SET32(meta, hdr->WorkSpace_Length, 16 * 1024 * 1024 / ss); 633 SET16(meta, hdr->Max_PD_Entries, DDF_MAX_DISKS - 1); 634 SET16(meta, hdr->Max_VD_Entries, DDF_MAX_VDISKS); 635 SET16(meta, hdr->Max_Partitions, DDF_MAX_PARTITIONS); 636 SET16(meta, hdr->Max_Primary_Element_Entries, DDF_MAX_DISKS); 637 SET16(meta, hdr->Configuration_Record_Length, 638 (sizeof(struct ddf_vdc_record) + 639 (4 + 8) * GET16(meta, hdr->Max_Primary_Element_Entries) + 640 ss - 1) / ss); 641 SET32(meta, hdr->cd_length, 642 (sizeof(struct ddf_cd_record) + ss - 1) / ss); 643 SET32(meta, hdr->pdr_length, 644 (sizeof(struct ddf_pd_record) + 645 sizeof(struct ddf_pd_entry) * 646 GET16(meta, hdr->Max_PD_Entries) + ss - 1) / ss); 647 SET32(meta, hdr->vdr_length, 648 (sizeof(struct ddf_vd_record) + 649 sizeof(struct ddf_vd_entry) * 650 GET16(meta, hdr->Max_VD_Entries) + ss - 1) / ss); 651 SET32(meta, hdr->cr_length, 652 GET16(meta, hdr->Configuration_Record_Length) * 653 (GET16(meta, hdr->Max_Partitions) + 1)); 654 SET32(meta, hdr->pdd_length, 655 (sizeof(struct ddf_pdd_record) + ss - 1) / 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 755 static void 756 ddf_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 782 static void 783 ddf_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 807 static void 808 ddf_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 841 static void 842 ddf_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 871 static void 872 ddf_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 bvd = GET8D(src, vdc->Secondary_Element_Seq); 885 size = GET16(src, hdr->Configuration_Record_Length) * src->sectorsize; 886 887 if (dst->vdc == NULL || 888 (!started && ((int32_t)(GET32D(src, vdc->Sequence_Number) - 889 GET32(dst, vdc->Sequence_Number))) > 0)) 890 vnew = 1; 891 else 892 vnew = 0; 893 894 if (dst->bvdc[bvd] == NULL || 895 (!started && ((int32_t)(GET32D(src, vdc->Sequence_Number) - 896 GET32(dst, bvdc[bvd]->Sequence_Number))) > 0)) 897 bvnew = 1; 898 else 899 bvnew = 0; 900 901 if (vnew) { 902 dst->bigendian = src->bigendian; 903 ss = dst->sectorsize = src->sectorsize; 904 if (dst->hdr != NULL) 905 free(dst->hdr, M_MD_DDF); 906 dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK); 907 memcpy(dst->hdr, src->hdr, ss); 908 if (dst->cdr != NULL) 909 free(dst->cdr, M_MD_DDF); 910 dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK); 911 memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss); 912 if (dst->vde != NULL) 913 free(dst->vde, M_MD_DDF); 914 dst->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK); 915 memcpy(dst->vde, vde, sizeof(struct ddf_vd_entry)); 916 if (dst->vdc != NULL) 917 free(dst->vdc, M_MD_DDF); 918 dst->vdc = malloc(size, M_MD_DDF, M_WAITOK); 919 memcpy(dst->vdc, vdc, size); 920 } 921 if (bvnew) { 922 if (dst->bvdc[bvd] != NULL) 923 free(dst->bvdc[bvd], M_MD_DDF); 924 dst->bvdc[bvd] = malloc(size, M_MD_DDF, M_WAITOK); 925 memcpy(dst->bvdc[bvd], vdc, size); 926 } 927 } 928 929 static void 930 ddf_vol_meta_free(struct ddf_vol_meta *meta) 931 { 932 int i; 933 934 if (meta->hdr != NULL) { 935 free(meta->hdr, M_MD_DDF); 936 meta->hdr = NULL; 937 } 938 if (meta->cdr != NULL) { 939 free(meta->cdr, M_MD_DDF); 940 meta->cdr = NULL; 941 } 942 if (meta->vde != NULL) { 943 free(meta->vde, M_MD_DDF); 944 meta->vde = NULL; 945 } 946 if (meta->vdc != NULL) { 947 free(meta->vdc, M_MD_DDF); 948 meta->vdc = NULL; 949 } 950 for (i = 0; i < DDF_MAX_DISKS_HARD; i++) { 951 if (meta->bvdc[i] != NULL) { 952 free(meta->bvdc[i], M_MD_DDF); 953 meta->bvdc[i] = NULL; 954 } 955 } 956 } 957 958 static int 959 ddf_meta_unused_range(struct ddf_meta *meta, off_t *off, off_t *size) 960 { 961 struct ddf_vdc_record *vdc; 962 off_t beg[32], end[32], beg1, end1; 963 uint64_t *offp; 964 int i, j, n, num, pos; 965 uint32_t ref; 966 967 *off = 0; 968 *size = 0; 969 ref = GET32(meta, pdd->PD_Reference); 970 pos = ddf_meta_find_pd(meta, NULL, ref); 971 beg[0] = 0; 972 end[0] = GET64(meta, pdr->entry[pos].Configured_Size); 973 n = 1; 974 num = GETCRNUM(meta); 975 for (i = 0; i < num; i++) { 976 vdc = GETVDCPTR(meta, i); 977 if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE) 978 continue; 979 for (pos = 0; pos < GET16D(meta, vdc->Primary_Element_Count); pos++) 980 if (GET32D(meta, vdc->Physical_Disk_Sequence[pos]) == ref) 981 break; 982 if (pos == GET16D(meta, vdc->Primary_Element_Count)) 983 continue; 984 offp = (uint64_t *)&(vdc->Physical_Disk_Sequence[ 985 GET16(meta, hdr->Max_Primary_Element_Entries)]); 986 beg1 = GET64P(meta, offp + pos); 987 end1 = beg1 + GET64D(meta, vdc->Block_Count); 988 for (j = 0; j < n; j++) { 989 if (beg[j] >= end1 || end[j] <= beg1 ) 990 continue; 991 if (beg[j] < beg1 && end[j] > end1) { 992 beg[n] = end1; 993 end[n] = end[j]; 994 end[j] = beg1; 995 n++; 996 } else if (beg[j] < beg1) 997 end[j] = beg1; 998 else 999 beg[j] = end1; 1000 } 1001 } 1002 for (j = 0; j < n; j++) { 1003 if (end[j] - beg[j] > *size) { 1004 *off = beg[j]; 1005 *size = end[j] - beg[j]; 1006 } 1007 } 1008 return ((*size > 0) ? 1 : 0); 1009 } 1010 1011 static void 1012 ddf_meta_get_name(struct ddf_meta *meta, int num, char *buf) 1013 { 1014 const char *b; 1015 int i; 1016 1017 b = meta->vdr->entry[num].VD_Name; 1018 for (i = 15; i >= 0; i--) 1019 if (b[i] != 0x20) 1020 break; 1021 memcpy(buf, b, i + 1); 1022 buf[i + 1] = 0; 1023 } 1024 1025 static void 1026 ddf_meta_put_name(struct ddf_vol_meta *meta, char *buf) 1027 { 1028 int len; 1029 1030 len = min(strlen(buf), 16); 1031 memset(meta->vde->VD_Name, 0x20, 16); 1032 memcpy(meta->vde->VD_Name, buf, len); 1033 } 1034 1035 static int 1036 ddf_meta_read(struct g_consumer *cp, struct ddf_meta *meta) 1037 { 1038 struct g_provider *pp; 1039 struct ddf_header *ahdr, *hdr; 1040 char *abuf, *buf; 1041 off_t plba, slba, lba; 1042 int error, len, i; 1043 u_int ss; 1044 uint32_t val; 1045 1046 ddf_meta_free(meta); 1047 pp = cp->provider; 1048 ss = meta->sectorsize = pp->sectorsize; 1049 /* Read anchor block. */ 1050 abuf = g_read_data(cp, pp->mediasize - ss, ss, &error); 1051 if (abuf == NULL) { 1052 G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).", 1053 pp->name, error); 1054 return (error); 1055 } 1056 ahdr = (struct ddf_header *)abuf; 1057 1058 /* Check if this is an DDF RAID struct */ 1059 if (be32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE) 1060 meta->bigendian = 1; 1061 else if (le32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE) 1062 meta->bigendian = 0; 1063 else { 1064 G_RAID_DEBUG(1, "DDF signature check failed on %s", pp->name); 1065 error = EINVAL; 1066 goto done; 1067 } 1068 if (ahdr->Header_Type != DDF_HEADER_ANCHOR) { 1069 G_RAID_DEBUG(1, "DDF header type check failed on %s", pp->name); 1070 error = EINVAL; 1071 goto done; 1072 } 1073 meta->hdr = ahdr; 1074 plba = GET64(meta, hdr->Primary_Header_LBA); 1075 slba = GET64(meta, hdr->Secondary_Header_LBA); 1076 val = GET32(meta, hdr->CRC); 1077 SET32(meta, hdr->CRC, 0xffffffff); 1078 meta->hdr = NULL; 1079 if (crc32(ahdr, ss) != val) { 1080 G_RAID_DEBUG(1, "DDF CRC mismatch on %s", pp->name); 1081 error = EINVAL; 1082 goto done; 1083 } 1084 if ((plba + 6) * ss >= pp->mediasize) { 1085 G_RAID_DEBUG(1, "DDF primary header LBA is wrong on %s", pp->name); 1086 error = EINVAL; 1087 goto done; 1088 } 1089 if (slba != -1 && (slba + 6) * ss >= pp->mediasize) { 1090 G_RAID_DEBUG(1, "DDF secondary header LBA is wrong on %s", pp->name); 1091 error = EINVAL; 1092 goto done; 1093 } 1094 lba = plba; 1095 1096 doread: 1097 error = 0; 1098 ddf_meta_free(meta); 1099 1100 /* Read header block. */ 1101 buf = g_read_data(cp, lba * ss, ss, &error); 1102 if (buf == NULL) { 1103 readerror: 1104 G_RAID_DEBUG(1, "DDF %s metadata read error on %s (error=%d).", 1105 (lba == plba) ? "primary" : "secondary", pp->name, error); 1106 if (lba == plba && slba != -1) { 1107 lba = slba; 1108 goto doread; 1109 } 1110 G_RAID_DEBUG(1, "DDF metadata read error on %s.", pp->name); 1111 goto done; 1112 } 1113 meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK); 1114 memcpy(meta->hdr, buf, ss); 1115 g_free(buf); 1116 hdr = meta->hdr; 1117 val = GET32(meta, hdr->CRC); 1118 SET32(meta, hdr->CRC, 0xffffffff); 1119 if (hdr->Signature != ahdr->Signature || 1120 crc32(meta->hdr, ss) != val || 1121 memcmp(hdr->DDF_Header_GUID, ahdr->DDF_Header_GUID, 24) || 1122 GET64(meta, hdr->Primary_Header_LBA) != plba || 1123 GET64(meta, hdr->Secondary_Header_LBA) != slba) { 1124 hdrerror: 1125 G_RAID_DEBUG(1, "DDF %s metadata check failed on %s", 1126 (lba == plba) ? "primary" : "secondary", pp->name); 1127 if (lba == plba && slba != -1) { 1128 lba = slba; 1129 goto doread; 1130 } 1131 G_RAID_DEBUG(1, "DDF metadata check failed on %s", pp->name); 1132 error = EINVAL; 1133 goto done; 1134 } 1135 if ((lba == plba && hdr->Header_Type != DDF_HEADER_PRIMARY) || 1136 (lba == slba && hdr->Header_Type != DDF_HEADER_SECONDARY)) 1137 goto hdrerror; 1138 len = 1; 1139 len = max(len, GET32(meta, hdr->cd_section) + GET32(meta, hdr->cd_length)); 1140 len = max(len, GET32(meta, hdr->pdr_section) + GET32(meta, hdr->pdr_length)); 1141 len = max(len, GET32(meta, hdr->vdr_section) + GET32(meta, hdr->vdr_length)); 1142 len = max(len, GET32(meta, hdr->cr_section) + GET32(meta, hdr->cr_length)); 1143 len = max(len, GET32(meta, hdr->pdd_section) + GET32(meta, hdr->pdd_length)); 1144 if ((val = GET32(meta, hdr->bbmlog_section)) != 0xffffffff) 1145 len = max(len, val + GET32(meta, hdr->bbmlog_length)); 1146 if ((val = GET32(meta, hdr->Diagnostic_Space)) != 0xffffffff) 1147 len = max(len, val + GET32(meta, hdr->Diagnostic_Space_Length)); 1148 if ((val = GET32(meta, hdr->Vendor_Specific_Logs)) != 0xffffffff) 1149 len = max(len, val + GET32(meta, hdr->Vendor_Specific_Logs_Length)); 1150 if ((plba + len) * ss >= pp->mediasize) 1151 goto hdrerror; 1152 if (slba != -1 && (slba + len) * ss >= pp->mediasize) 1153 goto hdrerror; 1154 /* Workaround for Adaptec implementation. */ 1155 if (GET16(meta, hdr->Max_Primary_Element_Entries) == 0xffff) { 1156 SET16(meta, hdr->Max_Primary_Element_Entries, 1157 min(GET16(meta, hdr->Max_PD_Entries), 1158 (GET16(meta, hdr->Configuration_Record_Length) * ss - 512) / 12)); 1159 } 1160 1161 /* Read controller data. */ 1162 buf = g_read_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss, 1163 GET32(meta, hdr->cd_length) * ss, &error); 1164 if (buf == NULL) 1165 goto readerror; 1166 meta->cdr = malloc(GET32(meta, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK); 1167 memcpy(meta->cdr, buf, GET32(meta, hdr->cd_length) * ss); 1168 g_free(buf); 1169 if (GET32(meta, cdr->Signature) != DDF_CONTROLLER_DATA_SIGNATURE) 1170 goto hdrerror; 1171 1172 /* Read physical disk records. */ 1173 buf = g_read_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss, 1174 GET32(meta, hdr->pdr_length) * ss, &error); 1175 if (buf == NULL) 1176 goto readerror; 1177 meta->pdr = malloc(GET32(meta, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK); 1178 memcpy(meta->pdr, buf, GET32(meta, hdr->pdr_length) * ss); 1179 g_free(buf); 1180 if (GET32(meta, pdr->Signature) != DDF_PDR_SIGNATURE) 1181 goto hdrerror; 1182 1183 /* Read virtual disk records. */ 1184 buf = g_read_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss, 1185 GET32(meta, hdr->vdr_length) * ss, &error); 1186 if (buf == NULL) 1187 goto readerror; 1188 meta->vdr = malloc(GET32(meta, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK); 1189 memcpy(meta->vdr, buf, GET32(meta, hdr->vdr_length) * ss); 1190 g_free(buf); 1191 if (GET32(meta, vdr->Signature) != DDF_VD_RECORD_SIGNATURE) 1192 goto hdrerror; 1193 1194 /* Read configuration records. */ 1195 buf = g_read_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss, 1196 GET32(meta, hdr->cr_length) * ss, &error); 1197 if (buf == NULL) 1198 goto readerror; 1199 meta->cr = malloc(GET32(meta, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK); 1200 memcpy(meta->cr, buf, GET32(meta, hdr->cr_length) * ss); 1201 g_free(buf); 1202 1203 /* Read physical disk data. */ 1204 buf = g_read_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss, 1205 GET32(meta, hdr->pdd_length) * ss, &error); 1206 if (buf == NULL) 1207 goto readerror; 1208 meta->pdd = malloc(GET32(meta, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK); 1209 memcpy(meta->pdd, buf, GET32(meta, hdr->pdd_length) * ss); 1210 g_free(buf); 1211 if (GET32(meta, pdd->Signature) != DDF_PDD_SIGNATURE) 1212 goto hdrerror; 1213 i = ddf_meta_find_pd(meta, NULL, GET32(meta, pdd->PD_Reference)); 1214 if (i < 0) 1215 goto hdrerror; 1216 1217 /* Read BBM Log. */ 1218 if (GET32(meta, hdr->bbmlog_section) != 0xffffffff && 1219 GET32(meta, hdr->bbmlog_length) != 0) { 1220 buf = g_read_data(cp, (lba + GET32(meta, hdr->bbmlog_section)) * ss, 1221 GET32(meta, hdr->bbmlog_length) * ss, &error); 1222 if (buf == NULL) 1223 goto readerror; 1224 meta->bbm = malloc(GET32(meta, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK); 1225 memcpy(meta->bbm, buf, GET32(meta, hdr->bbmlog_length) * ss); 1226 g_free(buf); 1227 if (GET32(meta, bbm->Signature) != DDF_BBML_SIGNATURE) 1228 goto hdrerror; 1229 } 1230 1231 done: 1232 g_free(abuf); 1233 if (error != 0) 1234 ddf_meta_free(meta); 1235 return (error); 1236 } 1237 1238 static int 1239 ddf_meta_write(struct g_consumer *cp, struct ddf_meta *meta) 1240 { 1241 struct g_provider *pp; 1242 struct ddf_vdc_record *vdc; 1243 off_t alba, plba, slba, lba; 1244 u_int ss, size; 1245 int error, i, num; 1246 1247 pp = cp->provider; 1248 ss = pp->sectorsize; 1249 lba = alba = pp->mediasize / ss - 1; 1250 plba = GET64(meta, hdr->Primary_Header_LBA); 1251 slba = GET64(meta, hdr->Secondary_Header_LBA); 1252 1253 next: 1254 SET8(meta, hdr->Header_Type, (lba == alba) ? DDF_HEADER_ANCHOR : 1255 (lba == plba) ? DDF_HEADER_PRIMARY : DDF_HEADER_SECONDARY); 1256 SET32(meta, hdr->CRC, 0xffffffff); 1257 SET32(meta, hdr->CRC, crc32(meta->hdr, ss)); 1258 error = g_write_data(cp, lba * ss, meta->hdr, ss); 1259 if (error != 0) { 1260 err: 1261 G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).", 1262 pp->name, error); 1263 if (lba != alba) 1264 goto done; 1265 } 1266 if (lba == alba) { 1267 lba = plba; 1268 goto next; 1269 } 1270 1271 size = GET32(meta, hdr->cd_length) * ss; 1272 SET32(meta, cdr->CRC, 0xffffffff); 1273 SET32(meta, cdr->CRC, crc32(meta->cdr, size)); 1274 error = g_write_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss, 1275 meta->cdr, size); 1276 if (error != 0) 1277 goto err; 1278 1279 size = GET32(meta, hdr->pdr_length) * ss; 1280 SET32(meta, pdr->CRC, 0xffffffff); 1281 SET32(meta, pdr->CRC, crc32(meta->pdr, size)); 1282 error = g_write_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss, 1283 meta->pdr, size); 1284 if (error != 0) 1285 goto err; 1286 1287 size = GET32(meta, hdr->vdr_length) * ss; 1288 SET32(meta, vdr->CRC, 0xffffffff); 1289 SET32(meta, vdr->CRC, crc32(meta->vdr, size)); 1290 error = g_write_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss, 1291 meta->vdr, size); 1292 if (error != 0) 1293 goto err; 1294 1295 size = GET16(meta, hdr->Configuration_Record_Length) * ss; 1296 num = GETCRNUM(meta); 1297 for (i = 0; i < num; i++) { 1298 vdc = GETVDCPTR(meta, i); 1299 SET32D(meta, vdc->CRC, 0xffffffff); 1300 SET32D(meta, vdc->CRC, crc32(vdc, size)); 1301 } 1302 error = g_write_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss, 1303 meta->cr, size * num); 1304 if (error != 0) 1305 goto err; 1306 1307 size = GET32(meta, hdr->pdd_length) * ss; 1308 SET32(meta, pdd->CRC, 0xffffffff); 1309 SET32(meta, pdd->CRC, crc32(meta->pdd, size)); 1310 error = g_write_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss, 1311 meta->pdd, size); 1312 if (error != 0) 1313 goto err; 1314 1315 if (GET32(meta, hdr->bbmlog_length) != 0) { 1316 size = GET32(meta, hdr->bbmlog_length) * ss; 1317 SET32(meta, bbm->CRC, 0xffffffff); 1318 SET32(meta, bbm->CRC, crc32(meta->bbm, size)); 1319 error = g_write_data(cp, 1320 (lba + GET32(meta, hdr->bbmlog_section)) * ss, 1321 meta->bbm, size); 1322 if (error != 0) 1323 goto err; 1324 } 1325 1326 done: 1327 if (lba == plba && slba != -1) { 1328 lba = slba; 1329 goto next; 1330 } 1331 1332 return (error); 1333 } 1334 1335 static int 1336 ddf_meta_erase(struct g_consumer *cp) 1337 { 1338 struct g_provider *pp; 1339 char *buf; 1340 int error; 1341 1342 pp = cp->provider; 1343 buf = malloc(pp->sectorsize, M_MD_DDF, M_WAITOK | M_ZERO); 1344 error = g_write_data(cp, pp->mediasize - pp->sectorsize, 1345 buf, pp->sectorsize); 1346 if (error != 0) { 1347 G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).", 1348 pp->name, error); 1349 } 1350 free(buf, M_MD_DDF); 1351 return (error); 1352 } 1353 1354 static struct g_raid_volume * 1355 g_raid_md_ddf_get_volume(struct g_raid_softc *sc, uint8_t *GUID) 1356 { 1357 struct g_raid_volume *vol; 1358 struct g_raid_md_ddf_pervolume *pv; 1359 1360 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 1361 pv = vol->v_md_data; 1362 if (memcmp(pv->pv_meta.vde->VD_GUID, GUID, 24) == 0) 1363 break; 1364 } 1365 return (vol); 1366 } 1367 1368 static struct g_raid_disk * 1369 g_raid_md_ddf_get_disk(struct g_raid_softc *sc, uint8_t *GUID, uint32_t id) 1370 { 1371 struct g_raid_disk *disk; 1372 struct g_raid_md_ddf_perdisk *pd; 1373 struct ddf_meta *meta; 1374 1375 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1376 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 1377 meta = &pd->pd_meta; 1378 if (GUID != NULL) { 1379 if (memcmp(meta->pdd->PD_GUID, GUID, 24) == 0) 1380 break; 1381 } else { 1382 if (GET32(meta, pdd->PD_Reference) == id) 1383 break; 1384 } 1385 } 1386 return (disk); 1387 } 1388 1389 static int 1390 g_raid_md_ddf_purge_volumes(struct g_raid_softc *sc) 1391 { 1392 struct g_raid_volume *vol, *tvol; 1393 struct g_raid_md_ddf_pervolume *pv; 1394 int i, res; 1395 1396 res = 0; 1397 TAILQ_FOREACH_SAFE(vol, &sc->sc_volumes, v_next, tvol) { 1398 pv = vol->v_md_data; 1399 if (vol->v_stopping) 1400 continue; 1401 for (i = 0; i < vol->v_disks_count; i++) { 1402 if (vol->v_subdisks[i].sd_state != G_RAID_SUBDISK_S_NONE) 1403 break; 1404 } 1405 if (i >= vol->v_disks_count) { 1406 g_raid_destroy_volume(vol); 1407 res = 1; 1408 } 1409 } 1410 return (res); 1411 } 1412 1413 static int 1414 g_raid_md_ddf_purge_disks(struct g_raid_softc *sc) 1415 { 1416 #if 0 1417 struct g_raid_disk *disk, *tdisk; 1418 struct g_raid_volume *vol; 1419 struct g_raid_md_ddf_perdisk *pd; 1420 int i, j, res; 1421 1422 res = 0; 1423 TAILQ_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) { 1424 if (disk->d_state == G_RAID_DISK_S_SPARE) 1425 continue; 1426 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 1427 1428 /* Scan for deleted volumes. */ 1429 for (i = 0; i < pd->pd_subdisks; ) { 1430 vol = g_raid_md_ddf_get_volume(sc, 1431 pd->pd_meta[i]->volume_id); 1432 if (vol != NULL && !vol->v_stopping) { 1433 i++; 1434 continue; 1435 } 1436 free(pd->pd_meta[i], M_MD_DDF); 1437 for (j = i; j < pd->pd_subdisks - 1; j++) 1438 pd->pd_meta[j] = pd->pd_meta[j + 1]; 1439 pd->pd_meta[DDF_MAX_SUBDISKS - 1] = NULL; 1440 pd->pd_subdisks--; 1441 pd->pd_updated = 1; 1442 } 1443 1444 /* If there is no metadata left - erase and delete disk. */ 1445 if (pd->pd_subdisks == 0) { 1446 ddf_meta_erase(disk->d_consumer); 1447 g_raid_destroy_disk(disk); 1448 res = 1; 1449 } 1450 } 1451 return (res); 1452 #endif 1453 return (0); 1454 } 1455 1456 static int 1457 g_raid_md_ddf_supported(int level, int qual, int disks, int force) 1458 { 1459 1460 if (disks > DDF_MAX_DISKS_HARD) 1461 return (0); 1462 switch (level) { 1463 case G_RAID_VOLUME_RL_RAID0: 1464 if (qual != G_RAID_VOLUME_RLQ_NONE) 1465 return (0); 1466 if (disks < 1) 1467 return (0); 1468 if (!force && disks < 2) 1469 return (0); 1470 break; 1471 case G_RAID_VOLUME_RL_RAID1: 1472 if (disks < 1) 1473 return (0); 1474 if (qual == G_RAID_VOLUME_RLQ_R1SM) { 1475 if (!force && disks != 2) 1476 return (0); 1477 } else if (qual == G_RAID_VOLUME_RLQ_R1MM) { 1478 if (!force && disks != 3) 1479 return (0); 1480 } else 1481 return (0); 1482 break; 1483 case G_RAID_VOLUME_RL_RAID3: 1484 if (qual != G_RAID_VOLUME_RLQ_R3P0 && 1485 qual != G_RAID_VOLUME_RLQ_R3PN) 1486 return (0); 1487 if (disks < 3) 1488 return (0); 1489 break; 1490 case G_RAID_VOLUME_RL_RAID4: 1491 if (qual != G_RAID_VOLUME_RLQ_R4P0 && 1492 qual != G_RAID_VOLUME_RLQ_R4PN) 1493 return (0); 1494 if (disks < 3) 1495 return (0); 1496 break; 1497 case G_RAID_VOLUME_RL_RAID5: 1498 if (qual != G_RAID_VOLUME_RLQ_R5RA && 1499 qual != G_RAID_VOLUME_RLQ_R5RS && 1500 qual != G_RAID_VOLUME_RLQ_R5LA && 1501 qual != G_RAID_VOLUME_RLQ_R5LS) 1502 return (0); 1503 if (disks < 3) 1504 return (0); 1505 break; 1506 case G_RAID_VOLUME_RL_RAID6: 1507 if (qual != G_RAID_VOLUME_RLQ_R6RA && 1508 qual != G_RAID_VOLUME_RLQ_R6RS && 1509 qual != G_RAID_VOLUME_RLQ_R6LA && 1510 qual != G_RAID_VOLUME_RLQ_R6LS) 1511 return (0); 1512 if (disks < 4) 1513 return (0); 1514 break; 1515 case G_RAID_VOLUME_RL_RAIDMDF: 1516 if (qual != G_RAID_VOLUME_RLQ_RMDFRA && 1517 qual != G_RAID_VOLUME_RLQ_RMDFRS && 1518 qual != G_RAID_VOLUME_RLQ_RMDFLA && 1519 qual != G_RAID_VOLUME_RLQ_RMDFLS) 1520 return (0); 1521 if (disks < 4) 1522 return (0); 1523 break; 1524 case G_RAID_VOLUME_RL_RAID1E: 1525 if (qual != G_RAID_VOLUME_RLQ_R1EA && 1526 qual != G_RAID_VOLUME_RLQ_R1EO) 1527 return (0); 1528 if (disks < 3) 1529 return (0); 1530 break; 1531 case G_RAID_VOLUME_RL_SINGLE: 1532 if (qual != G_RAID_VOLUME_RLQ_NONE) 1533 return (0); 1534 if (disks != 1) 1535 return (0); 1536 break; 1537 case G_RAID_VOLUME_RL_CONCAT: 1538 if (qual != G_RAID_VOLUME_RLQ_NONE) 1539 return (0); 1540 if (disks < 2) 1541 return (0); 1542 break; 1543 case G_RAID_VOLUME_RL_RAID5E: 1544 if (qual != G_RAID_VOLUME_RLQ_R5ERA && 1545 qual != G_RAID_VOLUME_RLQ_R5ERS && 1546 qual != G_RAID_VOLUME_RLQ_R5ELA && 1547 qual != G_RAID_VOLUME_RLQ_R5ELS) 1548 return (0); 1549 if (disks < 4) 1550 return (0); 1551 break; 1552 case G_RAID_VOLUME_RL_RAID5EE: 1553 if (qual != G_RAID_VOLUME_RLQ_R5EERA && 1554 qual != G_RAID_VOLUME_RLQ_R5EERS && 1555 qual != G_RAID_VOLUME_RLQ_R5EELA && 1556 qual != G_RAID_VOLUME_RLQ_R5EELS) 1557 return (0); 1558 if (disks < 4) 1559 return (0); 1560 break; 1561 case G_RAID_VOLUME_RL_RAID5R: 1562 if (qual != G_RAID_VOLUME_RLQ_R5RRA && 1563 qual != G_RAID_VOLUME_RLQ_R5RRS && 1564 qual != G_RAID_VOLUME_RLQ_R5RLA && 1565 qual != G_RAID_VOLUME_RLQ_R5RLS) 1566 return (0); 1567 if (disks < 3) 1568 return (0); 1569 break; 1570 default: 1571 return (0); 1572 } 1573 return (1); 1574 } 1575 1576 static int 1577 g_raid_md_ddf_start_disk(struct g_raid_disk *disk, struct g_raid_volume *vol) 1578 { 1579 struct g_raid_softc *sc; 1580 struct g_raid_subdisk *sd; 1581 struct g_raid_md_ddf_perdisk *pd; 1582 struct g_raid_md_ddf_pervolume *pv; 1583 struct g_raid_md_ddf_object *mdi; 1584 struct ddf_vol_meta *vmeta; 1585 struct ddf_meta *pdmeta, *gmeta; 1586 struct ddf_vdc_record *vdc1; 1587 struct ddf_sa_record *sa; 1588 off_t size, eoff = 0, esize = 0; 1589 uint64_t *val2; 1590 int disk_pos, md_disk_bvd = -1, md_disk_pos = -1, md_pde_pos; 1591 int i, resurrection = 0; 1592 uint32_t reference; 1593 1594 sc = disk->d_softc; 1595 mdi = (struct g_raid_md_ddf_object *)sc->sc_md; 1596 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 1597 pdmeta = &pd->pd_meta; 1598 reference = GET32(&pd->pd_meta, pdd->PD_Reference); 1599 1600 pv = vol->v_md_data; 1601 vmeta = &pv->pv_meta; 1602 gmeta = &mdi->mdio_meta; 1603 1604 /* Find disk position in metadata by it's reference. */ 1605 disk_pos = ddf_meta_find_disk(vmeta, reference, 1606 &md_disk_bvd, &md_disk_pos); 1607 md_pde_pos = ddf_meta_find_pd(gmeta, NULL, reference); 1608 1609 if (disk_pos < 0) { 1610 G_RAID_DEBUG1(1, sc, 1611 "Disk %s is not a present part of the volume %s", 1612 g_raid_get_diskname(disk), vol->v_name); 1613 1614 /* Failed stale disk is useless for us. */ 1615 if ((GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) != 0) { 1616 g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED); 1617 return (0); 1618 } 1619 1620 /* If disk has some metadata for this volume - erase. */ 1621 if ((vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL) 1622 SET32D(pdmeta, vdc1->Signature, 0xffffffff); 1623 1624 /* If we are in the start process, that's all for now. */ 1625 if (!pv->pv_started) 1626 goto nofit; 1627 /* 1628 * If we have already started - try to get use of the disk. 1629 * Try to replace OFFLINE disks first, then FAILED. 1630 */ 1631 if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >= 1632 GET16(&pd->pd_meta, hdr->Max_Partitions)) { 1633 G_RAID_DEBUG1(1, sc, "No free partitions on disk %s", 1634 g_raid_get_diskname(disk)); 1635 goto nofit; 1636 } 1637 ddf_meta_unused_range(&pd->pd_meta, &eoff, &esize); 1638 if (esize == 0) { 1639 G_RAID_DEBUG1(1, sc, "No free space on disk %s", 1640 g_raid_get_diskname(disk)); 1641 goto nofit; 1642 } 1643 eoff *= pd->pd_meta.sectorsize; 1644 esize *= pd->pd_meta.sectorsize; 1645 size = INT64_MAX; 1646 for (i = 0; i < vol->v_disks_count; i++) { 1647 sd = &vol->v_subdisks[i]; 1648 if (sd->sd_state != G_RAID_SUBDISK_S_NONE) 1649 size = sd->sd_size; 1650 if (sd->sd_state <= G_RAID_SUBDISK_S_FAILED && 1651 (disk_pos < 0 || 1652 vol->v_subdisks[i].sd_state < sd->sd_state)) 1653 disk_pos = i; 1654 } 1655 if (disk_pos >= 0 && 1656 vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT && 1657 esize < size) { 1658 G_RAID_DEBUG1(1, sc, "Disk %s free space " 1659 "is too small (%ju < %ju)", 1660 g_raid_get_diskname(disk), esize, size); 1661 disk_pos = -1; 1662 } 1663 if (disk_pos >= 0) { 1664 if (vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT) 1665 esize = size; 1666 md_disk_bvd = disk_pos / GET16(vmeta, vdc->Primary_Element_Count); // XXX 1667 md_disk_pos = disk_pos % GET16(vmeta, vdc->Primary_Element_Count); // XXX 1668 } else { 1669 nofit: 1670 if (disk->d_state == G_RAID_DISK_S_NONE) 1671 g_raid_change_disk_state(disk, 1672 G_RAID_DISK_S_STALE); 1673 return (0); 1674 } 1675 1676 /* 1677 * If spare is committable, delete spare record. 1678 * Othersize, mark it active and leave there. 1679 */ 1680 sa = ddf_meta_find_sa(&pd->pd_meta, 0); 1681 if (sa != NULL) { 1682 if ((GET8D(&pd->pd_meta, sa->Spare_Type) & 1683 DDF_SAR_TYPE_REVERTIBLE) == 0) { 1684 SET32D(&pd->pd_meta, sa->Signature, 0xffffffff); 1685 } else { 1686 SET8D(&pd->pd_meta, sa->Spare_Type, 1687 GET8D(&pd->pd_meta, sa->Spare_Type) | 1688 DDF_SAR_TYPE_ACTIVE); 1689 } 1690 } 1691 1692 G_RAID_DEBUG1(1, sc, "Disk %s takes pos %d in the volume %s", 1693 g_raid_get_diskname(disk), disk_pos, vol->v_name); 1694 resurrection = 1; 1695 } 1696 1697 sd = &vol->v_subdisks[disk_pos]; 1698 1699 if (resurrection && sd->sd_disk != NULL) { 1700 g_raid_change_disk_state(sd->sd_disk, 1701 G_RAID_DISK_S_STALE_FAILED); 1702 TAILQ_REMOVE(&sd->sd_disk->d_subdisks, 1703 sd, sd_next); 1704 } 1705 vol->v_subdisks[disk_pos].sd_disk = disk; 1706 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next); 1707 1708 /* Welcome the new disk. */ 1709 if (resurrection) 1710 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE); 1711 else if (GET8(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) 1712 g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED); 1713 else 1714 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE); 1715 1716 if (resurrection) { 1717 sd->sd_offset = eoff; 1718 sd->sd_size = esize; 1719 } else if (pdmeta->cr != NULL && 1720 (vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL) { 1721 val2 = (uint64_t *)&(vdc1->Physical_Disk_Sequence[GET16(vmeta, hdr->Max_Primary_Element_Entries)]); 1722 sd->sd_offset = (off_t)GET64P(pdmeta, val2 + md_disk_pos) * 512; 1723 sd->sd_size = (off_t)GET64D(pdmeta, vdc1->Block_Count) * 512; 1724 } 1725 1726 if (resurrection) { 1727 /* Stale disk, almost same as new. */ 1728 g_raid_change_subdisk_state(sd, 1729 G_RAID_SUBDISK_S_NEW); 1730 } else if (GET8(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) { 1731 /* Failed disk. */ 1732 g_raid_change_subdisk_state(sd, 1733 G_RAID_SUBDISK_S_FAILED); 1734 } else if ((GET8(gmeta, pdr->entry[md_pde_pos].PD_State) & 1735 (DDF_PDE_FAILED | DDF_PDE_REBUILD)) != 0) { 1736 /* Rebuilding disk. */ 1737 g_raid_change_subdisk_state(sd, 1738 G_RAID_SUBDISK_S_REBUILD); 1739 sd->sd_rebuild_pos = 0; 1740 } else if ((GET8(vmeta, vde->VD_State) & DDF_VDE_DIRTY) != 0 || 1741 (GET8(vmeta, vde->Init_State) & DDF_VDE_INIT_MASK) != 1742 DDF_VDE_INIT_FULL) { 1743 /* Stale disk or dirty volume (unclean shutdown). */ 1744 g_raid_change_subdisk_state(sd, 1745 G_RAID_SUBDISK_S_STALE); 1746 } else { 1747 /* Up to date disk. */ 1748 g_raid_change_subdisk_state(sd, 1749 G_RAID_SUBDISK_S_ACTIVE); 1750 } 1751 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW, 1752 G_RAID_EVENT_SUBDISK); 1753 1754 return (resurrection); 1755 } 1756 1757 static void 1758 g_raid_md_ddf_refill(struct g_raid_softc *sc) 1759 { 1760 struct g_raid_volume *vol; 1761 struct g_raid_subdisk *sd; 1762 struct g_raid_disk *disk; 1763 struct g_raid_md_object *md; 1764 struct g_raid_md_ddf_perdisk *pd; 1765 struct g_raid_md_ddf_pervolume *pv; 1766 int update, updated, i, bad; 1767 1768 md = sc->sc_md; 1769 restart: 1770 updated = 0; 1771 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 1772 pv = vol->v_md_data; 1773 if (!pv->pv_started || vol->v_stopping) 1774 continue; 1775 1776 /* Search for subdisk that needs replacement. */ 1777 bad = 0; 1778 for (i = 0; i < vol->v_disks_count; i++) { 1779 sd = &vol->v_subdisks[i]; 1780 if (sd->sd_state == G_RAID_SUBDISK_S_NONE || 1781 sd->sd_state == G_RAID_SUBDISK_S_FAILED) 1782 bad = 1; 1783 } 1784 if (!bad) 1785 continue; 1786 1787 G_RAID_DEBUG1(1, sc, "Volume %s is not complete, " 1788 "trying to refill.", vol->v_name); 1789 1790 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1791 /* Skip failed. */ 1792 if (disk->d_state < G_RAID_DISK_S_SPARE) 1793 continue; 1794 /* Skip already used by this volume. */ 1795 for (i = 0; i < vol->v_disks_count; i++) { 1796 sd = &vol->v_subdisks[i]; 1797 if (sd->sd_disk == disk) 1798 break; 1799 } 1800 if (i < vol->v_disks_count) 1801 continue; 1802 1803 /* Try to use disk if it has empty extents. */ 1804 pd = disk->d_md_data; 1805 if (ddf_meta_count_vdc(&pd->pd_meta, NULL) < 1806 GET16(&pd->pd_meta, hdr->Max_Partitions)) { 1807 update = g_raid_md_ddf_start_disk(disk, vol); 1808 } else 1809 update = 0; 1810 if (update) { 1811 updated = 1; 1812 g_raid_md_write_ddf(md, vol, NULL, disk); 1813 break; 1814 } 1815 } 1816 } 1817 if (updated) 1818 goto restart; 1819 } 1820 1821 static void 1822 g_raid_md_ddf_start(struct g_raid_volume *vol) 1823 { 1824 struct g_raid_softc *sc; 1825 struct g_raid_subdisk *sd; 1826 struct g_raid_disk *disk; 1827 struct g_raid_md_object *md; 1828 struct g_raid_md_ddf_perdisk *pd; 1829 struct g_raid_md_ddf_pervolume *pv; 1830 struct g_raid_md_ddf_object *mdi; 1831 struct ddf_vol_meta *vmeta; 1832 struct ddf_vdc_record *vdc; 1833 uint64_t *val2; 1834 int i, j, bvd; 1835 1836 sc = vol->v_softc; 1837 md = sc->sc_md; 1838 mdi = (struct g_raid_md_ddf_object *)md; 1839 pv = vol->v_md_data; 1840 vmeta = &pv->pv_meta; 1841 vdc = vmeta->vdc; 1842 1843 vol->v_raid_level = GET8(vmeta, vdc->Primary_RAID_Level); 1844 vol->v_raid_level_qualifier = GET8(vmeta, vdc->RLQ); 1845 if (GET8(vmeta, vdc->Secondary_Element_Count) > 1 && 1846 vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 && 1847 GET8(vmeta, vdc->Secondary_RAID_Level) == 0) 1848 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E; 1849 vol->v_sectorsize = GET16(vmeta, vdc->Block_Size); 1850 if (vol->v_sectorsize == 0xffff) 1851 vol->v_sectorsize = vmeta->sectorsize; 1852 vol->v_strip_size = vol->v_sectorsize << GET8(vmeta, vdc->Stripe_Size); 1853 vol->v_disks_count = GET16(vmeta, vdc->Primary_Element_Count) * 1854 GET8(vmeta, vdc->Secondary_Element_Count); 1855 vol->v_mdf_pdisks = GET8(vmeta, vdc->MDF_Parity_Disks); 1856 vol->v_mdf_polynomial = GET16(vmeta, vdc->MDF_Parity_Generator_Polynomial); 1857 vol->v_mdf_method = GET8(vmeta, vdc->MDF_Constant_Generation_Method); 1858 if (GET8(vmeta, vdc->Rotate_Parity_count) > 31) 1859 vol->v_rotate_parity = 1; 1860 else 1861 vol->v_rotate_parity = 1 << GET8(vmeta, vdc->Rotate_Parity_count); 1862 vol->v_mediasize = GET64(vmeta, vdc->VD_Size) * vol->v_sectorsize; 1863 for (i = 0, j = 0, bvd = 0; i < vol->v_disks_count; i++, j++) { 1864 if (j == GET16(vmeta, vdc->Primary_Element_Count)) { 1865 j = 0; 1866 bvd++; 1867 } 1868 sd = &vol->v_subdisks[i]; 1869 if (vmeta->bvdc[bvd] == NULL) { 1870 sd->sd_offset = 0; 1871 sd->sd_size = GET64(vmeta, vdc->Block_Count) * 1872 vol->v_sectorsize; 1873 continue; 1874 } 1875 val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[ 1876 GET16(vmeta, hdr->Max_Primary_Element_Entries)]); 1877 sd->sd_offset = GET64P(vmeta, val2 + j) * vol->v_sectorsize; 1878 sd->sd_size = GET64(vmeta, bvdc[bvd]->Block_Count) * 1879 vol->v_sectorsize; 1880 } 1881 g_raid_start_volume(vol); 1882 1883 /* Make all disks found till the moment take their places. */ 1884 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1885 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 1886 if (ddf_meta_find_vdc(&pd->pd_meta, vmeta->vdc->VD_GUID) != NULL) 1887 g_raid_md_ddf_start_disk(disk, vol); 1888 } 1889 1890 pv->pv_started = 1; 1891 mdi->mdio_starting--; 1892 callout_stop(&pv->pv_start_co); 1893 G_RAID_DEBUG1(0, sc, "Volume started."); 1894 g_raid_md_write_ddf(md, vol, NULL, NULL); 1895 1896 /* Pickup any STALE/SPARE disks to refill array if needed. */ 1897 g_raid_md_ddf_refill(sc); 1898 1899 g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME); 1900 } 1901 1902 static void 1903 g_raid_ddf_go(void *arg) 1904 { 1905 struct g_raid_volume *vol; 1906 struct g_raid_softc *sc; 1907 struct g_raid_md_ddf_pervolume *pv; 1908 1909 vol = arg; 1910 pv = vol->v_md_data; 1911 sc = vol->v_softc; 1912 if (!pv->pv_started) { 1913 G_RAID_DEBUG1(0, sc, "Force volume start due to timeout."); 1914 g_raid_event_send(vol, G_RAID_VOLUME_E_STARTMD, 1915 G_RAID_EVENT_VOLUME); 1916 } 1917 } 1918 1919 static void 1920 g_raid_md_ddf_new_disk(struct g_raid_disk *disk) 1921 { 1922 struct g_raid_softc *sc; 1923 struct g_raid_md_object *md; 1924 struct g_raid_md_ddf_perdisk *pd; 1925 struct g_raid_md_ddf_pervolume *pv; 1926 struct g_raid_md_ddf_object *mdi; 1927 struct g_raid_volume *vol; 1928 struct ddf_meta *pdmeta; 1929 struct ddf_vol_meta *vmeta; 1930 struct ddf_vdc_record *vdc; 1931 struct ddf_vd_entry *vde; 1932 int i, j, k, num, have, need, cnt, spare; 1933 uint32_t val; 1934 char buf[17]; 1935 1936 sc = disk->d_softc; 1937 md = sc->sc_md; 1938 mdi = (struct g_raid_md_ddf_object *)md; 1939 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 1940 pdmeta = &pd->pd_meta; 1941 spare = -1; 1942 1943 if (mdi->mdio_meta.hdr == NULL) 1944 ddf_meta_copy(&mdi->mdio_meta, pdmeta); 1945 else 1946 ddf_meta_update(&mdi->mdio_meta, pdmeta); 1947 1948 num = GETCRNUM(pdmeta); 1949 for (j = 0; j < num; j++) { 1950 vdc = GETVDCPTR(pdmeta, j); 1951 val = GET32D(pdmeta, vdc->Signature); 1952 1953 if (val == DDF_SA_SIGNATURE && spare == -1) 1954 spare = 1; 1955 1956 if (val != DDF_VDCR_SIGNATURE) 1957 continue; 1958 spare = 0; 1959 k = ddf_meta_find_vd(pdmeta, vdc->VD_GUID); 1960 if (k < 0) 1961 continue; 1962 vde = &pdmeta->vdr->entry[k]; 1963 1964 /* Look for volume with matching ID. */ 1965 vol = g_raid_md_ddf_get_volume(sc, vdc->VD_GUID); 1966 if (vol == NULL) { 1967 ddf_meta_get_name(pdmeta, k, buf); 1968 vol = g_raid_create_volume(sc, buf, 1969 GET16D(pdmeta, vde->VD_Number)); 1970 pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO); 1971 vol->v_md_data = pv; 1972 callout_init(&pv->pv_start_co, 1); 1973 callout_reset(&pv->pv_start_co, 1974 g_raid_start_timeout * hz, 1975 g_raid_ddf_go, vol); 1976 mdi->mdio_starting++; 1977 } else 1978 pv = vol->v_md_data; 1979 1980 /* If we haven't started yet - check metadata freshness. */ 1981 vmeta = &pv->pv_meta; 1982 ddf_vol_meta_update(vmeta, pdmeta, vdc->VD_GUID, pv->pv_started); 1983 } 1984 1985 if (spare == 1) { 1986 g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE); 1987 g_raid_md_ddf_refill(sc); 1988 } 1989 1990 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 1991 pv = vol->v_md_data; 1992 vmeta = &pv->pv_meta; 1993 1994 if (ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID) == NULL) 1995 continue; 1996 1997 if (pv->pv_started) { 1998 if (g_raid_md_ddf_start_disk(disk, vol)) 1999 g_raid_md_write_ddf(md, vol, NULL, NULL); 2000 continue; 2001 } 2002 2003 /* If we collected all needed disks - start array. */ 2004 need = 0; 2005 have = 0; 2006 for (k = 0; k < GET8(vmeta, vdc->Secondary_Element_Count); k++) { 2007 if (vmeta->bvdc[k] == NULL) { 2008 need += GET16(vmeta, vdc->Primary_Element_Count); 2009 continue; 2010 } 2011 cnt = GET16(vmeta, bvdc[k]->Primary_Element_Count); 2012 need += cnt; 2013 for (i = 0; i < cnt; i++) { 2014 val = GET32(vmeta, bvdc[k]->Physical_Disk_Sequence[i]); 2015 if (g_raid_md_ddf_get_disk(sc, NULL, val) != NULL) 2016 have++; 2017 } 2018 } 2019 G_RAID_DEBUG1(1, sc, "Volume %s now has %d of %d disks", 2020 vol->v_name, have, need); 2021 if (have == need) 2022 g_raid_md_ddf_start(vol); 2023 } 2024 } 2025 2026 static int 2027 g_raid_md_create_req_ddf(struct g_raid_md_object *md, struct g_class *mp, 2028 struct gctl_req *req, struct g_geom **gp) 2029 { 2030 struct g_geom *geom; 2031 struct g_raid_softc *sc; 2032 struct g_raid_md_ddf_object *mdi, *mdi1; 2033 char name[16]; 2034 const char *fmtopt; 2035 int be = 1; 2036 2037 mdi = (struct g_raid_md_ddf_object *)md; 2038 fmtopt = gctl_get_asciiparam(req, "fmtopt"); 2039 if (fmtopt == NULL || strcasecmp(fmtopt, "BE") == 0) 2040 be = 1; 2041 else if (strcasecmp(fmtopt, "LE") == 0) 2042 be = 0; 2043 else { 2044 gctl_error(req, "Incorrect fmtopt argument."); 2045 return (G_RAID_MD_TASTE_FAIL); 2046 } 2047 2048 /* Search for existing node. */ 2049 LIST_FOREACH(geom, &mp->geom, geom) { 2050 sc = geom->softc; 2051 if (sc == NULL) 2052 continue; 2053 if (sc->sc_stopping != 0) 2054 continue; 2055 if (sc->sc_md->mdo_class != md->mdo_class) 2056 continue; 2057 mdi1 = (struct g_raid_md_ddf_object *)sc->sc_md; 2058 if (mdi1->mdio_bigendian != be) 2059 continue; 2060 break; 2061 } 2062 if (geom != NULL) { 2063 *gp = geom; 2064 return (G_RAID_MD_TASTE_EXISTING); 2065 } 2066 2067 /* Create new one if not found. */ 2068 mdi->mdio_bigendian = be; 2069 snprintf(name, sizeof(name), "DDF%s", be ? "" : "-LE"); 2070 sc = g_raid_create_node(mp, name, md); 2071 if (sc == NULL) 2072 return (G_RAID_MD_TASTE_FAIL); 2073 md->mdo_softc = sc; 2074 *gp = sc->sc_geom; 2075 return (G_RAID_MD_TASTE_NEW); 2076 } 2077 2078 static int 2079 g_raid_md_taste_ddf(struct g_raid_md_object *md, struct g_class *mp, 2080 struct g_consumer *cp, struct g_geom **gp) 2081 { 2082 struct g_consumer *rcp; 2083 struct g_provider *pp; 2084 struct g_raid_softc *sc; 2085 struct g_raid_disk *disk; 2086 struct ddf_meta meta; 2087 struct g_raid_md_ddf_perdisk *pd; 2088 struct g_raid_md_ddf_object *mdi; 2089 struct g_geom *geom; 2090 int error, result, len, be; 2091 char name[16]; 2092 2093 G_RAID_DEBUG(1, "Tasting DDF on %s", cp->provider->name); 2094 mdi = (struct g_raid_md_ddf_object *)md; 2095 pp = cp->provider; 2096 2097 /* Read metadata from device. */ 2098 if (g_access(cp, 1, 0, 0) != 0) 2099 return (G_RAID_MD_TASTE_FAIL); 2100 g_topology_unlock(); 2101 bzero(&meta, sizeof(meta)); 2102 error = ddf_meta_read(cp, &meta); 2103 g_topology_lock(); 2104 g_access(cp, -1, 0, 0); 2105 if (error != 0) 2106 return (G_RAID_MD_TASTE_FAIL); 2107 be = meta.bigendian; 2108 2109 /* Metadata valid. Print it. */ 2110 g_raid_md_ddf_print(&meta); 2111 2112 /* Search for matching node. */ 2113 sc = NULL; 2114 LIST_FOREACH(geom, &mp->geom, geom) { 2115 sc = geom->softc; 2116 if (sc == NULL) 2117 continue; 2118 if (sc->sc_stopping != 0) 2119 continue; 2120 if (sc->sc_md->mdo_class != md->mdo_class) 2121 continue; 2122 mdi = (struct g_raid_md_ddf_object *)sc->sc_md; 2123 if (mdi->mdio_bigendian != be) 2124 continue; 2125 break; 2126 } 2127 2128 /* Found matching node. */ 2129 if (geom != NULL) { 2130 G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name); 2131 result = G_RAID_MD_TASTE_EXISTING; 2132 2133 } else { /* Not found matching node -- create one. */ 2134 result = G_RAID_MD_TASTE_NEW; 2135 mdi->mdio_bigendian = be; 2136 snprintf(name, sizeof(name), "DDF%s", be ? "" : "-LE"); 2137 sc = g_raid_create_node(mp, name, md); 2138 md->mdo_softc = sc; 2139 geom = sc->sc_geom; 2140 } 2141 2142 rcp = g_new_consumer(geom); 2143 g_attach(rcp, pp); 2144 if (g_access(rcp, 1, 1, 1) != 0) 2145 ; //goto fail1; 2146 2147 g_topology_unlock(); 2148 sx_xlock(&sc->sc_lock); 2149 2150 pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO); 2151 pd->pd_meta = meta; 2152 disk = g_raid_create_disk(sc); 2153 disk->d_md_data = (void *)pd; 2154 disk->d_consumer = rcp; 2155 rcp->private = disk; 2156 2157 /* Read kernel dumping information. */ 2158 disk->d_kd.offset = 0; 2159 disk->d_kd.length = OFF_MAX; 2160 len = sizeof(disk->d_kd); 2161 error = g_io_getattr("GEOM::kerneldump", rcp, &len, &disk->d_kd); 2162 if (disk->d_kd.di.dumper == NULL) 2163 G_RAID_DEBUG1(2, sc, "Dumping not supported by %s: %d.", 2164 rcp->provider->name, error); 2165 2166 g_raid_md_ddf_new_disk(disk); 2167 2168 sx_xunlock(&sc->sc_lock); 2169 g_topology_lock(); 2170 *gp = geom; 2171 return (result); 2172 } 2173 2174 static int 2175 g_raid_md_event_ddf(struct g_raid_md_object *md, 2176 struct g_raid_disk *disk, u_int event) 2177 { 2178 struct g_raid_softc *sc; 2179 2180 sc = md->mdo_softc; 2181 if (disk == NULL) 2182 return (-1); 2183 switch (event) { 2184 case G_RAID_DISK_E_DISCONNECTED: 2185 /* Delete disk. */ 2186 g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE); 2187 g_raid_destroy_disk(disk); 2188 g_raid_md_ddf_purge_volumes(sc); 2189 2190 /* Write updated metadata to all disks. */ 2191 g_raid_md_write_ddf(md, NULL, NULL, NULL); 2192 2193 /* Check if anything left. */ 2194 if (g_raid_ndisks(sc, -1) == 0) 2195 g_raid_destroy_node(sc, 0); 2196 else 2197 g_raid_md_ddf_refill(sc); 2198 return (0); 2199 } 2200 return (-2); 2201 } 2202 2203 static int 2204 g_raid_md_volume_event_ddf(struct g_raid_md_object *md, 2205 struct g_raid_volume *vol, u_int event) 2206 { 2207 struct g_raid_md_ddf_pervolume *pv; 2208 2209 pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data; 2210 switch (event) { 2211 case G_RAID_VOLUME_E_STARTMD: 2212 if (!pv->pv_started) 2213 g_raid_md_ddf_start(vol); 2214 return (0); 2215 } 2216 return (-2); 2217 } 2218 2219 static int 2220 g_raid_md_ctl_ddf(struct g_raid_md_object *md, 2221 struct gctl_req *req) 2222 { 2223 struct g_raid_softc *sc; 2224 struct g_raid_volume *vol, *vol1; 2225 struct g_raid_subdisk *sd; 2226 struct g_raid_disk *disk, *disks[DDF_MAX_DISKS_HARD]; 2227 struct g_raid_md_ddf_perdisk *pd; 2228 struct g_raid_md_ddf_pervolume *pv; 2229 struct g_raid_md_ddf_object *mdi; 2230 struct ddf_sa_record *sa; 2231 struct g_consumer *cp; 2232 struct g_provider *pp; 2233 char arg[16]; 2234 const char *nodename, *verb, *volname, *levelname, *diskname; 2235 char *tmp; 2236 int *nargs, *force; 2237 off_t size, sectorsize, strip, offs[DDF_MAX_DISKS_HARD], esize; 2238 intmax_t *sizearg, *striparg; 2239 int i, numdisks, len, level, qual; 2240 int error; 2241 2242 sc = md->mdo_softc; 2243 mdi = (struct g_raid_md_ddf_object *)md; 2244 verb = gctl_get_param(req, "verb", NULL); 2245 nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs)); 2246 error = 0; 2247 2248 if (strcmp(verb, "label") == 0) { 2249 2250 if (*nargs < 4) { 2251 gctl_error(req, "Invalid number of arguments."); 2252 return (-1); 2253 } 2254 volname = gctl_get_asciiparam(req, "arg1"); 2255 if (volname == NULL) { 2256 gctl_error(req, "No volume name."); 2257 return (-2); 2258 } 2259 levelname = gctl_get_asciiparam(req, "arg2"); 2260 if (levelname == NULL) { 2261 gctl_error(req, "No RAID level."); 2262 return (-3); 2263 } 2264 if (g_raid_volume_str2level(levelname, &level, &qual)) { 2265 gctl_error(req, "Unknown RAID level '%s'.", levelname); 2266 return (-4); 2267 } 2268 numdisks = *nargs - 3; 2269 force = gctl_get_paraml(req, "force", sizeof(*force)); 2270 if (!g_raid_md_ddf_supported(level, qual, numdisks, 2271 force ? *force : 0)) { 2272 gctl_error(req, "Unsupported RAID level " 2273 "(0x%02x/0x%02x), or number of disks (%d).", 2274 level, qual, numdisks); 2275 return (-5); 2276 } 2277 2278 /* Search for disks, connect them and probe. */ 2279 size = INT64_MAX; 2280 sectorsize = 0; 2281 bzero(disks, sizeof(disks)); 2282 bzero(offs, sizeof(offs)); 2283 for (i = 0; i < numdisks; i++) { 2284 snprintf(arg, sizeof(arg), "arg%d", i + 3); 2285 diskname = gctl_get_asciiparam(req, arg); 2286 if (diskname == NULL) { 2287 gctl_error(req, "No disk name (%s).", arg); 2288 error = -6; 2289 break; 2290 } 2291 if (strcmp(diskname, "NONE") == 0) 2292 continue; 2293 2294 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 2295 if (disk->d_consumer != NULL && 2296 disk->d_consumer->provider != NULL && 2297 strcmp(disk->d_consumer->provider->name, 2298 diskname) == 0) 2299 break; 2300 } 2301 if (disk != NULL) { 2302 if (disk->d_state != G_RAID_DISK_S_ACTIVE) { 2303 gctl_error(req, "Disk '%s' is in a " 2304 "wrong state (%s).", diskname, 2305 g_raid_disk_state2str(disk->d_state)); 2306 error = -7; 2307 break; 2308 } 2309 pd = disk->d_md_data; 2310 if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >= 2311 GET16(&pd->pd_meta, hdr->Max_Partitions)) { 2312 gctl_error(req, "No free partitions " 2313 "on disk '%s'.", 2314 diskname); 2315 error = -7; 2316 break; 2317 } 2318 pp = disk->d_consumer->provider; 2319 disks[i] = disk; 2320 ddf_meta_unused_range(&pd->pd_meta, 2321 &offs[i], &esize); 2322 offs[i] *= pp->sectorsize; 2323 size = MIN(size, (off_t)esize * pp->sectorsize); 2324 sectorsize = MAX(sectorsize, pp->sectorsize); 2325 continue; 2326 } 2327 2328 g_topology_lock(); 2329 cp = g_raid_open_consumer(sc, diskname); 2330 if (cp == NULL) { 2331 gctl_error(req, "Can't open disk '%s'.", 2332 diskname); 2333 g_topology_unlock(); 2334 error = -8; 2335 break; 2336 } 2337 pp = cp->provider; 2338 pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO); 2339 disk = g_raid_create_disk(sc); 2340 disk->d_md_data = (void *)pd; 2341 disk->d_consumer = cp; 2342 disks[i] = disk; 2343 cp->private = disk; 2344 ddf_meta_create(disk, &mdi->mdio_meta); 2345 if (mdi->mdio_meta.hdr == NULL) 2346 ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta); 2347 else 2348 ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta); 2349 g_topology_unlock(); 2350 2351 /* Read kernel dumping information. */ 2352 disk->d_kd.offset = 0; 2353 disk->d_kd.length = OFF_MAX; 2354 len = sizeof(disk->d_kd); 2355 g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd); 2356 if (disk->d_kd.di.dumper == NULL) 2357 G_RAID_DEBUG1(2, sc, 2358 "Dumping not supported by %s.", 2359 cp->provider->name); 2360 2361 /* Reserve some space for metadata. */ 2362 size = MIN(size, GET64(&pd->pd_meta, 2363 pdr->entry[0].Configured_Size) * pp->sectorsize); 2364 sectorsize = MAX(sectorsize, pp->sectorsize); 2365 } 2366 if (error != 0) { 2367 for (i = 0; i < numdisks; i++) { 2368 if (disks[i] != NULL && 2369 disks[i]->d_state == G_RAID_DISK_S_NONE) 2370 g_raid_destroy_disk(disks[i]); 2371 } 2372 return (error); 2373 } 2374 2375 if (sectorsize <= 0) { 2376 gctl_error(req, "Can't get sector size."); 2377 return (-8); 2378 } 2379 2380 /* Handle size argument. */ 2381 len = sizeof(*sizearg); 2382 sizearg = gctl_get_param(req, "size", &len); 2383 if (sizearg != NULL && len == sizeof(*sizearg) && 2384 *sizearg > 0) { 2385 if (*sizearg > size) { 2386 gctl_error(req, "Size too big %lld > %lld.", 2387 (long long)*sizearg, (long long)size); 2388 return (-9); 2389 } 2390 size = *sizearg; 2391 } 2392 2393 /* Handle strip argument. */ 2394 strip = 131072; 2395 len = sizeof(*striparg); 2396 striparg = gctl_get_param(req, "strip", &len); 2397 if (striparg != NULL && len == sizeof(*striparg) && 2398 *striparg > 0) { 2399 if (*striparg < sectorsize) { 2400 gctl_error(req, "Strip size too small."); 2401 return (-10); 2402 } 2403 if (*striparg % sectorsize != 0) { 2404 gctl_error(req, "Incorrect strip size."); 2405 return (-11); 2406 } 2407 strip = *striparg; 2408 } 2409 2410 /* Round size down to strip or sector. */ 2411 if (level == G_RAID_VOLUME_RL_RAID1 || 2412 level == G_RAID_VOLUME_RL_RAID3 || 2413 level == G_RAID_VOLUME_RL_SINGLE || 2414 level == G_RAID_VOLUME_RL_CONCAT) 2415 size -= (size % sectorsize); 2416 else if (level == G_RAID_VOLUME_RL_RAID1E && 2417 (numdisks & 1) != 0) 2418 size -= (size % (2 * strip)); 2419 else 2420 size -= (size % strip); 2421 if (size <= 0) { 2422 gctl_error(req, "Size too small."); 2423 return (-13); 2424 } 2425 2426 /* We have all we need, create things: volume, ... */ 2427 pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO); 2428 ddf_vol_meta_create(&pv->pv_meta, &mdi->mdio_meta); 2429 pv->pv_started = 1; 2430 vol = g_raid_create_volume(sc, volname, -1); 2431 vol->v_md_data = pv; 2432 vol->v_raid_level = level; 2433 vol->v_raid_level_qualifier = qual; 2434 vol->v_strip_size = strip; 2435 vol->v_disks_count = numdisks; 2436 if (level == G_RAID_VOLUME_RL_RAID0 || 2437 level == G_RAID_VOLUME_RL_CONCAT || 2438 level == G_RAID_VOLUME_RL_SINGLE) 2439 vol->v_mediasize = size * numdisks; 2440 else if (level == G_RAID_VOLUME_RL_RAID1) 2441 vol->v_mediasize = size; 2442 else if (level == G_RAID_VOLUME_RL_RAID3 || 2443 level == G_RAID_VOLUME_RL_RAID4 || 2444 level == G_RAID_VOLUME_RL_RAID5) 2445 vol->v_mediasize = size * (numdisks - 1); 2446 else if (level == G_RAID_VOLUME_RL_RAID5R) { 2447 vol->v_mediasize = size * (numdisks - 1); 2448 vol->v_rotate_parity = 1024; 2449 } else if (level == G_RAID_VOLUME_RL_RAID6 || 2450 level == G_RAID_VOLUME_RL_RAID5E || 2451 level == G_RAID_VOLUME_RL_RAID5EE) 2452 vol->v_mediasize = size * (numdisks - 2); 2453 else if (level == G_RAID_VOLUME_RL_RAIDMDF) { 2454 if (numdisks < 5) 2455 vol->v_mdf_pdisks = 2; 2456 else 2457 vol->v_mdf_pdisks = 3; 2458 vol->v_mdf_polynomial = 0x11d; 2459 vol->v_mdf_method = 0x00; 2460 vol->v_mediasize = size * (numdisks - vol->v_mdf_pdisks); 2461 } else { /* RAID1E */ 2462 vol->v_mediasize = ((size * numdisks) / strip / 2) * 2463 strip; 2464 } 2465 vol->v_sectorsize = sectorsize; 2466 g_raid_start_volume(vol); 2467 2468 /* , and subdisks. */ 2469 for (i = 0; i < numdisks; i++) { 2470 disk = disks[i]; 2471 sd = &vol->v_subdisks[i]; 2472 sd->sd_disk = disk; 2473 sd->sd_offset = offs[i]; 2474 sd->sd_size = size; 2475 if (disk == NULL) 2476 continue; 2477 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next); 2478 g_raid_change_disk_state(disk, 2479 G_RAID_DISK_S_ACTIVE); 2480 g_raid_change_subdisk_state(sd, 2481 G_RAID_SUBDISK_S_ACTIVE); 2482 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW, 2483 G_RAID_EVENT_SUBDISK); 2484 } 2485 2486 /* Write metadata based on created entities. */ 2487 G_RAID_DEBUG1(0, sc, "Array started."); 2488 g_raid_md_write_ddf(md, vol, NULL, NULL); 2489 2490 /* Pickup any STALE/SPARE disks to refill array if needed. */ 2491 g_raid_md_ddf_refill(sc); 2492 2493 g_raid_event_send(vol, G_RAID_VOLUME_E_START, 2494 G_RAID_EVENT_VOLUME); 2495 return (0); 2496 } 2497 if (strcmp(verb, "add") == 0) { 2498 2499 gctl_error(req, "`add` command is not applicable, " 2500 "use `label` instead."); 2501 return (-99); 2502 } 2503 if (strcmp(verb, "delete") == 0) { 2504 2505 nodename = gctl_get_asciiparam(req, "arg0"); 2506 if (nodename != NULL && strcasecmp(sc->sc_name, nodename) != 0) 2507 nodename = NULL; 2508 2509 /* Full node destruction. */ 2510 if (*nargs == 1 && nodename != NULL) { 2511 /* Check if some volume is still open. */ 2512 force = gctl_get_paraml(req, "force", sizeof(*force)); 2513 if (force != NULL && *force == 0 && 2514 g_raid_nopens(sc) != 0) { 2515 gctl_error(req, "Some volume is still open."); 2516 return (-4); 2517 } 2518 2519 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 2520 if (disk->d_consumer) 2521 ddf_meta_erase(disk->d_consumer); 2522 } 2523 g_raid_destroy_node(sc, 0); 2524 return (0); 2525 } 2526 2527 /* Destroy specified volume. If it was last - all node. */ 2528 if (*nargs > 2) { 2529 gctl_error(req, "Invalid number of arguments."); 2530 return (-1); 2531 } 2532 volname = gctl_get_asciiparam(req, 2533 nodename != NULL ? "arg1" : "arg0"); 2534 if (volname == NULL) { 2535 gctl_error(req, "No volume name."); 2536 return (-2); 2537 } 2538 2539 /* Search for volume. */ 2540 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 2541 if (strcmp(vol->v_name, volname) == 0) 2542 break; 2543 pp = vol->v_provider; 2544 if (pp == NULL) 2545 continue; 2546 if (strcmp(pp->name, volname) == 0) 2547 break; 2548 if (strncmp(pp->name, "raid/", 5) == 0 && 2549 strcmp(pp->name + 5, volname) == 0) 2550 break; 2551 } 2552 if (vol == NULL) { 2553 i = strtol(volname, &tmp, 10); 2554 if (verb != volname && tmp[0] == 0) { 2555 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 2556 if (vol->v_global_id == i) 2557 break; 2558 } 2559 } 2560 } 2561 if (vol == NULL) { 2562 gctl_error(req, "Volume '%s' not found.", volname); 2563 return (-3); 2564 } 2565 2566 /* Check if volume is still open. */ 2567 force = gctl_get_paraml(req, "force", sizeof(*force)); 2568 if (force != NULL && *force == 0 && 2569 vol->v_provider_open != 0) { 2570 gctl_error(req, "Volume is still open."); 2571 return (-4); 2572 } 2573 2574 /* Destroy volume and potentially node. */ 2575 i = 0; 2576 TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next) 2577 i++; 2578 if (i >= 2) { 2579 g_raid_destroy_volume(vol); 2580 g_raid_md_ddf_purge_disks(sc); 2581 g_raid_md_write_ddf(md, NULL, NULL, NULL); 2582 } else { 2583 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 2584 if (disk->d_consumer) 2585 ddf_meta_erase(disk->d_consumer); 2586 } 2587 g_raid_destroy_node(sc, 0); 2588 } 2589 return (0); 2590 } 2591 if (strcmp(verb, "remove") == 0 || 2592 strcmp(verb, "fail") == 0) { 2593 if (*nargs < 2) { 2594 gctl_error(req, "Invalid number of arguments."); 2595 return (-1); 2596 } 2597 for (i = 1; i < *nargs; i++) { 2598 snprintf(arg, sizeof(arg), "arg%d", i); 2599 diskname = gctl_get_asciiparam(req, arg); 2600 if (diskname == NULL) { 2601 gctl_error(req, "No disk name (%s).", arg); 2602 error = -2; 2603 break; 2604 } 2605 if (strncmp(diskname, "/dev/", 5) == 0) 2606 diskname += 5; 2607 2608 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 2609 if (disk->d_consumer != NULL && 2610 disk->d_consumer->provider != NULL && 2611 strcmp(disk->d_consumer->provider->name, 2612 diskname) == 0) 2613 break; 2614 } 2615 if (disk == NULL) { 2616 gctl_error(req, "Disk '%s' not found.", 2617 diskname); 2618 error = -3; 2619 break; 2620 } 2621 2622 if (strcmp(verb, "fail") == 0) { 2623 g_raid_md_fail_disk_ddf(md, NULL, disk); 2624 continue; 2625 } 2626 2627 /* Erase metadata on deleting disk and destroy it. */ 2628 ddf_meta_erase(disk->d_consumer); 2629 g_raid_destroy_disk(disk); 2630 } 2631 g_raid_md_ddf_purge_volumes(sc); 2632 2633 /* Write updated metadata to remaining disks. */ 2634 g_raid_md_write_ddf(md, NULL, NULL, NULL); 2635 2636 /* Check if anything left. */ 2637 if (g_raid_ndisks(sc, -1) == 0) 2638 g_raid_destroy_node(sc, 0); 2639 else 2640 g_raid_md_ddf_refill(sc); 2641 return (error); 2642 } 2643 if (strcmp(verb, "insert") == 0) { 2644 if (*nargs < 2) { 2645 gctl_error(req, "Invalid number of arguments."); 2646 return (-1); 2647 } 2648 for (i = 1; i < *nargs; i++) { 2649 /* Get disk name. */ 2650 snprintf(arg, sizeof(arg), "arg%d", i); 2651 diskname = gctl_get_asciiparam(req, arg); 2652 if (diskname == NULL) { 2653 gctl_error(req, "No disk name (%s).", arg); 2654 error = -3; 2655 break; 2656 } 2657 2658 /* Try to find provider with specified name. */ 2659 g_topology_lock(); 2660 cp = g_raid_open_consumer(sc, diskname); 2661 if (cp == NULL) { 2662 gctl_error(req, "Can't open disk '%s'.", 2663 diskname); 2664 g_topology_unlock(); 2665 error = -4; 2666 break; 2667 } 2668 pp = cp->provider; 2669 g_topology_unlock(); 2670 2671 pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO); 2672 2673 disk = g_raid_create_disk(sc); 2674 disk->d_consumer = cp; 2675 disk->d_md_data = (void *)pd; 2676 cp->private = disk; 2677 2678 /* Read kernel dumping information. */ 2679 disk->d_kd.offset = 0; 2680 disk->d_kd.length = OFF_MAX; 2681 len = sizeof(disk->d_kd); 2682 g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd); 2683 if (disk->d_kd.di.dumper == NULL) 2684 G_RAID_DEBUG1(2, sc, 2685 "Dumping not supported by %s.", 2686 cp->provider->name); 2687 2688 /* Welcome the "new" disk. */ 2689 g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE); 2690 ddf_meta_create(disk, &mdi->mdio_meta); 2691 sa = ddf_meta_find_sa(&pd->pd_meta, 1); 2692 if (sa != NULL) { 2693 SET32D(&pd->pd_meta, sa->Signature, 2694 DDF_SA_SIGNATURE); 2695 SET8D(&pd->pd_meta, sa->Spare_Type, 0); 2696 SET16D(&pd->pd_meta, sa->Populated_SAEs, 0); 2697 SET16D(&pd->pd_meta, sa->MAX_SAE_Supported, 2698 (GET16(&pd->pd_meta, hdr->Configuration_Record_Length) * 2699 pd->pd_meta.sectorsize - 2700 sizeof(struct ddf_sa_record)) / 2701 sizeof(struct ddf_sa_entry)); 2702 } 2703 if (mdi->mdio_meta.hdr == NULL) 2704 ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta); 2705 else 2706 ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta); 2707 g_raid_md_write_ddf(md, NULL, NULL, NULL); 2708 g_raid_md_ddf_refill(sc); 2709 } 2710 return (error); 2711 } 2712 return (-100); 2713 } 2714 2715 static int 2716 g_raid_md_write_ddf(struct g_raid_md_object *md, struct g_raid_volume *tvol, 2717 struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk) 2718 { 2719 struct g_raid_softc *sc; 2720 struct g_raid_volume *vol; 2721 struct g_raid_subdisk *sd; 2722 struct g_raid_disk *disk; 2723 struct g_raid_md_ddf_perdisk *pd; 2724 struct g_raid_md_ddf_pervolume *pv; 2725 struct g_raid_md_ddf_object *mdi; 2726 struct ddf_meta *gmeta; 2727 struct ddf_vol_meta *vmeta; 2728 struct ddf_vdc_record *vdc; 2729 struct ddf_sa_record *sa; 2730 uint64_t *val2; 2731 int i, j, pos, bvd, size; 2732 2733 sc = md->mdo_softc; 2734 mdi = (struct g_raid_md_ddf_object *)md; 2735 gmeta = &mdi->mdio_meta; 2736 2737 if (sc->sc_stopping == G_RAID_DESTROY_HARD) 2738 return (0); 2739 2740 /* 2741 * Clear disk flags to let only really needed ones to be reset. 2742 * Do it only if there are no volumes in starting state now, 2743 * as they can update disk statuses yet and we may kill innocent. 2744 */ 2745 if (mdi->mdio_starting == 0) { 2746 for (i = 0; i < GET16(gmeta, pdr->Populated_PDEs); i++) { 2747 if (isff(gmeta->pdr->entry[i].PD_GUID, 24)) 2748 continue; 2749 SET16(gmeta, pdr->entry[i].PD_Type, 2750 GET16(gmeta, pdr->entry[i].PD_Type) & 2751 ~(DDF_PDE_PARTICIPATING | 2752 DDF_PDE_GLOBAL_SPARE | DDF_PDE_CONFIG_SPARE)); 2753 if ((GET16(gmeta, pdr->entry[i].PD_State) & 2754 DDF_PDE_PFA) == 0) 2755 SET16(gmeta, pdr->entry[i].PD_State, 0); 2756 } 2757 } 2758 2759 /* Generate/update new per-volume metadata. */ 2760 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 2761 pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data; 2762 if (vol->v_stopping || !pv->pv_started) 2763 continue; 2764 vmeta = &pv->pv_meta; 2765 2766 SET32(vmeta, vdc->Sequence_Number, 2767 GET32(vmeta, vdc->Sequence_Number) + 1); 2768 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E && 2769 vol->v_disks_count % 2 == 0) 2770 SET16(vmeta, vdc->Primary_Element_Count, 2); 2771 else 2772 SET16(vmeta, vdc->Primary_Element_Count, 2773 vol->v_disks_count); 2774 SET8(vmeta, vdc->Stripe_Size, 2775 ffs(vol->v_strip_size / vol->v_sectorsize) - 1); 2776 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E && 2777 vol->v_disks_count % 2 == 0) { 2778 SET8(vmeta, vdc->Primary_RAID_Level, 2779 DDF_VDCR_RAID1); 2780 SET8(vmeta, vdc->RLQ, 0); 2781 SET8(vmeta, vdc->Secondary_Element_Count, 2782 vol->v_disks_count / 2); 2783 SET8(vmeta, vdc->Secondary_RAID_Level, 0); 2784 } else { 2785 SET8(vmeta, vdc->Primary_RAID_Level, 2786 vol->v_raid_level); 2787 SET8(vmeta, vdc->RLQ, 2788 vol->v_raid_level_qualifier); 2789 SET8(vmeta, vdc->Secondary_Element_Count, 1); 2790 SET8(vmeta, vdc->Secondary_RAID_Level, 0); 2791 } 2792 SET8(vmeta, vdc->Secondary_Element_Seq, 0); 2793 SET64(vmeta, vdc->Block_Count, 0); 2794 SET64(vmeta, vdc->VD_Size, vol->v_mediasize / vol->v_sectorsize); 2795 SET16(vmeta, vdc->Block_Size, vol->v_sectorsize); 2796 SET8(vmeta, vdc->Rotate_Parity_count, 2797 fls(vol->v_rotate_parity) - 1); 2798 SET8(vmeta, vdc->MDF_Parity_Disks, vol->v_mdf_pdisks); 2799 SET16(vmeta, vdc->MDF_Parity_Generator_Polynomial, 2800 vol->v_mdf_polynomial); 2801 SET8(vmeta, vdc->MDF_Constant_Generation_Method, 2802 vol->v_mdf_method); 2803 2804 SET16(vmeta, vde->VD_Number, vol->v_global_id); 2805 if (vol->v_state <= G_RAID_VOLUME_S_BROKEN) 2806 SET8(vmeta, vde->VD_State, DDF_VDE_FAILED); 2807 else if (vol->v_state <= G_RAID_VOLUME_S_DEGRADED) 2808 SET8(vmeta, vde->VD_State, DDF_VDE_DEGRADED); 2809 else if (vol->v_state <= G_RAID_VOLUME_S_SUBOPTIMAL) 2810 SET8(vmeta, vde->VD_State, DDF_VDE_PARTIAL); 2811 else 2812 SET8(vmeta, vde->VD_State, DDF_VDE_OPTIMAL); 2813 if (vol->v_dirty || 2814 g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_STALE) > 0 || 2815 g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_RESYNC) > 0) 2816 SET8(vmeta, vde->VD_State, 2817 GET8(vmeta, vde->VD_State) | DDF_VDE_DIRTY); 2818 SET8(vmeta, vde->Init_State, DDF_VDE_INIT_FULL); // XXX 2819 ddf_meta_put_name(vmeta, vol->v_name); 2820 2821 for (i = 0; i < vol->v_disks_count; i++) { 2822 sd = &vol->v_subdisks[i]; 2823 bvd = i / GET16(vmeta, vdc->Primary_Element_Count); 2824 pos = i % GET16(vmeta, vdc->Primary_Element_Count); 2825 disk = sd->sd_disk; 2826 if (disk != NULL) { 2827 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 2828 if (vmeta->bvdc[bvd] == NULL) { 2829 size = GET16(vmeta, 2830 hdr->Configuration_Record_Length) * 2831 vmeta->sectorsize; 2832 vmeta->bvdc[bvd] = malloc(size, 2833 M_MD_DDF, M_WAITOK); 2834 memset(vmeta->bvdc[bvd], 0xff, size); 2835 } 2836 memcpy(vmeta->bvdc[bvd], vmeta->vdc, 2837 sizeof(struct ddf_vdc_record)); 2838 SET8(vmeta, bvdc[bvd]->Secondary_Element_Seq, bvd); 2839 SET64(vmeta, bvdc[bvd]->Block_Count, 2840 sd->sd_size / vol->v_sectorsize); 2841 SET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos], 2842 GET32(&pd->pd_meta, pdd->PD_Reference)); 2843 val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[ 2844 GET16(vmeta, hdr->Max_Primary_Element_Entries)]); 2845 SET64P(vmeta, val2 + pos, 2846 sd->sd_offset / vol->v_sectorsize); 2847 } 2848 if (vmeta->bvdc[bvd] == NULL) 2849 continue; 2850 2851 j = ddf_meta_find_pd(gmeta, NULL, 2852 GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos])); 2853 if (j < 0) 2854 continue; 2855 SET32(gmeta, pdr->entry[j].PD_Type, 2856 GET32(gmeta, pdr->entry[j].PD_Type) | 2857 DDF_PDE_PARTICIPATING); 2858 if (sd->sd_state == G_RAID_SUBDISK_S_NONE) 2859 SET32(gmeta, pdr->entry[j].PD_State, 2860 GET32(gmeta, pdr->entry[j].PD_State) | 2861 (DDF_PDE_FAILED | DDF_PDE_MISSING)); 2862 else if (sd->sd_state == G_RAID_SUBDISK_S_FAILED) 2863 SET32(gmeta, pdr->entry[j].PD_State, 2864 GET32(gmeta, pdr->entry[j].PD_State) | 2865 (DDF_PDE_FAILED | DDF_PDE_PFA)); 2866 else if (sd->sd_state <= G_RAID_SUBDISK_S_REBUILD) 2867 SET32(gmeta, pdr->entry[j].PD_State, 2868 GET32(gmeta, pdr->entry[j].PD_State) | 2869 DDF_PDE_REBUILD); 2870 else 2871 SET32(gmeta, pdr->entry[j].PD_State, 2872 GET32(gmeta, pdr->entry[j].PD_State) | 2873 DDF_PDE_ONLINE); 2874 } 2875 } 2876 2877 /* Mark spare and failed disks as such. */ 2878 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 2879 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 2880 i = ddf_meta_find_pd(gmeta, NULL, 2881 GET32(&pd->pd_meta, pdd->PD_Reference)); 2882 if (i < 0) 2883 continue; 2884 if (disk->d_state == G_RAID_DISK_S_FAILED) { 2885 SET32(gmeta, pdr->entry[i].PD_State, 2886 GET32(gmeta, pdr->entry[i].PD_State) | 2887 (DDF_PDE_FAILED | DDF_PDE_PFA)); 2888 } 2889 if (disk->d_state != G_RAID_DISK_S_SPARE) 2890 continue; 2891 sa = ddf_meta_find_sa(&pd->pd_meta, 0); 2892 if (sa == NULL || 2893 (GET8D(&pd->pd_meta, sa->Spare_Type) & 2894 DDF_SAR_TYPE_DEDICATED) == 0) { 2895 SET16(gmeta, pdr->entry[i].PD_Type, 2896 GET16(gmeta, pdr->entry[i].PD_Type) | 2897 DDF_PDE_GLOBAL_SPARE); 2898 } else { 2899 SET16(gmeta, pdr->entry[i].PD_Type, 2900 GET16(gmeta, pdr->entry[i].PD_Type) | 2901 DDF_PDE_CONFIG_SPARE); 2902 } 2903 SET32(gmeta, pdr->entry[i].PD_State, 2904 GET32(gmeta, pdr->entry[i].PD_State) | 2905 DDF_PDE_ONLINE); 2906 } 2907 2908 /* Remove disks without "participating" flag (unused). */ 2909 for (i = 0, j = -1; i < GET16(gmeta, pdr->Populated_PDEs); i++) { 2910 if (isff(gmeta->pdr->entry[i].PD_GUID, 24)) 2911 continue; 2912 if ((GET16(gmeta, pdr->entry[i].PD_Type) & 2913 (DDF_PDE_PARTICIPATING | 2914 DDF_PDE_GLOBAL_SPARE | DDF_PDE_CONFIG_SPARE)) != 0 || 2915 g_raid_md_ddf_get_disk(sc, 2916 NULL, GET32(gmeta, pdr->entry[i].PD_Reference)) != NULL) 2917 j = i; 2918 else 2919 memset(&gmeta->pdr->entry[i], 0xff, 2920 sizeof(struct ddf_pd_entry)); 2921 } 2922 SET16(gmeta, pdr->Populated_PDEs, j + 1); 2923 2924 /* Update per-disk metadata and write them. */ 2925 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 2926 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 2927 if (disk->d_state != G_RAID_DISK_S_ACTIVE && 2928 disk->d_state != G_RAID_DISK_S_SPARE) 2929 continue; 2930 /* Update PDR. */ 2931 memcpy(pd->pd_meta.pdr, gmeta->pdr, 2932 GET32(&pd->pd_meta, hdr->pdr_length) * 2933 pd->pd_meta.sectorsize); 2934 /* Update VDR. */ 2935 SET16(&pd->pd_meta, vdr->Populated_VDEs, 0); 2936 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 2937 if (vol->v_stopping) 2938 continue; 2939 pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data; 2940 i = ddf_meta_find_vd(&pd->pd_meta, 2941 pv->pv_meta.vde->VD_GUID); 2942 if (i < 0) 2943 i = ddf_meta_find_vd(&pd->pd_meta, NULL); 2944 if (i >= 0) 2945 memcpy(&pd->pd_meta.vdr->entry[i], 2946 pv->pv_meta.vde, 2947 sizeof(struct ddf_vd_entry)); 2948 } 2949 /* Update VDC. */ 2950 if (mdi->mdio_starting == 0) { 2951 /* Remove all VDCs to restore needed later. */ 2952 j = GETCRNUM(&pd->pd_meta); 2953 for (i = 0; i < j; i++) { 2954 vdc = GETVDCPTR(&pd->pd_meta, i); 2955 if (GET32D(&pd->pd_meta, vdc->Signature) != 2956 DDF_VDCR_SIGNATURE) 2957 continue; 2958 SET32D(&pd->pd_meta, vdc->Signature, 0xffffffff); 2959 } 2960 } 2961 TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) { 2962 vol = sd->sd_volume; 2963 if (vol->v_stopping) 2964 continue; 2965 pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data; 2966 vmeta = &pv->pv_meta; 2967 vdc = ddf_meta_find_vdc(&pd->pd_meta, 2968 vmeta->vde->VD_GUID); 2969 if (vdc == NULL) 2970 vdc = ddf_meta_find_vdc(&pd->pd_meta, NULL); 2971 if (vdc != NULL) { 2972 bvd = sd->sd_pos / GET16(vmeta, 2973 vdc->Primary_Element_Count); 2974 memcpy(vdc, vmeta->bvdc[bvd], 2975 GET16(&pd->pd_meta, 2976 hdr->Configuration_Record_Length) * 2977 pd->pd_meta.sectorsize); 2978 } 2979 } 2980 G_RAID_DEBUG(1, "Writing DDF metadata to %s", 2981 g_raid_get_diskname(disk)); 2982 g_raid_md_ddf_print(&pd->pd_meta); 2983 ddf_meta_write(disk->d_consumer, &pd->pd_meta); 2984 } 2985 return (0); 2986 } 2987 2988 static int 2989 g_raid_md_fail_disk_ddf(struct g_raid_md_object *md, 2990 struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk) 2991 { 2992 struct g_raid_softc *sc; 2993 struct g_raid_md_ddf_perdisk *pd; 2994 struct g_raid_subdisk *sd; 2995 int i; 2996 2997 sc = md->mdo_softc; 2998 pd = (struct g_raid_md_ddf_perdisk *)tdisk->d_md_data; 2999 3000 /* We can't fail disk that is not a part of array now. */ 3001 if (tdisk->d_state != G_RAID_DISK_S_ACTIVE) 3002 return (-1); 3003 3004 /* 3005 * Mark disk as failed in metadata and try to write that metadata 3006 * to the disk itself to prevent it's later resurrection as STALE. 3007 */ 3008 G_RAID_DEBUG(1, "Writing DDF metadata to %s", 3009 g_raid_get_diskname(tdisk)); 3010 i = ddf_meta_find_pd(&pd->pd_meta, NULL, GET32(&pd->pd_meta, pdd->PD_Reference)); 3011 SET16(&pd->pd_meta, pdr->entry[i].PD_State, DDF_PDE_FAILED | DDF_PDE_PFA); 3012 if (tdisk->d_consumer != NULL) 3013 ddf_meta_write(tdisk->d_consumer, &pd->pd_meta); 3014 3015 /* Change states. */ 3016 g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED); 3017 TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) { 3018 g_raid_change_subdisk_state(sd, 3019 G_RAID_SUBDISK_S_FAILED); 3020 g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED, 3021 G_RAID_EVENT_SUBDISK); 3022 } 3023 3024 /* Write updated metadata to remaining disks. */ 3025 g_raid_md_write_ddf(md, NULL, NULL, tdisk); 3026 3027 g_raid_md_ddf_refill(sc); 3028 return (0); 3029 } 3030 3031 static int 3032 g_raid_md_free_disk_ddf(struct g_raid_md_object *md, 3033 struct g_raid_disk *disk) 3034 { 3035 struct g_raid_md_ddf_perdisk *pd; 3036 3037 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data; 3038 ddf_meta_free(&pd->pd_meta); 3039 free(pd, M_MD_DDF); 3040 disk->d_md_data = NULL; 3041 return (0); 3042 } 3043 3044 static int 3045 g_raid_md_free_volume_ddf(struct g_raid_md_object *md, 3046 struct g_raid_volume *vol) 3047 { 3048 struct g_raid_md_ddf_object *mdi; 3049 struct g_raid_md_ddf_pervolume *pv; 3050 3051 mdi = (struct g_raid_md_ddf_object *)md; 3052 pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data; 3053 ddf_vol_meta_free(&pv->pv_meta); 3054 if (!pv->pv_started) { 3055 pv->pv_started = 1; 3056 mdi->mdio_starting--; 3057 callout_stop(&pv->pv_start_co); 3058 } 3059 free(pv, M_MD_DDF); 3060 vol->v_md_data = NULL; 3061 return (0); 3062 } 3063 3064 static int 3065 g_raid_md_free_ddf(struct g_raid_md_object *md) 3066 { 3067 struct g_raid_md_ddf_object *mdi; 3068 3069 mdi = (struct g_raid_md_ddf_object *)md; 3070 if (!mdi->mdio_started) { 3071 mdi->mdio_started = 0; 3072 callout_stop(&mdi->mdio_start_co); 3073 G_RAID_DEBUG1(1, md->mdo_softc, 3074 "root_mount_rel %p", mdi->mdio_rootmount); 3075 root_mount_rel(mdi->mdio_rootmount); 3076 mdi->mdio_rootmount = NULL; 3077 } 3078 ddf_meta_free(&mdi->mdio_meta); 3079 return (0); 3080 } 3081 3082 G_RAID_MD_DECLARE(ddf, "DDF"); 3083