Refactor: lttng-ctl: follow terminology of the tracker documentation
[lttng-tools.git] / src / common / config / session-config.c
1 /*
2 * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 */
7
8 #include "lttng/tracker.h"
9 #define _LGPL_SOURCE
10 #include <assert.h>
11 #include <ctype.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <inttypes.h>
16 #include <dirent.h>
17 #include <unistd.h>
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <stdbool.h>
21
22 #include <common/defaults.h>
23 #include <common/error.h>
24 #include <common/macros.h>
25 #include <common/utils.h>
26 #include <common/dynamic-buffer.h>
27 #include <common/compat/getenv.h>
28 #include <lttng/lttng-error.h>
29 #include <libxml/parser.h>
30 #include <libxml/valid.h>
31 #include <libxml/xmlschemas.h>
32 #include <libxml/tree.h>
33 #include <lttng/lttng.h>
34 #include <lttng/snapshot.h>
35 #include <lttng/rotation.h>
36 #include <lttng/userspace-probe.h>
37
38 #include "session-config.h"
39 #include "config-internal.h"
40
41 #define CONFIG_USERSPACE_PROBE_LOOKUP_METHOD_NAME_MAX_LEN 7
42
43 struct handler_filter_args {
44 const char* section;
45 config_entry_handler_cb handler;
46 void *user_data;
47 };
48
49 struct session_config_validation_ctx {
50 xmlSchemaParserCtxtPtr parser_ctx;
51 xmlSchemaPtr schema;
52 xmlSchemaValidCtxtPtr schema_validation_ctx;
53 };
54
55 LTTNG_HIDDEN const char * const config_element_all = "all";
56 const char * const config_str_yes = "yes";
57 const char * const config_str_true = "true";
58 const char * const config_str_on = "on";
59 const char * const config_str_no = "no";
60 const char * const config_str_false = "false";
61 const char * const config_str_off = "off";
62 const char * const config_xml_encoding = "UTF-8";
63 const size_t config_xml_encoding_bytes_per_char = 2; /* Size of the encoding's largest character */
64 const char * const config_xml_indent_string = "\t";
65 const char * const config_xml_true = "true";
66 const char * const config_xml_false = "false";
67
68 const char * const config_element_channel = "channel";
69 const char * const config_element_channels = "channels";
70 const char * const config_element_domain = "domain";
71 const char * const config_element_domains = "domains";
72 const char * const config_element_event = "event";
73 const char * const config_element_events = "events";
74 const char * const config_element_context = "context";
75 const char * const config_element_contexts = "contexts";
76 const char * const config_element_attributes = "attributes";
77 const char * const config_element_exclusion = "exclusion";
78 const char * const config_element_exclusions = "exclusions";
79 const char * const config_element_function_attributes = "function_attributes";
80 const char * const config_element_probe_attributes = "probe_attributes";
81 const char * const config_element_symbol_name = "symbol_name";
82 const char * const config_element_address = "address";
83 const char * const config_element_offset = "offset";
84
85 LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup = "lookup_method";
86 LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup_function_default = "DEFAULT";
87 LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup_function_elf = "ELF";
88 LTTNG_HIDDEN const char * const config_element_userspace_probe_lookup_tracepoint_sdt = "SDT";
89 LTTNG_HIDDEN const char * const config_element_userspace_probe_location_binary_path = "binary_path";
90 LTTNG_HIDDEN const char * const config_element_userspace_probe_function_attributes = "userspace_probe_function_attributes";
91 LTTNG_HIDDEN const char * const config_element_userspace_probe_function_location_function_name = "function_name";
92 LTTNG_HIDDEN const char * const config_element_userspace_probe_tracepoint_attributes = "userspace_probe_tracepoint_attributes";
93 LTTNG_HIDDEN const char * const config_element_userspace_probe_tracepoint_location_provider_name = "provider_name";
94 LTTNG_HIDDEN const char * const config_element_userspace_probe_tracepoint_location_probe_name = "probe_name";
95
96 const char * const config_element_name = "name";
97 const char * const config_element_enabled = "enabled";
98 const char * const config_element_overwrite_mode = "overwrite_mode";
99 const char * const config_element_subbuf_size = "subbuffer_size";
100 const char * const config_element_num_subbuf = "subbuffer_count";
101 const char * const config_element_switch_timer_interval = "switch_timer_interval";
102 const char * const config_element_read_timer_interval = "read_timer_interval";
103 LTTNG_HIDDEN const char * const config_element_monitor_timer_interval = "monitor_timer_interval";
104 LTTNG_HIDDEN const char * const config_element_blocking_timeout = "blocking_timeout";
105 const char * const config_element_output = "output";
106 const char * const config_element_output_type = "output_type";
107 const char * const config_element_tracefile_size = "tracefile_size";
108 const char * const config_element_tracefile_count = "tracefile_count";
109 const char * const config_element_live_timer_interval = "live_timer_interval";
110 LTTNG_HIDDEN const char * const config_element_discarded_events = "discarded_events";
111 LTTNG_HIDDEN const char * const config_element_lost_packets = "lost_packets";
112 const char * const config_element_type = "type";
113 const char * const config_element_buffer_type = "buffer_type";
114 const char * const config_element_session = "session";
115 const char * const config_element_sessions = "sessions";
116 LTTNG_HIDDEN const char * const config_element_context_perf = "perf";
117 LTTNG_HIDDEN const char * const config_element_context_app = "app";
118 LTTNG_HIDDEN const char * const config_element_context_app_provider_name = "provider_name";
119 LTTNG_HIDDEN const char * const config_element_context_app_ctx_name = "ctx_name";
120 const char * const config_element_config = "config";
121 const char * const config_element_started = "started";
122 const char * const config_element_snapshot_mode = "snapshot_mode";
123 const char * const config_element_loglevel = "loglevel";
124 const char * const config_element_loglevel_type = "loglevel_type";
125 const char * const config_element_filter = "filter";
126 LTTNG_HIDDEN const char * const config_element_filter_expression = "filter_expression";
127 const char * const config_element_snapshot_outputs = "snapshot_outputs";
128 const char * const config_element_consumer_output = "consumer_output";
129 const char * const config_element_destination = "destination";
130 const char * const config_element_path = "path";
131 const char * const config_element_net_output = "net_output";
132 const char * const config_element_control_uri = "control_uri";
133 const char * const config_element_data_uri = "data_uri";
134 const char * const config_element_max_size = "max_size";
135 const char * const config_element_pid = "pid";
136 const char * const config_element_pids = "pids";
137 const char * const config_element_shared_memory_path = "shared_memory_path";
138
139 LTTNG_HIDDEN const char * const config_element_process_attr_id = "id";
140 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_pid = "pid_process_attr_tracker";
141 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_vpid = "vpid_process_attr_tracker";
142 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_uid = "uid_process_attr_tracker";
143 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_vuid = "vuid_process_attr_tracker";
144 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_gid = "gid_process_attr_tracker";
145 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_vgid = "vgid_process_attr_tracker";
146 LTTNG_HIDDEN const char * const config_element_process_attr_trackers = "process_attr_trackers";
147 LTTNG_HIDDEN const char * const config_element_process_attr_values = "process_attr_values";
148 LTTNG_HIDDEN const char * const config_element_process_attr_value_type = "process_attr_value_type";
149 LTTNG_HIDDEN const char * const config_element_process_attr_pid_value = "pid";
150 LTTNG_HIDDEN const char * const config_element_process_attr_vpid_value = "vpid";
151 LTTNG_HIDDEN const char * const config_element_process_attr_uid_value = "uid";
152 LTTNG_HIDDEN const char * const config_element_process_attr_vuid_value = "vuid";
153 LTTNG_HIDDEN const char * const config_element_process_attr_gid_value = "gid";
154 LTTNG_HIDDEN const char * const config_element_process_attr_vgid_value = "vgid";
155 LTTNG_HIDDEN const char * const config_element_process_attr_tracker_type = "process_attr_tracker_type";
156
157 LTTNG_HIDDEN const char * const config_element_rotation_schedules = "rotation_schedules";
158 LTTNG_HIDDEN const char * const config_element_rotation_schedule_periodic = "periodic";
159 LTTNG_HIDDEN const char * const config_element_rotation_schedule_periodic_time_us = "time_us";
160 LTTNG_HIDDEN const char * const config_element_rotation_schedule_size_threshold = "size_threshold";
161 LTTNG_HIDDEN const char * const config_element_rotation_schedule_size_threshold_bytes = "bytes";
162
163 const char * const config_domain_type_kernel = "KERNEL";
164 const char * const config_domain_type_ust = "UST";
165 const char * const config_domain_type_jul = "JUL";
166 const char * const config_domain_type_log4j = "LOG4J";
167 const char * const config_domain_type_python = "PYTHON";
168
169 const char * const config_buffer_type_per_pid = "PER_PID";
170 const char * const config_buffer_type_per_uid = "PER_UID";
171 const char * const config_buffer_type_global = "GLOBAL";
172
173 const char * const config_overwrite_mode_discard = "DISCARD";
174 const char * const config_overwrite_mode_overwrite = "OVERWRITE";
175
176 const char * const config_output_type_splice = "SPLICE";
177 const char * const config_output_type_mmap = "MMAP";
178
179 const char * const config_loglevel_type_all = "ALL";
180 const char * const config_loglevel_type_range = "RANGE";
181 const char * const config_loglevel_type_single = "SINGLE";
182
183 const char * const config_event_type_all = "ALL";
184 const char * const config_event_type_tracepoint = "TRACEPOINT";
185 const char * const config_event_type_probe = "PROBE";
186 LTTNG_HIDDEN const char * const config_event_type_userspace_probe = "USERSPACE_PROBE";
187 const char * const config_event_type_function = "FUNCTION";
188 const char * const config_event_type_function_entry = "FUNCTION_ENTRY";
189 const char * const config_event_type_noop = "NOOP";
190 const char * const config_event_type_syscall = "SYSCALL";
191 const char * const config_event_type_kprobe = "KPROBE";
192 const char * const config_event_type_kretprobe = "KRETPROBE";
193
194 const char * const config_event_context_pid = "PID";
195 const char * const config_event_context_procname = "PROCNAME";
196 const char * const config_event_context_prio = "PRIO";
197 const char * const config_event_context_nice = "NICE";
198 const char * const config_event_context_vpid = "VPID";
199 const char * const config_event_context_tid = "TID";
200 const char * const config_event_context_vtid = "VTID";
201 const char * const config_event_context_ppid = "PPID";
202 const char * const config_event_context_vppid = "VPPID";
203 const char * const config_event_context_pthread_id = "PTHREAD_ID";
204 const char * const config_event_context_hostname = "HOSTNAME";
205 const char * const config_event_context_ip = "IP";
206 const char * const config_event_context_perf_thread_counter = "PERF_THREAD_COUNTER";
207 LTTNG_HIDDEN const char * const config_event_context_app = "APP";
208 LTTNG_HIDDEN const char * const config_event_context_interruptible = "INTERRUPTIBLE";
209 LTTNG_HIDDEN const char * const config_event_context_preemptible = "PREEMPTIBLE";
210 LTTNG_HIDDEN const char * const config_event_context_need_reschedule = "NEED_RESCHEDULE";
211 LTTNG_HIDDEN const char * const config_event_context_migratable = "MIGRATABLE";
212 LTTNG_HIDDEN const char * const config_event_context_callstack_user= "CALLSTACK_USER";
213 LTTNG_HIDDEN const char * const config_event_context_callstack_kernel = "CALLSTACK_KERNEL";
214 LTTNG_HIDDEN const char * const config_event_context_cgroup_ns = "CGROUP_NS";
215 LTTNG_HIDDEN const char * const config_event_context_ipc_ns = "IPC_NS";
216 LTTNG_HIDDEN const char * const config_event_context_mnt_ns = "MNT_NS";
217 LTTNG_HIDDEN const char * const config_event_context_net_ns = "NET_NS";
218 LTTNG_HIDDEN const char * const config_event_context_pid_ns = "PID_NS";
219 LTTNG_HIDDEN const char * const config_event_context_user_ns = "USER_NS";
220 LTTNG_HIDDEN const char * const config_event_context_uts_ns = "UTS_NS";
221 LTTNG_HIDDEN const char * const config_event_context_uid = "UID";
222 LTTNG_HIDDEN const char * const config_event_context_euid = "EUID";
223 LTTNG_HIDDEN const char * const config_event_context_suid = "SUID";
224 LTTNG_HIDDEN const char * const config_event_context_gid = "GID";
225 LTTNG_HIDDEN const char * const config_event_context_egid = "EGID";
226 LTTNG_HIDDEN const char * const config_event_context_sgid = "SGID";
227 LTTNG_HIDDEN const char * const config_event_context_vuid = "VUID";
228 LTTNG_HIDDEN const char * const config_event_context_veuid = "VEUID";
229 LTTNG_HIDDEN const char * const config_event_context_vsuid = "VSUID";
230 LTTNG_HIDDEN const char * const config_event_context_vgid = "VGID";
231 LTTNG_HIDDEN const char * const config_event_context_vegid = "VEGID";
232 LTTNG_HIDDEN const char * const config_event_context_vsgid = "VSGID";
233
234 /* Deprecated symbols */
235 const char * const config_element_perf;
236
237 enum process_event_node_phase {
238 CREATION = 0,
239 ENABLE = 1,
240 };
241
242 struct consumer_output {
243 int enabled;
244 char *path;
245 char *control_uri;
246 char *data_uri;
247 };
248
249 static 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);
269 end:
270 return ret;
271 }
272
273 LTTNG_HIDDEN
274 int 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;
278 const char *path;
279 FILE *config_file = NULL;
280 struct handler_filter_args filter = { section, handler, user_data };
281
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. */
325 if (override_path) {
326 config_file = fopen(override_path, "r");
327 if (config_file) {
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);
333 } else {
334 ERR("Failed to open daemon configuration file at %s",
335 override_path);
336 ret = -ENOENT;
337 goto error;
338 }
339 }
340
341 /* Everything went well. */
342 ret = 0;
343
344 error:
345 return ret;
346 }
347
348 LTTNG_HIDDEN
349 int 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);
392 end:
393 return ret;
394 }
395
396 /*
397 * Returns a xmlChar string which must be released using xmlFree().
398 */
399 static 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 /*
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.
417 */
418 out_len = (in_len * 4) + 1;
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';
433 end:
434 return out_str;
435 }
436
437 LTTNG_HIDDEN
438 struct config_writer *config_writer_create(int fd_output, int indent)
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);
464 if (ret) {
465 goto error_destroy;
466 }
467
468 ret = xmlTextWriterSetIndent(writer->writer, indent);
469 if (ret) {
470 goto error_destroy;
471 }
472
473 end:
474 return writer;
475 error_destroy:
476 config_writer_destroy(writer);
477 return NULL;
478 }
479
480 LTTNG_HIDDEN
481 int 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);
500 end:
501 return ret;
502 }
503
504 LTTNG_HIDDEN
505 int 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);
524 end:
525 return ret >= 0 ? 0 : ret;
526 }
527
528 LTTNG_HIDDEN
529 int 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);
555 end:
556 xmlFree(encoded_name);
557 xmlFree(encoded_value);
558 return ret >= 0 ? 0 : ret;
559 }
560
561 LTTNG_HIDDEN
562 int 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);
572 end:
573 return ret >= 0 ? 0 : ret;
574 }
575
576 LTTNG_HIDDEN
577 int 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);
597 end:
598 return ret >= 0 ? 0 : ret;
599 }
600
601 LTTNG_HIDDEN
602 int 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);
622 end:
623 return ret >= 0 ? 0 : ret;
624 }
625
626 LTTNG_HIDDEN
627 int 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
634 LTTNG_HIDDEN
635 int 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,
661 encoded_value);
662 end:
663 xmlFree(encoded_element_name);
664 xmlFree(encoded_value);
665 return ret >= 0 ? 0 : ret;
666 }
667
668 static
669 void 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);
677 va_end(args);
678 if (ret == -1) {
679 ERR("String allocation failed in xml error handler");
680 return;
681 }
682
683 fprintf(stderr, "XML Error: %s", errMsg);
684 free(errMsg);
685 }
686
687 static
688 void 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
706 static
707 char *get_session_config_xsd_path()
708 {
709 char *xsd_path;
710 const char *base_path = lttng_secure_getenv(DEFAULT_SESSION_CONFIG_XSD_PATH_ENV);
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
726 strcpy(xsd_path, base_path);
727 if (xsd_path[base_path_len - 1] != '/') {
728 xsd_path[base_path_len++] = '/';
729 }
730
731 strcpy(xsd_path + base_path_len, DEFAULT_SESSION_CONFIG_XSD_FILENAME);
732 end:
733 return xsd_path;
734 }
735
736 static
737 int init_session_config_validation_ctx(
738 struct session_config_validation_ctx *ctx)
739 {
740 int ret;
741 char *xsd_path = get_session_config_xsd_path();
742
743 if (!xsd_path) {
744 ret = -LTTNG_ERR_NOMEM;
745 goto end;
746 }
747
748 ctx->parser_ctx = xmlSchemaNewParserCtxt(xsd_path);
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
775 end:
776 if (ret) {
777 fini_session_config_validation_ctx(ctx);
778 }
779
780 free(xsd_path);
781 return ret;
782 }
783
784 static
785 int 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
802 end:
803 return ret;
804 }
805
806 static
807 int 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
824 end:
825 return ret;
826 }
827
828 static
829 int 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 }
847 end:
848 return ret;
849 }
850
851 static
852 int 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;
866 } else if (!strcmp((char *) domain, config_domain_type_log4j)) {
867 ret = LTTNG_DOMAIN_LOG4J;
868 } else if (!strcmp((char *) domain, config_domain_type_python)) {
869 ret = LTTNG_DOMAIN_PYTHON;
870 } else {
871 goto error;
872 }
873
874 return ret;
875 error:
876 return -1;
877 }
878
879 static
880 int 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;
899 error:
900 return -1;
901 }
902
903 static
904 int 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;
922 error:
923 return -1;
924 }
925
926 static
927 int 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;
944 error:
945 return -1;
946 }
947
948 static
949 int 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;
963 } else if (!strcmp((char *) event_type,
964 config_event_type_userspace_probe)) {
965 ret = LTTNG_EVENT_USERSPACE_PROBE;
966 } else if (!strcmp((char *) event_type, config_event_type_function)) {
967 ret = LTTNG_EVENT_FUNCTION;
968 } else if (!strcmp((char *) event_type,
969 config_event_type_function_entry)) {
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;
980 error:
981 return -1;
982 }
983
984 static
985 int 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;
1006 error:
1007 return -1;
1008 }
1009
1010 /*
1011 * Return the context type or -1 on error.
1012 */
1013 static
1014 int 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;
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;
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;
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;
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;
1132 } else {
1133 goto error;
1134 }
1135
1136 return ret;
1137 error:
1138 return -1;
1139 }
1140
1141 static
1142 int 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;
1185 end:
1186 return ret;
1187 }
1188
1189 static
1190 int 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
1215 static
1216 int 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
1270 end:
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
1280 static
1281 int create_session_net_output(const char *name, const char *control_uri,
1282 const char *data_uri)
1283 {
1284 int ret;
1285 struct lttng_handle *handle;
1286 const char *uri = NULL;
1287
1288 assert(name);
1289
1290 handle = lttng_create_handle(name, NULL);
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);
1304 end:
1305 return ret;
1306 }
1307
1308 static
1309 int create_snapshot_session(const char *session_name, xmlNodePtr output_node,
1310 const struct config_load_session_override_attr *overrides)
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;
1340 const char *control_uri = NULL;
1341 const char *data_uri = NULL;
1342 const char *path = NULL;
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
1378 control_uri = output.control_uri;
1379 data_uri = output.data_uri;
1380 path = output.path;
1381
1382 if (overrides) {
1383 if (overrides->path_url) {
1384 path = overrides->path_url;
1385 /* Control/data_uri are null */
1386 control_uri = NULL;
1387 data_uri = NULL;
1388 } else {
1389 if (overrides->ctrl_url) {
1390 control_uri = overrides->ctrl_url;
1391 /* path is null */
1392 path = NULL;
1393 }
1394 if (overrides->data_url) {
1395 data_uri = overrides->data_url;
1396 /* path is null */
1397 path = NULL;
1398 }
1399 }
1400 }
1401
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
1418 if (path) {
1419 ret = lttng_snapshot_output_set_ctrl_url(path,
1420 snapshot_output);
1421 if (ret) {
1422 goto error_snapshot_output;
1423 }
1424 } else {
1425 if (control_uri) {
1426 ret = lttng_snapshot_output_set_ctrl_url(control_uri,
1427 snapshot_output);
1428 if (ret) {
1429 goto error_snapshot_output;
1430 }
1431 }
1432
1433 if (data_uri) {
1434 ret = lttng_snapshot_output_set_data_url(data_uri,
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);
1443 error_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 }
1453 end:
1454 return ret;
1455 }
1456
1457 static
1458 int create_session(const char *name,
1459 xmlNodePtr output_node,
1460 uint64_t live_timer_interval,
1461 const struct config_load_session_override_attr *overrides)
1462 {
1463 int ret;
1464 struct consumer_output output = { 0 };
1465 xmlNodePtr consumer_output_node;
1466 const char *control_uri = NULL;
1467 const char *data_uri = NULL;
1468 const char *path = NULL;
1469
1470 assert(name);
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
1493 control_uri = output.control_uri;
1494 data_uri = output.data_uri;
1495 path = output.path;
1496
1497 /* Check for override and apply them */
1498 if (overrides) {
1499 if (overrides->path_url) {
1500 path = overrides->path_url;
1501 /* control/data_uri are null */;
1502 control_uri = NULL;
1503 data_uri = NULL;
1504 } else {
1505 if (overrides->ctrl_url) {
1506 control_uri = overrides->ctrl_url;
1507 /* path is null */
1508 path = NULL;
1509 }
1510 if (overrides->data_url) {
1511 data_uri = overrides->data_url;
1512 /* path is null */
1513 path = NULL;
1514 }
1515 }
1516 }
1517
1518
1519 if (live_timer_interval != UINT64_MAX && !control_uri && !data_uri) {
1520 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1521 goto end;
1522 }
1523
1524 if (control_uri || data_uri) {
1525 /* network destination */
1526 if (live_timer_interval && live_timer_interval != UINT64_MAX) {
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);
1533 } else {
1534 ret = lttng_create_session(name, NULL);
1535 }
1536 if (ret) {
1537 goto end;
1538 }
1539
1540 ret = create_session_net_output(name, control_uri, data_uri);
1541 if (ret) {
1542 goto end;
1543 }
1544
1545 } else {
1546 /* either local output or no output */
1547 ret = lttng_create_session(name, path);
1548 if (ret) {
1549 goto end;
1550 }
1551 }
1552 end:
1553 free(output.path);
1554 free(output.control_uri);
1555 free(output.data_uri);
1556 return ret;
1557 }
1558
1559 static
1560 struct lttng_userspace_probe_location *
1561 process_userspace_probe_function_attribute_node(
1562 xmlNodePtr attribute_node)
1563 {
1564 xmlNodePtr function_attribute_node;
1565 char *function_name = NULL, *binary_path = NULL;
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)) {
1583 function_name = (char *) xmlNodeGetContent(function_attribute_node);
1584 if (!function_name) {
1585 goto error;
1586 }
1587 } else if (!strcmp((const char *) function_attribute_node->name,
1588 config_element_userspace_probe_location_binary_path)) {
1589 binary_path = (char *) xmlNodeGetContent(function_attribute_node);
1590 if (!binary_path) {
1591 goto error;
1592 }
1593 } else if (!strcmp((const char *) function_attribute_node->name,
1594 config_element_userspace_probe_lookup)) {
1595 char *lookup_method_name;
1596
1597 lookup_method_name = (char *) xmlNodeGetContent(
1598 function_attribute_node);
1599 if (!lookup_method_name) {
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");
1612 }
1613 } else {
1614 WARN("Unknown function lookup method");
1615 }
1616
1617 free(lookup_method_name);
1618 if (!lookup_method) {
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) {
1627 /* Ownership of lookup_method is transferred. */
1628 location =
1629 lttng_userspace_probe_location_function_create(
1630 binary_path, function_name,
1631 lookup_method);
1632 lookup_method = NULL;
1633 goto error;
1634 }
1635 }
1636 error:
1637 lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
1638 free(binary_path);
1639 free(function_name);
1640 return location;
1641 }
1642
1643 static
1644 struct lttng_userspace_probe_location *
1645 process_userspace_probe_tracepoint_attribute_node(
1646 xmlNodePtr attribute_node)
1647 {
1648 xmlNodePtr tracepoint_attribute_node;
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)) {
1665 probe_name = (char *) xmlNodeGetContent(tracepoint_attribute_node);
1666 if (!probe_name) {
1667 goto error;
1668 }
1669 } else if (!strcmp((const char *) tracepoint_attribute_node->name,
1670 config_element_userspace_probe_tracepoint_location_provider_name)) {
1671 provider_name = (char *) xmlNodeGetContent(tracepoint_attribute_node);
1672 if (!provider_name) {
1673 goto error;
1674 }
1675 } else if (!strcmp((const char *) tracepoint_attribute_node->name,
1676 config_element_userspace_probe_location_binary_path)) {
1677 binary_path = (char *) xmlNodeGetContent(tracepoint_attribute_node);
1678 if (!binary_path) {
1679 goto error;
1680 }
1681 } else if (!strcmp((const char *) tracepoint_attribute_node->name,
1682 config_element_userspace_probe_lookup)) {
1683 char *lookup_method_name;
1684
1685 lookup_method_name = (char *) xmlNodeGetContent(
1686 tracepoint_attribute_node);
1687 if (!lookup_method_name) {
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");
1697 }
1698 } else {
1699 WARN("Unknown tracepoint lookup method");
1700 }
1701
1702 free(lookup_method_name);
1703 if (!lookup_method) {
1704 goto error;
1705 }
1706 } else {
1707 WARN("Unknown tracepoint attribute");
1708 goto error;
1709 }
1710
1711 /* Check if all the necessary fields were found. */
1712 if (binary_path && provider_name && probe_name && lookup_method) {
1713 /* Ownership of lookup_method is transferred. */
1714 location =
1715 lttng_userspace_probe_location_tracepoint_create(
1716 binary_path, provider_name,
1717 probe_name, lookup_method);
1718 lookup_method = NULL;
1719 goto error;
1720 }
1721 }
1722 error:
1723 lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
1724 free(binary_path);
1725 free(provider_name);
1726 free(probe_name);
1727 return location;
1728 }
1729
1730 static
1731 int 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;
1782
1783 /* symbol_name */
1784 content = xmlNodeGetContent(probe_attribute_node);
1785 if (!content) {
1786 ret = -LTTNG_ERR_NOMEM;
1787 goto end;
1788 }
1789
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);
1798 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1799 free(content);
1800 goto end;
1801 }
1802 free(content);
1803 }
1804 ret = 0;
1805 end:
1806 return ret;
1807 }
1808
1809 static
1810 int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle,
1811 const char *channel_name, const enum process_event_node_phase phase)
1812 {
1813 int ret = 0, i;
1814 xmlNodePtr node;
1815 struct lttng_event *event;
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
1824 event = lttng_event_create();
1825 if (!event) {
1826 ret = -LTTNG_ERR_NOMEM;
1827 goto end;
1828 }
1829
1830 /* Initialize default log level which varies by domain */
1831 switch (handle->domain.type)
1832 {
1833 case LTTNG_DOMAIN_JUL:
1834 event->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
1835 break;
1836 case LTTNG_DOMAIN_LOG4J:
1837 event->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
1838 break;
1839 case LTTNG_DOMAIN_PYTHON:
1840 event->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
1841 break;
1842 case LTTNG_DOMAIN_UST:
1843 case LTTNG_DOMAIN_KERNEL:
1844 event->loglevel = LTTNG_LOGLEVEL_DEBUG;
1845 break;
1846 default:
1847 assert(0);
1848 }
1849
1850 for (node = xmlFirstElementChild(event_node); node;
1851 node = xmlNextElementSibling(node)) {
1852 if (!strcmp((const char *) node->name, config_element_name)) {
1853 xmlChar *content;
1854
1855 /* name */
1856 content = xmlNodeGetContent(node);
1857 if (!content) {
1858 ret = -LTTNG_ERR_NOMEM;
1859 goto end;
1860 }
1861
1862 ret = lttng_strncpy(event->name,
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);
1870 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1871 free(content);
1872 goto end;
1873 }
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
1885 ret = parse_bool(content, &event->enabled);
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
1908 event->type = ret;
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
1926 event->loglevel_type = ret;
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
1952 event->loglevel = loglevel;
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
1964 free(filter_expression);
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
2017 event->exclusion = 1;
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
2028 if (!strcmp((const char *) attribute_node->name,
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,
2039 &event->attr.probe);
2040 if (ret) {
2041 goto end;
2042 }
2043 }
2044 } else if (!strcmp((const char *) attribute_node->name,
2045 config_element_function_attributes)) {
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
2065 ret = lttng_strncpy(
2066 event->attr.ftrace.symbol_name,
2067 (char *) content, sym_len);
2068 if (ret == -1) {
2069 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2070 free(content);
2071 goto end;
2072 }
2073 free(content);
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;
2119 }
2120 }
2121 }
2122
2123 if ((event->enabled && phase == ENABLE) || phase == CREATION) {
2124 ret = lttng_enable_event_with_exclusions(handle, event, channel_name,
2125 filter_expression, exclusion_count, exclusions);
2126 if (ret < 0) {
2127 WARN("Enabling event (name:%s) on load failed.", event->name);
2128 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2129 goto end;
2130 }
2131 }
2132 ret = 0;
2133 end:
2134 for (i = 0; i < exclusion_count; i++) {
2135 free(exclusions[i]);
2136 }
2137
2138 lttng_event_destroy(event);
2139 free(exclusions);
2140 free(filter_expression);
2141 return ret;
2142 }
2143
2144 static
2145 int process_events_node(xmlNodePtr events_node, struct lttng_handle *handle,
2146 const char *channel_name)
2147 {
2148 int ret = 0;
2149 struct lttng_event event;
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)) {
2158 ret = process_event_node(node, handle, channel_name, CREATION);
2159 if (ret) {
2160 goto end;
2161 }
2162 }
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
2185 end:
2186 return ret;
2187 }
2188
2189 static
2190 int 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;
2203
2204 /* name */
2205 content = xmlNodeGetContent(attr_node);
2206 if (!content) {
2207 ret = -LTTNG_ERR_NOMEM;
2208 goto end;
2209 }
2210
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);
2219 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2220 free(content);
2221 goto end;
2222 }
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;
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 }
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 }
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;
2490 end:
2491 return ret;
2492 }
2493
2494 static
2495 int 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);
2516
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;
2530 } else if (!strcmp((const char *) context_child_node->name,
2531 config_element_context_perf)) {
2532 /* perf */
2533 xmlNodePtr perf_attr_node;
2534
2535 context.ctx = handle->domain.type == LTTNG_DOMAIN_KERNEL ?
2536 LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER :
2537 LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER;
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;
2590
2591 /* name */
2592 content = xmlNodeGetContent(perf_attr_node);
2593 if (!content) {
2594 ret = -LTTNG_ERR_NOMEM;
2595 goto end;
2596 }
2597
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);
2606 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2607 free(content);
2608 goto end;
2609 }
2610 free(content);
2611 }
2612 }
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;
2641 }
2642
2643 ret = lttng_add_context(handle, &context, NULL, channel_name);
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 }
2648 end:
2649 return ret;
2650 }
2651
2652 static
2653 int 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 }
2666 end:
2667 return ret;
2668 }
2669
2670 static int get_tracker_elements(enum lttng_process_attr process_attr,
2671 const char **element_id_tracker,
2672 const char **element_value_type,
2673 const char **element_value,
2674 const char **element_value_alias,
2675 const char **element_name)
2676 {
2677 int ret = 0;
2678
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;
2685 *element_name = NULL;
2686 break;
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;
2692 *element_name = NULL;
2693 break;
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;
2699 *element_name = config_element_name;
2700 break;
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;
2706 *element_name = config_element_name;
2707 break;
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;
2713 *element_name = config_element_name;
2714 break;
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;
2720 *element_name = config_element_name;
2721 break;
2722 default:
2723 ret = LTTNG_ERR_INVALID;
2724 }
2725 return ret;
2726 }
2727
2728 static int process_id_tracker_node(xmlNodePtr id_tracker_node,
2729 struct lttng_handle *handle,
2730 enum lttng_process_attr process_attr)
2731 {
2732 int ret = 0, child_count;
2733 xmlNodePtr targets_node = NULL;
2734 xmlNodePtr node;
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;
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;
2743
2744 assert(handle);
2745 assert(id_tracker_node);
2746
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,
2756 &element_target_id, &element_id, &element_id_alias,
2757 &element_name);
2758 if (ret) {
2759 goto end;
2760 }
2761
2762 /* get the targets node */
2763 for (node = xmlFirstElementChild(id_tracker_node); node;
2764 node = xmlNextElementSibling(node)) {
2765 if (!strcmp((const char *) node->name,
2766 config_element_process_attr_values)) {
2767 targets_node = node;
2768 break;
2769 }
2770 }
2771
2772 if (!targets_node) {
2773 ret = LTTNG_ERR_INVALID;
2774 goto end;
2775 }
2776
2777 /* Go through all id target node */
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;
2786 }
2787
2788 /* Add all tracked values. */
2789 for (node = xmlFirstElementChild(targets_node); node;
2790 node = xmlNextElementSibling(node)) {
2791 xmlNodePtr id_target_node = node;
2792
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;
2801 xmlChar *content = xmlNodeGetContent(node);
2802
2803 if (!content) {
2804 ret = LTTNG_ERR_LOAD_INVALID_CONFIG;
2805 goto end;
2806 }
2807
2808 ret = parse_int(content, &id);
2809 free(content);
2810 if (ret) {
2811 ret = LTTNG_ERR_LOAD_INVALID_CONFIG;
2812 goto end;
2813 }
2814
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;
2848 goto end;
2849 }
2850 } else if (element_name &&
2851 !strcmp((const char *) node->name,
2852 element_name)) {
2853 xmlChar *content = xmlNodeGetContent(node);
2854
2855 if (!content) {
2856 ret = LTTNG_ERR_LOAD_INVALID_CONFIG;
2857 goto end;
2858 }
2859
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;
2884 goto end;
2885 }
2886 free(content);
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;
2905 }
2906 }
2907 node = id_target_node;
2908 }
2909
2910 end:
2911 lttng_process_attr_tracker_handle_destroy(tracker_handle);
2912 return ret;
2913 }
2914
2915 static
2916 int 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;
2921 struct lttng_channel *channel = NULL;
2922 xmlNodePtr channels_node = NULL;
2923 xmlNodePtr trackers_node = NULL;
2924 xmlNodePtr pid_tracker_node = NULL;
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;
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)) {
2962 const enum lttng_domain_type original_domain = domain.type;
2963 xmlNodePtr contexts_node = NULL;
2964 xmlNodePtr events_node = NULL;
2965 xmlNodePtr channel_attr_node;
2966
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
2987 channel = lttng_channel_create(&domain);
2988 if (!channel) {
2989 ret = -1;
2990 goto end;
2991 }
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,
2997 channel, &contexts_node, &events_node);
2998 if (ret) {
2999 goto end;
3000 }
3001 }
3002
3003 ret = lttng_enable_channel(handle, channel);
3004 if (ret < 0) {
3005 goto end;
3006 }
3007
3008 /* Restore the original channel domain. */
3009 domain.type = original_domain;
3010
3011 ret = process_events_node(events_node, handle, channel->name);
3012 if (ret) {
3013 goto end;
3014 }
3015
3016 ret = process_contexts_node(contexts_node, handle,
3017 channel->name);
3018 if (ret) {
3019 goto end;
3020 }
3021
3022 lttng_channel_destroy(channel);
3023 }
3024 channel = NULL;
3025
3026 /* get the trackers node */
3027 for (node = xmlFirstElementChild(domain_node); node;
3028 node = xmlNextElementSibling(node)) {
3029 if (!strcmp((const char *) node->name,
3030 config_element_process_attr_trackers)) {
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)) {
3042 if (!strcmp((const char *) node->name,
3043 config_element_process_attr_tracker_pid)) {
3044 pid_tracker_node = node;
3045 ret = process_id_tracker_node(pid_tracker_node, handle,
3046 LTTNG_PROCESS_ATTR_PROCESS_ID);
3047 if (ret) {
3048 goto end;
3049 }
3050 }
3051 if (!strcmp((const char *) node->name,
3052 config_element_process_attr_tracker_vpid)) {
3053 vpid_tracker_node = node;
3054 ret = process_id_tracker_node(vpid_tracker_node, handle,
3055 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID);
3056 if (ret) {
3057 goto end;
3058 }
3059 }
3060 if (!strcmp((const char *) node->name,
3061 config_element_process_attr_tracker_uid)) {
3062 uid_tracker_node = node;
3063 ret = process_id_tracker_node(uid_tracker_node, handle,
3064 LTTNG_PROCESS_ATTR_USER_ID);
3065 if (ret) {
3066 goto end;
3067 }
3068 }
3069 if (!strcmp((const char *) node->name,
3070 config_element_process_attr_tracker_vuid)) {
3071 vuid_tracker_node = node;
3072 ret = process_id_tracker_node(vuid_tracker_node, handle,
3073 LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID);
3074 if (ret) {
3075 goto end;
3076 }
3077 }
3078 if (!strcmp((const char *) node->name,
3079 config_element_process_attr_tracker_gid)) {
3080 gid_tracker_node = node;
3081 ret = process_id_tracker_node(gid_tracker_node, handle,
3082 LTTNG_PROCESS_ATTR_GROUP_ID);
3083 if (ret) {
3084 goto end;
3085 }
3086 }
3087 if (!strcmp((const char *) node->name,
3088 config_element_process_attr_tracker_vgid)) {
3089 vgid_tracker_node = node;
3090 ret = process_id_tracker_node(vgid_tracker_node, handle,
3091 LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID);
3092 if (ret) {
3093 goto end;
3094 }
3095 }