[deliverable/binutils-gdb.git] / gdb / proc-api.c

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

   Copyright (C) 1999-2020 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 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/>.  */

/*
 * Pretty-print trace of api calls to the /proc api
 */

#include "defs.h"
#include "gdbcmd.h"
#include "completer.h"

#define _STRUCTURED_PROC 1

#include <sys/types.h>
#include <sys/procfs.h>
#include <sys/proc.h>	/* for struct proc */
#include <sys/user.h>	/* for struct user */
#include <fcntl.h>	/* for O_RDWR etc.  */
#include "gdbsupport/gdb_wait.h"

#include "proc-utils.h"

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

struct trans {
  long value;                   /* The numeric value */
  const char *name;             /* The equivalent symbolic value */
  const char *desc;             /* Short description of value */
};

static bool  procfs_trace   = false;
static FILE *procfs_file     = NULL;
static char *procfs_filename;

static void
prepare_to_trace (void)
{
  if (procfs_trace)			/* if procfs tracing turned on */
    if (procfs_file == NULL)		/* if output file not yet open */
      procfs_file = fopen (procfs_filename, "a");	/* open output file */
}

static void
set_procfs_trace_cmd (const char *args,
		      int from_tty, struct cmd_list_element *c)
{
#if 0	/* not sure what I might actually need to do here, if anything */
  if (procfs_file)
    fflush (procfs_file);
#endif
}

static void
set_procfs_file_cmd (const char *args,
		     int from_tty, struct cmd_list_element *c)
{
  /* Just changed the filename for procfs tracing.
     If a file was already open, close it.  */
  if (procfs_file)
    fclose (procfs_file);
  procfs_file = NULL;
}

static struct trans rw_table[] = {
  { PCAGENT,  "PCAGENT",  "create agent lwp with regs from argument" },
  { PCCFAULT, "PCCFAULT", "clear current fault" },
  { PCCSIG,   "PCCSIG",   "clear current signal" },
  { PCDSTOP,  "PCDSTOP",  "post stop request" },
  { PCKILL,   "PCKILL",   "post a signal" },
  { PCNICE,   "PCNICE",   "set nice priority" },
  { PCREAD,   "PCREAD",   "read from the address space" },
  { PCWRITE,  "PCWRITE",  "write to the address space" },
  { PCRUN,    "PCRUN",    "make process/lwp runnable" },
  { PCSASRS,  "PCSASRS",  "set ancillary state registers" },
  { PCSCRED,  "PCSCRED",  "set process credentials" },
  { PCSENTRY, "PCSENTRY", "set traced syscall entry set" },
  { PCSET,    "PCSET",    "set modes" },
  { PCSEXIT,  "PCSEXIT",  "set traced syscall exit  set" },
  { PCSFAULT, "PCSFAULT", "set traced fault set" },
  { PCSFPREG, "PCSFPREG", "set floating point registers" },
  { PCSHOLD,  "PCSHOLD",  "set signal mask" },
  { PCSREG,   "PCSREG",   "set general registers" },
  { PCSSIG,   "PCSSIG",   "set current signal" },
  { PCSTOP,   "PCSTOP",   "post stop request and wait" },
  { PCSTRACE, "PCSTRACE", "set traced signal set" },
  { PCSVADDR, "PCSVADDR", "set pc virtual address" },
  { PCSXREG,  "PCSXREG",  "set extra registers" },
  { PCTWSTOP, "PCTWSTOP", "wait for stop, with timeout arg" },
  { PCUNKILL, "PCUNKILL", "delete a pending signal" },
  { PCUNSET,  "PCUNSET",  "unset modes" },
  { PCWATCH,  "PCWATCH",  "set/unset watched memory area" },
  { PCWSTOP,  "PCWSTOP",  "wait for process/lwp to stop, no timeout" },
  { 0,        NULL,      NULL }
};

static off_t lseek_offset;

