diff --git a/SOURCES/TRACE_EVENT_FL_TRACEPOINT_flag.patch b/SOURCES/TRACE_EVENT_FL_TRACEPOINT_flag.patch
new file mode 100644
index 0000000..530f1ed
--- /dev/null
+++ b/SOURCES/TRACE_EVENT_FL_TRACEPOINT_flag.patch
@@ -0,0 +1,743 @@
+--- crash-trace-command-2.0/trace.c.orig
++++ crash-trace-command-2.0/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, o
+ 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 {
+@@ -101,16 +107,25 @@ 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 {
++	char name[NAME_MAX + 1];
++	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 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;
+@@ -229,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
+ }
+@@ -435,61 +453,140 @@ 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(ti->buffers, ti->ring_buffer,
++			ti->pages) < 0)
++		goto out_fail;
++
++	if (!ti->max_tr_ring_buffer)
++		return 0;
++
++	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(global_buffers, global_ring_buffer,
+-			global_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(global_buffers);
++	free(ti->max_tr_buffers);
++	free(ti->buffers);
+ 	return -1;
+ }
+ 
+-static int ftrace_int_max_tr_trace(void)
++static void ftrace_destroy_all_instance_buffers()
+ {
+-	if (trace_buffer_available) {
+-		if (!max_buffer_available)
+-			return 0;
++	int i;
+ 
+-		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);
++	for (i = 0; i < instance_count; i++)
++	{
++		struct trace_instance *ti = &trace_instances[i];
+ 
+-		if (!max_tr_ring_buffer)
+-			return 0;
++		if (ti->max_tr_ring_buffer) {
++			ftrace_destroy_buffers(ti->max_tr_buffers);
++			free(ti->max_tr_buffers);
++		}
+ 
+-		read_value(max_tr_pages, max_tr_ring_buffer, ring_buffer, pages);
++		ftrace_destroy_buffers(ti->buffers);
++		free(ti->buffers);
+ 	}
++}
+ 
+-	max_tr_buffers = calloc(sizeof(*max_tr_buffers), nr_cpu_ids);
+-	if (max_tr_buffers == NULL)
+-		goto out_fail;
++static void ftrace_destroy_instances()
++{
++	ftrace_destroy_all_instance_buffers();
++	free(trace_instances);
++}
+ 
+-	if (ftrace_init_buffers(max_tr_buffers, max_tr_ring_buffer,
+-			max_tr_pages) < 0)
+-		goto out_fail;
++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:
+-	free(max_tr_buffers);
+-	max_tr_ring_buffer = 0;
++	/* 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;
+ }
+ 
+@@ -504,7 +601,7 @@ static int ftrace_init_current_tracer(vo
+ 	} else {
+ 		read_value(addr, current_trace, POINTER_SYM, POINTER);
+ 	}
+-	
++
+ 	read_value(addr, addr, tracer, name);
+ 	read_string(addr, tmp, 128);
+ 
+@@ -524,9 +621,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;
+@@ -534,6 +633,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 {
+@@ -564,28 +670,31 @@ 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_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 (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 +704,15 @@ 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);
++	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);
+ 	}
+ 
+-	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 +763,8 @@ static int try_mkdir(const char *pathnam
+ 	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 +776,7 @@ static int ftrace_dump_buffers(const cha
+ 		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 +791,7 @@ static int ftrace_dump_buffers(const cha
+ 		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);
+ 	}
+ 
+@@ -1015,8 +1127,6 @@ static void ftrace_destroy_event_types(v
+ 	free(ftrace_common_fields);
+ }
+ 
+-#define TRACE_EVENT_FL_TRACEPOINT 0x40
+-
+ static
+ int ftrace_get_event_type_name(ulong call, char *name, int len)
+ {
+@@ -1024,34 +1134,35 @@ int ftrace_get_event_type_name(ulong cal
+ 	static int name_offset;
+ 	static int flags_offset;
+ 	static int tp_name_offset;
+-	uint flags;
++	static long tracepoint_flag;
+ 
++	uint flags;
+ 	ulong name_addr;
+ 
+ 	if (inited)
+ 		goto work;
+ 
+-	inited = 1;
+-	name_offset = MAX(MEMBER_OFFSET("ftrace_event_call", "name"),
+-		MEMBER_OFFSET("trace_event_call", "name"));
+-	if (name_offset >= 0)
+-		goto work;
+-
+-	name_offset = MAX(ANON_MEMBER_OFFSET("ftrace_event_call", "name"),
+-		ANON_MEMBER_OFFSET("trace_event_call", "name"));
+-	if (name_offset < 0)
+-		return -1;
++	name_offset = MAX(MEMBER_OFFSET("ftrace_event_call", "tp"),
++		MEMBER_OFFSET("trace_event_call", "tp"));
++	if (name_offset >= 0) {
++		flags_offset = MAX(MEMBER_OFFSET("ftrace_event_call", "flags"),
++			MEMBER_OFFSET("trace_event_call", "flags"));
++		if (flags_offset < 0)
++			return -1;
+ 
+-	flags_offset = MAX(MEMBER_OFFSET("ftrace_event_call", "flags"),
+-		MEMBER_OFFSET("trace_event_call", "flags"));
+-	if (flags_offset < 0)
+-		return -1;
++		tp_name_offset = MEMBER_OFFSET("tracepoint", "name");
++		if (tp_name_offset < 0)
++			return -1;
+ 
+-	tp_name_offset = MEMBER_OFFSET("tracepoint", "name");
+-	if (tp_name_offset < 0)
+-		return -1;
++		if (!enumerator_value("TRACE_EVENT_FL_TRACEPOINT", &tracepoint_flag))
++			return -1;
+ 
+-	inited = 2;
++		inited = 2;
++	} else {
++		name_offset = MAX(MEMBER_OFFSET("ftrace_event_call", "name"),
++			MEMBER_OFFSET("trace_event_call", "name"));
++		inited = 1;
++	}
+ 
+ work:
+ 	if (name_offset < 0)
+@@ -1067,7 +1178,7 @@ work:
+ 			     RETURN_ON_ERROR))
+ 			return -1;
+ 
+-		if (flags & TRACE_EVENT_FL_TRACEPOINT) {
++		if (flags & (uint)tracepoint_flag) {
+ 			if (!readmem(name_addr + tp_name_offset, KVADDR,
+ 				     &name_addr, sizeof(name_addr),
+ 				     "read tracepoint name", RETURN_ON_ERROR))
+@@ -1476,26 +1587,72 @@ static int dump_kallsyms(const char *dum
+ 
+ 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;
++	int i;
++	uint flags = 0;
+ 	char *dump_tracing_dir;
+-	char path[PATH_MAX];
+-	int ret;
++	char instance_path[PATH_MAX];
+ 
+         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";
+@@ -1526,38 +1683,34 @@ static void ftrace_dump(int argc, char *
+ 		return;
+ 	}
+ 
+-	ret = mkdir(dump_tracing_dir, 0755);
+-	if (ret < 0) {
+-		if (errno == EEXIST)
+-			error(INFO, "mkdir: %s exists\n", dump_tracing_dir);
++	if (!populate_ftrace_dir_tree(&global_trace_instance, dump_tracing_dir, flags))
+ 		return;
+-	}
+ 
+-	snprintf(path, sizeof(path), "%s/per_cpu", dump_tracing_dir);
+-	if (try_mkdir(path, 0755) < 0)
++	if (!multiple_instances_available || instance_count == 0)
+ 		return;
+ 
+-	if (ftrace_dump_buffers(path) < 0)
++	/* 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;
+ 
+-	if (dump_meta_data) {
+-		/* Dump event types */
+-		snprintf(path, sizeof(path), "%s/events", dump_tracing_dir);
+-		if (try_mkdir(path, 0755) < 0)
+-			return;
++	/* Don't care about the flags anymore */
++	flags = 0;
+ 
+-		if (ftrace_dump_event_types(path) < 0)
+-			return;
++	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);
+ 
+-		/* Dump pids with corresponding cmdlines */
+-		if (dump_saved_cmdlines(dump_tracing_dir) < 0)
+-			return;
++		if (populate_ftrace_dir_tree(ti, instance_path, flags) < 0)
++			break;
+ 	}
+ 
+-	if (dump_symbols) {
+-		/* Dump all symbols of the kernel */
+-		dump_kallsyms(dump_tracing_dir);
+-	}
++	return;
+ }
+ 
+ static void ftrace_show(int argc, char *argv[])
+@@ -2161,26 +2314,69 @@ 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;
+ 
+ 	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;
+@@ -2192,7 +2388,7 @@ static int save_record_data(int fd, int
+ 	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)
+@@ -2212,7 +2408,7 @@ static int save_record_data(int fd, int
+ 
+ 	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;
+@@ -2231,13 +2427,13 @@ static int save_record_data(int fd, int
+ 	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;
+@@ -2245,6 +2441,19 @@ static int __trace_cmd_data_output(int f
+ 		nr_cpu_buffers++;
+ 	}
+ 
++	return nr_cpu_buffers;
++}
++
++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);
++
+ 	if (save_initial_data(fd))
+ 		return -1;
+ 	if (save_header_files(fd))
+@@ -2257,9 +2466,38 @@ static int __trace_cmd_data_output(int f
+ 		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))
++	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;
diff --git a/SOURCES/big_endian_nr_pages.patch b/SOURCES/big_endian_nr_pages.patch
new file mode 100644
index 0000000..3498fad
--- /dev/null
+++ b/SOURCES/big_endian_nr_pages.patch
@@ -0,0 +1,26 @@
+--- crash-trace-command-2.0/trace.c.orig
++++ crash-trace-command-2.0/trace.c
+@@ -96,7 +96,7 @@ struct ring_buffer_per_cpu {
+ 	ulong real_head_page;
+ 
+ 	int head_page_index;
+-	unsigned int nr_pages;
++	unsigned long nr_pages;
+ 	ulong *pages;
+ 
+ 	ulong *linear_pages;
+@@ -430,7 +432,13 @@ static int ftrace_init_buffers(struct ri
+ 		buffer_read_value(overrun);
+ 		buffer_read_value(entries);
+ 		if (per_cpu_buffer_sizes) {
+-			buffer_read_value(nr_pages);
++			if (MEMBER_SIZE("ring_buffer_per_cpu", "nr_pages") == sizeof(unsigned int)) {
++				unsigned int tmp_nr_pages;
++				read_value(tmp_nr_pages, buffers[i].kaddr, ring_buffer_per_cpu, nr_pages);
++				buffers[i].nr_pages = (unsigned long) tmp_nr_pages;
++			} else {
++				buffer_read_value(nr_pages);
++			}
+ 			pages = buffers[i].nr_pages;
+ 		} else
+ 			buffers[i].nr_pages = pages;
diff --git a/SOURCES/ppc64_ring_buffer_read.patch b/SOURCES/ppc64_ring_buffer_read.patch
new file mode 100644
index 0000000..84ab1c8
--- /dev/null
+++ b/SOURCES/ppc64_ring_buffer_read.patch
@@ -0,0 +1,13 @@
+--- crash-trace-command-2.0/trace.c.orig
++++ crash-trace-command-2.0/trace.c
+@@ -198,7 +198,9 @@ static int init_offsets(void)
+ 			fprintf(fp, "per cpu buffer sizes\n");
+ 	}
+ 
+-	if (kernel_symbol_exists("ring_buffer_read"))
++	if (machine_type("PPC64") && kernel_symbol_exists(".ring_buffer_read"))
++		gdb_set_crash_scope(symbol_value(".ring_buffer_read"), ".ring_buffer_read");
++	else if (kernel_symbol_exists("ring_buffer_read"))
+ 		gdb_set_crash_scope(symbol_value("ring_buffer_read"), "ring_buffer_read");
+ 
+ 	if (!per_cpu_buffer_sizes)
diff --git a/SPECS/crash-trace-command.spec b/SPECS/crash-trace-command.spec
index fd6899a..e908a20 100644
--- a/SPECS/crash-trace-command.spec
+++ b/SPECS/crash-trace-command.spec
@@ -4,7 +4,7 @@
 Summary: Trace extension module for the crash utility
 Name: crash-trace-command
 Version: 2.0
-Release: 10%{?dist}
+Release: 12%{?dist}
 License: GPLv2
 Group: Development/Debuggers
 Source: %{name}-%{version}.tar.gz
@@ -24,6 +24,9 @@ Patch4: ARM64.patch
 Patch5: linux_3.10_support.patch
 Patch6: ppc64le.patch
 Patch7: linux_4.2_support.patch
+Patch8: TRACE_EVENT_FL_TRACEPOINT_flag.patch
+Patch9: big_endian_nr_pages.patch
+Patch10: ppc64_ring_buffer_read.patch
 
 %description
 Command for reading ftrace data from a dumpfile.
@@ -38,6 +41,9 @@ Command for reading ftrace data from a dumpfile.
 %patch5 -p1 -b linux_3.10_support.patch
 %patch6 -p1 -b ppc64le.patch
 %patch7 -p1 -b linux_4.2_support.patch
+%patch8 -p1 -b TRACE_EVENT_FL_TRACEPOINT_flag.patch
+%patch9 -p1 -b big_endian_nr_pages.patch
+%patch10 -p1 -b ppc64_ring_buffer_read.patch
 
 %build
 make
@@ -55,6 +61,13 @@ rm -rf %{buildroot}
 %doc COPYING
 
 %changelog
+* Sun Apr 16 2017 Dave Anderson <anderson@redhat.com> - 2.0.12
+- Differentiate ppc64 .ring_buffer_read text symbol from ring_buffer_read data symbol
+- Fix for ring_buffer_per_cpu.nr_pages size change on big-endian systems 
+- Fix for Linux 4.7 change to the TRACE_EVENT_FL_TRACEPOINT flag
+  Resolves: rhbz#1441914
+  Resolves: rhbz#1440726
+
 * Thu Feb 25 2016 Dave Anderson <anderson@redhat.com> - 2.0-10
 - Fix for ftrace symbol name changes in Linux 4.2 
   Resolves: rhbz#1265553