xnu_threads.h File Reference

#include <rz_debug.h>
#include <mach/mach_vm.h>

Go to the source code of this file.

Classes
struct	_exception_info
struct	_xnu_thread
struct	_exc_msg
struct	_rep_msg

Macros
#define	RETURN_ON_MACH_ERROR(msg, retval)

Typedefs
typedef struct _exception_info	xnu_exception_info
typedef struct _xnu_thread	xnu_thread_t
typedef struct _exc_msg	exc_msg
typedef struct _rep_msg	rep_msg

Functions
RZ_IPI int	rz_xnu_update_thread_list (RzDebug *dbg)
RZ_IPI xnu_thread_t *	rz_xnu_get_thread (RzDebug *dbg, int tid)
RZ_IPI thread_t	rz_xnu_get_cur_thread (RzDebug *dbg)
RZ_IPI bool	rz_xnu_thread_set_drx (RzDebug *dbg, xnu_thread_t *thread)
RZ_IPI bool	rz_xnu_thread_set_gpr (RzDebug *dbg, xnu_thread_t *thread)
RZ_IPI bool	rz_xnu_thread_get_gpr (RzDebug *dbg, xnu_thread_t *thread)
RZ_IPI bool	rz_xnu_thread_get_drx (RzDebug *dbg, xnu_thread_t *thread)
RZ_IPI bool	xnu_modify_trace_bit (RzDebug *dbg, xnu_thread_t *th, int enable)
static bool	xnu_set_trace_bit (RzDebug *dbg, xnu_thread_t *th)
static bool	xnu_clear_trace_bit (RzDebug *dbg, xnu_thread_t *th)
RZ_IPI bool	xnu_create_exception_thread (RzDebug *dbg)
RZ_IPI bool	xnu_restore_exception_ports (int pid)
RZ_IPI RzDebugReasonType	xnu_wait_for_exception (RzDebug *dbg, int pid, ut32 timeout_ms, bool quiet_signal)

Macro Definition Documentation

RETURN_ON_MACH_ERROR

#define RETURN_ON_MACH_ERROR	(		msg,
			retval
	)

Value:

    if (kr != KERN_SUCCESS) { \
        mach_error(msg, kr); \
        return ((retval)); \
    }

Definition at line 33 of file xnu_threads.h.

Typedef Documentation

exc_msg

typedef struct _exc_msg exc_msg

rep_msg

typedef struct _rep_msg rep_msg

xnu_exception_info

typedef struct _exception_info xnu_exception_info

xnu_thread_t

typedef struct _xnu_thread xnu_thread_t

Function Documentation

rz_xnu_get_cur_thread()

RZ_IPI thread_t rz_xnu_get_cur_thread

(

RzDebug *

dbg

)

Definition at line 402 of file xnu_threads.c.

                                                    {
    thread_t th;
    thread_array_t threads = NULL;
    unsigned int n_threads = 0;
    task_t t = pid_to_task(dbg->pid);
    if (!t) {
        return -1;
    }
    if (task_threads(t, &threads, &n_threads) != KERN_SUCCESS) {
        return -1;
    }
    if (n_threads > 0) {
        memcpy(&th, threads, sizeof(th));
    } else {
        th = -1;
    }
    vm_deallocate(mach_task_self(), (vm_address_t)threads, n_threads * sizeof(thread_act_t));
    return th;
}

References dbg, memcpy(), NULL, rz_debug_t::pid, pid_to_task(), and threads.

Referenced by rz_xnu_get_thread(), xnu_continue(), xnu_reg_read(), xnu_reg_write(), and xnu_step().

rz_xnu_get_thread()

RZ_IPI xnu_thread_t* rz_xnu_get_thread	(	RzDebug *	dbg,
		int	tid
	)