int
write_with_trace (int fd, void *varg, size_t len, char *file, int line)
{
  int i = ARRAY_SIZE (rw_table) - 1;
  int ret;
  procfs_ctl_t *arg = (procfs_ctl_t *) varg;

  prepare_to_trace ();
  if (procfs_trace)
    {
      procfs_ctl_t opcode = arg[0];
      for (i = 0; rw_table[i].name != NULL; i++)
	if (rw_table[i].value == opcode)
	  break;

      if (info_verbose)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "%s:%d -- ", file, line);
      switch (opcode) {
      case PCSET:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSET,   %s) %s\n", 
		 arg[1] == PR_FORK  ? "PR_FORK"  :
		 arg[1] == PR_RLC   ? "PR_RLC"   :
		 arg[1] == PR_ASYNC ? "PR_ASYNC" :
		 "<unknown flag>",
		 info_verbose ? rw_table[i].desc : "");
	break;
      case PCUNSET:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCRESET, %s) %s\n", 
		 arg[1] == PR_FORK  ? "PR_FORK"  :
		 arg[1] == PR_RLC   ? "PR_RLC"   :
		 arg[1] == PR_ASYNC ? "PR_ASYNC" :
		 "<unknown flag>",
		 info_verbose ? rw_table[i].desc : "");
	break;
      case PCSTRACE:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSTRACE) ");
	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
				     (sigset_t *) &arg[1], 0);
	break;
      case PCSFAULT:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSFAULT) ");
	proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
				    (fltset_t *) &arg[1], 0);
	break;
      case PCSENTRY:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSENTRY) ");
	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
				    (sysset_t *) &arg[1], 0);
	break;
      case PCSEXIT:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSEXIT) ");
	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
				    (sysset_t *) &arg[1], 0);
	break;
      case PCSHOLD:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSHOLD) ");
	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
				     (sigset_t *) &arg[1], 0);
	break;
      case PCSSIG:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCSSIG) ");
	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
				  arg[1] ? ((siginfo_t *) &arg[1])->si_signo 
				         : 0, 
				  0);
	fprintf (procfs_file ? procfs_file : stdout, "\n");
	break;
      case PCRUN:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCRUN) ");
	if (arg[1] & PRCSIG)
	  fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
	if (arg[1] & PRCFAULT)
	  fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
	if (arg[1] & PRSTEP)
	  fprintf (procfs_file ? procfs_file : stdout, "step ");
	if (arg[1] & PRSABORT)
	  fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
	if (arg[1] & PRSTOP)
	  fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
	  
	fprintf (procfs_file ? procfs_file : stdout, "\n");
	break;
      case PCKILL:
	fprintf (procfs_file ? procfs_file : stdout, 
		 "write (PCKILL) ");
	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
				  arg[1], 0);
	fprintf (procfs_file ? procfs_file : stdout, "\n");
	break;
      default:
	{
	  if (rw_table[i].name)
	    fprintf (procfs_file ? procfs_file : stdout, 
		     "write (%s) %s\n", 
		     rw_table[i].name, 
		     info_verbose ? rw_table[i].desc : "");
	  else
	    {
	      if (lseek_offset != -1)
		fprintf (procfs_file ? procfs_file : stdout, 
			 "write (<unknown>, %lud bytes at 0x%08lx) \n", 
			 (unsigned long) len, (unsigned long) lseek_offset);
	      else
		fprintf (procfs_file ? procfs_file : stdout, 
			 "write (<unknown>, %lud bytes) \n", 
			 (unsigned long) len);
	    }
	  break;
	}
      }
      if (procfs_file)
	fflush (procfs_file);
    }
  errno = 0;
  ret = write (fd, (void *) arg, len);
  if (procfs_trace && ret != len)
    {
      fprintf (procfs_file ? procfs_file : stdout, 
	       "[write (%s) FAILED! (%s)]\n",
	       rw_table[i].name != NULL ? 
	       rw_table[i].name : "<unknown>", 
	       safe_strerror (errno));
      if (procfs_file)
	fflush (procfs_file);
    }

  lseek_offset = -1;
  return ret;
}

