From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2672 invoked by alias); 17 Dec 2012 03:10:09 -0000 Received: (qmail 2649 invoked by uid 22791); 17 Dec 2012 03:10:06 -0000 X-SWARE-Spam-Status: No, hits=-3.5 required=5.0 tests=AWL,BAYES_00,KAM_STOCKTIP,KHOP_RCVD_UNTRUST,RCVD_IN_DNSWL_HI,RP_MATCHES_RCVD,SPF_HELO_PASS,TW_CP X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 17 Dec 2012 03:09:52 +0000 Received: from int-mx12.intmail.prod.int.phx2.redhat.com (int-mx12.intmail.prod.int.phx2.redhat.com [10.5.11.25]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id qBH39p4b024102 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Sun, 16 Dec 2012 22:09:51 -0500 Received: from psique (ovpn-113-43.phx2.redhat.com [10.3.113.43]) by int-mx12.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id qBH39lUq017760; Sun, 16 Dec 2012 22:09:48 -0500 From: Sergio Durigan Junior To: Binutils Development Cc: GDB Patches , Pedro Alves , "H.J. Lu" Subject: [PATCH/RFC 01/02 v2] Refactor PRPSINFO handling on Binutils X-URL: http://www.redhat.com Date: Mon, 17 Dec 2012 03:10:00 -0000 Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-IsSubscribed: yes Mailing-List: contact binutils-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: binutils-owner@sourceware.org X-SW-Source: 2012-12/txt/msg00159.txt.bz2 Hi, This is a follow-up on: Sorry for the delay on this. I addressed Pedro's and H.J.'s comments, and took some time to test the patch on different architectures. It also took me some time to decide the best way to handle several little issues that I was facing: different declarations for PPC needed, different declarations for PRPSINFO structures, etc. Anyway, I hope I managed to solve these problems, but I would really appreciate some comments (if you have, of course) about the code. The idea was to simplify the handling of PRPSINFO, so: 1) I created elf_{internal,external}_prpsinfo* structures, organized differently according to their purposes. 2) I created the new PRPSINFO*_COPY_FIELDS macros, which take care of (duh) copying the fields from the internal to the external structures, obeying bitness and such. 3) I also took the liberty to implement the i386 version of the *_write_core_note. 4) I removed some dependency on the CORE_HEADER macro (suggested by Pedro). Not sure if everything is correct, though. Anyway, I guess those are the main changes. Please let me know if you have some question about the patch. Thanks. -- Sergio 2012-12-17 Sergio Durigan Junior * Makefile.in (BUILD_CFILES): Add `elf-psinfo.h'. * elf-bfd.h (elf_internal_prpsinfo): Forward declaration for structure. (elfcore_write_prpsinfo): Change prototype, accepting `elf_internal_prpsinfo' as argument. * elf-psinfo.h: New file. * elf.c: Include `elf-psinfo.h'. (elfcore_psinfo_t, elfcore_psinfo32_t): Remove declarations. (elfcore_grok_psinfo): Refactor the #ifdef's to not consider `HAVE_PRPSINFO*' defines. (elfcore_write_prpsinfo): Change prototype, accepting `elf_internal_prpsinfo' as argument. Rewrite parts of the code to make use of the new argument. * elf32-arm.c: Include `elf-psinfo.h'. (elf32_arm_nabi_write_core_note): Refactor `NT_PRPSINFO' case. * elf32-i386.c: Include `elf-bfd.h', `elf-psinfo.h' and `stdarg.h'. Include `CORE_HEADER' if defined. (elf_i386_write_core_note): New function. * elf32-ppc.c: Include `elf-psinfo.h'. (ppc_elf_write_core_note): Refactor `NT_PRPSINFO' case. * elf64-ppc.c: Include `elf-psinfo.h'. (ppc64_elf_write_core_note): Refactor `NT_PRPSINFO' case. * elf64-x86-64.c: Include `elf-psinfo.h'. Include `stdarg.h' unconditionally. (elf_x86_64_write_core_note): Remove `#ifdef CORE_HEADER', making the function unconditionally available. Refactor `NT_PRPSINFO' case. * hosts/x86-64linux.h (HAVE_PRPSINFO32_T, HAVE_PRPSINFO32_T_PR_PID, elf_prpsinfo32, elf_prpsinfo64, prpsinfo32_t, prpsinfo64_t): Remove definitions, moving some of them to `elf-psinfo.h'. --- bfd/Makefile.in | 2 +- bfd/elf-bfd.h | 6 +- bfd/elf-psinfo.h | 215 +++++++++++++++++++++++++++++++++++++++++++++++ bfd/elf.c | 38 ++++----- bfd/elf32-arm.c | 13 ++- bfd/elf32-i386.c | 70 +++++++++++++++ bfd/elf32-ppc.c | 14 ++- bfd/elf64-ppc.c | 14 ++- bfd/elf64-x86-64.c | 36 ++++---- bfd/hosts/x86-64linux.h | 37 -------- 10 files changed, 353 insertions(+), 92 deletions(-) create mode 100644 bfd/elf-psinfo.h diff --git a/bfd/Makefile.in b/bfd/Makefile.in index 92d9d08..e12deb5 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -1050,7 +1050,7 @@ BUILD_CFILES = \ CFILES = $(SOURCE_CFILES) $(BUILD_CFILES) SOURCE_HFILES = \ aout-target.h aoutf1.h aoutx.h coffcode.h coffswap.h ecoffswap.h \ - elf-bfd.h elf-hppa.h elf32-hppa.h \ + elf-bfd.h elf-psinfo.h elf-hppa.h elf32-hppa.h \ elf64-hppa.h elfcode.h elfcore.h \ freebsd.h genlink.h go32stub.h \ libaout.h libbfd.h libcoff.h libecoff.h libhppa.h libieee.h \ diff --git a/bfd/elf-bfd.h b/bfd/elf-bfd.h index b8d82b1..d314291 100644 --- a/bfd/elf-bfd.h +++ b/bfd/elf-bfd.h @@ -2234,11 +2234,15 @@ extern bfd_boolean bfd_elf_lookup_section_flags extern Elf_Internal_Phdr * _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section); +/* Forward declaration of prpsinfo. See `elf-psinfo.h' for more details. */ + +struct elf_internal_prpsinfo; + /* Exported interface for writing elf corefile notes. */ extern char *elfcore_write_note (bfd *, char *, int *, const char *, int, const void *, int); extern char *elfcore_write_prpsinfo - (bfd *, char *, int *, const char *, const char *); + (bfd *, char *, int *, const struct elf_internal_prpsinfo *); extern char *elfcore_write_prstatus (bfd *, char *, int *, long, int, const void *); extern char * elfcore_write_pstatus diff --git a/bfd/elf-psinfo.h b/bfd/elf-psinfo.h new file mode 100644 index 0000000..61b38e1 --- /dev/null +++ b/bfd/elf-psinfo.h @@ -0,0 +1,215 @@ +/* Declarations for PRPSINFO structures under ELF on GNU/Linux. + Copyright 2012 Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + 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., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +#undef HAVE_PRPSINFO32_T +#define HAVE_PRPSINFO32_T +#undef HAVE_PRPSINFO32_T_PR_PID +#define HAVE_PRPSINFO32_T_PR_PID + +/* Maximum size of the arguments that can be stored in a PRPSINFO + structure. */ + +#define ELF_PRARGSZ (80) + +/* Internal structure which holds information to be included in the + PRPSINFO section of the corefile. + + This is an "internal" structure in the sense that it should be used to + pass information to BFD (via the `elfcore_write_prpsinfo', for example), + so things like endianess shouldn't be an issue. This structure will + eventually be converted in one of the `elf_external_*' structures + below. */ + +struct elf_internal_prpsinfo + { + char pr_state; /* Numeric process state. */ + char pr_sname; /* Char for pr_state. */ + char pr_zomb; /* Zombie. */ + char pr_nice; /* Nice val. */ + unsigned long pr_flag; /* Flags. */ + unsigned int pr_uid; + unsigned int pr_gid; + int pr_pid, pr_ppid, pr_pgrp, pr_sid; + /* Lots missing */ + char pr_fname[16]; /* Filename of executable. */ + char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ + }; + +/* External 32-bit structure for PRPSINFO. This structure is ABI-defined, + thus we choose to use char arrays here in order to avoid dealing with + different types in different architectures. + + This structure will ultimately be written in the corefile's note section, + as the PRPSINFO. */ + +struct elf_external_prpsinfo32 + { + char pr_state; /* Numeric process state. */ + char pr_sname; /* Char for pr_state. */ + char pr_zomb; /* Zombie. */ + char pr_nice; /* Nice val. */ + char pr_flag[4]; /* Flags. */ + char pr_uid[2]; + char pr_gid[2]; + char pr_pid[4]; + char pr_ppid[4]; + char pr_pgrp[4]; + char pr_sid[4]; + /* Lots missing */ + char pr_fname[16]; /* Filename of executable. */ + char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ + }; + +/* External 32-bit PPC structure for PRPSINFO. This structure is ABI-defined, + thus we choose to use char arrays here in order to avoid dealing with + different types in different architectures. + + The reason why we have a different structure only for PPC is because + on this architecture (and *only* here!) the size of 32-bit structure + changes. This is due to the different sizes of `pr_uid' and `pr_gid', + which on non-PPC architectures are declared as `short int' and on PPC + architectures are declared as `int'. + + This structure will ultimately be written in the corefile's note section, + as the PRPSINFO. */ + +struct elf_external_ppc_prpsinfo32 + { + char pr_state; /* Numeric process state. */ + char pr_sname; /* Char for pr_state. */ + char pr_zomb; /* Zombie. */ + char pr_nice; /* Nice val. */ + char pr_flag[4]; /* Flags. */ + char pr_uid[4]; + char pr_gid[4]; + char pr_pid[4]; + char pr_ppid[4]; + char pr_pgrp[4]; + char pr_sid[4]; + /* Lots missing */ + char pr_fname[16]; /* Filename of executable. */ + char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ + }; + +/* Helper macro to copy (properly handling endianess) things from the + `elf_internal_prpsinfo' structure to the `elf_external_prpsinfo32' + structure. + + Note that FROM should be a pointer, and TO should be the explicit type. */ + +#define PRPSINFO32_COPY_FIELDS(abfd, from, to) \ + do \ + { \ + H_PUT_8 (abfd, from->pr_state, &to.pr_state); \ + H_PUT_8 (abfd, from->pr_sname, &to.pr_sname); \ + H_PUT_8 (abfd, from->pr_zomb, &to.pr_zomb); \ + H_PUT_8 (abfd, from->pr_nice, &to.pr_nice); \ + H_PUT_32 (abfd, from->pr_flag, to.pr_flag); \ + H_PUT_16 (abfd, from->pr_uid, to.pr_uid); \ + H_PUT_16 (abfd, from->pr_gid, to.pr_gid); \ + H_PUT_32 (abfd, from->pr_pid, to.pr_pid); \ + H_PUT_32 (abfd, from->pr_ppid, to.pr_ppid); \ + H_PUT_32 (abfd, from->pr_pgrp, to.pr_pgrp); \ + H_PUT_32 (abfd, from->pr_sid, to.pr_sid); \ + strncpy (to.pr_fname, from->pr_fname, sizeof (to.pr_fname)); \ + strncpy (to.pr_psargs, from->pr_psargs, sizeof (to.pr_psargs)); \ + } while (0) + +/* Helper macro to copy (properly handling endianess) things from the + `elf_internal_prpsinfo' structure to the `elf_external_ppc_prpsinfo32' + structure. + + Note that FROM should be a pointer, and TO should be the explicit type. */ + +#define PRPSINFO32_PPC_COPY_FIELDS(abfd, from, to) \ + do \ + { \ + H_PUT_8 (abfd, from->pr_state, &to.pr_state); \ + H_PUT_8 (abfd, from->pr_sname, &to.pr_sname); \ + H_PUT_8 (abfd, from->pr_zomb, &to.pr_zomb); \ + H_PUT_8 (abfd, from->pr_nice, &to.pr_nice); \ + H_PUT_32 (abfd, from->pr_flag, to.pr_flag); \ + H_PUT_32 (abfd, from->pr_uid, to.pr_uid); \ + H_PUT_32 (abfd, from->pr_gid, to.pr_gid); \ + H_PUT_32 (abfd, from->pr_pid, to.pr_pid); \ + H_PUT_32 (abfd, from->pr_ppid, to.pr_ppid); \ + H_PUT_32 (abfd, from->pr_pgrp, to.pr_pgrp); \ + H_PUT_32 (abfd, from->pr_sid, to.pr_sid); \ + strncpy (to.pr_fname, from->pr_fname, sizeof (to.pr_fname)); \ + strncpy (to.pr_psargs, from->pr_psargs, sizeof (to.pr_psargs)); \ + } while (0) + +/* External 64-bit structure for PRPSINFO. This structure is ABI-defined, + thus we choose to use char arrays here in order to avoid dealing with + different types in different architectures. + + Differently from the 32-bit version, the PowerPC guys made our lives better + and used the same size as the other architectures. + + This structure will ultimately be written in the corefile's note section, + as the PRPSINFO. */ + +struct elf_external_prpsinfo64 + { + char pr_state; /* Numeric process state. */ + char pr_sname; /* Char for pr_state. */ + char pr_zomb; /* Zombie. */ + char pr_nice; /* Nice val. */ + char pr_flag[8]; /* Flags. */ + char gap[4]; + char pr_uid[4]; + char pr_gid[4]; + char pr_pid[4]; + char pr_ppid[4]; + char pr_pgrp[4]; + char pr_sid[4]; + /* Lots missing */ + char pr_fname[16]; /* Filename of executable. */ + char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ + }; + +/* Helper macro to copy (properly handling endianess) things from the + `elf_internal_prpsinfo' structure to the `elf_external_prpsinfo64' + structure. + + Note that FROM should be a pointer, and TO should be the explicit type. */ + +#define PRPSINFO64_COPY_FIELDS(abfd, from, to) \ + do \ + { \ + H_PUT_8 (abfd, from->pr_state, &to.pr_state); \ + H_PUT_8 (abfd, from->pr_sname, &to.pr_sname); \ + H_PUT_8 (abfd, from->pr_zomb, &to.pr_zomb); \ + H_PUT_8 (abfd, from->pr_nice, &to.pr_nice); \ + H_PUT_64 (abfd, from->pr_flag, to.pr_flag); \ + H_PUT_32 (abfd, from->pr_uid, to.pr_uid); \ + H_PUT_32 (abfd, from->pr_gid, to.pr_gid); \ + H_PUT_32 (abfd, from->pr_pid, to.pr_pid); \ + H_PUT_32 (abfd, from->pr_ppid, to.pr_ppid); \ + H_PUT_32 (abfd, from->pr_pgrp, to.pr_pgrp); \ + H_PUT_32 (abfd, from->pr_sid, to.pr_sid); \ + strncpy (to.pr_fname, from->pr_fname, sizeof (to.pr_fname)); \ + strncpy (to.pr_psargs, from->pr_psargs, sizeof (to.pr_psargs)); \ + } while (0) + +/* Process info. In the end we do provide typedefs for them. */ + +typedef struct elf_external_prpsinfo32 prpsinfo32_t; +typedef struct elf_external_prpsinfo64 prpsinfo64_t; diff --git a/bfd/elf.c b/bfd/elf.c index a92dd5d..a39b88c 100644 --- a/bfd/elf.c +++ b/bfd/elf.c @@ -44,6 +44,7 @@ SECTION #include "elf-bfd.h" #include "libiberty.h" #include "safe-ctype.h" +#include "elf-psinfo.h" #ifdef CORE_HEADER #include CORE_HEADER @@ -8161,13 +8162,6 @@ elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note) return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note); } -#if defined (HAVE_PRPSINFO_T) -typedef prpsinfo_t elfcore_psinfo_t; -#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */ -typedef prpsinfo32_t elfcore_psinfo32_t; -#endif -#endif - #if defined (HAVE_PSINFO_T) typedef psinfo_t elfcore_psinfo_t; #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */ @@ -8201,17 +8195,17 @@ _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max) return dups; } -#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) static bfd_boolean elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) { +#if defined (HAVE_PSINFO_T) if (note->descsz == sizeof (elfcore_psinfo_t)) { elfcore_psinfo_t psinfo; memcpy (&psinfo, note->descdata, sizeof (psinfo)); -#if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID) +#if defined (HAVE_PSINFO_T_PR_PID) elf_tdata (abfd)->core_pid = psinfo.pr_pid; #endif elf_tdata (abfd)->core_program @@ -8222,7 +8216,7 @@ elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs)); } -#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T) +#if defined (HAVE_PSINFO32_T) else if (note->descsz == sizeof (elfcore_psinfo32_t)) { /* 64-bit host, 32-bit corefile */ @@ -8230,7 +8224,7 @@ elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) memcpy (&psinfo, note->descdata, sizeof (psinfo)); -#if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID) +#if defined (HAVE_PSINFO32_T_PR_PID) elf_tdata (abfd)->core_pid = psinfo.pr_pid; #endif elf_tdata (abfd)->core_program @@ -8261,10 +8255,14 @@ elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) if (0 < n && command[n - 1] == ' ') command[n - 1] = '\0'; } +#else /* defined (HAVE_PSINFO_T) */ + /* Avoid compiler warning about "unused variables". */ + (void) abfd; + (void) note; return TRUE; +#endif } -#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */ #if defined (HAVE_PSTATUS_T) static bfd_boolean @@ -9062,16 +9060,16 @@ char * elfcore_write_prpsinfo (bfd *abfd, char *buf, int *bufsiz, - const char *fname, - const char *psargs) + const struct elf_internal_prpsinfo *input) { const struct elf_backend_data *bed = get_elf_backend_data (abfd); if (bed->elf_backend_write_core_note != NULL) { char *ret; + ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz, - NT_PRPSINFO, fname, psargs); + NT_PRPSINFO, input); if (ret != NULL) return ret; } @@ -9089,8 +9087,8 @@ elfcore_write_prpsinfo (bfd *abfd, #endif memset (&data, 0, sizeof (data)); - strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); - strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); + strncpy (data.pr_fname, input->pr_fname, sizeof (data.pr_fname)); + strncpy (data.pr_psargs, input->pr_psargs, sizeof (data.pr_psargs)); return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, &data, sizeof (data)); } @@ -9101,13 +9099,13 @@ elfcore_write_prpsinfo (bfd *abfd, psinfo_t data; int note_type = NT_PSINFO; #else - prpsinfo_t data; + prpsinfo64_t data; int note_type = NT_PRPSINFO; #endif memset (&data, 0, sizeof (data)); - strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); - strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); + strncpy (data.pr_fname, input->pr_fname, sizeof (data.pr_fname)); + strncpy (data.pr_psargs, input->pr_psargs, sizeof (data.pr_psargs)); return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, &data, sizeof (data)); } diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c index fd7d26a..cacc895 100644 --- a/bfd/elf32-arm.c +++ b/bfd/elf32-arm.c @@ -30,6 +30,7 @@ #include "elf-nacl.h" #include "elf-vxworks.h" #include "elf/arm.h" +#include "elf-psinfo.h" /* Return the relocation section associated with NAME. HTAB is the bfd's elf32_arm_link_hash_entry. */ @@ -2004,17 +2005,19 @@ elf32_arm_nabi_write_core_note (bfd *abfd, char *buf, int *bufsiz, case NT_PRPSINFO: { - char data[124]; + const struct elf_internal_prpsinfo *prpsinfo; + struct elf_external_prpsinfo32 data; va_list ap; va_start (ap, note_type); - memset (data, 0, sizeof (data)); - strncpy (data + 28, va_arg (ap, const char *), 16); - strncpy (data + 44, va_arg (ap, const char *), 80); + prpsinfo = va_arg (ap, const struct elf_internal_prpsinfo *); va_end (ap); + memset (&data, 0, sizeof (data)); + PRPSINFO32_COPY_FIELDS (abfd, prpsinfo, data); + return elfcore_write_note (abfd, buf, bufsiz, - "CORE", note_type, data, sizeof (data)); + "CORE", note_type, &data, sizeof (data)); } case NT_PRSTATUS: diff --git a/bfd/elf32-i386.c b/bfd/elf32-i386.c index a188cec..5b81baa 100644 --- a/bfd/elf32-i386.c +++ b/bfd/elf32-i386.c @@ -31,12 +31,20 @@ #include "objalloc.h" #include "hashtab.h" #include "dwarf2.h" +#include "elf-bfd.h" +#include "elf-psinfo.h" + +#include /* 386 uses REL relocations instead of RELA. */ #define USE_REL 1 #include "elf/i386.h" +#ifdef CORE_HEADER +#include CORE_HEADER +#endif + static reloc_howto_type elf_howto_table[]= { HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield, @@ -500,6 +508,67 @@ elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) return TRUE; } + +static char * +elf_i386_write_core_note (bfd *abfd, char *buf, int *bufsiz, + int note_type, ...) +{ + const struct elf_backend_data *bed = get_elf_backend_data (abfd); + va_list ap; + const struct elf_internal_prpsinfo *prpsinfo; + long pid; + int cursig; + const void *gregs; + struct elf_external_prpsinfo32 data; + + switch (note_type) + { + default: + return NULL; + + case NT_PRPSINFO: + va_start (ap, note_type); + prpsinfo = va_arg (ap, const struct elf_internal_prpsinfo *); + va_end (ap); + + memset (&data, 0, sizeof (data)); + PRPSINFO32_COPY_FIELDS (abfd, prpsinfo, data); + + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, + &data, sizeof (data)); + /* NOTREACHED */ + + case NT_PRSTATUS: + va_start (ap, note_type); + pid = va_arg (ap, long); + cursig = va_arg (ap, int); + gregs = va_arg (ap, const void *); + va_end (ap); + + if (bed->elf_machine_code == EM_X86_64) + { + prstatusx32_t prstat; + memset (&prstat, 0, sizeof (prstat)); + prstat.pr_pid = pid; + prstat.pr_cursig = cursig; + memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, + &prstat, sizeof (prstat)); + } + else + { + prstatus32_t prstat; + memset (&prstat, 0, sizeof (prstat)); + prstat.pr_pid = pid; + prstat.pr_cursig = cursig; + memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, + &prstat, sizeof (prstat)); + } + } + /* NOTREACHED */ +} + /* Functions for the i386 ELF linker. @@ -5140,6 +5209,7 @@ elf_i386_add_symbol_hook (bfd * abfd, #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook #define elf_backend_grok_prstatus elf_i386_grok_prstatus #define elf_backend_grok_psinfo elf_i386_grok_psinfo +#define elf_backend_write_core_note elf_i386_write_core_note #define elf_backend_reloc_type_class elf_i386_reloc_type_class #define elf_backend_relocate_section elf_i386_relocate_section #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections diff --git a/bfd/elf32-ppc.c b/bfd/elf32-ppc.c index 5241926..2869663 100644 --- a/bfd/elf32-ppc.c +++ b/bfd/elf32-ppc.c @@ -37,6 +37,7 @@ #include "elf32-ppc.h" #include "elf-vxworks.h" #include "dwarf2.h" +#include "elf-psinfo.h" typedef enum split16_format_type { @@ -2222,16 +2223,19 @@ ppc_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...) case NT_PRPSINFO: { - char data[128]; + const struct elf_internal_prpsinfo *prpsinfo; + struct elf_external_ppc_prpsinfo32 data; va_list ap; va_start (ap, note_type); - memset (data, 0, sizeof (data)); - strncpy (data + 32, va_arg (ap, const char *), 16); - strncpy (data + 48, va_arg (ap, const char *), 80); + prpsinfo = va_arg (ap, const struct elf_internal_prpsinfo *); va_end (ap); + + memset (&data, 0, sizeof (data)); + PRPSINFO32_PPC_COPY_FIELDS (abfd, prpsinfo, data); + return elfcore_write_note (abfd, buf, bufsiz, - "CORE", note_type, data, sizeof (data)); + "CORE", note_type, &data, sizeof (data)); } case NT_PRSTATUS: diff --git a/bfd/elf64-ppc.c b/bfd/elf64-ppc.c index 10b6f9d..4eda989 100644 --- a/bfd/elf64-ppc.c +++ b/bfd/elf64-ppc.c @@ -34,6 +34,7 @@ #include "elf-bfd.h" #include "elf/ppc64.h" #include "elf64-ppc.h" +#include "elf-psinfo.h" #include "dwarf2.h" static bfd_reloc_status_type ppc64_elf_ha_reloc @@ -2718,16 +2719,19 @@ ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, case NT_PRPSINFO: { - char data[136]; + const struct elf_internal_prpsinfo *prpsinfo; + struct elf_external_prpsinfo64 data; va_list ap; va_start (ap, note_type); - memset (data, 0, sizeof (data)); - strncpy (data + 40, va_arg (ap, const char *), 16); - strncpy (data + 56, va_arg (ap, const char *), 80); + prpsinfo = va_arg (ap, const struct elf_internal_prpsinfo *); va_end (ap); + + memset (&data, 0, sizeof (data)); + PRPSINFO64_COPY_FIELDS (abfd, prpsinfo, data); + return elfcore_write_note (abfd, buf, bufsiz, - "CORE", note_type, data, sizeof (data)); + "CORE", note_type, &data, sizeof (data)); } case NT_PRSTATUS: diff --git a/bfd/elf64-x86-64.c b/bfd/elf64-x86-64.c index 283681c..2c9939d 100644 --- a/bfd/elf64-x86-64.c +++ b/bfd/elf64-x86-64.c @@ -32,11 +32,13 @@ #include "hashtab.h" #include "dwarf2.h" #include "libiberty.h" +#include "elf-psinfo.h" + +#include #include "elf/x86-64.h" #ifdef CORE_HEADER -#include #include CORE_HEADER #endif @@ -415,14 +417,13 @@ elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) return TRUE; } -#ifdef CORE_HEADER static char * elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...) { const struct elf_backend_data *bed = get_elf_backend_data (abfd); va_list ap; - const char *fname, *psargs; + const struct elf_internal_prpsinfo *prpsinfo; long pid; int cursig; const void *gregs; @@ -434,27 +435,28 @@ elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, case NT_PRPSINFO: va_start (ap, note_type); - fname = va_arg (ap, const char *); - psargs = va_arg (ap, const char *); + prpsinfo = va_arg (ap, const struct elf_internal_prpsinfo *); va_end (ap); if (bed->s->elfclass == ELFCLASS32) { - prpsinfo32_t data; - memset (&data, 0, sizeof (data)); - strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); - strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); + struct elf_external_prpsinfo32 data32; + + memset (&data32, 0, sizeof (data32)); + PRPSINFO32_COPY_FIELDS (abfd, prpsinfo, data32); + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, - &data, sizeof (data)); + &data32, sizeof (data32)); } else { - prpsinfo64_t data; - memset (&data, 0, sizeof (data)); - strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); - strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); + struct elf_external_prpsinfo64 data64; + + memset (&data64, 0, sizeof (data64)); + PRPSINFO64_COPY_FIELDS (abfd, prpsinfo, data64); + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, - &data, sizeof (data)); + &data64, sizeof (data64)); } /* NOTREACHED */ @@ -501,7 +503,7 @@ elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, } /* NOTREACHED */ } -#endif + /* Functions for the x86-64 ELF linker. */ @@ -5225,9 +5227,7 @@ static const struct bfd_elf_special_section #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo -#ifdef CORE_HEADER #define elf_backend_write_core_note elf_x86_64_write_core_note -#endif #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class #define elf_backend_relocate_section elf_x86_64_relocate_section #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections diff --git a/bfd/hosts/x86-64linux.h b/bfd/hosts/x86-64linux.h index 78be09a..6070978 100644 --- a/bfd/hosts/x86-64linux.h +++ b/bfd/hosts/x86-64linux.h @@ -43,11 +43,6 @@ typedef unsigned long long int uint64_t; /* Unsigned 64-bit integer aligned to 8 bytes. */ typedef uint64_t __attribute__ ((__aligned__ (8))) a8_uint64_t; -#undef HAVE_PRPSINFO32_T -#define HAVE_PRPSINFO32_T -#undef HAVE_PRPSINFO32_T_PR_PID -#define HAVE_PRPSINFO32_T_PR_PID - #undef HAVE_PRSTATUS32_T #define HAVE_PRSTATUS32_T @@ -191,36 +186,6 @@ struct elf_prstatus64 int pr_fpvalid; /* True if math copro being used. */ }; -struct elf_prpsinfo32 - { - char pr_state; /* Numeric process state. */ - char pr_sname; /* Char for pr_state. */ - char pr_zomb; /* Zombie. */ - char pr_nice; /* Nice val. */ - unsigned int pr_flag; /* Flags. */ - unsigned short int pr_uid; - unsigned short int pr_gid; - int pr_pid, pr_ppid, pr_pgrp, pr_sid; - /* Lots missing */ - char pr_fname[16]; /* Filename of executable. */ - char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ - }; - -struct elf_prpsinfo64 - { - char pr_state; /* Numeric process state. */ - char pr_sname; /* Char for pr_state. */ - char pr_zomb; /* Zombie. */ - char pr_nice; /* Nice val. */ - a8_uint64_t pr_flag; /* Flags. */ - unsigned int pr_uid; - unsigned int pr_gid; - int pr_pid, pr_ppid, pr_pgrp, pr_sid; - /* Lots missing */ - char pr_fname[16]; /* Filename of executable. */ - char pr_psargs[ELF_PRARGSZ]; /* Initial part of arg list. */ - }; - /* The rest of this file provides the types for emulation of the Solaris interfaces that should be implemented by users of libthread_db. */ @@ -229,5 +194,3 @@ struct elf_prpsinfo64 typedef struct elf_prstatus32 prstatus32_t; typedef struct elf_prstatusx32 prstatusx32_t; typedef struct elf_prstatus64 prstatus64_t; -typedef struct elf_prpsinfo32 prpsinfo32_t; -typedef struct elf_prpsinfo64 prpsinfo64_t; -- 1.7.7.6