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