off_t
lseek_with_trace (int fd, off_t offset, int whence, char *file, int line)
{
  off_t ret;

  prepare_to_trace ();
  errno = 0;
  ret = lseek (fd, offset, whence);
  lseek_offset = ret;
  if (procfs_trace && (ret == -1 || errno != 0))
    {
      fprintf (procfs_file ? procfs_file : stdout, 
	       "[lseek (0x%08lx) FAILED! (%s)]\n", 
	       (unsigned long) offset, safe_strerror (errno));
      if (procfs_file)
	fflush (procfs_file);
    }

  return ret;
}

int
open_with_trace (char *filename, int mode, char *file, int line)
{
  int ret;

  prepare_to_trace ();
  errno = 0;
  ret = open (filename, mode);
  if (procfs_trace)
    {
      if (info_verbose)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "%s:%d -- ", file, line);

      if (errno)
	{
	  fprintf (procfs_file ? procfs_file : stdout, 
		   "[open FAILED! (%s) line %d]\\n", 
		   safe_strerror (errno), line);
	}
      else
	{
	  fprintf (procfs_file ? procfs_file : stdout, 
		   "%d = open (%s, ", ret, filename);
	  if (mode == O_RDONLY)
	    fprintf (procfs_file ? procfs_file : stdout, "O_RDONLY) %d\n",
		     line);
	  else if (mode == O_WRONLY)
	    fprintf (procfs_file ? procfs_file : stdout, "O_WRONLY) %d\n",
		     line);
	  else if (mode == O_RDWR)
	    fprintf (procfs_file ? procfs_file : stdout, "O_RDWR)   %d\n",
		     line);
	}
      if (procfs_file)
	fflush (procfs_file);
    }

  return ret;
}

int
close_with_trace (int fd, char *file, int line)
{
  int ret;

  prepare_to_trace ();
  errno = 0;
  ret = close (fd);
  if (procfs_trace)
    {
      if (info_verbose)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "%s:%d -- ", file, line);
      if (errno)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "[close FAILED! (%s)]\n", safe_strerror (errno));
      else
	fprintf (procfs_file ? procfs_file : stdout, 
		 "%d = close (%d)\n", ret, fd);
      if (procfs_file)
	fflush (procfs_file);
    }

  return ret;
}

pid_t
wait_with_trace (int *wstat, char *file, int line)
{
  int ret, lstat = 0;

  prepare_to_trace ();
  if (procfs_trace)
    {
      if (info_verbose)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "%s:%d -- ", file, line);
      fprintf (procfs_file ? procfs_file : stdout, 
	       "wait (line %d) ", line);
      if (procfs_file)
	fflush (procfs_file);
    }
  errno = 0;
  ret = wait (&lstat);
  if (procfs_trace)
    {
      if (errno)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "[wait FAILED! (%s)]\n", safe_strerror (errno));
      else
	fprintf (procfs_file ? procfs_file : stdout, 
		 "returned pid %d, status 0x%x\n", ret, lstat);
      if (procfs_file)
	fflush (procfs_file);
    }
  if (wstat)
    *wstat = lstat;

  return ret;
}

void
procfs_note (const char *msg, const char *file, int line)
{
  prepare_to_trace ();
  if (procfs_trace)
    {
      if (info_verbose)
	fprintf (procfs_file ? procfs_file : stdout, 
		 "%s:%d -- ", file, line);
      fprintf (procfs_file ? procfs_file : stdout, "%s", msg);
      if (procfs_file)
	fflush (procfs_file);
    }
}

void
proc_prettyfprint_status (long flags, int why, int what, int thread)
{
  prepare_to_trace ();
  if (procfs_trace)
    {
      if (thread)
	fprintf (procfs_file ? procfs_file : stdout,
		 "Thread %d: ", thread);

      proc_prettyfprint_flags (procfs_file ? procfs_file : stdout, 
			       flags, 0);

      if (flags & (PR_STOPPED | PR_ISTOP))
	proc_prettyfprint_why (procfs_file ? procfs_file : stdout, 
			       why, what, 0);
      if (procfs_file)
	fflush (procfs_file);
    }
}

