8354 sync regcomp(3C) with upstream (fix make catalog)

[unleashed/tickless.git] / usr / src / cmd / latencytop / common / table.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 <string.h>
#include <memory.h>
#include <stdio.h>
#include <ctype.h>

#include "latencytop.h"

/*
 * Structure that holds detail of a cause.
 */
typedef struct {
        int lt_c_cause_id;
        int lt_c_flags;
        char *lt_c_name;
} lt_cause_t;

/*
 * Structure that represents a matched cause.
 */
typedef struct  {
        int lt_mt_priority;
        int lt_mt_cause_id;
} lt_match_t;

/* All lt_cause_t that are created. */
static GHashTable *cause_lookup = NULL;
static GPtrArray *causes_array = NULL;
static int causes_array_len = 0;

/*
 * This hash table maps a symbol to a cause.
 * key is of type "char *" and value is of type "lt_match_t *".
 */
static GHashTable *symbol_lookup_table = NULL;

/*
 * The dtrace translation rules we get from the script
 */
char *dtrans = NULL;

/*
 * These structures are only used inside .trans parser.
 */
typedef struct {
        int lt_dm_priority;
        char *lt_dm_macro;
} lt_dmacro_t;

typedef struct {
        GSequence *lt_pr_cmd_disable;
        GHashTable *lt_pr_dmacro;
} lt_parser_t;

/* ARGSUSED */
static void
free_cause(lt_cause_t *cause, void *user)
{
        g_assert(cause != NULL && cause->lt_c_name != NULL);

        free(cause->lt_c_name);
        free(cause);
}

static void
free_dmacro(lt_dmacro_t *d)
{
        g_assert(d->lt_dm_macro != NULL);
        free(d->lt_dm_macro);
        free(d);
}

/*
 * Add a cause.
 */
static lt_cause_t *
new_cause(char *name, int flags)
{
        lt_cause_t *entry;

        g_assert(name != NULL);

        entry = (lt_cause_t *)lt_malloc(sizeof (lt_cause_t));
        entry->lt_c_flags = flags;
        entry->lt_c_name = name;
        entry->lt_c_cause_id = causes_array_len;

        g_ptr_array_add(causes_array, entry);
        ++causes_array_len;

        return (entry);
}

/*
 * Set a cause to "disabled" state.
 */
static void
disable_cause(char *cause_str, GHashTable *cause_table)
{
        lt_cause_t *cause;

        cause = (lt_cause_t *)g_hash_table_lookup(cause_table, cause_str);

        if (cause != NULL) {
                cause->lt_c_flags |= CAUSE_FLAG_DISABLED;
        }
}

/*
 * Helper functions that reads a line from a character array.
 */
static int
read_line_from_mem(const char *mem, int mem_len, char *line, int line_len,
    int *index)
{
        g_assert(mem != NULL && line != NULL && index != NULL);

        if (line_len <= 0 || mem_len <= 0) {
                return (0);
        }

        if (*index >= mem_len) {
                return (0);
        }

        while (line_len > 1 && *index < mem_len) {
                *line = mem[(*index)++];
                --line_len;
                ++line;

                if (*(line-1) == '\r' || *(line-1) == '\n') {
                        break;
                }
        }
        *line = '\0';

        return (1);
}

/*
 * Parse special command from configuration file. Special command
 * has the following format :

 *      disable_cause <cause name>
 */
static int
parse_config_cmd(char *begin, lt_parser_t *parser)
{
        char *tmp;
        char old_chr = 0;

        /*
         * disable_cause  FSFlush Daemon
         * ^
         */
        if (*begin == '\0') {
                return (0);
        }

        for (tmp = begin;
            *tmp != '\0' && !isspace(*tmp);
            ++tmp) {
        }
        old_chr = *tmp;
        *tmp = '\0';

        if (strcmp("disable_cause", begin) == 0) {
                if (old_chr == '\0') {
                        /* Must have an argument */
                        lt_display_error(
                            "Invalid command format: %s\n",
                            begin);
                        return (-1);
                }

                begin = tmp+1;
                while (isspace(*begin)) {
                        ++begin;
                }

                g_sequence_append(parser->lt_pr_cmd_disable,
                    lt_strdup(begin));
        } else   {
                *tmp = old_chr;
                lt_display_error(
                    "Unknown command: %s\n", begin);
                return (-1);
        }

        return (0);
}

