Subversion Repositories or1k

/* Machine independent support for SVR4 /proc (process file system) for GDB.

   Copyright 1999, 2000, 2001 Free Software Foundation, Inc.

   Written by Michael Snyder at Cygnus Solutions.

   Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.

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 2 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, write to the Free Software Foundation,

Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "defs.h"

#include "inferior.h"

#include "target.h"

#include "gdbcore.h"

#include "gdbcmd.h"

#include "gdbthread.h"

#if defined (NEW_PROC_API)

#define _STRUCTURED_PROC 1      /* Should be done by configure script. */

#endif

#include <sys/procfs.h>

#ifdef HAVE_SYS_FAULT_H

#include <sys/fault.h>

#endif

#ifdef HAVE_SYS_SYSCALL_H

#include <sys/syscall.h>

#endif

#include <sys/errno.h>

#include <sys/wait.h>

#include <signal.h>

#include <ctype.h>

/*

 * PROCFS.C

 *

 * This module provides the interface between GDB and the

 * /proc file system, which is used on many versions of Unix

 * as a means for debuggers to control other processes.

 * Examples of the systems that use this interface are:

 *   Irix

 *   Solaris

 *   OSF

 *   Unixware

 *   AIX5

 *

 * /proc works by immitating a file system: you open a simulated file

 * that represents the process you wish to interact with, and

 * perform operations on that "file" in order to examine or change

 * the state of the other process.

 *

 * The most important thing to know about /proc and this module

 * is that there are two very different interfaces to /proc:

 *   One that uses the ioctl system call, and

 *   another that uses read and write system calls.

 * This module has to support both /proc interfaces.  This means

 * that there are two different ways of doing every basic operation.

 *

 * In order to keep most of the code simple and clean, I have

 * defined an interface "layer" which hides all these system calls.

 * An ifdef (NEW_PROC_API) determines which interface we are using,

 * and most or all occurrances of this ifdef should be confined to

 * this interface layer.

 */

/* Determine which /proc API we are using:

   The ioctl API defines PIOCSTATUS, while

   the read/write (multiple fd) API never does.  */

#ifdef NEW_PROC_API

#include <sys/types.h>

#include "gdb_dirent.h" /* opendir/readdir, for listing the LWP's */

#endif

#include <fcntl.h>      /* for O_RDONLY */

#include <unistd.h>     /* for "X_OK" */

#include "gdb_stat.h"   /* for struct stat */

/* Note: procfs-utils.h must be included after the above system header

   files, because it redefines various system calls using macros.

   This may be incompatible with the prototype declarations.  */

#include "proc-utils.h"

/* Prototypes for supply_gregset etc. */

#include "gregset.h"

/* =================== TARGET_OPS "MODULE" =================== */

/*

 * This module defines the GDB target vector and its methods.

 */

static void procfs_open (char *, int);

static void procfs_attach (char *, int);

static void procfs_detach (char *, int);

static void procfs_resume (ptid_t, int, enum target_signal);

static int procfs_can_run (void);

static void procfs_stop (void);

static void procfs_files_info (struct target_ops *);

static void procfs_fetch_registers (int);

static void procfs_store_registers (int);

static void procfs_notice_signals (ptid_t);

static void procfs_prepare_to_store (void);

static void procfs_kill_inferior (void);

static void procfs_mourn_inferior (void);

static void procfs_create_inferior (char *, char *, char **);

static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);

static int procfs_xfer_memory (CORE_ADDR, char *, int, int,

                               struct mem_attrib *attrib,

                               struct target_ops *);

static int procfs_thread_alive (ptid_t);

void procfs_find_new_threads (void);

char *procfs_pid_to_str (ptid_t);

struct target_ops procfs_ops;           /* the target vector */

static void

init_procfs_ops (void)