void
_initialize_proc_api (void)
{
  add_setshow_boolean_cmd ("procfs-trace", no_class, &procfs_trace, _("\
Set tracing for /proc api calls."), _("\
Show tracing for /proc api calls."), NULL,
			   set_procfs_trace_cmd,
			   NULL, /* FIXME: i18n: */
			   &setlist, &showlist);

  procfs_filename = xstrdup ("procfs_trace");
  add_setshow_filename_cmd ("procfs-file", no_class, &procfs_filename, _("\
Set filename for /proc tracefile."), _("\
Show filename for /proc tracefile."), NULL,
			    set_procfs_file_cmd,
			    NULL, /* FIXME: i18n: */
			    &setlist, &showlist);
}
Commit	Line	Data
44122162	1	/* Machine independent support for Solaris /proc (process file system) for GDB.
2555fe1a	2
b811d2c2	3	Copyright (C) 1999-2020 Free Software Foundation, Inc.
2555fe1a	4
0fda6bd2 JM	5	Written by Michael Snyder at Cygnus Solutions.
	6	Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
	7
a9762ec7 JB	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/>. */
0fda6bd2 JM	22
	23	/*
	24	* Pretty-print trace of api calls to the /proc api
0fda6bd2 JM	25	*/
	26
	27	#include "defs.h"
	28	#include "gdbcmd.h"
8e40d292	29	#include "completer.h"
0fda6bd2	30
0fda6bd2	31	#define _STRUCTURED_PROC 1
0fda6bd2	32
0fda6bd2 JM	33	#include <sys/types.h>
	34	#include <sys/procfs.h>
	35	#include <sys/proc.h> /* for struct proc */
	36	#include <sys/user.h> /* for struct user */
0df8b418	37	#include <fcntl.h> /* for O_RDWR etc. */
268a13a5	38	#include "gdbsupport/gdb_wait.h"
0fda6bd2 JM	39
	40	#include "proc-utils.h"
	41
	42	/* Much of the information used in the /proc interface, particularly for
	43	printing status information, is kept as tables of structures of the
	44	following form. These tables can be used to map numeric values to
0df8b418	45	their symbolic names and to a string that describes their specific use. */
0fda6bd2 JM	46
	47	struct trans {
	48	long value; /* The numeric value */
995816ba PA	49	const char name; / The equivalent symbolic value */
995816ba PA	50	const char desc; / Short description of value */
0fda6bd2 JM	51	};
0fda6bd2 JM	52
491144b5	53	static bool procfs_trace = false;
0fda6bd2	54	static FILE *procfs_file = NULL;
3e83a920	55	static char *procfs_filename;
0fda6bd2	56
103b3ef5 MS	57	static void
	58	prepare_to_trace (void)
	59	{
	60	if (procfs_trace) /* if procfs tracing turned on */
	61	if (procfs_file == NULL) /* if output file not yet open */
3e83a920	62	procfs_file = fopen (procfs_filename, "a"); /* open output file */
103b3ef5 MS	63	}
103b3ef5 MS	64
0fda6bd2	65	static void
eb4c3f4a TT	66	set_procfs_trace_cmd (const char *args,
eb4c3f4a TT	67	int from_tty, struct cmd_list_element *c)
0fda6bd2 JM	68	{
	69	#if 0 /* not sure what I might actually need to do here, if anything */
	70	if (procfs_file)
	71	fflush (procfs_file);
	72	#endif
	73	}
	74
	75	static void
eb4c3f4a TT	76	set_procfs_file_cmd (const char *args,
eb4c3f4a TT	77	int from_tty, struct cmd_list_element *c)
0fda6bd2 JM	78	{
	79	/* Just changed the filename for procfs tracing.
	80	If a file was already open, close it. */
	81	if (procfs_file)
	82	fclose (procfs_file);
	83	procfs_file = NULL;
	84	}
	85
