projects / lttng-tools.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: Free variable before strdup() in process_event_node
[lttng-tools.git] / src / common / config / session-config.c
1 /*
2 * Copyright (C) 2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _LGPL_SOURCE
19 #include <assert.h>
20 #include <ctype.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <inttypes.h>
25 #include <dirent.h>
26 #include <unistd.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <stdbool.h>
30
31 #include <common/defaults.h>
32 #include <common/error.h>
33 #include <common/macros.h>
34 #include <common/utils.h>
35 #include <common/compat/getenv.h>
36 #include <lttng/lttng-error.h>
37 #include <libxml/parser.h>
38 #include <libxml/valid.h>
39 #include <libxml/xmlschemas.h>
40 #include <libxml/tree.h>
41 #include <lttng/lttng.h>
42 #include <lttng/snapshot.h>
43
44 #include "session-config.h"
45 #include "config-internal.h"
46
47 struct handler_filter_args {
48 const char* section;
49 config_entry_handler_cb handler;
50 void *user_data;
51 };
52
53 struct session_config_validation_ctx {
54 xmlSchemaParserCtxtPtr parser_ctx;
55 xmlSchemaPtr schema;
56 xmlSchemaValidCtxtPtr schema_validation_ctx;
57 };
58
59 const char * const config_str_yes = "yes";
60 const char * const config_str_true = "true";
61 const char * const config_str_on = "on";
62 const char * const config_str_no = "no";
63 const char * const config_str_false = "false";
64 const char * const config_str_off = "off";
65 const char * const config_xml_encoding = "UTF-8";
66 const size_t config_xml_encoding_bytes_per_char = 2; /* Size of the encoding's largest character */
67 const char * const config_xml_indent_string = "\t";
68 const char * const config_xml_true = "true";
69 const char * const config_xml_false = "false";
70
71 const char * const config_element_channel = "channel";
72 const char * const config_element_channels = "channels";
73 const char * const config_element_domain = "domain";
74 const char * const config_element_domains = "domains";
75 const char * const config_element_event = "event";
76 const char * const config_element_events = "events";
77 const char * const config_element_context = "context";
78 const char * const config_element_contexts = "contexts";
79 const char * const config_element_attributes = "attributes";
80 const char * const config_element_exclusion = "exclusion";
81 const char * const config_element_exclusions = "exclusions";
82 const char * const config_element_function_attributes = "function_attributes";
83 const char * const config_element_probe_attributes = "probe_attributes";
84 const char * const config_element_symbol_name = "symbol_name";
85 const char * const config_element_address = "address";
86 const char * const config_element_offset = "offset";
87 const char * const config_element_name = "name";
88 const char * const config_element_enabled = "enabled";
89 const char * const config_element_overwrite_mode = "overwrite_mode";
90 const char * const config_element_subbuf_size = "subbuffer_size";
91 const char * const config_element_num_subbuf = "subbuffer_count";
92 const char * const config_element_switch_timer_interval = "switch_timer_interval";
93 const char * const config_element_read_timer_interval = "read_timer_interval";
94 const char * const config_element_output = "output";
95 const char * const config_element_output_type = "output_type";
96 const char * const config_element_tracefile_size = "tracefile_size";
97 const char * const config_element_tracefile_count = "tracefile_count";
98 const char * const config_element_live_timer_interval = "live_timer_interval";
99 LTTNG_HIDDEN const char * const config_element_discarded_events = "discarded_events";
100 LTTNG_HIDDEN const char * const config_element_lost_packets = "lost_packets";
101 const char * const config_element_type = "type";
102 const char * const config_element_buffer_type = "buffer_type";
103 const char * const config_element_session = "session";
104 const char * const config_element_sessions = "sessions";
105 LTTNG_HIDDEN const char * const config_element_context_perf = "perf";
106 LTTNG_HIDDEN const char * const config_element_context_app = "app";
107 LTTNG_HIDDEN const char * const config_element_context_app_provider_name = "provider_name";
108 LTTNG_HIDDEN const char * const config_element_context_app_ctx_name = "ctx_name";
109 const char * const config_element_config = "config";
110 const char * const config_element_started = "started";
111 const char * const config_element_snapshot_mode = "snapshot_mode";
112 const char * const config_element_loglevel = "loglevel";
113 const char * const config_element_loglevel_type = "loglevel_type";
114 const char * const config_element_filter = "filter";
115 LTTNG_HIDDEN const char * const config_element_filter_expression = "filter_expression";
116 const char * const config_element_snapshot_outputs = "snapshot_outputs";
117 const char * const config_element_consumer_output = "consumer_output";
118 const char * const config_element_destination = "destination";
119 const char * const config_element_path = "path";
120 const char * const config_element_net_output = "net_output";
121 const char * const config_element_control_uri = "control_uri";
122 const char * const config_element_data_uri = "data_uri";
123 const char * const config_element_max_size = "max_size";
124 const char * const config_element_pid = "pid";
125 const char * const config_element_pids = "pids";
126 const char * const config_element_shared_memory_path = "shared_memory_path";
127 const char * const config_element_pid_tracker = "pid_tracker";
128 const char * const config_element_trackers = "trackers";
129 const char * const config_element_targets = "targets";
130 const char * const config_element_target_pid = "pid_target";
131
132 const char * const config_domain_type_kernel = "KERNEL";
133 const char * const config_domain_type_ust = "UST";
134 const char * const config_domain_type_jul = "JUL";
135 const char * const config_domain_type_log4j = "LOG4J";
136 const char * const config_domain_type_python = "PYTHON";
137
138 const char * const config_buffer_type_per_pid = "PER_PID";
139 const char * const config_buffer_type_per_uid = "PER_UID";
140 const char * const config_buffer_type_global = "GLOBAL";
141
142 const char * const config_overwrite_mode_discard = "DISCARD";
143 const char * const config_overwrite_mode_overwrite = "OVERWRITE";
144
145 const char * const config_output_type_splice = "SPLICE";
146 const char * const config_output_type_mmap = "MMAP";
147
148 const char * const config_loglevel_type_all = "ALL";
149 const char * const config_loglevel_type_range = "RANGE";
150 const char * const config_loglevel_type_single = "SINGLE";
151
152 const char * const config_event_type_all = "ALL";
153 const char * const config_event_type_tracepoint = "TRACEPOINT";
154 const char * const config_event_type_probe = "PROBE";
155 const char * const config_event_type_function = "FUNCTION";
156 const char * const config_event_type_function_entry = "FUNCTION_ENTRY";
157 const char * const config_event_type_noop = "NOOP";
158 const char * const config_event_type_syscall = "SYSCALL";
159 const char * const config_event_type_kprobe = "KPROBE";
160 const char * const config_event_type_kretprobe = "KRETPROBE";
161
162 const char * const config_event_context_pid = "PID";
163 const char * const config_event_context_procname = "PROCNAME";
164 const char * const config_event_context_prio = "PRIO";
165 const char * const config_event_context_nice = "NICE";
166 const char * const config_event_context_vpid = "VPID";
167 const char * const config_event_context_tid = "TID";
168 const char * const config_event_context_vtid = "VTID";
169 const char * const config_event_context_ppid = "PPID";
170 const char * const config_event_context_vppid = "VPPID";
171 const char * const config_event_context_pthread_id = "PTHREAD_ID";
172 const char * const config_event_context_hostname = "HOSTNAME";
173 const char * const config_event_context_ip = "IP";
174 const char * const config_event_context_perf_thread_counter = "PERF_THREAD_COUNTER";
175 LTTNG_HIDDEN const char * const config_event_context_app = "APP";
176 LTTNG_HIDDEN const char * const config_event_context_interruptible = "INTERRUPTIBLE";
177 LTTNG_HIDDEN const char * const config_event_context_preemptible = "PREEMPTIBLE";
178 LTTNG_HIDDEN const char * const config_event_context_need_reschedule = "NEED_RESCHEDULE";
179 LTTNG_HIDDEN const char * const config_event_context_migratable = "MIGRATABLE";
180
181 /* Deprecated symbols */
182 const char * const config_element_perf;
183
184 enum process_event_node_phase {
185 CREATION = 0,
186 ENABLE = 1,
187 };
188
189 struct consumer_output {
190 int enabled;
191 char *path;
192 char *control_uri;
193 char *data_uri;
194 };
195
196 static int config_entry_handler_filter(struct handler_filter_args *args,
197 const char *section, const char *name, const char *value)
198 {
199 int ret = 0;
200 struct config_entry entry = { section, name, value };
201
202 assert(args);
203
204 if (!section || !name || !value) {
205 ret = -EIO;
206 goto end;
207 }
208
209 if (args->section) {
210 if (strcmp(args->section, section)) {
211 goto end;
212 }
213 }
214
215 ret = args->handler(&entry, args->user_data);
216 end:
217 return ret;
218 }
219
220 LTTNG_HIDDEN
221 int config_get_section_entries(const char *override_path, const char *section,
222 config_entry_handler_cb handler, void *user_data)
223 {
224 int ret = 0;
225 char *path;
226 FILE *config_file = NULL;
227 struct handler_filter_args filter = { section, handler, user_data };
228
229 /* First, try system-wide conf. file. */
230 path = DEFAULT_DAEMON_SYSTEM_CONFIGPATH;
231
232 config_file = fopen(path, "r");
233 if (config_file) {
234 DBG("Loading daemon conf file at %s", path);
235 /*
236 * Return value is not very important here since error or not, we
237 * continue and try the next possible conf. file.
238 */
239 (void) ini_parse_file(config_file,
240 (ini_entry_handler) config_entry_handler_filter,
241 (void *) &filter);
242 fclose(config_file);
243 }
244
245 /* Second is the user local configuration. */
246 path = utils_get_home_dir();
247 if (path) {
248 char fullpath[PATH_MAX];
249
250 ret = snprintf(fullpath, sizeof(fullpath),
251 DEFAULT_DAEMON_HOME_CONFIGPATH, path);
252 if (ret < 0) {
253 PERROR("snprintf user conf. path");
254 goto error;
255 }
256
257 config_file = fopen(fullpath, "r");
258 if (config_file) {
259 DBG("Loading daemon user conf file at %s", path);
260 /*
261 * Return value is not very important here since error or not, we
262 * continue and try the next possible conf. file.
263 */
264 (void) ini_parse_file(config_file,
265 (ini_entry_handler) config_entry_handler_filter,
266 (void *) &filter);
267 fclose(config_file);
268 }
269 }
270
271 /* Final path is the one that the user might have provided. */
272 if (override_path) {
273 config_file = fopen(override_path, "r");
274 if (config_file) {
275 DBG("Loading daemon command line conf file at %s", override_path);
276 (void) ini_parse_file(config_file,
277 (ini_entry_handler) config_entry_handler_filter,
278 (void *) &filter);
279 fclose(config_file);
280 } else {
281 ERR("Failed to open daemon configuration file at %s",
282 override_path);
283 ret = -ENOENT;
284 goto error;
285 }
286 }
287
288 /* Everything went well. */
289 ret = 0;
290
291 error:
292 return ret;
293 }
294
295 LTTNG_HIDDEN
296 int config_parse_value(const char *value)
297 {
298 int i, ret = 0;
299 char *endptr, *lower_str;
300 size_t len;
301 unsigned long v;
302
303 len = strlen(value);
304 if (!len) {
305 ret = -1;
306 goto end;
307 }
308
309 v = strtoul(value, &endptr, 10);
310 if (endptr != value) {
311 ret = v;
312 goto end;
313 }
314
315 lower_str = zmalloc(len + 1);
316 if (!lower_str) {
317 PERROR("zmalloc");
318 ret = -errno;
319 goto end;
320 }
321
322 for (i = 0; i < len; i++) {
323 lower_str[i] = tolower(value[i]);
324 }
325
326 if (!strcmp(lower_str, config_str_yes) ||
327 !strcmp(lower_str, config_str_true) ||
328 !strcmp(lower_str, config_str_on)) {
329 ret = 1;
330 } else if (!strcmp(lower_str, config_str_no) ||
331 !strcmp(lower_str, config_str_false) ||
332 !strcmp(lower_str, config_str_off)) {
333 ret = 0;
334 } else {
335 ret = -1;
336 }
337
338 free(lower_str);
339 end:
340 return ret;
341 }
342
343 /*
344 * Returns a xmlChar string which must be released using xmlFree().
345 */
346 static xmlChar *encode_string(const char *in_str)
347 {
348 xmlChar *out_str = NULL;
349 xmlCharEncodingHandlerPtr handler;
350 int out_len, ret, in_len;
351
352 assert(in_str);
353
354 handler = xmlFindCharEncodingHandler(config_xml_encoding);
355 if (!handler) {
356 ERR("xmlFindCharEncodingHandler return NULL!. Configure issue!");
357 goto end;
358 }
359
360 in_len = strlen(in_str);
361 /*
362 * Add 1 byte for the NULL terminted character. The factor 4 here is
363 * used because UTF-8 characters can take up to 4 bytes.
364 */
365 out_len = (in_len * 4) + 1;
366 out_str = xmlMalloc(out_len);
367 if (!out_str) {
368 goto end;
369 }
370
371 ret = handler->input(out_str, &out_len, (const xmlChar *) in_str, &in_len);
372 if (ret < 0) {
373 xmlFree(out_str);
374 out_str = NULL;
375 goto end;
376 }
377
378 /* out_len is now the size of out_str */
379 out_str[out_len] = '\0';
380 end:
381 return out_str;
382 }
383
384 LTTNG_HIDDEN
385 struct config_writer *config_writer_create(int fd_output, int indent)
386 {
387 int ret;
388 struct config_writer *writer;
389 xmlOutputBufferPtr buffer;
390
391 writer = zmalloc(sizeof(struct config_writer));
392 if (!writer) {
393 PERROR("zmalloc config_writer_create");
394 goto end;
395 }
396
397 buffer = xmlOutputBufferCreateFd(fd_output, NULL);
398 if (!buffer) {
399 goto error_destroy;
400 }
401
402 writer->writer = xmlNewTextWriter(buffer);
403 ret = xmlTextWriterStartDocument(writer->writer, NULL,
404 config_xml_encoding, NULL);
405 if (ret < 0) {
406 goto error_destroy;
407 }
408
409 ret = xmlTextWriterSetIndentString(writer->writer,
410 BAD_CAST config_xml_indent_string);
411 if (ret) {
412 goto error_destroy;
413 }
414
415 ret = xmlTextWriterSetIndent(writer->writer, indent);
416 if (ret) {
417 goto error_destroy;
418 }
419
420 end:
421 return writer;
422 error_destroy:
423 config_writer_destroy(writer);
424 return NULL;
425 }
426
427 LTTNG_HIDDEN
428 int config_writer_destroy(struct config_writer *writer)
429 {
430 int ret = 0;
431
432 if (!writer) {
433 ret = -EINVAL;
434 goto end;
435 }
436
437 if (xmlTextWriterEndDocument(writer->writer) < 0) {
438 WARN("Could not close XML document");
439 ret = -EIO;
440 }
441
442 if (writer->writer) {
443 xmlFreeTextWriter(writer->writer);
444 }
445
446 free(writer);
447 end:
448 return ret;
449 }
450
451 LTTNG_HIDDEN
452 int config_writer_open_element(struct config_writer *writer,
453 const char *element_name)
454 {
455 int ret;
456 xmlChar *encoded_element_name;
457
458 if (!writer || !writer->writer || !element_name || !element_name[0]) {
459 ret = -1;
460 goto end;
461 }
462
463 encoded_element_name = encode_string(element_name);
464 if (!encoded_element_name) {
465 ret = -1;
466 goto end;
467 }
468
469 ret = xmlTextWriterStartElement(writer->writer, encoded_element_name);
470 xmlFree(encoded_element_name);
471 end:
472 return ret >= 0 ? 0 : ret;
473 }
474
475 LTTNG_HIDDEN
476 int config_writer_write_attribute(struct config_writer *writer,
477 const char *name, const char *value)
478 {
479 int ret;
480 xmlChar *encoded_name = NULL;
481 xmlChar *encoded_value = NULL;
482
483 if (!writer || !writer->writer || !name || !name[0]) {
484 ret = -1;
485 goto end;
486 }
487
488 encoded_name = encode_string(name);
489 if (!encoded_name) {
490 ret = -1;
491 goto end;
492 }
493
494 encoded_value = encode_string(value);
495 if (!encoded_value) {
496 ret = -1;
497 goto end;
498 }
499
500 ret = xmlTextWriterWriteAttribute(writer->writer, encoded_name,
501 encoded_value);
502 end:
503 xmlFree(encoded_name);
504 xmlFree(encoded_value);
505 return ret >= 0 ? 0 : ret;
506 }
507
508 LTTNG_HIDDEN
509 int config_writer_close_element(struct config_writer *writer)
510 {
511 int ret;
512
513 if (!writer || !writer->writer) {
514 ret = -1;
515 goto end;
516 }
517
518 ret = xmlTextWriterEndElement(writer->writer);
519 end:
520 return ret >= 0 ? 0 : ret;
521 }
522
523 LTTNG_HIDDEN
524 int config_writer_write_element_unsigned_int(struct config_writer *writer,
525 const char *element_name, uint64_t value)
526 {
527 int ret;
528 xmlChar *encoded_element_name;
529
530 if (!writer || !writer->writer || !element_name || !element_name[0]) {
531 ret = -1;
532 goto end;
533 }
534
535 encoded_element_name = encode_string(element_name);
536 if (!encoded_element_name) {
537 ret = -1;
538 goto end;
539 }
540
541 ret = xmlTextWriterWriteFormatElement(writer->writer,
542 encoded_element_name, "%" PRIu64, value);
543 xmlFree(encoded_element_name);
544 end:
545 return ret >= 0 ? 0 : ret;
546 }
547
548 LTTNG_HIDDEN
549 int config_writer_write_element_signed_int(struct config_writer *writer,
550 const char *element_name, int64_t value)
551 {
552 int ret;
553 xmlChar *encoded_element_name;
554
555 if (!writer || !writer->writer || !element_name || !element_name[0]) {
556 ret = -1;
557 goto end;
558 }
559
560 encoded_element_name = encode_string(element_name);
561 if (!encoded_element_name) {
562 ret = -1;
563 goto end;
564 }
565
566 ret = xmlTextWriterWriteFormatElement(writer->writer,
567 encoded_element_name, "%" PRIi64, value);
568 xmlFree(encoded_element_name);
569 end:
570 return ret >= 0 ? 0 : ret;
571 }
572
573 LTTNG_HIDDEN
574 int config_writer_write_element_bool(struct config_writer *writer,
575 const char *element_name, int value)
576 {
577 return config_writer_write_element_string(writer, element_name,
578 value ? config_xml_true : config_xml_false);
579 }
580
581 LTTNG_HIDDEN
582 int config_writer_write_element_string(struct config_writer *writer,
583 const char *element_name, const char *value)
584 {
585 int ret;
586 xmlChar *encoded_element_name = NULL;
587 xmlChar *encoded_value = NULL;
588
589 if (!writer || !writer->writer || !element_name || !element_name[0] ||
590 !value) {
591 ret = -1;
592 goto end;
593 }
594
595 encoded_element_name = encode_string(element_name);
596 if (!encoded_element_name) {
597 ret = -1;
598 goto end;
599 }
600
601 encoded_value = encode_string(value);
602 if (!encoded_value) {
603 ret = -1;
604 goto end;
605 }
606
607 ret = xmlTextWriterWriteElement(writer->writer, encoded_element_name,
608 encoded_value);
609 end:
610 xmlFree(encoded_element_name);
611 xmlFree(encoded_value);
612 return ret >= 0 ? 0 : ret;
613 }
614
615 static
616 void xml_error_handler(void *ctx, const char *format, ...)
617 {
618 char *errMsg;
619 va_list args;
620 int ret;
621
622 va_start(args, format);
623 ret = vasprintf(&errMsg, format, args);
624 va_end(args);
625 if (ret == -1) {
626 ERR("String allocation failed in xml error handler");
627 return;
628 }
629
630 fprintf(stderr, "XML Error: %s", errMsg);
631 free(errMsg);
632 }
633
634 static
635 void fini_session_config_validation_ctx(
636 struct session_config_validation_ctx *ctx)
637 {
638 if (ctx->parser_ctx) {
639 xmlSchemaFreeParserCtxt(ctx->parser_ctx);
640 }
641
642 if (ctx->schema) {
643 xmlSchemaFree(ctx->schema);
644 }
645
646 if (ctx->schema_validation_ctx) {
647 xmlSchemaFreeValidCtxt(ctx->schema_validation_ctx);
648 }
649
650 memset(ctx, 0, sizeof(struct session_config_validation_ctx));
651 }
652
653 static
654 char *get_session_config_xsd_path()
655 {
656 char *xsd_path;
657 const char *base_path = lttng_secure_getenv(DEFAULT_SESSION_CONFIG_XSD_PATH_ENV);
658 size_t base_path_len;
659 size_t max_path_len;
660
661 if (!base_path) {
662 base_path = DEFAULT_SESSION_CONFIG_XSD_PATH;
663 }
664
665 base_path_len = strlen(base_path);
666 max_path_len = base_path_len +
667 sizeof(DEFAULT_SESSION_CONFIG_XSD_FILENAME) + 1;
668 xsd_path = zmalloc(max_path_len);
669 if (!xsd_path) {
670 goto end;
671 }
672
673 strncpy(xsd_path, base_path, max_path_len);
674 if (xsd_path[base_path_len - 1] != '/') {
675 xsd_path[base_path_len++] = '/';
676 }
677
678 strncpy(xsd_path + base_path_len, DEFAULT_SESSION_CONFIG_XSD_FILENAME,
679 max_path_len - base_path_len);
680 end:
681 return xsd_path;
682 }
683
684 static
685 int init_session_config_validation_ctx(
686 struct session_config_validation_ctx *ctx)
687 {
688 int ret;
689 char *xsd_path = get_session_config_xsd_path();
690
691 if (!xsd_path) {
692 ret = -LTTNG_ERR_NOMEM;
693 goto end;
694 }
695
696 ctx->parser_ctx = xmlSchemaNewParserCtxt(xsd_path);
697 if (!ctx->parser_ctx) {
698 ERR("XSD parser context creation failed");
699 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
700 goto end;
701 }
702 xmlSchemaSetParserErrors(ctx->parser_ctx, xml_error_handler,
703 xml_error_handler, NULL);
704
705 ctx->schema = xmlSchemaParse(ctx->parser_ctx);
706 if (!ctx->schema) {
707 ERR("XSD parsing failed");
708 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
709 goto end;
710 }
711
712 ctx->schema_validation_ctx = xmlSchemaNewValidCtxt(ctx->schema);
713 if (!ctx->schema_validation_ctx) {
714 ERR("XSD validation context creation failed");
715 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
716 goto end;
717 }
718
719 xmlSchemaSetValidErrors(ctx->schema_validation_ctx, xml_error_handler,
720 xml_error_handler, NULL);
721 ret = 0;
722
723 end:
724 if (ret) {
725 fini_session_config_validation_ctx(ctx);
726 }
727
728 free(xsd_path);
729 return ret;
730 }
731
732 static
733 int parse_uint(xmlChar *str, uint64_t *val)
734 {
735 int ret;
736 char *endptr;
737
738 if (!str || !val) {
739 ret = -1;
740 goto end;
741 }
742
743 *val = strtoull((const char *) str, &endptr, 10);
744 if (!endptr || *endptr) {
745 ret = -1;
746 } else {
747 ret = 0;
748 }
749
750 end:
751 return ret;
752 }
753
754 static
755 int parse_int(xmlChar *str, int64_t *val)
756 {
757 int ret;
758 char *endptr;
759
760 if (!str || !val) {
761 ret = -1;
762 goto end;
763 }
764
765 *val = strtoll((const char *) str, &endptr, 10);
766 if (!endptr || *endptr) {
767 ret = -1;
768 } else {
769 ret = 0;
770 }
771
772 end:
773 return ret;
774 }
775
776 static
777 int parse_bool(xmlChar *str, int *val)
778 {
779 int ret = 0;
780
781 if (!str || !val) {
782 ret = -1;
783 goto end;
784 }
785
786 if (!strcmp((const char *) str, config_xml_true)) {
787 *val = 1;
788 } else if (!strcmp((const char *) str, config_xml_false)) {
789 *val = 0;
790 } else {
791 WARN("Invalid boolean value encoutered (%s).",
792 (const char *) str);
793 ret = -1;
794 }
795 end:
796 return ret;
797 }
798
799 static
800 int get_domain_type(xmlChar *domain)
801 {
802 int ret;
803
804 if (!domain) {
805 goto error;
806 }
807
808 if (!strcmp((char *) domain, config_domain_type_kernel)) {
809 ret = LTTNG_DOMAIN_KERNEL;
810 } else if (!strcmp((char *) domain, config_domain_type_ust)) {
811 ret = LTTNG_DOMAIN_UST;
812 } else if (!strcmp((char *) domain, config_domain_type_jul)) {
813 ret = LTTNG_DOMAIN_JUL;
814 } else if (!strcmp((char *) domain, config_domain_type_log4j)) {
815 ret = LTTNG_DOMAIN_LOG4J;
816 } else if (!strcmp((char *) domain, config_domain_type_python)) {
817 ret = LTTNG_DOMAIN_PYTHON;
818 } else {
819 goto error;
820 }
821
822 return ret;
823 error:
824 return -1;
825 }
826
827 static
828 int get_buffer_type(xmlChar *buffer_type)
829 {
830 int ret;
831
832 if (!buffer_type) {
833 goto error;
834 }
835
836 if (!strcmp((char *) buffer_type, config_buffer_type_global)) {
837 ret = LTTNG_BUFFER_GLOBAL;
838 } else if (!strcmp((char *) buffer_type, config_buffer_type_per_uid)) {
839 ret = LTTNG_BUFFER_PER_UID;
840 } else if (!strcmp((char *) buffer_type, config_buffer_type_per_pid)) {
841 ret = LTTNG_BUFFER_PER_PID;
842 } else {
843 goto error;
844 }
845
846 return ret;
847 error:
848 return -1;
849 }
850
851 static
852 int get_overwrite_mode(xmlChar *overwrite_mode)
853 {
854 int ret;
855
856 if (!overwrite_mode) {
857 goto error;
858 }
859
860 if (!strcmp((char *) overwrite_mode, config_overwrite_mode_overwrite)) {
861 ret = 1;
862 } else if (!strcmp((char *) overwrite_mode,
863 config_overwrite_mode_discard)) {
864 ret = 0;
865 } else {
866 goto error;
867 }
868
869 return ret;
870 error:
871 return -1;
872 }
873
874 static
875 int get_output_type(xmlChar *output_type)
876 {
877 int ret;
878
879 if (!output_type) {
880 goto error;
881 }
882
883 if (!strcmp((char *) output_type, config_output_type_mmap)) {
884 ret = LTTNG_EVENT_MMAP;
885 } else if (!strcmp((char *) output_type, config_output_type_splice)) {
886 ret = LTTNG_EVENT_SPLICE;
887 } else {
888 goto error;
889 }
890
891 return ret;
892 error:
893 return -1;
894 }
895
896 static
897 int get_event_type(xmlChar *event_type)
898 {
899 int ret;
900
901 if (!event_type) {
902 goto error;
903 }
904
905 if (!strcmp((char *) event_type, config_event_type_all)) {
906 ret = LTTNG_EVENT_ALL;
907 } else if (!strcmp((char *) event_type, config_event_type_tracepoint)) {
908 ret = LTTNG_EVENT_TRACEPOINT;
909 } else if (!strcmp((char *) event_type, config_event_type_probe)) {
910 ret = LTTNG_EVENT_PROBE;
911 } else if (!strcmp((char *) event_type, config_event_type_function)) {
912 ret = LTTNG_EVENT_FUNCTION;
913 } else if (!strcmp((char *) event_type,
914 config_event_type_function_entry)) {
915 ret = LTTNG_EVENT_FUNCTION_ENTRY;
916 } else if (!strcmp((char *) event_type, config_event_type_noop)) {
917 ret = LTTNG_EVENT_NOOP;
918 } else if (!strcmp((char *) event_type, config_event_type_syscall)) {
919 ret = LTTNG_EVENT_SYSCALL;
920 } else {
921 goto error;
922 }
923
924 return ret;
925 error:
926 return -1;
927 }
928
929 static
930 int get_loglevel_type(xmlChar *loglevel_type)
931 {
932 int ret;
933
934 if (!loglevel_type) {
935 goto error;
936 }
937
938 if (!strcmp((char *) loglevel_type, config_loglevel_type_all)) {
939 ret = LTTNG_EVENT_LOGLEVEL_ALL;
940 } else if (!strcmp((char *) loglevel_type,
941 config_loglevel_type_range)) {
942 ret = LTTNG_EVENT_LOGLEVEL_RANGE;
943 } else if (!strcmp((char *) loglevel_type,
944 config_loglevel_type_single)) {
945 ret = LTTNG_EVENT_LOGLEVEL_SINGLE;
946 } else {
947 goto error;
948 }
949
950 return ret;
951 error:
952 return -1;
953 }
954
955 /*
956 * Return the context type or -1 on error.
957 */
958 static
959 int get_context_type(xmlChar *context_type)
960 {
961 int ret;
962
963 if (!context_type) {
964 goto error;
965 }
966
967 if (!strcmp((char *) context_type, config_event_context_pid)) {
968 ret = LTTNG_EVENT_CONTEXT_PID;
969 } else if (!strcmp((char *) context_type,
970 config_event_context_procname)) {
971 ret = LTTNG_EVENT_CONTEXT_PROCNAME;
972 } else if (!strcmp((char *) context_type,
973 config_event_context_prio)) {
974 ret = LTTNG_EVENT_CONTEXT_PRIO;
975 } else if (!strcmp((char *) context_type,
976 config_event_context_nice)) {
977 ret = LTTNG_EVENT_CONTEXT_NICE;
978 } else if (!strcmp((char *) context_type,
979 config_event_context_vpid)) {
980 ret = LTTNG_EVENT_CONTEXT_VPID;
981 } else if (!strcmp((char *) context_type,
982 config_event_context_tid)) {
983 ret = LTTNG_EVENT_CONTEXT_TID;
984 } else if (!strcmp((char *) context_type,
985 config_event_context_vtid)) {
986 ret = LTTNG_EVENT_CONTEXT_VTID;
987 } else if (!strcmp((char *) context_type,
988 config_event_context_ppid)) {
989 ret = LTTNG_EVENT_CONTEXT_PPID;
990 } else if (!strcmp((char *) context_type,
991 config_event_context_vppid)) {
992 ret = LTTNG_EVENT_CONTEXT_VPPID;
993 } else if (!strcmp((char *) context_type,
994 config_event_context_pthread_id)) {
995 ret = LTTNG_EVENT_CONTEXT_PTHREAD_ID;
996 } else if (!strcmp((char *) context_type,
997 config_event_context_hostname)) {
998 ret = LTTNG_EVENT_CONTEXT_HOSTNAME;
999 } else if (!strcmp((char *) context_type,
1000 config_event_context_ip)) {
1001 ret = LTTNG_EVENT_CONTEXT_IP;
1002 } else if (!strcmp((char *) context_type,
1003 config_event_context_interruptible)) {
1004 ret = LTTNG_EVENT_CONTEXT_INTERRUPTIBLE;
1005 } else if (!strcmp((char *) context_type,
1006 config_event_context_preemptible)) {
1007 ret = LTTNG_EVENT_CONTEXT_PREEMPTIBLE;
1008 } else if (!strcmp((char *) context_type,
1009 config_event_context_need_reschedule)) {
1010 ret = LTTNG_EVENT_CONTEXT_NEED_RESCHEDULE;
1011 } else if (!strcmp((char *) context_type,
1012 config_event_context_migratable)) {
1013 ret = LTTNG_EVENT_CONTEXT_MIGRATABLE;
1014 } else {
1015 goto error;
1016 }
1017
1018 return ret;
1019 error:
1020 return -1;
1021 }
1022
1023 static
1024 int init_domain(xmlNodePtr domain_node, struct lttng_domain *domain)
1025 {
1026 int ret;
1027 xmlNodePtr node;
1028
1029 for (node = xmlFirstElementChild(domain_node); node;
1030 node = xmlNextElementSibling(node)) {
1031 if (!strcmp((const char *) node->name, config_element_type)) {
1032 /* domain type */
1033 xmlChar *node_content = xmlNodeGetContent(node);
1034 if (!node_content) {
1035 ret = -LTTNG_ERR_NOMEM;
1036 goto end;
1037 }
1038
1039 ret = get_domain_type(node_content);
1040 free(node_content);
1041 if (ret < 0) {
1042 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1043 goto end;
1044 }
1045
1046 domain->type = ret;
1047 } else if (!strcmp((const char *) node->name,
1048 config_element_buffer_type)) {
1049 /* buffer type */
1050 xmlChar *node_content = xmlNodeGetContent(node);
1051 if (!node_content) {
1052 ret = -LTTNG_ERR_NOMEM;
1053 goto end;
1054 }
1055
1056 ret = get_buffer_type(node_content);
1057 free(node_content);
1058 if (ret < 0) {
1059 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1060 goto end;
1061 }
1062
1063 domain->buf_type = ret;
1064 }
1065 }
1066 ret = 0;
1067 end:
1068 return ret;
1069 }
1070
1071 static
1072 int get_net_output_uris(xmlNodePtr net_output_node, char **control_uri,
1073 char **data_uri)
1074 {
1075 xmlNodePtr node;
1076
1077 for (node = xmlFirstElementChild(net_output_node); node;
1078 node = xmlNextElementSibling(node)) {
1079 if (!strcmp((const char *) node->name, config_element_control_uri)) {
1080 /* control_uri */
1081 *control_uri = (char *) xmlNodeGetContent(node);
1082 if (!*control_uri) {
1083 break;
1084 }
1085 } else {
1086 /* data_uri */
1087 *data_uri = (char *) xmlNodeGetContent(node);
1088 if (!*data_uri) {
1089 break;
1090 }
1091 }
1092 }
1093
1094 return *control_uri || *data_uri ? 0 : -LTTNG_ERR_LOAD_INVALID_CONFIG;
1095 }
1096
1097 static
1098 int process_consumer_output(xmlNodePtr consumer_output_node,
1099 struct consumer_output *output)
1100 {
1101 int ret;
1102 xmlNodePtr node;
1103
1104 assert(output);
1105
1106 for (node = xmlFirstElementChild(consumer_output_node); node;
1107 node = xmlNextElementSibling(node)) {
1108 if (!strcmp((const char *) node->name, config_element_enabled)) {
1109 xmlChar *enabled_str = xmlNodeGetContent(node);
1110
1111 /* enabled */
1112 if (!enabled_str) {
1113 ret = -LTTNG_ERR_NOMEM;
1114 goto end;
1115 }
1116
1117 ret = parse_bool(enabled_str, &output->enabled);
1118 free(enabled_str);
1119 if (ret) {
1120 goto end;
1121 }
1122 } else {
1123 xmlNodePtr output_type_node;
1124
1125 /* destination */
1126 output_type_node = xmlFirstElementChild(node);
1127 if (!output_type_node) {
1128 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1129 goto end;
1130 }
1131
1132 if (!strcmp((const char *) output_type_node->name,
1133 config_element_path)) {
1134 /* path */
1135 output->path = (char *) xmlNodeGetContent(output_type_node);
1136 if (!output->path) {
1137 ret = -LTTNG_ERR_NOMEM;
1138 goto end;
1139 }
1140 } else {
1141 /* net_output */
1142 ret = get_net_output_uris(output_type_node,
1143 &output->control_uri, &output->data_uri);
1144 if (ret) {
1145 goto end;
1146 }
1147 }
1148 }
1149 }
1150 ret = 0;
1151
1152 end:
1153 if (ret) {
1154 free(output->path);
1155 free(output->control_uri);
1156 free(output->data_uri);
1157 memset(output, 0, sizeof(struct consumer_output));
1158 }
1159 return ret;
1160 }
1161
1162 static
1163 int create_session_net_output(const char *name, const char *control_uri,
1164 const char *data_uri)
1165 {
1166 int ret;
1167 struct lttng_handle *handle;
1168 const char *uri = NULL;
1169
1170 assert(name);
1171
1172 handle = lttng_create_handle(name, NULL);
1173 if (!handle) {
1174 ret = -LTTNG_ERR_NOMEM;
1175 goto end;
1176 }
1177
1178 if (!control_uri || !data_uri) {
1179 uri = control_uri ? control_uri : data_uri;
1180 control_uri = uri;
1181 data_uri = uri;
1182 }
1183
1184 ret = lttng_set_consumer_url(handle, control_uri, data_uri);
1185 lttng_destroy_handle(handle);
1186 end:
1187 return ret;
1188 }
1189
1190 static
1191 int create_snapshot_session(const char *session_name, xmlNodePtr output_node)
1192 {
1193 int ret;
1194 xmlNodePtr node = NULL;
1195 xmlNodePtr snapshot_output_list_node;
1196 xmlNodePtr snapshot_output_node;
1197
1198 assert(session_name);
1199
1200 ret = lttng_create_session_snapshot(session_name, NULL);
1201 if (ret) {
1202 goto end;
1203 }
1204
1205 if (!output_node) {
1206 goto end;
1207 }
1208
1209 snapshot_output_list_node = xmlFirstElementChild(output_node);
1210
1211 /* Parse and create snapshot outputs */
1212
1213 for (snapshot_output_node =
1214 xmlFirstElementChild(snapshot_output_list_node);
1215 snapshot_output_node; snapshot_output_node =
1216 xmlNextElementSibling(snapshot_output_node)) {
1217 char *name = NULL;
1218 uint64_t max_size = UINT64_MAX;
1219 struct consumer_output output = { 0 };
1220 struct lttng_snapshot_output *snapshot_output = NULL;
1221
1222 for (node = xmlFirstElementChild(snapshot_output_node); node;
1223 node = xmlNextElementSibling(node)) {
1224 if (!strcmp((const char *) node->name,
1225 config_element_name)) {
1226 /* name */
1227 name = (char *) xmlNodeGetContent(node);
1228 if (!name) {
1229 ret = -LTTNG_ERR_NOMEM;
1230 goto error_snapshot_output;
1231 }
1232 } else if (!strcmp((const char *) node->name,
1233 config_element_max_size)) {
1234 xmlChar *content = xmlNodeGetContent(node);
1235
1236 /* max_size */
1237 if (!content) {
1238 ret = -LTTNG_ERR_NOMEM;
1239 goto error_snapshot_output;
1240 }
1241 ret = parse_uint(content, &max_size);
1242 free(content);
1243 if (ret) {
1244 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1245 goto error_snapshot_output;
1246 }
1247 } else {
1248 /* consumer_output */
1249 ret = process_consumer_output(node, &output);
1250 if (ret) {
1251 goto error_snapshot_output;
1252 }
1253 }
1254 }
1255
1256 snapshot_output = lttng_snapshot_output_create();
1257 if (!snapshot_output) {
1258 ret = -LTTNG_ERR_NOMEM;
1259 goto error_snapshot_output;
1260 }
1261
1262 ret = lttng_snapshot_output_set_name(name, snapshot_output);
1263 if (ret) {
1264 goto error_snapshot_output;
1265 }
1266
1267 ret = lttng_snapshot_output_set_size(max_size, snapshot_output);
1268 if (ret) {
1269 goto error_snapshot_output;
1270 }
1271
1272 if (output.path) {
1273 ret = lttng_snapshot_output_set_ctrl_url(output.path,
1274 snapshot_output);
1275 if (ret) {
1276 goto error_snapshot_output;
1277 }
1278 } else {
1279 if (output.control_uri) {
1280 ret = lttng_snapshot_output_set_ctrl_url(output.control_uri,
1281 snapshot_output);
1282 if (ret) {
1283 goto error_snapshot_output;
1284 }
1285 }
1286
1287 if (output.data_uri) {
1288 ret = lttng_snapshot_output_set_data_url(output.data_uri,
1289 snapshot_output);
1290 if (ret) {
1291 goto error_snapshot_output;
1292 }
1293 }
1294 }
1295
1296 ret = lttng_snapshot_add_output(session_name, snapshot_output);
1297 error_snapshot_output:
1298 free(name);
1299 free(output.path);
1300 free(output.control_uri);
1301 free(output.data_uri);
1302 lttng_snapshot_output_destroy(snapshot_output);
1303 if (ret) {
1304 goto end;
1305 }
1306 }
1307 end:
1308 return ret;
1309 }
1310
1311 static
1312 int create_session(const char *name,
1313 struct lttng_domain *kernel_domain,
1314 struct lttng_domain *ust_domain,
1315 struct lttng_domain *jul_domain,
1316 struct lttng_domain *log4j_domain,
1317 xmlNodePtr output_node,
1318 uint64_t live_timer_interval)
1319 {
1320 int ret;
1321 struct consumer_output output = { 0 };
1322 xmlNodePtr consumer_output_node;
1323
1324 assert(name);
1325
1326 if (output_node) {
1327 consumer_output_node = xmlFirstElementChild(output_node);
1328 if (!consumer_output_node) {
1329 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1330 goto end;
1331 }
1332
1333 if (strcmp((const char *) consumer_output_node->name,
1334 config_element_consumer_output)) {
1335 WARN("Invalid output type, expected %s node",
1336 config_element_consumer_output);
1337 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1338 goto end;
1339 }
1340
1341 ret = process_consumer_output(consumer_output_node, &output);
1342 if (ret) {
1343 goto end;
1344 }
1345 }
1346
1347 if (live_timer_interval != UINT64_MAX &&
1348 !output.control_uri && !output.data_uri) {
1349 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1350 goto end;
1351 }
1352
1353 if (output.control_uri || output.data_uri) {
1354 /* network destination */
1355 if (live_timer_interval && live_timer_interval != UINT64_MAX) {
1356 /*
1357 * URLs are provided for sure since the test above make sure that
1358 * with a live timer the data and control URIs are provided. So,
1359 * NULL is passed here and will be set right after.
1360 */
1361 ret = lttng_create_session_live(name, NULL, live_timer_interval);
1362 } else {
1363 ret = lttng_create_session(name, NULL);
1364 }
1365 if (ret) {
1366 goto end;
1367 }
1368
1369 ret = create_session_net_output(name, output.control_uri,
1370 output.data_uri);
1371 if (ret) {
1372 goto end;
1373 }
1374
1375 } else {
1376 /* either local output or no output */
1377 ret = lttng_create_session(name, output.path);
1378 if (ret) {
1379 goto end;
1380 }
1381 }
1382 end:
1383 free(output.path);
1384 free(output.control_uri);
1385 free(output.data_uri);
1386 return ret;
1387 }
1388 static
1389 int process_probe_attribute_node(xmlNodePtr probe_attribute_node,
1390 struct lttng_event_probe_attr *attr)
1391 {
1392 int ret;
1393
1394 assert(probe_attribute_node);
1395 assert(attr);
1396
1397 if (!strcmp((const char *) probe_attribute_node->name,
1398 config_element_address)) {
1399 xmlChar *content;
1400 uint64_t addr = 0;
1401
1402 /* addr */
1403 content = xmlNodeGetContent(probe_attribute_node);
1404 if (!content) {
1405 ret = -LTTNG_ERR_NOMEM;
1406 goto end;
1407 }
1408
1409 ret = parse_uint(content, &addr);
1410 free(content);
1411 if (ret) {
1412 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1413 goto end;
1414 }
1415
1416 attr->addr = addr;
1417 } else if (!strcmp((const char *) probe_attribute_node->name,
1418 config_element_offset)) {
1419 xmlChar *content;
1420 uint64_t offset = 0;
1421
1422 /* offset */
1423 content = xmlNodeGetContent(probe_attribute_node);
1424 if (!content) {
1425 ret = -LTTNG_ERR_NOMEM;
1426 goto end;
1427 }
1428
1429 ret = parse_uint(content, &offset);
1430 free(content);
1431 if (ret) {
1432 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1433 goto end;
1434 }
1435
1436 attr->offset = offset;
1437 } else if (!strcmp((const char *) probe_attribute_node->name,
1438 config_element_symbol_name)) {
1439 xmlChar *content;
1440 size_t name_len;
1441
1442 /* symbol_name */
1443 content = xmlNodeGetContent(probe_attribute_node);
1444 if (!content) {
1445 ret = -LTTNG_ERR_NOMEM;
1446 goto end;
1447 }
1448
1449 name_len = strlen((char *) content);
1450 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1451 WARN("symbol_name too long.");
1452 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1453 free(content);
1454 goto end;
1455 }
1456
1457 strncpy(attr->symbol_name, (const char *) content, name_len);
1458 free(content);
1459 }
1460 ret = 0;
1461 end:
1462 return ret;
1463 }
1464
1465 static
1466 int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle,
1467 const char *channel_name, const enum process_event_node_phase phase)
1468 {
1469 int ret = 0, i;
1470 xmlNodePtr node;
1471 struct lttng_event event;
1472 char **exclusions = NULL;
1473 unsigned long exclusion_count = 0;
1474 char *filter_expression = NULL;
1475
1476 assert(event_node);
1477 assert(handle);
1478 assert(channel_name);
1479
1480 memset(&event, 0, sizeof(event));
1481
1482 /* Initialize default log level which varies by domain */
1483 switch (handle->domain.type)
1484 {
1485 case LTTNG_DOMAIN_JUL:
1486 event.loglevel = LTTNG_LOGLEVEL_JUL_ALL;
1487 break;
1488 case LTTNG_DOMAIN_LOG4J:
1489 event.loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
1490 break;
1491 case LTTNG_DOMAIN_PYTHON:
1492 event.loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
1493 break;
1494 case LTTNG_DOMAIN_UST:
1495 case LTTNG_DOMAIN_KERNEL:
1496 event.loglevel = LTTNG_LOGLEVEL_DEBUG;
1497 break;
1498 default:
1499 assert(0);
1500 }
1501
1502 for (node = xmlFirstElementChild(event_node); node;
1503 node = xmlNextElementSibling(node)) {
1504 if (!strcmp((const char *) node->name, config_element_name)) {
1505 xmlChar *content;
1506 size_t name_len;
1507
1508 /* name */
1509 content = xmlNodeGetContent(node);
1510 if (!content) {
1511 ret = -LTTNG_ERR_NOMEM;
1512 goto end;
1513 }
1514
1515 name_len = strlen((char *) content);
1516 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1517 WARN("Channel name too long.");
1518 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1519 free(content);
1520 goto end;
1521 }
1522
1523 strncpy(event.name, (const char *) content, name_len);
1524 free(content);
1525 } else if (!strcmp((const char *) node->name,
1526 config_element_enabled)) {
1527 xmlChar *content = xmlNodeGetContent(node);
1528
1529 /* enabled */
1530 if (!content) {
1531 ret = -LTTNG_ERR_NOMEM;
1532 goto end;
1533 }
1534
1535 ret = parse_bool(content, &event.enabled);
1536 free(content);
1537 if (ret) {
1538 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1539 goto end;
1540 }
1541 } else if (!strcmp((const char *) node->name,
1542 config_element_type)) {
1543 xmlChar *content = xmlNodeGetContent(node);
1544
1545 /* type */
1546 if (!content) {
1547 ret = -LTTNG_ERR_NOMEM;
1548 goto end;
1549 }
1550
1551 ret = get_event_type(content);
1552 free(content);
1553 if (ret < 0) {
1554 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1555 goto end;
1556 }
1557
1558 event.type = ret;
1559 } else if (!strcmp((const char *) node->name,
1560 config_element_loglevel_type)) {
1561 xmlChar *content = xmlNodeGetContent(node);
1562
1563 /* loglevel_type */
1564 if (!content) {
1565 ret = -LTTNG_ERR_NOMEM;
1566 goto end;
1567 }
1568
1569 ret = get_loglevel_type(content);
1570 free(content);
1571 if (ret < 0) {
1572 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1573 goto end;
1574 }
1575
1576 event.loglevel_type = ret;
1577 } else if (!strcmp((const char *) node->name,
1578 config_element_loglevel)) {
1579 xmlChar *content;
1580 int64_t loglevel = 0;
1581
1582 /* loglevel */
1583 content = xmlNodeGetContent(node);
1584 if (!content) {
1585 ret = -LTTNG_ERR_NOMEM;
1586 goto end;
1587 }
1588
1589 ret = parse_int(content, &loglevel);
1590 free(content);
1591 if (ret) {
1592 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1593 goto end;
1594 }
1595
1596 if (loglevel > INT_MAX || loglevel < INT_MIN) {
1597 WARN("loglevel out of range.");
1598 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1599 goto end;
1600 }
1601
1602 event.loglevel = loglevel;
1603 } else if (!strcmp((const char *) node->name,
1604 config_element_filter)) {
1605 xmlChar *content =
1606 xmlNodeGetContent(node);
1607
1608 /* filter */
1609 if (!content) {
1610 ret = -LTTNG_ERR_NOMEM;
1611 goto end;
1612 }
1613
1614 free(filter_expression);
1615 filter_expression = strdup((char *) content);
1616 free(content);
1617 if (!filter_expression) {
1618 ret = -LTTNG_ERR_NOMEM;
1619 goto end;
1620 }
1621 } else if (!strcmp((const char *) node->name,
1622 config_element_exclusions)) {
1623 xmlNodePtr exclusion_node;
1624 int exclusion_index = 0;
1625
1626 /* exclusions */
1627 if (exclusions) {
1628 /*
1629 * Exclusions has already been initialized,
1630 * invalid file.
1631 */
1632 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1633 goto end;
1634 }
1635
1636 exclusion_count = xmlChildElementCount(node);
1637 if (!exclusion_count) {
1638 continue;
1639 }
1640
1641 exclusions = zmalloc(exclusion_count * sizeof(char *));
1642 if (!exclusions) {
1643 exclusion_count = 0;
1644 ret = -LTTNG_ERR_NOMEM;
1645 goto end;
1646 }
1647
1648 for (exclusion_node = xmlFirstElementChild(node); exclusion_node;
1649 exclusion_node = xmlNextElementSibling(exclusion_node)) {
1650 xmlChar *content =
1651 xmlNodeGetContent(exclusion_node);
1652
1653 if (!content) {
1654 ret = -LTTNG_ERR_NOMEM;
1655 goto end;
1656 }
1657
1658 exclusions[exclusion_index] = strdup((const char *) content);
1659 free(content);
1660 if (!exclusions[exclusion_index]) {
1661 ret = -LTTNG_ERR_NOMEM;
1662 goto end;
1663 }
1664 exclusion_index++;
1665 }
1666
1667 event.exclusion = 1;
1668 } else if (!strcmp((const char *) node->name,
1669 config_element_attributes)) {
1670 xmlNodePtr attribute_node = xmlFirstElementChild(node);
1671
1672 /* attributes */
1673 if (!attribute_node) {
1674 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1675 goto end;
1676 }
1677
1678 if (!strcmp((const char *) node->name,
1679 config_element_probe_attributes)) {
1680 xmlNodePtr probe_attribute_node;
1681
1682 /* probe_attributes */
1683 for (probe_attribute_node =
1684 xmlFirstElementChild(attribute_node); probe_attribute_node;
1685 probe_attribute_node = xmlNextElementSibling(
1686 probe_attribute_node)) {
1687
1688 ret = process_probe_attribute_node(probe_attribute_node,
1689 &event.attr.probe);
1690 if (ret) {
1691 goto end;
1692 }
1693 }
1694 } else {
1695 size_t sym_len;
1696 xmlChar *content;
1697 xmlNodePtr symbol_node = xmlFirstElementChild(attribute_node);
1698
1699 /* function_attributes */
1700 content = xmlNodeGetContent(symbol_node);
1701 if (!content) {
1702 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1703 goto end;
1704 }
1705
1706 sym_len = strlen((char *) content);
1707 if (sym_len >= LTTNG_SYMBOL_NAME_LEN) {
1708 WARN("Function name too long.");
1709 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1710 free(content);
1711 goto end;
1712 }
1713
1714 strncpy(event.attr.ftrace.symbol_name, (char *) content,
1715 sym_len);
1716 free(content);
1717 }
1718 }
1719 }
1720
1721 if ((event.enabled && phase == ENABLE) || phase == CREATION) {
1722 ret = lttng_enable_event_with_exclusions(handle, &event, channel_name,
1723 filter_expression, exclusion_count, exclusions);
1724 if (ret < 0) {
1725 WARN("Enabling event (name:%s) on load failed.", event.name);
1726 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1727 goto end;
1728 }
1729 }
1730 end:
1731 for (i = 0; i < exclusion_count; i++) {
1732 free(exclusions[i]);
1733 }
1734
1735 free(exclusions);
1736 free(filter_expression);
1737 return ret;
1738 }
1739
1740 static
1741 int process_events_node(xmlNodePtr events_node, struct lttng_handle *handle,
1742 const char *channel_name)
1743 {
1744 int ret = 0;
1745 struct lttng_event event;
1746 xmlNodePtr node;
1747
1748 assert(events_node);
1749 assert(handle);
1750 assert(channel_name);
1751
1752 for (node = xmlFirstElementChild(events_node); node;
1753 node = xmlNextElementSibling(node)) {
1754 ret = process_event_node(node, handle, channel_name, CREATION);
1755 if (ret) {
1756 goto end;
1757 }
1758 }
1759
1760 /*
1761 * Disable all events to enable only the necessary events.
1762 * Limitations regarding lttng_disable_events and tuple descriptor
1763 * force this approach.
1764 */
1765 memset(&event, 0, sizeof(event));
1766 event.loglevel = -1;
1767 event.type = LTTNG_EVENT_ALL;
1768 ret = lttng_disable_event_ext(handle, &event, channel_name, NULL);
1769 if (ret) {
1770 goto end;
1771 }
1772
1773 for (node = xmlFirstElementChild(events_node); node;
1774 node = xmlNextElementSibling(node)) {
1775 ret = process_event_node(node, handle, channel_name, ENABLE);
1776 if (ret) {
1777 goto end;
1778 }
1779 }
1780
1781 end:
1782 return ret;
1783 }
1784
1785 static
1786 int process_channel_attr_node(xmlNodePtr attr_node,
1787 struct lttng_channel *channel, xmlNodePtr *contexts_node,
1788 xmlNodePtr *events_node)
1789 {
1790 int ret;
1791
1792 assert(attr_node);
1793 assert(channel);
1794 assert(contexts_node);
1795 assert(events_node);
1796
1797 if (!strcmp((const char *) attr_node->name, config_element_name)) {
1798 xmlChar *content;
1799 size_t name_len;
1800
1801 /* name */
1802 content = xmlNodeGetContent(attr_node);
1803 if (!content) {
1804 ret = -LTTNG_ERR_NOMEM;
1805 goto end;
1806 }
1807
1808 name_len = strlen((char *) content);
1809 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1810 WARN("Channel name too long.");
1811 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1812 free(content);
1813 goto end;
1814 }
1815
1816 strncpy(channel->name, (const char *) content, name_len);
1817 free(content);
1818 } else if (!strcmp((const char *) attr_node->name,
1819 config_element_enabled)) {
1820 xmlChar *content;
1821 int enabled;
1822
1823 /* enabled */
1824 content = xmlNodeGetContent(attr_node);
1825 if (!content) {
1826 ret = -LTTNG_ERR_NOMEM;
1827 goto end;
1828 }
1829
1830 ret = parse_bool(content, &enabled);
1831 free(content);
1832 if (ret) {
1833 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1834 goto end;
1835 }
1836
1837 channel->enabled = enabled;
1838 } else if (!strcmp((const char *) attr_node->name,
1839 config_element_overwrite_mode)) {
1840 xmlChar *content;
1841
1842 /* overwrite_mode */
1843 content = xmlNodeGetContent(attr_node);
1844 if (!content) {
1845 ret = -LTTNG_ERR_NOMEM;
1846 goto end;
1847 }
1848
1849 ret = get_overwrite_mode(content);
1850 free(content);
1851 if (ret < 0) {
1852 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1853 goto end;
1854 }
1855
1856 channel->attr.overwrite = ret;
1857 } else if (!strcmp((const char *) attr_node->name,
1858 config_element_subbuf_size)) {
1859 xmlChar *content;
1860
1861 /* subbuffer_size */
1862 content = xmlNodeGetContent(attr_node);
1863 if (!content) {
1864 ret = -LTTNG_ERR_NOMEM;
1865 goto end;
1866 }
1867
1868 ret = parse_uint(content, &channel->attr.subbuf_size);
1869 free(content);
1870 if (ret) {
1871 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1872 goto end;
1873 }
1874 } else if (!strcmp((const char *) attr_node->name,
1875 config_element_num_subbuf)) {
1876 xmlChar *content;
1877
1878 /* subbuffer_count */
1879 content = xmlNodeGetContent(attr_node);
1880 if (!content) {
1881 ret = -LTTNG_ERR_NOMEM;
1882 goto end;
1883 }
1884
1885 ret = parse_uint(content, &channel->attr.num_subbuf);
1886 free(content);
1887 if (ret) {
1888 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1889 goto end;
1890 }
1891 } else if (!strcmp((const char *) attr_node->name,
1892 config_element_switch_timer_interval)) {
1893 xmlChar *content;
1894 uint64_t switch_timer_interval = 0;
1895
1896 /* switch_timer_interval */
1897 content = xmlNodeGetContent(attr_node);
1898 if (!content) {
1899 ret = -LTTNG_ERR_NOMEM;
1900 goto end;
1901 }
1902
1903 ret = parse_uint(content, &switch_timer_interval);
1904 free(content);
1905 if (ret) {
1906 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1907 goto end;
1908 }
1909
1910 if (switch_timer_interval > UINT_MAX) {
1911 WARN("switch_timer_interval out of range.");
1912 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1913 goto end;
1914 }
1915
1916 channel->attr.switch_timer_interval =
1917 switch_timer_interval;
1918 } else if (!strcmp((const char *) attr_node->name,
1919 config_element_read_timer_interval)) {
1920 xmlChar *content;
1921 uint64_t read_timer_interval = 0;
1922
1923 /* read_timer_interval */
1924 content = xmlNodeGetContent(attr_node);
1925 if (!content) {
1926 ret = -LTTNG_ERR_NOMEM;
1927 goto end;
1928 }
1929
1930 ret = parse_uint(content, &read_timer_interval);
1931 free(content);
1932 if (ret) {
1933 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1934 goto end;
1935 }
1936
1937 if (read_timer_interval > UINT_MAX) {
1938 WARN("read_timer_interval out of range.");
1939 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1940 goto end;
1941 }
1942
1943 channel->attr.read_timer_interval =
1944 read_timer_interval;
1945 } else if (!strcmp((const char *) attr_node->name,
1946 config_element_output_type)) {
1947 xmlChar *content;
1948
1949 /* output_type */
1950 content = xmlNodeGetContent(attr_node);
1951 if (!content) {
1952 ret = -LTTNG_ERR_NOMEM;
1953 goto end;
1954 }
1955
1956 ret = get_output_type(content);
1957 free(content);
1958 if (ret < 0) {
1959 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1960 goto end;
1961 }
1962
1963 channel->attr.output = ret;
1964 } else if (!strcmp((const char *) attr_node->name,
1965 config_element_tracefile_size)) {
1966 xmlChar *content;
1967
1968 /* tracefile_size */
1969 content = xmlNodeGetContent(attr_node);
1970 if (!content) {
1971 ret = -LTTNG_ERR_NOMEM;
1972 goto end;
1973 }
1974
1975 ret = parse_uint(content, &channel->attr.tracefile_size);
1976 free(content);
1977 if (ret) {
1978 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1979 goto end;
1980 }
1981 } else if (!strcmp((const char *) attr_node->name,
1982 config_element_tracefile_count)) {
1983 xmlChar *content;
1984
1985 /* tracefile_count */
1986 content = xmlNodeGetContent(attr_node);
1987 if (!content) {
1988 ret = -LTTNG_ERR_NOMEM;
1989 goto end;
1990 }
1991
1992 ret = parse_uint(content, &channel->attr.tracefile_count);
1993 free(content);
1994 if (ret) {
1995 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1996 goto end;
1997 }
1998 } else if (!strcmp((const char *) attr_node->name,
1999 config_element_live_timer_interval)) {
2000 xmlChar *content;
2001 uint64_t live_timer_interval = 0;
2002
2003 /* live_timer_interval */
2004 content = xmlNodeGetContent(attr_node);
2005 if (!content) {
2006 ret = -LTTNG_ERR_NOMEM;
2007 goto end;
2008 }
2009
2010 ret = parse_uint(content, &live_timer_interval);
2011 free(content);
2012 if (ret) {
2013 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2014 goto end;
2015 }
2016
2017 if (live_timer_interval > UINT_MAX) {
2018 WARN("live_timer_interval out of range.");
2019 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2020 goto end;
2021 }
2022
2023 channel->attr.live_timer_interval =
2024 live_timer_interval;
2025 } else if (!strcmp((const char *) attr_node->name,
2026 config_element_events)) {
2027 /* events */
2028 *events_node = attr_node;
2029 } else {
2030 /* contexts */
2031 *contexts_node = attr_node;
2032 }
2033 ret = 0;
2034 end:
2035 return ret;
2036 }
2037
2038 static
2039 int process_context_node(xmlNodePtr context_node,
2040 struct lttng_handle *handle, const char *channel_name)
2041 {
2042 int ret;
2043 struct lttng_event_context context;
2044 xmlNodePtr context_child_node = xmlFirstElementChild(context_node);
2045
2046 assert(handle);
2047 assert(channel_name);
2048
2049 if (!context_child_node) {
2050 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2051 goto end;
2052 }
2053
2054 memset(&context, 0, sizeof(context));
2055
2056 if (!strcmp((const char *) context_child_node->name,
2057 config_element_type)) {
2058 /* type */
2059 xmlChar *content = xmlNodeGetContent(context_child_node);
2060
2061 if (!content) {
2062 ret = -LTTNG_ERR_NOMEM;
2063 goto end;
2064 }
2065
2066 ret = get_context_type(content);
2067 free(content);
2068 if (ret < 0) {
2069 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2070 goto end;
2071 }
2072
2073 context.ctx = ret;
2074 } else if (!strcmp((const char *) context_child_node->name,
2075 config_element_context_perf)) {
2076 /* perf */
2077 xmlNodePtr perf_attr_node;
2078
2079 context.ctx = handle->domain.type == LTTNG_DOMAIN_KERNEL ?
2080 LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER :
2081 LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER;
2082 for (perf_attr_node = xmlFirstElementChild(context_child_node);
2083 perf_attr_node; perf_attr_node =
2084 xmlNextElementSibling(perf_attr_node)) {
2085 if (!strcmp((const char *) perf_attr_node->name,
2086 config_element_type)) {
2087 xmlChar *content;
2088 uint64_t type = 0;
2089
2090 /* type */
2091 content = xmlNodeGetContent(perf_attr_node);
2092 if (!content) {
2093 ret = -LTTNG_ERR_NOMEM;
2094 goto end;
2095 }
2096
2097 ret = parse_uint(content, &type);
2098 free(content);
2099 if (ret) {
2100 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2101 goto end;
2102 }
2103
2104 if (type > UINT32_MAX) {
2105 WARN("perf context type out of range.");
2106 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2107 goto end;
2108 }
2109
2110 context.u.perf_counter.type = type;
2111 } else if (!strcmp((const char *) perf_attr_node->name,
2112 config_element_config)) {
2113 xmlChar *content;
2114 uint64_t config = 0;
2115
2116 /* config */
2117 content = xmlNodeGetContent(perf_attr_node);
2118 if (!content) {
2119 ret = -LTTNG_ERR_NOMEM;
2120 goto end;
2121 }
2122
2123 ret = parse_uint(content, &config);
2124 free(content);
2125 if (ret) {
2126 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2127 goto end;
2128 }
2129
2130 context.u.perf_counter.config = config;
2131 } else if (!strcmp((const char *) perf_attr_node->name,
2132 config_element_name)) {
2133 xmlChar *content;
2134 size_t name_len;
2135
2136 /* name */
2137 content = xmlNodeGetContent(perf_attr_node);
2138 if (!content) {
2139 ret = -LTTNG_ERR_NOMEM;
2140 goto end;
2141 }
2142
2143 name_len = strlen((char *) content);
2144 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
2145 WARN("perf context name too long.");
2146 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2147 free(content);
2148 goto end;
2149 }
2150
2151 strncpy(context.u.perf_counter.name, (const char *) content,
2152 name_len);
2153 free(content);
2154 }
2155 }
2156 } else if (!strcmp((const char *) context_child_node->name,
2157 config_element_context_app)) {
2158 /* application context */
2159 xmlNodePtr app_ctx_node;
2160
2161 context.ctx = LTTNG_EVENT_CONTEXT_APP_CONTEXT;
2162 for (app_ctx_node = xmlFirstElementChild(context_child_node);
2163 app_ctx_node; app_ctx_node =
2164 xmlNextElementSibling(app_ctx_node)) {
2165 xmlChar *content;
2166 char **target = strcmp(
2167 (const char *) app_ctx_node->name,
2168 config_element_context_app_provider_name) == 0 ?
2169 &context.u.app_ctx.provider_name :
2170 &context.u.app_ctx.ctx_name;
2171
2172 content = xmlNodeGetContent(app_ctx_node);
2173 if (!content) {
2174 ret = -LTTNG_ERR_NOMEM;
2175 goto end;
2176 }
2177
2178 *target = (char *) content;
2179 }
2180 } else {
2181 /* Unrecognized context type */
2182 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2183 goto end;
2184 }
2185
2186 ret = lttng_add_context(handle, &context, NULL, channel_name);
2187 if (context.ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
2188 free(context.u.app_ctx.provider_name);
2189 free(context.u.app_ctx.ctx_name);
2190 }
2191 end:
2192 return ret;
2193 }
2194
2195 static
2196 int process_contexts_node(xmlNodePtr contexts_node,
2197 struct lttng_handle *handle, const char *channel_name)
2198 {
2199 int ret = 0;
2200 xmlNodePtr context_node;
2201
2202 for (context_node = xmlFirstElementChild(contexts_node); context_node;
2203 context_node = xmlNextElementSibling(context_node)) {
2204 ret = process_context_node(context_node, handle, channel_name);
2205 if (ret) {
2206 goto end;
2207 }
2208 }
2209 end:
2210 return ret;
2211 }
2212
2213 static
2214 int process_pid_tracker_node(xmlNodePtr pid_tracker_node,
2215 struct lttng_handle *handle)
2216 {
2217 int ret = 0, child;
2218 xmlNodePtr targets_node = NULL;
2219 xmlNodePtr node;
2220
2221 assert(handle);
2222 assert(pid_tracker_node);
2223 /* get the targets node */
2224 for (node = xmlFirstElementChild(pid_tracker_node); node;
2225 node = xmlNextElementSibling(node)) {
2226 if (!strcmp((const char *) node->name,
2227 config_element_targets)) {
2228 targets_node = node;
2229 break;
2230 }
2231 }
2232
2233 if (!targets_node) {
2234 ret = LTTNG_ERR_INVALID;
2235 goto end;
2236 }
2237
2238 /* Go through all pid_target node */
2239 child = xmlChildElementCount(targets_node);
2240 if (child == 0) {
2241 /* The session is explicitly set to target nothing. */
2242 ret = lttng_untrack_pid(handle, -1);
2243 if (ret) {
2244 goto end;
2245 }
2246 }
2247 for (node = xmlFirstElementChild(targets_node); node;
2248 node = xmlNextElementSibling(node)) {
2249 xmlNodePtr pid_target_node = node;
2250
2251 /* get pid node and track it */
2252 for (node = xmlFirstElementChild(pid_target_node); node;
2253 node = xmlNextElementSibling(node)) {
2254 if (!strcmp((const char *) node->name,
2255 config_element_pid)) {
2256 int64_t pid;
2257 xmlChar *content = NULL;
2258
2259 content = xmlNodeGetContent(node);
2260 if (!content) {
2261 ret = LTTNG_ERR_LOAD_INVALID_CONFIG;
2262 goto end;
2263 }
2264
2265 ret = parse_int(content, &pid);
2266 free(content);
2267 if (ret) {
2268 ret = LTTNG_ERR_LOAD_INVALID_CONFIG;
2269 goto end;
2270 }
2271
2272 ret = lttng_track_pid(handle, (int) pid);
2273 if (ret) {
2274 goto end;
2275 }
2276 }
2277 }
2278 node = pid_target_node;
2279 }
2280
2281 end:
2282 return ret;
2283 }
2284
2285
2286 static
2287 int process_domain_node(xmlNodePtr domain_node, const char *session_name)
2288 {
2289 int ret;
2290 struct lttng_domain domain = { 0 };
2291 struct lttng_handle *handle = NULL;
2292 xmlNodePtr channels_node = NULL;
2293 xmlNodePtr trackers_node = NULL;
2294 xmlNodePtr pid_tracker_node = NULL;
2295 xmlNodePtr node;
2296
2297 assert(session_name);
2298
2299 ret = init_domain(domain_node, &domain);
2300 if (ret) {
2301 goto end;
2302 }
2303
2304 handle = lttng_create_handle(session_name, &domain);
2305 if (!handle) {
2306 ret = -LTTNG_ERR_NOMEM;
2307 goto end;
2308 }
2309
2310 /* get the channels node */
2311 for (node = xmlFirstElementChild(domain_node); node;
2312 node = xmlNextElementSibling(node)) {
2313 if (!strcmp((const char *) node->name,
2314 config_element_channels)) {
2315 channels_node = node;
2316 break;
2317 }
2318 }
2319
2320 if (!channels_node) {
2321 goto end;
2322 }
2323
2324 /* create all channels */
2325 for (node = xmlFirstElementChild(channels_node); node;
2326 node = xmlNextElementSibling(node)) {
2327 struct lttng_channel channel;
2328 xmlNodePtr contexts_node = NULL;
2329 xmlNodePtr events_node = NULL;
2330 xmlNodePtr channel_attr_node;
2331
2332 memset(&channel, 0, sizeof(channel));
2333 lttng_channel_set_default_attr(&domain, &channel.attr);
2334
2335 for (channel_attr_node = xmlFirstElementChild(node);
2336 channel_attr_node; channel_attr_node =
2337 xmlNextElementSibling(channel_attr_node)) {
2338 ret = process_channel_attr_node(channel_attr_node,
2339 &channel, &contexts_node, &events_node);
2340 if (ret) {
2341 goto end;
2342 }
2343 }
2344
2345 ret = lttng_enable_channel(handle, &channel);
2346 if (ret < 0) {
2347 goto end;
2348 }
2349
2350 ret = process_events_node(events_node, handle, channel.name);
2351 if (ret) {
2352 goto end;
2353 }
2354
2355 ret = process_contexts_node(contexts_node, handle,
2356 channel.name);
2357 if (ret) {
2358 goto end;
2359 }
2360 }
2361
2362 /* get the trackers node */
2363 for (node = xmlFirstElementChild(domain_node); node;
2364 node = xmlNextElementSibling(node)) {
2365 if (!strcmp((const char *) node->name,
2366 config_element_trackers)) {
2367 trackers_node = node;
2368 break;
2369 }
2370 }
2371
2372 if (!trackers_node) {
2373 goto end;
2374 }
2375
2376 for (node = xmlFirstElementChild(trackers_node); node;
2377 node = xmlNextElementSibling(node)) {
2378 if (!strcmp((const char *)node->name,config_element_pid_tracker)) {
2379 pid_tracker_node = node;
2380 ret = process_pid_tracker_node(pid_tracker_node, handle);
2381 if (ret) {
2382 goto end;
2383 }
2384 }
2385 }
2386
2387 if (!pid_tracker_node) {
2388 lttng_track_pid(handle, -1);
2389 }
2390
2391 end:
2392 lttng_destroy_handle(handle);
2393 return ret;
2394 }
2395
2396 static
2397 int process_session_node(xmlNodePtr session_node, const char *session_name,
2398 int override)
2399 {
2400 int ret, started = -1, snapshot_mode = -1;
2401 uint64_t live_timer_interval = UINT64_MAX;
2402 xmlChar *name = NULL;
2403 xmlChar *shm_path = NULL;
2404 xmlNodePtr domains_node = NULL;
2405 xmlNodePtr output_node = NULL;
2406 xmlNodePtr node;
2407 struct lttng_domain *kernel_domain = NULL;
2408 struct lttng_domain *ust_domain = NULL;
2409 struct lttng_domain *jul_domain = NULL;
2410 struct lttng_domain *log4j_domain = NULL;
2411 struct lttng_domain *python_domain = NULL;
2412
2413 for (node = xmlFirstElementChild(session_node); node;
2414 node = xmlNextElementSibling(node)) {
2415 if (!name && !strcmp((const char *) node->name,
2416 config_element_name)) {
2417 /* name */
2418 xmlChar *node_content = xmlNodeGetContent(node);
2419 if (!node_content) {
2420 ret = -LTTNG_ERR_NOMEM;
2421 goto error;
2422 }
2423
2424 name = node_content;
2425 } else if (!domains_node && !strcmp((const char *) node->name,
2426 config_element_domains)) {
2427 /* domains */
2428 domains_node = node;
2429 } else if (started == -1 && !strcmp((const char *) node->name,
2430 config_element_started)) {
2431 /* started */
2432 xmlChar *node_content = xmlNodeGetContent(node);
2433 if (!node_content) {
2434 ret = -LTTNG_ERR_NOMEM;
2435 goto error;
2436 }
2437
2438 ret = parse_bool(node_content, &started);
2439 free(node_content);
2440 if (ret) {
2441 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2442 goto error;
2443 }
2444 } else if (!output_node && !strcmp((const char *) node->name,
2445 config_element_output)) {
2446 /* output */
2447 output_node = node;
2448 } else if (!shm_path && !strcmp((const char *) node->name,
2449 config_element_shared_memory_path)) {
2450 /* shared memory path */
2451 xmlChar *node_content = xmlNodeGetContent(node);
2452 if (!node_content) {
2453 ret = -LTTNG_ERR_NOMEM;
2454 goto error;
2455 }
2456
2457 shm_path = node_content;
2458 } else {
2459 /* attributes, snapshot_mode or live_timer_interval */
2460 xmlNodePtr attributes_child =
2461 xmlFirstElementChild(node);
2462
2463 if (!strcmp((const char *) attributes_child->name,
2464 config_element_snapshot_mode)) {
2465 /* snapshot_mode */
2466 xmlChar *snapshot_mode_content =
2467 xmlNodeGetContent(attributes_child);
2468 if (!snapshot_mode_content) {
2469 ret = -LTTNG_ERR_NOMEM;
2470 goto error;
2471 }
2472
2473 ret = parse_bool(snapshot_mode_content, &snapshot_mode);
2474 free(snapshot_mode_content);
2475 if (ret) {
2476 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2477 goto error;
2478 }
2479 } else {
2480 /* live_timer_interval */
2481 xmlChar *timer_interval_content =
2482 xmlNodeGetContent(attributes_child);
2483 if (!timer_interval_content) {
2484 ret = -LTTNG_ERR_NOMEM;
2485 goto error;
2486 }
2487
2488 ret = parse_uint(timer_interval_content, &live_timer_interval);
2489 free(timer_interval_content);
2490 if (ret) {
2491 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2492 goto error;
2493 }
2494 }
2495 }
2496 }
2497
2498 if (!name) {
2499 /* Mandatory attribute, as defined in the session XSD */
2500 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2501 goto error;
2502 }
2503
2504 if (session_name && strcmp((char *) name, session_name)) {
2505 /* This is not the session we are looking for */
2506 ret = -LTTNG_ERR_NO_SESSION;
2507 goto error;
2508 }
2509
2510 /* Init domains to create the session handles */
2511 for (node = xmlFirstElementChild(domains_node); node;
2512 node = xmlNextElementSibling(node)) {
2513 struct lttng_domain *domain;
2514
2515 domain = zmalloc(sizeof(*domain));
2516 if (!domain) {
2517 ret = -LTTNG_ERR_NOMEM;
2518 goto error;
2519 }
2520
2521 ret = init_domain(node, domain);
2522 if (ret) {
2523 goto domain_init_error;
2524 }
2525
2526 switch (domain->type) {
2527 case LTTNG_DOMAIN_KERNEL:
2528 if (kernel_domain) {
2529 /* Same domain seen twice, invalid! */
2530 goto domain_init_error;
2531 }
2532 kernel_domain = domain;
2533 break;
2534 case LTTNG_DOMAIN_UST:
2535 if (ust_domain) {
2536 /* Same domain seen twice, invalid! */
2537 goto domain_init_error;
2538 }
2539 ust_domain = domain;
2540 break;
2541 case LTTNG_DOMAIN_JUL:
2542 if (jul_domain) {
2543 /* Same domain seen twice, invalid! */
2544 goto domain_init_error;
2545 }
2546 jul_domain = domain;
2547 break;
2548 case LTTNG_DOMAIN_LOG4J:
2549 if (log4j_domain) {
2550 /* Same domain seen twice, invalid! */
2551 goto domain_init_error;
2552 }
2553 log4j_domain = domain;
2554 break;
2555 case LTTNG_DOMAIN_PYTHON:
2556 if (python_domain) {
2557 /* Same domain seen twice, invalid! */
2558 goto domain_init_error;
2559 }
2560 python_domain = domain;
2561 break;
2562 default:
2563 WARN("Invalid domain type");
2564 goto domain_init_error;
2565 }
2566 continue;
2567 domain_init_error:
2568 free(domain);
2569 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2570 goto error;
2571 }
2572
2573 if (override) {
2574 /* Destroy session if it exists */
2575 ret = lttng_destroy_session((const char *) name);
2576 if (ret && ret != -LTTNG_ERR_SESS_NOT_FOUND) {
2577 ERR("Failed to destroy existing session.");
2578 goto error;
2579 }
2580 }
2581
2582 /* Create session type depending on output type */
2583 if (snapshot_mode && snapshot_mode != -1) {
2584 ret = create_snapshot_session((const char *) name, output_node);
2585 } else if (live_timer_interval &&
2586 live_timer_interval != UINT64_MAX) {
2587 ret = create_session((const char *) name, kernel_domain,
2588 ust_domain, jul_domain, log4j_domain,
2589 output_node, live_timer_interval);
2590 } else {
2591 /* regular session */
2592 ret = create_session((const char *) name, kernel_domain,
2593 ust_domain, jul_domain, log4j_domain,
2594 output_node, UINT64_MAX);
2595 }
2596 if (ret) {
2597 goto error;
2598 }
2599
2600 if (shm_path) {
2601 ret = lttng_set_session_shm_path((const char *) name,
2602 (const char *) shm_path);
2603 if (ret) {
2604 goto error;
2605 }
2606 }
2607
2608 for (node = xmlFirstElementChild(domains_node); node;
2609 node = xmlNextElementSibling(node)) {
2610 ret = process_domain_node(node, (const char *) name);
2611 if (ret) {
2612 goto end;
2613 }
2614 }
2615
2616 if (started) {
2617 ret = lttng_start_tracing((const char *) name);
2618 if (ret) {
2619 goto end;
2620 }
2621 }
2622
2623 end:
2624 if (ret < 0) {
2625 ERR("Failed to load session %s: %s", (const char *) name,
2626 lttng_strerror(ret));
2627 lttng_destroy_session((const char *) name);
2628 }
2629
2630 error:
2631 free(kernel_domain);
2632 free(ust_domain);
2633 free(jul_domain);
2634 free(log4j_domain);
2635 free(python_domain);
2636 xmlFree(name);
2637 xmlFree(shm_path);
2638 return ret;
2639 }
2640
2641 /*
2642 * Return 1 if the given path is readable by the current UID or 0 if not.
2643 * Return -1 if the path is EPERM.
2644 */
2645 static int validate_file_read_creds(const char *path)
2646 {
2647 int ret;
2648
2649 assert(path);
2650
2651 /* Can we read the file. */
2652 ret = access(path, R_OK);
2653 if (!ret) {
2654 goto valid;
2655 }
2656 if (errno == EACCES) {
2657 return -1;
2658 } else {
2659 /* Invalid. */
2660 return 0;
2661 }
2662 valid:
2663 return 1;
2664 }
2665
2666 static
2667 int load_session_from_file(const char *path, const char *session_name,
2668 struct session_config_validation_ctx *validation_ctx, int override)
2669 {
2670 int ret, session_found = !session_name;
2671 xmlDocPtr doc = NULL;
2672 xmlNodePtr sessions_node;
2673 xmlNodePtr session_node;
2674
2675 assert(path);
2676 assert(validation_ctx);
2677
2678 ret = validate_file_read_creds(path);
2679 if (ret != 1) {
2680 if (ret == -1) {
2681 ret = -LTTNG_ERR_EPERM;
2682 } else {
2683 ret = -LTTNG_ERR_LOAD_SESSION_NOENT;
2684 }
2685 goto end;
2686 }
2687
2688 doc = xmlParseFile(path);
2689 if (!doc) {
2690 ret = -LTTNG_ERR_LOAD_IO_FAIL;
2691 goto end;
2692 }
2693
2694 ret = xmlSchemaValidateDoc(validation_ctx->schema_validation_ctx, doc);
2695 if (ret) {
2696 ERR("Session configuration file validation failed");
2697 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2698 goto end;
2699 }
2700
2701 sessions_node = xmlDocGetRootElement(doc);
2702 if (!sessions_node) {
2703 goto end;
2704 }
2705
2706 for (session_node = xmlFirstElementChild(sessions_node);
2707 session_node; session_node =
2708 xmlNextElementSibling(session_node)) {
2709 ret = process_session_node(session_node,
2710 session_name, override);
2711 if (session_name && ret == 0) {
2712 /* Target session found and loaded */
2713 session_found = 1;
2714 break;
2715 }
2716 }
2717 end:
2718 xmlFreeDoc(doc);
2719 if (!ret) {
2720 ret = session_found ? 0 : -LTTNG_ERR_LOAD_SESSION_NOENT;
2721 }
2722 return ret;
2723 }
2724
2725 /* Allocate dirent as recommended by READDIR(3), NOTES on readdir_r */
2726 static
2727 struct dirent *alloc_dirent(const char *path)
2728 {
2729 size_t len;
2730 long name_max;
2731 struct dirent *entry;
2732
2733 name_max = pathconf(path, _PC_NAME_MAX);
2734 if (name_max == -1) {
2735 name_max = PATH_MAX;
2736 }
2737 len = offsetof(struct dirent, d_name) + name_max + 1;
2738 entry = zmalloc(len);
2739 return entry;
2740 }
2741
2742 static
2743 int load_session_from_path(const char *path, const char *session_name,
2744 struct session_config_validation_ctx *validation_ctx, int override)
2745 {
2746 int ret, session_found = !session_name;
2747 DIR *directory = NULL;
2748
2749 assert(path);
2750 assert(validation_ctx);
2751
2752 directory = opendir(path);
2753 if (!directory) {
2754 switch (errno) {
2755 case ENOTDIR:
2756 /* Try the file loading. */
2757 break;
2758 case ENOENT:
2759 ret = -LTTNG_ERR_LOAD_SESSION_NOENT;
2760 goto end;
2761 default:
2762 ret = -LTTNG_ERR_LOAD_IO_FAIL;
2763 goto end;
2764 }
2765 }
2766 if (directory) {
2767 struct dirent *entry;
2768 struct dirent *result;
2769 char *file_path = NULL;
2770 size_t path_len = strlen(path);
2771
2772 if (path_len >= PATH_MAX) {
2773 ret = -LTTNG_ERR_INVALID;
2774 goto end;
2775 }
2776
2777 entry = alloc_dirent(path);
2778 if (!entry) {
2779 ret = -LTTNG_ERR_NOMEM;
2780 goto end;
2781 }
2782
2783 file_path = zmalloc(PATH_MAX);
2784 if (!file_path) {
2785 ret = -LTTNG_ERR_NOMEM;
2786 free(entry);
2787 goto end;
2788 }
2789
2790 strncpy(file_path, path, path_len);
2791 if (file_path[path_len - 1] != '/') {
2792 file_path[path_len++] = '/';
2793 }
2794
2795 ret = 0;
2796 /* Search for *.lttng files */
2797 while (!readdir_r(directory, entry, &result) && result) {
2798 size_t file_name_len = strlen(result->d_name);
2799
2800 if (file_name_len <=
2801 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION)) {
2802 continue;
2803 }
2804
2805 if (path_len + file_name_len >= PATH_MAX) {
2806 continue;
2807 }
2808
2809 if (strcmp(DEFAULT_SESSION_CONFIG_FILE_EXTENSION,
2810 result->d_name + file_name_len - sizeof(
2811 DEFAULT_SESSION_CONFIG_FILE_EXTENSION) + 1)) {
2812 continue;
2813 }
2814
2815 strncpy(file_path + path_len, result->d_name, file_name_len);
2816 file_path[path_len + file_name_len] = '\0';
2817
2818 ret = load_session_from_file(file_path, session_name,
2819 validation_ctx, override);
2820 if (session_name && !ret) {
2821 session_found = 1;
2822 break;
2823 }
2824 }
2825
2826 free(entry);
2827 free(file_path);
2828 } else {
2829 ret = load_session_from_file(path, session_name,
2830 validation_ctx, override);
2831 if (ret) {
2832 goto end;
2833 } else {
2834 session_found = 1;
2835 }
2836 }
2837
2838 end:
2839 if (directory) {
2840 if (closedir(directory)) {
2841 PERROR("closedir");
2842 }
2843 }
2844
2845 if (session_found) {
2846 ret = 0;
2847 }
2848
2849 return ret;
2850 }
2851
2852 /*
2853 * Validate that the given path's credentials and the current process have the
2854 * same UID. If so, return 1 else return 0 if it does NOT match.
2855 */
2856 static int validate_path_creds(const char *path)
2857 {
2858 int ret, uid = getuid();
2859 struct stat buf;
2860
2861 assert(path);
2862
2863 if (uid == 0) {
2864 goto valid;
2865 }
2866
2867 ret = stat(path, &buf);
2868 if (ret < 0) {
2869 if (errno != ENOENT) {
2870 PERROR("stat");
2871 }
2872 ret = -LTTNG_ERR_INVALID;
2873 goto valid;
2874 }
2875
2876 if (buf.st_uid != uid) {
2877 goto invalid;
2878 }
2879
2880 valid:
2881 return 1;
2882 invalid:
2883 return 0;
2884 }
2885
2886 LTTNG_HIDDEN
2887 int config_load_session(const char *path, const char *session_name,
2888 int override, unsigned int autoload)
2889 {
2890 int ret;
2891 bool session_loaded = false;
2892 const char *path_ptr = NULL;
2893 struct session_config_validation_ctx validation_ctx = { 0 };
2894
2895 ret = init_session_config_validation_ctx(&validation_ctx);
2896 if (ret) {
2897 goto end;
2898 }
2899
2900 if (!path) {
2901 char *home_path;
2902 const char *sys_path;
2903
2904 /* Try home path */
2905 home_path = utils_get_home_dir();
2906 if (home_path) {
2907 char path[PATH_MAX];
2908
2909 /*
2910 * Try user session configuration path. Ignore error here so we can
2911 * continue loading the system wide sessions.
2912 */
2913 if (autoload) {
2914 ret = snprintf(path, sizeof(path),
2915 DEFAULT_SESSION_HOME_CONFIGPATH "/"
2916 DEFAULT_SESSION_CONFIG_AUTOLOAD, home_path);
2917 if (ret < 0) {
2918 PERROR("snprintf session autoload home config path");
2919 goto end;
2920 }
2921
2922 /*
2923 * Credentials are only validated for the autoload in order to
2924 * avoid any user session daemon to try to load kernel sessions
2925 * automatically and failing all the times.
2926 */
2927 ret = validate_path_creds(path);
2928 if (ret) {
2929 path_ptr = path;
2930 }
2931 } else {
2932 ret = snprintf(path, sizeof(path),
2933 DEFAULT_SESSION_HOME_CONFIGPATH, home_path);
2934 if (ret < 0) {
2935 PERROR("snprintf session home config path");
2936 goto end;
2937 }
2938 path_ptr = path;
2939 }
2940 if (path_ptr) {
2941 ret = load_session_from_path(path_ptr, session_name,
2942 &validation_ctx, override);
2943 if (ret && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) {
2944 goto end;
2945 }
2946 /*
2947 * Continue even if the session was found since we have to try
2948 * the system wide sessions.
2949 */
2950 session_loaded = true;
2951 }
2952 }
2953
2954 /* Reset path pointer for the system wide dir. */
2955 path_ptr = NULL;
2956
2957 /* Try system wide configuration directory. */
2958 if (autoload) {
2959 sys_path = DEFAULT_SESSION_SYSTEM_CONFIGPATH "/"
2960 DEFAULT_SESSION_CONFIG_AUTOLOAD;
2961 ret = validate_path_creds(sys_path);
2962 if (ret) {
2963 path_ptr = sys_path;
2964 }
2965 } else {
2966 sys_path = DEFAULT_SESSION_SYSTEM_CONFIGPATH;
2967 path_ptr = sys_path;
2968 }
2969
2970 if (path_ptr) {
2971 ret = load_session_from_path(path_ptr, session_name,
2972 &validation_ctx, override);
2973 if (!ret) {
2974 session_loaded = true;
2975 }
2976 }
2977 } else {
2978 ret = access(path, F_OK);
2979 if (ret < 0) {
2980 PERROR("access");
2981 switch (errno) {
2982 case ENOENT:
2983 ret = -LTTNG_ERR_INVALID;
2984 WARN("Session configuration path does not exist.");
2985 break;
2986 case EACCES:
2987 ret = -LTTNG_ERR_EPERM;
2988 break;
2989 default:
2990 ret = -LTTNG_ERR_UNK;
2991 break;
2992 }
2993 goto end;
2994 }
2995
2996 ret = load_session_from_path(path, session_name,
2997 &validation_ctx, override);
2998 }
2999 end:
3000 fini_session_config_validation_ctx(&validation_ctx);
3001 if (ret == -LTTNG_ERR_LOAD_SESSION_NOENT && !session_name && !path) {
3002 /*
3003 * Don't report an error if no sessions are found when called
3004 * without a session_name or a search path.
3005 */
3006 ret = 0;
3007 }
3008
3009 if (session_loaded && ret == -LTTNG_ERR_LOAD_SESSION_NOENT) {
3010 /* A matching session was found in one of the search paths. */
3011 ret = 0;
3012 }
3013 return ret;
3014 }
LTTng 2.0 tools and control repository
This page took 0.0877599999999999 seconds and 5 git commands to generate.