{

  procfs_ops.to_shortname          = "procfs";

  procfs_ops.to_longname           = "Unix /proc child process";

  procfs_ops.to_doc                =

    "Unix /proc child process (started by the \"run\" command).";

  procfs_ops.to_open               = procfs_open;

  procfs_ops.to_can_run            = procfs_can_run;

  procfs_ops.to_create_inferior    = procfs_create_inferior;

  procfs_ops.to_kill               = procfs_kill_inferior;

  procfs_ops.to_mourn_inferior     = procfs_mourn_inferior;

  procfs_ops.to_attach             = procfs_attach;

  procfs_ops.to_detach             = procfs_detach;

  procfs_ops.to_wait               = procfs_wait;

  procfs_ops.to_resume             = procfs_resume;

  procfs_ops.to_prepare_to_store   = procfs_prepare_to_store;

  procfs_ops.to_fetch_registers    = procfs_fetch_registers;

  procfs_ops.to_store_registers    = procfs_store_registers;

  procfs_ops.to_xfer_memory        = procfs_xfer_memory;

  procfs_ops.to_insert_breakpoint  =  memory_insert_breakpoint;

  procfs_ops.to_remove_breakpoint  =  memory_remove_breakpoint;

  procfs_ops.to_notice_signals     = procfs_notice_signals;

  procfs_ops.to_files_info         = procfs_files_info;

  procfs_ops.to_stop               = procfs_stop;

  procfs_ops.to_terminal_init      = terminal_init_inferior;

  procfs_ops.to_terminal_inferior  = terminal_inferior;

  procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;

  procfs_ops.to_terminal_ours      = terminal_ours;

  procfs_ops.to_terminal_info      = child_terminal_info;

  procfs_ops.to_find_new_threads   = procfs_find_new_threads;

  procfs_ops.to_thread_alive       = procfs_thread_alive;

  procfs_ops.to_pid_to_str         = procfs_pid_to_str;

  procfs_ops.to_has_all_memory     = 1;

  procfs_ops.to_has_memory         = 1;

  procfs_ops.to_has_execution      = 1;

  procfs_ops.to_has_stack          = 1;

  procfs_ops.to_has_registers      = 1;

  procfs_ops.to_stratum            = process_stratum;

  procfs_ops.to_has_thread_control = tc_schedlock;

  procfs_ops.to_magic              = OPS_MAGIC;

}

/* =================== END, TARGET_OPS "MODULE" =================== */

/*

 * World Unification:

 *

 * Put any typedefs, defines etc. here that are required for

 * the unification of code that handles different versions of /proc.

 */

#ifdef NEW_PROC_API             /* Solaris 7 && 8 method for watchpoints */

#ifdef WA_READ

     enum { READ_WATCHFLAG  = WA_READ,

            WRITE_WATCHFLAG = WA_WRITE,

            EXEC_WATCHFLAG  = WA_EXEC,

            AFTER_WATCHFLAG = WA_TRAPAFTER

     };

#endif

#else                           /* Irix method for watchpoints */

     enum { READ_WATCHFLAG  = MA_READ,

            WRITE_WATCHFLAG = MA_WRITE,

            EXEC_WATCHFLAG  = MA_EXEC,

            AFTER_WATCHFLAG = 0          /* trapafter not implemented */

     };

#endif

/* gdb_sigset_t */

#ifdef HAVE_PR_SIGSET_T

typedef pr_sigset_t gdb_sigset_t;

#else

typedef sigset_t gdb_sigset_t;

#endif

/* sigaction */

#ifdef HAVE_PR_SIGACTION64_T

typedef pr_sigaction64_t gdb_sigaction_t;

#else

typedef struct sigaction gdb_sigaction_t;

#endif

/* siginfo */

#ifdef HAVE_PR_SIGINFO64_T

typedef pr_siginfo64_t gdb_siginfo_t;

#else

typedef struct siginfo gdb_siginfo_t;

#endif

/* gdb_premptysysset */

#ifdef premptysysset

#define gdb_premptysysset premptysysset

#else

#define gdb_premptysysset premptyset

#endif

/* praddsysset */

#ifdef praddsysset

#define gdb_praddsysset praddsysset

#else

#define gdb_praddsysset praddset

#endif

/* prdelsysset */

#ifdef prdelsysset

#define gdb_prdelsysset prdelsysset

#else

#define gdb_prdelsysset prdelset

#endif

/* prissyssetmember */

#ifdef prissyssetmember

#define gdb_pr_issyssetmember prissyssetmember

#else

#define gdb_pr_issyssetmember prismember

#endif