0fda6bd2	86	static struct trans rw_table[] = {
0fda6bd2	87	{ PCAGENT, "PCAGENT", "create agent lwp with regs from argument" },
0fda6bd2	88	{ PCCFAULT, "PCCFAULT", "clear current fault" },
0fda6bd2	89	{ PCCSIG, "PCCSIG", "clear current signal" },
0fda6bd2 JM	90	{ PCDSTOP, "PCDSTOP", "post stop request" },
	91	{ PCKILL, "PCKILL", "post a signal" },
	92	{ PCNICE, "PCNICE", "set nice priority" },
0fda6bd2 JM	93	{ PCREAD, "PCREAD", "read from the address space" },
0fda6bd2 JM	94	{ PCWRITE, "PCWRITE", "write to the address space" },
0fda6bd2	95	{ PCRUN, "PCRUN", "make process/lwp runnable" },
0fda6bd2	96	{ PCSASRS, "PCSASRS", "set ancillary state registers" },
0fda6bd2	97	{ PCSCRED, "PCSCRED", "set process credentials" },
0fda6bd2 JM	98	{ PCSENTRY, "PCSENTRY", "set traced syscall entry set" },
	99	{ PCSET, "PCSET", "set modes" },
	100	{ PCSEXIT, "PCSEXIT", "set traced syscall exit set" },
	101	{ PCSFAULT, "PCSFAULT", "set traced fault set" },
	102	{ PCSFPREG, "PCSFPREG", "set floating point registers" },
	103	{ PCSHOLD, "PCSHOLD", "set signal mask" },
	104	{ PCSREG, "PCSREG", "set general registers" },
	105	{ PCSSIG, "PCSSIG", "set current signal" },
	106	{ PCSTOP, "PCSTOP", "post stop request and wait" },
	107	{ PCSTRACE, "PCSTRACE", "set traced signal set" },
0fda6bd2	108	{ PCSVADDR, "PCSVADDR", "set pc virtual address" },
0fda6bd2	109	{ PCSXREG, "PCSXREG", "set extra registers" },
0fda6bd2	110	{ PCTWSTOP, "PCTWSTOP", "wait for stop, with timeout arg" },
0fda6bd2	111	{ PCUNKILL, "PCUNKILL", "delete a pending signal" },
0fda6bd2	112	{ PCUNSET, "PCUNSET", "unset modes" },
0fda6bd2	113	{ PCWATCH, "PCWATCH", "set/unset watched memory area" },
0fda6bd2 JM	114	{ PCWSTOP, "PCWSTOP", "wait for process/lwp to stop, no timeout" },
	115	{ 0, NULL, NULL }
	116	};
	117
	118	static off_t lseek_offset;
	119
	120	int
