OpenSolaris_b135/cmd/latencytop/common/stat.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2008-2009, Intel Corporation.
* All Rights Reserved.
*/
#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#include <string.h>
#include <limits.h>
#include <sys/stat.h>
#include "latencytop.h"
/* Statistics for each process/thread. */
typedef struct _lt_stat_collection lt_stat_collection_t;
typedef gboolean (*check_child_func_t) (gpointer key,
lt_stat_collection_t *stat, void *user);
typedef struct {
lt_stat_entry_t lt_grp_summary;
/* cause_id -> stat entry */
GHashTable *lt_grp_cidlist;
} lt_datagroup_t;
#define NGROUPS 2
#define GROUP_CAUSE 0
#define GROUP_SOBJ 1
/*
* A data collection hierarchy involving three entities - system, process
* and thread. The hierarchic relationship is as follows :
*
* 1 system -> 1 or more processes -> 1 or more threads
*/
struct _lt_stat_collection {
lt_stat_level_t lt_sc_level;
unsigned int lt_sc_id;
char *lt_sc_name;
lt_datagroup_t lt_sc_groups[NGROUPS];
/*
* The following fields: lt_sc_parent, lt_sc_children and
* lt_sc_check_child_func maintain the tree structure.
*/
lt_stat_collection_t *lt_sc_parent; /* Parent node */
GHashTable *lt_sc_children; /* pid/tid -> lt_stat_collection_t */
check_child_func_t lt_sc_check_child_func; /* Release dead children */
};
/* Internal data structure to back up a stat_list */
typedef struct _lt_stat_list lt_stat_list_t;
typedef void (*free_list_func_t)(lt_stat_list_t *);
struct _lt_stat_list {
int lt_sl_entry_count;
lt_stat_entry_t **lt_sl_entries;
uint64_t lt_sl_gtotal;
free_list_func_t lt_sl_free_func;
};
/* Root of the collection hierarchy: system level statistics */
static lt_stat_collection_t *stat_system = NULL;
/*
* Data structure to hold synchronization objects.
* We don't use normal "cause table" because this needs to be cleared
* every time we refresh in order to make sure that stale synchronization
* objects don't consume memory.
*/
typedef struct {
int lt_soi_type;
unsigned long long lt_soi_addr;
} lt_sobj_id_t;
typedef struct {
lt_sobj_id_t lt_so_oid;
int lt_so_cause_id;
char lt_so_string[32]; /* Enough to hold "%s: 0x%llX" */
} lt_sobj_t;
static GHashTable *sobj_table = NULL;
static int sobj_table_len = 0;
/*
* Lower 32-bit of the address of synchronization objects is used to hash
* them.
*/
static guint
sobj_id_hash(lt_sobj_id_t *id)
{
g_assert(id != NULL);
return (id->lt_soi_addr & 0xFFFFFFFF);
}
/*
* Test if two synchronization objects are the same.
*/
static gboolean
sobj_id_equal(lt_sobj_id_t *a, lt_sobj_id_t *b)
{
g_assert(a != NULL && b != NULL);
return (a->lt_soi_type == b->lt_soi_type &&
a->lt_soi_addr == b->lt_soi_addr);
}
/*
* Look up the cause_id of a synchronization object.
* Note that this cause_id is only unique in GROUP_SOBJ, and changes after
* a refresh.
*/
static lt_sobj_t *
lookup_sobj(lt_sobj_id_t *id)
{
const char *stype_str[] = {
"None",
"Mutex",
"RWLock",
"CV",
"Sema",
"User",
"User_PI",
"Shuttle"
};
const int stype_str_len =
sizeof (stype_str) / sizeof (stype_str[0]);
lt_sobj_t *ret = NULL;
g_assert(id != NULL);
if (id->lt_soi_type < 0 || id->lt_soi_type >= stype_str_len) {
return (NULL);
}
if (sobj_table != NULL) {
ret = (lt_sobj_t *)g_hash_table_lookup(sobj_table, id);
} else {
sobj_table = g_hash_table_new_full(
(GHashFunc)sobj_id_hash, (GEqualFunc)sobj_id_equal,
NULL, (GDestroyNotify)free);
lt_check_null(sobj_table);
}
if (ret == NULL) {
ret = (lt_sobj_t *)lt_zalloc(sizeof (lt_sobj_t));
ret->lt_so_cause_id = ++sobj_table_len;
(void) snprintf(ret->lt_so_string, sizeof (ret->lt_so_string),
"%s: 0x%llX", stype_str[id->lt_soi_type], id->lt_soi_addr);
ret->lt_so_oid.lt_soi_type = id->lt_soi_type;
ret->lt_so_oid.lt_soi_addr = id->lt_soi_addr;
g_hash_table_insert(sobj_table, &ret->lt_so_oid, ret);
}
return (ret);
}
/*
* Check if a process exists by using /proc/pid
*/
/* ARGSUSED */
static gboolean
check_process(gpointer key, lt_stat_collection_t *stat, void *user)
{
char name[PATH_MAX];
(void) snprintf(name, PATH_MAX, "/proc/%u", stat->lt_sc_id);
return (lt_file_exist(name) ? FALSE : TRUE);
}
/*
* Check if a thread exists by using /proc/pid/lwp/tid
*/
/* ARGSUSED */
static gboolean
check_thread(gpointer key, lt_stat_collection_t *stat, void *user)
{
char name[PATH_MAX];
g_assert(stat->lt_sc_parent != NULL);
g_assert(stat->lt_sc_parent->lt_sc_level == LT_LEVEL_PROCESS);
(void) snprintf(name, PATH_MAX, "/proc/%u/lwp/%u",
stat->lt_sc_parent->lt_sc_id, stat->lt_sc_id);
return (lt_file_exist(name) ? FALSE : TRUE);
}
/*
* Helper function to free a stat node.
*/
static void
free_stat(lt_stat_collection_t *stat)
{
int i;
if (stat == NULL) {
return;
}
for (i = 0; i < NGROUPS; ++i) {
if (stat->lt_sc_groups[i].lt_grp_cidlist != NULL) {
g_hash_table_destroy(stat->lt_sc_groups[i].
lt_grp_cidlist);
}
}
if (stat->lt_sc_children != NULL) {
g_hash_table_destroy(stat->lt_sc_children);
}
if (stat->lt_sc_name != NULL) {
free(stat->lt_sc_name);
}
free(stat);
}
/*
* Helper function to initialize a stat node.
*/
/* ARGSUSED */
static void
clear_stat(gpointer key, lt_stat_collection_t *stat, void *user)
{
int i;
g_assert(stat != NULL);
for (i = 0; i < NGROUPS; ++i) {
if (stat->lt_sc_groups[i].lt_grp_cidlist != NULL) {
g_hash_table_destroy(stat->lt_sc_groups[i].
lt_grp_cidlist);
stat->lt_sc_groups[i].lt_grp_cidlist = NULL;
}
stat->lt_sc_groups[i].lt_grp_summary.lt_se_data.lt_s_count = 0;
stat->lt_sc_groups[i].lt_grp_summary.lt_se_data.lt_s_total = 0;
stat->lt_sc_groups[i].lt_grp_summary.lt_se_data.lt_s_max = 0;
}
if (stat->lt_sc_children != NULL) {
g_hash_table_foreach_remove(stat->lt_sc_children,
(GHRFunc)stat->lt_sc_check_child_func, NULL);
g_hash_table_foreach(stat->lt_sc_children,
(GHFunc)clear_stat, NULL);
}
}
/*
* Update a collection with the given value.
* Recursively update parents in the hierarchy until the root is reached.
*/
static void
update_stat_entry(lt_stat_collection_t *stat, int cause_id,
lt_stat_type_t type, uint64_t value,
const char *string, int group_to_use)
{
lt_stat_entry_t *entry = NULL;
lt_datagroup_t *group;
if (group_to_use < 0 || group_to_use >= NGROUPS) {
return;
}
group = &(stat->lt_sc_groups[group_to_use]);
if (group->lt_grp_cidlist != NULL) {
entry = (lt_stat_entry_t *)g_hash_table_lookup(
group->lt_grp_cidlist, LT_INT_TO_POINTER(cause_id));
} else {
group->lt_grp_cidlist = g_hash_table_new_full(
g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify)free);
lt_check_null(group->lt_grp_cidlist);
}
if (entry == NULL) {
entry = (lt_stat_entry_t *)lt_zalloc(sizeof (lt_stat_entry_t));
entry->lt_se_string = string;
switch (group_to_use) {
case GROUP_CAUSE:
entry->lt_se_type = STAT_CAUSE;
entry->lt_se_tsdata.lt_se_t_cause.lt_se_c_id = cause_id;
entry->lt_se_tsdata.lt_se_t_cause.lt_se_c_flags =
lt_table_get_cause_flag(cause_id, CAUSE_ALL_FLAGS);
/* hide the first '#' */
if ((entry->lt_se_tsdata.lt_se_t_cause.lt_se_c_flags
& CAUSE_FLAG_HIDE_IN_SUMMARY) != 0) {
++entry->lt_se_string;
}
break;
case GROUP_SOBJ:
entry->lt_se_type = STAT_SOBJ;
entry->lt_se_tsdata.lt_se_t_sobj.lt_se_s_id = cause_id;
break;
}
g_hash_table_insert(group->lt_grp_cidlist,
LT_INT_TO_POINTER(cause_id), entry);
}
lt_update_stat_value(&entry->lt_se_data, type, value);
if (group_to_use == GROUP_SOBJ ||
(entry->lt_se_tsdata.lt_se_t_cause.lt_se_c_flags &
CAUSE_FLAG_HIDE_IN_SUMMARY) == 0) {
lt_update_stat_value(&group->lt_grp_summary.lt_se_data, type,
value);
}
if (stat->lt_sc_parent != NULL) {
update_stat_entry(stat->lt_sc_parent, cause_id, type, value,
string, group_to_use);
}
}
/*
* Identify the cause of latency from the given stack trace.
* Return cause_id.
*/
static void
find_cause(char *stack, int *cause_id, int *cause_priority)
{
int cause_temp;
int prio_temp;
int cause = INVALID_CAUSE;
int priority = 0;
int found = 0;
g_assert(cause_id != NULL);
g_assert(cause_priority != NULL);
while (stack != NULL) {
char *sep;
sep = strchr(stack, ' ');
if (sep != NULL) {
*sep = '\0';
}
found = lt_table_cause_from_stack(stack, &cause_temp,
&prio_temp);
if (found && (cause == INVALID_CAUSE ||
HIGHER_PRIORITY(prio_temp, priority))) {
cause = cause_temp;
priority = prio_temp;
}
if (sep != NULL) {
*sep = ' ';
stack = sep + 1;
} else {
stack = NULL;
}
}
*cause_id = cause;
*cause_priority = priority;
}
/*
* Create a new collection and hook it to the parent.
*/
static lt_stat_collection_t *
new_collection(lt_stat_level_t level, unsigned int id, char *name,
lt_stat_collection_t *parent, check_child_func_t check_child_func)
{
int i;
lt_stat_collection_t *ret;
ret = (lt_stat_collection_t *)
lt_zalloc(sizeof (lt_stat_collection_t));
ret->lt_sc_level = level;
ret->lt_sc_check_child_func = check_child_func;
ret->lt_sc_id = id;
ret->lt_sc_name = name;
for (i = 0; i < NGROUPS; ++i) {
ret->lt_sc_groups[i].lt_grp_summary.lt_se_string =
(const char *)name;
}
if (parent != NULL) {
ret->lt_sc_parent = parent;
if (parent->lt_sc_children == NULL) {
parent->lt_sc_children = g_hash_table_new_full(
g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify)free_stat);
lt_check_null(parent->lt_sc_children);
}
g_hash_table_insert(parent->lt_sc_children,
LT_INT_TO_POINTER((int)id), ret);
}
return (ret);
}
/*
* Find the "leaf" in the collection hierarchy, using the given pid and tid.
*/
static lt_stat_collection_t *
get_stat_c(pid_t pid, id_t tid)
{
lt_stat_collection_t *stat_p = NULL;
lt_stat_collection_t *stat_t = NULL;
if (stat_system == NULL) {
stat_system = new_collection(LT_LEVEL_GLOBAL,
PID_SYS_GLOBAL, lt_strdup("SYSTEM"), NULL, check_process);
} else if (stat_system->lt_sc_children != NULL) {
stat_p = (lt_stat_collection_t *)
g_hash_table_lookup(stat_system->lt_sc_children,
LT_INT_TO_POINTER(pid));
}
if (stat_p == NULL) {
char *fname;
fname = lt_get_proc_field(pid, LT_FIELD_FNAME);
if (fname == NULL) {
/*
* we could not get the executable name of the
* process; the process is probably already dead.
*/
return (NULL);
}
stat_p = new_collection(LT_LEVEL_PROCESS,
(unsigned int)pid, fname, stat_system, check_thread);
} else if (stat_p->lt_sc_children != NULL) {
stat_t = (lt_stat_collection_t *)
g_hash_table_lookup(stat_p->lt_sc_children,
LT_INT_TO_POINTER(tid));
}
if (stat_t == NULL) {
const int tname_size = 16; /* Enough for "Thread %d" */
char *tname;
tname = (char *)lt_zalloc(tname_size);
(void) snprintf(tname, tname_size, "Thread %d", tid);
stat_t = new_collection(LT_LEVEL_THREAD,
(unsigned int)tid, tname, stat_p, NULL);
}
return (stat_t);
}
/*
* Update statistics with the given cause_id. Values will be added to
* internal statistics.
*/
void
lt_stat_update_cause(pid_t pid, id_t tid, int cause_id, lt_stat_type_t type,
uint64_t value)
{
const char *string;
lt_stat_collection_t *stat_t = NULL;
if (cause_id < 0 || value == 0) {
return;
}
if (lt_table_get_cause_flag(cause_id, CAUSE_FLAG_DISABLED)) {
/* Ignore this cause */
return;
}
stat_t = get_stat_c(pid, tid);
if (stat_t == NULL) {
/* Process must be dead. */
return;
}
string = lt_table_get_cause_name(cause_id);
update_stat_entry(stat_t, cause_id, type, value, string, GROUP_CAUSE);
}
/*
* Update statistics with the given stack trace.
* The stack trace is mapped to a cause and lt_stat_update_cause() is called
* to update statistics.
*/
void
lt_stat_update(pid_t pid, id_t tid, char *stack, char *tag,
unsigned int tag_priority, lt_stat_type_t type, uint64_t value)
{
int tag_cause_id = INVALID_CAUSE;
int stack_cause_id = INVALID_CAUSE;
int cause_id = INVALID_CAUSE;
int stack_priority = 0;
if (value == 0) {
return;
}
find_cause(stack, &stack_cause_id, &stack_priority);
if (tag_priority != 0) {
tag_cause_id = lt_table_cause_from_name(tag, 0, 0);
if (tag_cause_id == INVALID_CAUSE) {
/* This must be a syscall tag */
char tmp[64];
(void) snprintf(tmp, sizeof (tmp), "Syscall: %s", tag);
tag_cause_id = lt_table_cause_from_name(tmp, 1, 0);
}
}
cause_id = (tag_priority > stack_priority) ? tag_cause_id :
stack_cause_id;
if (cause_id == INVALID_CAUSE) {
/*
* We got an unmapped stack. Set SPECIAL flag to display it
* in pane 2. This makes it easier to find the cause.
*/
cause_id = lt_table_cause_from_name(stack, 1,
CAUSE_FLAG_SPECIAL);
lt_klog_log(LT_KLOG_LEVEL_UNMAPPED, pid, stack, type, value);
} else {
lt_klog_log(LT_KLOG_LEVEL_MAPPED, pid, stack, type, value);
}
lt_stat_update_cause(pid, tid, cause_id, type, value);
}
/*
* Zero out all statistics, but keep the data structures in memory
* to be used to hold new data immediately following.
*/
void
lt_stat_clear_all(void)
{
if (stat_system != NULL) {
clear_stat(NULL, stat_system, NULL);
}
if (sobj_table != NULL) {
g_hash_table_destroy(sobj_table);
sobj_table = NULL;
}
}
/*
* Clean up function that frees all memory used for statistics.
*/
void
lt_stat_free_all(void)
{
if (stat_system != NULL) {
free_stat(stat_system);
stat_system = NULL;
}
if (sobj_table != NULL) {
g_hash_table_destroy(sobj_table);
sobj_table = NULL;
}
}
/*
* Get top N causes of latency for a process. Return handle to a stat_list.
* Use pid = PID_SYS_GLOBAL to get global top list.
* Call lt_stat_list_free after use to clean up.
*/
void *
lt_stat_list_create(lt_list_type_t list_type, lt_stat_level_t level,
pid_t pid, id_t tid, int count, lt_sort_t sort_by)
{
GCompareFunc func;
GList *list, *walk;
lt_stat_collection_t *stat_c = NULL;
lt_stat_list_t *ret;
lt_datagroup_t *group;
if (level == LT_LEVEL_GLOBAL) {
/* Use global entry */
stat_c = stat_system;
} else if (stat_system != NULL && stat_system->lt_sc_children != NULL) {
/* Find process entry first */
stat_c = (lt_stat_collection_t *)g_hash_table_lookup(
stat_system->lt_sc_children, LT_INT_TO_POINTER(pid));
if (level == LT_LEVEL_THREAD) {
/*
* If thread entry is requested, find it based on
* process entry.
*/
if (stat_c != NULL && stat_c->lt_sc_children != NULL) {
stat_c = (lt_stat_collection_t *)
g_hash_table_lookup(stat_c->lt_sc_children,
LT_INT_TO_POINTER(tid));
} else {
/*
* Thread entry was not found; set it to NULL,
* so that we can return empty list later.
*/
stat_c = NULL;
}
}
}
ret = (lt_stat_list_t *)lt_zalloc(sizeof (lt_stat_list_t));
ret->lt_sl_entries = (lt_stat_entry_t **)
lt_zalloc(count * sizeof (lt_stat_entry_t *));
if (stat_c == NULL) {
/* Empty list */
return (ret);
}
if (list_type == LT_LIST_SOBJ) {
group = &(stat_c->lt_sc_groups[GROUP_SOBJ]);
} else {
group = &(stat_c->lt_sc_groups[GROUP_CAUSE]);
}
if (group->lt_grp_cidlist == NULL) {
/* Empty list */
return (ret);
}
ret->lt_sl_gtotal = group->lt_grp_summary.lt_se_data.lt_s_total;
list = g_hash_table_get_values(group->lt_grp_cidlist);
switch (sort_by) {
case LT_SORT_TOTAL:
func = (GCompareFunc)lt_sort_by_total_desc;
break;
case LT_SORT_MAX:
func = (GCompareFunc)lt_sort_by_max_desc;
break;
case LT_SORT_AVG:
func = (GCompareFunc)lt_sort_by_avg_desc;
break;
case LT_SORT_COUNT:
func = (GCompareFunc)lt_sort_by_count_desc;
break;
}
list = g_list_sort(list, func);
for (walk = list;
walk != NULL && count > 0;
walk = g_list_next(walk), --count) {
lt_stat_entry_t *data = (lt_stat_entry_t *)walk->data;
if (list_type == LT_LIST_CAUSE &&
data->lt_se_type == STAT_CAUSE &&
(data->lt_se_tsdata.lt_se_t_cause.lt_se_c_flags &
CAUSE_FLAG_HIDE_IN_SUMMARY) != 0) {
continue;
}
if (list_type == LT_LIST_SPECIALS &&
data->lt_se_type == STAT_CAUSE &&
(data->lt_se_tsdata.lt_se_t_cause.lt_se_c_flags &
CAUSE_FLAG_SPECIAL) == 0) {
continue;
}
if (data->lt_se_data.lt_s_count == 0) {
break;
}
ret->lt_sl_entries[ret->lt_sl_entry_count++] = data;
}
g_list_free(list);
return (ret);
}
/*
* Free memory allocated by lt_stat_list_create().
*/
void
lt_stat_list_free(void *ptr)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL) {
return;
}
if (list->lt_sl_free_func != NULL) {
list->lt_sl_free_func(list);
}
if (list->lt_sl_entries != NULL) {
free(list->lt_sl_entries);
}
free(list);
}
/*
* Check if the given list contains the given item.
*/
int
lt_stat_list_has_item(void *ptr, int i)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL || i < 0 || i >= list->lt_sl_entry_count ||
list->lt_sl_entries[i] == NULL) {
return (0);
}
return (1);
}
/*
* Get display name of the given item i in the given list.
*/
const char *
lt_stat_list_get_reason(void *ptr, int i)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL || i < 0 || i >= list->lt_sl_entry_count ||
list->lt_sl_entries[i] == NULL) {
return (NULL);
}
g_assert(list->lt_sl_entries[i]->lt_se_string != NULL);
return (list->lt_sl_entries[i]->lt_se_string);
}
/*
* Get maximum value of the given item i in the given list.
*/
uint64_t
lt_stat_list_get_max(void *ptr, int i)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL || i < 0 || i >= list->lt_sl_entry_count ||
list->lt_sl_entries[i] == NULL) {
return (0);
}
return (list->lt_sl_entries[i]->lt_se_data.lt_s_max);
}
/*
* Get total value of the given item i in the given list.
*/
uint64_t
lt_stat_list_get_sum(void *ptr, int i)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL || i < 0 || i >= list->lt_sl_entry_count ||
list->lt_sl_entries[i] == NULL) {
return (0);
}
return (list->lt_sl_entries[i]->lt_se_data.lt_s_total);
}
/*
* Get count value of the given item i in the given list.
*/
uint64_t
lt_stat_list_get_count(void *ptr, int i)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL || i < 0 || i >= list->lt_sl_entry_count ||
list->lt_sl_entries[i] == NULL) {
return (0);
}
return (list->lt_sl_entries[i]->lt_se_data.lt_s_count);
}
/*
* Get grand total of all latency in the list.
*/
uint64_t
lt_stat_list_get_gtotal(void *ptr)
{
lt_stat_list_t *list = (lt_stat_list_t *)ptr;
if (list == NULL) {
return (0);
}
return (list->lt_sl_gtotal);
}
/*
* ============================================================================
* Process and thread list.
* They share a lot of the static variables that are used for keeping
* statistics, hence they are located in this file.
*/
/*
* Helper function, sort by PID/TID ascend.
*/
static int
sort_id(lt_stat_collection_t *a, lt_stat_collection_t *b)
{
return ((int)(a->lt_sc_id - b->lt_sc_id));
}
/*
* Get the current list of processes. Call lt_stat_proc_list_free after use
* to clean up.
*/
static int
plist_create(pid_t ** list)
{
GList *pid_list, *walk;
int ret, count;
ret = g_hash_table_size(stat_system->lt_sc_children);
*list = (pid_t *)lt_malloc(sizeof (pid_t) * ret);
pid_list = g_hash_table_get_values(stat_system->lt_sc_children);
pid_list = g_list_sort(pid_list, (GCompareFunc)sort_id);
for (walk = pid_list, count = 0;
walk != NULL && count < ret;
walk = g_list_next(walk), ++count) {
(*list)[count] = (int)
((lt_stat_collection_t *)(walk->data))->lt_sc_id;
}
g_list_free(pid_list);
return (ret);
}
/*
* Count the no. of threads currently present in a process.
* Only thread that have SSLEEP are counted.
*/
/* ARGSUSED */
static void
count_threads(gpointer key, lt_stat_collection_t *stat_c, int *ret)
{
g_assert(ret != NULL);
if (stat_c->lt_sc_children != NULL) {
*ret += g_hash_table_size(stat_c->lt_sc_children);
}
}
/*
* Get current list of processes and threads.
* Call lt_stat_proc_list_free after use to clean up.
*/
static int
tlist_create(pid_t ** plist, id_t ** tlist)
{
GList *pid_list, *walk_p;
GList *tid_list, *walk_t;
int ret = 0;
int count = 0;
g_hash_table_foreach(stat_system->lt_sc_children,
(GHFunc)count_threads, &ret);
*plist = (pid_t *)lt_malloc(sizeof (pid_t) * ret);
*tlist = (id_t *)lt_malloc(sizeof (id_t) * ret);
pid_list = g_hash_table_get_values(stat_system->lt_sc_children);
pid_list = g_list_sort(pid_list, (GCompareFunc)sort_id);
for (walk_p = pid_list; walk_p != NULL;
walk_p = g_list_next(walk_p)) {
lt_stat_collection_t *stat_p =
(lt_stat_collection_t *)walk_p->data;
if (stat_p->lt_sc_children == NULL) {
continue;
}
tid_list = g_hash_table_get_values(stat_p->lt_sc_children);
tid_list = g_list_sort(tid_list, (GCompareFunc)sort_id);
for (walk_t = tid_list; walk_t != NULL;
walk_t = g_list_next(walk_t)) {
lt_stat_collection_t *stat_t =
(lt_stat_collection_t *)walk_t->data;
(*plist)[count] = (int)stat_p->lt_sc_id;
(*tlist)[count] = (int)stat_t->lt_sc_id;
++count;
}
g_list_free(tid_list);
}
g_list_free(pid_list);
g_assert(count == ret);
return (ret);
}
/*
* List of processes that are tracked by LatencyTOP.
*/
int
lt_stat_proc_list_create(pid_t ** plist, id_t ** tlist)
{
if (plist == NULL) {
return (-1);
}
if (stat_system == NULL || stat_system->lt_sc_children == NULL) {
*plist = NULL;
if (tlist != NULL) {
*tlist = NULL;
}
return (0);
}
if (tlist == NULL) {
return (plist_create(plist));
} else {
return (tlist_create(plist, tlist));
}
}
/*
* Free memory allocated by lt_stat_proc_list_create().
*/
void
lt_stat_proc_list_free(pid_t *plist, id_t *tlist)
{
if (plist != NULL) {
free(plist);
}
if (tlist != NULL) {
free(tlist);
}
}
/*
* Get executable name of the given process (ID).
*/
const char *
lt_stat_proc_get_name(pid_t pid)
{
lt_stat_collection_t *stat_p = NULL;
if (stat_system == NULL || stat_system->lt_sc_children == NULL) {
return (NULL);
}
stat_p = (lt_stat_collection_t *)g_hash_table_lookup(
stat_system->lt_sc_children, LT_INT_TO_POINTER(pid));
if (stat_p != NULL) {
return (stat_p->lt_sc_name);
} else {
return (NULL);
}
}
/*
* Get number of threads.
*/
int
lt_stat_proc_get_nthreads(pid_t pid)
{
lt_stat_collection_t *stat_p = NULL;
if (stat_system == NULL || stat_system->lt_sc_children == NULL) {
return (0);
}
stat_p = (lt_stat_collection_t *)g_hash_table_lookup(
stat_system->lt_sc_children, LT_INT_TO_POINTER(pid));
if (stat_p != NULL) {
return (g_hash_table_size(stat_p->lt_sc_children));
} else {
return (0);
}
}
/*
* Update statistics for synchronization objects.
*/
void
lt_stat_update_sobj(pid_t pid, id_t tid, int stype,
unsigned long long wchan,
lt_stat_type_t type, uint64_t value)
{
lt_sobj_id_t id;
lt_sobj_t *sobj;
int cause_id;
lt_stat_collection_t *stat_t = NULL;
stat_t = get_stat_c(pid, tid);
if (stat_t == NULL) {
return;
}
id.lt_soi_type = stype;
id.lt_soi_addr = wchan;
sobj = lookup_sobj(&id);
if (sobj == NULL) {
return;
}
cause_id = sobj->lt_so_cause_id;
update_stat_entry(stat_t, cause_id, type, value,
sobj->lt_so_string, GROUP_SOBJ);
}