/* As a feature test, saying ``#if HAVE_PRSYSENT_T'' everywhere isn't

   as intuitively descriptive as it could be, so we'll define

   DYNAMIC_SYSCALLS to mean the same thing.  Anyway, at the time of

   this writing, this feature is only found on AIX5 systems and

   basically means that the set of syscalls is not fixed.  I.e,

   there's no nice table that one can #include to get all of the

   syscall numbers.  Instead, they're stored in /proc/PID/sysent

   for each process.  We are at least guaranteed that they won't

   change over the lifetime of the process.  But each process could

   (in theory) have different syscall numbers.

*/

#ifdef HAVE_PRSYSENT_T

#define DYNAMIC_SYSCALLS

#endif

/* =================== STRUCT PROCINFO "MODULE" =================== */

     /* FIXME: this comment will soon be out of date W.R.T. threads.  */

/* The procinfo struct is a wrapper to hold all the state information

   concerning a /proc process.  There should be exactly one procinfo

   for each process, and since GDB currently can debug only one

   process at a time, that means there should be only one procinfo.

   All of the LWP's of a process can be accessed indirectly thru the

   single process procinfo.

   However, against the day when GDB may debug more than one process,

   this data structure is kept in a list (which for now will hold no

   more than one member), and many functions will have a pointer to a

   procinfo as an argument.

   There will be a separate procinfo structure for use by the (not yet

   implemented) "info proc" command, so that we can print useful

   information about any random process without interfering with the

   inferior's procinfo information. */

#ifdef NEW_PROC_API

/* format strings for /proc paths */

# ifndef CTL_PROC_NAME_FMT

#  define MAIN_PROC_NAME_FMT   "/proc/%d"

#  define CTL_PROC_NAME_FMT    "/proc/%d/ctl"

#  define AS_PROC_NAME_FMT     "/proc/%d/as"

#  define MAP_PROC_NAME_FMT    "/proc/%d/map"

#  define STATUS_PROC_NAME_FMT "/proc/%d/status"

#  define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/8096/lstatus")

# endif

/* the name of the proc status struct depends on the implementation */

typedef pstatus_t   gdb_prstatus_t;

typedef lwpstatus_t gdb_lwpstatus_t;

#else /* ! NEW_PROC_API */

/* format strings for /proc paths */

# ifndef CTL_PROC_NAME_FMT

#  define MAIN_PROC_NAME_FMT   "/proc/%05d"

#  define CTL_PROC_NAME_FMT    "/proc/%05d"

#  define AS_PROC_NAME_FMT     "/proc/%05d"

#  define MAP_PROC_NAME_FMT    "/proc/%05d"

#  define STATUS_PROC_NAME_FMT "/proc/%05d"

#  define MAX_PROC_NAME_SIZE sizeof("/proc/ttttppppp")

# endif

/* the name of the proc status struct depends on the implementation */

typedef prstatus_t gdb_prstatus_t;

typedef prstatus_t gdb_lwpstatus_t;

#endif /* NEW_PROC_API */

typedef struct procinfo {

  struct procinfo *next;

  int pid;                      /* Process ID    */

  int tid;                      /* Thread/LWP id */

  /* process state */

  int was_stopped;

  int ignore_next_sigstop;

  /* The following four fd fields may be identical, or may contain

     several different fd's, depending on the version of /proc

     (old ioctl or new read/write).  */

  int ctl_fd;                   /* File descriptor for /proc control file */

  /*

   * The next three file descriptors are actually only needed in the

   * read/write, multiple-file-descriptor implemenation (NEW_PROC_API).

   * However, to avoid a bunch of #ifdefs in the code, we will use

   * them uniformly by (in the case of the ioctl single-file-descriptor

   * implementation) filling them with copies of the control fd.

   */

  int status_fd;                /* File descriptor for /proc status file */

  int as_fd;                    /* File descriptor for /proc as file */

  char pathname[MAX_PROC_NAME_SIZE];    /* Pathname to /proc entry */

  fltset_t saved_fltset;        /* Saved traced hardware fault set */

  gdb_sigset_t saved_sigset;    /* Saved traced signal set */

  gdb_sigset_t saved_sighold;   /* Saved held signal set */

  sysset_t *saved_exitset;      /* Saved traced system call exit set */

  sysset_t *saved_entryset;     /* Saved traced system call entry set */

  gdb_prstatus_t prstatus;      /* Current process status info */

#ifndef NEW_PROC_API

  gdb_fpregset_t fpregset;      /* Current floating point registers */

#endif

#ifdef DYNAMIC_SYSCALLS

  int num_syscalls;             /* Total number of syscalls */

  char **syscall_names;         /* Syscall number to name map */

#endif

  struct procinfo *thread_list;

  int status_valid : 1;

  int gregs_valid  : 1;

  int fpregs_valid : 1;

  int threads_valid: 1;

} procinfo;

