xnu_debug.h File Reference

#include <rz_util/rz_log.h>
#include <rz_debug.h>
#include <sys/ptrace.h>
#include <sys/proc_info.h>
#include <libproc.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <mach/exception_types.h>
#include <mach/mach_init.h>
#include <mach/mach_port.h>
#include <mach/mach_interface.h>
#include <mach/mach_traps.h>
#include <mach/mach_types.h>
#include <mach/mach_error.h>
#include <mach/task.h>
#include <mach/task_info.h>
#include <mach/thread_act.h>
#include <mach/thread_info.h>
#include <mach/vm_map.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <errno.h>
#include <unistd.h>
#include <sys/sysctl.h>
#include <sys/fcntl.h>
#include <sys/proc.h>
#include <mach/i386/thread_status.h>
#include <sys/ucontext.h>
#include <mach/i386/_structs.h>

Go to the source code of this file.

Classes
struct	coredump_thread_state_flavor_t
struct	tir_t

Macros
#define	LOG_MACH_ERROR(name, rc)
#define	HAS_LIBPROC
#define	ADDR   "%8x"
#define	HEADER_SIZE   0x1000
#define	IMAGE_OFFSET   0x201000
#define	KERNEL_LOWER   0x80000000
#define	REG_PC   ((dbg->bits == RZ_SYS_BITS_64) ? 16 : 10)
#define	REG_FL   ((dbg->bits == RZ_SYS_BITS_64) ? 17 : 9)
#define	REG_SP   (7)
#define	MAX_TSTATE_FLAVORS   10
#define	DEFAULT_COREFILE_DEST   "core.%u"
#define	RZ_DEBUG_REASON_MACH_RCV_INTERRUPTED   -2

Functions
task_t	pid_to_task (int pid)
int	xnu_get_vmmap_entries_for_pid (pid_t pid)
char *	xnu_corefile_default_location (void)
bool	xnu_generate_corefile (RzDebug *dbg, RzBuffer *dest)
int	xnu_reg_read (RzDebug *dbg, int type, ut8 *buf, int size)
int	xnu_reg_write (RzDebug *dgb, int type, const ut8 *buf, int size)
char *	xnu_reg_profile (RzDebug *dbg)
int	xnu_attach (RzDebug *dbg, int pid)
bool	xnu_step (RzDebug *dbg)
int	xnu_detach (RzDebug *dbg, int pid)
int	xnu_stop (RzDebug *dbg, int pid)
int	xnu_continue (RzDebug *dbg, int pid, int tid, int sig)
RzDebugMap *	xnu_map_alloc (RzDebug *dbg, ut64 addr, int size)
int	xnu_map_dealloc (RzDebug *dbg, ut64 addr, int size)
int	xnu_map_protect (RzDebug *dbg, ut64 addr, int size, int perms)
int	xnu_init (void)
int	xnu_wait (RzDebug *dbg, int pid)
RzDebugPid *	xnu_get_pid (int pid)
RzList *	xnu_dbg_maps (RzDebug *dbg, int only_modules)
RzList *	xnu_thread_list (RzDebug *dbg, int pid, RzList *list)
RzDebugInfo *	xnu_info (RzDebug *dbg, const char *arg)

Macro Definition Documentation

ADDR

#define ADDR   "%8x"

Definition at line 119 of file xnu_debug.h.

DEFAULT_COREFILE_DEST

#define DEFAULT_COREFILE_DEST   "core.%u"

Definition at line 260 of file xnu_debug.h.

HAS_LIBPROC

#define HAS_LIBPROC

Definition at line 49 of file xnu_debug.h.

HEADER_SIZE

#define HEADER_SIZE   0x1000

Definition at line 120 of file xnu_debug.h.

IMAGE_OFFSET

#define IMAGE_OFFSET   0x201000

Definition at line 121 of file xnu_debug.h.

KERNEL_LOWER

#define KERNEL_LOWER   0x80000000

Definition at line 122 of file xnu_debug.h.

LOG_MACH_ERROR

#define LOG_MACH_ERROR	(		name,
			rc
	)

Value:

    do { \
        const char *str = mach_error_string(rc); \
        RZ_LOG_ERROR("%s/%s: %s\n", __FUNCTION__, name, str ? str : "(unknown)"); \
    } while (0)

Definition at line 17 of file xnu_debug.h.

MAX_TSTATE_FLAVORS

#define MAX_TSTATE_FLAVORS   10

Definition at line 259 of file xnu_debug.h.

REG_FL

#define REG_FL   ((dbg->bits == RZ_SYS_BITS_64) ? 17 : 9)

Definition at line 129 of file xnu_debug.h.

REG_PC

#define REG_PC   ((dbg->bits == RZ_SYS_BITS_64) ? 16 : 10)

Definition at line 128 of file xnu_debug.h.

REG_SP

#define REG_SP   (7)

