X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fconfig%2Fsession-config.c;h=c2ae5e1201fb0cf0b4ef51c438ee74d48fe6d86f;hp=518fde70b5e63d1d244369ca634d0a647bb75f21;hb=499cbfa121fa1bc9ea78294f26b274b35fbc5e0a;hpb=ff86d8d0bd96d3660ad79aa6158fbeb9055652b2 diff --git a/src/common/config/session-config.c b/src/common/config/session-config.c index 518fde70b..c2ae5e120 100644 --- a/src/common/config/session-config.c +++ b/src/common/config/session-config.c @@ -42,10 +42,13 @@ #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; @@ -86,6 +89,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"; @@ -133,9 +148,11 @@ 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"; +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"; @@ -160,6 +177,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"; @@ -185,6 +203,27 @@ LTTNG_HIDDEN const char * const config_event_context_interruptible = "INTERRUPTI 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_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; @@ -230,7 +269,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 }; @@ -915,10 +954,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; @@ -1018,6 +1060,69 @@ int get_context_type(xmlChar *context_type) } 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_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; } @@ -1444,6 +1549,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) @@ -1529,7 +1806,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, { 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; @@ -1538,23 +1815,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); @@ -1572,7 +1853,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, goto end; } - ret = lttng_strncpy(event.name, + ret = lttng_strncpy(event->name, (const char *) content, LTTNG_SYMBOL_NAME_LEN); if (ret == -1) { @@ -1595,7 +1876,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; @@ -1618,7 +1899,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); @@ -1636,7 +1917,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; @@ -1662,7 +1943,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 = @@ -1727,7 +2008,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); @@ -1738,7 +2019,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; @@ -1749,12 +2030,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); @@ -1775,7 +2057,7 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, } ret = lttng_strncpy( - event.attr.ftrace.symbol_name, + event->attr.ftrace.symbol_name, (char *) content, sym_len); if (ret == -1) { ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; @@ -1783,15 +2065,60 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, 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; } } } - if ((event.enabled && phase == ENABLE) || phase == CREATION) { - ret = lttng_enable_event_with_exclusions(handle, &event, 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); + WARN("Enabling event (name:%s) on load failed.", event->name); ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; goto end; } @@ -1802,6 +2129,7 @@ end: free(exclusions[i]); } + lttng_event_destroy(event); free(exclusions); free(filter_expression); return ret; @@ -2546,6 +2874,153 @@ end: 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: + return ret; +} + static int process_session_node(xmlNodePtr session_node, const char *session_name, int overwrite, @@ -2651,40 +3126,17 @@ int process_session_node(xmlNodePtr session_node, const char *session_name, ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; 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); + } 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; } - } - 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(rotation_size_content, &rotation_size); - free(rotation_size_content); - if (ret) { - ret = -LTTNG_ERR_LOAD_INVALID_CONFIG; - goto error; - } } } } @@ -2822,23 +3274,17 @@ 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); + if (rotation_timer_interval) { + ret = add_periodic_rotation((const char *) name, + rotation_timer_interval); + if (ret < 0) { 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) { + } + if (rotation_size) { + ret = add_size_rotation((const char *) name, + rotation_size); + if (ret < 0) { goto error; } } @@ -3162,7 +3608,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 */