Definition at line 378 of file xnu_threads.c.

                                                              {
    if (!dbg || tid < 0) {
        return NULL;
    }
    if (!rz_xnu_update_thread_list(dbg)) {
        eprintf("Failed to update thread_list xnu_udpate_thread_list\n");
        return NULL;
    }
    // TODO get the current thread
    RzListIter *it = rz_list_find(dbg->threads, (const void *)(size_t)&tid,
        (RzListComparator)&thread_find);
    if (!it) {
        tid = rz_xnu_get_cur_thread(dbg);
        it = rz_list_find(dbg->threads, (const void *)(size_t)&tid,
            (RzListComparator)&thread_find);
        if (!it) {
            eprintf("Thread not found get_xnu_thread\n");
            return NULL;
        }
    }
    return (xnu_thread_t *)it->data;
}

References rz_list_iter_t::data, dbg, eprintf, NULL, rz_list_find(), rz_xnu_get_cur_thread(), rz_xnu_update_thread_list(), thread_find(), and rz_debug_t::threads.

Referenced by xnu_continue(), xnu_map_alloc(), xnu_map_dealloc(), xnu_reg_read(), xnu_reg_write(), and xnu_step().

rz_xnu_thread_get_drx()

RZ_IPI bool rz_xnu_thread_get_drx	(	RzDebug *	dbg,
		xnu_thread_t *	thread
	)

Definition at line 26 of file xnu_threads.c.

                                                                      {
    rz_return_val_if_fail(dbg && thread, false);
    kern_return_t rc;
#if __x86_64__ || __i386__
    thread->flavor = x86_DEBUG_STATE;
    thread->count = x86_DEBUG_STATE_COUNT;
    thread->state_size = (dbg->bits == RZ_SYS_BITS_64)
        ? sizeof(x86_debug_state64_t)
        : sizeof(x86_debug_state32_t);
    thread->state = &thread->drx.uds;
    rc = thread_get_state(thread->port, thread->flavor,
        (thread_state_t)&thread->drx, &thread->count);
#elif __arm64__ || __arm64 || __aarch64 || __aarch64__
    if (dbg->bits == RZ_SYS_BITS_64) {
        thread->count = ARM_DEBUG_STATE64_COUNT;
        thread->flavor = ARM_DEBUG_STATE64;
        rc = thread_get_state(thread->port, thread->flavor,
            (thread_state_t)&thread->debug.drx64,
            &thread->count);
    } else {
        thread->count = ARM_DEBUG_STATE32_COUNT;
        thread->flavor = ARM_DEBUG_STATE32;
        rc = thread_get_state(thread->port, thread->flavor,
            (thread_state_t)&thread->debug.drx32,
            &thread->count);
    }
#elif __arm__ || __arm || __armv7__
    thread->count = ARM_DEBUG_STATE_COUNT;
    thread->flavor = ARM_DEBUG_STATE;
    rc = thread_get_state(thread->port, thread->flavor,
        (thread_state_t)&thread->debug.drx,
        &thread->count);
#else
#warning xnu_thread_get_drx: Unsupported architecture
    rc = KERN_FAILURE;
#endif
    if (rc != KERN_SUCCESS) {
        LOG_MACH_ERROR("thread_get_state", rc);
        thread->count = 0;
        return false;
    }
    return true;
}

References rz_debug_t::bits, _xnu_thread::count, dbg, _xnu_thread::flavor, LOG_MACH_ERROR, _xnu_thread::port, rz_return_val_if_fail, RZ_SYS_BITS_64, _xnu_thread::state, _xnu_thread::state_size, and x86_DEBUG_STATE.

Referenced by xnu_reg_read().

rz_xnu_thread_get_gpr()

RZ_IPI bool rz_xnu_thread_get_gpr	(	RzDebug *	dbg,
		xnu_thread_t *	thread
	)

Definition at line 184 of file xnu_threads.c.

                                                                      {
    rz_return_val_if_fail(dbg && thread, false);
    RZ_REG_T *regs = &thread->gpr;
    if (!regs) {
        return false;
    }
    kern_return_t rc;
#if __POWERPC__
    thread->state = regs;
#elif __arm64 || __aarch64 || __aarch64__ || __arm64__
    // thread->state = regs;
    thread->state = &regs->uts;
    if (dbg->bits == RZ_SYS_BITS_64) {
        thread->flavor = ARM_THREAD_STATE64;
        thread->count = ARM_THREAD_STATE64_COUNT;
        thread->state_size = sizeof(arm_thread_state64_t);
    } else {
        thread->flavor = ARM_THREAD_STATE;
        thread->count = ARM_THREAD_STATE_COUNT;
        thread->state_size = sizeof(arm_thread_state32_t);
    }
#elif __arm || __arm__ || __armv7__
    thread->state = regs;
    thread->flavor = ARM_THREAD_STATE;
    thread->count = ARM_THREAD_STATE_COUNT;
    thread->state_size = sizeof(arm_thread_state_t);
#elif __x86_64__ || __i386__
    thread->state = &regs->uts;
    thread->flavor = x86_THREAD_STATE;
    thread->count = x86_THREAD_STATE_COUNT;
    thread->state_size = (dbg->bits == RZ_SYS_BITS_64) ? sizeof(x86_thread_state64_t) : sizeof(x86_thread_state32_t);
#endif
    rc = thread_get_state(thread->port, thread->flavor,
        (thread_state_t)regs, &thread->count);
    if (rc != KERN_SUCCESS) {
        LOG_MACH_ERROR("thread_get_state", rc);
        thread->count = 0;
        return false;
    }
    return true;
}

References rz_debug_t::bits, _xnu_thread::count, dbg, _xnu_thread::flavor, _xnu_thread::gpr, LOG_MACH_ERROR, _xnu_thread::port, regs, rz_return_val_if_fail, RZ_SYS_BITS_64, _xnu_thread::state, _xnu_thread::state_size, x86_THREAD_STATE, and x86_THREAD_STATE_COUNT.

Referenced by xnu_reg_read(), and xnu_thread_list().

rz_xnu_thread_set_drx()

RZ_IPI bool rz_xnu_thread_set_drx	(	RzDebug *	dbg,
		xnu_thread_t *	thread
	)

Definition at line 70 of file xnu_threads.c.

                                                                      {
    rz_return_val_if_fail(dbg && thread, false);
    kern_return_t rc;
#if __i386__ || __x86_64__
    x86_debug_state_t *regs = &thread->drx;
    if (!regs) {
        return false;
    }
    thread->flavor = x86_DEBUG_STATE;
    thread->count = x86_DEBUG_STATE_COUNT;
    if (dbg->bits == RZ_SYS_BITS_64) {
        regs->dsh.flavor = x86_DEBUG_STATE64;
        regs->dsh.count = x86_DEBUG_STATE64_COUNT;
    } else {
        regs->dsh.flavor = x86_DEBUG_STATE32;
        regs->dsh.count = x86_DEBUG_STATE32_COUNT;
    }
    rc = thread_set_state(thread->port, thread->flavor,
        (thread_state_t)regs, thread->count);
#elif __arm64__ || __arm64 || __aarch64 || __aarch64__
    if (dbg->bits == RZ_SYS_BITS_64) {
        thread->count = ARM_DEBUG_STATE64_COUNT;
        thread->flavor = ARM_DEBUG_STATE64;
        rc = thread_set_state(thread->port, thread->flavor,
            (thread_state_t)&thread->debug.drx64,
            thread->count);
    } else {
        thread->count = ARM_DEBUG_STATE32_COUNT;
        thread->flavor = ARM_DEBUG_STATE32;
        rc = thread_set_state(thread->port, thread->flavor,
            (thread_state_t)&thread->debug.drx32,
            thread->count);
    }
#elif __arm__ || __arm || __armv7__
    thread->count = ARM_DEBUG_STATE_COUNT;
    thread->flavor = ARM_DEBUG_STATE;
    rc = thread_set_state(thread->port, thread->flavor,
        (thread_state_t)&thread->debug.drx,
        &thread->count);
#elif __POWERPC__
/* not supported */
#ifndef PPC_DEBUG_STATE32
#define PPC_DEBUG_STATE32 1
#endif
    ppc_debug_state_t *regs;
    // thread->flavor = PPC_DEBUG_STATE32;
    // thread->count  = RZ_MIN (thread->count, sizeof (regs->uds.ds32));
    return false;
#else
    regs->dsh.flavor = 0;
    thread->count = 0;
#endif
    if (rc != KERN_SUCCESS) {
        LOG_MACH_ERROR("thread_set_state", rc);
        thread->count = 0;
        return false;
    }
    return true;
}

References rz_debug_t::bits, _xnu_thread::count, dbg, _xnu_thread::flavor, LOG_MACH_ERROR, _xnu_thread::port, regs, rz_return_val_if_fail, RZ_SYS_BITS_64, x86_DEBUG_STATE, x86_DEBUG_STATE32, and x86_DEBUG_STATE64.

Referenced by xnu_reg_write().

rz_xnu_thread_set_gpr()

RZ_IPI bool rz_xnu_thread_set_gpr	(	RzDebug *	dbg,
		xnu_thread_t *	thread
	)

Definition at line 130 of file xnu_threads.c.

                                                                      {
    rz_return_val_if_fail(dbg && thread, false);
    kern_return_t rc;
    RZ_REG_T *regs = (RZ_REG_T *)&thread->gpr;
    if (!regs) {
        return false;
    }
#if __i386__ || __x86_64__
    // thread->flavor is used in a switch+case but in regs->tsh.flavor we
    // specify
    thread->state = &regs->uts;
    // thread->state = regs;
    thread->flavor = x86_THREAD_STATE;
    thread->count = x86_THREAD_STATE_COUNT;
    if (dbg->bits == RZ_SYS_BITS_64) {
        regs->tsh.flavor = x86_THREAD_STATE64;
        regs->tsh.count = x86_THREAD_STATE64_COUNT;
    } else {
        regs->tsh.flavor = x86_THREAD_STATE32;
        regs->tsh.count = x86_THREAD_STATE32_COUNT;
    }
#elif __arm64 || __aarch64 || __arm64__ || __aarch64__
#if 0
    /* unified doesnt seems to work */
    thread->flavor = ARM_UNIFIED_THREAD_STATE;
    thread->count = ARM_UNIFIED_THREAD_STATE_COUNT;
#endif
    // thread->state = regs;
    thread->state = &regs->uts;
    if (dbg->bits == RZ_SYS_BITS_64) {
        thread->flavor = ARM_THREAD_STATE64;
        thread->count = ARM_THREAD_STATE64_COUNT;
        thread->state_size = sizeof(arm_thread_state64_t);
    } else {
        thread->flavor = ARM_THREAD_STATE32;
        thread->count = ARM_THREAD_STATE32_COUNT;
        thread->state_size = sizeof(arm_thread_state32_t);
    }
#elif __arm || __arm__ || __armv7__
    thread->flavor = ARM_THREAD_STATE;
    thread->count = ARM_THREAD_STATE_COUNT;
    thread->state_size = sizeof(arm_thread_state_t);
 
#endif
    rc = thread_set_state(thread->port, thread->flavor,
        (thread_state_t)regs, thread->count);
    if (rc != KERN_SUCCESS) {
        LOG_MACH_ERROR("thread_set_state", rc);
        thread->count = 0;
        return false;
    }
    return true;
}

References rz_debug_t::bits, _xnu_thread::count, dbg, _xnu_thread::flavor, _xnu_thread::gpr, if(), LOG_MACH_ERROR, _xnu_thread::port, regs, rz_return_val_if_fail, RZ_SYS_BITS_64, _xnu_thread::state, _xnu_thread::state_size, x86_THREAD_STATE, x86_THREAD_STATE32, x86_THREAD_STATE64, x86_THREAD_STATE64_COUNT, and x86_THREAD_STATE_COUNT.

