sys/dev/dkwedge/dkwedge_gpt.c

   1 /*      $NetBSD: dkwedge_gpt.c,v 1.9 2008/06/29 15:13:28 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2004 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * EFI GUID Partition Table support for disk wedges
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __KERNEL_RCSID(0, "$NetBSD: dkwedge_gpt.c,v 1.9 2008/06/29 15:13:28 christos Exp $");
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/proc.h>
  42 #include <sys/errno.h>
  43 #include <sys/disk.h>
  44 #include <sys/vnode.h>
  45 #include <sys/malloc.h>
  46
  47 #include <sys/disklabel_gpt.h>
  48 #include <sys/uuid.h>
  49
  50 /*
  51  * GUID to dkw_ptype mapping information.
  52  *
  53  * GPT_ENT_TYPE_MS_BASIC_DATA is not suited to mapping.  Aside from being
  54  * used for multiple Microsoft file systems, Linux uses it for it's own
  55  * set of native file systems.  Treating this GUID as unknown seems best.
  56  */
  57
  58 static const struct {
  59         struct uuid ptype_guid;
  60         const char *ptype_str;
  61 } gpt_ptype_guid_to_str_tab[] = {
  62         { GPT_ENT_TYPE_EFI,                     DKW_PTYPE_FAT },
  63         { GPT_ENT_TYPE_NETBSD_SWAP,             DKW_PTYPE_SWAP },
  64         { GPT_ENT_TYPE_FREEBSD_SWAP,            DKW_PTYPE_SWAP },
  65         { GPT_ENT_TYPE_NETBSD_FFS,              DKW_PTYPE_FFS },
  66         { GPT_ENT_TYPE_FREEBSD_UFS,             DKW_PTYPE_FFS },
  67         { GPT_ENT_TYPE_APPLE_UFS,               DKW_PTYPE_FFS },
  68         { GPT_ENT_TYPE_NETBSD_LFS,              DKW_PTYPE_LFS },
  69         { GPT_ENT_TYPE_NETBSD_RAIDFRAME,        DKW_PTYPE_RAIDFRAME },
  70         { GPT_ENT_TYPE_NETBSD_CCD,              DKW_PTYPE_CCD },
  71         { GPT_ENT_TYPE_NETBSD_CGD,              DKW_PTYPE_CGD },
  72         { GPT_ENT_TYPE_APPLE_HFS,               DKW_PTYPE_APPLEHFS },
  73 };
  74
  75 static const char *
  76 gpt_ptype_guid_to_str(const struct uuid *guid)
  77 {
  78         int i;
  79
  80         for (i = 0; i < __arraycount(gpt_ptype_guid_to_str_tab); i++) {
  81                 if (memcmp(&gpt_ptype_guid_to_str_tab[i].ptype_guid,
  82                            guid, sizeof(*guid)) == 0)
  83                         return (gpt_ptype_guid_to_str_tab[i].ptype_str);
  84         }
  85
  86         return (DKW_PTYPE_UNKNOWN);
  87 }
  88
  89 static const uint32_t gpt_crc_tab[16] = {
  90         0x00000000U, 0x1db71064U, 0x3b6e20c8U, 0x26d930acU,
  91         0x76dc4190U, 0x6b6b51f4U, 0x4db26158U, 0x5005713cU,
  92         0xedb88320U, 0xf00f9344U, 0xd6d6a3e8U, 0xcb61b38cU,
  93         0x9b64c2b0U, 0x86d3d2d4U, 0xa00ae278U, 0xbdbdf21cU
  94 };
  95
  96 static uint32_t
  97 gpt_crc32(const void *vbuf, size_t len)
  98 {
  99         const uint8_t *buf = vbuf;
 100         uint32_t crc;
 101
 102         crc = 0xffffffffU;
 103         while (len--) {
 104                 crc ^= *buf++;
 105                 crc = (crc >> 4) ^ gpt_crc_tab[crc & 0xf];
 106                 crc = (crc >> 4) ^ gpt_crc_tab[crc & 0xf];
 107         }
 108
 109         return (crc ^ 0xffffffffU);
 110 }
 111
 112 static int
 113 gpt_verify_header_crc(struct gpt_hdr *hdr)
 114 {
 115         uint32_t crc;
 116         int rv;
 117
 118         crc = hdr->hdr_crc_self;
 119         hdr->hdr_crc_self = 0;
 120         rv = le32toh(crc) == gpt_crc32(hdr, le32toh(hdr->hdr_size));
 121         hdr->hdr_crc_self = crc;
 122
 123         return (rv);
 124 }
 125
 126 static int
 127 dkwedge_discover_gpt(struct disk *pdk, struct vnode *vp)
 128 {
 129         static const struct uuid ent_type_unused = GPT_ENT_TYPE_UNUSED;
 130         static const char gpt_hdr_sig[] = GPT_HDR_SIG;
 131         struct dkwedge_info dkw;
 132         void *buf;
 133         struct gpt_hdr *hdr;
 134         struct gpt_ent *ent;
 135         uint32_t entries, entsz;
 136         daddr_t lba_start, lba_end, lba_table;
 137         uint32_t gpe_crc;
 138         int error;
 139         u_int i;
 140
 141         buf = malloc(DEV_BSIZE, M_DEVBUF, M_WAITOK);
 142
 143         /*
 144          * Note: We don't bother with a Legacy or Protective MBR
 145          * here.  If a GPT is found, then the search stops, and
 146          * the GPT is authoritative.
 147          */
 148
 149         /* Read in the GPT Header. */
 150         error = dkwedge_read(pdk, vp, GPT_HDR_BLKNO, buf, DEV_BSIZE);
 151         if (error)
 152                 goto out;
 153         hdr = buf;
 154
 155         /* Validate it. */
 156         if (memcmp(gpt_hdr_sig, hdr->hdr_sig, sizeof(hdr->hdr_sig)) != 0) {
 157                 /* XXX Should check at end-of-disk. */
 158                 error = ESRCH;
 159                 goto out;
 160         }
 161         if (hdr->hdr_revision != htole32(GPT_HDR_REVISION)) {
 162                 /* XXX Should check at end-of-disk. */
 163                 error = ESRCH;
 164                 goto out;
 165         }
 166         if (le32toh(hdr->hdr_size) > DEV_BSIZE) {
 167                 /* XXX Should check at end-of-disk. */
 168                 error = ESRCH;
 169                 goto out;
 170         }
 171         if (gpt_verify_header_crc(hdr) == 0) {
 172                 /* XXX Should check at end-of-disk. */
 173                 error = ESRCH;
 174                 goto out;
 175         }
 176
 177         /* XXX Now that we found it, should we validate the backup? */
 178
 179         {
 180                 struct uuid disk_guid;
 181                 char guid_str[UUID_STR_LEN];
 182                 uuid_dec_le(hdr->hdr_guid, &disk_guid);
 183                 uuid_snprintf(guid_str, sizeof(guid_str), &disk_guid);
 184                 aprint_verbose("%s: GPT GUID: %s\n", pdk->dk_name, guid_str);
 185         }
 186
 187         entries = le32toh(hdr->hdr_entries);
 188         entsz = roundup(le32toh(hdr->hdr_entsz), 8);
 189         if (entsz > roundup(sizeof(struct gpt_ent), 8)) {
 190                 aprint_error("%s: bogus GPT entry size: %u\n",
 191                     pdk->dk_name, le32toh(hdr->hdr_entsz));
 192                 error = EINVAL;
 193                 goto out;
 194         }
 195         gpe_crc = le32toh(hdr->hdr_crc_table);
 196
 197         /* XXX Clamp entries at 128 for now. */
 198         if (entries > 128) {
 199                 aprint_error("%s: WARNING: clamping number of GPT entries to "
 200                     "128 (was %u)\n", pdk->dk_name, entries);
 201                 entries = 128;
 202         }
 203
 204         lba_start = le64toh(hdr->hdr_lba_start);
 205         lba_end = le64toh(hdr->hdr_lba_end);
 206         lba_table = le64toh(hdr->hdr_lba_table);
 207         if (lba_start < 0 || lba_end < 0 || lba_table < 0) {
 208                 aprint_error("%s: GPT block numbers out of range\n",
 209                     pdk->dk_name);
 210                 error = EINVAL;
 211                 goto out;
 212         }
 213
 214         free(buf, M_DEVBUF);
 215         buf = malloc(roundup(entries * entsz, DEV_BSIZE), M_DEVBUF, M_WAITOK);
 216         error = dkwedge_read(pdk, vp, lba_table, buf,
 217                              roundup(entries * entsz, DEV_BSIZE));
 218         if (error) {
 219                 /* XXX Should check alternate location. */
 220                 aprint_error("%s: unable to read GPT partition array, "
 221                     "error = %d\n", pdk->dk_name, error);
 222                 goto out;
 223         }
 224
 225         if (gpt_crc32(buf, entries * entsz) != gpe_crc) {
 226                 /* XXX Should check alternate location. */
 227                 aprint_error("%s: bad GPT partition array CRC\n",
 228                     pdk->dk_name);
 229                 error = EINVAL;
 230                 goto out;
 231         }
 232
 233         /*
 234          * Walk the partitions, adding a wedge for each type we know about.
 235          */
 236         for (i = 0; i < entries; i++) {
 237                 struct uuid ptype_guid, ent_guid;
 238                 const char *ptype;
 239                 int j;
 240                 char ptype_guid_str[UUID_STR_LEN], ent_guid_str[UUID_STR_LEN];
 241
 242                 ent = (struct gpt_ent *)((char *)buf + (i * entsz));
 243
 244                 uuid_dec_le(ent->ent_type, &ptype_guid);
 245                 if (memcmp(&ptype_guid, &ent_type_unused,
 246                            sizeof(ptype_guid)) == 0)
 247                         continue;
 248
 249                 uuid_dec_le(ent->ent_guid, &ent_guid);
 250
 251                 uuid_snprintf(ptype_guid_str, sizeof(ptype_guid_str),
 252                     &ptype_guid);
 253                 uuid_snprintf(ent_guid_str, sizeof(ent_guid_str),
 254                     &ent_guid);
 255
 256                 /* figure out the type */
 257                 ptype = gpt_ptype_guid_to_str(&ptype_guid);
 258                 strcpy(dkw.dkw_ptype, ptype);
 259
 260                 strcpy(dkw.dkw_parent, pdk->dk_name);
 261                 dkw.dkw_offset = le64toh(ent->ent_lba_start);
 262                 dkw.dkw_size = le64toh(ent->ent_lba_end) - dkw.dkw_offset + 1;
 263
 264                 /* XXX Make sure it falls within the disk's data area. */
 265
 266                 if (ent->ent_name[0] == 0x0000)
 267                         strcpy(dkw.dkw_wname, ent_guid_str);
 268                 else {
 269                         for (j = 0; ent->ent_name[j] != 0x0000; j++) {
 270                                 /* XXX UTF-16 -> UTF-8 */
 271                                 dkw.dkw_wname[j] =
 272                                     le16toh(ent->ent_name[j]) & 0xff;
 273                         }
 274                         dkw.dkw_wname[j] = '\0';
 275                 }
 276
 277                 /*
 278                  * Try with the partition name first.  If that fails,
 279                  * use the GUID string.  If that fails, punt.
 280                  */
 281                 if ((error = dkwedge_add(&dkw)) == EEXIST) {
 282                         aprint_error("%s: wedge named '%s' already exists, "
 283                             "trying '%s'\n", pdk->dk_name,
 284                             dkw.dkw_wname, /* XXX Unicode */
 285                             ent_guid_str);
 286                         strcpy(dkw.dkw_wname, ent_guid_str);
 287                         error = dkwedge_add(&dkw);
 288                 }
 289                 if (error == EEXIST)
 290                         aprint_error("%s: wedge named '%s' already exists, "
 291                             "manual intervention required\n", pdk->dk_name,
 292                             dkw.dkw_wname);
 293                 else if (error)
 294                         aprint_error("%s: error %d adding entry %u (%s), "
 295                             "type %s\n", pdk->dk_name, error, i, ent_guid_str,
 296                             ptype_guid_str);
 297         }
 298         error = 0;
 299
 300  out:
 301         free(buf, M_DEVBUF);
 302         return (error);
 303 }
 304
 305 DKWEDGE_DISCOVERY_METHOD_DECL(GPT, 0, dkwedge_discover_gpt);