static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
static uint64_t relayd_net_seq_idx;
-/*
- * Both functions below are special case for the Kernel domain when
- * enabling/disabling all events.
- */
-static
-int enable_kevent_all(struct ltt_session *session,
- struct lttng_domain *domain, char *channel_name,
- struct lttng_event *event,
- char *filter_expression,
- struct lttng_filter_bytecode *filter, int wpipe);
-static
-int disable_kevent_all(struct ltt_session *session, int domain,
- char *channel_name,
- struct lttng_event *event);
-
/*
* Create a session path used by list_lttng_sessions for the case that the
* session consumer is on the network.
/*
* Command LTTNG_TRACK_PID processed by the client thread.
+ *
+ * Called with session lock held.
*/
int cmd_track_pid(struct ltt_session *session, int domain, int pid)
{
break;
}
case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_session *usess;
+
+ usess = session->ust_session;
+
+ ret = trace_ust_track_pid(usess, pid);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ break;
+ }
default:
ret = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
/*
* Command LTTNG_UNTRACK_PID processed by the client thread.
+ *
+ * Called with session lock held.
*/
int cmd_untrack_pid(struct ltt_session *session, int domain, int pid)
{
break;
}
case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_session *usess;
+
+ usess = session->ust_session;
+
+ ret = trace_ust_untrack_pid(usess, pid);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ break;
+ }
default:
ret = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
return ret;
}
-
/*
* Command LTTNG_DISABLE_EVENT processed by the client thread.
*/
|| event->pid || event->filter || event->exclusion) {
return LTTNG_ERR_UNK;
}
- /* Special handling for kernel domain all events. */
- if (domain == LTTNG_DOMAIN_KERNEL && !strcmp(event_name, "*")) {
- return disable_kevent_all(session, domain, channel_name, event);
- }
rcu_read_lock();
switch (event->type) {
case LTTNG_EVENT_ALL:
- case LTTNG_EVENT_TRACEPOINT:
- ret = event_kernel_disable_tracepoint(kchan, event_name);
+ ret = event_kernel_disable_event_all(kchan);
if (ret != LTTNG_OK) {
goto error;
}
break;
+ case LTTNG_EVENT_TRACEPOINT: /* fall-through */
case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_disable_syscall(kchan, event_name);
+ if (!strcmp(event_name, "*")) {
+ ret = event_kernel_disable_event_type(kchan,
+ event->type);
+ } else {
+ ret = event_kernel_disable_event(kchan,
+ event_name);
+ }
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ break;
+ case LTTNG_EVENT_PROBE:
+ case LTTNG_EVENT_FUNCTION:
+ case LTTNG_EVENT_FUNCTION_ENTRY:
+ ret = event_kernel_disable_event(kchan, event_name);
if (ret != LTTNG_OK) {
goto error;
}
return ret;
}
-/*
- * Command LTTNG_DISABLE_EVENT for event "*" processed by the client thread.
- */
-static
-int disable_kevent_all(struct ltt_session *session, int domain,
- char *channel_name,
- struct lttng_event *event)
-{
- int ret;
-
- rcu_read_lock();
-
- switch (domain) {
- case LTTNG_DOMAIN_KERNEL:
- {
- struct ltt_kernel_session *ksess;
- struct ltt_kernel_channel *kchan;
-
- ksess = session->kernel_session;
-
- /*
- * If a non-default channel has been created in the
- * session, explicitely require that -c chan_name needs
- * to be provided.
- */
- if (ksess->has_non_default_channel && channel_name[0] == '\0') {
- ret = LTTNG_ERR_NEED_CHANNEL_NAME;
- goto error;
- }
-
- kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
- if (kchan == NULL) {
- ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
- goto error;
- }
-
- switch (event->type) {
- case LTTNG_EVENT_ALL:
- ret = event_kernel_disable_all(kchan);
- if (ret != LTTNG_OK) {
- goto error;
- }
- break;
- case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_disable_syscall(kchan, "");
- if (ret != LTTNG_OK) {
- goto error;
- }
- break;
- default:
- ret = LTTNG_ERR_UNK;
- goto error;
- }
-
- kernel_wait_quiescent(kernel_tracer_fd);
- break;
- }
- default:
- ret = LTTNG_ERR_UND;
- goto error;
- }
-
- ret = LTTNG_OK;
-
-error:
- rcu_read_unlock();
- return ret;
-}
-
/*
* Command LTTNG_ADD_CONTEXT processed by the client thread.
*/
DBG("Enable event command for event \'%s\'", event->name);
- /* Special handling for kernel domain all events. */
- if (domain->type == LTTNG_DOMAIN_KERNEL && !strcmp(event->name, "*")) {
- return enable_kevent_all(session, domain, channel_name, event,
- filter_expression, filter, wpipe);
- }
-
ret = validate_event_name(event->name);
if (ret) {
goto error;
switch (event->type) {
case LTTNG_EVENT_ALL:
+ {
+ char *filter_expression_a = NULL;
+ struct lttng_filter_bytecode *filter_a = NULL;
+
+ /*
+ * We need to duplicate filter_expression and filter,
+ * because ownership is passed to first enable
+ * event.
+ */
+ if (filter_expression) {
+ filter_expression_a = strdup(filter_expression);
+ if (!filter_expression_a) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+ }
+ if (filter) {
+ filter_a = zmalloc(sizeof(*filter_a) + filter->len);
+ if (!filter_a) {
+ free(filter_expression_a);
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+ memcpy(filter_a, filter, sizeof(*filter_a) + filter->len);
+ }
+ event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
+ ret = event_kernel_enable_event(kchan, event,
+ filter_expression, filter);
+ /* We have passed ownership */
+ filter_expression = NULL;
+ filter = NULL;
+ if (ret != LTTNG_OK) {
+ if (channel_created) {
+ /* Let's not leak a useless channel. */
+ kernel_destroy_channel(kchan);
+ }
+ free(filter_expression_a);
+ free(filter_a);
+ goto error;
+ }
+ event->type = LTTNG_EVENT_SYSCALL; /* Hack */
+ ret = event_kernel_enable_event(kchan, event,
+ filter_expression_a, filter_a);
+ if (ret != LTTNG_OK) {
+ free(filter_expression_a);
+ free(filter_a);
+ goto error;
+ }
+ break;
+ }
case LTTNG_EVENT_PROBE:
case LTTNG_EVENT_FUNCTION:
case LTTNG_EVENT_FUNCTION_ENTRY:
case LTTNG_EVENT_TRACEPOINT:
- ret = event_kernel_enable_tracepoint(kchan, event);
+ ret = event_kernel_enable_event(kchan, event,
+ filter_expression, filter);
+ /* We have passed ownership */
+ filter_expression = NULL;
+ filter = NULL;
if (ret != LTTNG_OK) {
if (channel_created) {
/* Let's not leak a useless channel. */
}
break;
case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_enable_syscall(kchan, event->name);
+ ret = event_kernel_enable_event(kchan, event,
+ filter_expression, filter);
+ /* We have passed ownership */
+ filter_expression = NULL;
+ filter = NULL;
if (ret != LTTNG_OK) {
goto error;
}
return ret;
}
-/*
- * Command LTTNG_ENABLE_EVENT for event "*" processed by the client thread.
- */
-static
-int enable_kevent_all(struct ltt_session *session,
- struct lttng_domain *domain, char *channel_name,
- struct lttng_event *event,
- char *filter_expression,
- struct lttng_filter_bytecode *filter, int wpipe)
-{
- int ret;
- struct lttng_channel *attr;
-
- assert(session);
- assert(channel_name);
-
- rcu_read_lock();
-
- switch (domain->type) {
- case LTTNG_DOMAIN_KERNEL:
- {
- struct ltt_kernel_channel *kchan;
-
- assert(session->kernel_session);
-
- /*
- * If a non-default channel has been created in the
- * session, explicitely require that -c chan_name needs
- * to be provided.
- */
- if (session->kernel_session->has_non_default_channel
- && channel_name[0] == '\0') {
- ret = LTTNG_ERR_NEED_CHANNEL_NAME;
- goto error;
- }
-
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
- if (kchan == NULL) {
- /* Create default channel */
- attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL,
- LTTNG_BUFFER_GLOBAL);
- if (attr == NULL) {
- ret = LTTNG_ERR_FATAL;
- goto error;
- }
- strncpy(attr->name, channel_name, sizeof(attr->name));
-
- ret = cmd_enable_channel(session, domain, attr, wpipe);
- if (ret != LTTNG_OK) {
- free(attr);
- goto error;
- }
- free(attr);
-
- /* Get the newly created kernel channel pointer */
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
- assert(kchan);
- }
-
- switch (event->type) {
- case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_enable_syscall(kchan, "");
- if (ret != LTTNG_OK) {
- goto error;
- }
- break;
- case LTTNG_EVENT_TRACEPOINT:
- /*
- * This call enables all LTTNG_KERNEL_TRACEPOINTS and
- * events already registered to the channel.
- */
- ret = event_kernel_enable_all_tracepoints(kchan, kernel_tracer_fd);
- break;
- case LTTNG_EVENT_ALL:
- /* Enable syscalls and tracepoints */
- ret = event_kernel_enable_all(kchan, kernel_tracer_fd);
- break;
- default:
- ret = LTTNG_ERR_KERN_ENABLE_FAIL;
- goto error;
- }
-
- /* Manage return value */
- if (ret != LTTNG_OK) {
- /*
- * On error, cmd_enable_channel call will take care of destroying
- * the created channel if it was needed.
- */
- goto error;
- }
-
- kernel_wait_quiescent(kernel_tracer_fd);
- break;
- }
- default:
- ret = LTTNG_ERR_UND;
- goto error;
- }
-
- ret = LTTNG_OK;
-
-error:
- rcu_read_unlock();
- return ret;
-}
-
-
/*
* Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
*/
return syscall_table_list(events);
}
+/*
+ * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread.
+ *
+ * Called with session lock held.
+ */
+ssize_t cmd_list_tracker_pids(struct ltt_session *session,
+ int domain, int32_t **pids)
+{
+ int ret;
+ ssize_t nr_pids = 0;
+
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ {
+ struct ltt_kernel_session *ksess;
+
+ ksess = session->kernel_session;
+ nr_pids = kernel_list_tracker_pids(ksess, pids);
+ if (nr_pids < 0) {
+ ret = LTTNG_ERR_KERN_LIST_FAIL;
+ goto error;
+ }
+ break;
+ }
+ case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_session *usess;
+
+ usess = session->ust_session;
+ nr_pids = trace_ust_list_tracker_pids(usess, pids);
+ if (nr_pids < 0) {
+ ret = LTTNG_ERR_UST_LIST_FAIL;
+ goto error;
+ }
+ break;
+ }
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_PYTHON:
+ default:
+ ret = LTTNG_ERR_UND;
+ goto error;
+ }
+
+ return nr_pids;
+
+error:
+ /* Return negative value to differentiate return code */
+ return -ret;
+}
+
/*
* Command LTTNG_START_TRACE processed by the client thread.
+ *
+ * Called with session mutex held.
*/
int cmd_start_trace(struct ltt_session *session)
{
/*
* Command LTTNG_DESTROY_SESSION processed by the client thread.
+ *
+ * Called with session lock held.
*/
int cmd_destroy_session(struct ltt_session *session, int wpipe)
{