static char errmsg[128];        /* shared error msg buffer */

/* Function prototypes for procinfo module: */

static procinfo *find_procinfo_or_die (int pid, int tid);

static procinfo *find_procinfo (int pid, int tid);

static procinfo *create_procinfo (int pid, int tid);

static void destroy_procinfo (procinfo * p);

static void do_destroy_procinfo_cleanup (void *);

static void dead_procinfo (procinfo * p, char *msg, int killp);

static int open_procinfo_files (procinfo * p, int which);

static void close_procinfo_files (procinfo * p);

static int sysset_t_size (procinfo *p);

static sysset_t *sysset_t_alloc (procinfo * pi);

#ifdef DYNAMIC_SYSCALLS

static void load_syscalls (procinfo *pi);

static void free_syscalls (procinfo *pi);

static int find_syscall (procinfo *pi, char *name);

#endif /* DYNAMIC_SYSCALLS */

/* The head of the procinfo list: */

static procinfo * procinfo_list;

/*

 * Function: find_procinfo

 *

 * Search the procinfo list.

 *

 * Returns: pointer to procinfo, or NULL if not found.

 */

static procinfo *

find_procinfo (int pid, int tid)

{

  procinfo *pi;

  for (pi = procinfo_list; pi; pi = pi->next)

    if (pi->pid == pid)

      break;

  if (pi)

    if (tid)

      {

        /* Don't check threads_valid.  If we're updating the

           thread_list, we want to find whatever threads are already

           here.  This means that in general it is the caller's

           responsibility to check threads_valid and update before

           calling find_procinfo, if the caller wants to find a new

           thread. */

        for (pi = pi->thread_list; pi; pi = pi->next)

          if (pi->tid == tid)

            break;

      }

  return pi;

}

/*

 * Function: find_procinfo_or_die

 *

 * Calls find_procinfo, but errors on failure.

 */

static procinfo *

find_procinfo_or_die (int pid, int tid)

{

  procinfo *pi = find_procinfo (pid, tid);

  if (pi == NULL)

    {

      if (tid)

        error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.",

               pid, tid);

      else

        error ("procfs: couldn't find pid %d in procinfo list.", pid);

    }

  return pi;

}

/* open_with_retry() is a wrapper for open().  The appropriate

   open() call is attempted; if unsuccessful, it will be retried as

   many times as needed for the EAGAIN and EINTR conditions.

   For other conditions, open_with_retry() will retry the open() a

   limited number of times.  In addition, a short sleep is imposed

   prior to retrying the open().  The reason for this sleep is to give

   the kernel a chance to catch up and create the file in question in

   the event that GDB "wins" the race to open a file before the kernel

   has created it.  */

static int

open_with_retry (const char *pathname, int flags)

{

  int retries_remaining, status;

  retries_remaining = 2;

  while (1)

    {

      status = open (pathname, flags);

      if (status >= 0 || retries_remaining == 0)

        break;

      else if (errno != EINTR && errno != EAGAIN)

        {

          retries_remaining--;

          sleep (1);

        }

    }

  return status;

}

/*

 * Function: open_procinfo_files

 *

 * Open the file descriptor for the process or LWP.

 * ifdef NEW_PROC_API, we only open the control file descriptor;

 * the others are opened lazily as needed.

 * else (if not NEW_PROC_API), there is only one real

 * file descriptor, but we keep multiple copies of it so that

 * the code that uses them does not have to be #ifdef'd.

 *

 * Return: file descriptor, or zero for failure.

 */

enum { FD_CTL, FD_STATUS, FD_AS };

