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