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