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


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