#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mach/mach.h>
#include <mach/task_info.h>
#include <time.h>
#include <sys/sysctl.h>
#include <ctype.h>
#include <libproc.h>
#include <errno.h>
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);
}
int all_pids_size = sizeof (pid_t) * (process_count + 3);
pid_t *all_pids = (pid_t *) malloc (all_pids_size);
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;
}
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);
}
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;
}
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;
}
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;
}
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);
}
return gp_regs.__pc;
*wordsize = 4;
#endif
}
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;
thread_t thread;
pid_t pid = 0;
char *procname = NULL;
int arg_is_procname = 0;
int do_loop = 0;
int verbose = 0;
mach_port_t mytask = mach_task_self ();
if (argc != 2 && argc != 3 && argc != 4)
{
printf ("Usage: tdump [-l] [-v] 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;
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);
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");
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, unique tid %lld, 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 ("");
}
if (verbose)
{
printf (" ");
printf ("mach thread #0x%4.4x ", (int) thread_list[i]);
printf ("pthread handle id 0x%llx ", (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' ", pth.pth_name);
printf ("\n ");
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);
vm_deallocate (mytask, (vm_address_t) task, sizeof (task_t));
free ((void *) process_name);
return 0;
}