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