1 /* Low-level child interface to ptrace. 2 3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 4 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "command.h" 24 #include "inferior.h" 25 #include "inflow.h" 26 #include "terminal.h" 27 #include "gdbcore.h" 28 #include "regcache.h" 29 30 #include "gdb_assert.h" 31 #include "gdb_string.h" 32 #include "gdb_ptrace.h" 33 #include "gdb_wait.h" 34 #include <signal.h> 35 36 #include "inf-ptrace.h" 37 #include "inf-child.h" 38 #include "gdbthread.h" 39 40 41 42 #ifdef PT_GET_PROCESS_STATE 43 44 static int 45 inf_ptrace_follow_fork (struct target_ops *ops, int follow_child) 46 { 47 pid_t pid, fpid; 48 ptrace_state_t pe; 49 50 pid = ptid_get_pid (inferior_ptid); 51 52 if (ptrace (PT_GET_PROCESS_STATE, pid, 53 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) 54 perror_with_name (("ptrace")); 55 56 gdb_assert (pe.pe_report_event == PTRACE_FORK); 57 fpid = pe.pe_other_pid; 58 59 if (follow_child) 60 { 61 struct inferior *parent_inf, *child_inf; 62 struct thread_info *tp; 63 64 parent_inf = find_inferior_pid (pid); 65 66 /* Add the child. */ 67 child_inf = add_inferior (fpid); 68 child_inf->attach_flag = parent_inf->attach_flag; 69 copy_terminal_info (child_inf, parent_inf); 70 child_inf->pspace = parent_inf->pspace; 71 child_inf->aspace = parent_inf->aspace; 72 73 /* Before detaching from the parent, remove all breakpoints from 74 it. */ 75 remove_breakpoints (); 76 77 if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1) 78 perror_with_name (("ptrace")); 79 80 /* Switch inferior_ptid out of the parent's way. */ 81 inferior_ptid = pid_to_ptid (fpid); 82 83 /* Delete the parent. */ 84 detach_inferior (pid); 85 86 add_thread_silent (inferior_ptid); 87 } 88 else 89 { 90 /* Breakpoints have already been detached from the child by 91 infrun.c. */ 92 93 if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1) 94 perror_with_name (("ptrace")); 95 } 96 97 return 0; 98 } 99 100 #endif /* PT_GET_PROCESS_STATE */ 101 102 103 /* Prepare to be traced. */ 104 105 static void 106 inf_ptrace_me (void) 107 { 108 /* "Trace me, Dr. Memory!" */ 109 ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0); 110 } 111 112 /* Start a new inferior Unix child process. EXEC_FILE is the file to 113 run, ALLARGS is a string containing the arguments to the program. 114 ENV is the environment vector to pass. If FROM_TTY is non-zero, be 115 chatty about it. */ 116 117 static void 118 inf_ptrace_create_inferior (struct target_ops *ops, 119 char *exec_file, char *allargs, char **env, 120 int from_tty) 121 { 122 int pid; 123 124 /* Do not change either targets above or the same target if already present. 125 The reason is the target stack is shared across multiple inferiors. */ 126 int ops_already_pushed = target_is_pushed (ops); 127 struct cleanup *back_to = NULL; 128 129 if (! ops_already_pushed) 130 { 131 /* Clear possible core file with its process_stratum. */ 132 push_target (ops); 133 back_to = make_cleanup_unpush_target (ops); 134 } 135 136 pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL, 137 NULL, NULL); 138 139 if (! ops_already_pushed) 140 discard_cleanups (back_to); 141 142 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will 143 be 1 or 2 depending on whether we're starting without or with a 144 shell. */ 145 startup_inferior (START_INFERIOR_TRAPS_EXPECTED); 146 147 /* On some targets, there must be some explicit actions taken after 148 the inferior has been started up. */ 149 target_post_startup_inferior (pid_to_ptid (pid)); 150 } 151 152 #ifdef PT_GET_PROCESS_STATE 153 154 static void 155 inf_ptrace_post_startup_inferior (ptid_t pid) 156 { 157 ptrace_event_t pe; 158 159 /* Set the initial event mask. */ 160 memset (&pe, 0, sizeof pe); 161 pe.pe_set_event |= PTRACE_FORK; 162 if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid), 163 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) 164 perror_with_name (("ptrace")); 165 } 166 167 #endif 168 169 /* Clean up a rotting corpse of an inferior after it died. */ 170 171 static void 172 inf_ptrace_mourn_inferior (struct target_ops *ops) 173 { 174 int status; 175 176 /* Wait just one more time to collect the inferior's exit status. 177 Do not check whether this succeeds though, since we may be 178 dealing with a process that we attached to. Such a process will 179 only report its exit status to its original parent. */ 180 waitpid (ptid_get_pid (inferior_ptid), &status, 0); 181 182 generic_mourn_inferior (); 183 184 if (!have_inferiors ()) 185 unpush_target (ops); 186 } 187 188 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero, 189 be chatty about it. */ 190 191 static void 192 inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty) 193 { 194 char *exec_file; 195 pid_t pid; 196 struct inferior *inf; 197 198 /* Do not change either targets above or the same target if already present. 199 The reason is the target stack is shared across multiple inferiors. */ 200 int ops_already_pushed = target_is_pushed (ops); 201 struct cleanup *back_to = NULL; 202 203 pid = parse_pid_to_attach (args); 204 205 if (pid == getpid ()) /* Trying to masturbate? */ 206 error (_("I refuse to debug myself!")); 207 208 if (! ops_already_pushed) 209 { 210 /* target_pid_to_str already uses the target. Also clear possible core 211 file with its process_stratum. */ 212 push_target (ops); 213 back_to = make_cleanup_unpush_target (ops); 214 } 215 216 if (from_tty) 217 { 218 exec_file = get_exec_file (0); 219 220 if (exec_file) 221 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, 222 target_pid_to_str (pid_to_ptid (pid))); 223 else 224 printf_unfiltered (_("Attaching to %s\n"), 225 target_pid_to_str (pid_to_ptid (pid))); 226 227 gdb_flush (gdb_stdout); 228 } 229 230 #ifdef PT_ATTACH 231 errno = 0; 232 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0); 233 if (errno != 0) 234 perror_with_name (("ptrace")); 235 #else 236 error (_("This system does not support attaching to a process")); 237 #endif 238 239 inf = current_inferior (); 240 inferior_appeared (inf, pid); 241 inf->attach_flag = 1; 242 inferior_ptid = pid_to_ptid (pid); 243 244 /* Always add a main thread. If some target extends the ptrace 245 target, it should decorate the ptid later with more info. */ 246 add_thread_silent (inferior_ptid); 247 248 if (! ops_already_pushed) 249 discard_cleanups (back_to); 250 } 251 252 #ifdef PT_GET_PROCESS_STATE 253 254 void 255 inf_ptrace_post_attach (int pid) 256 { 257 ptrace_event_t pe; 258 259 /* Set the initial event mask. */ 260 memset (&pe, 0, sizeof pe); 261 pe.pe_set_event |= PTRACE_FORK; 262 if (ptrace (PT_SET_EVENT_MASK, pid, 263 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) 264 perror_with_name (("ptrace")); 265 } 266 267 #endif 268 269 /* Detach from the inferior, optionally passing it the signal 270 specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */ 271 272 static void 273 inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty) 274 { 275 pid_t pid = ptid_get_pid (inferior_ptid); 276 int sig = 0; 277 278 if (from_tty) 279 { 280 char *exec_file = get_exec_file (0); 281 if (exec_file == 0) 282 exec_file = ""; 283 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file, 284 target_pid_to_str (pid_to_ptid (pid))); 285 gdb_flush (gdb_stdout); 286 } 287 if (args) 288 sig = atoi (args); 289 290 #ifdef PT_DETACH 291 /* We'd better not have left any breakpoints in the program or it'll 292 die when it hits one. Also note that this may only work if we 293 previously attached to the inferior. It *might* work if we 294 started the process ourselves. */ 295 errno = 0; 296 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig); 297 if (errno != 0) 298 perror_with_name (("ptrace")); 299 #else 300 error (_("This system does not support detaching from a process")); 301 #endif 302 303 inferior_ptid = null_ptid; 304 detach_inferior (pid); 305 306 if (!have_inferiors ()) 307 unpush_target (ops); 308 } 309 310 /* Kill the inferior. */ 311 312 static void 313 inf_ptrace_kill (struct target_ops *ops) 314 { 315 pid_t pid = ptid_get_pid (inferior_ptid); 316 int status; 317 318 if (pid == FAKE_PROCESS_ID) 319 return; 320 321 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0); 322 waitpid (pid, &status, 0); 323 324 target_mourn_inferior (); 325 } 326 327 /* Stop the inferior. */ 328 329 static void 330 inf_ptrace_stop (ptid_t ptid) 331 { 332 /* Send a SIGINT to the process group. This acts just like the user 333 typed a ^C on the controlling terminal. Note that using a 334 negative process number in kill() is a System V-ism. The proper 335 BSD interface is killpg(). However, all modern BSDs support the 336 System V interface too. */ 337 kill (-inferior_process_group (), SIGINT); 338 } 339 340 /* Resume execution of thread PTID, or all threads if PTID is -1. If 341 STEP is nonzero, single-step it. If SIGNAL is nonzero, give it 342 that signal. */ 343 344 static void 345 inf_ptrace_resume (struct target_ops *ops, 346 ptid_t ptid, int step, enum target_signal signal) 347 { 348 pid_t pid = ptid_get_pid (ptid); 349 int request; 350 351 if (pid == -1) 352 /* Resume all threads. Traditionally ptrace() only supports 353 single-threaded processes, so simply resume the inferior. */ 354 pid = ptid_get_pid (inferior_ptid); 355 356 if (catch_syscall_enabled () > 0) 357 request = PT_SYSCALL; 358 else 359 request = PT_CONTINUE; 360 361 if (step) 362 { 363 /* If this system does not support PT_STEP, a higher level 364 function will have called single_step() to transmute the step 365 request into a continue request (by setting breakpoints on 366 all possible successor instructions), so we don't have to 367 worry about that here. */ 368 request = PT_STEP; 369 } 370 371 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from 372 where it was. If GDB wanted it to start some other way, we have 373 already written a new program counter value to the child. */ 374 errno = 0; 375 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal)); 376 if (errno != 0) 377 perror_with_name (("ptrace")); 378 } 379 380 /* Wait for the child specified by PTID to do something. Return the 381 process ID of the child, or MINUS_ONE_PTID in case of error; store 382 the status in *OURSTATUS. */ 383 384 static ptid_t 385 inf_ptrace_wait (struct target_ops *ops, 386 ptid_t ptid, struct target_waitstatus *ourstatus, int options) 387 { 388 pid_t pid; 389 int status, save_errno; 390 391 do 392 { 393 set_sigint_trap (); 394 395 do 396 { 397 pid = waitpid (ptid_get_pid (ptid), &status, 0); 398 save_errno = errno; 399 } 400 while (pid == -1 && errno == EINTR); 401 402 clear_sigint_trap (); 403 404 if (pid == -1) 405 { 406 fprintf_unfiltered (gdb_stderr, 407 _("Child process unexpectedly missing: %s.\n"), 408 safe_strerror (save_errno)); 409 410 /* Claim it exited with unknown signal. */ 411 ourstatus->kind = TARGET_WAITKIND_SIGNALLED; 412 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; 413 return inferior_ptid; 414 } 415 416 /* Ignore terminated detached child processes. */ 417 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid)) 418 pid = -1; 419 } 420 while (pid == -1); 421 422 #ifdef PT_GET_PROCESS_STATE 423 if (WIFSTOPPED (status)) 424 { 425 ptrace_state_t pe; 426 pid_t fpid; 427 428 if (ptrace (PT_GET_PROCESS_STATE, pid, 429 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) 430 perror_with_name (("ptrace")); 431 432 switch (pe.pe_report_event) 433 { 434 case PTRACE_FORK: 435 ourstatus->kind = TARGET_WAITKIND_FORKED; 436 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); 437 438 /* Make sure the other end of the fork is stopped too. */ 439 fpid = waitpid (pe.pe_other_pid, &status, 0); 440 if (fpid == -1) 441 perror_with_name (("waitpid")); 442 443 if (ptrace (PT_GET_PROCESS_STATE, fpid, 444 (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) 445 perror_with_name (("ptrace")); 446 447 gdb_assert (pe.pe_report_event == PTRACE_FORK); 448 gdb_assert (pe.pe_other_pid == pid); 449 if (fpid == ptid_get_pid (inferior_ptid)) 450 { 451 ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); 452 return pid_to_ptid (fpid); 453 } 454 455 return pid_to_ptid (pid); 456 } 457 } 458 #endif 459 460 store_waitstatus (ourstatus, status); 461 return pid_to_ptid (pid); 462 } 463 464 /* Attempt a transfer all LEN bytes starting at OFFSET between the 465 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer. 466 Return the number of bytes actually transferred. */ 467 468 static LONGEST 469 inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, 470 const char *annex, gdb_byte *readbuf, 471 const gdb_byte *writebuf, 472 ULONGEST offset, LONGEST len) 473 { 474 pid_t pid = ptid_get_pid (inferior_ptid); 475 476 switch (object) 477 { 478 case TARGET_OBJECT_MEMORY: 479 #ifdef PT_IO 480 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO 481 request that promises to be much more efficient in reading 482 and writing data in the traced process's address space. */ 483 { 484 struct ptrace_io_desc piod; 485 486 /* NOTE: We assume that there are no distinct address spaces 487 for instruction and data. However, on OpenBSD 3.9 and 488 later, PIOD_WRITE_D doesn't allow changing memory that's 489 mapped read-only. Since most code segments will be 490 read-only, using PIOD_WRITE_D will prevent us from 491 inserting breakpoints, so we use PIOD_WRITE_I instead. */ 492 piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D; 493 piod.piod_addr = writebuf ? (void *) writebuf : readbuf; 494 piod.piod_offs = (void *) (long) offset; 495 piod.piod_len = len; 496 497 errno = 0; 498 if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0) 499 /* Return the actual number of bytes read or written. */ 500 return piod.piod_len; 501 /* If the PT_IO request is somehow not supported, fallback on 502 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero 503 to indicate failure. */ 504 if (errno != EINVAL) 505 return 0; 506 } 507 #endif 508 { 509 union 510 { 511 PTRACE_TYPE_RET word; 512 gdb_byte byte[sizeof (PTRACE_TYPE_RET)]; 513 } buffer; 514 ULONGEST rounded_offset; 515 LONGEST partial_len; 516 517 /* Round the start offset down to the next long word 518 boundary. */ 519 rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET); 520 521 /* Since ptrace will transfer a single word starting at that 522 rounded_offset the partial_len needs to be adjusted down to 523 that (remember this function only does a single transfer). 524 Should the required length be even less, adjust it down 525 again. */ 526 partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset; 527 if (partial_len > len) 528 partial_len = len; 529 530 if (writebuf) 531 { 532 /* If OFFSET:PARTIAL_LEN is smaller than 533 ROUNDED_OFFSET:WORDSIZE then a read/modify write will 534 be needed. Read in the entire word. */ 535 if (rounded_offset < offset 536 || (offset + partial_len 537 < rounded_offset + sizeof (PTRACE_TYPE_RET))) 538 /* Need part of initial word -- fetch it. */ 539 buffer.word = ptrace (PT_READ_I, pid, 540 (PTRACE_TYPE_ARG3)(uintptr_t) 541 rounded_offset, 0); 542 543 /* Copy data to be written over corresponding part of 544 buffer. */ 545 memcpy (buffer.byte + (offset - rounded_offset), 546 writebuf, partial_len); 547 548 errno = 0; 549 ptrace (PT_WRITE_D, pid, 550 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset, 551 buffer.word); 552 if (errno) 553 { 554 /* Using the appropriate one (I or D) is necessary for 555 Gould NP1, at least. */ 556 errno = 0; 557 ptrace (PT_WRITE_I, pid, 558 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset, 559 buffer.word); 560 if (errno) 561 return 0; 562 } 563 } 564 565 if (readbuf) 566 { 567 errno = 0; 568 buffer.word = ptrace (PT_READ_I, pid, 569 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset, 570 0); 571 if (errno) 572 return 0; 573 /* Copy appropriate bytes out of the buffer. */ 574 memcpy (readbuf, buffer.byte + (offset - rounded_offset), 575 partial_len); 576 } 577 578 return partial_len; 579 } 580 581 case TARGET_OBJECT_UNWIND_TABLE: 582 return -1; 583 584 case TARGET_OBJECT_AUXV: 585 return -1; 586 587 case TARGET_OBJECT_WCOOKIE: 588 return -1; 589 590 default: 591 return -1; 592 } 593 } 594 595 /* Return non-zero if the thread specified by PTID is alive. */ 596 597 static int 598 inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid) 599 { 600 /* ??? Is kill the right way to do this? */ 601 return (kill (ptid_get_pid (ptid), 0) != -1); 602 } 603 604 /* Print status information about what we're accessing. */ 605 606 static void 607 inf_ptrace_files_info (struct target_ops *ignore) 608 { 609 struct inferior *inf = current_inferior (); 610 611 printf_filtered (_("\tUsing the running image of %s %s.\n"), 612 inf->attach_flag ? "attached" : "child", 613 target_pid_to_str (inferior_ptid)); 614 } 615 616 static char * 617 inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid) 618 { 619 return normal_pid_to_str (ptid); 620 } 621 622 /* Create a prototype ptrace target. The client can override it with 623 local methods. */ 624 625 struct target_ops * 626 inf_ptrace_target (void) 627 { 628 struct target_ops *t = inf_child_target (); 629 630 t->to_attach = inf_ptrace_attach; 631 t->to_detach = inf_ptrace_detach; 632 t->to_resume = inf_ptrace_resume; 633 t->to_wait = inf_ptrace_wait; 634 t->to_files_info = inf_ptrace_files_info; 635 t->to_kill = inf_ptrace_kill; 636 t->to_create_inferior = inf_ptrace_create_inferior; 637 #ifdef PT_GET_PROCESS_STATE 638 t->to_follow_fork = inf_ptrace_follow_fork; 639 t->to_post_startup_inferior = inf_ptrace_post_startup_inferior; 640 t->to_post_attach = inf_ptrace_post_attach; 641 #endif 642 t->to_mourn_inferior = inf_ptrace_mourn_inferior; 643 t->to_thread_alive = inf_ptrace_thread_alive; 644 t->to_pid_to_str = inf_ptrace_pid_to_str; 645 t->to_stop = inf_ptrace_stop; 646 t->to_xfer_partial = inf_ptrace_xfer_partial; 647 648 return t; 649 } 650 651 652 /* Pointer to a function that returns the offset within the user area 653 where a particular register is stored. */ 654 static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int); 655 656 /* Fetch register REGNUM from the inferior. */ 657 658 static void 659 inf_ptrace_fetch_register (struct regcache *regcache, int regnum) 660 { 661 struct gdbarch *gdbarch = get_regcache_arch (regcache); 662 CORE_ADDR addr; 663 size_t size; 664 PTRACE_TYPE_RET *buf; 665 int pid, i; 666 667 /* This isn't really an address, but ptrace thinks of it as one. */ 668 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0); 669 if (addr == (CORE_ADDR)-1 670 || gdbarch_cannot_fetch_register (gdbarch, regnum)) 671 { 672 regcache_raw_supply (regcache, regnum, NULL); 673 return; 674 } 675 676 /* Cater for systems like GNU/Linux, that implement threads as 677 separate processes. */ 678 pid = ptid_get_lwp (inferior_ptid); 679 if (pid == 0) 680 pid = ptid_get_pid (inferior_ptid); 681 682 size = register_size (gdbarch, regnum); 683 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); 684 buf = alloca (size); 685 686 /* Read the register contents from the inferior a chunk at a time. */ 687 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) 688 { 689 errno = 0; 690 buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0); 691 if (errno != 0) 692 error (_("Couldn't read register %s (#%d): %s."), 693 gdbarch_register_name (gdbarch, regnum), 694 regnum, safe_strerror (errno)); 695 696 addr += sizeof (PTRACE_TYPE_RET); 697 } 698 regcache_raw_supply (regcache, regnum, buf); 699 } 700 701 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this 702 for all registers. */ 703 704 static void 705 inf_ptrace_fetch_registers (struct target_ops *ops, 706 struct regcache *regcache, int regnum) 707 { 708 if (regnum == -1) 709 for (regnum = 0; 710 regnum < gdbarch_num_regs (get_regcache_arch (regcache)); 711 regnum++) 712 inf_ptrace_fetch_register (regcache, regnum); 713 else 714 inf_ptrace_fetch_register (regcache, regnum); 715 } 716 717 /* Store register REGNUM into the inferior. */ 718 719 static void 720 inf_ptrace_store_register (const struct regcache *regcache, int regnum) 721 { 722 struct gdbarch *gdbarch = get_regcache_arch (regcache); 723 CORE_ADDR addr; 724 size_t size; 725 PTRACE_TYPE_RET *buf; 726 int pid, i; 727 728 /* This isn't really an address, but ptrace thinks of it as one. */ 729 addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1); 730 if (addr == (CORE_ADDR)-1 731 || gdbarch_cannot_store_register (gdbarch, regnum)) 732 return; 733 734 /* Cater for systems like GNU/Linux, that implement threads as 735 separate processes. */ 736 pid = ptid_get_lwp (inferior_ptid); 737 if (pid == 0) 738 pid = ptid_get_pid (inferior_ptid); 739 740 size = register_size (gdbarch, regnum); 741 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); 742 buf = alloca (size); 743 744 /* Write the register contents into the inferior a chunk at a time. */ 745 regcache_raw_collect (regcache, regnum, buf); 746 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) 747 { 748 errno = 0; 749 ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]); 750 if (errno != 0) 751 error (_("Couldn't write register %s (#%d): %s."), 752 gdbarch_register_name (gdbarch, regnum), 753 regnum, safe_strerror (errno)); 754 755 addr += sizeof (PTRACE_TYPE_RET); 756 } 757 } 758 759 /* Store register REGNUM back into the inferior. If REGNUM is -1, do 760 this for all registers. */ 761 762 static void 763 inf_ptrace_store_registers (struct target_ops *ops, 764 struct regcache *regcache, int regnum) 765 { 766 if (regnum == -1) 767 for (regnum = 0; 768 regnum < gdbarch_num_regs (get_regcache_arch (regcache)); 769 regnum++) 770 inf_ptrace_store_register (regcache, regnum); 771 else 772 inf_ptrace_store_register (regcache, regnum); 773 } 774 775 /* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be 776 a function returning the offset within the user area where a 777 particular register is stored. */ 778 779 struct target_ops * 780 inf_ptrace_trad_target (CORE_ADDR (*register_u_offset) 781 (struct gdbarch *, int, int)) 782 { 783 struct target_ops *t = inf_ptrace_target(); 784 785 gdb_assert (register_u_offset); 786 inf_ptrace_register_u_offset = register_u_offset; 787 t->to_fetch_registers = inf_ptrace_fetch_registers; 788 t->to_store_registers = inf_ptrace_store_registers; 789 790 return t; 791 } 792