Definition at line 130 of file xnu_debug.h.

RZ_DEBUG_REASON_MACH_RCV_INTERRUPTED

#define RZ_DEBUG_REASON_MACH_RCV_INTERRUPTED   -2

Definition at line 261 of file xnu_debug.h.

Function Documentation

pid_to_task()

task_t pid_to_task

(

int

pid

)

Definition at line 498 of file xnu_debug.c.

                            {
    static int old_pid = -1;
    kern_return_t kr;
    task_t task = -1;
    int err;
    /* it means that we are done with the task*/
    if (task_dbg != 0 && old_pid == pid) {
        return task_dbg;
    }
    if (task_dbg != 0 && old_pid != pid) {
        // we changed the process pid so deallocate a ref from the old_task
        // since we are going to get a new task
        kr = mach_port_deallocate(mach_task_self(), task_dbg);
        if (kr != KERN_SUCCESS) {
            eprintf("pid_to_task: fail to deallocate port\n");
            /* ignore on purpose to not break process reload: ood */
            // return 0;
        }
    }
    err = task_for_pid(mach_task_self(), (pid_t)pid, &task);
    if ((err != KERN_SUCCESS) || !MACH_PORT_VALID(task)) {
        task = task_for_pid_workaround(pid);
        if (task == 0) {
            task = task_for_pid_ios9pangu(pid);
            if (task != MACH_PORT_NULL) {
                if (pid != -1) {
                    RZ_LOG_ERROR("Failed to get task %d for pid %d.\n",
                        (int)task, (int)pid);
                    RZ_LOG_ERROR("Reason: 0x%x: %s\n", err, rz_str_get_null(mach_error_string(err)));
                }
                eprintf("You probably need to run as root\n");
                return 0;
            }
        }
    }
    old_pid = pid;
    task_dbg = task;
    return task;
}

References eprintf, err, pid, RZ_LOG_ERROR, rz_str_get_null(), task_dbg, task_for_pid_ios9pangu(), and task_for_pid_workaround().

Referenced by rz_xnu_get_cur_thread(), rz_xnu_update_thread_list(), validate_mach_message(), xnu_continue(), xnu_create_exception_thread(), xnu_dbg_maps(), xnu_dbg_modules(), xnu_generate_corefile(), xnu_get_vmmap_entries_for_pid(), xnu_map_protect(), xnu_restore_exception_ports(), xnu_step(), and xnu_stop().

xnu_attach()

int xnu_attach	(	RzDebug *	dbg,
		int	pid
	)

Definition at line 133 of file xnu_debug.c.

                                      {
    dbg->pid = pid;
    // First start listening to exceptions, which will also deliver signals to us
    if (!xnu_create_exception_thread(dbg)) {
        RZ_LOG_ERROR("Failed to start listening to mach exceptions");
        return -1;
    }
 
    // Then do the actual attach.
    int r = rz_debug_ptrace(dbg, PT_ATTACHEXC, pid, 0, 0);
    if (r < 0) {
        perror("ptrace(PT_ATTACHEXC)");
        RZ_LOG_ERROR("Failed to attach to process");
        return -1;
    }
 
    // PT_ATTACHEXC will cause a SIGSTOP in the debuggee, so wait for it
    // Our signal handler will also suspend the task, so no need to call xnu_stop if successful
    RzDebugReasonType reas = xnu_wait_for_exception(dbg, pid, 1000, true);
    if (reas != RZ_DEBUG_REASON_SIGNAL || dbg->reason.signum != SIGSTOP) {
        RZ_LOG_ERROR("SIGSTOP from PT_ATTACHEXC not observed");
        xnu_stop(dbg, pid);
    }
 
    return pid;
}

References dbg, rz_debug_t::pid, pid, r, rz_debug_t::reason, RZ_DEBUG_REASON_SIGNAL, RZ_LOG_ERROR, rz_debug_reason_t::signum, xnu_create_exception_thread(), xnu_stop(), and xnu_wait_for_exception().

xnu_continue()

int xnu_continue	(	RzDebug *	dbg,
		int	pid,
		int	tid,
		int	sig
	)

Definition at line 227 of file xnu_debug.c.

                                                          {
    task_t task = pid_to_task(pid);
    if (!task) {
        return false;
    }
    // TODO free refs count threads
    xnu_thread_t *th = rz_xnu_get_thread(dbg, rz_xnu_get_cur_thread(dbg));
    if (!th) {
        eprintf("failed to get thread in xnu_continue\n");
        return false;
    }
    // disable trace bit if enable
    if (th->stepping) {
        if (!xnu_clear_trace_bit(dbg, th)) {
            eprintf("error clearing trace bit in xnu_continue\n");
            return false;
        }
    }
    kern_return_t kr = task_resume(task);
    if (kr != KERN_SUCCESS) {
        eprintf("xnu_continue: Warning: Failed to resume task\n");
    }
    return true;
}

References dbg, eprintf, pid, pid_to_task(), rz_xnu_get_cur_thread(), rz_xnu_get_thread(), _xnu_thread::stepping, and xnu_clear_trace_bit().

xnu_corefile_default_location()

char* xnu_corefile_default_location

(

void

)

xnu_dbg_maps()

RzList* xnu_dbg_maps	(	RzDebug *	dbg,
		int	only_modules
	)

Definition at line 1225 of file xnu_debug.c.

                                                     {
    // bool contiguous = false;
    // ut32 oldprot = UT32_MAX;
    // ut32 oldmaxprot = UT32_MAX;
    char buf[1024];
    char module_name[MAXPATHLEN];
    mach_vm_address_t address = MACH_VM_MIN_ADDRESS;
    mach_vm_size_t size = (mach_vm_size_t)0;
    mach_vm_size_t osize = (mach_vm_size_t)0;
    natural_t depth = 0;
    int tid = dbg->pid;
    task_t task = pid_to_task(tid);
    RzDebugMap *mr = NULL;
    int i = 0;
 
    if (!task) {
        return NULL;
    }
    RzList *modules = xnu_dbg_modules(dbg);
    if (only_modules) {
        return modules;
    }
#if __arm64__ || __aarch64__
    size = osize = 16384;
#else
    size = osize = 4096;
#endif
#if 0
    if (dbg->pid == 0) {
        vm_address_t base = get_kernel_base (task);
        eprintf ("Kernel Base Address: 0x%"PFMT64x"\n", (ut64)base);
        return NULL;
    }
#endif
    RzList *list = rz_list_new();
    if (!list) {
        return NULL;
    }
    list->free = (RzListFree)xnu_map_free;
    for (;;) {
        struct vm_region_submap_info_64 info = { 0 };
        mach_msg_type_number_t info_count = VM_REGION_SUBMAP_INFO_COUNT_64;
        kern_return_t kr = mach_vm_region_recurse(task, &address, &size, &depth,
            (vm_region_recurse_info_t)&info, &info_count);
        if (kr != KERN_SUCCESS) {
            break;
        }
        if (info.is_submap) {
            depth++;
            continue;
        }
        module_name[0] = 0;
#ifndef __POWERPC__
        {
            int ret = proc_regionfilename(tid, address, module_name,
                sizeof(module_name));
            module_name[ret] = 0;
        }
#endif
        if (true) {
            char maxperm[32];
            char depthstr[32];
            if (depth > 0) {
                snprintf(depthstr, sizeof(depthstr), "_%d", depth);
            } else {
                depthstr[0] = 0;
            }
 
            if (info.max_protection != info.protection) {
                strcpy(maxperm, rz_str_rwx_i(xwrz_testwx(info.max_protection)));
            } else {
                maxperm[0] = 0;
            }
            // XXX: if its shared, it cannot be read?
            snprintf(buf, sizeof(buf), "%02x_%s%s%s%s%s%s%s%s",
                i, unparse_inheritance(info.inheritance),
                info.user_tag ? "_user" : "",
                info.is_submap ? "_sub" : "",
                "", info.is_submap ? "_submap" : "",
                module_name, maxperm, depthstr);
            if (!(mr = rz_debug_map_new(buf, address, address + size, xwrz_testwx(info.protection), xwrz_testwx(info.max_protection)))) {
                eprintf("Cannot create rz_debug_map_new\n");
                break;
            }
            RzDebugMap *rdm = moduleAt(modules, address);
            if (rdm) {
                mr->file = strdup(rdm->name);
            } else {
                if (*module_name) {
                    mr->file = strdup(module_name);
                }
            }
            if (mr->file) {
                if (!strcmp(mr->file, mr->file)) {
                    mr->name[0] = 0;
                    const char *slash = rz_str_lchr(mr->file, '/');
                    if (slash) {
                        strcpy(mr->name, slash + 1);
                    }
                }
            }
            i++;
            mr->shared = false;
            rz_list_append(list, mr);
        }
        if (size < 1) {
            eprintf("size error\n");
            size = osize;
        }
        address += size;
        size = 0;
    }
    RzListIter *iter;
    RzDebugMap *m;
    rz_list_foreach (modules, iter, m) {
        RzDebugMap *m2 = rz_debug_map_clone(m);
        if (m2->name && m2->file) {
            if (!strcmp(m2->name, m2->file)) {
                m2->name[0] = 0;
                const char *slash = rz_str_lchr(m2->file, '/');
                if (slash) {
                    strcpy(m2->name, slash + 1);
                }
            }
        }
        rz_list_append(list, m2);
    }
    rz_list_sort(list, cmp);
    rz_list_free(modules);
    return list;
}

References cmp(), dbg, eprintf, rz_debug_map_t::file, get_kernel_base(), i, info(), list(), regress::m, mach_vm_region_recurse(), moduleAt(), regress::modules, mr(), rz_debug_map_t::name, NULL, PFMT64x, rz_debug_t::pid, pid_to_task(), proc_regionfilename(), rz_debug_map_clone(), rz_debug_map_new(), rz_list_append(), rz_list_free(), rz_list_new(), rz_list_sort(), rz_str_lchr(), rz_str_rwx_i(), snprintf, strdup(), unparse_inheritance(), ut64(), xnu_dbg_modules(), xnu_map_free(), and xwrz_testwx.

xnu_detach()

int xnu_detach	(	RzDebug *	dbg,
		int	pid
	)

Definition at line 160 of file xnu_debug.c.

                                      {
    // Not calling PT_DETACH results in a zombie
    int r = rz_debug_ptrace(dbg, PT_DETACH, pid, 0, 0);
    if (r < 0) {
        perror("ptrace(PT_DETACH)");
    }
 
    // do the cleanup necessary
    // XXX check for errors and ref counts
    (void)xnu_restore_exception_ports(pid);
    kern_return_t kr = mach_port_deallocate(mach_task_self(), task_dbg);
    if (kr != KERN_SUCCESS) {
        eprintf("xnu_detach: failed to deallocate port\n");
        return false;
    }
    // we mark the task as not longer available since we deallocated the ref
    task_dbg = 0;
    rz_list_free(dbg->threads);
    dbg->threads = NULL;
    return true;
}

References dbg, eprintf, NULL, pid, PT_DETACH, r, rz_list_free(), task_dbg, rz_debug_t::threads, and xnu_restore_exception_ports().

xnu_generate_corefile()

bool xnu_generate_corefile	(	RzDebug *	dbg,
		RzBuffer *	dest
	)

Definition at line 827 of file xnu_debug.c.

                                                         {
    int error = 0, i;
    int tstate_size;
    int segment_count;
    int command_size;
    int header_size;
    size_t mach_header_sz;
    size_t segment_command_sz;
    size_t padding_sz;
    int hoffset;
 
    RzBuffer *mem_maps_buffer;
    vm_offset_t header;
    ut8 *padding = NULL;
    RzListIter *iter, *iter2;
    RzList *threads_list;
    xnu_thread_t *thread;
    task_t task = pid_to_task(dbg->pid);
    coredump_thread_state_flavor_t flavors[MAX_TSTATE_FLAVORS];
    tir_t tir;
 
    mem_maps_buffer = rz_buf_new_with_bytes(NULL, 0);
 
    get_mach_header_sizes(&mach_header_sz, &segment_command_sz);
    (void)task_suspend(task);
    threads_list = xnu_thread_list(dbg, dbg->pid, rz_list_new());
    xnu_dealloc_threads(threads_list);
 
    segment_count = xnu_get_vmmap_entries_for_pid(dbg->pid);
 
    memcpy(thread_flavor_array, &flavors, sizeof(thread_flavor_array));
    tstate_size = 0;
 
    for (i = 0; i < coredump_nflavors; i++) {
        tstate_size += sizeof(coredump_thread_state_flavor_t) +
            (flavors[i].count * sizeof(int));
    }
 
    command_size = COMMAND_SIZE(segment_count, segment_command_sz,
        rz_list_length(threads_list), tstate_size);
    header_size = command_size + mach_header_sz; // XXX: Add here the round_page() ?
    header = (vm_offset_t)calloc(1, header_size);
    xnu_build_corefile_header(header, segment_count,
        rz_list_length(threads_list), command_size, dbg->pid);
 
    if (!dbg->maps) {
        perror("There are not loaded maps");
    }
    if (xnu_write_mem_maps_to_buffer(mem_maps_buffer, dbg->maps, round_page(header_size),
            header, mach_header_sz, segment_command_sz, &hoffset) < 0) {
        eprintf("There was an error while writing the memory maps");
        error = false;
        goto cleanup;
    }
 
    tir.header = header;
    tir.hoffset = hoffset;
    tir.flavors = flavors;
    tir.tstate_size = tstate_size;
 
    rz_list_foreach_safe (threads_list, iter, iter2, thread) {
        xnu_collect_thread_state(thread->port, &tir);
    }
    xnu_dealloc_threads(threads_list);
 
    rz_buf_append_bytes(dest, (const ut8 *)header, header_size);
    padding_sz = round_page(header_size) - header_size;
    padding = (ut8 *)calloc(1, padding_sz);
    rz_buf_append_bytes(dest, (const ut8 *)padding, padding_sz);
    rz_buf_append_buf(dest, mem_maps_buffer);
 
cleanup:
    // if (corefile_fd > 0) close (corefile_fd);
    rz_buf_free(mem_maps_buffer);
    free((void *)header);
    free((void *)padding);
    rz_list_free(threads_list);
    return !error;
}

References calloc(), cleanup(), COMMAND_SIZE, count, dbg, dest, eprintf, error(), tir_t::flavors, free(), get_mach_header_sizes(), tir_t::header, header, tir_t::hoffset, i, rz_debug_t::maps, MAX_TSTATE_FLAVORS, memcpy(), NULL, rz_debug_t::pid, pid_to_task(), _xnu_thread::port, rz_buf_append_buf(), rz_buf_append_bytes(), rz_buf_free(), rz_buf_new_with_bytes(), rz_list_free(), rz_list_length(), rz_list_new(), tir_t::tstate_size, xnu_build_corefile_header(), xnu_collect_thread_state(), xnu_dealloc_threads(), xnu_get_vmmap_entries_for_pid(), xnu_thread_list(), and xnu_write_mem_maps_to_buffer().

xnu_get_pid()

RzDebugPid* xnu_get_pid

(

int

pid

)

Definition at line 907 of file xnu_debug.c.

                                 {
    int psnamelen, foo, nargs, mib[3], uid;
    size_t size, argmax = 4096;
    char *curr_arg, *start_args, *iter_args, *end_args;
    char *procargs = NULL;
    char psname[4096];
#if 0
    /* Get the maximum process arguments size. */
    mib[0] = CTL_KERN;
    mib[1] = KERN_ARGMAX;
    size = sizeof(argmax);
    if (sysctl (mib, 2, &argmax, &size, NULL, 0) == -1) {
        eprintf ("sysctl() error on getting argmax\n");
        return NULL;
    }
#endif
    uid = uidFromPid(pid);
 
    /* Allocate space for the arguments. */
    procargs = (char *)malloc(argmax);
    if (!procargs) {
        eprintf("getcmdargs(): insufficient memory for procargs %d\n",
            (int)(size_t)argmax);
        return NULL;
    }
 
    /*
     * Make a sysctl() call to get the raw argument space of the process.
     */
    mib[0] = CTL_KERN;
    mib[1] = KERN_PROCARGS2;
    mib[2] = pid;
 
    size = argmax;
    procargs[0] = 0;
    if (sysctl(mib, 3, procargs, &size, NULL, 0) == -1) {
        if (EINVAL == errno) { // invalid == access denied for some reason
            // eprintf("EINVAL returned fetching argument space\n");
            free(procargs);
            return NULL;
        }
        eprintf("sysctl(): unspecified sysctl error - %i\n", errno);
        free(procargs);
        return NULL;
    }
 
    // copy the number of argument to nargs
    memcpy(&nargs, procargs, sizeof(nargs));
    iter_args = procargs + sizeof(nargs);
    end_args = &procargs[size - 30]; // end of the argument space
    if (iter_args >= end_args) {
        eprintf("getcmdargs(): argument length mismatch");
        free(procargs);
        return NULL;
    }
 
    // TODO: save the environment variables to envlist as well
    //  Skip over the exec_path and '\0' characters.
    //  XXX: fix parsing
#if 0
    while (iter_args < end_args && *iter_args != '\0') { iter_args++; }
    while (iter_args < end_args && *iter_args == '\0') { iter_args++; }
#endif
    if (iter_args == end_args) {
        free(procargs);
        return NULL;
    }
    curr_arg = iter_args;
    start_args = iter_args; // reset start position to beginning of cmdline
    foo = 1;
    *psname = 0;
    psnamelen = 0;
    while (iter_args < end_args && nargs > 0) {
        if (*iter_args++ == '\0') {
            int alen = strlen(curr_arg);
            if (foo) {
                memcpy(psname, curr_arg, alen + 1);
                foo = 0;
            } else {
                psname[psnamelen] = ' ';
                memcpy(psname + psnamelen + 1, curr_arg, alen + 1);
            }
            psnamelen += alen;
            // printf("arg[%i]: %s\n", iter_args, curr_arg);
            /* Fetch next argument */
            curr_arg = iter_args;
            nargs--;
        }
    }
#if 1
    /*
     * curr_arg position should be further than the start of the argspace
     * and number of arguments should be 0 after iterating above. Otherwise
     * we had an empty argument space or a missing terminating \0 etc.
     */
    if (curr_arg == start_args || nargs > 0) {
        psname[0] = 0;
        //      eprintf ("getcmdargs(): argument parsing failed");
        free(procargs);
        return NULL;
    }
#endif
    return rz_debug_pid_new(psname, pid, uid, 's', 0); // XXX 's' ??, 0?? must set correct values
}

References EINVAL, eprintf, foo, free(), malloc(), memcpy(), cmd_descs_generate::nargs, NULL, pid, rz_debug_pid_new(), and uidFromPid().

xnu_get_vmmap_entries_for_pid()

int xnu_get_vmmap_entries_for_pid

(

pid_t

pid

)

Definition at line 538 of file xnu_debug.c.

                                             {
    task_t task = pid_to_task(pid);
    kern_return_t kr = KERN_SUCCESS;
    vm_address_t address = 0;
    vm_size_t size = 0;
    int n = 1;
 
    for (;;) {
        mach_msg_type_number_t count;
        struct vm_region_submap_info_64 info;
        ut32 nesting_depth;
 
        count = VM_REGION_SUBMAP_INFO_COUNT_64;
        kr = vm_region_recurse_64(task, &address, &size, &nesting_depth,
            (vm_region_info_64_t)&info, &count);
        if (kr == KERN_INVALID_ADDRESS) {
            break;
        }
        if (kr) {
            mach_error("vm_region:", kr);
            break;
        }
        if (info.is_submap) {
            nesting_depth++;
        } else {
            address += size;
            n++;
        }
    }
 
    return n;
}

References count, info(), n, pid, and pid_to_task().

Referenced by xnu_generate_corefile().

xnu_info()

RzDebugInfo* xnu_info	(	RzDebug *	dbg,
		const char *	arg
	)

Definition at line 397 of file xnu_debug.c.

                                                     {
    struct kinfo_proc kp; // XXX This need to be freed?
    int kinfo_proc_error = 0;
    RzDebugInfo *rdi = RZ_NEW0(RzDebugInfo);
    if (!rdi)
        return NULL;
 
    kinfo_proc_error = xnu_get_kinfo_proc(dbg->pid, &kp);
 
    if (kinfo_proc_error) {
        eprintf("Error while querying the process info to sysctl\n");
        return NULL;
    }
    rdi->status = RZ_DBG_PROC_SLEEP; // TODO: Fix this w/o libproc ?
    rdi->pid = dbg->pid;
    rdi->tid = dbg->tid;
    rdi->uid = kp.kp_eproc.e_ucred.cr_uid;
    rdi->gid = kp.kp_eproc.e_ucred.cr_gid;
#ifdef HAS_LIBPROC
    struct proc_bsdinfo proc;
    rdi->status = 0;
    char file_path[MAXPATHLEN] = { 0 };
    int file_path_len;
    file_path_len = proc_pidpath(rdi->pid, file_path, sizeof(file_path));
    if (file_path_len > 0) {
        file_path[file_path_len] = 0;
        rdi->exe = strdup(file_path);
    }
    if (proc_pidinfo(rdi->pid, PROC_PIDTBSDINFO, 0,
            &proc, PROC_PIDTBSDINFO_SIZE) == PROC_PIDTBSDINFO_SIZE) {
        if ((proc.pbi_flags & PROC_FLAG_TRACED) != 0) {
            rdi->status = RZ_DBG_PROC_RUN;
        }
        if ((proc.pbi_flags & PROC_FLAG_INEXIT) != 0) {
            rdi->status = RZ_DBG_PROC_STOP;
        }
    }
#endif
    return rdi;
}

References dbg, eprintf, NULL, rz_debug_t::pid, proc, rdi, RZ_DBG_PROC_RUN, RZ_DBG_PROC_SLEEP, RZ_DBG_PROC_STOP, RZ_NEW0, strdup(), rz_debug_t::tid, and xnu_get_kinfo_proc().

xnu_init()

int xnu_init

(

void

)

xnu_map_alloc()

RzDebugMap* xnu_map_alloc	(	RzDebug *	dbg,
		ut64	addr,
		int	size
	)

Definition at line 346 of file xnu_debug.c.

                                                             {
    kern_return_t ret;
    ut8 *base = (ut8 *)addr;
    xnu_thread_t *th = rz_xnu_get_thread(dbg, dbg->tid);
    bool anywhere = !VM_FLAGS_ANYWHERE;
    if (!th) {
        return NULL;
    }
    if (addr == -1) {
        anywhere = VM_FLAGS_ANYWHERE;
    }
    ret = vm_allocate(th->port, (vm_address_t *)&base,
        (vm_size_t)size,
        anywhere | VM_MAKE_TAG(DEBUG_MAP_TAG_ID));
    if (ret != KERN_SUCCESS) {
        eprintf("vm_allocate failed\n");
        return NULL;
    }
    rz_debug_map_sync(dbg); // update process memory maps
    return rz_debug_map_get(dbg, (ut64)base);
}

References addr, dbg, DEBUG_MAP_TAG_ID, eprintf, NULL, _xnu_thread::port, rz_debug_map_get(), rz_debug_map_sync(), rz_xnu_get_thread(), rz_debug_t::tid, and ut64().

xnu_map_dealloc()

int xnu_map_dealloc	(	RzDebug *	dbg,
		ut64	addr,
		int	size
	)

Definition at line 368 of file xnu_debug.c.

                                                       {
    xnu_thread_t *th = rz_xnu_get_thread(dbg, dbg->tid);
    if (!th) {
        return false;
    }
    mach_error_t ret = vm_deallocate(th->port, (vm_address_t)addr, (vm_size_t)size);
    if (ret != KERN_SUCCESS) {
        LOG_MACH_ERROR("vm_deallocate", ret);
        return false;
    }
    return true;
}