/*
 * Parse symbol translation from configuration file. Symbol translation
 * has the following format :
 *
 *      <priority> <symbol name> <cause>
 *
 * Finally check if that cause has already been mapped.
 */
static int
parse_sym_trans(char *begin)
{
        int priority = 0;
        char *match;
        char *match_dup;
        char *cause_str;
        lt_cause_t *cause;
        lt_match_t *match_entry;
        char *tmp;

        /*
         * 10   genunix`pread                   Syscall pread
         * ^
         */
        priority = strtol(begin, &tmp, 10);

        if (tmp == begin || priority == 0) {
                return (-1);
        }

        begin = tmp;

        /*
         * 10   genunix`pread                   Syscall pread
         * --^
         */

        if (!isspace(*begin)) {
                /* At least one space char after <priority> */
                return (-1);
        }

        while (isspace(*begin)) {
                ++begin;
        }

        if (*begin == 0) {
                return (-1);
        }

        /*
         * 10   genunix`pread                   Syscall pread
         * -----^
         */
        for (tmp = begin;
            *tmp != '\0' && !isspace(*tmp);
            ++tmp) {
        }

        if (*tmp == '\0') {
                return (-1);
        }

        *tmp = '\0';
        match = begin;

        /* Check if we have mapped this function before. */
        match_entry = (lt_match_t *)
            g_hash_table_lookup(symbol_lookup_table, match);

        if (match_entry != NULL &&
            HIGHER_PRIORITY(match_entry->lt_mt_priority, priority)) {
                /* We already have a higher entry. Ignore this. */
                return (0);
        }

        begin = tmp + 1;

        /*
         * 10   genunix`pread                   Syscall pread
         * -------------------------------------^
         */
        while (isspace(*begin)) {
                ++begin;
        }

        if (*begin == 0) {
                return (-1);
        }

        cause_str = begin;

        /* Check if we have mapped this cause before. */
        cause = (lt_cause_t *)
            g_hash_table_lookup(cause_lookup, cause_str);

        if (cause == NULL) {
                char *cause_dup = lt_strdup(cause_str);
                cause = new_cause(cause_dup, 0);
                g_hash_table_insert(cause_lookup, cause_dup, cause);
        }

        match_entry = (lt_match_t *)lt_malloc(sizeof (lt_match_t));
        match_entry->lt_mt_priority = priority;
        match_entry->lt_mt_cause_id = cause->lt_c_cause_id;
        match_dup = lt_strdup(match);

        g_hash_table_insert(symbol_lookup_table, match_dup,
            match_entry);

        return (0);
}

/*
 * Parse D macro. D macros have the following format :
 *
 *      <priority> <entry probe> <return probe> <cause>
 *
 * Finally check if that cause has already been mapped.
 */