static int

open_procinfo_files (procinfo *pi, int which)

{

#ifdef NEW_PROC_API

  char tmp[MAX_PROC_NAME_SIZE];

#endif

  int  fd;

  /*

   * This function is getting ALMOST long enough to break up into several.

   * Here is some rationale:

   *

   * NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):

   *   There are several file descriptors that may need to be open

   *   for any given process or LWP.  The ones we're intereted in are:

   *     - control       (ctl)    write-only    change the state

   *     - status        (status) read-only     query the state

   *     - address space (as)     read/write    access memory

   *     - map           (map)    read-only     virtual addr map

   *   Most of these are opened lazily as they are needed.

   *   The pathnames for the 'files' for an LWP look slightly

   *   different from those of a first-class process:

   *     Pathnames for a process (<proc-id>):

   *       /proc/<proc-id>/ctl

   *       /proc/<proc-id>/status

   *       /proc/<proc-id>/as

   *       /proc/<proc-id>/map

   *     Pathnames for an LWP (lwp-id):

   *       /proc/<proc-id>/lwp/<lwp-id>/lwpctl

   *       /proc/<proc-id>/lwp/<lwp-id>/lwpstatus

   *   An LWP has no map or address space file descriptor, since

   *   the memory map and address space are shared by all LWPs.

   *

   * Everyone else (Solaris 2.5, Irix, OSF)

   *   There is only one file descriptor for each process or LWP.

   *   For convenience, we copy the same file descriptor into all

   *   three fields of the procinfo struct (ctl_fd, status_fd, and

   *   as_fd, see NEW_PROC_API above) so that code that uses them

   *   doesn't need any #ifdef's.

   *     Pathname for all:

   *       /proc/<proc-id>

   *

   *   Solaris 2.5 LWP's:

   *     Each LWP has an independent file descriptor, but these

   *     are not obtained via the 'open' system call like the rest:

   *     instead, they're obtained thru an ioctl call (PIOCOPENLWP)

   *     to the file descriptor of the parent process.

   *

   *   OSF threads:

   *     These do not even have their own independent file descriptor.

   *     All operations are carried out on the file descriptor of the

   *     parent process.  Therefore we just call open again for each

   *     thread, getting a new handle for the same 'file'.

   */

#ifdef NEW_PROC_API

  /*

   * In this case, there are several different file descriptors that

   * we might be asked to open.  The control file descriptor will be

   * opened early, but the others will be opened lazily as they are

   * needed.

   */

  strcpy (tmp, pi->pathname);

  switch (which) {      /* which file descriptor to open? */

  case FD_CTL:

    if (pi->tid)

      strcat (tmp, "/lwpctl");

    else

      strcat (tmp, "/ctl");

    fd = open_with_retry (tmp, O_WRONLY);

    if (fd <= 0)

      return 0;          /* fail */

    pi->ctl_fd = fd;

    break;

  case FD_AS:

    if (pi->tid)

      return 0;          /* there is no 'as' file descriptor for an lwp */

    strcat (tmp, "/as");

    fd = open_with_retry (tmp, O_RDWR);

    if (fd <= 0)

      return 0;          /* fail */

    pi->as_fd = fd;

    break;

  case FD_STATUS:

    if (pi->tid)

      strcat (tmp, "/lwpstatus");

    else

      strcat (tmp, "/status");

    fd = open_with_retry (tmp, O_RDONLY);

    if (fd <= 0)

      return 0;          /* fail */

    pi->status_fd = fd;

    break;

  default:

    return 0;            /* unknown file descriptor */

  }

#else  /* not NEW_PROC_API */

  /*

   * In this case, there is only one file descriptor for each procinfo

   * (ie. each process or LWP).  In fact, only the file descriptor for

   * the process can actually be opened by an 'open' system call.

   * The ones for the LWPs have to be obtained thru an IOCTL call

   * on the process's file descriptor.

   *

   * For convenience, we copy each procinfo's single file descriptor

   * into all of the fields occupied by the several file descriptors

   * of the NEW_PROC_API implementation.  That way, the code that uses

   * them can be written without ifdefs.

   */

#ifdef PIOCTSTATUS      /* OSF */

  /* Only one FD; just open it. */

  if ((fd = open_with_retry (pi->pathname, O_RDWR)) == 0)

    return 0;

#else                   /* Sol 2.5, Irix, other? */

  if (pi->tid == 0)      /* Master procinfo for the process */

    {

      fd = open_with_retry (pi->pathname, O_RDWR);

      if (fd <= 0)

        return 0;        /* fail */

    }

  else                  /* LWP thread procinfo */

    {

#ifdef PIOCOPENLWP      /* Sol 2.5, thread/LWP */

      procinfo *process;

      int lwpid = pi->tid;

      /* Find the procinfo for the entire process. */

      if ((process = find_procinfo (pi->pid, 0)) == NULL)

        return 0;        /* fail */

      /* Now obtain the file descriptor for the LWP. */

      if ((fd = ioctl (process->ctl_fd, PIOCOPENLWP, &lwpid)) <= 0)

        return 0;        /* fail */

#else                   /* Irix, other? */

      return 0;          /* Don't know how to open threads */

#endif  /* Sol 2.5 PIOCOPENLWP */

    }

#endif  /* OSF     PIOCTSTATUS */

  pi->ctl_fd = pi->as_fd = pi->status_fd = fd;

#endif  /* NEW_PROC_API */

  return 1;             /* success */

}

