diff options
| -rw-r--r-- | gdb/ChangeLog | 38 | ||||
| -rw-r--r-- | gdb/doc/ChangeLog | 6 | ||||
| -rw-r--r-- | gdb/doc/gdb.texinfo | 73 | ||||
| -rw-r--r-- | gdb/sparc64-linux-nat.c | 3 | ||||
| -rw-r--r-- | gdb/sparc64-linux-tdep.c | 69 | ||||
| -rw-r--r-- | gdb/sparc64-tdep.c | 509 | ||||
| -rw-r--r-- | gdb/sparc64-tdep.h | 2 | ||||
| -rw-r--r-- | gdb/testsuite/ChangeLog | 5 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.arch/sparc64-adi.c | 145 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.arch/sparc64-adi.exp | 53 |
10 files changed, 903 insertions, 0 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index b69339a..77a19c2 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,41 @@ +2017-08-07 Weimin Pan <weimin.pan@oracle.com> + + * sparc64-tdep.h: (adi_normalize_address): New export. + * sparc-nat.h: (open_adi_tag_fd): New export. + * sparc64-linux-nat.c: (open_adi_tag_fd): New function. + * sparc64-linux-tdep.c: + (SEGV_ACCADI, SEGV_ADIDERR, SEGV_ADIPERR) New defines. + (sparc64_linux_handle_segmentation_fault): New function. + (sparc64_linux_init_abi): Register + sparc64_linux_handle_segmentation_fault + * sparc64-tdep.c: Include cli-utils.h,gdbcmd.h,auxv.h. + (sparc64_addr_bits_remove): New function. + (sparc64_init_abi): Register sparc64_addr_bits_remove. + (MAX_PROC_NAME_SIZE): New macro. + (AT_ADI_BLKSZ, AT_ADI_NBITS, AT_ADI_UEONADI) New defines. + (sparc64adilist): New variable. + (adi_proc_list): New variable. + (find_adi_info): New function. + (add_adi_info): New function. + (get_adi_info_proc): New function. + (get_adi_info): New function. + (info_adi_command): New function. + (read_maps_entry): New function. + (adi_available): New function. + (adi_normalize_address): New function. + (adi_align_address): New function. + (adi_convert_byte_count): New function. + (adi_tag_fd): New function. + (adi_is_addr_mapped): New function. + (adi_read_versions): New function. + (adi_write_versions): New function. + (adi_print_versions): New function. + (do_examine): New function. + (do_assign): New function. + (adi_examine_command): New function. + (adi_assign_command): New function. + (_initialize_sparc64_adi_tdep): New function. + 2017-08-22 Simon Marchi <simon.marchi@ericsson.com> * breakpoint.c (breakpoints_info): Rename to ... diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index 32c9425..40b0e40 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,9 @@ +2017-08-07 Weimin Pan <weimin.pan@oracle.com> + + * gdb.texinfo (Architectures): Add new Sparc64 section to document + ADI support. + * NEWS: Add "adi examine" and "adi assign" commands. + 2017-08-18 Yao Qi <yao.qi@linaro.org> * gdb.texinfo (Server): Document "--selftest". diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 620d11d..d0d5d96 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -22474,6 +22474,7 @@ all uses of @value{GDBN} with the architecture, both native and cross. * SPU:: Cell Broadband Engine SPU architecture * PowerPC:: * Nios II:: +* Sparc64:: @end menu @node AArch64 @@ -22858,6 +22859,78 @@ target code in @value{GDBN}. Show the current setting of Nios II debugging messages. @end table +@node Sparc64 +@subsection Sparc64 +@cindex Sparc64 support +@cindex Application Data Integrity +@subsubsection ADI Support + +The M7 processor supports an Application Data Integrity (ADI) feature that +detects invalid data accesses. When software allocates memory and enables +ADI on the allocated memory, it chooses a 4-bit version number, sets the +version in the upper 4 bits of the 64-bit pointer to that data, and stores +the 4-bit version in every cacheline of that data. Hardware saves the latter +in spare bits in the cache and memory hierarchy. On each load and store, +the processor compares the upper 4 VA (virtual address) bits to the +cacheline's version. If there is a mismatch, the processor generates a +version mismatch trap which can be either precise or disrupting. The trap +is an error condition which the kernel delivers to the process as a SIGSEGV +signal. + +Note that only 64-bit applications can use ADI and need to be built with +ADI-enabled. + +Values of the ADI version tags, which are in granularity of a +cacheline (64 bytes), can be viewed or modified. + + +@table @code +@kindex adi examine +@item adi (examine | x) [ / @var{n} ] @var{addr} + +The @code{adi examine} command displays the value of one ADI version tag per +cacheline. + +@var{n} is a decimal integer specifying the number in bytes; the default +is 1. It specifies how much ADI version information, at the ratio of 1:ADI +block size, to display. + +@var{addr} is the address in user address space where you want @value{GDBN} +to begin displaying the ADI version tags. + +Below is an example of displaying ADI versions of variable "shmaddr". + +@smallexample +(@value{GDBP}) adi x/100 shmaddr + 0xfff800010002c000: 0 0 +@end smallexample + +@kindex adi assign +@item adi (assign | a) [ / @var{n} ] @var{addr} = @var{tag} + +The @code{adi assign} command is used to assign new ADI version tag +to an address. + +@var{n} is a decimal integer specifying the number in bytes; +the default is 1. It specifies how much ADI version information, at the +ratio of 1:ADI block size, to modify. + +@var{addr} is the address in user address space where you want @value{GDBN} +to begin modifying the ADI version tags. + +@var{tag} is the new ADI version tag. + +For example, do the following to modify then verify ADI versions of +variable "shmaddr": + +@smallexample +(@value{GDBP}) adi a/100 shmaddr = 7 +(@value{GDBP}) adi x/100 shmaddr + 0xfff800010002c000: 7 7 +@end smallexample + +@end table + @node Controlling GDB @chapter Controlling @value{GDBN} diff --git a/gdb/sparc64-linux-nat.c b/gdb/sparc64-linux-nat.c index 638aa29..282980a 100644 --- a/gdb/sparc64-linux-nat.c +++ b/gdb/sparc64-linux-nat.c @@ -89,5 +89,8 @@ _initialize_sparc64_linux_nat (void) /* Register the target. */ linux_nat_add_target (t); + /* ADI support */ + linux_nat_set_forget_process (t, sparc64_forget_process); + sparc_gregmap = &sparc64_linux_ptrace_gregmap; } diff --git a/gdb/sparc64-linux-tdep.c b/gdb/sparc64-linux-tdep.c index 814bc29..2da978f 100644 --- a/gdb/sparc64-linux-tdep.c +++ b/gdb/sparc64-linux-tdep.c @@ -33,6 +33,17 @@ #include "xml-syscall.h" #include "linux-tdep.h" +/* ADI specific si_code */ +#ifndef SEGV_ACCADI +#define SEGV_ACCADI 3 +#endif +#ifndef SEGV_ADIDERR +#define SEGV_ADIDERR 4 +#endif +#ifndef SEGV_ADIPERR +#define SEGV_ADIPERR 5 +#endif + /* The syscall's XML filename for sparc 64-bit. */ #define XML_SYSCALL_FILENAME_SPARC64 "syscalls/sparc64-linux.xml" @@ -104,6 +115,62 @@ sparc64_linux_sigframe_init (const struct tramp_frame *self, } trad_frame_set_id (this_cache, frame_id_build (base, func)); } + +/* sparc64 GNU/Linux implementation of the handle_segmentation_fault + gdbarch hook. + Displays information related to ADI memory corruptions. */ + +void +sparc64_linux_handle_segmentation_fault (struct gdbarch *gdbarch, + struct ui_out *uiout) +{ + if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 64) + return; + + CORE_ADDR addr = 0; + long si_code = 0; + + TRY + { + /* Evaluate si_code to see if the segfault is ADI related. */ + si_code = parse_and_eval_long ("$_siginfo.si_code\n"); + + if (si_code >= SEGV_ACCADI && si_code <= SEGV_ADIPERR) + addr = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr"); + } + CATCH (exception, RETURN_MASK_ALL) + { + return; + } + END_CATCH + + /* Print out ADI event based on sig_code value */ + switch (si_code) + { + case SEGV_ACCADI: /* adi not enabled */ + uiout->text ("\n"); + uiout->field_string ("sigcode-meaning", _("ADI disabled")); + uiout->text (_(" while accessing address ")); + uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr)); + break; + case SEGV_ADIDERR: /* disrupting mismatch */ + uiout->text ("\n"); + uiout->field_string ("sigcode-meaning", _("ADI deferred mismatch")); + uiout->text (_(" while accessing address ")); + uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr)); + break; + case SEGV_ADIPERR: /* precise mismatch */ + uiout->text ("\n"); + uiout->field_string ("sigcode-meaning", _("ADI precise mismatch")); + uiout->text (_(" while accessing address ")); + uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr)); + break; + default: + break; + } + +} + /* Return the address of a system call's alternative return address. */ @@ -338,6 +405,8 @@ sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64); set_gdbarch_get_syscall_number (gdbarch, sparc64_linux_get_syscall_number); + set_gdbarch_handle_segmentation_fault (gdbarch, + sparc64_linux_handle_segmentation_fault); } diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index 9e0e6b5..6f4fca7 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -46,6 +46,505 @@ sparc64_-prefix for 64-bit specific code and the sparc_-prefix for code can handle both. */ +/* The M7 processor supports an Application Data Integrity (ADI) feature + that detects invalid data accesses. When software allocates memory and + enables ADI on the allocated memory, it chooses a 4-bit version number, + sets the version in the upper 4 bits of the 64-bit pointer to that data, + and stores the 4-bit version in every cacheline of the object. Hardware + saves the latter in spare bits in the cache and memory hierarchy. On each + load and store, the processor compares the upper 4 VA (virtual address) bits + to the cacheline's version. If there is a mismatch, the processor generates + a version mismatch trap which can be either precise or disrupting. + The trap is an error condition which the kernel delivers to the process + as a SIGSEGV signal. + + The upper 4 bits of the VA represent a version and are not part of the + true address. The processor clears these bits and sign extends bit 59 + to generate the true address. + + Note that 32-bit applications cannot use ADI. */ + + +#include <algorithm> +#include "cli/cli-utils.h" +#include "gdbcmd.h" +#include "auxv.h" + +#define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus") + +/* ELF Auxiliary vectors */ +#ifndef AT_ADI_BLKSZ +#define AT_ADI_BLKSZ 34 +#endif +#ifndef AT_ADI_NBITS +#define AT_ADI_NBITS 35 +#endif +#ifndef AT_ADI_UEONADI +#define AT_ADI_UEONADI 36 +#endif + +/* ADI command list. */ +static struct cmd_list_element *sparc64adilist = NULL; + +/* ADI stat settings. */ +typedef struct +{ + /* The ADI block size. */ + unsigned long blksize; + + /* Number of bits used for an ADI version tag which can be + * used together with the shift value for an ADI version tag + * to encode or extract the ADI version value in a pointer. */ + unsigned long nbits; + + /* The maximum ADI version tag value supported. */ + int max_version; + + /* ADI version tag file. */ + int tag_fd = 0; + + /* ADI availability check has been done. */ + bool checked_avail = false; + + /* ADI is available. */ + bool is_avail = false; + +} adi_stat_t; + +/* Per-process ADI stat info. */ + +typedef struct sparc64_adi_info +{ + sparc64_adi_info (pid_t pid_) + : pid (pid_) + {} + + /* The process identifier. */ + pid_t pid; + + /* The ADI stat. */ + adi_stat_t stat = {}; + +} sparc64_adi_info; + +static std::forward_list<sparc64_adi_info> adi_proc_list; + + +/* Get ADI info for process PID, creating one if it doesn't exist. */ + +static sparc64_adi_info * +get_adi_info_proc (pid_t pid) +{ + auto found = std::find_if (adi_proc_list.begin (), adi_proc_list.end (), + [&pid] (const sparc64_adi_info &info) + { + return info.pid == pid; + }); + + if (found == adi_proc_list.end ()) + { + adi_proc_list.emplace_front (pid); + return &adi_proc_list.front (); + } + else + { + return &(*found); + } +} + +static adi_stat_t +get_adi_info (pid_t pid) +{ + sparc64_adi_info *proc; + + proc = get_adi_info_proc (pid); + return proc->stat; +} + +/* Is called when GDB is no longer debugging process PID. It + deletes data structure that keeps track of the ADI stat. */ + +void +sparc64_forget_process (pid_t pid) +{ + int target_errno; + + for (auto pit = adi_proc_list.before_begin (), + it = std::next (pit); + it != adi_proc_list.end (); + ) + { + if ((*it).pid == pid) + { + if ((*it).stat.tag_fd > 0) + target_fileio_close ((*it).stat.tag_fd, &target_errno); + adi_proc_list.erase_after (pit); + break; + } + else + pit = it++; + } + +} + +static void +info_adi_command (char *args, int from_tty) +{ + printf_unfiltered ("\"adi\" must be followed by \"examine\" " + "or \"assign\".\n"); + help_list (sparc64adilist, "adi ", all_commands, gdb_stdout); +} + +/* Read attributes of a maps entry in /proc/[pid]/adi/maps. */ + +static void +read_maps_entry (const char *line, + ULONGEST *addr, ULONGEST *endaddr) +{ + const char *p = line; + + *addr = strtoulst (p, &p, 16); + if (*p == '-') + p++; + + *endaddr = strtoulst (p, &p, 16); +} + +/* Check if ADI is available. */ + +static bool +adi_available (void) +{ + pid_t pid = ptid_get_pid (inferior_ptid); + sparc64_adi_info *proc = get_adi_info_proc (pid); + + if (proc->stat.checked_avail) + return proc->stat.is_avail; + + proc->stat.checked_avail = true; + if (target_auxv_search (¤t_target, AT_ADI_BLKSZ, + &proc->stat.blksize) <= 0) + return false; + target_auxv_search (¤t_target, AT_ADI_NBITS, &proc->stat.nbits); + proc->stat.max_version = (1 << proc->stat.nbits) - 2; + proc->stat.is_avail = true; + + return proc->stat.is_avail; +} + +/* Normalize a versioned address - a VA with ADI bits (63-60) set. */ + +static CORE_ADDR +adi_normalize_address (CORE_ADDR addr) +{ + adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid)); + + if (ast.nbits) + return ((CORE_ADDR)(((long)addr << ast.nbits) >> ast.nbits)); + return addr; +} + +/* Align a normalized address - a VA with bit 59 sign extended into + ADI bits. */ + +static CORE_ADDR +adi_align_address (CORE_ADDR naddr) +{ + adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid)); + + return (naddr - (naddr % ast.blksize)) / ast.blksize; +} + +/* Convert a byte count to count at a ratio of 1:adi_blksz. */ + +static int +adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl) +{ + adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid)); + + return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl; +} + +/* The /proc/[pid]/adi/tags file, which allows gdb to get/set ADI + version in a target process, maps linearly to the address space + of the target process at a ratio of 1:adi_blksz. + + A read (or write) at offset K in the file returns (or modifies) + the ADI version tag stored in the cacheline containing address + K * adi_blksz, encoded as 1 version tag per byte. The allowed + version tag values are between 0 and adi_stat.max_version. */ + +static int +adi_tag_fd (void) +{ + pid_t pid = ptid_get_pid (inferior_ptid); + sparc64_adi_info *proc = get_adi_info_proc (pid); + + if (proc->stat.tag_fd != 0) + return proc->stat.tag_fd; + + char cl_name[MAX_PROC_NAME_SIZE]; + snprintf (cl_name, sizeof(cl_name), "/proc/%d/adi/tags", pid); + int target_errno; + proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL, + 0, &target_errno); + return proc->stat.tag_fd; +} + +/* Check if an address set is ADI enabled, using /proc/[pid]/adi/maps + which was exported by the kernel and contains the currently ADI + mapped memory regions and their access permissions. */ + +static bool +adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt) +{ + char filename[MAX_PROC_NAME_SIZE]; + size_t i = 0; + + pid_t pid = ptid_get_pid (inferior_ptid); + snprintf (filename, sizeof filename, "/proc/%d/adi/maps", pid); + char *data = target_fileio_read_stralloc (NULL, filename); + if (data) + { + struct cleanup *cleanup = make_cleanup (xfree, data); + adi_stat_t adi_stat = get_adi_info (pid); + char *line; + for (line = strtok (data, "\n"); line; line = strtok (NULL, "\n")) + { + ULONGEST addr, endaddr; + + read_maps_entry (line, &addr, &endaddr); + + while (((vaddr + i) * adi_stat.blksize) >= addr + && ((vaddr + i) * adi_stat.blksize) < endaddr) + { + if (++i == cnt) + { + do_cleanups (cleanup); + return true; + } + } + } + do_cleanups (cleanup); + } + else + warning (_("unable to open /proc file '%s'"), filename); + + return false; +} + +/* Read ADI version tag value for memory locations starting at "VADDR" + for "SIZE" number of bytes. */ + +static int +adi_read_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags) +{ + int fd = adi_tag_fd (); + if (fd == -1) + return -1; + + if (!adi_is_addr_mapped (vaddr, size)) + { + adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid)); + error(_("Address at 0x%lx is not in ADI maps"), vaddr*ast.blksize); + } + + int target_errno; + return target_fileio_pread (fd, tags, size, vaddr, &target_errno); +} + +/* Write ADI version tag for memory locations starting at "VADDR" for + "SIZE" number of bytes to "TAGS". */ + +static int +adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags) +{ + int fd = adi_tag_fd (); + if (fd == -1) + return -1; + + if (!adi_is_addr_mapped (vaddr, size)) + { + adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid)); + error(_("Address at 0x%lx is not in ADI maps"), vaddr*ast.blksize); + } + + int target_errno; + return target_fileio_pwrite (fd, tags, size, vaddr, &target_errno); +} + +/* Print ADI version tag value in "TAGS" for memory locations starting + at "VADDR" with number of "CNT". */ + +static void +adi_print_versions (CORE_ADDR vaddr, size_t cnt, unsigned char *tags) +{ + int v_idx = 0; + const int maxelts = 8; /* # of elements per line */ + + adi_stat_t adi_stat = get_adi_info (ptid_get_pid (inferior_ptid)); + + while (cnt > 0) + { + QUIT; + printf_filtered ("0x%016lx:\t", vaddr * adi_stat.blksize); + for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--) + { + if (tags[v_idx] == 0xff) /* no version tag */ + printf_filtered ("-"); + else + printf_filtered ("%1X", tags[v_idx]); + if (cnt > 1) + printf_filtered (" "); + ++v_idx; + } + printf_filtered ("\n"); + gdb_flush (gdb_stdout); + vaddr += maxelts; + } +} + +static void +do_examine (CORE_ADDR start, int bcnt) +{ + CORE_ADDR vaddr = adi_normalize_address (start); + struct cleanup *cleanup; + + CORE_ADDR vstart = adi_align_address (vaddr); + int cnt = adi_convert_byte_count (vaddr, bcnt, vstart); + unsigned char *buf = (unsigned char *) xmalloc (cnt); + cleanup = make_cleanup (xfree, buf); + int read_cnt = adi_read_versions (vstart, cnt, buf); + if (read_cnt == -1) + error (_("No ADI information")); + else if (read_cnt < cnt) + error(_("No ADI information at 0x%lx"), vaddr); + + adi_print_versions (vstart, cnt, buf); + + do_cleanups (cleanup); +} + +static void +do_assign (CORE_ADDR start, size_t bcnt, int version) +{ + CORE_ADDR vaddr = adi_normalize_address (start); + + CORE_ADDR vstart = adi_align_address (vaddr); + int cnt = adi_convert_byte_count (vaddr, bcnt, vstart); + std::vector<unsigned char> buf (cnt, version); + int set_cnt = adi_write_versions (vstart, cnt, buf.data ()); + + if (set_cnt == -1) + error (_("No ADI information")); + else if (set_cnt < cnt) + error(_("No ADI information at 0x%lx"), vaddr); + +} + +/* ADI examine version tag command. + + Command syntax: + + adi (examine|x)/count <addr> */ + +static void +adi_examine_command (char *args, int from_tty) +{ + /* make sure program is active and adi is available */ + if (!target_has_execution) + error (_("ADI command requires a live process/thread")); + + if (!adi_available ()) + error (_("No ADI information")); + + pid_t pid = ptid_get_pid (inferior_ptid); + sparc64_adi_info *proc = get_adi_info_proc (pid); + int cnt = 1; + char *p = args; + if (p && *p == '/') + { + p++; + cnt = get_number (&p); + } + + CORE_ADDR next_address = 0; + if (p != 0 && *p != 0) + next_address = parse_and_eval_address (p); + if (!cnt || !next_address) + error (_("Usage: adi examine|x[/count] <addr>")); + + do_examine (next_address, cnt); +} + +/* ADI assign version tag command. + + Command syntax: + + adi (assign|a)/count <addr> = <version> */ + +static void +adi_assign_command (char *args, int from_tty) +{ + /* make sure program is active and adi is available */ + if (!target_has_execution) + error (_("ADI command requires a live process/thread")); + + if (!adi_available ()) + error (_("No ADI information")); + + char *exp = args; + if (exp == 0) + error_no_arg (_("Usage: adi assign|a[/count] <addr> = <version>")); + + char *q = (char *) strchr (exp, '='); + if (q) + *q++ = 0; + else + error (_("Usage: adi assign|a[/count] <addr> = <version>")); + + size_t cnt = 1; + char *p = args; + if (exp && *exp == '/') + { + p = exp + 1; + cnt = get_number (&p); + } + + CORE_ADDR next_address = 0; + if (p != 0 && *p != 0) + next_address = parse_and_eval_address (p); + else + error (_("Usage: adi assign|a[/count] <addr> = <version>")); + + int version = 0; + if (q != NULL) /* parse version tag */ + { + adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid)); + version = parse_and_eval_long (q); + if (version < 0 || version > ast.max_version) + error (_("Invalid ADI version tag %d"), version); + } + + do_assign (next_address, cnt, version); +} + +void +_initialize_sparc64_adi_tdep (void) +{ + + add_prefix_cmd ("adi", class_support, info_adi_command, + _("ADI version related commands."), + &sparc64adilist, "adi ", 0, &cmdlist); + add_cmd ("examine", class_support, adi_examine_command, + _("Examine ADI versions."), &sparc64adilist); + add_alias_cmd ("x", "examine", no_class, 1, &sparc64adilist); + add_cmd ("assign", class_support, adi_assign_command, + _("Assign ADI versions."), &sparc64adilist); + +} + + /* The functions on this page are intended to be used to classify function arguments. */ @@ -1290,6 +1789,14 @@ sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, } } +/* sparc64_addr_bits_remove - remove useless address bits */ + +static CORE_ADDR +sparc64_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr) +{ + return adi_normalize_address (addr); +} + void sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { @@ -1342,6 +1849,8 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind); frame_base_set_default (gdbarch, &sparc64_frame_base); + + set_gdbarch_addr_bits_remove (gdbarch, sparc64_addr_bits_remove); } diff --git a/gdb/sparc64-tdep.h b/gdb/sparc64-tdep.h index 324778e..da61a82 100644 --- a/gdb/sparc64-tdep.h +++ b/gdb/sparc64-tdep.h @@ -138,4 +138,6 @@ extern struct trad_frame_saved_reg * extern const struct sparc_fpregmap sparc64_bsd_fpregmap; +extern void sparc64_forget_process (pid_t pid); + #endif /* sparc64-tdep.h */ diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index d2ccd84..5581e5a 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2017-08-07 Weimin Pan <weimin.pan@oracle.com> + + * gdb.arch/sparc64-adi.exp: New file. + * gdb.arch/sparc64-adi.c: New file. + 2017-08-22 Pedro Alves <palves@redhat.com> * gdb.cp/overload.exp (line_range_pattern): New procedure. diff --git a/gdb/testsuite/gdb.arch/sparc64-adi.c b/gdb/testsuite/gdb.arch/sparc64-adi.c new file mode 100644 index 0000000..704fe26 --- /dev/null +++ b/gdb/testsuite/gdb.arch/sparc64-adi.c @@ -0,0 +1,145 @@ +/* Application Data Integrity (ADI) test in sparc64. + + Copyright 2017 Free Software Foundation, Inc. + + This file is part of GDB. + + 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, see <http://www.gnu.org/licenses/>. */ + +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <pthread.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> +#include <sys/errno.h> +#include <sys/utsname.h> +#include <sys/param.h> +#include <malloc.h> +#include <string.h> +#include <signal.h> +#include <sys/shm.h> +#include <errno.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <poll.h> +#include <setjmp.h> +#include "adi.h" + +#define ONEKB 1024 +#define PAT 0xdeadbeaf + +#define MAPSIZE 8192 +#define SHMSIZE 102400 +#ifndef PROT_ADI +#define PROT_ADI 0x10 +#endif + +static int +memory_fill (char *addr, size_t size, int pattern) +{ + long *aligned_addr = (long *) addr; + long i; + for (i = 0; i < size / sizeof (long); i += ONEKB) + { + *aligned_addr = pattern; + aligned_addr = aligned_addr + ONEKB; + } + return (0); +} + +int main () +{ + char *haddr; + caddr_t vaddr; + int version; + + /* Test ISM. */ + int shmid = shmget (IPC_PRIVATE, SHMSIZE, IPC_CREAT | 0666); + if (shmid == -1) + exit(1); + char *shmaddr = (char *)shmat (shmid, NULL, 0x666 | SHM_RND); + if (shmaddr == (char *)-1) + { + shmctl (shmid, IPC_RMID, NULL); + exit(1); + } + /* Enable ADI on ISM segment. */ + if (mprotect (shmaddr, SHMSIZE, PROT_READ|PROT_WRITE|PROT_ADI)) + { + perror ("mprotect failed"); + goto err_out; + } + if (memory_fill (shmaddr, SHMSIZE, PAT) != 0) /* line breakpoint here */ + { + exit(1); + } + adi_clr_version (shmaddr, SHMSIZE); + caddr_t vshmaddr = adi_set_version (shmaddr, SHMSIZE, 0x8); + if (vshmaddr == 0) + exit(1); + /* Test mmap. */ + int fd = open ("/dev/zero", O_RDWR); + if (fd < 0) + exit(1); + char *maddr = (char *)mmap (NULL, MAPSIZE, PROT_READ|PROT_WRITE, + MAP_PRIVATE, fd, 0); + if (maddr == (char *)-1) + exit(1); + /* Enable ADI. */ + if (mprotect (shmaddr, MAPSIZE, PROT_READ|PROT_WRITE|PROT_ADI)) + { + perror ("mprotect failed"); + goto err_out; + + } + if (memory_fill (maddr, MAPSIZE, PAT) != 0) + exit(1); + caddr_t vmaddr = adi_set_version (maddr, MAPSIZE, 0x8); + + /* Test heap. */ + haddr = (char*) memalign (MAPSIZE, MAPSIZE); + /* Enable ADI. */ + if (mprotect (shmaddr, MAPSIZE, PROT_READ|PROT_WRITE|PROT_ADI)) + { + perror ("mprotect failed"); + goto err_out; + } + + if (memory_fill (haddr, MAPSIZE, PAT) != 0) + exit(1); + adi_clr_version (haddr, MAPSIZE); + /* Set some ADP version number. */ + caddr_t vaddr1, vaddr2, vaddr3, vaddr4; + vaddr = adi_set_version (haddr, 64*2, 0x8); + vaddr1 = adi_set_version (haddr+64*2, 64*2, 0x9); + vaddr2 = adi_clr_version (haddr+64*4, 64*2); + vaddr3 = adi_set_version (haddr+64*6, 64*2, 0xa); + vaddr4 = adi_set_version (haddr+64*8, 64*10, 0x3); + if (vaddr == 0) + exit(1); + char *versioned_p = vaddr; + *versioned_p = 'a'; + char *uvp = haddr; // unversioned pointer + *uvp = 'b'; // version mismatch trap + + return (0); +err_out: + if (shmdt ((const void *)shmaddr) != 0) + perror ("Detach failure"); + shmctl (shmid, IPC_RMID, NULL); + exit (1); +} diff --git a/gdb/testsuite/gdb.arch/sparc64-adi.exp b/gdb/testsuite/gdb.arch/sparc64-adi.exp new file mode 100644 index 0000000..410bcf9 --- /dev/null +++ b/gdb/testsuite/gdb.arch/sparc64-adi.exp @@ -0,0 +1,53 @@ +# Copyright 2017 Free Software Foundation, Inc. + +# 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, see <http://www.gnu.org/licenses/>. + +# This file is part of the gdb testsuite. + +# Basic tests of examining/assigning ADI version tags, and reporting +# precise mismatch. + +if ![istarget "sparc64*-*-linux*"] then { + verbose "Skipping sparc64 ADI test." + return 0 +} + +standard_testfile + +if { [prepare_for_testing "failed to prepare" $testfile $srcfile \ + [list debug libs=-ladi]] } { + return -1 +} + +if ![runto_main] then { + untested "could not run to main" + return -1 +} + +gdb_test "break [gdb_get_line_number "line breakpoint here"]" \ + "Breakpoint .* at .*${srcfile}.*" \ + "set line breakpoint in main" +gdb_continue_to_breakpoint "continue to line breakpoint in main" + +########################################## +set newadi "7" +gdb_test "adi x shmaddr" "${hex}00:\t0" "examine ADI" +gdb_test_no_output "adi a/100 shmaddr=${newadi}" "assign ADI" +gdb_test "adi x/100 shmaddr" "${hex}00:\t${newadi} ${newadi}" \ + "examine new ADI" +gdb_test_no_output "adi a/100 shmaddr=0x0" "reset ADI" +gdb_test "continue" \ + [multi_line "Program received signal SIGSEGV, Segmentation fault.*" \ + "ADI precise mismatch while accessing address $hex.*" ] \ + "continue to sigsegv" |