#define PTRACE_EVENT_VFORK 2
#define PTRACE_EVENT_CLONE 3
#define PTRACE_EVENT_EXEC 4
-#define PTRACE_EVENT_VFORKDONE 5
+#define PTRACE_EVENT_VFORK_DONE 5
#define PTRACE_EVENT_EXIT 6
#endif /* PTRACE_EVENT_FORK */
ptrace (PTRACE_TRACEME, 0, 0, 0);
kill (getpid (), SIGSTOP);
fork ();
- exit (0);
+ _exit (0);
}
-/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. We
+/* Wrapper function for waitpid which handles EINTR. */
+
+static int
+my_waitpid (int pid, int *status, int flags)
+{
+ int ret;
+ do
+ {
+ ret = waitpid (pid, status, flags);
+ }
+ while (ret == -1 && errno == EINTR);
+
+ return ret;
+}
+
+/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
+
+ First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
+ we know that the feature is not available. This may change the tracing
+ options for ORIGINAL_PID, but we'll be setting them shortly anyway.
+
+ However, if it succeeds, we don't know for sure that the feature is
+ available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
create a child process, attach to it, use PTRACE_SETOPTIONS to enable
- fork tracing, and let it fork. If the process exits, we assume that
- we can't use TRACEFORK; if we get the fork notification, and we can
- extract the new child's PID, then we assume that we can. */
+ fork tracing, and let it fork. If the process exits, we assume that we
+ can't use TRACEFORK; if we get the fork notification, and we can extract
+ the new child's PID, then we assume that we can. */
static void
-linux_test_for_tracefork (void)
+linux_test_for_tracefork (int original_pid)
{
int child_pid, ret, status;
long second_pid;
+ linux_supports_tracefork_flag = 0;
+ linux_supports_tracevforkdone_flag = 0;
+
+ ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
+ if (ret != 0)
+ return;
+
child_pid = fork ();
if (child_pid == -1)
- perror_with_name ("linux_test_for_tracefork: fork");
+ perror_with_name (("fork"));
if (child_pid == 0)
linux_tracefork_child ();
- ret = waitpid (child_pid, &status, 0);
+ ret = my_waitpid (child_pid, &status, 0);
if (ret == -1)
- perror_with_name ("linux_test_for_tracefork: waitpid");
+ perror_with_name (("waitpid"));
else if (ret != child_pid)
- error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
+ error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
if (! WIFSTOPPED (status))
- error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
-
- linux_supports_tracefork_flag = 0;
+ error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status);
ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
if (ret != 0)
{
- ptrace (PTRACE_KILL, child_pid, 0, 0);
- waitpid (child_pid, &status, 0);
+ ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
+ if (ret != 0)
+ {
+ warning (_("linux_test_for_tracefork: failed to kill child"));
+ return;
+ }
+
+ ret = my_waitpid (child_pid, &status, 0);
+ if (ret != child_pid)
+ warning (_("linux_test_for_tracefork: failed to wait for killed child"));
+ else if (!WIFSIGNALED (status))
+ warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
+ "killed child"), status);
+
return;
}
PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
linux_supports_tracevforkdone_flag = (ret == 0);
- ptrace (PTRACE_CONT, child_pid, 0, 0);
- ret = waitpid (child_pid, &status, 0);
+ ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
+ if (ret != 0)
+ warning (_("linux_test_for_tracefork: failed to resume child"));
+
+ ret = my_waitpid (child_pid, &status, 0);
+
if (ret == child_pid && WIFSTOPPED (status)
&& status >> 16 == PTRACE_EVENT_FORK)
{
int second_status;
linux_supports_tracefork_flag = 1;
- waitpid (second_pid, &second_status, 0);
- ptrace (PTRACE_DETACH, second_pid, 0, 0);
+ my_waitpid (second_pid, &second_status, 0);
+ ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
+ if (ret != 0)
+ warning (_("linux_test_for_tracefork: failed to kill second child"));
}
}
+ else
+ warning (_("linux_test_for_tracefork: unexpected result from waitpid "
+ "(%d, status 0x%x)"), ret, status);
- if (WIFSTOPPED (status))
- {
- ptrace (PTRACE_DETACH, child_pid, 0, 0);
- waitpid (child_pid, &status, 0);
- }
+ ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
+ if (ret != 0)
+ warning (_("linux_test_for_tracefork: failed to kill child"));
+ my_waitpid (child_pid, &status, 0);
}
/* Return non-zero iff we have tracefork functionality available.
This function also sets linux_supports_tracefork_flag. */
static int
-linux_supports_tracefork (void)
+linux_supports_tracefork (int pid)
{
if (linux_supports_tracefork_flag == -1)
- linux_test_for_tracefork ();
+ linux_test_for_tracefork (pid);
return linux_supports_tracefork_flag;
}
static int
-linux_supports_tracevforkdone (void)
+linux_supports_tracevforkdone (int pid)
{
if (linux_supports_tracefork_flag == -1)
- linux_test_for_tracefork ();
+ linux_test_for_tracefork (pid);
return linux_supports_tracevforkdone_flag;
}
int pid = ptid_get_pid (ptid);
int options;
- if (! linux_supports_tracefork ())
+ if (! linux_supports_tracefork (pid))
return;
options = PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEEXEC
| PTRACE_O_TRACECLONE;
- if (linux_supports_tracevforkdone ())
+ if (linux_supports_tracevforkdone (pid))
options |= PTRACE_O_TRACEVFORKDONE;
/* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
if (has_vforked)
{
- if (linux_supports_tracevforkdone ())
+ gdb_assert (linux_supports_tracefork_flag >= 0);
+ if (linux_supports_tracevforkdone (0))
{
int status;
ptrace (PTRACE_CONT, parent_pid, 0, 0);
waitpid (parent_pid, &status, __WALL);
- if ((status >> 16) != PTRACE_EVENT_VFORKDONE)
- warning ("Unexpected waitpid result %06x when waiting for "
- "vfork-done", status);
+ if ((status >> 16) != PTRACE_EVENT_VFORK_DONE)
+ warning (_("Unexpected waitpid result %06x when waiting for "
+ "vfork-done"), status);
}
else
{
target_detach (NULL, 0);
inferior_ptid = pid_to_ptid (child_pid);
- push_target (&child_ops);
+ push_target (&deprecated_child_ops);
/* Reset breakpoints in the child as appropriate. */
follow_inferior_reset_breakpoints ();
(event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
} while (ret == -1 && errno == EINTR);
if (ret == -1)
- perror_with_name ("waiting for new child");
+ perror_with_name (_("waiting for new child"));
else if (ret != new_pid)
internal_error (__FILE__, __LINE__,
- "wait returned unexpected PID %d", ret);
+ _("wait returned unexpected PID %d"), ret);
else if (!WIFSTOPPED (status) || WSTOPSIG (status) != SIGSTOP)
internal_error (__FILE__, __LINE__,
- "wait returned unexpected status 0x%x", status);
+ _("wait returned unexpected status 0x%x"), status);
}
if (event == PTRACE_EVENT_FORK)
}
internal_error (__FILE__, __LINE__,
- "unknown ptrace event %d", event);
+ _("unknown ptrace event %d"), event);
}
\f
-int
+void
child_insert_fork_catchpoint (int pid)
{
- if (! linux_supports_tracefork ())
- error ("Your system does not support fork catchpoints.");
-
- return 0;
+ if (! linux_supports_tracefork (pid))
+ error (_("Your system does not support fork catchpoints."));
}
-int
+void
child_insert_vfork_catchpoint (int pid)
{
- if (!linux_supports_tracefork ())
- error ("Your system does not support vfork catchpoints.");
-
- return 0;
+ if (!linux_supports_tracefork (pid))
+ error (_("Your system does not support vfork catchpoints."));
}
-int
+void
child_insert_exec_catchpoint (int pid)
{
- if (!linux_supports_tracefork ())
- error ("Your system does not support exec catchpoints.");
-
- return 0;
+ if (!linux_supports_tracefork (pid))
+ error (_("Your system does not support exec catchpoints."));
}
void
|| last.kind == TARGET_WAITKIND_VFORKED)
{
ptrace (PT_KILL, last.value.related_pid, 0, 0);
- ptrace_wait (null_ptid, &status);
+ wait (&status);
}
/* Kill the current process. */
ptrace (PT_KILL, pid, 0, 0);
- ret = ptrace_wait (null_ptid, &status);
+ ret = wait (&status);
/* We might get a SIGCHLD instead of an exit status. This is
aggravated by the first kill above - a child has just died. */
while (ret == pid && WIFSTOPPED (status))
{
ptrace (PT_KILL, pid, 0, 0);
- ret = ptrace_wait (null_ptid, &status);
+ ret = wait (&status);
}
target_mourn_inferior ();
}
if (verbose)
- printf_filtered ("[New %s]\n", target_pid_to_str (ptid));
+ printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
found_lp = lp = find_lwp_pid (ptid);
if (lp == NULL)
int status;
if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
- error ("Can't attach %s: %s", target_pid_to_str (ptid),
+ error (_("Can't attach %s: %s"), target_pid_to_str (ptid),
safe_strerror (errno));
if (debug_linux_nat)
/* FIXME: We should probably accept a list of process id's, and
attach all of them. */
- child_ops.to_attach (args, from_tty);
+ deprecated_child_ops.to_attach (args, from_tty);
/* Add the initial process as the first LWP to the list. */
lp = add_lwp (BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid)));
pid = waitpid (GET_PID (inferior_ptid), &status, 0);
if (pid == -1 && errno == ECHILD)
{
- warning ("%s is a cloned process", target_pid_to_str (inferior_ptid));
+ warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid));
/* Try again with __WCLONE to check cloned processes. */
pid = waitpid (GET_PID (inferior_ptid), &status, __WCLONE);
errno = 0;
if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
WSTOPSIG (lp->status)) < 0)
- error ("Can't continue %s: %s", target_pid_to_str (lp->ptid),
+ error (_("Can't continue %s: %s"), target_pid_to_str (lp->ptid),
safe_strerror (errno));
if (debug_linux_nat)
errno = 0;
if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
WSTOPSIG (lp->status)) < 0)
- error ("Can't detach %s: %s", target_pid_to_str (lp->ptid),
+ error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
safe_strerror (errno));
if (debug_linux_nat)
sigemptyset (&blocked_mask);
inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
- child_ops.to_detach (args, from_tty);
+ deprecated_child_ops.to_detach (args, from_tty);
}
/* Resume LP. */
/* Core GDB cannot deal with us deleting the current thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
- printf_unfiltered ("[%s exited]\n",
+ printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (lp->ptid));
}
if (lp->status)
{
if (debug_linux_nat)
- printf_unfiltered ("FC: LP has pending status %06x\n", lp->status);
+ printf_unfiltered (_("FC: LP has pending status %06x\n"), lp->status);
if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status)))
lp->status = 0;
}
if (pid == -1)
{
- warning ("Child process unexpectedly missing: %s",
+ warning (_("Child process unexpectedly missing: %s"),
safe_strerror (errno));
/* Claim it exited with unknown signal. */
}
add_thread (lp->ptid);
- printf_unfiltered ("[New %s]\n",
+ printf_unfiltered (_("[New %s]\n"),
target_pid_to_str (lp->ptid));
}
}
thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
- printf_unfiltered ("[%s exited]\n",
+ printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (lp->ptid));
}
thread. */
if (!ptid_equal (lp->ptid, inferior_ptid))
delete_thread (lp->ptid);
- printf_unfiltered ("[%s exited]\n",
+ printf_unfiltered (_("[%s exited]\n"),
target_pid_to_str (lp->ptid));
}
if (debug_linux_nat)
linux_nat_create_inferior (char *exec_file, char *allargs, char **env,
int from_tty)
{
- child_ops.to_create_inferior (exec_file, allargs, env, from_tty);
+ deprecated_child_ops.to_create_inferior (exec_file, allargs, env, from_tty);
}
static void
sigprocmask (SIG_SETMASK, &normal_mask, NULL);
sigemptyset (&blocked_mask);
- child_ops.to_mourn_inferior ();
+ deprecated_child_ops.to_mourn_inferior ();
}
static int
honor the LWP id, so we can use them directly. */
linux_nat_ops.to_fetch_registers = fetch_inferior_registers;
linux_nat_ops.to_store_registers = store_inferior_registers;
- linux_nat_ops.to_xfer_memory = linux_nat_xfer_memory;
+ linux_nat_ops.deprecated_xfer_memory = linux_nat_xfer_memory;
linux_nat_ops.to_kill = linux_nat_kill;
linux_nat_ops.to_create_inferior = linux_nat_create_inferior;
linux_nat_ops.to_mourn_inferior = linux_nat_mourn_inferior;
/* Compose the filename for the /proc memory map, and open it. */
sprintf (mapsfilename, "/proc/%lld/maps", pid);
if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
- error ("Could not open %s\n", mapsfilename);
+ error (_("Could not open %s."), mapsfilename);
if (info_verbose)
fprintf_filtered (gdb_stdout,
argv++;
}
if (pid == 0)
- error ("No current process: you must name one.");
+ error (_("No current process: you must name one."));
sprintf (fname1, "/proc/%lld", pid);
if (stat (fname1, &dummy) != 0)
- error ("No /proc directory: '%s'", fname1);
+ error (_("No /proc directory: '%s'"), fname1);
- printf_filtered ("process %lld\n", pid);
+ printf_filtered (_("process %lld\n"), pid);
if (cmdline_f || all)
{
sprintf (fname1, "/proc/%lld/cmdline", pid);
fclose (procfile);
}
else
- warning ("unable to open /proc file '%s'", fname1);
+ warning (_("unable to open /proc file '%s'"), fname1);
}
if (cwd_f || all)
{
if (readlink (fname1, fname2, sizeof (fname2)) > 0)
printf_filtered ("cwd = '%s'\n", fname2);
else
- warning ("unable to read link '%s'", fname1);
+ warning (_("unable to read link '%s'"), fname1);
}
if (exe_f || all)
{
if (readlink (fname1, fname2, sizeof (fname2)) > 0)
printf_filtered ("exe = '%s'\n", fname2);
else
- warning ("unable to read link '%s'", fname1);
+ warning (_("unable to read link '%s'"), fname1);
}
if (mappings_f || all)
{
long long addr, endaddr, size, offset, inode;
char permissions[8], device[8], filename[MAXPATHLEN];
- printf_filtered ("Mapped address spaces:\n\n");
+ printf_filtered (_("Mapped address spaces:\n\n"));
if (TARGET_ADDR_BIT == 32)
{
printf_filtered ("\t%10s %10s %10s %10s %7s\n",
fclose (procfile);
}
else
- warning ("unable to open /proc file '%s'", fname1);
+ warning (_("unable to open /proc file '%s'"), fname1);
}
if (status_f || all)
{
fclose (procfile);
}
else
- warning ("unable to open /proc file '%s'", fname1);
+ warning (_("unable to open /proc file '%s'"), fname1);
}
if (stat_f || all)
{
char ctmp;
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Process: %d\n", itmp);
+ printf_filtered (_("Process: %d\n"), itmp);
if (fscanf (procfile, "%s ", &buffer[0]) > 0)
- printf_filtered ("Exec file: %s\n", buffer);
+ printf_filtered (_("Exec file: %s\n"), buffer);
if (fscanf (procfile, "%c ", &ctmp) > 0)
- printf_filtered ("State: %c\n", ctmp);
+ printf_filtered (_("State: %c\n"), ctmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Parent process: %d\n", itmp);
+ printf_filtered (_("Parent process: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Process group: %d\n", itmp);
+ printf_filtered (_("Process group: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Session id: %d\n", itmp);
+ printf_filtered (_("Session id: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("TTY: %d\n", itmp);
+ printf_filtered (_("TTY: %d\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("TTY owner process group: %d\n", itmp);
+ printf_filtered (_("TTY owner process group: %d\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Flags: 0x%x\n", itmp);
+ printf_filtered (_("Flags: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Minor faults (no memory page): %u\n",
+ printf_filtered (_("Minor faults (no memory page): %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Minor faults, children: %u\n",
+ printf_filtered (_("Minor faults, children: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Major faults (memory page faults): %u\n",
+ printf_filtered (_("Major faults (memory page faults): %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Major faults, children: %u\n",
+ printf_filtered (_("Major faults, children: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("utime: %d\n", itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("stime, children: %d\n", itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("jiffies remaining in current time slice: %d\n",
+ printf_filtered (_("jiffies remaining in current time slice: %d\n"),
itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
printf_filtered ("'nice' value: %d\n", itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("jiffies until next timeout: %u\n",
+ printf_filtered (_("jiffies until next timeout: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("jiffies until next SIGALRM: %u\n",
(unsigned int) itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("start time (jiffies since system boot): %d\n",
+ printf_filtered (_("start time (jiffies since system boot): %d\n"),
itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Virtual memory size: %u\n",
+ printf_filtered (_("Virtual memory size: %u\n"),
(unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Resident set size: %u\n", (unsigned int) itmp);
+ printf_filtered (_("Resident set size: %u\n"), (unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
printf_filtered ("rlim: %u\n", (unsigned int) itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Start of text: 0x%x\n", itmp);
+ printf_filtered (_("Start of text: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("End of text: 0x%x\n", itmp);
+ printf_filtered (_("End of text: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0)
- printf_filtered ("Start of stack: 0x%x\n", itmp);
+ printf_filtered (_("Start of stack: 0x%x\n"), itmp);
#if 0 /* Don't know how architecture-dependent the rest is...
Anyway the signal bitmap info is available from "status". */
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
- printf_filtered ("Kernel stack pointer: 0x%x\n", itmp);
+ printf_filtered (_("Kernel stack pointer: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
- printf_filtered ("Kernel instr pointer: 0x%x\n", itmp);
+ printf_filtered (_("Kernel instr pointer: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Pending signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Pending signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Blocked signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Blocked signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Ignored signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Ignored signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%d ", &itmp) > 0)
- printf_filtered ("Catched signals bitmap: 0x%x\n", itmp);
+ printf_filtered (_("Catched signals bitmap: 0x%x\n"), itmp);
if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
- printf_filtered ("wchan (system call): 0x%x\n", itmp);
+ printf_filtered (_("wchan (system call): 0x%x\n"), itmp);
#endif
fclose (procfile);
}
else
- warning ("unable to open /proc file '%s'", fname1);
+ warning (_("unable to open /proc file '%s'"), fname1);
}
}
int signum;
if (line[len] != '\n')
- error ("Could not parse signal set: %s", line);
+ error (_("Could not parse signal set: %s"), line);
p = line;
signum = len * 4;
else if (*p >= 'a' && *p <= 'f')
digit = *p - 'a' + 10;
else
- error ("Could not parse signal set: %s", line);
+ error (_("Could not parse signal set: %s"), line);
signum -= 4;
sprintf (fname, "/proc/%d/status", pid);
procfile = fopen (fname, "r");
if (procfile == NULL)
- error ("Could not open %s", fname);
+ error (_("Could not open %s"), fname);
while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
{
struct sigaction action;
extern void thread_db_init (struct target_ops *);
- child_ops.to_find_memory_regions = linux_nat_find_memory_regions;
- child_ops.to_make_corefile_notes = linux_nat_make_corefile_notes;
+ deprecated_child_ops.to_find_memory_regions = linux_nat_find_memory_regions;
+ deprecated_child_ops.to_make_corefile_notes = linux_nat_make_corefile_notes;
- add_info ("proc", linux_nat_info_proc_cmd,
- "Show /proc process information about any running process.\n\
+ add_info ("proc", linux_nat_info_proc_cmd, _("\
+Show /proc process information about any running process.\n\
Specify any process id, or use the program being debugged by default.\n\
Specify any of the following keywords for detailed info:\n\
mappings -- list of mapped memory regions.\n\
stat -- list a bunch of random process info.\n\
status -- list a different bunch of random process info.\n\
- all -- list all available /proc info.");
+ all -- list all available /proc info."));
init_linux_nat_ops ();
add_target (&linux_nat_ops);
sigemptyset (&blocked_mask);
- deprecated_add_show_from_set
- (add_set_cmd ("lin-lwp", no_class, var_zinteger,
- (char *) &debug_linux_nat,
- "Set debugging of GNU/Linux lwp module.\n\
-Enables printf debugging output.\n", &setdebuglist), &showdebuglist);
+ add_setshow_zinteger_cmd ("lin-lwp", no_class, &debug_linux_nat, _("\
+Set debugging of GNU/Linux lwp module."), _("\
+Show debugging of GNU/Linux lwp module."), _("\
+Enables printf debugging output."),
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setdebuglist, &showdebuglist);
}
\f
projects / external / binutils.git / blobdiff