sys/geom/part/g_part_ldm.c

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