projects / lttng-tools.git / blob
? search:


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