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