fba45db2	121	write_with_trace (int fd, void varg, size_t len, char file, int line)
0fda6bd2	122	{
1e52e2eb	123	int i = ARRAY_SIZE (rw_table) - 1;
0fda6bd2	124	int ret;
37de36c6	125	procfs_ctl_t arg = (procfs_ctl_t ) varg;
0fda6bd2	126
103b3ef5	127	prepare_to_trace ();
0fda6bd2 JM	128	if (procfs_trace)
0fda6bd2 JM	129	{
37de36c6	130	procfs_ctl_t opcode = arg[0];
0fda6bd2 JM	131	for (i = 0; rw_table[i].name != NULL; i++)
	132	if (rw_table[i].value == opcode)
	133	break;
	134
	135	if (info_verbose)
	136	fprintf (procfs_file ? procfs_file : stdout,
	137	"%s:%d -- ", file, line);
	138	switch (opcode) {
	139	case PCSET:
	140	fprintf (procfs_file ? procfs_file : stdout,
	141	"write (PCSET, %s) %s\n",
	142	arg[1] == PR_FORK ? "PR_FORK" :
	143	arg[1] == PR_RLC ? "PR_RLC" :
0fda6bd2	144	arg[1] == PR_ASYNC ? "PR_ASYNC" :
0fda6bd2 JM	145	"<unknown flag>",
	146	info_verbose ? rw_table[i].desc : "");
	147	break;
0fda6bd2	148	case PCUNSET:
0fda6bd2 JM	149	fprintf (procfs_file ? procfs_file : stdout,
	150	"write (PCRESET, %s) %s\n",
	151	arg[1] == PR_FORK ? "PR_FORK" :
	152	arg[1] == PR_RLC ? "PR_RLC" :
0fda6bd2	153	arg[1] == PR_ASYNC ? "PR_ASYNC" :
0fda6bd2 JM	154	"<unknown flag>",
	155	info_verbose ? rw_table[i].desc : "");
	156	break;
	157	case PCSTRACE:
	158	fprintf (procfs_file ? procfs_file : stdout,
	159	"write (PCSTRACE) ");
	160	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
	161	(sigset_t *) &arg[1], 0);
	162	break;
	163	case PCSFAULT:
	164	fprintf (procfs_file ? procfs_file : stdout,
	165	"write (PCSFAULT) ");
	166	proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
	167	(fltset_t *) &arg[1], 0);
	168	break;
	169	case PCSENTRY:
	170	fprintf (procfs_file ? procfs_file : stdout,
	171	"write (PCSENTRY) ");
	172	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
	173	(sysset_t *) &arg[1], 0);
	174	break;
	175	case PCSEXIT:
	176	fprintf (procfs_file ? procfs_file : stdout,
	177	"write (PCSEXIT) ");
	178	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
	179	(sysset_t *) &arg[1], 0);
	180	break;
	181	case PCSHOLD:
	182	fprintf (procfs_file ? procfs_file : stdout,
	183	"write (PCSHOLD) ");
	184	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
	185	(sigset_t *) &arg[1], 0);
	186	break;
	187	case PCSSIG:
	188	fprintf (procfs_file ? procfs_file : stdout,
	189	"write (PCSSIG) ");
	190	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
	191	arg[1] ? ((siginfo_t *) &arg[1])->si_signo
	192	: 0,
	193	0);
	194	fprintf (procfs_file ? procfs_file : stdout, "\n");
	195	break;
	196	case PCRUN:
	197	fprintf (procfs_file ? procfs_file : stdout,
	198	"write (PCRUN) ");
	199	if (arg[1] & PRCSIG)
	200	fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
	201	if (arg[1] & PRCFAULT)
	202	fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
	203	if (arg[1] & PRSTEP)
	204	fprintf (procfs_file ? procfs_file : stdout, "step ");
	205	if (arg[1] & PRSABORT)
	206	fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
	207	if (arg[1] & PRSTOP)
	208	fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
	209
	210	fprintf (procfs_file ? procfs_file : stdout, "\n");
	211	break;
	212	case PCKILL:
	213	fprintf (procfs_file ? procfs_file : stdout,
	214	"write (PCKILL) ");
	215	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
	216	arg[1], 0);
	217	fprintf (procfs_file ? procfs_file : stdout, "\n");
218	break;
219	default:
220	{
37de36c6	221	if (rw_table[i].name)
0fda6bd2 JM	222	fprintf (procfs_file ? procfs_file : stdout,
	223	"write (%s) %s\n",
	224	rw_table[i].name,
	225	info_verbose ? rw_table[i].desc : "");
	226	else
	227	{
	228	if (lseek_offset != -1)
	229	fprintf (procfs_file ? procfs_file : stdout,
b943d152 MS	230	"write (<unknown>, %lud bytes at 0x%08lx) \n",
b943d152 MS	231	(unsigned long) len, (unsigned long) lseek_offset);
0fda6bd2 JM	232	else
0fda6bd2 JM	233	fprintf (procfs_file ? procfs_file : stdout,
b943d152 MS	234	"write (<unknown>, %lud bytes) \n",
b943d152 MS	235	(unsigned long) len);
0fda6bd2 JM	236	}
	237	break;
	238	}
	239	}
	240	if (procfs_file)
	241	fflush (procfs_file);
	242	}
