?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
9098 loader: ptable_close should check for NULL argument
[unleashed.git] / usr / src / boot / sys / boot / common / part.c
blob37eb7870ead8830eb1f79041336fe31a98339e93
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 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28
29 #include <stand.h>
30 #include <sys/param.h>
31 #include <sys/diskmbr.h>
32 #include <sys/disklabel.h>
33 #include <sys/endian.h>
34 #include <sys/gpt.h>
35 #include <sys/stddef.h>
36 #include <sys/queue.h>
37 #include <sys/vtoc.h>
38
39 #include <crc32.h>
40 #include <part.h>
41 #include <uuid.h>
42
43 #ifdef PART_DEBUG
44 #define DEBUG(fmt, args...) printf("%s: " fmt "\n", __func__, ## args)
45 #else
46 #define DEBUG(fmt, args...)
47 #endif
48
49 #ifdef LOADER_GPT_SUPPORT
50 #define MAXTBLSZ 64
51 static const uuid_t gpt_uuid_unused = GPT_ENT_TYPE_UNUSED;
52 static const uuid_t gpt_uuid_ms_basic_data = GPT_ENT_TYPE_MS_BASIC_DATA;
53 static const uuid_t gpt_uuid_freebsd_ufs = GPT_ENT_TYPE_FREEBSD_UFS;
54 static const uuid_t gpt_uuid_efi = GPT_ENT_TYPE_EFI;
55 static const uuid_t gpt_uuid_freebsd = GPT_ENT_TYPE_FREEBSD;
56 static const uuid_t gpt_uuid_freebsd_boot = GPT_ENT_TYPE_FREEBSD_BOOT;
57 static const uuid_t gpt_uuid_freebsd_nandfs = GPT_ENT_TYPE_FREEBSD_NANDFS;
58 static const uuid_t gpt_uuid_freebsd_swap = GPT_ENT_TYPE_FREEBSD_SWAP;
59 static const uuid_t gpt_uuid_freebsd_zfs = GPT_ENT_TYPE_FREEBSD_ZFS;
60 static const uuid_t gpt_uuid_freebsd_vinum = GPT_ENT_TYPE_FREEBSD_VINUM;
61 static const uuid_t gpt_uuid_illumos_boot = GPT_ENT_TYPE_ILLUMOS_BOOT;
62 static const uuid_t gpt_uuid_illumos_ufs = GPT_ENT_TYPE_ILLUMOS_UFS;
63 static const uuid_t gpt_uuid_illumos_zfs = GPT_ENT_TYPE_ILLUMOS_ZFS;
64 static const uuid_t gpt_uuid_reserved = GPT_ENT_TYPE_RESERVED;
65 #endif
66
67 struct pentry {
68 struct ptable_entry part;
69 uint64_t flags;
70 union {
71 uint8_t bsd;
72 uint8_t mbr;
73 uuid_t gpt;
74 uint16_t vtoc8;
75 uint16_t vtoc;
76 } type;
77 STAILQ_ENTRY(pentry) entry;
78 };
79
80 struct ptable {
81 enum ptable_type type;
82 uint16_t sectorsize;
83 uint64_t sectors;
84
85 STAILQ_HEAD(, pentry) entries;
86 };
87
88 static struct parttypes {
89 enum partition_type type;
90 const char *desc;
91 } ptypes[] = {
92 { PART_UNKNOWN, "Unknown" },
93 { PART_EFI, "EFI" },
94 { PART_FREEBSD, "FreeBSD" },
95 { PART_FREEBSD_BOOT, "FreeBSD boot" },
96 { PART_FREEBSD_NANDFS, "FreeBSD nandfs" },
97 { PART_FREEBSD_UFS, "FreeBSD UFS" },
98 { PART_FREEBSD_ZFS, "FreeBSD ZFS" },
99 { PART_FREEBSD_SWAP, "FreeBSD swap" },
100 { PART_FREEBSD_VINUM, "FreeBSD vinum" },
101 { PART_LINUX, "Linux" },
102 { PART_LINUX_SWAP, "Linux swap" },
103 { PART_DOS, "DOS/Windows" },
104 { PART_SOLARIS2, "Solaris 2" },
105 { PART_ILLUMOS_UFS, "illumos UFS" },
106 { PART_ILLUMOS_ZFS, "illumos ZFS" },
107 { PART_RESERVED, "Reserved" },
108 { PART_VTOC_BOOT, "boot" },
109 { PART_VTOC_ROOT, "root" },
110 { PART_VTOC_SWAP, "swap" },
111 { PART_VTOC_USR, "usr" },
112 { PART_VTOC_STAND, "stand" },
113 { PART_VTOC_VAR, "var" },
114 { PART_VTOC_HOME, "home" }
115 };
116
117 const char *
118 parttype2str(enum partition_type type)
119 {
120 size_t i;
121
122 for (i = 0; i < nitems(ptypes); i++)
123 if (ptypes[i].type == type)
124 return (ptypes[i].desc);
125 return (ptypes[0].desc);
126 }
127
128 #ifdef LOADER_GPT_SUPPORT
129 static void
130 uuid_letoh(uuid_t *uuid)
131 {
132
133 uuid->time_low = le32toh(uuid->time_low);
134 uuid->time_mid = le16toh(uuid->time_mid);
135 uuid->time_hi_and_version = le16toh(uuid->time_hi_and_version);
136 }
137
138 static enum partition_type
139 gpt_parttype(uuid_t type)
140 {
141
142 if (uuid_equal(&type, &gpt_uuid_efi, NULL))
143 return (PART_EFI);
144 else if (uuid_equal(&type, &gpt_uuid_ms_basic_data, NULL))
145 return (PART_DOS);
146 else if (uuid_equal(&type, &gpt_uuid_freebsd_boot, NULL))
147 return (PART_FREEBSD_BOOT);
148 else if (uuid_equal(&type, &gpt_uuid_freebsd_ufs, NULL))
149 return (PART_FREEBSD_UFS);
150 else if (uuid_equal(&type, &gpt_uuid_freebsd_zfs, NULL))
151 return (PART_FREEBSD_ZFS);
152 else if (uuid_equal(&type, &gpt_uuid_freebsd_swap, NULL))
153 return (PART_FREEBSD_SWAP);
154 else if (uuid_equal(&type, &gpt_uuid_freebsd_vinum, NULL))
155 return (PART_FREEBSD_VINUM);
156 else if (uuid_equal(&type, &gpt_uuid_freebsd_nandfs, NULL))
157 return (PART_FREEBSD_NANDFS);
158 else if (uuid_equal(&type, &gpt_uuid_freebsd, NULL))
159 return (PART_FREEBSD);
160 else if (uuid_equal(&type, &gpt_uuid_illumos_boot, NULL))
161 return (PART_VTOC_BOOT);
162 else if (uuid_equal(&type, &gpt_uuid_illumos_ufs, NULL))
163 return (PART_ILLUMOS_UFS);
164 else if (uuid_equal(&type, &gpt_uuid_illumos_zfs, NULL))
165 return (PART_ILLUMOS_ZFS);
166 else if (uuid_equal(&type, &gpt_uuid_reserved, NULL))
167 return (PART_RESERVED);
168 return (PART_UNKNOWN);
169 }
170
171 static struct gpt_hdr *
172 gpt_checkhdr(struct gpt_hdr *hdr, uint64_t lba_self,
173 uint64_t lba_last __attribute((unused)), uint16_t sectorsize)
174 {
175 uint32_t sz, crc;
176
177 if (memcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof (hdr->hdr_sig)) != 0) {
178 DEBUG("no GPT signature");
179 return (NULL);
180 }
181 sz = le32toh(hdr->hdr_size);
182 if (sz < 92 || sz > sectorsize) {
183 DEBUG("invalid GPT header size: %d", sz);
184 return (NULL);
185 }
186 crc = le32toh(hdr->hdr_crc_self);
187 hdr->hdr_crc_self = 0;
188 if (crc32(hdr, sz) != crc) {
189 DEBUG("GPT header's CRC doesn't match");
190 return (NULL);
191 }
192 hdr->hdr_crc_self = crc;
193 hdr->hdr_revision = le32toh(hdr->hdr_revision);
194 if (hdr->hdr_revision < GPT_HDR_REVISION) {
195 DEBUG("unsupported GPT revision %d", hdr->hdr_revision);
196 return (NULL);
197 }
198 hdr->hdr_lba_self = le64toh(hdr->hdr_lba_self);
199 if (hdr->hdr_lba_self != lba_self) {
200 DEBUG("self LBA doesn't match");
201 return (NULL);
202 }
203 hdr->hdr_lba_alt = le64toh(hdr->hdr_lba_alt);
204 if (hdr->hdr_lba_alt == hdr->hdr_lba_self) {
205 DEBUG("invalid alternate LBA");
206 return (NULL);
207 }
208 hdr->hdr_entries = le32toh(hdr->hdr_entries);
209 hdr->hdr_entsz = le32toh(hdr->hdr_entsz);
210 if (hdr->hdr_entries == 0 ||
211 hdr->hdr_entsz < sizeof (struct gpt_ent) ||
212 sectorsize % hdr->hdr_entsz != 0) {
213 DEBUG("invalid entry size or number of entries");
214 return (NULL);
215 }
216 hdr->hdr_lba_start = le64toh(hdr->hdr_lba_start);
217 hdr->hdr_lba_end = le64toh(hdr->hdr_lba_end);
218 hdr->hdr_lba_table = le64toh(hdr->hdr_lba_table);
219 hdr->hdr_crc_table = le32toh(hdr->hdr_crc_table);
220 uuid_letoh(&hdr->hdr_uuid);
221 return (hdr);
222 }
223
224 static int
225 gpt_checktbl(const struct gpt_hdr *hdr, uint8_t *tbl, size_t size,
226 uint64_t lba_last __attribute((unused)))
227 {
228 struct gpt_ent *ent;
229 uint32_t i, cnt;
230
231 cnt = size / hdr->hdr_entsz;
232 if (hdr->hdr_entries <= cnt) {
233 cnt = hdr->hdr_entries;
234 /* Check CRC only when buffer size is enough for table. */
235 if (hdr->hdr_crc_table !=
236 crc32(tbl, hdr->hdr_entries * hdr->hdr_entsz)) {
237 DEBUG("GPT table's CRC doesn't match");
238 return (-1);
239 }
240 }
241 for (i = 0; i < cnt; i++) {
242 ent = (struct gpt_ent *)(tbl + i * hdr->hdr_entsz);
243 uuid_letoh(&ent->ent_type);
244 if (uuid_equal(&ent->ent_type, &gpt_uuid_unused, NULL))
245 continue;
246 ent->ent_lba_start = le64toh(ent->ent_lba_start);
247 ent->ent_lba_end = le64toh(ent->ent_lba_end);
248 }
249 return (0);
250 }
251
252 static struct ptable *
253 ptable_gptread(struct ptable *table, void *dev, diskread_t dread)
254 {
255 struct pentry *entry;
256 struct gpt_hdr *phdr, hdr;
257 struct gpt_ent *ent;
258 uint8_t *buf, *tbl;
259 uint64_t offset;
260 int pri, sec;
261 size_t size, i;
262
263 buf = malloc(table->sectorsize);
264 if (buf == NULL)
265 return (NULL);
266 tbl = malloc(table->sectorsize * MAXTBLSZ);
267 if (tbl == NULL) {
268 free(buf);
269 return (NULL);
270 }
271 /* Read the primary GPT header. */
272 if (dread(dev, buf, 1, 1) != 0) {
273 ptable_close(table);
274 table = NULL;
275 goto out;
276 }
277 pri = sec = 0;
278 /* Check the primary GPT header. */
279 phdr = gpt_checkhdr((struct gpt_hdr *)buf, 1, table->sectors - 1,
280 table->sectorsize);
281 if (phdr != NULL) {
282 /* Read the primary GPT table. */
283 size = MIN(MAXTBLSZ, (phdr->hdr_entries * phdr->hdr_entsz +
284 table->sectorsize - 1) / table->sectorsize);
285 if (dread(dev, tbl, size, phdr->hdr_lba_table) == 0 &&
286 gpt_checktbl(phdr, tbl, size * table->sectorsize,
287 table->sectors - 1) == 0) {
288 memcpy(&hdr, phdr, sizeof (hdr));
289 pri = 1;
290 }
291 }
292 offset = pri ? hdr.hdr_lba_alt: table->sectors - 1;
293 /* Read the backup GPT header. */
294 if (dread(dev, buf, 1, offset) != 0)
295 phdr = NULL;
296 else
297 phdr = gpt_checkhdr((struct gpt_hdr *)buf, offset,
298 table->sectors - 1, table->sectorsize);
299 if (phdr != NULL) {
300 /*
301 * Compare primary and backup headers.
302 * If they are equal, then we do not need to read backup
303 * table. If they are different, then prefer backup header
304 * and try to read backup table.
305 */
306 if (pri == 0 ||
307 uuid_equal(&hdr.hdr_uuid, &phdr->hdr_uuid, NULL) == 0 ||
308 hdr.hdr_revision != phdr->hdr_revision ||
309 hdr.hdr_size != phdr->hdr_size ||
310 hdr.hdr_lba_start != phdr->hdr_lba_start ||
311 hdr.hdr_lba_end != phdr->hdr_lba_end ||
312 hdr.hdr_entries != phdr->hdr_entries ||
313 hdr.hdr_entsz != phdr->hdr_entsz ||
314 hdr.hdr_crc_table != phdr->hdr_crc_table) {
315 /* Read the backup GPT table. */
316 size = MIN(MAXTBLSZ, (phdr->hdr_entries *
317 phdr->hdr_entsz + table->sectorsize - 1) /
318 table->sectorsize);
319 if (dread(dev, tbl, size, phdr->hdr_lba_table) == 0 &&
320 gpt_checktbl(phdr, tbl, size * table->sectorsize,
321 table->sectors - 1) == 0) {
322 memcpy(&hdr, phdr, sizeof (hdr));
323 sec = 1;
324 }
325 }
326 }
327 if (pri == 0 && sec == 0) {
328 /* Both primary and backup tables are invalid. */
329 table->type = PTABLE_NONE;
330 goto out;
331 }
332 DEBUG("GPT detected");
333 size = MIN(hdr.hdr_entries * hdr.hdr_entsz,
334 MAXTBLSZ * table->sectorsize);
335
336 /*
337 * If the disk's sector count is smaller than the sector count recorded
338 * in the disk's GPT table header, set the table->sectors to the value
339 * recorded in GPT tables. This is done to work around buggy firmware
340 * that returns truncated disk sizes.
341 *
342 * Note, this is still not a foolproof way to get disk's size. For
343 * example, an image file can be truncated when copied to smaller media.
344 */
345 if (hdr.hdr_lba_alt + 1 > table->sectors)
346 table->sectors = hdr.hdr_lba_alt + 1;
347
348 for (i = 0; i < size / hdr.hdr_entsz; i++) {
349 ent = (struct gpt_ent *)(tbl + i * hdr.hdr_entsz);
350 if (uuid_equal(&ent->ent_type, &gpt_uuid_unused, NULL))
351 continue;
352
353 /* Simple sanity checks. */
354 if (ent->ent_lba_start < hdr.hdr_lba_start ||
355 ent->ent_lba_end > hdr.hdr_lba_end ||
356 ent->ent_lba_start > ent->ent_lba_end)
357 continue;
358
359 entry = malloc(sizeof (*entry));
360 if (entry == NULL)
361 break;
362 entry->part.start = ent->ent_lba_start;
363 entry->part.end = ent->ent_lba_end;
364 entry->part.index = i + 1;
365 entry->part.type = gpt_parttype(ent->ent_type);
366 entry->flags = le64toh(ent->ent_attr);
367 memcpy(&entry->type.gpt, &ent->ent_type, sizeof (uuid_t));
368 STAILQ_INSERT_TAIL(&table->entries, entry, entry);
369 DEBUG("new GPT partition added");
370 }
371 out:
372 free(buf);
373 free(tbl);
374 return (table);
375 }
376 #endif /* LOADER_GPT_SUPPORT */
377
378 #ifdef LOADER_MBR_SUPPORT
379 /* We do not need to support too many EBR partitions in the loader */
380 #define MAXEBRENTRIES 8
381 static enum partition_type
382 mbr_parttype(uint8_t type)
383 {
384
385 switch (type) {
386 case DOSPTYP_386BSD:
387 return (PART_FREEBSD);
388 case DOSPTYP_LINSWP:
389 return (PART_LINUX_SWAP);
390 case DOSPTYP_LINUX:
391 return (PART_LINUX);
392 case DOSPTYP_SUNIXOS2:
393 return (PART_SOLARIS2);
394 case 0x01:
395 case 0x04:
396 case 0x06:
397 case 0x07:
398 case 0x0b:
399 case 0x0c:
400 case 0x0e:
401 return (PART_DOS);
402 }
403 return (PART_UNKNOWN);
404 }
405
406 static struct ptable *
407 ptable_ebrread(struct ptable *table, void *dev, diskread_t dread)
408 {
409 struct dos_partition *dp;
410 struct pentry *e1, *entry;
411 uint32_t start, end, offset;
412 uint8_t *buf;
413 int i, idx;
414
415 STAILQ_FOREACH(e1, &table->entries, entry) {
416 if (e1->type.mbr == DOSPTYP_EXT ||
417 e1->type.mbr == DOSPTYP_EXTLBA)
418 break;
419 }
420 if (e1 == NULL)
421 return (table);
422 idx = 5;
423 offset = e1->part.start;
424 buf = malloc(table->sectorsize);
425 if (buf == NULL)
426 return (table);
427 DEBUG("EBR detected");
428 for (i = 0; i < MAXEBRENTRIES; i++) {
429 #if 0 /* Some BIOSes return an incorrect number of sectors */
430 if (offset >= table->sectors)
431 break;
432 #endif
433 if (dread(dev, buf, 1, offset) != 0)
434 break;
435 dp = (struct dos_partition *)(buf + DOSPARTOFF);
436 if (dp[0].dp_typ == 0)
437 break;
438 start = le32toh(dp[0].dp_start);
439 if (dp[0].dp_typ == DOSPTYP_EXT &&
440 dp[1].dp_typ == 0) {
441 offset = e1->part.start + start;
442 continue;
443 }
444 end = le32toh(dp[0].dp_size);
445 entry = malloc(sizeof (*entry));
446 if (entry == NULL)
447 break;
448 entry->part.start = offset + start;
449 entry->part.end = entry->part.start + end - 1;
450 entry->part.index = idx++;
451 entry->part.type = mbr_parttype(dp[0].dp_typ);
452 entry->flags = dp[0].dp_flag;
453 entry->type.mbr = dp[0].dp_typ;
454 STAILQ_INSERT_TAIL(&table->entries, entry, entry);
455 DEBUG("new EBR partition added");
456 if (dp[1].dp_typ == 0)
457 break;
458 offset = e1->part.start + le32toh(dp[1].dp_start);
459 }
460 free(buf);
461 return (table);
462 }
463 #endif /* LOADER_MBR_SUPPORT */
464
465 static enum partition_type
466 bsd_parttype(uint8_t type)
467 {
468
469 switch (type) {
470 case FS_NANDFS:
471 return (PART_FREEBSD_NANDFS);
472 case FS_SWAP:
473 return (PART_FREEBSD_SWAP);
474 case FS_BSDFFS:
475 return (PART_FREEBSD_UFS);
476 case FS_VINUM:
477 return (PART_FREEBSD_VINUM);
478 case FS_ZFS:
479 return (PART_FREEBSD_ZFS);
480 }
481 return (PART_UNKNOWN);
482 }
483
484 static struct ptable *
485 ptable_bsdread(struct ptable *table, void *dev, diskread_t dread)
486 {
487 struct disklabel *dl;
488 struct partition *part;
489 struct pentry *entry;
490 uint8_t *buf;
491 uint32_t raw_offset;
492 int i;
493
494 if (table->sectorsize < sizeof (struct disklabel)) {
495 DEBUG("Too small sectorsize");
496 return (table);
497 }
498 buf = malloc(table->sectorsize);
499 if (buf == NULL)
500 return (table);
501 if (dread(dev, buf, 1, 1) != 0) {
502 DEBUG("read failed");
503 ptable_close(table);
504 table = NULL;
505 goto out;
506 }
507 dl = (struct disklabel *)buf;
508 if (le32toh(dl->d_magic) != DISKMAGIC &&
509 le32toh(dl->d_magic2) != DISKMAGIC)
510 goto out;
511 if (le32toh(dl->d_secsize) != table->sectorsize) {
512 DEBUG("unsupported sector size");
513 goto out;
514 }
515 dl->d_npartitions = le16toh(dl->d_npartitions);
516 if (dl->d_npartitions > 20 || dl->d_npartitions < 8) {
517 DEBUG("invalid number of partitions");
518 goto out;
519 }
520 DEBUG("BSD detected");
521 part = &dl->d_partitions[0];
522 raw_offset = le32toh(part[RAW_PART].p_offset);
523 for (i = 0; i < dl->d_npartitions; i++, part++) {
524 if (i == RAW_PART)
525 continue;
526 if (part->p_size == 0)
527 continue;
528 entry = malloc(sizeof (*entry));
529 if (entry == NULL)
530 break;
531 entry->part.start = le32toh(part->p_offset) - raw_offset;
532 entry->part.end = entry->part.start +
533 le32toh(part->p_size) - 1;
534 entry->part.type = bsd_parttype(part->p_fstype);
535 entry->part.index = i; /* starts from zero */
536 entry->type.bsd = part->p_fstype;
537 STAILQ_INSERT_TAIL(&table->entries, entry, entry);
538 DEBUG("new BSD partition added");
539 }
540 table->type = PTABLE_BSD;
541 out:
542 free(buf);
543 return (table);
544 }
545
546 #ifdef LOADER_VTOC8_SUPPORT
547 static enum partition_type
548 vtoc8_parttype(uint16_t type)
549 {
550
551 switch (type) {
552 case VTOC_TAG_FREEBSD_NANDFS:
553 return (PART_FREEBSD_NANDFS);
554 case VTOC_TAG_FREEBSD_SWAP:
555 return (PART_FREEBSD_SWAP);
556 case VTOC_TAG_FREEBSD_UFS:
557 return (PART_FREEBSD_UFS);
558 case VTOC_TAG_FREEBSD_VINUM:
559 return (PART_FREEBSD_VINUM);
560 case VTOC_TAG_FREEBSD_ZFS:
561 return (PART_FREEBSD_ZFS);
562 };
563 return (PART_UNKNOWN);
564 }
565
566 static struct ptable *
567 ptable_vtoc8read(struct ptable *table, void *dev, diskread_t dread)
568 {
569 struct pentry *entry;
570 struct vtoc8 *dl;
571 uint8_t *buf;
572 uint16_t sum, heads, sectors;
573 int i;
574
575 if (table->sectorsize != sizeof (struct vtoc8))
576 return (table);
577 buf = malloc(table->sectorsize);
578 if (buf == NULL)
579 return (table);
580 if (dread(dev, buf, 1, 0) != 0) {
581 DEBUG("read failed");
582 ptable_close(table);
583 table = NULL;
584 goto out;
585 }
586 dl = (struct vtoc8 *)buf;
587 /* Check the sum */
588 for (i = sum = 0; i < sizeof (struct vtoc8); i += sizeof (sum))
589 sum ^= be16dec(buf + i);
590 if (sum != 0) {
591 DEBUG("incorrect checksum");
592 goto out;
593 }
594 if (be16toh(dl->nparts) != VTOC8_NPARTS) {
595 DEBUG("invalid number of entries");
596 goto out;
597 }
598 sectors = be16toh(dl->nsecs);
599 heads = be16toh(dl->nheads);
600 if (sectors * heads == 0) {
601 DEBUG("invalid geometry");
602 goto out;
603 }
604 DEBUG("VTOC8 detected");
605 for (i = 0; i < VTOC8_NPARTS; i++) {
606 dl->part[i].tag = be16toh(dl->part[i].tag);
607 if (i == VTOC_RAW_PART ||
608 dl->part[i].tag == VTOC_TAG_UNASSIGNED)
609 continue;
610 entry = malloc(sizeof (*entry));
611 if (entry == NULL)
612 break;
613 entry->part.start = be32toh(dl->map[i].cyl) * heads * sectors;
614 entry->part.end = be32toh(dl->map[i].nblks) +
615 entry->part.start - 1;
616 entry->part.type = vtoc8_parttype(dl->part[i].tag);
617 entry->part.index = i; /* starts from zero */
618 entry->type.vtoc8 = dl->part[i].tag;
619 STAILQ_INSERT_TAIL(&table->entries, entry, entry);
620 DEBUG("new VTOC8 partition added");
621 }
622 table->type = PTABLE_VTOC8;
623 out:
624 free(buf);
625 return (table);
626
627 }
628 #endif /* LOADER_VTOC8_SUPPORT */
629
630 static enum partition_type
631 vtoc_parttype(uint16_t type)
632 {
633 switch (type) {
634 case VTOC_TAG_BOOT:
635 return (PART_VTOC_BOOT);
636 case VTOC_TAG_ROOT:
637 return (PART_VTOC_ROOT);
638 case VTOC_TAG_SWAP:
639 return (PART_VTOC_SWAP);
640 case VTOC_TAG_USR:
641 return (PART_VTOC_USR);
642 case VTOC_TAG_BACKUP:
643 return (PART_VTOC_BACKUP);
644 case VTOC_TAG_STAND:
645 return (PART_VTOC_STAND);
646 case VTOC_TAG_VAR:
647 return (PART_VTOC_VAR);
648 case VTOC_TAG_HOME:
649 return (PART_VTOC_HOME);
650 };
651 return (PART_UNKNOWN);
652 }
653
654 static struct ptable *
655 ptable_dklabelread(struct ptable *table, void *dev, diskread_t dread)
656 {
657 struct pentry *entry;
658 struct dk_label *dl;
659 struct dk_vtoc *dv;
660 uint8_t *buf;
661 int i;
662
663 if (table->sectorsize < sizeof (struct dk_label)) {
664 DEBUG("Too small sectorsize");
665 return (table);
666 }
667 buf = malloc(table->sectorsize);
668 if (buf == NULL)
669 return (table);
670 if (dread(dev, buf, 1, DK_LABEL_LOC) != 0) {
671 DEBUG("read failed");
672 ptable_close(table);
673 table = NULL;
674 goto out;
675 }
676 dl = (struct dk_label *)buf;
677 dv = (struct dk_vtoc *)&dl->dkl_vtoc;
678
679 if (dl->dkl_magic != VTOC_MAGIC) {
680 DEBUG("dk_label magic error");
681 goto out;
682 }
683 if (dv->v_sanity != VTOC_SANITY) {
684 DEBUG("this vtoc is not sane");
685 goto out;
686 }
687 if (dv->v_nparts != NDKMAP) {
688 DEBUG("invalid number of entries");
689 goto out;
690 }
691 DEBUG("VTOC detected");
692 for (i = 0; i < NDKMAP; i++) {
693 if (i == VTOC_RAW_PART || /* skip slice 2 and empty */
694 dv->v_part[i].p_size == 0)
695 continue;
696 entry = malloc(sizeof (*entry));
697 if (entry == NULL)
698 break;
699 entry->part.start = dv->v_part[i].p_start;
700 entry->part.end = dv->v_part[i].p_size +
701 entry->part.start - 1;
702 entry->part.type = vtoc_parttype(dv->v_part[i].p_tag);
703 entry->part.index = i; /* starts from zero */
704 entry->type.vtoc = dv->v_part[i].p_tag;
705 STAILQ_INSERT_TAIL(&table->entries, entry, entry);
706 DEBUG("new VTOC partition added");
707 }
708 table->type = PTABLE_VTOC;
709 out:
710 free(buf);
711 return (table);
712 }
713
714 struct ptable *
715 ptable_open(void *dev, uint64_t sectors, uint16_t sectorsize, diskread_t *dread)
716 {
717 struct dos_partition *dp;
718 struct ptable *table;
719 uint8_t *buf;
720 int i, count;
721 #ifdef LOADER_MBR_SUPPORT
722 struct pentry *entry;
723 uint32_t start, end;
724 int has_ext;
725 #endif
726 table = NULL;
727 buf = malloc(sectorsize);
728 if (buf == NULL)
729 return (NULL);
730 /* First, read the MBR. */
731 if (dread(dev, buf, 1, DOSBBSECTOR) != 0) {
732 DEBUG("read failed");
733 goto out;
734 }
735
736 table = malloc(sizeof (*table));
737 if (table == NULL)
738 goto out;
739 table->sectors = sectors;
740 table->sectorsize = sectorsize;
741 table->type = PTABLE_NONE;
742 STAILQ_INIT(&table->entries);
743
744 if (ptable_dklabelread(table, dev, dread) == NULL) { /* Read error. */
745 table = NULL;
746 goto out;
747 } else if (table->type == PTABLE_VTOC)
748 goto out;
749
750 #ifdef LOADER_VTOC8_SUPPORT
751 if (be16dec(buf + offsetof(struct vtoc8, magic)) == VTOC_MAGIC) {
752 if (ptable_vtoc8read(table, dev, dread) == NULL) {
753 /* Read error. */
754 table = NULL;
755 goto out;
756 } else if (table->type == PTABLE_VTOC8)
757 goto out;
758 }
759 #endif
760 /* Check the BSD label. */
761 if (ptable_bsdread(table, dev, dread) == NULL) { /* Read error. */
762 table = NULL;
763 goto out;
764 } else if (table->type == PTABLE_BSD)
765 goto out;
766
767 #if defined(LOADER_GPT_SUPPORT) || defined(LOADER_MBR_SUPPORT)
768 /* Check the MBR magic. */
769 if (buf[DOSMAGICOFFSET] != 0x55 ||
770 buf[DOSMAGICOFFSET + 1] != 0xaa) {
771 DEBUG("magic sequence not found");
772 #if defined(LOADER_GPT_SUPPORT)
773 /* There is no PMBR, check that we have backup GPT */
774 table->type = PTABLE_GPT;
775 table = ptable_gptread(table, dev, dread);
776 #endif
777 goto out;
778 }
779 /* Check that we have PMBR. Also do some validation. */
780 dp = (struct dos_partition *)(buf + DOSPARTOFF);
781 for (i = 0, count = 0; i < NDOSPART; i++) {
782 if (dp[i].dp_flag != 0 && dp[i].dp_flag != 0x80) {
783 DEBUG("invalid partition flag %x", dp[i].dp_flag);
784 goto out;
785 }
786 #ifdef LOADER_GPT_SUPPORT
787 if (dp[i].dp_typ == DOSPTYP_PMBR) {
788 table->type = PTABLE_GPT;
789 DEBUG("PMBR detected");
790 }
791 #endif
792 if (dp[i].dp_typ != 0)
793 count++;
794 }
795 /* Do we have some invalid values? */
796 if (table->type == PTABLE_GPT && count > 1) {
797 if (dp[1].dp_typ != DOSPTYP_HFS) {
798 table->type = PTABLE_NONE;
799 DEBUG("Incorrect PMBR, ignore it");
800 } else {
801 DEBUG("Bootcamp detected");
802 }
803 }
804 #ifdef LOADER_GPT_SUPPORT
805 if (table->type == PTABLE_GPT) {
806 table = ptable_gptread(table, dev, dread);
807 goto out;
808 }
809 #endif
810 #ifdef LOADER_MBR_SUPPORT
811 /* Read MBR. */
812 DEBUG("MBR detected");
813 table->type = PTABLE_MBR;
814 for (i = has_ext = 0; i < NDOSPART; i++) {
815 if (dp[i].dp_typ == 0)
816 continue;
817 start = le32dec(&(dp[i].dp_start));
818 end = le32dec(&(dp[i].dp_size));
819 if (start == 0 || end == 0)
820 continue;
821 #if 0 /* Some BIOSes return an incorrect number of sectors */
822 if (start + end - 1 >= sectors)
823 continue; /* XXX: ignore */
824 #endif
825 if (dp[i].dp_typ == DOSPTYP_EXT ||
826 dp[i].dp_typ == DOSPTYP_EXTLBA)
827 has_ext = 1;
828 entry = malloc(sizeof (*entry));
829 if (entry == NULL)
830 break;
831 entry->part.start = start;
832 entry->part.end = start + end - 1;
833 entry->part.index = i + 1;
834 entry->part.type = mbr_parttype(dp[i].dp_typ);
835 entry->flags = dp[i].dp_flag;
836 entry->type.mbr = dp[i].dp_typ;
837 STAILQ_INSERT_TAIL(&table->entries, entry, entry);
838 DEBUG("new MBR partition added");
839 }
840 if (has_ext) {
841 table = ptable_ebrread(table, dev, dread);
842 /* FALLTHROUGH */
843 }
844 #endif /* LOADER_MBR_SUPPORT */
845 #endif /* LOADER_MBR_SUPPORT || LOADER_GPT_SUPPORT */
846 out:
847 free(buf);
848 return (table);
849 }
850
851 void
852 ptable_close(struct ptable *table)
853 {
854 struct pentry *entry;
855
856 if (table == NULL)
857 return;
858
859 while (!STAILQ_EMPTY(&table->entries)) {
860 entry = STAILQ_FIRST(&table->entries);
861 STAILQ_REMOVE_HEAD(&table->entries, entry);
862 free(entry);
863 }
864 free(table);
865 }
866
867 enum ptable_type
868 ptable_gettype(const struct ptable *table)
869 {
870
871 return (table->type);
872 }
873
874 int
875 ptable_getsize(const struct ptable *table, uint64_t *sizep)
876 {
877 uint64_t tmp = table->sectors * table->sectorsize;
878
879 if (tmp < table->sectors)
880 return (EOVERFLOW);
881
882 if (sizep != NULL)
883 *sizep = tmp;
884 return (0);
885 }
886
887 int
888 ptable_getpart(const struct ptable *table, struct ptable_entry *part, int idx)
889 {
890 struct pentry *entry;
891
892 if (part == NULL || table == NULL)
893 return (EINVAL);
894
895 STAILQ_FOREACH(entry, &table->entries, entry) {
896 if (entry->part.index != idx)
897 continue;
898 memcpy(part, &entry->part, sizeof (*part));
899 return (0);
900 }
901 return (ENOENT);
902 }
903
904 /*
905 * Search for a slice with the following preferences:
906 *
907 * 1: Active illumos slice
908 * 2: Non-active illumos slice
909 * 3: Active Linux slice
910 * 4: non-active Linux slice
911 * 5: Active FAT/FAT32 slice
912 * 6: non-active FAT/FAT32 slice
913 */
914 #define PREF_RAWDISK 0
915 #define PREF_ILLUMOS_ACT 1
916 #define PREF_ILLUMOS 2
917 #define PREF_LINUX_ACT 3
918 #define PREF_LINUX 4
919 #define PREF_DOS_ACT 5
920 #define PREF_DOS 6
921 #define PREF_NONE 7
922 int
923 ptable_getbestpart(const struct ptable *table, struct ptable_entry *part)
924 {
925 struct pentry *entry, *best;
926 int pref, preflevel;
927
928 if (part == NULL || table == NULL)
929 return (EINVAL);
930
931 best = NULL;
932 preflevel = pref = PREF_NONE;
933 STAILQ_FOREACH(entry, &table->entries, entry) {
934 #ifdef LOADER_MBR_SUPPORT
935 if (table->type == PTABLE_MBR) {
936 switch (entry->type.mbr) {
937 case DOSPTYP_SUNIXOS2:
938 pref = entry->flags & 0x80 ? PREF_ILLUMOS_ACT:
939 PREF_ILLUMOS;
940 break;
941 case DOSPTYP_LINUX:
942 pref = entry->flags & 0x80 ? PREF_LINUX_ACT:
943 PREF_LINUX;
944 break;
945 case 0x01: /* DOS/Windows */
946 case 0x04:
947 case 0x06:
948 case 0x0c:
949 case 0x0e:
950 case DOSPTYP_FAT32:
951 pref = entry->flags & 0x80 ? PREF_DOS_ACT:
952 PREF_DOS;
953 break;
954 default:
955 pref = PREF_NONE;
956 }
957 }
958 #endif /* LOADER_MBR_SUPPORT */
959 #ifdef LOADER_GPT_SUPPORT
960 if (table->type == PTABLE_GPT) {
961 if (entry->part.type == PART_DOS)
962 pref = PREF_DOS;
963 else if (entry->part.type == PART_ILLUMOS_ZFS)
964 pref = PREF_ILLUMOS;
965 else
966 pref = PREF_NONE;
967 }
968 #endif /* LOADER_GPT_SUPPORT */
969 if (pref < preflevel) {
970 preflevel = pref;
971 best = entry;
972 }
973 }
974 if (best != NULL) {
975 memcpy(part, &best->part, sizeof (*part));
976 return (0);
977 }
978 return (ENOENT);
979 }
980
981 /*
982 * iterate will stop if iterator will return non 0.
983 */
984 int
985 ptable_iterate(const struct ptable *table, void *arg, ptable_iterate_t *iter)
986 {
987 struct pentry *entry;
988 char name[32];
989 int ret = 0;
990
991 name[0] = '\0';
992 STAILQ_FOREACH(entry, &table->entries, entry) {
993 #ifdef LOADER_MBR_SUPPORT
994 if (table->type == PTABLE_MBR)
995 sprintf(name, "s%d", entry->part.index);
996 else
997 #endif
998 #ifdef LOADER_GPT_SUPPORT
999 if (table->type == PTABLE_GPT)
1000 sprintf(name, "p%d", entry->part.index);
1001 else
1002 #endif
1003 #ifdef LOADER_VTOC8_SUPPORT
1004 if (table->type == PTABLE_VTOC8)
1005 sprintf(name, "%c", (uint8_t)'a' +
1006 entry->part.index);
1007 else
1008 #endif
1009 if (table->type == PTABLE_VTOC)
1010 sprintf(name, "%c", (uint8_t)'a' +
1011 entry->part.index);
1012 else
1013 if (table->type == PTABLE_BSD)
1014 sprintf(name, "%c", (uint8_t)'a' +
1015 entry->part.index);
1016 ret = iter(arg, name, &entry->part);
1017 if (ret != 0)
1018 return (ret);
1019 }
1020 return (ret);
1021 }
Unleashed OS