508 lines
16 KiB
C
508 lines
16 KiB
C
#include <ctype.h>
|
|
#include <dispatch/dispatch.h>
|
|
#include <errno.h>
|
|
#include <libproc.h>
|
|
#include <mach/mach.h>
|
|
#include <mach/task_info.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/sysctl.h>
|
|
#include <time.h>
|
|
|
|
// from System.framework/Versions/B/PrivateHeaders/sys/codesign.h
|
|
#define CS_OPS_STATUS 0 /* return status */
|
|
#define CS_RESTRICT 0x0000800 /* tell dyld to treat restricted */
|
|
int csops(pid_t pid, unsigned int ops, void *useraddr, size_t usersize);
|
|
|
|
/* Step through the process table, find a matching process name, return
|
|
the pid of that matched process.
|
|
If there are multiple processes with that name, issue a warning on stdout
|
|
and return the highest numbered process.
|
|
The proc_pidpath() call is used which gets the full process name including
|
|
directories to the executable and the full (longer than 16 character)
|
|
executable name. */
|
|
|
|
pid_t get_pid_for_process_name(const char *procname) {
|
|
int process_count = proc_listpids(PROC_ALL_PIDS, 0, NULL, 0) / sizeof(pid_t);
|
|
if (process_count < 1) {
|
|
printf("Only found %d processes running!\n", process_count);
|
|
exit(1);
|
|
}
|
|
|
|
// Allocate a few extra slots in case new processes are spawned
|
|
int all_pids_size = sizeof(pid_t) * (process_count + 3);
|
|
pid_t *all_pids = (pid_t *)malloc(all_pids_size);
|
|
|
|
// re-set process_count in case the number of processes changed (got smaller;
|
|
// we won't do bigger)
|
|
process_count =
|
|
proc_listpids(PROC_ALL_PIDS, 0, all_pids, all_pids_size) / sizeof(pid_t);
|
|
|
|
int i;
|
|
pid_t highest_pid = 0;
|
|
int match_count = 0;
|
|
for (i = 1; i < process_count; i++) {
|
|
char pidpath[PATH_MAX];
|
|
int pidpath_len = proc_pidpath(all_pids[i], pidpath, sizeof(pidpath));
|
|
if (pidpath_len == 0)
|
|
continue;
|
|
char *j = strrchr(pidpath, '/');
|
|
if ((j == NULL && strcmp(procname, pidpath) == 0) ||
|
|
(j != NULL && strcmp(j + 1, procname) == 0)) {
|
|
match_count++;
|
|
if (all_pids[i] > highest_pid)
|
|
highest_pid = all_pids[i];
|
|
}
|
|
}
|
|
free(all_pids);
|
|
|
|
if (match_count == 0) {
|
|
printf("Did not find process '%s'.\n", procname);
|
|
exit(1);
|
|
}
|
|
if (match_count > 1) {
|
|
printf("Warning: More than one process '%s'!\n", procname);
|
|
printf(" defaulting to the highest-pid one, %d\n", highest_pid);
|
|
}
|
|
return highest_pid;
|
|
}
|
|
|
|
/* Given a pid, get the full executable name (including directory
|
|
paths and the longer-than-16-chars executable name) and return
|
|
the basename of that (i.e. do not include the directory components).
|
|
This function mallocs the memory for the string it returns;
|
|
the caller must free this memory. */
|
|
|
|
const char *get_process_name_for_pid(pid_t pid) {
|
|
char tmp_name[PATH_MAX];
|
|
if (proc_pidpath(pid, tmp_name, sizeof(tmp_name)) == 0) {
|
|
printf("Could not find process with pid of %d\n", (int)pid);
|
|
exit(1);
|
|
}
|
|
if (strrchr(tmp_name, '/'))
|
|
return strdup(strrchr(tmp_name, '/') + 1);
|
|
else
|
|
return strdup(tmp_name);
|
|
}
|
|
|
|
/* Get a struct kinfo_proc structure for a given pid.
|
|
Process name is required for error printing.
|
|
Gives you the current state of the process and whether it is being debugged
|
|
by anyone.
|
|
memory is malloc()'ed for the returned struct kinfo_proc
|
|
and must be freed by the caller. */
|
|
|
|
struct kinfo_proc *get_kinfo_proc_for_pid(pid_t pid, const char *process_name) {
|
|
struct kinfo_proc *kinfo =
|
|
(struct kinfo_proc *)malloc(sizeof(struct kinfo_proc));
|
|
int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
|
|
size_t len = sizeof(struct kinfo_proc);
|
|
if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), kinfo, &len, NULL, 0) != 0) {
|
|
free((void *)kinfo);
|
|
printf("Could not get kinfo_proc for pid %d\n", (int)pid);
|
|
exit(1);
|
|
}
|
|
return kinfo;
|
|
}
|
|
|
|
/* Get the basic information (thread_basic_info_t) about a given
|
|
thread.
|
|
Gives you the suspend count; thread state; user time; system time; sleep
|
|
time; etc.
|
|
The return value is a pointer to malloc'ed memory - it is the caller's
|
|
responsibility to free it. */
|
|
|
|
thread_basic_info_t get_thread_basic_info(thread_t thread) {
|
|
kern_return_t kr;
|
|
integer_t *thinfo = (integer_t *)malloc(sizeof(integer_t) * THREAD_INFO_MAX);
|
|
mach_msg_type_number_t thread_info_count = THREAD_INFO_MAX;
|
|
kr = thread_info(thread, THREAD_BASIC_INFO, (thread_info_t)thinfo,
|
|
&thread_info_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to get basic thread info for a thread\n");
|
|
exit(1);
|
|
}
|
|
return (thread_basic_info_t)thinfo;
|
|
}
|
|
|
|
/* Get the thread identifier info (thread_identifier_info_data_t)
|
|
about a given thread.
|
|
Gives you the system-wide unique thread number; the pthread identifier number
|
|
*/
|
|
|
|
thread_identifier_info_data_t get_thread_identifier_info(thread_t thread) {
|
|
kern_return_t kr;
|
|
thread_identifier_info_data_t tident;
|
|
mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT;
|
|
kr = thread_info(thread, THREAD_IDENTIFIER_INFO, (thread_info_t)&tident,
|
|
&tident_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to get thread ident for a thread\n");
|
|
exit(1);
|
|
}
|
|
return tident;
|
|
}
|
|
|
|
/* Given a mach port # (in the examine-threads mach port namespace) for a
|
|
thread,
|
|
find the mach port # in the inferior program's port namespace.
|
|
Sets inferior_port if successful.
|
|
Returns true if successful, false if unable to find the port number. */
|
|
|
|
bool inferior_namespace_mach_port_num(task_t task,
|
|
thread_t examine_threads_port,
|
|
thread_t *inferior_port) {
|
|
kern_return_t retval;
|
|
mach_port_name_array_t names;
|
|
mach_msg_type_number_t nameslen;
|
|
mach_port_type_array_t types;
|
|
mach_msg_type_number_t typeslen;
|
|
|
|
if (inferior_port == NULL)
|
|
return false;
|
|
|
|
retval = mach_port_names(task, &names, &nameslen, &types, &typeslen);
|
|
if (retval != KERN_SUCCESS) {
|
|
printf("Error - unable to get mach port names for inferior.\n");
|
|
return false;
|
|
}
|
|
int i = 0;
|
|
for (i = 0; i < nameslen; i++) {
|
|
mach_port_t local_name;
|
|
mach_msg_type_name_t local_type;
|
|
retval = mach_port_extract_right(task, names[i], MACH_MSG_TYPE_COPY_SEND,
|
|
&local_name, &local_type);
|
|
if (retval == KERN_SUCCESS) {
|
|
mach_port_deallocate(mach_task_self(), local_name);
|
|
if (local_name == examine_threads_port) {
|
|
*inferior_port = names[i];
|
|
vm_deallocate(mach_task_self(), (vm_address_t)names,
|
|
nameslen * sizeof(mach_port_t));
|
|
vm_deallocate(mach_task_self(), (vm_address_t)types,
|
|
typeslen * sizeof(mach_port_t));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
vm_deallocate(mach_task_self(), (vm_address_t)names,
|
|
nameslen * sizeof(mach_port_t));
|
|
vm_deallocate(mach_task_self(), (vm_address_t)types,
|
|
typeslen * sizeof(mach_port_t));
|
|
return false;
|
|
}
|
|
|
|
/* Get the current pc value for a given thread. */
|
|
|
|
uint64_t get_current_pc(thread_t thread, int *wordsize) {
|
|
kern_return_t kr;
|
|
|
|
#if defined(__x86_64__) || defined(__i386__)
|
|
x86_thread_state_t gp_regs;
|
|
mach_msg_type_number_t gp_count = x86_THREAD_STATE_COUNT;
|
|
kr = thread_get_state(thread, x86_THREAD_STATE, (thread_state_t)&gp_regs,
|
|
&gp_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to get registers for a thread\n");
|
|
exit(1);
|
|
}
|
|
|
|
if (gp_regs.tsh.flavor == x86_THREAD_STATE64) {
|
|
*wordsize = 8;
|
|
return gp_regs.uts.ts64.__rip;
|
|
} else {
|
|
*wordsize = 4;
|
|
return gp_regs.uts.ts32.__eip;
|
|
}
|
|
#endif
|
|
|
|
#if defined(__arm__)
|
|
arm_thread_state_t gp_regs;
|
|
mach_msg_type_number_t gp_count = ARM_THREAD_STATE_COUNT;
|
|
kr = thread_get_state(thread, ARM_THREAD_STATE, (thread_state_t)&gp_regs,
|
|
&gp_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to get registers for a thread\n");
|
|
exit(1);
|
|
}
|
|
*wordsize = 4;
|
|
return gp_regs.__pc;
|
|
#endif
|
|
|
|
#if defined(__arm64__)
|
|
arm_thread_state64_t gp_regs;
|
|
mach_msg_type_number_t gp_count = ARM_THREAD_STATE64_COUNT;
|
|
kr = thread_get_state(thread, ARM_THREAD_STATE64, (thread_state_t)&gp_regs,
|
|
&gp_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to get registers for a thread\n");
|
|
exit(1);
|
|
}
|
|
*wordsize = 8;
|
|
return gp_regs.__pc;
|
|
#endif
|
|
}
|
|
|
|
/* Get the proc_threadinfo for a given thread.
|
|
Gives you the thread name, if set; current and max priorities.
|
|
Returns 1 if successful
|
|
Returns 0 if proc_pidinfo() failed
|
|
*/
|
|
|
|
int get_proc_threadinfo(pid_t pid, uint64_t thread_handle,
|
|
struct proc_threadinfo *pth) {
|
|
pth->pth_name[0] = '\0';
|
|
int ret = proc_pidinfo(pid, PROC_PIDTHREADINFO, thread_handle, pth,
|
|
sizeof(struct proc_threadinfo));
|
|
if (ret != 0)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
kern_return_t kr;
|
|
task_t task;
|
|
pid_t pid = 0;
|
|
char *procname = NULL;
|
|
int arg_is_procname = 0;
|
|
int do_loop = 0;
|
|
int verbose = 0;
|
|
int resume_when_done = 0;
|
|
mach_port_t mytask = mach_task_self();
|
|
|
|
if (argc != 2 && argc != 3 && argc != 4 && argc != 5) {
|
|
printf("Usage: tdump [-l] [-v] [-r] pid/procname\n");
|
|
exit(1);
|
|
}
|
|
|
|
if (argc == 3 || argc == 4) {
|
|
int i = 1;
|
|
while (i < argc - 1) {
|
|
if (strcmp(argv[i], "-l") == 0)
|
|
do_loop = 1;
|
|
if (strcmp(argv[i], "-v") == 0)
|
|
verbose = 1;
|
|
if (strcmp(argv[i], "-r") == 0)
|
|
resume_when_done++;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
char *c = argv[argc - 1];
|
|
if (*c == '\0') {
|
|
printf("Usage: tdump [-l] [-v] pid/procname\n");
|
|
exit(1);
|
|
}
|
|
while (*c != '\0') {
|
|
if (!isdigit(*c)) {
|
|
arg_is_procname = 1;
|
|
procname = argv[argc - 1];
|
|
break;
|
|
}
|
|
c++;
|
|
}
|
|
|
|
if (arg_is_procname && procname) {
|
|
pid = get_pid_for_process_name(procname);
|
|
} else {
|
|
errno = 0;
|
|
pid = (pid_t)strtol(argv[argc - 1], NULL, 10);
|
|
if (pid == 0 && errno == EINVAL) {
|
|
printf("Usage: tdump [-l] [-v] pid/procname\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
const char *process_name = get_process_name_for_pid(pid);
|
|
|
|
// At this point "pid" is the process id and "process_name" is the process
|
|
// name
|
|
// Now we have to get the process list from the kernel (which only has the
|
|
// truncated
|
|
// 16 char names)
|
|
|
|
struct kinfo_proc *kinfo = get_kinfo_proc_for_pid(pid, process_name);
|
|
|
|
printf("pid %d (%s) is currently ", pid, process_name);
|
|
switch (kinfo->kp_proc.p_stat) {
|
|
case SIDL:
|
|
printf("being created by fork");
|
|
break;
|
|
case SRUN:
|
|
printf("runnable");
|
|
break;
|
|
case SSLEEP:
|
|
printf("sleeping on an address");
|
|
break;
|
|
case SSTOP:
|
|
printf("suspended");
|
|
break;
|
|
case SZOMB:
|
|
printf("zombie state - awaiting collection by parent");
|
|
break;
|
|
default:
|
|
printf("unknown");
|
|
}
|
|
if (kinfo->kp_proc.p_flag & P_TRACED)
|
|
printf(" and is being debugged.");
|
|
free((void *)kinfo);
|
|
|
|
printf("\n");
|
|
|
|
int csops_flags = 0;
|
|
if (csops(pid, CS_OPS_STATUS, &csops_flags, sizeof(csops_flags)) != -1 &&
|
|
(csops_flags & CS_RESTRICT)) {
|
|
printf("pid %d (%s) is restricted so nothing can attach to it.\n", pid,
|
|
process_name);
|
|
}
|
|
|
|
kr = task_for_pid(mach_task_self(), pid, &task);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to task_for_pid()\n");
|
|
exit(1);
|
|
}
|
|
|
|
struct task_basic_info info;
|
|
unsigned int info_count = TASK_BASIC_INFO_COUNT;
|
|
|
|
kr = task_info(task, TASK_BASIC_INFO, (task_info_t)&info, &info_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to call task_info.\n");
|
|
exit(1);
|
|
}
|
|
printf("Task suspend count: %d.\n", info.suspend_count);
|
|
|
|
struct timespec *rqtp = (struct timespec *)malloc(sizeof(struct timespec));
|
|
rqtp->tv_sec = 0;
|
|
rqtp->tv_nsec = 150000000;
|
|
|
|
int loop_cnt = 1;
|
|
do {
|
|
int i;
|
|
if (do_loop)
|
|
printf("Iteration %d:\n", loop_cnt++);
|
|
thread_array_t thread_list;
|
|
mach_msg_type_number_t thread_count;
|
|
|
|
kr = task_threads(task, &thread_list, &thread_count);
|
|
if (kr != KERN_SUCCESS) {
|
|
printf("Error - unable to get thread list\n");
|
|
exit(1);
|
|
}
|
|
printf("pid %d has %d threads\n", pid, thread_count);
|
|
if (verbose)
|
|
printf("\n");
|
|
|
|
for (i = 0; i < thread_count; i++) {
|
|
thread_basic_info_t basic_info = get_thread_basic_info(thread_list[i]);
|
|
|
|
thread_identifier_info_data_t identifier_info =
|
|
get_thread_identifier_info(thread_list[i]);
|
|
|
|
int wordsize;
|
|
uint64_t pc = get_current_pc(thread_list[i], &wordsize);
|
|
|
|
printf("thread #%d, system-wide-unique-tid 0x%llx, suspend count is %d, ",
|
|
i, identifier_info.thread_id, basic_info->suspend_count);
|
|
if (wordsize == 8)
|
|
printf("pc 0x%016llx, ", pc);
|
|
else
|
|
printf("pc 0x%08llx, ", pc);
|
|
printf("run state is ");
|
|
switch (basic_info->run_state) {
|
|
case TH_STATE_RUNNING:
|
|
puts("running");
|
|
break;
|
|
case TH_STATE_STOPPED:
|
|
puts("stopped");
|
|
break;
|
|
case TH_STATE_WAITING:
|
|
puts("waiting");
|
|
break;
|
|
case TH_STATE_UNINTERRUPTIBLE:
|
|
puts("uninterruptible");
|
|
break;
|
|
case TH_STATE_HALTED:
|
|
puts("halted");
|
|
break;
|
|
default:
|
|
puts("");
|
|
}
|
|
|
|
printf(" pthread handle id 0x%llx (not the same value as "
|
|
"pthread_self() returns)\n",
|
|
(uint64_t)identifier_info.thread_handle);
|
|
|
|
struct proc_threadinfo pth;
|
|
int proc_threadinfo_succeeded =
|
|
get_proc_threadinfo(pid, identifier_info.thread_handle, &pth);
|
|
|
|
if (proc_threadinfo_succeeded && pth.pth_name[0] != '\0')
|
|
printf(" thread name '%s'\n", pth.pth_name);
|
|
|
|
printf(" libdispatch qaddr 0x%llx (not the same as the "
|
|
"dispatch_queue_t token)\n",
|
|
(uint64_t)identifier_info.dispatch_qaddr);
|
|
|
|
if (verbose) {
|
|
printf(
|
|
" (examine-threads port namespace) mach port # 0x%4.4x\n",
|
|
(int)thread_list[i]);
|
|
thread_t mach_port_inferior_namespace;
|
|
if (inferior_namespace_mach_port_num(task, thread_list[i],
|
|
&mach_port_inferior_namespace))
|
|
printf(" (inferior port namepsace) mach port # 0x%4.4x\n",
|
|
(int)mach_port_inferior_namespace);
|
|
printf(" user %d.%06ds, system %d.%06ds",
|
|
basic_info->user_time.seconds,
|
|
basic_info->user_time.microseconds,
|
|
basic_info->system_time.seconds,
|
|
basic_info->system_time.microseconds);
|
|
if (basic_info->cpu_usage > 0) {
|
|
float cpu_percentage = basic_info->cpu_usage / 10.0;
|
|
printf(", using %.1f%% cpu currently", cpu_percentage);
|
|
}
|
|
if (basic_info->sleep_time > 0)
|
|
printf(", this thread has slept for %d seconds",
|
|
basic_info->sleep_time);
|
|
|
|
printf("\n ");
|
|
printf("scheduling policy %d", basic_info->policy);
|
|
|
|
if (basic_info->flags != 0) {
|
|
printf(", flags %d", basic_info->flags);
|
|
if ((basic_info->flags | TH_FLAGS_SWAPPED) == TH_FLAGS_SWAPPED)
|
|
printf(" (thread is swapped out)");
|
|
if ((basic_info->flags | TH_FLAGS_IDLE) == TH_FLAGS_IDLE)
|
|
printf(" (thread is idle)");
|
|
}
|
|
if (proc_threadinfo_succeeded)
|
|
printf(", current pri %d, max pri %d", pth.pth_curpri,
|
|
pth.pth_maxpriority);
|
|
|
|
printf("\n\n");
|
|
}
|
|
|
|
free((void *)basic_info);
|
|
}
|
|
if (do_loop)
|
|
printf("\n");
|
|
vm_deallocate(mytask, (vm_address_t)thread_list,
|
|
thread_count * sizeof(thread_act_t));
|
|
nanosleep(rqtp, NULL);
|
|
} while (do_loop);
|
|
|
|
while (resume_when_done > 0) {
|
|
kern_return_t err = task_resume(task);
|
|
if (err != KERN_SUCCESS)
|
|
printf("Error resuming task: %d.", err);
|
|
resume_when_done--;
|
|
}
|
|
|
|
vm_deallocate(mytask, (vm_address_t)task, sizeof(task_t));
|
|
free((void *)process_name);
|
|
|
|
return 0;
|
|
}
|