1 /* Low-level siginfo manipulation for amd64. 2 3 Copyright (C) 2002-2019 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include <signal.h> 21 #include "common/common-defs.h" 22 #include "amd64-linux-siginfo.h" 23 24 #define GDB_SI_SIZE 128 25 26 /* The types below define the most complete kernel siginfo types known 27 for the architecture, independent of the system/libc headers. They 28 are named from a 64-bit kernel's perspective: 29 30 | layout | type | 31 |--------+----------------------| 32 | 64-bit | nat_siginfo_t | 33 | 32-bit | compat_siginfo_t | 34 | x32 | compat_x32_siginfo_t | 35 */ 36 37 #ifndef __ILP32__ 38 39 typedef int nat_int_t; 40 typedef unsigned long nat_uptr_t; 41 42 typedef int nat_time_t; 43 typedef int nat_timer_t; 44 45 /* For native 64-bit, clock_t in _sigchld is 64-bit. */ 46 typedef long nat_clock_t; 47 48 typedef union nat_sigval 49 { 50 nat_int_t sival_int; 51 nat_uptr_t sival_ptr; 52 } nat_sigval_t; 53 54 typedef struct nat_siginfo 55 { 56 int si_signo; 57 int si_errno; 58 int si_code; 59 60 union 61 { 62 int _pad[((128 / sizeof (int)) - 4)]; 63 /* kill() */ 64 struct 65 { 66 unsigned int _pid; 67 unsigned int _uid; 68 } _kill; 69 70 /* POSIX.1b timers */ 71 struct 72 { 73 nat_timer_t _tid; 74 int _overrun; 75 nat_sigval_t _sigval; 76 } _timer; 77 78 /* POSIX.1b signals */ 79 struct 80 { 81 unsigned int _pid; 82 unsigned int _uid; 83 nat_sigval_t _sigval; 84 } _rt; 85 86 /* SIGCHLD */ 87 struct 88 { 89 unsigned int _pid; 90 unsigned int _uid; 91 int _status; 92 nat_clock_t _utime; 93 nat_clock_t _stime; 94 } _sigchld; 95 96 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ 97 struct 98 { 99 nat_uptr_t _addr; 100 short int _addr_lsb; 101 struct 102 { 103 nat_uptr_t _lower; 104 nat_uptr_t _upper; 105 } si_addr_bnd; 106 } _sigfault; 107 108 /* SIGPOLL */ 109 struct 110 { 111 int _band; 112 int _fd; 113 } _sigpoll; 114 } _sifields; 115 } nat_siginfo_t; 116 117 #endif /* __ILP32__ */ 118 119 /* These types below (compat_*) define a siginfo type that is layout 120 compatible with the siginfo type exported by the 32-bit userspace 121 support. */ 122 123 typedef int compat_int_t; 124 typedef unsigned int compat_uptr_t; 125 126 typedef int compat_time_t; 127 typedef int compat_timer_t; 128 typedef int compat_clock_t; 129 130 struct compat_timeval 131 { 132 compat_time_t tv_sec; 133 int tv_usec; 134 }; 135 136 typedef union compat_sigval 137 { 138 compat_int_t sival_int; 139 compat_uptr_t sival_ptr; 140 } compat_sigval_t; 141 142 typedef struct compat_siginfo 143 { 144 int si_signo; 145 int si_errno; 146 int si_code; 147 148 union 149 { 150 int _pad[((128 / sizeof (int)) - 3)]; 151 152 /* kill() */ 153 struct 154 { 155 unsigned int _pid; 156 unsigned int _uid; 157 } _kill; 158 159 /* POSIX.1b timers */ 160 struct 161 { 162 compat_timer_t _tid; 163 int _overrun; 164 compat_sigval_t _sigval; 165 } _timer; 166 167 /* POSIX.1b signals */ 168 struct 169 { 170 unsigned int _pid; 171 unsigned int _uid; 172 compat_sigval_t _sigval; 173 } _rt; 174 175 /* SIGCHLD */ 176 struct 177 { 178 unsigned int _pid; 179 unsigned int _uid; 180 int _status; 181 compat_clock_t _utime; 182 compat_clock_t _stime; 183 } _sigchld; 184 185 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ 186 struct 187 { 188 unsigned int _addr; 189 short int _addr_lsb; 190 struct 191 { 192 unsigned int _lower; 193 unsigned int _upper; 194 } si_addr_bnd; 195 } _sigfault; 196 197 /* SIGPOLL */ 198 struct 199 { 200 int _band; 201 int _fd; 202 } _sigpoll; 203 } _sifields; 204 } compat_siginfo_t; 205 206 /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */ 207 typedef long __attribute__ ((__aligned__ (4))) compat_x32_clock_t; 208 209 typedef struct compat_x32_siginfo 210 { 211 int si_signo; 212 int si_errno; 213 int si_code; 214 215 union 216 { 217 int _pad[((128 / sizeof (int)) - 3)]; 218 219 /* kill() */ 220 struct 221 { 222 unsigned int _pid; 223 unsigned int _uid; 224 } _kill; 225 226 /* POSIX.1b timers */ 227 struct 228 { 229 compat_timer_t _tid; 230 int _overrun; 231 compat_sigval_t _sigval; 232 } _timer; 233 234 /* POSIX.1b signals */ 235 struct 236 { 237 unsigned int _pid; 238 unsigned int _uid; 239 compat_sigval_t _sigval; 240 } _rt; 241 242 /* SIGCHLD */ 243 struct 244 { 245 unsigned int _pid; 246 unsigned int _uid; 247 int _status; 248 compat_x32_clock_t _utime; 249 compat_x32_clock_t _stime; 250 } _sigchld; 251 252 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ 253 struct 254 { 255 unsigned int _addr; 256 unsigned int _addr_lsb; 257 } _sigfault; 258 259 /* SIGPOLL */ 260 struct 261 { 262 int _band; 263 int _fd; 264 } _sigpoll; 265 } _sifields; 266 } compat_x32_siginfo_t __attribute__ ((__aligned__ (8))); 267 268 /* To simplify usage of siginfo fields. */ 269 270 #define cpt_si_pid _sifields._kill._pid 271 #define cpt_si_uid _sifields._kill._uid 272 #define cpt_si_timerid _sifields._timer._tid 273 #define cpt_si_overrun _sifields._timer._overrun 274 #define cpt_si_status _sifields._sigchld._status 275 #define cpt_si_utime _sifields._sigchld._utime 276 #define cpt_si_stime _sifields._sigchld._stime 277 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr 278 #define cpt_si_addr _sifields._sigfault._addr 279 #define cpt_si_addr_lsb _sifields._sigfault._addr_lsb 280 #define cpt_si_band _sifields._sigpoll._band 281 #define cpt_si_fd _sifields._sigpoll._fd 282 283 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun. 284 In their place is si_timer1,si_timer2. */ 285 286 #ifndef si_timerid 287 #define si_timerid si_timer1 288 #endif 289 #ifndef si_overrun 290 #define si_overrun si_timer2 291 #endif 292 293 /* The type of the siginfo object the kernel returns in 294 PTRACE_GETSIGINFO. If gdb is built as a x32 program, we get a x32 295 siginfo. */ 296 #ifdef __ILP32__ 297 typedef compat_x32_siginfo_t ptrace_siginfo_t; 298 #else 299 typedef nat_siginfo_t ptrace_siginfo_t; 300 #endif 301 302 /* Convert the system provided siginfo into compatible siginfo. */ 303 304 static void 305 compat_siginfo_from_siginfo (compat_siginfo_t *to, const siginfo_t *from) 306 { 307 ptrace_siginfo_t from_ptrace; 308 309 memcpy (&from_ptrace, from, sizeof (from_ptrace)); 310 memset (to, 0, sizeof (*to)); 311 312 to->si_signo = from_ptrace.si_signo; 313 to->si_errno = from_ptrace.si_errno; 314 to->si_code = from_ptrace.si_code; 315 316 if (to->si_code == SI_TIMER) 317 { 318 to->cpt_si_timerid = from_ptrace.cpt_si_timerid; 319 to->cpt_si_overrun = from_ptrace.cpt_si_overrun; 320 to->cpt_si_ptr = from_ptrace.cpt_si_ptr; 321 } 322 else if (to->si_code == SI_USER) 323 { 324 to->cpt_si_pid = from_ptrace.cpt_si_pid; 325 to->cpt_si_uid = from_ptrace.cpt_si_uid; 326 } 327 else if (to->si_code < 0) 328 { 329 to->cpt_si_pid = from_ptrace.cpt_si_pid; 330 to->cpt_si_uid = from_ptrace.cpt_si_uid; 331 to->cpt_si_ptr = from_ptrace.cpt_si_ptr; 332 } 333 else 334 { 335 switch (to->si_signo) 336 { 337 case SIGCHLD: 338 to->cpt_si_pid = from_ptrace.cpt_si_pid; 339 to->cpt_si_uid = from_ptrace.cpt_si_uid; 340 to->cpt_si_status = from_ptrace.cpt_si_status; 341 to->cpt_si_utime = from_ptrace.cpt_si_utime; 342 to->cpt_si_stime = from_ptrace.cpt_si_stime; 343 break; 344 case SIGILL: 345 case SIGFPE: 346 case SIGSEGV: 347 case SIGBUS: 348 to->cpt_si_addr = from_ptrace.cpt_si_addr; 349 break; 350 case SIGPOLL: 351 to->cpt_si_band = from_ptrace.cpt_si_band; 352 to->cpt_si_fd = from_ptrace.cpt_si_fd; 353 break; 354 default: 355 to->cpt_si_pid = from_ptrace.cpt_si_pid; 356 to->cpt_si_uid = from_ptrace.cpt_si_uid; 357 to->cpt_si_ptr = from_ptrace.cpt_si_ptr; 358 break; 359 } 360 } 361 } 362 363 /* Convert the compatible siginfo into system siginfo. */ 364 365 static void 366 siginfo_from_compat_siginfo (siginfo_t *to, const compat_siginfo_t *from) 367 { 368 ptrace_siginfo_t to_ptrace; 369 370 memset (&to_ptrace, 0, sizeof (to_ptrace)); 371 372 to_ptrace.si_signo = from->si_signo; 373 to_ptrace.si_errno = from->si_errno; 374 to_ptrace.si_code = from->si_code; 375 376 if (to_ptrace.si_code == SI_TIMER) 377 { 378 to_ptrace.cpt_si_timerid = from->cpt_si_timerid; 379 to_ptrace.cpt_si_overrun = from->cpt_si_overrun; 380 to_ptrace.cpt_si_ptr = from->cpt_si_ptr; 381 } 382 else if (to_ptrace.si_code == SI_USER) 383 { 384 to_ptrace.cpt_si_pid = from->cpt_si_pid; 385 to_ptrace.cpt_si_uid = from->cpt_si_uid; 386 } 387 if (to_ptrace.si_code < 0) 388 { 389 to_ptrace.cpt_si_pid = from->cpt_si_pid; 390 to_ptrace.cpt_si_uid = from->cpt_si_uid; 391 to_ptrace.cpt_si_ptr = from->cpt_si_ptr; 392 } 393 else 394 { 395 switch (to_ptrace.si_signo) 396 { 397 case SIGCHLD: 398 to_ptrace.cpt_si_pid = from->cpt_si_pid; 399 to_ptrace.cpt_si_uid = from->cpt_si_uid; 400 to_ptrace.cpt_si_status = from->cpt_si_status; 401 to_ptrace.cpt_si_utime = from->cpt_si_utime; 402 to_ptrace.cpt_si_stime = from->cpt_si_stime; 403 break; 404 case SIGILL: 405 case SIGFPE: 406 case SIGSEGV: 407 case SIGBUS: 408 to_ptrace.cpt_si_addr = from->cpt_si_addr; 409 to_ptrace.cpt_si_addr_lsb = from->cpt_si_addr_lsb; 410 break; 411 case SIGPOLL: 412 to_ptrace.cpt_si_band = from->cpt_si_band; 413 to_ptrace.cpt_si_fd = from->cpt_si_fd; 414 break; 415 default: 416 to_ptrace.cpt_si_pid = from->cpt_si_pid; 417 to_ptrace.cpt_si_uid = from->cpt_si_uid; 418 to_ptrace.cpt_si_ptr = from->cpt_si_ptr; 419 break; 420 } 421 } 422 memcpy (to, &to_ptrace, sizeof (to_ptrace)); 423 } 424 425 /* Convert the system provided siginfo into compatible x32 siginfo. */ 426 427 static void 428 compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to, 429 const siginfo_t *from) 430 { 431 ptrace_siginfo_t from_ptrace; 432 433 memcpy (&from_ptrace, from, sizeof (from_ptrace)); 434 memset (to, 0, sizeof (*to)); 435 436 to->si_signo = from_ptrace.si_signo; 437 to->si_errno = from_ptrace.si_errno; 438 to->si_code = from_ptrace.si_code; 439 440 if (to->si_code == SI_TIMER) 441 { 442 to->cpt_si_timerid = from_ptrace.cpt_si_timerid; 443 to->cpt_si_overrun = from_ptrace.cpt_si_overrun; 444 to->cpt_si_ptr = from_ptrace.cpt_si_ptr; 445 } 446 else if (to->si_code == SI_USER) 447 { 448 to->cpt_si_pid = from_ptrace.cpt_si_pid; 449 to->cpt_si_uid = from_ptrace.cpt_si_uid; 450 } 451 else if (to->si_code < 0) 452 { 453 to->cpt_si_pid = from_ptrace.cpt_si_pid; 454 to->cpt_si_uid = from_ptrace.cpt_si_uid; 455 to->cpt_si_ptr = from_ptrace.cpt_si_ptr; 456 } 457 else 458 { 459 switch (to->si_signo) 460 { 461 case SIGCHLD: 462 to->cpt_si_pid = from_ptrace.cpt_si_pid; 463 to->cpt_si_uid = from_ptrace.cpt_si_uid; 464 to->cpt_si_status = from_ptrace.cpt_si_status; 465 memcpy (&to->cpt_si_utime, &from_ptrace.cpt_si_utime, 466 sizeof (to->cpt_si_utime)); 467 memcpy (&to->cpt_si_stime, &from_ptrace.cpt_si_stime, 468 sizeof (to->cpt_si_stime)); 469 break; 470 case SIGILL: 471 case SIGFPE: 472 case SIGSEGV: 473 case SIGBUS: 474 to->cpt_si_addr = from_ptrace.cpt_si_addr; 475 break; 476 case SIGPOLL: 477 to->cpt_si_band = from_ptrace.cpt_si_band; 478 to->cpt_si_fd = from_ptrace.cpt_si_fd; 479 break; 480 default: 481 to->cpt_si_pid = from_ptrace.cpt_si_pid; 482 to->cpt_si_uid = from_ptrace.cpt_si_uid; 483 to->cpt_si_ptr = from_ptrace.cpt_si_ptr; 484 break; 485 } 486 } 487 } 488 489 490 491 492 /* Convert the compatible x32 siginfo into system siginfo. */ 493 static void 494 siginfo_from_compat_x32_siginfo (siginfo_t *to, 495 const compat_x32_siginfo_t *from) 496 { 497 ptrace_siginfo_t to_ptrace; 498 499 memset (&to_ptrace, 0, sizeof (to_ptrace)); 500 to_ptrace.si_signo = from->si_signo; 501 to_ptrace.si_errno = from->si_errno; 502 to_ptrace.si_code = from->si_code; 503 504 if (to_ptrace.si_code == SI_TIMER) 505 { 506 to_ptrace.cpt_si_timerid = from->cpt_si_timerid; 507 to_ptrace.cpt_si_overrun = from->cpt_si_overrun; 508 to_ptrace.cpt_si_ptr = from->cpt_si_ptr; 509 } 510 else if (to_ptrace.si_code == SI_USER) 511 { 512 to_ptrace.cpt_si_pid = from->cpt_si_pid; 513 to_ptrace.cpt_si_uid = from->cpt_si_uid; 514 } 515 if (to_ptrace.si_code < 0) 516 { 517 to_ptrace.cpt_si_pid = from->cpt_si_pid; 518 to_ptrace.cpt_si_uid = from->cpt_si_uid; 519 to_ptrace.cpt_si_ptr = from->cpt_si_ptr; 520 } 521 else 522 { 523 switch (to_ptrace.si_signo) 524 { 525 case SIGCHLD: 526 to_ptrace.cpt_si_pid = from->cpt_si_pid; 527 to_ptrace.cpt_si_uid = from->cpt_si_uid; 528 to_ptrace.cpt_si_status = from->cpt_si_status; 529 memcpy (&to_ptrace.cpt_si_utime, &from->cpt_si_utime, 530 sizeof (to_ptrace.cpt_si_utime)); 531 memcpy (&to_ptrace.cpt_si_stime, &from->cpt_si_stime, 532 sizeof (to_ptrace.cpt_si_stime)); 533 break; 534 case SIGILL: 535 case SIGFPE: 536 case SIGSEGV: 537 case SIGBUS: 538 to_ptrace.cpt_si_addr = from->cpt_si_addr; 539 break; 540 case SIGPOLL: 541 to_ptrace.cpt_si_band = from->cpt_si_band; 542 to_ptrace.cpt_si_fd = from->cpt_si_fd; 543 break; 544 default: 545 to_ptrace.cpt_si_pid = from->cpt_si_pid; 546 to_ptrace.cpt_si_uid = from->cpt_si_uid; 547 to_ptrace.cpt_si_ptr = from->cpt_si_ptr; 548 break; 549 } 550 } 551 memcpy (to, &to_ptrace, sizeof (to_ptrace)); 552 } 553 554 /* Convert a ptrace siginfo object, into/from the siginfo in the 555 layout of the inferiors' architecture. Returns true if any 556 conversion was done; false otherwise. If DIRECTION is 1, then copy 557 from INF to PTRACE. If DIRECTION is 0, then copy from NATIVE to 558 INF. */ 559 560 int 561 amd64_linux_siginfo_fixup_common (siginfo_t *ptrace, gdb_byte *inf, 562 int direction, 563 enum amd64_siginfo_fixup_mode mode) 564 { 565 if (mode == FIXUP_32) 566 { 567 if (direction == 0) 568 compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, ptrace); 569 else 570 siginfo_from_compat_siginfo (ptrace, (struct compat_siginfo *) inf); 571 572 return 1; 573 } 574 else if (mode == FIXUP_X32) 575 { 576 if (direction == 0) 577 compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf, 578 ptrace); 579 else 580 siginfo_from_compat_x32_siginfo (ptrace, 581 (struct compat_x32_siginfo *) inf); 582 583 return 1; 584 } 585 return 0; 586 } 587 588 /* Sanity check for the siginfo structure sizes. */ 589 590 gdb_static_assert (sizeof (siginfo_t) == GDB_SI_SIZE); 591 #ifndef __ILP32__ 592 gdb_static_assert (sizeof (nat_siginfo_t) == GDB_SI_SIZE); 593 #endif 594 gdb_static_assert (sizeof (compat_x32_siginfo_t) == GDB_SI_SIZE); 595 gdb_static_assert (sizeof (compat_siginfo_t) == GDB_SI_SIZE); 596 gdb_static_assert (sizeof (ptrace_siginfo_t) == GDB_SI_SIZE); 597