#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"
{
int ret;
- assert(chan);
- assert(ctx);
+ LTTNG_ASSERT(chan);
+ LTTNG_ASSERT(ctx);
DBG("Adding context to channel %s", chan->channel->name);
ret = kernctl_add_context(chan->fd, &ctx->ctx);
int ret;
struct ltt_kernel_session *lks;
- assert(session);
+ LTTNG_ASSERT(session);
/* Allocate data structure */
lks = trace_kernel_create_session();
int ret;
struct ltt_kernel_channel *lkc;
- assert(session);
- assert(chan);
+ LTTNG_ASSERT(session);
+ LTTNG_ASSERT(chan);
/* Allocate kernel channel */
lkc = trace_kernel_create_channel(chan);
int ret;
int local_fd = -1;
- assert(event_notifier_group_fd);
+ LTTNG_ASSERT(event_notifier_group_fd);
/* Kernel event notifier group creation. */
ret = kernctl_create_event_notifier_group(kernel_tracer_fd);
const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
- assert(lttng_userspace_probe_location_get_type(probe_location) ==
+ LTTNG_ASSERT(lttng_userspace_probe_location_get_type(probe_location) ==
LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
lookup = lttng_userspace_probe_location_get_lookup_method(
lookup_method_type =
lttng_userspace_probe_location_lookup_method_get_type(lookup);
- assert(lookup_method_type ==
+ LTTNG_ASSERT(lookup_method_type ==
LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
symbol = lttng_userspace_probe_location_function_get_function_name(
int ret = 0;
int fd, i;
- assert(lttng_userspace_probe_location_get_type(probe_location) ==
+ LTTNG_ASSERT(lttng_userspace_probe_location_get_type(probe_location) ==
LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
lookup = lttng_userspace_probe_location_get_lookup_method(probe_location);
lookup_method_type =
lttng_userspace_probe_location_lookup_method_get_type(lookup);
- assert(lookup_method_type ==
+ LTTNG_ASSERT(lookup_method_type ==
LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
int ret;
const struct lttng_userspace_probe_location *location = NULL;
- assert(ev);
- assert(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
+ LTTNG_ASSERT(ev);
+ LTTNG_ASSERT(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
location = lttng_event_get_userspace_probe_location(ev);
if (!location) {
enum lttng_event_rule_type event_rule_type;
const struct lttng_userspace_probe_location *location = NULL;
- assert(rule);
- assert(creds);
+ LTTNG_ASSERT(rule);
+ LTTNG_ASSERT(creds);
event_rule_type = lttng_event_rule_get_type(rule);
- assert(event_rule_type == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE);
+ LTTNG_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;
enum lttng_error_code ret;
struct ltt_kernel_event *event;
- assert(ev);
- assert(channel);
+ LTTNG_ASSERT(ev);
+ LTTNG_ASSERT(channel);
/* We pass ownership of filter_expression and filter */
ret = trace_kernel_create_event(ev, filter_expression,
{
int ret;
- assert(chan);
+ LTTNG_ASSERT(chan);
ret = kernctl_disable(chan->fd);
if (ret < 0) {
{
int ret;
- assert(chan);
+ LTTNG_ASSERT(chan);
ret = kernctl_enable(chan->fd);
if (ret < 0 && ret != -EEXIST) {
{
int ret;
- assert(event);
+ LTTNG_ASSERT(event);
ret = kernctl_enable(event->fd);
if (ret < 0) {
{
int ret;
- assert(event);
+ LTTNG_ASSERT(event);
ret = kernctl_disable(event->fd);
if (ret < 0) {
{
int ret;
- assert(event);
+ LTTNG_ASSERT(event);
rcu_read_lock();
cds_lfht_del(kernel_token_to_event_notifier_rule_ht, &event->ht_node);
int ret;
struct ltt_kernel_metadata *lkm = NULL;
- assert(session);
+ LTTNG_ASSERT(session);
/* Allocate kernel metadata */
lkm = trace_kernel_create_metadata();
{
int ret;
- assert(session);
+ LTTNG_ASSERT(session);
ret = kernctl_start_session(session->fd);
if (ret < 0) {
int ret;
struct ltt_kernel_stream *stream;
- assert(channel);
+ LTTNG_ASSERT(channel);
DBG("Flush buffer for channel %s", channel->channel->name);
{
int ret;
- assert(session);
+ LTTNG_ASSERT(session);
ret = kernctl_stop_session(session->fd);
if (ret < 0) {
int ret;
struct ltt_kernel_stream *lks;
- assert(channel);
+ LTTNG_ASSERT(channel);
while ((ret = kernctl_create_stream(channel->fd)) >= 0) {
lks = trace_kernel_create_stream(channel->channel->name,
{
int ret;
- assert(session);
+ LTTNG_ASSERT(session);
ret = kernctl_create_stream(session->metadata->fd);
if (ret < 0) {
FILE *fp;
struct lttng_event *elist;
- assert(events);
+ LTTNG_ASSERT(events);
fd = kernctl_tracepoint_list(kernel_tracer_fd);
if (fd < 0) {
{
struct ltt_kernel_session *ksess = NULL;
- assert(kchan);
- assert(kchan->channel);
+ LTTNG_ASSERT(kchan);
+ LTTNG_ASSERT(kchan->channel);
DBG3("Kernel destroy channel %s", kchan->channel->name);
char *trace_path = NULL;
size_t consumer_path_offset = 0;
- assert(ksess);
- assert(ksess->consumer);
- assert(output);
+ LTTNG_ASSERT(ksess);
+ LTTNG_ASSERT(ksess->consumer);
+ LTTNG_ASSERT(output);
DBG("Kernel snapshot record started");
}
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_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits)
{
- assert(syscall_mask);
- assert(nr_bits);
+ LTTNG_ASSERT(syscall_mask);
+ LTTNG_ASSERT(nr_bits);
return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits);
}
struct lttng_ht_iter iter;
struct ltt_kernel_session *ksess = session->kernel_session;
- assert(ksess);
- assert(ksess->consumer);
+ LTTNG_ASSERT(ksess);
+ LTTNG_ASSERT(ksess->consumer);
DBG("Rotate kernel session %s started (session %" PRIu64 ")",
session->name, session->id);
enum lttng_trace_chunk_status chunk_status;
rcu_read_lock();
- assert(ksess->current_trace_chunk);
+ LTTNG_ASSERT(ksess->current_trace_chunk);
/*
* Create the index subdirectory which will take care
if (kernel_token_to_event_notifier_rule_ht) {
const int ret = cds_lfht_destroy(
kernel_token_to_event_notifier_rule_ht, NULL);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
}
DBG2("Closing kernel event notifier group file descriptor");
struct lttng_ht_iter iter;
struct ltt_kernel_session *ksess = session->kernel_session;
- assert(ksess);
- assert(ksess->consumer);
+ LTTNG_ASSERT(ksess);
+ LTTNG_ASSERT(ksess->consumer);
DBG("Clear kernel session %s (session %" PRIu64 ")",
session->name, session->id);
int local_fd = -1, ret;
enum lttng_error_code error_code_ret;
- assert(event_notifier_group_notification_fd);
+ LTTNG_ASSERT(event_notifier_group_notification_fd);
ret = kernctl_create_event_notifier_group_notification_fd(
kernel_tracer_event_notifier_group_fd);
const struct lttng_event_rule *event_rule = NULL;
enum lttng_condition_status cond_status;
- assert(trigger);
+ LTTNG_ASSERT(trigger);
condition = lttng_trigger_get_const_condition(trigger);
- assert(condition);
+ LTTNG_ASSERT(condition);
condition_type = lttng_condition_get_type(condition);
- assert(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
+ LTTNG_ASSERT(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
/* Does not acquire a reference. */
condition_status = lttng_condition_event_rule_matches_get_rule(
condition, &event_rule);
- assert(condition_status == LTTNG_CONDITION_STATUS_OK);
- assert(event_rule);
+ LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(event_rule);
event_rule_type = lttng_event_rule_get_type(event_rule);
- assert(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN);
+ LTTNG_ASSERT(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN);
error_code_ret = trace_kernel_create_event_notifier_rule(trigger, token,
lttng_condition_event_rule_matches_get_error_counter_index(
}
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_event_rule_matches_get_capture_descriptor_count(
condition, &capture_bytecode_count);
- assert(cond_status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(cond_status == LTTNG_CONDITION_STATUS_OK);
for (i = 0; i < capture_bytecode_count; i++) {
const struct lttng_bytecode *capture_bytecode =
lttng_trigger_get_const_condition(trigger);
const uint64_t token = lttng_trigger_get_tracer_token(trigger);
- assert(condition);
+ LTTNG_ASSERT(condition);
/* Does not acquire a reference to the event rule. */
status = lttng_condition_event_rule_matches_get_rule(
condition, &event_rule);
- assert(status == LTTNG_CONDITION_STATUS_OK);
+ LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK);
domain_type = lttng_event_rule_get_domain_type(event_rule);
- assert(domain_type == LTTNG_DOMAIN_KERNEL);
+ LTTNG_ASSERT(domain_type == LTTNG_DOMAIN_KERNEL);
ret = kernel_create_event_notifier_rule(trigger, cmd_creds, token);
if (ret != LTTNG_OK) {