X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Ftrace-ust.c;h=b6cf57cf2360bad1030fc1dfbf664ad41ea4018a;hb=c0e2990d32d1e55c783c7eb3299f23a7ce062270;hp=f64f51c280d670b9b83070abb6e2666d97ce51e2;hpb=55c9e7cac24318259d4f2549c97f7577b7b52db4;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/trace-ust.c b/src/bin/lttng-sessiond/trace-ust.c index f64f51c28..b6cf57cf2 100644 --- a/src/bin/lttng-sessiond/trace-ust.c +++ b/src/bin/lttng-sessiond/trace-ust.c @@ -1,19 +1,9 @@ /* - * Copyright (C) 2011 - David Goulet - * Copyright (C) 2016 - Jérémie Galarneau + * Copyright (C) 2011 David Goulet + * Copyright (C) 2016 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -26,6 +16,7 @@ #include #include #include +#include #include "buffer-registry.h" #include "trace-ust.h" @@ -92,7 +83,7 @@ int trace_ust_ht_match_event(struct cds_lfht_node *node, const void *_key) /* Event loglevel value and type. */ ll_match = loglevels_match(event->attr.loglevel_type, ev_loglevel_value, key->loglevel_type, - key->loglevel_value, LTTNG_UST_LOGLEVEL_ALL); + key->loglevel_value, LTTNG_UST_ABI_LOGLEVEL_ALL); if (!ll_match) { goto no_match; @@ -203,8 +194,8 @@ error: * MUST be acquired before calling this. */ struct ltt_ust_event *trace_ust_find_event(struct lttng_ht *ht, - char *name, struct lttng_filter_bytecode *filter, - enum lttng_ust_loglevel_type loglevel_type, int loglevel_value, + char *name, struct lttng_bytecode *filter, + enum lttng_ust_abi_loglevel_type loglevel_type, int loglevel_value, struct lttng_event_exclusion *exclusion) { struct lttng_ht_node_str *node; @@ -294,7 +285,7 @@ struct ltt_ust_session *trace_ust_create_session(uint64_t session_id) lus->metadata_attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM; lus->metadata_attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER; lus->metadata_attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER; - lus->metadata_attr.output = LTTNG_UST_MMAP; + lus->metadata_attr.output = LTTNG_UST_ABI_MMAP; /* * Default buffer type. This can be changed through an enable channel @@ -313,16 +304,16 @@ struct ltt_ust_session *trace_ust_create_session(uint64_t session_id) /* Alloc agent hash table. */ lus->agents = lttng_ht_new(0, LTTNG_HT_TYPE_U64); - lus->tracker_list_vpid = lttng_tracker_list_create(); - if (!lus->tracker_list_vpid) { + lus->tracker_vpid = process_attr_tracker_create(); + if (!lus->tracker_vpid) { goto error; } - lus->tracker_list_vuid = lttng_tracker_list_create(); - if (!lus->tracker_list_vuid) { + lus->tracker_vuid = process_attr_tracker_create(); + if (!lus->tracker_vuid) { goto error; } - lus->tracker_list_vgid = lttng_tracker_list_create(); - if (!lus->tracker_list_vgid) { + lus->tracker_vgid = process_attr_tracker_create(); + if (!lus->tracker_vgid) { goto error; } lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL); @@ -335,9 +326,9 @@ struct ltt_ust_session *trace_ust_create_session(uint64_t session_id) return lus; error: - lttng_tracker_list_destroy(lus->tracker_list_vpid); - lttng_tracker_list_destroy(lus->tracker_list_vuid); - lttng_tracker_list_destroy(lus->tracker_list_vgid); + process_attr_tracker_destroy(lus->tracker_vpid); + process_attr_tracker_destroy(lus->tracker_vuid); + process_attr_tracker_destroy(lus->tracker_vgid); ht_cleanup_push(lus->domain_global.channels); ht_cleanup_push(lus->agents); free(lus); @@ -371,7 +362,7 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, luc->attr.num_subbuf = chan->attr.num_subbuf; luc->attr.switch_timer_interval = chan->attr.switch_timer_interval; luc->attr.read_timer_interval = chan->attr.read_timer_interval; - luc->attr.output = (enum lttng_ust_output) chan->attr.output; + luc->attr.output = (enum lttng_ust_abi_output) chan->attr.output; luc->monitor_timer_interval = ((struct lttng_channel_extended *) chan->attr.extended.ptr)->monitor_timer_interval; luc->attr.u.s.blocking_timeout = ((struct lttng_channel_extended *) @@ -380,7 +371,7 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, /* Translate to UST output enum */ switch (luc->attr.output) { default: - luc->attr.output = LTTNG_UST_MMAP; + luc->attr.output = LTTNG_UST_ABI_MMAP; break; } @@ -394,7 +385,7 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, /* Copy channel name */ strncpy(luc->name, chan->name, sizeof(luc->name)); } - luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + luc->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0'; /* Init node */ lttng_ht_node_init_str(&luc->node, luc->name); @@ -455,7 +446,7 @@ end: */ enum lttng_error_code trace_ust_create_event(struct lttng_event *ev, char *filter_expression, - struct lttng_filter_bytecode *filter, + struct lttng_bytecode *filter, struct lttng_event_exclusion *exclusion, bool internal_event, struct ltt_ust_event **ust_event) @@ -481,16 +472,16 @@ enum lttng_error_code trace_ust_create_event(struct lttng_event *ev, switch (ev->type) { case LTTNG_EVENT_PROBE: - local_ust_event->attr.instrumentation = LTTNG_UST_PROBE; + local_ust_event->attr.instrumentation = LTTNG_UST_ABI_PROBE; break; case LTTNG_EVENT_FUNCTION: - local_ust_event->attr.instrumentation = LTTNG_UST_FUNCTION; + local_ust_event->attr.instrumentation = LTTNG_UST_ABI_FUNCTION; break; case LTTNG_EVENT_FUNCTION_ENTRY: - local_ust_event->attr.instrumentation = LTTNG_UST_FUNCTION; + local_ust_event->attr.instrumentation = LTTNG_UST_ABI_FUNCTION; break; case LTTNG_EVENT_TRACEPOINT: - local_ust_event->attr.instrumentation = LTTNG_UST_TRACEPOINT; + local_ust_event->attr.instrumentation = LTTNG_UST_ABI_TRACEPOINT; break; default: ERR("Unknown ust instrumentation type (%d)", ev->type); @@ -499,20 +490,20 @@ enum lttng_error_code trace_ust_create_event(struct lttng_event *ev, } /* Copy event name */ - strncpy(local_ust_event->attr.name, ev->name, LTTNG_UST_SYM_NAME_LEN); - local_ust_event->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + strncpy(local_ust_event->attr.name, ev->name, LTTNG_UST_ABI_SYM_NAME_LEN); + local_ust_event->attr.name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0'; switch (ev->loglevel_type) { case LTTNG_EVENT_LOGLEVEL_ALL: - local_ust_event->attr.loglevel_type = LTTNG_UST_LOGLEVEL_ALL; + local_ust_event->attr.loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL; local_ust_event->attr.loglevel = -1; /* Force to -1 */ break; case LTTNG_EVENT_LOGLEVEL_RANGE: - local_ust_event->attr.loglevel_type = LTTNG_UST_LOGLEVEL_RANGE; + local_ust_event->attr.loglevel_type = LTTNG_UST_ABI_LOGLEVEL_RANGE; local_ust_event->attr.loglevel = ev->loglevel; break; case LTTNG_EVENT_LOGLEVEL_SINGLE: - local_ust_event->attr.loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE; + local_ust_event->attr.loglevel_type = LTTNG_UST_ABI_LOGLEVEL_SINGLE; local_ust_event->attr.loglevel = ev->loglevel; break; default: @@ -554,69 +545,72 @@ int trace_ust_context_type_event_to_ust( switch (type) { case LTTNG_EVENT_CONTEXT_VTID: - utype = LTTNG_UST_CONTEXT_VTID; + utype = LTTNG_UST_ABI_CONTEXT_VTID; break; case LTTNG_EVENT_CONTEXT_VPID: - utype = LTTNG_UST_CONTEXT_VPID; + utype = LTTNG_UST_ABI_CONTEXT_VPID; break; case LTTNG_EVENT_CONTEXT_PTHREAD_ID: - utype = LTTNG_UST_CONTEXT_PTHREAD_ID; + utype = LTTNG_UST_ABI_CONTEXT_PTHREAD_ID; break; case LTTNG_EVENT_CONTEXT_PROCNAME: - utype = LTTNG_UST_CONTEXT_PROCNAME; + utype = LTTNG_UST_ABI_CONTEXT_PROCNAME; break; case LTTNG_EVENT_CONTEXT_IP: - utype = LTTNG_UST_CONTEXT_IP; + utype = LTTNG_UST_ABI_CONTEXT_IP; break; case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER: if (!ustctl_has_perf_counters()) { utype = -1; WARN("Perf counters not implemented in UST"); } else { - utype = LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER; + utype = LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER; } break; case LTTNG_EVENT_CONTEXT_APP_CONTEXT: - utype = LTTNG_UST_CONTEXT_APP_CONTEXT; + utype = LTTNG_UST_ABI_CONTEXT_APP_CONTEXT; break; case LTTNG_EVENT_CONTEXT_CGROUP_NS: - utype = LTTNG_UST_CONTEXT_CGROUP_NS; + utype = LTTNG_UST_ABI_CONTEXT_CGROUP_NS; break; case LTTNG_EVENT_CONTEXT_IPC_NS: - utype = LTTNG_UST_CONTEXT_IPC_NS; + utype = LTTNG_UST_ABI_CONTEXT_IPC_NS; break; case LTTNG_EVENT_CONTEXT_MNT_NS: - utype = LTTNG_UST_CONTEXT_MNT_NS; + utype = LTTNG_UST_ABI_CONTEXT_MNT_NS; break; case LTTNG_EVENT_CONTEXT_NET_NS: - utype = LTTNG_UST_CONTEXT_NET_NS; + utype = LTTNG_UST_ABI_CONTEXT_NET_NS; break; case LTTNG_EVENT_CONTEXT_PID_NS: - utype = LTTNG_UST_CONTEXT_PID_NS; + utype = LTTNG_UST_ABI_CONTEXT_PID_NS; + break; + case LTTNG_EVENT_CONTEXT_TIME_NS: + utype = LTTNG_UST_ABI_CONTEXT_TIME_NS; break; case LTTNG_EVENT_CONTEXT_USER_NS: - utype = LTTNG_UST_CONTEXT_USER_NS; + utype = LTTNG_UST_ABI_CONTEXT_USER_NS; break; case LTTNG_EVENT_CONTEXT_UTS_NS: - utype = LTTNG_UST_CONTEXT_UTS_NS; + utype = LTTNG_UST_ABI_CONTEXT_UTS_NS; break; case LTTNG_EVENT_CONTEXT_VUID: - utype = LTTNG_UST_CONTEXT_VUID; + utype = LTTNG_UST_ABI_CONTEXT_VUID; break; case LTTNG_EVENT_CONTEXT_VEUID: - utype = LTTNG_UST_CONTEXT_VEUID; + utype = LTTNG_UST_ABI_CONTEXT_VEUID; break; case LTTNG_EVENT_CONTEXT_VSUID: - utype = LTTNG_UST_CONTEXT_VSUID; + utype = LTTNG_UST_ABI_CONTEXT_VSUID; break; case LTTNG_EVENT_CONTEXT_VGID: - utype = LTTNG_UST_CONTEXT_VGID; + utype = LTTNG_UST_ABI_CONTEXT_VGID; break; case LTTNG_EVENT_CONTEXT_VEGID: - utype = LTTNG_UST_CONTEXT_VEGID; + utype = LTTNG_UST_ABI_CONTEXT_VEGID; break; case LTTNG_EVENT_CONTEXT_VSGID: - utype = LTTNG_UST_CONTEXT_VSGID; + utype = LTTNG_UST_ABI_CONTEXT_VSGID; break; default: utype = -1; @@ -641,7 +635,7 @@ int trace_ust_match_context(const struct ltt_ust_context *uctx, return 0; } switch (utype) { - case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER: + case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER: if (uctx->ctx.u.perf_counter.type != ctx->u.perf_counter.type) { return 0; @@ -652,11 +646,11 @@ int trace_ust_match_context(const struct ltt_ust_context *uctx, } if (strncmp(uctx->ctx.u.perf_counter.name, ctx->u.perf_counter.name, - LTTNG_UST_SYM_NAME_LEN)) { + LTTNG_UST_ABI_SYM_NAME_LEN)) { return 0; } break; - case LTTNG_UST_CONTEXT_APP_CONTEXT: + case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT: assert(uctx->ctx.u.app_ctx.provider_name); assert(uctx->ctx.u.app_ctx.ctx_name); if (strcmp(uctx->ctx.u.app_ctx.provider_name, @@ -697,16 +691,16 @@ struct ltt_ust_context *trace_ust_create_context( goto end; } - uctx->ctx.ctx = (enum lttng_ust_context_type) utype; + uctx->ctx.ctx = (enum lttng_ust_abi_context_type) utype; switch (utype) { - case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER: + case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER: uctx->ctx.u.perf_counter.type = ctx->u.perf_counter.type; uctx->ctx.u.perf_counter.config = ctx->u.perf_counter.config; strncpy(uctx->ctx.u.perf_counter.name, ctx->u.perf_counter.name, - LTTNG_UST_SYM_NAME_LEN); - uctx->ctx.u.perf_counter.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + LTTNG_UST_ABI_SYM_NAME_LEN); + uctx->ctx.u.perf_counter.name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0'; break; - case LTTNG_UST_CONTEXT_APP_CONTEXT: + case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT: { char *provider_name = NULL, *ctx_name = NULL; @@ -814,7 +808,7 @@ static int id_tracker_add_id(struct ust_id_tracker *id_tracker, int id) tracker_node = id_tracker_lookup(id_tracker, id, &iter); if (tracker_node) { /* Already exists. */ - retval = LTTNG_ERR_ID_TRACKED; + retval = LTTNG_ERR_PROCESS_ATTR_EXISTS; goto end; } tracker_node = zmalloc(sizeof(*tracker_node)); @@ -841,7 +835,7 @@ static int id_tracker_del_id(struct ust_id_tracker *id_tracker, int id) tracker_node = id_tracker_lookup(id_tracker, id, &iter); if (!tracker_node) { /* Not found */ - retval = LTTNG_ERR_ID_NOT_TRACKED; + retval = LTTNG_ERR_PROCESS_ATTR_MISSING; goto end; } ret = lttng_ht_del(id_tracker->ht, &iter); @@ -853,47 +847,56 @@ end: } static struct ust_id_tracker *get_id_tracker(struct ltt_ust_session *session, - enum lttng_tracker_type tracker_type) + enum lttng_process_attr process_attr) { - switch (tracker_type) { - case LTTNG_TRACKER_VPID: + switch (process_attr) { + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: return &session->vpid_tracker; - case LTTNG_TRACKER_VUID: + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: return &session->vuid_tracker; - case LTTNG_TRACKER_VGID: + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: return &session->vgid_tracker; default: return NULL; } } -static struct lttng_tracker_list *get_id_tracker_list( +static struct process_attr_tracker *_trace_ust_get_process_attr_tracker( struct ltt_ust_session *session, - enum lttng_tracker_type tracker_type) + enum lttng_process_attr process_attr) { - switch (tracker_type) { - case LTTNG_TRACKER_VPID: - return session->tracker_list_vpid; - case LTTNG_TRACKER_VUID: - return session->tracker_list_vuid; - case LTTNG_TRACKER_VGID: - return session->tracker_list_vgid; + switch (process_attr) { + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + return session->tracker_vpid; + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + return session->tracker_vuid; + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + return session->tracker_vgid; default: return NULL; } } +const struct process_attr_tracker *trace_ust_get_process_attr_tracker( + struct ltt_ust_session *session, + enum lttng_process_attr process_attr) +{ + return (const struct process_attr_tracker *) + _trace_ust_get_process_attr_tracker( + session, process_attr); +} + /* * The session lock is held when calling this function. */ -int trace_ust_id_tracker_lookup(enum lttng_tracker_type tracker_type, +int trace_ust_id_tracker_lookup(enum lttng_process_attr process_attr, struct ltt_ust_session *session, int id) { struct lttng_ht_iter iter; struct ust_id_tracker *id_tracker; - id_tracker = get_id_tracker(session, tracker_type); + id_tracker = get_id_tracker(session, process_attr); if (!id_tracker) { abort(); } @@ -909,230 +912,285 @@ int trace_ust_id_tracker_lookup(enum lttng_tracker_type tracker_type, /* * Called with the session lock held. */ -int trace_ust_track_id(enum lttng_tracker_type tracker_type, +enum lttng_error_code trace_ust_process_attr_tracker_set_tracking_policy( struct ltt_ust_session *session, - const struct lttng_tracker_id *id) + enum lttng_process_attr process_attr, + enum lttng_tracking_policy policy) { - int retval = LTTNG_OK; + int ret; + enum lttng_error_code ret_code = LTTNG_OK; + struct ust_id_tracker *id_tracker = + get_id_tracker(session, process_attr); + struct process_attr_tracker *tracker = + _trace_ust_get_process_attr_tracker( + session, process_attr); bool should_update_apps = false; - struct ust_id_tracker *id_tracker; - struct lttng_tracker_list *tracker_list; - int value; - struct lttng_tracker_id *saved_ids; - ssize_t saved_ids_count, i; + enum lttng_tracking_policy previous_policy; - if (tracker_type == LTTNG_TRACKER_PID) { - DBG("Backward compatible behavior: translate PID tracker to VPID tracker for UST domain."); - tracker_type = LTTNG_TRACKER_VPID; + if (!tracker) { + ret_code = LTTNG_ERR_INVALID; + goto end; } - retval = lttng_tracker_id_lookup_string(tracker_type, id, &value); - if (retval != LTTNG_OK) { - return retval; - } - tracker_list = get_id_tracker_list(session, tracker_type); - if (!tracker_list) { - return LTTNG_ERR_INVALID; - } - /* Save list for restore on error. */ - saved_ids_count = lttng_tracker_id_get_list(tracker_list, &saved_ids); - if (saved_ids_count < 0) { - return LTTNG_ERR_INVALID; - } - /* Add to list. */ - retval = lttng_tracker_list_add(tracker_list, id); - if (retval != LTTNG_OK) { + previous_policy = process_attr_tracker_get_tracking_policy(tracker); + ret = process_attr_tracker_set_tracking_policy(tracker, policy); + if (ret) { + ret_code = LTTNG_ERR_UNK; goto end; } - id_tracker = get_id_tracker(session, tracker_type); - if (!id_tracker) { - abort(); + if (previous_policy == policy) { + goto end; } - if (value == -1) { - /* Track all ids: destroy tracker if exists. */ + + switch (policy) { + case LTTNG_TRACKING_POLICY_INCLUDE_ALL: + /* Track all values: destroy tracker if exists. */ if (id_tracker->ht) { fini_id_tracker(id_tracker); /* Ensure all apps have session. */ should_update_apps = true; } - } else { - if (!id_tracker->ht) { - /* Create tracker. */ - retval = init_id_tracker(id_tracker); - if (retval != LTTNG_OK) { - ERR("Error initializing ID tracker"); - goto end_restore; - } - retval = id_tracker_add_id(id_tracker, value); - if (retval != LTTNG_OK) { - fini_id_tracker(id_tracker); - goto end_restore; - } - /* Remove all apps from session except pid. */ - should_update_apps = true; - } else { - struct ust_app *app; - - retval = id_tracker_add_id(id_tracker, value); - if (retval != LTTNG_OK) { - goto end_restore; - } - /* Add session to application */ - switch (tracker_type) { - case LTTNG_TRACKER_VPID: - app = ust_app_find_by_pid(value); - if (app) { - should_update_apps = true; - } - break; - default: - should_update_apps = true; - } + break; + case LTTNG_TRACKING_POLICY_EXCLUDE_ALL: + case LTTNG_TRACKING_POLICY_INCLUDE_SET: + /* fall-through. */ + fini_id_tracker(id_tracker); + ret_code = init_id_tracker(id_tracker); + if (ret_code != LTTNG_OK) { + ERR("Error initializing ID tracker"); + goto end; } + /* Remove all apps from session. */ + should_update_apps = true; + break; + default: + abort(); } if (should_update_apps && session->active) { ust_app_global_update_all(session); } - goto end; - -end_restore: - if (lttng_tracker_id_set_list(tracker_list, saved_ids, - saved_ids_count) != LTTNG_OK) { - ERR("Error on tracker add error handling.\n"); - } end: - for (i = 0; i < saved_ids_count; i++) { - free(saved_ids[i].string); - } - free(saved_ids); - return retval; + return ret_code; } -/* - * Called with the session lock held. - */ -int trace_ust_untrack_id(enum lttng_tracker_type tracker_type, +/* Called with the session lock held. */ +enum lttng_error_code trace_ust_process_attr_tracker_inclusion_set_add_value( struct ltt_ust_session *session, - const struct lttng_tracker_id *id) + enum lttng_process_attr process_attr, + const struct process_attr_value *value) { - int retval = LTTNG_OK; + enum lttng_error_code ret_code = LTTNG_OK; bool should_update_apps = false; - struct ust_id_tracker *id_tracker; - struct lttng_tracker_list *tracker_list; - int value; - struct lttng_tracker_id *saved_ids; - ssize_t saved_ids_count, i; + struct ust_id_tracker *id_tracker = + get_id_tracker(session, process_attr); + struct process_attr_tracker *tracker; + int integral_value; + enum process_attr_tracker_status status; + struct ust_app *app; - if (tracker_type == LTTNG_TRACKER_PID) { - DBG("Backward compatible behavior: translate PID tracker to VPID tracker for UST domain."); - tracker_type = LTTNG_TRACKER_VPID; - } - - retval = lttng_tracker_id_lookup_string(tracker_type, id, &value); - if (retval != LTTNG_OK) { - return retval; - } - - tracker_list = get_id_tracker_list(session, tracker_type); - if (!tracker_list) { - return LTTNG_ERR_INVALID; - } - /* Save list for restore on error. */ - saved_ids_count = lttng_tracker_id_get_list(tracker_list, &saved_ids); - if (saved_ids_count < 0) { - return LTTNG_ERR_INVALID; - } - /* Remove from list. */ - retval = lttng_tracker_list_remove(tracker_list, id); - if (retval != LTTNG_OK) { + /* + * Convert process attribute tracker value to the integral + * representation required by the kern-ctl API. + */ + switch (process_attr) { + case LTTNG_PROCESS_ATTR_PROCESS_ID: + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + integral_value = (int) value->value.pid; + break; + case LTTNG_PROCESS_ATTR_USER_ID: + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME) { + uid_t uid; + + ret_code = utils_user_id_from_name( + value->value.user_name, &uid); + if (ret_code != LTTNG_OK) { + goto end; + } + integral_value = (int) uid; + } else { + integral_value = (int) value->value.uid; + } + break; + case LTTNG_PROCESS_ATTR_GROUP_ID: + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME) { + gid_t gid; + + ret_code = utils_group_id_from_name( + value->value.group_name, &gid); + if (ret_code != LTTNG_OK) { + goto end; + } + integral_value = (int) gid; + } else { + integral_value = (int) value->value.gid; + } + break; + default: + ret_code = LTTNG_ERR_INVALID; goto end; } - id_tracker = get_id_tracker(session, tracker_type); - if (!id_tracker) { - abort(); + tracker = _trace_ust_get_process_attr_tracker(session, process_attr); + if (!tracker) { + ret_code = LTTNG_ERR_INVALID; + goto end; } - if (value == -1) { - /* Create empty tracker, replace old tracker. */ - struct ust_id_tracker tmp_tracker; - - tmp_tracker = *id_tracker; - retval = init_id_tracker(id_tracker); - if (retval != LTTNG_OK) { - ERR("Error initializing ID tracker"); - /* Rollback operation. */ - *id_tracker = tmp_tracker; - goto end_restore; + status = process_attr_tracker_inclusion_set_add_value(tracker, value); + if (status != PROCESS_ATTR_TRACKER_STATUS_OK) { + switch (status) { + case PROCESS_ATTR_TRACKER_STATUS_EXISTS: + ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS; + 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: + default: + ret_code = LTTNG_ERR_UNK; + break; } - fini_id_tracker(&tmp_tracker); + goto end; + } - /* Remove session from all applications */ - should_update_apps = true; - } else { - struct ust_app *app; + DBG("User space track %s %d for session id %" PRIu64, + lttng_process_attr_to_string(process_attr), + integral_value, session->id); - if (!id_tracker->ht) { - /* No ID being tracked. */ - retval = LTTNG_ERR_ID_NOT_TRACKED; - goto end_restore; - } - /* Remove ID from tracker */ - retval = id_tracker_del_id(id_tracker, value); - if (retval != LTTNG_OK) { - goto end_restore; - } - switch (tracker_type) { - case LTTNG_TRACKER_VPID: - /* Remove session from application. */ - app = ust_app_find_by_pid(value); - if (app) { - should_update_apps = true; - } - break; - default: - /* Keep only apps matching ID. */ + ret_code = id_tracker_add_id(id_tracker, integral_value); + if (ret_code != LTTNG_OK) { + goto end; + } + /* Add session to application */ + switch (process_attr) { + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + app = ust_app_find_by_pid(integral_value); + if (app) { should_update_apps = true; } + break; + default: + should_update_apps = true; + break; } if (should_update_apps && session->active) { ust_app_global_update_all(session); } - goto end; - -end_restore: - if (lttng_tracker_id_set_list(tracker_list, saved_ids, - saved_ids_count) != LTTNG_OK) { - ERR("Error on tracker remove error handling.\n"); - } end: - for (i = 0; i < saved_ids_count; i++) { - free(saved_ids[i].string); - } - free(saved_ids); - return retval; + return ret_code; } -/* - * Called with session lock held. - */ -ssize_t trace_ust_list_tracker_ids(enum lttng_tracker_type tracker_type, +/* Called with the session lock held. */ +enum lttng_error_code trace_ust_process_attr_tracker_inclusion_set_remove_value( struct ltt_ust_session *session, - struct lttng_tracker_id **_ids) + enum lttng_process_attr process_attr, + const struct process_attr_value *value) { - struct lttng_tracker_list *tracker_list; + enum lttng_error_code ret_code = LTTNG_OK; + bool should_update_apps = false; + struct ust_id_tracker *id_tracker = + get_id_tracker(session, process_attr); + struct process_attr_tracker *tracker; + int integral_value; + enum process_attr_tracker_status status; + struct ust_app *app; - if (tracker_type == LTTNG_TRACKER_PID) { - DBG("Backward compatible behavior: translate PID tracker to VPID tracker for UST domain."); - tracker_type = LTTNG_TRACKER_VPID; + /* + * Convert process attribute tracker value to the integral + * representation required by the kern-ctl API. + */ + switch (process_attr) { + case LTTNG_PROCESS_ATTR_PROCESS_ID: + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + integral_value = (int) value->value.pid; + break; + case LTTNG_PROCESS_ATTR_USER_ID: + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME) { + uid_t uid; + + ret_code = utils_user_id_from_name( + value->value.user_name, &uid); + if (ret_code != LTTNG_OK) { + goto end; + } + integral_value = (int) uid; + } else { + integral_value = (int) value->value.uid; + } + break; + case LTTNG_PROCESS_ATTR_GROUP_ID: + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME) { + gid_t gid; + + ret_code = utils_group_id_from_name( + value->value.group_name, &gid); + if (ret_code != LTTNG_OK) { + goto end; + } + integral_value = (int) gid; + } else { + integral_value = (int) value->value.gid; + } + break; + default: + ret_code = LTTNG_ERR_INVALID; + goto end; + } + + tracker = _trace_ust_get_process_attr_tracker(session, process_attr); + if (!tracker) { + ret_code = LTTNG_ERR_INVALID; + goto end; + } + + status = process_attr_tracker_inclusion_set_remove_value( + tracker, value); + if (status != PROCESS_ATTR_TRACKER_STATUS_OK) { + switch (status) { + case PROCESS_ATTR_TRACKER_STATUS_MISSING: + ret_code = LTTNG_ERR_PROCESS_ATTR_MISSING; + 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: + default: + ret_code = LTTNG_ERR_UNK; + break; + } + goto end; } - tracker_list = get_id_tracker_list(session, tracker_type); - if (!tracker_list) { - return -LTTNG_ERR_INVALID; + DBG("User space untrack %s %d for session id %" PRIu64, + lttng_process_attr_to_string(process_attr), + integral_value, session->id); + + ret_code = id_tracker_del_id(id_tracker, integral_value); + if (ret_code != LTTNG_OK) { + goto end; + } + /* Add session to application */ + switch (process_attr) { + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + app = ust_app_find_by_pid(integral_value); + if (app) { + should_update_apps = true; + } + break; + default: + should_update_apps = true; + break; } - return lttng_tracker_id_get_list(tracker_list, _ids); + if (should_update_apps && session->active) { + ust_app_global_update_all(session); + } +end: + return ret_code; } /* @@ -1197,7 +1255,7 @@ void trace_ust_destroy_context(struct ltt_ust_context *ctx) { assert(ctx); - if (ctx->ctx.ctx == LTTNG_UST_CONTEXT_APP_CONTEXT) { + if (ctx->ctx.ctx == LTTNG_UST_ABI_CONTEXT_APP_CONTEXT) { free(ctx->ctx.u.app_ctx.provider_name); free(ctx->ctx.u.app_ctx.ctx_name); } @@ -1364,9 +1422,9 @@ void trace_ust_destroy_session(struct ltt_ust_session *session) buffer_reg_uid_destroy(reg, session->consumer); } - lttng_tracker_list_destroy(session->tracker_list_vpid); - lttng_tracker_list_destroy(session->tracker_list_vuid); - lttng_tracker_list_destroy(session->tracker_list_vgid); + process_attr_tracker_destroy(session->tracker_vpid); + process_attr_tracker_destroy(session->tracker_vuid); + process_attr_tracker_destroy(session->tracker_vgid); fini_id_tracker(&session->vpid_tracker); fini_id_tracker(&session->vuid_tracker);