blob: 2c5042e83e33a800ed38204a8e5b46adacfdf242 [file] [log] [blame]
// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <pretty/sizes.h>
#include <task-utils/get.h>
#include <task-utils/walker.h>
#include <zircon/listnode.h>
#include <zircon/status.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/exception.h>
#include <zircon/syscalls/object.h>
#include <zircon/time.h>
#include <zircon/types.h>
#include <fcntl.h>
#include <inttypes.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
enum sort_order {
UNSORTED,
SORT_TIME_DELTA
};
typedef struct {
struct list_node node;
// has it been seen this pass?
bool scanned;
zx_duration_t delta_time;
// information about the thread
zx_koid_t proc_koid;
zx_koid_t koid;
zx_info_thread_t info;
zx_info_thread_stats_t stats;
char name[ZX_MAX_NAME_LEN];
char proc_name[ZX_MAX_NAME_LEN];
} thread_info_t;
// arguments
static zx_duration_t delay = ZX_SEC(1);
static int count = -1;
static bool print_all = false;
static bool raw_time = false;
static enum sort_order sort_order = SORT_TIME_DELTA;
// active locals
static struct list_node thread_list = LIST_INITIAL_VALUE(thread_list);
static char last_process_name[ZX_MAX_NAME_LEN];
static zx_koid_t last_process_scanned;
// Return text representation of thread state.
static const char* state_string(const zx_info_thread_t* info) {
if (info->wait_exception_port_type != ZX_EXCEPTION_PORT_TYPE_NONE) {
return "excp";
} else {
switch (ZX_THREAD_STATE_BASIC(info->state)) {
case ZX_THREAD_STATE_NEW:
return "new";
case ZX_THREAD_STATE_RUNNING:
return "run";
case ZX_THREAD_STATE_SUSPENDED:
return "susp";
case ZX_THREAD_STATE_BLOCKED:
return "block";
case ZX_THREAD_STATE_DYING:
return "dying";
case ZX_THREAD_STATE_DEAD:
return "dead";
default:
return "???";
}
}
}
static zx_status_t process_callback(void* unused_ctx, int depth,
zx_handle_t proc,
zx_koid_t koid, zx_koid_t parent_koid) {
last_process_scanned = koid;
zx_status_t status = zx_object_get_property(
proc, ZX_PROP_NAME, &last_process_name, sizeof(last_process_name));
return status;
}
// Adds a thread's information to the thread_list
static zx_status_t thread_callback(void* unused_ctx, int depth,
zx_handle_t thread,
zx_koid_t koid, zx_koid_t parent_koid) {
thread_info_t e = {};
e.koid = koid;
e.scanned = true;
e.proc_koid = last_process_scanned;
strlcpy(e.proc_name, last_process_name, sizeof(e.proc_name));
zx_status_t status =
zx_object_get_property(thread, ZX_PROP_NAME, e.name, sizeof(e.name));
if (status != ZX_OK) {
return status;
}
status = zx_object_get_info(
thread, ZX_INFO_THREAD, &e.info, sizeof(e.info), NULL, NULL);
if (status != ZX_OK) {
return status;
}
status = zx_object_get_info(
thread, ZX_INFO_THREAD_STATS, &e.stats, sizeof(e.stats), NULL, NULL);
if (status != ZX_OK) {
return status;
}
// see if this thread is in the list
thread_info_t* temp;
list_for_every_entry (&thread_list, temp, thread_info_t, node) {
if (e.koid == temp->koid) {
// mark it scanned, compute the delta time,
// and copy the new state over
temp->scanned = true;
temp->delta_time =
zx_duration_sub_duration(e.stats.total_runtime, temp->stats.total_runtime);
temp->info = e.info;
temp->stats = e.stats;
return ZX_OK;
}
}
// it wasn't in the list, add it
thread_info_t* new_entry = malloc(sizeof(thread_info_t));
*new_entry = e;
list_add_tail(&thread_list, &new_entry->node);
return ZX_OK;
}
static void sort_threads(enum sort_order order) {
if (order == UNSORTED)
return;
struct list_node new_list = LIST_INITIAL_VALUE(new_list);
// cheezy sort into second list, then swap back to first
thread_info_t* e;
while ((e = list_remove_head_type(&thread_list, thread_info_t, node))) {
thread_info_t* t;
bool found = false;
list_for_every_entry (&new_list, t, thread_info_t, node) {
if (order == SORT_TIME_DELTA) {
if (e->delta_time > t->delta_time) {
list_add_before(&t->node, &e->node);
found = true;
break;
}
}
}
// walked off the end
if (!found)
list_add_tail(&new_list, &e->node);
}
list_move(&new_list, &thread_list);
}
static void print_threads(void) {
thread_info_t* e;
printf("%8s %8s %10s %5s %s\n",
"PID", "TID", raw_time ? "TIME_NS" : "TIME%", "STATE", "NAME");
int i = 0;
list_for_every_entry (&thread_list, e, thread_info_t, node) {
// only print threads that are active
if (!print_all && e->delta_time == 0)
continue;
if (!raw_time) {
double percent = 0;
if (e->delta_time > 0)
percent = e->delta_time / (double)delay * 100;
printf("%8lu %8lu %10.2f %5s %s:%s\n",
e->proc_koid, e->koid, percent, state_string(&e->info),
e->proc_name, e->name);
} else {
printf("%8lu %8lu %10lu %5s %s:%s\n",
e->proc_koid, e->koid, e->delta_time, state_string(&e->info),
e->proc_name, e->name);
}
// only print the first count items (or all, if count < 0)
if (++i == count)
break;
}
}
static void print_help(FILE* f) {
fprintf(f, "Usage: top [options]\n");
fprintf(f, "Options:\n");
fprintf(f, " -a Print all threads, even if inactive\n");
fprintf(f, " -c <count> Print the first count threads (default infinity)\n");
fprintf(f, " -d <delay> Delay in seconds (default 1 second)\n");
fprintf(f, " -j <jobid> Show only threads that belong to a given jobid\n");
fprintf(f, " -n <times> Run this many times and then exit\n");
fprintf(f, " -o <sort field> Sort by different fields (default is time)\n");
fprintf(f, " -r Print raw time in nanoseconds\n");
fprintf(f, "\nSupported sort fields:\n");
fprintf(f, "\tnone : no sorting, in job order\n");
fprintf(f, "\ttime : sort by delta time between scans\n");
}
int main(int argc, char** argv) {
zx_handle_t target_job = ZX_HANDLE_INVALID;
int num_loops = -1;
for (int i = 1; i < argc; ++i) {
const char* arg = argv[i];
if (!strcmp(arg, "--help") || !strcmp(arg, "-h")) {
print_help(stdout);
return 0;
}
if (!strcmp(arg, "-a")) {
print_all = true;
} else if (!strcmp(arg, "-d")) {
delay = 0;
if (i + 1 < argc) {
delay = ZX_SEC(atoi(argv[i + 1]));
}
if (delay == 0) {
fprintf(stderr, "Bad -d value '%s'\n", argv[i + 1]);
print_help(stderr);
return 1;
}
i++;
} else if (!strcmp(arg, "-n")) {
num_loops = 0;
if (i + 1 < argc) {
num_loops = atoi(argv[i + 1]);
}
if (num_loops == 0) {
fprintf(stderr, "Bad -n value '%s'\n", argv[i + 1]);
print_help(stderr);
return 1;
}
i++;
} else if (!strcmp(arg, "-c")) {
count = 0;
if (i + 1 < argc) {
count = atoi(argv[i + 1]);
}
if (count == 0) {
fprintf(stderr, "Bad count\n");
print_help(stderr);
return 1;
}
i++;
} else if (!strcmp(arg, "-o")) {
if (i + 1 >= argc) {
fprintf(stderr, "Bad sort field\n");
print_help(stderr);
return 1;
} else if (!strcmp(argv[i + 1], "none")) {
sort_order = UNSORTED;
} else if (!strcmp(argv[i + 1], "time")) {
sort_order = SORT_TIME_DELTA;
} else {
fprintf(stderr, "Bad sort field\n");
print_help(stderr);
return 1;
}
i++;
} else if (!strcmp(arg, "-r")) {
raw_time = true;
} else if (!strcmp(arg, "-j")) {
if (i + 1 >= argc) {
fprintf(stderr, "Bad job field\n");
print_help(stderr);
return 1;
}
int jobid = atoi(argv[i + 1]);
zx_obj_type_t type;
zx_status_t status = get_task_by_koid(jobid, &type, &target_job);
if (status != ZX_OK) {
fprintf(stderr, "ERROR: get_task_by_koid failed: %s (%d)\n",
zx_status_get_string(status), status);
return 1;
}
if (type != ZX_OBJ_TYPE_JOB) {
fprintf(stderr, "ERROR: object with koid %d is not a job\n",
jobid);
return 1;
}
i++;
} else {
fprintf(stderr, "Unknown option: %s\n", arg);
print_help(stderr);
return 1;
}
}
bool is_term = false;
const char *term = getenv("TERM");
if (term != NULL) {
if (!strncmp(term, "screen", 6)) {
is_term = true;
}
if (!strncmp(term, "xterm", 5)) {
is_term = true;
}
}
// set stdin to non blocking
fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);
int ret = 0;
bool first_run = true;
for (;;) {
zx_time_t next_deadline = zx_deadline_after(delay);
// mark all active threads as not scanned
thread_info_t* e;
list_for_every_entry (&thread_list, e, thread_info_t, node) {
e->scanned = false;
}
// If we have a target job, only walk the target subtree. Otherwise walk from root.
zx_status_t status;
if (target_job != ZX_HANDLE_INVALID) {
status = walk_job_tree(target_job, NULL, process_callback, thread_callback, NULL);
} else {
status = walk_root_job_tree(NULL, process_callback, thread_callback, NULL);
}
if (status != ZX_OK) {
fprintf(stderr, "WARNING: walking the job tree failed: %s (%d)\n",
zx_status_get_string(status), status);
ret = 1;
goto finish;
}
// remove every entry that hasn't been scanned this pass
thread_info_t* temp;
list_for_every_entry_safe (&thread_list, e, temp, thread_info_t, node) {
if (!e->scanned) {
list_delete(&e->node);
free(e);
}
}
if (first_run) {
// We don't have data until after we scan twice, since we're
// computing deltas.
first_run = false;
continue;
}
// sort the list
sort_threads(sort_order);
// dump the list of threads
if (is_term) {
printf("\E[H\E[J");
}
print_threads();
if (num_loops > 0) {
if (--num_loops == 0) {
break;
}
} else {
// TODO: replace once ctrl-c works in the shell
char c;
int err;
while ((err = read(STDIN_FILENO, &c, 1)) > 0) {
if (c == 0x3) {
ret = 0;
goto finish;
}
}
}
zx_nanosleep(next_deadline);
}
finish:
if (target_job != ZX_HANDLE_INVALID) {
zx_handle_close(target_job);
}
return ret;
}