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