+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ if (!session->kernel_session) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ ret_code = kernel_process_attr_tracker_inclusion_set_add_value(
+ session->kernel_session, process_attr, value);
+ break;
+ case LTTNG_DOMAIN_UST:
+ if (!session->ust_session) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ ret_code = trace_ust_process_attr_tracker_inclusion_set_add_value(
+ session->ust_session, process_attr, value);
+ break;
+ default:
+ ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+ break;
+ }
+end:
+ return ret_code;
+}
+
+enum lttng_error_code cmd_process_attr_tracker_inclusion_set_remove_value(
+ struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ const struct process_attr_value *value)
+{
+ enum lttng_error_code ret_code = LTTNG_OK;
+
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ if (!session->kernel_session) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ ret_code = kernel_process_attr_tracker_inclusion_set_remove_value(
+ session->kernel_session, process_attr, value);
+ break;
+ case LTTNG_DOMAIN_UST:
+ if (!session->ust_session) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ ret_code = trace_ust_process_attr_tracker_inclusion_set_remove_value(
+ session->ust_session, process_attr, value);
+ break;
+ default:
+ ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+ break;
+ }
+end:
+ return ret_code;
+}
+
+enum lttng_error_code cmd_process_attr_tracker_get_inclusion_set(
+ struct ltt_session *session,
+ enum lttng_domain_type domain,
+ enum lttng_process_attr process_attr,
+ struct lttng_process_attr_values **values)
+{
+ enum lttng_error_code ret_code = LTTNG_OK;
+ const struct process_attr_tracker *tracker;
+ enum process_attr_tracker_status status;
+
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ if (!session->kernel_session) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ tracker = kernel_get_process_attr_tracker(
+ session->kernel_session, process_attr);
+ break;
+ case LTTNG_DOMAIN_UST:
+ if (!session->ust_session) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+ tracker = trace_ust_get_process_attr_tracker(
+ session->ust_session, process_attr);
+ break;
+ default:
+ ret_code = LTTNG_ERR_UNSUPPORTED_DOMAIN;
+ goto end;
+ }
+
+ if (!tracker) {
+ ret_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ status = process_attr_tracker_get_inclusion_set(tracker, values);
+ switch (status) {
+ case PROCESS_ATTR_TRACKER_STATUS_OK:
+ ret_code = LTTNG_OK;
+ break;
+ case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
+ ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
+ break;
+ case PROCESS_ATTR_TRACKER_STATUS_ERROR:
+ ret_code = LTTNG_ERR_NOMEM;
+ break;
+ default:
+ ret_code = LTTNG_ERR_UNK;
+ break;
+ }
+
+end:
+ return ret_code;
+}
+
+/*
+ * Command LTTNG_DISABLE_EVENT processed by the client thread.
+ */
+int cmd_disable_event(struct command_ctx *cmd_ctx, int sock)
+{
+ int ret;
+ size_t event_len;
+ const char *event_name;
+ ssize_t sock_recv_len;
+ struct lttng_event *event = NULL;
+ struct lttng_buffer_view view;
+ struct lttng_dynamic_buffer event_buffer;
+ struct lttng_event_exclusion *exclusion = NULL;
+ struct lttng_filter_bytecode *bytecode = NULL;
+ char *filter_expression = NULL;
+ unsigned int exclusion_count;
+ const struct ltt_session *session = cmd_ctx->session;
+ const char *channel_name = cmd_ctx->lsm->u.disable.channel_name;
+ enum lttng_domain_type domain = cmd_ctx->lsm->domain.type;
+
+ lttng_dynamic_buffer_init(&event_buffer);
+ event_len = (size_t) cmd_ctx->lsm->u.disable.length;
+ ret = lttng_dynamic_buffer_set_size(&event_buffer, event_len);
+ if (ret) {
+ ret = LTTNG_ERR_NOMEM;
+ goto error;
+ }
+
+ sock_recv_len = lttcomm_recv_unix_sock(
+ sock, event_buffer.data, event_len);
+ if (sock_recv_len < 0 || sock_recv_len != event_len) {
+ ERR("Failed to receive \"disable event\" command payload");
+ ret = LTTNG_ERR_INVALID;
+ goto error;
+ }
+
+ view = lttng_buffer_view_from_dynamic_buffer(&event_buffer, 0, -1);
+
+ if (lttng_event_create_from_buffer(&view, &event,
+ &exclusion, &filter_expression,
+ &bytecode, sock) != event_len) {
+ ERR("Invalid event payload received in \"disable event\" command");
+ ret = LTTNG_ERR_INVALID;
+ goto error;
+ }
+
+ DBG("Disable event command for event \'%s\'", event->name);
+
+ /*
+ * Filter and exclusions are simply not handled by the
+ * disable event command at this time.
+ *
+ * FIXME
+ */
+ (void) filter_expression;
+ (void) exclusion;
+ (void) exclusion_count;
+
+ /* Ignore the presence of filter or exclusion for the event */
+ event->filter = 0;
+ event->exclusion = 0;
+
+ event_name = event->name;
+
+ /* Error out on unhandled search criteria */
+ if (event->loglevel_type || event->loglevel != -1 || event->enabled
+ || event->pid || event->filter || event->exclusion) {
+ ret = LTTNG_ERR_UNK;
+ goto error;
+ }
+
+ rcu_read_lock();
+
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ {
+ struct ltt_kernel_channel *kchan;
+ struct ltt_kernel_session *ksess;
+
+ 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_unlock;
+ }
+
+ kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
+ if (kchan == NULL) {
+ ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
+ goto error_unlock;
+ }
+
+ switch (event->type) {
+ case LTTNG_EVENT_ALL:
+ case LTTNG_EVENT_TRACEPOINT:
+ case LTTNG_EVENT_SYSCALL:
+ case LTTNG_EVENT_PROBE:
+ case LTTNG_EVENT_FUNCTION:
+ case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
+ if (event_name[0] == '\0') {
+ ret = event_kernel_disable_event(kchan,
+ NULL, event->type);
+ } else {
+ ret = event_kernel_disable_event(kchan,
+ event_name, event->type);
+ }
+ if (ret != LTTNG_OK) {
+ goto error_unlock;
+ }
+ break;
+ default:
+ ret = LTTNG_ERR_UNK;
+ goto error_unlock;
+ }
+
+ kernel_wait_quiescent();
+ break;
+ }
+ case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_channel *uchan;
+ struct ltt_ust_session *usess;
+
+ usess = session->ust_session;
+
+ if (validate_ust_event_name(event_name)) {
+ ret = LTTNG_ERR_INVALID_EVENT_NAME;
+ goto error_unlock;
+ }