gdb/proc-api.c

   1 /* Machine independent support for SVR4 /proc (process file system) for GDB.
   2
   3    Copyright (C) 1999-2017 Free Software Foundation, Inc.
   4
   5    Written by Michael Snyder at Cygnus Solutions.
   6    Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
   7
   8    This file is part of GDB.
   9
  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.
  14
  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.
  19
  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/>.  */
  22
  23 /*
  24  * Pretty-print trace of api calls to the /proc api
  25  * (ioctl or read/write calls).
  26  *
  27  */
  28
  29 #include "defs.h"
  30 #include "gdbcmd.h"
  31 #include "completer.h"
  32
  33 #if defined (NEW_PROC_API)
  34 #define _STRUCTURED_PROC 1
  35 #endif
  36
  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"
  47
  48 #include "proc-utils.h"
  49
  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.  */
  54
  55 struct trans {
  56   long value;                   /* The numeric value */
  57   const char *name;             /* The equivalent symbolic value */
  58   const char *desc;             /* Short description of value */
  59 };
  60
  61 static int   procfs_trace    = 0;
  62 static FILE *procfs_file     = NULL;
  63 static char *procfs_filename;
  64
  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       procfs_file = fopen (procfs_filename, "a");       /* open output file */
  71 }
  72
  73 static void
  74 set_procfs_trace_cmd (char *args, int from_tty, struct cmd_list_element *c)
  75 {
  76 #if 0   /* not sure what I might actually need to do here, if anything */
  77   if (procfs_file)
  78     fflush (procfs_file);
  79 #endif
  80 }
  81
  82 static void
  83 set_procfs_file_cmd (char *args, int from_tty, struct cmd_list_element *c)
  84 {
  85   /* Just changed the filename for procfs tracing.
  86      If a file was already open, close it.  */
  87   if (procfs_file)
  88     fclose (procfs_file);
  89   procfs_file = NULL;
  90 }
  91
  92
  93 #ifndef NEW_PROC_API
  94
  95 static struct trans ioctl_table[] = {
  96 #ifdef PIOCACINFO                       /* irix */
  97   { PIOCACINFO,    "PIOCACINFO",   "get process account info" },
  98 #endif
  99   { PIOCACTION,    "PIOCACTION",   "get signal action structs" },
 100 #ifdef PIOCARGUMENTS                    /* osf */
 101   { PIOCARGUMENTS, "PIOCARGUMENTS", "command line args" },
 102 #endif
 103 #ifdef PIOCAUXV                         /* solaris aux vectors */
 104   { PIOCAUXV,      "PIOCAUXV",     "get aux vector" },
 105   { PIOCNAUXV,     "PIOCNAUXV",    "get number of aux vector entries" },
 106 #endif /* AUXV */
 107   { PIOCCFAULT,    "PIOCCFAULT",   "clear current fault" },
 108   { PIOCCRED,      "PIOCCRED",     "get process credentials" },
 109 #ifdef PIOCENEVCTRS                     /* irix event counters */
 110   { PIOCENEVCTRS,    "PIOCENEVCTRS",    "acquire and start event counters" },
 111   { PIOCGETEVCTRL,   "PIOCGETEVCTRL",   "get control info of event counters" },
 112   { PIOCGETEVCTRS,   "PIOCGETEVCTRS",   "dump event counters" },
 113   { PIOCGETPREVCTRS, "PIOCGETPREVCTRS", "dump event counters & prusage info" },
 114   { PIOCRELEVCTRS,   "PIOCRELEVCTRS",   "release/stop event counters" },
 115   { PIOCSETEVCTRL,   "PIOCSETEVCTRL",   "set control info of event counters" },
 116   { PIOCGETPTIMER,   "PIOCGETPTIMER",   "get process timers" },
 117 #endif  /* irix event counters */
 118   { PIOCGENTRY,    "PIOCGENTRY",   "get traced syscall entry set" },
 119 #if defined (PIOCGETPR)
 120   { PIOCGETPR,     "PIOCGETPR",    "read struct proc" },
 121 #endif
 122 #if defined (PIOCGETU)
 123   { PIOCGETU,      "PIOCGETU",     "read user area" },
 124 #endif
 125 #if defined (PIOCGETUTK) && (defined(KERNEL) || defined(SHOW_UTT)) /* osf */
 126   { PIOCGETUTK,  "PIOCGETUTK", "get the utask struct" },
 127 #endif
 128   { PIOCGEXIT,     "PIOCGEXIT",    "get traced syscall exit  set" },
 129   { PIOCGFAULT,    "PIOCGFAULT",   "get traced fault set" },
 130 #ifdef PIOCGFPCR                        /* osf */
 131   { PIOCGFPCR,     "PIOCGFPCR",    "get FP control register" },
 132   { PIOCSFPCR,     "PIOCSFPCR",    "set FP conrtol register" },
 133 #endif
 134   { PIOCGFPREG,    "PIOCGFPREG",   "get floating point registers" },
 135   { PIOCGHOLD,     "PIOCGHOLD",    "get held signal set" },
 136   { PIOCGREG,      "PIOCGREG",     "get general registers" },
 137   { PIOCGROUPS,    "PIOCGROUPS",   "get supplementary groups" },
 138 #ifdef PIOCGSPCACT                      /* osf */
 139   { PIOCGSPCACT,   "PIOCGSPCACT",  "get special action" },
 140   { PIOCSSPCACT,   "PIOCSSPCACT",  "set special action" },
 141 #endif
 142   { PIOCGTRACE,    "PIOCGTRACE",   "get traced signal set" },
 143 #ifdef PIOCGWATCH                       /* irix watchpoints */
 144   { PIOCGWATCH,    "PIOCGWATCH",   "get watchpoint" },
 145   { PIOCSWATCH,    "PIOCSWATCH",   "set watchpoint" },
 146   { PIOCNWATCH,    "PIOCNWATCH",   "get number of watchpoints" },
 147 #endif  /* irix watchpoints */
 148 #ifdef PIOCGWIN                         /* solaris sparc */
 149   { PIOCGWIN,      "PIOCGWIN",     "get gwindows_t" },
 150 #endif
 151 #ifdef PIOCGXREG                        /* solaris sparc extra regs */
 152   { PIOCGXREGSIZE, "PIOCXREGSIZE", "get extra register state size" },
 153   { PIOCGXREG,     "PIOCGXREG",    "get extra register state" },
 154   { PIOCSXREG,     "PIOCSXREG",    "set extra register state" },
 155 #endif /* XREG */
 156   { PIOCKILL,      "PIOCKILL",     "send signal" },
 157 #ifdef PIOCLDT                          /* solaris i386 */
 158   { PIOCLDT,       "PIOCLDT",      "get LDT" },
 159   { PIOCNLDT,      "PIOCNLDT",     "get number of LDT entries" },
 160 #endif
 161 #ifdef PIOCLSTATUS                      /* solaris */
 162   { PIOCLSTATUS,   "PIOCLSTATUS",  "get status of all lwps" },
 163   { PIOCLUSAGE,    "PIOCLUSAGE",   "get resource usage of all lwps" },
 164   { PIOCOPENLWP,   "PIOCOPENLWP",  "get lwp file descriptor" },
 165   { PIOCLWPIDS,    "PIOCLWPIDS",   "get lwp identifiers" },
 166 #endif /* LWP */
 167   { PIOCMAP,       "PIOCMAP",      "get memory map information" },
 168   { PIOCMAXSIG,    "PIOCMAXSIG",   "get max signal number" },
 169   { PIOCNICE,      "PIOCNICE",     "set nice priority" },
 170   { PIOCNMAP,      "PIOCNMAP",     "get number of memory mappings" },
 171   { PIOCOPENM,     "PIOCOPENM",    "open mapped object for reading" },
 172 #ifdef PIOCOPENMOBS                     /* osf */
 173   { PIOCOPENMOBS,  "PIOCOPENMOBS", "open mapped object" },
 174 #endif
 175 #ifdef PIOCOPENPD       /* solaris */
 176   { PIOCOPENPD,    "PIOCOPENPD",   "get page data file descriptor" },
 177 #endif
 178   { PIOCPSINFO,    "PIOCPSINFO",   "get ps(1) information" },
 179   { PIOCRESET,     "PIOCRESET",    "reset process flags" },
 180   { PIOCRFORK,     "PIOCRFORK",    "reset inherit-on-fork flag" },
 181   { PIOCRRLC,      "PIOCRRLC",     "reset run-on-last-close flag" },
 182   { PIOCRUN,       "PIOCRUN",      "make process runnable" },
 183 #ifdef PIOCSAVECCNTRS                   /* irix */
 184   { PIOCSAVECCNTRS, "PIOCSAVECCNTRS", "parent gets child cntrs" },
 185 #endif
 186   { PIOCSENTRY,    "PIOCSENTRY",   "set traced syscall entry set" },
 187   { PIOCSET,       "PIOCSET",      "set process flags" },
 188   { PIOCSEXIT,     "PIOCSEXIT",    "set traced syscall exit  set" },
 189   { PIOCSFAULT,    "PIOCSFAULT",   "set traced fault set" },
 190   { PIOCSFORK,     "PIOCSFORK",    "set inherit-on-fork flag" },
 191   { PIOCSFPREG,    "PIOCSFPREG",   "set floating point registers" },
 192   { PIOCSHOLD,     "PIOCSHOLD",    "set held signal set" },
 193   { PIOCSREG,      "PIOCSREG",     "set general registers" },
 194   { PIOCSRLC,      "PIOCSRLC",     "set run-on-last-close flag" },
 195   { PIOCSSIG,      "PIOCSSIG",     "set current signal" },
 196   { PIOCSTATUS,    "PIOCSTATUS",   "get process status" },
 197   { PIOCSTOP,      "PIOCSTOP",     "post stop request" },
 198   { PIOCSTRACE,    "PIOCSTRACE",   "set traced signal set" },
 199   { PIOCUNKILL,    "PIOCUNKILL",   "delete a signal" },
 200 #ifdef PIOCUSAGE        /* solaris */
 201   { PIOCUSAGE,     "PIOCUSAGE",    "get resource usage" },
 202 #endif
 203   { PIOCWSTOP,     "PIOCWSTOP",    "wait for process to stop" },
 204
 205 #ifdef PIOCNTHR                         /* osf threads */
 206   { PIOCNTHR,      "PIOCNTHR",     "get thread count" },
 207   { PIOCRTINH,     "PIOCRTINH",    "reset inherit-on-thread-creation" },
 208   { PIOCSTINH,     "PIOCSTINH",    "set   inherit-on-thread-creation" },
 209   { PIOCTLIST,     "PIOCTLIST",    "get thread ids" },
 210   { PIOCXPTH,      "PIOCXPTH",     "translate port to thread handle" },
 211   { PIOCTRUN,      "PIOCTRUN",     "make thread runnable" },
 212   { PIOCTSTATUS,   "PIOCTSTATUS",  "get thread status" },
 213   { PIOCTSTOP,     "PIOCTSTOP",    "stop a thread" },
 214   /* ... TGTRACE TSTRACE TSSIG TKILL TUNKILL TCFAULT TGFAULT TSFAULT
 215      TGFPREG TSFPREG TGREG TSREG TACTION TTERM TABRUN TGENTRY TSENTRY
 216      TGEXIT TSEXIT TSHOLD ... thread functions */
 217 #endif /* osf threads */
 218   { -1,            NULL,           NULL }
 219 };
 220
 221 int
 222 ioctl_with_trace (int fd, long opcode, void *ptr, char *file, int line)
 223 {
 224   int i = 0;
 225   int ret;
 226   int arg1;
 227
 228   prepare_to_trace ();
 229
 230   if (procfs_trace)
 231     {
 232       for (i = 0; ioctl_table[i].name != NULL; i++)
 233         if (ioctl_table[i].value == opcode)
 234           break;
 235
 236       if (info_verbose)
 237         fprintf (procfs_file ? procfs_file : stdout,
 238                  "%s:%d -- ", file, line);
 239       switch (opcode) {
 240       case PIOCSET:
 241         arg1 = ptr ? *(long *) ptr : 0;
 242         fprintf (procfs_file ? procfs_file : stdout,
 243                  "ioctl (PIOCSET,   %s) %s\n",
 244                  arg1 == PR_FORK  ? "PR_FORK"  :
 245                  arg1 == PR_RLC   ? "PR_RLC"   :
 246 #ifdef PR_ASYNC
 247                  arg1 == PR_ASYNC ? "PR_ASYNC" :
 248 #endif
 249                  "<unknown flag>",
 250                  info_verbose ? ioctl_table[i].desc : "");
 251         break;
 252       case PIOCRESET:
 253         arg1 = ptr ? *(long *) ptr : 0;
 254         fprintf (procfs_file ? procfs_file : stdout,
 255                  "ioctl (PIOCRESET, %s) %s\n",
 256                  arg1 == PR_FORK  ? "PR_FORK"  :
 257                  arg1 == PR_RLC   ? "PR_RLC"   :
 258 #ifdef PR_ASYNC
 259                  arg1 == PR_ASYNC ? "PR_ASYNC" :
 260 #endif
 261                  "<unknown flag>",
 262                  info_verbose ? ioctl_table[i].desc : "");
 263         break;
 264       case PIOCSTRACE:
 265         fprintf (procfs_file ? procfs_file : stdout,
 266                  "ioctl (PIOCSTRACE) ");
 267         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
 268                                      (sigset_t *) ptr, 0);
 269         break;
 270       case PIOCSFAULT:
 271         fprintf (procfs_file ? procfs_file : stdout,
 272                  "ioctl (%s) ",
 273                  opcode == PIOCSFAULT ? "PIOCSFAULT" : "PIOCGFAULT");
 274         proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
 275                                     (fltset_t *) ptr, 0);
 276         break;
 277       case PIOCSENTRY:
 278         fprintf (procfs_file ? procfs_file : stdout,
 279                  "ioctl (%s) ",
 280                  opcode == PIOCSENTRY ? "PIOCSENTRY" : "PIOCGENTRY");
 281         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
 282                                     (sysset_t *) ptr, 0);
 283         break;
 284       case PIOCSEXIT:
 285         fprintf (procfs_file ? procfs_file : stdout,
 286                  "ioctl (%s) ",
 287                  opcode == PIOCSEXIT ? "PIOCSEXIT" : "PIOCGEXIT");
 288         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
 289                                     (sysset_t *) ptr, 0);
 290         break;
 291       case PIOCSHOLD:
 292         fprintf (procfs_file ? procfs_file : stdout,
 293                  "ioctl (%s) ",
 294                  opcode == PIOCSHOLD ? "PIOCSHOLD" : "PIOCGHOLD");
 295         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
 296                                      (sigset_t *) ptr, 0);
 297         break;
 298       case PIOCSSIG:
 299         fprintf (procfs_file ? procfs_file : stdout,
 300                  "ioctl (PIOCSSIG) ");
 301         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
 302                                   ptr ? ((siginfo_t *) ptr)->si_signo : 0,
 303                                   0);
 304         fprintf (procfs_file ? procfs_file : stdout, "\n");
 305         break;
 306       case PIOCRUN:
 307         fprintf (procfs_file ? procfs_file : stdout,
 308                  "ioctl (PIOCRUN) ");
 309
 310         arg1 = ptr ? *(long *) ptr : 0;
 311         if (arg1 & PRCSIG)
 312           fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
 313         if (arg1 & PRCFAULT)
 314           fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
 315         if (arg1 & PRSTRACE)
 316           fprintf (procfs_file ? procfs_file : stdout, "setTrace ");
 317         if (arg1 & PRSHOLD)
 318           fprintf (procfs_file ? procfs_file : stdout, "setHold ");
 319         if (arg1 & PRSFAULT)
 320           fprintf (procfs_file ? procfs_file : stdout, "setFlt ");
 321         if (arg1 & PRSVADDR)
 322           fprintf (procfs_file ? procfs_file : stdout, "setVaddr ");
 323         if (arg1 & PRSTEP)
 324           fprintf (procfs_file ? procfs_file : stdout, "step ");
 325         if (arg1 & PRSABORT)
 326           fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
 327         if (arg1 & PRSTOP)
 328           fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
 329
 330         fprintf (procfs_file ? procfs_file : stdout, "\n");
 331         break;
 332       case PIOCKILL:
 333         fprintf (procfs_file ? procfs_file : stdout,
 334                  "ioctl (PIOCKILL) ");
 335         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
 336                                   ptr ? *(long *) ptr : 0, 0);
 337         fprintf (procfs_file ? procfs_file : stdout, "\n");
 338         break;
 339 #ifdef PIOCSSPCACT
 340       case PIOCSSPCACT:
 341         fprintf (procfs_file ? procfs_file : stdout,
 342                  "ioctl (PIOCSSPCACT) ");
 343         arg1 = ptr ? *(long *) ptr : 0;
 344         if (arg1 & PRFS_STOPFORK)
 345           fprintf (procfs_file ? procfs_file : stdout, "stopFork ");
 346         if (arg1 & PRFS_STOPEXEC)
 347           fprintf (procfs_file ? procfs_file : stdout, "stopExec ");
 348         if (arg1 & PRFS_STOPTERM)
 349           fprintf (procfs_file ? procfs_file : stdout, "stopTerm ");
 350         if (arg1 & PRFS_STOPTCR)
 351           fprintf (procfs_file ? procfs_file : stdout, "stopThreadCreate ");
 352         if (arg1 & PRFS_STOPTTERM)
 353           fprintf (procfs_file ? procfs_file : stdout, "stopThreadTerm ");
 354         if (arg1 & PRFS_KOLC)
 355           fprintf (procfs_file ? procfs_file : stdout, "killOnLastClose ");
 356         fprintf (procfs_file ? procfs_file : stdout, "\n");
 357         break;
 358 #endif /* PIOCSSPCACT */
 359       default:
 360         if (ioctl_table[i].name)
 361           fprintf (procfs_file ? procfs_file : stdout,
 362                    "ioctl (%s) %s\n",
 363                    ioctl_table[i].name,
 364                    info_verbose ? ioctl_table[i].desc : "");
 365         else
 366           fprintf (procfs_file ? procfs_file : stdout,
 367                    "ioctl (<unknown %ld (0x%lx)) \n", opcode, opcode);
 368         break;
 369       }
 370       if (procfs_file)
 371         fflush (procfs_file);
 372     }
 373   errno = 0;
 374   ret = ioctl (fd, opcode, ptr);
 375   if (procfs_trace && ret < 0)
 376     {
 377       fprintf (procfs_file ? procfs_file : stdout,
 378                "[ioctl (%s) FAILED! (%s)]\n",
 379                ioctl_table[i].name != NULL ?
 380                ioctl_table[i].name : "<unknown>",
 381                safe_strerror (errno));
 382       if (procfs_file)
 383         fflush (procfs_file);
 384     }
 385
 386   return ret;
 387 }
 388
 389 #else   /* NEW_PROC_API */
 390
 391 static struct trans rw_table[] = {
 392 #ifdef PCAGENT                  /* solaris */
 393   { PCAGENT,  "PCAGENT",  "create agent lwp with regs from argument" },
 394 #endif
 395   { PCCFAULT, "PCCFAULT", "clear current fault" },
 396 #ifdef PCCSIG                   /* solaris */
 397   { PCCSIG,   "PCCSIG",   "clear current signal" },
 398 #endif
 399 #ifdef PCDSTOP                  /* solaris */
 400   { PCDSTOP,  "PCDSTOP",  "post stop request" },
 401 #endif
 402   { PCKILL,   "PCKILL",   "post a signal" },
 403 #ifdef PCNICE                   /* solaris */
 404   { PCNICE,   "PCNICE",   "set nice priority" },
 405 #endif
 406 #ifdef PCREAD                   /* solaris */
 407   { PCREAD,   "PCREAD",   "read from the address space" },
 408   { PCWRITE,  "PCWRITE",  "write to the address space" },
 409 #endif
 410   { PCRUN,    "PCRUN",    "make process/lwp runnable" },
 411 #ifdef PCSASRS                  /* solaris 2.7 only */
 412   { PCSASRS,  "PCSASRS",  "set ancillary state registers" },
 413 #endif
 414 #ifdef PCSCRED                  /* solaris */
 415   { PCSCRED,  "PCSCRED",  "set process credentials" },
 416 #endif
 417   { PCSENTRY, "PCSENTRY", "set traced syscall entry set" },
 418   { PCSET,    "PCSET",    "set modes" },
 419   { PCSEXIT,  "PCSEXIT",  "set traced syscall exit  set" },
 420   { PCSFAULT, "PCSFAULT", "set traced fault set" },
 421   { PCSFPREG, "PCSFPREG", "set floating point registers" },
 422 #ifdef PCSHOLD                  /* solaris */
 423   { PCSHOLD,  "PCSHOLD",  "set signal mask" },
 424 #endif
 425   { PCSREG,   "PCSREG",   "set general registers" },
 426   { PCSSIG,   "PCSSIG",   "set current signal" },
 427   { PCSTOP,   "PCSTOP",   "post stop request and wait" },
 428   { PCSTRACE, "PCSTRACE", "set traced signal set" },
 429 #ifdef PCSVADDR                 /* solaris */
 430   { PCSVADDR, "PCSVADDR", "set pc virtual address" },
 431 #endif
 432 #ifdef PCSXREG                  /* solaris sparc only */
 433   { PCSXREG,  "PCSXREG",  "set extra registers" },
 434 #endif
 435 #ifdef PCTWSTOP                 /* solaris */
 436   { PCTWSTOP, "PCTWSTOP", "wait for stop, with timeout arg" },
 437 #endif
 438 #ifdef PCUNKILL                 /* solaris */
 439   { PCUNKILL, "PCUNKILL", "delete a pending signal" },
 440 #endif
 441 #ifdef PCUNSET                  /* solaris */
 442   { PCUNSET,  "PCUNSET",  "unset modes" },
 443 #endif
 444 #ifdef PCWATCH                  /* solaris */
 445   { PCWATCH,  "PCWATCH",  "set/unset watched memory area" },
 446 #endif
 447   { PCWSTOP,  "PCWSTOP",  "wait for process/lwp to stop, no timeout" },
 448   { 0,        NULL,      NULL }
 449 };
 450
 451 static off_t lseek_offset;
 452
 453 int
 454 write_with_trace (int fd, void *varg, size_t len, char *file, int line)
 455 {
 456   int i = ARRAY_SIZE (rw_table) - 1;
 457   int ret;
 458   procfs_ctl_t *arg = (procfs_ctl_t *) varg;
 459
 460   prepare_to_trace ();
 461   if (procfs_trace)
 462     {
 463       procfs_ctl_t opcode = arg[0];
 464       for (i = 0; rw_table[i].name != NULL; i++)
 465         if (rw_table[i].value == opcode)
 466           break;
 467
 468       if (info_verbose)
 469         fprintf (procfs_file ? procfs_file : stdout,
 470                  "%s:%d -- ", file, line);
 471       switch (opcode) {
 472       case PCSET:
 473         fprintf (procfs_file ? procfs_file : stdout,
 474                  "write (PCSET,   %s) %s\n",
 475                  arg[1] == PR_FORK  ? "PR_FORK"  :
 476                  arg[1] == PR_RLC   ? "PR_RLC"   :
 477 #ifdef PR_ASYNC
 478                  arg[1] == PR_ASYNC ? "PR_ASYNC" :
 479 #endif
 480                  "<unknown flag>",
 481                  info_verbose ? rw_table[i].desc : "");
 482         break;
 483 #ifdef PCUNSET
 484       case PCUNSET:
 485 #endif
 486 #ifdef PCRESET
 487 #if PCRESET != PCUNSET
 488       case PCRESET:
 489 #endif
 490 #endif
 491         fprintf (procfs_file ? procfs_file : stdout,
 492                  "write (PCRESET, %s) %s\n",
 493                  arg[1] == PR_FORK  ? "PR_FORK"  :
 494                  arg[1] == PR_RLC   ? "PR_RLC"   :
 495 #ifdef PR_ASYNC
 496                  arg[1] == PR_ASYNC ? "PR_ASYNC" :
 497 #endif
 498                  "<unknown flag>",
 499                  info_verbose ? rw_table[i].desc : "");
 500         break;
 501       case PCSTRACE:
 502         fprintf (procfs_file ? procfs_file : stdout,
 503                  "write (PCSTRACE) ");
 504         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
 505                                      (sigset_t *) &arg[1], 0);
 506         break;
 507       case PCSFAULT:
 508         fprintf (procfs_file ? procfs_file : stdout,
 509                  "write (PCSFAULT) ");
 510         proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
 511                                     (fltset_t *) &arg[1], 0);
 512         break;
 513       case PCSENTRY:
 514         fprintf (procfs_file ? procfs_file : stdout,
 515                  "write (PCSENTRY) ");
 516         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
 517                                     (sysset_t *) &arg[1], 0);
 518         break;
 519       case PCSEXIT:
 520         fprintf (procfs_file ? procfs_file : stdout,
 521                  "write (PCSEXIT) ");
 522         proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
 523                                     (sysset_t *) &arg[1], 0);
 524         break;
 525 #ifdef PCSHOLD
 526       case PCSHOLD:
 527         fprintf (procfs_file ? procfs_file : stdout,
 528                  "write (PCSHOLD) ");
 529         proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
 530                                      (sigset_t *) &arg[1], 0);
 531         break;
 532 #endif
 533       case PCSSIG:
 534         fprintf (procfs_file ? procfs_file : stdout,
 535                  "write (PCSSIG) ");
 536         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
 537                                   arg[1] ? ((siginfo_t *) &arg[1])->si_signo
 538                                          : 0,
 539                                   0);
 540         fprintf (procfs_file ? procfs_file : stdout, "\n");
 541         break;
 542       case PCRUN:
 543         fprintf (procfs_file ? procfs_file : stdout,
 544                  "write (PCRUN) ");
 545         if (arg[1] & PRCSIG)
 546           fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
 547         if (arg[1] & PRCFAULT)
 548           fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
 549         if (arg[1] & PRSTEP)
 550           fprintf (procfs_file ? procfs_file : stdout, "step ");
 551 #ifdef PRSABORT
 552         if (arg[1] & PRSABORT)
 553           fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
 554 #endif
 555 #ifdef PRSTOP
 556         if (arg[1] & PRSTOP)
 557           fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
 558 #endif
 559
 560         fprintf (procfs_file ? procfs_file : stdout, "\n");
 561         break;
 562       case PCKILL:
 563         fprintf (procfs_file ? procfs_file : stdout,
 564                  "write (PCKILL) ");
 565         proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
 566                                   arg[1], 0);
 567         fprintf (procfs_file ? procfs_file : stdout, "\n");
 568         break;
 569       default:
 570         {
 571           if (rw_table[i].name)
 572             fprintf (procfs_file ? procfs_file : stdout,
 573                      "write (%s) %s\n",
 574                      rw_table[i].name,
 575                      info_verbose ? rw_table[i].desc : "");
 576           else
 577             {
 578               if (lseek_offset != -1)
 579                 fprintf (procfs_file ? procfs_file : stdout,
 580                          "write (<unknown>, %lud bytes at 0x%08lx) \n",
 581                          (unsigned long) len, (unsigned long) lseek_offset);
 582               else
 583                 fprintf (procfs_file ? procfs_file : stdout,
 584                          "write (<unknown>, %lud bytes) \n",
 585                          (unsigned long) len);
 586             }
 587           break;
 588         }
 589       }
 590       if (procfs_file)
 591         fflush (procfs_file);
 592     }
 593   errno = 0;
 594   ret = write (fd, (void *) arg, len);
 595   if (procfs_trace && ret != len)
 596     {
 597       fprintf (procfs_file ? procfs_file : stdout,
 598                "[write (%s) FAILED! (%s)]\n",
 599                rw_table[i].name != NULL ?
 600                rw_table[i].name : "<unknown>",
 601                safe_strerror (errno));
 602       if (procfs_file)
 603         fflush (procfs_file);
 604     }
 605
 606   lseek_offset = -1;
 607   return ret;
 608 }
 609
 610 off_t
 611 lseek_with_trace (int fd, off_t offset, int whence, char *file, int line)
 612 {
 613   off_t ret;
 614
 615   prepare_to_trace ();
 616   errno = 0;
 617   ret = lseek (fd, offset, whence);
 618   lseek_offset = ret;
 619   if (procfs_trace && (ret == -1 || errno != 0))
 620     {
 621       fprintf (procfs_file ? procfs_file : stdout,
 622                "[lseek (0x%08lx) FAILED! (%s)]\n",
 623                (unsigned long) offset, safe_strerror (errno));
 624       if (procfs_file)
 625         fflush (procfs_file);
 626     }
 627
 628   return ret;
 629 }
 630
 631 #endif /* NEW_PROC_API */
 632
 633 int
 634 open_with_trace (char *filename, int mode, char *file, int line)
 635 {
 636   int ret;
 637
 638   prepare_to_trace ();
 639   errno = 0;
 640   ret = open (filename, mode);
 641   if (procfs_trace)
 642     {
 643       if (info_verbose)
 644         fprintf (procfs_file ? procfs_file : stdout,
 645                  "%s:%d -- ", file, line);
 646
 647       if (errno)
 648         {
 649           fprintf (procfs_file ? procfs_file : stdout,
 650                    "[open FAILED! (%s) line %d]\\n",
 651                    safe_strerror (errno), line);
 652         }
 653       else
 654         {
 655           fprintf (procfs_file ? procfs_file : stdout,
 656                    "%d = open (%s, ", ret, filename);
 657           if (mode == O_RDONLY)
 658             fprintf (procfs_file ? procfs_file : stdout, "O_RDONLY) %d\n",
 659                      line);
 660           else if (mode == O_WRONLY)
 661             fprintf (procfs_file ? procfs_file : stdout, "O_WRONLY) %d\n",
 662                      line);
 663           else if (mode == O_RDWR)
 664             fprintf (procfs_file ? procfs_file : stdout, "O_RDWR)   %d\n",
 665                      line);
 666         }
 667       if (procfs_file)
 668         fflush (procfs_file);
 669     }
 670
 671   return ret;
 672 }
 673
 674 int
 675 close_with_trace (int fd, char *file, int line)
 676 {
 677   int ret;
 678
 679   prepare_to_trace ();
 680   errno = 0;
 681   ret = close (fd);
 682   if (procfs_trace)
 683     {
 684       if (info_verbose)
 685         fprintf (procfs_file ? procfs_file : stdout,
 686                  "%s:%d -- ", file, line);
 687       if (errno)
 688         fprintf (procfs_file ? procfs_file : stdout,
 689                  "[close FAILED! (%s)]\n", safe_strerror (errno));
 690       else
 691         fprintf (procfs_file ? procfs_file : stdout,
 692                  "%d = close (%d)\n", ret, fd);
 693       if (procfs_file)
 694         fflush (procfs_file);
 695     }
 696
 697   return ret;
 698 }
 699
 700 pid_t
 701 wait_with_trace (int *wstat, char *file, int line)
 702 {
 703   int ret, lstat = 0;
 704
 705   prepare_to_trace ();
 706   if (procfs_trace)
 707     {
 708       if (info_verbose)
 709         fprintf (procfs_file ? procfs_file : stdout,
 710                  "%s:%d -- ", file, line);
 711       fprintf (procfs_file ? procfs_file : stdout,
 712                "wait (line %d) ", line);
 713       if (procfs_file)
 714         fflush (procfs_file);
 715     }
 716   errno = 0;
 717   ret = wait (&lstat);
 718   if (procfs_trace)
 719     {
 720       if (errno)
 721         fprintf (procfs_file ? procfs_file : stdout,
 722                  "[wait FAILED! (%s)]\n", safe_strerror (errno));
 723       else
 724         fprintf (procfs_file ? procfs_file : stdout,
 725                  "returned pid %d, status 0x%x\n", ret, lstat);
 726       if (procfs_file)
 727         fflush (procfs_file);
 728     }
 729   if (wstat)
 730     *wstat = lstat;
 731
 732   return ret;
 733 }
 734
 735 void
 736 procfs_note (const char *msg, const char *file, int line)
 737 {
 738   prepare_to_trace ();
 739   if (procfs_trace)
 740     {
 741       if (info_verbose)
 742         fprintf (procfs_file ? procfs_file : stdout,
 743                  "%s:%d -- ", file, line);
 744       fprintf (procfs_file ? procfs_file : stdout, "%s", msg);
 745       if (procfs_file)
 746         fflush (procfs_file);
 747     }
 748 }
 749
 750 void
 751 proc_prettyfprint_status (long flags, int why, int what, int thread)
 752 {
 753   prepare_to_trace ();
 754   if (procfs_trace)
 755     {
 756       if (thread)
 757         fprintf (procfs_file ? procfs_file : stdout,
 758                  "Thread %d: ", thread);
 759
 760       proc_prettyfprint_flags (procfs_file ? procfs_file : stdout,
 761                                flags, 0);
 762
 763       if (flags & (PR_STOPPED | PR_ISTOP))
 764         proc_prettyfprint_why (procfs_file ? procfs_file : stdout,
 765                                why, what, 0);
 766       if (procfs_file)
 767         fflush (procfs_file);
 768     }
 769 }
 770
 771 void
 772 _initialize_proc_api (void)
 773 {
 774   struct cmd_list_element *c;
 775
 776   add_setshow_boolean_cmd ("procfs-trace", no_class, &procfs_trace, _("\
 777 Set tracing for /proc api calls."), _("\
 778 Show tracing for /proc api calls."), NULL,
 779                            set_procfs_trace_cmd,
 780                            NULL, /* FIXME: i18n: */
 781                            &setlist, &showlist);
 782
 783   procfs_filename = xstrdup ("procfs_trace");
 784   add_setshow_filename_cmd ("procfs-file", no_class, &procfs_filename, _("\
 785 Set filename for /proc tracefile."), _("\
 786 Show filename for /proc tracefile."), NULL,
 787                             set_procfs_file_cmd,
 788                             NULL, /* FIXME: i18n: */
 789                             &setlist, &showlist);
 790 }