103b3ef5	243	errno = 0;
b943d152	244	ret = write (fd, (void *) arg, len);
0fda6bd2 JM	245	if (procfs_trace && ret != len)
	246	{
	247	fprintf (procfs_file ? procfs_file : stdout,
103b3ef5	248	"[write (%s) FAILED! (%s)]\n",
0fda6bd2	249	rw_table[i].name != NULL ?
103b3ef5 MS	250	rw_table[i].name : "<unknown>",
103b3ef5 MS	251	safe_strerror (errno));
0fda6bd2 JM	252	if (procfs_file)
	253	fflush (procfs_file);
	254	}
	255
	256	lseek_offset = -1;
	257	return ret;
	258	}
	259
	260	off_t
fba45db2	261	lseek_with_trace (int fd, off_t offset, int whence, char *file, int line)
0fda6bd2 JM	262	{
	263	off_t ret;
	264
103b3ef5 MS	265	prepare_to_trace ();
103b3ef5 MS	266	errno = 0;
0fda6bd2 JM	267	ret = lseek (fd, offset, whence);
0fda6bd2 JM	268	lseek_offset = ret;
103b3ef5	269	if (procfs_trace && (ret == -1 \|\| errno != 0))
0fda6bd2	270	{
0fda6bd2	271	fprintf (procfs_file ? procfs_file : stdout,
103b3ef5 MS	272	"[lseek (0x%08lx) FAILED! (%s)]\n",
103b3ef5 MS	273	(unsigned long) offset, safe_strerror (errno));
0fda6bd2 JM	274	if (procfs_file)
	275	fflush (procfs_file);
	276	}
	277
	278	return ret;
	279	}
	280
0fda6bd2	281	int
fba45db2	282	open_with_trace (char filename, int mode, char file, int line)
0fda6bd2	283	{
103b3ef5	284	int ret;
0fda6bd2	285
103b3ef5 MS	286	prepare_to_trace ();
	287	errno = 0;
	288	ret = open (filename, mode);
0fda6bd2 JM	289	if (procfs_trace)
0fda6bd2 JM	290	{
0fda6bd2 JM	291	if (info_verbose)
	292	fprintf (procfs_file ? procfs_file : stdout,
	293	"%s:%d -- ", file, line);
103b3ef5 MS	294
	295	if (errno)
	296	{
	297	fprintf (procfs_file ? procfs_file : stdout,
	298	"[open FAILED! (%s) line %d]\\n",
	299	safe_strerror (errno), line);
	300	}
	301	else
	302	{
	303	fprintf (procfs_file ? procfs_file : stdout,
	304	"%d = open (%s, ", ret, filename);
	305	if (mode == O_RDONLY)
	306	fprintf (procfs_file ? procfs_file : stdout, "O_RDONLY) %d\n",
	307	line);
	308	else if (mode == O_WRONLY)
	309	fprintf (procfs_file ? procfs_file : stdout, "O_WRONLY) %d\n",
	310	line);
	311	else if (mode == O_RDWR)
	312	fprintf (procfs_file ? procfs_file : stdout, "O_RDWR) %d\n",
	313	line);
	314	}
0fda6bd2 JM	315	if (procfs_file)
	316	fflush (procfs_file);
	317	}
	318
	319	return ret;
	320	}
	321
	322	int
fba45db2	323	close_with_trace (int fd, char *file, int line)
0fda6bd2	324	{
103b3ef5	325	int ret;
0fda6bd2	326
103b3ef5 MS	327	prepare_to_trace ();
	328	errno = 0;
	329	ret = close (fd);
0fda6bd2 JM	330	if (procfs_trace)
0fda6bd2 JM	331	{
0fda6bd2 JM	332	if (info_verbose)
	333	fprintf (procfs_file ? procfs_file : stdout,
	334	"%s:%d -- ", file, line);
103b3ef5 MS	335	if (errno)
	336	fprintf (procfs_file ? procfs_file : stdout,
	337	"[close FAILED! (%s)]\n", safe_strerror (errno));
	338	else
	339	fprintf (procfs_file ? procfs_file : stdout,
	340	"%d = close (%d)\n", ret, fd);
0fda6bd2 JM	341	if (procfs_file)
	342	fflush (procfs_file);
	343	}
	344
	345	return ret;
	346	}
	347
