#include <lttng/userspace-probe.h>
#include <lttng/userspace-probe-internal.h>
-#include <lttng/condition/on-event.h>
-#include <lttng/condition/on-event-internal.h>
+#include <lttng/condition/event-rule-matches.h>
+#include <lttng/condition/event-rule-matches-internal.h>
#include <lttng/event-rule/event-rule.h>
#include <lttng/event-rule/event-rule-internal.h>
-#include <lttng/event-rule/userspace-probe-internal.h>
+#include <lttng/event-rule/kernel-uprobe-internal.h>
#include "event-notifier-error-accounting.h"
#include "lttng-sessiond.h"
switch (type) {
case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
{
- struct lttng_kernel_event_callsite callsite;
+ struct lttng_kernel_abi_event_callsite callsite;
uint64_t offset;
ret = extract_userspace_probe_offset_function_elf(location,
int i;
uint64_t *offsets = NULL;
uint32_t offsets_count;
- struct lttng_kernel_event_callsite callsite;
+ struct lttng_kernel_abi_event_callsite callsite;
/*
* This call allocates the offsets buffer. This buffer must be freed
assert(creds);
event_rule_type = lttng_event_rule_get_type(rule);
- assert(event_rule_type == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE);
+ assert(event_rule_type == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE);
- status = lttng_event_rule_userspace_probe_get_location(rule, &location);
+ status = lttng_event_rule_kernel_uprobe_get_location(rule, &location);
if (status != LTTNG_EVENT_RULE_STATUS_OK || !location) {
ret = -1;
goto end;
ret = kernctl_disable(event->fd);
if (ret < 0) {
- switch (-ret) {
- case EEXIST:
- ret = LTTNG_ERR_KERN_EVENT_EXIST;
- break;
- default:
- PERROR("disable kernel event");
- break;
- }
+ PERROR("Failed to disable kernel event: name = '%s', fd = %d",
+ event->event->name, event->fd);
goto error;
}
ret = kernctl_disable(event->fd);
if (ret < 0) {
- switch (-ret) {
- case EEXIST:
- ret = LTTNG_ERR_KERN_EVENT_EXIST;
- break;
- default:
- PERROR("Failed to disable kernel event notifier: fd = %d, token = %" PRIu64,
- event->fd, event->token);
- break;
- }
+ PERROR("Failed to disable kernel event notifier: fd = %d, token = %" PRIu64,
+ event->fd, event->token);
goto error;
}
/*
* Get kernel version and validate it.
*/
-int kernel_validate_version(struct lttng_kernel_tracer_version *version,
- struct lttng_kernel_tracer_abi_version *abi_version)
+int kernel_validate_version(struct lttng_kernel_abi_tracer_version *version,
+ struct lttng_kernel_abi_tracer_abi_version *abi_version)
{
int ret;
ERR("Failed to retrieve lttng-modules ABI version");
goto error;
}
- if (abi_version->major != LTTNG_MODULES_ABI_MAJOR_VERSION) {
+ if (abi_version->major != LTTNG_KERNEL_ABI_MAJOR_VERSION) {
ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)",
abi_version->major, abi_version->minor,
- LTTNG_MODULES_ABI_MAJOR_VERSION);
+ LTTNG_KERNEL_ABI_MAJOR_VERSION);
goto error;
}
DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)",
}
trace_path = setup_channel_trace_path(ksess->consumer,
- DEFAULT_KERNEL_TRACE_DIR, &consumer_path_offset);
+ "", &consumer_path_offset);
if (!trace_path) {
status = LTTNG_ERR_INVALID;
goto error;
int kernel_tracer_abi_greater_or_equal(unsigned int major, unsigned int minor)
{
int ret;
- struct lttng_kernel_tracer_abi_version abi;
+ struct lttng_kernel_abi_tracer_abi_version abi;
ret = kernctl_tracer_abi_version(kernel_tracer_fd, &abi);
if (ret < 0) {
}
/* Validate kernel version */
- ret = kernel_validate_version(&kernel_tracer_version,
- &kernel_tracer_abi_version);
+ ret = kernel_validate_version(&the_kernel_tracer_version,
+ &the_kernel_tracer_abi_version);
if (ret < 0) {
goto error_version;
}
PERROR("Failed to close kernel tracer file descriptor: fd = %d",
kernel_tracer_fd);
}
+
kernel_tracer_fd = -1;
return LTTNG_ERR_KERN_VERSION;
kernel_tracer_event_notifier_group_notification_fd);
}
+ kernel_tracer_event_notifier_group_notification_fd = -1;
+
error_modules:
ret = close(kernel_tracer_event_notifier_group_fd);
if (ret) {
kernel_tracer_event_notifier_group_fd);
}
+ kernel_tracer_event_notifier_group_fd = -1;
+
ret = close(kernel_tracer_fd);
if (ret) {
PERROR("Failed to close kernel tracer file descriptor: fd = %d",
kernel_tracer_fd);
}
+ kernel_tracer_fd = -1;
+
error_open:
modprobe_remove_lttng_control();
DBG2("Closing kernel event notifier group notification file descriptor");
if (kernel_tracer_event_notifier_group_notification_fd >= 0) {
int ret = notification_thread_command_remove_tracer_event_source(
- notification_thread_handle,
+ the_notification_thread_handle,
kernel_tracer_event_notifier_group_notification_fd);
if (ret != LTTNG_OK) {
ERR("Failed to remove kernel event notifier notification from notification thread");
enum lttng_condition_type condition_type;
enum lttng_event_rule_type event_rule_type;
struct ltt_kernel_event_notifier_rule *event_notifier_rule;
- struct lttng_kernel_event_notifier kernel_event_notifier = {};
+ struct lttng_kernel_abi_event_notifier kernel_event_notifier = {};
unsigned int capture_bytecode_count = 0, i;
const struct lttng_condition *condition = NULL;
const struct lttng_event_rule *event_rule = NULL;
assert(condition);
condition_type = lttng_condition_get_type(condition);
- assert(condition_type == LTTNG_CONDITION_TYPE_ON_EVENT);
+ assert(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
/* Does not acquire a reference. */
- condition_status = lttng_condition_on_event_get_rule(
+ condition_status = lttng_condition_event_rule_matches_get_rule(
condition, &event_rule);
assert(condition_status == LTTNG_CONDITION_STATUS_OK);
assert(event_rule);
assert(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN);
error_code_ret = trace_kernel_create_event_notifier_rule(trigger, token,
- lttng_condition_on_event_get_error_counter_index(condition),
+ lttng_condition_event_rule_matches_get_error_counter_index(
+ condition),
&event_notifier_rule);
if (error_code_ret != LTTNG_OK) {
goto error;
kernel_event_notifier.event.token = event_notifier_rule->token;
kernel_event_notifier.error_counter_idx =
- lttng_condition_on_event_get_error_counter_index(condition);
+ lttng_condition_event_rule_matches_get_error_counter_index(
+ condition);
fd = kernctl_create_event_notifier(
kernel_tracer_event_notifier_group_fd,
}
if (lttng_event_rule_get_type(event_rule) ==
- LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE) {
+ LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE) {
ret = userspace_probe_event_rule_add_callsites(
event_rule, creds, event_notifier_rule->fd);
if (ret) {
}
/* Set the capture bytecode if any. */
- cond_status = lttng_condition_on_event_get_capture_descriptor_count(
+ cond_status = lttng_condition_event_rule_matches_get_capture_descriptor_count(
condition, &capture_bytecode_count);
assert(cond_status == LTTNG_CONDITION_STATUS_OK);
for (i = 0; i < capture_bytecode_count; i++) {
const struct lttng_bytecode *capture_bytecode =
- lttng_condition_on_event_get_capture_bytecode_at_index(
+ lttng_condition_event_rule_matches_get_capture_bytecode_at_index(
condition, i);
if (capture_bytecode == NULL) {
assert(condition);
/* Does not acquire a reference to the event rule. */
- status = lttng_condition_on_event_get_rule(
+ status = lttng_condition_event_rule_matches_get_rule(
condition, &event_rule);
assert(status == LTTNG_CONDITION_STATUS_OK);
projects / lttng-tools.git / blobdiff