Subversion Repositories openrisc_2011-10-31

/* GNU/Linux native-dependent code for debugging multiple forks.

   Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "inferior.h"

#include "regcache.h"

#include "gdbcmd.h"

#include "infcall.h"

#include "gdb_assert.h"

#include "gdb_string.h"

#include "linux-fork.h"

#include "linux-nat.h"

#include <sys/ptrace.h>

#include "gdb_wait.h"

#include <sys/param.h>

#include "gdb_dirent.h"

#include <ctype.h>

struct fork_info *fork_list;

static int highest_fork_num;

/* Prevent warning from -Wmissing-prototypes.  */

extern void _initialize_linux_fork (void);

int detach_fork = 1;            /* Default behavior is to detach

                                   newly forked processes (legacy).  */

/* Fork list data structure:  */

struct fork_info

{

  struct fork_info *next;

  ptid_t ptid;

  int num;                      /* Convenient handle (GDB fork id) */

  struct regcache *savedregs;   /* Convenient for info fork, saves

                                   having to actually switch contexts.  */

  int clobber_regs;             /* True if we should restore saved regs.  */

  ULONGEST pc;                  /* PC for info fork.  */

  off_t *filepos;               /* Set of open file descriptors' offsets.  */

  int maxfd;

};

/* Fork list methods:  */

extern int

forks_exist_p (void)

{

  return (fork_list != NULL);

}

/* Add a fork to internal fork list.

   Called from linux child_follow_fork.  */

extern struct fork_info *

add_fork (pid_t pid)

{

  struct fork_info *fp;

  if (fork_list == NULL && pid != PIDGET (inferior_ptid))

    {

      /* Special case -- if this is the first fork in the list

         (the list is hitherto empty), and if this new fork is

         NOT the current inferior_ptid, then add inferior_ptid

         first, as a special zeroeth fork id.  */

      highest_fork_num = -1;

      add_fork (PIDGET (inferior_ptid));        /* safe recursion */

    }

  fp = XZALLOC (struct fork_info);

  fp->ptid = ptid_build (pid, pid, 0);

  fp->num = ++highest_fork_num;

  fp->next = fork_list;

  fork_list = fp;

  return fp;

}

static void

free_fork (struct fork_info *fp)

{

  /* Notes on step-resume breakpoints: since this is a concern for

     threads, let's convince ourselves that it's not a concern for

     forks.  There are two ways for a fork_info to be created.  First,

     by the checkpoint command, in which case we're at a gdb prompt

     and there can't be any step-resume breakpoint.  Second, by a fork

     in the user program, in which case we *may* have stepped into the

     fork call, but regardless of whether we follow the parent or the

     child, we will return to the same place and the step-resume

     breakpoint, if any, will take care of itself as usual.  And

     unlike threads, we do not save a private copy of the step-resume

     breakpoint -- so we're OK.  */

  if (fp)

    {

      if (fp->savedregs)

        regcache_xfree (fp->savedregs);

      if (fp->filepos)

        xfree (fp->filepos);

      xfree (fp);

    }

}

static void

delete_fork (ptid_t ptid)

{

  struct fork_info *fp, *fpprev;

  fpprev = NULL;

  for (fp = fork_list; fp; fpprev = fp, fp = fp->next)

    if (ptid_equal (fp->ptid, ptid))

      break;

  if (!fp)

    return;

  if (fpprev)

    fpprev->next = fp->next;

  else

    fork_list = fp->next;

  free_fork (fp);

  /* Special case: if there is now only one process in the list,

     and if it is (hopefully!) the current inferior_ptid, then

     remove it, leaving the list empty -- we're now down to the

     default case of debugging a single process.  */

  if (fork_list != NULL && fork_list->next == NULL &&

      ptid_equal (fork_list->ptid, inferior_ptid))

    {

      /* Last fork -- delete from list and handle as solo process

         (should be a safe recursion).  */

      delete_fork (inferior_ptid);

    }

}

