197add2d470518bf0e18f4f2ecc16320d8a88265
[lttng-tools.git] / src / common / mi-lttng.c
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 */
33 LTTNG_HIDDEN const char * const mi_lttng_xmlns = "xmlns";
34 LTTNG_HIDDEN const char * const mi_lttng_xmlns_xsi = "xmlns:xsi";
35 LTTNG_HIDDEN const char * const mi_lttng_w3_schema_uri = "http://www.w3.org/2001/XMLSchema-instance";
36 LTTNG_HIDDEN const char * const mi_lttng_schema_location = "xsi:schemaLocation";
37 LTTNG_HIDDEN const char * const mi_lttng_schema_location_uri =
38 DEFAULT_LTTNG_MI_NAMESPACE " "
39 "http://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";
42 LTTNG_HIDDEN const char * const mi_lttng_schema_version = "schemaVersion";
43 LTTNG_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 */
47 const char * const mi_lttng_element_command = "command";
48 const char * const mi_lttng_element_command_action = "snapshot_action";
49 const char * const mi_lttng_element_command_add_context = "add-context";
50 const char * const mi_lttng_element_command_create = "create";
51 const char * const mi_lttng_element_command_destroy = "destroy";
52 const char * const mi_lttng_element_command_disable_channel = "disable-channel";
53 const char * const mi_lttng_element_command_disable_event = "disable-event";
54 const char * const mi_lttng_element_command_enable_channels = "enable-channel";
55 const char * const mi_lttng_element_command_enable_event = "enable-event";
56 const char * const mi_lttng_element_command_list = "list";
57 const char * const mi_lttng_element_command_load = "load";
58 LTTNG_HIDDEN const char * const mi_lttng_element_command_metadata = "metadata";
59 LTTNG_HIDDEN const char * const mi_lttng_element_command_metadata_action = "metadata_action";
60 LTTNG_HIDDEN const char * const mi_lttng_element_command_regenerate = "regenerate";
61 LTTNG_HIDDEN const char * const mi_lttng_element_command_regenerate_action = "regenerate_action";
62 const char * const mi_lttng_element_command_name = "name";
63 const char * const mi_lttng_element_command_output = "output";
64 const char * const mi_lttng_element_command_save = "save";
65 const char * const mi_lttng_element_command_set_session = "set-session";
66 const char * const mi_lttng_element_command_snapshot = "snapshot";
67 const char * const mi_lttng_element_command_snapshot_add = "add_snapshot";
68 const char * const mi_lttng_element_command_snapshot_del = "del_snapshot";
69 const char * const mi_lttng_element_command_snapshot_list = "list_snapshot";
70 const char * const mi_lttng_element_command_snapshot_record = "record_snapshot";
71 const char * const mi_lttng_element_command_start = "start";
72 const char * const mi_lttng_element_command_stop = "stop";
73 const char * const mi_lttng_element_command_success = "success";
74 const char * const mi_lttng_element_command_track = "track";
75 const char * const mi_lttng_element_command_untrack = "untrack";
76 const char * const mi_lttng_element_command_version = "version";
77
78 /* Strings related to version command */
79 const char * const mi_lttng_element_version = "version";
80 const char * const mi_lttng_element_version_commit = "commit";
81 const char * const mi_lttng_element_version_description = "description";
82 const char * const mi_lttng_element_version_license = "license";
83 const char * const mi_lttng_element_version_major = "major";
84 const char * const mi_lttng_element_version_minor = "minor";
85 const char * const mi_lttng_element_version_patch_level = "patchLevel";
86 const char * const mi_lttng_element_version_str = "string";
87 const char * const mi_lttng_element_version_web = "url";
88
89 /* String related to a lttng_event_field */
90 const char * const mi_lttng_element_event_field = "event_field";
91 const char * const mi_lttng_element_event_fields = "event_fields";
92
93 /* String related to lttng_event_perf_counter_ctx */
94 const char * const mi_lttng_element_perf_counter_context = "perf";
95
96 /* Strings related to pid */
97 const char * const mi_lttng_element_pid_id = "id";
98
99 /* Strings related to save command */
100 const char * const mi_lttng_element_save = "save";
101
102 /* Strings related to load command */
103 const char * const mi_lttng_element_load = "load";
104 LTTNG_HIDDEN const char * const mi_lttng_element_load_overrides = "overrides";
105 LTTNG_HIDDEN const char * const mi_lttng_element_load_override_url = "url";
106
107 /* General elements of mi_lttng */
108 const char * const mi_lttng_element_empty = "";
109 const char * const mi_lttng_element_id = "id";
110 const char * const mi_lttng_element_nowrite = "nowrite";
111 const char * const mi_lttng_element_success = "success";
112 const char * const mi_lttng_element_type_enum = "ENUM";
113 const char * const mi_lttng_element_type_float = "FLOAT";
114 const char * const mi_lttng_element_type_integer = "INTEGER";
115 const char * const mi_lttng_element_type_other = "OTHER";
116 const char * const mi_lttng_element_type_string = "STRING";
117
118 /* String related to loglevel */
119 const char * const mi_lttng_loglevel_str_alert = "TRACE_ALERT";
120 const char * const mi_lttng_loglevel_str_crit = "TRACE_CRIT";
121 const char * const mi_lttng_loglevel_str_debug = "TRACE_DEBUG";
122 const char * const mi_lttng_loglevel_str_debug_function = "TRACE_DEBUG_FUNCTION";
123 const char * const mi_lttng_loglevel_str_debug_line = "TRACE_DEBUG_LINE";
124 const char * const mi_lttng_loglevel_str_debug_module = "TRACE_DEBUG_MODULE";
125 const char * const mi_lttng_loglevel_str_debug_process = "TRACE_DEBUG_PROCESS";
126 const char * const mi_lttng_loglevel_str_debug_program = "TRACE_DEBUG_PROGRAM";
127 const char * const mi_lttng_loglevel_str_debug_system = "TRACE_DEBUG_SYSTEM";
128 const char * const mi_lttng_loglevel_str_debug_unit = "TRACE_DEBUG_UNIT";
129 const char * const mi_lttng_loglevel_str_emerg = "TRACE_EMERG";
130 const char * const mi_lttng_loglevel_str_err = "TRACE_ERR";
131 const char * const mi_lttng_loglevel_str_info = "TRACE_INFO";
132 const char * const mi_lttng_loglevel_str_notice = "TRACE_NOTICE";
133 const char * const mi_lttng_loglevel_str_unknown = "UNKNOWN";
134 const char * const mi_lttng_loglevel_str_warning = "TRACE_WARNING";
135
136 /* String related to loglevel JUL */
137 const char * const mi_lttng_loglevel_str_jul_all = "JUL_ALL";
138 const char * const mi_lttng_loglevel_str_jul_config = "JUL_CONFIG";
139 const char * const mi_lttng_loglevel_str_jul_fine = "JUL_FINE";
140 const char * const mi_lttng_loglevel_str_jul_finer = "JUL_FINER";
141 const char * const mi_lttng_loglevel_str_jul_finest = "JUL_FINEST";
142 const char * const mi_lttng_loglevel_str_jul_info = "JUL_INFO";
143 const char * const mi_lttng_loglevel_str_jul_off = "JUL_OFF";
144 const char * const mi_lttng_loglevel_str_jul_severe = "JUL_SEVERE";
145 const char * const mi_lttng_loglevel_str_jul_warning = "JUL_WARNING";
146
147 /* String related to loglevel LOG4J */
148 const char * const mi_lttng_loglevel_str_log4j_off = "LOG4J_OFF";
149 const char * const mi_lttng_loglevel_str_log4j_fatal = "LOG4J_FATAL";
150 const char * const mi_lttng_loglevel_str_log4j_error = "LOG4J_ERROR";
151 const char * const mi_lttng_loglevel_str_log4j_warn = "LOG4J_WARN";
152 const char * const mi_lttng_loglevel_str_log4j_info = "LOG4J_INFO";
153 const char * const mi_lttng_loglevel_str_log4j_debug = "LOG4J_DEBUG";
154 const char * const mi_lttng_loglevel_str_log4j_trace = "LOG4J_TRACE";
155 const char * const mi_lttng_loglevel_str_log4j_all = "LOG4J_ALL";
156
157 /* String related to loglevel Python */
158 const char * const mi_lttng_loglevel_str_python_critical = "PYTHON_CRITICAL";
159 const char * const mi_lttng_loglevel_str_python_error = "PYTHON_ERROR";
160 const char * const mi_lttng_loglevel_str_python_warning = "PYTHON_WARNING";
161 const char * const mi_lttng_loglevel_str_python_info = "PYTHON_INFO";
162 const char * const mi_lttng_loglevel_str_python_debug = "PYTHON_DEBUG";
163 const char * const mi_lttng_loglevel_str_python_notset = "PYTHON_NOTSET";
164
165 /* String related to loglevel type */
166 const char * const mi_lttng_loglevel_type_all = "ALL";
167 const char * const mi_lttng_loglevel_type_range = "RANGE";
168 const char * const mi_lttng_loglevel_type_single = "SINGLE";
169 const char * const mi_lttng_loglevel_type_unknown = "UNKNOWN";
170
171 /* String related to a lttng_snapshot_output */
172 const char * const mi_lttng_element_snapshot_ctrl_url = "ctrl_url";
173 const char * const mi_lttng_element_snapshot_data_url = "data_url";
174 const char * const mi_lttng_element_snapshot_max_size = "max_size";
175 const char * const mi_lttng_element_snapshot_n_ptr = "n_ptr";
176 const char * const mi_lttng_element_snapshot_session_name = "session_name";
177 const char * const mi_lttng_element_snapshots = "snapshots";
178
179 /* String related to track/untrack command */
180 const char * const mi_lttng_element_track_untrack_all_wildcard = "*";
181
182 /* Deprecated symbols preserved for ABI compatibility. */
183 const char * const mi_lttng_context_type_perf_counter;
184 const char * const mi_lttng_context_type_perf_cpu_counter;
185 const char * const mi_lttng_context_type_perf_thread_counter;
186 const char * const mi_lttng_element_track_untrack_pid_target;
187 const char * const mi_lttng_element_track_untrack_targets;
188 const char * const mi_lttng_element_calibrate;
189 const char * const mi_lttng_element_calibrate_function;
190 const char * const mi_lttng_element_command_calibrate;
191
192 /* This is a merge of jul loglevel and regular loglevel
193 * Those should never overlap by definition
194 * (see struct lttng_event loglevel)
195 */
196 LTTNG_HIDDEN
197 const char *mi_lttng_loglevel_string(int value, enum lttng_domain_type domain)
198 {
199 switch (domain) {
200 case LTTNG_DOMAIN_KERNEL:
201 case LTTNG_DOMAIN_UST:
202 switch (value) {
203 case -1:
204 return mi_lttng_element_empty;
205 case LTTNG_LOGLEVEL_EMERG:
206 return mi_lttng_loglevel_str_emerg;
207 case LTTNG_LOGLEVEL_ALERT:
208 return mi_lttng_loglevel_str_alert;
209 case LTTNG_LOGLEVEL_CRIT:
210 return mi_lttng_loglevel_str_crit;
211 case LTTNG_LOGLEVEL_ERR:
212 return mi_lttng_loglevel_str_err;
213 case LTTNG_LOGLEVEL_WARNING:
214 return mi_lttng_loglevel_str_warning;
215 case LTTNG_LOGLEVEL_NOTICE:
216 return mi_lttng_loglevel_str_notice;
217 case LTTNG_LOGLEVEL_INFO:
218 return mi_lttng_loglevel_str_info;
219 case LTTNG_LOGLEVEL_DEBUG_SYSTEM:
220 return mi_lttng_loglevel_str_debug_system;
221 case LTTNG_LOGLEVEL_DEBUG_PROGRAM:
222 return mi_lttng_loglevel_str_debug_program;
223 case LTTNG_LOGLEVEL_DEBUG_PROCESS:
224 return mi_lttng_loglevel_str_debug_process;
225 case LTTNG_LOGLEVEL_DEBUG_MODULE:
226 return mi_lttng_loglevel_str_debug_module;
227 case LTTNG_LOGLEVEL_DEBUG_UNIT:
228 return mi_lttng_loglevel_str_debug_unit;
229 case LTTNG_LOGLEVEL_DEBUG_FUNCTION:
230 return mi_lttng_loglevel_str_debug_function;
231 case LTTNG_LOGLEVEL_DEBUG_LINE:
232 return mi_lttng_loglevel_str_debug_line;
233 case LTTNG_LOGLEVEL_DEBUG:
234 return mi_lttng_loglevel_str_debug;
235 default:
236 return mi_lttng_loglevel_str_unknown;
237 }
238 break;
239 case LTTNG_DOMAIN_LOG4J:
240 switch (value) {
241 case -1:
242 return mi_lttng_element_empty;
243 case LTTNG_LOGLEVEL_LOG4J_OFF:
244 return mi_lttng_loglevel_str_log4j_off;
245 case LTTNG_LOGLEVEL_LOG4J_FATAL:
246 return mi_lttng_loglevel_str_log4j_fatal;
247 case LTTNG_LOGLEVEL_LOG4J_ERROR:
248 return mi_lttng_loglevel_str_log4j_error;
249 case LTTNG_LOGLEVEL_LOG4J_WARN:
250 return mi_lttng_loglevel_str_log4j_warn;
251 case LTTNG_LOGLEVEL_LOG4J_INFO:
252 return mi_lttng_loglevel_str_log4j_info;
253 case LTTNG_LOGLEVEL_LOG4J_DEBUG:
254 return mi_lttng_loglevel_str_log4j_debug;
255 case LTTNG_LOGLEVEL_LOG4J_TRACE:
256 return mi_lttng_loglevel_str_log4j_trace;
257 case LTTNG_LOGLEVEL_LOG4J_ALL:
258 return mi_lttng_loglevel_str_log4j_all;
259 default:
260 return mi_lttng_loglevel_str_unknown;
261 }
262 break;
263 case LTTNG_DOMAIN_JUL:
264 switch (value) {
265 case -1:
266 return mi_lttng_element_empty;
267 case LTTNG_LOGLEVEL_JUL_OFF:
268 return mi_lttng_loglevel_str_jul_off;
269 case LTTNG_LOGLEVEL_JUL_SEVERE:
270 return mi_lttng_loglevel_str_jul_severe;
271 case LTTNG_LOGLEVEL_JUL_WARNING:
272 return mi_lttng_loglevel_str_jul_warning;
273 case LTTNG_LOGLEVEL_JUL_INFO:
274 return mi_lttng_loglevel_str_jul_info;
275 case LTTNG_LOGLEVEL_JUL_CONFIG:
276 return mi_lttng_loglevel_str_jul_config;
277 case LTTNG_LOGLEVEL_JUL_FINE:
278 return mi_lttng_loglevel_str_jul_fine;
279 case LTTNG_LOGLEVEL_JUL_FINER:
280 return mi_lttng_loglevel_str_jul_finer;
281 case LTTNG_LOGLEVEL_JUL_FINEST:
282 return mi_lttng_loglevel_str_jul_finest;
283 case LTTNG_LOGLEVEL_JUL_ALL:
284 return mi_lttng_loglevel_str_jul_all;
285 default:
286 return mi_lttng_loglevel_str_unknown;
287 }
288 break;
289 case LTTNG_DOMAIN_PYTHON:
290 switch (value) {
291 case LTTNG_LOGLEVEL_PYTHON_CRITICAL:
292 return mi_lttng_loglevel_str_python_critical;
293 case LTTNG_LOGLEVEL_PYTHON_ERROR:
294 return mi_lttng_loglevel_str_python_error;
295 case LTTNG_LOGLEVEL_PYTHON_WARNING:
296 return mi_lttng_loglevel_str_python_warning;
297 case LTTNG_LOGLEVEL_PYTHON_INFO:
298 return mi_lttng_loglevel_str_python_info;
299 case LTTNG_LOGLEVEL_PYTHON_DEBUG:
300 return mi_lttng_loglevel_str_python_debug;
301 case LTTNG_LOGLEVEL_PYTHON_NOTSET:
302 return mi_lttng_loglevel_str_python_notset;
303 default:
304 return mi_lttng_loglevel_str_unknown;
305 }
306 break;
307 default:
308 return mi_lttng_loglevel_str_unknown;
309 }
310 }
311
312 LTTNG_HIDDEN
313 const char *mi_lttng_logleveltype_string(enum lttng_loglevel_type value)
314 {
315 switch (value) {
316 case LTTNG_EVENT_LOGLEVEL_ALL:
317 return mi_lttng_loglevel_type_all;
318 case LTTNG_EVENT_LOGLEVEL_RANGE:
319 return mi_lttng_loglevel_type_range;
320 case LTTNG_EVENT_LOGLEVEL_SINGLE:
321 return mi_lttng_loglevel_type_single;
322 default:
323 return mi_lttng_loglevel_type_unknown;
324 }
325 }
326
327 LTTNG_HIDDEN
328 const char *mi_lttng_eventtype_string(enum lttng_event_type value)
329 {
330 switch (value) {
331 case LTTNG_EVENT_ALL:
332 return config_event_type_all;
333 case LTTNG_EVENT_TRACEPOINT:
334 return config_event_type_tracepoint;
335 case LTTNG_EVENT_PROBE:
336 return config_event_type_probe;
337 case LTTNG_EVENT_FUNCTION:
338 return config_event_type_function;
339 case LTTNG_EVENT_FUNCTION_ENTRY:
340 return config_event_type_function_entry;
341 case LTTNG_EVENT_SYSCALL:
342 return config_event_type_syscall;
343 case LTTNG_EVENT_NOOP:
344 return config_event_type_noop;
345 default:
346 return mi_lttng_element_empty;
347 }
348 }
349
350 static
351 const char *mi_lttng_event_contexttype_string(enum lttng_event_context_type val)
352 {
353 switch (val) {
354 case LTTNG_EVENT_CONTEXT_PID:
355 return config_event_context_pid;
356 case LTTNG_EVENT_CONTEXT_PROCNAME:
357 return config_event_context_procname;
358 case LTTNG_EVENT_CONTEXT_PRIO:
359 return config_event_context_prio;
360 case LTTNG_EVENT_CONTEXT_NICE:
361 return config_event_context_nice;
362 case LTTNG_EVENT_CONTEXT_VPID:
363 return config_event_context_vpid;
364 case LTTNG_EVENT_CONTEXT_TID:
365 return config_event_context_tid;
366 case LTTNG_EVENT_CONTEXT_VTID:
367 return config_event_context_vtid;
368 case LTTNG_EVENT_CONTEXT_PPID:
369 return config_event_context_ppid;
370 case LTTNG_EVENT_CONTEXT_VPPID:
371 return config_event_context_vppid;
372 case LTTNG_EVENT_CONTEXT_PTHREAD_ID:
373 return config_event_context_pthread_id;
374 case LTTNG_EVENT_CONTEXT_HOSTNAME:
375 return config_event_context_hostname;
376 case LTTNG_EVENT_CONTEXT_IP:
377 return config_event_context_ip;
378 default:
379 return NULL;
380 }
381 }
382
383 LTTNG_HIDDEN
384 const char *mi_lttng_eventfieldtype_string(enum lttng_event_field_type val)
385 {
386 switch (val) {
387 case(LTTNG_EVENT_FIELD_INTEGER):
388 return mi_lttng_element_type_integer;
389 case(LTTNG_EVENT_FIELD_ENUM):
390 return mi_lttng_element_type_enum;
391 case(LTTNG_EVENT_FIELD_FLOAT):
392 return mi_lttng_element_type_float;
393 case(LTTNG_EVENT_FIELD_STRING):
394 return mi_lttng_element_type_string;
395 default:
396 return mi_lttng_element_type_other;
397 }
398 }
399
400 LTTNG_HIDDEN
401 const char *mi_lttng_domaintype_string(enum lttng_domain_type value)
402 {
403 /* Note: This is a *duplicate* of get_domain_str from bin/lttng/utils.c */
404 switch (value) {
405 case LTTNG_DOMAIN_KERNEL:
406 return config_domain_type_kernel;
407 case LTTNG_DOMAIN_UST:
408 return config_domain_type_ust;
409 case LTTNG_DOMAIN_JUL:
410 return config_domain_type_jul;
411 case LTTNG_DOMAIN_LOG4J:
412 return config_domain_type_log4j;
413 case LTTNG_DOMAIN_PYTHON:
414 return config_domain_type_python;
415 default:
416 /* Should not have an unknown domain */
417 assert(0);
418 return NULL;
419 }
420 }
421
422 LTTNG_HIDDEN
423 const char *mi_lttng_buffertype_string(enum lttng_buffer_type value)
424 {
425 switch (value) {
426 case LTTNG_BUFFER_PER_PID:
427 return config_buffer_type_per_pid;
428 case LTTNG_BUFFER_PER_UID:
429 return config_buffer_type_per_uid;
430 case LTTNG_BUFFER_GLOBAL:
431 return config_buffer_type_global;
432 default:
433 /* Should not have an unknow buffer type */
434 assert(0);
435 return NULL;
436 }
437 }
438
439 LTTNG_HIDDEN
440 struct mi_writer *mi_lttng_writer_create(int fd_output, int mi_output_type)
441 {
442 struct mi_writer *mi_writer;
443
444 mi_writer = zmalloc(sizeof(struct mi_writer));
445 if (!mi_writer) {
446 PERROR("zmalloc mi_writer_create");
447 goto end;
448 }
449 if (mi_output_type == LTTNG_MI_XML) {
450 mi_writer->writer = config_writer_create(fd_output, 0);
451 if (!mi_writer->writer) {
452 goto err_destroy;
453 }
454 mi_writer->type = LTTNG_MI_XML;
455 } else {
456 goto err_destroy;
457 }
458
459 end:
460 return mi_writer;
461
462 err_destroy:
463 free(mi_writer);
464 return NULL;
465 }
466
467 LTTNG_HIDDEN
468 int mi_lttng_writer_destroy(struct mi_writer *writer)
469 {
470 int ret;
471
472 if (!writer) {
473 ret = -EINVAL;
474 goto end;
475 }
476
477 ret = config_writer_destroy(writer->writer);
478 if (ret < 0) {
479 goto end;
480 }
481
482 free(writer);
483 end:
484 return ret;
485 }
486
487 LTTNG_HIDDEN
488 int mi_lttng_writer_command_open(struct mi_writer *writer, const char *command)
489 {
490 int ret;
491
492 /*
493 * A command is always the MI's root node, it must declare the current
494 * namespace and schema URIs and the schema's version.
495 */
496 ret = config_writer_open_element(writer->writer,
497 mi_lttng_element_command);
498 if (ret) {
499 goto end;
500 }
501
502 ret = config_writer_write_attribute(writer->writer,
503 mi_lttng_xmlns, DEFAULT_LTTNG_MI_NAMESPACE);
504 if (ret) {
505 goto end;
506 }
507
508 ret = config_writer_write_attribute(writer->writer,
509 mi_lttng_xmlns_xsi, mi_lttng_w3_schema_uri);
510 if (ret) {
511 goto end;
512 }
513
514 ret = config_writer_write_attribute(writer->writer,
515 mi_lttng_schema_location,
516 mi_lttng_schema_location_uri);
517 if (ret) {
518 goto end;
519 }
520
521 ret = config_writer_write_attribute(writer->writer,
522 mi_lttng_schema_version,
523 mi_lttng_schema_version_value);
524 if (ret) {
525 goto end;
526 }
527
528 ret = mi_lttng_writer_write_element_string(writer,
529 mi_lttng_element_command_name, command);
530 end:
531 return ret;
532 }
533
534 LTTNG_HIDDEN
535 int mi_lttng_writer_command_close(struct mi_writer *writer)
536 {
537 return mi_lttng_writer_close_element(writer);
538 }
539
540 LTTNG_HIDDEN
541 int mi_lttng_writer_open_element(struct mi_writer *writer,
542 const char *element_name)
543 {
544 return config_writer_open_element(writer->writer, element_name);
545 }
546
547 LTTNG_HIDDEN
548 int mi_lttng_writer_close_element(struct mi_writer *writer)
549 {
550 return config_writer_close_element(writer->writer);
551 }
552
553 LTTNG_HIDDEN
554 int mi_lttng_close_multi_element(struct mi_writer *writer,
555 unsigned int nb_element)
556 {
557 int ret, i;
558
559 if (nb_element < 1) {
560 ret = 0;
561 goto end;
562 }
563 for (i = 0; i < nb_element; i++) {
564 ret = mi_lttng_writer_close_element(writer);
565 if (ret) {
566 goto end;
567 }
568 }
569 end:
570 return ret;
571 }
572
573 LTTNG_HIDDEN
574 int mi_lttng_writer_write_element_unsigned_int(struct mi_writer *writer,
575 const char *element_name, uint64_t value)
576 {
577 return config_writer_write_element_unsigned_int(writer->writer,
578 element_name, value);
579 }
580
581 LTTNG_HIDDEN
582 int mi_lttng_writer_write_element_signed_int(struct mi_writer *writer,
583 const char *element_name, int64_t value)
584 {
585 return config_writer_write_element_signed_int(writer->writer,
586 element_name, value);
587 }
588
589 LTTNG_HIDDEN
590 int mi_lttng_writer_write_element_bool(struct mi_writer *writer,
591 const char *element_name, int value)
592 {
593 return config_writer_write_element_bool(writer->writer,
594 element_name, value);
595 }
596
597 LTTNG_HIDDEN
598 int mi_lttng_writer_write_element_string(struct mi_writer *writer,
599 const char *element_name, const char *value)
600 {
601 return config_writer_write_element_string(writer->writer,
602 element_name, value);
603 }
604
605 LTTNG_HIDDEN
606 int mi_lttng_version(struct mi_writer *writer, struct mi_lttng_version *version,
607 const char *lttng_description, const char *lttng_license)
608 {
609 int ret;
610
611 /* Open version */
612 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_version);
613 if (ret) {
614 goto end;
615 }
616
617 /* Version string (contain info like rc etc.) */
618 ret = mi_lttng_writer_write_element_string(writer,
619 mi_lttng_element_version_str, version->version);
620 if (ret) {
621 goto end;
622 }
623
624 /* Major version number */
625 ret = mi_lttng_writer_write_element_unsigned_int(writer,
626 mi_lttng_element_version_major, version->version_major);
627 if (ret) {
628 goto end;
629 }
630
631 /* Minor version number */
632 ret = mi_lttng_writer_write_element_unsigned_int(writer,
633 mi_lttng_element_version_minor, version->version_minor);
634 if (ret) {
635 goto end;
636 }
637
638 /* Commit version number */
639 ret = mi_lttng_writer_write_element_string(writer,
640 mi_lttng_element_version_commit, version->version_commit);
641 if (ret) {
642 goto end;
643 }
644
645 /* Patch number */
646 ret = mi_lttng_writer_write_element_unsigned_int(writer,
647 mi_lttng_element_version_patch_level, version->version_patchlevel);
648 if (ret) {
649 goto end;
650 }
651
652 /* Name of the version */
653 ret = mi_lttng_writer_write_element_string(writer,
654 config_element_name, version->version_name);
655 if (ret) {
656 goto end;
657 }
658
659 /* Description mostly related to beer... */
660 ret = mi_lttng_writer_write_element_string(writer,
661 mi_lttng_element_version_description, lttng_description);
662 if (ret) {
663 goto end;
664 }
665
666 /* url */
667 ret = mi_lttng_writer_write_element_string(writer,
668 mi_lttng_element_version_web, version->package_url);
669 if (ret) {
670 goto end;
671 }
672
673 /* License: free as in free beer...no...*speech* */
674 ret = mi_lttng_writer_write_element_string(writer,
675 mi_lttng_element_version_license, lttng_license);
676 if (ret) {
677 goto end;
678 }
679
680 /* Close version element */
681 ret = mi_lttng_writer_close_element(writer);
682
683 end:
684 return ret;
685 }
686
687 LTTNG_HIDDEN
688 int mi_lttng_sessions_open(struct mi_writer *writer)
689 {
690 return mi_lttng_writer_open_element(writer, config_element_sessions);
691 }
692
693 LTTNG_HIDDEN
694 int mi_lttng_session(struct mi_writer *writer,
695 struct lttng_session *session, int is_open)
696 {
697 int ret;
698
699 assert(session);
700
701 /* Open sessions element */
702 ret = mi_lttng_writer_open_element(writer,
703 config_element_session);
704 if (ret) {
705 goto end;
706 }
707
708 /* Name of the session */
709 ret = mi_lttng_writer_write_element_string(writer,
710 config_element_name, session->name);
711 if (ret) {
712 goto end;
713 }
714
715 /* Path */
716 ret = mi_lttng_writer_write_element_string(writer,
717 config_element_path, session->path);
718 if (ret) {
719 goto end;
720 }
721
722 /* Enabled ? */
723 ret = mi_lttng_writer_write_element_bool(writer,
724 config_element_enabled, session->enabled);
725 if (ret) {
726 goto end;
727 }
728
729 /* Snapshot mode */
730 ret = mi_lttng_writer_write_element_unsigned_int(writer,
731 config_element_snapshot_mode, session->snapshot_mode);
732 if (ret) {
733 goto end;
734 }
735
736 /* Live timer interval in usec */
737 ret = mi_lttng_writer_write_element_unsigned_int(writer,
738 config_element_live_timer_interval,
739 session->live_timer_interval);
740 if (ret) {
741 goto end;
742 }
743
744 if (!is_open) {
745 /* Closing session element */
746 ret = mi_lttng_writer_close_element(writer);
747 }
748 end:
749 return ret;
750
751 }
752
753 LTTNG_HIDDEN
754 int mi_lttng_domains_open(struct mi_writer *writer)
755 {
756 return mi_lttng_writer_open_element(writer, config_element_domains);
757 }
758
759 LTTNG_HIDDEN
760 int mi_lttng_domain(struct mi_writer *writer,
761 struct lttng_domain *domain, int is_open)
762 {
763 int ret = 0;
764 const char *str_domain;
765 const char *str_buffer;
766
767 assert(domain);
768
769 /* Open domain element */
770 ret = mi_lttng_writer_open_element(writer, config_element_domain);
771 if (ret) {
772 goto end;
773 }
774
775 /* Domain Type */
776 str_domain = mi_lttng_domaintype_string(domain->type);
777 ret = mi_lttng_writer_write_element_string(writer, config_element_type,
778 str_domain);
779 if (ret) {
780 goto end;
781 }
782
783 /* Buffer Type */
784 str_buffer= mi_lttng_buffertype_string(domain->buf_type);
785 ret = mi_lttng_writer_write_element_string(writer,
786 config_element_buffer_type, str_buffer);
787 if (ret) {
788 goto end;
789 }
790
791 /* TODO: union attr
792 * This union is not currently used and was added for
793 * future ust domain support.
794 * Date: 25-06-2014
795 * */
796
797 if (!is_open) {
798 /* Closing domain element */
799 ret = mi_lttng_writer_close_element(writer);
800 }
801
802 end:
803 return ret;
804
805 }
806
807 LTTNG_HIDDEN
808 int mi_lttng_channels_open(struct mi_writer *writer)
809 {
810 return mi_lttng_writer_open_element(writer, config_element_channels);
811 }
812
813 LTTNG_HIDDEN
814 int mi_lttng_channel(struct mi_writer *writer,
815 struct lttng_channel *channel, int is_open)
816 {
817 int ret = 0;
818
819 assert(channel);
820
821 /* Opening channel element */
822 ret = mi_lttng_writer_open_element(writer, config_element_channel);
823 if (ret) {
824 goto end;
825 }
826
827 /* Name */
828 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
829 channel->name);
830 if (ret) {
831 goto end;
832 }
833
834 /* Enabled ? */
835 ret = mi_lttng_writer_write_element_bool(writer,
836 config_element_enabled, channel->enabled);
837 if (ret) {
838 goto end;
839 }
840
841 /* Attribute */
842 ret = mi_lttng_channel_attr(writer, &channel->attr);
843 if (ret) {
844 goto end;
845 }
846
847 if (!is_open) {
848 /* Closing channel element */
849 ret = mi_lttng_writer_close_element(writer);
850 if (ret) {
851 goto end;
852 }
853 }
854 end:
855 return ret;
856 }
857
858 LTTNG_HIDDEN
859 int mi_lttng_channel_attr(struct mi_writer *writer,
860 struct lttng_channel_attr *attr)
861 {
862 int ret = 0;
863 struct lttng_channel *chan = caa_container_of(attr,
864 struct lttng_channel, attr);
865 uint64_t discarded_events, lost_packets, monitor_timer_interval;
866
867 assert(attr);
868
869 ret = lttng_channel_get_discarded_event_count(chan, &discarded_events);
870 if (ret) {
871 goto end;
872 }
873
874 ret = lttng_channel_get_lost_packet_count(chan, &lost_packets);
875 if (ret) {
876 goto end;
877 }
878
879 ret = lttng_channel_get_monitor_timer_interval(chan,
880 &monitor_timer_interval);
881 if (ret) {
882 goto end;
883 }
884
885 /* Opening Attributes */
886 ret = mi_lttng_writer_open_element(writer, config_element_attributes);
887 if (ret) {
888 goto end;
889 }
890
891 /* Overwrite */
892 ret = mi_lttng_writer_write_element_string(writer,
893 config_element_overwrite_mode,
894 attr->overwrite ? config_overwrite_mode_overwrite :
895 config_overwrite_mode_discard);
896 if (ret) {
897 goto end;
898 }
899
900 /* Sub buffer size in byte */
901 ret = mi_lttng_writer_write_element_unsigned_int(writer,
902 config_element_subbuf_size, attr->subbuf_size);
903 if (ret) {
904 goto end;
905 }
906
907 /* Number of subbuffer (power of two) */
908 ret = mi_lttng_writer_write_element_unsigned_int(writer,
909 config_element_num_subbuf,
910 attr->num_subbuf);
911 if (ret) {
912 goto end;
913 }
914
915 /* Switch timer interval in usec */
916 ret = mi_lttng_writer_write_element_unsigned_int(writer,
917 config_element_switch_timer_interval,
918 attr->switch_timer_interval);
919 if (ret) {
920 goto end;
921 }
922
923 /* Read timer interval in usec */
924 ret = mi_lttng_writer_write_element_unsigned_int(writer,
925 config_element_read_timer_interval,
926 attr->read_timer_interval);
927 if (ret) {
928 goto end;
929 }
930
931 /* Monitor timer interval in usec */
932 ret = mi_lttng_writer_write_element_unsigned_int(writer,
933 config_element_monitor_timer_interval,
934 monitor_timer_interval);
935 if (ret) {
936 goto end;
937 }
938
939 /* Event output */
940 ret = mi_lttng_writer_write_element_string(writer,
941 config_element_output_type,
942 attr->output == LTTNG_EVENT_SPLICE ?
943 config_output_type_splice : config_output_type_mmap);
944 if (ret) {
945 goto end;
946 }
947
948 /* Tracefile size in bytes */
949 ret = mi_lttng_writer_write_element_unsigned_int(writer,
950 config_element_tracefile_size, attr->tracefile_size);
951 if (ret) {
952 goto end;
953 }
954
955 /* Count of tracefiles */
956 ret = mi_lttng_writer_write_element_unsigned_int(writer,
957 config_element_tracefile_count,
958 attr->tracefile_count);
959 if (ret) {
960 goto end;
961 }
962
963 /* Live timer interval in usec*/
964 ret = mi_lttng_writer_write_element_unsigned_int(writer,
965 config_element_live_timer_interval,
966 attr->live_timer_interval);
967 if (ret) {
968 goto end;
969 }
970
971 /* Discarded events */
972 ret = mi_lttng_writer_write_element_unsigned_int(writer,
973 config_element_discarded_events,
974 discarded_events);
975 if (ret) {
976 goto end;
977 }
978
979 /* Lost packets */
980 ret = mi_lttng_writer_write_element_unsigned_int(writer,
981 config_element_lost_packets,
982 lost_packets);
983 if (ret) {
984 goto end;
985 }
986
987 /* Closing attributes */
988 ret = mi_lttng_writer_close_element(writer);
989 if (ret) {
990 goto end;
991 }
992 end:
993 return ret;
994
995 }
996
997 LTTNG_HIDDEN
998 int mi_lttng_event_common_attributes(struct mi_writer *writer,
999 struct lttng_event *event)
1000 {
1001 int ret;
1002 const char *filter_expression;
1003
1004 /* Open event element */
1005 ret = mi_lttng_writer_open_element(writer, config_element_event);
1006 if (ret) {
1007 goto end;
1008 }
1009
1010 /* Event name */
1011 ret = mi_lttng_writer_write_element_string(writer,
1012 config_element_name, event->name);
1013 if (ret) {
1014 goto end;
1015 }
1016
1017 /* Event type */
1018 ret = mi_lttng_writer_write_element_string(writer,
1019 config_element_type, mi_lttng_eventtype_string(event->type));
1020 if (ret) {
1021 goto end;
1022 }
1023
1024 /* Is event enabled */
1025 ret = mi_lttng_writer_write_element_bool(writer,
1026 config_element_enabled, event->enabled);
1027 if (ret) {
1028 goto end;
1029 }
1030
1031 /* Event filter expression */
1032 ret = lttng_event_get_filter_expression(event, &filter_expression);
1033 if (ret) {
1034 goto end;
1035 }
1036
1037 if (filter_expression) {
1038 ret = mi_lttng_writer_write_element_string(writer,
1039 config_element_filter_expression,
1040 filter_expression);
1041 if (ret) {
1042 goto end;
1043 }
1044 }
1045
1046 end:
1047 return ret;
1048 }
1049
1050 static int write_event_exclusions(struct mi_writer *writer,
1051 struct lttng_event *event)
1052 {
1053 int i;
1054 int ret;
1055 int exclusion_count;
1056
1057 /* Open event exclusions */
1058 ret = mi_lttng_writer_open_element(writer, config_element_exclusions);
1059 if (ret) {
1060 goto end;
1061 }
1062
1063 exclusion_count = lttng_event_get_exclusion_name_count(event);
1064 if (exclusion_count < 0) {
1065 ret = exclusion_count;
1066 goto end;
1067 }
1068
1069 for (i = 0; i < exclusion_count; i++) {
1070 const char *name;
1071
1072 ret = lttng_event_get_exclusion_name(event, i, &name);
1073 if (ret) {
1074 /* Close exclusions */
1075 mi_lttng_writer_close_element(writer);
1076 goto end;
1077 }
1078
1079 ret = mi_lttng_writer_write_element_string(writer,
1080 config_element_exclusion, name);
1081 if (ret) {
1082 /* Close exclusions */
1083 mi_lttng_writer_close_element(writer);
1084 goto end;
1085 }
1086 }
1087
1088 /* Close exclusions */
1089 ret = mi_lttng_writer_close_element(writer);
1090
1091 end:
1092 return ret;
1093 }
1094
1095 LTTNG_HIDDEN
1096 int mi_lttng_event_tracepoint_loglevel(struct mi_writer *writer,
1097 struct lttng_event *event, enum lttng_domain_type domain)
1098 {
1099 int ret;
1100
1101 /* Event loglevel */
1102 ret = mi_lttng_writer_write_element_string(writer,
1103 config_element_loglevel,
1104 mi_lttng_loglevel_string(event->loglevel, domain));
1105 if (ret) {
1106 goto end;
1107 }
1108
1109 /* Log level type */
1110 ret = mi_lttng_writer_write_element_string(writer,
1111 config_element_loglevel_type,
1112 mi_lttng_logleveltype_string(event->loglevel_type));
1113 if (ret) {
1114 goto end;
1115 }
1116
1117 /* Event exclusions */
1118 ret = write_event_exclusions(writer, event);
1119
1120 end:
1121 return ret;
1122 }
1123
1124 LTTNG_HIDDEN
1125 int mi_lttng_event_tracepoint_no_loglevel(struct mi_writer *writer,
1126 struct lttng_event *event)
1127 {
1128 /* event exclusion filter */
1129 return write_event_exclusions(writer, event);
1130 }
1131
1132 LTTNG_HIDDEN
1133 int mi_lttng_event_function_probe(struct mi_writer *writer,
1134 struct lttng_event *event)
1135 {
1136 int ret;
1137
1138 ret = mi_lttng_writer_open_element(writer, config_element_attributes);
1139 if (ret) {
1140 goto end;
1141 }
1142
1143 ret = mi_lttng_writer_open_element(writer, config_element_probe_attributes);
1144 if (ret) {
1145 goto end;
1146 }
1147
1148 if (event->attr.probe.addr != 0) {
1149 /* event probe address */
1150 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1151 config_element_address, event->attr.probe.addr);
1152 if (ret) {
1153 goto end;
1154 }
1155 } else {
1156 /* event probe offset */
1157 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1158 config_element_offset, event->attr.probe.offset);
1159 if (ret) {
1160 goto end;
1161 }
1162
1163 /* event probe symbol_name */
1164 ret = mi_lttng_writer_write_element_string(writer,
1165 config_element_symbol_name, event->attr.probe.symbol_name);
1166 if (ret) {
1167 goto end;
1168 }
1169 }
1170
1171 /* Close probe_attributes and attributes */
1172 ret = mi_lttng_close_multi_element(writer, 2);
1173 end:
1174 return ret;
1175 }
1176
1177 LTTNG_HIDDEN
1178 int mi_lttng_event_function_entry(struct mi_writer *writer,
1179 struct lttng_event *event)
1180 {
1181 int ret;
1182
1183 ret = mi_lttng_writer_open_element(writer, config_element_attributes);
1184 if (ret) {
1185 goto end;
1186 }
1187
1188 ret = mi_lttng_writer_open_element(writer, config_element_probe_attributes);
1189 if (ret) {
1190 goto end;
1191 }
1192
1193 /* event probe symbol_name */
1194 ret = mi_lttng_writer_write_element_string(writer,
1195 config_element_symbol_name, event->attr.ftrace.symbol_name);
1196 if (ret) {
1197 goto end;
1198 }
1199
1200 /* Close function_attributes and attributes */
1201 ret = mi_lttng_close_multi_element(writer, 2);
1202 end:
1203 return ret;
1204 }
1205
1206 LTTNG_HIDDEN
1207 int mi_lttng_events_open(struct mi_writer *writer)
1208 {
1209 return mi_lttng_writer_open_element(writer, config_element_events);
1210 }
1211
1212 LTTNG_HIDDEN
1213 int mi_lttng_event(struct mi_writer *writer,
1214 struct lttng_event *event, int is_open, enum lttng_domain_type domain)
1215 {
1216 int ret;
1217
1218 ret = mi_lttng_event_common_attributes(writer, event);
1219 if (ret) {
1220 goto end;
1221 }
1222
1223 switch (event->type) {
1224 case LTTNG_EVENT_TRACEPOINT:
1225 {
1226 if (event->loglevel != -1) {
1227 ret = mi_lttng_event_tracepoint_loglevel(writer, event, domain);
1228 } else {
1229 ret = mi_lttng_event_tracepoint_no_loglevel(writer, event);
1230 }
1231 break;
1232 }
1233 case LTTNG_EVENT_FUNCTION:
1234 /* Fallthrough */
1235 case LTTNG_EVENT_PROBE:
1236 ret = mi_lttng_event_function_probe(writer, event);
1237 break;
1238 case LTTNG_EVENT_FUNCTION_ENTRY:
1239 ret = mi_lttng_event_function_entry(writer, event);
1240 break;
1241 case LTTNG_EVENT_ALL:
1242 /* Fallthrough */
1243 default:
1244 break;
1245 }
1246
1247 if (!is_open) {
1248 ret = mi_lttng_writer_close_element(writer);
1249 }
1250
1251 end:
1252 return ret;
1253 }
1254
1255 LTTNG_HIDDEN
1256 int mi_lttng_trackers_open(struct mi_writer *writer)
1257 {
1258 return mi_lttng_writer_open_element(writer, config_element_trackers);
1259 }
1260
1261 LTTNG_HIDDEN
1262 int mi_lttng_pid_tracker_open(struct mi_writer *writer)
1263 {
1264 int ret;
1265
1266 /* Open element pid_tracker */
1267 ret = mi_lttng_writer_open_element(writer, config_element_pid_tracker);
1268 if (ret) {
1269 goto end;
1270 }
1271
1272 /* Open targets element */
1273 ret = mi_lttng_targets_open(writer);
1274 end:
1275 return ret;
1276 }
1277
1278 LTTNG_HIDDEN
1279 int mi_lttng_pids_open(struct mi_writer *writer)
1280 {
1281 return mi_lttng_writer_open_element(writer, config_element_pids);
1282 }
1283
1284 /*
1285 * TODO: move the listing of pid for user agent to process semantic on
1286 * mi api bump. The use of process element break the mi api.
1287 */
1288 LTTNG_HIDDEN
1289 int mi_lttng_pid(struct mi_writer *writer, pid_t pid , const char *name,
1290 int is_open)
1291 {
1292 int ret;
1293
1294 /* Open pid process */
1295 ret = mi_lttng_writer_open_element(writer, config_element_pid);
1296 if (ret) {
1297 goto end;
1298 }
1299
1300 /* Writing pid number */
1301 ret = mi_lttng_writer_write_element_signed_int(writer,
1302 mi_lttng_element_pid_id, (int)pid);
1303 if (ret) {
1304 goto end;
1305 }
1306
1307 /* Writing name of the process */
1308 if (name) {
1309 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1310 name);
1311 if (ret) {
1312 goto end;
1313 }
1314 }
1315
1316 if (!is_open) {
1317 /* Closing Pid */
1318 ret = mi_lttng_writer_close_element(writer);
1319 }
1320
1321 end:
1322 return ret;
1323 }
1324
1325 LTTNG_HIDDEN
1326 int mi_lttng_targets_open(struct mi_writer *writer)
1327 {
1328 return mi_lttng_writer_open_element(writer,
1329 config_element_targets);
1330 }
1331
1332 LTTNG_HIDDEN
1333 int mi_lttng_pid_target(struct mi_writer *writer, pid_t pid, int is_open)
1334 {
1335 int ret;
1336
1337 ret = mi_lttng_writer_open_element(writer,
1338 config_element_target_pid);
1339 if (ret) {
1340 goto end;
1341 }
1342
1343 /* Writing pid number
1344 * Special case for element all on track untrack command
1345 * All pid is represented as wildcard *
1346 */
1347 if ((int) pid == -1) {
1348 ret = mi_lttng_writer_write_element_string(writer,
1349 config_element_pid,
1350 mi_lttng_element_track_untrack_all_wildcard);
1351 } else {
1352 ret = mi_lttng_writer_write_element_signed_int(writer,
1353 config_element_pid, (int) pid);
1354 }
1355 if (ret) {
1356 goto end;
1357 }
1358
1359 if (!is_open) {
1360 ret = mi_lttng_writer_close_element(writer);
1361 if (ret) {
1362 goto end;
1363 }
1364 }
1365
1366 end:
1367 return ret;
1368 }
1369
1370 LTTNG_HIDDEN
1371 int mi_lttng_event_fields_open(struct mi_writer *writer)
1372 {
1373 return mi_lttng_writer_open_element(writer, mi_lttng_element_event_fields);
1374 }
1375
1376 LTTNG_HIDDEN
1377 int mi_lttng_event_field(struct mi_writer *writer,
1378 struct lttng_event_field *field)
1379 {
1380 int ret;
1381
1382 if (!field->field_name[0]) {
1383 ret = 0;
1384 goto end;
1385 }
1386
1387 /* Open field */
1388 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_field);
1389 if (ret) {
1390 goto end;
1391 }
1392
1393 if (!field->field_name[0]) {
1394 goto close;
1395 }
1396
1397 /* Name */
1398 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1399 field->field_name);
1400 if (ret) {
1401 goto end;
1402 }
1403
1404 /* Type */
1405 ret = mi_lttng_writer_write_element_string(writer, config_element_type,
1406 mi_lttng_eventfieldtype_string(field->type));
1407 if (ret) {
1408 goto end;
1409 }
1410
1411 /* nowrite */
1412 ret = mi_lttng_writer_write_element_signed_int(writer,
1413 mi_lttng_element_nowrite, field->nowrite);
1414 if (ret) {
1415 goto end;
1416 }
1417
1418 close:
1419 /* Close field element */
1420 ret = mi_lttng_writer_close_element(writer);
1421
1422 end:
1423 return ret;
1424 }
1425
1426 LTTNG_HIDDEN
1427 int mi_lttng_perf_counter_context(struct mi_writer *writer,
1428 struct lttng_event_perf_counter_ctx *perf_context)
1429 {
1430 int ret;
1431
1432 /* Open perf_counter_context */
1433 ret = mi_lttng_writer_open_element(writer,
1434 mi_lttng_element_perf_counter_context);
1435 if (ret) {
1436 goto end;
1437 }
1438
1439 /* Type */
1440 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1441 config_element_type, perf_context->type);
1442 if (ret) {
1443 goto end;
1444 }
1445
1446 /* Config */
1447 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1448 config_element_config, perf_context->config);
1449 if (ret) {
1450 goto end;
1451 }
1452
1453 /* Name of the perf counter */
1454 ret = mi_lttng_writer_write_element_string(writer,
1455 config_element_name, perf_context->name);
1456 if (ret) {
1457 goto end;
1458 }
1459
1460 /* Close perf_counter_context */
1461 ret = mi_lttng_writer_close_element(writer);
1462 end:
1463 return ret;
1464 }
1465
1466 static
1467 int mi_lttng_app_context(struct mi_writer *writer,
1468 const char *provider_name, const char *ctx_name)
1469 {
1470 int ret;
1471
1472 /* Open app */
1473 ret = mi_lttng_writer_open_element(writer,
1474 config_element_context_app);
1475 if (ret) {
1476 goto end;
1477 }
1478
1479 /* provider_name */
1480 ret = mi_lttng_writer_write_element_string(writer,
1481 config_element_context_app_provider_name,
1482 provider_name);
1483 if (ret) {
1484 goto end;
1485 }
1486
1487 /* ctx_name */
1488 ret = mi_lttng_writer_write_element_string(writer,
1489 config_element_context_app_ctx_name, ctx_name);
1490 if (ret) {
1491 goto end;
1492 }
1493
1494 /* Close app */
1495 ret = mi_lttng_writer_close_element(writer);
1496 end:
1497 return ret;
1498 }
1499
1500 LTTNG_HIDDEN
1501 int mi_lttng_context(struct mi_writer *writer,
1502 struct lttng_event_context *context, int is_open)
1503 {
1504 int ret;
1505
1506 /* Open context */
1507 ret = mi_lttng_writer_open_element(writer , config_element_context);
1508 if (ret) {
1509 goto end;
1510 }
1511
1512 /* Special case for PERF_*_COUNTER
1513 * print the lttng_event_perf_counter_ctx*/
1514 switch (context->ctx) {
1515 case LTTNG_EVENT_CONTEXT_PERF_COUNTER:
1516 case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER:
1517 case LTTNG_EVENT_CONTEXT_PERF_CPU_COUNTER:
1518 {
1519 struct lttng_event_perf_counter_ctx *perf_context =
1520 &context->u.perf_counter;
1521 ret = mi_lttng_perf_counter_context(writer, perf_context);
1522 if (ret) {
1523 goto end;
1524 }
1525 break;
1526 }
1527 case LTTNG_EVENT_CONTEXT_APP_CONTEXT:
1528 {
1529 ret = mi_lttng_app_context(writer,
1530 context->u.app_ctx.provider_name,
1531 context->u.app_ctx.ctx_name);
1532 if (ret) {
1533 goto end;
1534 }
1535 break;
1536 }
1537 default:
1538 {
1539 const char *type_string = mi_lttng_event_contexttype_string(
1540 context->ctx);
1541 if (!type_string) {
1542 ret = -LTTNG_ERR_INVALID;
1543 goto end;
1544 }
1545
1546 /* Print context type */
1547 ret = mi_lttng_writer_write_element_string(writer,
1548 config_element_type, type_string);
1549 break;
1550 }
1551 }
1552
1553 /* Close context */
1554 if (!is_open) {
1555 ret = mi_lttng_writer_close_element(writer);
1556 }
1557
1558 end:
1559 return ret;
1560 }
1561
1562 LTTNG_HIDDEN
1563 int mi_lttng_snapshot_output_session_name(struct mi_writer *writer,
1564 const char *session_name)
1565 {
1566 int ret;
1567
1568 /* Open session element */
1569 ret = mi_lttng_writer_open_element(writer, config_element_session);
1570 if (ret) {
1571 goto end;
1572 }
1573
1574 /* Snapshot output list for current session name */
1575 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1576 session_name);
1577 if (ret) {
1578 goto end;
1579 }
1580
1581 /* Open element snapshots (sequence one snapshot) */
1582 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_snapshots);
1583 if (ret) {
1584 goto end;
1585 }
1586
1587 end:
1588 return ret;
1589 }
1590
1591 LTTNG_HIDDEN
1592 int mi_lttng_snapshot_list_output(struct mi_writer *writer,
1593 struct lttng_snapshot_output *output)
1594 {
1595 int ret;
1596
1597 /* Open element snapshot output */
1598 ret = mi_lttng_writer_open_element(writer,
1599 mi_lttng_element_command_snapshot);
1600 if (ret) {
1601 goto end;
1602 }
1603
1604 /* ID of the snapshot output */
1605 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1606 mi_lttng_element_id, output->id);
1607 if (ret) {
1608 goto end;
1609 }
1610
1611 /* Name of the output */
1612 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1613 output->name);
1614 if (ret) {
1615 goto end;
1616 }
1617
1618 /* Destination of the output (ctrl_url)*/
1619 ret = mi_lttng_writer_write_element_string(writer,
1620 mi_lttng_element_snapshot_ctrl_url, output->ctrl_url);
1621 if (ret) {
1622 goto end;
1623 }
1624
1625 /* Destination of the output (data_url) */
1626 ret = mi_lttng_writer_write_element_string(writer,
1627 mi_lttng_element_snapshot_data_url, output->data_url);
1628 if (ret) {
1629 goto end;
1630 }
1631
1632 /* total size of all stream combined */
1633 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1634 mi_lttng_element_snapshot_max_size, output->max_size);
1635 if (ret) {
1636 goto end;
1637 }
1638
1639 /* Close snapshot output element */
1640 ret = mi_lttng_writer_close_element(writer);
1641
1642 end:
1643 return ret;
1644 }
1645
1646 LTTNG_HIDDEN
1647 int mi_lttng_snapshot_del_output(struct mi_writer *writer, int id,
1648 const char *name, const char *current_session_name)
1649 {
1650 int ret;
1651
1652 /* Open element del_snapshot */
1653 ret = mi_lttng_writer_open_element(writer,
1654 mi_lttng_element_command_snapshot);
1655 if (ret) {
1656 goto end;
1657 }
1658
1659
1660 if (id != UINT32_MAX) {
1661 /* "Snapshot output "id" successfully deleted
1662 * for "current_session_name"
1663 * ID of the snapshot output
1664 */
1665 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1666 mi_lttng_element_id, id);
1667 if (ret) {
1668 goto end;
1669 }
1670 } else {
1671 /* "Snapshot output "name" successfully deleted
1672 * for session "current_session_name"
1673 * Name of the output
1674 */
1675 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
1676 name);
1677 if (ret) {
1678 goto end;
1679 }
1680 }
1681
1682 /* Snapshot was deleted for session "current_session_name"*/
1683 ret = mi_lttng_writer_write_element_string(writer,
1684 mi_lttng_element_snapshot_session_name,
1685 current_session_name);
1686 if (ret) {
1687 goto end;
1688 }
1689
1690 /* Close snapshot element */
1691 ret = mi_lttng_writer_close_element(writer);
1692
1693 end:
1694 return ret;
1695 }
1696
1697 LTTNG_HIDDEN
1698 int mi_lttng_snapshot_add_output(struct mi_writer *writer,
1699 const char *current_session_name, const char *n_ptr,
1700 struct lttng_snapshot_output *output)
1701 {
1702 int ret;
1703
1704 /* Open element snapshot */
1705 ret = mi_lttng_writer_open_element(writer,
1706 mi_lttng_element_command_snapshot);
1707 if (ret) {
1708 goto end;
1709 }
1710
1711 /* Snapshot output id */
1712 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1713 mi_lttng_element_id, output->id);
1714 if (ret) {
1715 goto end;
1716 }
1717
1718 /* Snapshot output names */
1719 ret = mi_lttng_writer_write_element_string(writer,
1720 config_element_name, n_ptr);
1721 if (ret) {
1722 goto end;
1723 }
1724
1725 /* Destination of the output (ctrl_url)*/
1726 ret = mi_lttng_writer_write_element_string(writer,
1727 mi_lttng_element_snapshot_ctrl_url, output->ctrl_url);
1728 if (ret) {
1729 goto end;
1730 }
1731
1732 /* Snapshot added for session "current_session_name"*/
1733 ret = mi_lttng_writer_write_element_string(writer,
1734 mi_lttng_element_snapshot_session_name, current_session_name);
1735 if (ret) {
1736 goto end;
1737 }
1738
1739 /* total size of all stream combined */
1740 ret = mi_lttng_writer_write_element_unsigned_int(writer,
1741 mi_lttng_element_snapshot_max_size, output->max_size);
1742 if (ret) {
1743 goto end;
1744 }
1745
1746 /* Close snapshot element */
1747 ret = mi_lttng_writer_close_element(writer);
1748
1749 end:
1750 return ret;
1751 }
1752
1753 LTTNG_HIDDEN
1754 int mi_lttng_snapshot_record(struct mi_writer *writer,
1755 const char *current_session_name, const char *url,
1756 const char *cmdline_ctrl_url, const char *cmdline_data_url)
1757 {
1758 int ret;
1759
1760 /* Open element snapshot */
1761 ret = mi_lttng_writer_open_element(writer,
1762 mi_lttng_element_command_snapshot);
1763 if (ret) {
1764 goto end;
1765 }
1766
1767 /*
1768 * If a valid an URL was given, serialize it,
1769 * else take the command line data and ctrl urls*/
1770 if (url) {
1771 /* Destination of the output (ctrl_url)*/
1772 ret = mi_lttng_writer_write_element_string(writer,
1773 mi_lttng_element_snapshot_ctrl_url, url);
1774 if (ret) {
1775 goto end;
1776 }
1777 } else if (cmdline_ctrl_url) {
1778 /* Destination of the output (ctrl_url)*/
1779 ret = mi_lttng_writer_write_element_string(writer,
1780 mi_lttng_element_snapshot_ctrl_url, cmdline_ctrl_url);
1781 if (ret) {
1782 goto end;
1783 }
1784
1785 /* Destination of the output (data_url) */
1786 ret = mi_lttng_writer_write_element_string(writer,
1787 mi_lttng_element_snapshot_data_url, cmdline_data_url);
1788 if (ret) {
1789 goto end;
1790 }
1791 }
1792
1793 /* Close record_snapshot element */
1794 ret = mi_lttng_writer_close_element(writer);
1795
1796 end:
1797 return ret;
1798 }
This page took 0.11055 seconds and 4 git commands to generate.