X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Fconfig%2Fsession-config.c;h=70668470c4445a70494c0bf1b98ea91f35e77efd;hb=refs%2Fheads%2Fsow-2020-0002-rev2;hp=e625f316a96e735ff77485b1830926c38b663f9d;hpb=55c9e7cac24318259d4f2549c97f7577b7b52db4;p=lttng-tools.git diff --git a/src/common/config/session-config.c b/src/common/config/session-config.c index e625f316a..70668470c 100644 --- a/src/common/config/session-config.c +++ b/src/common/config/session-config.c @@ -1,20 +1,11 @@ /* - * Copyright (C) 2013 - Jérémie Galarneau + * Copyright (C) 2013 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. */ +#include "lttng/tracker.h" #define _LGPL_SOURCE #include #include @@ -33,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -61,7 +53,7 @@ struct session_config_validation_ctx { xmlSchemaValidCtxtPtr schema_validation_ctx; }; -const char * const config_element_all = "all"; +LTTNG_HIDDEN const char * const config_element_all = "all"; const char * const config_str_yes = "yes"; const char * const config_str_true = "true"; const char * const config_str_on = "on"; @@ -76,6 +68,8 @@ const char * const config_xml_false = "false"; const char * const config_element_channel = "channel"; const char * const config_element_channels = "channels"; +const char * const config_element_map = "map"; +const char * const config_element_maps = "maps"; const char * const config_element_domain = "domain"; const char * const config_element_domains = "domains"; const char * const config_element_event = "event"; @@ -142,25 +136,33 @@ const char * const config_element_control_uri = "control_uri"; const char * const config_element_data_uri = "data_uri"; const char * const config_element_max_size = "max_size"; const char * const config_element_pid = "pid"; -const char * const config_element_id = "id"; const char * const config_element_pids = "pids"; const char * const config_element_shared_memory_path = "shared_memory_path"; -const char * const config_element_pid_tracker = "pid_tracker"; -const char * const config_element_vpid_tracker = "vpid_tracker"; -const char * const config_element_uid_tracker = "uid_tracker"; -const char * const config_element_vuid_tracker = "vuid_tracker"; -const char * const config_element_gid_tracker = "gid_tracker"; -const char * const config_element_vgid_tracker = "vgid_tracker"; -const char * const config_element_trackers = "trackers"; -const char * const config_element_targets = "targets"; -const char * const config_element_target_type = "target_type"; -const char * const config_element_target_pid = "pid_target"; -const char * const config_element_target_vpid = "vpid_target"; -const char * const config_element_target_uid = "uid_target"; -const char * const config_element_target_vuid = "vuid_target"; -const char * const config_element_target_gid = "gid_target"; -const char * const config_element_target_vgid = "vgid_target"; -const char * const config_element_tracker_type = "tracker_type"; + +LTTNG_HIDDEN const char * const config_element_process_attr_id = "id"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_pid = "pid_process_attr_tracker"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_vpid = "vpid_process_attr_tracker"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_uid = "uid_process_attr_tracker"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_vuid = "vuid_process_attr_tracker"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_gid = "gid_process_attr_tracker"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_vgid = "vgid_process_attr_tracker"; +LTTNG_HIDDEN const char * const config_element_process_attr_trackers = "process_attr_trackers"; +LTTNG_HIDDEN const char * const config_element_process_attr_values = "process_attr_values"; +LTTNG_HIDDEN const char * const config_element_process_attr_value_type = "process_attr_value_type"; +LTTNG_HIDDEN const char * const config_element_process_attr_pid_value = "pid"; +LTTNG_HIDDEN const char * const config_element_process_attr_vpid_value = "vpid"; +LTTNG_HIDDEN const char * const config_element_process_attr_uid_value = "uid"; +LTTNG_HIDDEN const char * const config_element_process_attr_vuid_value = "vuid"; +LTTNG_HIDDEN const char * const config_element_process_attr_gid_value = "gid"; +LTTNG_HIDDEN const char * const config_element_process_attr_vgid_value = "vgid"; +LTTNG_HIDDEN const char * const config_element_process_attr_tracker_type = "process_attr_tracker_type"; + +/* Used for support of legacy tracker serialization (< 2.12). */ +LTTNG_HIDDEN const char * const config_element_trackers_legacy = "trackers"; +LTTNG_HIDDEN const char * const config_element_pid_tracker_legacy = "pid_tracker"; +LTTNG_HIDDEN const char * const config_element_tracker_targets_legacy = "targets"; +LTTNG_HIDDEN const char * const config_element_tracker_pid_target_legacy = "pid_target"; +LTTNG_HIDDEN const char * const config_element_tracker_pid_legacy = "pid"; LTTNG_HIDDEN const char * const config_element_rotation_schedules = "rotation_schedules"; LTTNG_HIDDEN const char * const config_element_rotation_schedule_periodic = "periodic"; @@ -184,6 +186,15 @@ const char * const config_overwrite_mode_overwrite = "OVERWRITE"; const char * const config_output_type_splice = "SPLICE"; const char * const config_output_type_mmap = "MMAP"; +LTTNG_HIDDEN const char * const config_element_bitness = "bitness"; +LTTNG_HIDDEN const char * const config_element_boundary_policy = "boundary_policy"; +LTTNG_HIDDEN const char * const config_element_coalesce_hits = "coalesce_hits"; +LTTNG_HIDDEN const char * const config_element_dimensions = "dimensions"; +LTTNG_HIDDEN const char * const config_element_dimension = "dimension"; +LTTNG_HIDDEN const char * const config_element_dimension_size = "size"; + +LTTNG_HIDDEN const char * const config_boundary_policy_overflow = "OVERFLOW"; + const char * const config_loglevel_type_all = "ALL"; const char * const config_loglevel_type_range = "RANGE"; const char * const config_loglevel_type_single = "SINGLE"; @@ -224,6 +235,7 @@ LTTNG_HIDDEN const char * const config_event_context_ipc_ns = "IPC_NS"; LTTNG_HIDDEN const char * const config_event_context_mnt_ns = "MNT_NS"; LTTNG_HIDDEN const char * const config_event_context_net_ns = "NET_NS"; LTTNG_HIDDEN const char * const config_event_context_pid_ns = "PID_NS"; +LTTNG_HIDDEN const char * const config_event_context_time_ns = "TIME_NS"; LTTNG_HIDDEN const char * const config_event_context_user_ns = "USER_NS"; LTTNG_HIDDEN const char * const config_event_context_uts_ns = "UTS_NS"; LTTNG_HIDDEN const char * const config_event_context_uid = "UID"; @@ -712,7 +724,7 @@ void fini_session_config_validation_ctx( } static -char *get_session_config_xsd_path() +char *get_session_config_xsd_path(void) { char *xsd_path; const char *base_path = lttng_secure_getenv(DEFAULT_SESSION_CONFIG_XSD_PATH_ENV); @@ -1095,6 +1107,9 @@ int get_context_type(xmlChar *context_type) } else if (!strcmp((char *) context_type, config_event_context_pid_ns)) { ret = LTTNG_EVENT_CONTEXT_PID_NS; + } else if (!strcmp((char *) context_type, + config_event_context_time_ns)) { + ret = LTTNG_EVENT_CONTEXT_TIME_NS; } else if (!strcmp((char *) context_type, config_event_context_user_ns)) { ret = LTTNG_EVENT_CONTEXT_USER_NS; @@ -2675,56 +2690,56 @@ end: return ret; } -static int get_tracker_elements(enum lttng_tracker_type tracker_type, +static int get_tracker_elements(enum lttng_process_attr process_attr, const char **element_id_tracker, - const char **element_target_id, - const char **element_id, - const char **element_id_alias, + const char **element_value_type, + const char **element_value, + const char **element_value_alias, const char **element_name) { int ret = 0; - switch (tracker_type) { - case LTTNG_TRACKER_PID: - *element_id_tracker = config_element_pid_tracker; - *element_target_id = config_element_target_pid; - *element_id = config_element_id; - *element_id_alias = config_element_pid; + switch (process_attr) { + case LTTNG_PROCESS_ATTR_PROCESS_ID: + *element_id_tracker = config_element_process_attr_tracker_pid; + *element_value_type = config_element_process_attr_pid_value; + *element_value = config_element_process_attr_id; + *element_value_alias = config_element_process_attr_id; *element_name = NULL; break; - case LTTNG_TRACKER_VPID: - *element_id_tracker = config_element_vpid_tracker; - *element_target_id = config_element_target_vpid; - *element_id = config_element_id; - *element_id_alias = NULL; + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + *element_id_tracker = config_element_process_attr_tracker_vpid; + *element_value_type = config_element_process_attr_vpid_value; + *element_value = config_element_process_attr_id; + *element_value_alias = NULL; *element_name = NULL; break; - case LTTNG_TRACKER_UID: - *element_id_tracker = config_element_uid_tracker; - *element_target_id = config_element_target_uid; - *element_id = config_element_id; - *element_id_alias = NULL; + case LTTNG_PROCESS_ATTR_USER_ID: + *element_id_tracker = config_element_process_attr_tracker_uid; + *element_value_type = config_element_process_attr_uid_value; + *element_value = config_element_process_attr_id; + *element_value_alias = NULL; *element_name = config_element_name; break; - case LTTNG_TRACKER_VUID: - *element_id_tracker = config_element_vuid_tracker; - *element_target_id = config_element_target_vuid; - *element_id = config_element_id; - *element_id_alias = NULL; + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + *element_id_tracker = config_element_process_attr_tracker_vuid; + *element_value_type = config_element_process_attr_vuid_value; + *element_value = config_element_process_attr_id; + *element_value_alias = NULL; *element_name = config_element_name; break; - case LTTNG_TRACKER_GID: - *element_id_tracker = config_element_gid_tracker; - *element_target_id = config_element_target_gid; - *element_id = config_element_id; - *element_id_alias = NULL; + case LTTNG_PROCESS_ATTR_GROUP_ID: + *element_id_tracker = config_element_process_attr_tracker_gid; + *element_value_type = config_element_process_attr_gid_value; + *element_value = config_element_process_attr_id; + *element_value_alias = NULL; *element_name = config_element_name; break; - case LTTNG_TRACKER_VGID: - *element_id_tracker = config_element_vgid_tracker; - *element_target_id = config_element_target_vgid; - *element_id = config_element_id; - *element_id_alias = NULL; + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + *element_id_tracker = config_element_process_attr_tracker_vgid; + *element_value_type = config_element_process_attr_vgid_value; + *element_value = config_element_process_attr_id; + *element_value_alias = NULL; *element_name = config_element_name; break; default: @@ -2733,11 +2748,10 @@ static int get_tracker_elements(enum lttng_tracker_type tracker_type, return ret; } -static int process_id_tracker_node(xmlNodePtr id_tracker_node, - struct lttng_handle *handle, - enum lttng_tracker_type tracker_type) +static int process_legacy_pid_tracker_node( + xmlNodePtr trackers_node, struct lttng_handle *handle) { - int ret = 0, child; + int ret = 0, child_count; xmlNodePtr targets_node = NULL; xmlNodePtr node; const char *element_id_tracker; @@ -2745,26 +2759,41 @@ static int process_id_tracker_node(xmlNodePtr id_tracker_node, const char *element_id; const char *element_id_alias; const char *element_name; + enum lttng_error_code tracker_handle_ret_code; + struct lttng_process_attr_tracker_handle *tracker_handle = NULL; + enum lttng_process_attr_tracker_handle_status status; + const enum lttng_process_attr process_attr = + handle->domain.type == LTTNG_DOMAIN_UST ? + LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID : + LTTNG_PROCESS_ATTR_PROCESS_ID; assert(handle); - assert(id_tracker_node); - ret = get_tracker_elements(tracker_type, &element_id_tracker, + tracker_handle_ret_code = lttng_session_get_tracker_handle( + handle->session_name, handle->domain.type, + process_attr, + &tracker_handle); + if (tracker_handle_ret_code != LTTNG_OK) { + ret = LTTNG_ERR_INVALID; + goto end; + } + + ret = get_tracker_elements(process_attr, &element_id_tracker, &element_target_id, &element_id, &element_id_alias, &element_name); if (ret) { - return ret; + goto end; } - /* get the targets node */ - for (node = xmlFirstElementChild(id_tracker_node); node; + /* Get the targets node */ + for (node = xmlFirstElementChild(trackers_node); node; node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, - config_element_targets)) { + config_element_tracker_targets_legacy)) { targets_node = node; break; } - } + } if (!targets_node) { ret = LTTNG_ERR_INVALID; @@ -2772,18 +2801,146 @@ static int process_id_tracker_node(xmlNodePtr id_tracker_node, } /* Go through all id target node */ - child = xmlChildElementCount(targets_node); - if (child == 0) { - struct lttng_tracker_id tracker_id; + child_count = xmlChildElementCount(targets_node); + status = lttng_process_attr_tracker_handle_set_tracking_policy( + tracker_handle, + child_count == 0 ? LTTNG_TRACKING_POLICY_EXCLUDE_ALL : + LTTNG_TRACKING_POLICY_INCLUDE_SET); + if (status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) { + ret = LTTNG_ERR_UNK; + goto end; + } - tracker_id.type = LTTNG_ID_ALL; - /* The session is explicitly set to target nothing. */ - ret = lttng_untrack_id(handle, tracker_type, &tracker_id); - if (ret) { - goto end; + /* Add all tracked values. */ + for (node = xmlFirstElementChild(targets_node); node; + node = xmlNextElementSibling(node)) { + xmlNodePtr pid_target_node = node; + + /* get pid_target node and track it */ + for (node = xmlFirstElementChild(pid_target_node); node; + node = xmlNextElementSibling(node)) { + if (!strcmp((const char *) node->name, + config_element_tracker_pid_legacy)) { + int64_t id; + xmlChar *content = xmlNodeGetContent(node); + + if (!content) { + ret = LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + ret = parse_int(content, &id); + free(content); + if (ret) { + ret = LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + switch (process_attr) { + case LTTNG_PROCESS_ATTR_PROCESS_ID: + status = lttng_process_attr_process_id_tracker_handle_add_pid( + tracker_handle, + (pid_t) id); + break; + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + status = lttng_process_attr_virtual_process_id_tracker_handle_add_pid( + tracker_handle, + (pid_t) id); + break; + default: + ret = LTTNG_ERR_INVALID; + goto end; + } + } + switch (status) { + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK: + continue; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID: + ret = LTTNG_ERR_INVALID; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS: + ret = LTTNG_ERR_PROCESS_ATTR_EXISTS; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING: + ret = LTTNG_ERR_PROCESS_ATTR_MISSING; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR: + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR: + default: + ret = LTTNG_ERR_UNK; + goto end; + } } + node = pid_target_node; } - for (node = xmlFirstElementChild(targets_node); node; + +end: + lttng_process_attr_tracker_handle_destroy(tracker_handle); + return ret; + } + +static int process_id_tracker_node(xmlNodePtr id_tracker_node, + struct lttng_handle *handle, + enum lttng_process_attr process_attr) +{ + int ret = 0, child_count; + xmlNodePtr values_node = NULL; + xmlNodePtr node; + const char *element_id_tracker; + const char *element_target_id; + const char *element_id; + const char *element_id_alias; + const char *element_name; + enum lttng_error_code tracker_handle_ret_code; + struct lttng_process_attr_tracker_handle *tracker_handle = NULL; + enum lttng_process_attr_tracker_handle_status status; + + assert(handle); + assert(id_tracker_node); + + tracker_handle_ret_code = lttng_session_get_tracker_handle( + handle->session_name, handle->domain.type, process_attr, + &tracker_handle); + if (tracker_handle_ret_code != LTTNG_OK) { + ret = LTTNG_ERR_INVALID; + goto end; + } + + ret = get_tracker_elements(process_attr, &element_id_tracker, + &element_target_id, &element_id, &element_id_alias, + &element_name); + if (ret) { + goto end; + } + + /* get the values node */ + for (node = xmlFirstElementChild(id_tracker_node); node; + node = xmlNextElementSibling(node)) { + if (!strcmp((const char *) node->name, + config_element_process_attr_values)) { + values_node = node; + break; + } + } + + if (!values_node) { + ret = LTTNG_ERR_INVALID; + goto end; + } + + /* Go through all id target node */ + child_count = xmlChildElementCount(values_node); + status = lttng_process_attr_tracker_handle_set_tracking_policy( + tracker_handle, + child_count == 0 ? LTTNG_TRACKING_POLICY_EXCLUDE_ALL : + LTTNG_TRACKING_POLICY_INCLUDE_SET); + if (status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) { + ret = LTTNG_ERR_UNK; + goto end; + } + + /* Add all tracked values. */ + for (node = xmlFirstElementChild(values_node); node; node = xmlNextElementSibling(node)) { xmlNodePtr id_target_node = node; @@ -2795,10 +2952,8 @@ static int process_id_tracker_node(xmlNodePtr id_tracker_node, !strcmp((const char *) node->name, element_id_alias))) { int64_t id; - xmlChar *content = NULL; - struct lttng_tracker_id tracker_id; + xmlChar *content = xmlNodeGetContent(node); - content = xmlNodeGetContent(node); if (!content) { ret = LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; @@ -2811,38 +2966,388 @@ static int process_id_tracker_node(xmlNodePtr id_tracker_node, goto end; } - tracker_id.type = LTTNG_ID_VALUE; - tracker_id.value = (int) id; - ret = lttng_track_id(handle, tracker_type, - &tracker_id); - if (ret) { + switch (process_attr) { + case LTTNG_PROCESS_ATTR_PROCESS_ID: + status = lttng_process_attr_process_id_tracker_handle_add_pid( + tracker_handle, + (pid_t) id); + break; + case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID: + status = lttng_process_attr_virtual_process_id_tracker_handle_add_pid( + tracker_handle, + (pid_t) id); + break; + case LTTNG_PROCESS_ATTR_USER_ID: + status = lttng_process_attr_user_id_tracker_handle_add_uid( + tracker_handle, + (uid_t) id); + break; + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + status = lttng_process_attr_virtual_user_id_tracker_handle_add_uid( + tracker_handle, + (uid_t) id); + break; + case LTTNG_PROCESS_ATTR_GROUP_ID: + status = lttng_process_attr_group_id_tracker_handle_add_gid( + tracker_handle, + (gid_t) id); + break; + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + status = lttng_process_attr_virtual_group_id_tracker_handle_add_gid( + tracker_handle, + (gid_t) id); + break; + default: + ret = LTTNG_ERR_INVALID; goto end; } - } - if (element_name && !strcmp((const char *) node->name, - element_name)) { - xmlChar *content = NULL; - struct lttng_tracker_id tracker_id; + } else if (element_name && + !strcmp((const char *) node->name, + element_name)) { + xmlChar *content = xmlNodeGetContent(node); - content = xmlNodeGetContent(node); if (!content) { ret = LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; } - tracker_id.type = LTTNG_ID_STRING; - tracker_id.string = (char *) content; - ret = lttng_track_id(handle, tracker_type, - &tracker_id); - free(content); - if (ret) { + + switch (process_attr) { + case LTTNG_PROCESS_ATTR_USER_ID: + status = lttng_process_attr_user_id_tracker_handle_add_user_name( + tracker_handle, + (const char *) content); + break; + case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID: + status = lttng_process_attr_virtual_user_id_tracker_handle_add_user_name( + tracker_handle, + (const char *) content); + break; + case LTTNG_PROCESS_ATTR_GROUP_ID: + status = lttng_process_attr_group_id_tracker_handle_add_group_name( + tracker_handle, + (const char *) content); + break; + case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID: + status = lttng_process_attr_virtual_group_id_tracker_handle_add_group_name( + tracker_handle, + (const char *) content); + break; + default: + free(content); + ret = LTTNG_ERR_INVALID; goto end; } + free(content); + } + switch (status) { + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK: + continue; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID: + ret = LTTNG_ERR_INVALID; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS: + ret = LTTNG_ERR_PROCESS_ATTR_EXISTS; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING: + ret = LTTNG_ERR_PROCESS_ATTR_MISSING; + break; + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR: + case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR: + default: + ret = LTTNG_ERR_UNK; + goto end; } } node = id_target_node; } end: + lttng_process_attr_tracker_handle_destroy(tracker_handle); + return ret; +} + +static +int process_channel_node(xmlNodePtr channel_node, struct lttng_handle *handle, + struct lttng_domain *domain, + enum lttng_domain_type original_domain) +{ + int ret; + struct lttng_channel *channel = NULL; + xmlNodePtr contexts_node = NULL; + xmlNodePtr events_node = NULL; + xmlNodePtr channel_attr_node; + + /* + * Channels of the "agent" types cannot be created directly. + * They are meant to be created implicitly through the + * activation of events in their domain. However, a user + * can override the default channel configuration attributes + * by creating the underlying UST channel _before_ enabling + * an agent domain event. + * + * Hence, the channel's type is substituted before the creation + * and restored by the time the events are created. + */ + switch (domain->type) { + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: + domain->type = LTTNG_DOMAIN_UST; + default: + break; + } + + channel = lttng_channel_create(domain); + if (!channel) { + ret = -1; + goto end; + } + + for (channel_attr_node = xmlFirstElementChild(channel_node); + channel_attr_node; channel_attr_node = + xmlNextElementSibling(channel_attr_node)) { + ret = process_channel_attr_node(channel_attr_node, + channel, &contexts_node, &events_node); + if (ret) { + goto end; + } + } + + ret = lttng_enable_channel(handle, channel); + if (ret < 0) { + goto end; + } + + /* Restore the original channel domain-> */ + domain->type = original_domain; + + ret = process_events_node(events_node, handle, channel->name); + if (ret) { + goto end; + } + + ret = process_contexts_node(contexts_node, handle, + channel->name); + if (ret) { + goto end; + } + +end: + lttng_channel_destroy(channel); + return ret; +} + +static int process_dimension_node(xmlNodePtr dimension_node, + struct lttng_dynamic_array *dimension_sizes) +{ + int ret; + xmlNodePtr node; + xmlChar *size_str = NULL; + uint64_t size; + + assert(strcmp((const char *) dimension_node->name, + config_element_dimension) == 0); + assert(dimension_sizes->element_size == sizeof(uint64_t)); + + for (node = xmlFirstElementChild(dimension_node); node; + node = xmlNextElementSibling(node)) { + if (strcmp((const char *) node->name, + config_element_dimension_size) == 0) { + assert(!size_str); + size_str = xmlNodeGetContent(node); + if (!size_str) { + ERR("Failed to get dimension size node content."); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + ret = parse_uint(size_str, &size); + assert(!ret); + + ret = lttng_dynamic_array_add_element(dimension_sizes, &size); + if (ret) { + goto end; + } + } else { + assert(false); + } + } + + ret = 0; + +end: + xmlFree(size_str); + return ret; +} + +/* `dimensions_sizes` must be initialized to hold uint64_t elements. */ + +static int process_dimensions_node(xmlNodePtr dimensions_node, + struct lttng_dynamic_array *dimension_sizes) +{ + xmlNodePtr dimension_node; + int ret = 0; + + assert(strcmp((const char *) dimensions_node->name, + config_element_dimensions) == 0); + assert(dimension_sizes->element_size == sizeof(uint64_t)); + assert(lttng_dynamic_array_get_count(dimension_sizes) == 0); + + for (dimension_node = xmlFirstElementChild(dimensions_node); + dimension_node; dimension_node = xmlNextElementSibling( + dimension_node)) { + ret = process_dimension_node(dimension_node, dimension_sizes); + if (ret) { + goto end; + } + } + + assert(lttng_dynamic_array_get_count(dimension_sizes) > 0); + +end: + return ret; +} + +static int process_map_node(xmlNodePtr map_node, struct lttng_handle *handle) +{ + int ret; + xmlNodePtr node; + xmlChar *name = NULL; + xmlChar *enabled_str = NULL; + int enabled; + xmlChar *bitness_str = NULL; + enum lttng_map_bitness bitness = LTTNG_MAP_BITNESS_32BITS; + xmlChar *boundary_policy_str = NULL; + enum lttng_map_boundary_policy boundary_policy = LTTNG_MAP_BOUNDARY_POLICY_OVERFLOW; + xmlChar *coalesce_hits_str = NULL; + int coalesce_hits; + enum lttng_map_status map_status; + struct lttng_map *map = NULL; + struct lttng_dynamic_array dimension_sizes; + enum lttng_error_code error_code; + + assert(strcmp((const char *) map_node->name, config_element_map) == 0); + + lttng_dynamic_array_init(&dimension_sizes, sizeof(uint64_t), NULL); + + for (node = xmlFirstElementChild(map_node); node; + node = xmlNextElementSibling(node)) { + if (strcmp((const char *) node->name, config_element_name) == + 0) { + assert(!name); + name = xmlNodeGetContent(node); + if (!name) { + ERR("Failed to get map name node content."); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + } else if (strcmp((const char *) node->name, + config_element_enabled) == 0) { + assert(!enabled_str); + enabled_str = xmlNodeGetContent(node); + if (!enabled_str) { + ERR("Failed to get map enabled node content."); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + ret = parse_bool(enabled_str, &enabled); + assert(!ret); + } else if (strcmp((const char *) node->name, + config_element_bitness) == 0) { + assert(!bitness_str); + bitness_str = xmlNodeGetContent(node); + if (!bitness_str) { + ERR("Failed to get map bitness node content."); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + if (strcmp((const char *) bitness_str, "32") == 0) { + bitness = LTTNG_MAP_BITNESS_32BITS; + } else { + assert(strcmp((const char *) bitness_str, + "64") == 0); + bitness = LTTNG_MAP_BITNESS_64BITS; + } + } else if (strcmp((const char *) node->name, + config_element_boundary_policy) == + 0) { + assert(!boundary_policy_str); + boundary_policy_str = xmlNodeGetContent(node); + if (!boundary_policy_str) { + ERR("Failed to get map boundary policy node content."); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + assert(strcmp((const char *) boundary_policy_str, + config_boundary_policy_overflow) == + 0); + boundary_policy = LTTNG_MAP_BOUNDARY_POLICY_OVERFLOW; + } else if (strcmp((const char *) node->name, + config_element_coalesce_hits) == 0) { + assert(!coalesce_hits_str); + coalesce_hits_str = xmlNodeGetContent(node); + if (!coalesce_hits_str) { + ERR("Failed to get map coalesce hits node content."); + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + ret = parse_bool(coalesce_hits_str, &coalesce_hits); + assert(!ret); + } else if (strcmp((const char *) node->name, + config_element_dimensions) == 0) { + ret = process_dimensions_node(node, &dimension_sizes); + if (ret) { + goto end; + } + } else { + assert(false); + } + } + + assert(name); + map_status = lttng_map_create((const char *) name, + lttng_dynamic_array_get_count(&dimension_sizes), + (uint64_t *) dimension_sizes.buffer.data, + handle->domain.type, handle->domain.buf_type, bitness, + boundary_policy, coalesce_hits, &map); + if (map_status != LTTNG_MAP_STATUS_OK) { + ERR("Failed to create map."); + ret = -LTTNG_ERR_UNK; + goto end; + } + + error_code = lttng_add_map(handle, map); + if (error_code != LTTNG_OK) { + ERR("Adding map \"%s\": %s", (const char *) name, + lttng_strerror(error_code)); + ret = error_code; + goto end; + } + + // FIXME: disabling the map after creating leaves a window of time + // where it is enabled, does it matter? + if (!enabled) { + ret = lttng_disable_map(handle, (const char *) name); + if (ret) { + goto end; + } + } + + ret = 0; + +end: + xmlFree(name); + xmlFree(enabled_str); + xmlFree(bitness_str); + xmlFree(boundary_policy_str); + xmlFree(coalesce_hits_str); + lttng_dynamic_array_reset(&dimension_sizes); + lttng_map_destroy(map); + return ret; } @@ -2852,8 +3357,8 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) int ret; struct lttng_domain domain = { 0 }; struct lttng_handle *handle = NULL; - struct lttng_channel *channel = NULL; xmlNodePtr channels_node = NULL; + xmlNodePtr maps_node = NULL; xmlNodePtr trackers_node = NULL; xmlNodePtr pid_tracker_node = NULL; xmlNodePtr vpid_tracker_node = NULL; @@ -2886,82 +3391,54 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) } } - if (!channels_node) { - goto end; - } - - /* create all channels */ - for (node = xmlFirstElementChild(channels_node); node; - node = xmlNextElementSibling(node)) { - const enum lttng_domain_type original_domain = domain.type; - xmlNodePtr contexts_node = NULL; - xmlNodePtr events_node = NULL; - xmlNodePtr channel_attr_node; - - /* - * Channels of the "agent" types cannot be created directly. - * They are meant to be created implicitly through the - * activation of events in their domain. However, a user - * can override the default channel configuration attributes - * by creating the underlying UST channel _before_ enabling - * an agent domain event. - * - * Hence, the channel's type is substituted before the creation - * and restored by the time the events are created. - */ - switch (domain.type) { - case LTTNG_DOMAIN_JUL: - case LTTNG_DOMAIN_LOG4J: - case LTTNG_DOMAIN_PYTHON: - domain.type = LTTNG_DOMAIN_UST; - default: - break; - } - - channel = lttng_channel_create(&domain); - if (!channel) { - ret = -1; - goto end; - } + if (channels_node) { + /* create all channels */ + for (node = xmlFirstElementChild(channels_node); node; + node = xmlNextElementSibling(node)) { + const enum lttng_domain_type original_domain = domain.type; - for (channel_attr_node = xmlFirstElementChild(node); - channel_attr_node; channel_attr_node = - xmlNextElementSibling(channel_attr_node)) { - ret = process_channel_attr_node(channel_attr_node, - channel, &contexts_node, &events_node); + ret = process_channel_node(node, handle, &domain, + original_domain); if (ret) { goto end; } } + } - ret = lttng_enable_channel(handle, channel); - if (ret < 0) { - goto end; - } - - /* Restore the original channel domain. */ - domain.type = original_domain; - - ret = process_events_node(events_node, handle, channel->name); - if (ret) { - goto end; + /* get the maps node */ + for (node = xmlFirstElementChild(domain_node); node; + node = xmlNextElementSibling(node)) { + if (!strcmp((const char *) node->name, config_element_maps)) { + maps_node = node; + break; } + } - ret = process_contexts_node(contexts_node, handle, - channel->name); - if (ret) { - goto end; + if (maps_node) { + /* create all maps */ + for (node = xmlFirstElementChild(maps_node); node; + node = xmlNextElementSibling(node)) { + ret = process_map_node(node, handle); + if (ret) { + goto end; + } } - - lttng_channel_destroy(channel); } - channel = NULL; /* get the trackers node */ for (node = xmlFirstElementChild(domain_node); node; node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, - config_element_trackers)) { + config_element_process_attr_trackers) || + !strcmp((const char *) node->name, + config_element_trackers_legacy)) { + if (trackers_node) { + ERR("Only one instance of `%s` or `%s` is allowed in a session configuration", + config_element_process_attr_trackers, + config_element_trackers_legacy); + ret = -1; + goto end; + } trackers_node = node; break; } @@ -2974,55 +3451,62 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) for (node = xmlFirstElementChild(trackers_node); node; node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, - config_element_pid_tracker)) { + config_element_process_attr_tracker_pid)) { pid_tracker_node = node; ret = process_id_tracker_node(pid_tracker_node, handle, - LTTNG_TRACKER_PID); + LTTNG_PROCESS_ATTR_PROCESS_ID); if (ret) { goto end; } } if (!strcmp((const char *) node->name, - config_element_vpid_tracker)) { + config_element_process_attr_tracker_vpid)) { vpid_tracker_node = node; ret = process_id_tracker_node(vpid_tracker_node, handle, - LTTNG_TRACKER_VPID); + LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID); if (ret) { goto end; } } if (!strcmp((const char *) node->name, - config_element_uid_tracker)) { + config_element_process_attr_tracker_uid)) { uid_tracker_node = node; ret = process_id_tracker_node(uid_tracker_node, handle, - LTTNG_TRACKER_UID); + LTTNG_PROCESS_ATTR_USER_ID); if (ret) { goto end; } } if (!strcmp((const char *) node->name, - config_element_vuid_tracker)) { + config_element_process_attr_tracker_vuid)) { vuid_tracker_node = node; ret = process_id_tracker_node(vuid_tracker_node, handle, - LTTNG_TRACKER_VUID); + LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID); if (ret) { goto end; } } if (!strcmp((const char *) node->name, - config_element_gid_tracker)) { + config_element_process_attr_tracker_gid)) { gid_tracker_node = node; ret = process_id_tracker_node(gid_tracker_node, handle, - LTTNG_TRACKER_GID); + LTTNG_PROCESS_ATTR_GROUP_ID); if (ret) { goto end; } } if (!strcmp((const char *) node->name, - config_element_vgid_tracker)) { + config_element_process_attr_tracker_vgid)) { vgid_tracker_node = node; ret = process_id_tracker_node(vgid_tracker_node, handle, - LTTNG_TRACKER_VGID); + LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *) node->name, + config_element_pid_tracker_legacy)) { + ret = process_legacy_pid_tracker_node(node, handle); if (ret) { goto end; } @@ -3030,7 +3514,6 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) } end: - lttng_channel_destroy(channel); lttng_destroy_handle(handle); return ret; } @@ -3547,10 +4030,24 @@ int load_session_from_file(const char *path, const char *session_name, xmlNextElementSibling(session_node)) { ret = process_session_node(session_node, session_name, overwrite, overrides); - if (session_name && ret == 0) { - /* Target session found and loaded */ - session_found = 1; - break; + if (!session_name && ret) { + /* Loading error occurred. */ + goto end; + } else if (session_name) { + if (ret == 0) { + /* Target session found and loaded */ + session_found = 1; + break; + } else if (ret == -LTTNG_ERR_NO_SESSION) { + /* + * Ignore this error, we are looking for a + * specific session. + */ + ret = 0; + } else { + /* Loading error occurred. */ + goto end; + } } } end: @@ -3558,9 +4055,6 @@ end: if (!ret) { ret = session_found ? 0 : -LTTNG_ERR_LOAD_SESSION_NOENT; } - if (ret == -LTTNG_ERR_NO_SESSION) { - ret = -LTTNG_ERR_LOAD_SESSION_NOENT; - } return ret; }