X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fprobes%2Flttng-uprobes.c;h=fed3a1d5a2b4c9beefe4f787370398a38d44474f;hb=f5ffbd770ec2b9d1ac9b7059eb33a01432043bce;hp=89b474d1d0e5ed19e93f69f6f6e11256dd19f2ed;hpb=437d5aa59380583ce1cd14d394a53b398be1275d;p=lttng-modules.git

diff --git a/src/probes/lttng-uprobes.c b/src/probes/lttng-uprobes.c
index 89b474d1..fed3a1d5 100644
--- a/src/probes/lttng-uprobes.c
+++ b/src/probes/lttng-uprobes.c
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <lttng/events.h>
+#include <lttng/events-internal.h>
 #include <lttng/tracer.h>
 #include <wrapper/irqflags.h>
 #include <ringbuffer/frontend_types.h>
@@ -27,104 +28,110 @@ int lttng_uprobes_event_handler_pre(struct uprobe_consumer *uc, struct pt_regs *
 {
 	struct lttng_uprobe_handler *uprobe_handler =
 		container_of(uc, struct lttng_uprobe_handler, up_consumer);
-	struct lttng_event *event = uprobe_handler->u.event;
-	struct lttng_probe_ctx lttng_probe_ctx = {
+	struct lttng_kernel_event_common *event = uprobe_handler->event;
+	struct lttng_kernel_probe_ctx lttng_probe_ctx = {
 		.event = event,
 		.interruptible = !lttng_regs_irqs_disabled(regs),
 	};
-	struct lttng_channel *chan = event->chan;
-	struct lib_ring_buffer_ctx ctx;
-	int ret;
-
 	struct {
 		unsigned long ip;
 	} payload;
 
-	if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
-		return 0;
-	if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
-		return 0;
+	switch (event->type) {
+	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+	{
+		struct lttng_kernel_event_recorder *event_recorder =
+			container_of(event, struct lttng_kernel_event_recorder, parent);
+		struct lttng_kernel_channel_buffer *chan = event_recorder->chan;
+
+		if (unlikely(!LTTNG_READ_ONCE(chan->parent.session->active)))
+			return 0;
+		if (unlikely(!LTTNG_READ_ONCE(chan->parent.enabled)))
+			return 0;
+		break;
+	}
+	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+		break;
+	default:
+		WARN_ON_ONCE(1);
+	}
+
 	if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
 		return 0;
 
-	lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
-		sizeof(payload), lttng_alignof(payload), -1);
-
-	ret = chan->ops->event_reserve(&ctx, event->id);
-	if (ret < 0)
-		return 0;
+	switch (event->type) {
+	case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+	{
+		struct lttng_kernel_event_recorder *event_recorder =
+			container_of(event, struct lttng_kernel_event_recorder, parent);
+		struct lttng_kernel_channel_buffer *chan = event_recorder->chan;
+		struct lttng_kernel_ring_buffer_ctx ctx;
+		int ret;
 
-	/* Event payload. */
-	payload.ip = (unsigned long)instruction_pointer(regs);
+		lib_ring_buffer_ctx_init(&ctx, event_recorder,
+			sizeof(payload), lttng_alignof(payload), &lttng_probe_ctx);
 
-	lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
-	chan->ops->event_write(&ctx, &payload, sizeof(payload));
-	chan->ops->event_commit(&ctx);
-	return 0;
-}
+		ret = chan->ops->event_reserve(&ctx);
+		if (ret < 0)
+			return 0;
 
-static
-int lttng_uprobes_event_notifier_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
-{
-	struct lttng_uprobe_handler *uprobe_handler =
-		container_of(uc, struct lttng_uprobe_handler, up_consumer);
-	struct lttng_event_notifier *event_notifier = uprobe_handler->u.event_notifier;
-	struct lttng_kernel_notifier_ctx notif_ctx;
+		/* Event payload. */
+		payload.ip = (unsigned long)instruction_pointer(regs);
 
-	if (unlikely(!READ_ONCE(event_notifier->enabled)))
-		return 0;
-
-	notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
-	event_notifier->send_notification(event_notifier, NULL, NULL, &notif_ctx);
+		chan->ops->event_write(&ctx, &payload, sizeof(payload), lttng_alignof(payload));
+		chan->ops->event_commit(&ctx);
+		break;
+	}
+	case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+	{
+		struct lttng_kernel_event_notifier *event_notifier =
+			container_of(event, struct lttng_kernel_event_notifier, parent);
+		struct lttng_kernel_notification_ctx notif_ctx;
+
+		notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
+		event_notifier->notification_send(event_notifier, NULL, NULL, &notif_ctx);
+		break;
+	}
+	default:
+		WARN_ON_ONCE(1);
+	}
 	return 0;
 }
 
-static const struct lttng_kernel_type_common *event_type =
-	lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
+static const struct lttng_kernel_event_field *event_fields[] = {
+	lttng_kernel_static_event_field("ip",
+		lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16),
+		false, false, false),
+};
+
+static const struct lttng_kernel_tracepoint_class tp_class = {
+	.nr_fields = ARRAY_SIZE(event_fields),
+	.fields = event_fields,
+};
 
 /*
  * Create event description.
  */
 static
