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