Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity
Files
a28aa6edd4ba848c110cd73fd4e29c2bbdb2cb72
binutils-gdb/gdb/nat/amd64-linux-siginfo.c
Pedro Alves 9cf12d57c5 Fix PR gdb/20287 - x32 and "gdb_static_assert (sizeof (nat_siginfo_t) == sizeof (siginfo_t))" 
Building an x32 gdb trips on a static assertion:

  In file included from .../src/gdb/common/common-defs.h:71:0,
		   from .../src/gdb/nat/amd64-linux-siginfo.c:21:
  .../src/gdb/common/gdb_assert.h:26:66: error: size of array ‘never_defined_just_used_for_checking’ is negative
     extern int never_defined_just_used_for_checking[(expr) ? 1 : -1]
								    ^
  .../src/gdb/nat/amd64-linux-siginfo.c:113:1: note: in expansion of macro ‘gdb_static_assert’
   gdb_static_assert (sizeof (nat_siginfo_t) == sizeof (siginfo_t));
   ^

The problem is that the way nat_siginfo_t is defined, it can only
match the host's siginfo_t object when gdb is built as a 64-bit
program.

Several bits of nat_siginfo_t are off:

- nat_siginfo_t's _pad field's definition is:

   int _pad[((128 / sizeof (int)) - 4)];

  while /usr/include/bits/siginfo.h has:

   # define __SI_MAX_SIZE     128
   # if __WORDSIZE == 64
   #  define __SI_PAD_SIZE     ((__SI_MAX_SIZE / sizeof (int)) - 4)
   # else
   #  define __SI_PAD_SIZE     ((__SI_MAX_SIZE / sizeof (int)) - 3)
   # endif

  and __WORDSIZE == 32 for x32.  This is what causes the size of
  nat_siginfo_t to be wrong and the assertion to fail.

- the nat_clock_t type is incorrect for 64-bit.  We have this:

   /* For native 64-bit, clock_t in _sigchld is 64bit aligned at 4 bytes.  */
   typedef long __attribute__ ((__aligned__ (4))) nat_clock_t;

  however, /usr/include/bits/siginfo.h has:

   # if defined __x86_64__ && __WORDSIZE == 32
   /* si_utime and si_stime must be 4 byte aligned for x32 to match the
      kernel.  We align siginfo_t to 8 bytes so that si_utime and si_stime
      are actually aligned to 8 bytes since their offsets are multiple of
      8 bytes.  */
   typedef __clock_t __attribute__ ((__aligned__ (4))) __sigchld_clock_t;
   #  define __SI_ALIGNMENT __attribute__ ((__aligned__ (8)))
   # else
   typedef __clock_t __sigchld_clock_t;
   #  define __SI_ALIGNMENT
   # endif

  So we're currently forcing 4-byte alignment on clock_t, when it
  should only be so for x32, not 64-bit.

The fix:

 - Leaves nat_siginfo_t strictly for the 64-bit ABI.

 - Adds a new typedef for the siginfo type that ptrace uses
   (ptrace_siginfo_t).  An x32 gdb always gets/sets an x32 siginfo_t
   type with PTRACE_GETSIGINFO/PTRACE_SETSIGINFO.

 - Uses this new ptrace_siginfo_t type instead of nat_siginfo_t as the
   intermediate conversion type.

gdb/ChangeLog:
2016-07-26  Pedro Alves  <palves@redhat.com>

	* amd64-linux-nat.c (amd64_linux_siginfo_fixup): Rename 'native'
	parameter to 'ptrace'.
	* nat/amd64-linux-siginfo.c (GDB_SI_SIZE): New define.
	(nat_uptr_t): New an unsigned long.
	(nat_clock_t): Remove attribute __aligned__.
	(struct nat_timeval): Delete.
	(nat_siginfo_t): Remove attribute __aligned__.
	(ptrace_siginfo_t): Define.
	(compat_siginfo_from_siginfo, siginfo_from_compat_siginfo)
	(compat_x32_siginfo_from_siginfo)
	(siginfo_from_compat_x32_siginfo): Make 'from' parameter const.
	Convert through a ptrace_siginfo_t instead of a nat_siginfo_t.
	Remove casts.
	(amd64_linux_siginfo_fixup_common): Rename 'native' parameter to
	'ptrace'.  Remove static assertions.
	(top level): New static assertions.

gdb/gdbserver/ChangeLog:
2016-07-26  Pedro Alves  <palves@redhat.com>

	* linux-x86-low.c (x86_siginfo_fixup): Rename 'native' parameter
	to 'ptrace'.
2016-07-26 19:35:40 +01:00

597 lines
14 KiB
C
Raw Blame History