static int
parse_dmacro(char *begin, lt_parser_t *parser)
{
        int priority = 0;
        char *entryprobe;
        char *returnprobe;
        char *cause_str;
        char buf[512];
        char probepair[512];
        char *tmp = NULL;
        lt_cause_t *cause;
        lt_dmacro_t *dmacro;

        /*
         * 10   syscall::pread:entry    syscall::pread:return   Syscall pread
         * ^
         */
        priority = strtol(begin, &tmp, 10);

        if (tmp == begin || priority == 0) {
                return (-1);
        }

        begin = tmp;

        /*
         * 10   syscall::pread:entry    syscall::pread:return   Syscall pread
         * --^
         */
        while (isspace(*begin)) {
                ++begin;
        }

        if (*begin == 0) {
                return (-1);
        }

        /*
         * 10   syscall::pread:entry    syscall::pread:return   Syscall pread
         * -----^
         */
        for (tmp = begin;
            *tmp != '\0' && !isspace(*tmp);
            ++tmp) {
        }

        if (*tmp == '\0') {
                return (-1);
        }

        *tmp = '\0';
        entryprobe = begin;
        begin = tmp + 1;

        while (isspace(*begin)) {
                ++begin;
        }

        /*
         * 10   syscall::pread:entry    syscall::pread:return   Syscall pread
         * -----------------------------^
         */
        for (tmp = begin;
            *tmp != '\0' && !isspace(*tmp);
            ++tmp) {
        }

        if (*tmp == '\0') {
                return (-1);
        }

        *tmp = '\0';
        returnprobe = begin;
        begin = tmp + 1;

        while (isspace(*begin)) {
                ++begin;
        }

        /*
         * 10   syscall::pread:entry    syscall::pread:return   Syscall pread
         * -----------------------------------------------------^
         */
        if (*begin == 0) {
                return (-1);
        }

        cause_str = begin;

        dmacro = NULL;

        /* Check if we have mapped this cause before. */
        cause = (lt_cause_t *)
            g_hash_table_lookup(cause_lookup, cause_str);

        if (cause == NULL) {
                char *cause_dup = lt_strdup(cause_str);
                cause = new_cause(cause_dup, 0);
                g_hash_table_insert(cause_lookup, cause_dup, cause);
        }

        (void) snprintf(buf, sizeof (buf), "\nTRANSLATE(%s, %s, \"%s\", %d)\n",
            entryprobe, returnprobe, cause_str, priority);

        (void) snprintf(probepair, sizeof (probepair), "%s %s", entryprobe,
            returnprobe);

        g_assert(cause != NULL);
        g_assert(parser->lt_pr_dmacro != NULL);

        dmacro = g_hash_table_lookup(parser->lt_pr_dmacro, probepair);

        if (dmacro == NULL) {
                dmacro = (lt_dmacro_t *)lt_malloc(sizeof (lt_dmacro_t));
                dmacro->lt_dm_priority = priority;
                dmacro->lt_dm_macro = lt_strdup(buf);
                g_hash_table_insert(parser->lt_pr_dmacro, lt_strdup(probepair),
                    dmacro);
        } else if (dmacro->lt_dm_priority < priority) {
                free(dmacro->lt_dm_macro);
                dmacro->lt_dm_priority = priority;
                dmacro->lt_dm_macro = lt_strdup(buf);
        }

        return (0);
}

/*
 * Helper function to collect TRANSLATE() macros.
 */
/* ARGSUSED */
static void
genscript(void *key, lt_dmacro_t *dmacro, GString *str)
{
        g_string_append(str, dmacro->lt_dm_macro);
}

/*
 * Main logic that parses translation rules one line at a time,
 * and creates a lookup table from it. The syntax for the translation
 * is as follows :
 *
 *      #                               <--- comment
 *      D <D macro rule>                <--- D macro
 *      S <Symbol translation>          <--- Symbols
 *      disable_cause <cause>           <--- special command
 */
