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

/*
 * Copyright (c) 2002-20014 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 "common.h"

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,
    .processName = "Unknown",
};

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)
{
    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 = 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;
    }
    
    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;
}

struct exc_port_info {
    mach_msg_type_number_t   count;
    mach_port_t      ports[EXC_TYPES_COUNT];
    exception_mask_t masks[EXC_TYPES_COUNT];
    exception_behavior_t behaviors[EXC_TYPES_COUNT];
    thread_state_flavor_t flavors[EXC_TYPES_COUNT];
};

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)
{
    kern_return_t kr = KERN_SUCCESS;
    exception_mask_t mask = EXC_MASK_ALL;
    struct exc_port_info excinfo;
    char behavior_string[30];
    char mask_string[200];
    
    kr = task_get_exception_ports(taskinfo->task, mask, excinfo.masks, &excinfo.count, excinfo.ports, excinfo.behaviors, excinfo.flavors);
    
    if (kr != KERN_SUCCESS) {
        fprintf(stderr, "Failed task_get_exception_ports task: %d pid: %d\n", taskinfo->task, taskinfo->pid);
        return kr;
    }
    boolean_t header_required = TRUE;
    for (int i = 0; i < excinfo.count; i++) {
        if (excinfo.ports[i] != MACH_PORT_NULL) {
            if (header_required) {
                printf("port        flavor <behaviors>           mask   \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, 200);
            printf("0x%08x  0x%03x  <%s> %s  \n" , excinfo.ports[i], excinfo.flavors[i], behavior_string, mask_string);
            mach_port_deallocate(mach_task_self(), excinfo.ports[i]);
        }
        
    }
    
    return kr;
}


kern_return_t print_task_threads_special_ports(my_per_task_info_t *taskinfo)
{
    kern_return_t kret = KERN_SUCCESS;
    thread_act_array_t threadlist;
    mach_msg_type_number_t threadcount=0;
    kret = task_threads(taskinfo->task, &threadlist, &threadcount);
    boolean_t header_required = TRUE;
    boolean_t newline_required = TRUE;
    unsigned th_kobject = 0;
    unsigned th_kotype = 0;
    
    for (int i = 0; i < threadcount; i++) {
        if (header_required) {
            printf("Threads             Thread-ID     Port Description.");
            header_required = FALSE;
        }
        
        if (newline_required) {
            printf("\n");
        }
        newline_required = TRUE;
        if (KERN_SUCCESS == mach_port_kernel_object(mach_task_self(), threadlist[i], &th_kotype, &th_kobject)) {
            /* TODO: Should print tid and stuff */
            thread_identifier_info_data_t th_info;
            mach_msg_type_number_t th_info_count = THREAD_IDENTIFIER_INFO_COUNT;
            printf("0x%08x ", th_kobject);
            if (KERN_SUCCESS == thread_info(threadlist[i], THREAD_IDENTIFIER_INFO, (thread_info_t)&th_info, &th_info_count)) {
                printf("0x%llx  ", th_info.thread_id);
            }
            else
                printf("                   ");
            
        }

        ipc_voucher_t th_voucher = IPC_VOUCHER_NULL;
        if (KERN_SUCCESS == thread_get_mach_voucher(threadlist[i], 0, &th_voucher) && th_voucher != IPC_VOUCHER_NULL) {
            show_voucher_detail(mach_task_self(), th_voucher);
            mach_port_deallocate(mach_task_self(), th_voucher);
            newline_required = FALSE;
        }
        mach_port_deallocate(mach_task_self(), threadlist[i]);
    }
    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)
{
    kern_return_t retval = KERN_FAILURE;
    boolean_t found = FALSE;
    *out_taskinfo = &NOT_FOUND_TASK_INFO;
 
    for (int j = 0; j < global_taskcount && !found; j++) {
        for (int k = 0; k < global_taskinfo[j].tableCount && !found; k++) {
            if ((global_taskinfo[j].table[k].iin_type & MACH_PORT_TYPE_RECEIVE) &&
                global_taskinfo[j].table[k].iin_object == sendright->iin_object ) {
                *out_taskinfo = &global_taskinfo[j];
                *out_recv_info = global_taskinfo[j].table[k].iin_name;
                found = TRUE;
                retval = KERN_SUCCESS;
            }
        }
    }
    return retval;
}
Commit	Line	Data
1a7e3f61 A	1	/*
	2	* Copyright (c) 2002-20014 Apple Inc. All rights reserved.
	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>
	30
	31	#include "common.h"
	32
	33	static my_per_task_info_t NOT_FOUND_TASK_INFO = {
	34	.task = NULL,
	35	.task_kobject = NULL,
	36	.pid = -1,
	37	.info = {0,0,0,0,0,0},
	38	.table = NULL,
	39	.tableCount = 0,
	40	.tree = NULL,
	41	.treeCount = 0,
	42	.valid = FALSE,
	43	.processName = "Unknown",
	44	};
	45
	46	char * get_task_name_by_pid(pid_t pid);
	47
	48	static void proc_pid_to_name(int pid, char *pname){
	49	if (0 == proc_name(pid, pname, PROC_NAME_LEN)) {
	50	strcpy(pname, "Unknown Process");
	51	}
	52	}
	53
	54	static my_per_task_info_t *global_taskinfo = NULL;
	55	static uint32_t global_taskcount = 0;
	56
	57	my_per_task_info_t * allocate_taskinfo_memory(uint32_t taskCount)
	58	{
	59	my_per_task_info_t * retval = malloc(taskCount * sizeof(my_per_task_info_t));
	60	if (retval) {
	61	bzero((void )retval, taskCount sizeof(my_per_task_info_t));
	62	}
	63	global_taskcount = taskCount;
	64	global_taskinfo = retval;
65	return retval;
66	}
67
68	void deallocate_taskinfo_memory(my_per_task_info_t *data){
69	if (data) {
70	free(data);
71	global_taskinfo = NULL;
72	global_taskcount = 0;
73	}
74	}
75
76	kern_return_t collect_per_task_info(my_per_task_info_t *taskinfo, task_t target_task)
77	{
78	kern_return_t ret = KERN_SUCCESS;
79	unsigned int kotype = 0;
80	vm_offset_t kobject = (vm_offset_t)0;
81
82	taskinfo->task = target_task;
83	pid_for_task(target_task, &taskinfo->pid);
84
85	ret = mach_port_space_info(target_task, &taskinfo->info,
86	&taskinfo->table, &taskinfo->tableCount,
87	&taskinfo->tree, &taskinfo->treeCount);
88
89	if (ret != KERN_SUCCESS) {
90	fprintf(stderr, "mach_port_space_info() failed: pid:%d error: %s\n",taskinfo->pid, mach_error_string(ret));
91	taskinfo->pid = 0;
92	return ret;
93	}
94
95	proc_pid_to_name(taskinfo->pid, taskinfo->processName);
96	ret = mach_port_kernel_object(mach_task_self(), taskinfo->task, &kotype, (unsigned *)&kobject);
97
98	if (ret == KERN_SUCCESS && kotype == IKOT_TASK) {
99	taskinfo->task_kobject = kobject;
100	taskinfo->valid = TRUE;
101	}
102
103	return ret;
104	}
105
106	struct exc_port_info {
107	mach_msg_type_number_t count;
108	mach_port_t ports[EXC_TYPES_COUNT];
109	exception_mask_t masks[EXC_TYPES_COUNT];
110	exception_behavior_t behaviors[EXC_TYPES_COUNT];
111	thread_state_flavor_t flavors[EXC_TYPES_COUNT];
112	};
113
114	void get_exc_behavior_string(exception_behavior_t b, char *out_string, size_t len)
115	{
116	out_string[0]='\0';
117
118	if (b & MACH_EXCEPTION_CODES)
119	strncat(out_string, "MACH +", len);
120	switch (b & ~MACH_EXCEPTION_CODES) {
121	case EXCEPTION_DEFAULT:
122	strncat(out_string, " DEFAULT", len);
123	break;
124	case EXCEPTION_STATE:
125	strncat(out_string, " STATE", len);
126	break;
127	case EXCEPTION_STATE_IDENTITY:
128	strncat(out_string, " IDENTITY", len);
129	break;
130	default:
131	strncat(out_string, " UNKNOWN", len);
132	}
133	}
134
135	void get_exc_mask_string(exception_mask_t m, char *out_string, size_t len)
136	{
137	out_string[0]='\0';
138
139	if (m & (1<<EXC_BAD_ACCESS))
140	strncat(out_string, " BAD_ACCESS", len);
141	if (m & (1<<EXC_BAD_INSTRUCTION))
142	strncat(out_string," BAD_INSTRUCTION", len);
143	if (m & (1<<EXC_ARITHMETIC))
144	strncat(out_string," ARITHMETIC", len);
145	if (m & (1<<EXC_EMULATION))
146	strncat(out_string," EMULATION", len);
147	if (m & (1<<EXC_SOFTWARE))
148	strncat(out_string," SOFTWARE", len);
149	if (m & (1<<EXC_BREAKPOINT))
150	strncat(out_string," BREAKPOINT", len);
151	if (m & (1<<EXC_SYSCALL))
152	strncat(out_string," SYSCALL", len);
153	if (m & (1<<EXC_MACH_SYSCALL))
154	strncat(out_string," MACH_SYSCALL", len);
155	if (m & (1<<EXC_RPC_ALERT))
156	strncat(out_string," RPC_ALERT", len);
157	if (m & (1<<EXC_CRASH))
158	strncat(out_string," CRASH", len);
159	if (m & (1<<EXC_RESOURCE))
160	strncat(out_string," RESOURCE", len);
161	if (m & (1<<EXC_GUARD))
162	strncat(out_string," GUARD", len);
163
164	}
165
166	kern_return_t print_task_exception_info(my_per_task_info_t *taskinfo)
167	{
168	kern_return_t kr = KERN_SUCCESS;
169	exception_mask_t mask = EXC_MASK_ALL;
170	struct exc_port_info excinfo;
171	char behavior_string[30];
172	char mask_string[200];
173
174	kr = task_get_exception_ports(taskinfo->task, mask, excinfo.masks, &excinfo.count, excinfo.ports, excinfo.behaviors, excinfo.flavors);
175
176	if (kr != KERN_SUCCESS) {
177	fprintf(stderr, "Failed task_get_exception_ports task: %d pid: %d\n", taskinfo->task, taskinfo->pid);
178	return kr;
179	}
180	boolean_t header_required = TRUE;
181	for (int i = 0; i < excinfo.count; i++) {
182	if (excinfo.ports[i] != MACH_PORT_NULL) {
183	if (header_required) {
184	printf("port flavor <behaviors> mask \n");
185	header_required = FALSE;
186	}
187	get_exc_behavior_string(excinfo.behaviors[i], behavior_string, sizeof(behavior_string));
188	get_exc_mask_string(excinfo.masks[i], mask_string, 200);
189	printf("0x%08x 0x%03x <%s> %s \n" , excinfo.ports[i], excinfo.flavors[i], behavior_string, mask_string);
190	mach_port_deallocate(mach_task_self(), excinfo.ports[i]);
191	}
192
193	}
194
195	return kr;
196	}
197
198
199	kern_return_t print_task_threads_special_ports(my_per_task_info_t *taskinfo)
200	{
201	kern_return_t kret = KERN_SUCCESS;
202	thread_act_array_t threadlist;
203	mach_msg_type_number_t threadcount=0;
204	kret = task_threads(taskinfo->task, &threadlist, &threadcount);
205	boolean_t header_required = TRUE;
206	boolean_t newline_required = TRUE;
207	unsigned th_kobject = 0;
208	unsigned th_kotype = 0;
209
210	for (int i = 0; i < threadcount; i++) {
211	if (header_required) {
9726c137	212	printf("Threads Thread-ID Port Description.");
1a7e3f61 A	213	header_required = FALSE;
	214	}
	215
	216	if (newline_required) {
	217	printf("\n");
	218	}
	219	newline_required = TRUE;
	220	if (KERN_SUCCESS == mach_port_kernel_object(mach_task_self(), threadlist[i], &th_kotype, &th_kobject)) {
	221	/* TODO: Should print tid and stuff */
	222	thread_identifier_info_data_t th_info;
	223	mach_msg_type_number_t th_info_count = THREAD_IDENTIFIER_INFO_COUNT;
	224	printf("0x%08x ", th_kobject);
	225	if (KERN_SUCCESS == thread_info(threadlist[i], THREAD_IDENTIFIER_INFO, (thread_info_t)&th_info, &th_info_count)) {
9726c137	226	printf("0x%llx ", th_info.thread_id);
1a7e3f61 A	227	}
1a7e3f61 A	228	else
9726c137	229	printf(" ");
1a7e3f61 A	230
	231	}
	232
	233	ipc_voucher_t th_voucher = IPC_VOUCHER_NULL;
	234	if (KERN_SUCCESS == thread_get_mach_voucher(threadlist[i], 0, &th_voucher) && th_voucher != IPC_VOUCHER_NULL) {
	235	show_voucher_detail(mach_task_self(), th_voucher);
	236	mach_port_deallocate(mach_task_self(), th_voucher);
	237	newline_required = FALSE;
	238	}
	239	mach_port_deallocate(mach_task_self(), threadlist[i]);
	240	}
