X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttng-context-callstack.c;h=57738bed5275bd460f0e7be5bee61540ce1318e2;hb=60d51de0fde1942b4143bcaf8592fea368952864;hp=d95cbc2eef3f7117f0fcb38508ff173106f9fadf;hpb=3c1a57e8ce82366ce96774e4ac1d7481c561cc4c;p=lttng-modules.git

diff --git a/lttng-context-callstack.c b/lttng-context-callstack.c
index d95cbc2e..57738bed 100644
--- a/lttng-context-callstack.c
+++ b/lttng-context-callstack.c
@@ -61,15 +61,20 @@
 #include "wrapper/vmalloc.h"
 #include "lttng-tracer.h"
 
-#define MAX_ENTRIES 25 /* BUG: saving more than 30 entries causes trace corruption */
+#define MAX_ENTRIES 25
+
+struct lttng_cs_nesting {
+	struct stack_trace stack_trace;
+	unsigned long entries[MAX_ENTRIES];
+};
 
 struct lttng_cs {
-	struct stack_trace items[RING_BUFFER_MAX_NESTING];
+	struct lttng_cs_nesting level[RING_BUFFER_MAX_NESTING];
 };
 
 struct field_data {
-	int mode;
 	struct lttng_cs __percpu *cs_percpu;
+	int mode;
 };
 
 struct lttng_cs_type {
@@ -85,14 +90,14 @@ enum lttng_cs_ctx_modes {
 
 static struct lttng_cs_type cs_types[] = {
 	{
-	  .name           = "callstack_kernel",
-	  .save_func_name = "save_stack_trace",
-	  .save_func      = NULL,
+		.name		= "callstack_kernel",
+		.save_func_name	= "save_stack_trace",
+		.save_func	= NULL,
 	},
 	{
-	  .name           = "callstack_user",
-	  .save_func_name = "save_stack_trace_user",
-	  .save_func      = NULL,
+		.name		= "callstack_user",
+		.save_func_name	= "save_stack_trace_user",
+		.save_func	= NULL,
 	},
 };
 
@@ -133,7 +138,7 @@ struct stack_trace *stack_trace_context(struct lttng_ctx_field *field,
 	if (nesting >= RING_BUFFER_MAX_NESTING) {
 		return NULL;
 	}
-	return &cs->items[nesting];
+	return &cs->level[nesting].stack_trace;
 }
 
 /*
@@ -151,65 +156,85 @@ size_t lttng_callstack_get_size(size_t offset, struct lttng_ctx_field *field,
 
 	/* do not write data if no space is available */
 	trace = stack_trace_context(field, ctx);
-	if (!trace)
-		return 0;
+	if (unlikely(!trace)) {
+		size += lib_ring_buffer_align(offset, lttng_alignof(unsigned int));
+		size += sizeof(unsigned int);
+		size += lib_ring_buffer_align(offset, lttng_alignof(unsigned long));
+		return size;
+	}
 
 	/* reset stack trace, no need to clear memory */
 	trace->nr_entries = 0;
 
 	/* do the real work and reserve space */
 	cs_types[fdata->mode].save_func(trace);
+	/*
+	 * Remove final ULONG_MAX delimiter. If we cannot find it, add
+	 * our own marker to show that the stack is incomplete. This is
+	 * more compact for a trace.
+	 */
+	if (trace->nr_entries > 0
+			&& trace->entries[trace->nr_entries - 1] == ULONG_MAX) {
+		trace->nr_entries--;
+	}
 	size += lib_ring_buffer_align(offset, lttng_alignof(unsigned int));
 	size += sizeof(unsigned int);
 	size += lib_ring_buffer_align(offset, lttng_alignof(unsigned long));
 	size += sizeof(unsigned long) * trace->nr_entries;
+	/* Add our own ULONG_MAX delimiter to show incomplete stack. */
+	if (trace->nr_entries == trace->max_entries)
+		size += sizeof(unsigned long);
 	return size;
 }
 
 static
 void lttng_callstack_record(struct lttng_ctx_field *field,
-			    struct lib_ring_buffer_ctx *ctx,
-			    struct lttng_channel *chan)
+			struct lib_ring_buffer_ctx *ctx,
+			struct lttng_channel *chan)
 {
 	struct stack_trace *trace = stack_trace_context(field, ctx);
+	unsigned int nr_seq_entries;
 
-	if (!trace)
+	if (unlikely(!trace)) {
+		nr_seq_entries = 0;
+		lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned int));
+		chan->ops->event_write(ctx, &nr_seq_entries, sizeof(unsigned int));
+		lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned long));
 		return;
