src/common/config/session-config.c

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