#include <lttng/msgpack.h>
#include <lttng/event-notifier-notification.h>
-static
-int capture_enum(struct lttng_msgpack_writer *writer,
- struct lttng_interpreter_output *output) __attribute__ ((unused));
+/*
+ * The capture buffer size needs to be below 1024 bytes to avoid the
+ * frame to be larger than the 1024 limit enforced by the kernel. If we
+ * ever need to increase it, we will need to use a memory allocation
+ * scheme which allows allocating temporary memory chunks from the
+ * instrumentation sites. This could be done by adapting lttng
+ * tp-mempool to become nmi-safe and lock-free.
+ */
+#define CAPTURE_BUFFER_SIZE 512
+
+struct lttng_event_notifier_notification {
+ int notification_fd;
+ uint64_t event_notifier_token;
+ uint8_t capture_buf[CAPTURE_BUFFER_SIZE];
+ struct lttng_msgpack_writer writer;
+ bool has_captures;
+};
+
static
int capture_enum(struct lttng_msgpack_writer *writer,
struct lttng_interpreter_output *output)
return value;
}
-static
-int capture_sequence(struct lttng_msgpack_writer *writer,
- struct lttng_interpreter_output *output) __attribute__ ((unused));
int capture_sequence(struct lttng_msgpack_writer *writer,
struct lttng_interpreter_output *output)
{
return ret;
}
-void lttng_event_notifier_notification_send(struct lttng_event_notifier *event_notifier)
+static
+int notification_append_capture(
+ struct lttng_event_notifier_notification *notif,
+ struct lttng_interpreter_output *output)
+{
+ struct lttng_msgpack_writer *writer = ¬if->writer;
+ int ret = 0;
+
+ switch (output->type) {
+ case LTTNG_INTERPRETER_TYPE_S64:
+ ret = lttng_msgpack_write_signed_integer(writer, output->u.s);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+ break;
+ case LTTNG_INTERPRETER_TYPE_U64:
+ ret = lttng_msgpack_write_unsigned_integer(writer, output->u.u);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+ break;
+ case LTTNG_INTERPRETER_TYPE_STRING:
+ ret = lttng_msgpack_write_str(writer, output->u.str.str);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+ break;
+ case LTTNG_INTERPRETER_TYPE_SEQUENCE:
+ ret = capture_sequence(writer, output);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+ break;
+ case LTTNG_INTERPRETER_TYPE_SIGNED_ENUM:
+ case LTTNG_INTERPRETER_TYPE_UNSIGNED_ENUM:
+ ret = capture_enum(writer, output);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+ break;
+ default:
+ ret = -1;
+ WARN_ON(1);
+ }
+end:
+ return ret;
+}
+
+static
+int notification_append_empty_capture(
+ struct lttng_event_notifier_notification *notif)
+{
+ int ret = lttng_msgpack_write_nil(¬if->writer);
+ if (ret)
+ WARN_ON_ONCE(1);
+
+ return ret;
+}
+
+static
+int notification_init(struct lttng_event_notifier_notification *notif,
+ struct lttng_event_notifier *event_notifier)
+{
+ struct lttng_msgpack_writer *writer = ¬if->writer;
+ int ret = 0;
+
+ notif->has_captures = false;
+
+ if (event_notifier->num_captures > 0) {
+ lttng_msgpack_writer_init(writer, notif->capture_buf,
+ CAPTURE_BUFFER_SIZE);
+
+ ret = lttng_msgpack_begin_array(writer, event_notifier->num_captures);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+
+ notif->has_captures = true;
+ }
+
+end:
+ return ret;
+}
+
+static
+void record_error(struct lttng_event_notifier *event_notifier)
+{
+
+ struct lttng_event_notifier_group *event_notifier_group = event_notifier->group;
+ size_t dimension_index[1];
+ int ret;
+
+ dimension_index[0] = event_notifier->error_counter_index;
+
+ ret = event_notifier_group->error_counter->ops->counter_add(
+ event_notifier_group->error_counter->counter,
+ dimension_index, 1);
+ if (ret)
+ WARN_ON_ONCE(1);
+}
+
+static
+void notification_send(struct lttng_event_notifier_notification *notif,
+ struct lttng_event_notifier *event_notifier)
{
struct lttng_event_notifier_group *event_notifier_group = event_notifier->group;
struct lib_ring_buffer_ctx ctx;
+ struct lttng_kernel_event_notifier_notification kernel_notif;
+ size_t capture_buffer_content_len, reserve_size;
int ret;
- if (unlikely(!READ_ONCE(event_notifier->enabled)))
- return;
+ reserve_size = sizeof(kernel_notif);
+ kernel_notif.token = event_notifier->user_token;
+
+ if (notif->has_captures) {
+ capture_buffer_content_len = notif->writer.write_pos - notif->writer.buffer;
+ } else {
+ capture_buffer_content_len = 0;
+ }
- lib_ring_buffer_ctx_init(&ctx, event_notifier_group->chan, NULL,
- sizeof(event_notifier->user_token),
- lttng_alignof(event_notifier->user_token), -1);
+ WARN_ON_ONCE(capture_buffer_content_len > CAPTURE_BUFFER_SIZE);
+
+ reserve_size += capture_buffer_content_len;
+ kernel_notif.capture_buf_size = capture_buffer_content_len;
+
+ lib_ring_buffer_ctx_init(&ctx, event_notifier_group->chan, NULL, reserve_size,
+ lttng_alignof(kernel_notif), -1);
ret = event_notifier_group->ops->event_reserve(&ctx, 0);
if (ret < 0) {
- //TODO: error handling with counter maps
- //silently drop for now.
- WARN_ON_ONCE(1);
+ record_error(event_notifier);
return;
}
- lib_ring_buffer_align_ctx(&ctx, lttng_alignof(event_notifier->user_token));
- event_notifier_group->ops->event_write(&ctx, &event_notifier->user_token,
- sizeof(event_notifier->user_token));
+
+ lib_ring_buffer_align_ctx(&ctx, lttng_alignof(kernel_notif));
+
+ /* Write the notif structure. */
+ event_notifier_group->ops->event_write(&ctx, &kernel_notif,
+ sizeof(kernel_notif));
+
+ /*
+ * Write the capture buffer. No need to realigned as the below is a raw
+ * char* buffer.
+ */
+ event_notifier_group->ops->event_write(&ctx, ¬if->capture_buf,
+ capture_buffer_content_len);
+
event_notifier_group->ops->event_commit(&ctx);
irq_work_queue(&event_notifier_group->wakeup_pending);
}
+
+void lttng_event_notifier_notification_send(struct lttng_event_notifier *event_notifier,
+ struct lttng_probe_ctx *lttng_probe_ctx,
+ const char *stack_data)
+{
+ struct lttng_event_notifier_notification notif = { 0 };
+ int ret;
+
+ if (unlikely(!READ_ONCE(event_notifier->enabled)))
+ return;
+
+ ret = notification_init(¬if, event_notifier);
+ if (ret) {
+ WARN_ON_ONCE(1);
+ goto end;
+ }
+
+ if (unlikely(!list_empty(&event_notifier->capture_bytecode_runtime_head))) {
+ struct lttng_bytecode_runtime *capture_bc_runtime;
+
+ /*
+ * Iterate over all the capture bytecodes. If the interpreter
+ * functions returns successfully, append the value of the
+ * `output` parameter to the capture buffer. If the interpreter
+ * fails, append an empty capture to the buffer.
+ */
+ list_for_each_entry(capture_bc_runtime,
+ &event_notifier->capture_bytecode_runtime_head, node) {
+ struct lttng_interpreter_output output;
+
+ if (capture_bc_runtime->interpreter_funcs.capture(capture_bc_runtime,
+ lttng_probe_ctx, stack_data, &output) & LTTNG_INTERPRETER_RECORD_FLAG)
+ ret = notification_append_capture(¬if, &output);
+ else
+ ret = notification_append_empty_capture(¬if);
+
+ if (ret)
+ printk(KERN_WARNING "Error appending capture to notification");
+ }
+ }
+
+ /*
+ * Send the notification (including the capture buffer) to the
+ * sessiond.
+ */
+ notification_send(¬if, event_notifier);
+end:
+ return;
+}
projects / lttng-modules.git / blobdiff