103b3ef5	348	pid_t
fba45db2	349	wait_with_trace (int wstat, char file, int line)
0fda6bd2 JM	350	{
	351	int ret, lstat = 0;
	352
103b3ef5	353	prepare_to_trace ();
0fda6bd2 JM	354	if (procfs_trace)
0fda6bd2 JM	355	{
0fda6bd2 JM	356	if (info_verbose)
	357	fprintf (procfs_file ? procfs_file : stdout,
	358	"%s:%d -- ", file, line);
	359	fprintf (procfs_file ? procfs_file : stdout,
	360	"wait (line %d) ", line);
	361	if (procfs_file)
	362	fflush (procfs_file);
	363	}
103b3ef5	364	errno = 0;
0fda6bd2 JM	365	ret = wait (&lstat);
	366	if (procfs_trace)
	367	{
103b3ef5 MS	368	if (errno)
	369	fprintf (procfs_file ? procfs_file : stdout,
	370	"[wait FAILED! (%s)]\n", safe_strerror (errno));
	371	else
	372	fprintf (procfs_file ? procfs_file : stdout,
	373	"returned pid %d, status 0x%x\n", ret, lstat);
0fda6bd2 JM	374	if (procfs_file)
	375	fflush (procfs_file);
	376	}
	377	if (wstat)
	378	*wstat = lstat;
	379
	380	return ret;
	381	}
	382
	383	void
995816ba	384	procfs_note (const char msg, const char file, int line)
0fda6bd2	385	{
103b3ef5	386	prepare_to_trace ();
0fda6bd2 JM	387	if (procfs_trace)
0fda6bd2 JM	388	{
0fda6bd2 JM	389	if (info_verbose)
	390	fprintf (procfs_file ? procfs_file : stdout,
	391	"%s:%d -- ", file, line);
e34e1a85	392	fprintf (procfs_file ? procfs_file : stdout, "%s", msg);
0fda6bd2 JM	393	if (procfs_file)
	394	fflush (procfs_file);
	395	}
	396	}
	397
	398	void
fba45db2	399	proc_prettyfprint_status (long flags, int why, int what, int thread)
0fda6bd2	400	{
103b3ef5	401	prepare_to_trace ();
0fda6bd2 JM	402	if (procfs_trace)
0fda6bd2 JM	403	{
0fda6bd2 JM	404	if (thread)
	405	fprintf (procfs_file ? procfs_file : stdout,
	406	"Thread %d: ", thread);
	407
	408	proc_prettyfprint_flags (procfs_file ? procfs_file : stdout,
	409	flags, 0);
	410
	411	if (flags & (PR_STOPPED \| PR_ISTOP))
	412	proc_prettyfprint_why (procfs_file ? procfs_file : stdout,
	413	why, what, 0);
	414	if (procfs_file)
	415	fflush (procfs_file);
	416	}
	417	}
	418
0fda6bd2	419	void
fba45db2	420	_initialize_proc_api (void)
0fda6bd2	421	{
54433e38 MK	422	add_setshow_boolean_cmd ("procfs-trace", no_class, &procfs_trace, _("\
	423	Set tracing for /proc api calls."), _("\
	424	Show tracing for /proc api calls."), NULL,
5bf193a2 AC	425	set_procfs_trace_cmd,
	426	NULL, /* FIXME: i18n: */
	427	&setlist, &showlist);
0fda6bd2	428
3e83a920	429	procfs_filename = xstrdup ("procfs_trace");
54433e38 MK	430	add_setshow_filename_cmd ("procfs-file", no_class, &procfs_filename, _("\
	431	Set filename for /proc tracefile."), _("\
	432	Show filename for /proc tracefile."), NULL,
f397e303 AC	433	set_procfs_file_cmd,
	434	NULL, /* FIXME: i18n: */
	435	&setlist, &showlist);
0fda6bd2	436	}