Print this page
NEX-16819 loader UEFI support
Includes work by Toomas Soome <tsoome@me.com>
Upstream commits:
loader: pxe receive cleanup
9475 libefi: Do not return only if ReceiveFilter
installboot: should support efi system partition
8931 boot1.efi: scan all display modes rather than
loader: spinconsole updates
loader: gfx experiment to try GOP Blt() function.
sha1 build test
loader: add sha1 hash calculation
common/sha1: update for loader build
loader: biosdisk rework
uts: 32-bit kernel FB needs mapping in low memory
uts: add diag-device
uts: boot console mirror with diag-device
uts: enable very early console on ttya
kmdb: add diag-device as input/output device
uts: test VGA memory exclusion from mapping
uts: clear boot mapping and protect boot pages test
uts: add dboot map debug printf
uts: need to release FB pages in release_bootstrap()
uts: add screenmap ioctl
uts: update sys/queue.h
loader: add illumos uts/common to include path
loader: tem/gfx font cleanup
loader: vbe checks
uts: gfx_private set KD_TEXT when KD_RESETTEXT is
uts: gfx 8-bit update
loader: gfx 8-bit fix
loader: always set media size from partition.
uts: MB2 support for 32-bit kernel
loader: x86 should have tem 80x25
uts: x86 should have tem 80x25
uts: font update
loader: font update
uts: tem attributes
loader: tem.c comment added
uts: use font module
loader: add font module
loader: build rules for new font setup
uts: gfx_private update for new font structure
uts: early boot update for new font structure
uts: font update
uts: font build rules update for new fonts
uts: tem update to new font structure
loader: module.c needs to include tem_impl.h
uts: gfx_private 8x16 font rework
uts: make font_lookup public
loader: font rework
uts: font rework
9259 libefi: efi_alloc_and_read should check for PMBR
uts: tem utf-8 support
loader: implement tem utf-8 support
loader: tem should be able to display UTF-8
7784 uts: console input should support utf-8
7796 uts: ldterm default to utf-8
uts: do not reset serial console
uts: set up colors even if tem is not console
uts: add type for early boot properties
uts: gfx_private experiment with drm and vga
uts: gfx_private should use setmode drm callback.
uts: identify FB types and set up gfx_private based
loader: replace gop and vesa with framebuffer
uts: boot needs simple tem to support mdb
uts: boot_keyboard should emit esc sequences for
uts: gfx_private FB showuld be written by line
kmdb: set terminal window size
uts: gfx_private needs to keep track of early boot FB
pnglite: move pnglite to usr/src/common
loader: gfx_fb
ficl-sys: add gfx primitives
loader: add illumos.png logo
ficl: add fb-putimage
loader: add png support
loader: add alpha blending for gfx_fb
loader: use term-drawrect for menu frame
ficl: add simple gfx words
uts: provide fb_info via fbgattr dev_specific array.
uts: gfx_private add alpha blending
uts: update sys/ascii.h
uts: tem OSC support (incomplete)
uts: implement env module support and use data from
uts: tem get colors from early boot data
loader: use crc32 from libstand (libz)
loader: optimize for size
loader: pass tem info to the environment
loader: import tem for loader console
loader: UEFI loader needs to set ISADIR based on
loader: need UEFI32 support
8918 loader.efi: add vesa edid support
uts: tem_safe_pix_clear_prom_output() should only
uts: tem_safe_pix_clear_entire_screen() should use
uts: tem_safe_check_first_time() should query cursor
uts: tem implement cls callback & visual_io v4
uts: gfx_vgatext use block cursor for vgatext
uts: gfx_private implement cls callback & visual_io
uts: gfx_private bitmap framebuffer implementation
uts: early start frame buffer console support
uts: font functions should check the input char
uts: font rendering should support 16/24/32bit depths
uts: use smallest font as fallback default.
uts: update terminal dimensions based on selected
7834 uts: vgatext should use gfx_private
uts: add spacing property to 8859-1.bdf
terminfo: add underline for sun-color
terminfo: sun-color has 16 colors
uts: add font load callback type
loader: do not repeat int13 calls with error 0x20 and
8905 loader: add skein/edonr support
8904 common/crypto: make skein and edonr loader
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Revert "NEX-16819 loader UEFI support"
This reverts commit ec06b9fc617b99234e538bf2e7e4d02a24993e0c.
Reverting due to failures in the zfs-tests and the sharefs-tests
NEX-16819 loader UEFI support
Includes work by Toomas Soome <tsoome@me.com>
Upstream commits:
loader: pxe receive cleanup
9475 libefi: Do not return only if ReceiveFilter
installboot: should support efi system partition
8931 boot1.efi: scan all display modes rather than
loader: spinconsole updates
loader: gfx experiment to try GOP Blt() function.
sha1 build test
loader: add sha1 hash calculation
common/sha1: update for loader build
loader: biosdisk rework
uts: 32-bit kernel FB needs mapping in low memory
uts: add diag-device
uts: boot console mirror with diag-device
uts: enable very early console on ttya
kmdb: add diag-device as input/output device
uts: test VGA memory exclusion from mapping
uts: clear boot mapping and protect boot pages test
uts: add dboot map debug printf
uts: need to release FB pages in release_bootstrap()
uts: add screenmap ioctl
uts: update sys/queue.h
loader: add illumos uts/common to include path
loader: tem/gfx font cleanup
loader: vbe checks
uts: gfx_private set KD_TEXT when KD_RESETTEXT is
uts: gfx 8-bit update
loader: gfx 8-bit fix
loader: always set media size from partition.
uts: MB2 support for 32-bit kernel
loader: x86 should have tem 80x25
uts: x86 should have tem 80x25
uts: font update
loader: font update
uts: tem attributes
loader: tem.c comment added
uts: use font module
loader: add font module
loader: build rules for new font setup
uts: gfx_private update for new font structure
uts: early boot update for new font structure
uts: font update
uts: font build rules update for new fonts
uts: tem update to new font structure
loader: module.c needs to include tem_impl.h
uts: gfx_private 8x16 font rework
uts: make font_lookup public
loader: font rework
uts: font rework
libefi: efi_alloc_and_read should check for PMBR
uts: tem utf-8 support
loader: implement tem utf-8 support
loader: tem should be able to display UTF-8
7784 uts: console input should support utf-8
7796 uts: ldterm default to utf-8
uts: do not reset serial console
uts: set up colors even if tem is not console
uts: add type for early boot properties
uts: gfx_private experiment with drm and vga
uts: gfx_private should use setmode drm callback.
uts: identify FB types and set up gfx_private based
loader: replace gop and vesa with framebuffer
uts: boot needs simple tem to support mdb
uts: boot_keyboard should emit esc sequences for
uts: gfx_private FB showuld be written by line
kmdb: set terminal window size
uts: gfx_private needs to keep track of early boot FB
pnglite: move pnglite to usr/src/common
loader: gfx_fb
ficl-sys: add gfx primitives
loader: add illumos.png logo
ficl: add fb-putimage
loader: add png support
loader: add alpha blending for gfx_fb
loader: use term-drawrect for menu frame
ficl: add simple gfx words
uts: provide fb_info via fbgattr dev_specific array.
uts: gfx_private add alpha blending
uts: update sys/ascii.h
uts: tem OSC support (incomplete)
uts: implement env module support and use data from
uts: tem get colors from early boot data
loader: use crc32 from libstand (libz)
loader: optimize for size
loader: pass tem info to the environment
loader: import tem for loader console
loader: UEFI loader needs to set ISADIR based on
loader: need UEFI32 support
8918 loader.efi: add vesa edid support
uts: tem_safe_pix_clear_prom_output() should only
uts: tem_safe_pix_clear_entire_screen() should use
uts: tem_safe_check_first_time() should query cursor
uts: tem implement cls callback & visual_io v4
uts: gfx_vgatext use block cursor for vgatext
uts: gfx_private implement cls callback & visual_io
uts: gfx_private bitmap framebuffer implementation
uts: early start frame buffer console support
uts: font functions should check the input char
uts: font rendering should support 16/24/32bit depths
uts: use smallest font as fallback default.
uts: update terminal dimensions based on selected
7834 uts: vgatext should use gfx_private
uts: add spacing property to 8859-1.bdf
terminfo: add underline for sun-color
terminfo: sun-color has 16 colors
uts: add font load callback type
loader: do not repeat int13 calls with error 0x20 and
8905 loader: add skein/edonr support
8904 common/crypto: make skein and edonr loader
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Sanjay Nadkarni <sanjay.nadkarni@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/boot/sys/boot/common/gpt.c
+++ new/usr/src/boot/sys/boot/common/gpt.c
1 1 /*-
2 2 * Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
3 3 * All rights reserved.
4 4 *
5 5 * Redistribution and use in source and binary forms, with or without
6 6 * modification, are permitted provided that the following conditions
7 7 * are met:
8 8 * 1. Redistributions of source code must retain the above copyright
9 9 * notice, this list of conditions and the following disclaimer.
10 10 * 2. Redistributions in binary form must reproduce the above copyright
11 11 * notice, this list of conditions and the following disclaimer in the
12 12 * documentation and/or other materials provided with the distribution.
13 13 *
14 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 24 * SUCH DAMAGE.
25 25 */
26 26
|
↓ open down ↓ |
26 lines elided |
↑ open up ↑ |
27 27 #include <sys/cdefs.h>
28 28 __FBSDID("$FreeBSD$");
29 29
30 30 #include <sys/param.h>
31 31 #include <sys/gpt.h>
32 32
33 33 #ifndef LITTLE_ENDIAN
34 34 #error gpt.c works only for little endian architectures
35 35 #endif
36 36
37 -#include "crc32.h"
37 +#include "zlib.h"
38 38 #include "drv.h"
39 39 #include "util.h"
40 40 #include "gpt.h"
41 41
42 42 #define MAXTBLENTS 128
43 43
44 44 static struct gpt_hdr hdr_primary, hdr_backup, *gpthdr;
45 45 static uint64_t hdr_primary_lba, hdr_backup_lba;
46 46 static struct gpt_ent table_primary[MAXTBLENTS], table_backup[MAXTBLENTS];
47 47 static struct gpt_ent *gpttable;
48 48 static int curent, bootonce;
49 49
50 50 /*
51 51 * Buffer below 64kB passed on gptread(), which can hold at least
52 52 * one sector of data (512 bytes).
53 53 */
54 54 static char *secbuf;
55 55
56 56 static void
57 57 gptupdate(const char *which, struct dsk *dskp, struct gpt_hdr *hdr,
58 58 struct gpt_ent *table)
59 59 {
60 60 int entries_per_sec, firstent;
61 61 daddr_t slba;
62 62
63 63 /*
64 64 * We need to update the following for both primary and backup GPT:
65 65 * 1. Sector on disk that contains current partition.
66 66 * 2. Partition table checksum.
67 67 * 3. Header checksum.
68 68 * 4. Header on disk.
69 69 */
70 70
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
71 71 entries_per_sec = DEV_BSIZE / hdr->hdr_entsz;
72 72 slba = curent / entries_per_sec;
73 73 firstent = slba * entries_per_sec;
74 74 bcopy(&table[firstent], secbuf, DEV_BSIZE);
75 75 slba += hdr->hdr_lba_table;
76 76 if (drvwrite(dskp, secbuf, slba, 1)) {
77 77 printf("%s: unable to update %s GPT partition table\n",
78 78 BOOTPROG, which);
79 79 return;
80 80 }
81 - hdr->hdr_crc_table = crc32(table, hdr->hdr_entries * hdr->hdr_entsz);
82 - hdr->hdr_crc_self = 0;
83 - hdr->hdr_crc_self = crc32(hdr, hdr->hdr_size);
81 + hdr->hdr_crc_table = crc32(0, Z_NULL, 0);
82 + hdr->hdr_crc_table = crc32(hdr->hdr_crc_table, table,
83 + hdr->hdr_entries * hdr->hdr_entsz);
84 + hdr->hdr_crc_self = crc32(0, Z_NULL, 0);
85 + hdr->hdr_crc_self = crc32(hdr->hdr_crc_self, hdr, hdr->hdr_size);
84 86 bzero(secbuf, DEV_BSIZE);
85 87 bcopy(hdr, secbuf, hdr->hdr_size);
86 88 if (drvwrite(dskp, secbuf, hdr->hdr_lba_self, 1)) {
87 89 printf("%s: unable to update %s GPT header\n", BOOTPROG, which);
88 90 return;
89 91 }
90 92 }
91 93
92 94 int
93 95 gptfind(const uuid_t *uuid, struct dsk *dskp, int part)
94 96 {
95 97 struct gpt_ent *ent;
96 98 int firsttry;
97 99
98 100 if (part >= 0) {
99 101 if (part == 0 || part > gpthdr->hdr_entries) {
100 102 printf("%s: invalid partition index\n", BOOTPROG);
101 103 return (-1);
102 104 }
103 105 ent = &gpttable[part - 1];
104 106 if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0) {
105 107 printf("%s: specified partition is not UFS\n",
106 108 BOOTPROG);
107 109 return (-1);
108 110 }
109 111 curent = part - 1;
110 112 goto found;
111 113 }
112 114
113 115 firsttry = (curent == -1);
114 116 curent++;
115 117 if (curent >= gpthdr->hdr_entries) {
116 118 curent = gpthdr->hdr_entries;
117 119 return (-1);
118 120 }
119 121 if (bootonce) {
120 122 /*
121 123 * First look for partition with both GPT_ENT_ATTR_BOOTME and
122 124 * GPT_ENT_ATTR_BOOTONCE flags.
123 125 */
124 126 for (; curent < gpthdr->hdr_entries; curent++) {
125 127 ent = &gpttable[curent];
126 128 if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0)
127 129 continue;
128 130 if (!(ent->ent_attr & GPT_ENT_ATTR_BOOTME))
129 131 continue;
130 132 if (!(ent->ent_attr & GPT_ENT_ATTR_BOOTONCE))
131 133 continue;
132 134 /* Ok, found one. */
133 135 goto found;
134 136 }
135 137 bootonce = 0;
136 138 curent = 0;
137 139 }
138 140 for (; curent < gpthdr->hdr_entries; curent++) {
139 141 ent = &gpttable[curent];
140 142 if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0)
141 143 continue;
142 144 if (!(ent->ent_attr & GPT_ENT_ATTR_BOOTME))
143 145 continue;
144 146 if (ent->ent_attr & GPT_ENT_ATTR_BOOTONCE)
145 147 continue;
146 148 /* Ok, found one. */
147 149 goto found;
148 150 }
149 151 if (firsttry) {
150 152 /*
151 153 * No partition with BOOTME flag was found, try to boot from
152 154 * first UFS partition.
153 155 */
154 156 for (curent = 0; curent < gpthdr->hdr_entries; curent++) {
155 157 ent = &gpttable[curent];
156 158 if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0)
157 159 continue;
158 160 /* Ok, found one. */
159 161 goto found;
160 162 }
161 163 }
162 164 return (-1);
163 165 found:
164 166 dskp->part = curent + 1;
165 167 ent = &gpttable[curent];
166 168 dskp->start = ent->ent_lba_start;
167 169 if (ent->ent_attr & GPT_ENT_ATTR_BOOTONCE) {
168 170 /*
169 171 * Clear BOOTME, but leave BOOTONCE set before trying to
170 172 * boot from this partition.
171 173 */
172 174 if (hdr_primary_lba > 0) {
173 175 table_primary[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTME;
174 176 gptupdate("primary", dskp, &hdr_primary, table_primary);
175 177 }
176 178 if (hdr_backup_lba > 0) {
177 179 table_backup[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTME;
178 180 gptupdate("backup", dskp, &hdr_backup, table_backup);
179 181 }
180 182 }
181 183 return (0);
182 184 }
183 185
184 186 static int
185 187 gptread_hdr(const char *which, struct dsk *dskp, struct gpt_hdr *hdr,
186 188 uint64_t hdrlba)
187 189 {
188 190 uint32_t crc;
189 191
190 192 if (drvread(dskp, secbuf, hdrlba, 1)) {
191 193 printf("%s: unable to read %s GPT header\n", BOOTPROG, which);
192 194 return (-1);
|
↓ open down ↓ |
99 lines elided |
↑ open up ↑ |
193 195 }
194 196 bcopy(secbuf, hdr, sizeof(*hdr));
195 197 if (bcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig)) != 0 ||
196 198 hdr->hdr_lba_self != hdrlba || hdr->hdr_revision < 0x00010000 ||
197 199 hdr->hdr_entsz < sizeof(struct gpt_ent) ||
198 200 hdr->hdr_entries > MAXTBLENTS || DEV_BSIZE % hdr->hdr_entsz != 0) {
199 201 printf("%s: invalid %s GPT header\n", BOOTPROG, which);
200 202 return (-1);
201 203 }
202 204 crc = hdr->hdr_crc_self;
203 - hdr->hdr_crc_self = 0;
204 - if (crc32(hdr, hdr->hdr_size) != crc) {
205 + hdr->hdr_crc_self = crc32(0, Z_NULL, 0);
206 + if (crc32(hdr->hdr_crc_self, hdr, hdr->hdr_size) != crc) {
205 207 printf("%s: %s GPT header checksum mismatch\n", BOOTPROG,
206 208 which);
207 209 return (-1);
208 210 }
209 211 hdr->hdr_crc_self = crc;
210 212 return (0);
211 213 }
212 214
213 215 void
214 216 gptbootfailed(struct dsk *dskp)
215 217 {
216 218
217 219 if (!(gpttable[curent].ent_attr & GPT_ENT_ATTR_BOOTONCE))
218 220 return;
219 221
220 222 if (hdr_primary_lba > 0) {
221 223 table_primary[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTONCE;
222 224 table_primary[curent].ent_attr |= GPT_ENT_ATTR_BOOTFAILED;
223 225 gptupdate("primary", dskp, &hdr_primary, table_primary);
224 226 }
225 227 if (hdr_backup_lba > 0) {
226 228 table_backup[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTONCE;
227 229 table_backup[curent].ent_attr |= GPT_ENT_ATTR_BOOTFAILED;
228 230 gptupdate("backup", dskp, &hdr_backup, table_backup);
229 231 }
230 232 }
231 233
232 234 static void
233 235 gptbootconv(const char *which, struct dsk *dskp, struct gpt_hdr *hdr,
234 236 struct gpt_ent *table)
235 237 {
236 238 struct gpt_ent *ent;
237 239 daddr_t slba;
238 240 int table_updated, sector_updated;
239 241 int entries_per_sec, nent, part;
240 242
241 243 table_updated = 0;
242 244 entries_per_sec = DEV_BSIZE / hdr->hdr_entsz;
243 245 for (nent = 0, slba = hdr->hdr_lba_table;
244 246 slba < hdr->hdr_lba_table + hdr->hdr_entries / entries_per_sec;
245 247 slba++, nent += entries_per_sec) {
246 248 sector_updated = 0;
247 249 for (part = 0; part < entries_per_sec; part++) {
248 250 ent = &table[nent + part];
249 251 if ((ent->ent_attr & (GPT_ENT_ATTR_BOOTME |
250 252 GPT_ENT_ATTR_BOOTONCE |
251 253 GPT_ENT_ATTR_BOOTFAILED)) !=
252 254 GPT_ENT_ATTR_BOOTONCE) {
253 255 continue;
254 256 }
255 257 ent->ent_attr &= ~GPT_ENT_ATTR_BOOTONCE;
256 258 ent->ent_attr |= GPT_ENT_ATTR_BOOTFAILED;
257 259 table_updated = 1;
258 260 sector_updated = 1;
259 261 }
|
↓ open down ↓ |
45 lines elided |
↑ open up ↑ |
260 262 if (!sector_updated)
261 263 continue;
262 264 bcopy(&table[nent], secbuf, DEV_BSIZE);
263 265 if (drvwrite(dskp, secbuf, slba, 1)) {
264 266 printf("%s: unable to update %s GPT partition table\n",
265 267 BOOTPROG, which);
266 268 }
267 269 }
268 270 if (!table_updated)
269 271 return;
270 - hdr->hdr_crc_table = crc32(table, hdr->hdr_entries * hdr->hdr_entsz);
271 - hdr->hdr_crc_self = 0;
272 - hdr->hdr_crc_self = crc32(hdr, hdr->hdr_size);
272 + hdr->hdr_crc_table = crc32(0, Z_NULL, 0);
273 + hdr->hdr_crc_table = crc32(hdr->hdr_crc_table, table,
274 + hdr->hdr_entries * hdr->hdr_entsz);
275 + hdr->hdr_crc_self = crc32(0, Z_NULL, 0);
276 + hdr->hdr_crc_self = crc32(hdr->hdr_crc_self, hdr, hdr->hdr_size);
273 277 bzero(secbuf, DEV_BSIZE);
274 278 bcopy(hdr, secbuf, hdr->hdr_size);
275 279 if (drvwrite(dskp, secbuf, hdr->hdr_lba_self, 1))
276 280 printf("%s: unable to update %s GPT header\n", BOOTPROG, which);
277 281 }
278 282
279 283 static int
280 284 gptread_table(const char *which, const uuid_t *uuid, struct dsk *dskp,
281 285 struct gpt_hdr *hdr, struct gpt_ent *table)
282 286 {
283 287 struct gpt_ent *ent;
284 288 int entries_per_sec;
285 289 int part, nent;
286 290 daddr_t slba;
287 291
288 292 if (hdr->hdr_entries == 0)
289 293 return (0);
290 294
291 295 entries_per_sec = DEV_BSIZE / hdr->hdr_entsz;
292 296 slba = hdr->hdr_lba_table;
293 297 nent = 0;
294 298 for (;;) {
295 299 if (drvread(dskp, secbuf, slba, 1)) {
296 300 printf("%s: unable to read %s GPT partition table\n",
297 301 BOOTPROG, which);
298 302 return (-1);
299 303 }
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
300 304 ent = (struct gpt_ent *)secbuf;
301 305 for (part = 0; part < entries_per_sec; part++, ent++) {
302 306 bcopy(ent, &table[nent], sizeof(table[nent]));
303 307 if (++nent >= hdr->hdr_entries)
304 308 break;
305 309 }
306 310 if (nent >= hdr->hdr_entries)
307 311 break;
308 312 slba++;
309 313 }
310 - if (crc32(table, nent * hdr->hdr_entsz) != hdr->hdr_crc_table) {
314 + if (crc32(0, table, nent * hdr->hdr_entsz) != hdr->hdr_crc_table) {
311 315 printf("%s: %s GPT table checksum mismatch\n", BOOTPROG, which);
312 316 return (-1);
313 317 }
314 318 return (0);
315 319 }
316 320
317 321 int
318 322 gptread(const uuid_t *uuid, struct dsk *dskp, char *buf)
319 323 {
320 324 uint64_t altlba;
321 325
322 326 /*
323 327 * Read and verify both GPT headers: primary and backup.
324 328 */
325 329
326 330 secbuf = buf;
327 331 hdr_primary_lba = hdr_backup_lba = 0;
328 332 curent = -1;
329 333 bootonce = 1;
330 334 dskp->start = 0;
331 335
332 336 if (gptread_hdr("primary", dskp, &hdr_primary, 1) == 0 &&
333 337 gptread_table("primary", uuid, dskp, &hdr_primary,
334 338 table_primary) == 0) {
335 339 hdr_primary_lba = hdr_primary.hdr_lba_self;
336 340 gpthdr = &hdr_primary;
337 341 gpttable = table_primary;
338 342 }
339 343
340 344 if (hdr_primary_lba > 0) {
341 345 /*
342 346 * If primary header is valid, we can get backup
343 347 * header location from there.
344 348 */
345 349 altlba = hdr_primary.hdr_lba_alt;
346 350 } else {
347 351 altlba = drvsize(dskp);
348 352 if (altlba > 0)
349 353 altlba--;
350 354 }
351 355 if (altlba == 0)
352 356 printf("%s: unable to locate backup GPT header\n", BOOTPROG);
353 357 else if (gptread_hdr("backup", dskp, &hdr_backup, altlba) == 0 &&
354 358 gptread_table("backup", uuid, dskp, &hdr_backup,
355 359 table_backup) == 0) {
356 360 hdr_backup_lba = hdr_backup.hdr_lba_self;
357 361 if (hdr_primary_lba == 0) {
358 362 gpthdr = &hdr_backup;
359 363 gpttable = table_backup;
360 364 printf("%s: using backup GPT\n", BOOTPROG);
361 365 }
362 366 }
363 367
364 368 /*
365 369 * Convert all BOOTONCE without BOOTME flags into BOOTFAILED.
366 370 * BOOTONCE without BOOTME means that we tried to boot from it,
367 371 * but failed after leaving gptboot and machine was rebooted.
368 372 * We don't want to leave partitions marked as BOOTONCE only,
369 373 * because when we boot successfully start-up scripts should
370 374 * find at most one partition with only BOOTONCE flag and this
371 375 * will mean that we booted from that partition.
372 376 */
373 377 if (hdr_primary_lba != 0)
374 378 gptbootconv("primary", dskp, &hdr_primary, table_primary);
375 379 if (hdr_backup_lba != 0)
376 380 gptbootconv("backup", dskp, &hdr_backup, table_backup);
377 381
378 382 if (hdr_primary_lba == 0 && hdr_backup_lba == 0)
379 383 return (-1);
380 384 return (0);
381 385 }
|
↓ open down ↓ |
61 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX