+ bool do_status = false;
+
+ switch (what)
+ {
+ case IP_MINIMAL:
+ do_cmdline = true;
+ do_cwd = true;
+ do_exe = true;
+ break;
+#ifdef HAVE_KINFO_GETVMMAP
+ case IP_MAPPINGS:
+ do_mappings = true;
+ break;
+#endif
+ case IP_STATUS:
+ case IP_STAT:
+ do_status = true;
+ break;
+ case IP_CMDLINE:
+ do_cmdline = true;
+ break;
+ case IP_EXE:
+ do_exe = true;
+ break;
+ case IP_CWD:
+ do_cwd = true;
+ break;
+#ifdef HAVE_KINFO_GETFILE
+ case IP_FILES:
+ do_files = true;
+ break;
+#endif
+ case IP_ALL:
+ do_cmdline = true;
+ do_cwd = true;
+ do_exe = true;
+#ifdef HAVE_KINFO_GETFILE
+ do_files = true;
+#endif
+#ifdef HAVE_KINFO_GETVMMAP
+ do_mappings = true;
+#endif
+ do_status = true;
+ break;
+ default:
+ error (_("Not supported on this target."));
+ }
+
+ gdb_argv built_argv (args);
+ if (built_argv.count () == 0)
+ {
+ pid = inferior_ptid.pid ();
+ if (pid == 0)
+ error (_("No current process: you must name one."));
+ }
+ else if (built_argv.count () == 1 && isdigit (built_argv[0][0]))
+ pid = strtol (built_argv[0], NULL, 10);
+ else
+ error (_("Invalid arguments."));
+
+ printf_filtered (_("process %d\n"), pid);
+#ifdef HAVE_KINFO_GETFILE
+ if (do_cwd || do_exe || do_files)
+ fdtbl.reset (kinfo_getfile (pid, &nfd));
+#endif
+
+ if (do_cmdline)
+ {
+ gdb::unique_xmalloc_ptr<char> cmdline = fbsd_fetch_cmdline (pid);
+ if (cmdline != nullptr)
+ printf_filtered ("cmdline = '%s'\n", cmdline.get ());
+ else
+ warning (_("unable to fetch command line"));
+ }
+ if (do_cwd)
+ {
+ const char *cwd = NULL;
+#ifdef HAVE_KINFO_GETFILE
+ struct kinfo_file *kf = fdtbl.get ();
+ for (int i = 0; i < nfd; i++, kf++)
+ {
+ if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_CWD)
+ {
+ cwd = kf->kf_path;
+ break;
+ }
+ }
+#endif
+ if (cwd != NULL)
+ printf_filtered ("cwd = '%s'\n", cwd);
+ else
+ warning (_("unable to fetch current working directory"));
+ }
+ if (do_exe)
+ {
+ const char *exe = NULL;
+#ifdef HAVE_KINFO_GETFILE
+ struct kinfo_file *kf = fdtbl.get ();
+ for (int i = 0; i < nfd; i++, kf++)
+ {
+ if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_TEXT)
+ {
+ exe = kf->kf_path;
+ break;
+ }
+ }
+#endif
+ if (exe == NULL)
+ exe = pid_to_exec_file (pid);
+ if (exe != NULL)
+ printf_filtered ("exe = '%s'\n", exe);
+ else
+ warning (_("unable to fetch executable path name"));
+ }
+#ifdef HAVE_KINFO_GETFILE
+ if (do_files)
+ {
+ struct kinfo_file *kf = fdtbl.get ();
+
+ if (nfd > 0)
+ {
+ fbsd_info_proc_files_header ();
+ for (int i = 0; i < nfd; i++, kf++)
+ fbsd_info_proc_files_entry (kf->kf_type, kf->kf_fd, kf->kf_flags,
+ kf->kf_offset, kf->kf_vnode_type,
+ kf->kf_sock_domain, kf->kf_sock_type,
+ kf->kf_sock_protocol, &kf->kf_sa_local,
+ &kf->kf_sa_peer, kf->kf_path);
+ }
+ else
+ warning (_("unable to fetch list of open files"));
+ }
+#endif
+#ifdef HAVE_KINFO_GETVMMAP
+ if (do_mappings)
+ {
+ int nvment;
+ gdb::unique_xmalloc_ptr<struct kinfo_vmentry>
+ vmentl (kinfo_getvmmap (pid, &nvment));
+
+ if (vmentl != nullptr)
+ {
+ int addr_bit = TARGET_CHAR_BIT * sizeof (void *);
+ fbsd_info_proc_mappings_header (addr_bit);
+
+ struct kinfo_vmentry *kve = vmentl.get ();
+ for (int i = 0; i < nvment; i++, kve++)
+ fbsd_info_proc_mappings_entry (addr_bit, kve->kve_start,
+ kve->kve_end, kve->kve_offset,
+ kve->kve_flags, kve->kve_protection,
+ kve->kve_path);
+ }
+ else
+ warning (_("unable to fetch virtual memory map"));
+ }
+#endif
+ if (do_status)
+ {
+ if (!fbsd_fetch_kinfo_proc (pid, &kp))
+ warning (_("Failed to fetch process information"));
+ else
+ {
+ const char *state;
+ int pgtok;
+
+ printf_filtered ("Name: %s\n", kp.ki_comm);
+ switch (kp.ki_stat)
+ {
+ case SIDL:
+ state = "I (idle)";
+ break;
+ case SRUN:
+ state = "R (running)";
+ break;
+ case SSTOP:
+ state = "T (stopped)";
+ break;
+ case SZOMB:
+ state = "Z (zombie)";
+ break;
+ case SSLEEP:
+ state = "S (sleeping)";
+ break;
+ case SWAIT:
+ state = "W (interrupt wait)";
+ break;
+ case SLOCK:
+ state = "L (blocked on lock)";
+ break;
+ default:
+ state = "? (unknown)";
+ break;
+ }
+ printf_filtered ("State: %s\n", state);
+ printf_filtered ("Parent process: %d\n", kp.ki_ppid);
+ printf_filtered ("Process group: %d\n", kp.ki_pgid);
+ printf_filtered ("Session id: %d\n", kp.ki_sid);
+ printf_filtered ("TTY: %ju\n", (uintmax_t) kp.ki_tdev);
+ printf_filtered ("TTY owner process group: %d\n", kp.ki_tpgid);
+ printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
+ kp.ki_ruid, kp.ki_uid, kp.ki_svuid);
+ printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
+ kp.ki_rgid, kp.ki_groups[0], kp.ki_svgid);
+ printf_filtered ("Groups: ");
+ for (int i = 0; i < kp.ki_ngroups; i++)
+ printf_filtered ("%d ", kp.ki_groups[i]);
+ printf_filtered ("\n");
+ printf_filtered ("Minor faults (no memory page): %ld\n",
+ kp.ki_rusage.ru_minflt);
+ printf_filtered ("Minor faults, children: %ld\n",
+ kp.ki_rusage_ch.ru_minflt);
+ printf_filtered ("Major faults (memory page faults): %ld\n",
+ kp.ki_rusage.ru_majflt);
+ printf_filtered ("Major faults, children: %ld\n",
+ kp.ki_rusage_ch.ru_majflt);
+ printf_filtered ("utime: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage.ru_utime.tv_sec,
+ kp.ki_rusage.ru_utime.tv_usec);
+ printf_filtered ("stime: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage.ru_stime.tv_sec,
+ kp.ki_rusage.ru_stime.tv_usec);
+ printf_filtered ("utime, children: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage_ch.ru_utime.tv_sec,
+ kp.ki_rusage_ch.ru_utime.tv_usec);
+ printf_filtered ("stime, children: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage_ch.ru_stime.tv_sec,
+ kp.ki_rusage_ch.ru_stime.tv_usec);
+ printf_filtered ("'nice' value: %d\n", kp.ki_nice);
+ printf_filtered ("Start time: %jd.%06ld\n", kp.ki_start.tv_sec,
+ kp.ki_start.tv_usec);
+ pgtok = getpagesize () / 1024;
+ printf_filtered ("Virtual memory size: %ju kB\n",
+ (uintmax_t) kp.ki_size / 1024);
+ printf_filtered ("Data size: %ju kB\n",
+ (uintmax_t) kp.ki_dsize * pgtok);
+ printf_filtered ("Stack size: %ju kB\n",
+ (uintmax_t) kp.ki_ssize * pgtok);
+ printf_filtered ("Text size: %ju kB\n",
+ (uintmax_t) kp.ki_tsize * pgtok);
+ printf_filtered ("Resident set size: %ju kB\n",
+ (uintmax_t) kp.ki_rssize * pgtok);
+ printf_filtered ("Maximum RSS: %ju kB\n",
+ (uintmax_t) kp.ki_rusage.ru_maxrss);
+ printf_filtered ("Pending Signals: ");
+ for (int i = 0; i < _SIG_WORDS; i++)
+ printf_filtered ("%08x ", kp.ki_siglist.__bits[i]);
+ printf_filtered ("\n");
+ printf_filtered ("Ignored Signals: ");
+ for (int i = 0; i < _SIG_WORDS; i++)
+ printf_filtered ("%08x ", kp.ki_sigignore.__bits[i]);
+ printf_filtered ("\n");
+ printf_filtered ("Caught Signals: ");
+ for (int i = 0; i < _SIG_WORDS; i++)
+ printf_filtered ("%08x ", kp.ki_sigcatch.__bits[i]);
+ printf_filtered ("\n");
+ }
+ }
+
+ return true;
+}
+
+/*
+ * The current layout of siginfo_t on FreeBSD was adopted in SVN
+ * revision 153154 which shipped in FreeBSD versions 7.0 and later.
+ * Don't bother supporting the older layout on older kernels. The
+ * older format was also never used in core dump notes.
+ */
+#if __FreeBSD_version >= 700009
+#define USE_SIGINFO
+#endif
+
+#ifdef USE_SIGINFO
+/* Return the size of siginfo for the current inferior. */
+
+#ifdef __LP64__
+union sigval32 {
+ int sival_int;
+ uint32_t sival_ptr;
+};
+
+/* This structure matches the naming and layout of `siginfo_t' in
+ <sys/signal.h>. In particular, the `si_foo' macros defined in that
+ header can be used with both types to copy fields in the `_reason'
+ union. */
+
+struct siginfo32
+{
+ int si_signo;
+ int si_errno;
+ int si_code;
+ __pid_t si_pid;
+ __uid_t si_uid;
+ int si_status;
+ uint32_t si_addr;
+ union sigval32 si_value;
+ union
+ {
+ struct
+ {
+ int _trapno;
+ } _fault;
+ struct
+ {
+ int _timerid;
+ int _overrun;
+ } _timer;
+ struct
+ {
+ int _mqd;
+ } _mesgq;
+ struct
+ {
+ int32_t _band;
+ } _poll;
+ struct
+ {
+ int32_t __spare1__;
+ int __spare2__[7];
+ } __spare__;
+ } _reason;
+};
+#endif
+
+static size_t
+fbsd_siginfo_size ()
+{
+#ifdef __LP64__
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+
+ /* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
+ if (gdbarch_long_bit (gdbarch) == 32)
+ return sizeof (struct siginfo32);
+#endif
+ return sizeof (siginfo_t);
+}
+
+/* Convert a native 64-bit siginfo object to a 32-bit object. Note
+ that FreeBSD doesn't support writing to $_siginfo, so this only
+ needs to convert one way. */
+
+static void
+fbsd_convert_siginfo (siginfo_t *si)
+{
+#ifdef __LP64__
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+
+ /* Is the inferior 32-bit? If not, nothing to do. */
+ if (gdbarch_long_bit (gdbarch) != 32)
+ return;
+
+ struct siginfo32 si32;
+
+ si32.si_signo = si->si_signo;
+ si32.si_errno = si->si_errno;
+ si32.si_code = si->si_code;
+ si32.si_pid = si->si_pid;
+ si32.si_uid = si->si_uid;
+ si32.si_status = si->si_status;
+ si32.si_addr = (uintptr_t) si->si_addr;
+
+ /* If sival_ptr is being used instead of sival_int on a big-endian
+ platform, then sival_int will be zero since it holds the upper
+ 32-bits of the pointer value. */
+#if _BYTE_ORDER == _BIG_ENDIAN
+ if (si->si_value.sival_int == 0)
+ si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
+ else
+ si32.si_value.sival_int = si->si_value.sival_int;
+#else
+ si32.si_value.sival_int = si->si_value.sival_int;
+#endif
+
+ /* Always copy the spare fields and then possibly overwrite them for
+ signal-specific or code-specific fields. */
+ si32._reason.__spare__.__spare1__ = si->_reason.__spare__.__spare1__;
+ for (int i = 0; i < 7; i++)
+ si32._reason.__spare__.__spare2__[i] = si->_reason.__spare__.__spare2__[i];
+ switch (si->si_signo) {
+ case SIGILL:
+ case SIGFPE:
+ case SIGSEGV:
+ case SIGBUS:
+ si32.si_trapno = si->si_trapno;
+ break;
+ }
+ switch (si->si_code) {
+ case SI_TIMER:
+ si32.si_timerid = si->si_timerid;
+ si32.si_overrun = si->si_overrun;
+ break;
+ case SI_MESGQ:
+ si32.si_mqd = si->si_mqd;
+ break;
+ }
+
+ memcpy(si, &si32, sizeof (si32));
+#endif
+}
+#endif
+
+/* Implement the "xfer_partial" target_ops method. */
+
+enum target_xfer_status
+fbsd_nat_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ pid_t pid = inferior_ptid.pid ();
+
+ switch (object)
+ {
+#ifdef USE_SIGINFO
+ case TARGET_OBJECT_SIGNAL_INFO:
+ {
+ struct ptrace_lwpinfo pl;
+ size_t siginfo_size;
+
+ /* FreeBSD doesn't support writing to $_siginfo. */
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+
+ if (inferior_ptid.lwp_p ())
+ pid = inferior_ptid.lwp ();
+
+ siginfo_size = fbsd_siginfo_size ();
+ if (offset > siginfo_size)
+ return TARGET_XFER_E_IO;
+
+ if (ptrace (PT_LWPINFO, pid, (PTRACE_TYPE_ARG3) &pl, sizeof (pl)) == -1)
+ return TARGET_XFER_E_IO;
+
+ if (!(pl.pl_flags & PL_FLAG_SI))
+ return TARGET_XFER_E_IO;
+
+ fbsd_convert_siginfo (&pl.pl_siginfo);
+ if (offset + len > siginfo_size)
+ len = siginfo_size - offset;
+
+ memcpy (readbuf, ((gdb_byte *) &pl.pl_siginfo) + offset, len);
+ *xfered_len = len;
+ return TARGET_XFER_OK;
+ }
+#endif
+#ifdef KERN_PROC_AUXV
+ case TARGET_OBJECT_AUXV:
+ {
+ gdb::byte_vector buf_storage;
+ gdb_byte *buf;
+ size_t buflen;
+ int mib[4];
+
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_AUXV;
+ mib[3] = pid;
+ if (offset == 0)
+ {
+ buf = readbuf;
+ buflen = len;
+ }
+ else
+ {
+ buflen = offset + len;
+ buf_storage.resize (buflen);
+ buf = buf_storage.data ();
+ }
+ if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
+ {
+ if (offset != 0)
+ {
+ if (buflen > offset)
+ {
+ buflen -= offset;
+ memcpy (readbuf, buf + offset, buflen);
+ }
+ else
+ buflen = 0;
+ }
+ *xfered_len = buflen;
+ return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
+ }
+ return TARGET_XFER_E_IO;
+ }
+#endif
+#if defined(KERN_PROC_VMMAP) && defined(KERN_PROC_PS_STRINGS)
+ case TARGET_OBJECT_FREEBSD_VMMAP:
+ case TARGET_OBJECT_FREEBSD_PS_STRINGS:
+ {
+ gdb::byte_vector buf_storage;
+ gdb_byte *buf;
+ size_t buflen;
+ int mib[4];
+
+ int proc_target;
+ uint32_t struct_size;
+ switch (object)
+ {
+ case TARGET_OBJECT_FREEBSD_VMMAP:
+ proc_target = KERN_PROC_VMMAP;
+ struct_size = sizeof (struct kinfo_vmentry);
+ break;
+ case TARGET_OBJECT_FREEBSD_PS_STRINGS:
+ proc_target = KERN_PROC_PS_STRINGS;
+ struct_size = sizeof (void *);
+ break;
+ }
+
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = proc_target;
+ mib[3] = pid;
+
+ if (sysctl (mib, 4, NULL, &buflen, NULL, 0) != 0)
+ return TARGET_XFER_E_IO;
+ buflen += sizeof (struct_size);
+
+ if (offset >= buflen)
+ {
+ *xfered_len = 0;
+ return TARGET_XFER_EOF;
+ }
+
+ buf_storage.resize (buflen);
+ buf = buf_storage.data ();
+
+ memcpy (buf, &struct_size, sizeof (struct_size));
+ buflen -= sizeof (struct_size);
+ if (sysctl (mib, 4, buf + sizeof (struct_size), &buflen, NULL, 0) != 0)
+ return TARGET_XFER_E_IO;
+ buflen += sizeof (struct_size);
+
+ if (buflen - offset < len)
+ len = buflen - offset;
+ memcpy (readbuf, buf + offset, len);
+ *xfered_len = len;
+ return TARGET_XFER_OK;
+ }
+#endif
+ default:
+ return inf_ptrace_target::xfer_partial (object, annex,
+ readbuf, writebuf, offset,
+ len, xfered_len);
+ }
+}
+
+#ifdef PT_LWPINFO
+static bool debug_fbsd_lwp;
+static bool debug_fbsd_nat;
+
+static void
+show_fbsd_lwp_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
+}
+
+static void
+show_fbsd_nat_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Debugging of FreeBSD native target is %s.\n"),
+ value);
+}