#include <blacklist/kprobes.h>
enum lttng_kretprobe_type {
- EVENT_ENTRY = 0,
- EVENT_RETURN = 1,
+ EVENT_ENTRY = 0,
+ EVENT_EXIT = 1,
};
struct lttng_krp {
struct kretprobe krp;
- struct lttng_event *event[2]; /* ENTRY and RETURN */
+ struct lttng_event *event[2]; /* ENTRY and EXIT */
struct kref kref_register;
struct kref kref_alloc;
};
}
static
-int lttng_kretprobes_handler_return(struct kretprobe_instance *krpi,
- struct pt_regs *regs)
+int lttng_kretprobes_handler_exit(struct kretprobe_instance *krpi,
+ struct pt_regs *regs)
{
- return _lttng_kretprobes_handler(krpi, regs, EVENT_RETURN);
+ return _lttng_kretprobes_handler(krpi, regs, EVENT_EXIT);
}
+static const struct lttng_kernel_type_common *event_type =
+ lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
+
/*
* Create event description
*/
int lttng_create_kprobe_event(const char *name, struct lttng_event *event,
enum lttng_kretprobe_type type)
{
- struct lttng_event_field *fields;
- struct lttng_event_desc *desc;
- int ret;
+ const struct lttng_kernel_event_field **fieldp_array;
+ struct lttng_kernel_event_field *field;
+ struct lttng_kernel_event_desc *desc;
char *alloc_name;
size_t name_len;
const char *suffix = NULL;
+ int ret;
- desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
+ desc = kzalloc(sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
name_len = strlen(name);
case EVENT_ENTRY:
suffix = "_entry";
break;
- case EVENT_RETURN:
- suffix = "_return";
+ case EVENT_EXIT:
+ suffix = "_exit";
break;
}
name_len += strlen(suffix);
}
strcpy(alloc_name, name);
strcat(alloc_name, suffix);
- desc->name = alloc_name;
+ desc->event_name = alloc_name;
desc->nr_fields = 2;
- desc->fields = fields =
- kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
- if (!desc->fields) {
+ fieldp_array = kzalloc(desc->nr_fields * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
+ if (!fieldp_array) {
+ ret = -ENOMEM;
+ goto error_fieldp_array;
+ }
+ desc->fields = fieldp_array;
+
+ field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
+ if (!field) {
+ ret = -ENOMEM;
+ goto error_field0;
+ }
+ field->name = "ip";
+ field->type = event_type;
+ desc->fields[0] = field;
+
+ field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
+ if (!field) {
ret = -ENOMEM;
- goto error_fields;
+ goto error_field1;
}
- fields[0].name = "ip";
- fields[0].type.atype = atype_integer;
- fields[0].type.u.integer.size = sizeof(unsigned long) * CHAR_BIT;
- fields[0].type.u.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
- fields[0].type.u.integer.signedness = lttng_is_signed_type(unsigned long);
- fields[0].type.u.integer.reverse_byte_order = 0;
- fields[0].type.u.integer.base = 16;
- fields[0].type.u.integer.encoding = lttng_encode_none;
-
- fields[1].name = "parent_ip";
- fields[1].type.atype = atype_integer;
- fields[1].type.u.integer.size = sizeof(unsigned long) * CHAR_BIT;
- fields[1].type.u.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
- fields[1].type.u.integer.signedness = lttng_is_signed_type(unsigned long);
- fields[1].type.u.integer.reverse_byte_order = 0;
- fields[1].type.u.integer.base = 16;
- fields[1].type.u.integer.encoding = lttng_encode_none;
+ field->name = "parent_ip";
+ field->type = event_type;
+ desc->fields[1] = field;
desc->owner = THIS_MODULE;
event->desc = desc;
return 0;
-error_fields:
- kfree(desc->name);
+error_field1:
+ kfree(desc->fields[0]);
+error_field0:
+ kfree(fieldp_array);
+error_fieldp_array:
+ kfree(desc->event_name);
error_str:
kfree(desc);
return ret;
uint64_t offset,
uint64_t addr,
struct lttng_event *event_entry,
- struct lttng_event *event_return)
+ struct lttng_event *event_exit)
{
int ret;
struct lttng_krp *lttng_krp;
ret = lttng_create_kprobe_event(name, event_entry, EVENT_ENTRY);
if (ret)
goto error;
- ret = lttng_create_kprobe_event(name, event_return, EVENT_RETURN);
+ ret = lttng_create_kprobe_event(name, event_exit, EVENT_EXIT);
if (ret)
- goto event_return_error;
+ goto event_exit_error;
lttng_krp = kzalloc(sizeof(*lttng_krp), GFP_KERNEL);
if (!lttng_krp)
goto krp_error;
lttng_krp->krp.entry_handler = lttng_kretprobes_handler_entry;
- lttng_krp->krp.handler = lttng_kretprobes_handler_return;
+ lttng_krp->krp.handler = lttng_kretprobes_handler_exit;
if (symbol_name) {
char *alloc_symbol;
alloc_symbol;
event_entry->u.kretprobe.symbol_name =
alloc_symbol;
- event_return->u.kretprobe.symbol_name =
+ event_exit->u.kretprobe.symbol_name =
alloc_symbol;
}
lttng_krp->krp.kp.offset = offset;
/* Allow probe handler to find event structures */
lttng_krp->event[EVENT_ENTRY] = event_entry;
- lttng_krp->event[EVENT_RETURN] = event_return;
+ lttng_krp->event[EVENT_EXIT] = event_exit;
event_entry->u.kretprobe.lttng_krp = lttng_krp;
- event_return->u.kretprobe.lttng_krp = lttng_krp;
+ event_exit->u.kretprobe.lttng_krp = lttng_krp;
/*
* Both events must be unregistered before the kretprobe is
name_error:
kfree(lttng_krp);
krp_error:
- kfree(event_return->desc->fields);
- kfree(event_return->desc->name);
- kfree(event_return->desc);
-event_return_error:
+ kfree(event_exit->desc->fields[0]);
+ kfree(event_exit->desc->fields[1]);
+ kfree(event_exit->desc->fields);
+ kfree(event_exit->desc->event_name);
+ kfree(event_exit->desc);
+event_exit_error:
+ kfree(event_entry->desc->fields[0]);
+ kfree(event_entry->desc->fields[1]);
kfree(event_entry->desc->fields);
- kfree(event_entry->desc->name);
+ kfree(event_entry->desc->event_name);
kfree(event_entry->desc);
error:
return ret;
void lttng_kretprobes_destroy_private(struct lttng_event *event)
{
+ kfree(event->desc->fields[0]);
+ kfree(event->desc->fields[1]);
kfree(event->desc->fields);
- kfree(event->desc->name);
+ kfree(event->desc->event_name);
kfree(event->desc);
kref_put(&event->u.kretprobe.lttng_krp->kref_alloc,
_lttng_kretprobes_release);
int lttng_kretprobes_event_enable_state(struct lttng_event *event,
int enable)
{
- struct lttng_event *event_return;
+ struct lttng_event *event_exit;
struct lttng_krp *lttng_krp;
if (event->instrumentation != LTTNG_KERNEL_KRETPROBE) {
return -EBUSY;
}
lttng_krp = event->u.kretprobe.lttng_krp;
- event_return = lttng_krp->event[EVENT_RETURN];
+ event_exit = lttng_krp->event[EVENT_EXIT];
WRITE_ONCE(event->enabled, enable);
- WRITE_ONCE(event_return->enabled, enable);
+ WRITE_ONCE(event_exit->enabled, enable);
return 0;
}
EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state);
projects / lttng-modules.git / blobdiff