References addr, dbg, LOG_MACH_ERROR, _xnu_thread::port, rz_xnu_get_thread(), and rz_debug_t::tid.

xnu_map_protect()

int xnu_map_protect	(	RzDebug *	dbg,
		ut64	addr,
		int	size,
		int	perms
	)

Definition at line 486 of file xnu_debug.c.

                                                                  {
    task_t task = pid_to_task(dbg->tid);
#define xwrz_testwx(x) ((x & 1) << 2) | (x & 2) | ((x & 4) >> 2)
    int xnu_perms = xwrz_testwx(perms);
    mach_error_t ret = mach_vm_protect(task, (vm_address_t)addr, (vm_size_t)size, (boolean_t)0, xnu_perms); // VM_PROT_COPY | perms);
    if (ret != KERN_SUCCESS) {
        LOG_MACH_ERROR("mach_vm_protect", ret);
        return false;
    }
    return true;
}

References addr, dbg, LOG_MACH_ERROR, pid_to_task(), rz_debug_t::tid, and xwrz_testwx.

xnu_reg_profile()

char* xnu_reg_profile

(

RzDebug *

dbg

)

Definition at line 252 of file xnu_debug.c.

                                    {
#if __i386__ || __x86_64__
    if (dbg->bits & RZ_SYS_BITS_32) {
#include "reg/darwin-x86.h"
    } else if (dbg->bits == RZ_SYS_BITS_64) {
#include "reg/darwin-x64.h"
    } else {
        eprintf("invalid bit size\n");
        return NULL;
    }
#elif __POWERPC__
#include "reg/darwin-ppc.h"
#elif __APPLE__ && (__aarch64__ || __arm64__ || __arm__)
    if (dbg->bits == RZ_SYS_BITS_64) {
#include "reg/darwin-arm64.h"
    } else {
#include "reg/darwin-arm.h"
    }
#else
#error "Unsupported Apple architecture"
#endif
}

References rz_debug_t::bits, dbg, eprintf, NULL, RZ_SYS_BITS_32, and RZ_SYS_BITS_64.

xnu_reg_read()

int xnu_reg_read	(	RzDebug *	dbg,
		int	type,
		ut8 *	buf,
		int	size
	)

Definition at line 315 of file xnu_debug.c.

                                                             {
    xnu_thread_t *th = rz_xnu_get_thread(dbg, rz_xnu_get_cur_thread(dbg));
    if (!th) {
        return 0;
    }
    switch (type) {
    case RZ_REG_TYPE_SEG:
    case RZ_REG_TYPE_FLG:
    case RZ_REG_TYPE_GPR:
        if (!rz_xnu_thread_get_gpr(dbg, th)) {
            return 0;
        }
        break;
    case RZ_REG_TYPE_DRX:
        if (!rz_xnu_thread_get_drx(dbg, th)) {
            return 0;
        }
        break;
    default:
        return 0;
    }
    if (th->state) {
        int rsz = RZ_MIN(th->state_size, size);
        if (rsz > 0) {
            memcpy(buf, th->state, rsz);
            return rsz;
        }
    }
    return 0;
}

References dbg, memcpy(), RZ_MIN, RZ_REG_TYPE_DRX, RZ_REG_TYPE_FLG, RZ_REG_TYPE_GPR, RZ_REG_TYPE_SEG, rz_xnu_get_cur_thread(), rz_xnu_get_thread(), rz_xnu_thread_get_drx(), rz_xnu_thread_get_gpr(), _xnu_thread::state, _xnu_thread::state_size, and type.

xnu_reg_write()

int xnu_reg_write	(	RzDebug *	dgb,
		int	type,
		const ut8 *	buf,
		int	size
	)

Definition at line 279 of file xnu_debug.c.

                                                                    {
    bool ret;
    xnu_thread_t *th = rz_xnu_get_thread(dbg, rz_xnu_get_cur_thread(dbg));
    if (!th) {
        return 0;
    }
    switch (type) {
    case RZ_REG_TYPE_DRX:
#if __x86_64__
        memcpy(&th->drx.uds.ds32, buf, RZ_MIN(size, sizeof(th->drx)));
#elif __i386__
        memcpy(&th->drx.uds.ds64, buf, RZ_MIN(size, sizeof(th->drx)));
#elif __arm64 || __aarch64
        if (dbg->bits == RZ_SYS_BITS_64) {
            memcpy(&th->debug.drx64, buf, RZ_MIN(size, sizeof(th->debug.drx64)));
        } else {
            memcpy(&th->debug.drx32, buf, RZ_MIN(size, sizeof(th->debug.drx32)));
        }
#elif __arm || __armv7 || __arm__ || __armv7__
        memcpy(&th->debug.drx, buf, RZ_MIN(size, sizeof(th->debug.drx)));
#endif
        ret = rz_xnu_thread_set_drx(dbg, th);
        break;
    default:
        // th->gpr has a header and the state we should copy on the state only
#if __POWERPC__
#warning TODO powerpc support here
#else
        memcpy(&th->gpr.uts, buf, RZ_MIN(size, sizeof(th->gpr.uts)));
#endif
        ret = rz_xnu_thread_set_gpr(dbg, th);
        break;
    }
    return ret;
}