/* Find a fork_info by matching PTID.  */

static struct fork_info *

find_fork_ptid (ptid_t ptid)

{

  struct fork_info *fp;

  for (fp = fork_list; fp; fp = fp->next)

    if (ptid_equal (fp->ptid, ptid))

      return fp;

  return NULL;

}

/* Find a fork_info by matching ID.  */

static struct fork_info *

find_fork_id (int num)

{

  struct fork_info *fp;

  for (fp = fork_list; fp; fp = fp->next)

    if (fp->num == num)

      return fp;

  return NULL;

}

/* Find a fork_info by matching pid.  */

extern struct fork_info *

find_fork_pid (pid_t pid)

{

  struct fork_info *fp;

  for (fp = fork_list; fp; fp = fp->next)

    if (pid == ptid_get_pid (fp->ptid))

      return fp;

  return NULL;

}

static ptid_t

fork_id_to_ptid (int num)

{

  struct fork_info *fork = find_fork_id (num);

  if (fork)

    return fork->ptid;

  else

    return pid_to_ptid (-1);

}

static void

init_fork_list (void)

{

  struct fork_info *fp, *fpnext;

  if (!fork_list)

    return;

  for (fp = fork_list; fp; fp = fpnext)

    {

      fpnext = fp->next;

      free_fork (fp);

    }

  fork_list = NULL;

}

/* Fork list <-> gdb interface.  */

/* Utility function for fork_load/fork_save.

   Calls lseek in the (current) inferior process.  */

static off_t

call_lseek (int fd, off_t offset, int whence)

{

  char exp[80];

  snprintf (&exp[0], sizeof (exp), "lseek (%d, %ld, %d)",

            fd, (long) offset, whence);

  return (off_t) parse_and_eval_long (&exp[0]);

}

/* Load infrun state for the fork PTID.  */

static void

fork_load_infrun_state (struct fork_info *fp)

{

  extern void nullify_last_target_wait_ptid ();

  int i;

  inferior_ptid = fp->ptid;

  linux_nat_switch_fork (inferior_ptid);

  if (fp->savedregs && fp->clobber_regs)

    regcache_cpy (get_current_regcache (), fp->savedregs);

  registers_changed ();

  reinit_frame_cache ();

  stop_pc = read_pc ();

  nullify_last_target_wait_ptid ();

  /* Now restore the file positions of open file descriptors.  */

  if (fp->filepos)

    {

      for (i = 0; i <= fp->maxfd; i++)

        if (fp->filepos[i] != (off_t) -1)

          call_lseek (i, fp->filepos[i], SEEK_SET);

      /* NOTE: I can get away with using SEEK_SET and SEEK_CUR because

         this is native-only.  If it ever has to be cross, we'll have

         to rethink this.  */

    }

}

/* Save infrun state for the fork PTID.

   Exported for use by linux child_follow_fork.  */

extern void

fork_save_infrun_state (struct fork_info *fp, int clobber_regs)

{

  char path[MAXPATHLEN];

  struct dirent *de;

  DIR *d;

  if (fp->savedregs)

    regcache_xfree (fp->savedregs);

  fp->savedregs = regcache_dup (get_current_regcache ());

  fp->clobber_regs = clobber_regs;

  fp->pc = read_pc ();

  if (clobber_regs)

    {

      /* Now save the 'state' (file position) of all open file descriptors.

         Unfortunately fork does not take care of that for us...  */

      snprintf (path, MAXPATHLEN, "/proc/%ld/fd", (long) PIDGET (fp->ptid));

      if ((d = opendir (path)) != NULL)

        {

          long tmp;

          fp->maxfd = 0;

          while ((de = readdir (d)) != NULL)

            {

              /* Count open file descriptors (actually find highest

                 numbered).  */

              tmp = strtol (&de->d_name[0], NULL, 10);

              if (fp->maxfd < tmp)

                fp->maxfd = tmp;

            }

          /* Allocate array of file positions.  */

          fp->filepos = xrealloc (fp->filepos,

                                  (fp->maxfd + 1) * sizeof (*fp->filepos));

          /* Initialize to -1 (invalid).  */

          for (tmp = 0; tmp <= fp->maxfd; tmp++)

            fp->filepos[tmp] = -1;

          /* Now find actual file positions.  */

          rewinddir (d);

          while ((de = readdir (d)) != NULL)

            if (isdigit (de->d_name[0]))

              {

                tmp = strtol (&de->d_name[0], NULL, 10);

                fp->filepos[tmp] = call_lseek (tmp, 0, SEEK_CUR);

              }

          closedir (d);

        }

    }

}

