X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-context-callstack-legacy-impl.h;h=833443d612c73efe38389a32a24ee3d52e79bb43;hb=f5ffbd770ec2b9d1ac9b7059eb33a01432043bce;hp=8d78fb95700891b0a2f2dc622b6c36b2b5f3fce6;hpb=cfa6cc1d0f01c2cfcc1a679abf3a6572d411c309;p=lttng-modules.git

diff --git a/src/lttng-context-callstack-legacy-impl.h b/src/lttng-context-callstack-legacy-impl.h
index 8d78fb95..833443d6 100644
--- a/src/lttng-context-callstack-legacy-impl.h
+++ b/src/lttng-context-callstack-legacy-impl.h
@@ -56,18 +56,6 @@ static struct lttng_cs_type cs_types[] = {
 	},
 };
 
-static
-const char *lttng_cs_ctx_mode_name(enum lttng_cs_ctx_modes mode)
-{
-	return cs_types[mode].name;
-}
-
-static
-const char *lttng_cs_ctx_mode_length_name(enum lttng_cs_ctx_modes mode)
-{
-	return cs_types[mode].length_name;
-}
-
 static
 int init_type(enum lttng_cs_ctx_modes mode)
 {
@@ -107,19 +95,21 @@ void lttng_cs_set_init(struct lttng_cs __percpu *cs_set)
 /* Keep track of nesting inside userspace callstack context code */
 DEFINE_PER_CPU(int, callstack_user_nesting);
 
+/*
+ * Note: these callbacks expect to be invoked with preemption disabled across
+ * get_size and record due to its use of a per-cpu stack.
+ */
 static
-struct stack_trace *stack_trace_context(struct lttng_ctx_field *field,
-					struct lib_ring_buffer_ctx *ctx)
+struct stack_trace *stack_trace_context(struct field_data *fdata, int cpu)
 {
 	int buffer_nesting, cs_user_nesting;
 	struct lttng_cs *cs;
-	struct field_data *fdata = field->priv;
 
 	/*
 	 * Do not gather the userspace callstack context when the event was
 	 * triggered by the userspace callstack context saving mechanism.
 	 */
-	cs_user_nesting = per_cpu(callstack_user_nesting, ctx->cpu);
+	cs_user_nesting = per_cpu(callstack_user_nesting, cpu);
 
 	if (fdata->mode == CALLSTACK_USER && cs_user_nesting >= 1)
 		return NULL;
@@ -131,8 +121,8 @@ struct stack_trace *stack_trace_context(struct lttng_ctx_field *field,
 	 * max nesting is checked in lib_ring_buffer_get_cpu().
 	 * Check it again as a safety net.
 	 */
-	cs = per_cpu_ptr(fdata->cs_percpu, ctx->cpu);
-	buffer_nesting = per_cpu(lib_ring_buffer_nesting, ctx->cpu) - 1;
+	cs = per_cpu_ptr(fdata->cs_percpu, cpu);
+	buffer_nesting = per_cpu(lib_ring_buffer_nesting, cpu) - 1;
 	if (buffer_nesting >= RING_BUFFER_MAX_NESTING)
 		return NULL;
 
@@ -140,9 +130,7 @@ struct stack_trace *stack_trace_context(struct lttng_ctx_field *field,
 }
 
 static
-size_t lttng_callstack_length_get_size(size_t offset, struct lttng_ctx_field *field,
-				struct lib_ring_buffer_ctx *ctx,
-				struct lttng_channel *chan)
+size_t lttng_callstack_length_get_size(void *priv, struct lttng_kernel_probe_ctx *probe_ctx, size_t offset)
 {
 	size_t orig_offset = offset;
 
@@ -156,16 +144,15 @@ size_t lttng_callstack_length_get_size(size_t offset, struct lttng_ctx_field *fi
  * resulting callstack is saved to be accessed in the record step.
  */
 static
-size_t lttng_callstack_sequence_get_size(size_t offset, struct lttng_ctx_field *field,
-					struct lib_ring_buffer_ctx *ctx,
-					struct lttng_channel *chan)
+size_t lttng_callstack_sequence_get_size(void *priv, struct lttng_kernel_probe_ctx *probe_ctx, size_t offset)
 {
 	struct stack_trace *trace;
-	struct field_data *fdata = field->priv;
+	struct field_data *fdata = (struct field_data *) priv;
 	size_t orig_offset = offset;
+	int cpu = smp_processor_id();
 
 	/* do not write data if no space is available */
-	trace = stack_trace_context(field, ctx);
+	trace = stack_trace_context(fdata, cpu);
 	if (unlikely(!trace)) {
 		offset += lib_ring_buffer_align(offset, lttng_alignof(unsigned long));
 		return offset - orig_offset;
@@ -175,13 +162,13 @@ size_t lttng_callstack_sequence_get_size(size_t offset, struct lttng_ctx_field *
 	trace->nr_entries = 0;
 
 	if (fdata->mode == CALLSTACK_USER)
-		++per_cpu(callstack_user_nesting, ctx->cpu);
+		++per_cpu(callstack_user_nesting, cpu);
 
 	/* do the real work and reserve space */
 	cs_types[fdata->mode].save_func(trace);
 
 	if (fdata->mode == CALLSTACK_USER)
-		per_cpu(callstack_user_nesting, ctx->cpu)--;
+		per_cpu(callstack_user_nesting, cpu)--;
 
 	/*
 	 * Remove final ULONG_MAX delimiter. If we cannot find it, add
@@ -201,14 +188,15 @@ size_t lttng_callstack_sequence_get_size(size_t offset, struct lttng_ctx_field *
 }
 
 static
-void lttng_callstack_length_record(struct lttng_ctx_field *field,
-			struct lib_ring_buffer_ctx *ctx,
-			struct lttng_channel *chan)
+void lttng_callstack_length_record(void *priv, struct lttng_kernel_probe_ctx *probe_ctx,
+			struct lttng_kernel_ring_buffer_ctx *ctx,
+			struct lttng_kernel_channel_buffer *chan)
 {
-	struct stack_trace *trace = stack_trace_context(field, ctx);
+	int cpu = ctx->priv.reserve_cpu;
+	struct field_data *fdata = (struct field_data *) priv;
+	struct stack_trace *trace = stack_trace_context(fdata, cpu);
 	unsigned int nr_seq_entries;
 
-	lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned int));
 	if (unlikely(!trace)) {
 		nr_seq_entries = 0;
 	} else {
@@ -216,29 +204,31 @@ void lttng_callstack_length_record(struct lttng_ctx_field *field,
 		if (trace->nr_entries == trace->max_entries)
 			nr_seq_entries++;
 	}
-	chan->ops->event_write(ctx, &nr_seq_entries, sizeof(unsigned int));
+	chan->ops->event_write(ctx, &nr_seq_entries, sizeof(unsigned int), lttng_alignof(unsigned int));
 }
 static
-void lttng_callstack_sequence_record(struct lttng_ctx_field *field,
-			struct lib_ring_buffer_ctx *ctx,
-			struct lttng_channel *chan)
+void lttng_callstack_sequence_record(void *priv, struct lttng_kernel_probe_ctx *probe_ctx,
+			struct lttng_kernel_ring_buffer_ctx *ctx,
+			struct lttng_kernel_channel_buffer *chan)
 {
-	struct stack_trace *trace = stack_trace_context(field, ctx);
+	int cpu = ctx->priv.reserve_cpu;
+	struct field_data *fdata = (struct field_data *) priv;
+	struct stack_trace *trace = stack_trace_context(fdata, cpu);
 	unsigned int nr_seq_entries;
 
-	lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned long));
 	if (unlikely(!trace)) {
+		lib_ring_buffer_align_ctx(ctx, lttng_alignof(unsigned long));
 		return;
 	}
 	nr_seq_entries = trace->nr_entries;
 	if (trace->nr_entries == trace->max_entries)
 		nr_seq_entries++;
 	chan->ops->event_write(ctx, trace->entries,
-			sizeof(unsigned long) * trace->nr_entries);
+			sizeof(unsigned long) * trace->nr_entries, lttng_alignof(unsigned long));
 	/* 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));
+		chan->ops->event_write(ctx, &delim, sizeof(unsigned long), 1);
 	}
 }