darwin_inferior *darwin_inf = get_darwin_inferior (inf);
std::vector<darwin_thread_t *> new_thread_vec;
+ if (darwin_inf == nullptr)
+ return;
+
/* Get list of threads. */
kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
MACH_CHECK_ERROR (kret);
pti->msg_state = DARWIN_RUNNING;
/* Add the new thread. */
- add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
+ add_thread_with_info (ptid_t (inf->pid, 0, new_id), pti);
new_thread_vec.push_back (pti);
new_ix++;
continue;
if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
{
/* A thread was removed. */
- delete_thread (ptid_build (inf->pid, 0, old_id));
+ struct thread_info *thr
+ = find_thread_ptid (ptid_t (inf->pid, 0, old_id));
+ delete_thread (thr);
kret = mach_port_deallocate (gdb_task, old_id);
MACH_CHECK_ERROR (kret);
old_ix++;
{
darwin_inferior *priv = get_darwin_inferior (inf);
- return priv->task == *(task_t *)port_ptr;
+ return priv != nullptr && priv->task == *(task_t *)port_ptr;
}
static int
{
darwin_inferior *priv = get_darwin_inferior (inf);
- for (darwin_thread_t *t : priv->threads)
- {
- if (t->gdb_port == thread)
- return t;
- }
+ if (priv != nullptr)
+ for (darwin_thread_t *t : priv->threads)
+ {
+ if (t->gdb_port == thread)
+ return t;
+ }
return NULL;
}
{
darwin_inferior *priv = get_darwin_inferior (inf);
- if (!priv->suspended)
+ if (priv != nullptr && !priv->suspended)
{
kern_return_t kret;
{
darwin_inferior *priv = get_darwin_inferior (inf);
- if (priv->suspended)
+ if (priv != nullptr && priv->suspended)
{
kern_return_t kret;
NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
integer_t *data = (integer_t *)(ndr + 1);
struct inferior *inf;
- darwin_thread_t *thread;
task_t task_port;
- thread_t thread_port;
- kern_return_t kret;
- int i;
/* Check message header. */
if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
inf = darwin_find_inferior_by_task (task_port);
*pinf = inf;
- darwin_inferior *priv = get_darwin_inferior (inf);
-
/* Check message destination. */
- if (inf != NULL && hdr->msgh_local_port != priv->notify_port)
- return -4;
+ if (inf != NULL)
+ {
+ darwin_inferior *priv = get_darwin_inferior (inf);
+ if (hdr->msgh_local_port != priv->notify_port)
+ return -4;
+ }
return 0;
}
priv->pending_messages--;
}
+/* Wrapper around the __pthread_kill syscall. We use this instead of the
+ pthread_kill function to be able to send a signal to any kind of thread,
+ including GCD threads. */
+
+static int
+darwin_pthread_kill (darwin_thread_t *thread, int nsignal)
+{
+ DIAGNOSTIC_PUSH;
+ DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS;
+ int res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
+ DIAGNOSTIC_POP;
+ return res;
+}
+
static void
darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
int step, int nsignal)
{
- kern_return_t kret;
- int res;
-
inferior_debug
(3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
thread->msg_state, thread->gdb_port, step, nsignal);
&& thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
{
/* Either deliver a new signal or cancel the signal received. */
- res = PTRACE (PT_THUPDATE, inf->pid,
- (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
+ int res = PTRACE (PT_THUPDATE, inf->pid,
+ (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
if (res < 0)
inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
}
{
/* Note: ptrace is allowed only if the process is stopped.
Directly send the signal to the thread. */
- res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
+ int res = darwin_pthread_kill (thread, nsignal);
inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
thread->gdb_port, nsignal, res);
thread->signaled = 1;
break;
case DARWIN_STOPPED:
- kret = thread_resume (thread->gdb_port);
+ kern_return_t kret = thread_resume (thread->gdb_port);
MACH_CHECK_ERROR (kret);
thread->msg_state = DARWIN_RUNNING;
{
darwin_inferior *priv = get_darwin_inferior (inf);
- for (darwin_thread_t *thread : priv->threads)
- darwin_resume_thread (inf, thread, step, nsignal);
+ if (priv != nullptr)
+ for (darwin_thread_t *thread : priv->threads)
+ darwin_resume_thread (inf, thread, step, nsignal);
}
struct resume_inferior_threads_param
darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
{
struct target_waitstatus status;
- int pid;
- kern_return_t kret;
- int res;
int nsignal;
- struct inferior *inf;
inferior_debug
(2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
- ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
+ ptid.pid (), ptid.tid (), step, signal);
if (signal == GDB_SIGNAL_0)
nsignal = 0;
ptid = inferior_ptid;
/* minus_one_ptid is RESUME_ALL. */
- if (ptid_equal (ptid, minus_one_ptid))
+ if (ptid == minus_one_ptid)
{
struct resume_inferior_threads_param param;
else
{
struct inferior *inf = find_inferior_ptid (ptid);
- long tid = ptid_get_tid (ptid);
+ long tid = ptid.tid ();
/* Stop the inferior (should be useless). */
darwin_suspend_inferior (inf);
break;
}
- return ptid_build (inf->pid, 0, thread->gdb_port);
+ return ptid_t (inf->pid, 0, thread->gdb_port);
}
else if (hdr->msgh_id == 0x48)
{
/* Looks necessary on Leopard and harmless... */
wait4 (inf->pid, &wstatus, 0, NULL);
- inferior_ptid = ptid_build (inf->pid, 0, 0);
+ inferior_ptid = ptid_t (inf->pid, 0, 0);
return inferior_ptid;
}
else
inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
status->kind = TARGET_WAITKIND_EXITED;
status->value.integer = 0; /* Don't know. */
- return ptid_build (inf->pid, 0, 0);
+ return ptid_t (inf->pid, 0, 0);
}
}
}
if (breakpoint_inserted_here_p (regcache->aspace (), pc))
{
inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
- (unsigned long) ptid_get_tid (ptid));
+ (unsigned long) ptid.tid ());
/* Back up the PC if necessary. */
if (gdbarch_decr_pc_after_break (gdbarch))
inferior_debug
(2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
- ptid_get_pid (ptid), ptid_get_tid (ptid));
+ ptid.pid (), ptid.tid ());
/* Handle fake stop events at first. */
if (darwin_inf_fake_stop != NULL)
status->value.sig = GDB_SIGNAL_TRAP;
thread = priv->threads[0];
thread->msg_state = DARWIN_STOPPED;
- return ptid_build (inf->pid, 0, thread->gdb_port);
+ return ptid_t (inf->pid, 0, thread->gdb_port);
}
do
darwin_dump_message (hdr, darwin_debug_flag > 11);
res = darwin_decode_message (hdr, &thread, &inf, status);
- if (ptid_equal (res, minus_one_ptid))
+ if (res == minus_one_ptid)
continue;
/* Early return in case an inferior has exited. */
&& thread->event.ex_type == EXC_BREAKPOINT)
{
if (thread->single_step
- || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
+ || cancel_breakpoint (ptid_t (inf->pid, 0, thread->gdb_port)))
{
gdb_assert (thread->msg_state == DARWIN_MESSAGE);
darwin_send_reply (inf, thread);
darwin_inferior *priv = get_darwin_inferior (inf);
kern_return_t kret;
mach_port_t prev;
- int i;
/* Deallocate threads. */
darwin_deallocate_threads (inf);
{
struct target_waitstatus wstatus;
ptid_t ptid;
- kern_return_t kret;
- int status;
int res;
darwin_inferior *priv = get_darwin_inferior (inf);
{
darwin_inferior *priv = get_darwin_inferior (inf);
kern_return_t kret;
- int traps_expected;
exception_mask_t mask;
kret = darwin_save_exception_ports (priv);
struct target_waitstatus wstatus;
ptid_t ptid;
kern_return_t kret;
- int status;
int res;
- if (ptid_equal (inferior_ptid, null_ptid))
+ if (inferior_ptid == null_ptid)
return;
gdb_assert (inf != NULL);
if (res == 0)
{
+ /* On MacOS version Sierra, the darwin_restore_exception_ports call
+ does not work as expected.
+ When the kill function is called, the SIGKILL signal is received
+ by gdb whereas it should have been received by the kernel since
+ the exception ports have been restored.
+ This behavior is not the expected one thus gdb does not reply to
+ the received SIGKILL message. This situation leads to a "busy"
+ resource from the kernel point of view and the inferior is never
+ released, causing it to remain as a zombie process, even after
+ GDB exits.
+ To work around this, we mark all the threads of the inferior as
+ signaled thus darwin_decode_message function knows that the kill
+ signal was sent by gdb and will take the appropriate action
+ (cancel signal and reply to the signal message). */
+ darwin_inferior *priv = get_darwin_inferior (inf);
+ for (darwin_thread_t *thread : priv->threads)
+ thread->signaled = 1;
+
darwin_resume_inferior (inf);
ptid = darwin_wait (inferior_ptid, &wstatus);
darwin_attach_pid (struct inferior *inf)
{
kern_return_t kret;
- mach_port_t prev_port;
- int traps_expected;
- mach_port_t prev_not;
- exception_mask_t mask;
darwin_inferior *priv = new darwin_inferior;
inf->priv.reset (priv);
- kret = task_for_pid (gdb_task, inf->pid, &priv->task);
- if (kret != KERN_SUCCESS)
+ TRY
{
- int status;
-
- if (!inf->attach_flag)
+ kret = task_for_pid (gdb_task, inf->pid, &priv->task);
+ if (kret != KERN_SUCCESS)
{
- kill (inf->pid, 9);
- waitpid (inf->pid, &status, 0);
- }
+ int status;
- error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
+ if (!inf->attach_flag)
+ {
+ kill (inf->pid, 9);
+ waitpid (inf->pid, &status, 0);
+ }
+
+ error
+ (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
" (please check gdb is codesigned - see taskgated(8))"),
- inf->pid, mach_error_string (kret), (unsigned long) kret);
- }
+ inf->pid, mach_error_string (kret), (unsigned long) kret);
+ }
- inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
- priv->task, inf->pid);
+ inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
+ priv->task, inf->pid);
- if (darwin_ex_port == MACH_PORT_NULL)
- {
- /* Create a port to get exceptions. */
- kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
- &darwin_ex_port);
- if (kret != KERN_SUCCESS)
- error (_("Unable to create exception port, mach_port_allocate "
- "returned: %d"),
- kret);
+ if (darwin_ex_port == MACH_PORT_NULL)
+ {
+ /* Create a port to get exceptions. */
+ kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
+ &darwin_ex_port);
+ if (kret != KERN_SUCCESS)
+ error (_("Unable to create exception port, mach_port_allocate "
+ "returned: %d"),
+ kret);
- kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
- MACH_MSG_TYPE_MAKE_SEND);
- if (kret != KERN_SUCCESS)
- error (_("Unable to create exception port, mach_port_insert_right "
- "returned: %d"),
- kret);
+ kret = mach_port_insert_right (gdb_task, darwin_ex_port,
+ darwin_ex_port,
+ MACH_MSG_TYPE_MAKE_SEND);
+ if (kret != KERN_SUCCESS)
+ error (_("Unable to create exception port, mach_port_insert_right "
+ "returned: %d"),
+ kret);
+
+ /* Create a port set and put ex_port in it. */
+ kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
+ &darwin_port_set);
+ if (kret != KERN_SUCCESS)
+ error (_("Unable to create port set, mach_port_allocate "
+ "returned: %d"),
+ kret);
- /* Create a port set and put ex_port in it. */
- kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
- &darwin_port_set);
+ kret = mach_port_move_member (gdb_task, darwin_ex_port,
+ darwin_port_set);
+ if (kret != KERN_SUCCESS)
+ error (_("Unable to move exception port into new port set, "
+ "mach_port_move_member\n"
+ "returned: %d"),
+ kret);
+ }
+
+ /* Create a port to be notified when the child task terminates. */
+ kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
+ &priv->notify_port);
if (kret != KERN_SUCCESS)
- error (_("Unable to create port set, mach_port_allocate "
+ error (_("Unable to create notification port, mach_port_allocate "
"returned: %d"),
kret);
- kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
+ kret = mach_port_move_member (gdb_task,
+ priv->notify_port, darwin_port_set);
if (kret != KERN_SUCCESS)
- error (_("Unable to move exception port into new port set, "
+ error (_("Unable to move notification port into new port set, "
"mach_port_move_member\n"
"returned: %d"),
kret);
- }
- /* Create a port to be notified when the child task terminates. */
- kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
- &priv->notify_port);
- if (kret != KERN_SUCCESS)
- error (_("Unable to create notification port, mach_port_allocate "
- "returned: %d"),
- kret);
+ darwin_setup_request_notification (inf);
- kret = mach_port_move_member (gdb_task,
- priv->notify_port, darwin_port_set);
- if (kret != KERN_SUCCESS)
- error (_("Unable to move notification port into new port set, "
- "mach_port_move_member\n"
- "returned: %d"),
- kret);
-
- darwin_setup_request_notification (inf);
+ darwin_setup_exceptions (inf);
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ exit_inferior (inf);
+ inferior_ptid = null_ptid;
- darwin_setup_exceptions (inf);
+ throw_exception (ex);
+ }
+ END_CATCH
target_ops *darwin_ops = get_native_target ();
if (!target_is_pushed (darwin_ops))
static void
darwin_ptrace_him (int pid)
{
- task_t itask;
- kern_return_t kret;
- mach_port_t prev_port;
- int traps_expected;
struct inferior *inf = current_inferior ();
darwin_attach_pid (inf);
posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
}
+/* Read kernel version, and return TRUE on Sierra or later. */
+
+static bool
+should_disable_startup_with_shell ()
+{
+ char str[16];
+ size_t sz = sizeof (str);
+ int ret;
+
+ ret = sysctlbyname ("kern.osrelease", str, &sz, NULL, 0);
+ if (ret == 0 && sz < sizeof (str))
+ {
+ unsigned long ver = strtoul (str, NULL, 10);
+ if (ver >= 16)
+ return true;
+ }
+ return false;
+}
+
void
darwin_nat_target::create_inferior (const char *exec_file,
const std::string &allargs,
char **env, int from_tty)
{
+ gdb::optional<scoped_restore_tmpl<int>> restore_startup_with_shell;
+
+ if (startup_with_shell && should_disable_startup_with_shell ())
+ {
+ warning (_("startup-with-shell not supported on this macOS version,"
+ " disabling it."));
+ restore_startup_with_shell.emplace (&startup_with_shell, 0);
+ }
+
/* Do the hard work. */
fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
darwin_ptrace_him, darwin_pre_ptrace, NULL,
darwin_nat_target::attach (const char *args, int from_tty)
{
pid_t pid;
- pid_t pid2;
- int wstatus;
- int res;
struct inferior *inf;
- kern_return_t kret;
pid = parse_pid_to_attach (args);
if (exec_file)
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
- target_pid_to_str (pid_to_ptid (pid)));
+ target_pid_to_str (ptid_t (pid)));
else
printf_unfiltered (_("Attaching to %s\n"),
- target_pid_to_str (pid_to_ptid (pid)));
+ target_pid_to_str (ptid_t (pid)));
gdb_flush (gdb_stdout);
}
error (_("Can't attach to process %d: %s (%d)"),
pid, safe_strerror (errno), errno);
- inferior_ptid = pid_to_ptid (pid);
+ inferior_ptid = ptid_t (pid);
inf = current_inferior ();
inferior_appeared (inf, pid);
inf->attach_flag = 1;
darwin_inferior *priv = get_darwin_inferior (inf);
- darwin_check_osabi (priv, ptid_get_tid (inferior_ptid));
+ darwin_check_osabi (priv, inferior_ptid.tid ());
darwin_setup_fake_stop_event (inf);
void
darwin_nat_target::detach (inferior *inf, int from_tty)
{
- pid_t pid = ptid_get_pid (inferior_ptid);
darwin_inferior *priv = get_darwin_inferior (inf);
kern_return_t kret;
int res;
darwin_nat_target::pid_to_str (ptid_t ptid)
{
static char buf[80];
- long tid = ptid_get_tid (ptid);
+ long tid = ptid.tid ();
if (tid != 0)
{
snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
- tid, ptid_get_pid (ptid));
+ tid, ptid.pid ());
return buf;
}
{
kern_return_t kret;
mach_vm_size_t res_length = 0;
- pointer_t copied;
- mach_msg_type_number_t copy_count;
- mach_vm_size_t remaining_length;
- mach_vm_address_t region_address;
- mach_vm_size_t region_length;
inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
task, core_addr_to_string (addr), pulongest (length));
{
struct task_dyld_info task_dyld_info;
mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
- int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
kern_return_t kret;
if (addr != 0 || length > sizeof (mach_vm_address_t))
set_enable_mach_exceptions (const char *args, int from_tty,
struct cmd_list_element *c)
{
- if (!ptid_equal (inferior_ptid, null_ptid))
+ if (inferior_ptid != null_ptid)
{
struct inferior *inf = current_inferior ();
darwin_inferior *priv = get_darwin_inferior (inf);
for (darwin_thread_t *t : priv->threads)
{
if (t->inf_port == lwp)
- return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
+ return ptid_t (inferior_ptid.pid (), 0, t->gdb_port);
}
/* Maybe the port was never extract. Do it now. */
names_count * sizeof (mach_port_t));
if (res)
- return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
+ return ptid_t (inferior_ptid.pid (), 0, res);
else
return null_ptid;
}
projects / deliverable / binutils-gdb.git / blobdiff