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, 2004 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 "command.h" 25#include "frame.h" 26#include "gdbcore.h" 27#include "inferior.h" 28#include "regcache.h" 29#include "target.h" 30 31#include "gdb_assert.h" 32#include "gdb_wait.h" 33#include "gdb_string.h" 34 35#include <sys/param.h> 36#include "gdb_dirent.h" 37#include <signal.h> 38#include <sys/ioctl.h> 39 40#include "gdb_ptrace.h" 41 42#ifdef HAVE_SYS_FILE_H 43#include <sys/file.h> 44#endif 45 46#if !defined (FETCH_INFERIOR_REGISTERS) 47#include <sys/user.h> /* Probably need to poke the user structure */ 48#endif /* !FETCH_INFERIOR_REGISTERS */ 49 50#if !defined (CHILD_XFER_MEMORY) 51static void udot_info (char *, int); 52#endif 53 54void _initialize_infptrace (void); 55 56 57/* This function simply calls ptrace with the given arguments. 58 It exists so that all calls to ptrace are isolated in this 59 machine-dependent file. */ 60int 61call_ptrace (int request, int pid, PTRACE_ARG3_TYPE addr, int data) 62{ 63 int pt_status = 0; 64 65#if 0 66 int saved_errno; 67 68 printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)", 69 request, pid, addr, data); 70#endif 71#if defined(PT_SETTRC) 72 /* If the parent can be told to attach to us, try to do it. */ 73 if (request == PT_SETTRC) 74 { 75 errno = 0; 76#ifndef PTRACE_TYPE_ARG5 77 pt_status = ptrace (PT_SETTRC, pid, addr, data); 78#else 79 /* Deal with HPUX 8.0 braindamage. We never use the 80 calls which require the fifth argument. */ 81 pt_status = ptrace (PT_SETTRC, pid, addr, data, 0); 82#endif 83 if (errno) 84 perror_with_name ("ptrace"); 85#if 0 86 printf (" = %d\n", pt_status); 87#endif 88 if (pt_status < 0) 89 return pt_status; 90 else 91 return parent_attach_all (pid, addr, data); 92 } 93#endif 94 95#if defined(PT_CONTIN1) 96 /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending 97 signals. If it's available, use it. */ 98 if (request == PT_CONTINUE) 99 request = PT_CONTIN1; 100#endif 101 102#if defined(PT_SINGLE1) 103 /* On HPUX, PT_SINGLE1 is a form of step that preserves pending 104 signals. If it's available, use it. */ 105 if (request == PT_STEP) 106 request = PT_SINGLE1; 107#endif 108 109#if 0 110 saved_errno = errno; 111 errno = 0; 112#endif 113#ifndef PTRACE_TYPE_ARG5 114 pt_status = ptrace (request, pid, addr, data); 115#else 116 /* Deal with HPUX 8.0 braindamage. We never use the 117 calls which require the fifth argument. */ 118 pt_status = ptrace (request, pid, addr, data, 0); 119#endif 120 121#if 0 122 if (errno) 123 printf (" [errno = %d]", errno); 124 125 errno = saved_errno; 126 printf (" = 0x%x\n", pt_status); 127#endif 128 return pt_status; 129} 130 131 132#if defined (DEBUG_PTRACE) || defined (PTRACE_TYPE_ARG5) 133/* For the rest of the file, use an extra level of indirection */ 134/* This lets us breakpoint usefully on call_ptrace. */ 135#define ptrace call_ptrace 136#endif 137 138/* Wait for a process to finish, possibly running a target-specific 139 hook before returning. */ 140 141/* NOTE: cagney: 2004-09-29: Dependant on the native configuration, 142 "hppah-nat.c" may either call this or infttrace.c's implementation 143 of ptrace_wait. See "hppahpux.mh". */ 144 145int 146ptrace_wait (ptid_t ptid, int *status) 147{ 148 int wstate; 149 150 wstate = wait (status); 151 return wstate; 152} 153 154#ifndef DEPRECATED_KILL_INFERIOR 155/* NOTE: cagney/2004-09-12: Instead of definining this macro, code 156 should call inf_ptrace_target to get a basic ptrace target and then 157 locally update any necessary methods. See ppcnbsd-nat.c. */ 158 159void 160kill_inferior (void) 161{ 162 int status; 163 int pid = PIDGET (inferior_ptid); 164 165 if (pid == 0) 166 return; 167 168 /* This once used to call "kill" to kill the inferior just in case 169 the inferior was still running. As others have noted in the past 170 (kingdon) there shouldn't be any way to get here if the inferior 171 is still running -- else there's a major problem elsewere in gdb 172 and it needs to be fixed. 173 174 The kill call causes problems under hpux10, so it's been removed; 175 if this causes problems we'll deal with them as they arise. */ 176 ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0); 177 wait (&status); 178 target_mourn_inferior (); 179} 180#endif /* DEPRECATED_KILL_INFERIOR */ 181 182#ifndef DEPRECATED_CHILD_RESUME 183/* NOTE: cagney/2004-09-12: Instead of definining this macro, code 184 should call inf_ptrace_target to get a basic ptrace target and then 185 locally update any necessary methods. See ppcnbsd-nat.c. */ 186 187/* Resume execution of the inferior process. 188 If STEP is nonzero, single-step it. 189 If SIGNAL is nonzero, give it that signal. */ 190 191void 192child_resume (ptid_t ptid, int step, enum target_signal signal) 193{ 194 int request = PT_CONTINUE; 195 int pid = PIDGET (ptid); 196 197 if (pid == -1) 198 /* Resume all threads. */ 199 /* I think this only gets used in the non-threaded case, where "resume 200 all threads" and "resume inferior_ptid" are the same. */ 201 pid = PIDGET (inferior_ptid); 202 203 if (step) 204 { 205 /* If this system does not support PT_STEP, a higher level 206 function will have called single_step() to transmute the step 207 request into a continue request (by setting breakpoints on 208 all possible successor instructions), so we don't have to 209 worry about that here. */ 210 211 gdb_assert (!SOFTWARE_SINGLE_STEP_P ()); 212 request = PT_STEP; 213 } 214 215 /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from 216 where it was. If GDB wanted it to start some other way, we have 217 already written a new PC value to the child. */ 218 219 errno = 0; 220 ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal)); 221 if (errno != 0) 222 perror_with_name ("ptrace"); 223} 224#endif /* DEPRECATED_CHILD_RESUME */ 225 226 227/* Start debugging the process whose number is PID. */ 228 229int 230attach (int pid) 231{ 232#ifdef PT_ATTACH 233 errno = 0; 234 ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0); 235 if (errno != 0) 236 perror_with_name ("ptrace"); 237 attach_flag = 1; 238 return pid; 239#else 240 error ("This system does not support attaching to a process"); 241#endif 242} 243 244/* Stop debugging the process whose number is PID and continue it with 245 signal number SIGNAL. SIGNAL = 0 means just continue it. */ 246 247void 248detach (int signal) 249{ 250#ifdef PT_DETACH 251 int pid = PIDGET (inferior_ptid); 252 253 errno = 0; 254 ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, signal); 255 if (errno != 0) 256 perror_with_name ("ptrace"); 257 attach_flag = 0; 258#else 259 error ("This system does not support detaching from a process"); 260#endif 261} 262 263 264#ifndef FETCH_INFERIOR_REGISTERS 265 266/* U_REGS_OFFSET is the offset of the registers within the u area. */ 267#ifndef U_REGS_OFFSET 268 269#ifndef offsetof 270#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER) 271#endif 272 273#define U_REGS_OFFSET \ 274 ptrace (PT_READ_U, PIDGET (inferior_ptid), \ 275 (PTRACE_TYPE_ARG3) (offsetof (struct user, u_ar0)), 0) \ 276 - KERNEL_U_ADDR 277#endif 278 279/* Fetch register REGNUM from the inferior. */ 280 281static void 282fetch_register (int regnum) 283{ 284 CORE_ADDR addr; 285 size_t size; 286 PTRACE_TYPE_RET *buf; 287 int tid, i; 288 289 if (CANNOT_FETCH_REGISTER (regnum)) 290 { 291 regcache_raw_supply (current_regcache, regnum, NULL); 292 return; 293 } 294 295 /* GNU/Linux LWP ID's are process ID's. */ 296 tid = TIDGET (inferior_ptid); 297 if (tid == 0) 298 tid = PIDGET (inferior_ptid); /* Not a threaded program. */ 299 300 /* This isn't really an address. But ptrace thinks of it as one. */ 301 addr = register_addr (regnum, U_REGS_OFFSET); 302 size = register_size (current_gdbarch, regnum); 303 304 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); 305 buf = alloca (size); 306 307 /* Read the register contents from the inferior a chuck at the time. */ 308 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) 309 { 310 errno = 0; 311 buf[i] = ptrace (PT_READ_U, tid, (PTRACE_TYPE_ARG3) addr, 0); 312 if (errno != 0) 313 error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regnum), 314 regnum, safe_strerror (errno)); 315 316 addr += sizeof (PTRACE_TYPE_RET); 317 } 318 regcache_raw_supply (current_regcache, regnum, buf); 319} 320 321/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this 322 for all registers. */ 323 324void 325fetch_inferior_registers (int regnum) 326{ 327 if (regnum == -1) 328 for (regnum = 0; regnum < NUM_REGS; regnum++) 329 fetch_register (regnum); 330 else 331 fetch_register (regnum); 332} 333 334/* Store register REGNUM into the inferior. */ 335 336static void 337store_register (int regnum) 338{ 339 CORE_ADDR addr; 340 size_t size; 341 PTRACE_TYPE_RET *buf; 342 int tid, i; 343 344 if (CANNOT_STORE_REGISTER (regnum)) 345 return; 346 347 /* GNU/Linux LWP ID's are process ID's. */ 348 tid = TIDGET (inferior_ptid); 349 if (tid == 0) 350 tid = PIDGET (inferior_ptid); /* Not a threaded program. */ 351 352 /* This isn't really an address. But ptrace thinks of it as one. */ 353 addr = register_addr (regnum, U_REGS_OFFSET); 354 size = register_size (current_gdbarch, regnum); 355 356 gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); 357 buf = alloca (size); 358 359 /* Write the register contents into the inferior a chunk at the time. */ 360 regcache_raw_collect (current_regcache, regnum, buf); 361 for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) 362 { 363 errno = 0; 364 ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) addr, buf[i]); 365 if (errno != 0) 366 error ("Couldn't write register %s (#%d): %s.", REGISTER_NAME (regnum), 367 regnum, safe_strerror (errno)); 368 369 addr += sizeof (PTRACE_TYPE_RET); 370 } 371} 372 373/* Store register REGNUM back into the inferior. If REGNUM is -1, do 374 this for all registers (including the floating point registers). */ 375 376void 377store_inferior_registers (int regnum) 378{ 379 if (regnum == -1) 380 for (regnum = 0; regnum < NUM_REGS; regnum++) 381 store_register (regnum); 382 else 383 store_register (regnum); 384} 385 386#endif /* not FETCH_INFERIOR_REGISTERS. */ 387 388 389/* Set an upper limit on alloca. */ 390#ifndef GDB_MAX_ALLOCA 391#define GDB_MAX_ALLOCA 0x1000 392#endif 393 394#if !defined (CHILD_XFER_MEMORY) 395/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory 396 in the NEW_SUN_PTRACE case. It ought to be straightforward. But 397 it appears that writing did not write the data that I specified. I 398 cannot understand where it got the data that it actually did write. */ 399 400/* Copy LEN bytes to or from inferior's memory starting at MEMADDR to 401 debugger memory starting at MYADDR. Copy to inferior if WRITE is 402 nonzero. TARGET is ignored. 403 404 Returns the length copied, which is either the LEN argument or 405 zero. This xfer function does not do partial moves, since 406 deprecated_child_ops doesn't allow memory operations to cross below 407 us in the target stack anyway. */ 408 409int 410child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, 411 struct mem_attrib *attrib, struct target_ops *target) 412{ 413 int i; 414 /* Round starting address down to longword boundary. */ 415 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET); 416 /* Round ending address up; get number of longwords that makes. */ 417 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1) 418 / sizeof (PTRACE_TYPE_RET)); 419 int alloc = count * sizeof (PTRACE_TYPE_RET); 420 PTRACE_TYPE_RET *buffer; 421 struct cleanup *old_chain = NULL; 422 423#ifdef PT_IO 424 /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request 425 that promises to be much more efficient in reading and writing 426 data in the traced process's address space. */ 427 428 { 429 struct ptrace_io_desc piod; 430 431 /* NOTE: We assume that there are no distinct address spaces for 432 instruction and data. */ 433 piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D; 434 piod.piod_offs = (void *) memaddr; 435 piod.piod_addr = myaddr; 436 piod.piod_len = len; 437 438 if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) &piod, 0) == -1) 439 { 440 /* If the PT_IO request is somehow not supported, fallback on 441 using PT_WRITE_D/PT_READ_D. Otherwise we will return zero 442 to indicate failure. */ 443 if (errno != EINVAL) 444 return 0; 445 } 446 else 447 { 448 /* Return the actual number of bytes read or written. */ 449 return piod.piod_len; 450 } 451 } 452#endif 453 454 /* Allocate buffer of that many longwords. */ 455 if (len < GDB_MAX_ALLOCA) 456 { 457 buffer = (PTRACE_TYPE_RET *) alloca (alloc); 458 } 459 else 460 { 461 buffer = (PTRACE_TYPE_RET *) xmalloc (alloc); 462 old_chain = make_cleanup (xfree, buffer); 463 } 464 465 if (write) 466 { 467 /* Fill start and end extra bytes of buffer with existing memory 468 data. */ 469 if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET)) 470 { 471 /* Need part of initial word -- fetch it. */ 472 buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_ptid), 473 (PTRACE_TYPE_ARG3) addr, 0); 474 } 475 476 if (count > 1) /* FIXME, avoid if even boundary. */ 477 { 478 buffer[count - 1] = 479 ptrace (PT_READ_I, PIDGET (inferior_ptid), 480 ((PTRACE_TYPE_ARG3) 481 (addr + (count - 1) * sizeof (PTRACE_TYPE_RET))), 0); 482 } 483 484 /* Copy data to be written over corresponding part of buffer. */ 485 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)), 486 myaddr, len); 487 488 /* Write the entire buffer. */ 489 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET)) 490 { 491 errno = 0; 492 ptrace (PT_WRITE_D, PIDGET (inferior_ptid), 493 (PTRACE_TYPE_ARG3) addr, buffer[i]); 494 if (errno) 495 { 496 /* Using the appropriate one (I or D) is necessary for 497 Gould NP1, at least. */ 498 errno = 0; 499 ptrace (PT_WRITE_I, PIDGET (inferior_ptid), 500 (PTRACE_TYPE_ARG3) addr, buffer[i]); 501 } 502 if (errno) 503 return 0; 504 } 505 } 506 else 507 { 508 /* Read all the longwords. */ 509 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET)) 510 { 511 errno = 0; 512 buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_ptid), 513 (PTRACE_TYPE_ARG3) addr, 0); 514 if (errno) 515 return 0; 516 QUIT; 517 } 518 519 /* Copy appropriate bytes out of the buffer. */ 520 memcpy (myaddr, 521 (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)), 522 len); 523 } 524 525 if (old_chain != NULL) 526 do_cleanups (old_chain); 527 return len; 528} 529 530 531static void 532udot_info (char *dummy1, int dummy2) 533{ 534#if defined (KERNEL_U_SIZE) 535 long udot_off; /* Offset into user struct */ 536 int udot_val; /* Value from user struct at udot_off */ 537 char mess[128]; /* For messages */ 538#endif 539 540 if (!target_has_execution) 541 { 542 error ("The program is not being run."); 543 } 544 545#if !defined (KERNEL_U_SIZE) 546 547 /* Adding support for this command is easy. Typically you just add a 548 routine, called "kernel_u_size" that returns the size of the user 549 struct, to the appropriate *-nat.c file and then add to the native 550 config file "#define KERNEL_U_SIZE kernel_u_size()" */ 551 error ("Don't know how large ``struct user'' is in this version of gdb."); 552 553#else 554 555 for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val)) 556 { 557 if ((udot_off % 24) == 0) 558 { 559 if (udot_off > 0) 560 { 561 printf_filtered ("\n"); 562 } 563 printf_filtered ("%s:", paddr (udot_off)); 564 } 565 udot_val = ptrace (PT_READ_U, PIDGET (inferior_ptid), (PTRACE_TYPE_ARG3) udot_off, 0); 566 if (errno != 0) 567 { 568 sprintf (mess, "\nreading user struct at offset 0x%s", 569 paddr_nz (udot_off)); 570 perror_with_name (mess); 571 } 572 /* Avoid using nonportable (?) "*" in print specs */ 573 printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val); 574 } 575 printf_filtered ("\n"); 576 577#endif 578} 579#endif /* !defined (CHILD_XFER_MEMORY). */ 580 581 582void 583_initialize_infptrace (void) 584{ 585#if !defined (CHILD_XFER_MEMORY) 586 add_info ("udot", udot_info, 587 "Print contents of kernel ``struct user'' for current child."); 588#endif 589} 590