gdb/proc-api.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

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

  3.    Copyright (C) 1999-2015 Free Software Foundation, Inc.

  5.    Written by Michael Snyder at Cygnus Solutions.
  6.    Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.

  8.    This file is part of GDB.

  10.    This program is free software; you can redistribute it and/or modify
  11.    it under the terms of the GNU General Public License as published by
  12.    the Free Software Foundation; either version 3 of the License, or
  13.    (at your option) any later version.

  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.

  20.    You should have received a copy of the GNU General Public License
  21.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  23. /*
  24. * Pretty-print trace of api calls to the /proc api
  25. * (ioctl or read/write calls).
  26. *
  27. */

  29. #include "defs.h"
  30. #include "gdbcmd.h"
  31. #include "completer.h"

  33. #if defined (NEW_PROC_API)
  34. ‌#define _STRUCTURED_PROC 1
  35. #endif

  37. #include <sys/types.h>
  38. #include <sys/procfs.h>
  39. #ifdef HAVE_SYS_PROC_H
  40. #include <sys/proc.h>        /* for struct proc */
  41. #endif
  42. #ifdef HAVE_SYS_USER_H
  43. #include <sys/user.h>        /* for struct user */
  44. #endif
  45. #include <fcntl.h>        /* for O_RDWR etc.  */
  46. #include "gdb_wait.h"

  48. #include "proc-utils.h"

  50. /*  Much of the information used in the /proc interface, particularly for
  51.     printing status information, is kept as tables of structures of the
  52.     following form.  These tables can be used to map numeric values to
  53.     their symbolic names and to a string that describes their specific use.  */

  55. ‌struct trans {
  56.   long value;                   /* The numeric value */
  57.   char *name;                   /* The equivalent symbolic value */
  58.   char *desc;                   /* Short description of value */
  59. };

  61. ‌static int   procfs_trace    = 0;
  62. ‌static FILE *procfs_file     = NULL;
  63. ‌static char *procfs_filename = "procfs_trace";

  65. static void
  66. ‌prepare_to_trace (void)
  67. {
  68.   if (procfs_trace)                        /* if procfs tracing turned on */
  69.     if (procfs_file == NULL)                /* if output file not yet open */
  70.       if (procfs_filename != NULL)        /* if output filename known */
  71.         procfs_file = fopen (procfs_filename, "a");        /* open output file */
  72. }

  74. static void
  75. ‌set_procfs_trace_cmd (char *args, int from_tty, struct cmd_list_element *c)
  76. {
  77. #if 0        /* not sure what I might actually need to do here, if anything */
  78.   if (procfs_file)
  79.     fflush (procfs_file);
  80. #endif
  81. }

  83. static void
  84. ‌set_procfs_file_cmd (char *args, int from_tty, struct cmd_list_element *c)
  85. {
  86.   /* Just changed the filename for procfs tracing.
  87.      If a file was already open, close it.  */
  88.   if (procfs_file)
  89.     fclose (procfs_file);
  90.   procfs_file = NULL;
  91. }


  94. #ifndef NEW_PROC_API

  96. ‌static struct trans ioctl_table[] = {
  97. #ifdef PIOCACINFO                        /* irix */
  98.   { PIOCACINFO,    "PIOCACINFO",   "get process account info" },
  99. #endif
  100.   { PIOCACTION,    "PIOCACTION",   "get signal action structs" },
  101. #ifdef PIOCARGUMENTS                        /* osf */
  102.   { PIOCARGUMENTS, "PIOCARGUMENTS", "command line args" },
  103. #endif
  104. #ifdef PIOCAUXV                                /* solaris aux vectors */
  105.   { PIOCAUXV,      "PIOCAUXV",     "get aux vector" },
  106.   { PIOCNAUXV,     "PIOCNAUXV",    "get number of aux vector entries" },
  107. #endif /* AUXV */
  108.   { PIOCCFAULT,    "PIOCCFAULT",   "clear current fault" },
  109.   { PIOCCRED,      "PIOCCRED",     "get process credentials" },
  110. #ifdef PIOCENEVCTRS                        /* irix event counters */
  111.   { PIOCENEVCTRS,    "PIOCENEVCTRS",    "acquire and start event counters" },
  112.   { PIOCGETEVCTRL,   "PIOCGETEVCTRL",   "get control info of event counters" },
  113.   { PIOCGETEVCTRS,   "PIOCGETEVCTRS",   "dump event counters" },
  114.   { PIOCGETPREVCTRS, "PIOCGETPREVCTRS", "dump event counters & prusage info" },
  115.   { PIOCRELEVCTRS,   "PIOCRELEVCTRS",   "release/stop event counters" },
  116.   { PIOCSETEVCTRL,   "PIOCSETEVCTRL",   "set control info of event counters" },
  117.   { PIOCGETPTIMER,   "PIOCGETPTIMER",   "get process timers" },
  118. #endif        /* irix event counters */
  119.   { PIOCGENTRY,    "PIOCGENTRY",   "get traced syscall entry set" },
  120. #if defined (PIOCGETPR)
  121.   { PIOCGETPR,     "PIOCGETPR",    "read struct proc" },
  122. #endif
  123. #if defined (PIOCGETU)
  124.   { PIOCGETU,      "PIOCGETU",     "read user area" },
  125. #endif
  126. #if defined (PIOCGETUTK) && (defined(KERNEL) || defined(SHOW_UTT)) /* osf */
  127.   { PIOCGETUTK,  "PIOCGETUTK", "get the utask struct" },
  128. #endif
  129.   { PIOCGEXIT,     "PIOCGEXIT",    "get traced syscall exit  set" },
  130.   { PIOCGFAULT,    "PIOCGFAULT",   "get traced fault set" },
  131. #ifdef PIOCGFPCR                        /* osf */
  132.   { PIOCGFPCR,     "PIOCGFPCR",    "get FP control register" },
  133.   { PIOCSFPCR,     "PIOCSFPCR",    "set FP conrtol register" },
  134. #endif
  135.   { PIOCGFPREG,    "PIOCGFPREG",   "get floating point registers" },
  136.   { PIOCGHOLD,     "PIOCGHOLD",    "get held signal set" },
  137.   { PIOCGREG,      "PIOCGREG",     "get general registers" },
  138.   { PIOCGROUPS,    "PIOCGROUPS",   "get supplementary groups" },
  139. #ifdef PIOCGSPCACT                        /* osf */
  140.   { PIOCGSPCACT,   "PIOCGSPCACT",  "get special action" },
  141.   { PIOCSSPCACT,   "PIOCSSPCACT",  "set special action" },
  142. #endif
  143.   { PIOCGTRACE,    "PIOCGTRACE",   "get traced signal set" },
  144. #ifdef PIOCGWATCH                        /* irix watchpoints */
  145.   { PIOCGWATCH,    "PIOCGWATCH",   "get watchpoint" },
  146.   { PIOCSWATCH,    "PIOCSWATCH",   "set watchpoint" },
  147.   { PIOCNWATCH,    "PIOCNWATCH",   "get number of watchpoints" },
  148. #endif        /* irix watchpoints */
  149. #ifdef PIOCGWIN                                /* solaris sparc */
  150.   { PIOCGWIN,      "PIOCGWIN",     "get gwindows_t" },
  151. #endif
  152. #ifdef PIOCGXREG                        /* solaris sparc extra regs */
  153.   { PIOCGXREGSIZE, "PIOCXREGSIZE", "get extra register state size" },
  154.   { PIOCGXREG,     "PIOCGXREG",    "get extra register state" },
  155.   { PIOCSXREG,     "PIOCSXREG",    "set extra register state" },
  156. #endif /* XREG */
  157.   { PIOCKILL,      "PIOCKILL",     "send signal" },
  158. #ifdef PIOCLDT                                /* solaris i386 */
  159.   { PIOCLDT,       "PIOCLDT",      "get LDT" },
  160.   { PIOCNLDT,      "PIOCNLDT",     "get number of LDT entries" },
  161. #endif
  162. #ifdef PIOCLSTATUS                        /* solaris */
  163.   { PIOCLSTATUS,   "PIOCLSTATUS",  "get status of all lwps" },
  164.   { PIOCLUSAGE,    "PIOCLUSAGE",   "get resource usage of all lwps" },
  165.   { PIOCOPENLWP,   "PIOCOPENLWP",  "get lwp file descriptor" },
  166.   { PIOCLWPIDS,    "PIOCLWPIDS",   "get lwp identifiers" },
  167. #endif /* LWP */
  168.   { PIOCMAP,       "PIOCMAP",      "get memory map information" },
  169.   { PIOCMAXSIG,    "PIOCMAXSIG",   "get max signal number" },
  170.   { PIOCNICE,      "PIOCNICE",     "set nice priority" },
  171.   { PIOCNMAP,      "PIOCNMAP",     "get number of memory mappings" },
  172.   { PIOCOPENM,     "PIOCOPENM",    "open mapped object for reading" },
  173. #ifdef PIOCOPENMOBS                        /* osf */
  174.   { PIOCOPENMOBS,  "PIOCOPENMOBS", "open mapped object" },
  175. #endif
  176. #ifdef PIOCOPENPD        /* solaris */
  177.   { PIOCOPENPD,    "PIOCOPENPD",   "get page data file descriptor" },
  178. #endif
  179.   { PIOCPSINFO,    "PIOCPSINFO",   "get ps(1) information" },
  180.   { PIOCRESET,     "PIOCRESET",    "reset process flags" },
  181.   { PIOCRFORK,     "PIOCRFORK",    "reset inherit-on-fork flag" },
  182.   { PIOCRRLC,      "PIOCRRLC",     "reset run-on-last-close flag" },
  183.   { PIOCRUN,       "PIOCRUN",      "make process runnable" },
  184. #ifdef PIOCSAVECCNTRS                        /* irix */
  185.   { PIOCSAVECCNTRS, "PIOCSAVECCNTRS", "parent gets child cntrs" },
  186. #endif
  187.   { PIOCSENTRY,    "PIOCSENTRY",   "set traced syscall entry set" },
  188.   { PIOCSET,       "PIOCSET",      "set process flags" },
  189.   { PIOCSEXIT,     "PIOCSEXIT",    "set traced syscall exit  set" },
  190.   { PIOCSFAULT,    "PIOCSFAULT",   "set traced fault set" },
  191.   { PIOCSFORK,     "PIOCSFORK",    "set inherit-on-fork flag" },
  192.   { PIOCSFPREG,    "PIOCSFPREG",   "set floating point registers" },
  193.   { PIOCSHOLD,     "PIOCSHOLD",    "set held signal set" },
  194.   { PIOCSREG,      "PIOCSREG",     "set general registers" },
  195.   { PIOCSRLC,      "PIOCSRLC",     "set run-on-last-close flag" },
  196.   { PIOCSSIG,      "PIOCSSIG",     "set current signal" },
  197.   { PIOCSTATUS,    "PIOCSTATUS",   "get process status" },
  198.   { PIOCSTOP,      "PIOCSTOP",     "post stop request" },
  199.   { PIOCSTRACE,    "PIOCSTRACE",   "set traced signal set" },
  200.   { PIOCUNKILL,    "PIOCUNKILL",   "delete a signal" },
  201. #ifdef PIOCUSAGE        /* solaris */
  202.   { PIOCUSAGE,     "PIOCUSAGE",    "get resource usage" },
  203. #endif
  204.   { PIOCWSTOP,     "PIOCWSTOP",    "wait for process to stop" },

  206. #ifdef PIOCNTHR                                /* osf threads */
  207.   { PIOCNTHR,      "PIOCNTHR",     "get thread count" },
  208.   { PIOCRTINH,     "PIOCRTINH",    "reset inherit-on-thread-creation" },
  209.   { PIOCSTINH,     "PIOCSTINH",    "set   inherit-on-thread-creation" },
  210.   { PIOCTLIST,     "PIOCTLIST",    "get thread ids" },
  211.   { PIOCXPTH,      "PIOCXPTH",     "translate port to thread handle" },
  212.   { PIOCTRUN,      "PIOCTRUN",     "make thread runnable" },
  213.   { PIOCTSTATUS,   "PIOCTSTATUS",  "get thread status" },
  214.   { PIOCTSTOP,     "PIOCTSTOP",    "stop a thread" },
  215.   /* ... TGTRACE TSTRACE TSSIG TKILL TUNKILL TCFAULT TGFAULT TSFAULT
  216.      TGFPREG TSFPREG TGREG TSREG TACTION TTERM TABRUN TGENTRY TSENTRY
  217.      TGEXIT TSEXIT TSHOLD ... thread functions */
  218. #endif /* osf threads */
  219.   { -1,            NULL,           NULL }
  220. };

  222. int
  223. ‌ioctl_with_trace (int fd, long opcode, void *ptr, char *file, int line)
  224. {
  225.   int i = 0;
  226.   int ret;
  227.   int arg1;

  229.   prepare_to_trace ();

  231.   if (procfs_trace)
  232.     {
  233.       for (i = 0; ioctl_table[i].name != NULL; i++)
  234.         if (ioctl_table[i].value == opcode)
  235.           break;

  237.       if (info_verbose)
  238.         fprintf (procfs_file ? procfs_file : stdout,
  239.                  "%s:%d -- ", file, line);
  240.       switch (opcode) {
  241.       case PIOCSET:
  242.         arg1 = ptr ? *(long *) ptr : 0;
  243.         fprintf (procfs_file ? procfs_file : stdout,
  244.                  "ioctl (PIOCSET,   %s) %s\n",
  245.                  arg1 == PR_FORK  ? "PR_FORK"  :
  246.                  arg1 == PR_RLC   ? "PR_RLC"   :
  247. #ifdef PR_ASYNC
  248.                  arg1 == PR_ASYNC ? "PR_ASYNC" :
  249. #endif
  250.                  "<unknown flag>",
  251.                  info_verbose ? ioctl_table[i].desc : "");
  252.         break;
  253.       case PIOCRESET:
  254.         arg1 = ptr ? *(long *) ptr : 0;
  255.         fprintf (procfs_file ? procfs_file : stdout,
  256.                  "ioctl (PIOCRESET, %s) %s\n",
  257.                  arg1 == PR_FORK  ? "PR_FORK"  :
  258.                  arg1 == PR_RLC   ? "PR_RLC"   :
  259. #ifdef PR_ASYNC
  260.                  arg1 == PR_ASYNC ? "PR_ASYNC" :
  261. #endif
  262.                  "<unknown flag>",
  263.                  info_verbose ? ioctl_table[i].desc : "");
  264.         break;
  265.       case PIOCSTRACE:
  266.         fprintf (procfs_file ? procfs_file : stdout,
  267.                  "ioctl (PIOCSTRACE) ");
  268.         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
  269.                                      (sigset_t *) ptr, 0);
  270.         break;
  271.       case PIOCSFAULT:
  272.         fprintf (procfs_file ? procfs_file : stdout,
  273.                  "ioctl (%s) ",
  274.                  opcode == PIOCSFAULT ? "PIOCSFAULT" : "PIOCGFAULT");
  275.         proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
  276.                                     (fltset_t *) ptr, 0);
  277.         break;
  278.       case PIOCSENTRY:
  279.         fprintf (procfs_file ? procfs_file : stdout,
  280.                  "ioctl (%s) ",
  281.                  opcode == PIOCSENTRY ? "PIOCSENTRY" : "PIOCGENTRY");
  282.         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
  283.                                     (sysset_t *) ptr, 0);
  284.         break;
  285.       case PIOCSEXIT:
  286.         fprintf (procfs_file ? procfs_file : stdout,
  287.                  "ioctl (%s) ",
  288.                  opcode == PIOCSEXIT ? "PIOCSEXIT" : "PIOCGEXIT");
  289.         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
  290.                                     (sysset_t *) ptr, 0);
  291.         break;
  292.       case PIOCSHOLD:
  293.         fprintf (procfs_file ? procfs_file : stdout,
  294.                  "ioctl (%s) ",
  295.                  opcode == PIOCSHOLD ? "PIOCSHOLD" : "PIOCGHOLD");
  296.         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
  297.                                      (sigset_t *) ptr, 0);
  298.         break;
  299.       case PIOCSSIG:
  300.         fprintf (procfs_file ? procfs_file : stdout,
  301.                  "ioctl (PIOCSSIG) ");
  302.         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
  303.                                   ptr ? ((siginfo_t *) ptr)->si_signo : 0,
  304.                                   0);
  305.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  306.         break;
  307.       case PIOCRUN:
  308.         fprintf (procfs_file ? procfs_file : stdout,
  309.                  "ioctl (PIOCRUN) ");

  311.         arg1 = ptr ? *(long *) ptr : 0;
  312.         if (arg1 & PRCSIG)
  313.           fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
  314.         if (arg1 & PRCFAULT)
  315.           fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
  316.         if (arg1 & PRSTRACE)
  317.           fprintf (procfs_file ? procfs_file : stdout, "setTrace ");
  318.         if (arg1 & PRSHOLD)
  319.           fprintf (procfs_file ? procfs_file : stdout, "setHold ");
  320.         if (arg1 & PRSFAULT)
  321.           fprintf (procfs_file ? procfs_file : stdout, "setFlt ");
  322.         if (arg1 & PRSVADDR)
  323.           fprintf (procfs_file ? procfs_file : stdout, "setVaddr ");
  324.         if (arg1 & PRSTEP)
  325.           fprintf (procfs_file ? procfs_file : stdout, "step ");
  326.         if (arg1 & PRSABORT)
  327.           fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
  328.         if (arg1 & PRSTOP)
  329.           fprintf (procfs_file ? procfs_file : stdout, "stopReq ");

  331.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  332.         break;
  333.       case PIOCKILL:
  334.         fprintf (procfs_file ? procfs_file : stdout,
  335.                  "ioctl (PIOCKILL) ");
  336.         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
  337.                                   ptr ? *(long *) ptr : 0, 0);
  338.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  339.         break;
  340. #ifdef PIOCSSPCACT
  341.       case PIOCSSPCACT:
  342.         fprintf (procfs_file ? procfs_file : stdout,
  343.                  "ioctl (PIOCSSPCACT) ");
  344.         arg1 = ptr ? *(long *) ptr : 0;
  345.         if (arg1 & PRFS_STOPFORK)
  346.           fprintf (procfs_file ? procfs_file : stdout, "stopFork ");
  347.         if (arg1 & PRFS_STOPEXEC)
  348.           fprintf (procfs_file ? procfs_file : stdout, "stopExec ");
  349.         if (arg1 & PRFS_STOPTERM)
  350.           fprintf (procfs_file ? procfs_file : stdout, "stopTerm ");
  351.         if (arg1 & PRFS_STOPTCR)
  352.           fprintf (procfs_file ? procfs_file : stdout, "stopThreadCreate ");
  353.         if (arg1 & PRFS_STOPTTERM)
  354.           fprintf (procfs_file ? procfs_file : stdout, "stopThreadTerm ");
  355.         if (arg1 & PRFS_KOLC)
  356.           fprintf (procfs_file ? procfs_file : stdout, "killOnLastClose ");
  357.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  358.         break;
  359. #endif /* PIOCSSPCACT */
  360.       default:
  361.         if (ioctl_table[i].name)
  362.           fprintf (procfs_file ? procfs_file : stdout,
  363.                    "ioctl (%s) %s\n",
  364.                    ioctl_table[i].name,
  365.                    info_verbose ? ioctl_table[i].desc : "");
  366.         else
  367.           fprintf (procfs_file ? procfs_file : stdout,
  368.                    "ioctl (<unknown %ld (0x%lx)) \n", opcode, opcode);
  369.         break;
  370.       }
  371.       if (procfs_file)
  372.         fflush (procfs_file);
  373.     }
  374.   errno = 0;
  375.   ret = ioctl (fd, opcode, ptr);
  376.   if (procfs_trace && ret < 0)
  377.     {
  378.       fprintf (procfs_file ? procfs_file : stdout,
  379.                "[ioctl (%s) FAILED! (%s)]\n",
  380.                ioctl_table[i].name != NULL ?
  381.                ioctl_table[i].name : "<unknown>",
  382.                safe_strerror (errno));
  383.       if (procfs_file)
  384.         fflush (procfs_file);
  385.     }

  387.   return ret;
  388. }

  390. #else        /* NEW_PROC_API */

  392. ‌static struct trans rw_table[] = {
  393. #ifdef PCAGENT                        /* solaris */
  394.   { PCAGENT,  "PCAGENT",  "create agent lwp with regs from argument" },
  395. #endif
  396.   { PCCFAULT, "PCCFAULT", "clear current fault" },
  397. #ifdef PCCSIG                        /* solaris */
  398.   { PCCSIG,   "PCCSIG",   "clear current signal" },
  399. #endif
  400. #ifdef PCDSTOP                        /* solaris */
  401.   { PCDSTOP,  "PCDSTOP",  "post stop request" },
  402. #endif
  403.   { PCKILL,   "PCKILL",   "post a signal" },
  404. #ifdef PCNICE                        /* solaris */
  405.   { PCNICE,   "PCNICE",   "set nice priority" },
  406. #endif
  407. #ifdef PCREAD                        /* solaris */
  408.   { PCREAD,   "PCREAD",   "read from the address space" },
  409.   { PCWRITE,  "PCWRITE",  "write to the address space" },
  410. #endif
  411.   { PCRUN,    "PCRUN",    "make process/lwp runnable" },
  412. #ifdef PCSASRS                        /* solaris 2.7 only */
  413.   { PCSASRS,  "PCSASRS",  "set ancillary state registers" },
  414. #endif
  415. #ifdef PCSCRED                        /* solaris */
  416.   { PCSCRED,  "PCSCRED",  "set process credentials" },
  417. #endif
  418.   { PCSENTRY, "PCSENTRY", "set traced syscall entry set" },
  419.   { PCSET,    "PCSET",    "set modes" },
  420.   { PCSEXIT,  "PCSEXIT",  "set traced syscall exit  set" },
  421.   { PCSFAULT, "PCSFAULT", "set traced fault set" },
  422.   { PCSFPREG, "PCSFPREG", "set floating point registers" },
  423. #ifdef PCSHOLD                        /* solaris */
  424.   { PCSHOLD,  "PCSHOLD",  "set signal mask" },
  425. #endif
  426.   { PCSREG,   "PCSREG",   "set general registers" },
  427.   { PCSSIG,   "PCSSIG",   "set current signal" },
  428.   { PCSTOP,   "PCSTOP",   "post stop request and wait" },
  429.   { PCSTRACE, "PCSTRACE", "set traced signal set" },
  430. #ifdef PCSVADDR                        /* solaris */
  431.   { PCSVADDR, "PCSVADDR", "set pc virtual address" },
  432. #endif
  433. #ifdef PCSXREG                        /* solaris sparc only */
  434.   { PCSXREG,  "PCSXREG",  "set extra registers" },
  435. #endif
  436. #ifdef PCTWSTOP                        /* solaris */
  437.   { PCTWSTOP, "PCTWSTOP", "wait for stop, with timeout arg" },
  438. #endif
  439. #ifdef PCUNKILL                        /* solaris */
  440.   { PCUNKILL, "PCUNKILL", "delete a pending signal" },
  441. #endif
  442. #ifdef PCUNSET                        /* solaris */
  443.   { PCUNSET,  "PCUNSET",  "unset modes" },
  444. #endif
  445. #ifdef PCWATCH                        /* solaris */
  446.   { PCWATCH,  "PCWATCH",  "set/unset watched memory area" },
  447. #endif
  448.   { PCWSTOP,  "PCWSTOP",  "wait for process/lwp to stop, no timeout" },
  449.   { 0,        NULL,      NULL }
  450. };

  452. ‌static off_t lseek_offset;

  454. int
  455. ‌write_with_trace (int fd, void *varg, size_t len, char *file, int line)
  456. {
  457.   int i = ARRAY_SIZE (rw_table) - 1;
  458.   int ret;
  459.   procfs_ctl_t *arg = (procfs_ctl_t *) varg;

  461.   prepare_to_trace ();
  462.   if (procfs_trace)
  463.     {
  464.       procfs_ctl_t opcode = arg[0];
  465.       for (i = 0; rw_table[i].name != NULL; i++)
  466.         if (rw_table[i].value == opcode)
  467.           break;

  469.       if (info_verbose)
  470.         fprintf (procfs_file ? procfs_file : stdout,
  471.                  "%s:%d -- ", file, line);
  472.       switch (opcode) {
  473.       case PCSET:
  474.         fprintf (procfs_file ? procfs_file : stdout,
  475.                  "write (PCSET,   %s) %s\n",
  476.                  arg[1] == PR_FORK  ? "PR_FORK"  :
  477.                  arg[1] == PR_RLC   ? "PR_RLC"   :
  478. #ifdef PR_ASYNC
  479.                  arg[1] == PR_ASYNC ? "PR_ASYNC" :
  480. #endif
  481.                  "<unknown flag>",
  482.                  info_verbose ? rw_table[i].desc : "");
  483.         break;
  484. #ifdef PCUNSET
  485.       case PCUNSET:
  486. #endif
  487. #ifdef PCRESET
  488. #if PCRESET != PCUNSET
  489.       case PCRESET:
  490. #endif
  491. #endif
  492.         fprintf (procfs_file ? procfs_file : stdout,
  493.                  "write (PCRESET, %s) %s\n",
  494.                  arg[1] == PR_FORK  ? "PR_FORK"  :
  495.                  arg[1] == PR_RLC   ? "PR_RLC"   :
  496. #ifdef PR_ASYNC
  497.                  arg[1] == PR_ASYNC ? "PR_ASYNC" :
  498. #endif
  499.                  "<unknown flag>",
  500.                  info_verbose ? rw_table[i].desc : "");
  501.         break;
  502.       case PCSTRACE:
  503.         fprintf (procfs_file ? procfs_file : stdout,
  504.                  "write (PCSTRACE) ");
  505.         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
  506.                                      (sigset_t *) &arg[1], 0);
  507.         break;
  508.       case PCSFAULT:
  509.         fprintf (procfs_file ? procfs_file : stdout,
  510.                  "write (PCSFAULT) ");
  511.         proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
  512.                                     (fltset_t *) &arg[1], 0);
  513.         break;
  514.       case PCSENTRY:
  515.         fprintf (procfs_file ? procfs_file : stdout,
  516.                  "write (PCSENTRY) ");
  517.         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
  518.                                     (sysset_t *) &arg[1], 0);
  519.         break;
  520.       case PCSEXIT:
  521.         fprintf (procfs_file ? procfs_file : stdout,
  522.                  "write (PCSEXIT) ");
  523.         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
  524.                                     (sysset_t *) &arg[1], 0);
  525.         break;
  526. #ifdef PCSHOLD
  527.       case PCSHOLD:
  528.         fprintf (procfs_file ? procfs_file : stdout,
  529.                  "write (PCSHOLD) ");
  530.         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
  531.                                      (sigset_t *) &arg[1], 0);
  532.         break;
  533. #endif
  534.       case PCSSIG:
  535.         fprintf (procfs_file ? procfs_file : stdout,
  536.                  "write (PCSSIG) ");
  537.         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
  538.                                   arg[1] ? ((siginfo_t *) &arg[1])->si_signo
  539.                                          : 0,
  540.                                   0);
  541.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  542.         break;
  543.       case PCRUN:
  544.         fprintf (procfs_file ? procfs_file : stdout,
  545.                  "write (PCRUN) ");
  546.         if (arg[1] & PRCSIG)
  547.           fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
  548.         if (arg[1] & PRCFAULT)
  549.           fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
  550.         if (arg[1] & PRSTEP)
  551.           fprintf (procfs_file ? procfs_file : stdout, "step ");
  552. #ifdef PRSABORT
  553.         if (arg[1] & PRSABORT)
  554.           fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
  555. #endif
  556. #ifdef PRSTOP
  557.         if (arg[1] & PRSTOP)
  558.           fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
  559. #endif

  561.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  562.         break;
  563.       case PCKILL:
  564.         fprintf (procfs_file ? procfs_file : stdout,
  565.                  "write (PCKILL) ");
  566.         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
  567.                                   arg[1], 0);
  568.         fprintf (procfs_file ? procfs_file : stdout, "\n");
  569.         break;
  570.       default:
  571.         {
  572.           if (rw_table[i].name)
  573.             fprintf (procfs_file ? procfs_file : stdout,
  574.                      "write (%s) %s\n",
  575.                      rw_table[i].name,
  576.                      info_verbose ? rw_table[i].desc : "");
  577.           else
  578.             {
  579.               if (lseek_offset != -1)
  580.                 fprintf (procfs_file ? procfs_file : stdout,
  581.                          "write (<unknown>, %lud bytes at 0x%08lx) \n",
  582.                          (unsigned long) len, (unsigned long) lseek_offset);
  583.               else
  584.                 fprintf (procfs_file ? procfs_file : stdout,
  585.                          "write (<unknown>, %lud bytes) \n",
  586.                          (unsigned long) len);
  587.             }
  588.           break;
  589.         }
  590.       }
  591.       if (procfs_file)
  592.         fflush (procfs_file);
  593.     }
  594.   errno = 0;
  595.   ret = write (fd, (void *) arg, len);
  596.   if (procfs_trace && ret != len)
  597.     {
  598.       fprintf (procfs_file ? procfs_file : stdout,
  599.                "[write (%s) FAILED! (%s)]\n",
  600.                rw_table[i].name != NULL ?
  601.                rw_table[i].name : "<unknown>",
  602.                safe_strerror (errno));
  603.       if (procfs_file)
  604.         fflush (procfs_file);
  605.     }

  607.   lseek_offset = -1;
  608.   return ret;
  609. }

  611. off_t
  612. ‌lseek_with_trace (int fd, off_t offset, int whence, char *file, int line)
  613. {
  614.   off_t ret;

  616.   prepare_to_trace ();
  617.   errno = 0;
  618.   ret = lseek (fd, offset, whence);
  619.   lseek_offset = ret;
  620.   if (procfs_trace && (ret == -1 || errno != 0))
  621.     {
  622.       fprintf (procfs_file ? procfs_file : stdout,
  623.                "[lseek (0x%08lx) FAILED! (%s)]\n",
  624.                (unsigned long) offset, safe_strerror (errno));
  625.       if (procfs_file)
  626.         fflush (procfs_file);
  627.     }

  629.   return ret;
  630. }

  632. #endif /* NEW_PROC_API */

  634. int
  635. ‌open_with_trace (char *filename, int mode, char *file, int line)
  636. {
  637.   int ret;

  639.   prepare_to_trace ();
  640.   errno = 0;
  641.   ret = open (filename, mode);
  642.   if (procfs_trace)
  643.     {
  644.       if (info_verbose)
  645.         fprintf (procfs_file ? procfs_file : stdout,
  646.                  "%s:%d -- ", file, line);

  648.       if (errno)
  649.         {
  650.           fprintf (procfs_file ? procfs_file : stdout,
  651.                    "[open FAILED! (%s) line %d]\\n",
  652.                    safe_strerror (errno), line);
  653.         }
  654.       else
  655.         {
  656.           fprintf (procfs_file ? procfs_file : stdout,
  657.                    "%d = open (%s, ", ret, filename);
  658.           if (mode == O_RDONLY)
  659.             fprintf (procfs_file ? procfs_file : stdout, "O_RDONLY) %d\n",
  660.                      line);
  661.           else if (mode == O_WRONLY)
  662.             fprintf (procfs_file ? procfs_file : stdout, "O_WRONLY) %d\n",
  663.                      line);
  664.           else if (mode == O_RDWR)
  665.             fprintf (procfs_file ? procfs_file : stdout, "O_RDWR)   %d\n",
  666.                      line);
  667.         }
  668.       if (procfs_file)
  669.         fflush (procfs_file);
  670.     }

  672.   return ret;
  673. }

  675. int
  676. ‌close_with_trace (int fd, char *file, int line)
  677. {
  678.   int ret;

  680.   prepare_to_trace ();
  681.   errno = 0;
  682.   ret = close (fd);
  683.   if (procfs_trace)
  684.     {
  685.       if (info_verbose)
  686.         fprintf (procfs_file ? procfs_file : stdout,
  687.                  "%s:%d -- ", file, line);
  688.       if (errno)
  689.         fprintf (procfs_file ? procfs_file : stdout,
  690.                  "[close FAILED! (%s)]\n", safe_strerror (errno));
  691.       else
  692.         fprintf (procfs_file ? procfs_file : stdout,
  693.                  "%d = close (%d)\n", ret, fd);
  694.       if (procfs_file)
  695.         fflush (procfs_file);
  696.     }

  698.   return ret;
  699. }

  701. pid_t
  702. ‌wait_with_trace (int *wstat, char *file, int line)
  703. {
  704.   int ret, lstat = 0;

  706.   prepare_to_trace ();
  707.   if (procfs_trace)
  708.     {
  709.       if (info_verbose)
  710.         fprintf (procfs_file ? procfs_file : stdout,
  711.                  "%s:%d -- ", file, line);
  712.       fprintf (procfs_file ? procfs_file : stdout,
  713.                "wait (line %d) ", line);
  714.       if (procfs_file)
  715.         fflush (procfs_file);
  716.     }
  717.   errno = 0;
  718.   ret = wait (&lstat);
  719.   if (procfs_trace)
  720.     {
  721.       if (errno)
  722.         fprintf (procfs_file ? procfs_file : stdout,
  723.                  "[wait FAILED! (%s)]\n", safe_strerror (errno));
  724.       else
  725.         fprintf (procfs_file ? procfs_file : stdout,
  726.                  "returned pid %d, status 0x%x\n", ret, lstat);
  727.       if (procfs_file)
  728.         fflush (procfs_file);
  729.     }
  730.   if (wstat)
  731.     *wstat = lstat;

  733.   return ret;
  734. }

  736. void
  737. ‌procfs_note (char *msg, char *file, int line)
  738. {
  739.   prepare_to_trace ();
  740.   if (procfs_trace)
  741.     {
  742.       if (info_verbose)
  743.         fprintf (procfs_file ? procfs_file : stdout,
  744.                  "%s:%d -- ", file, line);
  745.       fprintf (procfs_file ? procfs_file : stdout, "%s", msg);
  746.       if (procfs_file)
  747.         fflush (procfs_file);
  748.     }
  749. }

  751. void
  752. ‌proc_prettyfprint_status (long flags, int why, int what, int thread)
  753. {
  754.   prepare_to_trace ();
  755.   if (procfs_trace)
  756.     {
  757.       if (thread)
  758.         fprintf (procfs_file ? procfs_file : stdout,
  759.                  "Thread %d: ", thread);

  761.       proc_prettyfprint_flags (procfs_file ? procfs_file : stdout,
  762.                                flags, 0);

  764.       if (flags & (PR_STOPPED | PR_ISTOP))
  765.         proc_prettyfprint_why (procfs_file ? procfs_file : stdout,
  766.                                why, what, 0);
  767.       if (procfs_file)
  768.         fflush (procfs_file);
  769.     }
  770. }


  773. /* Provide a prototype to silence -Wmissing-prototypes.  */
  774. extern void _initialize_proc_api (void);

  776. void
  777. ‌_initialize_proc_api (void)
  778. {
  779.   struct cmd_list_element *c;

  781.   add_setshow_boolean_cmd ("procfs-trace", no_class, &procfs_trace, _("\
  782. Set tracing for /proc api calls."), _("\
  783. Show tracing for /proc api calls."), NULL,
  784.                            set_procfs_trace_cmd,
  785.                            NULL, /* FIXME: i18n: */
  786.                            &setlist, &showlist);

  788.   add_setshow_filename_cmd ("procfs-file", no_class, &procfs_filename, _("\
  789. Set filename for /proc tracefile."), _("\
  790. Show filename for /proc tracefile."), NULL,
  791.                             set_procfs_file_cmd,
  792.                             NULL, /* FIXME: i18n: */
  793.                             &setlist, &showlist);
  794. }