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