-int lttng_create_uprobe_event(const char *name, struct lttng_event *event)
+int lttng_create_uprobe_event(const char *name, struct lttng_kernel_event_recorder *event_recorder)
 {
-	const struct lttng_kernel_event_field **fieldp_array;
-	struct lttng_kernel_event_field *field;
 	struct lttng_kernel_event_desc *desc;
 	int ret;
 
 	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 	if (!desc)
 		return -ENOMEM;
+	desc->tp_class = &tp_class;
 	desc->event_name = kstrdup(name, GFP_KERNEL);
 	if (!desc->event_name) {
 		ret = -ENOMEM;
 		goto error_str;
 	}
-	desc->nr_fields = 1;
-	fieldp_array = kzalloc(1 * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
-	if (!fieldp_array) {
-		ret = -ENOMEM;
-		goto error_fieldp_array;
-	}
-	desc->fields = fieldp_array;
-	desc->fields[0] = field =
-		kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
-	if (!field) {
-		ret = -ENOMEM;
-		goto error_field;
-	}
-	field->name = "ip";
-	field->type = event_type;
 	desc->owner = THIS_MODULE;
-	event->desc = desc;
+	event_recorder->priv->parent.desc = desc;
 
 	return 0;
 
-error_field:
-	kfree(fieldp_array);
-error_fieldp_array:
-	kfree(desc->event_name);
 error_str:
 	kfree(desc);
 	return ret;
@@ -134,7 +141,7 @@ error_str:
  * Create event_notifier description.
  */
 static
-int lttng_create_uprobe_event_notifier(const char *name, struct lttng_event_notifier *event_notifier)
+int lttng_create_uprobe_event_notifier(const char *name, struct lttng_kernel_event_notifier *event_notifier)
 {
 	struct lttng_kernel_event_desc *desc;
 	int ret;
@@ -142,16 +149,14 @@ int lttng_create_uprobe_event_notifier(const char *name, struct lttng_event_noti
 	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 	if (!desc)
 		return -ENOMEM;
+	desc->tp_class = &tp_class;
 	desc->event_name = kstrdup(name, GFP_KERNEL);
 	if (!desc->event_name) {
 		ret = -ENOMEM;
 		goto error_str;
 	}
-
-	desc->nr_fields = 0;
-
 	desc->owner = THIS_MODULE;
-	event_notifier->desc = desc;
+	event_notifier->priv->parent.desc = desc;
 
 	return 0;
 
@@ -194,7 +199,7 @@ error:
 
 static
 int lttng_uprobes_add_callsite(struct lttng_uprobe *uprobe,
-	struct lttng_kernel_event_callsite __user *callsite,
+	struct lttng_kernel_abi_event_callsite __user *callsite,
 	int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs),
 	void *priv_data)
 {
@@ -216,7 +221,7 @@ int lttng_uprobes_add_callsite(struct lttng_uprobe *uprobe,
 	/* Ensure the memory we just allocated don't notify page faults. */
 	wrapper_vmalloc_sync_mappings();
 
-	uprobe_handler->u.event = priv_data;
+	uprobe_handler->event = priv_data;
 	uprobe_handler->up_consumer.handler = handler;
 
 	ret = copy_from_user(&uprobe_handler->offset, &callsite->u.uprobe.offset, sizeof(uint64_t));
@@ -244,22 +249,14 @@ end:
 	return ret;
 }
 
-int lttng_uprobes_event_add_callsite(struct lttng_event *event,
-	struct lttng_kernel_event_callsite __user *callsite)
+int lttng_uprobes_event_add_callsite(struct lttng_kernel_event_common *event,
+	struct lttng_kernel_abi_event_callsite __user *callsite)
 {
-	return lttng_uprobes_add_callsite(&event->u.uprobe, callsite,
+	return lttng_uprobes_add_callsite(&event->priv->u.uprobe, callsite,
 		lttng_uprobes_event_handler_pre, event);
 }
 EXPORT_SYMBOL_GPL(lttng_uprobes_event_add_callsite);
 
-int lttng_uprobes_event_notifier_add_callsite(struct lttng_event_notifier *event_notifier,
-	struct lttng_kernel_event_callsite __user *callsite)
-{
-	return lttng_uprobes_add_callsite(&event_notifier->u.uprobe, callsite,
-		lttng_uprobes_event_notifier_handler_pre, event_notifier);
-}
-EXPORT_SYMBOL_GPL(lttng_uprobes_event_notifier_add_callsite);
-
 static
 int lttng_uprobes_register(struct lttng_uprobe *uprobe, int fd)
 {
@@ -279,30 +276,30 @@ inode_error:
 	return ret;
 }
 
-int lttng_uprobes_register_event(const char *name, int fd, struct lttng_event *event)
+int lttng_uprobes_register_event(const char *name, int fd, struct lttng_kernel_event_recorder *event_recorder)
 {
 	int ret = 0;
 
-	ret = lttng_create_uprobe_event(name, event);
+	ret = lttng_create_uprobe_event(name, event_recorder);
 	if (ret)
 		goto error;
 
-	ret = lttng_uprobes_register(&event->u.uprobe, fd);
+	ret = lttng_uprobes_register(&event_recorder->priv->parent.u.uprobe, fd);
 	if (ret)
 		goto register_error;
 
 	return 0;
 
 register_error:
-	kfree(event->desc->event_name);
-	kfree(event->desc);
+	kfree(event_recorder->priv->parent.desc->event_name);
+	kfree(event_recorder->priv->parent.desc);
 error:
 	return ret;
 }
 EXPORT_SYMBOL_GPL(lttng_uprobes_register_event);
 
 int lttng_uprobes_register_event_notifier(const char *name, int fd,
-		struct lttng_event_notifier *event_notifier)
+		struct lttng_kernel_event_notifier *event_notifier)
 {
 	int ret = 0;
 
@@ -310,15 +307,15 @@ int lttng_uprobes_register_event_notifier(const char *name, int fd,
 	if (ret)
 		goto error;
 
-	ret = lttng_uprobes_register(&event_notifier->u.uprobe, fd);
+	ret = lttng_uprobes_register(&event_notifier->priv->parent.u.uprobe, fd);
 	if (ret)
 		goto register_error;
 
 	return 0;
 
 register_error:
-	kfree(event_notifier->desc->event_name);
-	kfree(event_notifier->desc);
+	kfree(event_notifier->priv->parent.desc->event_name);
+	kfree(event_notifier->priv->parent.desc);
 error:
 	return ret;
 }
@@ -338,36 +335,33 @@ void lttng_uprobes_unregister(struct inode *inode, struct list_head *head)
 		list_del(&iter->node);
 		kfree(iter);
 	}
-
 }
 
-void lttng_uprobes_unregister_event(struct lttng_event *event)
+void lttng_uprobes_unregister_event(struct lttng_kernel_event_recorder *event_recorder)
 {
-	lttng_uprobes_unregister(event->u.uprobe.inode, &event->u.uprobe.head);
+	lttng_uprobes_unregister(event_recorder->priv->parent.u.uprobe.inode, &event_recorder->priv->parent.u.uprobe.head);
 }
 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event);
 
-void lttng_uprobes_unregister_event_notifier(struct lttng_event_notifier *event_notifier)
+void lttng_uprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier)
 {
-	lttng_uprobes_unregister(event_notifier->u.uprobe.inode, &event_notifier->u.uprobe.head);
+	lttng_uprobes_unregister(event_notifier->priv->parent.u.uprobe.inode, &event_notifier->priv->parent.u.uprobe.head);
 }
 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event_notifier);
 
-void lttng_uprobes_destroy_event_private(struct lttng_event *event)
+void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_recorder *event_recorder)
 {
-	iput(event->u.uprobe.inode);
-	kfree(event->desc->fields[0]);
-	kfree(event->desc->fields);
-	kfree(event->desc->event_name);
-	kfree(event->desc);
+	iput(event_recorder->priv->parent.u.uprobe.inode);
+	kfree(event_recorder->priv->parent.desc->event_name);
+	kfree(event_recorder->priv->parent.desc);
 }
 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private);
 
-void lttng_uprobes_destroy_event_notifier_private(struct lttng_event_notifier *event_notifier)
+void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier)
 {
-	iput(event_notifier->u.uprobe.inode);
-	kfree(event_notifier->desc->event_name);
-	kfree(event_notifier->desc);
+	iput(event_notifier->priv->parent.u.uprobe.inode);
+	kfree(event_notifier->priv->parent.desc->event_name);
+	kfree(event_notifier->priv->parent.desc);
 }
 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private);