/* Kill 'em all, let God sort 'em out...  */

extern void

linux_fork_killall (void)

{

  /* Walk list and kill every pid.  No need to treat the

     current inferior_ptid as special (we do not return a

     status for it) -- however any process may be a child

     or a parent, so may get a SIGCHLD from a previously

     killed child.  Wait them all out.  */

  struct fork_info *fp;

  pid_t pid, ret;

  int status;

  for (fp = fork_list; fp; fp = fp->next)

    {

      pid = PIDGET (fp->ptid);

      do {

        ptrace (PT_KILL, pid, 0, 0);

        ret = waitpid (pid, &status, 0);

        /* We might get a SIGCHLD instead of an exit status.  This is

         aggravated by the first kill above - a child has just

         died.  MVS comment cut-and-pasted from linux-nat.  */

      } while (ret == pid && WIFSTOPPED (status));

    }

  init_fork_list ();    /* Clear list, prepare to start fresh.  */

}

/* The current inferior_ptid has exited, but there are other viable

   forks to debug.  Delete the exiting one and context-switch to the

   first available.  */

extern void

linux_fork_mourn_inferior (void)

{

  /* Wait just one more time to collect the inferior's exit status.

     Do not check whether this succeeds though, since we may be

     dealing with a process that we attached to.  Such a process will

     only report its exit status to its original parent.  */

  int status;

  waitpid (ptid_get_pid (inferior_ptid), &status, 0);

  /* OK, presumably inferior_ptid is the one who has exited.

     We need to delete that one from the fork_list, and switch

     to the next available fork.  */

  delete_fork (inferior_ptid);

  /* There should still be a fork - if there's only one left,

     delete_fork won't remove it, because we haven't updated

     inferior_ptid yet.  */

  gdb_assert (fork_list);

  fork_load_infrun_state (fork_list);

  printf_filtered (_("[Switching to %s]\n"),

                   target_pid_to_str (inferior_ptid));

  /* If there's only one fork, switch back to non-fork mode.  */

  if (fork_list->next == NULL)

    delete_fork (inferior_ptid);

}

/* Fork list <-> user interface.  */

static void

delete_fork_command (char *args, int from_tty)

{

  ptid_t ptid;

  if (!args || !*args)

    error (_("Requires argument (fork/checkpoint id to delete)"));

  ptid = fork_id_to_ptid (parse_and_eval_long (args));

  if (ptid_equal (ptid, minus_one_ptid))

    error (_("No such fork/checkpoint id, %s"), args);

  if (ptid_equal (ptid, inferior_ptid))

    error (_("Please switch to another fork/checkpoint before deleting the current one"));

  if (ptrace (PTRACE_KILL, PIDGET (ptid), 0, 0))

    error (_("Unable to kill pid %s"), target_tid_to_str (ptid));

  if (from_tty)

    printf_filtered (_("Killed %s\n"), target_pid_to_str (ptid));

  delete_fork (ptid);

}

static void

detach_fork_command (char *args, int from_tty)

