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