+	}
 	lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned int));
-	chan->ops->event_write(ctx, &trace->nr_entries, sizeof(unsigned int));
+	nr_seq_entries = trace->nr_entries;
+	if (trace->nr_entries == trace->max_entries)
+		nr_seq_entries++;
+	chan->ops->event_write(ctx, &nr_seq_entries, sizeof(unsigned int));
 	lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned long));
 	chan->ops->event_write(ctx, trace->entries,
 			sizeof(unsigned long) * trace->nr_entries);
+	/* Add our own ULONG_MAX delimiter to show incomplete stack. */
+	if (trace->nr_entries == trace->max_entries) {
+		unsigned long delim = ULONG_MAX;
+
+		chan->ops->event_write(ctx, &delim, sizeof(unsigned long));
+	}
 }
 
 static
 void field_data_free(struct field_data *fdata)
 {
-	int cpu, i;
-	struct lttng_cs *cs;
-
 	if (!fdata)
 		return;
-	for_each_possible_cpu(cpu) {
-		cs = per_cpu_ptr(fdata->cs_percpu, cpu);
-		for (i = 0; i < RING_BUFFER_MAX_NESTING; i++) {
-			kfree(cs->items[i].entries);
-		}
-	}
 	free_percpu(fdata->cs_percpu);
 	kfree(fdata);
 }
 
 static
-struct field_data __percpu *field_data_create(unsigned int entries, int type)
+struct field_data __percpu *field_data_create(int type)
 {
 	int cpu, i;
-	struct stack_trace *item;
-	struct lttng_cs *cs;
 	struct lttng_cs __percpu *cs_set;
-	struct field_data* fdata;
+	struct field_data *fdata;
 
-	fdata = kzalloc(sizeof(unsigned long) * entries, GFP_KERNEL);
+	fdata = kzalloc(sizeof(*fdata), GFP_KERNEL);
 	if (!fdata)
 		return NULL;
 	cs_set = alloc_percpu(struct lttng_cs);
@@ -218,14 +243,15 @@ struct field_data __percpu *field_data_create(unsigned int entries, int type)
 
 	fdata->cs_percpu = cs_set;
 	for_each_possible_cpu(cpu) {
+		struct lttng_cs *cs;
+
 		cs = per_cpu_ptr(cs_set, cpu);
 		for (i = 0; i < RING_BUFFER_MAX_NESTING; i++) {
-			item = &cs->items[i];
-			item->entries = kzalloc(sizeof(unsigned long) * entries, GFP_KERNEL);
-			if (!item->entries) {
-				goto error_alloc;
-			}
-			item->max_entries = entries;
+			struct lttng_cs_nesting *level;
+
+			level = &cs->level[i];
+			level->stack_trace.entries = level->entries;
+			level->stack_trace.max_entries = MAX_ENTRIES;
 		}
 	}
 	fdata->mode = type;
@@ -262,7 +288,7 @@ int __lttng_add_callstack_generic(struct lttng_ctx **ctx, int mode)
 		ret = -EEXIST;
 		goto error_find;
 	}
-	fdata = field_data_create(MAX_ENTRIES, mode);
+	fdata = field_data_create(mode);
 	if (!fdata) {
 		ret = -ENOMEM;
 		goto error_create;