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


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