/*

 * Function: create_procinfo

 *

 * Allocate a data structure and link it into the procinfo list.

 * (First tries to find a pre-existing one (FIXME: why?)

 *

 * Return: pointer to new procinfo struct.

 */

static procinfo *

create_procinfo (int pid, int tid)

{

  procinfo *pi, *parent;

  if ((pi = find_procinfo (pid, tid)))

    return pi;                  /* Already exists, nothing to do. */

  /* find parent before doing malloc, to save having to cleanup */

  if (tid != 0)

    parent = find_procinfo_or_die (pid, 0);      /* FIXME: should I

                                                   create it if it

                                                   doesn't exist yet? */

  pi = (procinfo *) xmalloc (sizeof (procinfo));

  memset (pi, 0, sizeof (procinfo));

  pi->pid = pid;

  pi->tid = tid;

#ifdef DYNAMIC_SYSCALLS

  load_syscalls (pi);

#endif

  /* Chain into list.  */

  if (tid == 0)

    {

      sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);

      pi->next = procinfo_list;

      procinfo_list = pi;

    }

  else

    {

#ifdef NEW_PROC_API

      sprintf (pi->pathname, "/proc/%05d/lwp/%d", pid, tid);

#else

      sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);

#endif

      pi->next = parent->thread_list;

      parent->thread_list = pi;

    }

  return pi;

}

/*

 * Function: close_procinfo_files

 *

 * Close all file descriptors associated with the procinfo

 */

static void

close_procinfo_files (procinfo *pi)

{

  if (pi->ctl_fd > 0)

    close (pi->ctl_fd);

#ifdef NEW_PROC_API

  if (pi->as_fd > 0)

    close (pi->as_fd);

  if (pi->status_fd > 0)

    close (pi->status_fd);

#endif

  pi->ctl_fd = pi->as_fd = pi->status_fd = 0;

}

/*

 * Function: destroy_procinfo

 *

 * Destructor function.  Close, unlink and deallocate the object.

 */

static void

destroy_one_procinfo (procinfo **list, procinfo *pi)

{

  procinfo *ptr;

  /* Step one: unlink the procinfo from its list */

  if (pi == *list)

    *list = pi->next;

  else

    for (ptr = *list; ptr; ptr = ptr->next)

      if (ptr->next == pi)

        {

          ptr->next =  pi->next;

          break;

        }

  /* Step two: close any open file descriptors */

  close_procinfo_files (pi);

  /* Step three: free the memory. */

#ifdef DYNAMIC_SYSCALLS

  free_syscalls (pi);

#endif

  xfree (pi);

}

static void

destroy_procinfo (procinfo *pi)

{

  procinfo *tmp;

  if (pi->tid != 0)      /* destroy a thread procinfo */

    {

      tmp = find_procinfo (pi->pid, 0);  /* find the parent process */

      destroy_one_procinfo (&tmp->thread_list, pi);