scripts.c

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0
#include <elf.h>
#include <inttypes.h>
#include <sys/ttydefaults.h>
#include <string.h>
#include "../../util/sort.h"
#include "../../util/util.h"
#include "../../util/hist.h"
#include "../../util/debug.h"
#include "../../util/symbol.h"
#include "../browser.h"
#include "../helpline.h"
#include "../libslang.h"

/* 2048 lines should be enough for a script output */
#define MAX_LINES       2048

/* 160 bytes for one output line */
#define AVERAGE_LINE_LEN    160

struct script_line {
    struct list_head node;
    char line[AVERAGE_LINE_LEN];
};

struct perf_script_browser {
    struct ui_browser b;
    struct list_head entries;
    const char *script_name;
    int nr_lines;
};

#define SCRIPT_NAMELEN  128
#define SCRIPT_MAX_NO   64
/*
 * Usually the full path for a script is:
 *  /home/username/libexec/perf-core/scripts/python/xxx.py
 *  /home/username/libexec/perf-core/scripts/perl/xxx.pl
 * So 256 should be long enough to contain the full path.
 */
#define SCRIPT_FULLPATH_LEN 256

/*
 * When success, will copy the full path of the selected script
 * into  the buffer pointed by script_name, and return 0.
 * Return -1 on failure.
 */
static int list_scripts(char *script_name)
{
    char *buf, *names[SCRIPT_MAX_NO], *paths[SCRIPT_MAX_NO];
    int i, num, choice, ret = -1;

    /* Preset the script name to SCRIPT_NAMELEN */
    buf = malloc(SCRIPT_MAX_NO * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN));
    if (!buf)
        return ret;

    for (i = 0; i < SCRIPT_MAX_NO; i++) {
        names[i] = buf + i * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN);
        paths[i] = names[i] + SCRIPT_NAMELEN;
    }

    num = find_scripts(names, paths);
    if (num > 0) {
        choice = ui__popup_menu(num, names);
        if (choice < num && choice >= 0) {
            strcpy(script_name, paths[choice]);
            ret = 0;
        }
    }

    free(buf);
    return ret;
}

static void script_browser__write(struct ui_browser *browser,
                   void *entry, int row)
{
    struct script_line *sline = list_entry(entry, struct script_line, node);
    bool current_entry = ui_browser__is_current_entry(browser, row);

    ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
                               HE_COLORSET_NORMAL);

    ui_browser__write_nstring(browser, sline->line, browser->width);
}

static int script_browser__run(struct perf_script_browser *browser)
{
    int key;

    if (ui_browser__show(&browser->b, browser->script_name,
                 "Press ESC to exit") < 0)
        return -1;

    while (1) {
        key = ui_browser__run(&browser->b, 0);

        /* We can add some special key handling here if needed */
        break;
    }

    ui_browser__hide(&browser->b);
    return key;
}


int script_browse(const char *script_opt)
{
    char cmd[SCRIPT_FULLPATH_LEN*2], script_name[SCRIPT_FULLPATH_LEN];
    char *line = NULL;
    size_t len = 0;
    ssize_t retlen;
    int ret = -1, nr_entries = 0;
    FILE *fp;
    void *buf;
    struct script_line *sline;

    struct perf_script_browser script = {
        .b = {
            .refresh    = ui_browser__list_head_refresh,
            .seek       = ui_browser__list_head_seek,
            .write      = script_browser__write,
        },
        .script_name = script_name,
    };

    INIT_LIST_HEAD(&script.entries);

    /* Save each line of the output in one struct script_line object. */
    buf = zalloc((sizeof(*sline)) * MAX_LINES);
    if (!buf)
        return -1;
    sline = buf;

    memset(script_name, 0, SCRIPT_FULLPATH_LEN);
    if (list_scripts(script_name))
        goto exit;

    sprintf(cmd, "perf script -s %s ", script_name);

    if (script_opt)
        strcat(cmd, script_opt);

    if (input_name) {
        strcat(cmd, " -i ");
        strcat(cmd, input_name);
    }

    strcat(cmd, " 2>&1");

    fp = popen(cmd, "r");
    if (!fp)
        goto exit;

    while ((retlen = getline(&line, &len, fp)) != -1) {
        strncpy(sline->line, line, AVERAGE_LINE_LEN);

        /* If one output line is very large, just cut it short */
        if (retlen >= AVERAGE_LINE_LEN) {
            sline->line[AVERAGE_LINE_LEN - 1] = '\0';
            sline->line[AVERAGE_LINE_LEN - 2] = '\n';
        }
        list_add_tail(&sline->node, &script.entries);

        if (script.b.width < retlen)
            script.b.width = retlen;

        if (nr_entries++ >= MAX_LINES - 1)
            break;
        sline++;
    }

    if (script.b.width > AVERAGE_LINE_LEN)
        script.b.width = AVERAGE_LINE_LEN;

    free(line);
    pclose(fp);

    script.nr_lines = nr_entries;
    script.b.nr_entries = nr_entries;
    script.b.entries = &script.entries;

    ret = script_browser__run(&script);
exit:
    free(buf);
    return ret;
}