event.filter = (unsigned char) !!kevent->filter_expression;
switch (kevent->event->instrumentation) {
- case LTTNG_KERNEL_TRACEPOINT:
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
event.type = LTTNG_EVENT_TRACEPOINT;
break;
- case LTTNG_KERNEL_KRETPROBE:
+ case LTTNG_KERNEL_ABI_KRETPROBE:
event.type = LTTNG_EVENT_FUNCTION;
memcpy(&event.attr.probe, &kevent->event->u.kprobe,
- sizeof(struct lttng_kernel_kprobe));
+ sizeof(struct lttng_kernel_abi_kprobe));
break;
- case LTTNG_KERNEL_KPROBE:
+ case LTTNG_KERNEL_ABI_KPROBE:
event.type = LTTNG_EVENT_PROBE;
memcpy(&event.attr.probe, &kevent->event->u.kprobe,
- sizeof(struct lttng_kernel_kprobe));
+ sizeof(struct lttng_kernel_abi_kprobe));
break;
- case LTTNG_KERNEL_UPROBE:
+ case LTTNG_KERNEL_ABI_UPROBE:
event.type = LTTNG_EVENT_USERSPACE_PROBE;
break;
- case LTTNG_KERNEL_FUNCTION:
+ case LTTNG_KERNEL_ABI_FUNCTION:
event.type = LTTNG_EVENT_FUNCTION;
memcpy(&event.attr.ftrace, &kevent->event->u.ftrace,
- sizeof(struct lttng_kernel_function));
+ sizeof(struct lttng_kernel_abi_function));
break;
- case LTTNG_KERNEL_NOOP:
+ case LTTNG_KERNEL_ABI_NOOP:
event.type = LTTNG_EVENT_NOOP;
break;
- case LTTNG_KERNEL_SYSCALL:
+ case LTTNG_KERNEL_ABI_SYSCALL:
event.type = LTTNG_EVENT_SYSCALL;
break;
- case LTTNG_KERNEL_ALL:
+ case LTTNG_KERNEL_ABI_ALL:
/* fall-through. */
default:
assert(0);
payload_size_before_location = payload.size;
comm_ret = lttng_trace_archive_location_serialize(location,
&payload);
+ lttng_trace_archive_location_put(location);
if (comm_ret < 0) {
ERR("Failed to serialize the location of the trace archive produced during the destruction of session \"%s\"",
session->name);
assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
assert(condition);
- assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT);
+ assert(lttng_condition_get_type(condition) ==
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name :
- "(unnamed)";
+ trigger_name : "(anonymous)";
session_lock_list();
switch (trigger_domain) {
enum lttng_error_code cmd_register_trigger(const struct lttng_credentials *cmd_creds,
struct lttng_trigger *trigger,
+ bool is_trigger_anonymous,
struct notification_thread_handle *notification_thread,
struct lttng_trigger **return_trigger)
{
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(unnamed)";
+ trigger_name : "(anonymous)";
trigger_status = lttng_trigger_get_owner_uid(
trigger, &trigger_owner);
* it is safe to use without any locking as its properties are
* immutable.
*/
- ret_code = notification_thread_command_register_trigger(notification_thread,
- trigger);
+ ret_code = notification_thread_command_register_trigger(
+ notification_thread, trigger, is_trigger_anonymous);
if (ret_code != LTTNG_OK) {
DBG("Failed to register trigger to notification thread: trigger name = '%s', trigger owner uid = %d, error code = %d",
trigger_name, (int) trigger_owner, ret_code);
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(unnamed)";
+ trigger_name : "(anonymous)";
/*
* Synchronize tracers if the trigger adds an event notifier.
trigger);
assert(condition);
- assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT);
+ assert(lttng_condition_get_type(condition) ==
+ LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
session_lock_list();
switch (trigger_domain) {
struct lttng_trigger *sessiond_trigger = NULL;
trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
- trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(unnamed)";
+ trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ? trigger_name : "(anonymous)";
trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_owner);
assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
return ret_code;
}
-int cmd_list_triggers(struct command_ctx *cmd_ctx,
+enum lttng_error_code cmd_list_triggers(struct command_ctx *cmd_ctx,
struct notification_thread_handle *notification_thread,
struct lttng_triggers **return_triggers)
{
- int ret = 0;
+ int ret;
enum lttng_error_code ret_code;
struct lttng_triggers *triggers = NULL;
ret_code = notification_thread_command_list_triggers(
notification_thread, cmd_ctx->creds.uid, &triggers);
if (ret_code != LTTNG_OK) {
- ret = ret_code;
+ goto end;
+ }
+
+ ret = lttng_triggers_remove_hidden_triggers(triggers);
+ if (ret) {
+ ret_code = LTTNG_ERR_UNK;
goto end;
}
*return_triggers = triggers;
triggers = NULL;
- ret = LTTNG_OK;
+ ret_code = LTTNG_OK;
end:
lttng_triggers_destroy(triggers);
- return ret;
+ return ret_code;
}
enum lttng_error_code cmd_execute_error_query(const struct lttng_credentials *cmd_creds,
{
enum lttng_error_code ret_code;
const struct lttng_trigger *query_target_trigger;
- struct lttng_action *query_target_action = NULL;
+ const struct lttng_action *query_target_action = NULL;
struct lttng_trigger *matching_trigger = NULL;
const char *trigger_name;
uid_t trigger_owner;
case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
query_target_trigger = lttng_error_query_trigger_borrow_target(query);
break;
+ case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
+ query_target_trigger =
+ lttng_error_query_condition_borrow_target(query);
+ break;
case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
query_target_trigger = lttng_error_query_action_borrow_trigger_target(
query);
trigger_status = lttng_trigger_get_name(matching_trigger, &trigger_name);
trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
- trigger_name : "(unnamed)";
+ trigger_name : "(anonymous)";
trigger_status = lttng_trigger_get_owner_uid(matching_trigger,
&trigger_owner);
assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
}
break;
+ case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION:
+ {
+ trigger_status = lttng_trigger_condition_add_error_results(
+ matching_trigger, results);
+
+ switch (trigger_status) {
+ case LTTNG_TRIGGER_STATUS_OK:
+ break;
+ default:
+ ret_code = LTTNG_ERR_UNK;
+ goto end;
+ }
+
+ break;
+ }
case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
{
const enum lttng_action_status action_status =
consumer_copy_output(snapshot_output->consumer);
strcpy(snapshot_kernel_consumer_output->chunk_path,
snapshot_chunk_name);
+
+ /* Copy the original domain subdir. */
+ strcpy(snapshot_kernel_consumer_output->domain_subdir,
+ original_kernel_consumer_output->domain_subdir);
+
ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
original_kernel_consumer_output);
if (ret < 0) {
consumer_copy_output(snapshot_output->consumer);
strcpy(snapshot_ust_consumer_output->chunk_path,
snapshot_chunk_name);
+
+ /* Copy the original domain subdir. */
+ strcpy(snapshot_ust_consumer_output->domain_subdir,
+ original_ust_consumer_output->domain_subdir);
+
ret = consumer_copy_sockets(snapshot_ust_consumer_output,
original_ust_consumer_output);
if (ret < 0) {