X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fconfig%2Fsession-config.c;h=37c5ce383962e1b278e150a9dfac0a063998fd4e;hp=8fcb75230ad4309e4efddb428ab748c9b6721ab9;hb=d37ac3cdc4fe21f117edfb829db4d0eb7cf914a1;hpb=7b4aa11d71edf81f1e5a81a447b4e6b788551594 diff --git a/src/common/config/session-config.c b/src/common/config/session-config.c index 8fcb75230..37c5ce383 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 @@ -26,11 +17,13 @@ #include #include #include +#include #include #include #include #include +#include #include #include #include @@ -39,10 +32,14 @@ #include #include #include +#include +#include #include "session-config.h" #include "config-internal.h" +#define CONFIG_USERSPACE_PROBE_LOOKUP_METHOD_NAME_MAX_LEN 7 + struct handler_filter_args { const char* section; config_entry_handler_cb handler; @@ -55,6 +52,7 @@ struct session_config_validation_ctx { xmlSchemaValidCtxtPtr schema_validation_ctx; }; +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"; @@ -83,6 +81,18 @@ const char * const config_element_probe_attributes = "probe_attributes"; const char * const config_element_symbol_name = "symbol_name"; const char * const config_element_address = "address"; const char * const config_element_offset = "offset"; + +LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup = "lookup_method"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup_function_default = "DEFAULT"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup_function_elf = "ELF"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup_tracepoint_sdt = "SDT"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_location_binary_path = "binary_path"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_function_attributes = "userspace_probe_function_attributes"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_function_location_function_name = "function_name"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_tracepoint_attributes = "userspace_probe_tracepoint_attributes"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_tracepoint_location_provider_name = "provider_name"; +LTTNG_HIDDEN const char * const config_element_userspace_probe_tracepoint_location_probe_name = "probe_name"; + const char * const config_element_name = "name"; const char * const config_element_enabled = "enabled"; const char * const config_element_overwrite_mode = "overwrite_mode"; @@ -90,26 +100,30 @@ const char * const config_element_subbuf_size = "subbuffer_size"; const char * const config_element_num_subbuf = "subbuffer_count"; const char * const config_element_switch_timer_interval = "switch_timer_interval"; const char * const config_element_read_timer_interval = "read_timer_interval"; +LTTNG_HIDDEN const char * const config_element_monitor_timer_interval = "monitor_timer_interval"; +LTTNG_HIDDEN const char * const config_element_blocking_timeout = "blocking_timeout"; const char * const config_element_output = "output"; const char * const config_element_output_type = "output_type"; const char * const config_element_tracefile_size = "tracefile_size"; const char * const config_element_tracefile_count = "tracefile_count"; const char * const config_element_live_timer_interval = "live_timer_interval"; +LTTNG_HIDDEN const char * const config_element_discarded_events = "discarded_events"; +LTTNG_HIDDEN const char * const config_element_lost_packets = "lost_packets"; const char * const config_element_type = "type"; const char * const config_element_buffer_type = "buffer_type"; const char * const config_element_session = "session"; const char * const config_element_sessions = "sessions"; -const char * const config_element_context_perf = "perf"; -const char * const config_element_context_app = "app"; -const char * const config_element_context_app_provider_name = "provider_name"; -const char * const config_element_context_app_ctx_name = "ctx_name"; +LTTNG_HIDDEN const char * const config_element_context_perf = "perf"; +LTTNG_HIDDEN const char * const config_element_context_app = "app"; +LTTNG_HIDDEN const char * const config_element_context_app_provider_name = "provider_name"; +LTTNG_HIDDEN const char * const config_element_context_app_ctx_name = "ctx_name"; const char * const config_element_config = "config"; const char * const config_element_started = "started"; const char * const config_element_snapshot_mode = "snapshot_mode"; const char * const config_element_loglevel = "loglevel"; const char * const config_element_loglevel_type = "loglevel_type"; const char * const config_element_filter = "filter"; -const char * const config_element_filter_expression = "filter_expression"; +LTTNG_HIDDEN const char * const config_element_filter_expression = "filter_expression"; const char * const config_element_snapshot_outputs = "snapshot_outputs"; const char * const config_element_consumer_output = "consumer_output"; const char * const config_element_destination = "destination"; @@ -121,10 +135,37 @@ const char * const config_element_max_size = "max_size"; const char * const config_element_pid = "pid"; 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_trackers = "trackers"; -const char * const config_element_targets = "targets"; -const char * const config_element_target_pid = "pid_target"; + +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"; +LTTNG_HIDDEN const char * const config_element_rotation_schedule_periodic_time_us = "time_us"; +LTTNG_HIDDEN const char * const config_element_rotation_schedule_size_threshold = "size_threshold"; +LTTNG_HIDDEN const char * const config_element_rotation_schedule_size_threshold_bytes = "bytes"; const char * const config_domain_type_kernel = "KERNEL"; const char * const config_domain_type_ust = "UST"; @@ -149,6 +190,7 @@ const char * const config_loglevel_type_single = "SINGLE"; const char * const config_event_type_all = "ALL"; const char * const config_event_type_tracepoint = "TRACEPOINT"; const char * const config_event_type_probe = "PROBE"; +LTTNG_HIDDEN const char * const config_event_type_userspace_probe = "USERSPACE_PROBE"; const char * const config_event_type_function = "FUNCTION"; const char * const config_event_type_function_entry = "FUNCTION_ENTRY"; const char * const config_event_type_noop = "NOOP"; @@ -169,8 +211,41 @@ const char * const config_event_context_pthread_id = "PTHREAD_ID"; const char * const config_event_context_hostname = "HOSTNAME"; const char * const config_event_context_ip = "IP"; const char * const config_event_context_perf_thread_counter = "PERF_THREAD_COUNTER"; -const char * const config_event_context_app = "APP"; - +LTTNG_HIDDEN const char * const config_event_context_app = "APP"; +LTTNG_HIDDEN const char * const config_event_context_interruptible = "INTERRUPTIBLE"; +LTTNG_HIDDEN const char * const config_event_context_preemptible = "PREEMPTIBLE"; +LTTNG_HIDDEN const char * const config_event_context_need_reschedule = "NEED_RESCHEDULE"; +LTTNG_HIDDEN const char * const config_event_context_migratable = "MIGRATABLE"; +LTTNG_HIDDEN const char * const config_event_context_callstack_user= "CALLSTACK_USER"; +LTTNG_HIDDEN const char * const config_event_context_callstack_kernel = "CALLSTACK_KERNEL"; +LTTNG_HIDDEN const char * const config_event_context_cgroup_ns = "CGROUP_NS"; +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"; +LTTNG_HIDDEN const char * const config_event_context_euid = "EUID"; +LTTNG_HIDDEN const char * const config_event_context_suid = "SUID"; +LTTNG_HIDDEN const char * const config_event_context_gid = "GID"; +LTTNG_HIDDEN const char * const config_event_context_egid = "EGID"; +LTTNG_HIDDEN const char * const config_event_context_sgid = "SGID"; +LTTNG_HIDDEN const char * const config_event_context_vuid = "VUID"; +LTTNG_HIDDEN const char * const config_event_context_veuid = "VEUID"; +LTTNG_HIDDEN const char * const config_event_context_vsuid = "VSUID"; +LTTNG_HIDDEN const char * const config_event_context_vgid = "VGID"; +LTTNG_HIDDEN const char * const config_event_context_vegid = "VEGID"; +LTTNG_HIDDEN const char * const config_event_context_vsgid = "VSGID"; + +/* Deprecated symbols */ +const char * const config_element_perf; + +enum process_event_node_phase { + CREATION = 0, + ENABLE = 1, +}; struct consumer_output { int enabled; @@ -208,7 +283,7 @@ int config_get_section_entries(const char *override_path, const char *section, config_entry_handler_cb handler, void *user_data) { int ret = 0; - char *path; + const char *path; FILE *config_file = NULL; struct handler_filter_args filter = { section, handler, user_data }; @@ -455,7 +530,40 @@ int config_writer_open_element(struct config_writer *writer, ret = xmlTextWriterStartElement(writer->writer, encoded_element_name); xmlFree(encoded_element_name); end: - return ret > 0 ? 0 : ret; + return ret >= 0 ? 0 : ret; +} + +LTTNG_HIDDEN +int config_writer_write_attribute(struct config_writer *writer, + const char *name, const char *value) +{ + int ret; + xmlChar *encoded_name = NULL; + xmlChar *encoded_value = NULL; + + if (!writer || !writer->writer || !name || !name[0]) { + ret = -1; + goto end; + } + + encoded_name = encode_string(name); + if (!encoded_name) { + ret = -1; + goto end; + } + + encoded_value = encode_string(value); + if (!encoded_value) { + ret = -1; + goto end; + } + + ret = xmlTextWriterWriteAttribute(writer->writer, encoded_name, + encoded_value); +end: + xmlFree(encoded_name); + xmlFree(encoded_value); + return ret >= 0 ? 0 : ret; } LTTNG_HIDDEN @@ -470,7 +578,7 @@ int config_writer_close_element(struct config_writer *writer) ret = xmlTextWriterEndElement(writer->writer); end: - return ret > 0 ? 0 : ret; + return ret >= 0 ? 0 : ret; } LTTNG_HIDDEN @@ -495,7 +603,7 @@ int config_writer_write_element_unsigned_int(struct config_writer *writer, encoded_element_name, "%" PRIu64, value); xmlFree(encoded_element_name); end: - return ret > 0 ? 0 : ret; + return ret >= 0 ? 0 : ret; } LTTNG_HIDDEN @@ -520,7 +628,7 @@ int config_writer_write_element_signed_int(struct config_writer *writer, encoded_element_name, "%" PRIi64, value); xmlFree(encoded_element_name); end: - return ret > 0 ? 0 : ret; + return ret >= 0 ? 0 : ret; } LTTNG_HIDDEN @@ -562,7 +670,7 @@ int config_writer_write_element_string(struct config_writer *writer, end: xmlFree(encoded_element_name); xmlFree(encoded_value); - return ret > 0 ? 0 : ret; + return ret >= 0 ? 0 : ret; } static @@ -623,13 +731,12 @@ char *get_session_config_xsd_path() goto end; } - strncpy(xsd_path, base_path, max_path_len); + strcpy(xsd_path, base_path); if (xsd_path[base_path_len - 1] != '/') { xsd_path[base_path_len++] = '/'; } - strncpy(xsd_path + base_path_len, DEFAULT_SESSION_CONFIG_XSD_FILENAME, - max_path_len - base_path_len); + strcpy(xsd_path + base_path_len, DEFAULT_SESSION_CONFIG_XSD_FILENAME); end: return xsd_path; } @@ -861,10 +968,13 @@ int get_event_type(xmlChar *event_type) ret = LTTNG_EVENT_TRACEPOINT; } else if (!strcmp((char *) event_type, config_event_type_probe)) { ret = LTTNG_EVENT_PROBE; + } else if (!strcmp((char *) event_type, + config_event_type_userspace_probe)) { + ret = LTTNG_EVENT_USERSPACE_PROBE; } else if (!strcmp((char *) event_type, config_event_type_function)) { ret = LTTNG_EVENT_FUNCTION; } else if (!strcmp((char *) event_type, - config_event_type_function_entry)) { + config_event_type_function_entry)) { ret = LTTNG_EVENT_FUNCTION_ENTRY; } else if (!strcmp((char *) event_type, config_event_type_noop)) { ret = LTTNG_EVENT_NOOP; @@ -952,6 +1062,84 @@ int get_context_type(xmlChar *context_type) } else if (!strcmp((char *) context_type, config_event_context_ip)) { ret = LTTNG_EVENT_CONTEXT_IP; + } else if (!strcmp((char *) context_type, + config_event_context_interruptible)) { + ret = LTTNG_EVENT_CONTEXT_INTERRUPTIBLE; + } else if (!strcmp((char *) context_type, + config_event_context_preemptible)) { + ret = LTTNG_EVENT_CONTEXT_PREEMPTIBLE; + } else if (!strcmp((char *) context_type, + config_event_context_need_reschedule)) { + ret = LTTNG_EVENT_CONTEXT_NEED_RESCHEDULE; + } else if (!strcmp((char *) context_type, + config_event_context_migratable)) { + ret = LTTNG_EVENT_CONTEXT_MIGRATABLE; + } else if (!strcmp((char *) context_type, + config_event_context_callstack_user)) { + ret = LTTNG_EVENT_CONTEXT_CALLSTACK_USER; + } else if (!strcmp((char *) context_type, + config_event_context_callstack_kernel)) { + ret = LTTNG_EVENT_CONTEXT_CALLSTACK_KERNEL; + } else if (!strcmp((char *) context_type, + config_event_context_cgroup_ns)) { + ret = LTTNG_EVENT_CONTEXT_CGROUP_NS; + } else if (!strcmp((char *) context_type, + config_event_context_ipc_ns)) { + ret = LTTNG_EVENT_CONTEXT_IPC_NS; + } else if (!strcmp((char *) context_type, + config_event_context_mnt_ns)) { + ret = LTTNG_EVENT_CONTEXT_MNT_NS; + } else if (!strcmp((char *) context_type, + config_event_context_net_ns)) { + ret = LTTNG_EVENT_CONTEXT_NET_NS; + } 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; + } else if (!strcmp((char *) context_type, + config_event_context_uts_ns)) { + ret = LTTNG_EVENT_CONTEXT_UTS_NS; + } else if (!strcmp((char *) context_type, + config_event_context_uid)) { + ret = LTTNG_EVENT_CONTEXT_UID; + } else if (!strcmp((char *) context_type, + config_event_context_euid)) { + ret = LTTNG_EVENT_CONTEXT_EUID; + } else if (!strcmp((char *) context_type, + config_event_context_suid)) { + ret = LTTNG_EVENT_CONTEXT_SUID; + } else if (!strcmp((char *) context_type, + config_event_context_gid)) { + ret = LTTNG_EVENT_CONTEXT_GID; + } else if (!strcmp((char *) context_type, + config_event_context_egid)) { + ret = LTTNG_EVENT_CONTEXT_EGID; + } else if (!strcmp((char *) context_type, + config_event_context_sgid)) { + ret = LTTNG_EVENT_CONTEXT_SGID; + } else if (!strcmp((char *) context_type, + config_event_context_vuid)) { + ret = LTTNG_EVENT_CONTEXT_VUID; + } else if (!strcmp((char *) context_type, + config_event_context_veuid)) { + ret = LTTNG_EVENT_CONTEXT_VEUID; + } else if (!strcmp((char *) context_type, + config_event_context_vsuid)) { + ret = LTTNG_EVENT_CONTEXT_VSUID; + } else if (!strcmp((char *) context_type, + config_event_context_vgid)) { + ret = LTTNG_EVENT_CONTEXT_VGID; + } else if (!strcmp((char *) context_type, + config_event_context_vegid)) { + ret = LTTNG_EVENT_CONTEXT_VEGID; + } else if (!strcmp((char *) context_type, + config_event_context_vsgid)) { + ret = LTTNG_EVENT_CONTEXT_VSGID; } else { goto error; } @@ -1101,17 +1289,16 @@ end: } static -int create_session_net_output(const char *name, struct lttng_domain *domain, - const char *control_uri, const char *data_uri) +int create_session_net_output(const char *name, const char *control_uri, + const char *data_uri) { int ret; struct lttng_handle *handle; const char *uri = NULL; assert(name); - assert(domain); - handle = lttng_create_handle(name, domain); + handle = lttng_create_handle(name, NULL); if (!handle) { ret = -LTTNG_ERR_NOMEM; goto end; @@ -1130,7 +1317,8 @@ end: } static -int create_snapshot_session(const char *session_name, xmlNodePtr output_node) +int create_snapshot_session(const char *session_name, xmlNodePtr output_node, + const struct config_load_session_override_attr *overrides) { int ret; xmlNodePtr node = NULL; @@ -1160,6 +1348,9 @@ int create_snapshot_session(const char *session_name, xmlNodePtr output_node) uint64_t max_size = UINT64_MAX; struct consumer_output output = { 0 }; struct lttng_snapshot_output *snapshot_output = NULL; + const char *control_uri = NULL; + const char *data_uri = NULL; + const char *path = NULL; for (node = xmlFirstElementChild(snapshot_output_node); node; node = xmlNextElementSibling(node)) { @@ -1195,6 +1386,30 @@ int create_snapshot_session(const char *session_name, xmlNodePtr output_node) } } + control_uri = output.control_uri; + data_uri = output.data_uri; + path = output.path; + + if (overrides) { + if (overrides->path_url) { + path = overrides->path_url; + /* Control/data_uri are null */ + control_uri = NULL; + data_uri = NULL; + } else { + if (overrides->ctrl_url) { + control_uri = overrides->ctrl_url; + /* path is null */ + path = NULL; + } + if (overrides->data_url) { + data_uri = overrides->data_url; + /* path is null */ + path = NULL; + } + } + } + snapshot_output = lttng_snapshot_output_create(); if (!snapshot_output) { ret = -LTTNG_ERR_NOMEM; @@ -1211,23 +1426,23 @@ int create_snapshot_session(const char *session_name, xmlNodePtr output_node) goto error_snapshot_output; } - if (output.path) { - ret = lttng_snapshot_output_set_ctrl_url(output.path, + if (path) { + ret = lttng_snapshot_output_set_ctrl_url(path, snapshot_output); if (ret) { goto error_snapshot_output; } } else { - if (output.control_uri) { - ret = lttng_snapshot_output_set_ctrl_url(output.control_uri, + if (control_uri) { + ret = lttng_snapshot_output_set_ctrl_url(control_uri, snapshot_output); if (ret) { goto error_snapshot_output; } } - if (output.data_uri) { - ret = lttng_snapshot_output_set_data_url(output.data_uri, + if (data_uri) { + ret = lttng_snapshot_output_set_data_url(data_uri, snapshot_output); if (ret) { goto error_snapshot_output; @@ -1252,16 +1467,16 @@ end: static int create_session(const char *name, - struct lttng_domain *kernel_domain, - struct lttng_domain *ust_domain, - struct lttng_domain *jul_domain, - struct lttng_domain *log4j_domain, xmlNodePtr output_node, - uint64_t live_timer_interval) + uint64_t live_timer_interval, + const struct config_load_session_override_attr *overrides) { int ret; struct consumer_output output = { 0 }; xmlNodePtr consumer_output_node; + const char *control_uri = NULL; + const char *data_uri = NULL; + const char *path = NULL; assert(name); @@ -1286,18 +1501,38 @@ int create_session(const char *name, } } - if (live_timer_interval != UINT64_MAX && - !output.control_uri && !output.data_uri) { + control_uri = output.control_uri; + data_uri = output.data_uri; + path = output.path; + + /* Check for override and apply them */ + if (overrides) { + if (overrides->path_url) { + path = overrides->path_url; + /* control/data_uri are null */; + control_uri = NULL; + data_uri = NULL; + } else { + if (overrides->ctrl_url) { + control_uri = overrides->ctrl_url; + /* path is null */ + path = NULL; + } + if (overrides->data_url) { + data_uri = overrides->data_url; + /* path is null */ + path = NULL; + } + } + } + + + if (live_timer_interval != UINT64_MAX && !control_uri && !data_uri) { ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; } - if (output.control_uri || output.data_uri) { - int i; - struct lttng_domain *domain; - struct lttng_domain *domains[] = - { kernel_domain, ust_domain, jul_domain, log4j_domain }; - + if (control_uri || data_uri) { /* network destination */ if (live_timer_interval && live_timer_interval != UINT64_MAX) { /* @@ -1313,21 +1548,14 @@ int create_session(const char *name, goto end; } - for (i = 0; i < (sizeof(domains) / sizeof(domains[0])); i++) { - domain = domains[i]; - if (!domain) { - continue; - } - - ret = create_session_net_output(name, domain, output.control_uri, - output.data_uri); - if (ret) { - goto end; - } + ret = create_session_net_output(name, control_uri, data_uri); + if (ret) { + goto end; } + } else { /* either local output or no output */ - ret = lttng_create_session(name, output.path); + ret = lttng_create_session(name, path); if (ret) { goto end; } @@ -1338,6 +1566,178 @@ end: free(output.data_uri); return ret; } + +static +struct lttng_userspace_probe_location * +process_userspace_probe_function_attribute_node( + xmlNodePtr attribute_node) +{ + xmlNodePtr function_attribute_node; + char *function_name = NULL, *binary_path = NULL; + struct lttng_userspace_probe_location *location = NULL; + struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL; + + /* + * Process userspace probe location function attributes. The order of + * the fields are not guaranteed so we need to iterate over all fields + * and check at the end if everything we need for this location type is + * there. + */ + for (function_attribute_node = + xmlFirstElementChild(attribute_node); + function_attribute_node; + function_attribute_node = xmlNextElementSibling( + function_attribute_node)) { + /* Handle function name, binary path and lookup method. */ + if (!strcmp((const char *) function_attribute_node->name, + config_element_userspace_probe_function_location_function_name)) { + function_name = (char *) xmlNodeGetContent(function_attribute_node); + if (!function_name) { + goto error; + } + } else if (!strcmp((const char *) function_attribute_node->name, + config_element_userspace_probe_location_binary_path)) { + binary_path = (char *) xmlNodeGetContent(function_attribute_node); + if (!binary_path) { + goto error; + } + } else if (!strcmp((const char *) function_attribute_node->name, + config_element_userspace_probe_lookup)) { + char *lookup_method_name; + + lookup_method_name = (char *) xmlNodeGetContent( + function_attribute_node); + if (!lookup_method_name) { + goto error; + } + + /* + * function_default lookup method defaults to + * function_elf lookup method at the moment. + */ + if (!strcmp(lookup_method_name, config_element_userspace_probe_lookup_function_elf) + || !strcmp(lookup_method_name, config_element_userspace_probe_lookup_function_default)) { + lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create(); + if (!lookup_method) { + PERROR("Error creating function default/ELF lookup method"); + } + } else { + WARN("Unknown function lookup method"); + } + + free(lookup_method_name); + if (!lookup_method) { + goto error; + } + } else { + goto error; + } + + /* Check if all the necessary fields were found. */ + if (binary_path && function_name && lookup_method) { + /* Ownership of lookup_method is transferred. */ + location = + lttng_userspace_probe_location_function_create( + binary_path, function_name, + lookup_method); + lookup_method = NULL; + goto error; + } + } +error: + lttng_userspace_probe_location_lookup_method_destroy(lookup_method); + free(binary_path); + free(function_name); + return location; +} + +static +struct lttng_userspace_probe_location * +process_userspace_probe_tracepoint_attribute_node( + xmlNodePtr attribute_node) +{ + xmlNodePtr tracepoint_attribute_node; + char *probe_name = NULL, *provider_name = NULL, *binary_path = NULL; + struct lttng_userspace_probe_location *location = NULL; + struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL; + + /* + * Process userspace probe location tracepoint attributes. The order of + * the fields are not guaranteed so we need to iterate over all fields + * and check at the end if everything we need for this location type is + * there. + */ + for (tracepoint_attribute_node = + xmlFirstElementChild(attribute_node); tracepoint_attribute_node; + tracepoint_attribute_node = xmlNextElementSibling( + tracepoint_attribute_node)) { + if (!strcmp((const char *) tracepoint_attribute_node->name, + config_element_userspace_probe_tracepoint_location_probe_name)) { + probe_name = (char *) xmlNodeGetContent(tracepoint_attribute_node); + if (!probe_name) { + goto error; + } + } else if (!strcmp((const char *) tracepoint_attribute_node->name, + config_element_userspace_probe_tracepoint_location_provider_name)) { + provider_name = (char *) xmlNodeGetContent(tracepoint_attribute_node); + if (!provider_name) { + goto error; + } + } else if (!strcmp((const char *) tracepoint_attribute_node->name, + config_element_userspace_probe_location_binary_path)) { + binary_path = (char *) xmlNodeGetContent(tracepoint_attribute_node); + if (!binary_path) { + goto error; + } + } else if (!strcmp((const char *) tracepoint_attribute_node->name, + config_element_userspace_probe_lookup)) { + char *lookup_method_name; + + lookup_method_name = (char *) xmlNodeGetContent( + tracepoint_attribute_node); + if (!lookup_method_name) { + goto error; + } + + if (!strcmp(lookup_method_name, + config_element_userspace_probe_lookup_tracepoint_sdt)) { + lookup_method = + lttng_userspace_probe_location_lookup_method_tracepoint_sdt_create(); + if (!lookup_method) { + PERROR("Error creating tracepoint SDT lookup method"); + } + } else { + WARN("Unknown tracepoint lookup method"); + } + + free(lookup_method_name); + if (!lookup_method) { + goto error; + } + } else { + WARN("Unknown tracepoint attribute"); + goto error; + } + + /* Check if all the necessary fields were found. */ + if (binary_path && provider_name && probe_name && lookup_method) { + /* Ownership of lookup_method is transferred. */ + location = + lttng_userspace_probe_location_tracepoint_create( + binary_path, provider_name, + probe_name, lookup_method); + lookup_method = NULL; + goto error; + } + } +error: + lttng_userspace_probe_location_lookup_method_destroy(lookup_method); + free(binary_path); + free(provider_name); + free(probe_name); + return location; +} + static int process_probe_attribute_node(xmlNodePtr probe_attribute_node, struct lttng_event_probe_attr *attr) @@ -1390,7 +1790,6 @@ int process_probe_attribute_node(xmlNodePtr probe_attribute_node, } else if (!strcmp((const char *) probe_attribute_node->name, config_element_symbol_name)) { xmlChar *content; - size_t name_len; /* symbol_name */ content = xmlNodeGetContent(probe_attribute_node); @@ -1399,15 +1798,18 @@ int process_probe_attribute_node(xmlNodePtr probe_attribute_node, goto end; } - name_len = strlen((char *) content); - if (name_len >= LTTNG_SYMBOL_NAME_LEN) { - WARN("symbol_name too long."); + ret = lttng_strncpy(attr->symbol_name, + (const char *) content, + LTTNG_SYMBOL_NAME_LEN); + if (ret == -1) { + ERR("symbol name \"%s\"'s length (%zu) exceeds the maximal permitted length (%d) in session configuration", + (const char *) content, + strlen((const char *) content), + LTTNG_SYMBOL_NAME_LEN); ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; free(content); goto end; } - - strncpy(attr->symbol_name, (const char *) content, name_len); free(content); } ret = 0; @@ -1417,11 +1819,11 @@ end: static int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, - const char *channel_name) + const char *channel_name, const enum process_event_node_phase phase) { - int ret, i; + int ret = 0, i; xmlNodePtr node; - struct lttng_event event; + struct lttng_event *event; char **exclusions = NULL; unsigned long exclusion_count = 0; char *filter_expression = NULL; @@ -1430,23 +1832,27 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, assert(handle); assert(channel_name); - memset(&event, 0, sizeof(event)); + event = lttng_event_create(); + if (!event) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } /* Initialize default log level which varies by domain */ switch (handle->domain.type) { case LTTNG_DOMAIN_JUL: - event.loglevel = LTTNG_LOGLEVEL_JUL_ALL; + event->loglevel = LTTNG_LOGLEVEL_JUL_ALL; break; case LTTNG_DOMAIN_LOG4J: - event.loglevel = LTTNG_LOGLEVEL_LOG4J_ALL; + event->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL; break; case LTTNG_DOMAIN_PYTHON: - event.loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG; + event->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG; break; case LTTNG_DOMAIN_UST: case LTTNG_DOMAIN_KERNEL: - event.loglevel = LTTNG_LOGLEVEL_DEBUG; + event->loglevel = LTTNG_LOGLEVEL_DEBUG; break; default: assert(0); @@ -1456,7 +1862,6 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, config_element_name)) { xmlChar *content; - size_t name_len; /* name */ content = xmlNodeGetContent(node); @@ -1465,15 +1870,18 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - name_len = strlen((char *) content); - if (name_len >= LTTNG_SYMBOL_NAME_LEN) { - WARN("Channel name too long."); + ret = lttng_strncpy(event->name, + (const char *) content, + LTTNG_SYMBOL_NAME_LEN); + if (ret == -1) { + WARN("Event \"%s\"'s name length (%zu) exceeds the maximal permitted length (%d) in session configuration", + (const char *) content, + strlen((const char *) content), + LTTNG_SYMBOL_NAME_LEN); ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; free(content); goto end; } - - strncpy(event.name, (const char *) content, name_len); free(content); } else if (!strcmp((const char *) node->name, config_element_enabled)) { @@ -1485,7 +1893,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - ret = parse_bool(content, &event.enabled); + ret = parse_bool(content, &event->enabled); free(content); if (ret) { ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; @@ -1508,7 +1916,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - event.type = ret; + event->type = ret; } else if (!strcmp((const char *) node->name, config_element_loglevel_type)) { xmlChar *content = xmlNodeGetContent(node); @@ -1526,7 +1934,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - event.loglevel_type = ret; + event->loglevel_type = ret; } else if (!strcmp((const char *) node->name, config_element_loglevel)) { xmlChar *content; @@ -1552,7 +1960,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - event.loglevel = loglevel; + event->loglevel = loglevel; } else if (!strcmp((const char *) node->name, config_element_filter)) { xmlChar *content = @@ -1564,6 +1972,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } + free(filter_expression); filter_expression = strdup((char *) content); free(content); if (!filter_expression) { @@ -1616,7 +2025,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, exclusion_index++; } - event.exclusion = 1; + event->exclusion = 1; } else if (!strcmp((const char *) node->name, config_element_attributes)) { xmlNodePtr attribute_node = xmlFirstElementChild(node); @@ -1627,7 +2036,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - if (!strcmp((const char *) node->name, + if (!strcmp((const char *) attribute_node->name, config_element_probe_attributes)) { xmlNodePtr probe_attribute_node; @@ -1638,12 +2047,13 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, probe_attribute_node)) { ret = process_probe_attribute_node(probe_attribute_node, - &event.attr.probe); + &event->attr.probe); if (ret) { goto end; } } - } else { + } else if (!strcmp((const char *) attribute_node->name, + config_element_function_attributes)) { size_t sym_len; xmlChar *content; xmlNodePtr symbol_node = xmlFirstElementChild(attribute_node); @@ -1663,38 +2073,80 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - strncpy(event.attr.ftrace.symbol_name, (char *) content, - sym_len); + ret = lttng_strncpy( + event->attr.ftrace.symbol_name, + (char *) content, sym_len); + if (ret == -1) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + free(content); + goto end; + } free(content); + } else if (!strcmp((const char *) attribute_node->name, + config_element_userspace_probe_tracepoint_attributes)) { + struct lttng_userspace_probe_location *location; + + location = process_userspace_probe_tracepoint_attribute_node(attribute_node); + if (!location) { + WARN("Error processing userspace probe tracepoint attribute"); + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + ret = lttng_event_set_userspace_probe_location( + event, location); + if (ret) { + WARN("Error setting userspace probe location field"); + lttng_userspace_probe_location_destroy( + location); + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + } else if (!strcmp((const char *) attribute_node->name, + config_element_userspace_probe_function_attributes)) { + struct lttng_userspace_probe_location *location; + + location = + process_userspace_probe_function_attribute_node( + attribute_node); + if (!location) { + WARN("Error processing userspace probe function attribute"); + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + ret = lttng_event_set_userspace_probe_location( + event, location); + if (ret) { + WARN("Error setting userspace probe location field"); + lttng_userspace_probe_location_destroy( + location); + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + } else { + /* Unknown event attribute. */ + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; } } } - ret = lttng_enable_event_with_exclusions(handle, &event, channel_name, - filter_expression, exclusion_count, exclusions); - if (ret) { - goto end; - } - - if (!event.enabled) { - /* - * Note that we should use lttng_disable_event_ext() (2.6+) to - * eliminate the risk of clashing on events of the same - * name (with different event types and loglevels). - * - * Unfortunately, lttng_disable_event_ext() only performs a - * match on the name and event type and errors out if any other - * event attribute is not set to its default value. - * - * This will disable all events that match this name. - */ - ret = lttng_disable_event(handle, event.name, channel_name); + if ((event->enabled && phase == ENABLE) || phase == CREATION) { + ret = lttng_enable_event_with_exclusions(handle, event, channel_name, + filter_expression, exclusion_count, exclusions); + if (ret < 0) { + WARN("Enabling event (name:%s) on load failed.", event->name); + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } } + ret = 0; end: for (i = 0; i < exclusion_count; i++) { free(exclusions[i]); } + lttng_event_destroy(event); free(exclusions); free(filter_expression); return ret; @@ -1705,6 +2157,7 @@ int process_events_node(xmlNodePtr events_node, struct lttng_handle *handle, const char *channel_name) { int ret = 0; + struct lttng_event event; xmlNodePtr node; assert(events_node); @@ -1713,11 +2166,33 @@ int process_events_node(xmlNodePtr events_node, struct lttng_handle *handle, for (node = xmlFirstElementChild(events_node); node; node = xmlNextElementSibling(node)) { - ret = process_event_node(node, handle, channel_name); + ret = process_event_node(node, handle, channel_name, CREATION); + if (ret) { + goto end; + } + } + + /* + * Disable all events to enable only the necessary events. + * Limitations regarding lttng_disable_events and tuple descriptor + * force this approach. + */ + memset(&event, 0, sizeof(event)); + event.loglevel = -1; + event.type = LTTNG_EVENT_ALL; + ret = lttng_disable_event_ext(handle, &event, channel_name, NULL); + if (ret) { + goto end; + } + + for (node = xmlFirstElementChild(events_node); node; + node = xmlNextElementSibling(node)) { + ret = process_event_node(node, handle, channel_name, ENABLE); if (ret) { goto end; } } + end: return ret; } @@ -1736,7 +2211,6 @@ int process_channel_attr_node(xmlNodePtr attr_node, if (!strcmp((const char *) attr_node->name, config_element_name)) { xmlChar *content; - size_t name_len; /* name */ content = xmlNodeGetContent(attr_node); @@ -1745,15 +2219,18 @@ int process_channel_attr_node(xmlNodePtr attr_node, goto end; } - name_len = strlen((char *) content); - if (name_len >= LTTNG_SYMBOL_NAME_LEN) { - WARN("Channel name too long."); + ret = lttng_strncpy(channel->name, + (const char *) content, + LTTNG_SYMBOL_NAME_LEN); + if (ret == -1) { + WARN("Channel \"%s\"'s name length (%zu) exceeds the maximal permitted length (%d) in session configuration", + (const char *) content, + strlen((const char *) content), + LTTNG_SYMBOL_NAME_LEN); ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; free(content); goto end; } - - strncpy(channel->name, (const char *) content, name_len); free(content); } else if (!strcmp((const char *) attr_node->name, config_element_enabled)) { @@ -1962,6 +2439,56 @@ int process_channel_attr_node(xmlNodePtr attr_node, channel->attr.live_timer_interval = live_timer_interval; + } else if (!strcmp((const char *) attr_node->name, + config_element_monitor_timer_interval)) { + xmlChar *content; + uint64_t monitor_timer_interval = 0; + + /* monitor_timer_interval */ + content = xmlNodeGetContent(attr_node); + if (!content) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + ret = parse_uint(content, &monitor_timer_interval); + free(content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + ret = lttng_channel_set_monitor_timer_interval(channel, + monitor_timer_interval); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + } else if (!strcmp((const char *) attr_node->name, + config_element_blocking_timeout)) { + xmlChar *content; + int64_t blocking_timeout = 0; + + /* blocking_timeout */ + content = xmlNodeGetContent(attr_node); + if (!content) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + ret = parse_int(content, &blocking_timeout); + free(content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + ret = lttng_channel_set_blocking_timeout(channel, + blocking_timeout); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } } else if (!strcmp((const char *) attr_node->name, config_element_events)) { /* events */ @@ -2071,7 +2598,6 @@ int process_context_node(xmlNodePtr context_node, } else if (!strcmp((const char *) perf_attr_node->name, config_element_name)) { xmlChar *content; - size_t name_len; /* name */ content = xmlNodeGetContent(perf_attr_node); @@ -2080,16 +2606,18 @@ int process_context_node(xmlNodePtr context_node, goto end; } - name_len = strlen((char *) content); - if (name_len >= LTTNG_SYMBOL_NAME_LEN) { - WARN("perf context name too long."); + ret = lttng_strncpy(context.u.perf_counter.name, + (const char *) content, + LTTNG_SYMBOL_NAME_LEN); + if (ret == -1) { + WARN("Perf counter \"%s\"'s name length (%zu) exceeds the maximal permitted length (%d) in session configuration", + (const char *) content, + strlen((const char *) content), + LTTNG_SYMBOL_NAME_LEN); ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; free(content); goto end; } - - strncpy(context.u.perf_counter.name, (const char *) content, - name_len); free(content); } } @@ -2150,78 +2678,381 @@ end: return ret; } -static -int process_pid_tracker_node(xmlNodePtr pid_tracker_node, - struct lttng_handle *handle) +static int get_tracker_elements(enum lttng_process_attr process_attr, + const char **element_id_tracker, + const char **element_value_type, + const char **element_value, + const char **element_value_alias, + const char **element_name) { - int ret = 0, child; - xmlNodePtr targets_node = NULL; - xmlNodePtr node; + int ret = 0; + + 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_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_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_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_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_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: + ret = LTTNG_ERR_INVALID; + } + return ret; +} + +static int process_legacy_pid_tracker_node( + xmlNodePtr trackers_node, struct lttng_handle *handle) +{ + int ret = 0, child_count; + xmlNodePtr targets_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; + 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(pid_tracker_node); - /* get the targets node */ - for (node = xmlFirstElementChild(pid_tracker_node); node; - node = xmlNextElementSibling(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 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; goto end; } - /* Go through all pid_target node */ - child = xmlChildElementCount(targets_node); - if (child == 0) { - /* The session is explicitly set to target nothing. */ - ret = lttng_untrack_pid(handle, -1); - if (ret) { - goto end; - } + /* Go through all id target node */ + 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; } + + /* Add all tracked values. */ for (node = xmlFirstElementChild(targets_node); node; node = xmlNextElementSibling(node)) { xmlNodePtr pid_target_node = node; - /* get pid node and track it */ + /* get pid_target node and track it */ for (node = xmlFirstElementChild(pid_target_node); node; - node = xmlNextElementSibling(node)) { + node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, - config_element_pid)) { - int64_t pid; - xmlChar *content = NULL; + config_element_tracker_pid_legacy)) { + int64_t id; + xmlChar *content = xmlNodeGetContent(node); - content = xmlNodeGetContent(node); if (!content) { ret = LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; } - ret = parse_int(content, &pid); + ret = parse_int(content, &id); free(content); if (ret) { ret = LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; } - ret = lttng_track_pid(handle, (int) pid); - 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; + 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; } 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; + + /* get id node and track it */ + for (node = xmlFirstElementChild(id_target_node); node; + node = xmlNextElementSibling(node)) { + if (!strcmp((const char *) node->name, element_id) || + (element_id_alias && + !strcmp((const char *) node->name, + element_id_alias))) { + 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; + 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; + } + } else if (element_name && + !strcmp((const char *) node->name, + element_name)) { + xmlChar *content = xmlNodeGetContent(node); + + if (!content) { + ret = LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + 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_domain_node(xmlNodePtr domain_node, const char *session_name) @@ -2229,9 +3060,15 @@ 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 trackers_node = NULL; xmlNodePtr pid_tracker_node = NULL; + xmlNodePtr vpid_tracker_node = NULL; + xmlNodePtr uid_tracker_node = NULL; + xmlNodePtr vuid_tracker_node = NULL; + xmlNodePtr gid_tracker_node = NULL; + xmlNodePtr vgid_tracker_node = NULL; xmlNodePtr node; assert(session_name); @@ -2264,46 +3101,84 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) /* create all channels */ for (node = xmlFirstElementChild(channels_node); node; node = xmlNextElementSibling(node)) { - struct lttng_channel channel; + const enum lttng_domain_type original_domain = domain.type; xmlNodePtr contexts_node = NULL; xmlNodePtr events_node = NULL; xmlNodePtr channel_attr_node; - memset(&channel, 0, sizeof(channel)); - lttng_channel_set_default_attr(&domain, &channel.attr); + /* + * 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(node); channel_attr_node; channel_attr_node = xmlNextElementSibling(channel_attr_node)) { ret = process_channel_attr_node(channel_attr_node, - &channel, &contexts_node, &events_node); + channel, &contexts_node, &events_node); if (ret) { goto end; } } - ret = lttng_enable_channel(handle, &channel); + ret = lttng_enable_channel(handle, channel); if (ret < 0) { goto end; } - ret = process_events_node(events_node, handle, channel.name); + /* 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); + channel->name); 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; } @@ -2315,35 +3190,237 @@ 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)) { + if (!strcmp((const char *) node->name, + config_element_process_attr_tracker_pid)) { pid_tracker_node = node; - ret = process_pid_tracker_node(pid_tracker_node, handle); + ret = process_id_tracker_node(pid_tracker_node, handle, + LTTNG_PROCESS_ATTR_PROCESS_ID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *) node->name, + config_element_process_attr_tracker_vpid)) { + vpid_tracker_node = node; + ret = process_id_tracker_node(vpid_tracker_node, handle, + LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *) node->name, + config_element_process_attr_tracker_uid)) { + uid_tracker_node = node; + ret = process_id_tracker_node(uid_tracker_node, handle, + LTTNG_PROCESS_ATTR_USER_ID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *) node->name, + config_element_process_attr_tracker_vuid)) { + vuid_tracker_node = node; + ret = process_id_tracker_node(vuid_tracker_node, handle, + LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *) node->name, + config_element_process_attr_tracker_gid)) { + gid_tracker_node = node; + ret = process_id_tracker_node(gid_tracker_node, handle, + LTTNG_PROCESS_ATTR_GROUP_ID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *) node->name, + config_element_process_attr_tracker_vgid)) { + vgid_tracker_node = node; + ret = process_id_tracker_node(vgid_tracker_node, handle, + 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; } } } - if (!pid_tracker_node) { - lttng_track_pid(handle, -1); +end: + lttng_channel_destroy(channel); + lttng_destroy_handle(handle); + return ret; +} + +static +int add_periodic_rotation(const char *name, uint64_t time_us) +{ + int ret; + enum lttng_rotation_status status; + struct lttng_rotation_schedule *periodic = + lttng_rotation_schedule_periodic_create(); + + if (!periodic) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + + status = lttng_rotation_schedule_periodic_set_period(periodic, + time_us); + if (status != LTTNG_ROTATION_STATUS_OK) { + ret = -LTTNG_ERR_INVALID; + goto error; + } + + status = lttng_session_add_rotation_schedule(name, periodic); + switch (status) { + case LTTNG_ROTATION_STATUS_OK: + ret = 0; + break; + case LTTNG_ROTATION_STATUS_SCHEDULE_ALREADY_SET: + case LTTNG_ROTATION_STATUS_INVALID: + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + break; + default: + ret = -LTTNG_ERR_UNK; + break; + } +error: + lttng_rotation_schedule_destroy(periodic); + return ret; +} + +static +int add_size_rotation(const char *name, uint64_t size_bytes) +{ + int ret; + enum lttng_rotation_status status; + struct lttng_rotation_schedule *size = + lttng_rotation_schedule_size_threshold_create(); + + if (!size) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + + status = lttng_rotation_schedule_size_threshold_set_threshold(size, + size_bytes); + if (status != LTTNG_ROTATION_STATUS_OK) { + ret = -LTTNG_ERR_INVALID; + goto error; + } + + status = lttng_session_add_rotation_schedule(name, size); + switch (status) { + case LTTNG_ROTATION_STATUS_OK: + ret = 0; + break; + case LTTNG_ROTATION_STATUS_SCHEDULE_ALREADY_SET: + case LTTNG_ROTATION_STATUS_INVALID: + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + break; + default: + ret = -LTTNG_ERR_UNK; + break; + } +error: + lttng_rotation_schedule_destroy(size); + return ret; +} + +static +int process_session_rotation_schedules_node( + xmlNodePtr schedules_node, + uint64_t *rotation_timer_interval, + uint64_t *rotation_size) +{ + int ret = 0; + xmlNodePtr child; + + for (child = xmlFirstElementChild(schedules_node); + child; + child = xmlNextElementSibling(child)) { + if (!strcmp((const char *) child->name, + config_element_rotation_schedule_periodic)) { + xmlChar *content; + xmlNodePtr time_us_node; + + /* periodic rotation schedule */ + time_us_node = xmlFirstElementChild(child); + if (!time_us_node || + strcmp((const char *) time_us_node->name, + config_element_rotation_schedule_periodic_time_us)) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + /* time_us child */ + content = xmlNodeGetContent(time_us_node); + if (!content) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + ret = parse_uint(content, rotation_timer_interval); + free(content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + } else if (!strcmp((const char *) child->name, + config_element_rotation_schedule_size_threshold)) { + xmlChar *content; + xmlNodePtr bytes_node; + + /* size_threshold rotation schedule */ + bytes_node = xmlFirstElementChild(child); + if (!bytes_node || + strcmp((const char *) bytes_node->name, + config_element_rotation_schedule_size_threshold_bytes)) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + + /* bytes child */ + content = xmlNodeGetContent(bytes_node); + if (!content) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + ret = parse_uint(content, rotation_size); + free(content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + } } end: - lttng_destroy_handle(handle); return ret; } static int process_session_node(xmlNodePtr session_node, const char *session_name, - int override) + int overwrite, + const struct config_load_session_override_attr *overrides) { int ret, started = -1, snapshot_mode = -1; - uint64_t live_timer_interval = UINT64_MAX; + uint64_t live_timer_interval = UINT64_MAX, + rotation_timer_interval = 0, + rotation_size = 0; xmlChar *name = NULL; xmlChar *shm_path = NULL; xmlNodePtr domains_node = NULL; xmlNodePtr output_node = NULL; xmlNodePtr node; + xmlNodePtr attributes_child; struct lttng_domain *kernel_domain = NULL; struct lttng_domain *ust_domain = NULL; struct lttng_domain *jul_domain = NULL; @@ -2396,40 +3473,55 @@ int process_session_node(xmlNodePtr session_node, const char *session_name, shm_path = node_content; } else { - /* attributes, snapshot_mode or live_timer_interval */ - xmlNodePtr attributes_child = - xmlFirstElementChild(node); - - if (!strcmp((const char *) attributes_child->name, - config_element_snapshot_mode)) { - /* snapshot_mode */ - xmlChar *snapshot_mode_content = - xmlNodeGetContent(attributes_child); - if (!snapshot_mode_content) { - ret = -LTTNG_ERR_NOMEM; - goto error; - } + /* + * attributes, snapshot_mode, live_timer_interval, rotation_size, + * rotation_timer_interval. + */ + for (attributes_child = xmlFirstElementChild(node); attributes_child; + attributes_child = xmlNextElementSibling(attributes_child)) { + if (!strcmp((const char *) attributes_child->name, + config_element_snapshot_mode)) { + /* snapshot_mode */ + xmlChar *snapshot_mode_content = + xmlNodeGetContent(attributes_child); + if (!snapshot_mode_content) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } - ret = parse_bool(snapshot_mode_content, &snapshot_mode); - free(snapshot_mode_content); - if (ret) { - ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; - goto error; - } - } else { - /* live_timer_interval */ - xmlChar *timer_interval_content = - xmlNodeGetContent(attributes_child); - if (!timer_interval_content) { - ret = -LTTNG_ERR_NOMEM; - goto error; - } + ret = parse_bool(snapshot_mode_content, &snapshot_mode); + free(snapshot_mode_content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto error; + } + } else if (!strcmp((const char *) attributes_child->name, + config_element_live_timer_interval)) { + /* live_timer_interval */ + xmlChar *timer_interval_content = + xmlNodeGetContent(attributes_child); + if (!timer_interval_content) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + + ret = parse_uint(timer_interval_content, &live_timer_interval); + free(timer_interval_content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto error; + } + } else if (!strcmp((const char *) attributes_child->name, + config_element_rotation_schedules)) { + ret = process_session_rotation_schedules_node( + attributes_child, + &rotation_timer_interval, + &rotation_size); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto error; + } - ret = parse_uint(timer_interval_content, &live_timer_interval); - free(timer_interval_content); - if (ret) { - ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; - goto error; } } } @@ -2510,7 +3602,22 @@ domain_init_error: goto error; } - if (override) { + /* Apply overrides */ + if (overrides) { + if (overrides->session_name) { + xmlChar *name_override = xmlStrdup(BAD_CAST(overrides->session_name)); + if (!name_override) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + + /* Overrides the session name to the provided name */ + xmlFree(name); + name = name_override; + } + } + + if (overwrite) { /* Destroy session if it exists */ ret = lttng_destroy_session((const char *) name); if (ret && ret != -LTTNG_ERR_SESS_NOT_FOUND) { @@ -2521,17 +3628,16 @@ domain_init_error: /* Create session type depending on output type */ if (snapshot_mode && snapshot_mode != -1) { - ret = create_snapshot_session((const char *) name, output_node); + ret = create_snapshot_session((const char *) name, output_node, + overrides); } else if (live_timer_interval && live_timer_interval != UINT64_MAX) { - ret = create_session((const char *) name, kernel_domain, - ust_domain, jul_domain, log4j_domain, - output_node, live_timer_interval); + ret = create_session((const char *) name, + output_node, live_timer_interval, overrides); } else { /* regular session */ - ret = create_session((const char *) name, kernel_domain, - ust_domain, jul_domain, log4j_domain, - output_node, UINT64_MAX); + ret = create_session((const char *) name, + output_node, UINT64_MAX, overrides); } if (ret) { goto error; @@ -2553,6 +3659,21 @@ domain_init_error: } } + if (rotation_timer_interval) { + ret = add_periodic_rotation((const char *) name, + rotation_timer_interval); + if (ret < 0) { + goto error; + } + } + if (rotation_size) { + ret = add_size_rotation((const char *) name, + rotation_size); + if (ret < 0) { + goto error; + } + } + if (started) { ret = lttng_start_tracing((const char *) name); if (ret) { @@ -2605,7 +3726,8 @@ valid: static int load_session_from_file(const char *path, const char *session_name, - struct session_config_validation_ctx *validation_ctx, int override) + struct session_config_validation_ctx *validation_ctx, int overwrite, + const struct config_load_session_override_attr *overrides) { int ret, session_found = !session_name; xmlDocPtr doc = NULL; @@ -2640,6 +3762,7 @@ int load_session_from_file(const char *path, const char *session_name, sessions_node = xmlDocGetRootElement(doc); if (!sessions_node) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; } @@ -2647,11 +3770,25 @@ int load_session_from_file(const char *path, const char *session_name, session_node; session_node = xmlNextElementSibling(session_node)) { ret = process_session_node(session_node, - session_name, override); - if (session_name && ret == 0) { - /* Target session found and loaded */ - session_found = 1; - break; + session_name, overwrite, overrides); + 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: @@ -2662,32 +3799,26 @@ end: return ret; } -/* Allocate dirent as recommended by READDIR(3), NOTES on readdir_r */ -static -struct dirent *alloc_dirent(const char *path) -{ - size_t len; - long name_max; - struct dirent *entry; - - name_max = pathconf(path, _PC_NAME_MAX); - if (name_max == -1) { - name_max = PATH_MAX; - } - len = offsetof(struct dirent, d_name) + name_max + 1; - entry = zmalloc(len); - return entry; -} - static int load_session_from_path(const char *path, const char *session_name, - struct session_config_validation_ctx *validation_ctx, int override) + struct session_config_validation_ctx *validation_ctx, int overwrite, + const struct config_load_session_override_attr *overrides) { int ret, session_found = !session_name; DIR *directory = NULL; + struct lttng_dynamic_buffer file_path; + size_t path_len; assert(path); assert(validation_ctx); + path_len = strlen(path); + lttng_dynamic_buffer_init(&file_path); + if (path_len >= LTTNG_PATH_MAX) { + ERR("Session configuration load path \"%s\" length (%zu) exceeds the maximal length allowed (%d)", + path, path_len, LTTNG_PATH_MAX); + ret = -LTTNG_ERR_INVALID; + goto end; + } directory = opendir(path); if (!directory) { @@ -2704,88 +3835,130 @@ int load_session_from_path(const char *path, const char *session_name, } } if (directory) { - struct dirent *entry; - struct dirent *result; - char *file_path = NULL; - size_t path_len = strlen(path); + size_t file_path_root_len; - if (path_len >= PATH_MAX) { - ret = -LTTNG_ERR_INVALID; - goto end; - } - - entry = alloc_dirent(path); - if (!entry) { + ret = lttng_dynamic_buffer_set_capacity(&file_path, + LTTNG_PATH_MAX); + if (ret) { ret = -LTTNG_ERR_NOMEM; goto end; } - file_path = zmalloc(PATH_MAX); - if (!file_path) { + ret = lttng_dynamic_buffer_append(&file_path, path, path_len); + if (ret) { ret = -LTTNG_ERR_NOMEM; - free(entry); goto end; } - strncpy(file_path, path, path_len); - if (file_path[path_len - 1] != '/') { - file_path[path_len++] = '/'; + if (file_path.data[file_path.size - 1] != '/') { + ret = lttng_dynamic_buffer_append(&file_path, "/", 1); + if (ret) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } } + file_path_root_len = file_path.size; - ret = 0; /* Search for *.lttng files */ - while (!readdir_r(directory, entry, &result) && result) { - size_t file_name_len = strlen(result->d_name); + for (;;) { + size_t file_name_len; + struct dirent *result; + + /* + * When the end of the directory stream is reached, NULL + * is returned and errno is kept unchanged. When an + * error occurs, NULL is returned and errno is set + * accordingly. To distinguish between the two, set + * errno to zero before calling readdir(). + * + * On success, readdir() returns a pointer to a dirent + * structure. This structure may be statically + * allocated, do not attempt to free(3) it. + */ + errno = 0; + result = readdir(directory); + + /* Reached end of dir stream or error out. */ + if (!result) { + if (errno) { + PERROR("Failed to enumerate the contents of path \"%s\" while loading session, readdir returned", path); + ret = -LTTNG_ERR_LOAD_IO_FAIL; + goto end; + } + break; + } + + file_name_len = strlen(result->d_name); if (file_name_len <= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION)) { continue; } - if (path_len + file_name_len >= PATH_MAX) { + if (file_path.size + file_name_len >= LTTNG_PATH_MAX) { + WARN("Ignoring file \"%s\" since the path's length (%zu) would exceed the maximal permitted size (%d)", + result->d_name, + /* +1 to account for NULL terminator. */ + file_path.size + file_name_len + 1, + LTTNG_PATH_MAX); continue; } + /* Does the file end with .lttng? */ if (strcmp(DEFAULT_SESSION_CONFIG_FILE_EXTENSION, - result->d_name + file_name_len - sizeof( - DEFAULT_SESSION_CONFIG_FILE_EXTENSION) + 1)) { + result->d_name + file_name_len - sizeof( + DEFAULT_SESSION_CONFIG_FILE_EXTENSION) + 1)) { continue; } - strncpy(file_path + path_len, result->d_name, file_name_len); - file_path[path_len + file_name_len] = '\0'; + ret = lttng_dynamic_buffer_append(&file_path, result->d_name, + file_name_len + 1); + if (ret) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } - ret = load_session_from_file(file_path, session_name, - validation_ctx, override); - if (session_name && !ret) { + ret = load_session_from_file(file_path.data, session_name, + validation_ctx, overwrite, overrides); + if (session_name && + (!ret || ret != -LTTNG_ERR_LOAD_SESSION_NOENT)) { session_found = 1; break; } + if (ret && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) { + goto end; + } + /* + * Reset the buffer's size to the location of the + * path's trailing '/'. + */ + ret = lttng_dynamic_buffer_set_size(&file_path, + file_path_root_len); + if (ret) { + ret = -LTTNG_ERR_UNK; + goto end; + } } - - free(entry); - free(file_path); } else { ret = load_session_from_file(path, session_name, - validation_ctx, override); + validation_ctx, overwrite, overrides); if (ret) { goto end; - } else { - session_found = 1; } + session_found = 1; } + ret = 0; end: if (directory) { if (closedir(directory)) { PERROR("closedir"); } } - - if (!session_found) { + if (!ret && !session_found) { ret = -LTTNG_ERR_LOAD_SESSION_NOENT; } - + lttng_dynamic_buffer_reset(&file_path); return ret; } @@ -2809,7 +3982,6 @@ static int validate_path_creds(const char *path) if (errno != ENOENT) { PERROR("stat"); } - ret = -LTTNG_ERR_INVALID; goto valid; } @@ -2825,9 +3997,11 @@ invalid: LTTNG_HIDDEN int config_load_session(const char *path, const char *session_name, - int override, unsigned int autoload) + int overwrite, unsigned int autoload, + const struct config_load_session_override_attr *overrides) { int ret; + bool session_loaded = false; const char *path_ptr = NULL; struct session_config_validation_ctx validation_ctx = { 0 }; @@ -2837,7 +4011,7 @@ int config_load_session(const char *path, const char *session_name, } if (!path) { - char *home_path; + const char *home_path; const char *sys_path; /* Try home path */ @@ -2855,6 +4029,7 @@ int config_load_session(const char *path, const char *session_name, DEFAULT_SESSION_CONFIG_AUTOLOAD, home_path); if (ret < 0) { PERROR("snprintf session autoload home config path"); + ret = -LTTNG_ERR_INVALID; goto end; } @@ -2872,13 +4047,14 @@ int config_load_session(const char *path, const char *session_name, DEFAULT_SESSION_HOME_CONFIGPATH, home_path); if (ret < 0) { PERROR("snprintf session home config path"); + ret = -LTTNG_ERR_INVALID; goto end; } path_ptr = path; } if (path_ptr) { ret = load_session_from_path(path_ptr, session_name, - &validation_ctx, override); + &validation_ctx, overwrite, overrides); if (ret && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) { goto end; } @@ -2886,6 +4062,7 @@ int config_load_session(const char *path, const char *session_name, * Continue even if the session was found since we have to try * the system wide sessions. */ + session_loaded = true; } } @@ -2907,7 +4084,12 @@ int config_load_session(const char *path, const char *session_name, if (path_ptr) { ret = load_session_from_path(path_ptr, session_name, - &validation_ctx, override); + &validation_ctx, overwrite, overrides); + if (!ret) { + session_loaded = true; + } + } else { + ret = 0; } } else { ret = access(path, F_OK); @@ -2929,7 +4111,7 @@ int config_load_session(const char *path, const char *session_name, } ret = load_session_from_path(path, session_name, - &validation_ctx, override); + &validation_ctx, overwrite, overrides); } end: fini_session_config_validation_ctx(&validation_ctx); @@ -2940,5 +4122,16 @@ end: */ ret = 0; } + + if (session_loaded && ret == -LTTNG_ERR_LOAD_SESSION_NOENT) { + /* A matching session was found in one of the search paths. */ + ret = 0; + } return ret; } + +static +void __attribute__((destructor)) session_config_exit(void) +{ + xmlCleanupParser(); +}