8:44 p.m.
This is my first time submitting a patch to a mailing list, so please be
patient with me if I've made any mistakes.
Since the 3.10 release, the Linux kernel has offered the ability to create
multiple independent ftrace buffers. At present, however, crash is only able to
extract the primary buffer. These patches seek to change that. All of the data
is already collected in the vmcore file; crash just isn't currently extracting
it.
I've split this changeset up into two pieces to address this. This first part
shouldn't lead to any change in functionality; it simply refactors the trace
extension so that the global instance is passed around as a parameter rather
than accessing it directly. That facilitates the second part, which locates all
of the available instances and extracts the data from each of them.
My testing has only included vmcores collected from 32-bit ARM systems, but I
don't believe I have made any assumptions about the architecture in my code.
Kyle Tomsic (2):
Refactor trace extension to pass trace information as an argument
Add support for multiple ftrace instances to trace extension
extensions/trace.c | 430 +++++++++++++++++++++++++++++++++++++++++------------
1 file changed, 333 insertions(+), 97 deletions(-)
--
2.9.2
8:44 p.m.
New subject: [Crash-Utility] [PATCH 1/2] Refactor trace extension to pass trace information as an argument
From: Kyle Tomsic <ktomsic(a)lexmark.com>
The trace extension was written assuming only one trace buffer, the
top-level (global) buffer, is available, which was true until the 3.10
kernel release. Since there was only one buffer, most of the functions
in trace.c accessed it through (static) global variables.
In order to support multiple buffer extraction, the functions that use
the top-level instance were refactored to take it as an argument. This
will allow reusing these functions for other ftrace buffers; support for
extracting these will be added in the other patch in this series.
---
extensions/trace.c | 235 ++++++++++++++++++++++++++++-------------------------
1 file changed, 126 insertions(+), 109 deletions(-)
diff --git a/extensions/trace.c b/extensions/trace.c
index f8ccd91..f97aa6a 100644
--- a/extensions/trace.c
+++ b/extensions/trace.c
@@ -101,16 +101,21 @@ struct ring_buffer_per_cpu {
};
static ulong global_trace;
-static ulong global_trace_buffer;
-static ulong global_max_buffer;
-static ulong global_ring_buffer;
-static unsigned global_pages;
-static struct ring_buffer_per_cpu *global_buffers;
-
static ulong max_tr_trace;
-static ulong max_tr_ring_buffer;
-static unsigned max_tr_pages;
-static struct ring_buffer_per_cpu *max_tr_buffers;
+
+struct trace_instance {
+ ulong trace_buffer;
+ ulong max_buffer;
+ ulong ring_buffer;
+ unsigned pages;
+ struct ring_buffer_per_cpu *buffers;
+
+ ulong max_tr_ring_buffer;
+ unsigned max_tr_pages;
+ struct ring_buffer_per_cpu *max_tr_buffers;
+};
+
+static struct trace_instance global_trace_instance;
static ulong ftrace_events;
static ulong current_trace;
@@ -435,64 +440,54 @@ out_fail:
return -1;
}
-static int ftrace_int_global_trace(void)
+static int ftrace_init_trace(struct trace_instance *ti, ulong instance_addr)
{
if (trace_buffer_available) {
- global_trace_buffer = global_trace + koffset(trace_array, trace_buffer);
- read_value(global_ring_buffer, global_trace_buffer, trace_buffer, buffer);
+ ti->trace_buffer = instance_addr +
+ koffset(trace_array, trace_buffer);
+ read_value(ti->ring_buffer, ti->trace_buffer,
+ trace_buffer, buffer);
+
+ if (max_buffer_available) {
+ ti->max_buffer = instance_addr +
+ koffset(trace_array, max_buffer);
+ read_value(ti->max_tr_ring_buffer, ti->max_buffer,
+ trace_buffer, buffer);
+ }
} else {
- read_value(global_ring_buffer, global_trace, trace_array, buffer);
- read_value(global_pages, global_ring_buffer, ring_buffer, pages);
+ read_value(ti->ring_buffer, instance_addr, trace_array, buffer);
+ read_value(ti->pages, ti->ring_buffer, ring_buffer, pages);
+
+ read_value(ti->max_tr_ring_buffer, max_tr_trace, trace_array, buffer);
+ if (ti->max_tr_ring_buffer)
+ read_value(ti->max_tr_pages, ti->max_tr_ring_buffer, ring_buffer, pages);
}
- global_buffers = calloc(sizeof(*global_buffers), nr_cpu_ids);
- if (global_buffers == NULL)
+ ti->buffers = calloc(sizeof(*ti->buffers), nr_cpu_ids);
+ if (ti->buffers == NULL)
goto out_fail;
- if (ftrace_init_buffers(global_buffers, global_ring_buffer,
- global_pages) < 0)
+ if (ftrace_init_buffers(ti->buffers, ti->ring_buffer,
+ ti->pages) < 0)
goto out_fail;
- return 0;
-
-out_fail:
- free(global_buffers);
- return -1;
-}
-
-static int ftrace_int_max_tr_trace(void)
-{
- if (trace_buffer_available) {
- if (!max_buffer_available)
- return 0;
-
- global_max_buffer = global_trace + koffset(trace_array, max_buffer);
- read_value(max_tr_ring_buffer, global_max_buffer, trace_buffer, buffer);
- } else {
- read_value(max_tr_ring_buffer, max_tr_trace, trace_array, buffer);
-
- if (!max_tr_ring_buffer)
- return 0;
-
- read_value(max_tr_pages, max_tr_ring_buffer, ring_buffer, pages);
- }
-
- max_tr_buffers = calloc(sizeof(*max_tr_buffers), nr_cpu_ids);
- if (max_tr_buffers == NULL)
+ ti->max_tr_buffers = calloc(sizeof(*ti->max_tr_buffers), nr_cpu_ids);
+ if (ti->max_tr_buffers == NULL)
goto out_fail;
- if (ftrace_init_buffers(max_tr_buffers, max_tr_ring_buffer,
- max_tr_pages) < 0)
+ if (ftrace_init_buffers(ti->max_tr_buffers, ti->max_tr_ring_buffer,
+ ti->max_tr_pages) < 0)
goto out_fail;
return 0;
out_fail:
- free(max_tr_buffers);
- max_tr_ring_buffer = 0;
+ free(ti->max_tr_buffers);
+ free(ti->buffers);
return -1;
}
+
static int ftrace_init_current_tracer(void)
{
ulong addr;
@@ -504,7 +499,7 @@ static int ftrace_init_current_tracer(void)
} else {
read_value(addr, current_trace, POINTER_SYM, POINTER);
}
-
+
read_value(addr, addr, tracer, name);
read_string(addr, tmp, 128);
@@ -564,10 +559,9 @@ static int ftrace_init(void)
return -1;
print_offsets();
- if (ftrace_int_global_trace() < 0)
+ if (ftrace_init_trace(&global_trace_instance, global_trace) < 0)
goto out_0;
- ftrace_int_max_tr_trace();
if (ftrace_init_event_types() < 0)
goto out_1;
@@ -580,12 +574,12 @@ static int ftrace_init(void)
out_2:
ftrace_destroy_event_types();
out_1:
- if (max_tr_ring_buffer) {
- ftrace_destroy_buffers(max_tr_buffers);
- free(max_tr_buffers);
+ if (global_trace_instance.max_tr_ring_buffer) {
+ ftrace_destroy_buffers(global_trace_instance.max_tr_buffers);
+ free(global_trace_instance.max_tr_buffers);
}
- ftrace_destroy_buffers(global_buffers);
- free(global_buffers);
+ ftrace_destroy_buffers(global_trace_instance.buffers);
+ free(global_trace_instance.buffers);
out_0:
return -1;
}
@@ -595,13 +589,13 @@ static void ftrace_destroy(void)
free(current_tracer_name);
ftrace_destroy_event_types();
- if (max_tr_ring_buffer) {
- ftrace_destroy_buffers(max_tr_buffers);
- free(max_tr_buffers);
+ if (global_trace_instance.max_tr_ring_buffer) {
+ ftrace_destroy_buffers(global_trace_instance.max_tr_buffers);
+ free(global_trace_instance.max_tr_buffers);
}
- ftrace_destroy_buffers(global_buffers);
- free(global_buffers);
+ ftrace_destroy_buffers(global_trace_instance.buffers);
+ free(global_trace_instance.buffers);
}
static int ftrace_dump_page(int fd, ulong page, void *page_tmp)
@@ -652,7 +646,8 @@ static int try_mkdir(const char *pathname, mode_t mode)
return 0;
}
-static int ftrace_dump_buffers(const char *per_cpu_path)
+static int ftrace_dump_buffers(const char *per_cpu_path,
+ struct trace_instance *ti)
{
int i;
void *page_tmp;
@@ -664,7 +659,7 @@ static int ftrace_dump_buffers(const char *per_cpu_path)
return -1;
for (i = 0; i < nr_cpu_ids; i++) {
- struct ring_buffer_per_cpu *cpu_buffer = &global_buffers[i];
+ struct ring_buffer_per_cpu *cpu_buffer = &ti->buffers[i];
if (!cpu_buffer->kaddr)
continue;
@@ -679,7 +674,7 @@ static int ftrace_dump_buffers(const char *per_cpu_path)
if (fd < 0)
goto out_fail;
- ftrace_dump_buffer(fd, cpu_buffer, global_pages, page_tmp);
+ ftrace_dump_buffer(fd, cpu_buffer, ti->pages, page_tmp);
close(fd);
}
@@ -1478,26 +1473,70 @@ static int dump_kallsyms(const char *dump_tracing_dir)
static int trace_cmd_data_output(int fd);
+#define FTRACE_DUMP_SYMBOLS (1 << 0)
+#define FTRACE_DUMP_META_DATA (1 << 1)
+
+static int populate_ftrace_dir_tree(struct trace_instance *ti,
+ char *root, uint flags)
+{
+ char path[PATH_MAX];
+ int ret;
+
+ ret = mkdir(root, 0755);
+ if (ret < 0) {
+ if (errno == EEXIST)
+ error(INFO, "mkdir: %s exists\n", root);
+ return FALSE;
+ }
+
+ snprintf(path, sizeof(path), "%s/per_cpu", root);
+ if (try_mkdir(path, 0755) < 0)
+ return FALSE;
+
+ if (ftrace_dump_buffers(path, ti) < 0)
+ return FALSE;
+
+ if (flags & FTRACE_DUMP_META_DATA) {
+ /* Dump event types */
+ snprintf(path, sizeof(path), "%s/events", root);
+ if (try_mkdir(path, 0755) < 0)
+ return FALSE;
+
+ if (ftrace_dump_event_types(path) < 0)
+ return FALSE;
+
+ /* Dump pids with corresponding cmdlines */
+ if (dump_saved_cmdlines(root) < 0)
+ return FALSE;
+ }
+
+ if (flags & FTRACE_DUMP_SYMBOLS) {
+ /* Dump all symbols of the kernel */
+ dump_kallsyms(root);
+ }
+
+ return TRUE;
+}
+
static void ftrace_dump(int argc, char *argv[])
{
int c;
- int dump_meta_data = 0;
- int dump_symbols = 0;
+ uint flags = 0;
char *dump_tracing_dir;
- char path[PATH_MAX];
- int ret;
while ((c = getopt(argc, argv, "smt")) != EOF) {
switch(c)
{
case 's':
- dump_symbols = 1;
+ flags |= FTRACE_DUMP_SYMBOLS;
break;
case 'm':
- dump_meta_data = 1;
+ flags |= FTRACE_DUMP_META_DATA;
break;
case 't':
- if (dump_symbols || dump_meta_data || argc - optind > 1)
+ if (flags & FTRACE_DUMP_SYMBOLS ||
+ flags & FTRACE_DUMP_META_DATA ||
+ argc - optind > 1)
cmd_usage(pc->curcmd, SYNOPSIS);
else {
char *trace_dat = "trace.dat";
@@ -1528,38 +1567,7 @@ static void ftrace_dump(int argc, char *argv[])
return;
}
- ret = mkdir(dump_tracing_dir, 0755);
- if (ret < 0) {
- if (errno == EEXIST)
- error(INFO, "mkdir: %s exists\n", dump_tracing_dir);
- return;
- }
-
- snprintf(path, sizeof(path), "%s/per_cpu", dump_tracing_dir);
- if (try_mkdir(path, 0755) < 0)
- return;
-
- if (ftrace_dump_buffers(path) < 0)
- return;
-
- if (dump_meta_data) {
- /* Dump event types */
- snprintf(path, sizeof(path), "%s/events", dump_tracing_dir);
- if (try_mkdir(path, 0755) < 0)
- return;
-
- if (ftrace_dump_event_types(path) < 0)
- return;
-
- /* Dump pids with corresponding cmdlines */
- if (dump_saved_cmdlines(dump_tracing_dir) < 0)
- return;
- }
-
- if (dump_symbols) {
- /* Dump all symbols of the kernel */
- dump_kallsyms(dump_tracing_dir);
- }
+ populate_ftrace_dir_tree(&global_trace_instance, dump_tracing_dir, flags);
}
static void ftrace_show(int argc, char *argv[])
@@ -2182,7 +2190,7 @@ static int save_res_data(int fd, int nr_cpu_buffers)
return 0;
}
-static int save_record_data(int fd, int nr_cpu_buffers)
+static int save_record_data(int fd, int nr_cpu_buffers, struct trace_instance *ti)
{
int i, j;
unsigned long long offset, buffer_offset;
@@ -2194,7 +2202,7 @@ static int save_record_data(int fd, int nr_cpu_buffers)
buffer_offset = offset;
for (i = 0; i < nr_cpu_ids; i++) {
- struct ring_buffer_per_cpu *cpu_buffer = &global_buffers[i];
+ struct ring_buffer_per_cpu *cpu_buffer = &ti->buffers[i];
unsigned long long buffer_size;
if (!cpu_buffer->kaddr)
@@ -2214,7 +2222,7 @@ static int save_record_data(int fd, int nr_cpu_buffers)
lseek(fd, offset, SEEK_SET);
for (i = 0; i < nr_cpu_ids; i++) {
- struct ring_buffer_per_cpu *cpu_buffer = &global_buffers[i];
+ struct ring_buffer_per_cpu *cpu_buffer = &ti->buffers[i];
if (!cpu_buffer->kaddr)
continue;
@@ -2233,13 +2241,13 @@ static int save_record_data(int fd, int nr_cpu_buffers)
return 0;
}
-static int __trace_cmd_data_output(int fd)
+static int get_nr_cpu_buffers(struct trace_instance *ti)
{
int i;
int nr_cpu_buffers = 0;
for (i = 0; i < nr_cpu_ids; i++) {
- struct ring_buffer_per_cpu *cpu_buffer = &global_buffers[i];
+ struct ring_buffer_per_cpu *cpu_buffer = &ti->buffers[i];
if (!cpu_buffer->kaddr)
continue;
@@ -2247,6 +2255,15 @@ static int __trace_cmd_data_output(int fd)
nr_cpu_buffers++;
}
+ return nr_cpu_buffers;
+}
+
+static int __trace_cmd_data_output(int fd)
+{
+ int nr_cpu_buffers;
+
+ nr_cpu_buffers = get_nr_cpu_buffers(&global_trace_instance);
+
if (save_initial_data(fd))
return -1;
if (save_header_files(fd))
@@ -2261,7 +2278,7 @@ static int __trace_cmd_data_output(int fd)
return -1;
if (save_res_data(fd, nr_cpu_buffers))
return -1;
- if (save_record_data(fd, nr_cpu_buffers))
+ if (save_record_data(fd, nr_cpu_buffers, &global_trace_instance))
return -1;
return 0;
--
2.9.2
8:44 p.m.
New subject: [Crash-Utility] [PATCH 2/2] Add support for multiple ftrace instances to trace extension
From: Kyle Tomsic <ktomsic(a)lexmark.com>
Since 3.10, the Linux kernel has supported multiple ftrace buffers.
However, the trace extension predates this addition and could only
extract data from the global instance.
This changeset adds support for dumping these additional buffers by
walking the ftrace_trace_arrays list to find the additional buffers.
Several functions that relied on global variables have been refactored
to accept the data they operate on as parameters so they could be reused
for the instances as well.
---
extensions/trace.c | 237 +++++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 228 insertions(+), 9 deletions(-)
diff --git a/extensions/trace.c b/extensions/trace.c
index f97aa6a..1344e48 100644
--- a/extensions/trace.c
+++ b/extensions/trace.c
@@ -38,6 +38,10 @@ static int trace_buffer_available;
* max_buffer is supported
*/
static int max_buffer_available;
+/*
+ * multiple trace instances are supported
+ */
+static int multiple_instances_available;
#define koffset(struct, member) struct##_##member##_offset
@@ -78,6 +82,8 @@ static int koffset(ftrace_event_field, offset);
static int koffset(ftrace_event_field, size);
static int koffset(ftrace_event_field, is_signed);
+static int koffset(trace_array, name);
+
static int koffset(POINTER_SYM, POINTER) = 0;
struct ring_buffer_per_cpu {
@@ -104,6 +110,7 @@ static ulong global_trace;
static ulong max_tr_trace;
struct trace_instance {
+ char name[NAME_MAX + 1];
ulong trace_buffer;
ulong max_buffer;
ulong ring_buffer;
@@ -115,7 +122,10 @@ struct trace_instance {
struct ring_buffer_per_cpu *max_tr_buffers;
};
+static ulong ftrace_trace_arrays;
static struct trace_instance global_trace_instance;
+static struct trace_instance *trace_instances = NULL;
+static int instance_count;
static ulong ftrace_events;
static ulong current_trace;
@@ -234,6 +244,9 @@ static int init_offsets(void)
init_offset(ftrace_event_field, size);
init_offset(ftrace_event_field, is_signed);
+ if (MEMBER_EXISTS("trace_array", "name"))
+ init_offset(trace_array, name);
+
return 0;
#undef init_offset
}
@@ -487,6 +500,92 @@ out_fail:
return -1;
}
+static void ftrace_destroy_all_instance_buffers()
+{
+ int i;
+
+ for (i = 0; i < instance_count; i++)
+ {
+ struct trace_instance *ti = &trace_instances[i];
+
+ if (ti->max_tr_ring_buffer) {
+ ftrace_destroy_buffers(ti->max_tr_buffers);
+ free(ti->max_tr_buffers);
+ }
+
+ ftrace_destroy_buffers(ti->buffers);
+ free(ti->buffers);
+ }
+}
+
+static void ftrace_destroy_instances()
+{
+ ftrace_destroy_all_instance_buffers();
+ free(trace_instances);
+}
+
+static int ftrace_init_instances()
+{
+ int i;
+ struct trace_instance *ti;
+ struct list_data list_data;
+ struct list_data *ld = &list_data;
+
+ if (!multiple_instances_available)
+ return 0;
+
+ BZERO(ld, sizeof(struct list_data));
+ ld->start = ftrace_trace_arrays;
+ ld->end = global_trace;
+ ld->flags = LIST_ALLOCATE;
+ instance_count = do_list(ld);
+
+ /* The do_list count includes the list_head, which is not a
+ * proper instance */
+ instance_count--;
+ if (instance_count <= 0)
+ return 0;
+
+ trace_instances = calloc(sizeof(struct trace_instance), instance_count);
+
+ /* We start i at 1 to skip over the list_head and continue to the last
+ * instance, which lies at index instance_count */
+ for (i = 1; i <= instance_count; i++)
+ {
+ ulong instance_ptr;
+ ulong name_addr;
+ int ret;
+
+ ti = &trace_instances[i-1];
+ instance_ptr = ld->list_ptr[i];
+ read_value(name_addr, instance_ptr, trace_array, name);
+ if (!name_addr)
+ {
+ console("Instance name is NULL\n");
+ }
+ else if (!read_string(name_addr, ti->name, sizeof(ti->name)))
+ {
+ console("Failed to read instance name at address %p\n", (void*)name_addr);
+ goto out_fail;
+ }
+
+ ret = ftrace_init_trace(ti, instance_ptr);
+ if (ret < 0)
+ goto out_fail;
+ }
+ FREEBUF(ld->list_ptr);
+
+ return 0;
+
+out_fail:
+ /* We've already freed the current instance's trace buffer info, so
+ * we'll clear that out to avoid double freeing in
+ * ftrace_destroy_instances() */
+ BZERO(ti, sizeof(struct trace_instance));
+ ftrace_destroy_instances();
+
+ return -1;
+}
static int ftrace_init_current_tracer(void)
{
@@ -519,9 +618,11 @@ static int ftrace_init(void)
struct syment *sym_max_tr_trace;
struct syment *sym_ftrace_events;
struct syment *sym_current_trace;
+ struct syment *sym_ftrace_trace_arrays;
sym_global_trace = symbol_search("global_trace");
sym_ftrace_events = symbol_search("ftrace_events");
+ sym_ftrace_trace_arrays = symbol_search("ftrace_trace_arrays");
if (sym_global_trace == NULL || sym_ftrace_events == NULL)
return -1;
@@ -529,6 +630,13 @@ static int ftrace_init(void)
global_trace = sym_global_trace->value;
ftrace_events = sym_ftrace_events->value;
+ if (sym_ftrace_trace_arrays)
+ {
+ multiple_instances_available = 1;
+ ftrace_trace_arrays = sym_ftrace_trace_arrays->value;
+ }
+
+
if (MEMBER_EXISTS("trace_array", "current_trace")) {
encapsulated_current_trace = 1;
} else {
@@ -562,17 +670,21 @@ static int ftrace_init(void)
if (ftrace_init_trace(&global_trace_instance, global_trace) < 0)
goto out_0;
+ if (ftrace_init_instances() < 0)
+ goto out_1;
if (ftrace_init_event_types() < 0)
- goto out_1;
+ goto out_2;
if (ftrace_init_current_tracer() < 0)
- goto out_2;
+ goto out_3;
return 0;
-out_2:
+out_3:
ftrace_destroy_event_types();
+out_2:
+ ftrace_destroy_instances();
out_1:
if (global_trace_instance.max_tr_ring_buffer) {
ftrace_destroy_buffers(global_trace_instance.max_tr_buffers);
@@ -589,6 +701,8 @@ static void ftrace_destroy(void)
free(current_tracer_name);
ftrace_destroy_event_types();
+ ftrace_destroy_instances();
+
if (global_trace_instance.max_tr_ring_buffer) {
ftrace_destroy_buffers(global_trace_instance.max_tr_buffers);
free(global_trace_instance.max_tr_buffers);
@@ -1521,8 +1635,10 @@ static int populate_ftrace_dir_tree(struct trace_instance *ti,
static void ftrace_dump(int argc, char *argv[])
{
int c;
+ int i;
uint flags = 0;
char *dump_tracing_dir;
+ char instance_path[PATH_MAX];
while ((c = getopt(argc, argv, "smt")) != EOF) {
switch(c)
@@ -1567,7 +1683,34 @@ static void ftrace_dump(int argc, char *argv[])
return;
}
- populate_ftrace_dir_tree(&global_trace_instance, dump_tracing_dir, flags);
+ if (!populate_ftrace_dir_tree(&global_trace_instance, dump_tracing_dir, flags))
+ return;
+
+ if (!multiple_instances_available || instance_count == 0)
+ return;
+
+ /* Create an instances directory, and dump instance data in there */
+ snprintf(instance_path, sizeof(instance_path),
+ "%s/instances", dump_tracing_dir);
+ if (try_mkdir(instance_path, 0755) < 0)
+ return;
+
+ /* Don't care about the flags anymore */
+ flags = 0;
+
+ for (i = 0; i < instance_count; i++)
+ {
+ struct trace_instance *ti = &trace_instances[i];
+
+ snprintf(instance_path, sizeof(instance_path),
+ "%s/instances/%s", dump_tracing_dir,
+ ti->name);
+
+ if (populate_ftrace_dir_tree(ti, instance_path, flags) < 0)
+ break;
+ }
+
+ return;
}
static void ftrace_show(int argc, char *argv[])
@@ -2171,19 +2314,62 @@ static int save_ftrace_cmdlines(int fd)
return tmp_file_flush(fd);
}
-static int save_res_data(int fd, int nr_cpu_buffers)
+/* From trace-cmd.h */
+enum {
+ TRACECMD_OPTION_DONE, /* 0 */
+ TRACECMD_OPTION_DATE, /* 1 */
+ TRACECMD_OPTION_CPUSTAT, /* 2 */
+ TRACECMD_OPTION_BUFFER, /* 3 */
+ TRACECMD_OPTION_TRACECLOCK, /* 4 */
+ TRACECMD_OPTION_UNAME, /* 5 */
+ TRACECMD_OPTION_HOOK, /* 6 */
+};
+
+static int write_options(int fd, unsigned long long *buffer_offsets)
{
- unsigned short option = 0;
+ int i;
+ unsigned short option;
- if (write_and_check(fd, &nr_cpu_buffers, 4))
- return -1;
+ if (!multiple_instances_available)
+ return 0;
if (write_and_check(fd, "options ", 10))
return -1;
+ option = TRACECMD_OPTION_BUFFER;
+ for (i = 0; i < instance_count; i++)
+ {
+ char *name = trace_instances[i].name;
+ size_t name_size = strlen(name) + 1; /* Name length + '\0' */
+ unsigned long long option_size = 8 + name_size;
+ unsigned long long offset;
+
+ offset = buffer_offsets ? buffer_offsets[i] : 0;
+ if (write_and_check(fd, &option, 2))
+ return -1;
+ if (write_and_check(fd, &option_size, 4))
+ return -1;
+ if (write_and_check(fd, &offset, 8))
+ return -1;
+ if (write_and_check(fd, name, name_size))
+ return -1;
+ }
+
+ option = TRACECMD_OPTION_DONE;
if (write_and_check(fd, &option, 2))
return -1;
+ return 0;
+}
+
+static int save_res_data(int fd, int nr_cpu_buffers, unsigned long long *buffer_offsets)
+{
+ if (write_and_check(fd, &nr_cpu_buffers, 4))
+ return -1;
+
+ if (write_options(fd, buffer_offsets))
+ return -1;
+
if (write_and_check(fd, "flyrecord", 10))
return -1;
@@ -2261,6 +2447,10 @@ static int get_nr_cpu_buffers(struct trace_instance *ti)
static int __trace_cmd_data_output(int fd)
{
int nr_cpu_buffers;
+ unsigned long long global_res_data_offset;
+ unsigned long long *instance_offsets;
+
+ instance_offsets = calloc(sizeof(unsigned long long), instance_count);
nr_cpu_buffers = get_nr_cpu_buffers(&global_trace_instance);
@@ -2276,11 +2466,40 @@ static int __trace_cmd_data_output(int fd)
return -1;
if (save_ftrace_cmdlines(fd))
return -1;
- if (save_res_data(fd, nr_cpu_buffers))
+
+ /* We don't have the instance buffer offsets yet, so we'll write in 0s
+ * for now, and fix it up after we have that information available */
+ global_res_data_offset = lseek(fd, 0, SEEK_CUR);
+ if (save_res_data(fd, nr_cpu_buffers, NULL))
return -1;
if (save_record_data(fd, nr_cpu_buffers, &global_trace_instance))
return -1;
+ if (multiple_instances_available)
+ {
+ int i;
+
+ for (i = 0; i < instance_count; i++)
+ {
+ struct trace_instance *ti = &trace_instances[i];
+ nr_cpu_buffers = get_nr_cpu_buffers(ti);
+
+ /* Save off the instance offset for fixup later */
+ instance_offsets[i] = lseek(fd, 0, SEEK_CUR);
+
+ if (write_and_check(fd, "flyrecord", 10))
+ return -1;
+ if (save_record_data(fd, nr_cpu_buffers, ti))
+ return -1;
+ }
+ }
+
+ /* Fix up the global trace's options header with the instance offsets */
+ lseek(fd, global_res_data_offset, SEEK_SET);
+ nr_cpu_buffers = get_nr_cpu_buffers(&global_trace_instance);
+ if (save_res_data(fd, nr_cpu_buffers, instance_offsets))
+ return -1;
+
return 0;
}
--
2.9.2
11:03 a.m.
New subject: extensions/trace: Add support for multiple ftrace buffers
----- Original Message -----
This is my first time submitting a patch to a mailing list, so please
be
patient with me if I've made any mistakes.
Hello Kyle,
You've done the right thing. Sorry for the delay -- I'm swamped with
post-vacation chores...
However, I personally do not maintain the extensions/trace.c file.
It was written by Fujitsu, and has passed through a couple of their
maintainers since its origination. Currently it's owned by Qiao Nuohan,
and with any proposed patch, I would need his ACK to check it in.
On the other hand, there was this recent trace.c patch posted and accepted
last month:
[Crash-utility] [PATCH] extensions/trace: Fix ftrace_get_event_type_name()
https://www.redhat.com/archives/crash-utility/2016-July/msg00000.html
Re: [Crash-utility] [PATCH] extensions/trace: Fix ftrace_get_event_type_name()
https://www.redhat.com/archives/crash-utility/2016-July/msg00001.html
Re: [Crash-utility] [PATCH] extensions/trace: Fix ftrace_get_event_type_name()
https://www.redhat.com/archives/crash-utility/2016-July/msg00002.html
Re: [Crash-utility] [PATCH] extensions/trace: Fix ftrace_get_event_type_name()
https://www.redhat.com/archives/crash-utility/2016-July/msg00003.html
In that case, there was no response from Qiao. But since the patch was simple
enough, and wouldn't break backwards-compatibility, I went ahead and checked
it in.
But due to the complexity of this patchset, I'm not comfortable doing that, and
I want a review/ACK from Qiao, or if there is still no response from him, from
Steve Rostedt, who has offered to take over maintainership of the module in the past.
I'm cc'ing everyone directly in hopes of getting a response this time.
Thanks,
Dave
Since the 3.10 release, the Linux kernel has offered the ability to
create
multiple independent ftrace buffers. At present, however, crash is only able to
extract the primary buffer. These patches seek to change that. All of the data
is already collected in the vmcore file; crash just isn't currently
extracting
it.
I've split this changeset up into two pieces to address this. This first part
shouldn't lead to any change in functionality; it simply refactors the trace
extension so that the global instance is passed around as a parameter rather
than accessing it directly. That facilitates the second part, which locates all
of the available instances and extracts the data from each of them.
My testing has only included vmcores collected from 32-bit ARM systems, but I
don't believe I have made any assumptions about the architecture in my code.
Kyle Tomsic (2):
Refactor trace extension to pass trace information as an argument
Add support for multiple ftrace instances to trace extension
extensions/trace.c | 430
+++++++++++++++++++++++++++++++++++++++++------------
1 file changed, 333 insertions(+), 97 deletions(-)
--
2.9.2
--
Crash-utility mailing list
Crash-utility(a)redhat.com
https://www.redhat.com/mailman/listinfo/crash-utility
11:54 a.m.
New subject: extensions/trace: Add support for multiple ftrace buffers
On Tue, 9 Aug 2016 12:03:16 -0400 (EDT)
Dave Anderson <anderson(a)redhat.com> wrote:
But due to the complexity of this patchset, I'm not comfortable
doing that, and
I want a review/ACK from Qiao, or if there is still no response from him, from
Steve Rostedt, who has offered to take over maintainership of the module in the past.
I'm cc'ing everyone directly in hopes of getting a response this time.
I'm happy to test this, check for backward compatibility and give an
ack. I just have a few other things on my plate at the moment.
-- Steve
3062
days inactive
3068
days old
devel@lists.crash-utility.osci.io
4 comments
3 participants
participants (3)
-
Dave Anderson -
Kyle Tomsic -
Steven Rostedt