761 lines
14 KiB
C
761 lines
14 KiB
C
|
// SPDX-License-Identifier: GPL-2.0
|
||
|
|
/*
|
||
|
|
* Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <sys/stat.h>
|
||
|
|
|
||
|
|
#include "tracefs.h"
|
||
|
|
#include "trace-local.h"
|
||
|
|
|
||
|
|
|
||
|
|
static void dump_file_content(const char *path)
|
||
|
|
{
|
||
|
|
char buf[BUFSIZ];
|
||
|
|
ssize_t n;
|
||
|
|
FILE *fp;
|
||
|
|
|
||
|
|
fp = fopen(path, "r");
|
||
|
|
if (!fp)
|
||
|
|
die("reading %s", path);
|
||
|
|
|
||
|
|
do {
|
||
|
|
n = fread(buf, 1, BUFSIZ, fp);
|
||
|
|
if (n > 0)
|
||
|
|
fwrite(buf, 1, n, stdout);
|
||
|
|
} while (n > 0);
|
||
|
|
fclose(fp);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
void show_instance_file(struct buffer_instance *instance, const char *name)
|
||
|
|
{
|
||
|
|
char *path;
|
||
|
|
|
||
|
|
path = tracefs_instance_get_file(instance->tracefs, name);
|
||
|
|
dump_file_content(path);
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
}
|
||
|
|
|
||
|
|
enum {
|
||
|
|
SHOW_EVENT_FORMAT = 1 << 0,
|
||
|
|
SHOW_EVENT_FILTER = 1 << 1,
|
||
|
|
SHOW_EVENT_TRIGGER = 1 << 2,
|
||
|
|
SHOW_EVENT_FULL = 1 << 3,
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
void show_file(const char *name)
|
||
|
|
{
|
||
|
|
char *path;
|
||
|
|
|
||
|
|
path = tracefs_get_tracing_file(name);
|
||
|
|
dump_file_content(path);
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
}
|
||
|
|
|
||
|
|
typedef int (*process_file_func)(char *buf, int len, int flags);
|
||
|
|
|
||
|
|
static void process_file_re(process_file_func func,
|
||
|
|
const char *name, const char *re, int flags)
|
||
|
|
{
|
||
|
|
regex_t reg;
|
||
|
|
char *path;
|
||
|
|
char *buf = NULL;
|
||
|
|
char *str;
|
||
|
|
FILE *fp;
|
||
|
|
ssize_t n;
|
||
|
|
size_t l = strlen(re);
|
||
|
|
|
||
|
|
/* Just in case :-p */
|
||
|
|
if (!re || l == 0) {
|
||
|
|
show_file(name);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Handle the newline at end of names for the user */
|
||
|
|
str = malloc(l + 3);
|
||
|
|
if (!str)
|
||
|
|
die("Failed to allocate reg ex %s", re);
|
||
|
|
strcpy(str, re);
|
||
|
|
if (re[l-1] == '$')
|
||
|
|
strcpy(&str[l-1], "\n*$");
|
||
|
|
|
||
|
|
if (regcomp(®, str, REG_ICASE|REG_NOSUB))
|
||
|
|
die("invalid function regex '%s'", re);
|
||
|
|
|
||
|
|
free(str);
|
||
|
|
|
||
|
|
path = tracefs_get_tracing_file(name);
|
||
|
|
fp = fopen(path, "r");
|
||
|
|
if (!fp)
|
||
|
|
die("reading %s", path);
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
|
||
|
|
do {
|
||
|
|
n = getline(&buf, &l, fp);
|
||
|
|
if (n > 0 && regexec(®, buf, 0, NULL, 0) == 0)
|
||
|
|
func(buf, n, flags);
|
||
|
|
} while (n > 0);
|
||
|
|
free(buf);
|
||
|
|
fclose(fp);
|
||
|
|
|
||
|
|
regfree(®);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_event(process_file_func func, const char *system,
|
||
|
|
const char *event, int flags)
|
||
|
|
{
|
||
|
|
char *buf;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
ret = asprintf(&buf, "%s:%s", system, event);
|
||
|
|
if (ret < 0)
|
||
|
|
die("Can not allocate event");
|
||
|
|
func(buf, strlen(buf), flags);
|
||
|
|
free(buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_system(process_file_func func, const char *system, int flags)
|
||
|
|
{
|
||
|
|
char **events;
|
||
|
|
int e;
|
||
|
|
|
||
|
|
events = tracefs_system_events(NULL, system);
|
||
|
|
if (!events) /* die? */
|
||
|
|
return;
|
||
|
|
|
||
|
|
for (e = 0; events[e]; e++)
|
||
|
|
show_event(func, system, events[e], flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_event_systems(process_file_func func, char **systems, int flags)
|
||
|
|
{
|
||
|
|
int s;
|
||
|
|
|
||
|
|
for (s = 0; systems[s]; s++)
|
||
|
|
show_system(func, systems[s], flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void match_system_events(process_file_func func, const char *system,
|
||
|
|
regex_t *reg, int flags)
|
||
|
|
{
|
||
|
|
char **events;
|
||
|
|
int e;
|
||
|
|
|
||
|
|
events = tracefs_system_events(NULL, system);
|
||
|
|
if (!events) /* die? */
|
||
|
|
return;
|
||
|
|
for (e = 0; events[e]; e++) {
|
||
|
|
if (regexec(reg, events[e], 0, NULL, 0) == 0)
|
||
|
|
show_event(func, system, events[e], flags);
|
||
|
|
}
|
||
|
|
tracefs_list_free(events);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void process_events(process_file_func func, const char *re, int flags)
|
||
|
|
{
|
||
|
|
const char *ftrace = "ftrace";
|
||
|
|
regex_t system_reg;
|
||
|
|
regex_t event_reg;
|
||
|
|
char *str;
|
||
|
|
size_t l = strlen(re);
|
||
|
|
bool just_systems = true;
|
||
|
|
char **systems;
|
||
|
|
char *system;
|
||
|
|
char *event;
|
||
|
|
int s;
|
||
|
|
|
||
|
|
systems = tracefs_event_systems(NULL);
|
||
|
|
if (!systems)
|
||
|
|
return process_file_re(func, "available_events", re, flags);
|
||
|
|
|
||
|
|
if (!re || l == 0) {
|
||
|
|
show_event_systems(func, systems, flags);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
str = strdup(re);
|
||
|
|
if (!str)
|
||
|
|
die("Can not allocate momory for regex");
|
||
|
|
|
||
|
|
system = strtok(str, ":");
|
||
|
|
event = strtok(NULL, "");
|
||
|
|
|
||
|
|
if (regcomp(&system_reg, system, REG_ICASE|REG_NOSUB))
|
||
|
|
die("invalid regex '%s'", system);
|
||
|
|
|
||
|
|
if (event) {
|
||
|
|
if (regcomp(&event_reg, event, REG_ICASE|REG_NOSUB))
|
||
|
|
die("invalid regex '%s'", event);
|
||
|
|
} else {
|
||
|
|
/*
|
||
|
|
* If the regex ends with ":", then event would be null,
|
||
|
|
* but we do not want to match events.
|
||
|
|
*/
|
||
|
|
if (re[l-1] != ':')
|
||
|
|
just_systems = false;
|
||
|
|
}
|
||
|
|
free(str);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* See if this matches the special ftrace system, as ftrace is not included
|
||
|
|
* in the systems list, but can get events from tracefs_system_events().
|
||
|
|
*/
|
||
|
|
if (regexec(&system_reg, ftrace, 0, NULL, 0) == 0) {
|
||
|
|
if (!event)
|
||
|
|
show_system(func, ftrace, flags);
|
||
|
|
else
|
||
|
|
match_system_events(func, ftrace, &event_reg, flags);
|
||
|
|
} else if (!just_systems) {
|
||
|
|
match_system_events(func, ftrace, &system_reg, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (s = 0; systems[s]; s++) {
|
||
|
|
|
||
|
|
if (regexec(&system_reg, systems[s], 0, NULL, 0) == 0) {
|
||
|
|
if (!event) {
|
||
|
|
show_system(func, systems[s], flags);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
match_system_events(func, systems[s], &event_reg, flags);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (just_systems)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
match_system_events(func, systems[s], &system_reg, flags);
|
||
|
|
}
|
||
|
|
tracefs_list_free(systems);
|
||
|
|
|
||
|
|
regfree(&system_reg);
|
||
|
|
if (event)
|
||
|
|
regfree(&event_reg);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int show_file_write(char *buf, int len, int flags)
|
||
|
|
{
|
||
|
|
return fwrite(buf, 1, len, stdout);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_file_re(const char *name, const char *re)
|
||
|
|
{
|
||
|
|
process_file_re(show_file_write, name, re, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static char *get_event_file(const char *type, char *buf, int len)
|
||
|
|
{
|
||
|
|
char *system;
|
||
|
|
char *event;
|
||
|
|
char *path;
|
||
|
|
char *file;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
if (buf[len-1] == '\n')
|
||
|
|
buf[len-1] = '\0';
|
||
|
|
|
||
|
|
system = strtok(buf, ":");
|
||
|
|
if (!system)
|
||
|
|
die("no system found in %s", buf);
|
||
|
|
|
||
|
|
event = strtok(NULL, ":");
|
||
|
|
if (!event)
|
||
|
|
die("no event found in %s\n", buf);
|
||
|
|
|
||
|
|
path = tracefs_get_tracing_file("events");
|
||
|
|
ret = asprintf(&file, "%s/%s/%s/%s", path, system, event, type);
|
||
|
|
if (ret < 0)
|
||
|
|
die("Failed to allocate event file %s %s", system, event);
|
||
|
|
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
|
||
|
|
return file;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int event_filter_write(char *buf, int len, int flags)
|
||
|
|
{
|
||
|
|
char *file;
|
||
|
|
|
||
|
|
if (buf[len-1] == '\n')
|
||
|
|
buf[len-1] = '\0';
|
||
|
|
|
||
|
|
printf("%s\n", buf);
|
||
|
|
|
||
|
|
file = get_event_file("filter", buf, len);
|
||
|
|
dump_file_content(file);
|
||
|
|
free(file);
|
||
|
|
printf("\n");
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int event_trigger_write(char *buf, int len, int flags)
|
||
|
|
{
|
||
|
|
char *file;
|
||
|
|
|
||
|
|
if (buf[len-1] == '\n')
|
||
|
|
buf[len-1] = '\0';
|
||
|
|
|
||
|
|
printf("%s\n", buf);
|
||
|
|
|
||
|
|
file = get_event_file("trigger", buf, len);
|
||
|
|
dump_file_content(file);
|
||
|
|
free(file);
|
||
|
|
printf("\n");
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int event_format_write(char *fbuf, int len, int flags)
|
||
|
|
{
|
||
|
|
char *file = get_event_file("format", fbuf, len);
|
||
|
|
char *buf = NULL;
|
||
|
|
size_t l;
|
||
|
|
FILE *fp;
|
||
|
|
bool full;
|
||
|
|
int n;
|
||
|
|
|
||
|
|
full = flags & SHOW_EVENT_FULL;
|
||
|
|
|
||
|
|
/* The get_event_file() crops system in fbuf */
|
||
|
|
printf("system: %s\n", fbuf);
|
||
|
|
|
||
|
|
/* Don't print the print fmt, it's ugly */
|
||
|
|
|
||
|
|
fp = fopen(file, "r");
|
||
|
|
if (!fp)
|
||
|
|
die("reading %s", file);
|
||
|
|
|
||
|
|
do {
|
||
|
|
n = getline(&buf, &l, fp);
|
||
|
|
if (n > 0) {
|
||
|
|
if (!full && strncmp(buf, "print fmt", 9) == 0)
|
||
|
|
break;
|
||
|
|
fwrite(buf, 1, n, stdout);
|
||
|
|
}
|
||
|
|
} while (n > 0);
|
||
|
|
fclose(fp);
|
||
|
|
free(buf);
|
||
|
|
free(file);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int event_name(char *buf, int len, int flags)
|
||
|
|
{
|
||
|
|
printf("%s\n", buf);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_event_filter_re(const char *re)
|
||
|
|
{
|
||
|
|
process_events(event_filter_write, re, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_event_trigger_re(const char *re)
|
||
|
|
{
|
||
|
|
process_events(event_trigger_write, re, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_event_format_re(const char *re, int flags)
|
||
|
|
{
|
||
|
|
process_events(event_format_write, re, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_event_names_re(const char *re)
|
||
|
|
{
|
||
|
|
process_events(event_name, re, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_events(const char *eventre, int flags)
|
||
|
|
{
|
||
|
|
if (flags && !eventre)
|
||
|
|
die("When specifying event files, an event must be named");
|
||
|
|
|
||
|
|
if (eventre) {
|
||
|
|
if (flags & SHOW_EVENT_FORMAT)
|
||
|
|
show_event_format_re(eventre, flags);
|
||
|
|
|
||
|
|
else if (flags & SHOW_EVENT_FILTER)
|
||
|
|
show_event_filter_re(eventre);
|
||
|
|
|
||
|
|
else if (flags & SHOW_EVENT_TRIGGER)
|
||
|
|
show_event_trigger_re(eventre);
|
||
|
|
else
|
||
|
|
show_event_names_re(eventre);
|
||
|
|
} else
|
||
|
|
show_file("available_events");
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_tracers(void)
|
||
|
|
{
|
||
|
|
show_file("available_tracers");
|
||
|
|
}
|
||
|
|
|
||
|
|
void show_options(const char *prefix, struct buffer_instance *buffer)
|
||
|
|
{
|
||
|
|
struct tracefs_instance *instance = buffer ? buffer->tracefs : NULL;
|
||
|
|
struct dirent *dent;
|
||
|
|
struct stat st;
|
||
|
|
char *path;
|
||
|
|
DIR *dir;
|
||
|
|
|
||
|
|
if (!prefix)
|
||
|
|
prefix = "";
|
||
|
|
|
||
|
|
path = tracefs_instance_get_file(instance, "options");
|
||
|
|
if (!path)
|
||
|
|
goto show_file;
|
||
|
|
if (stat(path, &st) < 0)
|
||
|
|
goto show_file;
|
||
|
|
|
||
|
|
if ((st.st_mode & S_IFMT) != S_IFDIR)
|
||
|
|
goto show_file;
|
||
|
|
|
||
|
|
dir = opendir(path);
|
||
|
|
if (!dir)
|
||
|
|
die("Can not read instance directory");
|
||
|
|
|
||
|
|
while ((dent = readdir(dir))) {
|
||
|
|
const char *name = dent->d_name;
|
||
|
|
long long val;
|
||
|
|
char *file;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
if (strcmp(name, ".") == 0 ||
|
||
|
|
strcmp(name, "..") == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
ret = asprintf(&file, "options/%s", name);
|
||
|
|
if (ret < 0)
|
||
|
|
die("Failed to allocate file name");
|
||
|
|
ret = tracefs_instance_file_read_number(instance, file, &val);
|
||
|
|
if (!ret) {
|
||
|
|
if (val)
|
||
|
|
printf("%s%s\n", prefix, name);
|
||
|
|
else
|
||
|
|
printf("%sno%s\n", prefix, name);
|
||
|
|
}
|
||
|
|
free(file);
|
||
|
|
}
|
||
|
|
closedir(dir);
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
return;
|
||
|
|
|
||
|
|
show_file:
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
show_file("trace_options");
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_clocks(void)
|
||
|
|
{
|
||
|
|
char *clocks;
|
||
|
|
int size;
|
||
|
|
|
||
|
|
clocks = tracefs_instance_file_read(NULL, "trace_clock", &size);
|
||
|
|
if (!clocks)
|
||
|
|
die("getting clocks");
|
||
|
|
if (clocks[size - 1] == '\n')
|
||
|
|
clocks[size - 1] = 0;
|
||
|
|
|
||
|
|
if (trace_tsc2nsec_is_supported())
|
||
|
|
printf("%s %s\n", clocks, TSCNSEC_CLOCK);
|
||
|
|
else
|
||
|
|
printf("%s\n", clocks);
|
||
|
|
|
||
|
|
free(clocks);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_functions(const char *funcre)
|
||
|
|
{
|
||
|
|
if (funcre)
|
||
|
|
show_file_re("available_filter_functions", funcre);
|
||
|
|
else
|
||
|
|
show_file("available_filter_functions");
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_buffers(void)
|
||
|
|
{
|
||
|
|
struct dirent *dent;
|
||
|
|
DIR *dir;
|
||
|
|
char *path;
|
||
|
|
int printed = 0;
|
||
|
|
|
||
|
|
path = tracefs_get_tracing_file("instances");
|
||
|
|
dir = opendir(path);
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
if (!dir)
|
||
|
|
die("Can not read instance directory");
|
||
|
|
|
||
|
|
while ((dent = readdir(dir))) {
|
||
|
|
const char *name = dent->d_name;
|
||
|
|
|
||
|
|
if (strcmp(name, ".") == 0 ||
|
||
|
|
strcmp(name, "..") == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
printf("%s\n", name);
|
||
|
|
printed = 1;
|
||
|
|
}
|
||
|
|
closedir(dir);
|
||
|
|
|
||
|
|
if (!printed)
|
||
|
|
printf("No buffer instances defined\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_systems(void)
|
||
|
|
{
|
||
|
|
struct dirent *dent;
|
||
|
|
char *path;
|
||
|
|
DIR *dir;
|
||
|
|
|
||
|
|
path = tracefs_get_tracing_file("events");
|
||
|
|
dir = opendir(path);
|
||
|
|
|
||
|
|
if (!dir)
|
||
|
|
die("Can not read events directory");
|
||
|
|
|
||
|
|
while ((dent = readdir(dir))) {
|
||
|
|
const char *name = dent->d_name;
|
||
|
|
struct stat st;
|
||
|
|
char *spath;
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
if (strcmp(name, ".") == 0 ||
|
||
|
|
strcmp(name, "..") == 0)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (asprintf(&spath, "%s/%s", path, name) < 0)
|
||
|
|
continue;
|
||
|
|
ret = stat(spath, &st);
|
||
|
|
if (!ret && S_ISDIR(st.st_mode))
|
||
|
|
printf("%s\n", name);
|
||
|
|
|
||
|
|
free(spath);
|
||
|
|
}
|
||
|
|
|
||
|
|
printf("\n");
|
||
|
|
closedir(dir);
|
||
|
|
tracefs_put_tracing_file(path);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_plugin_options(void)
|
||
|
|
{
|
||
|
|
struct tep_handle *pevent;
|
||
|
|
struct tep_plugin_list *list;
|
||
|
|
struct trace_seq s;
|
||
|
|
|
||
|
|
tracecmd_ftrace_load_options();
|
||
|
|
|
||
|
|
pevent = tep_alloc();
|
||
|
|
if (!pevent)
|
||
|
|
die("Can not allocate pevent\n");
|
||
|
|
|
||
|
|
trace_seq_init(&s);
|
||
|
|
|
||
|
|
list = trace_load_plugins(pevent, 0);
|
||
|
|
tep_plugin_print_options(&s);
|
||
|
|
trace_seq_do_printf(&s);
|
||
|
|
tep_unload_plugins(list, pevent);
|
||
|
|
tep_free(pevent);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void trace_option(int argc, char **argv)
|
||
|
|
{
|
||
|
|
show_plugin_options();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void show_plugins(void)
|
||
|
|
{
|
||
|
|
struct tep_handle *pevent;
|
||
|
|
struct tep_plugin_list *list;
|
||
|
|
struct trace_seq s;
|
||
|
|
|
||
|
|
pevent = tep_alloc();
|
||
|
|
if (!pevent)
|
||
|
|
die("Can not allocate pevent\n");
|
||
|
|
|
||
|
|
trace_seq_init(&s);
|
||
|
|
|
||
|
|
list = trace_load_plugins(pevent, 0);
|
||
|
|
tep_print_plugins(&s, " ", "\n", list);
|
||
|
|
|
||
|
|
trace_seq_do_printf(&s);
|
||
|
|
tep_unload_plugins(list, pevent);
|
||
|
|
tep_free(pevent);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void show_compression(void)
|
||
|
|
{
|
||
|
|
char **versions, **names;
|
||
|
|
int c, i;
|
||
|
|
|
||
|
|
c = tracecmd_compress_protos_get(&names, &versions);
|
||
|
|
if (c <= 0) {
|
||
|
|
printf("No compression algorithms are supported\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
printf("Supported compression algorithms:\n");
|
||
|
|
for (i = 0; i < c; i++)
|
||
|
|
printf("\t%s, %s\n", names[i], versions[i]);
|
||
|
|
|
||
|
|
free(names);
|
||
|
|
free(versions);
|
||
|
|
}
|
||
|
|
|
||
|
|
void trace_list(int argc, char **argv)
|
||
|
|
{
|
||
|
|
int events = 0;
|
||
|
|
int tracer = 0;
|
||
|
|
int options = 0;
|
||
|
|
int funcs = 0;
|
||
|
|
int buffers = 0;
|
||
|
|
int clocks = 0;
|
||
|
|
int plug = 0;
|
||
|
|
int plug_op = 0;
|
||
|
|
int flags = 0;
|
||
|
|
int systems = 0;
|
||
|
|
int show_all = 1;
|
||
|
|
int compression = 0;
|
||
|
|
int i;
|
||
|
|
const char *arg;
|
||
|
|
const char *funcre = NULL;
|
||
|
|
const char *eventre = NULL;
|
||
|
|
|
||
|
|
for (i = 2; i < argc; i++) {
|
||
|
|
arg = NULL;
|
||
|
|
if (argv[i][0] == '-') {
|
||
|
|
if (i < argc - 1) {
|
||
|
|
if (argv[i+1][0] != '-')
|
||
|
|
arg = argv[i+1];
|
||
|
|
}
|
||
|
|
switch (argv[i][1]) {
|
||
|
|
case 'h':
|
||
|
|
usage(argv);
|
||
|
|
break;
|
||
|
|
case 'e':
|
||
|
|
events = 1;
|
||
|
|
eventre = arg;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'B':
|
||
|
|
buffers = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'C':
|
||
|
|
clocks = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'F':
|
||
|
|
flags |= SHOW_EVENT_FORMAT;
|
||
|
|
break;
|
||
|
|
case 'R':
|
||
|
|
flags |= SHOW_EVENT_TRIGGER;
|
||
|
|
break;
|
||
|
|
case 'l':
|
||
|
|
flags |= SHOW_EVENT_FILTER;
|
||
|
|
break;
|
||
|
|
case 'p':
|
||
|
|
case 't':
|
||
|
|
tracer = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'P':
|
||
|
|
plug = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'O':
|
||
|
|
plug_op = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'o':
|
||
|
|
options = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'f':
|
||
|
|
funcs = 1;
|
||
|
|
funcre = arg;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 's':
|
||
|
|
systems = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case 'c':
|
||
|
|
compression = 1;
|
||
|
|
show_all = 0;
|
||
|
|
break;
|
||
|
|
case '-':
|
||
|
|
if (strcmp(argv[i], "--debug") == 0) {
|
||
|
|
tracecmd_set_debug(true);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (strcmp(argv[i], "--full") == 0) {
|
||
|
|
flags |= SHOW_EVENT_FULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
fprintf(stderr, "list: invalid option -- '%s'\n",
|
||
|
|
argv[i]);
|
||
|
|
default:
|
||
|
|
fprintf(stderr, "list: invalid option -- '%c'\n",
|
||
|
|
argv[i][1]);
|
||
|
|
usage(argv);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (events)
|
||
|
|
show_events(eventre, flags);
|
||
|
|
|
||
|
|
if (tracer)
|
||
|
|
show_tracers();
|
||
|
|
|
||
|
|
if (options)
|
||
|
|
show_options(NULL, NULL);
|
||
|
|
|
||
|
|
if (plug)
|
||
|
|
show_plugins();
|
||
|
|
|
||
|
|
if (plug_op)
|
||
|
|
show_plugin_options();
|
||
|
|
|
||
|
|
if (funcs)
|
||
|
|
show_functions(funcre);
|
||
|
|
|
||
|
|
if (buffers)
|
||
|
|
show_buffers();
|
||
|
|
|
||
|
|
if (clocks)
|
||
|
|
show_clocks();
|
||
|
|
if (systems)
|
||
|
|
show_systems();
|
||
|
|
if (compression)
|
||
|
|
show_compression();
|
||
|
|
if (show_all) {
|
||
|
|
printf("event systems:\n");
|
||
|
|
show_systems();
|
||
|
|
printf("events:\n");
|
||
|
|
show_events(NULL, 0);
|
||
|
|
printf("\ntracers:\n");
|
||
|
|
show_tracers();
|
||
|
|
printf("\noptions:\n");
|
||
|
|
show_options(NULL, NULL);
|
||
|
|
show_compression();
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
|
||
|
|
}
|