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