1 /*-
2 * Copyright (c) 2016 The FreeBSD Foundation
3 *
4 * This software was developed by Konstantin Belousov under sponsorship
5 * from the FreeBSD Foundation.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <stand.h>
30 #include <string.h>
31 #include <sys/param.h>
32 #include <machine/cpufunc.h>
33 #include <machine/psl.h>
34 #include <machine/segments.h>
35 #include <machine/frame.h>
36 #include <machine/tss.h>
37
38 #include <efi.h>
39 #include <efilib.h>
40
41 #include "bootstrap.h"
42 #include "loader_efi.h"
43
44 #define NUM_IST 8
45 #define NUM_EXC 32
46
47 /*
48 * This code catches exceptions but forwards hardware interrupts to
49 * handlers installed by firmware. It differentiates exceptions
50 * vs. interrupts by presence of the error code on the stack, which
51 * causes different stack pointer value on trap handler entry.
52 *
53 * Use kernel layout for the trapframe just to not be original.
54 *
55 * Use free IST slot in existing TSS, or create our own TSS if
56 * firmware did not configured any, to have stack switched to
57 * IST-specified one, e.g. to handle #SS. If hand-off cannot find
58 * unused IST slot, or create a new descriptor in GDT, we bail out.
59 */
60
61 static struct region_descriptor fw_idt; /* Descriptor for pristine fw IDT */
62 static struct region_descriptor loader_idt;/* Descriptor for loader
63 shadow IDT */
64 static EFI_PHYSICAL_ADDRESS lidt_pa; /* Address of loader shadow IDT */
65 static EFI_PHYSICAL_ADDRESS tss_pa; /* Address of TSS */
66 static EFI_PHYSICAL_ADDRESS exc_stack_pa;/* Address of IST stack for loader */
67 EFI_PHYSICAL_ADDRESS exc_rsp; /* %rsp value on our IST stack when
68 exception happens */
69 EFI_PHYSICAL_ADDRESS fw_intr_handlers[NUM_EXC]; /* fw handlers for < 32 IDT
70 vectors */
71 static int intercepted[NUM_EXC];
72 static int ist; /* IST for exception handlers */
73 static uint32_t tss_fw_seg; /* Fw TSS segment */
74 static uint32_t loader_tss; /* Loader TSS segment */
75 static struct region_descriptor fw_gdt; /* Descriptor of pristine GDT */
76 static EFI_PHYSICAL_ADDRESS loader_gdt_pa; /* Address of loader shadow GDT */
77 static UINTN loader_gdt_pa_size;
78
79 struct frame {
80 struct frame *fr_savfp;
81 uintptr_t fr_savpc;
82 };
83
84 void report_exc(struct trapframe *tf);
85
86 static void
stack_trace(struct frame * fp,uintptr_t pc)87 stack_trace(struct frame *fp, uintptr_t pc)
88 {
89 uintptr_t base;
90 char buf[80];
91
92 base = (uintptr_t)boot_img->ImageBase;
93
94 printf("Stack trace:\n");
95 pager_open();
96 while (fp != NULL || pc != 0) {
97 struct frame *nfp;
98 char *source = "PC";
99
100 if (pc >= base && pc < base + boot_img->ImageSize) {
101 pc -= base;
102 source = "loader PC";
103 }
104 (void) snprintf(buf, sizeof (buf), "FP %016lx: %s 0x%016lx\n",
105 (uintptr_t)fp, source, pc);
106 if (pager_output(buf))
107 break;
108
109 if (fp == NULL)
110 break;
111
112 nfp = fp->fr_savfp;
113 if (nfp != NULL && nfp <= fp) {
114 printf("FP %016lx: loop detected, stopping trace\n",
115 (uintptr_t)nfp);
116 break;
117 }
118 fp = nfp;
119
120 if (fp != NULL)
121 pc = fp->fr_savpc;
122 else
123 pc = 0;
124 }
125 pager_close();
126 }
127
128 void
panic_action(void)129 panic_action(void)
130 {
131 struct frame *fp;
132 uintptr_t rip;
133
134 __asm __volatile("movq %%rbp,%0" : "=r" (fp));
135 rip = fp->fr_savpc;
136
137 stack_trace(fp, rip);
138 printf("--> Press a key on the console to reboot <--\n");
139 getchar();
140 printf("Rebooting...\n");
141 exit(1);
142 }
143
144 void
report_exc(struct trapframe * tf)145 report_exc(struct trapframe *tf)
146 {
147 /*
148 * printf() depends on loader runtime and UEFI firmware health
149 * to produce the console output, in case of exception, the
150 * loader or firmware runtime may fail to support the printf().
151 */
152 printf("===================================================="
153 "============================\n");
154 printf("Exception %u\n", tf->tf_trapno);
155 printf("ss 0x%04hx cs 0x%04hx ds 0x%04hx es 0x%04hx fs 0x%04hx "
156 "gs 0x%04hx\n",
157 (uint16_t)tf->tf_ss, (uint16_t)tf->tf_cs, (uint16_t)tf->tf_ds,
158 (uint16_t)tf->tf_es, (uint16_t)tf->tf_fs, (uint16_t)tf->tf_gs);
159 printf("err 0x%08x rfl 0x%08x addr 0x%016lx\n"
160 "rsp 0x%016lx rip 0x%016lx\n",
161 (uint32_t)tf->tf_err, (uint32_t)tf->tf_rflags, tf->tf_addr,
162 tf->tf_rsp, tf->tf_rip);
163 printf(
164 "rdi 0x%016lx rsi 0x%016lx rdx 0x%016lx\n"
165 "rcx 0x%016lx r8 0x%016lx r9 0x%016lx\n"
166 "rax 0x%016lx rbx 0x%016lx rbp 0x%016lx\n"
167 "r10 0x%016lx r11 0x%016lx r12 0x%016lx\n"
168 "r13 0x%016lx r14 0x%016lx r15 0x%016lx\n",
169 tf->tf_rdi, tf->tf_rsi, tf->tf_rdx, tf->tf_rcx, tf->tf_r8,
170 tf->tf_r9, tf->tf_rax, tf->tf_rbx, tf->tf_rbp, tf->tf_r10,
171 tf->tf_r11, tf->tf_r12, tf->tf_r13, tf->tf_r14, tf->tf_r15);
172
173 stack_trace((struct frame *)tf->tf_rbp, tf->tf_rip);
174
175 printf("Machine stopped.\n");
176 }
177
178 static void
prepare_exception(unsigned idx,uint64_t my_handler,int ist_use_table[static NUM_IST])179 prepare_exception(unsigned idx, uint64_t my_handler,
180 int ist_use_table[static NUM_IST])
181 {
182 struct gate_descriptor *fw_idt_e, *loader_idt_e;
183
184 fw_idt_e = &((struct gate_descriptor *)fw_idt.rd_base)[idx];
185 loader_idt_e = &((struct gate_descriptor *)loader_idt.rd_base)[idx];
186 fw_intr_handlers[idx] = fw_idt_e->gd_looffset +
187 (fw_idt_e->gd_hioffset << 16);
188 intercepted[idx] = 1;
189 ist_use_table[fw_idt_e->gd_ist]++;
190 loader_idt_e->gd_looffset = my_handler;
191 loader_idt_e->gd_hioffset = my_handler >> 16;
192 /*
193 * We reuse uefi selector for the code segment for the exception
194 * handler code, while the reason for the fault might be the
195 * corruption of that gdt entry. On the other hand, allocating
196 * our own descriptor might be not much better, if gdt is corrupted.
197 */
198 loader_idt_e->gd_selector = fw_idt_e->gd_selector;
199 loader_idt_e->gd_ist = 0;
200 loader_idt_e->gd_type = SDT_SYSIGT;
201 loader_idt_e->gd_dpl = 0;
202 loader_idt_e->gd_p = 1;
203 loader_idt_e->gd_xx = 0;
204 loader_idt_e->sd_xx1 = 0;
205 }
206 #define PREPARE_EXCEPTION(N) \
207 extern char EXC##N##_handler[]; \
208 prepare_exception(N, (uintptr_t)EXC##N##_handler, ist_use_table);
209
210 static void
free_tables(void)211 free_tables(void)
212 {
213
214 if (lidt_pa != 0) {
215 BS->FreePages(lidt_pa, EFI_SIZE_TO_PAGES(fw_idt.rd_limit));
216 lidt_pa = 0;
217 }
218 if (exc_stack_pa != 0) {
219 BS->FreePages(exc_stack_pa, 1);
220 exc_stack_pa = 0;
221 }
222 if (tss_pa != 0 && tss_fw_seg == 0) {
223 BS->FreePages(tss_pa, EFI_SIZE_TO_PAGES(sizeof(struct
224 amd64tss)));
225 tss_pa = 0;
226 }
227 if (loader_gdt_pa != 0) {
228 BS->FreePages(loader_gdt_pa, loader_gdt_pa_size);
229 loader_gdt_pa = 0;
230 }
231 ist = 0;
232 loader_tss = 0;
233 }
234
235 static int
efi_setup_tss(struct region_descriptor * gdt,uint32_t loader_tss_idx,struct amd64tss ** tss)236 efi_setup_tss(struct region_descriptor *gdt, uint32_t loader_tss_idx,
237 struct amd64tss **tss)
238 {
239 EFI_STATUS status;
240 struct system_segment_descriptor *tss_desc;
241
242 tss_desc = (struct system_segment_descriptor *)(gdt->rd_base +
243 (loader_tss_idx << 3));
244 status = BS->AllocatePages(AllocateAnyPages, EfiLoaderData,
245 EFI_SIZE_TO_PAGES(sizeof(struct amd64tss)), &tss_pa);
246 if (EFI_ERROR(status)) {
247 printf("efi_setup_tss: AllocatePages tss error %lu\n",
248 DECODE_ERROR(status));
249 return (0);
250 }
251 *tss = (struct amd64tss *)tss_pa;
252 bzero(*tss, sizeof(**tss));
253 tss_desc->sd_lolimit = sizeof(struct amd64tss);
254 tss_desc->sd_lobase = tss_pa;
255 tss_desc->sd_type = SDT_SYSTSS;
256 tss_desc->sd_dpl = 0;
257 tss_desc->sd_p = 1;
258 tss_desc->sd_hilimit = sizeof(struct amd64tss) >> 16;
259 tss_desc->sd_gran = 0;
260 tss_desc->sd_hibase = tss_pa >> 24;
261 tss_desc->sd_xx0 = 0;
262 tss_desc->sd_xx1 = 0;
263 tss_desc->sd_mbz = 0;
264 tss_desc->sd_xx2 = 0;
265 return (1);
266 }
267
268 static int
efi_redirect_exceptions(void)269 efi_redirect_exceptions(void)
270 {
271 int ist_use_table[NUM_IST];
272 struct gate_descriptor *loader_idt_e;
273 struct system_segment_descriptor *tss_desc, *gdt_desc;
274 struct amd64tss *tss;
275 struct region_descriptor *gdt_rd, loader_gdt;
276 uint32_t i;
277 EFI_STATUS status;
278 register_t rfl;
279
280 sidt(&fw_idt);
281 status = BS->AllocatePages(AllocateAnyPages, EfiLoaderData,
282 EFI_SIZE_TO_PAGES(fw_idt.rd_limit), &lidt_pa);
283 if (EFI_ERROR(status)) {
284 printf("efi_redirect_exceptions: AllocatePages IDT error %lu\n",
285 DECODE_ERROR(status));
286 lidt_pa = 0;
287 return (0);
288 }
289 status = BS->AllocatePages(AllocateAnyPages, EfiLoaderData, 1,
290 &exc_stack_pa);
291 if (EFI_ERROR(status)) {
292 printf("efi_redirect_exceptions: AllocatePages stk error %lu\n",
293 DECODE_ERROR(status));
294 exc_stack_pa = 0;
295 free_tables();
296 return (0);
297 }
298 loader_idt.rd_limit = fw_idt.rd_limit;
299 loader_idt.rd_base = lidt_pa;
300 bcopy((void *)fw_idt.rd_base, (void *)loader_idt.rd_base,
301 loader_idt.rd_limit);
302 bzero(ist_use_table, sizeof(ist_use_table));
303 bzero(fw_intr_handlers, sizeof(fw_intr_handlers));
304 bzero(intercepted, sizeof(intercepted));
305
306 sgdt(&fw_gdt);
307 tss_fw_seg = read_tr();
308 gdt_rd = NULL;
309 if (tss_fw_seg == 0) {
310 for (i = 2; (i << 3) + sizeof(*gdt_desc) <= fw_gdt.rd_limit;
311 i += 2) {
312 gdt_desc = (struct system_segment_descriptor *)(
313 fw_gdt.rd_base + (i << 3));
314 if (gdt_desc->sd_type == 0 && gdt_desc->sd_mbz == 0) {
315 gdt_rd = &fw_gdt;
316 break;
317 }
318 }
319 if (gdt_rd == NULL) {
320 if (i >= 8190) {
321 printf("efi_redirect_exceptions: all slots "
322 "in gdt are used\n");
323 free_tables();
324 return (0);
325 }
326 loader_gdt.rd_limit = roundup2(fw_gdt.rd_limit +
327 sizeof(struct system_segment_descriptor),
328 sizeof(struct system_segment_descriptor)) - 1;
329 loader_gdt_pa_size =
330 EFI_SIZE_TO_PAGES(loader_gdt.rd_limit);
331 i = (loader_gdt.rd_limit + 1 -
332 sizeof(struct system_segment_descriptor)) /
333 sizeof(struct system_segment_descriptor) * 2;
334 status = BS->AllocatePages(AllocateAnyPages,
335 EfiLoaderData, loader_gdt_pa_size, &loader_gdt_pa);
336 if (EFI_ERROR(status)) {
337 printf("efi_setup_tss: AllocatePages gdt error "
338 "%lu\n", DECODE_ERROR(status));
339 loader_gdt_pa = 0;
340 free_tables();
341 return (0);
342 }
343 loader_gdt.rd_base = loader_gdt_pa;
344 bzero((void *)loader_gdt.rd_base, loader_gdt.rd_limit);
345 bcopy((void *)fw_gdt.rd_base,
346 (void *)loader_gdt.rd_base, fw_gdt.rd_limit);
347 gdt_rd = &loader_gdt;
348 }
349 loader_tss = i << 3;
350 if (!efi_setup_tss(gdt_rd, i, &tss)) {
351 tss_pa = 0;
352 free_tables();
353 return (0);
354 }
355 } else {
356 tss_desc = (struct system_segment_descriptor *)((char *)
357 fw_gdt.rd_base + tss_fw_seg);
358 if (tss_desc->sd_type != SDT_SYSTSS &&
359 tss_desc->sd_type != SDT_SYSBSY) {
360 printf("LTR points to non-TSS descriptor\n");
361 free_tables();
362 return (0);
363 }
364 tss_pa = tss_desc->sd_lobase + (tss_desc->sd_hibase << 24);
365 tss = (struct amd64tss *)tss_pa;
366 tss_desc->sd_type = SDT_SYSTSS; /* unbusy */
367 }
368
369 PREPARE_EXCEPTION(0);
370 PREPARE_EXCEPTION(1);
371 PREPARE_EXCEPTION(2);
372 PREPARE_EXCEPTION(3);
373 PREPARE_EXCEPTION(4);
374 PREPARE_EXCEPTION(5);
375 PREPARE_EXCEPTION(6);
376 PREPARE_EXCEPTION(7);
377 PREPARE_EXCEPTION(8);
378 PREPARE_EXCEPTION(9);
379 PREPARE_EXCEPTION(10);
380 PREPARE_EXCEPTION(11);
381 PREPARE_EXCEPTION(12);
382 PREPARE_EXCEPTION(13);
383 PREPARE_EXCEPTION(14);
384 PREPARE_EXCEPTION(16);
385 PREPARE_EXCEPTION(17);
386 PREPARE_EXCEPTION(18);
387 PREPARE_EXCEPTION(19);
388 PREPARE_EXCEPTION(20);
389
390 exc_rsp = exc_stack_pa + EFI_PAGE_SIZE -
391 (6 /* hw exception frame */ + 3 /* scratch regs */) * 8;
392
393 /* Find free IST and use it */
394 for (ist = 1; ist < NUM_IST; ist++) {
395 if (ist_use_table[ist] == 0)
396 break;
397 }
398 if (ist == NUM_IST) {
399 printf("efi_redirect_exceptions: all ISTs used\n");
400 free_tables();
401 lidt_pa = 0;
402 return (0);
403 }
404 for (i = 0; i < NUM_EXC; i++) {
405 loader_idt_e = &((struct gate_descriptor *)loader_idt.
406 rd_base)[i];
407 if (intercepted[i])
408 loader_idt_e->gd_ist = ist;
409 }
410 (&(tss->tss_ist1))[ist - 1] = exc_stack_pa + EFI_PAGE_SIZE;
411
412 /* Switch to new IDT */
413 rfl = intr_disable();
414 if (loader_gdt_pa != 0)
415 bare_lgdt(&loader_gdt);
416 if (loader_tss != 0)
417 ltr(loader_tss);
418 lidt(&loader_idt);
419 intr_restore(rfl);
420 return (1);
421 }
422
423 static void
efi_unredirect_exceptions(void)424 efi_unredirect_exceptions(void)
425 {
426 register_t rfl;
427
428 if (lidt_pa == 0)
429 return;
430
431 rfl = intr_disable();
432 if (ist != 0)
433 (&(((struct amd64tss *)tss_pa)->tss_ist1))[ist - 1] = 0;
434 if (loader_gdt_pa != 0)
435 bare_lgdt(&fw_gdt);
436 if (loader_tss != 0)
437 ltr(tss_fw_seg);
438 lidt(&fw_idt);
439 intr_restore(rfl);
440 free_tables();
441 }
442
443 static int
command_grab_faults(int argc,char * argv[])444 command_grab_faults(int argc, char *argv[])
445 {
446 int res;
447
448 res = efi_redirect_exceptions();
449 if (!res)
450 printf("failed\n");
451 return (CMD_OK);
452 }
453 COMMAND_SET(grab_faults, "grab_faults", "grab faults", command_grab_faults);
454
455 static int
command_ungrab_faults(int argc,char * argv[])456 command_ungrab_faults(int argc, char *argv[])
457 {
458
459 efi_unredirect_exceptions();
460 return (CMD_OK);
461 }
462 COMMAND_SET(ungrab_faults, "ungrab_faults", "ungrab faults",
463 command_ungrab_faults);
464
465 static int
command_fault(int argc,char * argv[])466 command_fault(int argc, char *argv[])
467 {
468
469 __asm("ud2");
470 return (CMD_OK);
471 }
472 COMMAND_SET(fault, "fault", "generate fault", command_fault);
473