* [PATCH v3] trace-cmd: Handle filtered PIDs per ftarce instance
@ 2020-05-05 10:17 Tzvetomir Stoyanov (VMware)
2020-05-05 10:17 ` [PATCH v3] trace-cmd: List ftrace instances at the end of trace-cmd stat Tzvetomir Stoyanov (VMware)
0 siblings, 1 reply; 2+ messages in thread
From: Tzvetomir Stoyanov (VMware) @ 2020-05-05 10:17 UTC (permalink / raw)
To: rostedt; +Cc: linux-trace-devel
Ftrace supports PID filtering per instance. Currently
trace-cmd does not use this functionality, all PIDs specified
with "-P" option are propagated to all configured tracing instances.
The patch affects these trace-cmd options:
-P, -O, -T, --proc-map
their configuration scope is limited to the specified ftrace instance
only. If no instance is specified, the configuration is applied to
the main instance.
Signed-off-by: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
---
v3: Check if event / function fork is supported by the kernel using the top
frtace instance, as the other instances are not yet created when the
arguments are parsed.
tracecmd/include/trace-local.h | 24 +-
tracecmd/trace-record.c | 535 ++++++++++++++++++---------------
2 files changed, 317 insertions(+), 242 deletions(-)
diff --git a/tracecmd/include/trace-local.h b/tracecmd/include/trace-local.h
index 0f58c772..4c6a63d0 100644
--- a/tracecmd/include/trace-local.h
+++ b/tracecmd/include/trace-local.h
@@ -184,6 +184,17 @@ struct pid_addr_maps {
int pid;
};
+struct opt_list {
+ struct opt_list *next;
+ const char *option;
+};
+
+struct filter_pids {
+ struct filter_pids *next;
+ int pid;
+ int exclude;
+};
+
struct buffer_instance {
struct buffer_instance *next;
struct tracefs_instance *tracefs;
@@ -202,6 +213,18 @@ struct buffer_instance {
struct func_list *filter_funcs;
struct func_list *notrace_funcs;
+ struct opt_list *options;
+ struct filter_pids *filter_pids;
+ char *common_pid_filter;
+ int nr_filter_pids;
+ int len_filter_pids;
+ bool ptrace_child;
+
+ int have_set_event_pid;
+ int have_event_fork;
+ int have_func_fork;
+ int get_procmap;
+
const char *clock;
unsigned int *client_ports;
@@ -260,7 +283,6 @@ int get_guest_vcpu_pid(unsigned int guest_cid, unsigned int guest_vcpu);
/* moved from trace-cmd.h */
void tracecmd_create_top_instance(char *name);
void tracecmd_remove_instances(void);
-void tracecmd_filter_pid(int pid, int exclude);
int tracecmd_add_event(const char *event_str, int stack);
void tracecmd_enable_events(void);
void tracecmd_disable_all_tracing(int disable_tracer);
diff --git a/tracecmd/trace-record.c b/tracecmd/trace-record.c
index 1e4d38fa..d0619ba6 100644
--- a/tracecmd/trace-record.c
+++ b/tracecmd/trace-record.c
@@ -90,8 +90,6 @@ static int max_kb;
static bool use_tcp;
static int do_ptrace;
-static int do_children;
-static int get_procmap;
static int filter_task;
static bool no_filter = false;
@@ -114,31 +112,8 @@ static int func_stack;
static int save_stdout = -1;
-struct filter_pids {
- struct filter_pids *next;
- int pid;
- int exclude;
-};
-
-static struct filter_pids *filter_pids;
-static int nr_filter_pids;
-static int len_filter_pids;
-
-static int have_set_event_pid;
-static int have_event_fork;
-static int have_func_fork;
-
-struct opt_list {
- struct opt_list *next;
- const char *option;
-};
-
-static struct opt_list *options;
-
static struct hook_list *hooks;
-static char *common_pid_filter;
-
struct event_list {
struct event_list *next;
const char *event;
@@ -227,7 +202,6 @@ struct common_record_context {
int date;
int manual;
int topt;
- int do_child;
int run_command;
int saved_cmdlines_size;
};
@@ -327,41 +301,47 @@ void add_instance(struct buffer_instance *instance, int cpu_count)
buffers++;
}
-static void test_set_event_pid(void)
+static void instance_reset_file_save(struct buffer_instance *instance, char *file, int prio)
{
- static int tested;
- struct stat st;
char *path;
- int ret;
- if (tested)
- return;
-
- path = tracefs_get_tracing_file("set_event_pid");
- ret = stat(path, &st);
- if (!ret) {
- have_set_event_pid = 1;
- reset_save_file(path, RESET_DEFAULT_PRIO);
- }
+ path = tracefs_instance_get_file(instance->tracefs, file);
+ if (path)
+ reset_save_file(path, prio);
tracefs_put_tracing_file(path);
+}
- path = tracefs_get_tracing_file("options/event-fork");
- ret = stat(path, &st);
- if (!ret) {
- have_event_fork = 1;
- reset_save_file(path, RESET_DEFAULT_PRIO);
- }
- tracefs_put_tracing_file(path);
+static void test_set_event_pid(struct buffer_instance *instance)
+{
+ static int have_set_event_pid;
+ static int have_event_fork;
+ static int have_func_fork;
- path = tracefs_get_tracing_file("options/function-fork");
- ret = stat(path, &st);
- if (!ret) {
+ if (!have_set_event_pid &&
+ tracefs_file_exists(top_instance.tracefs, "set_event_pid"))
+ have_set_event_pid = 1;
+ if (!have_event_fork &&
+ tracefs_file_exists(top_instance.tracefs, "options/event-fork"))
+ have_event_fork = 1;
+ if (!have_func_fork &&
+ tracefs_file_exists(top_instance.tracefs, "options/function-fork"))
have_func_fork = 1;
- reset_save_file(path, RESET_DEFAULT_PRIO);
- }
- tracefs_put_tracing_file(path);
- tested = 1;
+ if (!instance->have_set_event_pid && have_set_event_pid) {
+ instance->have_set_event_pid = 1;
+ instance_reset_file_save(instance, "set_event_pid",
+ RESET_DEFAULT_PRIO);
+ }
+ if (!instance->have_event_fork && have_event_fork) {
+ instance->have_event_fork = 1;
+ instance_reset_file_save(instance, "options/event-fork",
+ RESET_DEFAULT_PRIO);
+ }
+ if (!instance->have_func_fork && have_func_fork) {
+ instance->have_func_fork = 1;
+ instance_reset_file_save(instance, "options/function-fork",
+ RESET_DEFAULT_PRIO);
+ }
}
/**
@@ -864,70 +844,74 @@ static void reset_max_latency(struct buffer_instance *instance)
"tracing_max_latency", "0");
}
-static void add_filter_pid(int pid, int exclude)
+static int add_filter_pid(struct buffer_instance *instance, int pid, int exclude)
{
struct filter_pids *p;
char buf[100];
- for (p = filter_pids; p; p = p->next) {
+ for (p = instance->filter_pids; p; p = p->next) {
if (p->pid == pid) {
p->exclude = exclude;
- return;
+ return 0;
}
}
p = malloc(sizeof(*p));
if (!p)
die("Failed to allocate pid filter");
- p->next = filter_pids;
+ p->next = instance->filter_pids;
p->exclude = exclude;
p->pid = pid;
- filter_pids = p;
- nr_filter_pids++;
+ instance->filter_pids = p;
+ instance->nr_filter_pids++;
+
+ instance->len_filter_pids += sprintf(buf, "%d", pid);
- len_filter_pids += sprintf(buf, "%d", pid);
+ return 1;
+}
+
+static void add_filter_pid_all(int pid, int exclude)
+{
+ struct buffer_instance *instance;
+
+ for_all_instances(instance)
+ add_filter_pid(instance, pid, exclude);
}
-static void update_ftrace_pid(const char *pid, int reset)
+static void reset_save_ftrace_pid(struct buffer_instance *instance)
{
static char *path;
+
+ if (!tracefs_file_exists(instance->tracefs, "set_ftrace_pid"))
+ return;
+
+ path = tracefs_instance_get_file(instance->tracefs, "set_ftrace_pid");
+ if (!path)
+ return;
+
+ reset_save_file_cond(path, RESET_DEFAULT_PRIO, "no pid", "");
+
+ tracefs_put_tracing_file(path);
+}
+
+static void update_ftrace_pid(struct buffer_instance *instance,
+ const char *pid, int reset)
+{
+ int fd = -1;
+ char *path;
int ret;
- static int fd = -1;
- static int first = 1;
- struct stat st;
- if (!pid) {
- if (fd >= 0)
- close(fd);
- if (path)
- tracefs_put_tracing_file(path);
- fd = -1;
- path = NULL;
+ if (!tracefs_file_exists(instance->tracefs, "set_ftrace_pid"))
return;
- }
- /* Force reopen on reset */
- if (reset && fd >= 0) {
- close(fd);
- fd = -1;
- }
+ path = tracefs_instance_get_file(instance->tracefs, "set_ftrace_pid");
+ if (!path)
+ return;
- if (fd < 0) {
- if (!path)
- path = tracefs_get_tracing_file("set_ftrace_pid");
- if (!path)
- return;
- ret = stat(path, &st);
- if (ret < 0)
- return;
- if (first) {
- first = 0;
- reset_save_file_cond(path, RESET_DEFAULT_PRIO, "no pid", "");
- }
- fd = open(path, O_WRONLY | O_CLOEXEC | (reset ? O_TRUNC : 0));
- if (fd < 0)
- return;
- }
+ fd = open(path, O_WRONLY | O_CLOEXEC | (reset ? O_TRUNC : 0));
+ tracefs_put_tracing_file(path);
+ if (fd < 0)
+ return;
ret = write(fd, pid, strlen(pid));
@@ -939,24 +923,35 @@ static void update_ftrace_pid(const char *pid, int reset)
if (ret < 0)
die("error writing to %s", path);
-
/* add whitespace in case another pid is written */
write(fd, " ", 1);
+ close(fd);
}
static void update_ftrace_pids(int reset)
{
- char buf[100];
+ struct buffer_instance *instance;
struct filter_pids *pid;
+ static int first = 1;
+ char buf[100];
+ int rst;
- for (pid = filter_pids; pid; pid = pid->next) {
- if (pid->exclude)
- continue;
- snprintf(buf, 100, "%d ", pid->pid);
- update_ftrace_pid(buf, reset);
- /* Only reset the first entry */
- reset = 0;
+ for_all_instances(instance) {
+ if (first)
+ reset_save_ftrace_pid(instance);
+ rst = reset;
+ for (pid = instance->filter_pids; pid; pid = pid->next) {
+ if (pid->exclude)
+ continue;
+ snprintf(buf, 100, "%d ", pid->pid);
+ update_ftrace_pid(instance, buf, rst);
+ /* Only reset the first entry */
+ rst = 0;
+ }
}
+
+ if (first)
+ first = 0;
}
static void update_event_filters(struct buffer_instance *instance);
@@ -1026,7 +1021,8 @@ static void append_filter_pid_range(char **filter, int *curr_len,
* If @curr_filter is not NULL, it will add this string as:
* (@curr_filter) && ((@field == pid) || ...)
*/
-static char *make_pid_filter(char *curr_filter, const char *field)
+static char *make_pid_filter(struct buffer_instance *instance,
+ char *curr_filter, const char *field)
{
int start_pid = -1, last_pid = -1;
int last_exclude = -1;
@@ -1035,13 +1031,13 @@ static char *make_pid_filter(char *curr_filter, const char *field)
int curr_len = 0;
/* Use the new method if possible */
- if (have_set_event_pid)
+ if (instance->have_set_event_pid)
return NULL;
- if (!filter_pids)
+ if (!instance->filter_pids)
return curr_filter;
- for (p = filter_pids; p; p = p->next) {
+ for (p = instance->filter_pids; p; p = p->next) {
/*
* PIDs are inserted in `filter_pids` from the front and that's
* why we expect them in descending order here.
@@ -1075,9 +1071,8 @@ static char *make_pid_filter(char *curr_filter, const char *field)
#define _STRINGIFY(x) #x
#define STRINGIFY(x) _STRINGIFY(x)
-static int get_pid_addr_maps(int pid)
+static int get_pid_addr_maps(struct buffer_instance *instance, int pid)
{
- struct buffer_instance *instance = &top_instance;
struct pid_addr_maps *maps = instance->pid_maps;
struct tracecmd_proc_addr_map *map;
unsigned long long begin, end;
@@ -1178,12 +1173,17 @@ out_fail:
static void get_filter_pid_maps(void)
{
+ struct buffer_instance *instance;
struct filter_pids *p;
- for (p = filter_pids; p; p = p->next) {
- if (p->exclude)
+ for_all_instances(instance) {
+ if (!instance->get_procmap)
continue;
- get_pid_addr_maps(p->pid);
+ for (p = instance->filter_pids; p; p = p->next) {
+ if (p->exclude)
+ continue;
+ get_pid_addr_maps(instance, p->pid);
+ }
}
}
@@ -1195,32 +1195,19 @@ static void update_task_filter(void)
if (no_filter)
return;
- if (get_procmap && filter_pids)
- get_filter_pid_maps();
+ get_filter_pid_maps();
if (filter_task)
- add_filter_pid(pid, 0);
-
- if (!filter_pids)
- return;
-
- common_pid_filter = make_pid_filter(NULL, "common_pid");
-
- update_ftrace_pids(1);
- for_all_instances(instance)
- update_pid_event_filters(instance);
-}
-
-void tracecmd_filter_pid(int pid, int exclude)
-{
- struct buffer_instance *instance;
-
- add_filter_pid(pid, exclude);
- common_pid_filter = make_pid_filter(NULL, "common_pid");
-
- if (!filter_pids)
- return;
+ add_filter_pid_all(pid, 0);
+ for_all_instances(instance) {
+ if (!instance->filter_pids)
+ continue;
+ if (instance->common_pid_filter)
+ free(instance->common_pid_filter);
+ instance->common_pid_filter = make_pid_filter(instance, NULL,
+ "common_pid");
+ }
update_ftrace_pids(1);
for_all_instances(instance)
update_pid_event_filters(instance);
@@ -1287,8 +1274,6 @@ static void append_sched_event(struct event_list *event, const char *field, int
static void update_sched_events(struct buffer_instance *instance, int pid)
{
- if (have_set_event_pid)
- return;
/*
* Also make sure that the sched_switch to this pid
* and wakeups of this pid are also traced.
@@ -1302,36 +1287,44 @@ static void update_sched_events(struct buffer_instance *instance, int pid)
static int open_instance_fd(struct buffer_instance *instance,
const char *file, int flags);
-static void add_event_pid(const char *buf)
+static void add_event_pid(struct buffer_instance *instance, const char *buf)
{
- struct buffer_instance *instance;
-
- for_all_instances(instance)
- tracefs_instance_file_write(instance->tracefs,
- "set_event_pid", buf);
+ tracefs_instance_file_write(instance->tracefs, "set_event_pid", buf);
}
-static void add_new_filter_pid(int pid)
+static void add_new_filter_child_pid(int pid, int child)
{
struct buffer_instance *instance;
+ struct filter_pids *fpid;
char buf[100];
- add_filter_pid(pid, 0);
- sprintf(buf, "%d", pid);
- update_ftrace_pid(buf, 0);
-
- if (have_set_event_pid)
- return add_event_pid(buf);
+ for_all_instances(instance) {
+ if (!instance->ptrace_child || !instance->filter_pids)
+ continue;
+ for (fpid = instance->filter_pids; fpid; fpid = fpid->next) {
+ if (fpid->pid == pid)
+ break;
+ }
+ if (!fpid)
+ continue;
- common_pid_filter = append_pid_filter(common_pid_filter, "common_pid", pid);
+ add_filter_pid(instance, child, 0);
+ sprintf(buf, "%d", child);
+ update_ftrace_pid(instance, buf, 0);
- for_all_instances(instance) {
- update_sched_events(instance, pid);
- update_event_filters(instance);
+ instance->common_pid_filter = append_pid_filter(instance->common_pid_filter,
+ "common_pid", pid);
+ if (instance->have_set_event_pid) {
+ add_event_pid(instance, buf);
+ } else {
+ update_sched_events(instance, pid);
+ update_event_filters(instance);
+ }
}
+
}
-static void ptrace_attach(int pid)
+static void ptrace_attach(struct buffer_instance *instance, int pid)
{
int ret;
@@ -1341,7 +1334,10 @@ static void ptrace_attach(int pid)
do_ptrace = 0;
return;
}
- add_filter_pid(pid, 0);
+ if (instance)
+ add_filter_pid(instance, pid, 0);
+ else
+ add_filter_pid_all(pid, 0);
}
static void enable_ptrace(void)
@@ -1352,11 +1348,32 @@ static void enable_ptrace(void)
ptrace(PTRACE_TRACEME, 0, NULL, 0);
}
+static struct buffer_instance *get_intance_fpid(int pid)
+{
+ struct buffer_instance *instance;
+ struct filter_pids *fpid;
+
+ for_all_instances(instance) {
+ for (fpid = instance->filter_pids; fpid; fpid = fpid->next) {
+ if (fpid->exclude)
+ continue;
+ if (fpid->pid == pid)
+ break;
+ }
+ if (fpid)
+ return instance;
+ }
+
+ return NULL;
+}
+
static void ptrace_wait(enum trace_type type)
{
+ struct buffer_instance *instance;
struct filter_pids *fpid;
unsigned long send_sig;
unsigned long child;
+ int nr_pids = 0;
siginfo_t sig;
int main_pids;
int cstatus;
@@ -1367,18 +1384,24 @@ static void ptrace_wait(enum trace_type type)
int pid;
int ret;
- pids = calloc(nr_filter_pids, sizeof(int));
+
+ for_all_instances(instance)
+ nr_pids += instance->nr_filter_pids;
+
+ pids = calloc(nr_pids, sizeof(int));
if (!pids) {
- warning("Unable to allocate array for %d PIDs", nr_filter_pids);
+ warning("Unable to allocate array for %d PIDs", nr_pids);
return;
}
-
- for (fpid = filter_pids; fpid; fpid = fpid->next) {
- if (fpid->exclude)
+ for_all_instances(instance) {
+ if (!instance->ptrace_child && !instance->get_procmap)
continue;
- pids[i++] = fpid->pid;
- if (i >= nr_filter_pids)
- break;
+
+ for (fpid = instance->filter_pids; fpid && i < nr_pids; fpid = fpid->next) {
+ if (fpid->exclude)
+ continue;
+ pids[i++] = fpid->pid;
+ }
}
main_pids = i;
@@ -1407,13 +1430,14 @@ static void ptrace_wait(enum trace_type type)
PTRACE_O_TRACEVFORK |
PTRACE_O_TRACECLONE |
PTRACE_O_TRACEEXIT);
- add_new_filter_pid(child);
+ add_new_filter_child_pid(pid, child);
ptrace(PTRACE_CONT, child, NULL, 0);
break;
case PTRACE_EVENT_EXIT:
- if (get_procmap)
- get_pid_addr_maps(pid);
+ instance = get_intance_fpid(pid);
+ if (instance && instance->get_procmap)
+ get_pid_addr_maps(instance, pid);
ptrace(PTRACE_GETEVENTMSG, pid, NULL, &cstatus);
ptrace(PTRACE_DETACH, pid, NULL, NULL);
break;
@@ -1427,13 +1451,12 @@ static void ptrace_wait(enum trace_type type)
}
if (WIFEXITED(status) ||
(WIFSTOPPED(status) && event == PTRACE_EVENT_EXIT)) {
- for (i = 0; i < nr_filter_pids; i++) {
+ for (i = 0; i < nr_pids; i++) {
if (pid == pids[i]) {
pids[i] = 0;
main_pids--;
if (!main_pids)
finished = 1;
- break;
}
}
}
@@ -1444,15 +1467,15 @@ static void ptrace_wait(enum trace_type type)
#else
static inline void ptrace_wait(enum trace_type type) { }
static inline void enable_ptrace(void) { }
-static inline void ptrace_attach(int pid) { }
+static inline void ptrace_attach(struct buffer_instance *instance, int pid) { }
#endif /* NO_PTRACE */
-static void trace_or_sleep(enum trace_type type)
+static void trace_or_sleep(enum trace_type type, bool pwait)
{
struct timeval tv = { 1 , 0 };
- if (do_ptrace && filter_pids)
+ if (pwait)
ptrace_wait(type);
else if (type & TRACE_TYPE_STREAM)
trace_stream_read(pids, recorder_threads, &tv);
@@ -1520,8 +1543,7 @@ static void run_cmd(enum trace_type type, const char *user, int argc, char **arg
}
}
if (do_ptrace) {
- add_filter_pid(pid, 0);
- ptrace_attach(pid);
+ ptrace_attach(NULL, pid);
ptrace_wait(type);
} else
trace_waitpid(type, pid, &status, 0);
@@ -1590,24 +1612,24 @@ static void set_plugin(const char *name)
set_plugin_instance(instance, name);
}
-static void save_option(const char *option)
+static void save_option(struct buffer_instance *instance, const char *option)
{
struct opt_list *opt;
opt = malloc(sizeof(*opt));
if (!opt)
die("Failed to allocate option");
- opt->next = options;
- options = opt;
+ opt->next = instance->options;
+ instance->options = opt;
opt->option = option;
}
-static int set_option(const char *option)
+static int set_option(struct buffer_instance *instance, const char *option)
{
FILE *fp;
char *path;
- path = tracefs_get_tracing_file("trace_options");
+ path = tracefs_instance_get_file(instance->tracefs, "trace_options");
fp = fopen(path, "w");
if (!fp)
warning("writing to '%s'", path);
@@ -1646,7 +1668,7 @@ static void disable_func_stack_trace_instance(struct buffer_instance *instance)
if (memcmp(cond, "function", size - (cond - content)) !=0)
goto out;
- set_option("nofunc_stack_trace");
+ set_option(instance, "nofunc_stack_trace");
out:
free(content);
}
@@ -1659,7 +1681,7 @@ static void disable_func_stack_trace(void)
disable_func_stack_trace_instance(instance);
}
-static void add_reset_options(void)
+static void add_reset_options(struct buffer_instance *instance)
{
struct opt_list *opt;
const char *option;
@@ -1671,10 +1693,10 @@ static void add_reset_options(void)
if (keep)
return;
- path = tracefs_get_tracing_file("trace_options");
+ path = tracefs_instance_get_file(instance->tracefs, "trace_options");
content = get_file_content(path);
- for (opt = options; opt; opt = opt->next) {
+ for (opt = instance->options; opt; opt = opt->next) {
option = opt->option;
len = strlen(option);
ptr = content;
@@ -1740,18 +1762,21 @@ static void add_reset_options(void)
static void set_options(void)
{
+ struct buffer_instance *instance;
struct opt_list *opt;
int ret;
- add_reset_options();
-
- while (options) {
- opt = options;
- options = opt->next;
- ret = set_option(opt->option);
- if (ret < 0)
- exit(-1);
- free(opt);
+ for_all_instances(instance) {
+ add_reset_options(instance);
+ while (instance->options) {
+ opt = instance->options;
+ instance->options = opt->next;
+ ret = set_option(instance, opt->option);
+ if (ret < 0)
+ die("Failed to set ftrace option %s",
+ opt->option);
+ free(opt);
+ }
}
}
@@ -2352,6 +2377,8 @@ void tracecmd_disable_tracing(void)
void tracecmd_disable_all_tracing(int disable_tracer)
{
+ struct buffer_instance *instance;
+
tracecmd_disable_tracing();
if (disable_tracer) {
@@ -2362,19 +2389,20 @@ void tracecmd_disable_all_tracing(int disable_tracer)
reset_events();
/* Force close and reset of ftrace pid file */
- update_ftrace_pid("", 1);
- update_ftrace_pid(NULL, 0);
+ for_all_instances(instance)
+ update_ftrace_pid(instance, "", 1);
clear_trace_instances();
}
static void
-update_sched_event(struct event_list *event, const char *field)
+update_sched_event(struct buffer_instance *instance,
+ struct event_list *event, const char *field)
{
if (!event)
return;
- event->pid_filter = make_pid_filter(event->pid_filter, field);
+ event->pid_filter = make_pid_filter(instance, event->pid_filter, field);
}
static void update_event_filters(struct buffer_instance *instance)
@@ -2385,15 +2413,15 @@ static void update_event_filters(struct buffer_instance *instance)
int len;
int common_len = 0;
- if (common_pid_filter)
- common_len = strlen(common_pid_filter);
+ if (instance->common_pid_filter)
+ common_len = strlen(instance->common_pid_filter);
for (event = instance->events; event; event = event->next) {
if (!event->neg) {
free_it = 0;
if (event->filter) {
- if (!common_pid_filter)
+ if (!instance->common_pid_filter)
/*
* event->pid_filter is only created if
* common_pid_filter is. No need to check that.
@@ -2408,7 +2436,7 @@ static void update_event_filters(struct buffer_instance *instance)
if (!event_filter)
die("Failed to allocate event_filter");
sprintf(event_filter, "(%s)&&(%s||%s)",
- event->filter, common_pid_filter,
+ event->filter, instance->common_pid_filter,
event->pid_filter);
} else {
free_it = 1;
@@ -2418,11 +2446,11 @@ static void update_event_filters(struct buffer_instance *instance)
if (!event_filter)
die("Failed to allocate event_filter");
sprintf(event_filter, "(%s)&&(%s)",
- event->filter, common_pid_filter);
+ event->filter, instance->common_pid_filter);
}
} else {
/* event->pid_filter only exists when common_pid_filter does */
- if (!common_pid_filter)
+ if (!instance->common_pid_filter)
continue;
if (event->pid_filter) {
@@ -2433,9 +2461,9 @@ static void update_event_filters(struct buffer_instance *instance)
if (!event_filter)
die("Failed to allocate event_filter");
sprintf(event_filter, "%s||%s",
- common_pid_filter, event->pid_filter);
+ instance->common_pid_filter, event->pid_filter);
} else
- event_filter = common_pid_filter;
+ event_filter = instance->common_pid_filter;
}
update_event(event, event_filter, 1, '1');
@@ -2462,14 +2490,14 @@ static void update_pid_filters(struct buffer_instance *instance)
if (fd < 0)
die("Failed to access set_event_pid");
- len = len_filter_pids + nr_filter_pids;
+ len = instance->len_filter_pids + instance->nr_filter_pids;
filter = malloc(len);
if (!filter)
die("Failed to allocate pid filter");
str = filter;
- for (p = filter_pids; p; p = p->next) {
+ for (p = instance->filter_pids; p; p = p->next) {
if (p->exclude)
continue;
len = sprintf(str, "%d ", p->pid);
@@ -2495,16 +2523,16 @@ static void update_pid_filters(struct buffer_instance *instance)
static void update_pid_event_filters(struct buffer_instance *instance)
{
- if (have_set_event_pid)
+ if (instance->have_set_event_pid)
return update_pid_filters(instance);
/*
* Also make sure that the sched_switch to this pid
* and wakeups of this pid are also traced.
* Only need to do this if the events are active.
*/
- update_sched_event(instance->sched_switch_event, "next_pid");
- update_sched_event(instance->sched_wakeup_event, "pid");
- update_sched_event(instance->sched_wakeup_new_event, "pid");
+ update_sched_event(instance, instance->sched_switch_event, "next_pid");
+ update_sched_event(instance, instance->sched_wakeup_event, "pid");
+ update_sched_event(instance, instance->sched_wakeup_new_event, "pid");
update_event_filters(instance);
}
@@ -2700,7 +2728,7 @@ create_event(struct buffer_instance *instance, char *path, struct event_list *ol
*event = *old_event;
add_event(instance, event);
- if (event->filter || filter_task || filter_pids) {
+ if (event->filter || filter_task || instance->filter_pids) {
event->filter_file = strdup(path);
if (!event->filter_file)
die("malloc filter file");
@@ -3903,7 +3931,7 @@ void start_threads(enum trace_type type, struct common_record_context *ctx)
if (brass)
close(brass[1]);
if (pid > 0)
- add_filter_pid(pid, 1);
+ add_filter_pid(instance, pid, 1);
}
}
recorder_threads = i;
@@ -4423,7 +4451,7 @@ static void set_funcs(struct buffer_instance *instance)
if (func_stack && is_top_instance(instance)) {
if (!functions_filtered(instance))
die("Function stack trace set, but functions not filtered");
- save_option(FUNC_STACK_TRACE);
+ save_option(instance, FUNC_STACK_TRACE);
}
clear_function_filters = 1;
}
@@ -4809,7 +4837,10 @@ static void reset_cpu_mask(void)
static void reset_event_pid(void)
{
- add_event_pid("");
+ struct buffer_instance *instance;
+
+ for_all_instances(instance)
+ add_event_pid(instance, "");
}
static void clear_triggers(void)
@@ -4996,7 +5027,7 @@ static void check_function_plugin(void)
static int __check_doing_something(struct buffer_instance *instance)
{
return is_guest(instance) || (instance->flags & BUFFER_FL_PROFILE) ||
- instance->plugin || instance->events;
+ instance->plugin || instance->events || instance->get_procmap;
}
static void check_doing_something(void)
@@ -5328,7 +5359,7 @@ static void enable_profile(struct buffer_instance *instance)
* kernel, then we need to default to the stack trace option.
* This is less efficient but still works.
*/
- save_option("stacktrace");
+ save_option(instance, "stacktrace");
for (i = 0; trigger_events[i]; i++)
@@ -5690,6 +5721,8 @@ static void parse_record_options(int argc,
int neg_event = 0;
struct buffer_instance *instance;
bool guest_sync_set = false;
+ int do_children = 0;
+ int fpids_count = 0;
init_common_record_context(ctx, curr_cmd);
@@ -5817,38 +5850,40 @@ static void parse_record_options(int argc,
break;
}
case 'F':
- test_set_event_pid();
+ test_set_event_pid(ctx->instance);
filter_task = 1;
break;
case 'G':
ctx->global = 1;
break;
case 'P':
- test_set_event_pid();
+ test_set_event_pid(ctx->instance);
pids = strdup(optarg);
if (!pids)
die("strdup");
pid = strtok_r(pids, ",", &sav);
while (pid) {
- add_filter_pid(atoi(pid), 0);
+ fpids_count += add_filter_pid(ctx->instance,
+ atoi(pid), 0);
pid = strtok_r(NULL, ",", &sav);
}
free(pids);
break;
case 'c':
- test_set_event_pid();
- if (!have_event_fork) {
+ test_set_event_pid(ctx->instance);
+ do_children = 1;
+ if (!ctx->instance->have_event_fork) {
#ifdef NO_PTRACE
die("-c invalid: ptrace not supported");
#endif
do_ptrace = 1;
- do_children = 1;
+ ctx->instance->ptrace_child = 1;
+
} else {
- save_option("event-fork");
- ctx->do_child = 1;
+ save_option(ctx->instance, "event-fork");
}
- if (have_func_fork)
- save_option("function-fork");
+ if (ctx->instance->have_func_fork)
+ save_option(ctx->instance, "function-fork");
break;
case 'C':
ctx->instance->clock = optarg;
@@ -5923,10 +5958,10 @@ static void parse_record_options(int argc,
break;
case 'O':
option = optarg;
- save_option(option);
+ save_option(ctx->instance, option);
break;
case 'T':
- save_option("stacktrace");
+ save_option(ctx->instance, "stacktrace");
break;
case 'H':
add_hook(ctx->instance, optarg);
@@ -6000,7 +6035,7 @@ static void parse_record_options(int argc,
die("Failed to allocate user name");
break;
case OPT_procmap:
- get_procmap = 1;
+ ctx->instance->get_procmap = 1;
break;
case OPT_date:
ctx->date = 1;
@@ -6103,10 +6138,8 @@ static void parse_record_options(int argc,
add_func(&ctx->instance->filter_funcs,
ctx->instance->filter_mod, "*");
- if (do_children && !filter_task && !nr_filter_pids)
+ if (do_children && !filter_task && !fpids_count)
die(" -c can only be used with -F (or -P with event-fork support)");
- if (ctx->do_child && !filter_task && !nr_filter_pids)
- die(" -c can only be used with -P or -F");
if ((argc - optind) >= 2) {
if (IS_START(ctx))
@@ -6120,11 +6153,25 @@ static void parse_record_options(int argc,
if (ctx->user && !ctx->run_command)
warning("--user %s is ignored, no command is specified",
ctx->user);
- if (get_procmap) {
- if (!ctx->run_command && !nr_filter_pids)
- warning("--proc-map is ignored, no command or filtered PIDs are specified.");
- else
+
+ if (top_instance.get_procmap) {
+ /* use ptrace to get procmap on the command exit */
+ if (ctx->run_command) {
do_ptrace = 1;
+ } else if (!top_instance.nr_filter_pids) {
+ warning("--proc-map is ignored for top instance, "
+ "no command or filtered PIDs are specified.");
+ top_instance.get_procmap = 0;
+ }
+ }
+
+ for_all_instances(instance) {
+ if (instance->get_procmap && !instance->nr_filter_pids) {
+ warning("--proc-map is ignored for instance %s, "
+ "no filtered PIDs are specified.",
+ tracefs_instance_get_name(instance->tracefs));
+ instance->get_procmap = 0;
+ }
}
}
@@ -6210,7 +6257,7 @@ static void record_trace(int argc, char **argv,
* If top_instance doesn't have any plugins or events, then
* remove it from being processed.
*/
- if (!__check_doing_something(&top_instance))
+ if (!__check_doing_something(&top_instance) && !filter_task)
first_instance = buffer_instances;
else
ctx->topt = 1;
@@ -6297,19 +6344,25 @@ static void record_trace(int argc, char **argv,
tracecmd_enable_tracing();
tracecmd_msg_wait_close(ctx->instance->msg_handle);
} else {
+ bool pwait = false;
+
update_task_filter();
tracecmd_enable_tracing();
/* We don't ptrace ourself */
- if (do_ptrace && filter_pids) {
- for (pid = filter_pids; pid; pid = pid->next) {
- if (!pid->exclude)
- ptrace_attach(pid->pid);
+ if (do_ptrace) {
+ for_all_instances(instance) {
+ for (pid = instance->filter_pids; pid; pid = pid->next) {
+ if (!pid->exclude && instance->ptrace_child) {
+ ptrace_attach(instance, pid->pid);
+ pwait = true;
+ }
+ }
}
}
/* sleep till we are woken with Ctrl^C */
printf("Hit Ctrl^C to stop recording\n");
while (!finished)
- trace_or_sleep(type);
+ trace_or_sleep(type, pwait);
}
tell_guests_to_stop();
--
2.26.2
^ permalink raw reply related [flat|nested] 2+ messages in thread
* [PATCH v3] trace-cmd: List ftrace instances at the end of trace-cmd stat
2020-05-05 10:17 [PATCH v3] trace-cmd: Handle filtered PIDs per ftarce instance Tzvetomir Stoyanov (VMware)
@ 2020-05-05 10:17 ` Tzvetomir Stoyanov (VMware)
0 siblings, 0 replies; 2+ messages in thread
From: Tzvetomir Stoyanov (VMware) @ 2020-05-05 10:17 UTC (permalink / raw)
To: rostedt; +Cc: linux-trace-devel
By default, "trace-cmd stat" command prints status of the main ftrace
instance. At top of the output there is a listing of all configured
instances abd the user could be confused which status is displayed.
Moved this list at the end of the command output.
Signed-off-by: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
---
v3: Removed the "main" when top instance is displayed and move instance
listing at the end of command's output.
tracecmd/trace-stat.c | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/tracecmd/trace-stat.c b/tracecmd/trace-stat.c
index c5057978..bd0e647a 100644
--- a/tracecmd/trace-stat.c
+++ b/tracecmd/trace-stat.c
@@ -920,8 +920,7 @@ static void stat_instance(struct buffer_instance *instance)
printf("---------------\n");
printf("Instance: %s\n",
tracefs_instance_get_name(instance->tracefs));
- } else
- report_instances();
+ }
report_plugin(instance);
report_events(instance);
@@ -937,6 +936,8 @@ static void stat_instance(struct buffer_instance *instance)
report_uprobes(instance);
report_traceon(instance);
report_errorlog(instance);
+ if (instance == &top_instance)
+ report_instances();
}
void trace_stat (int argc, char **argv)
--
2.26.2
^ permalink raw reply related [flat|nested] 2+ messages in thread
end of thread, other threads:[~2020-05-05 10:17 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-05-05 10:17 [PATCH v3] trace-cmd: Handle filtered PIDs per ftarce instance Tzvetomir Stoyanov (VMware)
2020-05-05 10:17 ` [PATCH v3] trace-cmd: List ftrace instances at the end of trace-cmd stat Tzvetomir Stoyanov (VMware)
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).