References rz_debug_t::bits, dbg, _xnu_thread::gpr, memcpy(), RZ_MIN, RZ_REG_TYPE_DRX, RZ_SYS_BITS_64, rz_xnu_get_cur_thread(), rz_xnu_get_thread(), rz_xnu_thread_set_drx(), rz_xnu_thread_set_gpr(), and type.

xnu_step()

bool xnu_step

(

RzDebug *

dbg

)

Definition at line 112 of file xnu_debug.c.

                            {
    // we must find a way to get the current thread not just the first one
    task_t task = pid_to_task(dbg->pid);
    if (!task) {
        eprintf("step failed on task %d for pid %d\n", task, dbg->tid);
        return false;
    }
    xnu_thread_t *th = rz_xnu_get_thread(dbg, rz_xnu_get_cur_thread(dbg));
    if (!th) {
        return false;
    }
    int ret = xnu_set_trace_bit(dbg, th);
    if (!ret) {
        eprintf("xnu_step modificy_trace_bit error\n");
        return false;
    }
    th->stepping = true;
    task_resume(task);
    return ret;
}

References dbg, eprintf, rz_debug_t::pid, pid_to_task(), rz_xnu_get_cur_thread(), rz_xnu_get_thread(), _xnu_thread::stepping, rz_debug_t::tid, and xnu_set_trace_bit().

xnu_stop()

int xnu_stop	(	RzDebug *	dbg,
		int	pid
	)

Definition at line 194 of file xnu_debug.c.

                                    {
    task_t task = pid_to_task(pid);
    if (!task) {
        return false;
    }
 
    int suspend_count = task_suspend_count(task);
    if (suspend_count == -1) {
        return false;
    }
    if (suspend_count == 1) {
        // Hopefully _we_ suspended it.
        return true;
    }
    if (suspend_count > 1) {
        // This is unexpected.
        return false;
    }
 
    kern_return_t kr = task_suspend(task);
    if (kr != KERN_SUCCESS) {
        eprintf("failed to suspend task\n");
        return false;
    }
 
    suspend_count = task_suspend_count(task);
    if (suspend_count != 1) {
        // This is unexpected.
        return false;
    }
    return true;
}

References eprintf, pid, pid_to_task(), and task_suspend_count().

Referenced by xnu_attach().

xnu_thread_list()

RzList* xnu_thread_list	(	RzDebug *	dbg,
		int	pid,
		RzList *	list
	)

Definition at line 453 of file xnu_debug.c.

                                                             {
#if __arm__ || __arm64__ || __aarch_64__
#define CPU_PC (dbg->bits == RZ_SYS_BITS_64) ? state.ts_64.__pc : state.ts_32.__pc
#elif __POWERPC__
#define CPU_PC state.srr0
#elif __x86_64__ || __i386__
#define CPU_PC (dbg->bits == RZ_SYS_BITS_64) ? state.uts.ts64.__rip : state.uts.ts32.__eip
#endif
    RzListIter *iter;
    xnu_thread_t *thread;
    RZ_REG_T state;
    rz_xnu_update_thread_list(dbg);
    list->free = (RzListFree)&rz_debug_pid_free;
    rz_list_foreach (dbg->threads, iter, thread) {
        if (!rz_xnu_thread_get_gpr(dbg, thread)) {
            eprintf("Failed to get gpr registers xnu_thread_list\n");
            continue;
        }
        thread->state_size = sizeof(thread->gpr);
        memcpy(&state, &thread->gpr, sizeof(RZ_REG_T));
        rz_list_append(list, rz_debug_pid_new(thread->name, thread->port, getuid(), 's', CPU_PC));
    }
    return list;
}

References dbg, eprintf, _xnu_thread::gpr, list(), memcpy(), _xnu_thread::name, _xnu_thread::port, rz_debug_pid_free(), rz_debug_pid_new(), rz_list_append(), rz_xnu_thread_get_gpr(), rz_xnu_update_thread_list(), _xnu_thread::state_size, and rz_debug_t::threads.

Referenced by xnu_generate_corefile().

xnu_wait()

int xnu_wait	(	RzDebug *	dbg,
		int	pid
	)

Definition at line 108 of file xnu_debug.c.

                                    {
    return xnu_wait_for_exception(dbg, pid, 0, false);
}

References dbg, pid, and xnu_wait_for_exception().