src/common/config/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 _GNU_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
  30 #include <common/defaults.h>
  31 #include <common/error.h>
  32 #include <common/macros.h>
  33 #include <common/utils.h>
  34 #include <lttng/lttng-error.h>
  35 #include <libxml/parser.h>
  36 #include <libxml/valid.h>
  37 #include <libxml/xmlschemas.h>
  38 #include <libxml/tree.h>
  39 #include <lttng/lttng.h>
  40 #include <lttng/snapshot.h>
  41
  42 #include "config.h"
  43 #include "config-internal.h"
  44
  45 struct handler_filter_args {
  46         const char* section;
  47         config_entry_handler_cb handler;
  48         void *user_data;
  49 };
  50
  51 struct session_config_validation_ctx {
  52         xmlSchemaParserCtxtPtr parser_ctx;
  53         xmlSchemaPtr schema;
  54         xmlSchemaValidCtxtPtr schema_validation_ctx;
  55 };
  56
  57 const char * const config_str_yes = "yes";
  58 const char * const config_str_true = "true";
  59 const char * const config_str_on = "on";
  60 const char * const config_str_no = "no";
  61 const char * const config_str_false = "false";
  62 const char * const config_str_off = "off";
  63 const char * const config_xml_encoding = "UTF-8";
  64 const size_t config_xml_encoding_bytes_per_char = 2;    /* Size of the encoding's largest character */
  65 const char * const config_xml_indent_string = "\t";
  66 const char * const config_xml_true = "true";
  67 const char * const config_xml_false = "false";
  68
  69 const char * const config_element_channel = "channel";
  70 const char * const config_element_channels = "channels";
  71 const char * const config_element_domain = "domain";
  72 const char * const config_element_domains = "domains";
  73 const char * const config_element_event = "event";
  74 const char * const config_element_events = "events";
  75 const char * const config_element_context = "context";
  76 const char * const config_element_contexts = "contexts";
  77 const char * const config_element_attributes = "attributes";
  78 const char * const config_element_exclusion = "exclusion";
  79 const char * const config_element_exclusions = "exclusions";
  80 const char * const config_element_function_attributes = "function_attributes";
  81 const char * const config_element_probe_attributes = "probe_attributes";
  82 const char * const config_element_symbol_name = "symbol_name";
  83 const char * const config_element_address = "address";
  84 const char * const config_element_offset = "offset";
  85 const char * const config_element_name = "name";
  86 const char * const config_element_enabled = "enabled";
  87 const char * const config_element_overwrite_mode = "overwrite_mode";
  88 const char * const config_element_subbuf_size = "subbuffer_size";
  89 const char * const config_element_num_subbuf = "subbuffer_count";
  90 const char * const config_element_switch_timer_interval = "switch_timer_interval";
  91 const char * const config_element_read_timer_interval = "read_timer_interval";
  92 const char * const config_element_output = "output";
  93 const char * const config_element_output_type = "output_type";
  94 const char * const config_element_tracefile_size = "tracefile_size";
  95 const char * const config_element_tracefile_count = "tracefile_count";
  96 const char * const config_element_live_timer_interval = "live_timer_interval";
  97 const char * const config_element_type = "type";
  98 const char * const config_element_buffer_type = "buffer_type";
  99 const char * const config_element_session = "session";
 100 const char * const config_element_sessions = "sessions";
 101 const char * const config_element_perf = "perf";
 102 const char * const config_element_config = "config";
 103 const char * const config_element_started = "started";
 104 const char * const config_element_snapshot_mode = "snapshot_mode";
 105 const char * const config_element_loglevel = "loglevel";
 106 const char * const config_element_loglevel_type = "loglevel_type";
 107 const char * const config_element_filter = "filter";
 108 const char * const config_element_snapshot_outputs = "snapshot_outputs";
 109 const char * const config_element_consumer_output = "consumer_output";
 110 const char * const config_element_destination = "destination";
 111 const char * const config_element_path = "path";
 112 const char * const config_element_net_output = "net_output";
 113 const char * const config_element_control_uri = "control_uri";
 114 const char * const config_element_data_uri = "data_uri";
 115 const char * const config_element_max_size = "max_size";
 116
 117 const char * const config_domain_type_kernel = "KERNEL";
 118 const char * const config_domain_type_ust = "UST";
 119 const char * const config_domain_type_jul = "JUL";
 120
 121 const char * const config_buffer_type_per_pid = "PER_PID";
 122 const char * const config_buffer_type_per_uid = "PER_UID";
 123 const char * const config_buffer_type_global = "GLOBAL";
 124
 125 const char * const config_overwrite_mode_discard = "DISCARD";
 126 const char * const config_overwrite_mode_overwrite = "OVERWRITE";
 127
 128 const char * const config_output_type_splice = "SPLICE";
 129 const char * const config_output_type_mmap = "MMAP";
 130
 131 const char * const config_loglevel_type_all = "ALL";
 132 const char * const config_loglevel_type_range = "RANGE";
 133 const char * const config_loglevel_type_single = "SINGLE";
 134
 135 const char * const config_event_type_all = "ALL";
 136 const char * const config_event_type_tracepoint = "TRACEPOINT";
 137 const char * const config_event_type_probe = "PROBE";
 138 const char * const config_event_type_function = "FUNCTION";
 139 const char * const config_event_type_function_entry = "FUNCTION_ENTRY";
 140 const char * const config_event_type_noop = "NOOP";
 141 const char * const config_event_type_syscall = "SYSCALL";
 142 const char * const config_event_type_kprobe = "KPROBE";
 143 const char * const config_event_type_kretprobe = "KRETPROBE";
 144
 145 const char * const config_event_context_pid = "PID";
 146 const char * const config_event_context_procname = "PROCNAME";
 147 const char * const config_event_context_prio = "PRIO";
 148 const char * const config_event_context_nice = "NICE";
 149 const char * const config_event_context_vpid = "VPID";
 150 const char * const config_event_context_tid = "TID";
 151 const char * const config_event_context_vtid = "VTID";
 152 const char * const config_event_context_ppid = "PPID";
 153 const char * const config_event_context_vppid = "VPPID";
 154 const char * const config_event_context_pthread_id = "PTHREAD_ID";
 155 const char * const config_event_context_hostname = "HOSTNAME";
 156 const char * const config_event_context_ip = "IP";
 157
 158 struct consumer_output {
 159         int enabled;
 160         char *path;
 161         char *control_uri;
 162         char *data_uri;
 163 };
 164
 165 static int config_entry_handler_filter(struct handler_filter_args *args,
 166                 const char *section, const char *name, const char *value)
 167 {
 168         int ret = 0;
 169         struct config_entry entry = { section, name, value };
 170
 171         assert(args);
 172
 173         if (!section || !name || !value) {
 174                 ret = -EIO;
 175                 goto end;
 176         }
 177
 178         if (args->section) {
 179                 if (strcmp(args->section, section)) {
 180                         goto end;
 181                 }
 182         }
 183
 184         ret = args->handler(&entry, args->user_data);
 185 end:
 186         return ret;
 187 }
 188
 189 LTTNG_HIDDEN
 190 int config_get_section_entries(const char *override_path, const char *section,
 191                 config_entry_handler_cb handler, void *user_data)
 192 {
 193         int ret = 0;
 194         FILE *config_file = NULL;
 195         struct handler_filter_args filter = { section, handler, user_data };
 196
 197         if (override_path) {
 198                 config_file = fopen(override_path, "r");
 199                 if (config_file) {
 200                         DBG("Loaded daemon configuration file at %s",
 201                                 override_path);
 202                 } else {
 203                         ERR("Failed to open daemon configuration file at %s",
 204                                 override_path);
 205                         ret = -ENOENT;
 206                         goto end;
 207                 }
 208         } else {
 209                 char *path = utils_get_home_dir();
 210
 211                 /* Try to open the user's daemon configuration file */
 212                 if (path) {
 213                         ret = asprintf(&path, DEFAULT_DAEMON_HOME_CONFIGPATH, path);
 214                         if (ret < 0) {
 215                                 goto end;
 216                         }
 217
 218                         ret = 0;
 219                         config_file = fopen(path, "r");
 220                         if (config_file) {
 221                                 DBG("Loaded daemon configuration file at %s", path);
 222                         }
 223
 224                         free(path);
 225                 }
 226
 227                 /* Try to open the system daemon configuration file */
 228                 if (!config_file) {
 229                         config_file = fopen(DEFAULT_DAEMON_HOME_CONFIGPATH, "r");
 230                 }
 231         }
 232
 233         if (!config_file) {
 234                 DBG("No daemon configuration file found.");
 235                 goto end;
 236         }
 237
 238         ret = ini_parse_file(config_file,
 239                         (ini_entry_handler) config_entry_handler_filter, (void *) &filter);
 240
 241 end:
 242         return ret;
 243 }
 244
 245 LTTNG_HIDDEN
 246 int config_parse_value(const char *value)
 247 {
 248         int i, ret = 0;
 249         char *endptr, *lower_str;
 250         size_t len;
 251         unsigned long v;
 252
 253         len = strlen(value);
 254         if (!len) {
 255                 ret = -1;
 256                 goto end;
 257         }
 258
 259         v = strtoul(value, &endptr, 10);
 260         if (endptr != value) {
 261                 ret = v;
 262                 goto end;
 263         }
 264
 265         lower_str = zmalloc(len + 1);
 266         if (!lower_str) {
 267                 PERROR("zmalloc");
 268                 ret = -errno;
 269                 goto end;
 270         }
 271
 272         for (i = 0; i < len; i++) {
 273                 lower_str[i] = tolower(value[i]);
 274         }
 275
 276         if (!strcmp(lower_str, config_str_yes) ||
 277                 !strcmp(lower_str, config_str_true) ||
 278                 !strcmp(lower_str, config_str_on)) {
 279                 ret = 1;
 280         } else if (!strcmp(lower_str, config_str_no) ||
 281                 !strcmp(lower_str, config_str_false) ||
 282                 !strcmp(lower_str, config_str_off)) {
 283                 ret = 0;
 284         } else {
 285                 ret = -1;
 286         }
 287
 288         free(lower_str);
 289 end:
 290         return ret;
 291 }
 292
 293 /*
 294  * Returns a xmlChar string which must be released using xmlFree().
 295  */
 296 static xmlChar *encode_string(const char *in_str)
 297 {
 298         xmlChar *out_str = NULL;
 299         xmlCharEncodingHandlerPtr handler;
 300         int out_len, ret, in_len;
 301
 302         assert(in_str);
 303
 304         handler = xmlFindCharEncodingHandler(config_xml_encoding);
 305         if (!handler) {
 306                 ERR("xmlFindCharEncodingHandler return NULL!. Configure issue!");
 307                 goto end;
 308         }
 309
 310         in_len = strlen(in_str);
 311         /*
 312          * Add 1 byte for the NULL terminted character. The factor 2 here is
 313          * because UTF-8 can be on two bytes so this fits the worst case for each
 314          * bytes.
 315          */
 316         out_len = (in_len * 2) + 1;
 317         out_str = xmlMalloc(out_len);
 318         if (!out_str) {
 319                 goto end;
 320         }
 321
 322         ret = handler->input(out_str, &out_len, (const xmlChar *) in_str, &in_len);
 323         if (ret < 0) {
 324                 xmlFree(out_str);
 325                 out_str = NULL;
 326                 goto end;
 327         }
 328
 329         /* out_len is now the size of out_str */
 330         out_str[out_len] = '\0';
 331 end:
 332         return out_str;
 333 }
 334
 335 LTTNG_HIDDEN
 336 struct config_writer *config_writer_create(int fd_output)
 337 {
 338         int ret;
 339         struct config_writer *writer;
 340         xmlOutputBufferPtr buffer;
 341
 342         writer = zmalloc(sizeof(struct config_writer));
 343         if (!writer) {
 344                 PERROR("zmalloc config_writer_create");
 345                 goto end;
 346         }
 347
 348         buffer = xmlOutputBufferCreateFd(fd_output, NULL);
 349         if (!buffer) {
 350                 goto error_destroy;
 351         }
 352
 353         writer->writer = xmlNewTextWriter(buffer);
 354         ret = xmlTextWriterStartDocument(writer->writer, NULL,
 355                 config_xml_encoding, NULL);
 356         if (ret < 0) {
 357                 goto error_destroy;
 358         }
 359
 360         ret = xmlTextWriterSetIndentString(writer->writer,
 361                 BAD_CAST config_xml_indent_string);
 362         if (ret)  {
 363                 goto error_destroy;
 364         }
 365
 366         ret = xmlTextWriterSetIndent(writer->writer, 1);
 367         if (ret)  {
 368                 goto error_destroy;
 369         }
 370
 371 end:
 372         return writer;
 373 error_destroy:
 374         config_writer_destroy(writer);
 375         return NULL;
 376 }
 377
 378 LTTNG_HIDDEN
 379 int config_writer_destroy(struct config_writer *writer)
 380 {
 381         int ret = 0;
 382
 383         if (!writer) {
 384                 ret = -EINVAL;
 385                 goto end;
 386         }
 387
 388         if (xmlTextWriterEndDocument(writer->writer) < 0) {
 389                 WARN("Could not close XML document");
 390                 ret = -EIO;
 391         }
 392
 393         if (writer->writer) {
 394                 xmlFreeTextWriter(writer->writer);
 395         }
 396
 397         free(writer);
 398 end:
 399         return ret;
 400 }
 401
 402 LTTNG_HIDDEN
 403 int config_writer_open_element(struct config_writer *writer,
 404         const char *element_name)
 405 {
 406         int ret;
 407         xmlChar *encoded_element_name;
 408
 409         if (!writer || !writer->writer || !element_name || !element_name[0]) {
 410                 ret = -1;
 411                 goto end;
 412         }
 413
 414         encoded_element_name = encode_string(element_name);
 415         if (!encoded_element_name) {
 416                 ret = -1;
 417                 goto end;
 418         }
 419
 420         ret = xmlTextWriterStartElement(writer->writer, encoded_element_name);
 421         xmlFree(encoded_element_name);
 422 end:
 423         return ret > 0 ? 0 : ret;
 424 }
 425
 426 LTTNG_HIDDEN
 427 int config_writer_close_element(struct config_writer *writer)
 428 {
 429         int ret;
 430
 431         if (!writer || !writer->writer) {
 432                 ret = -1;
 433                 goto end;
 434         }
 435
 436         ret = xmlTextWriterEndElement(writer->writer);
 437 end:
 438         return ret > 0 ? 0 : ret;
 439 }
 440
 441 LTTNG_HIDDEN
 442 int config_writer_write_element_unsigned_int(struct config_writer *writer,
 443                 const char *element_name, uint64_t value)
 444 {
 445         int ret;
 446         xmlChar *encoded_element_name;
 447
 448         if (!writer || !writer->writer || !element_name || !element_name[0]) {
 449                 ret = -1;
 450                 goto end;
 451         }
 452
 453         encoded_element_name = encode_string(element_name);
 454         if (!encoded_element_name) {
 455                 ret = -1;
 456                 goto end;
 457         }
 458
 459         ret = xmlTextWriterWriteFormatElement(writer->writer,
 460                 encoded_element_name, "%" PRIu64, value);
 461         xmlFree(encoded_element_name);
 462 end:
 463         return ret > 0 ? 0 : ret;
 464 }
 465
 466 LTTNG_HIDDEN
 467 int config_writer_write_element_signed_int(struct config_writer *writer,
 468                 const char *element_name, int64_t value)
 469 {
 470         int ret;
 471         xmlChar *encoded_element_name;
 472
 473         if (!writer || !writer->writer || !element_name || !element_name[0]) {
 474                 ret = -1;
 475                 goto end;
 476         }
 477
 478         encoded_element_name = encode_string(element_name);
 479         if (!encoded_element_name) {
 480                 ret = -1;
 481                 goto end;
 482         }
 483
 484         ret = xmlTextWriterWriteFormatElement(writer->writer,
 485                 encoded_element_name, "%" PRIi64, value);
 486         xmlFree(encoded_element_name);
 487 end:
 488         return ret > 0 ? 0 : ret;
 489 }
 490
 491 LTTNG_HIDDEN
 492 int config_writer_write_element_bool(struct config_writer *writer,
 493                 const char *element_name, int value)
 494 {
 495         return config_writer_write_element_string(writer, element_name,
 496                 value ? config_xml_true : config_xml_false);
 497 }
 498
 499 LTTNG_HIDDEN
 500 int config_writer_write_element_string(struct config_writer *writer,
 501                 const char *element_name, const char *value)
 502 {
 503         int ret;
 504         xmlChar *encoded_element_name = NULL;
 505         xmlChar *encoded_value = NULL;
 506
 507         if (!writer || !writer->writer || !element_name || !element_name[0] ||
 508                 !value) {
 509                 ret = -1;
 510                 goto end;
 511         }
 512
 513         encoded_element_name = encode_string(element_name);
 514         if (!encoded_element_name) {
 515                 ret = -1;
 516                 goto end;
 517         }
 518
 519         encoded_value = encode_string(value);
 520         if (!encoded_value) {
 521                 ret = -1;
 522                 goto end;
 523         }
 524
 525         ret = xmlTextWriterWriteElement(writer->writer, encoded_element_name,
 526                         encoded_value);
 527 end:
 528         xmlFree(encoded_element_name);
 529         xmlFree(encoded_value);
 530         return ret > 0 ? 0 : ret;
 531 }
 532
 533 static
 534 void xml_error_handler(void *ctx, const char *format, ...)
 535 {
 536         char *errMsg;
 537         va_list args;
 538         int ret;
 539
 540         va_start(args, format);
 541         ret = vasprintf(&errMsg, format, args);
 542         va_end(args);
 543         if (ret == -1) {
 544                 ERR("String allocation failed in xml error handler");
 545                 return;
 546         }
 547
 548         fprintf(stderr, "XML Error: %s", errMsg);
 549         free(errMsg);
 550 }
 551
 552 static
 553 void fini_session_config_validation_ctx(
 554         struct session_config_validation_ctx *ctx)
 555 {
 556         if (ctx->parser_ctx) {
 557                 xmlSchemaFreeParserCtxt(ctx->parser_ctx);
 558         }
 559
 560         if (ctx->schema) {
 561                 xmlSchemaFree(ctx->schema);
 562         }
 563
 564         if (ctx->schema_validation_ctx) {
 565                 xmlSchemaFreeValidCtxt(ctx->schema_validation_ctx);
 566         }
 567
 568         memset(ctx, 0, sizeof(struct session_config_validation_ctx));
 569 }
 570
 571 static
 572 int init_session_config_validation_ctx(
 573         struct session_config_validation_ctx *ctx)
 574 {
 575         int ret;
 576
 577         ctx->parser_ctx = xmlSchemaNewParserCtxt(DEFAULT_SESSION_CONFIG_XSD_PATH);
 578         if (!ctx->parser_ctx) {
 579                 ERR("XSD parser context creation failed");
 580                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
 581                 goto end;
 582         }
 583         xmlSchemaSetParserErrors(ctx->parser_ctx, xml_error_handler,
 584                 xml_error_handler, NULL);
 585
 586         ctx->schema = xmlSchemaParse(ctx->parser_ctx);
 587         if (!ctx->schema) {
 588                 ERR("XSD parsing failed");
 589                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
 590                 goto end;
 591         }
 592
 593         ctx->schema_validation_ctx = xmlSchemaNewValidCtxt(ctx->schema);
 594         if (!ctx->schema_validation_ctx) {
 595                 ERR("XSD validation context creation failed");
 596                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
 597                 goto end;
 598         }
 599
 600         xmlSchemaSetValidErrors(ctx->schema_validation_ctx, xml_error_handler,
 601                         xml_error_handler, NULL);
 602         ret = 0;
 603
 604 end:
 605         if (ret) {
 606                 fini_session_config_validation_ctx(ctx);
 607         }
 608
 609         return ret;
 610 }
 611
 612 static
 613 int parse_uint(xmlChar *str, uint64_t *val)
 614 {
 615         int ret;
 616         char *endptr;
 617
 618         if (!str || !val) {
 619                 ret = -1;
 620                 goto end;
 621         }
 622
 623         *val = strtoull((const char *) str, &endptr, 10);
 624         if (!endptr || *endptr) {
 625                 ret = -1;
 626         } else {
 627                 ret = 0;
 628         }
 629
 630 end:
 631         return ret;
 632 }
 633
 634 static
 635 int parse_int(xmlChar *str, int64_t *val)
 636 {
 637         int ret;
 638         char *endptr;
 639
 640         if (!str || !val) {
 641                 ret = -1;
 642                 goto end;
 643         }
 644
 645         *val = strtoll((const char *) str, &endptr, 10);
 646         if (!endptr || *endptr) {
 647                 ret = -1;
 648         } else {
 649                 ret = 0;
 650         }
 651
 652 end:
 653         return ret;
 654 }
 655
 656 static
 657 int parse_bool(xmlChar *str, int *val)
 658 {
 659         int ret = 0;
 660
 661         if (!str || !val) {
 662                 ret = -1;
 663                 goto end;
 664         }
 665
 666         if (!strcmp((const char *) str, config_xml_true)) {
 667                 *val = 1;
 668         } else if (!strcmp((const char *) str, config_xml_false)) {
 669                 *val = 0;
 670         } else {
 671                 WARN("Invalid boolean value encoutered (%s).",
 672                         (const char *) str);
 673                 ret = -1;
 674         }
 675 end:
 676         return ret;
 677 }
 678
 679 static
 680 int get_domain_type(xmlChar *domain)
 681 {
 682         int ret;
 683
 684         if (!domain) {
 685                 goto error;
 686         }
 687
 688         if (!strcmp((char *) domain, config_domain_type_kernel)) {
 689                 ret = LTTNG_DOMAIN_KERNEL;
 690         } else if (!strcmp((char *) domain, config_domain_type_ust)) {
 691                 ret = LTTNG_DOMAIN_UST;
 692         } else if (!strcmp((char *) domain, config_domain_type_jul)) {
 693                 ret = LTTNG_DOMAIN_JUL;
 694         } else {
 695                 goto error;
 696         }
 697
 698         return ret;
 699 error:
 700         return -1;
 701 }
 702
 703 static
 704 int get_buffer_type(xmlChar *buffer_type)
 705 {
 706         int ret;
 707
 708         if (!buffer_type) {
 709                 goto error;
 710         }
 711
 712         if (!strcmp((char *) buffer_type, config_buffer_type_global)) {
 713                 ret = LTTNG_BUFFER_GLOBAL;
 714         } else if (!strcmp((char *) buffer_type, config_buffer_type_per_uid)) {
 715                 ret = LTTNG_BUFFER_PER_UID;
 716         } else if (!strcmp((char *) buffer_type, config_buffer_type_per_pid)) {
 717                 ret = LTTNG_BUFFER_PER_PID;
 718         } else {
 719                 goto error;
 720         }
 721
 722         return ret;
 723 error:
 724         return -1;
 725 }
 726
 727 static
 728 int get_overwrite_mode(xmlChar *overwrite_mode)
 729 {
 730         int ret;
 731
 732         if (!overwrite_mode) {
 733                 goto error;
 734         }
 735
 736         if (!strcmp((char *) overwrite_mode, config_overwrite_mode_overwrite)) {
 737                 ret = 1;
 738         } else if (!strcmp((char *) overwrite_mode,
 739                 config_overwrite_mode_discard)) {
 740                 ret = 0;
 741         } else {
 742                 goto error;
 743         }
 744
 745         return ret;
 746 error:
 747         return -1;
 748 }
 749
 750 static
 751 int get_output_type(xmlChar *output_type)
 752 {
 753         int ret;
 754
 755         if (!output_type) {
 756                 goto error;
 757         }
 758
 759         if (!strcmp((char *) output_type, config_output_type_mmap)) {
 760                 ret = LTTNG_EVENT_MMAP;
 761         } else if (!strcmp((char *) output_type, config_output_type_splice)) {
 762                 ret = LTTNG_EVENT_SPLICE;
 763         } else {
 764                 goto error;
 765         }
 766
 767         return ret;
 768 error:
 769         return -1;
 770 }
 771
 772 static
 773 int get_event_type(xmlChar *event_type)
 774 {
 775         int ret;
 776
 777         if (!event_type) {
 778                 goto error;
 779         }
 780
 781         if (!strcmp((char *) event_type, config_event_type_all)) {
 782                 ret = LTTNG_EVENT_ALL;
 783         } else if (!strcmp((char *) event_type, config_event_type_tracepoint)) {
 784                 ret = LTTNG_EVENT_TRACEPOINT;
 785         } else if (!strcmp((char *) event_type, config_event_type_probe)) {
 786                 ret = LTTNG_EVENT_PROBE;
 787         } else if (!strcmp((char *) event_type, config_event_type_function)) {
 788                 ret = LTTNG_EVENT_FUNCTION;
 789         } else if (!strcmp((char *) event_type,
 790                 config_event_type_function_entry)) {
 791                 ret = LTTNG_EVENT_FUNCTION_ENTRY;
 792         } else if (!strcmp((char *) event_type, config_event_type_noop)) {
 793                 ret = LTTNG_EVENT_NOOP;
 794         } else if (!strcmp((char *) event_type, config_event_type_syscall)) {
 795                 ret = LTTNG_EVENT_SYSCALL;
 796         } else {
 797                 goto error;
 798         }
 799
 800         return ret;
 801 error:
 802         return -1;
 803 }
 804
 805 static
 806 int get_loglevel_type(xmlChar *loglevel_type)
 807 {
 808         int ret;
 809
 810         if (!loglevel_type) {
 811                 goto error;
 812         }
 813
 814         if (!strcmp((char *) loglevel_type, config_loglevel_type_all)) {
 815                 ret = LTTNG_EVENT_LOGLEVEL_ALL;
 816         } else if (!strcmp((char *) loglevel_type,
 817                 config_loglevel_type_range)) {
 818                 ret = LTTNG_EVENT_LOGLEVEL_RANGE;
 819         } else if (!strcmp((char *) loglevel_type,
 820                 config_loglevel_type_single)) {
 821                 ret = LTTNG_EVENT_LOGLEVEL_SINGLE;
 822         } else {
 823                 goto error;
 824         }
 825
 826         return ret;
 827 error:
 828         return -1;
 829 }
 830
 831 /*
 832  * Return the context type or -1 on error.
 833  */
 834 static
 835 int get_context_type(xmlChar *context_type)
 836 {
 837         int ret;
 838
 839         if (!context_type) {
 840                 goto error;
 841         }
 842
 843         if (!strcmp((char *) context_type, config_event_context_pid)) {
 844                 ret = LTTNG_EVENT_CONTEXT_PID;
 845         } else if (!strcmp((char *) context_type,
 846                 config_event_context_procname)) {
 847                 ret = LTTNG_EVENT_CONTEXT_PROCNAME;
 848         } else if (!strcmp((char *) context_type,
 849                 config_event_context_prio)) {
 850                 ret = LTTNG_EVENT_CONTEXT_PRIO;
 851         } else if (!strcmp((char *) context_type,
 852                 config_event_context_nice)) {
 853                 ret = LTTNG_EVENT_CONTEXT_NICE;
 854         } else if (!strcmp((char *) context_type,
 855                 config_event_context_vpid)) {
 856                 ret = LTTNG_EVENT_CONTEXT_VPID;
 857         } else if (!strcmp((char *) context_type,
 858                 config_event_context_tid)) {
 859                 ret = LTTNG_EVENT_CONTEXT_TID;
 860         } else if (!strcmp((char *) context_type,
 861                 config_event_context_vtid)) {
 862                 ret = LTTNG_EVENT_CONTEXT_VTID;
 863         } else if (!strcmp((char *) context_type,
 864                 config_event_context_ppid)) {
 865                 ret = LTTNG_EVENT_CONTEXT_PPID;
 866         } else if (!strcmp((char *) context_type,
 867                 config_event_context_vppid)) {
 868                 ret = LTTNG_EVENT_CONTEXT_VPPID;
 869         } else if (!strcmp((char *) context_type,
 870                 config_event_context_pthread_id)) {
 871                 ret = LTTNG_EVENT_CONTEXT_PTHREAD_ID;
 872         } else if (!strcmp((char *) context_type,
 873                 config_event_context_hostname)) {
 874                 ret = LTTNG_EVENT_CONTEXT_HOSTNAME;
 875         } else if (!strcmp((char *) context_type,
 876                 config_event_context_ip)) {
 877                 ret = LTTNG_EVENT_CONTEXT_IP;
 878         } else {
 879                 goto error;
 880         }
 881
 882         return ret;
 883 error:
 884         return -1;
 885 }
 886
 887 static
 888 int init_domain(xmlNodePtr domain_node, struct lttng_domain *domain)
 889 {
 890         int ret;
 891         xmlNodePtr node;
 892
 893         for (node = xmlFirstElementChild(domain_node); node;
 894                 node = xmlNextElementSibling(node)) {
 895                 if (!strcmp((const char *) node->name, config_element_type)) {
 896                         /* domain type */
 897                         xmlChar *node_content = xmlNodeGetContent(node);
 898                         if (!node_content) {
 899                                 ret = -LTTNG_ERR_NOMEM;
 900                                 goto end;
 901                         }
 902
 903                         ret = get_domain_type(node_content);
 904                         free(node_content);
 905                         if (ret < 0) {
 906                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
 907                                 goto end;
 908                         }
 909
 910                         domain->type = ret;
 911                 } else if (!strcmp((const char *) node->name,
 912                         config_element_buffer_type)) {
 913                         /* buffer type */
 914                         xmlChar *node_content = xmlNodeGetContent(node);
 915                         if (!node_content) {
 916                                 ret = -LTTNG_ERR_NOMEM;
 917                                 goto end;
 918                         }
 919
 920                         ret = get_buffer_type(node_content);
 921                         free(node_content);
 922                         if (ret < 0) {
 923                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
 924                                 goto end;
 925                         }
 926
 927                         domain->buf_type = ret;
 928                 }
 929         }
 930         ret = 0;
 931 end:
 932         return ret;
 933 }
 934
 935 static
 936 int get_net_output_uris(xmlNodePtr net_output_node, char **control_uri,
 937         char **data_uri)
 938 {
 939         xmlNodePtr node;
 940
 941         for (node = xmlFirstElementChild(net_output_node); node;
 942                 node = xmlNextElementSibling(node)) {
 943                 if (!strcmp((const char *) node->name, config_element_control_uri)) {
 944                         /* control_uri */
 945                         *control_uri = (char *) xmlNodeGetContent(node);
 946                         if (!*control_uri) {
 947                                 break;
 948                         }
 949                 } else {
 950                         /* data_uri */
 951                         *data_uri = (char *) xmlNodeGetContent(node);
 952                         if (!*data_uri) {
 953                                 break;
 954                         }
 955                 }
 956         }
 957
 958         return *control_uri || *data_uri ? 0 : -LTTNG_ERR_LOAD_INVALID_CONFIG;
 959 }
 960
 961 static
 962 int process_consumer_output(xmlNodePtr consumer_output_node,
 963         struct consumer_output *output)
 964 {
 965         int ret;
 966         xmlNodePtr node;
 967
 968         assert(output);
 969
 970         for (node = xmlFirstElementChild(consumer_output_node); node;
 971                         node = xmlNextElementSibling(node)) {
 972                 if (!strcmp((const char *) node->name, config_element_enabled)) {
 973                         xmlChar *enabled_str = xmlNodeGetContent(node);
 974
 975                         /* enabled */
 976                         if (!enabled_str) {
 977                                 ret = -LTTNG_ERR_NOMEM;
 978                                 goto end;
 979                         }
 980
 981                         ret = parse_bool(enabled_str, &output->enabled);
 982                         free(enabled_str);
 983                         if (ret) {
 984                                 goto end;
 985                         }
 986                 } else {
 987                         xmlNodePtr output_type_node;
 988
 989                         /* destination */
 990                         output_type_node = xmlFirstElementChild(node);
 991                         if (!output_type_node) {
 992                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
 993                                 goto end;
 994                         }
 995
 996                         if (!strcmp((const char *) output_type_node->name,
 997                                         config_element_path)) {
 998                                 /* path */
 999                                 output->path = (char *) xmlNodeGetContent(output_type_node);
1000                                 if (!output->path) {
1001                                         ret = -LTTNG_ERR_NOMEM;
1002                                         goto end;
1003                                 }
1004                         } else {
1005                                 /* net_output */
1006                                 ret = get_net_output_uris(output_type_node,
1007                                                 &output->control_uri, &output->data_uri);
1008                                 if (ret) {
1009                                         goto end;
1010                                 }
1011                         }
1012                 }
1013         }
1014         ret = 0;
1015
1016 end:
1017         if (ret) {
1018                 free(output->path);
1019                 free(output->control_uri);
1020                 free(output->data_uri);
1021                 memset(output, 0, sizeof(struct consumer_output));
1022         }
1023         return ret;
1024 }
1025
1026 static
1027 int create_session_net_output(const char *name, struct lttng_domain *domain,
1028         const char *control_uri, const char *data_uri)
1029 {
1030         int ret;
1031         struct lttng_handle *handle;
1032         const char *uri = NULL;
1033
1034         assert(name);
1035         assert(domain);
1036
1037         handle = lttng_create_handle(name, domain);
1038         if (!handle) {
1039                 ret = -LTTNG_ERR_NOMEM;
1040                 goto end;
1041         }
1042
1043         if (!control_uri || !data_uri) {
1044                 uri = control_uri ? control_uri : data_uri;
1045                 control_uri = uri;
1046                 data_uri = uri;
1047         }
1048
1049         ret = lttng_set_consumer_url(handle, control_uri, data_uri);
1050         lttng_destroy_handle(handle);
1051 end:
1052         return ret;
1053 }
1054
1055 static
1056 int create_snapshot_session(const char *session_name, xmlNodePtr output_node)
1057 {
1058         int ret;
1059         xmlNodePtr node = NULL;
1060         xmlNodePtr snapshot_output_list_node;
1061         xmlNodePtr snapshot_output_node;
1062
1063         assert(session_name);
1064
1065         ret = lttng_create_session_snapshot(session_name, NULL);
1066         if (ret) {
1067                 goto end;
1068         }
1069
1070         if (!output_node) {
1071                 goto end;
1072         }
1073
1074         snapshot_output_list_node = xmlFirstElementChild(output_node);
1075
1076         /* Parse and create snapshot outputs */
1077
1078         for (snapshot_output_node =
1079                         xmlFirstElementChild(snapshot_output_list_node);
1080                         snapshot_output_node; snapshot_output_node =
1081                         xmlNextElementSibling(snapshot_output_node)) {
1082                 char *name = NULL;
1083                 uint64_t max_size = UINT64_MAX;
1084                 struct consumer_output output = { 0 };
1085                 struct lttng_snapshot_output *snapshot_output = NULL;
1086
1087                 for (node = xmlFirstElementChild(snapshot_output_node); node;
1088                                 node = xmlNextElementSibling(node)) {
1089                         if (!strcmp((const char *) node->name,
1090                                 config_element_name)) {
1091                                 /* name */
1092                                 name = (char *) xmlNodeGetContent(node);
1093                                 if (!name) {
1094                                         ret = -LTTNG_ERR_NOMEM;
1095                                         goto error_snapshot_output;
1096                                 }
1097                         } else if (!strcmp((const char *) node->name,
1098                                 config_element_max_size)) {
1099                                 xmlChar *content = xmlNodeGetContent(node);
1100
1101                                 /* max_size */
1102                                 if (!content) {
1103                                         ret = -LTTNG_ERR_NOMEM;
1104                                         goto error_snapshot_output;
1105                                 }
1106                                 ret = parse_uint(content, &max_size);
1107                                 free(content);
1108                                 if (ret) {
1109                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1110                                         goto error_snapshot_output;
1111                                 }
1112                         } else {
1113                                 /* consumer_output */
1114                                 ret = process_consumer_output(node, &output);
1115                                 if (ret) {
1116                                         goto error_snapshot_output;
1117                                 }
1118                         }
1119                 }
1120
1121                 snapshot_output = lttng_snapshot_output_create();
1122                 if (!snapshot_output) {
1123                         ret = -LTTNG_ERR_NOMEM;
1124                         goto error_snapshot_output;
1125                 }
1126
1127                 ret = lttng_snapshot_output_set_name(name, snapshot_output);
1128                 if (ret) {
1129                         goto error_snapshot_output;
1130                 }
1131
1132                 ret = lttng_snapshot_output_set_size(max_size, snapshot_output);
1133                 if (ret) {
1134                         goto error_snapshot_output;
1135                 }
1136
1137                 if (output.path) {
1138                         ret = lttng_snapshot_output_set_ctrl_url(output.path,
1139                                         snapshot_output);
1140                         if (ret) {
1141                                 goto error_snapshot_output;
1142                         }
1143                 } else {
1144                         if (output.control_uri) {
1145                                 ret = lttng_snapshot_output_set_ctrl_url(output.control_uri,
1146                                                 snapshot_output);
1147                                 if (ret) {
1148                                         goto error_snapshot_output;
1149                                 }
1150                         }
1151
1152                         if (output.data_uri) {
1153                                 ret = lttng_snapshot_output_set_data_url(output.data_uri,
1154                                                 snapshot_output);
1155                                 if (ret) {
1156                                         goto error_snapshot_output;
1157                                 }
1158                         }
1159                 }
1160
1161                 ret = lttng_snapshot_add_output(session_name, snapshot_output);
1162 error_snapshot_output:
1163                 free(name);
1164                 free(output.path);
1165                 free(output.control_uri);
1166                 free(output.data_uri);
1167                 lttng_snapshot_output_destroy(snapshot_output);
1168                 if (ret) {
1169                         goto end;
1170                 }
1171         }
1172 end:
1173         return ret;
1174 }
1175
1176 static
1177 int create_session(const char *name,
1178         struct lttng_domain *kernel_domain,
1179         struct lttng_domain *ust_domain,
1180         struct lttng_domain *jul_domain,
1181         xmlNodePtr output_node,
1182         uint64_t live_timer_interval)
1183 {
1184         int ret;
1185         struct consumer_output output = { 0 };
1186         xmlNodePtr consumer_output_node;
1187
1188         assert(name);
1189         assert(kernel_domain);
1190         assert(ust_domain);
1191         assert(jul_domain);
1192
1193         if (output_node) {
1194                 consumer_output_node = xmlFirstElementChild(output_node);
1195                 if (!consumer_output_node) {
1196                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1197                         goto end;
1198                 }
1199
1200                 if (strcmp((const char *) consumer_output_node->name,
1201                         config_element_consumer_output)) {
1202                         WARN("Invalid output type, expected %s node",
1203                                 config_element_consumer_output);
1204                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1205                         goto end;
1206                 }
1207
1208                 ret = process_consumer_output(consumer_output_node, &output);
1209                 if (ret) {
1210                         goto end;
1211                 }
1212         }
1213
1214         if (live_timer_interval != UINT64_MAX &&
1215                 !output.control_uri && !output.data_uri) {
1216                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1217                 goto end;
1218         }
1219
1220         if (output.control_uri || output.data_uri) {
1221                 int i;
1222                 struct lttng_domain *domain;
1223                 struct lttng_domain *domains[] =
1224                         { kernel_domain, ust_domain, jul_domain };
1225
1226                 /* network destination */
1227                 if (live_timer_interval && live_timer_interval != UINT64_MAX) {
1228                         const char *url = output.control_uri ?
1229                                 output.control_uri : output.data_uri;
1230
1231                         /* URL has to be provided, even if we'll overwrite it after. */
1232                         ret = lttng_create_session_live(name, url, live_timer_interval);
1233                 } else {
1234                         ret = lttng_create_session(name, NULL);
1235                 }
1236                 if (ret) {
1237                         goto end;
1238                 }
1239
1240                 for (i = 0; i < (sizeof(domains) / sizeof(domains[0])); i++) {
1241                         domain = domains[i];
1242                         if (!domain) {
1243                                 continue;
1244                         }
1245
1246                         ret = create_session_net_output(name, domain, output.control_uri,
1247                                         output.data_uri);
1248                         if (ret) {
1249                                 goto end;
1250                         }
1251                 }
1252         } else {
1253                 /* either local output or no output */
1254                 ret = lttng_create_session(name, output.path);
1255                 if (ret) {
1256                         goto end;
1257                 }
1258         }
1259 end:
1260         free(output.path);
1261         free(output.control_uri);
1262         free(output.data_uri);
1263         return ret;
1264 }
1265 static
1266 int process_probe_attribute_node(xmlNodePtr probe_attribute_node,
1267         struct lttng_event_probe_attr *attr)
1268 {
1269         int ret;
1270
1271         assert(probe_attribute_node);
1272         assert(attr);
1273
1274         if (!strcmp((const char *) probe_attribute_node->name,
1275                 config_element_address)) {
1276                 xmlChar *content;
1277                 uint64_t addr = 0;
1278
1279                 /* addr */
1280                 content = xmlNodeGetContent(probe_attribute_node);
1281                 if (!content) {
1282                         ret = -LTTNG_ERR_NOMEM;
1283                         goto end;
1284                 }
1285
1286                 ret = parse_uint(content, &addr);
1287                 free(content);
1288                 if (ret) {
1289                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1290                         goto end;
1291                 }
1292
1293                 attr->addr = addr;
1294         } else if (!strcmp((const char *) probe_attribute_node->name,
1295                 config_element_offset)) {
1296                 xmlChar *content;
1297                 uint64_t offset = 0;
1298
1299                 /* offset */
1300                 content = xmlNodeGetContent(probe_attribute_node);
1301                 if (!content) {
1302                         ret = -LTTNG_ERR_NOMEM;
1303                         goto end;
1304                 }
1305
1306                 ret = parse_uint(content, &offset);
1307                 free(content);
1308                 if (ret) {
1309                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1310                         goto end;
1311                 }
1312
1313                 attr->offset = offset;
1314         } else if (!strcmp((const char *) probe_attribute_node->name,
1315                 config_element_symbol_name)) {
1316                 xmlChar *content;
1317                 size_t name_len;
1318
1319                 /* symbol_name */
1320                 content = xmlNodeGetContent(probe_attribute_node);
1321                 if (!content) {
1322                         ret = -LTTNG_ERR_NOMEM;
1323                         goto end;
1324                 }
1325
1326                 name_len = strlen((char *) content);
1327                 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1328                         WARN("symbol_name too long.");
1329                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1330                         free(content);
1331                         goto end;
1332                 }
1333
1334                 strncpy(attr->symbol_name, (const char *) content, name_len);
1335                 free(content);
1336         }
1337         ret = 0;
1338 end:
1339         return ret;
1340 }
1341
1342 static
1343 int process_event_node(xmlNodePtr event_node, struct lttng_handle *handle,
1344         const char *channel_name)
1345 {
1346         int ret, i;
1347         xmlNodePtr node;
1348         struct lttng_event event;
1349         char **exclusions = NULL;
1350         unsigned long exclusion_count = 0;
1351         char *filter_expression = NULL;
1352
1353         assert(event_node);
1354         assert(handle);
1355         assert(channel_name);
1356
1357         memset(&event, 0, sizeof(event));
1358
1359         for (node = xmlFirstElementChild(event_node); node;
1360                 node = xmlNextElementSibling(node)) {
1361                 if (!strcmp((const char *) node->name, config_element_name)) {
1362                         xmlChar *content;
1363                         size_t name_len;
1364
1365                         /* name */
1366                         content = xmlNodeGetContent(node);
1367                         if (!content) {
1368                                 ret = -LTTNG_ERR_NOMEM;
1369                                 goto end;
1370                         }
1371
1372                         name_len = strlen((char *) content);
1373                         if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1374                                 WARN("Channel name too long.");
1375                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1376                                 free(content);
1377                                 goto end;
1378                         }
1379
1380                         strncpy(event.name, (const char *) content, name_len);
1381                         free(content);
1382                 } else if (!strcmp((const char *) node->name,
1383                         config_element_enabled)) {
1384                         xmlChar *content = xmlNodeGetContent(node);
1385
1386                         /* enabled */
1387                         if (!content) {
1388                                 ret = -LTTNG_ERR_NOMEM;
1389                                 goto end;
1390                         }
1391
1392                         ret = parse_bool(content, &event.enabled);
1393                         free(content);
1394                         if (ret) {
1395                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1396                                 goto end;
1397                         }
1398                 } else if (!strcmp((const char *) node->name,
1399                         config_element_type)) {
1400                         xmlChar *content = xmlNodeGetContent(node);
1401
1402                         /* type */
1403                         if (!content) {
1404                                 ret = -LTTNG_ERR_NOMEM;
1405                                 goto end;
1406                         }
1407
1408                         ret = get_event_type(content);
1409                         free(content);
1410                         if (ret < 0) {
1411                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1412                                 goto end;
1413                         }
1414
1415                         event.type = ret;
1416                 } else if (!strcmp((const char *) node->name,
1417                         config_element_loglevel_type)) {
1418                         xmlChar *content = xmlNodeGetContent(node);
1419
1420                         /* loglevel_type */
1421                         if (!content) {
1422                                 ret = -LTTNG_ERR_NOMEM;
1423                                 goto end;
1424                         }
1425
1426                         ret = get_loglevel_type(content);
1427                         free(content);
1428                         if (ret < 0) {
1429                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1430                                 goto end;
1431                         }
1432
1433                         event.loglevel_type = ret;
1434                 } else if (!strcmp((const char *) node->name,
1435                         config_element_loglevel)) {
1436                         xmlChar *content;
1437                         int64_t loglevel = 0;
1438
1439                         /* loglevel */
1440                         content = xmlNodeGetContent(node);
1441                         if (!content) {
1442                                 ret = -LTTNG_ERR_NOMEM;
1443                                 goto end;
1444                         }
1445
1446                         ret = parse_int(content, &loglevel);
1447                         free(content);
1448                         if (ret) {
1449                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1450                                 goto end;
1451                         }
1452
1453                         if (loglevel > INT_MAX || loglevel < INT_MIN) {
1454                                 WARN("loglevel out of range.");
1455                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1456                                 goto end;
1457                         }
1458
1459                         event.loglevel = loglevel;
1460                 } else if (!strcmp((const char *) node->name,
1461                         config_element_filter)) {
1462                         xmlChar *content =
1463                                 xmlNodeGetContent(node);
1464
1465                         /* filter */
1466                         if (!content) {
1467                                 ret = -LTTNG_ERR_NOMEM;
1468                                 goto end;
1469                         }
1470
1471                         filter_expression = strdup((char *) content);
1472                         free(content);
1473                         if (!filter_expression) {
1474                                 ret = -LTTNG_ERR_NOMEM;
1475                                 goto end;
1476                         }
1477                 } else if (!strcmp((const char *) node->name,
1478                         config_element_exclusions)) {
1479                         xmlNodePtr exclusion_node;
1480                         int exclusion_index = 0;
1481
1482                         /* exclusions */
1483                         if (exclusions) {
1484                                 /*
1485                                  * Exclusions has already been initialized,
1486                                  * invalid file.
1487                                  */
1488                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1489                                 goto end;
1490                         }
1491
1492                         exclusion_count = xmlChildElementCount(node);
1493                         if (!exclusion_count) {
1494                                 continue;
1495                         }
1496
1497                         exclusions = zmalloc(exclusion_count * sizeof(char *));
1498                         if (!exclusions) {
1499                                 exclusion_count = 0;
1500                                 ret = -LTTNG_ERR_NOMEM;
1501                                 goto end;
1502                         }
1503
1504                         for (exclusion_node = xmlFirstElementChild(node); exclusion_node;
1505                                         exclusion_node = xmlNextElementSibling(exclusion_node)) {
1506                                 xmlChar *content =
1507                                         xmlNodeGetContent(exclusion_node);
1508
1509                                 if (!content) {
1510                                         ret = -LTTNG_ERR_NOMEM;
1511                                         goto end;
1512                                 }
1513
1514                                 exclusions[exclusion_index] = strdup((const char *) content);
1515                                 free(content);
1516                                 if (!exclusions[exclusion_index]) {
1517                                         ret = -LTTNG_ERR_NOMEM;
1518                                         goto end;
1519                                 }
1520                                 exclusion_index++;
1521                         }
1522
1523                         event.exclusion = 1;
1524                 } else if (!strcmp((const char *) node->name,
1525                         config_element_attributes)) {
1526                         xmlNodePtr attribute_node = xmlFirstElementChild(node);
1527
1528                         /* attributes */
1529                         if (!attribute_node) {
1530                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1531                                 goto end;
1532                         }
1533
1534                         if (!strcmp((const char *) node->name,
1535                                                 config_element_probe_attributes)) {
1536                                 xmlNodePtr probe_attribute_node;
1537
1538                                 /* probe_attributes */
1539                                 for (probe_attribute_node =
1540                                         xmlFirstElementChild(attribute_node); probe_attribute_node;
1541                                         probe_attribute_node = xmlNextElementSibling(
1542                                                         probe_attribute_node)) {
1543
1544                                         ret = process_probe_attribute_node(probe_attribute_node,
1545                                                         &event.attr.probe);
1546                                         if (ret) {
1547                                                 goto end;
1548                                         }
1549                                 }
1550                         } else {
1551                                 size_t sym_len;
1552                                 xmlChar *content;
1553                                 xmlNodePtr symbol_node = xmlFirstElementChild(attribute_node);
1554
1555                                 /* function_attributes */
1556                                 content = xmlNodeGetContent(symbol_node);
1557                                 if (!content) {
1558                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1559                                         goto end;
1560                                 }
1561
1562                                 sym_len = strlen((char *) content);
1563                                 if (sym_len >= LTTNG_SYMBOL_NAME_LEN) {
1564                                         WARN("Function name too long.");
1565                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1566                                         free(content);
1567                                         goto end;
1568                                 }
1569
1570                                 strncpy(event.attr.ftrace.symbol_name, (char *) content,
1571                                                 sym_len);
1572                                 free(content);
1573                         }
1574                 }
1575         }
1576
1577         ret = lttng_enable_event_with_exclusions(handle, &event, channel_name,
1578                         filter_expression, exclusion_count, exclusions);
1579 end:
1580         for (i = 0; i < exclusion_count; i++) {
1581                 free(exclusions[i]);
1582         }
1583
1584         free(exclusions);
1585         free(filter_expression);
1586         return ret;
1587 }
1588
1589 static
1590 int process_events_node(xmlNodePtr events_node, struct lttng_handle *handle,
1591         const char *channel_name)
1592 {
1593         int ret = 0;
1594         xmlNodePtr node;
1595
1596         assert(events_node);
1597         assert(handle);
1598         assert(channel_name);
1599
1600         for (node = xmlFirstElementChild(events_node); node;
1601                 node = xmlNextElementSibling(node)) {
1602                 ret = process_event_node(node, handle, channel_name);
1603                 if (ret) {
1604                         goto end;
1605                 }
1606         }
1607 end:
1608         return ret;
1609 }
1610
1611 static
1612 int process_channel_attr_node(xmlNodePtr attr_node,
1613                 struct lttng_channel *channel, xmlNodePtr *contexts_node,
1614                 xmlNodePtr *events_node)
1615 {
1616         int ret;
1617
1618         assert(attr_node);
1619         assert(channel);
1620         assert(contexts_node);
1621         assert(events_node);
1622
1623         if (!strcmp((const char *) attr_node->name, config_element_name)) {
1624                 xmlChar *content;
1625                 size_t name_len;
1626
1627                 /* name */
1628                 content = xmlNodeGetContent(attr_node);
1629                 if (!content) {
1630                         ret = -LTTNG_ERR_NOMEM;
1631                         goto end;
1632                 }
1633
1634                 name_len = strlen((char *) content);
1635                 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1636                         WARN("Channel name too long.");
1637                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1638                         free(content);
1639                         goto end;
1640                 }
1641
1642                 strncpy(channel->name, (const char *) content, name_len);
1643                 free(content);
1644         } else if (!strcmp((const char *) attr_node->name,
1645                         config_element_enabled)) {
1646                 xmlChar *content;
1647                 int enabled;
1648
1649                 /* enabled */
1650                 content = xmlNodeGetContent(attr_node);
1651                 if (!content) {
1652                         ret = -LTTNG_ERR_NOMEM;
1653                         goto end;
1654                 }
1655
1656                 ret = parse_bool(content, &enabled);
1657                 free(content);
1658                 if (ret) {
1659                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1660                         goto end;
1661                 }
1662
1663                 channel->enabled = enabled;
1664         } else if (!strcmp((const char *) attr_node->name,
1665                         config_element_overwrite_mode)) {
1666                 xmlChar *content;
1667
1668                 /* overwrite_mode */
1669                 content = xmlNodeGetContent(attr_node);
1670                 if (!content) {
1671                         ret = -LTTNG_ERR_NOMEM;
1672                         goto end;
1673                 }
1674
1675                 ret = get_overwrite_mode(content);
1676                 free(content);
1677                 if (ret < 0) {
1678                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1679                         goto end;
1680                 }
1681
1682                 channel->attr.overwrite = ret;
1683         } else if (!strcmp((const char *) attr_node->name,
1684                         config_element_subbuf_size)) {
1685                 xmlChar *content;
1686
1687                 /* subbuffer_size */
1688                 content = xmlNodeGetContent(attr_node);
1689                 if (!content) {
1690                         ret = -LTTNG_ERR_NOMEM;
1691                         goto end;
1692                 }
1693
1694                 ret = parse_uint(content, &channel->attr.subbuf_size);
1695                 free(content);
1696                 if (ret) {
1697                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1698                         goto end;
1699                 }
1700         } else if (!strcmp((const char *) attr_node->name,
1701                         config_element_num_subbuf)) {
1702                 xmlChar *content;
1703
1704                 /* subbuffer_count */
1705                 content = xmlNodeGetContent(attr_node);
1706                 if (!content) {
1707                         ret = -LTTNG_ERR_NOMEM;
1708                         goto end;
1709                 }
1710
1711                 ret = parse_uint(content, &channel->attr.num_subbuf);
1712                 free(content);
1713                 if (ret) {
1714                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1715                         goto end;
1716                 }
1717         } else if (!strcmp((const char *) attr_node->name,
1718                         config_element_switch_timer_interval)) {
1719                 xmlChar *content;
1720                 uint64_t switch_timer_interval = 0;
1721
1722                 /* switch_timer_interval */
1723                 content = xmlNodeGetContent(attr_node);
1724                 if (!content) {
1725                         ret = -LTTNG_ERR_NOMEM;
1726                         goto end;
1727                 }
1728
1729                 ret = parse_uint(content, &switch_timer_interval);
1730                 free(content);
1731                 if (ret) {
1732                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1733                         goto end;
1734                 }
1735
1736                 if (switch_timer_interval > UINT_MAX) {
1737                         WARN("switch_timer_interval out of range.");
1738                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1739                         goto end;
1740                 }
1741
1742                 channel->attr.switch_timer_interval =
1743                         switch_timer_interval;
1744         } else if (!strcmp((const char *) attr_node->name,
1745                         config_element_read_timer_interval)) {
1746                 xmlChar *content;
1747                 uint64_t read_timer_interval = 0;
1748
1749                 /* read_timer_interval */
1750                 content = xmlNodeGetContent(attr_node);
1751                 if (!content) {
1752                         ret = -LTTNG_ERR_NOMEM;
1753                         goto end;
1754                 }
1755
1756                 ret = parse_uint(content, &read_timer_interval);
1757                 free(content);
1758                 if (ret) {
1759                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1760                         goto end;
1761                 }
1762
1763                 if (read_timer_interval > UINT_MAX) {
1764                         WARN("read_timer_interval out of range.");
1765                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1766                         goto end;
1767                 }
1768
1769                 channel->attr.read_timer_interval =
1770                         read_timer_interval;
1771         } else if (!strcmp((const char *) attr_node->name,
1772                         config_element_output_type)) {
1773                 xmlChar *content;
1774
1775                 /* output_type */
1776                 content = xmlNodeGetContent(attr_node);
1777                 if (!content) {
1778                         ret = -LTTNG_ERR_NOMEM;
1779                         goto end;
1780                 }
1781
1782                 ret = get_output_type(content);
1783                 free(content);
1784                 if (ret < 0) {
1785                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1786                         goto end;
1787                 }
1788
1789                 channel->attr.output = ret;
1790         } else if (!strcmp((const char *) attr_node->name,
1791                         config_element_tracefile_size)) {
1792                 xmlChar *content;
1793
1794                 /* tracefile_size */
1795                 content = xmlNodeGetContent(attr_node);
1796                 if (!content) {
1797                         ret = -LTTNG_ERR_NOMEM;
1798                         goto end;
1799                 }
1800
1801                 ret = parse_uint(content, &channel->attr.tracefile_size);
1802                 free(content);
1803                 if (ret) {
1804                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1805                         goto end;
1806                 }
1807         } else if (!strcmp((const char *) attr_node->name,
1808                         config_element_tracefile_count)) {
1809                 xmlChar *content;
1810
1811                 /* tracefile_count */
1812                 content = xmlNodeGetContent(attr_node);
1813                 if (!content) {
1814                         ret = -LTTNG_ERR_NOMEM;
1815                         goto end;
1816                 }
1817
1818                 ret = parse_uint(content, &channel->attr.tracefile_count);
1819                 free(content);
1820                 if (ret) {
1821                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1822                         goto end;
1823                 }
1824         } else if (!strcmp((const char *) attr_node->name,
1825                         config_element_live_timer_interval)) {
1826                 xmlChar *content;
1827                 uint64_t live_timer_interval = 0;
1828
1829                 /* live_timer_interval */
1830                 content = xmlNodeGetContent(attr_node);
1831                 if (!content) {
1832                         ret = -LTTNG_ERR_NOMEM;
1833                         goto end;
1834                 }
1835
1836                 ret = parse_uint(content, &live_timer_interval);
1837                 free(content);
1838                 if (ret) {
1839                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1840                         goto end;
1841                 }
1842
1843                 if (live_timer_interval > UINT_MAX) {
1844                         WARN("live_timer_interval out of range.");
1845                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1846                         goto end;
1847                 }
1848
1849                 channel->attr.live_timer_interval =
1850                         live_timer_interval;
1851         } else if (!strcmp((const char *) attr_node->name,
1852                         config_element_events)) {
1853                 /* events */
1854                 *events_node = attr_node;
1855         } else {
1856                 /* contexts */
1857                 *contexts_node = attr_node;
1858         }
1859         ret = 0;
1860 end:
1861         return ret;
1862 }
1863
1864 static
1865 int process_context_node(xmlNodePtr context_node,
1866         struct lttng_handle *handle, const char *channel_name)
1867 {
1868         int ret;
1869         struct lttng_event_context context;
1870         xmlNodePtr context_child_node = xmlFirstElementChild(context_node);
1871
1872         assert(handle);
1873         assert(channel_name);
1874
1875         if (!context_child_node) {
1876                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1877                 goto end;
1878         }
1879
1880         memset(&context, 0, sizeof(context));
1881
1882         if (!strcmp((const char *) context_child_node->name,
1883                 config_element_type)) {
1884                 /* type */
1885                 xmlChar *content = xmlNodeGetContent(context_child_node);
1886                 if (!content) {
1887                         ret = -LTTNG_ERR_NOMEM;
1888                         goto end;
1889                 }
1890
1891                 ret = get_context_type(content);
1892                 free(content);
1893                 if (ret < 0) {
1894                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1895                         goto end;
1896                 }
1897
1898                 context.ctx = ret;
1899         } else {
1900                 xmlNodePtr perf_attr_node;
1901
1902                 /* perf */
1903                 context.ctx = LTTNG_EVENT_CONTEXT_PERF_COUNTER;
1904                 for (perf_attr_node = xmlFirstElementChild(context_child_node);
1905                         perf_attr_node; perf_attr_node =
1906                                 xmlNextElementSibling(perf_attr_node)) {
1907                         if (!strcmp((const char *) perf_attr_node->name,
1908                                 config_element_type)) {
1909                                 xmlChar *content;
1910                                 uint64_t type = 0;
1911
1912                                 /* type */
1913                                 content = xmlNodeGetContent(perf_attr_node);
1914                                 if (!content) {
1915                                         ret = -LTTNG_ERR_NOMEM;
1916                                         goto end;
1917                                 }
1918
1919                                 ret = parse_uint(content, &type);
1920                                 free(content);
1921                                 if (ret) {
1922                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1923                                         goto end;
1924                                 }
1925
1926                                 if (type > UINT32_MAX) {
1927                                         WARN("perf context type out of range.");
1928                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1929                                         goto end;
1930                                 }
1931
1932                                 context.u.perf_counter.type = type;
1933                         } else if (!strcmp((const char *) perf_attr_node->name,
1934                                 config_element_config)) {
1935                                 xmlChar *content;
1936                                 uint64_t config = 0;
1937
1938                                 /* config */
1939                                 content = xmlNodeGetContent(perf_attr_node);
1940                                 if (!content) {
1941                                         ret = -LTTNG_ERR_NOMEM;
1942                                         goto end;
1943                                 }
1944
1945                                 ret = parse_uint(content, &config);
1946                                 free(content);
1947                                 if (ret) {
1948                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1949                                         goto end;
1950                                 }
1951
1952                                 context.u.perf_counter.config = config;
1953                         } else if (!strcmp((const char *) perf_attr_node->name,
1954                                 config_element_name)) {
1955                                 xmlChar *content;
1956                                 size_t name_len;
1957
1958                                 /* name */
1959                                 content = xmlNodeGetContent(perf_attr_node);
1960                                 if (!content) {
1961                                         ret = -LTTNG_ERR_NOMEM;
1962                                         goto end;
1963                                 }
1964
1965                                 name_len = strlen((char *) content);
1966                                 if (name_len >= LTTNG_SYMBOL_NAME_LEN) {
1967                                         WARN("perf context name too long.");
1968                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
1969                                         free(content);
1970                                         goto end;
1971                                 }
1972
1973                                 strncpy(context.u.perf_counter.name, (const char *) content,
1974                                                 name_len);
1975                                 free(content);
1976                         }
1977                 }
1978         }
1979
1980         ret = lttng_add_context(handle, &context, NULL, channel_name);
1981 end:
1982         return ret;
1983 }
1984
1985 static
1986 int process_contexts_node(xmlNodePtr contexts_node,
1987         struct lttng_handle *handle, const char *channel_name)
1988 {
1989         int ret = 0;
1990         xmlNodePtr context_node;
1991
1992         for (context_node = xmlFirstElementChild(contexts_node); context_node;
1993                         context_node = xmlNextElementSibling(context_node)) {
1994                 ret = process_context_node(context_node, handle, channel_name);
1995                 if (ret) {
1996                         goto end;
1997                 }
1998         }
1999 end:
2000         return ret;
2001 }
2002
2003 static
2004 int process_domain_node(xmlNodePtr domain_node, const char *session_name)
2005 {
2006         int ret;
2007         struct lttng_domain domain = { 0 };
2008         struct lttng_handle *handle = NULL;
2009         xmlNodePtr channels_node = NULL;
2010         xmlNodePtr node;
2011
2012         assert(session_name);
2013
2014         ret = init_domain(domain_node, &domain);
2015         if (ret) {
2016                 goto end;
2017         }
2018
2019         handle = lttng_create_handle(session_name, &domain);
2020         if (!handle) {
2021                 ret = -LTTNG_ERR_NOMEM;
2022                 goto end;
2023         }
2024
2025         /* get the channels node */
2026         for (node = xmlFirstElementChild(domain_node); node;
2027                 node = xmlNextElementSibling(node)) {
2028                 if (!strcmp((const char *) node->name,
2029                         config_element_channels)) {
2030                         channels_node = node;
2031                         break;
2032                 }
2033         }
2034
2035         if (!channels_node) {
2036                 goto end;
2037         }
2038
2039         /* create all channels */
2040         for (node = xmlFirstElementChild(channels_node); node;
2041                 node = xmlNextElementSibling(node)) {
2042                 struct lttng_channel channel;
2043                 xmlNodePtr contexts_node = NULL;
2044                 xmlNodePtr events_node = NULL;
2045                 xmlNodePtr channel_attr_node;
2046
2047                 memset(&channel, 0, sizeof(channel));
2048                 lttng_channel_set_default_attr(&domain, &channel.attr);
2049
2050                 for (channel_attr_node = xmlFirstElementChild(node);
2051                         channel_attr_node; channel_attr_node =
2052                         xmlNextElementSibling(channel_attr_node)) {
2053                         ret = process_channel_attr_node(channel_attr_node,
2054                                 &channel, &contexts_node, &events_node);
2055                         if (ret) {
2056                                 goto end;
2057                         }
2058                 }
2059
2060                 ret = lttng_enable_channel(handle, &channel);
2061                 if (ret < 0) {
2062                         goto end;
2063                 }
2064
2065                 ret = process_events_node(events_node, handle, channel.name);
2066                 if (ret) {
2067                         goto end;
2068                 }
2069
2070                 ret = process_contexts_node(contexts_node, handle,
2071                         channel.name);
2072                 if (ret) {
2073                         goto end;
2074                 }
2075         }
2076 end:
2077         lttng_destroy_handle(handle);
2078         return ret;
2079 }
2080
2081 static
2082 int process_session_node(xmlNodePtr session_node, const char *session_name,
2083                 int override)
2084 {
2085         int ret, started = -1, snapshot_mode = -1;
2086         uint64_t live_timer_interval = UINT64_MAX;
2087         char *name = NULL;
2088         xmlNodePtr domains_node = NULL;
2089         xmlNodePtr output_node = NULL;
2090         xmlNodePtr node;
2091         struct lttng_domain *kernel_domain = NULL;
2092         struct lttng_domain *ust_domain = NULL;
2093         struct lttng_domain *jul_domain = NULL;
2094
2095         for (node = xmlFirstElementChild(session_node); node;
2096                 node = xmlNextElementSibling(node)) {
2097                 if (!name && !strcmp((const char *) node->name,
2098                         config_element_name)) {
2099                         /* name */
2100                         xmlChar *node_content = xmlNodeGetContent(node);
2101                         if (!node_content) {
2102                                 ret = -LTTNG_ERR_NOMEM;
2103                                 goto end;
2104                         }
2105
2106                         name = (char *) node_content;
2107                 } else if (!domains_node && !strcmp((const char *) node->name,
2108                         config_element_domains)) {
2109                         /* domains */
2110                         domains_node = node;
2111                 } else if (started == -1 && !strcmp((const char *) node->name,
2112                         config_element_started)) {
2113                         /* started */
2114                         xmlChar *node_content = xmlNodeGetContent(node);
2115                         if (!node_content) {
2116                                 ret = -LTTNG_ERR_NOMEM;
2117                                 goto end;
2118                         }
2119
2120                         ret = parse_bool(node_content, &started);
2121                         free(node_content);
2122                         if (ret) {
2123                                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2124                                 goto end;
2125                         }
2126                 } else if (!output_node && !strcmp((const char *) node->name,
2127                         config_element_output)) {
2128                         /* output */
2129                         output_node = node;
2130                 } else {
2131                         /* attributes, snapshot_mode or live_timer_interval */
2132                         xmlNodePtr attributes_child =
2133                                 xmlFirstElementChild(node);
2134
2135                         if (!strcmp((const char *) attributes_child->name,
2136                                 config_element_snapshot_mode)) {
2137                                 /* snapshot_mode */
2138                                 xmlChar *snapshot_mode_content =
2139                                         xmlNodeGetContent(attributes_child);
2140                                 if (!snapshot_mode_content) {
2141                                         ret = -LTTNG_ERR_NOMEM;
2142                                         goto end;
2143                                 }
2144
2145                                 ret = parse_bool(snapshot_mode_content, &snapshot_mode);
2146                                 free(snapshot_mode_content);
2147                                 if (ret) {
2148                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2149                                         goto end;
2150                                 }
2151                         } else {
2152                                 /* live_timer_interval */
2153                                 xmlChar *timer_interval_content =
2154                                         xmlNodeGetContent(attributes_child);
2155                                 if (!timer_interval_content) {
2156                                         ret = -LTTNG_ERR_NOMEM;
2157                                         goto end;
2158                                 }
2159
2160                                 ret = parse_uint(timer_interval_content, &live_timer_interval);
2161                                 free(timer_interval_content);
2162                                 if (ret) {
2163                                         ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2164                                         goto end;
2165                                 }
2166                         }
2167                 }
2168         }
2169
2170         if (!name) {
2171                 /* Mandatory attribute, as defined in the session XSD */
2172                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2173                 goto end;
2174         }
2175
2176         if (session_name && strcmp(name, session_name)) {
2177                 /* This is not the session we are looking for */
2178                 ret = -LTTNG_ERR_LOAD_SESSION_NOENT;
2179                 goto end;
2180         }
2181
2182         /* Init domains to create the session handles */
2183         for (node = xmlFirstElementChild(domains_node); node;
2184                 node = xmlNextElementSibling(node)) {
2185                 struct lttng_domain *domain;
2186
2187                 domain = zmalloc(sizeof(*domain));
2188                 if (!domain) {
2189                         ret = -LTTNG_ERR_NOMEM;
2190                         goto end;
2191                 }
2192
2193                 ret = init_domain(node, domain);
2194                 if (ret) {
2195                         goto domain_init_error;
2196                 }
2197
2198                 switch (domain->type) {
2199                 case LTTNG_DOMAIN_KERNEL:
2200                         if (kernel_domain) {
2201                                 /* Same domain seen twice, invalid! */
2202                                 goto domain_init_error;
2203                         }
2204                         kernel_domain = domain;
2205                         break;
2206                 case LTTNG_DOMAIN_UST:
2207                         if (ust_domain) {
2208                                 /* Same domain seen twice, invalid! */
2209                                 goto domain_init_error;
2210                         }
2211                         ust_domain = domain;
2212                         break;
2213                 case LTTNG_DOMAIN_JUL:
2214                         if (jul_domain) {
2215                                 /* Same domain seen twice, invalid! */
2216                                 goto domain_init_error;
2217                         }
2218                         jul_domain = domain;
2219                         break;
2220                 default:
2221                         WARN("Invalid domain type");
2222                         goto domain_init_error;
2223                 }
2224                 continue;
2225 domain_init_error:
2226                 free(domain);
2227                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2228                 goto end;
2229         }
2230
2231         if (override) {
2232                 /* Destroy session if it exists */
2233                 ret = lttng_destroy_session(name);
2234                 if (ret && ret != -LTTNG_ERR_SESS_NOT_FOUND) {
2235                         ERR("Failed to destroy existing session.");
2236                         goto end;
2237                 }
2238         }
2239
2240         /* Create session type depending on output type */
2241         if (snapshot_mode && snapshot_mode != -1) {
2242                 ret = create_snapshot_session(name, output_node);
2243         } else if (live_timer_interval &&
2244                 live_timer_interval != UINT64_MAX) {
2245                 ret = create_session(name, kernel_domain, ust_domain, jul_domain,
2246                                 output_node, live_timer_interval);
2247         } else {
2248                 /* regular session */
2249                 ret = create_session(name, kernel_domain, ust_domain, jul_domain,
2250                                 output_node, UINT64_MAX);
2251         }
2252
2253         if (ret) {
2254                 goto end;
2255         }
2256
2257         for (node = xmlFirstElementChild(domains_node); node;
2258                 node = xmlNextElementSibling(node)) {
2259                 ret = process_domain_node(node, name);
2260                 if (ret) {
2261                         goto end;
2262                 }
2263         }
2264
2265         if (started) {
2266                 ret = lttng_start_tracing(name);
2267                 if (ret) {
2268                         goto end;
2269                 }
2270         }
2271 end:
2272         free(kernel_domain);
2273         free(ust_domain);
2274         free(jul_domain);
2275         free(name);
2276         return ret;
2277 }
2278
2279 static
2280 int load_session_from_file(const char *path, const char *session_name,
2281         struct session_config_validation_ctx *validation_ctx, int override)
2282 {
2283         int ret, session_found = !session_name;
2284         xmlDocPtr doc = NULL;
2285         xmlNodePtr sessions_node;
2286         xmlNodePtr session_node;
2287         struct stat sb;
2288
2289         assert(path);
2290         assert(validation_ctx);
2291
2292         ret = stat(path, &sb);
2293         if (ret) {
2294                 ret = -LTTNG_ERR_LOAD_SESSION_NOENT;
2295                 goto end;
2296         }
2297
2298         doc = xmlParseFile(path);
2299         if (!doc) {
2300                 ret = -LTTNG_ERR_LOAD_IO_FAIL;
2301                 goto end;
2302         }
2303
2304         ret = xmlSchemaValidateDoc(validation_ctx->schema_validation_ctx, doc);
2305         if (ret) {
2306                 ERR("Session configuration file validation failed");
2307                 ret = -LTTNG_ERR_LOAD_INVALID_CONFIG;
2308                 goto end;
2309         }
2310
2311         sessions_node = xmlDocGetRootElement(doc);
2312         if (!sessions_node) {
2313                 goto end;
2314         }
2315
2316         for (session_node = xmlFirstElementChild(sessions_node);
2317                 session_node; session_node =
2318                         xmlNextElementSibling(session_node)) {
2319                 ret = process_session_node(session_node,
2320                         session_name, override);
2321                 if (session_name && ret == 0) {
2322                         /* Target session found and loaded */
2323                         session_found = 1;
2324                         break;
2325                 }
2326         }
2327 end:
2328         xmlFreeDoc(doc);
2329         if (!ret) {
2330                 ret = session_found ? 0 : -LTTNG_ERR_LOAD_SESSION_NOENT;
2331         }
2332         return ret;
2333 }
2334
2335 static
2336 int load_session_from_path(const char *path, const char *session_name,
2337         struct session_config_validation_ctx *validation_ctx, int override)
2338 {
2339         int ret, session_found = !session_name;
2340         DIR *directory = NULL;
2341
2342         assert(path);
2343         assert(validation_ctx);
2344
2345         directory = opendir(path);
2346         if (!directory) {
2347                 if (errno != ENOTDIR) {
2348                         ret = -LTTNG_ERR_LOAD_IO_FAIL;
2349                         goto end;
2350                 }
2351         }
2352         if (directory) {
2353                 struct dirent *entry;
2354                 struct dirent *result;
2355                 char *file_path = NULL;
2356                 size_t path_len = strlen(path);
2357
2358                 if (path_len >= PATH_MAX) {
2359                         ret = -LTTNG_ERR_INVALID;
2360                         goto end;
2361                 }
2362
2363                 entry = zmalloc(sizeof(*entry));
2364                 if (!entry) {
2365                         ret = -LTTNG_ERR_NOMEM;
2366                         goto end;
2367                 }
2368
2369                 file_path = zmalloc(PATH_MAX);
2370                 if (!file_path) {
2371                         ret = -LTTNG_ERR_NOMEM;
2372                         free(entry);
2373                         goto end;
2374                 }
2375
2376                 strncpy(file_path, path, path_len);
2377                 if (file_path[path_len - 1] != '/') {
2378                         file_path[path_len++] = '/';
2379                 }
2380
2381                 ret = 0;
2382                 /* Search for *.lttng files */
2383                 while (!readdir_r(directory, entry, &result) && result) {
2384                         size_t file_name_len = strlen(result->d_name);
2385
2386                         if (file_name_len <=
2387                                 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION)) {
2388                                 continue;
2389                         }
2390
2391                         if (path_len + file_name_len > PATH_MAX) {
2392                                 continue;
2393                         }
2394
2395                         if (strcmp(DEFAULT_SESSION_CONFIG_FILE_EXTENSION,
2396                                 result->d_name + file_name_len - sizeof(
2397                                 DEFAULT_SESSION_CONFIG_FILE_EXTENSION) + 1)) {
2398                                 continue;
2399                         }
2400
2401                         strncpy(file_path + path_len, result->d_name, file_name_len);
2402                         file_path[path_len + file_name_len] = '\0';
2403
2404                         ret = load_session_from_file(file_path, session_name,
2405                                 validation_ctx, override);
2406                         if (session_name && !ret) {
2407                                 session_found = 1;
2408                                 break;
2409                         }
2410                 }
2411
2412                 free(entry);
2413                 free(file_path);
2414         } else {
2415                 ret = load_session_from_file(path, session_name,
2416                         validation_ctx, override);
2417                 if (ret) {
2418                         goto end;
2419                 } else {
2420                         session_found = 1;
2421                 }
2422         }
2423
2424 end:
2425         if (directory) {
2426                 if (closedir(directory)) {
2427                         PERROR("closedir");
2428                 }
2429         }
2430
2431         if (!session_found) {
2432                 ret = -LTTNG_ERR_LOAD_SESSION_NOENT;
2433         }
2434
2435         return ret;
2436 }
2437
2438 LTTNG_HIDDEN
2439 int config_load_session(const char *path, const char *session_name,
2440                 int override)
2441 {
2442         int ret;
2443         struct session_config_validation_ctx validation_ctx = { 0 };
2444
2445         ret = init_session_config_validation_ctx(&validation_ctx);
2446         if (ret) {
2447                 goto end;
2448         }
2449
2450         if (!path) {
2451                 /* Try home path */
2452                 char *home_path = utils_get_home_dir();
2453                 if (home_path) {
2454                         char *path;
2455
2456                         ret = asprintf(&path, DEFAULT_SESSION_HOME_CONFIGPATH,
2457                                 home_path);
2458                         if (ret < 0) {
2459                                 goto end;
2460                         }
2461
2462                         ret = load_session_from_path(path, NULL,
2463                                 &validation_ctx, 0);
2464                         if (ret && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) {
2465                                 free(path);
2466                                 goto end;
2467                         }
2468
2469                         free(path);
2470                 }
2471
2472                 /* Try system session configuration path */
2473                 ret = load_session_from_path(DEFAULT_SESSION_SYSTEM_CONFIGPATH, NULL,
2474                                 &validation_ctx, 0);
2475                 if (ret && ret != -LTTNG_ERR_LOAD_SESSION_NOENT) {
2476                         goto end;
2477                 }
2478         } else {
2479                 ret = access(path, F_OK);
2480                 if (ret < 0) {
2481                         PERROR("access");
2482                         switch (errno) {
2483                         case ENOENT:
2484                                 ret = -LTTNG_ERR_INVALID;
2485                                 WARN("Session configuration path does not exist.");
2486                                 break;
2487                         case EACCES:
2488                                 ret = -LTTNG_ERR_EPERM;
2489                                 break;
2490                         default:
2491                                 ret = -LTTNG_ERR_UNK;
2492                                 break;
2493                         }
2494                         goto end;
2495                 }
2496
2497                 ret = load_session_from_path(path, session_name,
2498                         &validation_ctx, override);
2499         }
2500 end:
2501         fini_session_config_validation_ctx(&validation_ctx);
2502         return ret;
2503 }