static int
parse_config(const char *work, int work_len)
{
        char line[256];
        int len;
        char *begin, *end;
        int current = 0;
        lt_parser_t parser;
        int ret = 0;
        char flag;
        GString *script;

        cause_lookup = g_hash_table_new(g_str_hash, g_str_equal);
        lt_check_null(cause_lookup);

        parser.lt_pr_cmd_disable = g_sequence_new((GDestroyNotify)free);
        lt_check_null(parser.lt_pr_cmd_disable);

        parser.lt_pr_dmacro = g_hash_table_new_full(g_str_hash,
            g_str_equal, (GDestroyNotify)free, (GDestroyNotify)free_dmacro);
        lt_check_null(parser.lt_pr_dmacro);

        while (read_line_from_mem(work, work_len, line, sizeof (line),
            &current)) {
                len = strlen(line);

                if (line[len-1] != '\n' && line[len-1] != '\r' &&
                    current < work_len) {
                        lt_display_error("Configuration line too long.\n");
                        goto err;
                }

                begin = line;

                while (isspace(*begin)) {
                        ++begin;
                }

                if (*begin == '\0') {
                        /* Ignore empty line */
                        continue;
                }

                /* Delete trailing spaces. */
                end = begin + strlen(begin) - 1;

                while (isspace(*end)) {
                        --end;
                }

                end[1] = '\0';

                flag = *begin;
                ++begin;

                switch (flag) {
                case '#':
                        ret = 0;
                        break;
                case ';':
                        ret = parse_config_cmd(begin, &parser);
                        break;
                case 'D':
                case 'd':
                        if (!isspace(*begin)) {
                                lt_display_error(
                                    "No space after flag char: %s\n", line);
                        }
                        while (isspace(*begin)) {
                                ++begin;
                        }
                        ret = parse_dmacro(begin, &parser);
                        break;
                case 'S':
                case 's':
                        if (!isspace(*begin)) {
                                lt_display_error(
                                    "No space after flag char: %s\n", line);
                        }
                        while (isspace(*begin)) {
                                ++begin;
                        }
                        ret = parse_sym_trans(begin);
                        break;
                default:
                        ret = -1;
                        break;
                }

                if (ret != 0) {
                        lt_display_error(
                            "Invalid configuration line: %s\n", line);
                        goto err;
                }
        }

        script = g_string_new(NULL);
        g_hash_table_foreach(parser.lt_pr_dmacro, (GHFunc)genscript, script);
        dtrans = g_string_free(script, FALSE);

        if (dtrans != NULL && strlen(dtrans) == 0) {
                free(dtrans);
                dtrans = NULL;
        }

        g_sequence_foreach(parser.lt_pr_cmd_disable, (GFunc)disable_cause,
            cause_lookup);
        g_sequence_free(parser.lt_pr_cmd_disable);

        return (0);

err:
        g_sequence_free(parser.lt_pr_cmd_disable);
        g_hash_table_destroy(parser.lt_pr_dmacro);
        return (-1);

}

/*
 * Init function, called when latencytop starts.
 * It loads translation rules from the configuration file. The configuration
 * file defines some causes and symbols that match those causes.
 */
int
lt_table_init(void)
{
        char *config_loaded = NULL;
        int config_loaded_len = 0;
        const char *work = NULL;
        int work_len = 0;
        lt_cause_t *cause;

#ifdef EMBED_CONFIGS
        work = &latencytop_trans_start;
        work_len = (int)(&latencytop_trans_end - &latencytop_trans_start);
#endif

        if (g_config.lt_cfg_config_name != NULL) {
                FILE *fp;
                fp = fopen(g_config.lt_cfg_config_name, "r");

                if (NULL == fp) {
                        lt_display_error(
                            "Unable to open configuration file.\n");
                        return (-1);
                }

                (void) fseek(fp, 0, SEEK_END);
                config_loaded_len = (int)ftell(fp);
                config_loaded = (char *)lt_malloc(config_loaded_len);
                (void) fseek(fp, 0, SEEK_SET);

                /* A zero-byte translation is valid */
                if (config_loaded_len != 0 &&
                    fread(config_loaded, config_loaded_len, 1, fp) == 0) {
                        lt_display_error(
                            "Unable to read configuration file.\n");
                        (void) fclose(fp);
                        free(config_loaded);
                        return (-1);
                }

                (void) fclose(fp);
                (void) printf("Loaded configuration from %s\n",
                    g_config.lt_cfg_config_name);

                work = config_loaded;
                work_len = config_loaded_len;
        }

        lt_table_deinit();
        causes_array = g_ptr_array_new();
        lt_check_null(causes_array);

        /* 0 is not used, but it is kept as a place for bugs etc. */
        cause = new_cause(lt_strdup("Nothing"), CAUSE_FLAG_DISABLED);
        g_assert(cause->lt_c_cause_id == INVALID_CAUSE);

        symbol_lookup_table = g_hash_table_new_full(
            g_str_hash, g_str_equal,
            (GDestroyNotify)free, (GDestroyNotify)free);
        lt_check_null(symbol_lookup_table);

        if (work_len != 0 && parse_config(work, work_len) != 0) {
                return (-1);
        }

        if (config_loaded != NULL) {
                free(config_loaded);
        }

        return (0);
}

