src/common/mi-lttng.cpp

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