{

  ptid_t ptid;

  if (!args || !*args)

    error (_("Requires argument (fork id to detach)"));

  ptid = fork_id_to_ptid (parse_and_eval_long (args));

  if (ptid_equal (ptid, minus_one_ptid))

    error (_("No such fork id, %s"), args);

  if (ptid_equal (ptid, inferior_ptid))

    error (_("Please switch to another fork before detaching the current one"));

  if (ptrace (PTRACE_DETACH, PIDGET (ptid), 0, 0))

    error (_("Unable to detach %s"), target_pid_to_str (ptid));

  if (from_tty)

    printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid));

  delete_fork (ptid);

}

/* Print information about currently known forks.  */

static void

info_forks_command (char *arg, int from_tty)

{

  struct frame_info *cur_frame;

  struct symtab_and_line sal;

  struct symtab *cur_symtab;

  struct fork_info *fp;

  int cur_line;

  ULONGEST pc;

  int requested = -1;

  struct fork_info *printed = NULL;

  if (arg && *arg)

    requested = (int) parse_and_eval_long (arg);

  for (fp = fork_list; fp; fp = fp->next)

    {

      if (requested > 0 && fp->num != requested)

        continue;

      printed = fp;

      if (ptid_equal (fp->ptid, inferior_ptid))

        {

          printf_filtered ("* ");

          pc = read_pc ();

        }

      else

        {

          printf_filtered ("  ");

          pc = fp->pc;

        }

      printf_filtered ("%d %s", fp->num, target_pid_to_str (fp->ptid));

      if (fp->num == 0)

        printf_filtered (_(" (main process)"));

      printf_filtered (_(" at "));

      fputs_filtered (paddress (pc), gdb_stdout);

      sal = find_pc_line (pc, 0);

      if (sal.symtab)

        {

          char *tmp = strrchr (sal.symtab->filename, '/');

          if (tmp)

            printf_filtered (_(", file %s"), tmp + 1);

          else

            printf_filtered (_(", file %s"), sal.symtab->filename);

        }

      if (sal.line)

        printf_filtered (_(", line %d"), sal.line);

      if (!sal.symtab && !sal.line)

        {

          struct minimal_symbol *msym;

          msym = lookup_minimal_symbol_by_pc (pc);

          if (msym)

            printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym));

        }

      putchar_filtered ('\n');

    }

  if (printed == NULL)

    {

      if (requested > 0)

        printf_filtered (_("No fork number %d.\n"), requested);

      else

        printf_filtered (_("No forks.\n"));

    }

}

/* Save/restore mode variable 'detach_fork':

   We need to temporarily take over this mode variable, while

   preserving the user-specified state, and make sure that it

   gets restored in case of error.

   The int pointer that we use comes from the caller, so we can

   be called more than once (even though currently we don't need to).  */

static void

restore_detach_fork (void *arg)

{

  detach_fork = *(int *) arg;

}

static struct cleanup *

save_detach_fork (int *saved_val)

{

  *saved_val = detach_fork;

  return make_cleanup (restore_detach_fork, (void *) saved_val);

}

static void

checkpoint_command (char *args, int from_tty)

{

  struct target_waitstatus last_target_waitstatus;

  ptid_t last_target_ptid;

  struct value *fork_fn = NULL, *ret;

  struct fork_info *fp;

  pid_t retpid;

  struct cleanup *old_chain;

  long i;

  /* Make this temp var static, 'cause it's used in the error context.  */

  static int temp_detach_fork;

  /* Make the inferior fork, record its (and gdb's) state.  */

  if (lookup_minimal_symbol ("fork", NULL, NULL) != NULL)

    fork_fn = find_function_in_inferior ("fork");

  if (!fork_fn)

    if (lookup_minimal_symbol ("_fork", NULL, NULL) != NULL)

      fork_fn = find_function_in_inferior ("fork");

  if (!fork_fn)

    error (_("checkpoint: can't find fork function in inferior."));

  ret = value_from_longest (builtin_type_int, 0);

  old_chain = save_detach_fork (&temp_detach_fork);

  detach_fork = 0;

  ret = call_function_by_hand (fork_fn, 0, &ret);

  do_cleanups (old_chain);

  if (!ret)     /* Probably can't happen.  */

    error (_("checkpoint: call_function_by_hand returned null."));

  retpid = value_as_long (ret);

  get_last_target_status (&last_target_ptid, &last_target_waitstatus);

  if (from_tty)

    {

      int parent_pid;

      printf_filtered (_("checkpoint: fork returned pid %ld.\n"),

                       (long) retpid);

      if (info_verbose)

        {

          parent_pid = ptid_get_lwp (last_target_ptid);

          if (parent_pid == 0)

            parent_pid = ptid_get_pid (last_target_ptid);

          printf_filtered (_("   gdb says parent = %ld.\n"),

                           (long) parent_pid);

        }

    }

  fp = find_fork_pid (retpid);

  if (!fp)

    error (_("Failed to find new fork"));

  fork_save_infrun_state (fp, 1);

}

