From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 3849 invoked by alias); 10 Jan 2013 19:47:56 -0000 Received: (qmail 3817 invoked by uid 22791); 10 Jan 2013 19:47:55 -0000 X-SWARE-Spam-Status: No, hits=-2.2 required=5.0 tests=AWL,BAYES_50,KAM_STOCKTIP,KHOP_RCVD_UNTRUST,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,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; Thu, 10 Jan 2013 19:47:45 +0000 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r0AJlhnh017920 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Thu, 10 Jan 2013 14:47:43 -0500 Received: from psique (ovpn-113-189.phx2.redhat.com [10.3.113.189]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r0AJld2b017013; Thu, 10 Jan 2013 14:47:40 -0500 From: Sergio Durigan Junior To: Pedro Alves Cc: Jan Kratochvil , Binutils Development , GDB Patches , "H.J. Lu" Subject: Re: [PATCH/RFC 01/02 v2] Refactor PRPSINFO handling on Binutils In-Reply-To: <50EF07C8.3050307@redhat.com> (Pedro Alves's message of "Thu, 10 Jan 2013 18:26:16 +0000") References: <20121218173747.GA24546@host2.jankratochvil.net> <20121218193104.GA29194@host2.jankratochvil.net> <20130101143027.GA17408@host2.jankratochvil.net> <20130103134431.GA4099@host2.jankratochvil.net> <50EF07C8.3050307@redhat.com> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.3 (gnu/linux) X-URL: http://www.redhat.com Date: Thu, 10 Jan 2013 19:47:00 -0000 Message-ID: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2013-01/txt/msg00202.txt.bz2 Thanks for the review. On Thursday, January 10 2013, Pedro Alves wrote: > On 01/04/2013 04:39 AM, Sergio Durigan Junior wrote:> +++ b/bfd/elf-psinfo.h >> @@ -0,0 +1,124 @@ >> +/* Definitions for PRPSINFO structures under ELF on GNU/Linux. > > What about other OSs, like e.g., Solaris? Since I took the definitions from the Linux kernel, I thought it'd be better to explicitly mention that. I'm afraid I don't know how Solaris handle corefiles, do you think this comment should be expanded? >> +/* 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. > > In the current revision, this comment appears out of the blue. > Better would be to instead add a comment further up, above the > 32-bit version stating that these are used by most architectures, > although some define their own versions (like e.g., PPC). You're right, the PowerPC note doesn't belong here, I will remove it, thanks. >> +/* Process info. In the end we do provide typedefs for them. */ >> + >> +typedef struct elf_external_prpsinfo32 prpsinfo32; >> +typedef struct elf_external_prpsinfo64 prpsinfo64; > > What's the point of these typedefs? To me, they just > obscure things, and are easily confused with the host > types... > >> @@ -8165,7 +8166,7 @@ elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *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; >> +typedef prpsinfo32 elfcore_psinfo32_t; > > ... like here. HAVE_PRPSINFO32_T/prpsinfo32_t were > about a host type. prpsinfo32 is always defined (it's a > bfd type). This in fact looks suspiciously wrong, and a > potential breakage if in fact Sparc32 has a different > psinfo32_t (what OS was that?), or in the other spots, > some other arcane port/OS/arch having a different psinfo32_t > than the Linux one. Either the #ifdef can be removed and > this made unconditional, and host independent (the best), > or the type should remain the host type (until all ports > convert to implement elf_backend_write_core_note&co > host-independent hooks). Thanks for the explanation. I confess this is an area which I don't feel very confident, so I decided not to mess with anything and just leave things as they were. I will remove the typedef's from elf-psinfo.h. >> #endif >> #endif >> > >> + 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 > > This "only here" bit of the comment should go away, because > it'll generate confusion whenever some other arch needs > its own structure, making this outdated, because nobody > will remember to update it. Ops, sorry about it, I will remove. >> case NT_PRSTATUS: >> +#ifdef CORE_HEADER >> va_start (ap, note_type); >> pid = va_arg (ap, long); >> cursig = va_arg (ap, int); >> @@ -498,10 +501,13 @@ elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, >> return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, >> &prstat, sizeof (prstat)); >> } >> +#else >> + return NULL; >> +#endif /* CORE_HEADER */ >> } >> /* NOTREACHED */ >> } >> -#endif >> + > > Do you plan on following up with similar treatment for prstatus? Yeah, I was actually talking about it yesterday on #gdb. Since PRPSTATUS is quite similar, I believe it could be easily done as well. But first I am focusing on getting the PRPSINFO part upstream. Here is the updated version of the patch. Thanks. -- Sergio 2013-01-10 Sergio Durigan Junior * Makefile.in (BUILD_CFILES): Add `elf-psinfo.h'. * elf-bfd.h (ELF_PRARGSZ): New conditional definition. (elf_internal_prpsinfo): New structure declaration. (elfcore_write_prpsinfo): Change prototype, accepting `elf_internal_prpsinfo' as argument. * elf-psinfo.h: New file. * elf.c (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'. (elf_i386_write_core_note): New function. * elf32-ppc.c: Include `elf-psinfo.h'. (elf_external_ppc_prpsinfo32): New structure declaration. (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. Refactor `NT_PRSTATUS' case, making it conditional to `CORE_HEADER'. * hosts/x86-64linux.h (HAVE_PRPSINFO32_T, HAVE_PRPSINFO32_T_PR_PID, elf_prpsinfo32, elf_prpsinfo64, prpsinfo32_t, prpsinfo64_t): Remove definitions. --- bfd/Makefile.in | 2 +- bfd/elf-bfd.h | 26 ++++++++++- bfd/elf-psinfo.h | 119 +++++++++++++++++++++++++++++++++++++++++++++++ bfd/elf.c | 15 +++--- bfd/elf32-arm.c | 13 +++-- bfd/elf32-i386.c | 37 +++++++++++++++ bfd/elf32-ppc.c | 70 +++++++++++++++++++++++++-- bfd/elf64-ppc.c | 14 ++++-- bfd/elf64-x86-64.c | 40 +++++++++------- bfd/hosts/x86-64linux.h | 37 --------------- 10 files changed, 294 insertions(+), 79 deletions(-) create mode 100644 bfd/elf-psinfo.h diff --git a/bfd/Makefile.in b/bfd/Makefile.in index af4e5ed..f6c8857 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -1072,7 +1072,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 43a077c..c035c0f 100644 --- a/bfd/elf-bfd.h +++ b/bfd/elf-bfd.h @@ -1723,6 +1723,30 @@ struct elf_obj_tdata (elf_known_obj_attributes (bfd) [OBJ_ATTR_PROC]) #define elf_other_obj_attributes_proc(bfd) \ (elf_other_obj_attributes (bfd) [OBJ_ATTR_PROC]) + +/* 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; + char pr_fname[16 + 1]; /* Filename of executable. */ + char pr_psargs[80 + 1]; /* Initial part of arg list. */ + }; + extern void _bfd_elf_swap_verdef_in (bfd *, const Elf_External_Verdef *, Elf_Internal_Verdef *); @@ -2239,7 +2263,7 @@ extern Elf_Internal_Phdr * _bfd_elf_find_segment_containing_section 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..e241842 --- /dev/null +++ b/bfd/elf-psinfo.h @@ -0,0 +1,119 @@ +/* Definitions for PRPSINFO structures under ELF on GNU/Linux. + Copyright 2013 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. */ + +/* The PRPSINFO structures defined below are used by most architectures, + although some of them define their own versions (like e.g., PPC). */ + +/* 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]; + char pr_fname[16]; /* Filename of executable. */ + char pr_psargs[80]; /* Initial part of arg list. */ + }; + +/* Helper macro to swap (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_SWAP_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) + +/* 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. + + 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]; + char pr_fname[16]; /* Filename of executable. */ + char pr_psargs[80]; /* Initial part of arg list. */ + }; + +/* Helper macro to swap (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_SWAP_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) diff --git a/bfd/elf.c b/bfd/elf.c index 9cd3542..444bb44 100644 --- a/bfd/elf.c +++ b/bfd/elf.c @@ -45,6 +45,7 @@ SECTION #include "elf-bfd.h" #include "libiberty.h" #include "safe-ctype.h" +#include "elf-psinfo.h" #ifdef CORE_HEADER #include CORE_HEADER @@ -9103,16 +9104,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; } @@ -9130,8 +9131,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)); } @@ -9147,8 +9148,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)); } diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c index e2f8a96..c9c3d15 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_SWAP_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 f76c7a7..b81b35b 100644 --- a/bfd/elf32-i386.c +++ b/bfd/elf32-i386.c @@ -31,6 +31,10 @@ #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 @@ -500,6 +504,38 @@ 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, ...) +{ + va_list ap; + + switch (note_type) + { + default: + return NULL; + + case NT_PRPSINFO: + { + const struct elf_internal_prpsinfo *prpsinfo; + struct elf_external_prpsinfo32 data; + + va_start (ap, note_type); + prpsinfo = va_arg (ap, const struct elf_internal_prpsinfo *); + va_end (ap); + + memset (&data, 0, sizeof (data)); + PRPSINFO32_SWAP_FIELDS (abfd, prpsinfo, data); + + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, + &data, sizeof (data)); + } + /* NOTREACHED */ + } + /* NOTREACHED */ +} + /* Functions for the i386 ELF linker. @@ -5042,6 +5078,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..429ccb2 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 { @@ -1777,6 +1778,62 @@ static reloc_howto_type ppc_elf_howto_raw[] = { 0xffff, /* dst_mask */ FALSE), /* pcrel_offset */ }; + +/* 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 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[80]; /* Initial part of arg list. */ + }; + +/* Helper macro to swap (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_SWAP_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) + /* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */ @@ -2222,16 +2279,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_SWAP_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..937ef7f 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_SWAP_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 92bf991..b0f6194 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,31 +435,33 @@ 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_SWAP_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_SWAP_FIELDS (abfd, prpsinfo, data64); + return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, - &data, sizeof (data)); + &data64, sizeof (data64)); } /* NOTREACHED */ case NT_PRSTATUS: +#ifdef CORE_HEADER va_start (ap, note_type); pid = va_arg (ap, long); cursig = va_arg (ap, int); @@ -498,10 +501,13 @@ elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz, return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, &prstat, sizeof (prstat)); } +#else + return NULL; +#endif /* CORE_HEADER */ } /* NOTREACHED */ } -#endif + /* Functions for the x86-64 ELF linker. */ @@ -5157,9 +5163,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