1 /* Native-dependent code for NetBSD.
3 Copyright (C) 2006-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "gdbthread.h"
24 #include "nbsd-tdep.h"
28 #include <sys/types.h>
29 #include <sys/ptrace.h>
30 #include <sys/sysctl.h>
33 /* Return the name of a file that can be opened to get the symbols for
34 the child process identified by PID. */
37 nbsd_nat_target::pid_to_exec_file (int pid
)
39 static char buf
[PATH_MAX
];
41 int mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, pid
, KERN_PROC_PATHNAME
};
42 buflen
= sizeof (buf
);
43 if (sysctl (mib
, ARRAY_SIZE (mib
), buf
, &buflen
, NULL
, 0))
48 /* Return the current directory for the process identified by PID. */
51 nbsd_pid_to_cwd (int pid
)
55 int mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, pid
, KERN_PROC_CWD
};
56 buflen
= sizeof (buf
);
57 if (sysctl (mib
, ARRAY_SIZE (mib
), buf
, &buflen
, NULL
, 0))
62 /* Return the kinfo_proc2 structure for the process identified by PID. */
65 nbsd_pid_to_kinfo_proc2 (pid_t pid
, struct kinfo_proc2
*kp
)
67 gdb_assert (kp
!= nullptr);
69 size_t size
= sizeof (*kp
);
70 int mib
[6] = {CTL_KERN
, KERN_PROC2
, KERN_PROC_PID
, pid
,
71 static_cast<int> (size
), 1};
72 return !sysctl (mib
, ARRAY_SIZE (mib
), kp
, &size
, NULL
, 0);
75 /* Return the command line for the process identified by PID. */
77 static gdb::unique_xmalloc_ptr
<char[]>
78 nbsd_pid_to_cmdline (int pid
)
80 int mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, pid
, KERN_PROC_ARGV
};
83 if (sysctl (mib
, ARRAY_SIZE (mib
), NULL
, &size
, NULL
, 0) == -1 || size
== 0)
86 gdb::unique_xmalloc_ptr
<char[]> args (XNEWVAR (char, size
));
88 if (sysctl (mib
, ARRAY_SIZE (mib
), args
.get (), &size
, NULL
, 0) == -1
92 /* Arguments are returned as a flattened string with NUL separators.
93 Join the arguments with spaces to form a single string. */
94 for (size_t i
= 0; i
< size
- 1; i
++)
97 args
[size
- 1] = '\0';
102 /* Generic thread (LWP) lister within a specified process. The callback
103 parameters is a C++ function that is called for each detected thread. */
106 nbsd_thread_lister (const pid_t pid
,
107 gdb::function_view
<bool (const struct kinfo_lwp
*)>
110 int mib
[5] = {CTL_KERN
, KERN_LWP
, pid
, sizeof (struct kinfo_lwp
), 0};
113 if (sysctl (mib
, ARRAY_SIZE (mib
), NULL
, &size
, NULL
, 0) == -1 || size
== 0)
114 perror_with_name (("sysctl"));
116 mib
[4] = size
/ sizeof (size_t);
118 gdb::unique_xmalloc_ptr
<struct kinfo_lwp
[]> kl
119 ((struct kinfo_lwp
*) xcalloc (size
, 1));
121 if (sysctl (mib
, ARRAY_SIZE (mib
), kl
.get (), &size
, NULL
, 0) == -1
123 perror_with_name (("sysctl"));
125 for (size_t i
= 0; i
< size
/ sizeof (struct kinfo_lwp
); i
++)
127 struct kinfo_lwp
*l
= &kl
[i
];
129 /* Return true if the specified thread is alive. */
131 = [] (struct kinfo_lwp
*lwp
)
146 /* Ignore embryonic or demised threads. */
157 /* Return true if PTID is still active in the inferior. */
160 nbsd_nat_target::thread_alive (ptid_t ptid
)
162 pid_t pid
= ptid
.pid ();
163 int lwp
= ptid
.lwp ();
166 = [&lwp
] (const struct kinfo_lwp
*kl
)
168 return kl
->l_lid
== lwp
;
171 return nbsd_thread_lister (pid
, fn
);
174 /* Return the name assigned to a thread by an application. Returns
175 the string in a static buffer. */
178 nbsd_nat_target::thread_name (struct thread_info
*thr
)
180 ptid_t ptid
= thr
->ptid
;
181 pid_t pid
= ptid
.pid ();
182 int lwp
= ptid
.lwp ();
184 static char buf
[KI_LNAMELEN
] = {};
187 = [&lwp
] (const struct kinfo_lwp
*kl
)
189 if (kl
->l_lid
== lwp
)
191 xsnprintf (buf
, sizeof buf
, "%s", kl
->l_name
);
197 if (nbsd_thread_lister (pid
, fn
))
203 /* Implement the "post_attach" target_ops method. */
206 nbsd_add_threads (nbsd_nat_target
*target
, pid_t pid
)
209 = [&target
, &pid
] (const struct kinfo_lwp
*kl
)
211 ptid_t ptid
= ptid_t (pid
, kl
->l_lid
, 0);
212 if (!in_thread_list (target
, ptid
))
214 if (inferior_ptid
.lwp () == 0)
215 thread_change_ptid (target
, inferior_ptid
, ptid
);
217 add_thread (target
, ptid
);
222 nbsd_thread_lister (pid
, fn
);
225 /* Enable additional event reporting on new processes. */
228 nbsd_enable_proc_events (pid_t pid
)
232 if (ptrace (PT_GET_EVENT_MASK
, pid
, &events
, sizeof (events
)) == -1)
233 perror_with_name (("ptrace"));
235 events
|= PTRACE_LWP_CREATE
;
236 events
|= PTRACE_LWP_EXIT
;
238 if (ptrace (PT_SET_EVENT_MASK
, pid
, &events
, sizeof (events
)) == -1)
239 perror_with_name (("ptrace"));
242 /* Implement the "post_startup_inferior" target_ops method. */
245 nbsd_nat_target::post_startup_inferior (ptid_t ptid
)
247 nbsd_enable_proc_events (ptid
.pid ());
250 /* Implement the "post_attach" target_ops method. */
253 nbsd_nat_target::post_attach (int pid
)
255 nbsd_enable_proc_events (pid
);
256 nbsd_add_threads (this, pid
);
259 /* Implement the "update_thread_list" target_ops method. */
262 nbsd_nat_target::update_thread_list ()
264 delete_exited_threads ();
267 /* Convert PTID to a string. */
270 nbsd_nat_target::pid_to_str (ptid_t ptid
)
272 int lwp
= ptid
.lwp ();
276 pid_t pid
= ptid
.pid ();
278 return string_printf ("LWP %d of process %d", lwp
, pid
);
281 return normal_pid_to_str (ptid
);
284 /* Retrieve all the memory regions in the specified process. */
286 static gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
[]>
287 nbsd_kinfo_get_vmmap (pid_t pid
, size_t *size
)
289 int mib
[5] = {CTL_VM
, VM_PROC
, VM_PROC_MAP
, pid
,
290 sizeof (struct kinfo_vmentry
)};
293 if (sysctl (mib
, ARRAY_SIZE (mib
), NULL
, &length
, NULL
, 0))
299 /* Prereserve more space. The length argument is volatile and can change
300 between the sysctl(3) calls as this function can be called against a
302 length
= length
* 5 / 3;
304 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
[]> kiv
305 (XNEWVAR (kinfo_vmentry
, length
));
307 if (sysctl (mib
, ARRAY_SIZE (mib
), kiv
.get (), &length
, NULL
, 0))
313 *size
= length
/ sizeof (struct kinfo_vmentry
);
317 /* Iterate over all the memory regions in the current inferior,
318 calling FUNC for each memory region. OBFD is passed as the last
322 nbsd_nat_target::find_memory_regions (find_memory_region_ftype func
,
325 pid_t pid
= inferior_ptid
.pid ();
328 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
[]> vmentl
329 = nbsd_kinfo_get_vmmap (pid
, &nitems
);
331 perror_with_name (_("Couldn't fetch VM map entries."));
333 for (size_t i
= 0; i
< nitems
; i
++)
335 struct kinfo_vmentry
*kve
= &vmentl
[i
];
337 /* Skip unreadable segments and those where MAP_NOCORE has been set. */
338 if (!(kve
->kve_protection
& KVME_PROT_READ
)
339 || kve
->kve_flags
& KVME_FLAG_NOCOREDUMP
)
342 /* Skip segments with an invalid type. */
343 switch (kve
->kve_type
)
345 case KVME_TYPE_VNODE
:
347 case KVME_TYPE_SUBMAP
:
348 case KVME_TYPE_OBJECT
:
354 size_t size
= kve
->kve_end
- kve
->kve_start
;
357 fprintf_filtered (gdb_stdout
,
358 "Save segment, %ld bytes at %s (%c%c%c)\n",
360 paddress (target_gdbarch (), kve
->kve_start
),
361 kve
->kve_protection
& KVME_PROT_READ
? 'r' : '-',
362 kve
->kve_protection
& KVME_PROT_WRITE
? 'w' : '-',
363 kve
->kve_protection
& KVME_PROT_EXEC
? 'x' : '-');
366 /* Invoke the callback function to create the corefile segment.
367 Pass MODIFIED as true, we do not know the real modification state. */
368 func (kve
->kve_start
, size
, kve
->kve_protection
& KVME_PROT_READ
,
369 kve
->kve_protection
& KVME_PROT_WRITE
,
370 kve
->kve_protection
& KVME_PROT_EXEC
, 1, data
);
375 /* Implement the "info_proc" target_ops method. */
378 nbsd_nat_target::info_proc (const char *args
, enum info_proc_what what
)
381 bool do_cmdline
= false;
384 bool do_mappings
= false;
385 bool do_status
= false;
418 error (_("Not supported on this target."));
421 gdb_argv
built_argv (args
);
422 if (built_argv
.count () == 0)
424 pid
= inferior_ptid
.pid ();
426 error (_("No current process: you must name one."));
428 else if (built_argv
.count () == 1 && isdigit (built_argv
[0][0]))
429 pid
= strtol (built_argv
[0], NULL
, 10);
431 error (_("Invalid arguments."));
433 printf_filtered (_("process %d\n"), pid
);
437 gdb::unique_xmalloc_ptr
<char[]> cmdline
= nbsd_pid_to_cmdline (pid
);
438 if (cmdline
!= nullptr)
439 printf_filtered ("cmdline = '%s'\n", cmdline
.get ());
441 warning (_("unable to fetch command line"));
445 std::string cwd
= nbsd_pid_to_cwd (pid
);
447 printf_filtered ("cwd = '%s'\n", cwd
.c_str ());
449 warning (_("unable to fetch current working directory"));
453 const char *exe
= pid_to_exec_file (pid
);
455 printf_filtered ("exe = '%s'\n", exe
);
457 warning (_("unable to fetch executable path name"));
462 gdb::unique_xmalloc_ptr
<struct kinfo_vmentry
[]> vmentl
463 = nbsd_kinfo_get_vmmap (pid
, &nvment
);
465 if (vmentl
!= nullptr)
467 int addr_bit
= TARGET_CHAR_BIT
* sizeof (void *);
468 nbsd_info_proc_mappings_header (addr_bit
);
470 struct kinfo_vmentry
*kve
= vmentl
.get ();
471 for (int i
= 0; i
< nvment
; i
++, kve
++)
472 nbsd_info_proc_mappings_entry (addr_bit
, kve
->kve_start
,
473 kve
->kve_end
, kve
->kve_offset
,
474 kve
->kve_flags
, kve
->kve_protection
,
478 warning (_("unable to fetch virtual memory map"));
482 struct kinfo_proc2 kp
;
483 if (!nbsd_pid_to_kinfo_proc2 (pid
, &kp
))
484 warning (_("Failed to fetch process information"));
505 return "? (unknown)";
509 printf_filtered ("Name: %s\n", kp
.p_comm
);
510 printf_filtered ("State: %s\n", process_status(kp
.p_realstat
));
511 printf_filtered ("Parent process: %" PRId32
"\n", kp
.p_ppid
);
512 printf_filtered ("Process group: %" PRId32
"\n", kp
.p__pgid
);
513 printf_filtered ("Session id: %" PRId32
"\n", kp
.p_sid
);
514 printf_filtered ("TTY: %" PRId32
"\n", kp
.p_tdev
);
515 printf_filtered ("TTY owner process group: %" PRId32
"\n", kp
.p_tpgid
);
516 printf_filtered ("User IDs (real, effective, saved): "
517 "%" PRIu32
" %" PRIu32
" %" PRIu32
"\n",
518 kp
.p_ruid
, kp
.p_uid
, kp
.p_svuid
);
519 printf_filtered ("Group IDs (real, effective, saved): "
520 "%" PRIu32
" %" PRIu32
" %" PRIu32
"\n",
521 kp
.p_rgid
, kp
.p_gid
, kp
.p_svgid
);
523 printf_filtered ("Groups:");
524 for (int i
= 0; i
< kp
.p_ngroups
; i
++)
525 printf_filtered (" %" PRIu32
, kp
.p_groups
[i
]);
526 printf_filtered ("\n");
527 printf_filtered ("Minor faults (no memory page): %" PRIu64
"\n",
529 printf_filtered ("Major faults (memory page faults): %" PRIu64
"\n",
531 printf_filtered ("utime: %" PRIu32
".%06" PRIu32
"\n",
532 kp
.p_uutime_sec
, kp
.p_uutime_usec
);
533 printf_filtered ("stime: %" PRIu32
".%06" PRIu32
"\n",
534 kp
.p_ustime_sec
, kp
.p_ustime_usec
);
535 printf_filtered ("utime+stime, children: %" PRIu32
".%06" PRIu32
"\n",
536 kp
.p_uctime_sec
, kp
.p_uctime_usec
);
537 printf_filtered ("'nice' value: %" PRIu8
"\n", kp
.p_nice
);
538 printf_filtered ("Start time: %" PRIu32
".%06" PRIu32
"\n",
539 kp
.p_ustart_sec
, kp
.p_ustart_usec
);
540 int pgtok
= getpagesize () / 1024;
541 printf_filtered ("Data size: %" PRIuMAX
" kB\n",
542 (uintmax_t) kp
.p_vm_dsize
* pgtok
);
543 printf_filtered ("Stack size: %" PRIuMAX
" kB\n",
544 (uintmax_t) kp
.p_vm_ssize
* pgtok
);
545 printf_filtered ("Text size: %" PRIuMAX
" kB\n",
546 (uintmax_t) kp
.p_vm_tsize
* pgtok
);
547 printf_filtered ("Resident set size: %" PRIuMAX
" kB\n",
548 (uintmax_t) kp
.p_vm_rssize
* pgtok
);
549 printf_filtered ("Maximum RSS: %" PRIu64
" kB\n", kp
.p_uru_maxrss
);
550 printf_filtered ("Pending Signals:");
551 for (size_t i
= 0; i
< ARRAY_SIZE (kp
.p_siglist
.__bits
); i
++)
552 printf_filtered (" %08" PRIx32
, kp
.p_siglist
.__bits
[i
]);
553 printf_filtered ("\n");
554 printf_filtered ("Ignored Signals:");
555 for (size_t i
= 0; i
< ARRAY_SIZE (kp
.p_sigignore
.__bits
); i
++)
556 printf_filtered (" %08" PRIx32
, kp
.p_sigignore
.__bits
[i
]);
557 printf_filtered ("\n");
558 printf_filtered ("Caught Signals:");
559 for (size_t i
= 0; i
< ARRAY_SIZE (kp
.p_sigcatch
.__bits
); i
++)
560 printf_filtered (" %08" PRIx32
, kp
.p_sigcatch
.__bits
[i
]);
561 printf_filtered ("\n");
568 /* Resume execution of a specified PTID, that points to a process or a thread
569 within a process. If one thread is specified, all other threads are
570 suspended. If STEP is nonzero, single-step it. If SIGNAL is nonzero,
571 give it that signal. */
574 nbsd_resume(nbsd_nat_target
*target
, ptid_t ptid
, int step
,
575 enum gdb_signal signal
)
579 gdb_assert (minus_one_ptid
!= ptid
);
583 /* If ptid is a specific LWP, suspend all other LWPs in the process. */
584 inferior
*inf
= find_inferior_ptid (target
, ptid
);
586 for (thread_info
*tp
: inf
->non_exited_threads ())
588 if (tp
->ptid
.lwp () == ptid
.lwp ())
591 request
= PT_SUSPEND
;
593 if (ptrace (request
, tp
->ptid
.pid (), NULL
, tp
->ptid
.lwp ()) == -1)
594 perror_with_name (("ptrace"));
599 /* If ptid is a wildcard, resume all matching threads (they won't run
600 until the process is continued however). */
601 for (thread_info
*tp
: all_non_exited_threads (target
, ptid
))
602 if (ptrace (PT_RESUME
, tp
->ptid
.pid (), NULL
, tp
->ptid
.lwp ()) == -1)
603 perror_with_name (("ptrace"));
608 for (thread_info
*tp
: all_non_exited_threads (target
, ptid
))
609 if (ptrace (PT_SETSTEP
, tp
->ptid
.pid (), NULL
, tp
->ptid
.lwp ()) == -1)
610 perror_with_name (("ptrace"));
614 for (thread_info
*tp
: all_non_exited_threads (target
, ptid
))
615 if (ptrace (PT_CLEARSTEP
, tp
->ptid
.pid (), NULL
, tp
->ptid
.lwp ()) == -1)
616 perror_with_name (("ptrace"));
619 if (catch_syscall_enabled () > 0)
620 request
= PT_SYSCALL
;
622 request
= PT_CONTINUE
;
624 /* An address of (void *)1 tells ptrace to continue from
625 where it was. If GDB wanted it to start some other way, we have
626 already written a new program counter value to the child. */
627 if (ptrace (request
, ptid
.pid (), (void *)1, gdb_signal_to_host (signal
)) == -1)
628 perror_with_name (("ptrace"));
631 /* Resume execution of thread PTID, or all threads of all inferiors
632 if PTID is -1. If STEP is nonzero, single-step it. If SIGNAL is nonzero,
633 give it that signal. */
636 nbsd_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
638 if (minus_one_ptid
!= ptid
)
639 nbsd_resume (this, ptid
, step
, signal
);
642 for (inferior
*inf
: all_non_exited_inferiors (this))
643 nbsd_resume (this, ptid_t (inf
->pid
, 0, 0), step
, signal
);
647 /* Implement a safe wrapper around waitpid(). */
650 nbsd_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
659 /* The common code passes WNOHANG that leads to crashes, overwrite it. */
660 pid
= waitpid (ptid
.pid (), &status
, 0);
662 while (pid
== -1 && errno
== EINTR
);
664 clear_sigint_trap ();
667 perror_with_name (_("Child process unexpectedly missing"));
669 store_waitstatus (ourstatus
, status
);
673 /* Wait for the child specified by PTID to do something. Return the
674 process ID of the child, or MINUS_ONE_PTID in case of error; store
675 the status in *OURSTATUS. */
678 nbsd_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
681 pid_t pid
= nbsd_wait (ptid
, ourstatus
, target_options
);
682 ptid_t wptid
= ptid_t (pid
);
684 /* If the child stopped, keep investigating its status. */
685 if (ourstatus
->kind
!= TARGET_WAITKIND_STOPPED
)
688 /* Extract the event and thread that received a signal. */
689 ptrace_siginfo_t psi
;
690 if (ptrace (PT_GET_SIGINFO
, pid
, &psi
, sizeof (psi
)) == -1)
691 perror_with_name (("ptrace"));
693 /* Pick child's siginfo_t. */
694 siginfo_t
*si
= &psi
.psi_siginfo
;
696 int lwp
= psi
.psi_lwpid
;
698 int signo
= si
->si_signo
;
699 const int code
= si
->si_code
;
701 /* Construct PTID with a specified thread that received the event.
702 If a signal was targeted to the whole process, lwp is 0. */
703 wptid
= ptid_t (pid
, lwp
, 0);
705 /* Bail out on non-debugger oriented signals.. */
706 if (signo
!= SIGTRAP
)
709 /* Stop examining non-debugger oriented SIGTRAP codes. */
710 if (code
<= SI_USER
|| code
== SI_NOINFO
)
713 /* Process state for threading events */
714 ptrace_state_t pst
= {};
715 if (code
== TRAP_LWP
)
717 if (ptrace (PT_GET_PROCESS_STATE
, pid
, &pst
, sizeof (pst
)) == -1)
718 perror_with_name (("ptrace"));
721 if (code
== TRAP_LWP
&& pst
.pe_report_event
== PTRACE_LWP_EXIT
)
723 /* If GDB attaches to a multi-threaded process, exiting
724 threads might be skipped during post_attach that
725 have not yet reported their PTRACE_LWP_EXIT event.
726 Ignore exited events for an unknown LWP. */
727 thread_info
*thr
= find_thread_ptid (this, wptid
);
729 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
732 ourstatus
->kind
= TARGET_WAITKIND_THREAD_EXITED
;
733 /* NetBSD does not store an LWP exit status. */
734 ourstatus
->value
.integer
= 0;
736 if (print_thread_events
)
737 printf_unfiltered (_("[%s exited]\n"),
738 target_pid_to_str (wptid
).c_str ());
742 /* The GDB core expects that the rest of the threads are running. */
743 if (ptrace (PT_CONTINUE
, pid
, (void *) 1, 0) == -1)
744 perror_with_name (("ptrace"));
749 if (in_thread_list (this, ptid_t (pid
)))
750 thread_change_ptid (this, ptid_t (pid
), wptid
);
752 if (code
== TRAP_LWP
&& pst
.pe_report_event
== PTRACE_LWP_CREATE
)
754 /* If GDB attaches to a multi-threaded process, newborn
755 threads might be added by nbsd_add_threads that have
756 not yet reported their PTRACE_LWP_CREATE event. Ignore
757 born events for an already-known LWP. */
758 if (in_thread_list (this, wptid
))
759 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
762 add_thread (this, wptid
);
763 ourstatus
->kind
= TARGET_WAITKIND_THREAD_CREATED
;
768 if (code
== TRAP_EXEC
)
770 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
771 ourstatus
->value
.execd_pathname
= xstrdup (pid_to_exec_file (pid
));
775 if (code
== TRAP_TRACE
)
777 /* Unhandled at this level. */
781 if (code
== TRAP_SCE
|| code
== TRAP_SCX
)
783 int sysnum
= si
->si_sysnum
;
785 if (!catch_syscall_enabled () || !catching_syscall_number (sysnum
))
787 /* If the core isn't interested in this event, ignore it. */
788 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
793 (code
== TRAP_SCE
) ? TARGET_WAITKIND_SYSCALL_ENTRY
:
794 TARGET_WAITKIND_SYSCALL_RETURN
;
795 ourstatus
->value
.syscall_number
= sysnum
;
799 if (code
== TRAP_BRKPT
)
801 /* Unhandled at this level. */
805 /* Unclassified SIGTRAP event. */
806 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
810 /* Implement the "insert_exec_catchpoint" target_ops method. */
813 nbsd_nat_target::insert_exec_catchpoint (int pid
)
819 /* Implement the "remove_exec_catchpoint" target_ops method. */
822 nbsd_nat_target::remove_exec_catchpoint (int pid
)
828 /* Implement the "set_syscall_catchpoint" target_ops method. */
831 nbsd_nat_target::set_syscall_catchpoint (int pid
, bool needed
,
833 gdb::array_view
<const int> syscall_counts
)
835 /* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
836 will catch all system call entries and exits. The system calls
837 are filtered by GDB rather than the kernel. */