static void

linux_fork_context (struct fork_info *newfp, int from_tty)

{

  /* Now we attempt to switch processes.  */

  struct fork_info *oldfp = find_fork_ptid (inferior_ptid);

  ptid_t ptid;

  int id, i;

  if (!newfp)

    error (_("No such fork/process"));

  if (!oldfp)

    oldfp = add_fork (ptid_get_pid (inferior_ptid));

  fork_save_infrun_state (oldfp, 1);

  fork_load_infrun_state (newfp);

  printf_filtered (_("Switching to %s\n"),

                   target_pid_to_str (inferior_ptid));

  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);

}

/* Switch inferior process (fork) context, by process id.  */

static void

process_command (char *args, int from_tty)

{

  struct fork_info *fp;

  if (!args || !*args)

    error (_("Requires argument (process id to switch to)"));

  if ((fp = find_fork_pid (parse_and_eval_long (args))) == NULL)

    error (_("Not found: process id %s"), args);

  linux_fork_context (fp, from_tty);

}

/* Switch inferior process (fork) context, by fork id.  */

static void

fork_command (char *args, int from_tty)

{

  struct fork_info *fp;

  if (!args || !*args)

    error (_("Requires argument (fork id to switch to)"));

  if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)

    error (_("Not found: fork id %s"), args);

  linux_fork_context (fp, from_tty);

}

/* Switch inferior process (fork) context, by checkpoint id.  */

static void

restart_command (char *args, int from_tty)

{

  struct fork_info *fp;

  if (!args || !*args)

    error (_("Requires argument (checkpoint id to restart)"));

  if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)

    error (_("Not found: checkpoint id %s"), args);

  linux_fork_context (fp, from_tty);

}

void

_initialize_linux_fork (void)

{

  init_fork_list ();

  /* Set/show detach-on-fork: user-settable mode.  */

  add_setshow_boolean_cmd ("detach-on-fork", class_obscure, &detach_fork, _("\

Set whether gdb will detach the child of a fork."), _("\

Show whether gdb will detach the child of a fork."), _("\

Tells gdb whether to detach the child of a fork."),

                           NULL, NULL, &setlist, &showlist);

  /* Set/show restart-auto-finish: user-settable count.  Causes the

     first "restart" of a fork to do some number of "finish" commands

     before returning to user.

     Useful because otherwise the virgin fork process will be stopped

     somewhere in the un-interesting fork system call.  */

  /* Checkpoint command: create a fork of the inferior process

     and set it aside for later debugging.  */

  add_com ("checkpoint", class_obscure, checkpoint_command, _("\

Fork a duplicate process (experimental)."));

  /* Restart command: restore the context of a specified fork

     process.  May be used for "program forks" as well as for

     "debugger forks" (checkpoints).  */

  add_com ("restart", class_obscure, restart_command, _("\

restart <n>: restore program context from a checkpoint.\n\

Argument 'n' is checkpoint ID, as displayed by 'info checkpoints'."));

  /* Delete checkpoint command: kill the process and remove it from

     fork list.  */