Referenced by xnu_reg_write().

rz_xnu_update_thread_list()

RZ_IPI int rz_xnu_update_thread_list

(

RzDebug *

dbg

)

Definition at line 290 of file xnu_threads.c.

                                                   {
    thread_array_t thread_list = NULL;
    unsigned int thread_count = 0;
    xnu_thread_t *thread;
    kern_return_t kr;
    task_t task;
    int i;
 
    if (!dbg->threads) {
        dbg->threads = rz_list_newf((RzListFree)&xnu_thread_free);
        if (!dbg->threads) {
            return false;
        }
    }
    // ok we have the list that will hold our threads, now is time to get
    // them
    task = pid_to_task(dbg->pid);
    if (!task) {
        return false;
    }
    kr = task_threads(task, &thread_list, &thread_count);
    if (kr != KERN_SUCCESS) {
        // we can get into this when the process has terminated but we
        // still hold the old task because we are caching it
        eprintf("Failed to get list of task's threads\n");
        return false;
    }
    if (rz_list_empty(dbg->threads)) {
        // it's the first time write all threads inside the list
        for (i = 0; i < thread_count; i++) {
            thread = xnu_get_thread_with_info(dbg, thread_list[i]);
            if (!thread) {
                eprintf("Failed to fill_thread\n");
                continue;
            }
            if (!rz_list_append(dbg->threads, thread)) {
                eprintf("Failed to add thread to list\n");
                xnu_thread_free(thread);
            }
        }
    } else {
        RzListIter *iter, *iter2;
        // first pass to get rid of those threads that are not longer
        // alive
        rz_list_foreach_safe (dbg->threads, iter, iter2, thread) {
            bool flag = true; // this flag will denote when delete
                      // a thread
            for (i = 0; i < thread_count; i++) {
                if (thread->port == thread_list[i]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                // it is not longer alive so remove from the
                // list
                rz_list_delete(dbg->threads, iter);
            } else {
                // otherwise update the info
                xnu_update_thread_info(dbg, thread);
            }
        }
        // ok now we have to insert those threads that we don't have
        for (i = 0; i < thread_count; i++) {
            xnu_thread_t *t;
            iter = rz_list_find(dbg->threads, &thread_list[i],
                (RzListComparator)&thread_find);
            // it means is already in our list
            if (iter) {
                // free the ownership over the thread
                kr = mach_port_deallocate(mach_task_self(),
                    thread_list[i]);
                if (kr != KERN_SUCCESS) {
                    eprintf("Failed to deallocate port\n");
                }
                continue;
            }
            // otherwise insert it
            t = xnu_get_thread_with_info(dbg, thread_list[i]);
            rz_list_append(dbg->threads, t);
        }
    }
    // once that is over we need to free the buffer
    (void)vm_deallocate(mach_task_self(), (mach_vm_address_t)thread_list,
        thread_count * sizeof(thread_t));
    return true;
}

References dbg, eprintf, i, NULL, rz_debug_t::pid, pid_to_task(), _xnu_thread::port, rz_list_append(), rz_list_delete(), rz_list_find(), rz_list_newf(), thread_find(), rz_debug_t::threads, xnu_get_thread_with_info(), xnu_thread_free(), and xnu_update_thread_info().

Referenced by rz_xnu_get_thread(), and xnu_thread_list().

xnu_clear_trace_bit()

static bool xnu_clear_trace_bit ( RzDebug *  dbg, xnu_thread_t *  th  )

inlinestatic

Definition at line 114 of file xnu_threads.h.

                                                                       {
    return xnu_modify_trace_bit(dbg, th, 0);
}

References dbg, and xnu_modify_trace_bit().

Referenced by xnu_continue().

xnu_create_exception_thread()

RZ_IPI bool xnu_create_exception_thread

(

RzDebug *

dbg

)

Definition at line 479 of file xnu_excthreads.c.

                                                      {
#if __POWERPC__
    return false;
#else
    kern_return_t kr;
    mach_port_t exception_port = MACH_PORT_NULL;
    mach_port_t req_port;
    // Got the Mach port for the current process
    mach_port_t task_self = mach_task_self();
    task_t task = pid_to_task(dbg->pid);
    if (!task) {
        eprintf("error to get task for the debuggee process"
            " xnu_start_exception_thread\n");
        return false;
    }
    if (!MACH_PORT_VALID(task_self)) {
        eprintf("error to get the task for the current process"
            " xnu_start_exception_thread\n");
        return false;
    }
    // Allocate an exception port that we will use to track our child process
    kr = mach_port_allocate(task_self, MACH_PORT_RIGHT_RECEIVE,
        &exception_port);
    RETURN_ON_MACH_ERROR("error to allocate mach_port exception\n", false);
    // Add the ability to send messages on the new exception port
    kr = mach_port_insert_right(task_self, exception_port, exception_port,
        MACH_MSG_TYPE_MAKE_SEND);
    RETURN_ON_MACH_ERROR("error to allocate insert right\n", false);
    // Atomically swap out (and save) the child process's exception ports
    // for the one we just created. We'll want to receive all exceptions.
    ex.count = (sizeof(ex.ports) / sizeof(*ex.ports));
    kr = task_swap_exception_ports(task, EXC_MASK_ALL, exception_port,
        EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES, THREAD_STATE_NONE,
        ex.masks, &ex.count, ex.ports, ex.behaviors, ex.flavors);
    RETURN_ON_MACH_ERROR("failed to swap exception ports\n", false);
    // get notification when process die
    kr = mach_port_request_notification(task_self, task, MACH_NOTIFY_DEAD_NAME,
        0, exception_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, &req_port);
    if (kr != KERN_SUCCESS) {
        eprintf("Termination notification request failed\n");
    }
    ex.exception_port = exception_port;
    return true;
#endif
}

References _exception_info::behaviors, _exception_info::count, dbg, eprintf, ex, _exception_info::exception_port, _exception_info::flavors, _exception_info::masks, rz_debug_t::pid, pid_to_task(), _exception_info::ports, and RETURN_ON_MACH_ERROR.

Referenced by xnu_attach().

xnu_modify_trace_bit()

RZ_IPI bool xnu_modify_trace_bit	(	RzDebug *	dbg,
		xnu_thread_t *	th,
		int	enable
	)

Referenced by xnu_clear_trace_bit(), and xnu_set_trace_bit().

xnu_restore_exception_ports()

RZ_IPI bool xnu_restore_exception_ports

(

int

pid

)

Definition at line 226 of file xnu_excthreads.c.

                                                 {
    kern_return_t kr;
    int i;
    task_t task = pid_to_task(pid);
    if (!task)
        return false;
    for (i = 0; i < ex.count; i++) {
        kr = task_set_exception_ports(task, ex.masks[i], ex.ports[i],
            ex.behaviors[i], ex.flavors[i]);
        if (kr != KERN_SUCCESS) {
            eprintf("fail to restore exception ports\n");
            return false;
        }
    }
    kr = mach_port_deallocate(mach_task_self(), ex.exception_port);
    if (kr != KERN_SUCCESS) {
        eprintf("failed to deallocate exception port\n");
        return false;
    }
    return true;
}

References _exception_info::behaviors, _exception_info::count, eprintf, ex, _exception_info::exception_port, _exception_info::flavors, i, _exception_info::masks, pid, pid_to_task(), and _exception_info::ports.

Referenced by xnu_detach().

xnu_set_trace_bit()

static bool xnu_set_trace_bit ( RzDebug *  dbg, xnu_thread_t *  th  )

inlinestatic

Definition at line 111 of file xnu_threads.h.

                                                                     {
    return xnu_modify_trace_bit(dbg, th, 1);
}

References dbg, and xnu_modify_trace_bit().

Referenced by xnu_step().

xnu_wait_for_exception()

RZ_IPI RzDebugReasonType xnu_wait_for_exception	(	RzDebug *	dbg,
		int	pid,
		ut32	timeout_ms,
		bool	quiet_signal
	)

Wait for a Mach exception, reply to it and handle it.

Parameters

timeout_ms	if zero, wait infinitely, otherwise specifies a timeout for receiving
quiet_signal	don't print when receiving a standard unix signal

Definition at line 409 of file xnu_excthreads.c.

                                                                                                           {
    rz_return_val_if_fail(dbg, RZ_DEBUG_REASON_ERROR);
    kern_return_t kr;
    int ret_code;
    RzDebugReasonType reason = RZ_DEBUG_REASON_UNKNOWN;
    mig_reply_error_t reply;
    bool ret;
    exc_msg msg = { 0 };
    if (!dbg) {
        return reason;
    }
    msg.hdr.msgh_local_port = ex.exception_port;
    msg.hdr.msgh_size = sizeof(exc_msg);
    for (;;) {
        kr = mach_msg(
            &msg.hdr,
            MACH_RCV_MSG | MACH_RCV_INTERRUPT | (timeout_ms ? MACH_RCV_TIMEOUT : 0), 0,
            sizeof(exc_msg), ex.exception_port,
            timeout_ms ? timeout_ms : MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
        if (kr == MACH_RCV_INTERRUPTED) {
            reason = RZ_DEBUG_REASON_MACH_RCV_INTERRUPTED;
            break;
        } else if (kr == MACH_RCV_TIMED_OUT) {
            RZ_LOG_ERROR("Waiting for Mach exception timed out");
            reason = RZ_DEBUG_REASON_UNKNOWN;
            break;
        } else if (kr != MACH_MSG_SUCCESS) {
            RZ_LOG_ERROR("message didn't succeeded\n");
            break;
        }
        ret = validate_mach_message(dbg, &msg);
        if (!ret) {
            ret = handle_dead_notify(dbg, &msg);
            if (ret) {
                reason = RZ_DEBUG_REASON_DEAD;
                break;
            }
        }
        if (!ret) {
            encode_reply(&reply, &msg.hdr, KERN_FAILURE);
            kr = mach_msg(&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
                reply.Head.msgh_size, 0,
                MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
                MACH_PORT_NULL);
            if (reply.Head.msgh_remote_port != 0 && kr != MACH_MSG_SUCCESS) {
                kr = mach_port_deallocate(mach_task_self(), reply.Head.msgh_remote_port);
                if (kr != KERN_SUCCESS) {
                    eprintf("failed to deallocate reply port\n");
                }
            }
            continue;
        }
 
        reason = handle_exception_message(dbg, &msg, &ret_code, quiet_signal);
        encode_reply(&reply, &msg.hdr, ret_code);
        kr = mach_msg(&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
            reply.Head.msgh_size, 0,
            MACH_PORT_NULL, 0,
            MACH_PORT_NULL);
        if (reply.Head.msgh_remote_port != 0 && kr != MACH_MSG_SUCCESS) {
            kr = mach_port_deallocate(mach_task_self(), reply.Head.msgh_remote_port);
            if (kr != KERN_SUCCESS)
                eprintf("failed to deallocate reply port\n");
        }
        break; // to avoid infinite loops
    }
    dbg->stopaddr = rz_debug_reg_get(dbg, "PC");
    return reason;
}

References dbg, encode_reply(), eprintf, ex, _exception_info::exception_port, handle_dead_notify(), handle_exception_message(), msg, RZ_DEBUG_REASON_DEAD, RZ_DEBUG_REASON_ERROR, RZ_DEBUG_REASON_MACH_RCV_INTERRUPTED, RZ_DEBUG_REASON_UNKNOWN, rz_debug_reg_get(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_debug_t::stopaddr, and validate_mach_message().

Referenced by xnu_attach(), and xnu_wait().