X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;ds=inline;f=src%2Fcommon%2Fconfig%2Fconfig.c;h=d7b1bb1b308febca2cafe431271ed9c8ee869628;hb=b2f26ff8607f18abba98718fb6a114ea04142975;hp=bfb2576f4d5bab954b37958d7c1d672bcbfd7c13;hpb=cf53c06d8c89926284a15f6c27d60cf31761e622;p=lttng-tools.git diff --git a/src/common/config/config.c b/src/common/config/config.c index bfb2576f4..d7b1bb1b3 100644 --- a/src/common/config/config.c +++ b/src/common/config/config.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include @@ -117,6 +118,7 @@ const char * const config_element_max_size = "max_size"; const char * const config_domain_type_kernel = "KERNEL"; const char * const config_domain_type_ust = "UST"; const char * const config_domain_type_jul = "JUL"; +const char * const config_domain_type_log4j = "LOG4J"; const char * const config_buffer_type_per_pid = "PER_PID"; const char * const config_buffer_type_per_uid = "PER_UID"; @@ -156,6 +158,11 @@ 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"; +enum process_event_node_phase { + CREATION = 0, + ENABLE = 1, +}; + struct consumer_output { int enabled; char *path; @@ -329,11 +336,10 @@ static xmlChar *encode_string(const char *in_str) in_len = strlen(in_str); /* - * Add 1 byte for the NULL terminted character. The factor 2 here is - * because UTF-8 can be on two bytes so this fits the worst case for each - * bytes. + * Add 1 byte for the NULL terminted character. The factor 4 here is + * used because UTF-8 characters can take up to 4 bytes. */ - out_len = (in_len * 2) + 1; + out_len = (in_len * 4) + 1; out_str = xmlMalloc(out_len); if (!out_str) { goto end; @@ -353,7 +359,7 @@ end: } LTTNG_HIDDEN -struct config_writer *config_writer_create(int fd_output) +struct config_writer *config_writer_create(int fd_output, int indent) { int ret; struct config_writer *writer; @@ -379,12 +385,12 @@ struct config_writer *config_writer_create(int fd_output) ret = xmlTextWriterSetIndentString(writer->writer, BAD_CAST config_xml_indent_string); - if (ret) { + if (ret) { goto error_destroy; } - ret = xmlTextWriterSetIndent(writer->writer, 1); - if (ret) { + ret = xmlTextWriterSetIndent(writer->writer, indent); + if (ret) { goto error_destroy; } @@ -749,6 +755,8 @@ int get_domain_type(xmlChar *domain) ret = LTTNG_DOMAIN_UST; } else if (!strcmp((char *) domain, config_domain_type_jul)) { ret = LTTNG_DOMAIN_JUL; + } else if (!strcmp((char *) domain, config_domain_type_log4j)) { + ret = LTTNG_DOMAIN_LOG4J; } else { goto error; } @@ -1236,6 +1244,7 @@ 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) { @@ -1276,7 +1285,7 @@ int create_session(const char *name, int i; struct lttng_domain *domain; struct lttng_domain *domains[] = - { kernel_domain, ust_domain, jul_domain }; + { kernel_domain, ust_domain, jul_domain, log4j_domain}; /* network destination */ if (live_timer_interval && live_timer_interval != UINT64_MAX) { @@ -1397,9 +1406,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; @@ -1412,6 +1421,23 @@ int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle, memset(&event, 0, sizeof(event)); + /* Initialize default log level which varies by domain */ + switch (handle->domain.type) + { + case LTTNG_DOMAIN_JUL: + event.loglevel = LTTNG_LOGLEVEL_JUL_ALL; + break; + case LTTNG_DOMAIN_LOG4J: + event.loglevel = LTTNG_LOGLEVEL_LOG4J_ALL; + break; + case LTTNG_DOMAIN_UST: + case LTTNG_DOMAIN_KERNEL: + event.loglevel = LTTNG_LOGLEVEL_DEBUG; + break; + default: + assert(0); + } + for (node = xmlFirstElementChild(event_node); node; node = xmlNextElementSibling(node)) { if (!strcmp((const char *) node->name, config_element_name)) { @@ -1524,6 +1550,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) { @@ -1630,8 +1657,15 @@ 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 ((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++) { free(exclusions[i]); @@ -1647,6 +1681,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); @@ -1655,11 +1690,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; } @@ -1956,7 +2013,9 @@ int process_context_node(xmlNodePtr context_node, xmlNodePtr perf_attr_node; /* perf */ - context.ctx = LTTNG_EVENT_CONTEXT_PERF_COUNTER; + context.ctx = handle->domain.type == LTTNG_DOMAIN_KERNEL ? + LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER : + LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER; for (perf_attr_node = xmlFirstElementChild(context_child_node); perf_attr_node; perf_attr_node = xmlNextElementSibling(perf_attr_node)) { @@ -2140,13 +2199,14 @@ int process_session_node(xmlNodePtr session_node, const char *session_name, { int ret, started = -1, snapshot_mode = -1; uint64_t live_timer_interval = UINT64_MAX; - char *name = NULL; + xmlChar *name = NULL; xmlNodePtr domains_node = NULL; xmlNodePtr output_node = NULL; xmlNodePtr node; struct lttng_domain *kernel_domain = NULL; struct lttng_domain *ust_domain = NULL; struct lttng_domain *jul_domain = NULL; + struct lttng_domain *log4j_domain = NULL; for (node = xmlFirstElementChild(session_node); node; node = xmlNextElementSibling(node)) { @@ -2159,7 +2219,7 @@ int process_session_node(xmlNodePtr session_node, const char *session_name, goto error; } - name = (char *) node_content; + name = node_content; } else if (!domains_node && !strcmp((const char *) node->name, config_element_domains)) { /* domains */ @@ -2229,7 +2289,7 @@ int process_session_node(xmlNodePtr session_node, const char *session_name, goto error; } - if (session_name && strcmp(name, session_name)) { + if (session_name && strcmp((char *) name, session_name)) { /* This is not the session we are looking for */ ret = -LTTNG_ERR_NO_SESSION; goto error; @@ -2273,6 +2333,13 @@ int process_session_node(xmlNodePtr session_node, const char *session_name, } jul_domain = domain; break; + case LTTNG_DOMAIN_LOG4J: + if (log4j_domain) { + /* Same domain seen twice, invalid! */ + goto domain_init_error; + } + log4j_domain = domain; + break; default: WARN("Invalid domain type"); goto domain_init_error; @@ -2286,7 +2353,7 @@ domain_init_error: if (override) { /* Destroy session if it exists */ - ret = lttng_destroy_session(name); + ret = lttng_destroy_session((const char *) name); if (ret && ret != -LTTNG_ERR_SESS_NOT_FOUND) { ERR("Failed to destroy existing session."); goto error; @@ -2295,14 +2362,16 @@ domain_init_error: /* Create session type depending on output type */ if (snapshot_mode && snapshot_mode != -1) { - ret = create_snapshot_session(name, output_node); + ret = create_snapshot_session((const char *) name, output_node); } else if (live_timer_interval && live_timer_interval != UINT64_MAX) { - ret = create_session(name, kernel_domain, ust_domain, jul_domain, + ret = create_session((const char *) name, kernel_domain, + ust_domain, jul_domain, log4j_domain, output_node, live_timer_interval); } else { /* regular session */ - ret = create_session(name, kernel_domain, ust_domain, jul_domain, + ret = create_session((const char *) name, kernel_domain, + ust_domain, jul_domain, log4j_domain, output_node, UINT64_MAX); } if (ret) { @@ -2311,14 +2380,14 @@ domain_init_error: for (node = xmlFirstElementChild(domains_node); node; node = xmlNextElementSibling(node)) { - ret = process_domain_node(node, name); + ret = process_domain_node(node, (const char *) name); if (ret) { goto end; } } if (started) { - ret = lttng_start_tracing(name); + ret = lttng_start_tracing((const char *) name); if (ret) { goto end; } @@ -2326,15 +2395,17 @@ domain_init_error: end: if (ret < 0) { - ERR("Failed to load session %s: %s", name, lttng_strerror(ret)); - lttng_destroy_session(name); + ERR("Failed to load session %s: %s", (const char *) name, + lttng_strerror(ret)); + lttng_destroy_session((const char *) name); } error: free(kernel_domain); free(ust_domain); free(jul_domain); - free(name); + free(log4j_domain); + xmlFree(name); return ret; } @@ -2422,6 +2493,23 @@ 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) @@ -2457,7 +2545,7 @@ int load_session_from_path(const char *path, const char *session_name, goto end; } - entry = zmalloc(sizeof(*entry)); + entry = alloc_dirent(path); if (!entry) { ret = -LTTNG_ERR_NOMEM; goto end; @@ -2525,8 +2613,8 @@ end: } } - if (!session_found) { - ret = -LTTNG_ERR_LOAD_SESSION_NOENT; + if (session_found) { + ret = 0; } return ret; @@ -2571,6 +2659,7 @@ int config_load_session(const char *path, const char *session_name, int override, unsigned int autoload) { int ret; + bool session_loaded = false; const char *path_ptr = NULL; struct session_config_validation_ctx validation_ctx = { 0 }; @@ -2629,6 +2718,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; } } @@ -2651,6 +2741,9 @@ 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); + if (!ret) { + session_loaded = true; + } } } else { ret = access(path, F_OK); @@ -2683,5 +2776,10 @@ 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; }