/* Memory-access and commands for remote VxWorks processes, for GDB.
- Copyright (C) 1990-95, 1997-98, 1999, 2001 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
+ 2001 Free Software Foundation, Inc.
Contributed by Wind River Systems and Cygnus Support.
This file is part of GDB.
break_status = 0;
ptrace_in.addr = addr;
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = PIDGET (inferior_ptid);
status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
&break_status);
return net_break (addr, VX_BREAK_DELETE);
}
-/* Start an inferior process and sets inferior_pid to its pid.
+/* Start an inferior process and sets inferior_ptid to its pid.
EXEC_FILE is the file to run.
ALLARGS is a string containing the arguments to the program.
ENV is the environment vector to pass.
strlen (passArgs.arg_array_val[0]));
push_target (&vx_run_ops);
- inferior_pid = taskStart.pid;
+ inferior_ptid = pid_to_ptid (taskStart.pid);
/* We will get a trace trap after one instruction.
Insert breakpoints and continue. */
memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
- pid = inferior_pid;
+ pid = PIDGET inferior_ptid);
status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
pEvent);
/* don't let rdbTask suspend itself by passing a pid of 0 */
- if ((pid = inferior_pid) == 0)
+ if ((pid = PIDGET (inferior_ptid)) == 0)
return -1;
status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
/* Initialize RPC input argument structure. */
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = PIDGET (inferior_ptid);
ptrace_in.info.ttype = NOINFO;
/* Initialize RPC return value structure. */
in_data.bytes = reg_buf;
in_data.len = len;
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = PIDGET (inferior_ptid);
ptrace_in.info.ttype = DATA;
ptrace_in.info.more_data = (caddr_t) & in_data;
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = inferior_pid; /* XXX pid unnecessary for READDATA */
+ ptrace_in.pid = PIDGET (inferior_ptid); /* XXX pid unnecessary for READDATA */
ptrace_in.addr = (int) memaddr; /* Where from */
ptrace_in.data = len; /* How many bytes */
{
printf_unfiltered ("\tRunning %s VxWorks process %s",
vx_running ? "child" : "attached",
- local_hex_string (inferior_pid));
+ local_hex_string (PIDGET (inferior_ptid)));
if (vx_running)
printf_unfiltered (", function `%s'", vx_running);
printf_unfiltered (".\n");
}
static void
-vx_resume (int pid, int step, enum target_signal siggnal)
+vx_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
CORE_ADDR cont_addr;
- if (pid == -1)
- pid = inferior_pid;
+ if (ptid_equal (ptid, minus_one_ptid))
+ ptid = inferior_ptid;
if (siggnal != 0 && siggnal != stop_signal)
error ("Cannot send signals to VxWorks processes");
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = pid;
+ ptrace_in.pid = PIDGET (ptid);
ptrace_in.addr = cont_addr; /* Target side insists on this, or it panics. */
if (step)
/* Refuse to load the module if a debugged task is running. Doing so
can have a number of unpleasant consequences to the running task. */
- if (inferior_pid != 0 && target_has_execution)
+ if (PIDGET (inferior_ptid) != 0 && target_has_execution)
{
if (query ("You may not load a module while the target task is running.\n\
Kill the target task? "))
int step_status;
SOURCE_STEP source_step;
- source_step.taskId = inferior_pid;
+ source_step.taskId = PIDGET (inferior_ptid);
if (step_range_end)
{
perror_with_name ("select");
}
-static int
-vx_wait (int pid_to_wait_for, struct target_waitstatus *status)
+static ptid_t
+vx_wait (ptid_t ptid_to_wait_for, struct target_waitstatus *status)
{
register int pid;
RDB_EVENT rdbEvent;
{
sleep_ms (200); /* FIXME Don't kill the network too badly */
}
- else if (pid != inferior_pid)
+ else if (pid != PIDGET (inferior_ptid))
internal_error (__FILE__, __LINE__,
"Bad pid for debugged task: %s\n",
local_hex_string ((unsigned long) pid));
#endif
break;
} /* switch */
- return pid;
+ return pid_to_ptid (pid);
}
\f
static int
/* It worked... */
- inferior_pid = pid;
+ inferior_ptid = pid_to_ptid (pid);
push_target (&vx_run_ops);
if (vx_running)
if (from_tty)
printf_unfiltered ("Detaching pid %s.\n",
- local_hex_string ((unsigned long) inferior_pid));
+ local_hex_string (
+ (unsigned long) PIDGET (inferior_ptid)));
if (args) /* FIXME, should be possible to leave suspended */
signal = atoi (args);
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = PIDGET (inferior_ptid);
status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
if (status == -1)
perror_with_name ("Detaching VxWorks process");
}
- inferior_pid = 0;
+ inferior_ptid = null_ptid;
pop_target (); /* go back to non-executing VxWorks connection */
}
Ptrace_return ptrace_out;
int status;
- printf_unfiltered ("Killing pid %s.\n", local_hex_string ((unsigned long) inferior_pid));
+ printf_unfiltered ("Killing pid %s.\n", local_hex_string ((unsigned long) PIDGET (inferior_ptid)));
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = PIDGET (inferior_ptid);
status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
if (status == -1)
/* If it gives good status, the process is *gone*, no events remain.
If the kill failed, assume the process is gone anyhow. */
- inferior_pid = 0;
+ inferior_ptid = null_ptid;
pop_target (); /* go back to non-executing VxWorks connection */
}
static void
vx_proc_close (int quitting)
{
- inferior_pid = 0; /* No longer have a process. */
+ inferior_ptid = null_ptid; /* No longer have a process. */
if (vx_running)
xfree (vx_running);
vx_running = 0;