src/common/mi-lttng.c

   1 /*
   2  * Copyright (C) 2014 Jonathan Rajotte <jonathan.r.julien@gmail.com>
   3  * Copyright (C) 2014 Olivier Cotte <olivier.cotte@polymtl.ca>
   4  * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-only
   7  *
   8  */
   9
  10 #define _LGPL_SOURCE
  11 #include <common/config/session-config.h>
  12 #include <common/defaults.h>
  13 #include <lttng/snapshot-internal.h>
  14 #include <lttng/tracker-internal.h>
  15 #include <lttng/channel.h>
  16 #include "mi-lttng.h"
  17
  18 #include <assert.h>
  19
  20 #define MI_SCHEMA_MAJOR_VERSION 3
  21 #define MI_SCHEMA_MINOR_VERSION 0
  22
  23 /* Machine interface namespace URI */
  24 LTTNG_HIDDEN const char * const mi_lttng_xmlns = "xmlns";
  25 LTTNG_HIDDEN const char * const mi_lttng_xmlns_xsi = "xmlns:xsi";
  26 LTTNG_HIDDEN const char * const mi_lttng_w3_schema_uri = "http://www.w3.org/2001/XMLSchema-instance";
  27 LTTNG_HIDDEN const char * const mi_lttng_schema_location = "xsi:schemaLocation";
  28 LTTNG_HIDDEN const char * const mi_lttng_schema_location_uri =
  29         DEFAULT_LTTNG_MI_NAMESPACE " "
  30         "https://lttng.org/xml/schemas/lttng-mi/" XSTR(MI_SCHEMA_MAJOR_VERSION)
  31         "/lttng-mi-" XSTR(MI_SCHEMA_MAJOR_VERSION) "."
  32         XSTR(MI_SCHEMA_MINOR_VERSION) ".xsd";
  33 LTTNG_HIDDEN const char * const mi_lttng_schema_version = "schemaVersion";
  34 LTTNG_HIDDEN const char * const mi_lttng_schema_version_value = XSTR(MI_SCHEMA_MAJOR_VERSION)
  35         "." XSTR(MI_SCHEMA_MINOR_VERSION);
  36
  37 /* Strings related to command */
  38 const char * const mi_lttng_element_command = "command";
  39 const char * const mi_lttng_element_command_action = "snapshot_action";
  40 const char * const mi_lttng_element_command_add_context = "add-context";
  41 const char * const mi_lttng_element_command_create = "create";
  42 const char * const mi_lttng_element_command_destroy = "destroy";
  43 const char * const mi_lttng_element_command_disable_channel = "disable-channel";
  44 const char * const mi_lttng_element_command_disable_event = "disable-event";
  45 const char * const mi_lttng_element_command_enable_channels = "enable-channel";
  46 const char * const mi_lttng_element_command_enable_event = "enable-event";
  47 const char * const mi_lttng_element_command_list = "list";
  48 const char * const mi_lttng_element_command_load = "load";
  49 LTTNG_HIDDEN const char * const mi_lttng_element_command_metadata = "metadata";
  50 LTTNG_HIDDEN const char * const mi_lttng_element_command_metadata_action = "metadata_action";
  51 LTTNG_HIDDEN const char * const mi_lttng_element_command_regenerate = "regenerate";
  52 LTTNG_HIDDEN const char * const mi_lttng_element_command_regenerate_action = "regenerate_action";
  53 const char * const mi_lttng_element_command_name = "name";
  54 const char * const mi_lttng_element_command_output = "output";
  55 const char * const mi_lttng_element_command_save = "save";
  56 const char * const mi_lttng_element_command_set_session = "set-session";
  57 const char * const mi_lttng_element_command_snapshot = "snapshot";
  58 const char * const mi_lttng_element_command_snapshot_add = "add_snapshot";
  59 const char * const mi_lttng_element_command_snapshot_del = "del_snapshot";
  60 const char * const mi_lttng_element_command_snapshot_list = "list_snapshot";
  61 const char * const mi_lttng_element_command_snapshot_record = "record_snapshot";
  62 const char * const mi_lttng_element_command_start = "start";
  63 const char * const mi_lttng_element_command_stop = "stop";
  64 const char * const mi_lttng_element_command_success = "success";
  65 const char * const mi_lttng_element_command_track = "track";
  66 const char * const mi_lttng_element_command_untrack = "untrack";
  67 const char * const mi_lttng_element_command_version = "version";
  68 LTTNG_HIDDEN const char * const mi_lttng_element_command_rotate = "rotate";
  69 LTTNG_HIDDEN const char * const mi_lttng_element_command_enable_rotation = "enable-rotation";
  70 LTTNG_HIDDEN const char * const mi_lttng_element_command_disable_rotation = "disable-rotation";
  71 LTTNG_HIDDEN const char * const mi_lttng_element_command_clear = "clear";
  72
  73 /* Strings related to version command */
  74 const char * const mi_lttng_element_version = "version";
  75 const char * const mi_lttng_element_version_commit = "commit";
  76 const char * const mi_lttng_element_version_description = "description";
  77 const char * const mi_lttng_element_version_license = "license";
  78 const char * const mi_lttng_element_version_major = "major";
  79 const char * const mi_lttng_element_version_minor = "minor";
  80 const char * const mi_lttng_element_version_patch_level = "patchLevel";
  81 const char * const mi_lttng_element_version_str = "string";
  82 const char * const mi_lttng_element_version_web = "url";
  83
  84 /* String related to a lttng_event_field */
  85 const char * const mi_lttng_element_event_field = "event_field";
  86 const char * const mi_lttng_element_event_fields = "event_fields";
  87
  88 /* String related to lttng_event_perf_counter_ctx */
  89 const char * const mi_lttng_element_perf_counter_context = "perf";
  90
  91 /* Strings related to pid */
  92 const char * const mi_lttng_element_pid_id = "id";
  93
  94 /* Strings related to save command */
  95 const char * const mi_lttng_element_save = "save";
  96
  97 /* Strings related to load command */
  98 const char * const mi_lttng_element_load = "load";
  99 LTTNG_HIDDEN const char * const mi_lttng_element_load_overrides = "overrides";
 100 LTTNG_HIDDEN const char * const mi_lttng_element_load_override_url = "url";
 101
 102 /* General elements of mi_lttng */
 103 const char * const mi_lttng_element_empty = "";
 104 const char * const mi_lttng_element_id = "id";
 105 const char * const mi_lttng_element_nowrite = "nowrite";
 106 const char * const mi_lttng_element_success = "success";
 107 const char * const mi_lttng_element_type_enum = "ENUM";
 108 const char * const mi_lttng_element_type_float = "FLOAT";
 109 const char * const mi_lttng_element_type_integer = "INTEGER";
 110 const char * const mi_lttng_element_type_other = "OTHER";
 111 const char * const mi_lttng_element_type_string = "STRING";
 112
 113 /* String related to loglevel */
 114 const char * const mi_lttng_loglevel_str_alert = "TRACE_ALERT";
 115 const char * const mi_lttng_loglevel_str_crit = "TRACE_CRIT";
 116 const char * const mi_lttng_loglevel_str_debug = "TRACE_DEBUG";
 117 const char * const mi_lttng_loglevel_str_debug_function = "TRACE_DEBUG_FUNCTION";
 118 const char * const mi_lttng_loglevel_str_debug_line = "TRACE_DEBUG_LINE";
 119 const char * const mi_lttng_loglevel_str_debug_module = "TRACE_DEBUG_MODULE";
 120 const char * const mi_lttng_loglevel_str_debug_process = "TRACE_DEBUG_PROCESS";
 121 const char * const mi_lttng_loglevel_str_debug_program = "TRACE_DEBUG_PROGRAM";
 122 const char * const mi_lttng_loglevel_str_debug_system = "TRACE_DEBUG_SYSTEM";
 123 const char * const mi_lttng_loglevel_str_debug_unit = "TRACE_DEBUG_UNIT";
 124 const char * const mi_lttng_loglevel_str_emerg = "TRACE_EMERG";
 125 const char * const mi_lttng_loglevel_str_err = "TRACE_ERR";
 126 const char * const mi_lttng_loglevel_str_info = "TRACE_INFO";
 127 const char * const mi_lttng_loglevel_str_notice = "TRACE_NOTICE";
 128 const char * const mi_lttng_loglevel_str_unknown = "UNKNOWN";
 129 const char * const mi_lttng_loglevel_str_warning = "TRACE_WARNING";
 130
 131 /* String related to loglevel JUL */
 132 const char * const mi_lttng_loglevel_str_jul_all = "JUL_ALL";
 133 const char * const mi_lttng_loglevel_str_jul_config = "JUL_CONFIG";
 134 const char * const mi_lttng_loglevel_str_jul_fine = "JUL_FINE";
 135 const char * const mi_lttng_loglevel_str_jul_finer = "JUL_FINER";
 136 const char * const mi_lttng_loglevel_str_jul_finest = "JUL_FINEST";
 137 const char * const mi_lttng_loglevel_str_jul_info = "JUL_INFO";
 138 const char * const mi_lttng_loglevel_str_jul_off = "JUL_OFF";
 139 const char * const mi_lttng_loglevel_str_jul_severe = "JUL_SEVERE";
 140 const char * const mi_lttng_loglevel_str_jul_warning = "JUL_WARNING";
 141
 142 /* String related to loglevel LOG4J */
 143 const char * const mi_lttng_loglevel_str_log4j_off = "LOG4J_OFF";
 144 const char * const mi_lttng_loglevel_str_log4j_fatal = "LOG4J_FATAL";
 145 const char * const mi_lttng_loglevel_str_log4j_error = "LOG4J_ERROR";
 146 const char * const mi_lttng_loglevel_str_log4j_warn = "LOG4J_WARN";
 147 const char * const mi_lttng_loglevel_str_log4j_info = "LOG4J_INFO";
 148 const char * const mi_lttng_loglevel_str_log4j_debug = "LOG4J_DEBUG";
 149 const char * const mi_lttng_loglevel_str_log4j_trace = "LOG4J_TRACE";
 150 const char * const mi_lttng_loglevel_str_log4j_all = "LOG4J_ALL";
 151
 152 /* String related to loglevel Python */
 153 const char * const mi_lttng_loglevel_str_python_critical = "PYTHON_CRITICAL";
 154 const char * const mi_lttng_loglevel_str_python_error = "PYTHON_ERROR";
 155 const char * const mi_lttng_loglevel_str_python_warning = "PYTHON_WARNING";
 156 const char * const mi_lttng_loglevel_str_python_info = "PYTHON_INFO";
 157 const char * const mi_lttng_loglevel_str_python_debug = "PYTHON_DEBUG";
 158 const char * const mi_lttng_loglevel_str_python_notset = "PYTHON_NOTSET";
 159
 160 /* String related to loglevel type */
 161 const char * const mi_lttng_loglevel_type_all = "ALL";
 162 const char * const mi_lttng_loglevel_type_range = "RANGE";
 163 const char * const mi_lttng_loglevel_type_single = "SINGLE";
 164 const char * const mi_lttng_loglevel_type_unknown = "UNKNOWN";
 165
 166 /* String related to a lttng_snapshot_output */
 167 const char * const mi_lttng_element_snapshot_ctrl_url = "ctrl_url";
 168 const char * const mi_lttng_element_snapshot_data_url = "data_url";
 169 const char * const mi_lttng_element_snapshot_max_size = "max_size";
 170 const char * const mi_lttng_element_snapshot_n_ptr = "n_ptr";
 171 const char * const mi_lttng_element_snapshot_session_name = "session_name";
 172 const char * const mi_lttng_element_snapshots = "snapshots";
 173
 174 /* String related to track/untrack command */
 175 const char * const mi_lttng_element_track_untrack_all_wildcard = "*";
 176
 177 LTTNG_HIDDEN const char * const mi_lttng_element_session_name = "session_name";
 178
 179 /* String related to rotate command */
 180 LTTNG_HIDDEN const char * const mi_lttng_element_rotation = "rotation";
 181 LTTNG_HIDDEN const char * const mi_lttng_element_rotate_status = "status";
 182 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule = "rotation_schedule";
 183 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedules = "rotation_schedules";
 184 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule_result = "rotation_schedule_result";
 185 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule_results = "rotation_schedule_results";
 186 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule_periodic = "periodic";
 187 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule_periodic_time_us = "time_us";
 188 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule_size_threshold = "size_threshold";
 189 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_schedule_size_threshold_bytes = "bytes";
 190 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_state = "state";
 191 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location = "location";
 192 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_local = "local";
 193 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_local_absolute_path = "absolute_path";
 194 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_relay = "relay";
 195 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_relay_host = "host";
 196 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_relay_control_port = "control_port";
 197 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_relay_data_port = "data_port";
 198 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_relay_protocol = "protocol";
 199 LTTNG_HIDDEN const char * const mi_lttng_element_rotation_location_relay_relative_path = "relative_path";
 200
 201 /* String related to enum lttng_rotation_state */
 202 LTTNG_HIDDEN const char * const mi_lttng_rotation_state_str_ongoing = "ONGOING";
 203 LTTNG_HIDDEN const char * const mi_lttng_rotation_state_str_completed = "COMPLETED";
 204 LTTNG_HIDDEN const char * const mi_lttng_rotation_state_str_expired = "EXPIRED";
 205 LTTNG_HIDDEN const char * const mi_lttng_rotation_state_str_error = "ERROR";
 206
 207 /* String related to enum lttng_trace_archive_location_relay_protocol_type */
 208 LTTNG_HIDDEN const char * const mi_lttng_rotation_location_relay_protocol_str_tcp = "TCP";
 209
 210 /* String related to add-context command */
 211 LTTNG_HIDDEN const char * const mi_lttng_element_context_symbol = "symbol";
 212
 213 /* Deprecated symbols preserved for ABI compatibility. */
 214 const char * const mi_lttng_context_type_perf_counter;
 215 const char * const mi_lttng_context_type_perf_cpu_counter;
 216 const char * const mi_lttng_context_type_perf_thread_counter;
 217 const char * const mi_lttng_element_track_untrack_pid_target;
 218 const char * const mi_lttng_element_track_untrack_targets;
 219 const char * const mi_lttng_element_calibrate;
 220 const char * const mi_lttng_element_calibrate_function;
 221 const char * const mi_lttng_element_command_calibrate;
 222
 223 /* This is a merge of jul loglevel and regular loglevel
 224  * Those should never overlap by definition
 225  * (see struct lttng_event loglevel)
 226  */
 227 LTTNG_HIDDEN
 228 const char *mi_lttng_loglevel_string(int value, enum lttng_domain_type domain)
 229 {
 230         switch (domain) {
 231         case LTTNG_DOMAIN_KERNEL:
 232         case LTTNG_DOMAIN_UST:
 233                 switch (value) {
 234                 case -1:
 235                         return mi_lttng_element_empty;
 236                 case LTTNG_LOGLEVEL_EMERG:
 237                         return mi_lttng_loglevel_str_emerg;
 238                 case LTTNG_LOGLEVEL_ALERT:
 239                         return mi_lttng_loglevel_str_alert;
 240                 case LTTNG_LOGLEVEL_CRIT:
 241                         return mi_lttng_loglevel_str_crit;
 242                 case LTTNG_LOGLEVEL_ERR:
 243                         return mi_lttng_loglevel_str_err;
 244                 case LTTNG_LOGLEVEL_WARNING:
 245                         return mi_lttng_loglevel_str_warning;
 246                 case LTTNG_LOGLEVEL_NOTICE:
 247                         return mi_lttng_loglevel_str_notice;
 248                 case LTTNG_LOGLEVEL_INFO:
 249                         return mi_lttng_loglevel_str_info;
 250                 case LTTNG_LOGLEVEL_DEBUG_SYSTEM:
 251                         return mi_lttng_loglevel_str_debug_system;
 252                 case LTTNG_LOGLEVEL_DEBUG_PROGRAM:
 253                         return mi_lttng_loglevel_str_debug_program;
 254                 case LTTNG_LOGLEVEL_DEBUG_PROCESS:
 255                         return mi_lttng_loglevel_str_debug_process;
 256                 case LTTNG_LOGLEVEL_DEBUG_MODULE:
 257                         return mi_lttng_loglevel_str_debug_module;
 258                 case LTTNG_LOGLEVEL_DEBUG_UNIT:
 259                         return mi_lttng_loglevel_str_debug_unit;
 260                 case LTTNG_LOGLEVEL_DEBUG_FUNCTION:
 261                         return mi_lttng_loglevel_str_debug_function;
 262                 case LTTNG_LOGLEVEL_DEBUG_LINE:
 263                         return mi_lttng_loglevel_str_debug_line;
 264                 case LTTNG_LOGLEVEL_DEBUG:
 265                         return mi_lttng_loglevel_str_debug;
 266                 default:
 267                         return mi_lttng_loglevel_str_unknown;
 268                 }
 269                 break;
 270         case LTTNG_DOMAIN_LOG4J:
 271                 switch (value) {
 272                 case -1:
 273                         return mi_lttng_element_empty;
 274                 case LTTNG_LOGLEVEL_LOG4J_OFF:
 275                         return mi_lttng_loglevel_str_log4j_off;
 276                 case LTTNG_LOGLEVEL_LOG4J_FATAL:
 277                         return mi_lttng_loglevel_str_log4j_fatal;
 278                 case LTTNG_LOGLEVEL_LOG4J_ERROR:
 279                         return mi_lttng_loglevel_str_log4j_error;
 280                 case LTTNG_LOGLEVEL_LOG4J_WARN:
 281                         return mi_lttng_loglevel_str_log4j_warn;
 282                 case LTTNG_LOGLEVEL_LOG4J_INFO:
 283                         return mi_lttng_loglevel_str_log4j_info;
 284                 case LTTNG_LOGLEVEL_LOG4J_DEBUG:
 285                         return mi_lttng_loglevel_str_log4j_debug;
 286                 case LTTNG_LOGLEVEL_LOG4J_TRACE:
 287                         return mi_lttng_loglevel_str_log4j_trace;
 288                 case LTTNG_LOGLEVEL_LOG4J_ALL:
 289                         return mi_lttng_loglevel_str_log4j_all;
 290                 default:
 291                         return mi_lttng_loglevel_str_unknown;
 292                 }
 293                 break;
 294         case LTTNG_DOMAIN_JUL:
 295                 switch (value) {
 296                 case -1:
 297                         return mi_lttng_element_empty;
 298                 case LTTNG_LOGLEVEL_JUL_OFF:
 299                         return mi_lttng_loglevel_str_jul_off;
 300                 case LTTNG_LOGLEVEL_JUL_SEVERE:
 301                         return mi_lttng_loglevel_str_jul_severe;
 302                 case LTTNG_LOGLEVEL_JUL_WARNING:
 303                         return mi_lttng_loglevel_str_jul_warning;
 304                 case LTTNG_LOGLEVEL_JUL_INFO:
 305                         return mi_lttng_loglevel_str_jul_info;
 306                 case LTTNG_LOGLEVEL_JUL_CONFIG:
 307                         return mi_lttng_loglevel_str_jul_config;
 308                 case LTTNG_LOGLEVEL_JUL_FINE:
 309                         return mi_lttng_loglevel_str_jul_fine;
 310                 case LTTNG_LOGLEVEL_JUL_FINER:
 311                         return mi_lttng_loglevel_str_jul_finer;
 312                 case LTTNG_LOGLEVEL_JUL_FINEST:
 313                         return mi_lttng_loglevel_str_jul_finest;
 314                 case LTTNG_LOGLEVEL_JUL_ALL:
 315                         return mi_lttng_loglevel_str_jul_all;
 316                 default:
 317                         return mi_lttng_loglevel_str_unknown;
 318                 }
 319                 break;
 320         case LTTNG_DOMAIN_PYTHON:
 321                 switch (value) {
 322                 case LTTNG_LOGLEVEL_PYTHON_CRITICAL:
 323                         return mi_lttng_loglevel_str_python_critical;
 324                 case LTTNG_LOGLEVEL_PYTHON_ERROR:
 325                         return mi_lttng_loglevel_str_python_error;
 326                 case LTTNG_LOGLEVEL_PYTHON_WARNING:
 327                         return mi_lttng_loglevel_str_python_warning;
 328                 case LTTNG_LOGLEVEL_PYTHON_INFO:
 329                         return mi_lttng_loglevel_str_python_info;
 330                 case LTTNG_LOGLEVEL_PYTHON_DEBUG:
 331                         return mi_lttng_loglevel_str_python_debug;
 332                 case LTTNG_LOGLEVEL_PYTHON_NOTSET:
 333                         return mi_lttng_loglevel_str_python_notset;
 334                 default:
 335                         return mi_lttng_loglevel_str_unknown;
 336                 }
 337                 break;
 338         default:
 339                 return mi_lttng_loglevel_str_unknown;
 340         }
 341 }
 342
 343 LTTNG_HIDDEN
 344 const char *mi_lttng_logleveltype_string(enum lttng_loglevel_type value)
 345 {
 346         switch (value) {
 347         case LTTNG_EVENT_LOGLEVEL_ALL:
 348                 return mi_lttng_loglevel_type_all;
 349         case LTTNG_EVENT_LOGLEVEL_RANGE:
 350                 return mi_lttng_loglevel_type_range;
 351         case LTTNG_EVENT_LOGLEVEL_SINGLE:
 352                 return mi_lttng_loglevel_type_single;
 353         default:
 354                 return mi_lttng_loglevel_type_unknown;
 355         }
 356 }
 357
 358 static
 359 const char *mi_lttng_eventtype_string(enum lttng_event_type value)
 360 {
 361         switch (value) {
 362         case LTTNG_EVENT_ALL:
 363                 return config_event_type_all;
 364         case LTTNG_EVENT_TRACEPOINT:
 365                 return config_event_type_tracepoint;
 366         case LTTNG_EVENT_PROBE:
 367                 return config_event_type_probe;
 368         case LTTNG_EVENT_USERSPACE_PROBE:
 369                 return config_event_type_userspace_probe;
 370         case LTTNG_EVENT_FUNCTION:
 371                 return config_event_type_function;
 372         case LTTNG_EVENT_FUNCTION_ENTRY:
 373                 return config_event_type_function_entry;
 374         case LTTNG_EVENT_SYSCALL:
 375                 return config_event_type_syscall;
 376         case LTTNG_EVENT_NOOP:
 377                 return config_event_type_noop;
 378         default:
 379                 return mi_lttng_element_empty;
 380         }
 381 }
 382
 383 static
 384 const char *mi_lttng_event_contexttype_string(enum lttng_event_context_type val)
 385 {
 386         switch (val) {
 387         case LTTNG_EVENT_CONTEXT_PID:
 388                 return config_event_context_pid;
 389         case LTTNG_EVENT_CONTEXT_PROCNAME:
 390                 return config_event_context_procname;
 391         case LTTNG_EVENT_CONTEXT_PRIO:
 392                 return config_event_context_prio;
 393         case LTTNG_EVENT_CONTEXT_NICE:
 394                 return config_event_context_nice;
 395         case LTTNG_EVENT_CONTEXT_VPID:
 396                 return config_event_context_vpid;
 397         case LTTNG_EVENT_CONTEXT_TID:
 398                 return config_event_context_tid;
 399         case LTTNG_EVENT_CONTEXT_VTID:
 400                 return config_event_context_vtid;
 401         case LTTNG_EVENT_CONTEXT_PPID:
 402                 return config_event_context_ppid;
 403         case LTTNG_EVENT_CONTEXT_VPPID:
 404                 return config_event_context_vppid;
 405         case LTTNG_EVENT_CONTEXT_PTHREAD_ID:
 406                 return config_event_context_pthread_id;
 407         case LTTNG_EVENT_CONTEXT_HOSTNAME:
 408                 return config_event_context_hostname;
 409         case LTTNG_EVENT_CONTEXT_IP:
 410                 return config_event_context_ip;
 411         case LTTNG_EVENT_CONTEXT_INTERRUPTIBLE:
 412                 return config_event_context_interruptible;
 413         case LTTNG_EVENT_CONTEXT_PREEMPTIBLE:
 414                 return config_event_context_preemptible;
 415         case LTTNG_EVENT_CONTEXT_NEED_RESCHEDULE:
 416                 return config_event_context_need_reschedule;
 417         case LTTNG_EVENT_CONTEXT_MIGRATABLE:
 418                 return config_event_context_migratable;
 419         case LTTNG_EVENT_CONTEXT_CALLSTACK_USER:
 420                 return config_event_context_callstack_user;
 421         case LTTNG_EVENT_CONTEXT_CALLSTACK_KERNEL:
 422                 return config_event_context_callstack_kernel;
 423         case LTTNG_EVENT_CONTEXT_CGROUP_NS:
 424                 return config_event_context_cgroup_ns;
 425         case LTTNG_EVENT_CONTEXT_IPC_NS:
 426                 return config_event_context_ipc_ns;
 427         case LTTNG_EVENT_CONTEXT_MNT_NS:
 428                 return config_event_context_mnt_ns;
 429         case LTTNG_EVENT_CONTEXT_NET_NS:
 430                 return config_event_context_net_ns;
 431         case LTTNG_EVENT_CONTEXT_PID_NS:
 432                 return config_event_context_pid_ns;
 433         case LTTNG_EVENT_CONTEXT_USER_NS:
 434                 return config_event_context_user_ns;
 435         case LTTNG_EVENT_CONTEXT_UTS_NS:
 436                 return config_event_context_uts_ns;
 437         case LTTNG_EVENT_CONTEXT_UID:
 438                 return config_event_context_uid;
 439         case LTTNG_EVENT_CONTEXT_EUID:
 440                 return config_event_context_euid;
 441         case LTTNG_EVENT_CONTEXT_SUID:
 442                 return config_event_context_suid;
 443         case LTTNG_EVENT_CONTEXT_GID:
 444                 return config_event_context_gid;
 445         case LTTNG_EVENT_CONTEXT_EGID:
 446                 return config_event_context_egid;
 447         case LTTNG_EVENT_CONTEXT_SGID:
 448                 return config_event_context_sgid;
 449         case LTTNG_EVENT_CONTEXT_VUID:
 450                 return config_event_context_vuid;
 451         case LTTNG_EVENT_CONTEXT_VEUID:
 452                 return config_event_context_veuid;
 453         case LTTNG_EVENT_CONTEXT_VSUID:
 454                 return config_event_context_vsuid;
 455         case LTTNG_EVENT_CONTEXT_VGID:
 456                 return config_event_context_vgid;
 457         case LTTNG_EVENT_CONTEXT_VEGID:
 458                 return config_event_context_vegid;
 459         case LTTNG_EVENT_CONTEXT_VSGID:
 460                 return config_event_context_vsgid;
 461         default:
 462                 return NULL;
 463         }
 464 }
 465
 466 LTTNG_HIDDEN
 467 const char *mi_lttng_eventfieldtype_string(enum lttng_event_field_type val)
 468 {
 469         switch (val) {
 470         case(LTTNG_EVENT_FIELD_INTEGER):
 471                 return mi_lttng_element_type_integer;
 472         case(LTTNG_EVENT_FIELD_ENUM):
 473                 return mi_lttng_element_type_enum;
 474         case(LTTNG_EVENT_FIELD_FLOAT):
 475                 return mi_lttng_element_type_float;
 476         case(LTTNG_EVENT_FIELD_STRING):
 477                 return mi_lttng_element_type_string;
 478         default:
 479                 return mi_lttng_element_type_other;
 480         }
 481 }
 482
 483 LTTNG_HIDDEN
 484 const char *mi_lttng_domaintype_string(enum lttng_domain_type value)
 485 {
 486         /* Note: This is a *duplicate* of get_domain_str from bin/lttng/utils.c */
 487         switch (value) {
 488         case LTTNG_DOMAIN_KERNEL:
 489                 return config_domain_type_kernel;
 490         case LTTNG_DOMAIN_UST:
 491                 return config_domain_type_ust;
 492         case LTTNG_DOMAIN_JUL:
 493                 return config_domain_type_jul;
 494         case LTTNG_DOMAIN_LOG4J:
 495                 return config_domain_type_log4j;
 496         case LTTNG_DOMAIN_PYTHON:
 497                 return config_domain_type_python;
 498         default:
 499                 /* Should not have an unknown domain */
 500                 assert(0);
 501                 return NULL;
 502         }
 503 }
 504
 505 LTTNG_HIDDEN
 506 const char *mi_lttng_buffertype_string(enum lttng_buffer_type value)
 507 {
 508         switch (value) {
 509         case LTTNG_BUFFER_PER_PID:
 510                 return config_buffer_type_per_pid;
 511         case LTTNG_BUFFER_PER_UID:
 512                 return config_buffer_type_per_uid;
 513         case LTTNG_BUFFER_GLOBAL:
 514                 return config_buffer_type_global;
 515         default:
 516                 /* Should not have an unknow buffer type */
 517                 assert(0);
 518                 return NULL;
 519         }
 520 }
 521
 522 LTTNG_HIDDEN
 523 const char *mi_lttng_rotation_state_string(enum lttng_rotation_state value)
 524 {
 525         switch (value) {
 526         case LTTNG_ROTATION_STATE_ONGOING:
 527                 return mi_lttng_rotation_state_str_ongoing;
 528         case LTTNG_ROTATION_STATE_COMPLETED:
 529                 return mi_lttng_rotation_state_str_completed;
 530         case LTTNG_ROTATION_STATE_EXPIRED:
 531                 return mi_lttng_rotation_state_str_expired;
 532         case LTTNG_ROTATION_STATE_ERROR:
 533                 return mi_lttng_rotation_state_str_error;
 534         default:
 535                 /* Should not have an unknow rotation state. */
 536                 assert(0);
 537                 return NULL;
 538         }
 539 }
 540
 541 LTTNG_HIDDEN
 542 const char *mi_lttng_trace_archive_location_relay_protocol_type_string(
 543                 enum lttng_trace_archive_location_relay_protocol_type value)
 544 {
 545         switch (value) {
 546         case LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP:
 547                 return mi_lttng_rotation_location_relay_protocol_str_tcp;
 548         default:
 549                 /* Should not have an unknow relay protocol. */
 550                 assert(0);
 551                 return NULL;
 552         }
 553 }
 554
 555 LTTNG_HIDDEN
 556 struct mi_writer *mi_lttng_writer_create(int fd_output, int mi_output_type)
 557 {
 558         struct mi_writer *mi_writer;
 559
 560         mi_writer = zmalloc(sizeof(struct mi_writer));
 561         if (!mi_writer) {
 562                 PERROR("zmalloc mi_writer_create");
 563                 goto end;
 564         }
 565         if (mi_output_type == LTTNG_MI_XML) {
 566                 mi_writer->writer = config_writer_create(fd_output, 0);
 567                 if (!mi_writer->writer) {
 568                         goto err_destroy;
 569                 }
 570                 mi_writer->type = LTTNG_MI_XML;
 571         } else {
 572                 goto err_destroy;
 573         }
 574
 575 end:
 576         return mi_writer;
 577
 578 err_destroy:
 579         free(mi_writer);
 580         return NULL;
 581 }
 582
 583 LTTNG_HIDDEN
 584 int mi_lttng_writer_destroy(struct mi_writer *writer)
 585 {
 586         int ret;
 587
 588         if (!writer) {
 589                 ret = -EINVAL;
 590                 goto end;
 591         }
 592
 593         ret = config_writer_destroy(writer->writer);
 594         if (ret < 0) {
 595                 goto end;
 596         }
 597
 598         free(writer);
 599 end:
 600         return ret;
 601 }
 602
 603 LTTNG_HIDDEN
 604 int mi_lttng_writer_command_open(struct mi_writer *writer, const char *command)
 605 {
 606         int ret;
 607
 608         /*
 609          * A command is always the MI's root node, it must declare the current
 610          * namespace and schema URIs and the schema's version.
 611          */
 612         ret = config_writer_open_element(writer->writer,
 613                         mi_lttng_element_command);
 614         if (ret) {
 615                 goto end;
 616         }
 617
 618         ret = config_writer_write_attribute(writer->writer,
 619                         mi_lttng_xmlns, DEFAULT_LTTNG_MI_NAMESPACE);
 620         if (ret) {
 621                 goto end;
 622         }
 623
 624         ret = config_writer_write_attribute(writer->writer,
 625                         mi_lttng_xmlns_xsi, mi_lttng_w3_schema_uri);
 626         if (ret) {
 627                 goto end;
 628         }
 629
 630         ret = config_writer_write_attribute(writer->writer,
 631                         mi_lttng_schema_location,
 632                         mi_lttng_schema_location_uri);
 633         if (ret) {
 634                 goto end;
 635         }
 636
 637         ret = config_writer_write_attribute(writer->writer,
 638                         mi_lttng_schema_version,
 639                         mi_lttng_schema_version_value);
 640         if (ret) {
 641                 goto end;
 642         }
 643
 644         ret = mi_lttng_writer_write_element_string(writer,
 645                         mi_lttng_element_command_name, command);
 646 end:
 647         return ret;
 648 }
 649
 650 LTTNG_HIDDEN
 651 int mi_lttng_writer_command_close(struct mi_writer *writer)
 652 {
 653         return mi_lttng_writer_close_element(writer);
 654 }
 655
 656 LTTNG_HIDDEN
 657 int mi_lttng_writer_open_element(struct mi_writer *writer,
 658                 const char *element_name)
 659 {
 660         return config_writer_open_element(writer->writer, element_name);
 661 }
 662
 663 LTTNG_HIDDEN
 664 int mi_lttng_writer_close_element(struct mi_writer *writer)
 665 {
 666         return config_writer_close_element(writer->writer);
 667 }
 668
 669 LTTNG_HIDDEN
 670 int mi_lttng_close_multi_element(struct mi_writer *writer,
 671                 unsigned int nb_element)
 672 {
 673         int ret, i;
 674
 675         if (nb_element < 1) {
 676                 ret = 0;
 677                 goto end;
 678         }
 679         for (i = 0; i < nb_element; i++) {
 680                 ret = mi_lttng_writer_close_element(writer);
 681                 if (ret) {
 682                         goto end;
 683                 }
 684         }
 685 end:
 686         return ret;
 687 }
 688
 689 LTTNG_HIDDEN
 690 int mi_lttng_writer_write_element_unsigned_int(struct mi_writer *writer,
 691                 const char *element_name, uint64_t value)
 692 {
 693         return config_writer_write_element_unsigned_int(writer->writer,
 694                         element_name, value);
 695 }
 696
 697 LTTNG_HIDDEN
 698 int mi_lttng_writer_write_element_signed_int(struct mi_writer *writer,
 699                 const char *element_name, int64_t value)
 700 {
 701         return config_writer_write_element_signed_int(writer->writer,
 702                         element_name, value);
 703 }
 704
 705 LTTNG_HIDDEN
 706 int mi_lttng_writer_write_element_bool(struct mi_writer *writer,
 707                 const char *element_name, int value)
 708 {
 709         return config_writer_write_element_bool(writer->writer,
 710                         element_name, value);
 711 }
 712
 713 LTTNG_HIDDEN
 714 int mi_lttng_writer_write_element_string(struct mi_writer *writer,
 715                 const char *element_name, const char *value)
 716 {
 717         return config_writer_write_element_string(writer->writer,
 718                         element_name, value);
 719 }
 720
 721 LTTNG_HIDDEN
 722 int mi_lttng_version(struct mi_writer *writer, struct mi_lttng_version *version,
 723         const char *lttng_description, const char *lttng_license)
 724 {
 725         int ret;
 726
 727         /* Open version */
 728         ret = mi_lttng_writer_open_element(writer, mi_lttng_element_version);
 729         if (ret) {
 730                 goto end;
 731         }
 732
 733         /* Version string (contain info like rc etc.) */
 734         ret = mi_lttng_writer_write_element_string(writer,
 735                         mi_lttng_element_version_str, version->version);
 736         if (ret) {
 737                 goto end;
 738         }
 739
 740         /* Major version number */
 741         ret = mi_lttng_writer_write_element_unsigned_int(writer,
 742                         mi_lttng_element_version_major, version->version_major);
 743         if (ret) {
 744                 goto end;
 745         }
 746
 747         /* Minor version number */
 748         ret = mi_lttng_writer_write_element_unsigned_int(writer,
 749                         mi_lttng_element_version_minor, version->version_minor);
 750         if (ret) {
 751                 goto end;
 752         }
 753
 754         /* Commit version number */
 755         ret = mi_lttng_writer_write_element_string(writer,
 756                         mi_lttng_element_version_commit, version->version_commit);
 757         if (ret) {
 758                 goto end;
 759         }
 760
 761         /* Patch number */
 762         ret = mi_lttng_writer_write_element_unsigned_int(writer,
 763                         mi_lttng_element_version_patch_level, version->version_patchlevel);
 764         if (ret) {
 765                 goto end;
 766         }
 767
 768         /* Name of the version */
 769         ret = mi_lttng_writer_write_element_string(writer,
 770                         config_element_name, version->version_name);
 771         if (ret) {
 772                 goto end;
 773         }
 774
 775         /* Description mostly related to beer... */
 776         ret = mi_lttng_writer_write_element_string(writer,
 777                         mi_lttng_element_version_description, lttng_description);
 778         if (ret) {
 779                 goto end;
 780         }
 781
 782         /* url */
 783         ret = mi_lttng_writer_write_element_string(writer,
 784                         mi_lttng_element_version_web, version->package_url);
 785         if (ret) {
 786                 goto end;
 787         }
 788
 789         /* License: free as in free beer...no...*speech* */
 790         ret = mi_lttng_writer_write_element_string(writer,
 791                         mi_lttng_element_version_license, lttng_license);
 792         if (ret) {
 793                 goto end;
 794         }
 795
 796         /* Close version element */
 797         ret = mi_lttng_writer_close_element(writer);
 798
 799 end:
 800         return ret;
 801 }
 802
 803 LTTNG_HIDDEN
 804 int mi_lttng_sessions_open(struct mi_writer *writer)
 805 {
 806         return mi_lttng_writer_open_element(writer, config_element_sessions);
 807 }
 808
 809 LTTNG_HIDDEN
 810 int mi_lttng_session(struct mi_writer *writer,
 811                 struct lttng_session *session, int is_open)
 812 {
 813         int ret;
 814
 815         assert(session);
 816
 817         /* Open sessions element */
 818         ret = mi_lttng_writer_open_element(writer,
 819                         config_element_session);
 820         if (ret) {
 821                 goto end;
 822         }
 823
 824         /* Name of the session */
 825         ret = mi_lttng_writer_write_element_string(writer,
 826                         config_element_name, session->name);
 827         if (ret) {
 828                 goto end;
 829         }
 830
 831         /* Path */
 832         ret = mi_lttng_writer_write_element_string(writer,
 833                         config_element_path, session->path);
 834         if (ret) {
 835                 goto end;
 836         }
 837
 838         /* Enabled ? */
 839         ret = mi_lttng_writer_write_element_bool(writer,
 840                         config_element_enabled, session->enabled);
 841         if (ret) {
 842                 goto end;
 843         }
 844
 845         /* Snapshot mode */
 846         ret = mi_lttng_writer_write_element_unsigned_int(writer,
 847                         config_element_snapshot_mode, session->snapshot_mode);
 848         if (ret) {
 849                 goto end;
 850         }
 851
 852         /* Live timer interval in usec */
 853         ret = mi_lttng_writer_write_element_unsigned_int(writer,
 854                         config_element_live_timer_interval,
 855                         session->live_timer_interval);
 856         if (ret) {
 857                 goto end;
 858         }
 859
 860         if (!is_open) {
 861                 /* Closing session element */
 862                 ret = mi_lttng_writer_close_element(writer);
 863         }
 864 end:
 865         return ret;
 866
 867 }
 868
 869 LTTNG_HIDDEN
 870 int mi_lttng_domains_open(struct mi_writer *writer)
 871 {
 872         return mi_lttng_writer_open_element(writer, config_element_domains);
 873 }
 874
 875 LTTNG_HIDDEN
 876 int mi_lttng_domain(struct mi_writer *writer,
 877                 struct lttng_domain *domain, int is_open)
 878 {
 879         int ret = 0;
 880         const char *str_domain;
 881         const char *str_buffer;
 882
 883         assert(domain);
 884
 885         /* Open domain element */
 886         ret = mi_lttng_writer_open_element(writer, config_element_domain);
 887         if (ret) {
 888                 goto end;
 889         }
 890
 891         /* Domain Type */
 892         str_domain = mi_lttng_domaintype_string(domain->type);
 893         ret = mi_lttng_writer_write_element_string(writer, config_element_type,
 894                         str_domain);
 895         if (ret) {
 896                 goto end;
 897         }
 898
 899         /* Buffer Type */
 900         str_buffer= mi_lttng_buffertype_string(domain->buf_type);
 901         ret = mi_lttng_writer_write_element_string(writer,
 902                         config_element_buffer_type, str_buffer);
 903         if (ret) {
 904                 goto end;
 905         }
 906
 907         /* TODO: union  attr
 908          * This union is not currently used and was added for
 909          * future ust domain support.
 910          * Date: 25-06-2014
 911          * */
 912
 913         if (!is_open) {
 914                 /* Closing domain element */
 915                 ret = mi_lttng_writer_close_element(writer);
 916         }
 917
 918 end:
 919         return ret;
 920
 921 }
 922
 923 LTTNG_HIDDEN
 924 int mi_lttng_channels_open(struct mi_writer *writer)
 925 {
 926         return mi_lttng_writer_open_element(writer, config_element_channels);
 927 }
 928
 929 LTTNG_HIDDEN
 930 int mi_lttng_channel(struct mi_writer *writer,
 931                 struct lttng_channel *channel, int is_open)
 932 {
 933         int ret = 0;
 934
 935         assert(channel);
 936
 937         /* Opening channel element */
 938         ret = mi_lttng_writer_open_element(writer, config_element_channel);
 939         if (ret) {
 940                 goto end;
 941         }
 942
 943         /* Name */
 944         ret = mi_lttng_writer_write_element_string(writer, config_element_name,
 945                         channel->name);
 946         if (ret) {
 947                 goto end;
 948         }
 949
 950         /* Enabled ? */
 951         ret = mi_lttng_writer_write_element_bool(writer,
 952                         config_element_enabled, channel->enabled);
 953         if (ret) {
 954                 goto end;
 955         }
 956
 957         /* Attribute */
 958         ret = mi_lttng_channel_attr(writer, &channel->attr);
 959         if (ret) {
 960                 goto end;
 961         }
 962
 963         if (!is_open) {
 964                 /* Closing channel element */
 965                 ret = mi_lttng_writer_close_element(writer);
 966                 if (ret) {
 967                         goto end;
 968                 }
 969         }
 970 end:
 971         return ret;
 972 }
 973
 974 LTTNG_HIDDEN
 975 int mi_lttng_channel_attr(struct mi_writer *writer,
 976                 struct lttng_channel_attr *attr)
 977 {
 978         int ret = 0;
 979         struct lttng_channel *chan = caa_container_of(attr,
 980                         struct lttng_channel, attr);
 981         uint64_t discarded_events, lost_packets, monitor_timer_interval;
 982         int64_t blocking_timeout;
 983
 984         assert(attr);
 985
 986         ret = lttng_channel_get_discarded_event_count(chan, &discarded_events);
 987         if (ret) {
 988                 goto end;
 989         }
 990
 991         ret = lttng_channel_get_lost_packet_count(chan, &lost_packets);
 992         if (ret) {
 993                 goto end;
 994         }
 995
 996         ret = lttng_channel_get_monitor_timer_interval(chan,
 997                         &monitor_timer_interval);
 998         if (ret) {
 999                 goto end;
1000         }
1001
1002         ret = lttng_channel_get_blocking_timeout(chan,
1003                         &blocking_timeout);
1004         if (ret) {
1005                 goto end;
1006         }
1007
1008         /* Opening Attributes */
1009         ret = mi_lttng_writer_open_element(writer, config_element_attributes);
1010         if (ret) {
1011                 goto end;
1012         }
1013
1014         /* Overwrite */
1015         ret = mi_lttng_writer_write_element_string(writer,
1016                 config_element_overwrite_mode,
1017                 attr->overwrite ? config_overwrite_mode_overwrite :
1018                         config_overwrite_mode_discard);
1019         if (ret) {
1020                 goto end;
1021         }
1022
1023         /* Sub buffer size in byte */
1024         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1025                 config_element_subbuf_size, attr->subbuf_size);
1026         if (ret) {
1027                 goto end;
1028         }
1029
1030         /* Number of subbuffer (power of two) */
1031         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1032                 config_element_num_subbuf,
1033                 attr->num_subbuf);
1034         if (ret) {
1035                 goto end;
1036         }
1037
1038         /* Switch timer interval in usec */
1039         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1040                 config_element_switch_timer_interval,
1041                 attr->switch_timer_interval);
1042         if (ret) {
1043                 goto end;
1044         }
1045
1046         /* Read timer interval in usec */
1047         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1048                 config_element_read_timer_interval,
1049                 attr->read_timer_interval);
1050         if (ret) {
1051                 goto end;
1052         }
1053
1054         /* Monitor timer interval in usec */
1055         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1056                 config_element_monitor_timer_interval,
1057                 monitor_timer_interval);
1058         if (ret) {
1059                 goto end;
1060         }
1061
1062         /* Retry timeout in usec */
1063         ret = mi_lttng_writer_write_element_signed_int(writer,
1064                 config_element_blocking_timeout,
1065                 blocking_timeout);
1066         if (ret) {
1067                 goto end;
1068         }
1069
1070         /* Event output */
1071         ret = mi_lttng_writer_write_element_string(writer,
1072                 config_element_output_type,
1073                 attr->output == LTTNG_EVENT_SPLICE ?
1074                 config_output_type_splice : config_output_type_mmap);
1075         if (ret) {
1076                 goto end;
1077         }
1078
1079         /* Tracefile size in bytes */
1080         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1081                 config_element_tracefile_size, attr->tracefile_size);
1082         if (ret) {
1083                 goto end;
1084         }
1085
1086         /* Count of tracefiles */
1087         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1088                 config_element_tracefile_count,
1089                 attr->tracefile_count);
1090         if (ret) {
1091                 goto end;
1092         }
1093
1094         /* Live timer interval in usec*/
1095         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1096                 config_element_live_timer_interval,
1097                 attr->live_timer_interval);
1098         if (ret) {
1099                 goto end;
1100         }
1101
1102         /* Discarded events */
1103         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1104                 config_element_discarded_events,
1105                 discarded_events);
1106         if (ret) {
1107                 goto end;
1108         }
1109
1110         /* Lost packets */
1111         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1112                 config_element_lost_packets,
1113                 lost_packets);
1114         if (ret) {
1115                 goto end;
1116         }
1117
1118         /* Closing attributes */
1119         ret = mi_lttng_writer_close_element(writer);
1120         if (ret) {
1121                 goto end;
1122         }
1123 end:
1124         return ret;
1125
1126 }
1127
1128 LTTNG_HIDDEN
1129 int mi_lttng_event_common_attributes(struct mi_writer *writer,
1130                 struct lttng_event *event)
1131 {
1132         int ret;
1133         const char *filter_expression;
1134
1135         /* Open event element */
1136         ret = mi_lttng_writer_open_element(writer, config_element_event);
1137         if (ret) {
1138                 goto end;
1139         }
1140
1141         /* Event name */
1142         ret = mi_lttng_writer_write_element_string(writer,
1143                         config_element_name, event->name);
1144         if (ret) {
1145                 goto end;
1146         }
1147
1148         /* Event type */
1149         ret = mi_lttng_writer_write_element_string(writer,
1150                         config_element_type, mi_lttng_eventtype_string(event->type));
1151         if (ret) {
1152                 goto end;
1153         }
1154
1155         /* Is event enabled */
1156         ret = mi_lttng_writer_write_element_bool(writer,
1157                         config_element_enabled, event->enabled);
1158         if (ret) {
1159                 goto end;
1160         }
1161
1162         /* Event filter expression */
1163         ret = lttng_event_get_filter_expression(event, &filter_expression);
1164         if (ret) {
1165                 goto end;
1166         }
1167
1168         if (filter_expression) {
1169                 ret = mi_lttng_writer_write_element_string(writer,
1170                                 config_element_filter_expression,
1171                                 filter_expression);
1172                 if (ret) {
1173                         goto end;
1174                 }
1175         }
1176
1177 end:
1178         return ret;
1179 }
1180
1181 static int write_event_exclusions(struct mi_writer *writer,
1182                 struct lttng_event *event)
1183 {
1184         int i;
1185         int ret;
1186         int exclusion_count;
1187
1188         /* Open event exclusions */
1189         ret = mi_lttng_writer_open_element(writer, config_element_exclusions);
1190         if (ret) {
1191                 goto end;
1192         }
1193
1194         exclusion_count = lttng_event_get_exclusion_name_count(event);
1195         if (exclusion_count < 0) {
1196                 ret = exclusion_count;
1197                 goto end;
1198         }
1199
1200         for (i = 0; i < exclusion_count; i++) {
1201                 const char *name;
1202
1203                 ret = lttng_event_get_exclusion_name(event, i, &name);
1204                 if (ret) {
1205                         /* Close exclusions */
1206                         mi_lttng_writer_close_element(writer);
1207                         goto end;
1208                 }
1209
1210                 ret = mi_lttng_writer_write_element_string(writer,
1211                                 config_element_exclusion, name);
1212                 if (ret) {
1213                         /* Close exclusions */
1214                         mi_lttng_writer_close_element(writer);
1215                         goto end;
1216                 }
1217         }
1218
1219         /* Close exclusions */
1220         ret = mi_lttng_writer_close_element(writer);
1221
1222 end:
1223         return ret;
1224 }
1225
1226 LTTNG_HIDDEN
1227 int mi_lttng_event_tracepoint_loglevel(struct mi_writer *writer,
1228                 struct lttng_event *event, enum lttng_domain_type domain)
1229 {
1230         int ret;
1231
1232         /* Event loglevel */
1233         ret = mi_lttng_writer_write_element_string(writer,
1234                         config_element_loglevel,
1235                         mi_lttng_loglevel_string(event->loglevel, domain));
1236         if (ret) {
1237                 goto end;
1238         }
1239
1240         /* Log level type */
1241         ret = mi_lttng_writer_write_element_string(writer,
1242                         config_element_loglevel_type,
1243                         mi_lttng_logleveltype_string(event->loglevel_type));
1244         if (ret) {
1245                 goto end;
1246         }
1247
1248         /* Event exclusions */
1249         ret = write_event_exclusions(writer, event);
1250
1251 end:
1252         return ret;
1253 }
1254
1255 LTTNG_HIDDEN
1256 int mi_lttng_event_tracepoint_no_loglevel(struct mi_writer *writer,
1257                 struct lttng_event *event)
1258 {
1259         /* event exclusion filter */
1260         return write_event_exclusions(writer, event);
1261 }
1262
1263 LTTNG_HIDDEN
1264 int mi_lttng_event_function_probe(struct mi_writer *writer,
1265                 struct lttng_event *event)
1266 {
1267         int ret;
1268
1269         ret = mi_lttng_writer_open_element(writer, config_element_attributes);
1270         if (ret) {
1271                 goto end;
1272         }
1273
1274         ret = mi_lttng_writer_open_element(writer, config_element_probe_attributes);
1275         if (ret) {
1276                 goto end;
1277         }
1278
1279         if (event->attr.probe.addr != 0) {
1280                 /* event probe address */
1281                 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1282                                 config_element_address, event->attr.probe.addr);
1283                 if (ret) {
1284                         goto end;
1285                 }
1286         } else {
1287                 /* event probe offset */
1288                 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1289                                 config_element_offset, event->attr.probe.offset);
1290                 if (ret) {
1291                         goto end;
1292                 }
1293
1294                 /* event probe symbol_name */
1295                 ret = mi_lttng_writer_write_element_string(writer,
1296                                 config_element_symbol_name, event->attr.probe.symbol_name);
1297                 if (ret) {
1298                         goto end;
1299                 }
1300         }
1301
1302         /* Close probe_attributes and attributes */
1303         ret = mi_lttng_close_multi_element(writer, 2);
1304 end:
1305         return ret;
1306 }
1307
1308 static
1309 int mi_lttng_event_userspace_probe(struct mi_writer *writer,
1310                 struct lttng_event *event)
1311 {
1312         int ret;
1313         const struct lttng_userspace_probe_location *location;
1314         const struct lttng_userspace_probe_location_lookup_method *lookup_method;
1315         enum lttng_userspace_probe_location_lookup_method_type lookup_type;
1316
1317         location = lttng_event_get_userspace_probe_location(event);
1318         if (!location) {
1319                 ret = -LTTNG_ERR_INVALID;
1320                 goto end;
1321         }
1322
1323         lookup_method = lttng_userspace_probe_location_get_lookup_method(location);
1324         if (!lookup_method) {
1325                 ret = -LTTNG_ERR_INVALID;
1326                 goto end;
1327         }
1328
1329         lookup_type = lttng_userspace_probe_location_lookup_method_get_type(lookup_method);
1330
1331         ret = mi_lttng_writer_open_element(writer, config_element_attributes);
1332         if (ret) {
1333                 goto end;
1334         }
1335
1336         switch (lttng_userspace_probe_location_get_type(location)) {
1337         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
1338         {
1339                 const char *function_name;
1340                 const char *binary_path;
1341
1342                 ret = mi_lttng_writer_open_element(writer,
1343                                 config_element_userspace_probe_function_attributes);
1344                 if (ret) {
1345                         goto end;
1346                 }
1347
1348                 switch (lookup_type) {
1349                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
1350                         ret = mi_lttng_writer_write_element_string(writer,
1351                                         config_element_userspace_probe_lookup,
1352                                         config_element_userspace_probe_lookup_function_elf);
1353                         if (ret) {
1354                                 goto end;
1355                         }
1356                         break;
1357                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:
1358                         ret = mi_lttng_writer_write_element_string(writer,
1359                                         config_element_userspace_probe_lookup,
1360                                         config_element_userspace_probe_lookup_function_default);
1361                         if (ret) {
1362                                 goto end;
1363                         }
1364                         break;
1365                 default:
1366                         goto end;
1367                 }
1368
1369                 binary_path = lttng_userspace_probe_location_function_get_binary_path(location);
1370                 ret = mi_lttng_writer_write_element_string(writer,
1371                                 config_element_userspace_probe_location_binary_path, binary_path);
1372                 if (ret) {
1373                         goto end;
1374                 }
1375
1376                 function_name = lttng_userspace_probe_location_function_get_function_name(location);
1377                 ret = mi_lttng_writer_write_element_string(writer,
1378                                 config_element_userspace_probe_function_location_function_name,
1379                                 function_name);
1380                 if (ret) {
1381                         goto end;
1382                 }
1383
1384                 break;
1385         }
1386         case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
1387         {
1388                 const char *probe_name, *provider_name;
1389                 const char *binary_path;
1390
1391                 ret = mi_lttng_writer_open_element(writer,
1392                                 config_element_userspace_probe_function_attributes);
1393                 if (ret) {
1394                         goto end;
1395                 }
1396
1397                 switch (lookup_type) {
1398                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
1399                         ret = mi_lttng_writer_write_element_string(writer,
1400                                         config_element_userspace_probe_lookup,
1401                                         config_element_userspace_probe_lookup_tracepoint_sdt);
1402                         if (ret) {
1403                                 goto end;
1404                         }
1405                         break;
1406                 default:
1407                         goto end;
1408                 }
1409
1410                 binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(location);
1411                 ret = mi_lttng_writer_write_element_string(writer,
1412                                 config_element_userspace_probe_location_binary_path,
1413                                 binary_path);
1414                 if (ret) {
1415                         goto end;
1416                 }
1417
1418                 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(location);
1419                 ret = mi_lttng_writer_write_element_string(writer,
1420                                 config_element_userspace_probe_tracepoint_location_provider_name,
1421                                 provider_name);
1422                 if (ret) {
1423                         goto end;
1424                 }
1425
1426                 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(location);
1427                 ret = mi_lttng_writer_write_element_string(writer,
1428                                 config_element_userspace_probe_tracepoint_location_probe_name, probe_name);
1429                 if (ret) {
1430                         goto end;
1431                 }
1432                 break;
1433         }
1434         default:
1435                 ERR("Invalid probe type encountered");
1436         }
1437         /* Close probe_attributes and attributes */
1438         ret = mi_lttng_close_multi_element(writer, 2);
1439 end:
1440         return ret;
1441 }
1442
1443 LTTNG_HIDDEN
1444 int mi_lttng_event_function_entry(struct mi_writer *writer,
1445                 struct lttng_event *event)
1446 {
1447         int ret;
1448
1449         ret = mi_lttng_writer_open_element(writer, config_element_attributes);
1450         if (ret) {
1451                 goto end;
1452         }
1453
1454         ret = mi_lttng_writer_open_element(writer, config_element_probe_attributes);
1455         if (ret) {
1456                 goto end;
1457         }
1458
1459         /* event probe symbol_name */
1460         ret = mi_lttng_writer_write_element_string(writer,
1461                         config_element_symbol_name, event->attr.ftrace.symbol_name);
1462         if (ret) {
1463                 goto end;
1464         }
1465
1466         /* Close function_attributes and attributes */
1467         ret = mi_lttng_close_multi_element(writer, 2);
1468 end:
1469         return ret;
1470 }
1471
1472 LTTNG_HIDDEN
1473 int mi_lttng_events_open(struct mi_writer *writer)
1474 {
1475         return mi_lttng_writer_open_element(writer, config_element_events);
1476 }
1477
1478 LTTNG_HIDDEN
1479 int mi_lttng_event(struct mi_writer *writer,
1480                 struct lttng_event *event, int is_open, enum lttng_domain_type domain)
1481 {
1482         int ret;
1483
1484         ret = mi_lttng_event_common_attributes(writer, event);
1485         if (ret) {
1486                 goto end;
1487         }
1488
1489         switch (event->type) {
1490         case LTTNG_EVENT_TRACEPOINT:
1491         {
1492                 if (event->loglevel != -1) {
1493                         ret = mi_lttng_event_tracepoint_loglevel(writer, event, domain);
1494                 } else {
1495                         ret = mi_lttng_event_tracepoint_no_loglevel(writer, event);
1496                 }
1497                 break;
1498         }
1499         case LTTNG_EVENT_FUNCTION:
1500                 /* Fallthrough */
1501         case LTTNG_EVENT_PROBE:
1502                 ret = mi_lttng_event_function_probe(writer, event);
1503                 break;
1504         case LTTNG_EVENT_FUNCTION_ENTRY:
1505                 ret = mi_lttng_event_function_entry(writer, event);
1506                 break;
1507         case LTTNG_EVENT_USERSPACE_PROBE:
1508                 ret = mi_lttng_event_userspace_probe(writer, event);
1509                 break;
1510         case LTTNG_EVENT_ALL:
1511                 /* Fallthrough */
1512         default:
1513                 break;
1514         }
1515
1516         if (ret) {
1517                 goto end;
1518         }
1519
1520         if (!is_open) {
1521                 ret = mi_lttng_writer_close_element(writer);
1522         }
1523
1524 end:
1525         return ret;
1526 }
1527
1528 LTTNG_HIDDEN
1529 int mi_lttng_trackers_open(struct mi_writer *writer)
1530 {
1531         return mi_lttng_writer_open_element(writer, config_element_trackers);
1532 }
1533
1534 static int get_tracker_elements(enum lttng_tracker_type tracker_type,
1535                 const char **element_id_tracker,
1536                 const char **element_target_id)
1537 {
1538         int ret = 0;
1539
1540         switch (tracker_type) {
1541         case LTTNG_TRACKER_PID:
1542                 *element_id_tracker = config_element_pid_tracker;
1543                 *element_target_id = config_element_target_pid;
1544                 break;
1545         case LTTNG_TRACKER_VPID:
1546                 *element_id_tracker = config_element_vpid_tracker;
1547                 *element_target_id = config_element_target_vpid;
1548                 break;
1549         case LTTNG_TRACKER_UID:
1550                 *element_id_tracker = config_element_uid_tracker;
1551                 *element_target_id = config_element_target_uid;
1552                 break;
1553         case LTTNG_TRACKER_VUID:
1554                 *element_id_tracker = config_element_vuid_tracker;
1555                 *element_target_id = config_element_target_vuid;
1556                 break;
1557         case LTTNG_TRACKER_GID:
1558                 *element_id_tracker = config_element_gid_tracker;
1559                 *element_target_id = config_element_target_gid;
1560                 break;
1561         case LTTNG_TRACKER_VGID:
1562                 *element_id_tracker = config_element_vgid_tracker;
1563                 *element_target_id = config_element_target_vgid;
1564                 break;
1565         default:
1566                 ret = LTTNG_ERR_SAVE_IO_FAIL;
1567         }
1568         return ret;
1569 }
1570
1571 LTTNG_HIDDEN
1572 int mi_lttng_id_tracker_open(
1573                 struct mi_writer *writer, enum lttng_tracker_type tracker_type)
1574 {
1575         int ret;
1576         const char *element_id_tracker, *element_target_id;
1577
1578         ret = get_tracker_elements(
1579                         tracker_type, &element_id_tracker, &element_target_id);
1580         if (ret) {
1581                 return ret;
1582         }
1583
1584         /* Open element $id_tracker */
1585         ret = mi_lttng_writer_open_element(writer, element_id_tracker);
1586         if (ret) {
1587                 goto end;
1588         }
1589
1590         /* Open targets element */
1591         ret = mi_lttng_targets_open(writer);
1592 end:
1593         return ret;
1594 }
1595
1596 LTTNG_HIDDEN
1597 int mi_lttng_pids_open(struct mi_writer *writer)
1598 {
1599         return mi_lttng_writer_open_element(writer, config_element_pids);
1600 }
1601
1602 /*
1603  * TODO: move the listing of pid for user agent to process semantic on
1604  * mi api bump. The use of process element break the mi api.
1605  */
1606 LTTNG_HIDDEN
1607 int mi_lttng_pid(struct mi_writer *writer,
1608                 pid_t pid,
1609                 const char *name,
1610                 int is_open)
1611 {
1612         int ret;
1613
1614         /* Open pid process */
1615         ret = mi_lttng_writer_open_element(writer, config_element_pid);
1616         if (ret) {
1617                 goto end;
1618         }
1619
1620         /* Writing pid number */
1621         ret = mi_lttng_writer_write_element_signed_int(writer,
1622                         mi_lttng_element_pid_id, (int)pid);
1623         if (ret) {
1624                 goto end;
1625         }
1626
1627         /* Writing name of the process */
1628         if (name) {
1629                 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1630                                 name);
1631                 if (ret) {
1632                         goto end;
1633                 }
1634         }
1635
1636         if (!is_open) {
1637                 /* Closing Pid */
1638                 ret = mi_lttng_writer_close_element(writer);
1639         }
1640
1641 end:
1642         return ret;
1643 }
1644
1645 LTTNG_HIDDEN
1646 int mi_lttng_targets_open(struct mi_writer *writer)
1647 {
1648         return mi_lttng_writer_open_element(writer,
1649                         config_element_targets);
1650 }
1651
1652 LTTNG_HIDDEN
1653 int mi_lttng_id_target(struct mi_writer *writer,
1654                 enum lttng_tracker_type tracker_type,
1655                 const struct lttng_tracker_id *id,
1656                 int is_open)
1657 {
1658         int ret;
1659         const char *element_id_tracker, *element_target_id;
1660         enum lttng_tracker_id_status status;
1661         int value;
1662         const char *string;
1663
1664         ret = get_tracker_elements(
1665                         tracker_type, &element_id_tracker, &element_target_id);
1666         if (ret) {
1667                 return ret;
1668         }
1669
1670         switch (lttng_tracker_id_get_type(id)) {
1671         case LTTNG_ID_ALL:
1672                 ret = mi_lttng_writer_open_element(writer, element_target_id);
1673                 if (ret) {
1674                         goto end;
1675                 }
1676                 ret = mi_lttng_writer_open_element(writer, config_element_type);
1677                 if (ret) {
1678                         goto end;
1679                 }
1680                 ret = mi_lttng_writer_write_element_bool(
1681                                 writer, config_element_all, 1);
1682                 if (ret) {
1683                         goto end;
1684                 }
1685                 ret = mi_lttng_writer_close_element(writer);
1686                 if (ret) {
1687                         goto end;
1688                 }
1689                 break;
1690         case LTTNG_ID_VALUE:
1691                 ret = mi_lttng_writer_open_element(writer, element_target_id);
1692                 if (ret) {
1693                         goto end;
1694                 }
1695                 ret = mi_lttng_writer_open_element(writer, config_element_type);
1696                 if (ret) {
1697                         goto end;
1698                 }
1699
1700                 status = lttng_tracker_id_get_value(id, &value);
1701                 if (status != LTTNG_TRACKER_ID_STATUS_OK) {
1702                         ret = -1;
1703                         goto end;
1704                 }
1705
1706                 ret = mi_lttng_writer_write_element_signed_int(
1707                                 writer, config_element_id, value);
1708                 if (ret) {
1709                         goto end;
1710                 }
1711                 ret = mi_lttng_writer_close_element(writer);
1712                 if (ret) {
1713                         goto end;
1714                 }
1715                 break;
1716         case LTTNG_ID_STRING:
1717                 ret = mi_lttng_writer_open_element(writer, element_target_id);
1718                 if (ret) {
1719                         goto end;
1720                 }
1721                 ret = mi_lttng_writer_open_element(writer, config_element_type);
1722                 if (ret) {
1723                         goto end;
1724                 }
1725
1726                 status = lttng_tracker_id_get_string(id, &string);
1727                 if (status != LTTNG_TRACKER_ID_STATUS_OK) {
1728                         ret = -1;
1729                         goto end;
1730                 }
1731
1732                 ret = mi_lttng_writer_write_element_string(
1733                                 writer, config_element_name, string);
1734                 if (ret) {
1735                         goto end;
1736                 }
1737                 ret = mi_lttng_writer_close_element(writer);
1738                 if (ret) {
1739                         goto end;
1740                 }
1741                 break;
1742         case LTTNG_ID_UNKNOWN:
1743                 ret = -LTTNG_ERR_INVALID;
1744                 goto end;
1745         }
1746
1747         if (!is_open) {
1748                 ret = mi_lttng_writer_close_element(writer);
1749                 if (ret) {
1750                         goto end;
1751                 }
1752         }
1753
1754 end:
1755         return ret;
1756 }
1757
1758 LTTNG_HIDDEN
1759 int mi_lttng_event_fields_open(struct mi_writer *writer)
1760 {
1761         return mi_lttng_writer_open_element(writer, mi_lttng_element_event_fields);
1762 }
1763
1764 LTTNG_HIDDEN
1765 int mi_lttng_event_field(struct mi_writer *writer,
1766                 struct lttng_event_field *field)
1767 {
1768         int ret;
1769
1770         if (!field->field_name[0]) {
1771                 ret = 0;
1772                 goto end;
1773         }
1774
1775         /* Open field */
1776         ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_field);
1777         if (ret) {
1778                 goto end;
1779         }
1780
1781         if (!field->field_name[0]) {
1782                 goto close;
1783         }
1784
1785         /* Name */
1786         ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1787                         field->field_name);
1788         if (ret) {
1789                 goto end;
1790         }
1791
1792         /* Type */
1793         ret = mi_lttng_writer_write_element_string(writer, config_element_type,
1794                         mi_lttng_eventfieldtype_string(field->type));
1795         if (ret) {
1796                 goto end;
1797         }
1798
1799         /* nowrite  */
1800         ret = mi_lttng_writer_write_element_signed_int(writer,
1801                         mi_lttng_element_nowrite, field->nowrite);
1802         if (ret) {
1803                 goto end;
1804         }
1805
1806 close:
1807         /* Close field element */
1808         ret = mi_lttng_writer_close_element(writer);
1809
1810 end:
1811         return ret;
1812 }
1813
1814 LTTNG_HIDDEN
1815 int mi_lttng_perf_counter_context(struct mi_writer *writer,
1816                 struct lttng_event_perf_counter_ctx  *perf_context)
1817 {
1818         int ret;
1819
1820         /* Open perf_counter_context */
1821         ret = mi_lttng_writer_open_element(writer,
1822                         mi_lttng_element_perf_counter_context);
1823         if (ret) {
1824                 goto end;
1825         }
1826
1827         /* Type */
1828         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1829                         config_element_type, perf_context->type);
1830         if (ret) {
1831                 goto end;
1832         }
1833
1834         /* Config */
1835         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1836                         config_element_config, perf_context->config);
1837         if (ret) {
1838                 goto end;
1839         }
1840
1841         /* Name of the perf counter */
1842         ret = mi_lttng_writer_write_element_string(writer,
1843                         config_element_name, perf_context->name);
1844         if (ret) {
1845                 goto end;
1846         }
1847
1848         /* Close perf_counter_context */
1849         ret = mi_lttng_writer_close_element(writer);
1850 end:
1851         return ret;
1852 }
1853
1854 static
1855 int mi_lttng_app_context(struct mi_writer *writer,
1856                 const char *provider_name, const char *ctx_name)
1857 {
1858         int ret;
1859
1860         /* Open app */
1861         ret = mi_lttng_writer_open_element(writer,
1862                         config_element_context_app);
1863         if (ret) {
1864                 goto end;
1865         }
1866
1867         /* provider_name */
1868         ret = mi_lttng_writer_write_element_string(writer,
1869                         config_element_context_app_provider_name,
1870                         provider_name);
1871         if (ret) {
1872                 goto end;
1873         }
1874
1875         /* ctx_name */
1876         ret = mi_lttng_writer_write_element_string(writer,
1877                         config_element_context_app_ctx_name, ctx_name);
1878         if (ret) {
1879                 goto end;
1880         }
1881
1882         /* Close app */
1883         ret = mi_lttng_writer_close_element(writer);
1884 end:
1885         return ret;
1886 }
1887
1888 LTTNG_HIDDEN
1889 int mi_lttng_context(struct mi_writer *writer,
1890                 struct lttng_event_context *context, int is_open)
1891 {
1892         int ret;
1893
1894         /* Open context */
1895         ret = mi_lttng_writer_open_element(writer , config_element_context);
1896         if (ret) {
1897                 goto end;
1898         }
1899
1900         /* Special case for PERF_*_COUNTER
1901          * print the lttng_event_perf_counter_ctx*/
1902         switch (context->ctx) {
1903         case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
1904         case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER:
1905         case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
1906         {
1907                 struct lttng_event_perf_counter_ctx *perf_context =
1908                                 &context->u.perf_counter;
1909                 ret =  mi_lttng_perf_counter_context(writer, perf_context);
1910                 if (ret) {
1911                         goto end;
1912                 }
1913                 break;
1914         }
1915         case LTTNG_EVENT_CONTEXT_APP_CONTEXT:
1916         {
1917                 ret = mi_lttng_app_context(writer,
1918                                 context->u.app_ctx.provider_name,
1919                                 context->u.app_ctx.ctx_name);
1920                 if (ret) {
1921                         goto end;
1922                 }
1923                 break;
1924         }
1925         default:
1926         {
1927                 const char *type_string = mi_lttng_event_contexttype_string(
1928                                 context->ctx);
1929                 if (!type_string) {
1930                         ret = -LTTNG_ERR_INVALID;
1931                         goto end;
1932                 }
1933
1934                 /* Print context type */
1935                 ret = mi_lttng_writer_write_element_string(writer,
1936                                 config_element_type, type_string);
1937                 break;
1938         }
1939         }
1940
1941         /* Close context */
1942         if (!is_open) {
1943                 ret = mi_lttng_writer_close_element(writer);
1944         }
1945
1946 end:
1947         return ret;
1948 }
1949
1950 LTTNG_HIDDEN
1951 int mi_lttng_snapshot_output_session_name(struct mi_writer *writer,
1952                 const char *session_name)
1953 {
1954         int ret;
1955
1956         /* Open session element */
1957         ret = mi_lttng_writer_open_element(writer, config_element_session);
1958         if (ret) {
1959                 goto end;
1960         }
1961
1962         /* Snapshot output list for current session name */
1963         ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1964                         session_name);
1965         if (ret) {
1966                 goto end;
1967         }
1968
1969         /* Open element snapshots (sequence one snapshot) */
1970         ret = mi_lttng_writer_open_element(writer, mi_lttng_element_snapshots);
1971         if (ret) {
1972                 goto end;
1973         }
1974
1975 end:
1976         return ret;
1977 }
1978
1979 LTTNG_HIDDEN
1980 int mi_lttng_snapshot_list_output(struct mi_writer *writer,
1981                 struct lttng_snapshot_output *output)
1982 {
1983         int ret;
1984
1985         /* Open element snapshot output */
1986         ret = mi_lttng_writer_open_element(writer,
1987                         mi_lttng_element_command_snapshot);
1988         if (ret) {
1989                 goto end;
1990         }
1991
1992         /* ID of the snapshot output */
1993         ret = mi_lttng_writer_write_element_unsigned_int(writer,
1994                         mi_lttng_element_id, output->id);
1995         if (ret) {
1996                 goto end;
1997         }
1998
1999         /* Name of the output */
2000         ret = mi_lttng_writer_write_element_string(writer, config_element_name,
2001                         output->name);
2002         if (ret) {
2003                 goto end;
2004         }
2005
2006         /* Destination of the output (ctrl_url)*/
2007         ret = mi_lttng_writer_write_element_string(writer,
2008                         mi_lttng_element_snapshot_ctrl_url, output->ctrl_url);
2009         if (ret) {
2010                 goto end;
2011         }
2012
2013         /* Destination of the output (data_url) */
2014         ret = mi_lttng_writer_write_element_string(writer,
2015                         mi_lttng_element_snapshot_data_url, output->data_url);
2016         if (ret) {
2017                 goto end;
2018         }
2019
2020         /* total size of all stream combined */
2021         ret = mi_lttng_writer_write_element_unsigned_int(writer,
2022                         mi_lttng_element_snapshot_max_size, output->max_size);
2023         if (ret) {
2024                 goto end;
2025         }
2026
2027         /* Close snapshot output element */
2028         ret = mi_lttng_writer_close_element(writer);
2029
2030 end:
2031         return ret;
2032 }
2033
2034 LTTNG_HIDDEN
2035 int mi_lttng_snapshot_del_output(struct mi_writer *writer, int id,
2036                 const char *name, const char *current_session_name)
2037 {
2038         int ret;
2039
2040         /* Open element del_snapshot */
2041         ret = mi_lttng_writer_open_element(writer,
2042                         mi_lttng_element_command_snapshot);
2043         if (ret) {
2044                 goto end;
2045         }
2046
2047
2048         if (id != UINT32_MAX) {
2049                 /* "Snapshot output "id" successfully deleted
2050                  * for "current_session_name"
2051                  * ID of the snapshot output
2052                  */
2053                 ret = mi_lttng_writer_write_element_unsigned_int(writer,
2054                                 mi_lttng_element_id, id);
2055                 if (ret) {
2056                         goto end;
2057                 }
2058         } else {
2059                 /* "Snapshot output "name" successfully deleted
2060                  * for session "current_session_name"
2061                  * Name of the output
2062                  */
2063                 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
2064                                 name);
2065                 if (ret) {
2066                         goto end;
2067                 }
2068         }
2069
2070         /* Snapshot was deleted for session "current_session_name"*/
2071         ret = mi_lttng_writer_write_element_string(writer,
2072                         mi_lttng_element_snapshot_session_name,
2073                         current_session_name);
2074         if (ret) {
2075                 goto end;
2076         }
2077
2078         /* Close snapshot element */
2079         ret = mi_lttng_writer_close_element(writer);
2080
2081 end:
2082         return ret;
2083 }
2084
2085 LTTNG_HIDDEN
2086 int mi_lttng_snapshot_add_output(struct mi_writer *writer,
2087                 const char *current_session_name, const char *n_ptr,
2088                 struct lttng_snapshot_output *output)
2089 {
2090         int ret;
2091
2092         /* Open element snapshot */
2093         ret = mi_lttng_writer_open_element(writer,
2094                         mi_lttng_element_command_snapshot);
2095         if (ret) {
2096                 goto end;
2097         }
2098
2099         /* Snapshot output id */
2100         ret = mi_lttng_writer_write_element_unsigned_int(writer,
2101                         mi_lttng_element_id, output->id);
2102         if (ret) {
2103                 goto end;
2104         }
2105
2106         /* Snapshot output names */
2107         ret = mi_lttng_writer_write_element_string(writer,
2108                         config_element_name, n_ptr);
2109         if (ret) {
2110                 goto end;
2111         }
2112
2113         /* Destination of the output (ctrl_url)*/
2114         ret = mi_lttng_writer_write_element_string(writer,
2115                         mi_lttng_element_snapshot_ctrl_url, output->ctrl_url);
2116         if (ret) {
2117                 goto end;
2118         }
2119
2120         /* Snapshot added for session "current_session_name"*/
2121         ret = mi_lttng_writer_write_element_string(writer,
2122                         mi_lttng_element_snapshot_session_name, current_session_name);
2123         if (ret) {
2124                 goto end;
2125         }
2126
2127         /* total size of all stream combined */
2128         ret = mi_lttng_writer_write_element_unsigned_int(writer,
2129                         mi_lttng_element_snapshot_max_size, output->max_size);
2130         if (ret) {
2131                 goto end;
2132         }
2133
2134         /* Close snapshot element */
2135         ret = mi_lttng_writer_close_element(writer);
2136
2137 end:
2138         return ret;
2139 }
2140
2141 LTTNG_HIDDEN
2142 int mi_lttng_snapshot_record(struct mi_writer *writer,
2143                 const char *current_session_name, const char *url,
2144                 const char *cmdline_ctrl_url, const char *cmdline_data_url)
2145 {
2146         int ret;
2147
2148         /* Open element snapshot */
2149         ret = mi_lttng_writer_open_element(writer,
2150                         mi_lttng_element_command_snapshot);
2151         if (ret) {
2152                 goto end;
2153         }
2154
2155         /*
2156          * If a valid an URL was given, serialize it,
2157          * else take the command line data and ctrl urls*/
2158         if (url) {
2159                 /* Destination of the output (ctrl_url)*/
2160                 ret = mi_lttng_writer_write_element_string(writer,
2161                                 mi_lttng_element_snapshot_ctrl_url, url);
2162                 if (ret) {
2163                         goto end;
2164                 }
2165         } else if (cmdline_ctrl_url) {
2166                 /* Destination of the output (ctrl_url)*/
2167                 ret = mi_lttng_writer_write_element_string(writer,
2168                                 mi_lttng_element_snapshot_ctrl_url, cmdline_ctrl_url);
2169                 if (ret) {
2170                         goto end;
2171                 }
2172
2173                 /* Destination of the output (data_url) */
2174                 ret = mi_lttng_writer_write_element_string(writer,
2175                                 mi_lttng_element_snapshot_data_url, cmdline_data_url);
2176                 if (ret) {
2177                         goto end;
2178                 }
2179         }
2180
2181         /* Close record_snapshot element */
2182         ret = mi_lttng_writer_close_element(writer);
2183
2184 end:
2185         return ret;
2186 }
2187
2188 LTTNG_HIDDEN
2189 int mi_lttng_rotation_schedule(struct mi_writer *writer,
2190                 const struct lttng_rotation_schedule *schedule)
2191 {
2192         int ret = 0;
2193         enum lttng_rotation_status status;
2194         uint64_t value;
2195         const char *element_name;
2196         const char *value_name;
2197         bool empty_schedule = false;
2198
2199         switch (lttng_rotation_schedule_get_type(schedule)) {
2200         case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
2201                 status = lttng_rotation_schedule_periodic_get_period(schedule,
2202                                 &value);
2203                 element_name = mi_lttng_element_rotation_schedule_periodic;
2204                 value_name = mi_lttng_element_rotation_schedule_periodic_time_us;
2205                 break;
2206         case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
2207                 status = lttng_rotation_schedule_size_threshold_get_threshold(
2208                                 schedule, &value);
2209                 element_name = mi_lttng_element_rotation_schedule_size_threshold;
2210                 value_name = mi_lttng_element_rotation_schedule_size_threshold_bytes;
2211                 break;
2212         default:
2213                 ret = -1;
2214                 goto end;
2215         }
2216
2217         if (status != LTTNG_ROTATION_STATUS_OK) {
2218                 if (status == LTTNG_ROTATION_STATUS_UNAVAILABLE) {
2219                         empty_schedule = true;
2220                 } else {
2221                         ret = -1;
2222                         goto end;
2223                 }
2224         }
2225
2226         ret = mi_lttng_writer_open_element(writer, element_name);
2227         if (ret) {
2228                 goto end;
2229         }
2230
2231         if (!empty_schedule) {
2232                 ret = mi_lttng_writer_write_element_unsigned_int(writer,
2233                                 value_name, value);
2234                 if (ret) {
2235                         goto end;
2236                 }
2237         }
2238
2239         /* Close schedule descriptor element. */
2240         ret = mi_lttng_writer_close_element(writer);
2241         if (ret) {
2242                 goto end;
2243         }
2244 end:
2245         return ret;
2246 }
2247
2248 LTTNG_HIDDEN
2249 int mi_lttng_rotation_schedule_result(struct mi_writer *writer,
2250                 const struct lttng_rotation_schedule *schedule,
2251                 bool success)
2252 {
2253         int ret = 0;
2254
2255         ret = mi_lttng_writer_open_element(writer,
2256                         mi_lttng_element_rotation_schedule_result);
2257         if (ret) {
2258                 goto end;
2259         }
2260
2261         ret = mi_lttng_writer_open_element(writer,
2262                         mi_lttng_element_rotation_schedule);
2263         if (ret) {
2264                 goto end;
2265         }
2266
2267         ret = mi_lttng_rotation_schedule(writer, schedule);
2268         if (ret) {
2269                 goto end;
2270         }
2271
2272         /* Close rotation_schedule element */
2273         ret = mi_lttng_writer_close_element(writer);
2274         if (ret) {
2275                 goto end;
2276         }
2277
2278         ret = mi_lttng_writer_write_element_bool(writer,
2279                         mi_lttng_element_command_success, success);
2280         if (ret) {
2281                 goto end;
2282         }
2283
2284         /* Close rotation_schedule_result element */
2285         ret = mi_lttng_writer_close_element(writer);
2286         if (ret) {
2287                 goto end;
2288         }
2289 end:
2290         return ret;
2291 }
2292
2293 static
2294 int mi_lttng_location(struct mi_writer *writer,
2295                 const struct lttng_trace_archive_location *location)
2296 {
2297         int ret = 0;
2298         enum lttng_trace_archive_location_type location_type;
2299         enum lttng_trace_archive_location_status status;
2300
2301         location_type = lttng_trace_archive_location_get_type(location);
2302
2303         switch (location_type) {
2304         case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
2305         {
2306                 const char *absolute_path;
2307
2308                 status = lttng_trace_archive_location_local_get_absolute_path(
2309                                 location, &absolute_path);
2310                 if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
2311                         ret = -1;
2312                         goto end;
2313                 }
2314
2315                 ret = mi_lttng_writer_open_element(writer,
2316                                 mi_lttng_element_rotation_location_local);
2317                 if (ret) {
2318                         goto end;
2319                 }
2320
2321
2322                 ret = mi_lttng_writer_write_element_string(writer,
2323                                 mi_lttng_element_rotation_location_local_absolute_path,
2324                                 absolute_path);
2325                 if (ret) {
2326                         goto end;
2327                 }
2328
2329                 /* Close local element */
2330                 ret = mi_lttng_writer_close_element(writer);
2331                 if (ret) {
2332                         goto end;
2333                 }
2334                 break;
2335         }
2336         case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
2337         {
2338                 uint16_t control_port, data_port;
2339                 const char *host, *relative_path;
2340                 enum lttng_trace_archive_location_relay_protocol_type protocol;
2341
2342                 /* Fetch all relay location parameters. */
2343                 status = lttng_trace_archive_location_relay_get_protocol_type(
2344                                 location, &protocol);
2345                 if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
2346                         ret = -1;
2347                         goto end;
2348                 }
2349
2350                 status = lttng_trace_archive_location_relay_get_host(
2351                                 location, &host);
2352                 if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
2353                         ret = -1;
2354                         goto end;
2355                 }
2356
2357                 status = lttng_trace_archive_location_relay_get_control_port(
2358                                 location, &control_port);
2359                 if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
2360                         ret = -1;
2361                         goto end;
2362                 }
2363
2364                 status = lttng_trace_archive_location_relay_get_data_port(
2365                                 location, &data_port);
2366                 if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
2367                         ret = -1;
2368                         goto end;
2369                 }
2370
2371                 status = lttng_trace_archive_location_relay_get_relative_path(
2372                                 location, &relative_path);
2373                 if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
2374                         ret = -1;
2375                         goto end;
2376                 }
2377
2378                 ret = mi_lttng_writer_open_element(writer,
2379                                 mi_lttng_element_rotation_location_relay);
2380                 if (ret) {
2381                         goto end;
2382                 }
2383
2384                 ret = mi_lttng_writer_write_element_string(writer,
2385                                 mi_lttng_element_rotation_location_relay_host,
2386                                 host);
2387                 if (ret) {
2388                         goto end;
2389                 }
2390
2391                 ret = mi_lttng_writer_write_element_unsigned_int(writer,
2392                                 mi_lttng_element_rotation_location_relay_control_port,
2393                                 control_port);
2394                 if (ret) {
2395                         goto end;
2396                 }
2397
2398                 ret = mi_lttng_writer_write_element_unsigned_int(writer,
2399                                 mi_lttng_element_rotation_location_relay_data_port,
2400                                 data_port);
2401                 if (ret) {
2402                         goto end;
2403                 }
2404
2405                 ret = mi_lttng_writer_write_element_string(writer,
2406                                 mi_lttng_element_rotation_location_relay_protocol,
2407                                 mi_lttng_trace_archive_location_relay_protocol_type_string(protocol));
2408                 if (ret) {
2409                         goto end;
2410                 }
2411
2412                 ret = mi_lttng_writer_write_element_string(writer,
2413                                 mi_lttng_element_rotation_location_relay_relative_path,
2414                                 relative_path);
2415                 if (ret) {
2416                         goto end;
2417                 }
2418
2419                 /* Close relay element */
2420                 ret = mi_lttng_writer_close_element(writer);
2421                 if (ret) {
2422                         goto end;
2423                 }
2424                 break;
2425         }
2426         default:
2427                 abort();
2428         }
2429 end:
2430         return ret;
2431 }
2432
2433 LTTNG_HIDDEN
2434 int mi_lttng_rotate(struct mi_writer *writer,
2435                 const char *session_name,
2436                 enum lttng_rotation_state rotation_state,
2437                 const struct lttng_trace_archive_location *location)
2438 {
2439         int ret;
2440
2441         ret = mi_lttng_writer_open_element(writer,
2442                         mi_lttng_element_rotation);
2443         if (ret) {
2444                 goto end;
2445         }
2446
2447         ret = mi_lttng_writer_write_element_string(writer,
2448                         mi_lttng_element_session_name,
2449                         session_name);
2450         if (ret) {
2451                 goto end;
2452         }
2453
2454         ret = mi_lttng_writer_write_element_string(writer,
2455                         mi_lttng_element_rotation_state,
2456                         mi_lttng_rotation_state_string(rotation_state));
2457         if (ret) {
2458                 goto end;
2459         }
2460
2461         if (!location) {
2462                 /* Not a serialization error. */
2463                 goto close_rotation;
2464         }
2465
2466         ret = mi_lttng_writer_open_element(writer,
2467                         mi_lttng_element_rotation_location);
2468         if (ret) {
2469                 goto end;
2470         }
2471
2472         ret = mi_lttng_location(writer, location);
2473         if (ret) {
2474                 goto close_location;
2475         }
2476
2477 close_location:
2478         /* Close location element */
2479         ret = mi_lttng_writer_close_element(writer);
2480         if (ret) {
2481                 goto end;
2482         }
2483
2484 close_rotation:
2485         /* Close rotation element */
2486         ret = mi_lttng_writer_close_element(writer);
2487         if (ret) {
2488                 goto end;
2489         }
2490 end:
2491         return ret;
2492 }