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