[apple/system_cmds.git] / lsmp.tproj / task_details.c

/*
 * Copyright (c) 2002-2016 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 *
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <unistd.h>
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <mach_debug/ipc_info.h>
#include <stdio.h>
#include <stdlib.h>
#include <libproc.h>
#include <assert.h>

#include "common.h"

#pragma mark kobject to name hash table implementation

#if (K2N_TABLE_SIZE & (K2N_TABLE_SIZE - 1) != 0)
#error K2N_TABLE_SIZE must be a power of two
#endif

#define K2N_TABLE_MASK	(K2N_TABLE_SIZE - 1)

static uint32_t k2n_hash(natural_t kobject) {
    return (uint64_t)kobject * 2654435761 >> 32;
}

struct k2n_table_node *k2n_table_lookup_next(struct k2n_table_node *node, natural_t kobject) {
    while (node) {
        if (kobject == node->kobject)
            return node;

        node = node->next;
    }

    return NULL;
}

struct k2n_table_node *k2n_table_lookup(struct k2n_table_node **table, natural_t kobject) {
    uint32_t hv;
    struct k2n_table_node *node;

    hv = k2n_hash(kobject);

    node = table[hv & K2N_TABLE_MASK];

    return k2n_table_lookup_next(node, kobject);
}

static void k2n_table_enter(struct k2n_table_node **table, natural_t kobject, ipc_info_name_t *info_name) {
    uint32_t hv;
    struct k2n_table_node *node;

    hv = k2n_hash(kobject);

    node = malloc(sizeof (struct k2n_table_node));
    assert(node);

    node->kobject = kobject;
    node->info_name = info_name;

    node->next = table[hv & K2N_TABLE_MASK];
    table[hv & K2N_TABLE_MASK] = node;
}

#pragma mark -

static my_per_task_info_t NOT_FOUND_TASK_INFO = {
    .task = NULL,
    .task_kobject = NULL,
    .pid = -1,
    .info = {0,0,0,0,0,0},
    .table = NULL,
    .tableCount = 0,
    .tree = NULL,
    .treeCount = 0,
    .valid = FALSE,
    .k2ntable = {0},
    .processName = "Unknown",
    .exceptionInfo = {0},
    .threadInfos = NULL,
    .threadCount = 0,
    .threadExceptionInfos = NULL
};

char * get_task_name_by_pid(pid_t pid);

static void proc_pid_to_name(int pid, char *pname){
    if (0 == proc_name(pid, pname, PROC_NAME_LEN)) {
        strcpy(pname, "Unknown Process");
    }
}

static my_per_task_info_t *global_taskinfo = NULL;
static uint32_t global_taskcount = 0;

my_per_task_info_t * allocate_taskinfo_memory(uint32_t taskCount)
{
    my_per_task_info_t * retval = malloc(taskCount * sizeof(my_per_task_info_t));
    if (retval) {
        bzero((void *)retval, taskCount * sizeof(my_per_task_info_t));
    }
    global_taskcount = taskCount;
    global_taskinfo = retval;
    return retval;
}

void deallocate_taskinfo_memory(my_per_task_info_t *data){
    if (data) {
        free(data);
        global_taskinfo = NULL;
        global_taskcount = 0;
    }
}

kern_return_t collect_per_task_info(my_per_task_info_t *taskinfo, task_t target_task)
{
    int i;
    kern_return_t ret = KERN_SUCCESS;
    unsigned int kotype = 0;
    vm_offset_t kobject = (vm_offset_t)0;

    taskinfo->task = target_task;
    pid_for_task(target_task, &taskinfo->pid);

    ret = task_get_exception_ports(taskinfo->task, EXC_MASK_ALL, taskinfo->exceptionInfo.masks, &taskinfo->exceptionInfo.count, taskinfo->exceptionInfo.ports, taskinfo->exceptionInfo.behaviors, taskinfo->exceptionInfo.flavors);

    if (ret != KERN_SUCCESS) {
        fprintf(stderr, "task_get_exception_ports() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
        taskinfo->pid = 0;
    }

    /* collect threads port as well */
    taskinfo->threadCount = 0;
    thread_act_array_t threadPorts;
    ret = task_threads(taskinfo->task, &threadPorts, &taskinfo->threadCount);

    if (ret != KERN_SUCCESS) {
        fprintf(stderr, "task_threads() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
        taskinfo->threadCount = 0;
    } else {
        /* collect the thread information */
        taskinfo->threadInfos = (struct my_per_thread_info *)malloc(sizeof(struct my_per_thread_info) * taskinfo->threadCount);
        bzero(taskinfo->threadInfos, sizeof(struct my_per_thread_info) * taskinfo->threadCount);

        /* now collect exception ports for each of those threads as well */
        taskinfo->threadExceptionInfos = (struct exc_port_info *) malloc(sizeof(struct exc_port_info) * taskinfo->threadCount);
        boolean_t found_exception = false;
        for (int i = 0; i < taskinfo->threadCount; i++) {
            unsigned th_kobject = 0;
            unsigned th_kotype = 0;
            ipc_voucher_t th_voucher = IPC_VOUCHER_NULL;
            thread_identifier_info_data_t th_info;
            mach_msg_type_number_t th_info_count = THREAD_IDENTIFIER_INFO_COUNT;
            struct exc_port_info *excinfo = &(taskinfo->threadExceptionInfos[i]);

            ret = thread_get_exception_ports(threadPorts[i], EXC_MASK_ALL, excinfo->masks, &excinfo->count, excinfo->ports, excinfo->behaviors, excinfo->flavors);
            if (ret != KERN_SUCCESS){
                fprintf(stderr, "thread_get_exception_ports() failed: pid: %d thread: %d error %s\n", taskinfo->pid, threadPorts[i], mach_error_string(ret));
            }

            if (excinfo->count != 0) {
                found_exception = true;
            }

            taskinfo->threadInfos[i].thread = threadPorts[i];

            if (KERN_SUCCESS == mach_port_kernel_object(mach_task_self(), threadPorts[i], &th_kotype, &th_kobject)) {
                taskinfo->threadInfos[i].th_kobject = th_kobject;
                if (KERN_SUCCESS == thread_info(threadPorts[i], THREAD_IDENTIFIER_INFO, (thread_info_t)&th_info, &th_info_count)) {
                    taskinfo->threadInfos[i].th_id = th_info.thread_id;
                }
            }

            if (KERN_SUCCESS == thread_get_mach_voucher(threadPorts[i], 0, &th_voucher) && th_voucher != IPC_VOUCHER_NULL) {
                char *detail = copy_voucher_detail(mach_task_self(), th_voucher);
                taskinfo->threadInfos[i].voucher_detail = strndup(detail, VOUCHER_DETAIL_MAXLEN);
                free(detail);

                mach_port_deallocate(mach_task_self(), th_voucher);
            }

            mach_port_deallocate(mach_task_self(), threadPorts[i]);
            threadPorts[i] = MACH_PORT_NULL;
        }

        if (found_exception == false) {
            free(taskinfo->threadExceptionInfos);
            taskinfo->threadExceptionInfos = NULL;
        }

    }

    vm_deallocate(mach_task_self(), threadPorts, taskinfo->threadCount * sizeof(thread_act_t));
    threadPorts = NULL;

    ret = mach_port_space_info(target_task, &taskinfo->info, &taskinfo->table, &taskinfo->tableCount, &taskinfo->tree, &taskinfo->treeCount);

    if (ret != KERN_SUCCESS) {
        fprintf(stderr, "mach_port_space_info() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
        taskinfo->pid = 0;
        return ret;
    }

    bzero(taskinfo->k2ntable, K2N_TABLE_SIZE * sizeof (struct k2n_table_node *));
    for (i = 0; i < taskinfo->tableCount; i++) {
        k2n_table_enter(taskinfo->k2ntable, taskinfo->table[i].iin_object, &taskinfo->table[i]);
    }

    proc_pid_to_name(taskinfo->pid, taskinfo->processName);

    ret = mach_port_kernel_object(mach_task_self(), taskinfo->task, &kotype, (unsigned *)&kobject);

    if (ret == KERN_SUCCESS && kotype == IKOT_TASK) {
        taskinfo->task_kobject = kobject;
        taskinfo->valid = TRUE;
    }

    return ret;
}

void get_exc_behavior_string(exception_behavior_t b, char *out_string, size_t len)
{
    out_string[0]='\0';

    if (b & MACH_EXCEPTION_CODES)
        strncat(out_string, "MACH +", len);
    switch (b & ~MACH_EXCEPTION_CODES) {
        case EXCEPTION_DEFAULT:
            strncat(out_string, " DEFAULT", len);
            break;
        case EXCEPTION_STATE:
            strncat(out_string, " STATE", len);
            break;
        case EXCEPTION_STATE_IDENTITY:
            strncat(out_string, " IDENTITY", len);
            break;
        default:
            strncat(out_string, " UNKNOWN", len);
    }
}

void get_exc_mask_string(exception_mask_t m, char *out_string, size_t len)
{
    out_string[0]='\0';

    if (m & (1<<EXC_BAD_ACCESS))
        strncat(out_string, " BAD_ACCESS", len);
    if (m & (1<<EXC_BAD_INSTRUCTION))
        strncat(out_string," BAD_INSTRUCTION", len);
    if (m & (1<<EXC_ARITHMETIC))
        strncat(out_string," ARITHMETIC", len);
    if (m & (1<<EXC_EMULATION))
        strncat(out_string," EMULATION", len);
    if (m & (1<<EXC_SOFTWARE))
        strncat(out_string," SOFTWARE", len);
    if (m & (1<<EXC_BREAKPOINT))
        strncat(out_string," BREAKPOINT", len);
    if (m & (1<<EXC_SYSCALL))
        strncat(out_string," SYSCALL", len);
    if (m & (1<<EXC_MACH_SYSCALL))
        strncat(out_string," MACH_SYSCALL", len);
    if (m & (1<<EXC_RPC_ALERT))
        strncat(out_string," RPC_ALERT", len);
    if (m & (1<<EXC_CRASH))
        strncat(out_string," CRASH", len);
    if (m & (1<<EXC_RESOURCE))
        strncat(out_string," RESOURCE", len);
    if (m & (1<<EXC_GUARD))
        strncat(out_string," GUARD", len);
}

kern_return_t print_task_exception_info(my_per_task_info_t *taskinfo)
{

    char behavior_string[30];
    char mask_string[200];

    boolean_t header_required = TRUE;
    for (int i = 0; i < taskinfo->exceptionInfo.count; i++) {
        if (taskinfo->exceptionInfo.ports[i] != MACH_PORT_NULL) {
            if (header_required) {

                printf("    exc_port    flavor <behaviors>           mask   \n");
                header_required = FALSE;
            }
            get_exc_behavior_string(taskinfo->exceptionInfo.behaviors[i], behavior_string, sizeof(behavior_string));
            get_exc_mask_string(taskinfo->exceptionInfo.masks[i], mask_string, 200);
            printf("    0x%08x  0x%03x  <%s>           %s  \n" , taskinfo->exceptionInfo.ports[i], taskinfo->exceptionInfo.flavors[i], behavior_string, mask_string);
        }

    }

    return KERN_SUCCESS;
}


kern_return_t print_task_threads_special_ports(my_per_task_info_t *taskinfo)
{
    kern_return_t kret = KERN_SUCCESS;
    mach_msg_type_number_t threadcount = taskinfo->threadCount;
    boolean_t header_required = TRUE;
    boolean_t newline_required = TRUE;
    struct my_per_thread_info * info = NULL;

    for (int i = 0; i < threadcount; i++) {
        info = &taskinfo->threadInfos[i];
        if (header_required) {
            printf("Thread_KObject  Thread-ID     Port Description.");
            header_required = FALSE;
        }

        if (newline_required) {
            printf("\n");
        }
        newline_required = TRUE;

        if (info->th_kobject != 0) {
            /* TODO: Should print tid and stuff */
            printf("0x%08x       ", info->th_kobject);
            printf("0x%llx  ", info->th_id);
        }

        if (info->voucher_detail != NULL) {
            printf("%s\n", info->voucher_detail);
        }

        /* print the thread exception ports also */
        if (taskinfo->threadExceptionInfos != NULL)
        {

            struct exc_port_info *excinfo = &taskinfo->threadExceptionInfos[i];
            char behavior_string[30];
            char mask_string[200];

            if (excinfo->count > 0) {
                boolean_t header_required = TRUE;
                for (int i = 0; i < excinfo->count; i++) {
                    if (excinfo->ports[i] != MACH_PORT_NULL) {
                        if (header_required) {
                            printf("\n    exc_port    flavor <behaviors>           mask   -> name    owner\n");
                            header_required = FALSE;
                        }
                        get_exc_behavior_string(excinfo->behaviors[i], behavior_string, sizeof(behavior_string));
                        get_exc_mask_string(excinfo->masks[i], mask_string, sizeof(mask_string));
                        printf("    0x%08x  0x%03x  <%s>           %s  " , excinfo->ports[i], excinfo->flavors[i], behavior_string, mask_string);

                        ipc_info_name_t actual_sendinfo;
                        if (KERN_SUCCESS == get_ipc_info_from_lsmp_spaceinfo(excinfo->ports[i], &actual_sendinfo)) {
                            my_per_task_info_t *recv_holder_taskinfo;
                            mach_port_name_t recv_name = MACH_PORT_NULL;
                            if (KERN_SUCCESS == get_taskinfo_of_receiver_by_send_right(&actual_sendinfo, &recv_holder_taskinfo, &recv_name)) {
                                printf("   -> 0x%08x  0x%08x  (%d) %s\n",
                                       recv_name,
                                       actual_sendinfo.iin_object,
                                       recv_holder_taskinfo->pid,
                                       recv_holder_taskinfo->processName);
                            }

                        } else {
                            fprintf(stderr, "failed to find");
                        }

                        printf("\n");

                    }

                }
            }

        }

    }
    printf("\n");
    return kret;
}

char * get_task_name_by_pid(pid_t pid) {
    char * retval = "Unknown";
    for (int i = 0; i < global_taskcount; i++) {
        if (pid == global_taskinfo[i].pid) {
            return global_taskinfo[i].processName;
        }
    }
    return retval;
}

my_per_task_info_t * get_taskinfo_by_kobject(natural_t kobj) {
    my_per_task_info_t *retval = &NOT_FOUND_TASK_INFO;
    for (int j = 0; j < global_taskcount; j++) {
        if (global_taskinfo[j].task_kobject == kobj) {
            retval = &global_taskinfo[j];
            break;
        }
    }
    return retval;
}

kern_return_t get_taskinfo_of_receiver_by_send_right(ipc_info_name_t *sendright, my_per_task_info_t **out_taskinfo, mach_port_name_t *out_recv_info)
{
    *out_taskinfo = &NOT_FOUND_TASK_INFO;
    struct k2n_table_node *k2nnode;

    for (int j = 0; j < global_taskcount; j++) {
        if ((k2nnode = k2n_table_lookup(global_taskinfo[j].k2ntable, sendright->iin_object))) {
            assert(k2nnode->info_name->iin_object == sendright->iin_object);

            if (k2nnode->info_name->iin_type & MACH_PORT_TYPE_RECEIVE) {
                *out_taskinfo = &global_taskinfo[j];
                *out_recv_info = k2nnode->info_name->iin_name;
                return KERN_SUCCESS;
            }
        }
    }

    return KERN_FAILURE;
}

kern_return_t get_ipc_info_from_lsmp_spaceinfo(mach_port_t port_name, ipc_info_name_t *out_sendright){
    kern_return_t retval = KERN_FAILURE;
    bzero(out_sendright, sizeof(ipc_info_name_t));
    my_per_task_info_t *mytaskinfo = NULL;
    for (int i = global_taskcount - 1; i >= 0; i--){
        if (global_taskinfo[i].task == mach_task_self()){
            mytaskinfo = &global_taskinfo[i];
            break;
        }
    }
    if (mytaskinfo) {
        for (int k = 0; k < mytaskinfo->tableCount; k++) {
            if (port_name == mytaskinfo->table[k].iin_name){
                bcopy(&mytaskinfo->table[k], out_sendright, sizeof(ipc_info_name_t));
                retval = KERN_SUCCESS;
                break;
            }
        }
    }
    return retval;

}
Commit	Line	Data
1a7e3f61	1	/*
cf37c299	2	* Copyright (c) 2002-2016 Apple Inc. All rights reserved.
1a7e3f61 A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22
	23	#include <unistd.h>
	24	#include <mach/mach.h>
	25	#include <mach/mach_error.h>
	26	#include <mach_debug/ipc_info.h>
	27	#include <stdio.h>
	28	#include <stdlib.h>
	29	#include <libproc.h>
cf37c299	30	#include <assert.h>
1a7e3f61 A	31
	32	#include "common.h"
	33
cf37c299 A	34	#pragma mark kobject to name hash table implementation
	35
	36	#if (K2N_TABLE_SIZE & (K2N_TABLE_SIZE - 1) != 0)
	37	#error K2N_TABLE_SIZE must be a power of two
	38	#endif
	39
	40	#define K2N_TABLE_MASK (K2N_TABLE_SIZE - 1)
	41
	42	static uint32_t k2n_hash(natural_t kobject) {
	43	return (uint64_t)kobject * 2654435761 >> 32;
	44	}
	45
	46	struct k2n_table_node k2n_table_lookup_next(struct k2n_table_node node, natural_t kobject) {
	47	while (node) {
	48	if (kobject == node->kobject)
	49	return node;
	50
	51	node = node->next;
	52	}
	53
	54	return NULL;
	55	}
	56
	57	struct k2n_table_node k2n_table_lookup(struct k2n_table_node *table, natural_t kobject) {
	58	uint32_t hv;
	59	struct k2n_table_node *node;
	60
	61	hv = k2n_hash(kobject);
	62
	63	node = table[hv & K2N_TABLE_MASK];
	64
	65	return k2n_table_lookup_next(node, kobject);
	66	}
	67
	68	static void k2n_table_enter(struct k2n_table_node *table, natural_t kobject, ipc_info_name_t info_name) {
	69	uint32_t hv;
	70	struct k2n_table_node *node;
	71
	72	hv = k2n_hash(kobject);
	73
	74	node = malloc(sizeof (struct k2n_table_node));
	75	assert(node);
	76
	77	node->kobject = kobject;
	78	node->info_name = info_name;
	79
	80	node->next = table[hv & K2N_TABLE_MASK];
	81	table[hv & K2N_TABLE_MASK] = node;
	82	}
	83
	84	#pragma mark -
	85
1a7e3f61 A	86	static my_per_task_info_t NOT_FOUND_TASK_INFO = {
	87	.task = NULL,
	88	.task_kobject = NULL,
	89	.pid = -1,
	90	.info = {0,0,0,0,0,0},
	91	.table = NULL,
	92	.tableCount = 0,
	93	.tree = NULL,
	94	.treeCount = 0,
	95	.valid = FALSE,
cf37c299	96	.k2ntable = {0},
1a7e3f61	97	.processName = "Unknown",
ac27e6b4 A	98	.exceptionInfo = {0},
	99	.threadInfos = NULL,
	100	.threadCount = 0,
	101	.threadExceptionInfos = NULL
1a7e3f61 A	102	};
	103
	104	char * get_task_name_by_pid(pid_t pid);
	105
	106	static void proc_pid_to_name(int pid, char *pname){
	107	if (0 == proc_name(pid, pname, PROC_NAME_LEN)) {
	108	strcpy(pname, "Unknown Process");
	109	}
	110	}
	111
	112	static my_per_task_info_t *global_taskinfo = NULL;
	113	static uint32_t global_taskcount = 0;
	114
	115	my_per_task_info_t * allocate_taskinfo_memory(uint32_t taskCount)
	116	{
	117	my_per_task_info_t * retval = malloc(taskCount * sizeof(my_per_task_info_t));
	118	if (retval) {
	119	bzero((void )retval, taskCount sizeof(my_per_task_info_t));
	120	}
	121	global_taskcount = taskCount;
	122	global_taskinfo = retval;
	123	return retval;
	124	}
	125
	126	void deallocate_taskinfo_memory(my_per_task_info_t *data){
	127	if (data) {
	128	free(data);
	129	global_taskinfo = NULL;
	130	global_taskcount = 0;
	131	}
	132	}
	133
	134	kern_return_t collect_per_task_info(my_per_task_info_t *taskinfo, task_t target_task)
	135	{
cf37c299	136	int i;
1a7e3f61 A	137	kern_return_t ret = KERN_SUCCESS;
	138	unsigned int kotype = 0;
	139	vm_offset_t kobject = (vm_offset_t)0;
cf37c299	140
1a7e3f61 A	141	taskinfo->task = target_task;
1a7e3f61 A	142	pid_for_task(target_task, &taskinfo->pid);
ac27e6b4 A	143
	144	ret = task_get_exception_ports(taskinfo->task, EXC_MASK_ALL, taskinfo->exceptionInfo.masks, &taskinfo->exceptionInfo.count, taskinfo->exceptionInfo.ports, taskinfo->exceptionInfo.behaviors, taskinfo->exceptionInfo.flavors);
	145
	146	if (ret != KERN_SUCCESS) {
	147	fprintf(stderr, "task_get_exception_ports() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
	148	taskinfo->pid = 0;
	149	}
	150
	151	/* collect threads port as well */
	152	taskinfo->threadCount = 0;
	153	thread_act_array_t threadPorts;
	154	ret = task_threads(taskinfo->task, &threadPorts, &taskinfo->threadCount);
	155
	156	if (ret != KERN_SUCCESS) {
	157	fprintf(stderr, "task_threads() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
	158	taskinfo->threadCount = 0;
	159	} else {
	160	/* collect the thread information */
	161	taskinfo->threadInfos = (struct my_per_thread_info )malloc(sizeof(struct my_per_thread_info) taskinfo->threadCount);
	162	bzero(taskinfo->threadInfos, sizeof(struct my_per_thread_info) * taskinfo->threadCount);
	163
	164	/* now collect exception ports for each of those threads as well */
	165	taskinfo->threadExceptionInfos = (struct exc_port_info ) malloc(sizeof(struct exc_port_info) taskinfo->threadCount);
	166	boolean_t found_exception = false;
	167	for (int i = 0; i < taskinfo->threadCount; i++) {
	168	unsigned th_kobject = 0;
	169	unsigned th_kotype = 0;
	170	ipc_voucher_t th_voucher = IPC_VOUCHER_NULL;
	171	thread_identifier_info_data_t th_info;
	172	mach_msg_type_number_t th_info_count = THREAD_IDENTIFIER_INFO_COUNT;
	173	struct exc_port_info *excinfo = &(taskinfo->threadExceptionInfos[i]);
	174
	175	ret = thread_get_exception_ports(threadPorts[i], EXC_MASK_ALL, excinfo->masks, &excinfo->count, excinfo->ports, excinfo->behaviors, excinfo->flavors);
	176	if (ret != KERN_SUCCESS){
	177	fprintf(stderr, "thread_get_exception_ports() failed: pid: %d thread: %d error %s\n", taskinfo->pid, threadPorts[i], mach_error_string(ret));
	178	}
	179
	180	if (excinfo->count != 0) {
	181	found_exception = true;
	182	}
	183
	184	taskinfo->threadInfos[i].thread = threadPorts[i];
	185
	186	if (KERN_SUCCESS == mach_port_kernel_object(mach_task_self(), threadPorts[i], &th_kotype, &th_kobject)) {
	187	taskinfo->threadInfos[i].th_kobject = th_kobject;
	188	if (KERN_SUCCESS == thread_info(threadPorts[i], THREAD_IDENTIFIER_INFO, (thread_info_t)&th_info, &th_info_count)) {
	189	taskinfo->threadInfos[i].th_id = th_info.thread_id;
	190	}
	191	}
	192
	193	if (KERN_SUCCESS == thread_get_mach_voucher(threadPorts[i], 0, &th_voucher) && th_voucher != IPC_VOUCHER_NULL) {
	194	char *detail = copy_voucher_detail(mach_task_self(), th_voucher);
	195	taskinfo->threadInfos[i].voucher_detail = strndup(detail, VOUCHER_DETAIL_MAXLEN);
	196	free(detail);
	197
	198	mach_port_deallocate(mach_task_self(), th_voucher);
	199	}
	200
	201	mach_port_deallocate(mach_task_self(), threadPorts[i]);
	202	threadPorts[i] = MACH_PORT_NULL;
	203	}
	204
	205	if (found_exception == false) {
	206	free(taskinfo->threadExceptionInfos);
207	taskinfo->threadExceptionInfos = NULL;
208	}
209
210	}
211
212	vm_deallocate(mach_task_self(), threadPorts, taskinfo->threadCount * sizeof(thread_act_t));
213	threadPorts = NULL;
cf37c299	214
ac27e6b4	215	ret = mach_port_space_info(target_task, &taskinfo->info, &taskinfo->table, &taskinfo->tableCount, &taskinfo->tree, &taskinfo->treeCount);
cf37c299	216
1a7e3f61 A	217	if (ret != KERN_SUCCESS) {
	218	fprintf(stderr, "mach_port_space_info() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
	219	taskinfo->pid = 0;
	220	return ret;
	221	}
cf37c299 A	222
	223	bzero(taskinfo->k2ntable, K2N_TABLE_SIZE * sizeof (struct k2n_table_node *));
	224	for (i = 0; i < taskinfo->tableCount; i++) {
	225	k2n_table_enter(taskinfo->k2ntable, taskinfo->table[i].iin_object, &taskinfo->table[i]);
	226	}
	227
1a7e3f61	228	proc_pid_to_name(taskinfo->pid, taskinfo->processName);
ac27e6b4	229
1a7e3f61	230	ret = mach_port_kernel_object(mach_task_self(), taskinfo->task, &kotype, (unsigned *)&kobject);
cf37c299	231
1a7e3f61 A	232	if (ret == KERN_SUCCESS && kotype == IKOT_TASK) {
	233	taskinfo->task_kobject = kobject;
	234	taskinfo->valid = TRUE;
	235	}
cf37c299	236
1a7e3f61 A	237	return ret;
	238	}
	239
1a7e3f61 A	240	void get_exc_behavior_string(exception_behavior_t b, char *out_string, size_t len)
	241	{
	242	out_string[0]='\0';
cf37c299	243
1a7e3f61 A	244	if (b & MACH_EXCEPTION_CODES)
	245	strncat(out_string, "MACH +", len);
	246	switch (b & ~MACH_EXCEPTION_CODES) {
	247	case EXCEPTION_DEFAULT:
	248	strncat(out_string, " DEFAULT", len);
	249	break;
	250	case EXCEPTION_STATE:
	251	strncat(out_string, " STATE", len);
	252	break;
	253	case EXCEPTION_STATE_IDENTITY:
	254	strncat(out_string, " IDENTITY", len);
	255	break;
	256	default:
	257	strncat(out_string, " UNKNOWN", len);
	258	}
	259	}
	260
	261	void get_exc_mask_string(exception_mask_t m, char *out_string, size_t len)
	262	{
	263	out_string[0]='\0';
cf37c299	264
1a7e3f61 A	265	if (m & (1<<EXC_BAD_ACCESS))
	266	strncat(out_string, " BAD_ACCESS", len);
	267	if (m & (1<<EXC_BAD_INSTRUCTION))
	268	strncat(out_string," BAD_INSTRUCTION", len);
	269	if (m & (1<<EXC_ARITHMETIC))
	270	strncat(out_string," ARITHMETIC", len);
	271	if (m & (1<<EXC_EMULATION))
	272	strncat(out_string," EMULATION", len);
	273	if (m & (1<<EXC_SOFTWARE))
	274	strncat(out_string," SOFTWARE", len);
	275	if (m & (1<<EXC_BREAKPOINT))
	276	strncat(out_string," BREAKPOINT", len);
	277	if (m & (1<<EXC_SYSCALL))
	278	strncat(out_string," SYSCALL", len);
	279	if (m & (1<<EXC_MACH_SYSCALL))
	280	strncat(out_string," MACH_SYSCALL", len);
	281	if (m & (1<<EXC_RPC_ALERT))
	282	strncat(out_string," RPC_ALERT", len);
	283	if (m & (1<<EXC_CRASH))
	284	strncat(out_string," CRASH", len);
	285	if (m & (1<<EXC_RESOURCE))
	286	strncat(out_string," RESOURCE", len);
	287	if (m & (1<<EXC_GUARD))
	288	strncat(out_string," GUARD", len);
1a7e3f61 A	289	}
	290
	291	kern_return_t print_task_exception_info(my_per_task_info_t *taskinfo)
	292	{
ac27e6b4	293
1a7e3f61 A	294	char behavior_string[30];
1a7e3f61 A	295	char mask_string[200];
ac27e6b4	296
1a7e3f61	297	boolean_t header_required = TRUE;
ac27e6b4 A	298	for (int i = 0; i < taskinfo->exceptionInfo.count; i++) {
ac27e6b4 A	299	if (taskinfo->exceptionInfo.ports[i] != MACH_PORT_NULL) {
1a7e3f61	300	if (header_required) {
ac27e6b4 A	301
ac27e6b4 A	302	printf(" exc_port flavor <behaviors> mask \n");
1a7e3f61 A	303	header_required = FALSE;
1a7e3f61 A	304	}
ac27e6b4 A	305	get_exc_behavior_string(taskinfo->exceptionInfo.behaviors[i], behavior_string, sizeof(behavior_string));
	306	get_exc_mask_string(taskinfo->exceptionInfo.masks[i], mask_string, 200);
	307	printf(" 0x%08x 0x%03x <%s> %s \n" , taskinfo->exceptionInfo.ports[i], taskinfo->exceptionInfo.flavors[i], behavior_string, mask_string);
1a7e3f61	308	}
cf37c299	309
1a7e3f61	310	}
cf37c299	311
ac27e6b4	312	return KERN_SUCCESS;
1a7e3f61 A	313	}
	314
	315
	316	kern_return_t print_task_threads_special_ports(my_per_task_info_t *taskinfo)
	317	{
	318	kern_return_t kret = KERN_SUCCESS;
ac27e6b4	319	mach_msg_type_number_t threadcount = taskinfo->threadCount;
1a7e3f61 A	320	boolean_t header_required = TRUE;
1a7e3f61 A	321	boolean_t newline_required = TRUE;
ac27e6b4	322	struct my_per_thread_info * info = NULL;
cf37c299	323
1a7e3f61	324	for (int i = 0; i < threadcount; i++) {
ac27e6b4	325	info = &taskinfo->threadInfos[i];
1a7e3f61	326	if (header_required) {
ac27e6b4	327	printf("Thread_KObject Thread-ID Port Description.");
1a7e3f61 A	328	header_required = FALSE;
1a7e3f61 A	329	}
cf37c299	330
1a7e3f61 A	331	if (newline_required) {
	332	printf("\n");
	333	}
	334	newline_required = TRUE;
cf37c299	335
ac27e6b4	336	if (info->th_kobject != 0) {
1a7e3f61	337	/* TODO: Should print tid and stuff */
ac27e6b4 A	338	printf("0x%08x ", info->th_kobject);
ac27e6b4 A	339	printf("0x%llx ", info->th_id);
1a7e3f61 A	340	}
1a7e3f61 A	341
ac27e6b4 A	342	if (info->voucher_detail != NULL) {
	343	printf("%s\n", info->voucher_detail);
	344	}
	345
	346	/* print the thread exception ports also */
	347	if (taskinfo->threadExceptionInfos != NULL)
	348	{
	349
	350	struct exc_port_info *excinfo = &taskinfo->threadExceptionInfos[i];
	351	char behavior_string[30];
	352	char mask_string[200];
	353
	354	if (excinfo->count > 0) {
	355	boolean_t header_required = TRUE;
	356	for (int i = 0; i < excinfo->count; i++) {
	357	if (excinfo->ports[i] != MACH_PORT_NULL) {
	358	if (header_required) {
	359	printf("\n exc_port flavor <behaviors> mask -> name owner\n");
	360	header_required = FALSE;
	361	}
	362	get_exc_behavior_string(excinfo->behaviors[i], behavior_string, sizeof(behavior_string));
	363	get_exc_mask_string(excinfo->masks[i], mask_string, sizeof(mask_string));
	364	printf(" 0x%08x 0x%03x <%s> %s " , excinfo->ports[i], excinfo->flavors[i], behavior_string, mask_string);
	365
	366	ipc_info_name_t actual_sendinfo;
	367	if (KERN_SUCCESS == get_ipc_info_from_lsmp_spaceinfo(excinfo->ports[i], &actual_sendinfo)) {
	368	my_per_task_info_t *recv_holder_taskinfo;
	369	mach_port_name_t recv_name = MACH_PORT_NULL;
	370	if (KERN_SUCCESS == get_taskinfo_of_receiver_by_send_right(&actual_sendinfo, &recv_holder_taskinfo, &recv_name)) {
	371	printf(" -> 0x%08x 0x%08x (%d) %s\n",
	372	recv_name,
	373	actual_sendinfo.iin_object,
	374	recv_holder_taskinfo->pid,
	375	recv_holder_taskinfo->processName);
	376	}
	377
	378	} else {
	379	fprintf(stderr, "failed to find");
	380	}
	381
	382	printf("\n");
	383
	384	}
	385
	386	}
	387	}
	388
1a7e3f61	389	}
ac27e6b4	390
1a7e3f61	391	}
9726c137	392	printf("\n");
1a7e3f61 A	393	return kret;
	394	}
	395
	396	char * get_task_name_by_pid(pid_t pid) {
	397	char * retval = "Unknown";
	398	for (int i = 0; i < global_taskcount; i++) {
	399	if (pid == global_taskinfo[i].pid) {
	400	return global_taskinfo[i].processName;
	401	}
	402	}
	403	return retval;
	404	}
	405
	406	my_per_task_info_t * get_taskinfo_by_kobject(natural_t kobj) {
	407	my_per_task_info_t *retval = &NOT_FOUND_TASK_INFO;
	408	for (int j = 0; j < global_taskcount; j++) {
	409	if (global_taskinfo[j].task_kobject == kobj) {
	410	retval = &global_taskinfo[j];
	411	break;
	412	}
	413	}
	414	return retval;
	415	}
	416
	417	kern_return_t get_taskinfo_of_receiver_by_send_right(ipc_info_name_t sendright, my_per_task_info_t out_taskinfo, mach_port_name_t out_recv_info)
	418	{
1a7e3f61	419	*out_taskinfo = &NOT_FOUND_TASK_INFO;
cf37c299 A	420	struct k2n_table_node *k2nnode;
	421
	422	for (int j = 0; j < global_taskcount; j++) {
	423	if ((k2nnode = k2n_table_lookup(global_taskinfo[j].k2ntable, sendright->iin_object))) {
	424	assert(k2nnode->info_name->iin_object == sendright->iin_object);
	425
	426	if (k2nnode->info_name->iin_type & MACH_PORT_TYPE_RECEIVE) {
1a7e3f61	427	*out_taskinfo = &global_taskinfo[j];
cf37c299 A	428	*out_recv_info = k2nnode->info_name->iin_name;
cf37c299 A	429	return KERN_SUCCESS;
1a7e3f61 A	430	}
	431	}
	432	}
cf37c299 A	433
cf37c299 A	434	return KERN_FAILURE;
1a7e3f61 A	435	}
1a7e3f61 A	436
ac27e6b4 A	437	kern_return_t get_ipc_info_from_lsmp_spaceinfo(mach_port_t port_name, ipc_info_name_t *out_sendright){
	438	kern_return_t retval = KERN_FAILURE;
	439	bzero(out_sendright, sizeof(ipc_info_name_t));
	440	my_per_task_info_t *mytaskinfo = NULL;
	441	for (int i = global_taskcount - 1; i >= 0; i--){
	442	if (global_taskinfo[i].task == mach_task_self()){
	443	mytaskinfo = &global_taskinfo[i];
	444	break;
	445	}
	446	}
	447	if (mytaskinfo) {
	448	for (int k = 0; k < mytaskinfo->tableCount; k++) {
	449	if (port_name == mytaskinfo->table[k].iin_name){
	450	bcopy(&mytaskinfo->table[k], out_sendright, sizeof(ipc_info_name_t));
	451	retval = KERN_SUCCESS;
	452	break;
	453	}
	454	}
	455	}
	456	return retval;
	457
	458	}