1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2012 Andrey V. Elsukov <ae@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 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 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/diskmbr.h> 35 #include <sys/endian.h> 36 #include <sys/gpt.h> 37 #include <sys/kernel.h> 38 #include <sys/kobj.h> 39 #include <sys/limits.h> 40 #include <sys/lock.h> 41 #include <sys/malloc.h> 42 #include <sys/mutex.h> 43 #include <sys/queue.h> 44 #include <sys/sbuf.h> 45 #include <sys/systm.h> 46 #include <sys/sysctl.h> 47 #include <sys/uuid.h> 48 #include <geom/geom.h> 49 #include <geom/part/g_part.h> 50 51 #include "g_part_if.h" 52 53 FEATURE(geom_part_ldm, "GEOM partitioning class for LDM support"); 54 55 SYSCTL_DECL(_kern_geom_part); 56 static SYSCTL_NODE(_kern_geom_part, OID_AUTO, ldm, 57 CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 58 "GEOM_PART_LDM Logical Disk Manager"); 59 60 static u_int ldm_debug = 0; 61 SYSCTL_UINT(_kern_geom_part_ldm, OID_AUTO, debug, 62 CTLFLAG_RWTUN, &ldm_debug, 0, "Debug level"); 63 64 /* 65 * This allows access to mirrored LDM volumes. Since we do not 66 * doing mirroring here, it is not enabled by default. 67 */ 68 static u_int show_mirrors = 0; 69 SYSCTL_UINT(_kern_geom_part_ldm, OID_AUTO, show_mirrors, 70 CTLFLAG_RWTUN, &show_mirrors, 0, "Show mirrored volumes"); 71 72 #define LDM_DEBUG(lvl, fmt, ...) do { \ 73 if (ldm_debug >= (lvl)) { \ 74 printf("GEOM_PART: " fmt "\n", __VA_ARGS__); \ 75 } \ 76 } while (0) 77 #define LDM_DUMP(buf, size) do { \ 78 if (ldm_debug > 1) { \ 79 hexdump(buf, size, NULL, 0); \ 80 } \ 81 } while (0) 82 83 /* 84 * There are internal representations of LDM structures. 85 * 86 * We do not keep all fields of on-disk structures, only most useful. 87 * All numbers in an on-disk structures are in big-endian format. 88 */ 89 90 /* 91 * Private header is 512 bytes long. There are three copies on each disk. 92 * Offset and sizes are in sectors. Location of each copy: 93 * - the first offset is relative to the disk start; 94 * - the second and third offset are relative to the LDM database start. 95 * 96 * On a disk partitioned with GPT, the LDM has not first private header. 97 */ 98 #define LDM_PH_MBRINDEX 0 99 #define LDM_PH_GPTINDEX 2 100 static const uint64_t ldm_ph_off[] = {6, 1856, 2047}; 101 #define LDM_VERSION_2K 0x2000b 102 #define LDM_VERSION_VISTA 0x2000c 103 #define LDM_PH_VERSION_OFF 0x00c 104 #define LDM_PH_DISKGUID_OFF 0x030 105 #define LDM_PH_DGGUID_OFF 0x0b0 106 #define LDM_PH_DGNAME_OFF 0x0f0 107 #define LDM_PH_START_OFF 0x11b 108 #define LDM_PH_SIZE_OFF 0x123 109 #define LDM_PH_DB_OFF 0x12b 110 #define LDM_PH_DBSIZE_OFF 0x133 111 #define LDM_PH_TH1_OFF 0x13b 112 #define LDM_PH_TH2_OFF 0x143 113 #define LDM_PH_CONFSIZE_OFF 0x153 114 #define LDM_PH_LOGSIZE_OFF 0x15b 115 #define LDM_PH_SIGN "PRIVHEAD" 116 struct ldm_privhdr { 117 struct uuid disk_guid; 118 struct uuid dg_guid; 119 u_char dg_name[32]; 120 uint64_t start; /* logical disk start */ 121 uint64_t size; /* logical disk size */ 122 uint64_t db_offset; /* LDM database start */ 123 #define LDM_DB_SIZE 2048 124 uint64_t db_size; /* LDM database size */ 125 #define LDM_TH_COUNT 2 126 uint64_t th_offset[LDM_TH_COUNT]; /* TOC header offsets */ 127 uint64_t conf_size; /* configuration size */ 128 uint64_t log_size; /* size of log */ 129 }; 130 131 /* 132 * Table of contents header is 512 bytes long. 133 * There are two identical copies at offsets from the private header. 134 * Offsets are relative to the LDM database start. 135 */ 136 #define LDM_TH_SIGN "TOCBLOCK" 137 #define LDM_TH_NAME1 "config" 138 #define LDM_TH_NAME2 "log" 139 #define LDM_TH_NAME1_OFF 0x024 140 #define LDM_TH_CONF_OFF 0x02e 141 #define LDM_TH_CONFSIZE_OFF 0x036 142 #define LDM_TH_NAME2_OFF 0x046 143 #define LDM_TH_LOG_OFF 0x050 144 #define LDM_TH_LOGSIZE_OFF 0x058 145 struct ldm_tochdr { 146 uint64_t conf_offset; /* configuration offset */ 147 uint64_t log_offset; /* log offset */ 148 }; 149 150 /* 151 * LDM database header is 512 bytes long. 152 */ 153 #define LDM_VMDB_SIGN "VMDB" 154 #define LDM_DB_LASTSEQ_OFF 0x004 155 #define LDM_DB_SIZE_OFF 0x008 156 #define LDM_DB_STATUS_OFF 0x010 157 #define LDM_DB_VERSION_OFF 0x012 158 #define LDM_DB_DGNAME_OFF 0x016 159 #define LDM_DB_DGGUID_OFF 0x035 160 struct ldm_vmdbhdr { 161 uint32_t last_seq; /* sequence number of last VBLK */ 162 uint32_t size; /* size of VBLK */ 163 }; 164 165 /* 166 * The LDM database configuration section contains VMDB header and 167 * many VBLKs. Each VBLK represents a disk group, disk partition, 168 * component or volume. 169 * 170 * The most interesting for us are volumes, they are represents 171 * partitions in the GEOM_PART meaning. But volume VBLK does not 172 * contain all information needed to create GEOM provider. And we 173 * should get this information from the related VBLK. This is how 174 * VBLK releated: 175 * Volumes <- Components <- Partitions -> Disks 176 * 177 * One volume can contain several components. In this case LDM 178 * does mirroring of volume data to each component. 179 * 180 * Also each component can contain several partitions (spanned or 181 * striped volumes). 182 */ 183 184 struct ldm_component { 185 uint64_t id; /* object id */ 186 uint64_t vol_id; /* parent volume object id */ 187 188 int count; 189 LIST_HEAD(, ldm_partition) partitions; 190 LIST_ENTRY(ldm_component) entry; 191 }; 192 193 struct ldm_volume { 194 uint64_t id; /* object id */ 195 uint64_t size; /* volume size */ 196 uint8_t number; /* used for ordering */ 197 uint8_t part_type; /* partition type */ 198 199 int count; 200 LIST_HEAD(, ldm_component) components; 201 LIST_ENTRY(ldm_volume) entry; 202 }; 203 204 struct ldm_disk { 205 uint64_t id; /* object id */ 206 struct uuid guid; /* disk guid */ 207 208 LIST_ENTRY(ldm_disk) entry; 209 }; 210 211 #if 0 212 struct ldm_disk_group { 213 uint64_t id; /* object id */ 214 struct uuid guid; /* disk group guid */ 215 u_char name[32]; /* disk group name */ 216 217 LIST_ENTRY(ldm_disk_group) entry; 218 }; 219 #endif 220 221 struct ldm_partition { 222 uint64_t id; /* object id */ 223 uint64_t disk_id; /* disk object id */ 224 uint64_t comp_id; /* parent component object id */ 225 uint64_t start; /* offset relative to disk start */ 226 uint64_t offset; /* offset for spanned volumes */ 227 uint64_t size; /* partition size */ 228 229 LIST_ENTRY(ldm_partition) entry; 230 }; 231 232 /* 233 * Each VBLK is 128 bytes long and has standard 16 bytes header. 234 * Some of VBLK's fields are fixed size, but others has variable size. 235 * Fields with variable size are prefixed with one byte length marker. 236 * Some fields are strings and also can have fixed size and variable. 237 * Strings with fixed size are NULL-terminated, others are not. 238 * All VBLKs have same several first fields: 239 * Offset Size Description 240 * ---------------+---------------+-------------------------- 241 * 0x00 16 standard VBLK header 242 * 0x10 2 update status 243 * 0x13 1 VBLK type 244 * 0x18 PS object id 245 * 0x18+ PN object name 246 * 247 * o Offset 0x18+ means '0x18 + length of all variable-width fields' 248 * o 'P' in size column means 'prefixed' (variable-width), 249 * 'S' - string, 'N' - number. 250 */ 251 #define LDM_VBLK_SIGN "VBLK" 252 #define LDM_VBLK_SEQ_OFF 0x04 253 #define LDM_VBLK_GROUP_OFF 0x08 254 #define LDM_VBLK_INDEX_OFF 0x0c 255 #define LDM_VBLK_COUNT_OFF 0x0e 256 #define LDM_VBLK_TYPE_OFF 0x13 257 #define LDM_VBLK_OID_OFF 0x18 258 struct ldm_vblkhdr { 259 uint32_t seq; /* sequence number */ 260 uint32_t group; /* group number */ 261 uint16_t index; /* index in the group */ 262 uint16_t count; /* number of entries in the group */ 263 }; 264 265 #define LDM_VBLK_T_COMPONENT 0x32 266 #define LDM_VBLK_T_PARTITION 0x33 267 #define LDM_VBLK_T_DISK 0x34 268 #define LDM_VBLK_T_DISKGROUP 0x35 269 #define LDM_VBLK_T_DISK4 0x44 270 #define LDM_VBLK_T_DISKGROUP4 0x45 271 #define LDM_VBLK_T_VOLUME 0x51 272 struct ldm_vblk { 273 uint8_t type; /* VBLK type */ 274 union { 275 uint64_t id; 276 struct ldm_volume vol; 277 struct ldm_component comp; 278 struct ldm_disk disk; 279 struct ldm_partition part; 280 #if 0 281 struct ldm_disk_group disk_group; 282 #endif 283 } u; 284 LIST_ENTRY(ldm_vblk) entry; 285 }; 286 287 /* 288 * Some VBLKs contains a bit more data than can fit into 128 bytes. These 289 * VBLKs are called eXtended VBLK. Before parsing, the data from these VBLK 290 * should be placed into continuous memory buffer. We can determine xVBLK 291 * by the count field in the standard VBLK header (count > 1). 292 */ 293 struct ldm_xvblk { 294 uint32_t group; /* xVBLK group number */ 295 uint32_t size; /* the total size of xVBLK */ 296 uint8_t map; /* bitmask of currently saved VBLKs */ 297 u_char *data; /* xVBLK data */ 298 299 LIST_ENTRY(ldm_xvblk) entry; 300 }; 301 302 /* The internal representation of LDM database. */ 303 struct ldm_db { 304 struct ldm_privhdr ph; /* private header */ 305 struct ldm_tochdr th; /* TOC header */ 306 struct ldm_vmdbhdr dh; /* VMDB header */ 307 308 LIST_HEAD(, ldm_volume) volumes; 309 LIST_HEAD(, ldm_disk) disks; 310 LIST_HEAD(, ldm_vblk) vblks; 311 LIST_HEAD(, ldm_xvblk) xvblks; 312 }; 313 314 static struct uuid gpt_uuid_ms_ldm_metadata = GPT_ENT_TYPE_MS_LDM_METADATA; 315 316 struct g_part_ldm_table { 317 struct g_part_table base; 318 uint64_t db_offset; 319 int is_gpt; 320 }; 321 struct g_part_ldm_entry { 322 struct g_part_entry base; 323 uint8_t type; 324 }; 325 326 static int g_part_ldm_add(struct g_part_table *, struct g_part_entry *, 327 struct g_part_parms *); 328 static int g_part_ldm_bootcode(struct g_part_table *, struct g_part_parms *); 329 static int g_part_ldm_create(struct g_part_table *, struct g_part_parms *); 330 static int g_part_ldm_destroy(struct g_part_table *, struct g_part_parms *); 331 static void g_part_ldm_dumpconf(struct g_part_table *, struct g_part_entry *, 332 struct sbuf *, const char *); 333 static int g_part_ldm_dumpto(struct g_part_table *, struct g_part_entry *); 334 static int g_part_ldm_modify(struct g_part_table *, struct g_part_entry *, 335 struct g_part_parms *); 336 static const char *g_part_ldm_name(struct g_part_table *, struct g_part_entry *, 337 char *, size_t); 338 static int g_part_ldm_probe(struct g_part_table *, struct g_consumer *); 339 static int g_part_ldm_read(struct g_part_table *, struct g_consumer *); 340 static const char *g_part_ldm_type(struct g_part_table *, struct g_part_entry *, 341 char *, size_t); 342 static int g_part_ldm_write(struct g_part_table *, struct g_consumer *); 343 344 static kobj_method_t g_part_ldm_methods[] = { 345 KOBJMETHOD(g_part_add, g_part_ldm_add), 346 KOBJMETHOD(g_part_bootcode, g_part_ldm_bootcode), 347 KOBJMETHOD(g_part_create, g_part_ldm_create), 348 KOBJMETHOD(g_part_destroy, g_part_ldm_destroy), 349 KOBJMETHOD(g_part_dumpconf, g_part_ldm_dumpconf), 350 KOBJMETHOD(g_part_dumpto, g_part_ldm_dumpto), 351 KOBJMETHOD(g_part_modify, g_part_ldm_modify), 352 KOBJMETHOD(g_part_name, g_part_ldm_name), 353 KOBJMETHOD(g_part_probe, g_part_ldm_probe), 354 KOBJMETHOD(g_part_read, g_part_ldm_read), 355 KOBJMETHOD(g_part_type, g_part_ldm_type), 356 KOBJMETHOD(g_part_write, g_part_ldm_write), 357 { 0, 0 } 358 }; 359 360 static struct g_part_scheme g_part_ldm_scheme = { 361 "LDM", 362 g_part_ldm_methods, 363 sizeof(struct g_part_ldm_table), 364 .gps_entrysz = sizeof(struct g_part_ldm_entry) 365 }; 366 G_PART_SCHEME_DECLARE(g_part_ldm); 367 MODULE_VERSION(geom_part_ldm, 0); 368 369 static struct g_part_ldm_alias { 370 u_char typ; 371 int alias; 372 } ldm_alias_match[] = { 373 { DOSPTYP_386BSD, G_PART_ALIAS_FREEBSD }, 374 { DOSPTYP_FAT32, G_PART_ALIAS_MS_FAT32 }, 375 { DOSPTYP_FAT32LBA, G_PART_ALIAS_MS_FAT32LBA }, 376 { DOSPTYP_LDM, G_PART_ALIAS_MS_LDM_DATA }, 377 { DOSPTYP_LINLVM, G_PART_ALIAS_LINUX_LVM }, 378 { DOSPTYP_LINRAID, G_PART_ALIAS_LINUX_RAID }, 379 { DOSPTYP_LINSWP, G_PART_ALIAS_LINUX_SWAP }, 380 { DOSPTYP_LINUX, G_PART_ALIAS_LINUX_DATA }, 381 { DOSPTYP_NTFS, G_PART_ALIAS_MS_NTFS }, 382 }; 383 384 static u_char* 385 ldm_privhdr_read(struct g_consumer *cp, uint64_t off, int *error) 386 { 387 struct g_provider *pp; 388 u_char *buf; 389 390 pp = cp->provider; 391 buf = g_read_data(cp, off, pp->sectorsize, error); 392 if (buf == NULL) 393 return (NULL); 394 395 if (memcmp(buf, LDM_PH_SIGN, strlen(LDM_PH_SIGN)) != 0) { 396 LDM_DEBUG(1, "%s: invalid LDM private header signature", 397 pp->name); 398 g_free(buf); 399 buf = NULL; 400 *error = EINVAL; 401 } 402 return (buf); 403 } 404 405 static int 406 ldm_privhdr_parse(struct g_consumer *cp, struct ldm_privhdr *hdr, 407 const u_char *buf) 408 { 409 uint32_t version; 410 int error; 411 412 memset(hdr, 0, sizeof(*hdr)); 413 version = be32dec(buf + LDM_PH_VERSION_OFF); 414 if (version != LDM_VERSION_2K && 415 version != LDM_VERSION_VISTA) { 416 LDM_DEBUG(0, "%s: unsupported LDM version %u.%u", 417 cp->provider->name, version >> 16, 418 version & 0xFFFF); 419 return (ENXIO); 420 } 421 error = parse_uuid(buf + LDM_PH_DISKGUID_OFF, &hdr->disk_guid); 422 if (error != 0) 423 return (error); 424 error = parse_uuid(buf + LDM_PH_DGGUID_OFF, &hdr->dg_guid); 425 if (error != 0) 426 return (error); 427 strncpy(hdr->dg_name, buf + LDM_PH_DGNAME_OFF, sizeof(hdr->dg_name)); 428 hdr->start = be64dec(buf + LDM_PH_START_OFF); 429 hdr->size = be64dec(buf + LDM_PH_SIZE_OFF); 430 hdr->db_offset = be64dec(buf + LDM_PH_DB_OFF); 431 hdr->db_size = be64dec(buf + LDM_PH_DBSIZE_OFF); 432 hdr->th_offset[0] = be64dec(buf + LDM_PH_TH1_OFF); 433 hdr->th_offset[1] = be64dec(buf + LDM_PH_TH2_OFF); 434 hdr->conf_size = be64dec(buf + LDM_PH_CONFSIZE_OFF); 435 hdr->log_size = be64dec(buf + LDM_PH_LOGSIZE_OFF); 436 return (0); 437 } 438 439 static int 440 ldm_privhdr_check(struct ldm_db *db, struct g_consumer *cp, int is_gpt) 441 { 442 struct g_consumer *cp2; 443 struct g_provider *pp; 444 struct ldm_privhdr hdr; 445 uint64_t offset, last; 446 int error, found, i; 447 u_char *buf; 448 449 pp = cp->provider; 450 if (is_gpt) { 451 /* 452 * The last LBA is used in several checks below, for the 453 * GPT case it should be calculated relative to the whole 454 * disk. 455 */ 456 cp2 = LIST_FIRST(&pp->geom->consumer); 457 last = 458 cp2->provider->mediasize / cp2->provider->sectorsize - 1; 459 } else 460 last = pp->mediasize / pp->sectorsize - 1; 461 for (found = 0, i = is_gpt; i < nitems(ldm_ph_off); i++) { 462 offset = ldm_ph_off[i]; 463 /* 464 * In the GPT case consumer is attached to the LDM metadata 465 * partition and we don't need add db_offset. 466 */ 467 if (!is_gpt) 468 offset += db->ph.db_offset; 469 if (i == LDM_PH_MBRINDEX) { 470 /* 471 * Prepare to errors and setup new base offset 472 * to read backup private headers. Assume that LDM 473 * database is in the last 1Mbyte area. 474 */ 475 db->ph.db_offset = last - LDM_DB_SIZE; 476 } 477 buf = ldm_privhdr_read(cp, offset * pp->sectorsize, &error); 478 if (buf == NULL) { 479 LDM_DEBUG(1, "%s: failed to read private header " 480 "%d at LBA %ju", pp->name, i, (uintmax_t)offset); 481 continue; 482 } 483 error = ldm_privhdr_parse(cp, &hdr, buf); 484 if (error != 0) { 485 LDM_DEBUG(1, "%s: failed to parse private " 486 "header %d", pp->name, i); 487 LDM_DUMP(buf, pp->sectorsize); 488 g_free(buf); 489 continue; 490 } 491 g_free(buf); 492 if (hdr.start > last || 493 hdr.start + hdr.size - 1 > last || 494 (hdr.start + hdr.size - 1 > hdr.db_offset && !is_gpt) || 495 hdr.db_size != LDM_DB_SIZE || 496 hdr.db_offset + LDM_DB_SIZE - 1 > last || 497 hdr.th_offset[0] >= LDM_DB_SIZE || 498 hdr.th_offset[1] >= LDM_DB_SIZE || 499 hdr.conf_size + hdr.log_size >= LDM_DB_SIZE) { 500 LDM_DEBUG(1, "%s: invalid values in the " 501 "private header %d", pp->name, i); 502 LDM_DEBUG(2, "%s: start: %jd, size: %jd, " 503 "db_offset: %jd, db_size: %jd, th_offset0: %jd, " 504 "th_offset1: %jd, conf_size: %jd, log_size: %jd, " 505 "last: %jd", pp->name, hdr.start, hdr.size, 506 hdr.db_offset, hdr.db_size, hdr.th_offset[0], 507 hdr.th_offset[1], hdr.conf_size, hdr.log_size, 508 last); 509 continue; 510 } 511 if (found != 0 && memcmp(&db->ph, &hdr, sizeof(hdr)) != 0) { 512 LDM_DEBUG(0, "%s: private headers are not equal", 513 pp->name); 514 if (i > 1) { 515 /* 516 * We have different headers in the LDM. 517 * We can not trust this metadata. 518 */ 519 LDM_DEBUG(0, "%s: refuse LDM metadata", 520 pp->name); 521 return (EINVAL); 522 } 523 /* 524 * We already have read primary private header 525 * and it differs from this backup one. 526 * Prefer the backup header and save it. 527 */ 528 found = 0; 529 } 530 if (found == 0) 531 memcpy(&db->ph, &hdr, sizeof(hdr)); 532 found = 1; 533 } 534 if (found == 0) { 535 LDM_DEBUG(1, "%s: valid LDM private header not found", 536 pp->name); 537 return (ENXIO); 538 } 539 return (0); 540 } 541 542 static int 543 ldm_gpt_check(struct ldm_db *db, struct g_consumer *cp) 544 { 545 struct g_part_table *gpt; 546 struct g_part_entry *e; 547 struct g_consumer *cp2; 548 int error; 549 550 cp2 = LIST_NEXT(cp, consumer); 551 g_topology_lock(); 552 gpt = cp->provider->geom->softc; 553 error = 0; 554 LIST_FOREACH(e, &gpt->gpt_entry, gpe_entry) { 555 if (cp->provider == e->gpe_pp) { 556 /* ms-ldm-metadata partition */ 557 if (e->gpe_start != db->ph.db_offset || 558 e->gpe_end != db->ph.db_offset + LDM_DB_SIZE - 1) 559 error++; 560 } else if (cp2->provider == e->gpe_pp) { 561 /* ms-ldm-data partition */ 562 if (e->gpe_start != db->ph.start || 563 e->gpe_end != db->ph.start + db->ph.size - 1) 564 error++; 565 } 566 if (error != 0) { 567 LDM_DEBUG(0, "%s: GPT partition %d boundaries " 568 "do not match with the LDM metadata", 569 e->gpe_pp->name, e->gpe_index); 570 error = ENXIO; 571 break; 572 } 573 } 574 g_topology_unlock(); 575 return (error); 576 } 577 578 static int 579 ldm_tochdr_check(struct ldm_db *db, struct g_consumer *cp) 580 { 581 struct g_provider *pp; 582 struct ldm_tochdr hdr; 583 uint64_t offset, conf_size, log_size; 584 int error, found, i; 585 u_char *buf; 586 587 pp = cp->provider; 588 for (i = 0, found = 0; i < LDM_TH_COUNT; i++) { 589 offset = db->ph.db_offset + db->ph.th_offset[i]; 590 buf = g_read_data(cp, 591 offset * pp->sectorsize, pp->sectorsize, &error); 592 if (buf == NULL) { 593 LDM_DEBUG(1, "%s: failed to read TOC header " 594 "at LBA %ju", pp->name, (uintmax_t)offset); 595 continue; 596 } 597 if (memcmp(buf, LDM_TH_SIGN, strlen(LDM_TH_SIGN)) != 0 || 598 memcmp(buf + LDM_TH_NAME1_OFF, LDM_TH_NAME1, 599 strlen(LDM_TH_NAME1)) != 0 || 600 memcmp(buf + LDM_TH_NAME2_OFF, LDM_TH_NAME2, 601 strlen(LDM_TH_NAME2)) != 0) { 602 LDM_DEBUG(1, "%s: failed to parse TOC header " 603 "at LBA %ju", pp->name, (uintmax_t)offset); 604 LDM_DUMP(buf, pp->sectorsize); 605 g_free(buf); 606 continue; 607 } 608 hdr.conf_offset = be64dec(buf + LDM_TH_CONF_OFF); 609 hdr.log_offset = be64dec(buf + LDM_TH_LOG_OFF); 610 conf_size = be64dec(buf + LDM_TH_CONFSIZE_OFF); 611 log_size = be64dec(buf + LDM_TH_LOGSIZE_OFF); 612 if (conf_size != db->ph.conf_size || 613 hdr.conf_offset + conf_size >= LDM_DB_SIZE || 614 log_size != db->ph.log_size || 615 hdr.log_offset + log_size >= LDM_DB_SIZE) { 616 LDM_DEBUG(1, "%s: invalid values in the " 617 "TOC header at LBA %ju", pp->name, 618 (uintmax_t)offset); 619 LDM_DUMP(buf, pp->sectorsize); 620 g_free(buf); 621 continue; 622 } 623 g_free(buf); 624 if (found == 0) 625 memcpy(&db->th, &hdr, sizeof(hdr)); 626 found = 1; 627 } 628 if (found == 0) { 629 LDM_DEBUG(0, "%s: valid LDM TOC header not found.", 630 pp->name); 631 return (ENXIO); 632 } 633 return (0); 634 } 635 636 static int 637 ldm_vmdbhdr_check(struct ldm_db *db, struct g_consumer *cp) 638 { 639 struct g_provider *pp; 640 struct uuid dg_guid; 641 uint64_t offset; 642 uint32_t version; 643 int error; 644 u_char *buf; 645 646 pp = cp->provider; 647 offset = db->ph.db_offset + db->th.conf_offset; 648 buf = g_read_data(cp, offset * pp->sectorsize, pp->sectorsize, 649 &error); 650 if (buf == NULL) { 651 LDM_DEBUG(0, "%s: failed to read VMDB header at " 652 "LBA %ju", pp->name, (uintmax_t)offset); 653 return (error); 654 } 655 if (memcmp(buf, LDM_VMDB_SIGN, strlen(LDM_VMDB_SIGN)) != 0) { 656 g_free(buf); 657 LDM_DEBUG(0, "%s: failed to parse VMDB header at " 658 "LBA %ju", pp->name, (uintmax_t)offset); 659 return (ENXIO); 660 } 661 /* Check version. */ 662 version = be32dec(buf + LDM_DB_VERSION_OFF); 663 if (version != 0x4000A) { 664 g_free(buf); 665 LDM_DEBUG(0, "%s: unsupported VMDB version %u.%u", 666 pp->name, version >> 16, version & 0xFFFF); 667 return (ENXIO); 668 } 669 /* 670 * Check VMDB update status: 671 * 1 - in a consistent state; 672 * 2 - in a creation phase; 673 * 3 - in a deletion phase; 674 */ 675 if (be16dec(buf + LDM_DB_STATUS_OFF) != 1) { 676 g_free(buf); 677 LDM_DEBUG(0, "%s: VMDB is not in a consistent state", 678 pp->name); 679 return (ENXIO); 680 } 681 db->dh.last_seq = be32dec(buf + LDM_DB_LASTSEQ_OFF); 682 db->dh.size = be32dec(buf + LDM_DB_SIZE_OFF); 683 error = parse_uuid(buf + LDM_DB_DGGUID_OFF, &dg_guid); 684 /* Compare disk group name and guid from VMDB and private headers */ 685 if (error != 0 || db->dh.size == 0 || 686 pp->sectorsize % db->dh.size != 0 || 687 strncmp(buf + LDM_DB_DGNAME_OFF, db->ph.dg_name, 31) != 0 || 688 memcmp(&dg_guid, &db->ph.dg_guid, sizeof(dg_guid)) != 0 || 689 db->dh.size * db->dh.last_seq > 690 db->ph.conf_size * pp->sectorsize) { 691 LDM_DEBUG(0, "%s: invalid values in the VMDB header", 692 pp->name); 693 LDM_DUMP(buf, pp->sectorsize); 694 g_free(buf); 695 return (EINVAL); 696 } 697 g_free(buf); 698 return (0); 699 } 700 701 static int 702 ldm_xvblk_handle(struct ldm_db *db, struct ldm_vblkhdr *vh, const u_char *p) 703 { 704 struct ldm_xvblk *blk; 705 size_t size; 706 707 size = db->dh.size - 16; 708 LIST_FOREACH(blk, &db->xvblks, entry) 709 if (blk->group == vh->group) 710 break; 711 if (blk == NULL) { 712 blk = g_malloc(sizeof(*blk), M_WAITOK | M_ZERO); 713 blk->group = vh->group; 714 blk->size = size * vh->count + 16; 715 blk->data = g_malloc(blk->size, M_WAITOK | M_ZERO); 716 blk->map = 0xFF << vh->count; 717 LIST_INSERT_HEAD(&db->xvblks, blk, entry); 718 } 719 if ((blk->map & (1 << vh->index)) != 0) { 720 /* Block with given index has been already saved. */ 721 return (EINVAL); 722 } 723 /* Copy the data block to the place related to index. */ 724 memcpy(blk->data + size * vh->index + 16, p + 16, size); 725 blk->map |= 1 << vh->index; 726 return (0); 727 } 728 729 /* Read the variable-width numeric field and return new offset */ 730 static int 731 ldm_vnum_get(const u_char *buf, int offset, uint64_t *result, size_t range) 732 { 733 uint64_t num; 734 uint8_t len; 735 736 len = buf[offset++]; 737 if (len > sizeof(uint64_t) || len + offset >= range) 738 return (-1); 739 for (num = 0; len > 0; len--) 740 num = (num << 8) | buf[offset++]; 741 *result = num; 742 return (offset); 743 } 744 745 /* Read the variable-width string and return new offset */ 746 static int 747 ldm_vstr_get(const u_char *buf, int offset, u_char *result, 748 size_t maxlen, size_t range) 749 { 750 uint8_t len; 751 752 len = buf[offset++]; 753 if (len >= maxlen || len + offset >= range) 754 return (-1); 755 memcpy(result, buf + offset, len); 756 result[len] = '\0'; 757 return (offset + len); 758 } 759 760 /* Just skip the variable-width variable and return new offset */ 761 static int 762 ldm_vparm_skip(const u_char *buf, int offset, size_t range) 763 { 764 uint8_t len; 765 766 len = buf[offset++]; 767 if (offset + len >= range) 768 return (-1); 769 770 return (offset + len); 771 } 772 773 static int 774 ldm_vblk_handle(struct ldm_db *db, const u_char *p, size_t size) 775 { 776 struct ldm_vblk *blk; 777 struct ldm_volume *volume, *last; 778 const char *errstr; 779 u_char vstr[64]; 780 int error, offset; 781 782 blk = g_malloc(sizeof(*blk), M_WAITOK | M_ZERO); 783 blk->type = p[LDM_VBLK_TYPE_OFF]; 784 offset = ldm_vnum_get(p, LDM_VBLK_OID_OFF, &blk->u.id, size); 785 if (offset < 0) { 786 errstr = "object id"; 787 goto fail; 788 } 789 offset = ldm_vstr_get(p, offset, vstr, sizeof(vstr), size); 790 if (offset < 0) { 791 errstr = "object name"; 792 goto fail; 793 } 794 switch (blk->type) { 795 /* 796 * Component VBLK fields: 797 * Offset Size Description 798 * ------------+-------+------------------------ 799 * 0x18+ PS volume state 800 * 0x18+5 PN component children count 801 * 0x1D+16 PN parent's volume object id 802 * 0x2D+1 PN stripe size 803 */ 804 case LDM_VBLK_T_COMPONENT: 805 offset = ldm_vparm_skip(p, offset, size); 806 if (offset < 0) { 807 errstr = "volume state"; 808 goto fail; 809 } 810 offset = ldm_vparm_skip(p, offset + 5, size); 811 if (offset < 0) { 812 errstr = "children count"; 813 goto fail; 814 } 815 offset = ldm_vnum_get(p, offset + 16, 816 &blk->u.comp.vol_id, size); 817 if (offset < 0) { 818 errstr = "volume id"; 819 goto fail; 820 } 821 break; 822 /* 823 * Partition VBLK fields: 824 * Offset Size Description 825 * ------------+-------+------------------------ 826 * 0x18+12 8 partition start offset 827 * 0x18+20 8 volume offset 828 * 0x18+28 PN partition size 829 * 0x34+ PN parent's component object id 830 * 0x34+ PN disk's object id 831 */ 832 case LDM_VBLK_T_PARTITION: 833 if (offset + 28 >= size) { 834 errstr = "too small buffer"; 835 goto fail; 836 } 837 blk->u.part.start = be64dec(p + offset + 12); 838 blk->u.part.offset = be64dec(p + offset + 20); 839 offset = ldm_vnum_get(p, offset + 28, &blk->u.part.size, size); 840 if (offset < 0) { 841 errstr = "partition size"; 842 goto fail; 843 } 844 offset = ldm_vnum_get(p, offset, &blk->u.part.comp_id, size); 845 if (offset < 0) { 846 errstr = "component id"; 847 goto fail; 848 } 849 offset = ldm_vnum_get(p, offset, &blk->u.part.disk_id, size); 850 if (offset < 0) { 851 errstr = "disk id"; 852 goto fail; 853 } 854 break; 855 /* 856 * Disk VBLK fields: 857 * Offset Size Description 858 * ------------+-------+------------------------ 859 * 0x18+ PS disk GUID 860 */ 861 case LDM_VBLK_T_DISK: 862 errstr = "disk guid"; 863 offset = ldm_vstr_get(p, offset, vstr, sizeof(vstr), size); 864 if (offset < 0) 865 goto fail; 866 error = parse_uuid(vstr, &blk->u.disk.guid); 867 if (error != 0) 868 goto fail; 869 LIST_INSERT_HEAD(&db->disks, &blk->u.disk, entry); 870 break; 871 /* 872 * Disk group VBLK fields: 873 * Offset Size Description 874 * ------------+-------+------------------------ 875 * 0x18+ PS disk group GUID 876 */ 877 case LDM_VBLK_T_DISKGROUP: 878 #if 0 879 strncpy(blk->u.disk_group.name, vstr, 880 sizeof(blk->u.disk_group.name)); 881 offset = ldm_vstr_get(p, offset, vstr, sizeof(vstr), size); 882 if (offset < 0) { 883 errstr = "disk group guid"; 884 goto fail; 885 } 886 error = parse_uuid(name, &blk->u.disk_group.guid); 887 if (error != 0) { 888 errstr = "disk group guid"; 889 goto fail; 890 } 891 LIST_INSERT_HEAD(&db->groups, &blk->u.disk_group, entry); 892 #endif 893 break; 894 /* 895 * Disk VBLK fields: 896 * Offset Size Description 897 * ------------+-------+------------------------ 898 * 0x18+ 16 disk GUID 899 */ 900 case LDM_VBLK_T_DISK4: 901 be_uuid_dec(p + offset, &blk->u.disk.guid); 902 LIST_INSERT_HEAD(&db->disks, &blk->u.disk, entry); 903 break; 904 /* 905 * Disk group VBLK fields: 906 * Offset Size Description 907 * ------------+-------+------------------------ 908 * 0x18+ 16 disk GUID 909 */ 910 case LDM_VBLK_T_DISKGROUP4: 911 #if 0 912 strncpy(blk->u.disk_group.name, vstr, 913 sizeof(blk->u.disk_group.name)); 914 be_uuid_dec(p + offset, &blk->u.disk.guid); 915 LIST_INSERT_HEAD(&db->groups, &blk->u.disk_group, entry); 916 #endif 917 break; 918 /* 919 * Volume VBLK fields: 920 * Offset Size Description 921 * ------------+-------+------------------------ 922 * 0x18+ PS volume type 923 * 0x18+ PS unknown 924 * 0x18+ 14(S) volume state 925 * 0x18+16 1 volume number 926 * 0x18+21 PN volume children count 927 * 0x2D+16 PN volume size 928 * 0x3D+4 1 partition type 929 */ 930 case LDM_VBLK_T_VOLUME: 931 offset = ldm_vparm_skip(p, offset, size); 932 if (offset < 0) { 933 errstr = "volume type"; 934 goto fail; 935 } 936 offset = ldm_vparm_skip(p, offset, size); 937 if (offset < 0) { 938 errstr = "unknown param"; 939 goto fail; 940 } 941 if (offset + 21 >= size) { 942 errstr = "too small buffer"; 943 goto fail; 944 } 945 blk->u.vol.number = p[offset + 16]; 946 offset = ldm_vparm_skip(p, offset + 21, size); 947 if (offset < 0) { 948 errstr = "children count"; 949 goto fail; 950 } 951 offset = ldm_vnum_get(p, offset + 16, &blk->u.vol.size, size); 952 if (offset < 0) { 953 errstr = "volume size"; 954 goto fail; 955 } 956 if (offset + 4 >= size) { 957 errstr = "too small buffer"; 958 goto fail; 959 } 960 blk->u.vol.part_type = p[offset + 4]; 961 /* keep volumes ordered by volume number */ 962 last = NULL; 963 LIST_FOREACH(volume, &db->volumes, entry) { 964 if (volume->number > blk->u.vol.number) 965 break; 966 last = volume; 967 } 968 if (last != NULL) 969 LIST_INSERT_AFTER(last, &blk->u.vol, entry); 970 else 971 LIST_INSERT_HEAD(&db->volumes, &blk->u.vol, entry); 972 break; 973 default: 974 LDM_DEBUG(1, "unknown VBLK type 0x%02x\n", blk->type); 975 LDM_DUMP(p, size); 976 } 977 LIST_INSERT_HEAD(&db->vblks, blk, entry); 978 return (0); 979 fail: 980 LDM_DEBUG(0, "failed to parse '%s' in VBLK of type 0x%02x\n", 981 errstr, blk->type); 982 LDM_DUMP(p, size); 983 g_free(blk); 984 return (EINVAL); 985 } 986 987 static void 988 ldm_vmdb_free(struct ldm_db *db) 989 { 990 struct ldm_vblk *vblk; 991 struct ldm_xvblk *xvblk; 992 993 while (!LIST_EMPTY(&db->xvblks)) { 994 xvblk = LIST_FIRST(&db->xvblks); 995 LIST_REMOVE(xvblk, entry); 996 g_free(xvblk->data); 997 g_free(xvblk); 998 } 999 while (!LIST_EMPTY(&db->vblks)) { 1000 vblk = LIST_FIRST(&db->vblks); 1001 LIST_REMOVE(vblk, entry); 1002 g_free(vblk); 1003 } 1004 } 1005 1006 static int 1007 ldm_vmdb_parse(struct ldm_db *db, struct g_consumer *cp) 1008 { 1009 struct g_provider *pp; 1010 struct ldm_vblk *vblk; 1011 struct ldm_xvblk *xvblk; 1012 struct ldm_volume *volume; 1013 struct ldm_component *comp; 1014 struct ldm_vblkhdr vh; 1015 u_char *buf, *p; 1016 size_t size, n, sectors; 1017 uint64_t offset; 1018 int error; 1019 1020 pp = cp->provider; 1021 size = howmany(db->dh.last_seq * db->dh.size, pp->sectorsize); 1022 size -= 1; /* one sector takes vmdb header */ 1023 for (n = 0; n < size; n += MAXPHYS / pp->sectorsize) { 1024 offset = db->ph.db_offset + db->th.conf_offset + n + 1; 1025 sectors = (size - n) > (MAXPHYS / pp->sectorsize) ? 1026 MAXPHYS / pp->sectorsize: size - n; 1027 /* read VBLKs */ 1028 buf = g_read_data(cp, offset * pp->sectorsize, 1029 sectors * pp->sectorsize, &error); 1030 if (buf == NULL) { 1031 LDM_DEBUG(0, "%s: failed to read VBLK\n", 1032 pp->name); 1033 goto fail; 1034 } 1035 for (p = buf; p < buf + sectors * pp->sectorsize; 1036 p += db->dh.size) { 1037 if (memcmp(p, LDM_VBLK_SIGN, 1038 strlen(LDM_VBLK_SIGN)) != 0) { 1039 LDM_DEBUG(0, "%s: no VBLK signature\n", 1040 pp->name); 1041 LDM_DUMP(p, db->dh.size); 1042 goto fail; 1043 } 1044 vh.seq = be32dec(p + LDM_VBLK_SEQ_OFF); 1045 vh.group = be32dec(p + LDM_VBLK_GROUP_OFF); 1046 /* skip empty blocks */ 1047 if (vh.seq == 0 || vh.group == 0) 1048 continue; 1049 vh.index = be16dec(p + LDM_VBLK_INDEX_OFF); 1050 vh.count = be16dec(p + LDM_VBLK_COUNT_OFF); 1051 if (vh.count == 0 || vh.count > 4 || 1052 vh.seq > db->dh.last_seq) { 1053 LDM_DEBUG(0, "%s: invalid values " 1054 "in the VBLK header\n", pp->name); 1055 LDM_DUMP(p, db->dh.size); 1056 goto fail; 1057 } 1058 if (vh.count > 1) { 1059 error = ldm_xvblk_handle(db, &vh, p); 1060 if (error != 0) { 1061 LDM_DEBUG(0, "%s: xVBLK " 1062 "is corrupted\n", pp->name); 1063 LDM_DUMP(p, db->dh.size); 1064 goto fail; 1065 } 1066 continue; 1067 } 1068 if (be16dec(p + 16) != 0) 1069 LDM_DEBUG(1, "%s: VBLK update" 1070 " status is %u\n", pp->name, 1071 be16dec(p + 16)); 1072 error = ldm_vblk_handle(db, p, db->dh.size); 1073 if (error != 0) 1074 goto fail; 1075 } 1076 g_free(buf); 1077 buf = NULL; 1078 } 1079 /* Parse xVBLKs */ 1080 while (!LIST_EMPTY(&db->xvblks)) { 1081 xvblk = LIST_FIRST(&db->xvblks); 1082 if (xvblk->map == 0xFF) { 1083 error = ldm_vblk_handle(db, xvblk->data, xvblk->size); 1084 if (error != 0) 1085 goto fail; 1086 } else { 1087 LDM_DEBUG(0, "%s: incomplete or corrupt " 1088 "xVBLK found\n", pp->name); 1089 goto fail; 1090 } 1091 LIST_REMOVE(xvblk, entry); 1092 g_free(xvblk->data); 1093 g_free(xvblk); 1094 } 1095 /* construct all VBLKs relations */ 1096 LIST_FOREACH(volume, &db->volumes, entry) { 1097 LIST_FOREACH(vblk, &db->vblks, entry) 1098 if (vblk->type == LDM_VBLK_T_COMPONENT && 1099 vblk->u.comp.vol_id == volume->id) { 1100 LIST_INSERT_HEAD(&volume->components, 1101 &vblk->u.comp, entry); 1102 volume->count++; 1103 } 1104 LIST_FOREACH(comp, &volume->components, entry) 1105 LIST_FOREACH(vblk, &db->vblks, entry) 1106 if (vblk->type == LDM_VBLK_T_PARTITION && 1107 vblk->u.part.comp_id == comp->id) { 1108 LIST_INSERT_HEAD(&comp->partitions, 1109 &vblk->u.part, entry); 1110 comp->count++; 1111 } 1112 } 1113 return (0); 1114 fail: 1115 ldm_vmdb_free(db); 1116 g_free(buf); 1117 return (ENXIO); 1118 } 1119 1120 static int 1121 g_part_ldm_add(struct g_part_table *basetable, struct g_part_entry *baseentry, 1122 struct g_part_parms *gpp) 1123 { 1124 1125 return (ENOSYS); 1126 } 1127 1128 static int 1129 g_part_ldm_bootcode(struct g_part_table *basetable, struct g_part_parms *gpp) 1130 { 1131 1132 return (ENOSYS); 1133 } 1134 1135 static int 1136 g_part_ldm_create(struct g_part_table *basetable, struct g_part_parms *gpp) 1137 { 1138 1139 return (ENOSYS); 1140 } 1141 1142 static int 1143 g_part_ldm_destroy(struct g_part_table *basetable, struct g_part_parms *gpp) 1144 { 1145 struct g_part_ldm_table *table; 1146 struct g_provider *pp; 1147 1148 table = (struct g_part_ldm_table *)basetable; 1149 /* 1150 * To destroy LDM on a disk partitioned with GPT we should delete 1151 * ms-ldm-metadata partition, but we can't do this via standard 1152 * GEOM_PART method. 1153 */ 1154 if (table->is_gpt) 1155 return (ENOSYS); 1156 pp = LIST_FIRST(&basetable->gpt_gp->consumer)->provider; 1157 /* 1158 * To destroy LDM we should wipe MBR, first private header and 1159 * backup private headers. 1160 */ 1161 basetable->gpt_smhead = (1 << ldm_ph_off[0]) | 1; 1162 /* 1163 * Don't touch last backup private header when LDM database is 1164 * not located in the last 1MByte area. 1165 * XXX: can't remove all blocks. 1166 */ 1167 if (table->db_offset + LDM_DB_SIZE == 1168 pp->mediasize / pp->sectorsize) 1169 basetable->gpt_smtail = 1; 1170 return (0); 1171 } 1172 1173 static void 1174 g_part_ldm_dumpconf(struct g_part_table *basetable, 1175 struct g_part_entry *baseentry, struct sbuf *sb, const char *indent) 1176 { 1177 struct g_part_ldm_entry *entry; 1178 1179 entry = (struct g_part_ldm_entry *)baseentry; 1180 if (indent == NULL) { 1181 /* conftxt: libdisk compatibility */ 1182 sbuf_printf(sb, " xs LDM xt %u", entry->type); 1183 } else if (entry != NULL) { 1184 /* confxml: partition entry information */ 1185 sbuf_printf(sb, "%s<rawtype>%u</rawtype>\n", indent, 1186 entry->type); 1187 } else { 1188 /* confxml: scheme information */ 1189 } 1190 } 1191 1192 static int 1193 g_part_ldm_dumpto(struct g_part_table *table, struct g_part_entry *baseentry) 1194 { 1195 1196 return (0); 1197 } 1198 1199 static int 1200 g_part_ldm_modify(struct g_part_table *basetable, 1201 struct g_part_entry *baseentry, struct g_part_parms *gpp) 1202 { 1203 1204 return (ENOSYS); 1205 } 1206 1207 static const char * 1208 g_part_ldm_name(struct g_part_table *table, struct g_part_entry *baseentry, 1209 char *buf, size_t bufsz) 1210 { 1211 1212 snprintf(buf, bufsz, "s%d", baseentry->gpe_index); 1213 return (buf); 1214 } 1215 1216 static int 1217 ldm_gpt_probe(struct g_part_table *basetable, struct g_consumer *cp) 1218 { 1219 struct g_part_ldm_table *table; 1220 struct g_part_table *gpt; 1221 struct g_part_entry *entry; 1222 struct g_consumer *cp2; 1223 struct gpt_ent *part; 1224 u_char *buf; 1225 int error; 1226 1227 /* 1228 * XXX: We use some knowledge about GEOM_PART_GPT internal 1229 * structures, but it is easier than parse GPT by himself. 1230 */ 1231 g_topology_lock(); 1232 gpt = cp->provider->geom->softc; 1233 LIST_FOREACH(entry, &gpt->gpt_entry, gpe_entry) { 1234 part = (struct gpt_ent *)(entry + 1); 1235 /* Search ms-ldm-metadata partition */ 1236 if (memcmp(&part->ent_type, 1237 &gpt_uuid_ms_ldm_metadata, sizeof(struct uuid)) != 0 || 1238 entry->gpe_end - entry->gpe_start < LDM_DB_SIZE - 1) 1239 continue; 1240 1241 /* Create new consumer and attach it to metadata partition */ 1242 cp2 = g_new_consumer(cp->geom); 1243 error = g_attach(cp2, entry->gpe_pp); 1244 if (error != 0) { 1245 g_destroy_consumer(cp2); 1246 g_topology_unlock(); 1247 return (ENXIO); 1248 } 1249 error = g_access(cp2, 1, 0, 0); 1250 if (error != 0) { 1251 g_detach(cp2); 1252 g_destroy_consumer(cp2); 1253 g_topology_unlock(); 1254 return (ENXIO); 1255 } 1256 g_topology_unlock(); 1257 1258 LDM_DEBUG(2, "%s: LDM metadata partition %s found in the GPT", 1259 cp->provider->name, cp2->provider->name); 1260 /* Read the LDM private header */ 1261 buf = ldm_privhdr_read(cp2, 1262 ldm_ph_off[LDM_PH_GPTINDEX] * cp2->provider->sectorsize, 1263 &error); 1264 if (buf != NULL) { 1265 table = (struct g_part_ldm_table *)basetable; 1266 table->is_gpt = 1; 1267 g_free(buf); 1268 return (G_PART_PROBE_PRI_HIGH); 1269 } 1270 1271 /* second consumer is no longer needed. */ 1272 g_topology_lock(); 1273 g_access(cp2, -1, 0, 0); 1274 g_detach(cp2); 1275 g_destroy_consumer(cp2); 1276 break; 1277 } 1278 g_topology_unlock(); 1279 return (ENXIO); 1280 } 1281 1282 static int 1283 g_part_ldm_probe(struct g_part_table *basetable, struct g_consumer *cp) 1284 { 1285 struct g_provider *pp; 1286 u_char *buf, type[64]; 1287 int error, idx; 1288 1289 pp = cp->provider; 1290 if (pp->sectorsize != 512) 1291 return (ENXIO); 1292 1293 error = g_getattr("PART::scheme", cp, &type); 1294 if (error == 0 && strcmp(type, "GPT") == 0) { 1295 if (g_getattr("PART::type", cp, &type) != 0 || 1296 strcmp(type, "ms-ldm-data") != 0) 1297 return (ENXIO); 1298 error = ldm_gpt_probe(basetable, cp); 1299 return (error); 1300 } 1301 1302 if (basetable->gpt_depth != 0) 1303 return (ENXIO); 1304 1305 /* LDM has 1M metadata area */ 1306 if (pp->mediasize <= 1024 * 1024) 1307 return (ENOSPC); 1308 1309 /* Check that there's a MBR */ 1310 buf = g_read_data(cp, 0, pp->sectorsize, &error); 1311 if (buf == NULL) 1312 return (error); 1313 1314 if (le16dec(buf + DOSMAGICOFFSET) != DOSMAGIC) { 1315 g_free(buf); 1316 return (ENXIO); 1317 } 1318 error = ENXIO; 1319 /* Check that we have LDM partitions in the MBR */ 1320 for (idx = 0; idx < NDOSPART && error != 0; idx++) { 1321 if (buf[DOSPARTOFF + idx * DOSPARTSIZE + 4] == DOSPTYP_LDM) 1322 error = 0; 1323 } 1324 g_free(buf); 1325 if (error == 0) { 1326 LDM_DEBUG(2, "%s: LDM data partitions found in MBR", 1327 pp->name); 1328 /* Read the LDM private header */ 1329 buf = ldm_privhdr_read(cp, 1330 ldm_ph_off[LDM_PH_MBRINDEX] * pp->sectorsize, &error); 1331 if (buf == NULL) 1332 return (error); 1333 g_free(buf); 1334 return (G_PART_PROBE_PRI_HIGH); 1335 } 1336 return (error); 1337 } 1338 1339 static int 1340 g_part_ldm_read(struct g_part_table *basetable, struct g_consumer *cp) 1341 { 1342 struct g_part_ldm_table *table; 1343 struct g_part_ldm_entry *entry; 1344 struct g_consumer *cp2; 1345 struct ldm_component *comp; 1346 struct ldm_partition *part; 1347 struct ldm_volume *vol; 1348 struct ldm_disk *disk; 1349 struct ldm_db db; 1350 int error, index, skipped; 1351 1352 table = (struct g_part_ldm_table *)basetable; 1353 memset(&db, 0, sizeof(db)); 1354 cp2 = cp; /* ms-ldm-data */ 1355 if (table->is_gpt) 1356 cp = LIST_FIRST(&cp->geom->consumer); /* ms-ldm-metadata */ 1357 /* Read and parse LDM private headers. */ 1358 error = ldm_privhdr_check(&db, cp, table->is_gpt); 1359 if (error != 0) 1360 goto gpt_cleanup; 1361 basetable->gpt_first = table->is_gpt ? 0: db.ph.start; 1362 basetable->gpt_last = basetable->gpt_first + db.ph.size - 1; 1363 table->db_offset = db.ph.db_offset; 1364 /* Make additional checks for GPT */ 1365 if (table->is_gpt) { 1366 error = ldm_gpt_check(&db, cp); 1367 if (error != 0) 1368 goto gpt_cleanup; 1369 /* 1370 * Now we should reset database offset to zero, because our 1371 * consumer cp is attached to the ms-ldm-metadata partition 1372 * and we don't need add db_offset to read from it. 1373 */ 1374 db.ph.db_offset = 0; 1375 } 1376 /* Read and parse LDM TOC headers. */ 1377 error = ldm_tochdr_check(&db, cp); 1378 if (error != 0) 1379 goto gpt_cleanup; 1380 /* Read and parse LDM VMDB header. */ 1381 error = ldm_vmdbhdr_check(&db, cp); 1382 if (error != 0) 1383 goto gpt_cleanup; 1384 error = ldm_vmdb_parse(&db, cp); 1385 /* 1386 * For the GPT case we must detach and destroy 1387 * second consumer before return. 1388 */ 1389 gpt_cleanup: 1390 if (table->is_gpt) { 1391 g_topology_lock(); 1392 g_access(cp, -1, 0, 0); 1393 g_detach(cp); 1394 g_destroy_consumer(cp); 1395 g_topology_unlock(); 1396 cp = cp2; 1397 } 1398 if (error != 0) 1399 return (error); 1400 /* Search current disk in the disk list. */ 1401 LIST_FOREACH(disk, &db.disks, entry) 1402 if (memcmp(&disk->guid, &db.ph.disk_guid, 1403 sizeof(struct uuid)) == 0) 1404 break; 1405 if (disk == NULL) { 1406 LDM_DEBUG(1, "%s: no LDM volumes on this disk", 1407 cp->provider->name); 1408 ldm_vmdb_free(&db); 1409 return (ENXIO); 1410 } 1411 index = 1; 1412 LIST_FOREACH(vol, &db.volumes, entry) { 1413 LIST_FOREACH(comp, &vol->components, entry) { 1414 /* Skip volumes from different disks. */ 1415 part = LIST_FIRST(&comp->partitions); 1416 if (part->disk_id != disk->id) 1417 continue; 1418 skipped = 0; 1419 /* We don't support spanned and striped volumes. */ 1420 if (comp->count > 1 || part->offset != 0) { 1421 LDM_DEBUG(1, "%s: LDM volume component " 1422 "%ju has %u partitions. Skipped", 1423 cp->provider->name, (uintmax_t)comp->id, 1424 comp->count); 1425 skipped = 1; 1426 } 1427 /* 1428 * Allow mirrored volumes only when they are explicitly 1429 * allowed with kern.geom.part.ldm.show_mirrors=1. 1430 */ 1431 if (vol->count > 1 && show_mirrors == 0) { 1432 LDM_DEBUG(1, "%s: LDM volume %ju has %u " 1433 "components. Skipped", 1434 cp->provider->name, (uintmax_t)vol->id, 1435 vol->count); 1436 skipped = 1; 1437 } 1438 entry = (struct g_part_ldm_entry *)g_part_new_entry( 1439 basetable, index++, 1440 basetable->gpt_first + part->start, 1441 basetable->gpt_first + part->start + 1442 part->size - 1); 1443 /* 1444 * Mark skipped partition as ms-ldm-data partition. 1445 * We do not support them, but it is better to show 1446 * that we have something there, than just show 1447 * free space. 1448 */ 1449 if (skipped == 0) 1450 entry->type = vol->part_type; 1451 else 1452 entry->type = DOSPTYP_LDM; 1453 LDM_DEBUG(1, "%s: new volume id: %ju, start: %ju," 1454 " end: %ju, type: 0x%02x\n", cp->provider->name, 1455 (uintmax_t)part->id,(uintmax_t)part->start + 1456 basetable->gpt_first, (uintmax_t)part->start + 1457 part->size + basetable->gpt_first - 1, 1458 vol->part_type); 1459 } 1460 } 1461 ldm_vmdb_free(&db); 1462 return (error); 1463 } 1464 1465 static const char * 1466 g_part_ldm_type(struct g_part_table *basetable, struct g_part_entry *baseentry, 1467 char *buf, size_t bufsz) 1468 { 1469 struct g_part_ldm_entry *entry; 1470 int i; 1471 1472 entry = (struct g_part_ldm_entry *)baseentry; 1473 for (i = 0; i < nitems(ldm_alias_match); i++) { 1474 if (ldm_alias_match[i].typ == entry->type) 1475 return (g_part_alias_name(ldm_alias_match[i].alias)); 1476 } 1477 snprintf(buf, bufsz, "!%d", entry->type); 1478 return (buf); 1479 } 1480 1481 static int 1482 g_part_ldm_write(struct g_part_table *basetable, struct g_consumer *cp) 1483 { 1484 1485 return (ENOSYS); 1486 } 1487