GDB (xrefs)
Loading...
Searching...
No Matches
netbsd-nat.c
Go to the documentation of this file.
1/* Native-dependent code for NetBSD.
2
3 Copyright (C) 2006-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21
22#include "netbsd-nat.h"
23#include "nat/netbsd-nat.h"
24#include "gdbthread.h"
25#include "netbsd-tdep.h"
26#include "inferior.h"
27#include "gdbarch.h"
28#include "gdbsupport/buildargv.h"
29
30#include <sys/types.h>
31#include <sys/ptrace.h>
32#include <sys/sysctl.h>
33#include <sys/wait.h>
34
35/* Return the name of a file that can be opened to get the symbols for
36 the child process identified by PID. */
37
38const char *
43
44/* Return the current directory for the process identified by PID. */
45
46static std::string
48{
49 char buf[PATH_MAX];
50 size_t buflen;
51 int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_CWD};
52 buflen = sizeof (buf);
53 if (sysctl (mib, ARRAY_SIZE (mib), buf, &buflen, NULL, 0))
54 return "";
55 return buf;
56}
57
58/* Return the kinfo_proc2 structure for the process identified by PID. */
59
60static bool
61nbsd_pid_to_kinfo_proc2 (pid_t pid, struct kinfo_proc2 *kp)
62{
63 gdb_assert (kp != nullptr);
64
65 size_t size = sizeof (*kp);
66 int mib[6] = {CTL_KERN, KERN_PROC2, KERN_PROC_PID, pid,
67 static_cast<int> (size), 1};
68 return !sysctl (mib, ARRAY_SIZE (mib), kp, &size, NULL, 0);
69}
70
71/* Return the command line for the process identified by PID. */
72
73static gdb::unique_xmalloc_ptr<char[]>
75{
76 int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV};
77
78 size_t size = 0;
79 if (::sysctl (mib, ARRAY_SIZE (mib), NULL, &size, NULL, 0) == -1 || size == 0)
80 return nullptr;
81
82 gdb::unique_xmalloc_ptr<char[]> args (XNEWVAR (char, size));
83
84 if (::sysctl (mib, ARRAY_SIZE (mib), args.get (), &size, NULL, 0) == -1
85 || size == 0)
86 return nullptr;
87
88 /* Arguments are returned as a flattened string with NUL separators.
89 Join the arguments with spaces to form a single string. */
90 for (size_t i = 0; i < size - 1; i++)
91 if (args[i] == '\0')
92 args[i] = ' ';
93 args[size - 1] = '\0';
94
95 return args;
96}
97
98/* Return true if PTID is still active in the inferior. */
99
100bool
102{
103 return netbsd_nat::thread_alive (ptid);
104}
105
106/* Return the name assigned to a thread by an application. Returns
107 the string in a static buffer. */
108
109const char *
111{
112 ptid_t ptid = thr->ptid;
113 return netbsd_nat::thread_name (ptid);
114}
115
116/* Implement the "post_attach" target_ops method. */
117
118static void
120{
121 auto fn
122 = [&target] (ptid_t ptid)
123 {
124 if (!in_thread_list (target, ptid))
125 {
126 if (inferior_ptid.lwp () == 0)
127 thread_change_ptid (target, inferior_ptid, ptid);
128 else
129 add_thread (target, ptid);
130 }
131 };
132
134}
135
136/* Implement the virtual inf_ptrace_target::post_startup_inferior method. */
137
138void
143
144/* Implement the "post_attach" target_ops method. */
145
146void
152
153/* Implement the "update_thread_list" target_ops method. */
154
155void
160
161/* Convert PTID to a string. */
162
163std::string
165{
166 int lwp = ptid.lwp ();
167
168 if (lwp != 0)
169 {
170 pid_t pid = ptid.pid ();
171
172 return string_printf ("LWP %d of process %d", lwp, pid);
173 }
174
175 return normal_pid_to_str (ptid);
176}
177
178/* Retrieve all the memory regions in the specified process. */
179
180static gdb::unique_xmalloc_ptr<struct kinfo_vmentry[]>
182{
183 int mib[5] = {CTL_VM, VM_PROC, VM_PROC_MAP, pid,
184 sizeof (struct kinfo_vmentry)};
185
186 size_t length = 0;
187 if (sysctl (mib, ARRAY_SIZE (mib), NULL, &length, NULL, 0))
188 {
189 *size = 0;
190 return NULL;
191 }
192
193 /* Prereserve more space. The length argument is volatile and can change
194 between the sysctl(3) calls as this function can be called against a
195 running process. */
196 length = length * 5 / 3;
197
198 gdb::unique_xmalloc_ptr<struct kinfo_vmentry[]> kiv
199 (XNEWVAR (kinfo_vmentry, length));
200
201 if (sysctl (mib, ARRAY_SIZE (mib), kiv.get (), &length, NULL, 0))
202 {
203 *size = 0;
204 return NULL;
205 }
206
207 *size = length / sizeof (struct kinfo_vmentry);
208 return kiv;
209}
210
211/* Iterate over all the memory regions in the current inferior,
212 calling FUNC for each memory region. OBFD is passed as the last
213 argument to FUNC. */
214
215int
217 void *data)
218{
219 pid_t pid = inferior_ptid.pid ();
220
221 size_t nitems;
222 gdb::unique_xmalloc_ptr<struct kinfo_vmentry[]> vmentl
223 = nbsd_kinfo_get_vmmap (pid, &nitems);
224 if (vmentl == NULL)
225 perror_with_name (_("Couldn't fetch VM map entries"));
226
227 for (size_t i = 0; i < nitems; i++)
228 {
229 struct kinfo_vmentry *kve = &vmentl[i];
230
231 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
232 if (!(kve->kve_protection & KVME_PROT_READ)
233 || kve->kve_flags & KVME_FLAG_NOCOREDUMP)
234 continue;
235
236 /* Skip segments with an invalid type. */
237 switch (kve->kve_type)
238 {
239 case KVME_TYPE_VNODE:
240 case KVME_TYPE_ANON:
241 case KVME_TYPE_SUBMAP:
242 case KVME_TYPE_OBJECT:
243 break;
244 default:
245 continue;
246 }
247
248 size_t size = kve->kve_end - kve->kve_start;
249 if (info_verbose)
250 {
251 gdb_printf ("Save segment, %ld bytes at %s (%c%c%c)\n",
252 (long) size,
253 paddress (target_gdbarch (), kve->kve_start),
254 kve->kve_protection & KVME_PROT_READ ? 'r' : '-',
255 kve->kve_protection & KVME_PROT_WRITE ? 'w' : '-',
256 kve->kve_protection & KVME_PROT_EXEC ? 'x' : '-');
257 }
258
259 /* Invoke the callback function to create the corefile segment.
260 Pass MODIFIED as true, we do not know the real modification state. */
261 func (kve->kve_start, size, kve->kve_protection & KVME_PROT_READ,
262 kve->kve_protection & KVME_PROT_WRITE,
263 kve->kve_protection & KVME_PROT_EXEC, 1, false, data);
264 }
265 return 0;
266}
267
268/* Implement the "info_proc" target_ops method. */
269
270bool
271nbsd_nat_target::info_proc (const char *args, enum info_proc_what what)
272{
273 pid_t pid;
274 bool do_cmdline = false;
275 bool do_cwd = false;
276 bool do_exe = false;
277 bool do_mappings = false;
278 bool do_status = false;
279
280 switch (what)
281 {
282 case IP_MINIMAL:
283 do_cmdline = true;
284 do_cwd = true;
285 do_exe = true;
286 break;
287 case IP_STAT:
288 case IP_STATUS:
289 do_status = true;
290 break;
291 case IP_MAPPINGS:
292 do_mappings = true;
293 break;
294 case IP_CMDLINE:
295 do_cmdline = true;
296 break;
297 case IP_EXE:
298 do_exe = true;
299 break;
300 case IP_CWD:
301 do_cwd = true;
302 break;
303 case IP_ALL:
304 do_cmdline = true;
305 do_cwd = true;
306 do_exe = true;
307 do_mappings = true;
308 do_status = true;
309 break;
310 default:
311 error (_("Not supported on this target."));
312 }
313
314 gdb_argv built_argv (args);
315 if (built_argv.count () == 0)
316 {
317 pid = inferior_ptid.pid ();
318 if (pid == 0)
319 error (_("No current process: you must name one."));
320 }
321 else if (built_argv.count () == 1 && isdigit (built_argv[0][0]))
322 pid = strtol (built_argv[0], NULL, 10);
323 else
324 error (_("Invalid arguments."));
325
326 gdb_printf (_("process %d\n"), pid);
327
328 if (do_cmdline)
329 {
330 gdb::unique_xmalloc_ptr<char[]> cmdline = nbsd_pid_to_cmdline (pid);
331 if (cmdline != nullptr)
332 gdb_printf ("cmdline = '%s'\n", cmdline.get ());
333 else
334 warning (_("unable to fetch command line"));
335 }
336 if (do_cwd)
337 {
338 std::string cwd = nbsd_pid_to_cwd (pid);
339 if (cwd != "")
340 gdb_printf ("cwd = '%s'\n", cwd.c_str ());
341 else
342 warning (_("unable to fetch current working directory"));
343 }
344 if (do_exe)
345 {
346 const char *exe = pid_to_exec_file (pid);
347 if (exe != nullptr)
348 gdb_printf ("exe = '%s'\n", exe);
349 else
350 warning (_("unable to fetch executable path name"));
351 }
352 if (do_mappings)
353 {
354 size_t nvment;
355 gdb::unique_xmalloc_ptr<struct kinfo_vmentry[]> vmentl
356 = nbsd_kinfo_get_vmmap (pid, &nvment);
357
358 if (vmentl != nullptr)
359 {
360 int addr_bit = TARGET_CHAR_BIT * sizeof (void *);
362
363 struct kinfo_vmentry *kve = vmentl.get ();
364 for (int i = 0; i < nvment; i++, kve++)
365 nbsd_info_proc_mappings_entry (addr_bit, kve->kve_start,
366 kve->kve_end, kve->kve_offset,
367 kve->kve_flags, kve->kve_protection,
368 kve->kve_path);
369 }
370 else
371 warning (_("unable to fetch virtual memory map"));
372 }
373 if (do_status)
374 {
375 struct kinfo_proc2 kp;
376 if (!nbsd_pid_to_kinfo_proc2 (pid, &kp))
377 warning (_("Failed to fetch process information"));
378 else
379 {
380 auto process_status
381 = [] (int8_t stat)
382 {
383 switch (stat)
384 {
385 case SIDL:
386 return "IDL";
387 case SACTIVE:
388 return "ACTIVE";
389 case SDYING:
390 return "DYING";
391 case SSTOP:
392 return "STOP";
393 case SZOMB:
394 return "ZOMB";
395 case SDEAD:
396 return "DEAD";
397 default:
398 return "? (unknown)";
399 }
400 };
401
402 gdb_printf ("Name: %s\n", kp.p_comm);
403 gdb_printf ("State: %s\n", process_status(kp.p_realstat));
404 gdb_printf ("Parent process: %" PRId32 "\n", kp.p_ppid);
405 gdb_printf ("Process group: %" PRId32 "\n", kp.p__pgid);
406 gdb_printf ("Session id: %" PRId32 "\n", kp.p_sid);
407 gdb_printf ("TTY: %" PRId32 "\n", kp.p_tdev);
408 gdb_printf ("TTY owner process group: %" PRId32 "\n", kp.p_tpgid);
409 gdb_printf ("User IDs (real, effective, saved): "
410 "%" PRIu32 " %" PRIu32 " %" PRIu32 "\n",
411 kp.p_ruid, kp.p_uid, kp.p_svuid);
412 gdb_printf ("Group IDs (real, effective, saved): "
413 "%" PRIu32 " %" PRIu32 " %" PRIu32 "\n",
414 kp.p_rgid, kp.p_gid, kp.p_svgid);
415
416 gdb_printf ("Groups:");
417 for (int i = 0; i < kp.p_ngroups; i++)
418 gdb_printf (" %" PRIu32, kp.p_groups[i]);
419 gdb_printf ("\n");
420 gdb_printf ("Minor faults (no memory page): %" PRIu64 "\n",
421 kp.p_uru_minflt);
422 gdb_printf ("Major faults (memory page faults): %" PRIu64 "\n",
423 kp.p_uru_majflt);
424 gdb_printf ("utime: %" PRIu32 ".%06" PRIu32 "\n",
425 kp.p_uutime_sec, kp.p_uutime_usec);
426 gdb_printf ("stime: %" PRIu32 ".%06" PRIu32 "\n",
427 kp.p_ustime_sec, kp.p_ustime_usec);
428 gdb_printf ("utime+stime, children: %" PRIu32 ".%06" PRIu32 "\n",
429 kp.p_uctime_sec, kp.p_uctime_usec);
430 gdb_printf ("'nice' value: %" PRIu8 "\n", kp.p_nice);
431 gdb_printf ("Start time: %" PRIu32 ".%06" PRIu32 "\n",
432 kp.p_ustart_sec, kp.p_ustart_usec);
433 int pgtok = getpagesize () / 1024;
434 gdb_printf ("Data size: %" PRIuMAX " kB\n",
435 (uintmax_t) kp.p_vm_dsize * pgtok);
436 gdb_printf ("Stack size: %" PRIuMAX " kB\n",
437 (uintmax_t) kp.p_vm_ssize * pgtok);
438 gdb_printf ("Text size: %" PRIuMAX " kB\n",
439 (uintmax_t) kp.p_vm_tsize * pgtok);
440 gdb_printf ("Resident set size: %" PRIuMAX " kB\n",
441 (uintmax_t) kp.p_vm_rssize * pgtok);
442 gdb_printf ("Maximum RSS: %" PRIu64 " kB\n", kp.p_uru_maxrss);
443 gdb_printf ("Pending Signals:");
444 for (size_t i = 0; i < ARRAY_SIZE (kp.p_siglist.__bits); i++)
445 gdb_printf (" %08" PRIx32, kp.p_siglist.__bits[i]);
446 gdb_printf ("\n");
447 gdb_printf ("Ignored Signals:");
448 for (size_t i = 0; i < ARRAY_SIZE (kp.p_sigignore.__bits); i++)
449 gdb_printf (" %08" PRIx32, kp.p_sigignore.__bits[i]);
450 gdb_printf ("\n");
451 gdb_printf ("Caught Signals:");
452 for (size_t i = 0; i < ARRAY_SIZE (kp.p_sigcatch.__bits); i++)
453 gdb_printf (" %08" PRIx32, kp.p_sigcatch.__bits[i]);
454 gdb_printf ("\n");
455 }
456 }
457
458 return true;
459}
460
461/* Resume execution of a specified PTID, that points to a process or a thread
462 within a process. If one thread is specified, all other threads are
463 suspended. If STEP is nonzero, single-step it. If SIGNAL is nonzero,
464 give it that signal. */
465
466static void
467nbsd_resume(nbsd_nat_target *target, ptid_t ptid, int step,
468 enum gdb_signal signal)
469{
470 int request;
471
472 gdb_assert (minus_one_ptid != ptid);
473
474 if (ptid.lwp_p ())
475 {
476 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
477 inferior *inf = find_inferior_ptid (target, ptid);
478
479 for (thread_info *tp : inf->non_exited_threads ())
480 {
481 if (tp->ptid.lwp () == ptid.lwp ())
482 request = PT_RESUME;
483 else
484 request = PT_SUSPEND;
485
486 if (ptrace (request, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
487 perror_with_name (("ptrace"));
488 }
489 }
490 else
491 {
492 /* If ptid is a wildcard, resume all matching threads (they won't run
493 until the process is continued however). */
494 for (thread_info *tp : all_non_exited_threads (target, ptid))
495 if (ptrace (PT_RESUME, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
496 perror_with_name (("ptrace"));
497 }
498
499 if (step)
500 {
501 for (thread_info *tp : all_non_exited_threads (target, ptid))
502 if (ptrace (PT_SETSTEP, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
503 perror_with_name (("ptrace"));
504 }
505 else
506 {
507 for (thread_info *tp : all_non_exited_threads (target, ptid))
508 if (ptrace (PT_CLEARSTEP, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
509 perror_with_name (("ptrace"));
510 }
511
512 if (catch_syscall_enabled () > 0)
513 request = PT_SYSCALL;
514 else
515 request = PT_CONTINUE;
516
517 /* An address of (void *)1 tells ptrace to continue from
518 where it was. If GDB wanted it to start some other way, we have
519 already written a new program counter value to the child. */
520 if (ptrace (request, ptid.pid (), (void *)1, gdb_signal_to_host (signal)) == -1)
521 perror_with_name (("ptrace"));
522}
523
524/* Resume execution of thread PTID, or all threads of all inferiors
525 if PTID is -1. If STEP is nonzero, single-step it. If SIGNAL is nonzero,
526 give it that signal. */
527
528void
529nbsd_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
530{
531 if (minus_one_ptid != ptid)
532 nbsd_resume (this, ptid, step, signal);
533 else
534 {
536 nbsd_resume (this, ptid_t (inf->pid, 0, 0), step, signal);
537 }
538}
539
540/* Implement a safe wrapper around waitpid(). */
541
542static pid_t
543nbsd_wait (ptid_t ptid, struct target_waitstatus *ourstatus,
544 target_wait_flags options)
545{
546 pid_t pid;
547 int status;
548
550
551 do
552 {
553 /* The common code passes WNOHANG that leads to crashes, overwrite it. */
554 pid = waitpid (ptid.pid (), &status, 0);
555 }
556 while (pid == -1 && errno == EINTR);
557
559
560 if (pid == -1)
561 perror_with_name (_("Child process unexpectedly missing"));
562
563 *ourstatus = host_status_to_waitstatus (status);
564 return pid;
565}
566
567/* Wait for the child specified by PTID to do something. Return the
568 process ID of the child, or MINUS_ONE_PTID in case of error; store
569 the status in *OURSTATUS. */
570
571ptid_t
572nbsd_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
573 target_wait_flags target_options)
574{
575 pid_t pid = nbsd_wait (ptid, ourstatus, target_options);
576 ptid_t wptid = ptid_t (pid);
577
578 /* If the child stopped, keep investigating its status. */
579 if (ourstatus->kind () != TARGET_WAITKIND_STOPPED)
580 return wptid;
581
582 /* Extract the event and thread that received a signal. */
584 if (ptrace (PT_GET_SIGINFO, pid, &psi, sizeof (psi)) == -1)
585 perror_with_name (("ptrace"));
586
587 /* Pick child's siginfo_t. */
588 siginfo_t *si = &psi.psi_siginfo;
589
590 int lwp = psi.psi_lwpid;
591
592 int signo = si->si_signo;
593 const int code = si->si_code;
594
595 /* Construct PTID with a specified thread that received the event.
596 If a signal was targeted to the whole process, lwp is 0. */
597 wptid = ptid_t (pid, lwp, 0);
598
599 /* Bail out on non-debugger oriented signals.. */
600 if (signo != SIGTRAP)
601 return wptid;
602
603 /* Stop examining non-debugger oriented SIGTRAP codes. */
604 if (code <= SI_USER || code == SI_NOINFO)
605 return wptid;
606
607 /* Process state for threading events */
608 ptrace_state_t pst = {};
609 if (code == TRAP_LWP)
610 {
611 if (ptrace (PT_GET_PROCESS_STATE, pid, &pst, sizeof (pst)) == -1)
612 perror_with_name (("ptrace"));
613 }
614
615 if (code == TRAP_LWP && pst.pe_report_event == PTRACE_LWP_EXIT)
616 {
617 /* If GDB attaches to a multi-threaded process, exiting
618 threads might be skipped during post_attach that
619 have not yet reported their PTRACE_LWP_EXIT event.
620 Ignore exited events for an unknown LWP. */
621 thread_info *thr = this->find_thread (wptid);
622 if (thr == nullptr)
623 ourstatus->set_spurious ();
624 else
625 {
626 /* NetBSD does not store an LWP exit status. */
627 ourstatus->set_thread_exited (0);
628
629 delete_thread (thr);
630 }
631
632 /* The GDB core expects that the rest of the threads are running. */
633 if (ptrace (PT_CONTINUE, pid, (void *) 1, 0) == -1)
634 perror_with_name (("ptrace"));
635
636 return wptid;
637 }
638
639 if (in_thread_list (this, ptid_t (pid)))
640 thread_change_ptid (this, ptid_t (pid), wptid);
641
642 if (code == TRAP_LWP && pst.pe_report_event == PTRACE_LWP_CREATE)
643 {
644 /* If GDB attaches to a multi-threaded process, newborn
645 threads might be added by nbsd_add_threads that have
646 not yet reported their PTRACE_LWP_CREATE event. Ignore
647 born events for an already-known LWP. */
648 if (in_thread_list (this, wptid))
649 ourstatus->set_spurious ();
650 else
651 {
652 add_thread (this, wptid);
653 ourstatus->set_thread_created ();
654 }
655 return wptid;
656 }
657
658 if (code == TRAP_EXEC)
659 {
660 ourstatus->set_execd (make_unique_xstrdup (pid_to_exec_file (pid)));
661 return wptid;
662 }
663
664 if (code == TRAP_TRACE)
665 {
666 /* Unhandled at this level. */
667 return wptid;
668 }
669
670 if (code == TRAP_SCE || code == TRAP_SCX)
671 {
672 int sysnum = si->si_sysnum;
673
675 {
676 /* If the core isn't interested in this event, ignore it. */
677 ourstatus->set_spurious ();
678 return wptid;
679 }
680
681 if (code == TRAP_SCE)
682 ourstatus->set_syscall_entry (sysnum);
683 else
684 ourstatus->set_syscall_return (sysnum);
685 return wptid;
686 }
687
688 if (code == TRAP_BRKPT)
689 {
690 /* Unhandled at this level. */
691 return wptid;
692 }
693
694 /* Unclassified SIGTRAP event. */
695 ourstatus->set_spurious ();
696 return wptid;
697}
698
699/* Implement the "insert_exec_catchpoint" target_ops method. */
700
701int
703{
704 /* Nothing to do. */
705 return 0;
706}
707
708/* Implement the "remove_exec_catchpoint" target_ops method. */
709
710int
712{
713 /* Nothing to do. */
714 return 0;
715}
716
717/* Implement the "set_syscall_catchpoint" target_ops method. */
718
719int
721 int any_count,
722 gdb::array_view<const int> syscall_counts)
723{
724 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
725 will catch all system call entries and exits. The system calls
726 are filtered by GDB rather than the kernel. */
727 return 0;
728}
729
730/* Implement the "supports_multi_process" target_ops method. */
731
732bool
734{
735 return true;
736}
737
738/* Implement the "xfer_partial" target_ops method. */
739
742 const char *annex, gdb_byte *readbuf,
743 const gdb_byte *writebuf,
744 ULONGEST offset, ULONGEST len,
745 ULONGEST *xfered_len)
746{
747 pid_t pid = inferior_ptid.pid ();
748
749 switch (object)
750 {
752 {
753 len = netbsd_nat::qxfer_siginfo(pid, annex, readbuf, writebuf, offset,
754 len);
755
756 if (len == -1)
757 return TARGET_XFER_E_IO;
758
759 *xfered_len = len;
760 return TARGET_XFER_OK;
761 }
763 {
764 size_t xfered;
765 int res;
766 if (writebuf != nullptr)
767 res = netbsd_nat::write_memory (pid, writebuf, offset, len, &xfered);
768 else
769 res = netbsd_nat::read_memory (pid, readbuf, offset, len, &xfered);
770 if (res != 0)
771 {
772 if (res == EACCES)
773 gdb_printf (gdb_stderr, "Cannot %s process at %s (%s). "
774 "Is PaX MPROTECT active? See security(7), "
775 "sysctl(7), paxctl(8)\n",
776 (writebuf ? "write to" : "read from"),
777 pulongest (offset), safe_strerror (errno));
778 return TARGET_XFER_E_IO;
779 }
780 if (xfered == 0)
781 return TARGET_XFER_EOF;
782 *xfered_len = (ULONGEST) xfered;
783 return TARGET_XFER_OK;
784 }
785 default:
786 return inf_ptrace_target::xfer_partial (object, annex,
787 readbuf, writebuf, offset,
788 len, xfered_len);
789 }
790}
791
792/* Implement the "supports_dumpcore" target_ops method. */
793
794bool
796{
797 return true;
798}
799
800/* Implement the "dumpcore" target_ops method. */
801
802void
803nbsd_nat_target::dumpcore (const char *filename)
804{
805 pid_t pid = inferior_ptid.pid ();
806
807 if (ptrace (PT_DUMPCORE, pid, const_cast<char *>(filename),
808 strlen (filename)) == -1)
809 perror_with_name (("ptrace"));
810}
int code
Definition ada-lex.l:670
struct gdbarch * target_gdbarch(void)
int catch_syscall_enabled(void)
bool catching_syscall_number(int syscall_number)
thread_info * find_thread(ptid_t ptid)
ptid_t ptid
Definition gdbthread.h:259
bool info_verbose
Definition top.c:1941
info_proc_what
Definition defs.h:380
@ IP_CMDLINE
Definition defs.h:394
@ IP_EXE
Definition defs.h:397
@ IP_ALL
Definition defs.h:406
@ IP_MAPPINGS
Definition defs.h:385
@ IP_STATUS
Definition defs.h:388
@ IP_MINIMAL
Definition defs.h:382
@ IP_CWD
Definition defs.h:400
@ IP_STAT
Definition defs.h:391
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition defs.h:350
#define PT_CONTINUE
Definition gdb_ptrace.h:79
#define ptrace(request, pid, addr, data)
Definition gdb_ptrace.h:141
#define PT_SYSCALL
Definition gdb_ptrace.h:120
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:336
void delete_thread(thread_info *thread)
Definition thread.c:527
all_non_exited_threads_range all_non_exited_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition gdbthread.h:753
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
Definition thread.c:811
bool in_thread_list(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:631
void delete_exited_threads(void)
Definition thread.c:753
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1791
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
size_t size
Definition go32-nat.c:239
target_waitstatus host_status_to_waitstatus(int hoststatus)
Definition inf-child.c:57
ptid_t inferior_ptid
Definition infcmd.c:74
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
Definition inferior.c:406
void set_sigint_trap(void)
Definition inflow.c:866
void clear_sigint_trap(void)
Definition inflow.c:881
all_non_exited_inferiors_range all_non_exited_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:830
int write_memory(pid_t pid, unsigned const char *writebuf, CORE_ADDR offset, size_t len, size_t *xfered_len)
Definition netbsd-nat.c:216
void enable_proc_events(pid_t pid)
Definition netbsd-nat.c:170
void for_each_thread(pid_t pid, gdb::function_view< void(ptid_t)> callback)
Definition netbsd-nat.c:154
const char * pid_to_exec_file(pid_t pid)
Definition netbsd-nat.c:38
const char * thread_name(ptid_t ptid)
Definition netbsd-nat.c:127
int qxfer_siginfo(pid_t pid, const char *annex, unsigned char *readbuf, unsigned const char *writebuf, CORE_ADDR offset, int len)
Definition netbsd-nat.c:187
bool thread_alive(ptid_t ptid)
Definition netbsd-nat.c:110
int read_memory(pid_t pid, unsigned char *readbuf, CORE_ADDR offset, size_t len, size_t *xfered_len)
Definition netbsd-nat.c:258
static gdb::unique_xmalloc_ptr< struct kinfo_vmentry[]> nbsd_kinfo_get_vmmap(pid_t pid, size_t *size)
Definition netbsd-nat.c:181
static void nbsd_add_threads(nbsd_nat_target *target, pid_t pid)
Definition netbsd-nat.c:119
static std::string nbsd_pid_to_cwd(int pid)
Definition netbsd-nat.c:47
static pid_t nbsd_wait(ptid_t ptid, struct target_waitstatus *ourstatus, target_wait_flags options)
Definition netbsd-nat.c:543
static void nbsd_resume(nbsd_nat_target *target, ptid_t ptid, int step, enum gdb_signal signal)
Definition netbsd-nat.c:467
static gdb::unique_xmalloc_ptr< char[]> nbsd_pid_to_cmdline(int pid)
Definition netbsd-nat.c:74
static bool nbsd_pid_to_kinfo_proc2(pid_t pid, struct kinfo_proc2 *kp)
Definition netbsd-nat.c:61
void nbsd_info_proc_mappings_entry(int addr_bit, ULONGEST kve_start, ULONGEST kve_end, ULONGEST kve_offset, int kve_flags, int kve_protection, const char *kve_path)
void nbsd_info_proc_mappings_header(int addr_bit)
void(* func)(remote_target *remote, char *)
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
Definition inf-ptrace.c:424
Definition gnu-nat.c:153
pid_t pid
Definition gnu-nat.c:165
void dumpcore(const char *filename) override
Definition netbsd-nat.c:803
void resume(ptid_t, int, enum gdb_signal) override
Definition netbsd-nat.c:529
const char * pid_to_exec_file(int pid) override
Definition netbsd-nat.c:39
void post_attach(int pid) override
Definition netbsd-nat.c:147
void post_startup_inferior(ptid_t ptid) override
Definition netbsd-nat.c:139
bool thread_alive(ptid_t ptid) override
Definition netbsd-nat.c:101
int insert_exec_catchpoint(int pid) override
Definition netbsd-nat.c:702
bool supports_multi_process() override
Definition netbsd-nat.c:733
int remove_exec_catchpoint(int pid) override
Definition netbsd-nat.c:711
const char * thread_name(struct thread_info *thr) override
Definition netbsd-nat.c:110
bool supports_dumpcore() override
Definition netbsd-nat.c:795
int find_memory_regions(find_memory_region_ftype func, void *data) override
Definition netbsd-nat.c:216
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
Definition netbsd-nat.c:741
int set_syscall_catchpoint(int pid, bool needed, int any_count, gdb::array_view< const int > syscall_counts) override
Definition netbsd-nat.c:720
void update_thread_list() override
Definition netbsd-nat.c:156
std::string pid_to_str(ptid_t ptid) override
Definition netbsd-nat.c:164
bool info_proc(const char *, enum info_proc_what) override
Definition netbsd-nat.c:271
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
Definition netbsd-nat.c:572
target_waitstatus & set_spurious()
Definition waitstatus.h:300
target_waitstatus & set_syscall_return(int syscall_number)
Definition waitstatus.h:292
target_waitstatus & set_execd(gdb::unique_xmalloc_ptr< char > execd_pathname)
Definition waitstatus.h:269
target_waitstatus & set_thread_exited(int exit_status)
Definition waitstatus.h:335
target_waitstatus & set_syscall_entry(int syscall_number)
Definition waitstatus.h:284
target_waitkind kind() const
Definition waitstatus.h:345
target_waitstatus & set_thread_created()
Definition waitstatus.h:328
std::string normal_pid_to_str(ptid_t ptid)
Definition target.c:3693
target_xfer_status
Definition target.h:219
@ TARGET_XFER_E_IO
Definition target.h:232
@ TARGET_XFER_EOF
Definition target.h:224
@ TARGET_XFER_OK
Definition target.h:221
target_object
Definition target.h:143
@ TARGET_OBJECT_SIGNAL_INFO
Definition target.h:187
@ TARGET_OBJECT_MEMORY
Definition target.h:147
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187
@ TARGET_WAITKIND_STOPPED
Definition waitstatus.h:36