/* Native-dependent code for FreeBSD.
- Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2002-2014 Free Software Foundation, Inc.
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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include "regset.h"
+#include "gdbthread.h"
#include "gdb_assert.h"
-#include "gdb_string.h"
+#include <string.h>
#include <sys/types.h>
#include <sys/procfs.h>
#include <sys/sysctl.h>
#include "elf-bfd.h"
#include "fbsd-nat.h"
-/* Return a the name of file that can be opened to get the symbols for
+/* Return the name of a file that can be opened to get the symbols for
the child process identified by PID. */
char *
-fbsd_pid_to_exec_file (int pid)
+fbsd_pid_to_exec_file (struct target_ops *self, int pid)
{
- size_t len = MAXPATHLEN;
- char *buf = xcalloc (len, sizeof (char));
- char *path;
+ ssize_t len = PATH_MAX;
+ static char buf[PATH_MAX];
+ char name[PATH_MAX];
#ifdef KERN_PROC_PATHNAME
int mib[4];
return buf;
#endif
- path = xstrprintf ("/proc/%d/file", pid);
- if (readlink (path, buf, MAXPATHLEN) == -1)
+ xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
+ len = readlink (name, buf, PATH_MAX - 1);
+ if (len != -1)
{
- xfree (buf);
- buf = NULL;
+ buf[len] = '\0';
+ return buf;
}
- xfree (path);
- return buf;
+ return NULL;
}
static int
argument to FUNC. */
int
-fbsd_find_memory_regions (int (*func) (CORE_ADDR, unsigned long,
- int, int, int, void *),
- void *obfd)
+fbsd_find_memory_regions (struct target_ops *self,
+ find_memory_region_ftype func, void *obfd)
{
pid_t pid = ptid_get_pid (inferior_ptid);
char *mapfilename;
unsigned long start, end, size;
char protection[4];
int read, write, exec;
+ struct cleanup *cleanup;
mapfilename = xstrprintf ("/proc/%ld/map", (long) pid);
+ cleanup = make_cleanup (xfree, mapfilename);
mapfile = fopen (mapfilename, "r");
if (mapfile == NULL)
error (_("Couldn't open %s."), mapfilename);
+ make_cleanup_fclose (mapfile);
if (info_verbose)
fprintf_filtered (gdb_stdout,
if (info_verbose)
{
fprintf_filtered (gdb_stdout,
- "Save segment, %ld bytes at 0x%s (%c%c%c)\n",
- size, paddr_nz (start),
+ "Save segment, %ld bytes at %s (%c%c%c)\n",
+ size, paddress (target_gdbarch (), start),
read ? 'r' : '-',
write ? 'w' : '-',
exec ? 'x' : '-');
}
- /* Invoke the callback function to create the corefile segment. */
- func (start, size, read, write, exec, obfd);
+ /* Invoke the callback function to create the corefile segment.
+ Pass MODIFIED as true, we do not know the real modification state. */
+ func (start, size, read, write, exec, 1, obfd);
}
- fclose (mapfile);
+ do_cleanups (cleanup);
return 0;
}
+static int
+find_signalled_thread (struct thread_info *info, void *data)
+{
+ if (info->suspend.stop_signal != GDB_SIGNAL_0
+ && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
+ return 1;
+
+ return 0;
+}
+
+static enum gdb_signal
+find_stop_signal (void)
+{
+ struct thread_info *info =
+ iterate_over_threads (find_signalled_thread, NULL);
+
+ if (info)
+ return info->suspend.stop_signal;
+ else
+ return GDB_SIGNAL_0;
+}
+
/* Create appropriate note sections for a corefile, returning them in
allocated memory. */
char *
-fbsd_make_corefile_notes (bfd *obfd, int *note_size)
+fbsd_make_corefile_notes (struct target_ops *self, bfd *obfd, int *note_size)
{
- struct gdbarch *gdbarch = current_gdbarch;
- const struct regcache *regcache = current_regcache;
+ const struct regcache *regcache = get_current_regcache ();
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
gregset_t gregs;
fpregset_t fpregs;
char *note_data = NULL;
note_data = elfcore_write_prstatus (obfd, note_data, note_size,
ptid_get_pid (inferior_ptid),
- stop_signal, &gregs);
+ find_stop_signal (), &gregs);
size = sizeof fpregs;
regset = gdbarch_regset_from_core_section (gdbarch, ".reg2", size);
if (get_exec_file (0))
{
- char *fname = strrchr (get_exec_file (0), '/') + 1;
+ const char *fname = lbasename (get_exec_file (0));
char *psargs = xstrdup (fname);
if (get_inferior_args ())
- psargs = reconcat (psargs, psargs, " ", get_inferior_args (), NULL);
+ psargs = reconcat (psargs, psargs, " ", get_inferior_args (),
+ (char *) NULL);
note_data = elfcore_write_prpsinfo (obfd, note_data, note_size,
fname, psargs);
}
- make_cleanup (xfree, note_data);
return note_data;
}
projects / deliverable / binutils-gdb.git / blobdiff