/* Low-level siginfo manipulation for amd64.
Copyright (C) 2002-2016 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 <signal.h>
#include "common-defs.h"
#include "amd64-linux-siginfo.h"
#define GDB_SI_SIZE 128
/* The types below define the most complete kernel siginfo types known
for the architecture, independent of the system/libc headers. They
are named from a 64-bit kernel's perspective:
| layout | type |
|--------+----------------------|
| 64-bit | nat_siginfo_t |
| 32-bit | compat_siginfo_t |
| x32 | compat_x32_siginfo_t |
*/
#ifndef __ILP32__
typedef int nat_int_t;
typedef unsigned long nat_uptr_t;
typedef int nat_time_t;
typedef int nat_timer_t;
/* For native 64-bit, clock_t in _sigchld is 64-bit. */
typedef long nat_clock_t;
typedef union nat_sigval
{
nat_int_t sival_int;
nat_uptr_t sival_ptr;
} nat_sigval_t;
typedef struct nat_siginfo
{
int si_signo;
int si_errno;
int si_code;
union
{
int _pad[((128 / sizeof (int)) - 4)];
/* kill() */
struct
{
unsigned int _pid;
unsigned int _uid;
} _kill;
/* POSIX.1b timers */
struct
{
nat_timer_t _tid;
int _overrun;
nat_sigval_t _sigval;
} _timer;
/* POSIX.1b signals */
struct
{
unsigned int _pid;
unsigned int _uid;
nat_sigval_t _sigval;
} _rt;
/* SIGCHLD */
struct
{
unsigned int _pid;
unsigned int _uid;
int _status;
nat_clock_t _utime;
nat_clock_t _stime;
} _sigchld;
/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
struct
{
nat_uptr_t _addr;
short int _addr_lsb;
struct
{
nat_uptr_t _lower;
nat_uptr_t _upper;
} si_addr_bnd;
} _sigfault;
/* SIGPOLL */
struct
{
int _band;
int _fd;
} _sigpoll;
} _sifields;
} nat_siginfo_t;
#endif /* __ILP32__ */
/* These types below (compat_*) define a siginfo type that is layout
compatible with the siginfo type exported by the 32-bit userspace
support. */
typedef int compat_int_t;
typedef unsigned int compat_uptr_t;
typedef int compat_time_t;
typedef int compat_timer_t;
typedef int compat_clock_t;
struct compat_timeval
{
compat_time_t tv_sec;
int tv_usec;
};
typedef union compat_sigval
{
compat_int_t sival_int;
compat_uptr_t sival_ptr;
} compat_sigval_t;
typedef struct compat_siginfo
{
int si_signo;
int si_errno;
int si_code;
union
{
int _pad[((128 / sizeof (int)) - 3)];
/* kill() */
struct
{
unsigned int _pid;
unsigned int _uid;
} _kill;
/* POSIX.1b timers */
struct
{
compat_timer_t _tid;
int _overrun;
compat_sigval_t _sigval;
} _timer;
/* POSIX.1b signals */
struct
{
unsigned int _pid;
unsigned int _uid;
compat_sigval_t _sigval;
} _rt;
/* SIGCHLD */
struct
{
unsigned int _pid;
unsigned int _uid;
int _status;
compat_clock_t _utime;
compat_clock_t _stime;
} _sigchld;
/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
struct
{
unsigned int _addr;
short int _addr_lsb;
struct
{
unsigned int _lower;
unsigned int _upper;
} si_addr_bnd;
} _sigfault;
/* SIGPOLL */
struct
{
int _band;
int _fd;
} _sigpoll;
} _sifields;
} compat_siginfo_t;
/* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */
typedef long __attribute__ ((__aligned__ (4))) compat_x32_clock_t;
typedef struct compat_x32_siginfo
{
int si_signo;
int si_errno;
int si_code;
union
{
int _pad[((128 / sizeof (int)) - 3)];
/* kill() */
struct
{
unsigned int _pid;
unsigned int _uid;
} _kill;
/* POSIX.1b timers */
struct
{
compat_timer_t _tid;
int _overrun;
compat_sigval_t _sigval;
} _timer;
/* POSIX.1b signals */
struct
{
unsigned int _pid;
unsigned int _uid;
compat_sigval_t _sigval;
} _rt;
/* SIGCHLD */
struct
{
unsigned int _pid;
unsigned int _uid;
int _status;
compat_x32_clock_t _utime;
compat_x32_clock_t _stime;
} _sigchld;
/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
struct
{
unsigned int _addr;
unsigned int _addr_lsb;
} _sigfault;
/* SIGPOLL */
struct
{
int _band;
int _fd;
} _sigpoll;
} _sifields;
} compat_x32_siginfo_t __attribute__ ((__aligned__ (8)));
/* To simplify usage of siginfo fields. */
#define cpt_si_pid _sifields._kill._pid
#define cpt_si_uid _sifields._kill._uid
#define cpt_si_timerid _sifields._timer._tid
#define cpt_si_overrun _sifields._timer._overrun
#define cpt_si_status _sifields._sigchld._status
#define cpt_si_utime _sifields._sigchld._utime
#define cpt_si_stime _sifields._sigchld._stime
#define cpt_si_ptr _sifields._rt._sigval.sival_ptr
#define cpt_si_addr _sifields._sigfault._addr
#define cpt_si_addr_lsb _sifields._sigfault._addr_lsb
#define cpt_si_band _sifields._sigpoll._band
#define cpt_si_fd _sifields._sigpoll._fd
/* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
In their place is si_timer1,si_timer2. */
#ifndef si_timerid
#define si_timerid si_timer1
#endif
#ifndef si_overrun
#define si_overrun si_timer2
#endif
/* The type of the siginfo object the kernel returns in
PTRACE_GETSIGINFO. If gdb is built as a x32 program, we get a x32
siginfo. */
#ifdef __ILP32__
typedef compat_x32_siginfo_t ptrace_siginfo_t;
#else
typedef nat_siginfo_t ptrace_siginfo_t;
#endif
/* Convert the system provided siginfo into compatible siginfo. */
static void
compat_siginfo_from_siginfo (compat_siginfo_t *to, const siginfo_t *from)
{
ptrace_siginfo_t from_ptrace;
memcpy (&from_ptrace, from, sizeof (from_ptrace));
memset (to, 0, sizeof (*to));
to->si_signo = from_ptrace.si_signo;
to->si_errno = from_ptrace.si_errno;
to->si_code = from_ptrace.si_code;
if (to->si_code == SI_TIMER)
{
to->cpt_si_timerid = from_ptrace.cpt_si_timerid;
to->cpt_si_overrun = from_ptrace.cpt_si_overrun;
to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
}
else if (to->si_code == SI_USER)
{
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
}
else if (to->si_code < 0)
{
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
}
else
{
switch (to->si_signo)
{
case SIGCHLD:
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
to->cpt_si_status = from_ptrace.cpt_si_status;
to->cpt_si_utime = from_ptrace.cpt_si_utime;
to->cpt_si_stime = from_ptrace.cpt_si_stime;
break;
case SIGILL:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
to->cpt_si_addr = from_ptrace.cpt_si_addr;
break;
case SIGPOLL:
to->cpt_si_band = from_ptrace.cpt_si_band;
to->cpt_si_fd = from_ptrace.cpt_si_fd;
break;
default:
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
break;
}
}
}
/* Convert the compatible siginfo into system siginfo. */
static void
siginfo_from_compat_siginfo (siginfo_t *to, const compat_siginfo_t *from)
{
ptrace_siginfo_t to_ptrace;
memset (&to_ptrace, 0, sizeof (to_ptrace));
to_ptrace.si_signo = from->si_signo;
to_ptrace.si_errno = from->si_errno;
to_ptrace.si_code = from->si_code;
if (to_ptrace.si_code == SI_TIMER)
{
to_ptrace.cpt_si_timerid = from->cpt_si_timerid;
to_ptrace.cpt_si_overrun = from->cpt_si_overrun;
to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
}
else if (to_ptrace.si_code == SI_USER)
{
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
}
if (to_ptrace.si_code < 0)
{
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
}
else
{
switch (to_ptrace.si_signo)
{
case SIGCHLD:
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
to_ptrace.cpt_si_status = from->cpt_si_status;
to_ptrace.cpt_si_utime = from->cpt_si_utime;
to_ptrace.cpt_si_stime = from->cpt_si_stime;
break;
case SIGILL:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
to_ptrace.cpt_si_addr = from->cpt_si_addr;
to_ptrace.cpt_si_addr_lsb = from->cpt_si_addr_lsb;
break;
case SIGPOLL:
to_ptrace.cpt_si_band = from->cpt_si_band;
to_ptrace.cpt_si_fd = from->cpt_si_fd;
break;
default:
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
break;
}
}
memcpy (to, &to_ptrace, sizeof (to_ptrace));
}
/* Convert the system provided siginfo into compatible x32 siginfo. */
static void
compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
const siginfo_t *from)
{
ptrace_siginfo_t from_ptrace;
memcpy (&from_ptrace, from, sizeof (from_ptrace));
memset (to, 0, sizeof (*to));
to->si_signo = from_ptrace.si_signo;
to->si_errno = from_ptrace.si_errno;
to->si_code = from_ptrace.si_code;
if (to->si_code == SI_TIMER)
{
to->cpt_si_timerid = from_ptrace.cpt_si_timerid;
to->cpt_si_overrun = from_ptrace.cpt_si_overrun;
to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
}
else if (to->si_code == SI_USER)
{
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
}
else if (to->si_code < 0)
{
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
}
else
{
switch (to->si_signo)
{
case SIGCHLD:
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
to->cpt_si_status = from_ptrace.cpt_si_status;
memcpy (&to->cpt_si_utime, &from_ptrace.cpt_si_utime,
sizeof (to->cpt_si_utime));
memcpy (&to->cpt_si_stime, &from_ptrace.cpt_si_stime,
sizeof (to->cpt_si_stime));
break;
case SIGILL:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
to->cpt_si_addr = from_ptrace.cpt_si_addr;
break;
case SIGPOLL:
to->cpt_si_band = from_ptrace.cpt_si_band;
to->cpt_si_fd = from_ptrace.cpt_si_fd;
break;
default:
to->cpt_si_pid = from_ptrace.cpt_si_pid;
to->cpt_si_uid = from_ptrace.cpt_si_uid;
to->cpt_si_ptr = from_ptrace.cpt_si_ptr;
break;
}
}
}
/* Convert the compatible x32 siginfo into system siginfo. */
static void
siginfo_from_compat_x32_siginfo (siginfo_t *to,
const compat_x32_siginfo_t *from)
{
ptrace_siginfo_t to_ptrace;
memset (&to_ptrace, 0, sizeof (to_ptrace));
to_ptrace.si_signo = from->si_signo;
to_ptrace.si_errno = from->si_errno;
to_ptrace.si_code = from->si_code;
if (to_ptrace.si_code == SI_TIMER)
{
to_ptrace.cpt_si_timerid = from->cpt_si_timerid;
to_ptrace.cpt_si_overrun = from->cpt_si_overrun;
to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
}
else if (to_ptrace.si_code == SI_USER)
{
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
}
if (to_ptrace.si_code < 0)
{
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
}
else
{
switch (to_ptrace.si_signo)
{
case SIGCHLD:
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
to_ptrace.cpt_si_status = from->cpt_si_status;
memcpy (&to_ptrace.cpt_si_utime, &from->cpt_si_utime,
sizeof (to_ptrace.cpt_si_utime));
memcpy (&to_ptrace.cpt_si_stime, &from->cpt_si_stime,
sizeof (to_ptrace.cpt_si_stime));
break;
case SIGILL:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
to_ptrace.cpt_si_addr = from->cpt_si_addr;
break;
case SIGPOLL:
to_ptrace.cpt_si_band = from->cpt_si_band;
to_ptrace.cpt_si_fd = from->cpt_si_fd;
break;
default:
to_ptrace.cpt_si_pid = from->cpt_si_pid;
to_ptrace.cpt_si_uid = from->cpt_si_uid;
to_ptrace.cpt_si_ptr = from->cpt_si_ptr;
break;
}
}
memcpy (to, &to_ptrace, sizeof (to_ptrace));
}
/* Convert a ptrace siginfo object, into/from the siginfo in the
layout of the inferiors' architecture. Returns true if any
conversion was done; false otherwise. If DIRECTION is 1, then copy
from INF to PTRACE. If DIRECTION is 0, then copy from NATIVE to
INF. */
int
amd64_linux_siginfo_fixup_common (siginfo_t *ptrace, gdb_byte *inf,
int direction,
enum amd64_siginfo_fixup_mode mode)
{
if (mode == FIXUP_32)
{
if (direction == 0)
compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, ptrace);
else
siginfo_from_compat_siginfo (ptrace, (struct compat_siginfo *) inf);
return 1;
}
else if (mode == FIXUP_X32)
{
if (direction == 0)
compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
ptrace);
else
siginfo_from_compat_x32_siginfo (ptrace,
(struct compat_x32_siginfo *) inf);
return 1;
}
return 0;
}
/* Sanity check for the siginfo structure sizes. */
gdb_static_assert (sizeof (siginfo_t) == GDB_SI_SIZE);
#ifndef __ILP32__
gdb_static_assert (sizeof (nat_siginfo_t) == GDB_SI_SIZE);
#endif
gdb_static_assert (sizeof (compat_x32_siginfo_t) == GDB_SI_SIZE);
gdb_static_assert (sizeof (compat_siginfo_t) == GDB_SI_SIZE);
gdb_static_assert (sizeof (ptrace_siginfo_t) == GDB_SI_SIZE);
View Git Blame Copy Permalink