Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl> |
| 3 | * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl> |
| 4 | * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com> |
Wichert Akkerman | 4dc8a2a | 1999-12-23 14:20:14 +0000 | [diff] [blame] | 5 | * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl> |
| 6 | * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation |
| 7 | * Linux for s390 port by D.J. Barrow |
| 8 | * <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com> |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 9 | * All rights reserved. |
| 10 | * |
| 11 | * Redistribution and use in source and binary forms, with or without |
| 12 | * modification, are permitted provided that the following conditions |
| 13 | * are met: |
| 14 | * 1. Redistributions of source code must retain the above copyright |
| 15 | * notice, this list of conditions and the following disclaimer. |
| 16 | * 2. Redistributions in binary form must reproduce the above copyright |
| 17 | * notice, this list of conditions and the following disclaimer in the |
| 18 | * documentation and/or other materials provided with the distribution. |
| 19 | * 3. The name of the author may not be used to endorse or promote products |
| 20 | * derived from this software without specific prior written permission. |
| 21 | * |
| 22 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| 23 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| 24 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| 25 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 26 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 27 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 28 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 29 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 30 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 31 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 32 | */ |
| 33 | |
| 34 | #include "defs.h" |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 35 | #include <sys/user.h> |
| 36 | #include <fcntl.h> |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 37 | |
Wichert Akkerman | 36915a1 | 1999-07-13 15:45:02 +0000 | [diff] [blame] | 38 | #ifdef HAVE_SYS_REG_H |
| 39 | # include <sys/reg.h> |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 40 | # ifndef PTRACE_PEEKUSR |
| 41 | # define PTRACE_PEEKUSR PTRACE_PEEKUSER |
| 42 | # endif |
| 43 | # ifndef PTRACE_POKEUSR |
| 44 | # define PTRACE_POKEUSR PTRACE_POKEUSER |
| 45 | # endif |
Wichert Akkerman | faf7222 | 2000-02-19 23:59:03 +0000 | [diff] [blame] | 46 | #elif defined(HAVE_LINUX_PTRACE_H) |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 47 | # undef PTRACE_SYSCALL |
Roland McGrath | b0acdfd | 2004-03-01 21:31:02 +0000 | [diff] [blame] | 48 | # ifdef HAVE_STRUCT_IA64_FPREG |
| 49 | # define ia64_fpreg XXX_ia64_fpreg |
| 50 | # endif |
| 51 | # ifdef HAVE_STRUCT_PT_ALL_USER_REGS |
| 52 | # define pt_all_user_regs XXX_pt_all_user_regs |
| 53 | # endif |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 54 | # include <linux/ptrace.h> |
Roland McGrath | b0acdfd | 2004-03-01 21:31:02 +0000 | [diff] [blame] | 55 | # undef ia64_fpreg |
| 56 | # undef pt_all_user_regs |
Wichert Akkerman | 15dea97 | 1999-10-06 13:06:34 +0000 | [diff] [blame] | 57 | #endif |
Wichert Akkerman | 36915a1 | 1999-07-13 15:45:02 +0000 | [diff] [blame] | 58 | |
Wichert Akkerman | 8b1b40c | 2000-02-03 21:58:30 +0000 | [diff] [blame] | 59 | #ifdef IA64 |
| 60 | # include <asm/ptrace_offsets.h> |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 61 | #endif |
Wichert Akkerman | 8b1b40c | 2000-02-03 21:58:30 +0000 | [diff] [blame] | 62 | |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 63 | #if defined(SPARC) || defined(SPARC64) || defined(MIPS) |
Roland McGrath | 576b784 | 2007-11-04 00:00:00 +0000 | [diff] [blame] | 64 | typedef struct { |
| 65 | struct pt_regs si_regs; |
| 66 | int si_mask; |
| 67 | } m_siginfo_t; |
Roland McGrath | 30ff45e | 2003-01-30 20:15:23 +0000 | [diff] [blame] | 68 | #elif defined HAVE_ASM_SIGCONTEXT_H |
H.J. Lu | 35be581 | 2012-04-16 13:00:01 +0200 | [diff] [blame] | 69 | # if !defined(IA64) && !defined(X86_64) && !defined(X32) |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 70 | # include <asm/sigcontext.h> |
Denys Vlasenko | a6d91de | 2012-03-16 12:02:22 +0100 | [diff] [blame] | 71 | # endif |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 72 | #else /* !HAVE_ASM_SIGCONTEXT_H */ |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 73 | # if defined M68K && !defined HAVE_STRUCT_SIGCONTEXT |
| 74 | struct sigcontext { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 75 | unsigned long sc_mask; |
| 76 | unsigned long sc_usp; |
| 77 | unsigned long sc_d0; |
| 78 | unsigned long sc_d1; |
| 79 | unsigned long sc_a0; |
| 80 | unsigned long sc_a1; |
| 81 | unsigned short sc_sr; |
| 82 | unsigned long sc_pc; |
| 83 | unsigned short sc_formatvec; |
| 84 | }; |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 85 | # endif /* M68K */ |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 86 | #endif /* !HAVE_ASM_SIGCONTEXT_H */ |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 87 | #if defined(I386) || defined(X86_64) |
| 88 | struct i386_sigcontext_struct { |
| 89 | uint16_t gs, __gsh; |
| 90 | uint16_t fs, __fsh; |
| 91 | uint16_t es, __esh; |
| 92 | uint16_t ds, __dsh; |
| 93 | uint32_t edi; |
| 94 | uint32_t esi; |
| 95 | uint32_t ebp; |
| 96 | uint32_t esp; |
| 97 | uint32_t ebx; |
| 98 | uint32_t edx; |
| 99 | uint32_t ecx; |
| 100 | uint32_t eax; |
| 101 | uint32_t trapno; |
| 102 | uint32_t err; |
| 103 | uint32_t eip; |
| 104 | uint16_t cs, __csh; |
| 105 | uint32_t eflags; |
| 106 | uint32_t esp_at_signal; |
| 107 | uint16_t ss, __ssh; |
| 108 | uint32_t i387; |
| 109 | uint32_t oldmask; |
| 110 | uint32_t cr2; |
| 111 | }; |
| 112 | struct i386_fpstate { |
| 113 | uint32_t cw; |
| 114 | uint32_t sw; |
| 115 | uint32_t tag; |
| 116 | uint32_t ipoff; |
| 117 | uint32_t cssel; |
| 118 | uint32_t dataoff; |
| 119 | uint32_t datasel; |
| 120 | uint8_t st[8][10]; /* 8*10 bytes: FP regs */ |
| 121 | uint16_t status; |
| 122 | uint16_t magic; |
| 123 | uint32_t fxsr_env[6]; |
| 124 | uint32_t mxcsr; |
| 125 | uint32_t reserved; |
| 126 | uint8_t stx[8][16]; /* 8*16 bytes: FP regs, each padded to 16 bytes */ |
| 127 | uint8_t xmm[8][16]; /* 8 XMM regs */ |
| 128 | uint32_t padding1[44]; |
| 129 | uint32_t padding2[12]; /* union with struct _fpx_sw_bytes */ |
| 130 | }; |
| 131 | #endif |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 132 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 133 | #ifndef NSIG |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 134 | # warning: NSIG is not defined, using 32 |
| 135 | # define NSIG 32 |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 136 | #endif |
| 137 | #ifdef ARM |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 138 | /* Ugh. Is this really correct? ARM has no RT signals?! */ |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 139 | # undef NSIG |
| 140 | # define NSIG 32 |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 141 | #endif |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 142 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 143 | #ifdef HAVE_SIGACTION |
| 144 | |
H.J. Lu | 35be581 | 2012-04-16 13:00:01 +0200 | [diff] [blame] | 145 | #if defined I386 || defined X86_64 || defined X32 |
Roland McGrath | 2638cb4 | 2002-12-15 23:58:41 +0000 | [diff] [blame] | 146 | /* The libc headers do not define this constant since it should only be |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 147 | used by the implementation. So we define it here. */ |
Roland McGrath | 2638cb4 | 2002-12-15 23:58:41 +0000 | [diff] [blame] | 148 | # ifndef SA_RESTORER |
| 149 | # define SA_RESTORER 0x04000000 |
| 150 | # endif |
| 151 | #endif |
| 152 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 153 | static const struct xlat sigact_flags[] = { |
Wichert Akkerman | c792698 | 2000-04-10 22:22:31 +0000 | [diff] [blame] | 154 | #ifdef SA_RESTORER |
| 155 | { SA_RESTORER, "SA_RESTORER" }, |
| 156 | #endif |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 157 | #ifdef SA_STACK |
| 158 | { SA_STACK, "SA_STACK" }, |
| 159 | #endif |
| 160 | #ifdef SA_RESTART |
| 161 | { SA_RESTART, "SA_RESTART" }, |
| 162 | #endif |
| 163 | #ifdef SA_INTERRUPT |
| 164 | { SA_INTERRUPT, "SA_INTERRUPT" }, |
| 165 | #endif |
Roland McGrath | 4fef51d | 2008-07-18 01:02:41 +0000 | [diff] [blame] | 166 | #ifdef SA_NODEFER |
| 167 | { SA_NODEFER, "SA_NODEFER" }, |
| 168 | #endif |
| 169 | #if defined SA_NOMASK && SA_NODEFER != SA_NOMASK |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 170 | { SA_NOMASK, "SA_NOMASK" }, |
| 171 | #endif |
Roland McGrath | 4fef51d | 2008-07-18 01:02:41 +0000 | [diff] [blame] | 172 | #ifdef SA_RESETHAND |
| 173 | { SA_RESETHAND, "SA_RESETHAND" }, |
| 174 | #endif |
| 175 | #if defined SA_ONESHOT && SA_ONESHOT != SA_RESETHAND |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 176 | { SA_ONESHOT, "SA_ONESHOT" }, |
| 177 | #endif |
| 178 | #ifdef SA_SIGINFO |
| 179 | { SA_SIGINFO, "SA_SIGINFO" }, |
| 180 | #endif |
| 181 | #ifdef SA_RESETHAND |
| 182 | { SA_RESETHAND, "SA_RESETHAND" }, |
| 183 | #endif |
| 184 | #ifdef SA_ONSTACK |
| 185 | { SA_ONSTACK, "SA_ONSTACK" }, |
| 186 | #endif |
| 187 | #ifdef SA_NODEFER |
| 188 | { SA_NODEFER, "SA_NODEFER" }, |
| 189 | #endif |
| 190 | #ifdef SA_NOCLDSTOP |
| 191 | { SA_NOCLDSTOP, "SA_NOCLDSTOP" }, |
| 192 | #endif |
| 193 | #ifdef SA_NOCLDWAIT |
| 194 | { SA_NOCLDWAIT, "SA_NOCLDWAIT" }, |
| 195 | #endif |
| 196 | #ifdef _SA_BSDCALL |
| 197 | { _SA_BSDCALL, "_SA_BSDCALL" }, |
| 198 | #endif |
Chris Metcalf | c8c6698 | 2009-12-28 10:00:15 -0500 | [diff] [blame] | 199 | #ifdef SA_NOPTRACE |
| 200 | { SA_NOPTRACE, "SA_NOPTRACE" }, |
| 201 | #endif |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 202 | { 0, NULL }, |
| 203 | }; |
| 204 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 205 | static const struct xlat sigprocmaskcmds[] = { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 206 | { SIG_BLOCK, "SIG_BLOCK" }, |
| 207 | { SIG_UNBLOCK, "SIG_UNBLOCK" }, |
| 208 | { SIG_SETMASK, "SIG_SETMASK" }, |
| 209 | #ifdef SIG_SETMASK32 |
| 210 | { SIG_SETMASK32,"SIG_SETMASK32" }, |
| 211 | #endif |
| 212 | { 0, NULL }, |
| 213 | }; |
| 214 | |
| 215 | #endif /* HAVE_SIGACTION */ |
| 216 | |
Nate Sammons | ce780fc | 1999-03-29 23:23:13 +0000 | [diff] [blame] | 217 | /* Anonymous realtime signals. */ |
| 218 | /* Under glibc 2.1, SIGRTMIN et al are functions, but __SIGRTMIN is a |
| 219 | constant. This is what we want. Otherwise, just use SIGRTMIN. */ |
| 220 | #ifdef SIGRTMIN |
| 221 | #ifndef __SIGRTMIN |
| 222 | #define __SIGRTMIN SIGRTMIN |
| 223 | #define __SIGRTMAX SIGRTMAX /* likewise */ |
| 224 | #endif |
| 225 | #endif |
| 226 | |
Denys Vlasenko | d9560c1 | 2011-08-19 17:41:28 +0200 | [diff] [blame] | 227 | /* Note on the size of sigset_t: |
| 228 | * |
| 229 | * In glibc, sigset_t is an array with space for 1024 bits (!), |
| 230 | * even though all arches supported by Linux have only 64 signals |
| 231 | * except MIPS, which has 128. IOW, it is 128 bytes long. |
| 232 | * |
| 233 | * In-kernel sigset_t is sized correctly (it is either 64 or 128 bit long). |
| 234 | * However, some old syscall return only 32 lower bits (one word). |
| 235 | * Example: sys_sigpending vs sys_rt_sigpending. |
| 236 | * |
| 237 | * Be aware of this fact when you try to |
| 238 | * memcpy(&tcp->u_arg[1], &something, sizeof(sigset_t)) |
| 239 | * - sizeof(sigset_t) is much bigger than you think, |
| 240 | * it may overflow tcp->u_arg[] array, and it may try to copy more data |
| 241 | * than is really available in <something>. |
| 242 | * Similarly, |
| 243 | * umoven(tcp, addr, sizeof(sigset_t), &sigset) |
| 244 | * may be a bad idea: it'll try to read much more data than needed |
| 245 | * to fetch a sigset_t. |
| 246 | * Use (NSIG / 8) as a size instead. |
| 247 | */ |
| 248 | |
Roland McGrath | ee36ce1 | 2004-09-04 03:53:10 +0000 | [diff] [blame] | 249 | const char * |
Denys Vlasenko | eccc48c | 2011-06-09 01:28:11 +0200 | [diff] [blame] | 250 | signame(int sig) |
Nate Sammons | ce780fc | 1999-03-29 23:23:13 +0000 | [diff] [blame] | 251 | { |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 252 | static char buf[sizeof("SIGRT_%d") + sizeof(int)*3]; |
| 253 | |
| 254 | if (sig >= 0 && sig < nsignals) |
Nate Sammons | ce780fc | 1999-03-29 23:23:13 +0000 | [diff] [blame] | 255 | return signalent[sig]; |
| 256 | #ifdef SIGRTMIN |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 257 | if (sig >= __SIGRTMIN && sig <= __SIGRTMAX) { |
| 258 | sprintf(buf, "SIGRT_%d", (int)(sig - __SIGRTMIN)); |
Nate Sammons | ce780fc | 1999-03-29 23:23:13 +0000 | [diff] [blame] | 259 | return buf; |
| 260 | } |
Denys Vlasenko | 041b3ee | 2011-08-18 12:48:56 +0200 | [diff] [blame] | 261 | #endif |
| 262 | sprintf(buf, "%d", sig); |
| 263 | return buf; |
Nate Sammons | ce780fc | 1999-03-29 23:23:13 +0000 | [diff] [blame] | 264 | } |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 265 | |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 266 | static void |
Denys Vlasenko | eccc48c | 2011-06-09 01:28:11 +0200 | [diff] [blame] | 267 | long_to_sigset(long l, sigset_t *s) |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 268 | { |
| 269 | sigemptyset(s); |
| 270 | *(long *)s = l; |
| 271 | } |
| 272 | |
| 273 | static int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 274 | copy_sigset_len(struct tcb *tcp, long addr, sigset_t *s, int len) |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 275 | { |
| 276 | if (len > sizeof(*s)) |
| 277 | len = sizeof(*s); |
| 278 | sigemptyset(s); |
| 279 | if (umoven(tcp, addr, len, (char *)s) < 0) |
| 280 | return -1; |
| 281 | return 0; |
| 282 | } |
| 283 | |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 284 | /* Original sigset is unsigned long */ |
| 285 | #define copy_sigset(tcp, addr, s) copy_sigset_len(tcp, addr, s, sizeof(long)) |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 286 | |
Dmitry V. Levin | ab9008b | 2007-01-11 22:05:04 +0000 | [diff] [blame] | 287 | static const char * |
| 288 | sprintsigmask(const char *str, sigset_t *mask, int rt) |
| 289 | /* set might include realtime sigs */ |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 290 | { |
Denys Vlasenko | d9560c1 | 2011-08-19 17:41:28 +0200 | [diff] [blame] | 291 | /* Was [8 * sizeof(sigset_t) * 8], but |
| 292 | * glibc sigset_t is huge (1024 bits = 128 *bytes*), |
| 293 | * and we were ending up with 8k (!) buffer here. |
| 294 | * |
| 295 | * No Unix system can have sig > 255 |
| 296 | * (waitpid API won't be able to indicate death from one) |
| 297 | * and sig 0 doesn't exist either. |
| 298 | * Therefore max possible no of sigs is 255: 1..255 |
| 299 | */ |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 300 | static char outstr[8 * (255 * 2 / 3)]; |
Denys Vlasenko | d9560c1 | 2011-08-19 17:41:28 +0200 | [diff] [blame] | 301 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 302 | int i, nsigs; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 303 | int maxsigs; |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 304 | int show_members; |
| 305 | char sep; |
Dmitry V. Levin | 30145dd | 2010-09-06 22:08:24 +0000 | [diff] [blame] | 306 | char *s; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 307 | |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 308 | /* Note: nsignals = ARRAY_SIZE(signalent[]), |
| 309 | * and that array may not have SIGRTnn. |
| 310 | */ |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 311 | maxsigs = nsignals; |
| 312 | #ifdef __SIGRTMAX |
| 313 | if (rt) |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 314 | maxsigs = __SIGRTMAX + 1; /* instead */ |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 315 | #endif |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 316 | s = stpcpy(outstr, str); |
| 317 | nsigs = 0; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 318 | for (i = 1; i < maxsigs; i++) { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 319 | if (sigismember(mask, i) == 1) |
| 320 | nsigs++; |
| 321 | } |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 322 | |
| 323 | /* 1: show mask members, 0: show those which are NOT in mask */ |
| 324 | show_members = (nsigs < nsignals * 2 / 3); |
| 325 | if (!show_members) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 326 | *s++ = '~'; |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 327 | |
| 328 | sep = '['; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 329 | for (i = 1; i < maxsigs; i++) { |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 330 | if (sigismember(mask, i) == show_members) { |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 331 | *s++ = sep; |
John Hughes | bdf48f5 | 2001-03-06 15:08:09 +0000 | [diff] [blame] | 332 | if (i < nsignals) { |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 333 | s = stpcpy(s, signalent[i] + 3); |
John Hughes | bdf48f5 | 2001-03-06 15:08:09 +0000 | [diff] [blame] | 334 | } |
Roland McGrath | 90b4cb5 | 2003-09-23 22:19:32 +0000 | [diff] [blame] | 335 | #ifdef SIGRTMIN |
| 336 | else if (i >= __SIGRTMIN && i <= __SIGRTMAX) { |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 337 | s += sprintf(s, "RT_%u", i - __SIGRTMIN); |
Roland McGrath | 90b4cb5 | 2003-09-23 22:19:32 +0000 | [diff] [blame] | 338 | } |
| 339 | #endif /* SIGRTMIN */ |
John Hughes | bdf48f5 | 2001-03-06 15:08:09 +0000 | [diff] [blame] | 340 | else { |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 341 | s += sprintf(s, "%u", i); |
John Hughes | bdf48f5 | 2001-03-06 15:08:09 +0000 | [diff] [blame] | 342 | } |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 343 | sep = ' '; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 344 | } |
| 345 | } |
Denys Vlasenko | 4f3df07 | 2012-01-29 22:38:35 +0100 | [diff] [blame] | 346 | if (sep == '[') |
| 347 | *s++ = sep; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 348 | *s++ = ']'; |
| 349 | *s = '\0'; |
| 350 | return outstr; |
| 351 | } |
| 352 | |
| 353 | static void |
Denys Vlasenko | eccc48c | 2011-06-09 01:28:11 +0200 | [diff] [blame] | 354 | printsigmask(sigset_t *mask, int rt) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 355 | { |
Denys Vlasenko | 5940e65 | 2011-09-01 09:55:05 +0200 | [diff] [blame] | 356 | tprints(sprintsigmask("", mask, rt)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | void |
Denys Vlasenko | eccc48c | 2011-06-09 01:28:11 +0200 | [diff] [blame] | 360 | printsignal(int nr) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 361 | { |
Denys Vlasenko | 5940e65 | 2011-09-01 09:55:05 +0200 | [diff] [blame] | 362 | tprints(signame(nr)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 363 | } |
| 364 | |
Dmitry V. Levin | 95ebf5a | 2006-10-13 20:25:12 +0000 | [diff] [blame] | 365 | void |
| 366 | print_sigset(struct tcb *tcp, long addr, int rt) |
| 367 | { |
| 368 | sigset_t ss; |
| 369 | |
| 370 | if (!addr) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 371 | tprints("NULL"); |
Dmitry V. Levin | 95ebf5a | 2006-10-13 20:25:12 +0000 | [diff] [blame] | 372 | else if (copy_sigset(tcp, addr, &ss) < 0) |
| 373 | tprintf("%#lx", addr); |
| 374 | else |
| 375 | printsigmask(&ss, rt); |
| 376 | } |
| 377 | |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 378 | #ifndef ILL_ILLOPC |
| 379 | #define ILL_ILLOPC 1 /* illegal opcode */ |
| 380 | #define ILL_ILLOPN 2 /* illegal operand */ |
| 381 | #define ILL_ILLADR 3 /* illegal addressing mode */ |
| 382 | #define ILL_ILLTRP 4 /* illegal trap */ |
| 383 | #define ILL_PRVOPC 5 /* privileged opcode */ |
| 384 | #define ILL_PRVREG 6 /* privileged register */ |
| 385 | #define ILL_COPROC 7 /* coprocessor error */ |
| 386 | #define ILL_BADSTK 8 /* internal stack error */ |
| 387 | #define FPE_INTDIV 1 /* integer divide by zero */ |
| 388 | #define FPE_INTOVF 2 /* integer overflow */ |
| 389 | #define FPE_FLTDIV 3 /* floating point divide by zero */ |
| 390 | #define FPE_FLTOVF 4 /* floating point overflow */ |
| 391 | #define FPE_FLTUND 5 /* floating point underflow */ |
| 392 | #define FPE_FLTRES 6 /* floating point inexact result */ |
| 393 | #define FPE_FLTINV 7 /* floating point invalid operation */ |
| 394 | #define FPE_FLTSUB 8 /* subscript out of range */ |
| 395 | #define SEGV_MAPERR 1 /* address not mapped to object */ |
| 396 | #define SEGV_ACCERR 2 /* invalid permissions for mapped object */ |
| 397 | #define BUS_ADRALN 1 /* invalid address alignment */ |
| 398 | #define BUS_ADRERR 2 /* non-existant physical address */ |
| 399 | #define BUS_OBJERR 3 /* object specific hardware error */ |
| 400 | #define TRAP_BRKPT 1 /* process breakpoint */ |
| 401 | #define TRAP_TRACE 2 /* process trace trap */ |
| 402 | #define CLD_EXITED 1 /* child has exited */ |
| 403 | #define CLD_KILLED 2 /* child was killed */ |
| 404 | #define CLD_DUMPED 3 /* child terminated abnormally */ |
| 405 | #define CLD_TRAPPED 4 /* traced child has trapped */ |
| 406 | #define CLD_STOPPED 5 /* child has stopped */ |
| 407 | #define CLD_CONTINUED 6 /* stopped child has continued */ |
| 408 | #define POLL_IN 1 /* data input available */ |
| 409 | #define POLL_OUT 2 /* output buffers available */ |
| 410 | #define POLL_MSG 3 /* input message available */ |
| 411 | #define POLL_ERR 4 /* i/o error */ |
| 412 | #define POLL_PRI 5 /* high priority input available */ |
| 413 | #define POLL_HUP 6 /* device disconnected */ |
Dmitry V. Levin | 7d4bff1 | 2011-03-10 21:41:34 +0000 | [diff] [blame] | 414 | #define SI_KERNEL 0x80 /* sent by kernel */ |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 415 | #define SI_USER 0 /* sent by kill, sigsend, raise */ |
| 416 | #define SI_QUEUE -1 /* sent by sigqueue */ |
| 417 | #define SI_TIMER -2 /* sent by timer expiration */ |
| 418 | #define SI_MESGQ -3 /* sent by real time mesq state change */ |
| 419 | #define SI_ASYNCIO -4 /* sent by AIO completion */ |
Dmitry V. Levin | 7d4bff1 | 2011-03-10 21:41:34 +0000 | [diff] [blame] | 420 | #define SI_SIGIO -5 /* sent by SIGIO */ |
| 421 | #define SI_TKILL -6 /* sent by tkill */ |
| 422 | #define SI_ASYNCNL -60 /* sent by asynch name lookup completion */ |
Denys Vlasenko | 2c4fb90 | 2012-03-15 17:24:49 +0100 | [diff] [blame] | 423 | #endif |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 424 | |
Denys Vlasenko | 2c4fb90 | 2012-03-15 17:24:49 +0100 | [diff] [blame] | 425 | #ifndef SI_FROMUSER |
| 426 | # define SI_FROMUSER(sip) ((sip)->si_code <= 0) |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 427 | #endif |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 428 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 429 | static const struct xlat siginfo_codes[] = { |
Dmitry V. Levin | 7d4bff1 | 2011-03-10 21:41:34 +0000 | [diff] [blame] | 430 | #ifdef SI_KERNEL |
| 431 | { SI_KERNEL, "SI_KERNEL" }, |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 432 | #endif |
| 433 | #ifdef SI_USER |
| 434 | { SI_USER, "SI_USER" }, |
| 435 | #endif |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 436 | #ifdef SI_QUEUE |
| 437 | { SI_QUEUE, "SI_QUEUE" }, |
| 438 | #endif |
| 439 | #ifdef SI_TIMER |
| 440 | { SI_TIMER, "SI_TIMER" }, |
| 441 | #endif |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 442 | #ifdef SI_MESGQ |
| 443 | { SI_MESGQ, "SI_MESGQ" }, |
| 444 | #endif |
Dmitry V. Levin | 7d4bff1 | 2011-03-10 21:41:34 +0000 | [diff] [blame] | 445 | #ifdef SI_ASYNCIO |
| 446 | { SI_ASYNCIO, "SI_ASYNCIO" }, |
| 447 | #endif |
Roland McGrath | 941b740 | 2003-05-23 00:29:02 +0000 | [diff] [blame] | 448 | #ifdef SI_SIGIO |
| 449 | { SI_SIGIO, "SI_SIGIO" }, |
| 450 | #endif |
| 451 | #ifdef SI_TKILL |
| 452 | { SI_TKILL, "SI_TKILL" }, |
| 453 | #endif |
Dmitry V. Levin | 7d4bff1 | 2011-03-10 21:41:34 +0000 | [diff] [blame] | 454 | #ifdef SI_ASYNCNL |
| 455 | { SI_ASYNCNL, "SI_ASYNCNL" }, |
| 456 | #endif |
| 457 | #ifdef SI_NOINFO |
| 458 | { SI_NOINFO, "SI_NOINFO" }, |
| 459 | #endif |
| 460 | #ifdef SI_LWP |
| 461 | { SI_LWP, "SI_LWP" }, |
| 462 | #endif |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 463 | { 0, NULL }, |
| 464 | }; |
| 465 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 466 | static const struct xlat sigill_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 467 | { ILL_ILLOPC, "ILL_ILLOPC" }, |
| 468 | { ILL_ILLOPN, "ILL_ILLOPN" }, |
| 469 | { ILL_ILLADR, "ILL_ILLADR" }, |
| 470 | { ILL_ILLTRP, "ILL_ILLTRP" }, |
| 471 | { ILL_PRVOPC, "ILL_PRVOPC" }, |
| 472 | { ILL_PRVREG, "ILL_PRVREG" }, |
| 473 | { ILL_COPROC, "ILL_COPROC" }, |
| 474 | { ILL_BADSTK, "ILL_BADSTK" }, |
| 475 | { 0, NULL }, |
| 476 | }; |
| 477 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 478 | static const struct xlat sigfpe_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 479 | { FPE_INTDIV, "FPE_INTDIV" }, |
| 480 | { FPE_INTOVF, "FPE_INTOVF" }, |
| 481 | { FPE_FLTDIV, "FPE_FLTDIV" }, |
| 482 | { FPE_FLTOVF, "FPE_FLTOVF" }, |
| 483 | { FPE_FLTUND, "FPE_FLTUND" }, |
| 484 | { FPE_FLTRES, "FPE_FLTRES" }, |
| 485 | { FPE_FLTINV, "FPE_FLTINV" }, |
| 486 | { FPE_FLTSUB, "FPE_FLTSUB" }, |
| 487 | { 0, NULL }, |
| 488 | }; |
| 489 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 490 | static const struct xlat sigtrap_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 491 | { TRAP_BRKPT, "TRAP_BRKPT" }, |
| 492 | { TRAP_TRACE, "TRAP_TRACE" }, |
| 493 | { 0, NULL }, |
| 494 | }; |
| 495 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 496 | static const struct xlat sigchld_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 497 | { CLD_EXITED, "CLD_EXITED" }, |
| 498 | { CLD_KILLED, "CLD_KILLED" }, |
| 499 | { CLD_DUMPED, "CLD_DUMPED" }, |
| 500 | { CLD_TRAPPED, "CLD_TRAPPED" }, |
| 501 | { CLD_STOPPED, "CLD_STOPPED" }, |
| 502 | { CLD_CONTINUED,"CLD_CONTINUED" }, |
| 503 | { 0, NULL }, |
| 504 | }; |
| 505 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 506 | static const struct xlat sigpoll_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 507 | { POLL_IN, "POLL_IN" }, |
| 508 | { POLL_OUT, "POLL_OUT" }, |
| 509 | { POLL_MSG, "POLL_MSG" }, |
| 510 | { POLL_ERR, "POLL_ERR" }, |
| 511 | { POLL_PRI, "POLL_PRI" }, |
| 512 | { POLL_HUP, "POLL_HUP" }, |
| 513 | { 0, NULL }, |
| 514 | }; |
| 515 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 516 | static const struct xlat sigprof_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 517 | #ifdef PROF_SIG |
| 518 | { PROF_SIG, "PROF_SIG" }, |
| 519 | #endif |
| 520 | { 0, NULL }, |
| 521 | }; |
| 522 | |
| 523 | #ifdef SIGEMT |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 524 | static const struct xlat sigemt_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 525 | #ifdef EMT_TAGOVF |
| 526 | { EMT_TAGOVF, "EMT_TAGOVF" }, |
| 527 | #endif |
| 528 | { 0, NULL }, |
| 529 | }; |
| 530 | #endif |
| 531 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 532 | static const struct xlat sigsegv_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 533 | { SEGV_MAPERR, "SEGV_MAPERR" }, |
| 534 | { SEGV_ACCERR, "SEGV_ACCERR" }, |
| 535 | { 0, NULL }, |
| 536 | }; |
| 537 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 538 | static const struct xlat sigbus_codes[] = { |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 539 | { BUS_ADRALN, "BUS_ADRALN" }, |
| 540 | { BUS_ADRERR, "BUS_ADRERR" }, |
| 541 | { BUS_OBJERR, "BUS_OBJERR" }, |
| 542 | { 0, NULL }, |
| 543 | }; |
| 544 | |
| 545 | void |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 546 | printsiginfo(siginfo_t *sip, int verbose) |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 547 | { |
Roland McGrath | f9c49b2 | 2004-10-06 22:11:54 +0000 | [diff] [blame] | 548 | const char *code; |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 549 | |
| 550 | if (sip->si_signo == 0) { |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 551 | tprints("{}"); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 552 | return; |
| 553 | } |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 554 | tprints("{si_signo="); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 555 | printsignal(sip->si_signo); |
| 556 | code = xlookup(siginfo_codes, sip->si_code); |
| 557 | if (!code) { |
| 558 | switch (sip->si_signo) { |
| 559 | case SIGTRAP: |
| 560 | code = xlookup(sigtrap_codes, sip->si_code); |
| 561 | break; |
| 562 | case SIGCHLD: |
| 563 | code = xlookup(sigchld_codes, sip->si_code); |
| 564 | break; |
| 565 | case SIGPOLL: |
| 566 | code = xlookup(sigpoll_codes, sip->si_code); |
| 567 | break; |
| 568 | case SIGPROF: |
| 569 | code = xlookup(sigprof_codes, sip->si_code); |
| 570 | break; |
| 571 | case SIGILL: |
| 572 | code = xlookup(sigill_codes, sip->si_code); |
| 573 | break; |
| 574 | #ifdef SIGEMT |
| 575 | case SIGEMT: |
| 576 | code = xlookup(sigemt_codes, sip->si_code); |
| 577 | break; |
| 578 | #endif |
| 579 | case SIGFPE: |
| 580 | code = xlookup(sigfpe_codes, sip->si_code); |
| 581 | break; |
| 582 | case SIGSEGV: |
| 583 | code = xlookup(sigsegv_codes, sip->si_code); |
| 584 | break; |
| 585 | case SIGBUS: |
| 586 | code = xlookup(sigbus_codes, sip->si_code); |
| 587 | break; |
| 588 | } |
| 589 | } |
| 590 | if (code) |
| 591 | tprintf(", si_code=%s", code); |
| 592 | else |
| 593 | tprintf(", si_code=%#x", sip->si_code); |
| 594 | #ifdef SI_NOINFO |
| 595 | if (sip->si_code != SI_NOINFO) |
| 596 | #endif |
| 597 | { |
| 598 | if (sip->si_errno) { |
| 599 | if (sip->si_errno < 0 || sip->si_errno >= nerrnos) |
| 600 | tprintf(", si_errno=%d", sip->si_errno); |
| 601 | else |
| 602 | tprintf(", si_errno=%s", |
| 603 | errnoent[sip->si_errno]); |
| 604 | } |
| 605 | #ifdef SI_FROMUSER |
| 606 | if (SI_FROMUSER(sip)) { |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 607 | tprintf(", si_pid=%lu, si_uid=%lu", |
| 608 | (unsigned long) sip->si_pid, |
| 609 | (unsigned long) sip->si_uid); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 610 | switch (sip->si_code) { |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 611 | #ifdef SI_USER |
| 612 | case SI_USER: |
| 613 | break; |
| 614 | #endif |
| 615 | #ifdef SI_TKILL |
| 616 | case SI_TKILL: |
| 617 | break; |
| 618 | #endif |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 619 | #ifdef SI_TIMER |
| 620 | case SI_TIMER: |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 621 | tprintf(", si_value=%d", sip->si_int); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 622 | break; |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 623 | #endif |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 624 | default: |
Dmitry V. Levin | b41e1c9 | 2011-03-10 23:14:47 +0000 | [diff] [blame] | 625 | if (!sip->si_ptr) |
| 626 | break; |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 627 | if (!verbose) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 628 | tprints(", ..."); |
Dmitry V. Levin | 6d9e8e8 | 2011-03-10 22:18:56 +0000 | [diff] [blame] | 629 | else |
| 630 | tprintf(", si_value={int=%u, ptr=%#lx}", |
| 631 | sip->si_int, |
| 632 | (unsigned long) sip->si_ptr); |
| 633 | break; |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 634 | } |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 635 | } |
| 636 | else |
| 637 | #endif /* SI_FROMUSER */ |
| 638 | { |
| 639 | switch (sip->si_signo) { |
| 640 | case SIGCHLD: |
| 641 | tprintf(", si_pid=%ld, si_status=", |
| 642 | (long) sip->si_pid); |
| 643 | if (sip->si_code == CLD_EXITED) |
| 644 | tprintf("%d", sip->si_status); |
| 645 | else |
| 646 | printsignal(sip->si_status); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 647 | if (!verbose) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 648 | tprints(", ..."); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 649 | else |
H.J. Lu | 2bb4581 | 2012-04-15 11:17:13 -0700 | [diff] [blame] | 650 | tprintf(", si_utime=%llu, si_stime=%llu", |
| 651 | (unsigned long long) sip->si_utime, |
| 652 | (unsigned long long) sip->si_stime); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 653 | break; |
| 654 | case SIGILL: case SIGFPE: |
| 655 | case SIGSEGV: case SIGBUS: |
| 656 | tprintf(", si_addr=%#lx", |
| 657 | (unsigned long) sip->si_addr); |
| 658 | break; |
| 659 | case SIGPOLL: |
| 660 | switch (sip->si_code) { |
| 661 | case POLL_IN: case POLL_OUT: case POLL_MSG: |
| 662 | tprintf(", si_band=%ld", |
| 663 | (long) sip->si_band); |
| 664 | break; |
| 665 | } |
| 666 | break; |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 667 | default: |
Dmitry V. Levin | b41e1c9 | 2011-03-10 23:14:47 +0000 | [diff] [blame] | 668 | if (sip->si_pid || sip->si_uid) |
| 669 | tprintf(", si_pid=%lu, si_uid=%lu", |
| 670 | (unsigned long) sip->si_pid, |
| 671 | (unsigned long) sip->si_uid); |
| 672 | if (!sip->si_ptr) |
| 673 | break; |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 674 | if (!verbose) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 675 | tprints(", ..."); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 676 | else { |
Dmitry V. Levin | b41e1c9 | 2011-03-10 23:14:47 +0000 | [diff] [blame] | 677 | tprintf(", si_value={int=%u, ptr=%#lx}", |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 678 | sip->si_int, |
| 679 | (unsigned long) sip->si_ptr); |
| 680 | } |
Roland McGrath | a39c5a1 | 2002-12-17 05:10:37 +0000 | [diff] [blame] | 681 | |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 682 | } |
| 683 | } |
| 684 | } |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 685 | tprints("}"); |
John Hughes | 5826589 | 2001-10-18 15:13:53 +0000 | [diff] [blame] | 686 | } |
| 687 | |
Denys Vlasenko | d4d3ede | 2013-02-13 16:31:32 +0100 | [diff] [blame] | 688 | void |
| 689 | printsiginfo_at(struct tcb *tcp, long addr) |
| 690 | { |
| 691 | siginfo_t si; |
| 692 | if (!addr) { |
| 693 | tprints("NULL"); |
| 694 | return; |
| 695 | } |
| 696 | if (syserror(tcp)) { |
| 697 | tprintf("%#lx", addr); |
| 698 | return; |
| 699 | } |
| 700 | if (umove(tcp, addr, &si) < 0) { |
| 701 | tprints("{???}"); |
| 702 | return; |
| 703 | } |
| 704 | printsiginfo(&si, verbose(tcp)); |
| 705 | } |
| 706 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 707 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 708 | sys_sigsetmask(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 709 | { |
| 710 | if (entering(tcp)) { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 711 | sigset_t sigm; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 712 | long_to_sigset(tcp->u_arg[0], &sigm); |
| 713 | printsigmask(&sigm, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 714 | } |
| 715 | else if (!syserror(tcp)) { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 716 | sigset_t sigm; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 717 | long_to_sigset(tcp->u_rval, &sigm); |
| 718 | tcp->auxstr = sprintsigmask("old mask ", &sigm, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 719 | |
| 720 | return RVAL_HEX | RVAL_STR; |
| 721 | } |
| 722 | return 0; |
| 723 | } |
| 724 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 725 | #ifdef HAVE_SIGACTION |
| 726 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 727 | struct old_sigaction { |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 728 | /* sa_handler may be a libc #define, need to use other name: */ |
| 729 | void (*__sa_handler)(int); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 730 | unsigned long sa_mask; |
| 731 | unsigned long sa_flags; |
| 732 | void (*sa_restorer)(void); |
| 733 | }; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 734 | |
| 735 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 736 | sys_sigaction(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 737 | { |
| 738 | long addr; |
John Hughes | 1e4cb34 | 2001-03-06 09:25:46 +0000 | [diff] [blame] | 739 | sigset_t sigset; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 740 | struct old_sigaction sa; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 741 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 742 | if (entering(tcp)) { |
| 743 | printsignal(tcp->u_arg[0]); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 744 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 745 | addr = tcp->u_arg[1]; |
| 746 | } else |
| 747 | addr = tcp->u_arg[2]; |
| 748 | if (addr == 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 749 | tprints("NULL"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 750 | else if (!verbose(tcp)) |
| 751 | tprintf("%#lx", addr); |
| 752 | else if (umove(tcp, addr, &sa) < 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 753 | tprints("{...}"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 754 | else { |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 755 | /* Architectures using function pointers, like |
| 756 | * hppa, may need to manipulate the function pointer |
| 757 | * to compute the result of a comparison. However, |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 758 | * the __sa_handler function pointer exists only in |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 759 | * the address space of the traced process, and can't |
| 760 | * be manipulated by strace. In order to prevent the |
| 761 | * compiler from generating code to manipulate |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 762 | * __sa_handler we cast the function pointers to long. */ |
| 763 | if ((long)sa.__sa_handler == (long)SIG_ERR) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 764 | tprints("{SIG_ERR, "); |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 765 | else if ((long)sa.__sa_handler == (long)SIG_DFL) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 766 | tprints("{SIG_DFL, "); |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 767 | else if ((long)sa.__sa_handler == (long)SIG_IGN) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 768 | tprints("{SIG_IGN, "); |
Denys Vlasenko | 023b770 | 2012-01-18 16:30:47 +0100 | [diff] [blame] | 769 | else |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 770 | tprintf("{%#lx, ", (long) sa.__sa_handler); |
Denys Vlasenko | bbe29b3 | 2012-01-18 15:30:56 +0100 | [diff] [blame] | 771 | long_to_sigset(sa.sa_mask, &sigset); |
| 772 | printsigmask(&sigset, 0); |
Denys Vlasenko | bbe29b3 | 2012-01-18 15:30:56 +0100 | [diff] [blame] | 773 | tprints(", "); |
| 774 | printflags(sigact_flags, sa.sa_flags, "SA_???"); |
| 775 | #ifdef SA_RESTORER |
| 776 | if (sa.sa_flags & SA_RESTORER) |
| 777 | tprintf(", %p", sa.sa_restorer); |
| 778 | #endif |
| 779 | tprints("}"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 780 | } |
| 781 | if (entering(tcp)) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 782 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 783 | else |
| 784 | tprintf(", %#lx", (unsigned long) sa.sa_restorer); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 785 | return 0; |
| 786 | } |
| 787 | |
| 788 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 789 | sys_signal(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 790 | { |
| 791 | if (entering(tcp)) { |
| 792 | printsignal(tcp->u_arg[0]); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 793 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 794 | switch (tcp->u_arg[1]) { |
Jan Kratochvil | 1f94271 | 2008-08-06 21:38:52 +0000 | [diff] [blame] | 795 | case (long) SIG_ERR: |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 796 | tprints("SIG_ERR"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 797 | break; |
Jan Kratochvil | 1f94271 | 2008-08-06 21:38:52 +0000 | [diff] [blame] | 798 | case (long) SIG_DFL: |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 799 | tprints("SIG_DFL"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 800 | break; |
Jan Kratochvil | 1f94271 | 2008-08-06 21:38:52 +0000 | [diff] [blame] | 801 | case (long) SIG_IGN: |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 802 | tprints("SIG_IGN"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 803 | break; |
| 804 | default: |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 805 | tprintf("%#lx", tcp->u_arg[1]); |
| 806 | } |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 807 | return 0; |
| 808 | } |
Dmitry V. Levin | 21a7534 | 2008-09-03 01:22:18 +0000 | [diff] [blame] | 809 | else if (!syserror(tcp)) { |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 810 | switch (tcp->u_rval) { |
Denys Vlasenko | 989ebc9 | 2012-03-17 04:42:07 +0100 | [diff] [blame] | 811 | case (long) SIG_ERR: |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 812 | tcp->auxstr = "SIG_ERR"; break; |
Denys Vlasenko | 989ebc9 | 2012-03-17 04:42:07 +0100 | [diff] [blame] | 813 | case (long) SIG_DFL: |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 814 | tcp->auxstr = "SIG_DFL"; break; |
Denys Vlasenko | 989ebc9 | 2012-03-17 04:42:07 +0100 | [diff] [blame] | 815 | case (long) SIG_IGN: |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 816 | tcp->auxstr = "SIG_IGN"; break; |
Denys Vlasenko | 989ebc9 | 2012-03-17 04:42:07 +0100 | [diff] [blame] | 817 | default: |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 818 | tcp->auxstr = NULL; |
| 819 | } |
| 820 | return RVAL_HEX | RVAL_STR; |
| 821 | } |
Dmitry V. Levin | 21a7534 | 2008-09-03 01:22:18 +0000 | [diff] [blame] | 822 | return 0; |
Wichert Akkerman | 16a03d2 | 2000-08-10 02:14:04 +0000 | [diff] [blame] | 823 | } |
| 824 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 825 | #endif /* HAVE_SIGACTION */ |
| 826 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 827 | int |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 828 | sys_sigreturn(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 829 | { |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 830 | #if defined(ARM) |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 831 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 832 | struct sigcontext_struct sc; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 833 | sigset_t sigm; |
Denys Vlasenko | 401374e | 2013-02-06 18:24:39 +0100 | [diff] [blame] | 834 | if (umove(tcp, arm_regs.ARM_sp, &sc) < 0) |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 835 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 836 | long_to_sigset(sc.oldmask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 837 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 838 | } |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 839 | #elif defined(S390) || defined(S390X) |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 840 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 841 | long usp; |
| 842 | struct sigcontext_struct sc; |
Denys Vlasenko | 752e5a0 | 2013-06-28 14:35:47 +0200 | [diff] [blame] | 843 | if (upeek(tcp->pid, PT_GPR15, &usp) < 0) |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 844 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 845 | if (umove(tcp, usp + __SIGNAL_FRAMESIZE, &sc) < 0) |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 846 | return 0; |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 847 | tprints(sprintsigmask(") (mask ", (sigset_t *)&sc.oldmask[0], 0)); |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 848 | } |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 849 | #elif defined(I386) || defined(X86_64) |
| 850 | # if defined(X86_64) |
| 851 | if (current_personality == 0) /* 64-bit */ |
| 852 | return 0; |
| 853 | # endif |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 854 | if (entering(tcp)) { |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 855 | struct { |
| 856 | struct i386_sigcontext_struct sc; |
| 857 | struct i386_fpstate fp; |
| 858 | uint32_t extramask[1]; |
| 859 | } signal_stack; |
| 860 | /* On i386, sc is followed on stack by struct fpstate |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 861 | * and after it an additional u32 extramask[1] which holds |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 862 | * upper half of the mask. |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 863 | */ |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 864 | sigset_t sigm; |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 865 | if (umove(tcp, *i386_esp_ptr, &signal_stack) < 0) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 866 | return 0; |
Denys Vlasenko | b51f364 | 2013-07-16 12:06:25 +0200 | [diff] [blame^] | 867 | sigemptyset(&sigm); |
| 868 | ((uint32_t*)&sigm)[0] = signal_stack.sc.oldmask; |
| 869 | ((uint32_t*)&sigm)[1] = signal_stack.extramask[0]; |
| 870 | tprints(sprintsigmask(") (mask ", &sigm, /*RT sigs too?:*/ 1)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 871 | } |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 872 | #elif defined(IA64) |
Wichert Akkerman | 8b1b40c | 2000-02-03 21:58:30 +0000 | [diff] [blame] | 873 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 874 | struct sigcontext sc; |
| 875 | long sp; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 876 | sigset_t sigm; |
Wichert Akkerman | 5ae21ea | 2000-05-01 01:53:59 +0000 | [diff] [blame] | 877 | /* offset of sigcontext in the kernel's sigframe structure: */ |
| 878 | # define SIGFRAME_SC_OFFSET 0x90 |
Denys Vlasenko | 752e5a0 | 2013-06-28 14:35:47 +0200 | [diff] [blame] | 879 | if (upeek(tcp->pid, PT_R12, &sp) < 0) |
Wichert Akkerman | 8b1b40c | 2000-02-03 21:58:30 +0000 | [diff] [blame] | 880 | return 0; |
Wichert Akkerman | 5ae21ea | 2000-05-01 01:53:59 +0000 | [diff] [blame] | 881 | if (umove(tcp, sp + 16 + SIGFRAME_SC_OFFSET, &sc) < 0) |
Wichert Akkerman | 8b1b40c | 2000-02-03 21:58:30 +0000 | [diff] [blame] | 882 | return 0; |
Denys Vlasenko | d9560c1 | 2011-08-19 17:41:28 +0200 | [diff] [blame] | 883 | sigemptyset(&sigm); |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 884 | memcpy(&sigm, &sc.sc_mask, NSIG / 8); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 885 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Wichert Akkerman | 8b1b40c | 2000-02-03 21:58:30 +0000 | [diff] [blame] | 886 | } |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 887 | #elif defined(POWERPC) |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 888 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 889 | long esp; |
| 890 | struct sigcontext_struct sc; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 891 | sigset_t sigm; |
Anton Blanchard | ce6e33b | 2013-06-26 15:53:33 +0200 | [diff] [blame] | 892 | |
| 893 | esp = ppc_regs.gpr[1]; |
| 894 | |
Andreas Schwab | edb3934 | 2010-02-23 00:18:51 +0100 | [diff] [blame] | 895 | /* Skip dummy stack frame. */ |
Andreas Schwab | d69fa49 | 2010-07-12 21:39:57 +0200 | [diff] [blame] | 896 | #ifdef POWERPC64 |
| 897 | if (current_personality == 0) |
| 898 | esp += 128; |
| 899 | else |
| 900 | esp += 64; |
Andreas Schwab | edb3934 | 2010-02-23 00:18:51 +0100 | [diff] [blame] | 901 | #else |
| 902 | esp += 64; |
| 903 | #endif |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 904 | if (umove(tcp, esp, &sc) < 0) |
| 905 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 906 | long_to_sigset(sc.oldmask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 907 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 908 | } |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 909 | #elif defined(M68K) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 910 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 911 | long usp; |
| 912 | struct sigcontext sc; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 913 | sigset_t sigm; |
Denys Vlasenko | 752e5a0 | 2013-06-28 14:35:47 +0200 | [diff] [blame] | 914 | if (upeek(tcp->pid, 4*PT_USP, &usp) < 0) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 915 | return 0; |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 916 | if (umove(tcp, usp, &sc) < 0) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 917 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 918 | long_to_sigset(sc.sc_mask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 919 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 920 | } |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 921 | #elif defined(ALPHA) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 922 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 923 | long fp; |
| 924 | struct sigcontext_struct sc; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 925 | sigset_t sigm; |
Denys Vlasenko | 752e5a0 | 2013-06-28 14:35:47 +0200 | [diff] [blame] | 926 | if (upeek(tcp->pid, REG_FP, &fp) < 0) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 927 | return 0; |
Roland McGrath | 0f87c49 | 2003-06-03 23:29:04 +0000 | [diff] [blame] | 928 | if (umove(tcp, fp, &sc) < 0) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 929 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 930 | long_to_sigset(sc.sc_mask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 931 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 932 | } |
Denys Vlasenko | c36c352 | 2012-02-25 02:47:15 +0100 | [diff] [blame] | 933 | #elif defined(SPARC) || defined(SPARC64) |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 934 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 935 | long i1; |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 936 | m_siginfo_t si; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 937 | sigset_t sigm; |
Denys Vlasenko | 48e4c1b | 2013-02-16 08:23:40 +0100 | [diff] [blame] | 938 | i1 = sparc_regs.u_regs[U_REG_O1]; |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 939 | if (umove(tcp, i1, &si) < 0) { |
Denys Vlasenko | 905e8e0 | 2013-02-26 12:30:09 +0100 | [diff] [blame] | 940 | perror_msg("sigreturn: umove"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 941 | return 0; |
| 942 | } |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 943 | long_to_sigset(si.si_mask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 944 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 945 | } |
Denys Vlasenko | c36c352 | 2012-02-25 02:47:15 +0100 | [diff] [blame] | 946 | #elif defined(LINUX_MIPSN32) || defined(LINUX_MIPSN64) |
Roland McGrath | 542c2c6 | 2008-05-20 01:11:56 +0000 | [diff] [blame] | 947 | /* This decodes rt_sigreturn. The 64-bit ABIs do not have |
| 948 | sigreturn. */ |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 949 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 950 | long sp; |
| 951 | struct ucontext uc; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 952 | sigset_t sigm; |
Denys Vlasenko | 752e5a0 | 2013-06-28 14:35:47 +0200 | [diff] [blame] | 953 | if (upeek(tcp->pid, REG_SP, &sp) < 0) |
Denys Vlasenko | 5ae2b7c | 2009-02-27 20:32:52 +0000 | [diff] [blame] | 954 | return 0; |
Roland McGrath | 542c2c6 | 2008-05-20 01:11:56 +0000 | [diff] [blame] | 955 | /* There are six words followed by a 128-byte siginfo. */ |
| 956 | sp = sp + 6 * 4 + 128; |
| 957 | if (umove(tcp, sp, &uc) < 0) |
Denys Vlasenko | 5ae2b7c | 2009-02-27 20:32:52 +0000 | [diff] [blame] | 958 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 959 | long_to_sigset(*(long *) &uc.uc_sigmask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 960 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Roland McGrath | 542c2c6 | 2008-05-20 01:11:56 +0000 | [diff] [blame] | 961 | } |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 962 | #elif defined(MIPS) |
Denys Vlasenko | b63256e | 2011-06-07 12:13:24 +0200 | [diff] [blame] | 963 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 964 | long sp; |
| 965 | struct pt_regs regs; |
| 966 | m_siginfo_t si; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 967 | sigset_t sigm; |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 968 | if (ptrace(PTRACE_GETREGS, tcp->pid, (char *)®s, 0) < 0) { |
Denys Vlasenko | 905e8e0 | 2013-02-26 12:30:09 +0100 | [diff] [blame] | 969 | perror_msg("sigreturn: PTRACE_GETREGS"); |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 970 | return 0; |
| 971 | } |
Roland McGrath | 576b784 | 2007-11-04 00:00:00 +0000 | [diff] [blame] | 972 | sp = regs.regs[29]; |
| 973 | if (umove(tcp, sp, &si) < 0) |
Denys Vlasenko | facd45b | 2011-06-09 01:22:10 +0200 | [diff] [blame] | 974 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 975 | long_to_sigset(si.si_mask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 976 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Wichert Akkerman | f90da01 | 1999-10-31 21:15:38 +0000 | [diff] [blame] | 977 | } |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 978 | #elif defined(CRISV10) || defined(CRISV32) |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 979 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 980 | struct sigcontext sc; |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 981 | long regs[PT_MAX+1]; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 982 | sigset_t sigm; |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 983 | if (ptrace(PTRACE_GETREGS, tcp->pid, NULL, (long)regs) < 0) { |
Denys Vlasenko | 905e8e0 | 2013-02-26 12:30:09 +0100 | [diff] [blame] | 984 | perror_msg("sigreturn: PTRACE_GETREGS"); |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 985 | return 0; |
| 986 | } |
| 987 | if (umove(tcp, regs[PT_USP], &sc) < 0) |
| 988 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 989 | long_to_sigset(sc.oldmask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 990 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 991 | } |
Chris Metcalf | c8c6698 | 2009-12-28 10:00:15 -0500 | [diff] [blame] | 992 | #elif defined(TILE) |
Chris Metcalf | c8c6698 | 2009-12-28 10:00:15 -0500 | [diff] [blame] | 993 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 994 | struct ucontext uc; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 995 | sigset_t sigm; |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 996 | |
| 997 | /* offset of ucontext in the kernel's sigframe structure */ |
Chris Metcalf | 5c0796f | 2013-05-21 20:25:22 -0400 | [diff] [blame] | 998 | # define SIGFRAME_UC_OFFSET C_ABI_SAVE_AREA_SIZE + sizeof(siginfo_t) |
Chris Metcalf | 0b99a8a | 2013-02-05 17:48:33 +0100 | [diff] [blame] | 999 | if (umove(tcp, tile_regs.sp + SIGFRAME_UC_OFFSET, &uc) < 0) |
Chris Metcalf | c8c6698 | 2009-12-28 10:00:15 -0500 | [diff] [blame] | 1000 | return 0; |
Denys Vlasenko | d9560c1 | 2011-08-19 17:41:28 +0200 | [diff] [blame] | 1001 | sigemptyset(&sigm); |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 1002 | memcpy(&sigm, &uc.uc_sigmask, NSIG / 8); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 1003 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Chris Metcalf | c8c6698 | 2009-12-28 10:00:15 -0500 | [diff] [blame] | 1004 | } |
Edgar E. Iglesias | 939caba | 2010-07-06 14:21:07 +0200 | [diff] [blame] | 1005 | #elif defined(MICROBLAZE) |
Edgar E. Iglesias | 939caba | 2010-07-06 14:21:07 +0200 | [diff] [blame] | 1006 | /* TODO: Verify that this is correct... */ |
| 1007 | if (entering(tcp)) { |
Denys Vlasenko | 56a5298 | 2011-06-09 01:36:29 +0200 | [diff] [blame] | 1008 | struct sigcontext sc; |
Edgar E. Iglesias | 939caba | 2010-07-06 14:21:07 +0200 | [diff] [blame] | 1009 | long sp; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 1010 | sigset_t sigm; |
Edgar E. Iglesias | 939caba | 2010-07-06 14:21:07 +0200 | [diff] [blame] | 1011 | /* Read r1, the stack pointer. */ |
Denys Vlasenko | 752e5a0 | 2013-06-28 14:35:47 +0200 | [diff] [blame] | 1012 | if (upeek(tcp->pid, 1 * 4, &sp) < 0) |
Edgar E. Iglesias | 939caba | 2010-07-06 14:21:07 +0200 | [diff] [blame] | 1013 | return 0; |
| 1014 | if (umove(tcp, sp, &sc) < 0) |
| 1015 | return 0; |
Denys Vlasenko | b11322f | 2012-01-10 16:40:35 +0100 | [diff] [blame] | 1016 | long_to_sigset(sc.oldmask, &sigm); |
Andreas Schwab | a7920a8 | 2012-01-17 17:56:44 +0100 | [diff] [blame] | 1017 | tprints(sprintsigmask(") (mask ", &sigm, 0)); |
Edgar E. Iglesias | 939caba | 2010-07-06 14:21:07 +0200 | [diff] [blame] | 1018 | } |
Chris Zankel | 8f636ed | 2013-03-25 10:22:07 -0700 | [diff] [blame] | 1019 | #elif defined(XTENSA) |
| 1020 | /* Xtensa only has rt_sys_sigreturn */ |
Wichert Akkerman | c1652e2 | 2001-03-27 12:17:16 +0000 | [diff] [blame] | 1021 | #else |
Dmitry V. Levin | f112d07 | 2012-05-15 00:13:59 +0000 | [diff] [blame] | 1022 | # warning No sys_sigreturn() for this architecture |
| 1023 | # warning (no problem, just a reminder :-) |
Denys Vlasenko | ea0e6e8 | 2009-02-25 17:08:40 +0000 | [diff] [blame] | 1024 | #endif |
Dmitry V. Levin | f112d07 | 2012-05-15 00:13:59 +0000 | [diff] [blame] | 1025 | return 0; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1026 | } |
| 1027 | |
| 1028 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1029 | sys_siggetmask(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1030 | { |
| 1031 | if (exiting(tcp)) { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1032 | sigset_t sigm; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1033 | long_to_sigset(tcp->u_rval, &sigm); |
| 1034 | tcp->auxstr = sprintsigmask("mask ", &sigm, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1035 | } |
| 1036 | return RVAL_HEX | RVAL_STR; |
| 1037 | } |
| 1038 | |
| 1039 | int |
Dmitry V. Levin | e5e6085 | 2009-12-31 22:50:49 +0000 | [diff] [blame] | 1040 | sys_sigsuspend(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1041 | { |
| 1042 | if (entering(tcp)) { |
| 1043 | sigset_t sigm; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1044 | long_to_sigset(tcp->u_arg[2], &sigm); |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1045 | printsigmask(&sigm, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1046 | } |
| 1047 | return 0; |
| 1048 | } |
| 1049 | |
Denys Vlasenko | 8470374 | 2012-02-25 02:38:52 +0100 | [diff] [blame] | 1050 | #if !defined SS_ONSTACK |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1051 | #define SS_ONSTACK 1 |
| 1052 | #define SS_DISABLE 2 |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1053 | #endif |
| 1054 | |
Roland McGrath | d9f816f | 2004-09-04 03:39:20 +0000 | [diff] [blame] | 1055 | static const struct xlat sigaltstack_flags[] = { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1056 | { SS_ONSTACK, "SS_ONSTACK" }, |
| 1057 | { SS_DISABLE, "SS_DISABLE" }, |
| 1058 | { 0, NULL }, |
| 1059 | }; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1060 | |
Dmitry V. Levin | 338c069 | 2013-02-09 02:03:04 +0000 | [diff] [blame] | 1061 | static void |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1062 | print_stack_t(struct tcb *tcp, unsigned long addr) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1063 | { |
| 1064 | stack_t ss; |
Dmitry V. Levin | 338c069 | 2013-02-09 02:03:04 +0000 | [diff] [blame] | 1065 | |
| 1066 | if (!addr) { |
| 1067 | tprints("NULL"); |
| 1068 | } else if (umove(tcp, addr, &ss) < 0) { |
| 1069 | tprintf("%#lx", addr); |
| 1070 | } else { |
| 1071 | tprintf("{ss_sp=%#lx, ss_flags=", (unsigned long) ss.ss_sp); |
| 1072 | printflags(sigaltstack_flags, ss.ss_flags, "SS_???"); |
| 1073 | tprintf(", ss_size=%lu}", (unsigned long) ss.ss_size); |
| 1074 | } |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1075 | } |
| 1076 | |
| 1077 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1078 | sys_sigaltstack(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1079 | { |
| 1080 | if (entering(tcp)) { |
Dmitry V. Levin | 338c069 | 2013-02-09 02:03:04 +0000 | [diff] [blame] | 1081 | print_stack_t(tcp, tcp->u_arg[0]); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1082 | } |
| 1083 | else { |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1084 | tprints(", "); |
Dmitry V. Levin | 338c069 | 2013-02-09 02:03:04 +0000 | [diff] [blame] | 1085 | print_stack_t(tcp, tcp->u_arg[1]); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1086 | } |
| 1087 | return 0; |
| 1088 | } |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1089 | |
| 1090 | #ifdef HAVE_SIGACTION |
| 1091 | |
| 1092 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1093 | sys_sigprocmask(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1094 | { |
| 1095 | #ifdef ALPHA |
Mike Frysinger | dde045c | 2012-03-15 00:45:33 -0400 | [diff] [blame] | 1096 | sigset_t ss; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1097 | if (entering(tcp)) { |
Mike Frysinger | dde045c | 2012-03-15 00:45:33 -0400 | [diff] [blame] | 1098 | /* |
| 1099 | * Alpha/OSF is different: it doesn't pass in two pointers, |
| 1100 | * but rather passes in the new bitmask as an argument and |
| 1101 | * then returns the old bitmask. This "works" because we |
| 1102 | * only have 64 signals to worry about. If you want more, |
| 1103 | * use of the rt_sigprocmask syscall is required. |
| 1104 | * Alpha: |
| 1105 | * old = osf_sigprocmask(how, new); |
| 1106 | * Everyone else: |
| 1107 | * ret = sigprocmask(how, &new, &old, ...); |
| 1108 | */ |
| 1109 | memcpy(&ss, &tcp->u_arg[1], sizeof(long)); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1110 | printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1111 | tprints(", "); |
Mike Frysinger | dde045c | 2012-03-15 00:45:33 -0400 | [diff] [blame] | 1112 | printsigmask(&ss, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1113 | } |
| 1114 | else if (!syserror(tcp)) { |
Mike Frysinger | dde045c | 2012-03-15 00:45:33 -0400 | [diff] [blame] | 1115 | memcpy(&ss, &tcp->u_rval, sizeof(long)); |
| 1116 | tcp->auxstr = sprintsigmask("old mask ", &ss, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1117 | return RVAL_HEX | RVAL_STR; |
| 1118 | } |
| 1119 | #else /* !ALPHA */ |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1120 | if (entering(tcp)) { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1121 | printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1122 | tprints(", "); |
Dmitry V. Levin | 95ebf5a | 2006-10-13 20:25:12 +0000 | [diff] [blame] | 1123 | print_sigset(tcp, tcp->u_arg[1], 0); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1124 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1125 | } |
| 1126 | else { |
| 1127 | if (!tcp->u_arg[2]) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1128 | tprints("NULL"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1129 | else if (syserror(tcp)) |
| 1130 | tprintf("%#lx", tcp->u_arg[2]); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1131 | else |
Dmitry V. Levin | 95ebf5a | 2006-10-13 20:25:12 +0000 | [diff] [blame] | 1132 | print_sigset(tcp, tcp->u_arg[2], 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1133 | } |
| 1134 | #endif /* !ALPHA */ |
| 1135 | return 0; |
| 1136 | } |
| 1137 | |
| 1138 | #endif /* HAVE_SIGACTION */ |
| 1139 | |
| 1140 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1141 | sys_kill(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1142 | { |
| 1143 | if (entering(tcp)) { |
Denys Vlasenko | e015d2d | 2013-02-15 14:58:52 +0100 | [diff] [blame] | 1144 | tprintf("%ld, %s", |
| 1145 | widen_to_long(tcp->u_arg[0]), |
| 1146 | signame(tcp->u_arg[1]) |
| 1147 | ); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1148 | } |
| 1149 | return 0; |
| 1150 | } |
| 1151 | |
Roland McGrath | 8ffc352 | 2003-07-09 09:47:49 +0000 | [diff] [blame] | 1152 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1153 | sys_tgkill(struct tcb *tcp) |
Roland McGrath | 8ffc352 | 2003-07-09 09:47:49 +0000 | [diff] [blame] | 1154 | { |
| 1155 | if (entering(tcp)) { |
| 1156 | tprintf("%ld, %ld, %s", |
Denys Vlasenko | e015d2d | 2013-02-15 14:58:52 +0100 | [diff] [blame] | 1157 | widen_to_long(tcp->u_arg[0]), |
| 1158 | widen_to_long(tcp->u_arg[1]), |
| 1159 | signame(tcp->u_arg[2]) |
| 1160 | ); |
Roland McGrath | 8ffc352 | 2003-07-09 09:47:49 +0000 | [diff] [blame] | 1161 | } |
| 1162 | return 0; |
| 1163 | } |
Roland McGrath | 8ffc352 | 2003-07-09 09:47:49 +0000 | [diff] [blame] | 1164 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1165 | int |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1166 | sys_sigpending(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1167 | { |
| 1168 | sigset_t sigset; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1169 | |
| 1170 | if (exiting(tcp)) { |
| 1171 | if (syserror(tcp)) |
| 1172 | tprintf("%#lx", tcp->u_arg[0]); |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1173 | else if (copy_sigset(tcp, tcp->u_arg[0], &sigset) < 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1174 | tprints("[?]"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1175 | else |
Wichert Akkerman | 4695657 | 1999-11-26 10:12:59 +0000 | [diff] [blame] | 1176 | printsigmask(&sigset, 0); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1177 | } |
| 1178 | return 0; |
| 1179 | } |
| 1180 | |
Denys Vlasenko | 1201426 | 2011-05-30 14:00:14 +0200 | [diff] [blame] | 1181 | int |
| 1182 | sys_rt_sigprocmask(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1183 | { |
| 1184 | sigset_t sigset; |
| 1185 | |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1186 | /* Note: arg[3] is the length of the sigset. */ |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1187 | if (entering(tcp)) { |
| 1188 | printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1189 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1190 | if (!tcp->u_arg[1]) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1191 | tprints("NULL, "); |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1192 | else if (copy_sigset_len(tcp, tcp->u_arg[1], &sigset, tcp->u_arg[3]) < 0) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1193 | tprintf("%#lx, ", tcp->u_arg[1]); |
| 1194 | else { |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1195 | printsigmask(&sigset, 1); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1196 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1197 | } |
| 1198 | } |
| 1199 | else { |
| 1200 | if (!tcp->u_arg[2]) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1201 | tprints("NULL"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1202 | else if (syserror(tcp)) |
| 1203 | tprintf("%#lx", tcp->u_arg[2]); |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1204 | else if (copy_sigset_len(tcp, tcp->u_arg[2], &sigset, tcp->u_arg[3]) < 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1205 | tprints("[?]"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1206 | else |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1207 | printsigmask(&sigset, 1); |
Nate Sammons | dab325a | 1999-03-29 23:33:35 +0000 | [diff] [blame] | 1208 | tprintf(", %lu", tcp->u_arg[3]); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1209 | } |
| 1210 | return 0; |
| 1211 | } |
| 1212 | |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1213 | /* Structure describing the action to be taken when a signal arrives. */ |
| 1214 | struct new_sigaction |
| 1215 | { |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 1216 | /* sa_handler may be a libc #define, need to use other name: */ |
| 1217 | void (*__sa_handler)(int); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1218 | unsigned long sa_flags; |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 1219 | void (*sa_restorer)(void); |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1220 | /* Kernel treats sa_mask as an array of longs. */ |
| 1221 | unsigned long sa_mask[NSIG / sizeof(long) ? NSIG / sizeof(long) : 1]; |
| 1222 | }; |
| 1223 | /* Same for i386-on-x86_64 and similar cases */ |
| 1224 | struct new_sigaction32 |
| 1225 | { |
| 1226 | uint32_t __sa_handler; |
| 1227 | uint32_t sa_flags; |
| 1228 | uint32_t sa_restorer; |
| 1229 | uint32_t sa_mask[2 * (NSIG / sizeof(long) ? NSIG / sizeof(long) : 1)]; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1230 | }; |
| 1231 | |
Roland McGrath | 5f20681 | 2008-08-20 01:59:40 +0000 | [diff] [blame] | 1232 | int |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1233 | sys_rt_sigaction(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1234 | { |
| 1235 | struct new_sigaction sa; |
| 1236 | sigset_t sigset; |
| 1237 | long addr; |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1238 | int r; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1239 | |
| 1240 | if (entering(tcp)) { |
| 1241 | printsignal(tcp->u_arg[0]); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1242 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1243 | addr = tcp->u_arg[1]; |
| 1244 | } else |
| 1245 | addr = tcp->u_arg[2]; |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1246 | |
| 1247 | if (addr == 0) { |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1248 | tprints("NULL"); |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1249 | goto after_sa; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1250 | } |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1251 | if (!verbose(tcp)) { |
| 1252 | tprintf("%#lx", addr); |
| 1253 | goto after_sa; |
| 1254 | } |
Denys Vlasenko | d4d3ede | 2013-02-13 16:31:32 +0100 | [diff] [blame] | 1255 | #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4 |
Denys Vlasenko | 9fd4f96 | 2012-03-19 09:36:42 +0100 | [diff] [blame] | 1256 | if (current_wordsize != sizeof(sa.sa_flags) && current_wordsize == 4) { |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1257 | struct new_sigaction32 sa32; |
| 1258 | r = umove(tcp, addr, &sa32); |
| 1259 | if (r >= 0) { |
| 1260 | memset(&sa, 0, sizeof(sa)); |
| 1261 | sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler; |
| 1262 | sa.sa_flags = sa32.sa_flags; |
| 1263 | sa.sa_restorer = (void*)(unsigned long)sa32.sa_restorer; |
| 1264 | /* Kernel treats sa_mask as an array of longs. |
| 1265 | * For 32-bit process, "long" is uint32_t, thus, for example, |
| 1266 | * 32th bit in sa_mask will end up as bit 0 in sa_mask[1]. |
| 1267 | * But for (64-bit) kernel, 32th bit in sa_mask is |
| 1268 | * 32th bit in 0th (64-bit) long! |
| 1269 | * For little-endian, it's the same. |
| 1270 | * For big-endian, we swap 32-bit words. |
| 1271 | */ |
| 1272 | sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32); |
| 1273 | } |
| 1274 | } else |
| 1275 | #endif |
| 1276 | { |
| 1277 | r = umove(tcp, addr, &sa); |
| 1278 | } |
| 1279 | if (r < 0) { |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1280 | tprints("{...}"); |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1281 | goto after_sa; |
| 1282 | } |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 1283 | /* Architectures using function pointers, like |
| 1284 | * hppa, may need to manipulate the function pointer |
| 1285 | * to compute the result of a comparison. However, |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 1286 | * the __sa_handler function pointer exists only in |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 1287 | * the address space of the traced process, and can't |
| 1288 | * be manipulated by strace. In order to prevent the |
| 1289 | * compiler from generating code to manipulate |
Denys Vlasenko | 86d9484 | 2013-02-08 12:59:13 +0100 | [diff] [blame] | 1290 | * __sa_handler we cast the function pointers to long. */ |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 1291 | if ((long)sa.__sa_handler == (long)SIG_ERR) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1292 | tprints("{SIG_ERR, "); |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 1293 | else if ((long)sa.__sa_handler == (long)SIG_DFL) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1294 | tprints("{SIG_DFL, "); |
Carlos O'Donell | 4677c8a | 2009-09-09 18:13:19 +0000 | [diff] [blame] | 1295 | else if ((long)sa.__sa_handler == (long)SIG_IGN) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1296 | tprints("{SIG_IGN, "); |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1297 | else |
| 1298 | tprintf("{%#lx, ", (long) sa.__sa_handler); |
| 1299 | /* Questionable code below. |
| 1300 | * Kernel won't handle sys_rt_sigaction |
| 1301 | * with wrong sigset size (just returns EINVAL) |
| 1302 | * therefore tcp->u_arg[3(4)] _must_ be NSIG / 8 here, |
| 1303 | * and we always use smaller memcpy. */ |
| 1304 | sigemptyset(&sigset); |
Denys Vlasenko | 9472a27 | 2013-02-12 11:43:46 +0100 | [diff] [blame] | 1305 | #if defined(SPARC) || defined(SPARC64) |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1306 | if (tcp->u_arg[4] <= sizeof(sigset)) |
| 1307 | memcpy(&sigset, &sa.sa_mask, tcp->u_arg[4]); |
| 1308 | #else |
| 1309 | if (tcp->u_arg[3] <= sizeof(sigset)) |
| 1310 | memcpy(&sigset, &sa.sa_mask, tcp->u_arg[3]); |
| 1311 | #endif |
| 1312 | else |
| 1313 | memcpy(&sigset, &sa.sa_mask, sizeof(sigset)); |
| 1314 | printsigmask(&sigset, 1); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1315 | tprints(", "); |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1316 | printflags(sigact_flags, sa.sa_flags, "SA_???"); |
| 1317 | #ifdef SA_RESTORER |
| 1318 | if (sa.sa_flags & SA_RESTORER) |
| 1319 | tprintf(", %p", sa.sa_restorer); |
| 1320 | #endif |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1321 | tprints("}"); |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1322 | |
| 1323 | after_sa: |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1324 | if (entering(tcp)) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1325 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1326 | else |
Denys Vlasenko | 9472a27 | 2013-02-12 11:43:46 +0100 | [diff] [blame] | 1327 | #if defined(SPARC) || defined(SPARC64) |
Wichert Akkerman | dacfb6e | 1999-06-03 14:21:07 +0000 | [diff] [blame] | 1328 | tprintf(", %#lx, %lu", tcp->u_arg[3], tcp->u_arg[4]); |
| 1329 | #elif defined(ALPHA) |
| 1330 | tprintf(", %lu, %#lx", tcp->u_arg[3], tcp->u_arg[4]); |
| 1331 | #else |
Denys Vlasenko | 7a862d7 | 2009-04-15 13:22:59 +0000 | [diff] [blame] | 1332 | tprintf(", %lu", tcp->u_arg[3]); |
Wichert Akkerman | dacfb6e | 1999-06-03 14:21:07 +0000 | [diff] [blame] | 1333 | #endif |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1334 | return 0; |
| 1335 | } |
| 1336 | |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1337 | int |
| 1338 | sys_rt_sigpending(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1339 | { |
| 1340 | sigset_t sigset; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1341 | |
| 1342 | if (exiting(tcp)) { |
| 1343 | if (syserror(tcp)) |
| 1344 | tprintf("%#lx", tcp->u_arg[0]); |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1345 | else if (copy_sigset_len(tcp, tcp->u_arg[0], |
| 1346 | &sigset, tcp->u_arg[1]) < 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1347 | tprints("[?]"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1348 | else |
Wichert Akkerman | 4695657 | 1999-11-26 10:12:59 +0000 | [diff] [blame] | 1349 | printsigmask(&sigset, 1); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1350 | } |
| 1351 | return 0; |
| 1352 | } |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1353 | |
| 1354 | int |
| 1355 | sys_rt_sigsuspend(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1356 | { |
| 1357 | if (entering(tcp)) { |
| 1358 | sigset_t sigm; |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1359 | if (copy_sigset_len(tcp, tcp->u_arg[0], &sigm, tcp->u_arg[1]) < 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1360 | tprints("[?]"); |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1361 | else |
| 1362 | printsigmask(&sigm, 1); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1363 | } |
| 1364 | return 0; |
| 1365 | } |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1366 | |
Dmitry V. Levin | 297632b | 2012-03-13 15:51:13 +0000 | [diff] [blame] | 1367 | static void |
| 1368 | print_sigqueueinfo(struct tcb *tcp, int sig, unsigned long uinfo) |
| 1369 | { |
Dmitry V. Levin | 297632b | 2012-03-13 15:51:13 +0000 | [diff] [blame] | 1370 | printsignal(sig); |
| 1371 | tprints(", "); |
Denys Vlasenko | d4d3ede | 2013-02-13 16:31:32 +0100 | [diff] [blame] | 1372 | printsiginfo_at(tcp, uinfo); |
Dmitry V. Levin | 297632b | 2012-03-13 15:51:13 +0000 | [diff] [blame] | 1373 | } |
| 1374 | |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1375 | int |
| 1376 | sys_rt_sigqueueinfo(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1377 | { |
| 1378 | if (entering(tcp)) { |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1379 | tprintf("%lu, ", tcp->u_arg[0]); |
Dmitry V. Levin | 297632b | 2012-03-13 15:51:13 +0000 | [diff] [blame] | 1380 | print_sigqueueinfo(tcp, tcp->u_arg[1], tcp->u_arg[2]); |
| 1381 | } |
| 1382 | return 0; |
| 1383 | } |
| 1384 | |
| 1385 | int |
| 1386 | sys_rt_tgsigqueueinfo(struct tcb *tcp) |
| 1387 | { |
| 1388 | if (entering(tcp)) { |
| 1389 | tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]); |
| 1390 | print_sigqueueinfo(tcp, tcp->u_arg[2], tcp->u_arg[3]); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1391 | } |
| 1392 | return 0; |
| 1393 | } |
| 1394 | |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1395 | int sys_rt_sigtimedwait(struct tcb *tcp) |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1396 | { |
| 1397 | if (entering(tcp)) { |
| 1398 | sigset_t sigset; |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1399 | |
Roland McGrath | a39c5a1 | 2002-12-17 05:10:37 +0000 | [diff] [blame] | 1400 | if (copy_sigset_len(tcp, tcp->u_arg[0], |
Nate Sammons | 4a12143 | 1999-04-06 01:19:39 +0000 | [diff] [blame] | 1401 | &sigset, tcp->u_arg[3]) < 0) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1402 | tprints("[?]"); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1403 | else |
Wichert Akkerman | 4695657 | 1999-11-26 10:12:59 +0000 | [diff] [blame] | 1404 | printsigmask(&sigset, 1); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1405 | tprints(", "); |
Denys Vlasenko | b1a78cf | 2009-04-15 13:31:59 +0000 | [diff] [blame] | 1406 | /* This is the only "return" parameter, */ |
| 1407 | if (tcp->u_arg[1] != 0) |
| 1408 | return 0; |
| 1409 | /* ... if it's NULL, can decode all on entry */ |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1410 | tprints("NULL, "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1411 | } |
Denys Vlasenko | b1a78cf | 2009-04-15 13:31:59 +0000 | [diff] [blame] | 1412 | else if (tcp->u_arg[1] != 0) { |
| 1413 | /* syscall exit, and u_arg[1] wasn't NULL */ |
Denys Vlasenko | d4d3ede | 2013-02-13 16:31:32 +0100 | [diff] [blame] | 1414 | printsiginfo_at(tcp, tcp->u_arg[1]); |
| 1415 | tprints(", "); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1416 | } |
Denys Vlasenko | b1a78cf | 2009-04-15 13:31:59 +0000 | [diff] [blame] | 1417 | else { |
| 1418 | /* syscall exit, and u_arg[1] was NULL */ |
| 1419 | return 0; |
| 1420 | } |
| 1421 | print_timespec(tcp, tcp->u_arg[2]); |
| 1422 | tprintf(", %d", (int) tcp->u_arg[3]); |
Wichert Akkerman | 76baf7c | 1999-02-19 00:21:36 +0000 | [diff] [blame] | 1423 | return 0; |
| 1424 | }; |
| 1425 | |
Roland McGrath | 79dcd7a | 2006-01-12 22:34:50 +0000 | [diff] [blame] | 1426 | int |
Denys Vlasenko | 1d63246 | 2009-04-14 12:51:00 +0000 | [diff] [blame] | 1427 | sys_restart_syscall(struct tcb *tcp) |
Roland McGrath | 79dcd7a | 2006-01-12 22:34:50 +0000 | [diff] [blame] | 1428 | { |
| 1429 | if (entering(tcp)) |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1430 | tprints("<... resuming interrupted call ...>"); |
Roland McGrath | 79dcd7a | 2006-01-12 22:34:50 +0000 | [diff] [blame] | 1431 | return 0; |
| 1432 | } |
| 1433 | |
Dmitry V. Levin | 4371b10 | 2008-11-10 22:53:02 +0000 | [diff] [blame] | 1434 | static int |
| 1435 | do_signalfd(struct tcb *tcp, int flags_arg) |
Roland McGrath | f46ccd3 | 2007-08-02 01:15:59 +0000 | [diff] [blame] | 1436 | { |
| 1437 | if (entering(tcp)) { |
Dmitry V. Levin | 3138213 | 2011-03-04 05:08:02 +0300 | [diff] [blame] | 1438 | printfd(tcp, tcp->u_arg[0]); |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1439 | tprints(", "); |
Roland McGrath | f46ccd3 | 2007-08-02 01:15:59 +0000 | [diff] [blame] | 1440 | print_sigset(tcp, tcp->u_arg[1], 1); |
Dmitry V. Levin | 9d2ee3d | 2009-10-05 13:45:19 +0000 | [diff] [blame] | 1441 | tprintf(", %lu", tcp->u_arg[2]); |
Dmitry V. Levin | 4371b10 | 2008-11-10 22:53:02 +0000 | [diff] [blame] | 1442 | if (flags_arg >= 0) { |
Denys Vlasenko | 60fe8c1 | 2011-09-01 10:00:28 +0200 | [diff] [blame] | 1443 | tprints(", "); |
Dmitry V. Levin | 4371b10 | 2008-11-10 22:53:02 +0000 | [diff] [blame] | 1444 | printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); |
| 1445 | } |
Roland McGrath | f46ccd3 | 2007-08-02 01:15:59 +0000 | [diff] [blame] | 1446 | } |
| 1447 | return 0; |
| 1448 | } |
Dmitry V. Levin | 4371b10 | 2008-11-10 22:53:02 +0000 | [diff] [blame] | 1449 | |
| 1450 | int |
| 1451 | sys_signalfd(struct tcb *tcp) |
| 1452 | { |
| 1453 | return do_signalfd(tcp, -1); |
| 1454 | } |
| 1455 | |
| 1456 | int |
| 1457 | sys_signalfd4(struct tcb *tcp) |
| 1458 | { |
| 1459 | return do_signalfd(tcp, 3); |
| 1460 | } |