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