X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Fconfig%2Fsession-config.c;h=5ae56a483b353e7e1d23cbf5ad3f3901185c2827;hb=9d4b0931c687d50af2b494b5362cfdaf0adc0b22;hp=d89249879aece2dc99ea2b138dfcc3784154f097;hpb=fb83fe64f250bec7416f18891a8264450c61ead3;p=lttng-tools.git diff --git a/src/common/config/session-config.c b/src/common/config/session-config.c index d89249879..5ae56a483 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 @@ -55,6 +56,7 @@ struct session_config_validation_ctx { xmlSchemaValidCtxtPtr schema_validation_ctx; }; +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,7 +85,6 @@ 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"; -const char * const config_element_name = "name"; const char * const config_element_enabled = "enabled"; const char * const config_element_overwrite_mode = "overwrite_mode"; const char * const config_element_subbuf_size = "subbuffer_size"; @@ -95,23 +96,23 @@ 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"; -const char * const config_element_discarded_events = "discarded_events"; -const char * const config_element_lost_packets = "lost_packets"; +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,12 +122,26 @@ const char * const config_element_control_uri = "control_uri"; const char * const config_element_data_uri = "data_uri"; const char * const config_element_max_size = "max_size"; const char * const config_element_pid = "pid"; +const char * const config_element_id = "id"; const char * const config_element_pids = "pids"; +const char * const config_element_name = "name"; const char * const config_element_shared_memory_path = "shared_memory_path"; const char * const config_element_pid_tracker = "pid_tracker"; +const char * const config_element_vpid_tracker = "vpid_tracker"; +const char * const config_element_uid_tracker = "uid_tracker"; +const char * const config_element_vuid_tracker = "vuid_tracker"; +const char * const config_element_gid_tracker = "gid_tracker"; +const char * const config_element_vgid_tracker = "vgid_tracker"; const char * const config_element_trackers = "trackers"; const char * const config_element_targets = "targets"; +const char * const config_element_target_type = "target_type"; const char * const config_element_target_pid = "pid_target"; +const char * const config_element_target_vpid = "vpid_target"; +const char * const config_element_target_uid = "uid_target"; +const char * const config_element_target_vuid = "vuid_target"; +const char * const config_element_target_gid = "gid_target"; +const char * const config_element_target_vgid = "vgid_target"; +const char * const config_element_tracker_type = "tracker_type"; const char * const config_domain_type_kernel = "KERNEL"; const char * const config_domain_type_ust = "UST"; @@ -171,8 +186,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; @@ -987,6 +1013,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; } @@ -1136,17 +1174,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; @@ -1165,7 +1202,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; @@ -1195,6 +1233,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)) { @@ -1230,6 +1271,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; @@ -1246,23 +1311,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; @@ -1292,11 +1357,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); @@ -1321,18 +1390,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) { /* @@ -1348,21 +1437,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; } @@ -1452,9 +1534,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; @@ -1599,6 +1681,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) { @@ -1705,25 +1788,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++) { @@ -1740,6 +1812,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); @@ -1748,11 +1821,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; } @@ -2186,17 +2281,88 @@ end: } static -int process_pid_tracker_node(xmlNodePtr pid_tracker_node, - struct lttng_handle *handle) +int get_tracker_elements(enum lttng_tracker_type tracker_type, + const char **element_id_tracker, + const char **element_target_id, + const char **element_id, + const char **element_id_alias, + const char **element_name) +{ + int ret = 0; + + switch (tracker_type) { + case LTTNG_TRACKER_PID: + *element_id_tracker = config_element_pid_tracker; + *element_target_id = config_element_target_pid; + *element_id = config_element_id; + *element_id_alias = config_element_pid; + *element_name = NULL; + break; + case LTTNG_TRACKER_VPID: + *element_id_tracker = config_element_vpid_tracker; + *element_target_id = config_element_target_vpid; + *element_id = config_element_id; + *element_id_alias = NULL; + *element_name = NULL; + break; + case LTTNG_TRACKER_UID: + *element_id_tracker = config_element_uid_tracker; + *element_target_id = config_element_target_uid; + *element_id = config_element_id; + *element_id_alias = NULL; + *element_name = config_element_name; + break; + case LTTNG_TRACKER_VUID: + *element_id_tracker = config_element_vuid_tracker; + *element_target_id = config_element_target_vuid; + *element_id = config_element_id; + *element_id_alias = NULL; + *element_name = config_element_name; + break; + case LTTNG_TRACKER_GID: + *element_id_tracker = config_element_gid_tracker; + *element_target_id = config_element_target_gid; + *element_id = config_element_id; + *element_id_alias = NULL; + *element_name = config_element_name; + break; + case LTTNG_TRACKER_VGID: + *element_id_tracker = config_element_vgid_tracker; + *element_target_id = config_element_target_vgid; + *element_id = config_element_id; + *element_id_alias = NULL; + *element_name = config_element_name; + break; + default: + ret = LTTNG_ERR_INVALID; + } + return ret; +} + +static +int process_id_tracker_node(xmlNodePtr id_tracker_node, + struct lttng_handle *handle, enum lttng_tracker_type tracker_type) { int ret = 0, child; 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; assert(handle); - assert(pid_tracker_node); + assert(id_tracker_node); + + ret = get_tracker_elements(tracker_type, &element_id_tracker, + &element_target_id, &element_id, &element_id_alias, &element_name); + if (ret) { + return ret; + } + /* get the targets node */ - for (node = xmlFirstElementChild(pid_tracker_node); node; + for (node = xmlFirstElementChild(id_tracker_node); node; node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, config_element_targets)) { @@ -2210,26 +2376,31 @@ int process_pid_tracker_node(xmlNodePtr pid_tracker_node, goto end; } - /* Go through all pid_target node */ + /* Go through all id target node */ child = xmlChildElementCount(targets_node); if (child == 0) { + struct lttng_tracker_id tracker_id; + + tracker_id.type = LTTNG_ID_ALL; /* The session is explicitly set to target nothing. */ - ret = lttng_untrack_pid(handle, -1); + ret = lttng_untrack_id(handle, tracker_type, &tracker_id); if (ret) { goto end; } } for (node = xmlFirstElementChild(targets_node); node; node = xmlNextElementSibling(node)) { - xmlNodePtr pid_target_node = node; + xmlNodePtr id_target_node = node; - /* get pid node and track it */ - for (node = xmlFirstElementChild(pid_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, - config_element_pid)) { - int64_t pid; + if (!strcmp((const char *) node->name, element_id) || + (element_id_alias && !strcmp((const char *) node->name, + element_id_alias))) { + int64_t id; xmlChar *content = NULL; + struct lttng_tracker_id tracker_id; content = xmlNodeGetContent(node); if (!content) { @@ -2237,20 +2408,40 @@ int process_pid_tracker_node(xmlNodePtr pid_tracker_node, 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); + tracker_id.type = LTTNG_ID_VALUE; + tracker_id.value = (int) id; + ret = lttng_track_id(handle, tracker_type, &tracker_id); + if (ret) { + goto end; + } + } + if (element_name && !strcmp((const char *) node->name, + element_name)) { + xmlChar *content = NULL; + struct lttng_tracker_id tracker_id; + + content = xmlNodeGetContent(node); + if (!content) { + ret = LTTNG_ERR_LOAD_INVALID_CONFIG; + goto end; + } + tracker_id.type = LTTNG_ID_STRING; + tracker_id.string = (char *) content; + ret = lttng_track_id(handle, tracker_type, &tracker_id); + free(content); if (ret) { goto end; } } } - node = pid_target_node; + node = id_target_node; } end: @@ -2267,6 +2458,11 @@ int process_domain_node(xmlNodePtr domain_node, const char *session_name) 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); @@ -2350,17 +2546,54 @@ 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_pid_tracker)) { pid_tracker_node = node; - ret = process_pid_tracker_node(pid_tracker_node, handle); + ret = process_id_tracker_node(pid_tracker_node, handle, + LTTNG_TRACKER_PID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *)node->name, config_element_vpid_tracker)) { + vpid_tracker_node = node; + ret = process_id_tracker_node(vpid_tracker_node, handle, + LTTNG_TRACKER_VPID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *)node->name, config_element_uid_tracker)) { + uid_tracker_node = node; + ret = process_id_tracker_node(uid_tracker_node, handle, + LTTNG_TRACKER_UID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *)node->name, config_element_vuid_tracker)) { + vuid_tracker_node = node; + ret = process_id_tracker_node(vuid_tracker_node, handle, + LTTNG_TRACKER_VUID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *)node->name, config_element_gid_tracker)) { + gid_tracker_node = node; + ret = process_id_tracker_node(gid_tracker_node, handle, + LTTNG_TRACKER_GID); + if (ret) { + goto end; + } + } + if (!strcmp((const char *)node->name, config_element_vgid_tracker)) { + vgid_tracker_node = node; + ret = process_id_tracker_node(vgid_tracker_node, handle, + LTTNG_TRACKER_VGID); if (ret) { goto end; } } - } - - if (!pid_tracker_node) { - lttng_track_pid(handle, -1); } end: @@ -2370,7 +2603,8 @@ end: 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; @@ -2545,7 +2779,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) { @@ -2556,17 +2805,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; @@ -2640,7 +2890,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; @@ -2675,6 +2926,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; } @@ -2682,7 +2934,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; @@ -2694,6 +2946,9 @@ end: if (!ret) { ret = session_found ? 0 : -LTTNG_ERR_LOAD_SESSION_NOENT; } + if (ret == -LTTNG_ERR_NO_SESSION) { + ret = -LTTNG_ERR_LOAD_SESSION_NOENT; + } return ret; } @@ -2716,7 +2971,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; @@ -2791,8 +3047,8 @@ 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); - if (session_name && !ret) { + validation_ctx, overwrite, overrides); + if (session_name && (!ret || ret != -LTTNG_ERR_LOAD_SESSION_NOENT)) { session_found = 1; break; } @@ -2800,16 +3056,19 @@ int load_session_from_path(const char *path, const char *session_name, free(entry); free(file_path); + if (ret && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) { + goto end; + } } 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)) { @@ -2817,7 +3076,7 @@ end: } } - if (!session_found) { + if (!ret && !session_found) { ret = -LTTNG_ERR_LOAD_SESSION_NOENT; } @@ -2860,9 +3119,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 }; @@ -2890,6 +3151,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; } @@ -2907,13 +3169,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; } @@ -2921,6 +3184,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; } } @@ -2942,7 +3206,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); @@ -2964,7 +3233,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); @@ -2975,5 +3244,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(); +}