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