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