Subject: [PATCH] crash-trace-command: generate trace.dat from core-file
This patch adds a command "trace dump -t" for crash-trace-command
which is extension of crash(8) for analyzing and dumping ftrace from core-file.
This extension already has "trace show" to show what events had happened
before crash, but it is just 1000 lines of code and it is not so
smart as "trace-cmd report". New command "trace dump -t" generates a trace.dat,
and then, we can use "trace-cmd report" for this trace.dat.
trace-cmd(1) is a ftrace tool written by Steven Rostedt <rostedt@xxxxxxxxxxx>.
It includes two tools for showing ftrace events "trace-cmd report" and "kernelshark".
SEE ALSO: trace-cmd(1), trace-cmd-report(1), trace-cmd.dat(5)
Note, this patch does not just improve crash-trace-command, it improves trace-cmd
also. It makes trace-cmd can handle ftrace even the kernel crashed.
Usage:
1) start crash(8) for a core-file, and execute the following command in crash(8):
2) extend <your-path-to-crash-trace-command, example: /usr/lib/crash/trace.so>
3) trace dump -t
4) q<enter> to quit crash
5) trace-cmd report or kernelshark
Signed-off-by: Lai Jiangshan <laijs@xxxxxxxxxxxxxx>
---
trace.c | 778 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 693 insertions(+), 85 deletions(-)
diff --git a/extensions/trace.c b/extensions/trace.c
index 89eb477..d100869 100755
--- a/extensions/trace.c
+++ b/extensions/trace.c
@@ -1,7 +1,7 @@
/*
* trace extension module for crash
*
- * Copyright (C) 2009 FUJITSU LIMITED
+ * Copyright (C) 2009, 2010 FUJITSU LIMITED
* Author: Lai Jiangshan <laijs@xxxxxxxxxxxxxx>
*
* This program is free software; you can redistribute it and/or modify
@@ -53,6 +53,7 @@ static int koffset(list_head, next);
static int koffset(ftrace_event_call, list);
static int koffset(ftrace_event_call, name);
static int koffset(ftrace_event_call, system);
+static int koffset(ftrace_event_call, print_fmt);
static int koffset(ftrace_event_call, id);
static int koffset(ftrace_event_call, fields);
@@ -74,8 +75,11 @@ struct ring_buffer_per_cpu {
ulong reader_page;
ulong real_head_page;
- ulong *pages;
int head_page_index;
+ ulong *pages;
+
+ ulong *linear_pages;
+ int nr_linear_pages;
ulong overrun;
ulong entries;
@@ -112,6 +116,22 @@ static void ftrace_show_destroy(void);
/* Remove the "const" qualifiers for ptr */
#define free(ptr) free((void *)(ptr))
+static int write_and_check(int fd, void *data, size_t size)
+{
+ size_t tot = 0;
+ size_t w;
+
+ do {
+ w = write(fd, data, size - tot);
+ tot += w;
+
+ if (w <= 0)
+ return -1;
+ } while (tot != size);
+
+ return 0;
+}
+
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif
@@ -153,6 +173,7 @@ static void init_offsets(void)
init_offset(ftrace_event_call, list);
init_offset(ftrace_event_call, name);
init_offset(ftrace_event_call, system);
+ init_offset(ftrace_event_call, print_fmt);
init_offset(ftrace_event_call, id);
init_offset(ftrace_event_call, fields);
@@ -199,6 +220,7 @@ static void print_offsets(void)
print_offset(ftrace_event_call, list);
print_offset(ftrace_event_call, name);
print_offset(ftrace_event_call, system);
+ print_offset(ftrace_event_call, print_fmt);
print_offset(ftrace_event_call, id);
print_offset(ftrace_event_call, fields);
@@ -214,7 +236,7 @@ static void print_offsets(void)
static int ftrace_init_pages(struct ring_buffer_per_cpu *cpu_buffer,
unsigned nr_pages)
{
- unsigned j = 0;
+ unsigned j = 0, count = 0;
ulong head, page;
ulong real_head_page = cpu_buffer->head_page;
@@ -222,6 +244,12 @@ static int ftrace_init_pages(struct ring_buffer_per_cpu *cpu_buffer,
if (cpu_buffer->pages == NULL)
return -1;
+ cpu_buffer->linear_pages = calloc(sizeof(ulong), nr_pages + 1);
+ if (cpu_buffer->linear_pages == NULL) {
+ free(cpu_buffer->pages);
+ return -1;
+ }
+
if (lockless_ring_buffer) {
read_value(head, cpu_buffer->kaddr, ring_buffer_per_cpu, pages);
cpu_buffer->pages[j++] = head - koffset(buffer_page, list);
@@ -253,6 +281,8 @@ static int ftrace_init_pages(struct ring_buffer_per_cpu *cpu_buffer,
goto out_fail;
}
+ /* find head page and head_page_index */
+
cpu_buffer->real_head_page = real_head_page;
cpu_buffer->head_page_index = -1;
@@ -268,10 +298,38 @@ static int ftrace_init_pages(struct ring_buffer_per_cpu *cpu_buffer,
goto out_fail;
}
+ /* Setup linear pages */
+
+ cpu_buffer->linear_pages[count++] = cpu_buffer->reader_page;
+
+ if (cpu_buffer->reader_page == cpu_buffer->commit_page)
+ goto done;
+
+ j = cpu_buffer->head_page_index;
+ for (;;) {
+ cpu_buffer->linear_pages[count++] = cpu_buffer->pages[j];
+
+ if (cpu_buffer->pages[j] == cpu_buffer->commit_page)
+ break;
+
+ j++;
+ if (j == nr_pages)
+ j = 0;
+
+ if (j == cpu_buffer->head_page_index) {
+ /* cpu_buffer->commit_page may be corrupted */
+ break;
+ }
+ }
+
+done:
+ cpu_buffer->nr_linear_pages = count;
+
return 0;
out_fail:
free(cpu_buffer->pages);
+ free(cpu_buffer->linear_pages);
return -1;
}
@@ -284,6 +342,7 @@ static void ftrace_destroy_buffers(struct ring_buffer_per_cpu *buffers)
continue;
free(buffers[i].pages);
+ free(buffers[i].linear_pages);
}
}
@@ -470,7 +529,7 @@ static void ftrace_destroy(void)
free(global_buffers);
}
-static int ftrace_dump_page(FILE *out, ulong page, void *page_tmp)
+static int ftrace_dump_page(int fd, ulong page, void *page_tmp)
{
ulong raw_page;
@@ -480,7 +539,8 @@ static int ftrace_dump_page(FILE *out, ulong page, void *page_tmp)
RETURN_ON_ERROR))
goto out_fail;
- fwrite(page_tmp, 1, PAGESIZE(), out);
+ if (write_and_check(fd, page_tmp, PAGESIZE()))
+ return -1;
return 0;
@@ -489,33 +549,15 @@ out_fail:
}
static
-void ftrace_dump_buffer(FILE *out, struct ring_buffer_per_cpu *cpu_buffer,
+void ftrace_dump_buffer(int fd, struct ring_buffer_per_cpu *cpu_buffer,
unsigned pages, void *page_tmp)
{
- unsigned i;
-
- if (ftrace_dump_page(out, cpu_buffer->reader_page, page_tmp) < 0)
- return;
-
- if (cpu_buffer->reader_page == cpu_buffer->commit_page)
- return;
-
- i = cpu_buffer->head_page_index;
- for (;;) {
- if (ftrace_dump_page(out, cpu_buffer->pages[i], page_tmp) < 0)
- break;
-
- if (cpu_buffer->pages[i] == cpu_buffer->commit_page)
- break;
-
- i++;
- if (i == pages)
- i = 0;
+ int i;
- if (i == cpu_buffer->head_page_index) {
- /* cpu_buffer->commit_page may be corrupted */
+ for (i = 0; i < cpu_buffer->nr_linear_pages; i++) {
+ if (ftrace_dump_page(fd, cpu_buffer->linear_pages[i],
+ page_tmp) < 0)
break;
- }
}
}
@@ -540,7 +582,7 @@ static int ftrace_dump_buffers(const char *per_cpu_path)
int i;
void *page_tmp;
char path[PATH_MAX];
- FILE *out;
+ int fd;
page_tmp = malloc(PAGESIZE());
if (page_tmp == NULL)
@@ -558,12 +600,12 @@ static int ftrace_dump_buffers(const char *per_cpu_path)
snprintf(path, sizeof(path), "%s/cpu%d/trace_pipe_raw",
per_cpu_path, i);
- out = fopen(path, "wb");
- if (out == NULL)
+ fd = open(path, O_WRONLY | O_CREAT, 0644);
+ if (fd < 0)
goto out_fail;
- ftrace_dump_buffer(out, cpu_buffer, global_pages, page_tmp);
- fclose(out);
+ ftrace_dump_buffer(fd, cpu_buffer, global_pages, page_tmp);
+ close(fd);
}
free(page_tmp);
@@ -727,6 +769,7 @@ static void ftrace_destroy_event_types(void)
free(event_types[i]->fields);
free(event_types[i]->system);
free(event_types[i]->name);
+ free(event_types[i]->print_fmt);
free(event_types[i]);
}
@@ -746,8 +789,8 @@ static int ftrace_init_event_types(void)
read_value(event, ftrace_events, list_head, next);
while (event != ftrace_events) {
ulong call;
- ulong name_addr, system_addr;
- char name[128], system[128];
+ ulong name_addr, system_addr, print_fmt_addr;
+ char name[128], system[128], print_fmt[4096];
int id;
call = event - koffset(ftrace_event_call, list);
@@ -756,11 +799,14 @@ static int ftrace_init_event_types(void)
read_value(id, call, ftrace_event_call, id);
read_value(name_addr, call, ftrace_event_call, name);
read_value(system_addr, call, ftrace_event_call, system);
+ read_value(print_fmt_addr, call, ftrace_event_call, print_fmt);
if (!read_string(name_addr, name, 128))
goto out_fail;
if (!read_string(system_addr, system, 128))
goto out_fail;
+ if (!read_string(print_fmt_addr, print_fmt, 4096))
+ goto out_fail;
/* Enlarge event types array when need */
if (nr_event_types >= max_types) {
@@ -782,6 +828,7 @@ static int ftrace_init_event_types(void)
aevent_type->system = strdup(system);
aevent_type->name = strdup(name);
+ aevent_type->print_fmt = strdup(print_fmt);
aevent_type->id = id;
aevent_type->nfields = 0;
aevent_type->fields = NULL;
@@ -812,6 +859,7 @@ static int ftrace_init_event_types(void)
out_fail_free_aevent_type:
free(aevent_type->system);
free(aevent_type->name);
+ free(aevent_type->print_fmt);
free(aevent_type);
out_fail:
ftrace_destroy_event_types();
@@ -868,6 +916,7 @@ static int ftrace_dump_event_type(struct event_type *t, const char *path)
char format_path[PATH_MAX];
FILE *out;
int i;
+ int common_field_count = 5;
snprintf(format_path, sizeof(format_path), "%s/format", path);
out = fopen(format_path, "w");
@@ -878,15 +927,40 @@ static int ftrace_dump_event_type(struct event_type *t, const char *path)
fprintf(out, "ID: %d\n", t->id);
fprintf(out, "format:\n");
- for (i = 0; i < t->nfields; i++) {
- struct ftrace_field *f = &t->fields[i];
+ for (i = t->nfields - 1; i >= 0; i--) {
+ /*
+ * Smartly shows the array type(except dynamic array).
+ * Normal:
+ * field:TYPE VAR
+ * If TYPE := TYPE[LEN], it is shown:
+ * field:TYPE VAR[LEN]
+ */
+ struct ftrace_field *field = &t->fields[i];
+ const char *array_descriptor = strchr(field->type, '[');
+
+ if (!strncmp(field->type, "__data_loc", 10))
+ array_descriptor = NULL;
+
+ if (!array_descriptor) {
+ fprintf(out, "\tfield:%s %s;\toffset:%u;"
+ "\tsize:%u;\tsigned:%d;\n",
+ field->type, field->name, field->offset,
+ field->size, !!field->is_signed);
+ } else {
+ fprintf(out, "\tfield:%.*s %s%s;\toffset:%u;"
+ "\tsize:%u;\tsigned:%d;\n",
+ (int)(array_descriptor - field->type),
+ field->type, field->name,
+ array_descriptor, field->offset,
+ field->size, !!field->is_signed);
+ }
- fprintf(out, "\tfield:%s %s;\toffset:%d;\tsize:%d;\n",
- f->type, f->name, f->offset, f->size);
+ if (--common_field_count == 0)
+ fprintf(out, "\n");
}
- /* TODO */
- fprintf(out, "\nprint fmt: \"unknow fmt from dump\"\n");
+ fprintf(out, "\nprint fmt: %s\n", t->print_fmt);
+
fclose(out);
return 0;
@@ -918,9 +992,7 @@ static int ftrace_dump_event_types(const char *events_path)
struct ring_buffer_per_cpu_stream {
struct ring_buffer_per_cpu *cpu_buffer;
- ulong *pages;
void *curr_page;
- int available_pages;
int curr_page_indx;
uint64_t ts;
@@ -932,43 +1004,11 @@ static
int ring_buffer_per_cpu_stream_init(struct ring_buffer_per_cpu *cpu_buffer,
unsigned pages, struct ring_buffer_per_cpu_stream *s)
{
- unsigned i, count = 0;
-
s->cpu_buffer = cpu_buffer;
s->curr_page = malloc(PAGESIZE());
if (s->curr_page == NULL)
return -1;
- s->pages = malloc(sizeof(ulong) * (pages + 1));
- if (s->pages == NULL) {
- free(s->curr_page);
- return -1;
- }
-
- s->pages[count++] = cpu_buffer->reader_page;
-
- if (cpu_buffer->reader_page == cpu_buffer->commit_page)
- goto pages_done;
-
- i = cpu_buffer->head_page_index;
- for (;;) {
- s->pages[count++] = cpu_buffer->pages[i];
-
- if (cpu_buffer->pages[i] == cpu_buffer->commit_page)
- break;
-
- i++;
- if (i == pages)
- i = 0;
-
- if (i == cpu_buffer->head_page_index) {
- /* cpu_buffer->commit_page may be corrupted */
- break;
- }
- }
-
-pages_done:
- s->available_pages = count;
s->curr_page_indx = -1;
return 0;
}
@@ -977,7 +1017,6 @@ static
void ring_buffer_per_cpu_stream_destroy(struct ring_buffer_per_cpu_stream *s)
{
free(s->curr_page);
- free(s->pages);
}
struct ftrace_event {
@@ -1003,7 +1042,8 @@ int ring_buffer_per_cpu_stream_get_page(struct ring_buffer_per_cpu_stream *s)
{
ulong raw_page;
- read_value(raw_page, s->pages[s->curr_page_indx], buffer_page, page);
+ read_value(raw_page, s->cpu_buffer->linear_pages[s->curr_page_indx],
+ buffer_page, page);
if (!readmem(raw_page, KVADDR, s->curr_page, PAGESIZE(),
"get page context", RETURN_ON_ERROR))
@@ -1027,18 +1067,18 @@ int ring_buffer_per_cpu_stream_pop_event(struct ring_buffer_per_cpu_stream *s,
res->data = NULL;
- if (s->curr_page_indx >= s->available_pages)
+ if (s->curr_page_indx >= s->cpu_buffer->nr_linear_pages)
return -1;
again:
if ((s->curr_page_indx == -1) || (s->offset >= s->commit)) {
s->curr_page_indx++;
- if (s->curr_page_indx == s->available_pages)
+ if (s->curr_page_indx == s->cpu_buffer->nr_linear_pages)
return -1;
if (ring_buffer_per_cpu_stream_get_page(s) < 0) {
- s->curr_page_indx = s->available_pages;
+ s->curr_page_indx = s->cpu_buffer->nr_linear_pages;
return -1;
}
@@ -1350,6 +1390,39 @@ static int dump_saved_cmdlines(const char *dump_tracing_dir)
return 0;
}
+static int dump_kallsyms(const char *dump_tracing_dir)
+{
+ char path[PATH_MAX];
+ FILE *out;
+ int i;
+ struct syment *sp;
+
+ snprintf(path, sizeof(path), "%s/kallsyms", dump_tracing_dir);
+ out = fopen(path, "w");
+ if (out == NULL)
+ return -1;
+
+ for (sp = st->symtable; sp < st->symend; sp++)
+ fprintf(out, "%lx %c %s\n", sp->value, sp->type, sp->name);
+
+ for (i = 0; i < st->mods_installed; i++) {
+ struct load_module *lm = &st->load_modules[i];
+
+ for (sp = lm->mod_symtable; sp <= lm->mod_symend; sp++) {
+ if (!strncmp(sp->name, "_MODULE_", strlen("_MODULE_")))
+ continue;
+
+ fprintf(out, "%lx %c %s\t[%s]\n", sp->value, sp->type,
+ sp->name, lm->mod_name);
+ }
+ }
+
+ fclose(out);
+ return 0;
+}
+
+static int trace_cmd_data_output(int fd);
+
static void ftrace_dump(int argc, char *argv[])
{
int c;
@@ -1359,7 +1432,7 @@ static void ftrace_dump(int argc, char *argv[])
char path[PATH_MAX];
int ret;
- while ((c = getopt(argc, argv, "sm")) != EOF) {
+ while ((c = getopt(argc, argv, "smt")) != EOF) {
switch(c)
{
case 's':
@@ -1368,6 +1441,23 @@ static void ftrace_dump(int argc, char *argv[])
case 'm':
dump_meta_data = 1;
break;
+ case 't':
+ if (dump_symbols || dump_meta_data || argc - optind > 1)
+ cmd_usage(pc->curcmd, SYNOPSIS);
+ else {
+ char *trace_dat;
+ int fd;
+
+ if (argc - optind == 0)
+ trace_dat = "trace.dat";
+ else if (argc - optind == 1)
+ trace_dat = argv[optind];
+ fd = open(trace_dat, O_WRONLY | O_CREAT
+ | O_TRUNC, 0644);
+ trace_cmd_data_output(fd);
+ close(fd);
+ }
+ return;
default:
cmd_usage(pc->curcmd, SYNOPSIS);
return;
@@ -1413,10 +1503,7 @@ static void ftrace_dump(int argc, char *argv[])
if (dump_symbols) {
/* Dump all symbols of the kernel */
- fprintf(fp, "\n-s option hasn't been implemented.\n");
- fprintf(fp, "symbols is not dumpped.\n");
- fprintf(fp, "You can use `sym -l > %s/kallsyms`\n\n",
- dump_tracing_dir);
+ dump_kallsyms(dump_tracing_dir);
}
}
@@ -2508,6 +2595,9 @@ static char *help_ftrace[] = {
" the same as debugfs/tracing.",
" -m: also dump metadata of ftrace.",
" -s: also dump symbols of the kernel <not implemented>.",
+"trace dump -t [output-file-name]",
+" dump ring_buffers and all meta data to a file that can",
+" be parsed by trace-cmd. Default output file name is \"trace.dat\".",
NULL
};
@@ -2536,3 +2626,521 @@ int _fini(void)
return 1;
}
+
+#define TRACE_CMD_FILE_VERSION_STRING "6"
+
+static inline int host_bigendian(void)
+{
+ unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
+ unsigned int *ptr;
+
+ ptr = (unsigned int *)str;
+ return *ptr == 0x01020304;
+}
+
+static char *tmp_file_buf;
+static unsigned long long tmp_file_pos;
+static unsigned long long tmp_file_size;
+static int tmp_file_error;
+
+static int init_tmp_file(void)
+{
+ tmp_file_buf = malloc(4096);
+ if (tmp_file_buf == NULL)
+ return -1;
+
+ tmp_file_pos = 0;
+ tmp_file_size = 4096;
+ tmp_file_error = 0;
+
+ return 0;
+}
+
+static void destory_tmp_file(void)
+{
+ free(tmp_file_buf);
+}
+
+#define tmp_fprintf(fmt...) \
+do { \
+ char *__buf = tmp_file_buf; \
+ unsigned long long __pos; \
+ \
+ if (tmp_file_error) \
+ break; \
+ __pos = tmp_file_pos; \
+ __pos += snprintf(__buf + __pos, tmp_file_size - __pos, fmt); \
+ if (__pos > tmp_file_size) { \
+ tmp_file_size = __pos + tmp_file_size; \
+ __buf = realloc(__buf, tmp_file_size); \
+ if (!__buf) { \
+ tmp_file_error = 1; \
+ break; \
+ } \
+ tmp_file_buf = __buf; \
+ __pos = tmp_file_pos; \
+ __pos += snprintf(__buf + __pos, tmp_file_size - __pos, fmt);\
+ } \
+ tmp_file_pos = __pos; \
+} while (0)
+
+static int tmp_file_record_size4(int fd)
+{
+ unsigned int size = tmp_file_pos;
+
+ if (tmp_file_error)
+ return -1;
+ if (write_and_check(fd, &size, 4))
+ return -1;
+ return 0;
+}
+
+static int tmp_file_record_size8(int fd)
+{
+ if (tmp_file_error)
+ return -1;
+ if (write_and_check(fd, &tmp_file_pos, 8))
+ return -1;
+ return 0;
+}
+
+static int tmp_file_flush(int fd)
+{
+ if (tmp_file_error)
+ return -1;
+ if (write_and_check(fd, tmp_file_buf, tmp_file_pos))
+ return -1;
+ tmp_file_pos = 0;
+ return 0;
+}
+
+static int save_initial_data(int fd)
+{
+ int page_size;
+ char buf[20];
+
+ if (write_and_check(fd, "\027\010\104tracing", 10))
+ return -1;
+
+ if (write_and_check(fd, TRACE_CMD_FILE_VERSION_STRING,
+ strlen(TRACE_CMD_FILE_VERSION_STRING) + 1))
+ return -1;
+
+ /* Crash ensure core file endian and the host endian are the same */
+ if (host_bigendian())
+ buf[0] = 1;
+ else
+ buf[0] = 0;
+
+ if (write_and_check(fd, buf, 1))
+ return -1;
+
+ /* save size of long (this may not be what the kernel is) */
+ buf[0] = sizeof(long);
+ if (write_and_check(fd, buf, 1))
+ return -1;
+
+ page_size = PAGESIZE();
+ if (write_and_check(fd, &page_size, 4))
+ return -1;
+
+ return 0;
+}
+
+static int save_header_files(int fd)
+{
+ /* save header_page */
+ if (write_and_check(fd, "header_page", 12))
+ return -1;
+
+ tmp_fprintf("\tfield: u64 timestamp;\toffset:0;\tsize:8;\tsigned:0;\n");
+
+ tmp_fprintf("\tfield: local_t commit;\toffset:8;\tsize:%u;\t"
+ "signed:1;\n", (unsigned int)sizeof(long));
+
+ tmp_fprintf("\tfield: int overwrite;\toffset:8;\tsize:%u;\tsigned:1;\n",
+ (unsigned int)sizeof(long));
+
+ tmp_fprintf("\tfield: char data;\toffset:%u;\tsize:%u;\tsigned:1;\n",
+ (unsigned int)(8 + sizeof(long)),
+ (unsigned int)(PAGESIZE() - 8 - sizeof(long)));
+
+ if (tmp_file_record_size8(fd))
+ return -1;
+ if (tmp_file_flush(fd))
+ return -1;
+
+ /* save header_event */
+ if (write_and_check(fd, "header_event", 13))
+ return -1;
+
+ tmp_fprintf(
+ "# compressed entry header\n"
+ "\ttype_len : 5 bits\n"
+ "\ttime_delta : 27 bits\n"
+ "\tarray : 32 bits\n"
+ "\n"
+ "\tpadding : type == 29\n"
+ "\ttime_extend : type == 30\n"
+ "\tdata max type_len == 28\n"
+ );
+
+ if (tmp_file_record_size8(fd))
+ return -1;
+ if (tmp_file_flush(fd))
+ return -1;
+
+ return 0;
+}
+
+static int save_event_file(int fd, struct event_type *t)
+{
+ int i;
+ int common_field_count = 5;
+
+ tmp_fprintf("name: %s\n", t->name);
+ tmp_fprintf("ID: %d\n", t->id);
+ tmp_fprintf("format:\n");
+
+ for (i = t->nfields - 1; i >= 0; i--) {
+ /*
+ * Smartly shows the array type(except dynamic array).
+ * Normal:
+ * field:TYPE VAR
+ * If TYPE := TYPE[LEN], it is shown:
+ * field:TYPE VAR[LEN]
+ */
+ struct ftrace_field *field = &t->fields[i];
+ const char *array_descriptor = strchr(field->type, '[');
+
+ if (!strncmp(field->type, "__data_loc", 10))
+ array_descriptor = NULL;
+
+ if (!array_descriptor) {
+ tmp_fprintf("\tfield:%s %s;\toffset:%u;"
+ "\tsize:%u;\tsigned:%d;\n",
+ field->type, field->name, field->offset,
+ field->size, !!field->is_signed);
+ } else {
+ tmp_fprintf("\tfield:%.*s %s%s;\toffset:%u;"
+ "\tsize:%u;\tsigned:%d;\n",
+ (int)(array_descriptor - field->type),
+ field->type, field->name,
+ array_descriptor, field->offset,
+ field->size, !!field->is_signed);
+ }
+
+ if (--common_field_count == 0)
+ tmp_fprintf("\n");
+ }
+
+ tmp_fprintf("\nprint fmt: %s\n", t->print_fmt);
+
+ if (tmp_file_record_size8(fd))
+ return -1;
+ return tmp_file_flush(fd);
+}
+
+static int save_system_files(int fd, int *system_ids, int system_id)
+{
+ int i, total = 0;
+
+ for (i = 0; i < nr_event_types; i++) {
+ if (system_ids[i] == system_id)
+ total++;
+ }
+
+ if (write_and_check(fd, &total, 4))
+ return -1;
+
+ for (i = 0; i < nr_event_types; i++) {
+ if (system_ids[i] != system_id)
+ continue;
+
+ if (save_event_file(fd, event_types[i]))
+ return -1;
+ }
+
+ return 0;
+}
+
+static int save_events_files(int fd)
+{
+ int system_id = 1, *system_ids;
+ const char *system = "ftrace";
+ int i;
+ int nr_systems;
+
+ system_ids = calloc(sizeof(*system_ids), nr_event_types);
+ if (system_ids == NULL)
+ return -1;
+
+ for (;;) {
+ for (i = 0; i < nr_event_types; i++) {
+ if (system_ids[i])
+ continue;
+ if (!system) {
+ system = event_types[i]->system;
+ system_ids[i] = system_id;
+ continue;
+ }
+ if (!strcmp(event_types[i]->system, system))
+ system_ids[i] = system_id;
+ }
+ if (!system)
+ break;
+ system_id++;
+ system = NULL;
+ }
+
+ /* ftrace events */
+ if (save_system_files(fd, system_ids, 1))
+ goto fail;
+
+ /* other systems events */
+ nr_systems = system_id - 2;
+ if (write_and_check(fd, &nr_systems, 4))
+ goto fail;
+ for (system_id = 2; system_id < nr_systems + 2; system_id++) {
+ for (i = 0; i < nr_event_types; i++) {
+ if (system_ids[i] == system_id)
+ break;
+ }
+ if (write_and_check(fd, (void *)event_types[i]->system,
+ strlen(event_types[i]->system) + 1))
+ goto fail;
+ if (save_system_files(fd, system_ids, system_id))
+ goto fail;
+ }
+
+ free(system_ids);
+ return 0;
+
+fail:
+ free(system_ids);
+ return -1;
+}
+
+static int save_proc_kallsyms(int fd)
+{
+ int i;
+ struct syment *sp;
+
+ for (sp = st->symtable; sp < st->symend; sp++)
+ tmp_fprintf("%lx %c %s\n", sp->value, sp->type, sp->name);
+
+ for (i = 0; i < st->mods_installed; i++) {
+ struct load_module *lm = &st->load_modules[i];
+
+ for (sp = lm->mod_symtable; sp <= lm->mod_symend; sp++) {
+ if (!strncmp(sp->name, "_MODULE_", strlen("_MODULE_")))
+ continue;
+
+ tmp_fprintf("%lx %c %s\t[%s]\n", sp->value, sp->type,
+ sp->name, lm->mod_name);
+ }
+ }
+
+ if (tmp_file_record_size4(fd))
+ return -1;
+ return tmp_file_flush(fd);
+}
+
+static int save_ftrace_printk(int fd)
+{
+ struct syment *s, *e;
+ long bprintk_fmt_s, bprintk_fmt_e;
+ char string[4096];
+ long *address;
+ size_t i, count;
+
+ s = symbol_search("__start___trace_bprintk_fmt");
+ e = symbol_search("__stop___trace_bprintk_fmt");
+ if (s == NULL || e == NULL)
+ return -1;
+
+ bprintk_fmt_s = s->value;
+ bprintk_fmt_e = e->value;
+ count = (bprintk_fmt_e - bprintk_fmt_s) / sizeof(long);
+
+ if (count == 0) {
+ unsigned int size = 0;
+ return write_and_check(fd, &size, 4);
+ }
+
+ address = malloc(count * sizeof(long));
+ if (address == NULL)
+ return -1;
+
+ if (!readmem(bprintk_fmt_s, KVADDR, address, count * sizeof(long),
+ "get printk address", RETURN_ON_ERROR)) {
+ free(address);
+ return -1;
+ }
+
+ for (i = 0; i < count; i++) {
+ size_t len = read_string(address[i], string, sizeof(string));
+ if (!len) {
+ free(address);
+ return -1;
+ }
+
+ tmp_fprintf("0x%lx : \"", address[i]);
+
+ for (i = 0; string[i]; i++) {
+ switch (string[i]) {
+ case '\n':
+ tmp_fprintf("\\n");
+ break;
+ case '\t':
+ tmp_fprintf("\\t");
+ break;
+ case '\\':
+ tmp_fprintf("\\\\");
+ break;
+ case '"':
+ tmp_fprintf("\\\"");
+ break;
+ default:
+ tmp_fprintf("%c", string[i]);
+ }
+ }
+ tmp_fprintf("\"\n");
+ }
+
+ free(address);
+
+ if (tmp_file_record_size4(fd))
+ return -1;
+ return tmp_file_flush(fd);
+}
+
+static int save_ftrace_cmdlines(int fd)
+{
+ int i;
+ struct task_context *tc = FIRST_CONTEXT();
+
+ for (i = 0; i < RUNNING_TASKS(); i++)
+ tmp_fprintf("%d %s\n", (int)tc[i].pid, tc[i].comm);
+
+ if (tmp_file_record_size8(fd))
+ return -1;
+ return tmp_file_flush(fd);
+}
+
+static int save_res_data(int fd, int nr_cpu_buffers)
+{
+ unsigned short option = 0;
+
+ if (write_and_check(fd, &nr_cpu_buffers, 4))
+ return -1;
+
+ if (write_and_check(fd, "options ", 10))
+ return -1;
+
+ if (write_and_check(fd, &option, 2))
+ return -1;
+
+ if (write_and_check(fd, "flyrecord", 10))
+ return -1;
+
+ return 0;
+}
+
+static int save_record_data(int fd, int nr_cpu_buffers)
+{
+ int i, j;
+ unsigned long long offset, buffer_offset;
+ void *page_tmp;
+
+ offset = lseek(fd, 0, SEEK_CUR);
+ offset += nr_cpu_buffers * 16;
+ offset = (offset + (PAGESIZE() - 1)) & ~(PAGESIZE() - 1);
+ buffer_offset = offset;
+
+ for (i = 0; i < nr_cpu_ids; i++) {
+ struct ring_buffer_per_cpu *cpu_buffer = &global_buffers[i];
+ unsigned long long buffer_size;
+
+ if (!cpu_buffer->kaddr)
+ continue;
+
+ buffer_size = PAGESIZE() * cpu_buffer->nr_linear_pages;
+ if (write_and_check(fd, &buffer_offset, 8))
+ return -1;
+ if (write_and_check(fd, &buffer_size, 8))
+ return -1;
+ buffer_offset += buffer_size;
+ }
+
+ page_tmp = malloc(PAGESIZE());
+ if (page_tmp == NULL)
+ return -1;
+
+ lseek(fd, offset, SEEK_SET);
+ for (i = 0; i < nr_cpu_ids; i++) {
+ struct ring_buffer_per_cpu *cpu_buffer = &global_buffers[i];
+
+ if (!cpu_buffer->kaddr)
+ continue;
+
+ for (j = 0; j < cpu_buffer->nr_linear_pages; j++) {
+ if (ftrace_dump_page(fd, cpu_buffer->linear_pages[i],
+ page_tmp) < 0) {
+ free(page_tmp);
+ return -1;
+ }
+ }
+ }
+
+ free(page_tmp);
+
+ return 0;
+}
+
+static int __trace_cmd_data_output(int fd)
+{
+ 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];
+
+ if (!cpu_buffer->kaddr)
+ continue;
+
+ nr_cpu_buffers++;
+ }
+
+ if (save_initial_data(fd))
+ return -1;
+ if (save_header_files(fd))
+ return -1;
+ if (save_events_files(fd)) /* ftrace events and other systems events */
+ return -1;
+ if (save_proc_kallsyms(fd))
+ return -1;
+ if (save_ftrace_printk(fd))
+ return -1;
+ if (save_ftrace_cmdlines(fd))
+ return -1;
+ if (save_res_data(fd, nr_cpu_buffers))
+ return -1;
+ if (save_record_data(fd, nr_cpu_buffers))
+ return -1;
+
+ return 0;
+}
+
+static int trace_cmd_data_output(int fd)
+{
+ int ret;
+
+ if (init_tmp_file())
+ return -1;
+
+ ret = __trace_cmd_data_output(fd);
+ destory_tmp_file();
+
+ return ret;
+}
--
Crash-utility mailing list
Crash-utility@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/crash-utility
