X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fconfig%2Fsession-config.c;h=0d75a088d402e17076b53994fb6f6915b0d8f13c;hp=11e0dcc4ea8e24120aadb74da453ab17b6faf70e;hb=36d1687c718cc647604741cf21e1ffa0b3459429;hpb=28676a1d553d82f961ac83147097c53dd8a401d2 diff --git a/src/common/config/session-config.c b/src/common/config/session-config.c index 11e0dcc4e..0d75a088d 100644 --- a/src/common/config/session-config.c +++ b/src/common/config/session-config.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include @@ -39,6 +40,7 @@ #include #include #include +#include #include "session-config.h" #include "config-internal.h" @@ -90,26 +92,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"; @@ -126,6 +132,10 @@ 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_rotation_timer_interval = "rotation_schedule_timer_period"; +LTTNG_HIDDEN const char * const config_element_rotation_size = "rotation_schedule_size"; +LTTNG_HIDDEN const char * const config_element_rotation_schedule = "rotation_schedule"; + const char * const config_domain_type_kernel = "KERNEL"; const char * const config_domain_type_ust = "UST"; const char * const config_domain_type_jul = "JUL"; @@ -169,8 +179,19 @@ 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"; + +/* Deprecated symbols */ +const char * const config_element_perf; + +enum process_event_node_phase { + CREATION = 0, + ENABLE = 1, +}; struct consumer_output { int enabled; @@ -458,6 +479,39 @@ end: 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 int config_writer_close_element(struct config_writer *writer) { @@ -952,6 +1006,18 @@ 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 { goto error; } @@ -1101,17 +1167,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 +1195,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 +1226,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 +1264,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 +1304,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; @@ -1257,11 +1350,15 @@ int create_session(const char *name, 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 +1383,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 +1430,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; } @@ -1417,9 +1527,9 @@ 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; char **exclusions = NULL; @@ -1564,6 +1674,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) { @@ -1670,25 +1781,14 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, } } - 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; + } } end: for (i = 0; i < exclusion_count; i++) { @@ -1705,6 +1805,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 +1814,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; } @@ -1962,6 +2085,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 */ @@ -2222,13 +2395,13 @@ end: return ret; } - static 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; @@ -2264,40 +2437,69 @@ 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; @@ -2329,21 +2531,26 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) } end: + lttng_channel_destroy(channel); 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 +2603,78 @@ 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; + 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 { - /* live_timer_interval */ - xmlChar *timer_interval_content = - xmlNodeGetContent(attributes_child); - if (!timer_interval_content) { - ret = -LTTNG_ERR_NOMEM; - goto error; + if (!strcmp((const char *) attributes_child->name, + config_element_rotation_timer_interval)) { + /* rotation_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, &rotation_timer_interval); + free(timer_interval_content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto error; + } } + if (!strcmp((const char *) attributes_child->name, + config_element_rotation_size)) { + /* rotation_size */ + xmlChar *rotation_size_content = + xmlNodeGetContent(attributes_child); + if (!rotation_size_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; + ret = parse_uint(rotation_size_content, &rotation_size); + free(rotation_size_content); + if (ret) { + ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; + goto error; + } } } } @@ -2510,7 +2755,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 +2781,18 @@ 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); + 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); + output_node, UINT64_MAX, overrides); } if (ret) { goto error; @@ -2553,6 +2814,27 @@ domain_init_error: } } + if (rotation_timer_interval || rotation_size) { + struct lttng_rotation_schedule_attr *rotation_attr = lttng_rotation_schedule_attr_create(); + + if (!rotation_attr) { + goto error; + } + ret = lttng_rotation_schedule_attr_set_session_name(rotation_attr, (const char *) name); + if (ret) { + lttng_rotation_schedule_attr_destroy(rotation_attr); + goto error; + } + lttng_rotation_schedule_attr_set_timer_period(rotation_attr, + rotation_timer_interval); + lttng_rotation_schedule_attr_set_size(rotation_attr, rotation_size); + ret = lttng_rotation_set_schedule(rotation_attr); + lttng_rotation_schedule_attr_destroy(rotation_attr); + if (ret) { + goto error; + } + } + if (started) { ret = lttng_start_tracing((const char *) name); if (ret) { @@ -2605,7 +2887,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; @@ -2647,7 +2930,7 @@ 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); + session_name, overwrite, overrides); if (session_name && ret == 0) { /* Target session found and loaded */ session_found = 1; @@ -2681,7 +2964,8 @@ struct dirent *alloc_dirent(const char *path) 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; @@ -2756,7 +3040,7 @@ int load_session_from_path(const char *path, const char *session_name, file_path[path_len + file_name_len] = '\0'; ret = load_session_from_file(file_path, session_name, - validation_ctx, override); + validation_ctx, overwrite, overrides); if (session_name && !ret) { session_found = 1; break; @@ -2767,7 +3051,7 @@ int load_session_from_path(const char *path, const char *session_name, free(file_path); } else { ret = load_session_from_file(path, session_name, - validation_ctx, override); + validation_ctx, overwrite, overrides); if (ret) { goto end; } else { @@ -2782,8 +3066,8 @@ end: } } - if (!session_found) { - ret = -LTTNG_ERR_LOAD_SESSION_NOENT; + if (session_found && !ret) { + ret = 0; } return ret; @@ -2809,7 +3093,6 @@ static int validate_path_creds(const char *path) if (errno != ENOENT) { PERROR("stat"); } - ret = -LTTNG_ERR_INVALID; goto valid; } @@ -2825,9 +3108,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 }; @@ -2878,7 +3163,7 @@ 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 && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) { goto end; } @@ -2886,6 +3171,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 +3193,10 @@ 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 = access(path, F_OK); @@ -2929,7 +3218,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 +3229,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(); +}