/*
 * Some causes, such as "lock spinning", do not have stack trace. Names
 * of such causes are explicitly specified in the D script.
 * This function resolves such causes and dynamically adds them
 * to the global tables when they are found first. If auto_create is set
 * to TRUE, the entry will be created if it is not found.
 * Return cause_id of the cause.
 */
int
lt_table_cause_from_name(char *name, int auto_create, int flags)
{
        lt_cause_t *cause = NULL;

        if (cause_lookup == NULL) {
                cause_lookup = g_hash_table_new(g_str_hash, g_str_equal);
                lt_check_null(cause_lookup);
        } else   {
                cause = (lt_cause_t *)
                    g_hash_table_lookup(cause_lookup, name);
        }

        if (cause == NULL && auto_create) {
                char *cause_dup;

                if (name[0] == '#') {
                        flags |= CAUSE_FLAG_HIDE_IN_SUMMARY;
                }

                cause_dup = lt_strdup(name);
                cause = new_cause(cause_dup, flags);
                g_hash_table_insert(cause_lookup, cause_dup, cause);
        }

        return (cause == NULL ? INVALID_CAUSE : cause->lt_c_cause_id);
}

/*
 * Try to map a symbol on stack to a known cause.
 * module_func has the format "module_name`function_name".
 * cause_id and priority will be set if a cause is found.
 * If cause is found return 1, otherwise return 0.
 */
int
lt_table_cause_from_stack(const char *module_func, int *cause_id, int *priority)
{
        lt_match_t *match;

        g_assert(module_func != NULL && cause_id != NULL && priority != NULL);

        if (symbol_lookup_table == NULL) {
                return (0);
        }

        match = (lt_match_t *)
            g_hash_table_lookup(symbol_lookup_table, module_func);

        if (match == NULL) {
                char *func = strchr(module_func, '`');

                if (func != NULL) {
                        match = (lt_match_t *)
                            g_hash_table_lookup(symbol_lookup_table, func);
                }
        }

        if (match == NULL) {
                return (0);
        } else   {
                *cause_id = match->lt_mt_cause_id;
                *priority = match->lt_mt_priority;
                return (1);
        }
}

/*
 * Get the display name of a cause. cause_id must be valid,
 * it is usually returned from lt_table_cause_from_stack() or
 * lt_table_cause_from_name().
 */
const char *
lt_table_get_cause_name(int cause_id)
{
        lt_cause_t *cause;

        if (cause_id < 0 || cause_id >= causes_array_len) {
                return (NULL);
        }

        cause = (lt_cause_t *)g_ptr_array_index(causes_array, cause_id);

        if (cause == NULL) {
                return (NULL);
        } else {
                return (cause->lt_c_name);
        }
}

/*
 * Check cause flag.
 * If CAUSE_ALL_FLAGS is passed in, all flags are returned.
 */
int
lt_table_get_cause_flag(int cause_id, int flag)
{
        lt_cause_t *cause;

        if (cause_id < 0 || cause_id >= causes_array_len) {
                return (0);
        }

        cause = (lt_cause_t *)g_ptr_array_index(causes_array, cause_id);

        if (cause == NULL) {
                return (0);
        } else {
                return (cause->lt_c_flags & flag);
        }
}

/*
 * Append macros to D script, if any.
 */
int
lt_table_append_trans(FILE *fp)
{
        if (dtrans != NULL) {
                if (fwrite(dtrans, strlen(dtrans), 1, fp) != 1) {
                        return (-1);
                }
        }

        return (0);
}

/*
 * Clean up function.
 * Free the resources used for symbol table (symbols, causes etc.).
 */
void
lt_table_deinit(void)
{
        if (symbol_lookup_table != NULL) {
                g_hash_table_destroy(symbol_lookup_table);
                symbol_lookup_table = NULL;
        }

        if (cause_lookup != NULL) {
                g_hash_table_destroy(cause_lookup);
                cause_lookup = NULL;
        }

        if (causes_array != NULL) {
                g_ptr_array_foreach(causes_array, (GFunc)free_cause, NULL);
                g_ptr_array_free(causes_array, TRUE);
                causes_array = NULL;
                causes_array_len = 0;
        }

        if (dtrans != NULL) {
                g_free(dtrans);
                dtrans = NULL;
        }
}