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