9726c137	241	printf("\n");
1a7e3f61 A	242	return kret;
	243	}
	244
	245	char * get_task_name_by_pid(pid_t pid) {
	246	char * retval = "Unknown";
	247	for (int i = 0; i < global_taskcount; i++) {
	248	if (pid == global_taskinfo[i].pid) {
	249	return global_taskinfo[i].processName;
	250	}
	251	}
	252	return retval;
	253	}
	254
	255	my_per_task_info_t * get_taskinfo_by_kobject(natural_t kobj) {
	256	my_per_task_info_t *retval = &NOT_FOUND_TASK_INFO;
	257	for (int j = 0; j < global_taskcount; j++) {
	258	if (global_taskinfo[j].task_kobject == kobj) {
	259	retval = &global_taskinfo[j];
	260	break;
	261	}
	262	}
	263	return retval;
	264	}
	265
	266	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)
	267	{
	268	kern_return_t retval = KERN_FAILURE;
	269	boolean_t found = FALSE;
	270	*out_taskinfo = &NOT_FOUND_TASK_INFO;
	271
	272	for (int j = 0; j < global_taskcount && !found; j++) {
	273	for (int k = 0; k < global_taskinfo[j].tableCount && !found; k++) {
	274	if ((global_taskinfo[j].table[k].iin_type & MACH_PORT_TYPE_RECEIVE) &&
	275	global_taskinfo[j].table[k].iin_object == sendright->iin_object ) {
	276	*out_taskinfo = &global_taskinfo[j];
	277	*out_recv_info = global_taskinfo[j].table[k].iin_name;
	278	found = TRUE;
	279	retval = KERN_SUCCESS;
	280	}
	281	}
	282	}
	283	return retval;
	284	}
	285
	286