2 * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
32 #include <sys/diskmbr.h>
33 #include <sys/endian.h>
35 #include <sys/kernel.h>
37 #include <sys/limits.h>
39 #include <sys/malloc.h>
40 #include <sys/mutex.h>
41 #include <sys/queue.h>
43 #include <sys/systm.h>
44 #include <sys/sysctl.h>
46 #include <geom/geom.h>
47 #include <geom/part/g_part.h>
49 #include "g_part_if.h"
51 FEATURE(geom_part_ldm, "GEOM partitioning class for LDM support");
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");
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");
63 * This allows access to mirrored LDM volumes. Since we do not
64 * doing mirroring here, it is not enabled by default.
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");
71 #define LDM_DEBUG(lvl, fmt, ...) do { \
72 if (ldm_debug >= (lvl)) { \
73 printf("GEOM_PART: " fmt "\n", __VA_ARGS__); \
76 #define LDM_DUMP(buf, size) do { \
77 if (ldm_debug > 1) { \
78 hexdump(buf, size, NULL, 0); \
83 * There are internal representations of LDM structures.
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.
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.
95 * On a disk partitioned with GPT, the LDM has not first private header.
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"
116 struct uuid disk_guid;
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 */
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.
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
145 uint64_t conf_offset; /* configuration offset */
146 uint64_t log_offset; /* log offset */
150 * LDM database header is 512 bytes long.
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
160 uint32_t last_seq; /* sequence number of last VBLK */
161 uint32_t size; /* size of VBLK */
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.
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
174 * Volumes <- Components <- Partitions -> Disks
176 * One volume can contain several components. In this case LDM
177 * does mirroring of volume data to each component.
179 * Also each component can contain several partitions (spanned or
183 struct ldm_component {
184 uint64_t id; /* object id */
185 uint64_t vol_id; /* parent volume object id */
188 LIST_HEAD(, ldm_partition) partitions;
189 LIST_ENTRY(ldm_component) entry;
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 */
199 LIST_HEAD(, ldm_component) components;
200 LIST_ENTRY(ldm_volume) entry;
204 uint64_t id; /* object id */
205 struct uuid guid; /* disk guid */
207 LIST_ENTRY(ldm_disk) entry;
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 */
216 LIST_ENTRY(ldm_disk_group) entry;
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 */
228 LIST_ENTRY(ldm_partition) entry;
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
244 * 0x18+ PN object name
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.
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
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 */
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
272 uint8_t type; /* VBLK type */
275 struct ldm_volume vol;
276 struct ldm_component comp;
277 struct ldm_disk disk;
278 struct ldm_partition part;
280 struct ldm_disk_group disk_group;
283 LIST_ENTRY(ldm_vblk) entry;
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).
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 */
298 LIST_ENTRY(ldm_xvblk) entry;
301 /* The internal representation of LDM database. */
303 struct ldm_privhdr ph; /* private header */
304 struct ldm_tochdr th; /* TOC header */
305 struct ldm_vmdbhdr dh; /* VMDB header */
307 LIST_HEAD(, ldm_volume) volumes;
308 LIST_HEAD(, ldm_disk) disks;
309 LIST_HEAD(, ldm_vblk) vblks;
310 LIST_HEAD(, ldm_xvblk) xvblks;
313 static struct uuid gpt_uuid_ms_ldm_metadata = GPT_ENT_TYPE_MS_LDM_METADATA;
315 struct g_part_ldm_table {
316 struct g_part_table base;
320 struct g_part_ldm_entry {
321 struct g_part_entry base;
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 *,
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 *,
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 *);
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),
365 static struct g_part_scheme g_part_ldm_scheme = {
368 sizeof(struct g_part_ldm_table),
369 .gps_entrysz = sizeof(struct g_part_ldm_entry)
371 G_PART_SCHEME_DECLARE(g_part_ldm);
373 static struct g_part_ldm_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 },
388 ldm_privhdr_read(struct g_consumer *cp, uint64_t off, int *error)
390 struct g_provider *pp;
394 buf = g_read_data(cp, off, pp->sectorsize, error);
398 if (memcmp(buf, LDM_PH_SIGN, strlen(LDM_PH_SIGN)) != 0) {
399 LDM_DEBUG(1, "%s: invalid LDM private header signature",
409 ldm_privhdr_parse(struct g_consumer *cp, struct ldm_privhdr *hdr,
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,
424 error = parse_uuid(buf + LDM_PH_DISKGUID_OFF, &hdr->disk_guid);
427 error = parse_uuid(buf + LDM_PH_DGGUID_OFF, &hdr->dg_guid);
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);
443 ldm_privhdr_check(struct ldm_db *db, struct g_consumer *cp, int is_gpt)
445 struct g_consumer *cp2;
446 struct g_provider *pp;
447 struct ldm_privhdr hdr;
448 uint64_t offset, last;
455 * The last LBA is used in several checks below, for the
456 * GPT case it should be calculated relative to the whole
459 cp2 = LIST_FIRST(&pp->geom->consumer);
461 cp2->provider->mediasize / cp2->provider->sectorsize - 1;
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];
468 * In the GPT case consumer is attached to the LDM metadata
469 * partition and we don't need add db_offset.
472 offset += db->ph.db_offset;
473 if (i == LDM_PH_MBRINDEX) {
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.
479 db->ph.db_offset = last - LDM_DB_SIZE;
481 buf = ldm_privhdr_read(cp, offset * pp->sectorsize, &error);
483 LDM_DEBUG(1, "%s: failed to read private header "
484 "%d at LBA %ju", pp->name, i, (uintmax_t)offset);
487 error = ldm_privhdr_parse(cp, &hdr, buf);
489 LDM_DEBUG(1, "%s: failed to parse private "
490 "header %d", pp->name, i);
491 LDM_DUMP(buf, pp->sectorsize);
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,
515 if (found != 0 && memcmp(&db->ph, &hdr, sizeof(hdr)) != 0) {
516 LDM_DEBUG(0, "%s: private headers are not equal",
520 * We have different headers in the LDM.
521 * We can not trust this metadata.
523 LDM_DEBUG(0, "%s: refuse LDM metadata",
528 * We already have read primary private header
529 * and it differs from this backup one.
530 * Prefer the backup header and save it.
535 memcpy(&db->ph, &hdr, sizeof(hdr));
539 LDM_DEBUG(1, "%s: valid LDM private header not found",
547 ldm_gpt_check(struct ldm_db *db, struct g_consumer *cp)
549 struct g_part_table *gpt;
550 struct g_part_entry *e;
551 struct g_consumer *cp2;
554 cp2 = LIST_NEXT(cp, consumer);
556 gpt = cp->provider->geom->softc;
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)
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)
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);
583 ldm_tochdr_check(struct ldm_db *db, struct g_consumer *cp)
585 struct g_provider *pp;
586 struct ldm_tochdr hdr;
587 uint64_t offset, conf_size, log_size;
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);
597 LDM_DEBUG(1, "%s: failed to read TOC header "
598 "at LBA %ju", pp->name, (uintmax_t)offset);
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);
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,
623 LDM_DUMP(buf, pp->sectorsize);
629 memcpy(&db->th, &hdr, sizeof(hdr));
633 LDM_DEBUG(0, "%s: valid LDM TOC header not found.",
641 ldm_vmdbhdr_check(struct ldm_db *db, struct g_consumer *cp)
643 struct g_provider *pp;
651 offset = db->ph.db_offset + db->th.conf_offset;
652 buf = g_read_data(cp, offset * pp->sectorsize, pp->sectorsize,
655 LDM_DEBUG(0, "%s: failed to read VMDB header at "
656 "LBA %ju", pp->name, (uintmax_t)offset);
659 if (memcmp(buf, LDM_VMDB_SIGN, strlen(LDM_VMDB_SIGN)) != 0) {
661 LDM_DEBUG(0, "%s: failed to parse VMDB header at "
662 "LBA %ju", pp->name, (uintmax_t)offset);
666 version = be32dec(buf + LDM_DB_VERSION_OFF);
667 if (version != 0x4000A) {
669 LDM_DEBUG(0, "%s: unsupported VMDB version %u.%u",
670 pp->name, version >> 16, version & 0xFFFF);
674 * Check VMDB update status:
675 * 1 - in a consistent state;
676 * 2 - in a creation phase;
677 * 3 - in a deletion phase;
679 if (be16dec(buf + LDM_DB_STATUS_OFF) != 1) {
681 LDM_DEBUG(0, "%s: VMDB is not in a consistent state",
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",
697 LDM_DUMP(buf, pp->sectorsize);
706 ldm_xvblk_handle(struct ldm_db *db, struct ldm_vblkhdr *vh, const u_char *p)
708 struct ldm_xvblk *blk;
711 size = db->dh.size - 16;
712 LIST_FOREACH(blk, &db->xvblks, entry)
713 if (blk->group == vh->group)
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);
723 if ((blk->map & (1 << vh->index)) != 0) {
724 /* Block with given index has been already saved. */
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;
733 /* Read the variable-width numeric field and return new offset */
735 ldm_vnum_get(const u_char *buf, int offset, uint64_t *result, size_t range)
741 if (len > sizeof(uint64_t) || len + offset >= range)
743 for (num = 0; len > 0; len--)
744 num = (num << 8) | buf[offset++];
749 /* Read the variable-width string and return new offset */
751 ldm_vstr_get(const u_char *buf, int offset, u_char *result,
752 size_t maxlen, size_t range)
757 if (len >= maxlen || len + offset >= range)
759 memcpy(result, buf + offset, len);
761 return (offset + len);
764 /* Just skip the variable-width variable and return new offset */
766 ldm_vparm_skip(const u_char *buf, int offset, size_t range)
771 if (offset + len >= range)
774 return (offset + len);
778 ldm_vblk_handle(struct ldm_db *db, const u_char *p, size_t size)
780 struct ldm_vblk *blk;
781 struct ldm_volume *volume, *last;
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);
790 errstr = "object id";
793 offset = ldm_vstr_get(p, offset, vstr, sizeof(vstr), size);
795 errstr = "object name";
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
808 case LDM_VBLK_T_COMPONENT:
809 offset = ldm_vparm_skip(p, offset, size);
811 errstr = "volume state";
814 offset = ldm_vparm_skip(p, offset + 5, size);
816 errstr = "children count";
819 offset = ldm_vnum_get(p, offset + 16,
820 &blk->u.comp.vol_id, size);
822 errstr = "volume id";
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
836 case LDM_VBLK_T_PARTITION:
837 if (offset + 28 >= size) {
838 errstr = "too small buffer";
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);
845 errstr = "partition size";
848 offset = ldm_vnum_get(p, offset, &blk->u.part.comp_id, size);
850 errstr = "component id";
853 offset = ldm_vnum_get(p, offset, &blk->u.part.disk_id, size);
861 * Offset Size Description
862 * ------------+-------+------------------------
865 case LDM_VBLK_T_DISK:
866 errstr = "disk guid";
867 offset = ldm_vstr_get(p, offset, vstr, sizeof(vstr), size);
870 error = parse_uuid(vstr, &blk->u.disk.guid);
873 LIST_INSERT_HEAD(&db->disks, &blk->u.disk, entry);
876 * Disk group VBLK fields:
877 * Offset Size Description
878 * ------------+-------+------------------------
879 * 0x18+ PS disk group GUID
881 case LDM_VBLK_T_DISKGROUP:
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);
887 errstr = "disk group guid";
890 error = parse_uuid(name, &blk->u.disk_group.guid);
892 errstr = "disk group guid";
895 LIST_INSERT_HEAD(&db->groups, &blk->u.disk_group, entry);
900 * Offset Size Description
901 * ------------+-------+------------------------
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);
909 * Disk group VBLK fields:
910 * Offset Size Description
911 * ------------+-------+------------------------
914 case LDM_VBLK_T_DISKGROUP4:
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);
923 * Volume VBLK fields:
924 * Offset Size Description
925 * ------------+-------+------------------------
926 * 0x18+ PS volume type
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
934 case LDM_VBLK_T_VOLUME:
935 offset = ldm_vparm_skip(p, offset, size);
937 errstr = "volume type";
940 offset = ldm_vparm_skip(p, offset, size);
942 errstr = "unknown param";
945 if (offset + 21 >= size) {
946 errstr = "too small buffer";
949 blk->u.vol.number = p[offset + 16];
950 offset = ldm_vparm_skip(p, offset + 21, size);
952 errstr = "children count";
955 offset = ldm_vnum_get(p, offset + 16, &blk->u.vol.size, size);
957 errstr = "volume size";
960 if (offset + 4 >= size) {
961 errstr = "too small buffer";
964 blk->u.vol.part_type = p[offset + 4];
965 /* keep volumes ordered by volume number */
967 LIST_FOREACH(volume, &db->volumes, entry) {
968 if (volume->number > blk->u.vol.number)
973 LIST_INSERT_AFTER(last, &blk->u.vol, entry);
975 LIST_INSERT_HEAD(&db->volumes, &blk->u.vol, entry);
978 LDM_DEBUG(1, "unknown VBLK type 0x%02x\n", blk->type);
981 LIST_INSERT_HEAD(&db->vblks, blk, entry);
984 LDM_DEBUG(0, "failed to parse '%s' in VBLK of type 0x%02x\n",
992 ldm_vmdb_free(struct ldm_db *db)
994 struct ldm_vblk *vblk;
995 struct ldm_xvblk *xvblk;
997 while (!LIST_EMPTY(&db->xvblks)) {
998 xvblk = LIST_FIRST(&db->xvblks);
999 LIST_REMOVE(xvblk, entry);
1000 g_free(xvblk->data);
1003 while (!LIST_EMPTY(&db->vblks)) {
1004 vblk = LIST_FIRST(&db->vblks);
1005 LIST_REMOVE(vblk, entry);
1011 ldm_vmdb_parse(struct ldm_db *db, struct g_consumer *cp)
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;
1020 size_t size, n, sectors;
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;
1033 buf = g_read_data(cp, offset * pp->sectorsize,
1034 sectors * pp->sectorsize, &error);
1036 LDM_DEBUG(0, "%s: failed to read VBLK\n",
1040 for (p = buf; p < buf + sectors * pp->sectorsize;
1042 if (memcmp(p, LDM_VBLK_SIGN,
1043 strlen(LDM_VBLK_SIGN)) != 0) {
1044 LDM_DEBUG(0, "%s: no VBLK signature\n",
1046 LDM_DUMP(p, db->dh.size);
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)
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);
1064 error = ldm_xvblk_handle(db, &vh, p);
1066 LDM_DEBUG(0, "%s: xVBLK "
1067 "is corrupted\n", pp->name);
1068 LDM_DUMP(p, db->dh.size);
1073 if (be16dec(p + 16) != 0)
1074 LDM_DEBUG(1, "%s: VBLK update"
1075 " status is %u\n", pp->name,
1077 error = ldm_vblk_handle(db, p, db->dh.size);
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);
1092 LDM_DEBUG(0, "%s: incomplete or corrupt "
1093 "xVBLK found\n", pp->name);
1096 LIST_REMOVE(xvblk, entry);
1097 g_free(xvblk->data);
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);
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);
1126 g_part_ldm_add(struct g_part_table *basetable, struct g_part_entry *baseentry,
1127 struct g_part_parms *gpp)
1134 g_part_ldm_bootcode(struct g_part_table *basetable, struct g_part_parms *gpp)
1141 g_part_ldm_create(struct g_part_table *basetable, struct g_part_parms *gpp)
1148 g_part_ldm_destroy(struct g_part_table *basetable, struct g_part_parms *gpp)
1150 struct g_part_ldm_table *table;
1151 struct g_provider *pp;
1153 table = (struct g_part_ldm_table *)basetable;
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
1161 pp = LIST_FIRST(&basetable->gpt_gp->consumer)->provider;
1163 * To destroy LDM we should wipe MBR, first private header and
1164 * backup private headers.
1166 basetable->gpt_smhead = (1 << ldm_ph_off[0]) | 1;
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.
1172 if (table->db_offset + LDM_DB_SIZE ==
1173 pp->mediasize / pp->sectorsize)
1174 basetable->gpt_smtail = 1;
1179 g_part_ldm_dumpconf(struct g_part_table *basetable,
1180 struct g_part_entry *baseentry, struct sbuf *sb, const char *indent)
1182 struct g_part_ldm_entry *entry;
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,
1193 /* confxml: scheme information */
1198 g_part_ldm_dumpto(struct g_part_table *table, struct g_part_entry *baseentry)
1205 g_part_ldm_modify(struct g_part_table *basetable,
1206 struct g_part_entry *baseentry, struct g_part_parms *gpp)
1213 g_part_ldm_resize(struct g_part_table *basetable,
1214 struct g_part_entry *baseentry, struct g_part_parms *gpp)
1221 g_part_ldm_name(struct g_part_table *table, struct g_part_entry *baseentry,
1222 char *buf, size_t bufsz)
1225 snprintf(buf, bufsz, "s%d", baseentry->gpe_index);
1230 ldm_gpt_probe(struct g_part_table *basetable, struct g_consumer *cp)
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;
1241 * XXX: We use some knowlege about GEOM_PART_GPT internal
1242 * structures, but it is easier than parse GPT by himself.
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)
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);
1258 g_destroy_consumer(cp2);
1259 g_topology_unlock();
1262 error = g_access(cp2, 1, 0, 0);
1265 g_destroy_consumer(cp2);
1266 g_topology_unlock();
1269 g_topology_unlock();
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,
1278 table = (struct g_part_ldm_table *)basetable;
1281 return (G_PART_PROBE_PRI_HIGH);
1284 /* second consumer is no longer needed. */
1286 g_access(cp2, -1, 0, 0);
1288 g_destroy_consumer(cp2);
1291 g_topology_unlock();
1296 g_part_ldm_probe(struct g_part_table *basetable, struct g_consumer *cp)
1298 struct g_provider *pp;
1299 u_char *buf, type[64];
1304 if (pp->sectorsize != 512)
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)
1312 error = ldm_gpt_probe(basetable, cp);
1316 if (basetable->gpt_depth != 0)
1319 /* LDM has 1M metadata area */
1320 if (pp->mediasize <= 1024 * 1024)
1323 /* Check that there's a MBR */
1324 buf = g_read_data(cp, 0, pp->sectorsize, &error);
1328 if (le16dec(buf + DOSMAGICOFFSET) != DOSMAGIC) {
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)
1340 LDM_DEBUG(2, "%s: LDM data partitions found in MBR",
1342 /* Read the LDM private header */
1343 buf = ldm_privhdr_read(cp,
1344 ldm_ph_off[LDM_PH_MBRINDEX] * pp->sectorsize, &error);
1348 return (G_PART_PROBE_PRI_HIGH);
1354 g_part_ldm_read(struct g_part_table *basetable, struct g_consumer *cp)
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;
1364 int error, index, skipped;
1366 table = (struct g_part_ldm_table *)basetable;
1367 memset(&db, 0, sizeof(db));
1368 cp2 = cp; /* ms-ldm-data */
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);
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);
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.
1388 db.ph.db_offset = 0;
1390 /* Read and parse LDM TOC headers. */
1391 error = ldm_tochdr_check(&db, cp);
1394 /* Read and parse LDM VMDB header. */
1395 error = ldm_vmdbhdr_check(&db, cp);
1398 error = ldm_vmdb_parse(&db, cp);
1400 * For the GPT case we must detach and destroy
1401 * second consumer before return.
1404 if (table->is_gpt) {
1406 g_access(cp, -1, 0, 0);
1408 g_destroy_consumer(cp);
1409 g_topology_unlock();
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)
1420 LDM_DEBUG(1, "%s: no LDM volumes on this disk",
1421 cp->provider->name);
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)
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,
1442 * Allow mirrored volumes only when they are explicitly
1443 * allowed with kern.geom.part.ldm.show_mirrors=1.
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,
1452 entry = (struct g_part_ldm_entry *)g_part_new_entry(
1454 basetable->gpt_first + part->start,
1455 basetable->gpt_first + part->start +
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
1464 entry->type = vol->part_type;
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,
1480 g_part_ldm_setunset(struct g_part_table *table, struct g_part_entry *baseentry,
1481 const char *attrib, unsigned int set)
1488 g_part_ldm_type(struct g_part_table *basetable, struct g_part_entry *baseentry,
1489 char *buf, size_t bufsz)
1491 struct g_part_ldm_entry *entry;
1494 entry = (struct g_part_ldm_entry *)baseentry;
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));
1500 snprintf(buf, bufsz, "!%d", entry->type);
1505 g_part_ldm_write(struct g_part_table *basetable, struct g_consumer *cp)