From 6e7a315eb67cb6c113cf37e1d66c4f11a51a2b3e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 18:29:51 +0200 Subject: Adding upstream version 2.06. Signed-off-by: Daniel Baumann --- grub-core/gdb/cstub.c | 366 +++++++++++++++++++++++++++++++++++++++++++ grub-core/gdb/gdb.c | 104 ++++++++++++ grub-core/gdb/i386/idt.c | 78 +++++++++ grub-core/gdb/i386/machdep.S | 245 +++++++++++++++++++++++++++++ grub-core/gdb/i386/signal.c | 53 +++++++ 5 files changed, 846 insertions(+) create mode 100644 grub-core/gdb/cstub.c create mode 100644 grub-core/gdb/gdb.c create mode 100644 grub-core/gdb/i386/idt.c create mode 100644 grub-core/gdb/i386/machdep.S create mode 100644 grub-core/gdb/i386/signal.c (limited to 'grub-core/gdb') diff --git a/grub-core/gdb/cstub.c b/grub-core/gdb/cstub.c new file mode 100644 index 0000000..b64acd7 --- /dev/null +++ b/grub-core/gdb/cstub.c @@ -0,0 +1,366 @@ +/* cstub.c - machine independent portion of remote GDB stub */ +/* + * Copyright (C) 2006 Lubomir Kundrak + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include + +static const char hexchars[] = "0123456789abcdef"; +int grub_gdb_regs[GRUB_MACHINE_NR_REGS]; + +#define GRUB_GDB_COMBUF_SIZE 400 /* At least sizeof(grub_gdb_regs)*2 are needed for + register packets. */ +static char grub_gdb_inbuf[GRUB_GDB_COMBUF_SIZE + 1]; +static char grub_gdb_outbuf[GRUB_GDB_COMBUF_SIZE + 1]; + +struct grub_serial_port *grub_gdb_port; + +static int +hex (char ch) +{ + if ((ch >= 'a') && (ch <= 'f')) + return (ch - 'a' + 10); + if ((ch >= '0') && (ch <= '9')) + return (ch - '0'); + if ((ch >= 'A') && (ch <= 'F')) + return (ch - 'A' + 10); + return (-1); +} + +/* Scan for the sequence $#. */ +static char * +grub_gdb_getpacket (void) +{ + char *buffer = &grub_gdb_inbuf[0]; + unsigned char checksum; + unsigned char xmitcsum; + int count; + int ch; + + while (1) + { + /* Wait around for the start character, ignore all other + characters. */ + while ((ch = grub_serial_port_fetch (grub_gdb_port)) != '$'); + + retry: + checksum = 0; + xmitcsum = -1; + count = 0; + + /* Now read until a # or end of buffer is found. */ + while (count < GRUB_GDB_COMBUF_SIZE) + { + do + ch = grub_serial_port_fetch (grub_gdb_port); + while (ch < 0); + if (ch == '$') + goto retry; + if (ch == '#') + break; + checksum += ch; + buffer[count] = ch; + count = count + 1; + } + buffer[count] = 0; + if (ch == '#') + { + do + ch = grub_serial_port_fetch (grub_gdb_port); + while (ch < 0); + xmitcsum = hex (ch) << 4; + do + ch = grub_serial_port_fetch (grub_gdb_port); + while (ch < 0); + xmitcsum += hex (ch); + + if (checksum != xmitcsum) + grub_serial_port_put (grub_gdb_port, '-'); /* Failed checksum. */ + else + { + grub_serial_port_put (grub_gdb_port, '+'); /* Successful transfer. */ + + /* If a sequence char is present, reply the sequence ID. */ + if (buffer[2] == ':') + { + grub_serial_port_put (grub_gdb_port, buffer[0]); + grub_serial_port_put (grub_gdb_port, buffer[1]); + + return &buffer[3]; + } + return &buffer[0]; + } + } + } +} + +/* Send the packet in buffer. */ +static void +grub_gdb_putpacket (char *buffer) +{ + grub_uint8_t checksum; + + /* $#. */ + do + { + char *ptr; + grub_serial_port_put (grub_gdb_port, '$'); + checksum = 0; + + for (ptr = buffer; *ptr; ptr++) + { + grub_serial_port_put (grub_gdb_port, *ptr); + checksum += *ptr; + } + + grub_serial_port_put (grub_gdb_port, '#'); + grub_serial_port_put (grub_gdb_port, hexchars[checksum >> 4]); + grub_serial_port_put (grub_gdb_port, hexchars[checksum & 0xf]); + } + while (grub_serial_port_fetch (grub_gdb_port) != '+'); +} + +/* Convert the memory pointed to by mem into hex, placing result in buf. + Return a pointer to the last char put in buf (NULL). */ +static char * +grub_gdb_mem2hex (char *mem, char *buf, grub_size_t count) +{ + grub_size_t i; + unsigned char ch; + + for (i = 0; i < count; i++) + { + ch = *mem++; + *buf++ = hexchars[ch >> 4]; + *buf++ = hexchars[ch % 16]; + } + *buf = 0; + return (buf); +} + +/* Convert the hex array pointed to by buf into binary to be placed in mem. + Return a pointer to the character after the last byte written. */ +static char * +grub_gdb_hex2mem (char *buf, char *mem, int count) +{ + int i; + unsigned char ch; + + for (i = 0; i < count; i++) + { + ch = hex (*buf++) << 4; + ch = ch + hex (*buf++); + *mem++ = ch; + } + return (mem); +} + +/* Convert hex characters to int and return the number of characters + processed. */ +static int +grub_gdb_hex2int (char **ptr, grub_uint64_t *int_value) +{ + int num_chars = 0; + int hex_value; + + *int_value = 0; + + while (**ptr) + { + hex_value = hex (**ptr); + if (hex_value >= 0) + { + *int_value = (*int_value << 4) | hex_value; + num_chars++; + } + else + break; + + (*ptr)++; + } + + return (num_chars); +} + +/* This function does all command procesing for interfacing to gdb. */ +void __attribute__ ((regparm(3))) +grub_gdb_trap (int trap_no) +{ + unsigned int sig_no; + int stepping; + grub_uint64_t addr; + grub_uint64_t length; + char *ptr; + + if (!grub_gdb_port) + { + grub_printf ("Unhandled exception 0x%x at ", trap_no); + grub_backtrace_print_address ((void *) grub_gdb_regs[PC]); + grub_printf ("\n"); + grub_backtrace_pointer ((void *) grub_gdb_regs[EBP]); + grub_fatal ("Unhandled exception"); + } + + sig_no = grub_gdb_trap2sig (trap_no); + + ptr = grub_gdb_outbuf; + + /* Reply to host that an exception has occurred. */ + + *ptr++ = 'T'; /* Notify gdb with signo, PC, FP and SP. */ + + *ptr++ = hexchars[sig_no >> 4]; + *ptr++ = hexchars[sig_no & 0xf]; + + /* Stack pointer. */ + *ptr++ = hexchars[SP]; + *ptr++ = ':'; + ptr = grub_gdb_mem2hex ((char *) &grub_gdb_regs[ESP], ptr, 4); + *ptr++ = ';'; + + /* Frame pointer. */ + *ptr++ = hexchars[FP]; + *ptr++ = ':'; + ptr = grub_gdb_mem2hex ((char *) &grub_gdb_regs[EBP], ptr, 4); + *ptr++ = ';'; + + /* Program counter. */ + *ptr++ = hexchars[PC]; + *ptr++ = ':'; + ptr = grub_gdb_mem2hex ((char *) &grub_gdb_regs[PC], ptr, 4); + *ptr++ = ';'; + + *ptr = '\0'; + + grub_gdb_putpacket (grub_gdb_outbuf); + + stepping = 0; + + while (1) + { + grub_gdb_outbuf[0] = 0; + ptr = grub_gdb_getpacket (); + + switch (*ptr++) + { + case '?': + grub_gdb_outbuf[0] = 'S'; + grub_gdb_outbuf[1] = hexchars[sig_no >> 4]; + grub_gdb_outbuf[2] = hexchars[sig_no & 0xf]; + grub_gdb_outbuf[3] = 0; + break; + + /* Return values of the CPU registers. */ + case 'g': + grub_gdb_mem2hex ((char *) grub_gdb_regs, grub_gdb_outbuf, + sizeof (grub_gdb_regs)); + break; + + /* Set values of the CPU registers -- return OK. */ + case 'G': + grub_gdb_hex2mem (ptr, (char *) grub_gdb_regs, + sizeof (grub_gdb_regs)); + grub_strcpy (grub_gdb_outbuf, "OK"); + break; + + /* Set the value of a single CPU register -- return OK. */ + case 'P': + { + grub_uint64_t regno; + + if (grub_gdb_hex2int (&ptr, ®no) && *ptr++ == '=') + if (regno < GRUB_MACHINE_NR_REGS) + { + grub_gdb_hex2mem (ptr, (char *) &grub_gdb_regs[regno], 4); + grub_strcpy (grub_gdb_outbuf, "OK"); + break; + } + /* FIXME: GDB requires setting orig_eax. I don't know what's + this register is about. For now just simulate setting any + registers. */ + grub_strcpy (grub_gdb_outbuf, /*"E01"*/ "OK"); + break; + } + + /* mAA..AA,LLLL: Read LLLL bytes at address AA..AA. */ + case 'm': + /* Try to read %x,%x. Set ptr = 0 if successful. */ + if (grub_gdb_hex2int (&ptr, &addr)) + if (*(ptr++) == ',') + if (grub_gdb_hex2int (&ptr, &length)) + { + ptr = 0; + grub_gdb_mem2hex ((char *) (grub_addr_t) addr, + grub_gdb_outbuf, length); + } + if (ptr) + grub_strcpy (grub_gdb_outbuf, "E01"); + break; + + /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA -- return OK. */ + case 'M': + /* Try to read %x,%x. Set ptr = 0 if successful. */ + if (grub_gdb_hex2int (&ptr, &addr)) + if (*(ptr++) == ',') + if (grub_gdb_hex2int (&ptr, &length)) + if (*(ptr++) == ':') + { + grub_gdb_hex2mem (ptr, (char *) (grub_addr_t) addr, length); + grub_strcpy (grub_gdb_outbuf, "OK"); + ptr = 0; + } + if (ptr) + { + grub_strcpy (grub_gdb_outbuf, "E02"); + } + break; + + /* sAA..AA: Step one instruction from AA..AA(optional). */ + case 's': + stepping = 1; + /* FALLTHROUGH */ + + /* cAA..AA: Continue at address AA..AA(optional). */ + case 'c': + /* try to read optional parameter, pc unchanged if no parm */ + if (grub_gdb_hex2int (&ptr, &addr)) + grub_gdb_regs[PC] = addr; + + /* Clear the trace bit. */ + grub_gdb_regs[PS] &= 0xfffffeff; + + /* Set the trace bit if we're stepping. */ + if (stepping) + grub_gdb_regs[PS] |= 0x100; + + return; + + /* Kill the program. */ + case 'k': + /* Do nothing. */ + return; + } + + /* Reply to the request. */ + grub_gdb_putpacket (grub_gdb_outbuf); + } +} + diff --git a/grub-core/gdb/gdb.c b/grub-core/gdb/gdb.c new file mode 100644 index 0000000..1818cb6 --- /dev/null +++ b/grub-core/gdb/gdb.c @@ -0,0 +1,104 @@ +/* gdb.c - gdb remote stub module */ +/* + * Copyright (C) 2003 Free Software Foundation, Inc. + * Copyright (C) 2006 Lubomir Kundrak + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +GRUB_MOD_LICENSE ("GPLv3+"); + +static grub_err_t +grub_cmd_gdbstub (struct grub_command *cmd __attribute__ ((unused)), + int argc, char **args) +{ + struct grub_serial_port *port; + if (argc < 1) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "port required"); + port = grub_serial_find (args[0]); + if (!port) + return grub_errno; + grub_gdb_port = port; + /* TRANSLATORS: at this position GRUB waits for the user to do an action + in remote debugger, namely to tell it to establish connection. */ + grub_puts_ (N_("Now connect the remote debugger, please.")); + grub_gdb_breakpoint (); + return 0; +} + +static grub_err_t +grub_cmd_gdbstop (struct grub_command *cmd __attribute__ ((unused)), + int argc __attribute__ ((unused)), + char **args __attribute__ ((unused))) +{ + grub_gdb_port = NULL; + return 0; +} + +static grub_err_t +grub_cmd_gdb_break (struct grub_command *cmd __attribute__ ((unused)), + int argc __attribute__ ((unused)), + char **args __attribute__ ((unused))) +{ + if (!grub_gdb_port) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "No GDB stub is running"); + grub_gdb_breakpoint (); + return 0; +} + +static grub_command_t cmd, cmd_stop, cmd_break; + +GRUB_MOD_INIT (gdb) +{ + grub_gdb_idtinit (); + cmd = grub_register_command_lockdown ("gdbstub", grub_cmd_gdbstub, + N_("PORT"), + /* + * TRANSLATORS: GDB stub is a small part of + * GDB functionality running on local host + * which allows remote debugger to + * connect to it. + */ + N_("Start GDB stub on given port")); + cmd_break = grub_register_command_lockdown ("gdbstub_break", grub_cmd_gdb_break, + /* + * TRANSLATORS: this refers to triggering + * a breakpoint so that the user will land + * into GDB. + */ + 0, N_("Break into GDB")); + cmd_stop = grub_register_command_lockdown ("gdbstub_stop", grub_cmd_gdbstop, + 0, N_("Stop GDB stub")); +} + +GRUB_MOD_FINI (gdb) +{ + grub_unregister_command (cmd); + grub_unregister_command (cmd_stop); + grub_gdb_idtrestore (); +} + diff --git a/grub-core/gdb/i386/idt.c b/grub-core/gdb/i386/idt.c new file mode 100644 index 0000000..69bfcb0 --- /dev/null +++ b/grub-core/gdb/i386/idt.c @@ -0,0 +1,78 @@ +/* idt.c - routines for constructing IDT fot the GDB stub */ +/* + * Copyright (C) 2006 Lubomir Kundrak + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include + +static struct grub_cpu_interrupt_gate grub_gdb_idt[GRUB_GDB_LAST_TRAP + 1] + __attribute__ ((aligned(16))); + +/* Sets up a gate descriptor in the IDT table. */ +static void +grub_idt_gate (struct grub_cpu_interrupt_gate *gate, void (*offset) (void), + grub_uint16_t selector, grub_uint8_t type, grub_uint8_t dpl) +{ + gate->offset_lo = (int) offset & 0xffff; + gate->selector = selector & 0xffff; + gate->unused = 0; + gate->gate = (type & 0x1f) | ((dpl & 0x3) << 5) | 0x80; + gate->offset_hi = ((int) offset >> 16) & 0xffff; +} + +static struct grub_cpu_idt_descriptor grub_gdb_orig_idt_desc + __attribute__ ((aligned(16))); +static struct grub_cpu_idt_descriptor grub_gdb_idt_desc + __attribute__ ((aligned(16))); + +/* Set up interrupt and trap handler descriptors in IDT. */ +void +grub_gdb_idtinit (void) +{ + int i; + grub_uint16_t seg; + + asm volatile ("xorl %%eax, %%eax\n" + "mov %%cs, %%ax\n" :"=a" (seg)); + + for (i = 0; i <= GRUB_GDB_LAST_TRAP; i++) + { + grub_idt_gate (&grub_gdb_idt[i], + grub_gdb_trapvec[i], seg, + GRUB_CPU_TRAP_GATE, 0); + } + + grub_gdb_idt_desc.base = (grub_addr_t) grub_gdb_idt; + grub_gdb_idt_desc.limit = sizeof (grub_gdb_idt) - 1; + asm volatile ("sidt %0" : : "m" (grub_gdb_orig_idt_desc)); + asm volatile ("lidt %0" : : "m" (grub_gdb_idt_desc)); +} + +void +grub_gdb_idtrestore (void) +{ + asm volatile ("lidt %0" : : "m" (grub_gdb_orig_idt_desc)); +} + +void +grub_gdb_breakpoint (void) +{ + asm volatile ("int $3"); +} diff --git a/grub-core/gdb/i386/machdep.S b/grub-core/gdb/i386/machdep.S new file mode 100644 index 0000000..f96d2b9 --- /dev/null +++ b/grub-core/gdb/i386/machdep.S @@ -0,0 +1,245 @@ +/* machdep.S - machine dependent assembly routines for the GDB stub */ +/* + * Copyright (C) 2006 Lubomir Kundrak + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include + +#define EC_PRESENT 1 +#define EC_ABSENT 0 + +#define GRUB_GDB_STACKSIZE 40000 + +#define SEP , + +#ifdef __APPLE__ + .zerofill __DATA, __bss, LOCAL(grub_gdb_stack_end), GRUB_GDB_STACKSIZE, 4 + LOCAL(grub_gdb_stack) = LOCAL(grub_gdb_stack_end) +#else +/* + * The .data index for the address vector. + */ + +#define VECTOR 1 + + .bss + .space GRUB_GDB_STACKSIZE +VARIABLE(grub_gdb_stack) +#endif + +/* + * Supplemental macros for register saving/restoration + * on exception handler entry/leave. + */ + +#ifdef __APPLE__ +.macro save32 +#define REG $0 +#define NDX $1 +#else +.macro save32 reg ndx +#define REG \reg +#define NDX \ndx +#endif + movl REG, EXT_C(grub_gdb_regs)+(NDX * 4) +.endm + +#undef REG +#undef NDX + +#ifdef __APPLE__ +.macro save16 +#define REG $0 +#define NDX $1 +#else +.macro save16 reg ndx +#define REG \reg +#define NDX \ndx +#endif + xorl %eax, %eax + movw REG, EXT_C(grub_gdb_regs)+(NDX * 4) + movw %ax, EXT_C(grub_gdb_regs)+(NDX * 4 + 2) + movl EXT_C(grub_gdb_regs)+(EAX * 4), %eax +.endm + +#undef REG +#undef NDX + +#ifdef __APPLE__ +.macro load32 +#define NDX $0 +#define REG $1 +#else +.macro load32 ndx reg +#define REG \reg +#define NDX \ndx +#endif + movl EXT_C(grub_gdb_regs)+(NDX * 4), REG +.endm + +#undef REG +#undef NDX + +#ifdef __APPLE__ +.macro load16 +#define NDX $0 +#define REG $1 +#else +.macro load16 ndx reg +#define NDX \ndx +#define REG \reg +#endif + movw EXT_C(grub_gdb_regs)+(NDX * 4), REG +.endm + +#undef REG +#undef NDX + +.macro save_context + save32 %eax, EAX + + save32 %ecx, ECX + save32 %edx, EDX + save32 %ebx, EBX + save32 %ebp, EBP + save32 %esi, ESI + save32 %edi, EDI + + popl %ebx + save32 %ebx, EIP + popl %ebx + save32 %ebx, CS + popl %ebx + save32 %ebx, EFLAGS + + save32 %esp, ESP + + save16 %ds, DS + save16 %es, ES + save16 %fs, FS + save16 %gs, GS + save16 %ss, SS +.endm + +.macro load_context + load16 SS, %ss + load32 ESP, %esp + + load32 EBP, %ebp + load32 ESI, %esi + load32 EDI, %edi + + load16 DS, %ds + load16 ES, %es + load16 FS, %fs + load16 GS, %gs + + load32 EFLAGS, %eax + pushl %eax + load32 CS, %eax + pushl %eax + load32 EIP, %eax + pushl %eax + + load32 EBX, %ebx + load32 EDX, %edx + load32 ECX, %ecx + load32 EAX, %eax +.endm + +/* + * This macro creates handlers for a given range of exception numbers + * and adds their addresses to the grub_gdb_trapvec array. + */ + +#ifdef __APPLE__ +.macro ent +#define EC $0 +#define BEG $1 +#define END $2 +#else +.macro ent ec beg end=0 +#define EC \ec +#define BEG \beg +#define END \end +#endif + + /* + * Wrapper body itself. + */ + + .text +1: + .if EC + add MACRO_DOLLAR(4), %esp + .endif + + save_context +#ifdef __APPLE__ + mov $LOCAL(grub_gdb_stack), %esp +#else + mov $EXT_C(grub_gdb_stack), %esp +#endif + mov $(BEG), %eax /* trap number */ + call EXT_C(grub_gdb_trap) + load_context + iret + + /* + * Address entry in trapvec array. + */ + +#ifdef __APPLE__ + .section __DATA, VECTOR +#else + .data VECTOR +#endif + .long 1b + + /* + * Next... (recursion). + */ + + .if END-BEG > 0 +#ifdef __APPLE__ + ent EC, (BEG+1), END +#else + ent \ec "(\beg+1)" \end +#endif + .endif +.endm + +/* + * Here does the actual construction of the address array and handlers + * take place. + */ +#ifdef __APPLE__ + .section __DATA, VECTOR +#else + .data VECTOR +#endif +VARIABLE(grub_gdb_trapvec) + ent EC_ABSENT, 0, 7 + ent EC_PRESENT, 8 + ent EC_ABSENT, 9 + ent EC_PRESENT, 10, 14 + /* + * You may have to split this further or as(1) + * will complain about nesting being too deep. + */ + ent EC_ABSENT, 15, GRUB_GDB_LAST_TRAP diff --git a/grub-core/gdb/i386/signal.c b/grub-core/gdb/i386/signal.c new file mode 100644 index 0000000..1ac3bbd --- /dev/null +++ b/grub-core/gdb/i386/signal.c @@ -0,0 +1,53 @@ +/* idt.c - routines for constructing IDT fot the GDB stub */ +/* + * Copyright (C) 2006 Lubomir Kundrak + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include + +/* Converting CPU trap number to UNIX signal number as + described in System V ABI i386 Processor Supplement, 3-25. */ +unsigned int +grub_gdb_trap2sig (int trap_no) +{ + const int signals[] = { + SIGFPE, /* 0: Divide error fault */ + SIGTRAP, /* 1: Single step trap fault */ + SIGABRT, /* 2: # Nonmaskable interrupt */ + SIGTRAP, /* 3: Breakpoint trap */ + SIGSEGV, /* 4: Overflow trap */ + SIGSEGV, /* 5: Bounds check fault */ + SIGILL, /* 6: Invalid opcode fault */ + SIGFPE, /* 7: No coprocessor fault */ + SIGABRT, /* 8: # Double fault abort */ + SIGSEGV, /* 9: Coprocessor overrun abort */ + SIGSEGV, /* 10: Invalid TSS fault */ + SIGSEGV, /* 11: Segment not present fault */ + SIGSEGV, /* 12: Stack exception fault */ + SIGSEGV, /* 13: General protection fault abort */ + SIGSEGV, /* 14: Page fault */ + SIGABRT, /* 15: (reserved) */ + SIGFPE, /* 16: Coprocessor error fault */ + SIGUSR1 /* other */ + }; + + return signals[trap_no < 17 ? trap_no : 17]; +} + -- cgit v1.2.3