infptrace.c revision 130809
1/* Low level Unix child interface to ptrace, for GDB when running under Unix. 2 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 3 1998, 1999, 2000, 2001, 2002 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23#include "defs.h" 24#include "frame.h" 25#include "inferior.h" 26#include "target.h" 27#include "gdb_string.h" 28#include "regcache.h" 29 30#include "gdb_wait.h" 31 32#include "command.h" 33 34#ifdef USG 35#include <sys/types.h> 36#endif 37 38#include <sys/param.h> 39#include "gdb_dirent.h" 40#include <signal.h> 41#include <sys/ioctl.h> 42 43#ifdef HAVE_PTRACE_H 44#include <ptrace.h> 45#else 46#ifdef HAVE_SYS_PTRACE_H 47#include <sys/ptrace.h> 48#endif 49#endif 50 51#if !defined (PT_READ_I) 52#define PT_READ_I 1 /* Read word from text space */ 53#endif 54#if !defined (PT_READ_D) 55#define PT_READ_D 2 /* Read word from data space */ 56#endif 57#if !defined (PT_READ_U) 58#define PT_READ_U 3 /* Read word from kernel user struct */ 59#endif 60#if !defined (PT_WRITE_I) 61#define PT_WRITE_I 4 /* Write word to text space */ 62#endif 63#if !defined (PT_WRITE_D) 64#define PT_WRITE_D 5 /* Write word to data space */ 65#endif 66#if !defined (PT_WRITE_U) 67#define PT_WRITE_U 6 /* Write word to kernel user struct */ 68#endif 69#if !defined (PT_CONTINUE) 70#define PT_CONTINUE 7 /* Continue after signal */ 71#endif 72#if !defined (PT_STEP) 73#define PT_STEP 9 /* Set flag for single stepping */ 74#endif 75#if !defined (PT_KILL) 76#define PT_KILL 8 /* Send child a SIGKILL signal */ 77#endif 78 79#ifndef PT_ATTACH 80#define PT_ATTACH PTRACE_ATTACH 81#endif 82#ifndef PT_DETACH 83#define PT_DETACH PTRACE_DETACH 84#endif 85 86#include "gdbcore.h" 87#ifndef NO_SYS_FILE 88#include <sys/file.h> 89#endif 90#if 0 91/* Don't think this is used anymore. On the sequent (not sure whether it's 92 dynix or ptx or both), it is included unconditionally by sys/user.h and 93 not protected against multiple inclusion. */ 94#include "gdb_stat.h" 95#endif 96 97#if !defined (FETCH_INFERIOR_REGISTERS) 98#include <sys/user.h> /* Probably need to poke the user structure */ 99#if defined (KERNEL_U_ADDR_BSD) 100#include <a.out.h> /* For struct nlist */ 101#endif /* KERNEL_U_ADDR_BSD. */ 102#endif /* !FETCH_INFERIOR_REGISTERS */ 103 104#if !defined (CHILD_XFER_MEMORY) 105static void udot_info (char *, int); 106#endif 107 108#if !defined (FETCH_INFERIOR_REGISTERS) 109static void fetch_register (int); 110static void store_register (int); 111#endif 112 113void _initialize_kernel_u_addr (void); 114void _initialize_infptrace (void); 115 116 117/* This function simply calls ptrace with the given arguments. 118 It exists so that all calls to ptrace are isolated in this 119 machine-dependent file. */ 120int 121call_ptrace (int request, int pid, PTRACE_ARG3_TYPE addr, int data) 122{ 123 int pt_status = 0; 124 125#if 0 126 int saved_errno; 127 128 printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)", 129 request, pid, addr, data); 130#endif 131#if defined(PT_SETTRC) 132 /* If the parent can be told to attach to us, try to do it. */ 133 if (request == PT_SETTRC) 134 { 135 errno = 0; 136#if !defined (FIVE_ARG_PTRACE) 137 pt_status = ptrace (PT_SETTRC, pid, addr, data); 138#else 139 /* Deal with HPUX 8.0 braindamage. We never use the 140 calls which require the fifth argument. */ 141 pt_status = ptrace (PT_SETTRC, pid, addr, data, 0); 142#endif 143 if (errno) 144 perror_with_name ("ptrace"); 145#if 0 146 printf (" = %d\n", pt_status); 147#endif 148 if (pt_status < 0) 149 return pt_status; 150 else 151 return parent_attach_all (pid, addr, data); 152 } 153#endif 154 155#if defined(PT_CONTIN1) 156 /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending 157 signals. If it's available, use it. */ 158 if (request == PT_CONTINUE) 159 request = PT_CONTIN1; 160#endif 161 162#if defined(PT_SINGLE1) 163 /* On HPUX, PT_SINGLE1 is a form of step that preserves pending 164 signals. If it's available, use it. */ 165 if (request == PT_STEP) 166 request = PT_SINGLE1; 167#endif 168 169#if 0 170 saved_errno = errno; 171 errno = 0; 172#endif 173#if !defined (FIVE_ARG_PTRACE) 174 pt_status = ptrace (request, pid, addr, data); 175#else 176 /* Deal with HPUX 8.0 braindamage. We never use the 177 calls which require the fifth argument. */ 178 pt_status = ptrace (request, pid, addr, data, 0); 179#endif 180 181#if 0 182 if (errno) 183 printf (" [errno = %d]", errno); 184 185 errno = saved_errno; 186 printf (" = 0x%x\n", pt_status); 187#endif 188 return pt_status; 189} 190 191 192#if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE) 193/* For the rest of the file, use an extra level of indirection */ 194/* This lets us breakpoint usefully on call_ptrace. */ 195#define ptrace call_ptrace 196#endif 197 198/* Wait for a process to finish, possibly running a target-specific 199 hook before returning. */ 200 201int 202ptrace_wait (ptid_t ptid, int *status) 203{ 204 int wstate; 205 206 wstate = wait (status); 207 target_post_wait (pid_to_ptid (wstate), *status); 208 return wstate; 209} 210 211#ifndef KILL_INFERIOR 212void 213kill_inferior (void) 214{ 215 int status; 216 int pid = PIDGET (inferior_ptid); 217 218 if (pid == 0) 219 return; 220 221 /* This once used to call "kill" to kill the inferior just in case 222 the inferior was still running. As others have noted in the past 223 (kingdon) there shouldn't be any way to get here if the inferior 224 is still running -- else there's a major problem elsewere in gdb 225 and it needs to be fixed. 226 227 The kill call causes problems under hpux10, so it's been removed; 228 if this causes problems we'll deal with them as they arise. */ 229 ptrace (PT_KILL, pid, (PTRACE_ARG3_TYPE) 0, 0); 230 ptrace_wait (null_ptid, &status); 231 target_mourn_inferior (); 232} 233#endif /* KILL_INFERIOR */ 234 235#ifndef CHILD_RESUME 236 237/* Resume execution of the inferior process. 238 If STEP is nonzero, single-step it. 239 If SIGNAL is nonzero, give it that signal. */ 240 241void 242child_resume (ptid_t ptid, int step, enum target_signal signal) 243{ 244 int pid = PIDGET (ptid); 245 246 errno = 0; 247 248 if (pid == -1) 249 /* Resume all threads. */ 250 /* I think this only gets used in the non-threaded case, where "resume 251 all threads" and "resume inferior_ptid" are the same. */ 252 pid = PIDGET (inferior_ptid); 253 254 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where 255 it was. (If GDB wanted it to start some other way, we have already 256 written a new PC value to the child.) 257 258 If this system does not support PT_STEP, a higher level function will 259 have called single_step() to transmute the step request into a 260 continue request (by setting breakpoints on all possible successor 261 instructions), so we don't have to worry about that here. */ 262 263 if (step) 264 { 265 if (SOFTWARE_SINGLE_STEP_P ()) 266 internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Make sure this doesn't happen. */ 267 else 268 ptrace (PT_STEP, pid, (PTRACE_ARG3_TYPE) 1, 269 target_signal_to_host (signal)); 270 } 271 else 272 ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1, 273 target_signal_to_host (signal)); 274 275 if (errno) 276 { 277 perror_with_name ("ptrace"); 278 } 279} 280#endif /* CHILD_RESUME */ 281 282 283#ifdef ATTACH_DETACH 284/* Start debugging the process whose number is PID. */ 285int 286attach (int pid) 287{ 288 errno = 0; 289 ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0); 290 if (errno) 291 perror_with_name ("ptrace"); 292 attach_flag = 1; 293 return pid; 294} 295 296/* Stop debugging the process whose number is PID 297 and continue it with signal number SIGNAL. 298 SIGNAL = 0 means just continue it. */ 299 300void 301detach (int signal) 302{ 303 errno = 0; 304 ptrace (PT_DETACH, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) 1, 305 signal); 306 if (errno) 307 print_sys_errmsg ("ptrace", errno); 308 attach_flag = 0; 309} 310#endif /* ATTACH_DETACH */ 311 312/* Default the type of the ptrace transfer to int. */ 313#ifndef PTRACE_XFER_TYPE 314#define PTRACE_XFER_TYPE int 315#endif 316 317/* KERNEL_U_ADDR is the amount to subtract from u.u_ar0 318 to get the offset in the core file of the register values. */ 319#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS) 320/* Get kernel_u_addr using BSD-style nlist(). */ 321CORE_ADDR kernel_u_addr; 322#endif /* KERNEL_U_ADDR_BSD. */ 323 324void 325_initialize_kernel_u_addr (void) 326{ 327#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS) 328 struct nlist names[2]; 329 330 names[0].n_un.n_name = "_u"; 331 names[1].n_un.n_name = NULL; 332 if (nlist ("/vmunix", names) == 0) 333 kernel_u_addr = names[0].n_value; 334 else 335 internal_error (__FILE__, __LINE__, 336 "Unable to get kernel u area address."); 337#endif /* KERNEL_U_ADDR_BSD. */ 338} 339 340#if !defined (FETCH_INFERIOR_REGISTERS) 341 342#if !defined (offsetof) 343#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER) 344#endif 345 346/* U_REGS_OFFSET is the offset of the registers within the u area. */ 347#if !defined (U_REGS_OFFSET) 348#define U_REGS_OFFSET \ 349 ptrace (PT_READ_U, PIDGET (inferior_ptid), \ 350 (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \ 351 - KERNEL_U_ADDR 352#endif 353 354/* Fetch one register. */ 355 356static void 357fetch_register (int regno) 358{ 359 /* This isn't really an address. But ptrace thinks of it as one. */ 360 CORE_ADDR regaddr; 361 char mess[128]; /* For messages */ 362 int i; 363 unsigned int offset; /* Offset of registers within the u area. */ 364 char buf[MAX_REGISTER_SIZE]; 365 int tid; 366 367 if (CANNOT_FETCH_REGISTER (regno)) 368 { 369 memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ 370 supply_register (regno, buf); 371 return; 372 } 373 374 /* Overload thread id onto process id */ 375 if ((tid = TIDGET (inferior_ptid)) == 0) 376 tid = PIDGET (inferior_ptid); /* no thread id, just use process id */ 377 378 offset = U_REGS_OFFSET; 379 380 regaddr = register_addr (regno, offset); 381 for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) 382 { 383 errno = 0; 384 *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid, 385 (PTRACE_ARG3_TYPE) regaddr, 0); 386 regaddr += sizeof (PTRACE_XFER_TYPE); 387 if (errno != 0) 388 { 389 sprintf (mess, "reading register %s (#%d)", 390 REGISTER_NAME (regno), regno); 391 perror_with_name (mess); 392 } 393 } 394 supply_register (regno, buf); 395} 396 397 398/* Fetch register values from the inferior. 399 If REGNO is negative, do this for all registers. 400 Otherwise, REGNO specifies which register (so we can save time). */ 401 402void 403fetch_inferior_registers (int regno) 404{ 405 if (regno >= 0) 406 { 407 fetch_register (regno); 408 } 409 else 410 { 411 for (regno = 0; regno < NUM_REGS; regno++) 412 { 413 fetch_register (regno); 414 } 415 } 416} 417 418/* Store one register. */ 419 420static void 421store_register (int regno) 422{ 423 /* This isn't really an address. But ptrace thinks of it as one. */ 424 CORE_ADDR regaddr; 425 char mess[128]; /* For messages */ 426 int i; 427 unsigned int offset; /* Offset of registers within the u area. */ 428 int tid; 429 char buf[MAX_REGISTER_SIZE]; 430 431 if (CANNOT_STORE_REGISTER (regno)) 432 { 433 return; 434 } 435 436 /* Overload thread id onto process id */ 437 if ((tid = TIDGET (inferior_ptid)) == 0) 438 tid = PIDGET (inferior_ptid); /* no thread id, just use process id */ 439 440 offset = U_REGS_OFFSET; 441 442 regaddr = register_addr (regno, offset); 443 444 /* Put the contents of regno into a local buffer */ 445 regcache_collect (regno, buf); 446 447 /* Store the local buffer into the inferior a chunk at the time. */ 448 for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) 449 { 450 errno = 0; 451 ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, 452 *(PTRACE_XFER_TYPE *) (buf + i)); 453 regaddr += sizeof (PTRACE_XFER_TYPE); 454 if (errno != 0) 455 { 456 sprintf (mess, "writing register %s (#%d)", 457 REGISTER_NAME (regno), regno); 458 perror_with_name (mess); 459 } 460 } 461} 462 463/* Store our register values back into the inferior. 464 If REGNO is negative, do this for all registers. 465 Otherwise, REGNO specifies which register (so we can save time). */ 466 467void 468store_inferior_registers (int regno) 469{ 470 if (regno >= 0) 471 { 472 store_register (regno); 473 } 474 else 475 { 476 for (regno = 0; regno < NUM_REGS; regno++) 477 { 478 store_register (regno); 479 } 480 } 481} 482#endif /* !defined (FETCH_INFERIOR_REGISTERS). */ 483 484 485/* Set an upper limit on alloca. */ 486#ifndef GDB_MAX_ALLOCA 487#define GDB_MAX_ALLOCA 0x1000 488#endif 489 490#if !defined (CHILD_XFER_MEMORY) 491/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory 492 in the NEW_SUN_PTRACE case. It ought to be straightforward. But 493 it appears that writing did not write the data that I specified. I 494 cannot understand where it got the data that it actually did write. */ 495 496/* Copy LEN bytes to or from inferior's memory starting at MEMADDR to 497 debugger memory starting at MYADDR. Copy to inferior if WRITE is 498 nonzero. TARGET is ignored. 499 500 Returns the length copied, which is either the LEN argument or 501 zero. This xfer function does not do partial moves, since 502 child_ops doesn't allow memory operations to cross below us in the 503 target stack anyway. */ 504 505int 506child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, 507 struct mem_attrib *attrib, struct target_ops *target) 508{ 509 int i; 510 /* Round starting address down to longword boundary. */ 511 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE); 512 /* Round ending address up; get number of longwords that makes. */ 513 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) 514 / sizeof (PTRACE_XFER_TYPE)); 515 int alloc = count * sizeof (PTRACE_XFER_TYPE); 516 PTRACE_XFER_TYPE *buffer; 517 struct cleanup *old_chain = NULL; 518 519#ifdef PT_IO 520 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request 521 that promises to be much more efficient in reading and writing 522 data in the traced process's address space. */ 523 524 { 525 struct ptrace_io_desc piod; 526 527 /* NOTE: We assume that there are no distinct address spaces for 528 instruction and data. */ 529 piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D; 530 piod.piod_offs = (void *) memaddr; 531 piod.piod_addr = myaddr; 532 piod.piod_len = len; 533 534 if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) &piod, 0) == -1) 535 { 536 /* If the PT_IO request is somehow not supported, fallback on 537 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero 538 to indicate failure. */ 539 if (errno != EINVAL) 540 return 0; 541 } 542 else 543 { 544 /* Return the actual number of bytes read or written. */ 545 return piod.piod_len; 546 } 547 } 548#endif 549 550 /* Allocate buffer of that many longwords. */ 551 if (len < GDB_MAX_ALLOCA) 552 { 553 buffer = (PTRACE_XFER_TYPE *) alloca (alloc); 554 } 555 else 556 { 557 buffer = (PTRACE_XFER_TYPE *) xmalloc (alloc); 558 old_chain = make_cleanup (xfree, buffer); 559 } 560 561 if (write) 562 { 563 /* Fill start and end extra bytes of buffer with existing memory 564 data. */ 565 if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE)) 566 { 567 /* Need part of initial word -- fetch it. */ 568 buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_ptid), 569 (PTRACE_ARG3_TYPE) addr, 0); 570 } 571 572 if (count > 1) /* FIXME, avoid if even boundary. */ 573 { 574 buffer[count - 1] = 575 ptrace (PT_READ_I, PIDGET (inferior_ptid), 576 ((PTRACE_ARG3_TYPE) 577 (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))), 0); 578 } 579 580 /* Copy data to be written over corresponding part of buffer. */ 581 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), 582 myaddr, len); 583 584 /* Write the entire buffer. */ 585 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) 586 { 587 errno = 0; 588 ptrace (PT_WRITE_D, PIDGET (inferior_ptid), 589 (PTRACE_ARG3_TYPE) addr, buffer[i]); 590 if (errno) 591 { 592 /* Using the appropriate one (I or D) is necessary for 593 Gould NP1, at least. */ 594 errno = 0; 595 ptrace (PT_WRITE_I, PIDGET (inferior_ptid), 596 (PTRACE_ARG3_TYPE) addr, buffer[i]); 597 } 598 if (errno) 599 return 0; 600 } 601#ifdef CLEAR_INSN_CACHE 602 CLEAR_INSN_CACHE (); 603#endif 604 } 605 else 606 { 607 /* Read all the longwords. */ 608 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) 609 { 610 errno = 0; 611 buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_ptid), 612 (PTRACE_ARG3_TYPE) addr, 0); 613 if (errno) 614 return 0; 615 QUIT; 616 } 617 618 /* Copy appropriate bytes out of the buffer. */ 619 memcpy (myaddr, 620 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), 621 len); 622 } 623 624 if (old_chain != NULL) 625 do_cleanups (old_chain); 626 return len; 627} 628 629 630static void 631udot_info (char *dummy1, int dummy2) 632{ 633#if defined (KERNEL_U_SIZE) 634 long udot_off; /* Offset into user struct */ 635 int udot_val; /* Value from user struct at udot_off */ 636 char mess[128]; /* For messages */ 637#endif 638 639 if (!target_has_execution) 640 { 641 error ("The program is not being run."); 642 } 643 644#if !defined (KERNEL_U_SIZE) 645 646 /* Adding support for this command is easy. Typically you just add a 647 routine, called "kernel_u_size" that returns the size of the user 648 struct, to the appropriate *-nat.c file and then add to the native 649 config file "#define KERNEL_U_SIZE kernel_u_size()" */ 650 error ("Don't know how large ``struct user'' is in this version of gdb."); 651 652#else 653 654 for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val)) 655 { 656 if ((udot_off % 24) == 0) 657 { 658 if (udot_off > 0) 659 { 660 printf_filtered ("\n"); 661 } 662 printf_filtered ("%s:", paddr (udot_off)); 663 } 664 udot_val = ptrace (PT_READ_U, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) udot_off, 0); 665 if (errno != 0) 666 { 667 sprintf (mess, "\nreading user struct at offset 0x%s", 668 paddr_nz (udot_off)); 669 perror_with_name (mess); 670 } 671 /* Avoid using nonportable (?) "*" in print specs */ 672 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val); 673 } 674 printf_filtered ("\n"); 675 676#endif 677} 678#endif /* !defined (CHILD_XFER_MEMORY). */ 679 680 681void 682_initialize_infptrace (void) 683{ 684#if !defined (CHILD_XFER_MEMORY) 685 add_info ("udot", udot_info, 686 "Print contents of kernel ``struct user'' for current child."); 687#endif 688} 689