projects / lttng-tools.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Mi create command: support and validation
[lttng-tools.git] / src / common / mi-lttng.c
CommitLineData
c7e35b03
JR		 1/*
2 * Copyright (C) 2014 - Jonathan Rajotte <jonathan.r.julien@gmail.com>
3 * - Olivier Cotte <olivier.cotte@polymtl.ca>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License, version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 51
16 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
5e18ec73 19
c7e35b03
JR		 20#include <include/config.h>
21#include <common/config/config.h>
c7e35b03
JR		 22#include "mi-lttng.h"
23
5e18ec73
JR		 24#include <assert.h>
25
c7e35b03
JR		 26/* Strings related to command */
27const char * const mi_lttng_element_command = "command";
37d03ff7 28const char * const mi_lttng_element_command_name = "name";
c7e35b03
JR		 29const char * const mi_lttng_element_command_version = "version";
30const char * const mi_lttng_element_command_list = "list";
1734c658
JRJ		 31const char * const mi_lttng_element_command_save = "save";
32const char * const mi_lttng_element_command_load = "load";
1cfc0bc8 33const char * const mi_lttng_element_command_start = "start";
e5b83100 34const char * const mi_lttng_element_command_stop = "stop";
37d03ff7 35const char * const mi_lttng_element_command_create = "create";
c7e35b03 36const char * const mi_lttng_element_command_output = "output";
1734c658 37const char * const mi_lttng_element_command_success = "success";
c7e35b03 38
1734c658 39/* Strings related to version command */
c7e35b03
JR		 40const char * const mi_lttng_element_version = "version";
41const char * const mi_lttng_element_version_str = "string";
42const char * const mi_lttng_element_version_web = "url";
43const char * const mi_lttng_element_version_major = "major";
44const char * const mi_lttng_element_version_minor = "minor";
314d5222 45const char * const mi_lttng_element_version_commit = "commit";
c7e35b03
JR		 46const char * const mi_lttng_element_version_license = "license";
47const char * const mi_lttng_element_version_patch_level = "patchLevel";
48const char * const mi_lttng_element_version_description = "description";
49
5e18ec73
JR		 50/* Strings related to pid */
51const char * const mi_lttng_element_pids = "pids";
52const char * const mi_lttng_element_pid = "pid";
53const char * const mi_lttng_element_pid_id = "id";
54
1734c658
JRJ		 55/* Strings related to save command */
56const char * const mi_lttng_element_save = "save";
57
58/* Strings related to load command */
59const char * const mi_lttng_element_load = "load";
60
5e18ec73
JR		 61/* String related to a lttng_event_field */
62const char * const mi_lttng_element_event_field = "event_field";
63const char * const mi_lttng_element_event_fields = "event_fields";
64
65/* General elements of mi_lttng */
66const char * const mi_lttng_element_type_other = "OTHER";
67const char * const mi_lttng_element_type_integer = "INTEGER";
68const char * const mi_lttng_element_type_enum = "ENUM";
69const char * const mi_lttng_element_type_float = "FLOAT";
70const char * const mi_lttng_element_type_string = "STRING";
71const char * const mi_lttng_element_nowrite = "nowrite";
72
73/* String related to loglevel */
74const char * const mi_lttng_loglevel_str_alert = "TRACE_ALERT";
75const char * const mi_lttng_loglevel_str_crit = "TRACE_CRIT";
76const char * const mi_lttng_loglevel_str_debug = "TRACE_DEBUG";
77const char * const mi_lttng_loglevel_str_debug_function = "TRACE_DEBUG_FUNCTION";
78const char * const mi_lttng_loglevel_str_debug_line = "TRACE_DEBUG_LINE";
79const char * const mi_lttng_loglevel_str_debug_module = "TRACE_DEBUG_MODULE";
80const char * const mi_lttng_loglevel_str_debug_process = "TRACE_DEBUG_PROCESS";
81const char * const mi_lttng_loglevel_str_debug_program = "TRACE_DEBUG_PROGRAM";
82const char * const mi_lttng_loglevel_str_debug_system = "TRACE_DEBUG_SYSTEM";
83const char * const mi_lttng_loglevel_str_debug_unit = "TRACE_DEBUG_UNIT";
84const char * const mi_lttng_loglevel_str_emerg = "TRACE_EMERG";
85const char * const mi_lttng_loglevel_str_err = "TRACE_ERR";
86const char * const mi_lttng_loglevel_str_info = "TRACE_INFO";
87const char * const mi_lttng_loglevel_str_notice = "TRACE_NOTICE";
88const char * const mi_lttng_loglevel_str_unknown = "UNKNOWN";
89const char * const mi_lttng_loglevel_str_warning = "TRACE_WARNING";
90
1734c658 91/* String related to loglevel type */
5e18ec73
JR		 92const char * const mi_lttng_loglevel_type_all = "ALL";
93const char * const mi_lttng_loglevel_type_range = "RANGE";
94const char * const mi_lttng_loglevel_type_single = "SINGLE";
95const char * const mi_lttng_loglevel_type_unknown = "UNKNOWN";
96
97const char * const mi_lttng_element_empty = "";
98
99const char *mi_lttng_loglevel_string(int value)
100{
101 switch (value) {
102 case -1:
103 return mi_lttng_element_empty;
104 case LTTNG_LOGLEVEL_EMERG:
105 return mi_lttng_loglevel_str_emerg;
106 case LTTNG_LOGLEVEL_ALERT:
107 return mi_lttng_loglevel_str_alert;
108 case LTTNG_LOGLEVEL_CRIT:
109 return mi_lttng_loglevel_str_crit;
110 case LTTNG_LOGLEVEL_ERR:
111 return mi_lttng_loglevel_str_err;
112 case LTTNG_LOGLEVEL_WARNING:
113 return mi_lttng_loglevel_str_warning;
114 case LTTNG_LOGLEVEL_NOTICE:
115 return mi_lttng_loglevel_str_notice;
116 case LTTNG_LOGLEVEL_INFO:
117 return mi_lttng_loglevel_str_info;
118 case LTTNG_LOGLEVEL_DEBUG_SYSTEM:
119 return mi_lttng_loglevel_str_debug_system;
120 case LTTNG_LOGLEVEL_DEBUG_PROGRAM:
121 return mi_lttng_loglevel_str_debug_program;
122 case LTTNG_LOGLEVEL_DEBUG_PROCESS:
123 return mi_lttng_loglevel_str_debug_process;
124 case LTTNG_LOGLEVEL_DEBUG_MODULE:
125 return mi_lttng_loglevel_str_debug_module;
126 case LTTNG_LOGLEVEL_DEBUG_UNIT:
127 return mi_lttng_loglevel_str_debug_unit;
128 case LTTNG_LOGLEVEL_DEBUG_FUNCTION:
129 return mi_lttng_loglevel_str_debug_function;
130 case LTTNG_LOGLEVEL_DEBUG_LINE:
131 return mi_lttng_loglevel_str_debug_line;
132 case LTTNG_LOGLEVEL_DEBUG:
133 return mi_lttng_loglevel_str_debug;
134 default:
135 return mi_lttng_loglevel_str_unknown;
136 }
137}
138
139const char *mi_lttng_logleveltype_string(enum lttng_loglevel_type value)
140{
141 switch (value) {
142 case LTTNG_EVENT_LOGLEVEL_ALL:
143 return mi_lttng_loglevel_type_all;
144 case LTTNG_EVENT_LOGLEVEL_RANGE:
145 return mi_lttng_loglevel_type_range;
146 case LTTNG_EVENT_LOGLEVEL_SINGLE:
147 return mi_lttng_loglevel_type_single;
148 default:
149 return mi_lttng_loglevel_type_unknown;
150 }
151}
152
153const char *mi_lttng_eventtype_string(enum lttng_event_type value)
154{
155 switch (value) {
156 case LTTNG_EVENT_ALL:
157 return config_event_type_all;
158 case LTTNG_EVENT_TRACEPOINT:
159 return config_event_type_tracepoint;
160 case LTTNG_EVENT_PROBE:
161 return config_event_type_probe;
162 case LTTNG_EVENT_FUNCTION:
163 return config_event_type_function;
164 case LTTNG_EVENT_FUNCTION_ENTRY:
165 return config_event_type_function_entry;
166 case LTTNG_EVENT_SYSCALL:
167 return config_event_type_syscall;
168 case LTTNG_EVENT_NOOP:
169 return config_event_type_noop;
170 default:
171 return mi_lttng_element_empty;
172 }
173}
174
175const char *mi_lttng_eventfieldtype_string(enum lttng_event_field_type val)
176{
177 switch (val) {
178 case(LTTNG_EVENT_FIELD_INTEGER):
179 return mi_lttng_element_type_integer;
180 case(LTTNG_EVENT_FIELD_ENUM):
181 return mi_lttng_element_type_enum;
182 case(LTTNG_EVENT_FIELD_FLOAT):
183 return mi_lttng_element_type_float;
184 case(LTTNG_EVENT_FIELD_STRING):
185 return mi_lttng_element_type_string;
186 default:
187 return mi_lttng_element_type_other;
188 }
189}
190
191const char *mi_lttng_domaintype_string(enum lttng_domain_type value)
192{
193 /* Note: This is a *duplicate* of get_domain_str from bin/lttng/utils.c */
194 switch (value) {
195 case LTTNG_DOMAIN_KERNEL:
196 return config_domain_type_kernel;
197 case LTTNG_DOMAIN_UST:
198 return config_domain_type_ust;
199 case LTTNG_DOMAIN_JUL:
200 return config_domain_type_jul;
201 default:
202 /* Should not have an unknown domain */
203 assert(0);
204 }
205}
206
207const char *mi_lttng_buffertype_string(enum lttng_buffer_type value)
208{
209 switch (value) {
210 case LTTNG_BUFFER_PER_PID:
211 return config_buffer_type_per_pid;
212 case LTTNG_BUFFER_PER_UID:
213 return config_buffer_type_per_uid;
214 case LTTNG_BUFFER_GLOBAL:
215 return config_buffer_type_global;
216 default:
217 /* Should not have an unknow buffer type */
218 assert(0);
219 }
220}
221
c7e35b03
JR		 222LTTNG_HIDDEN
223struct mi_writer *mi_lttng_writer_create(int fd_output, int mi_output_type)
224{
225 struct mi_writer *mi_writer;
226
227 mi_writer = zmalloc(sizeof(struct mi_writer));
228 if (!mi_writer) {
229 PERROR("zmalloc mi_writer_create");
230 goto end;
231 }
232 if (mi_output_type == LTTNG_MI_XML) {
233 mi_writer->writer = config_writer_create(fd_output);
234 if (!mi_writer->writer) {
235 goto err_destroy;
236 }
237 mi_writer->type = LTTNG_MI_XML;
238 } else {
239 goto err_destroy;
240 }
241
242end:
243 return mi_writer;
244
245err_destroy:
246 free(mi_writer);
247 return NULL;
248}
249
250LTTNG_HIDDEN
251int mi_lttng_writer_destroy(struct mi_writer *writer)
252{
253 int ret;
254
255 if (!writer) {
256 ret = -EINVAL;
257 goto end;
258 }
259
260 ret = config_writer_destroy(writer->writer);
261 if (ret < 0) {
262 goto end;
263 }
264
265 free(writer);
266end:
267 return ret;
268}
269
270LTTNG_HIDDEN
271int mi_lttng_writer_command_open(struct mi_writer *writer, const char *command)
272{
273 int ret;
274
275 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_command);
276 if (ret) {
277 goto end;
278 }
279 ret = mi_lttng_writer_write_element_string(writer,
280 mi_lttng_element_command_name, command);
281end:
282 return ret;
283}
284
285LTTNG_HIDDEN
286int mi_lttng_writer_command_close(struct mi_writer *writer)
287{
288 return mi_lttng_writer_close_element(writer);
289}
290
291LTTNG_HIDDEN
292int mi_lttng_writer_open_element(struct mi_writer *writer,
293 const char *element_name)
294{
295 return config_writer_open_element(writer->writer, element_name);
296}
297
298LTTNG_HIDDEN
299int mi_lttng_writer_close_element(struct mi_writer *writer)
300{
301 return config_writer_close_element(writer->writer);
302}
303
5e18ec73
JR		 304LTTNG_HIDDEN
305int mi_lttng_close_multi_element(struct mi_writer *writer,
306 unsigned int nb_element)
307{
308 int ret, i;
309
310 if (nb_element < 1) {
311 ret = 0;
312 goto end;
313 }
314 for (i = 0; i < nb_element; i++) {
315 ret = mi_lttng_writer_close_element(writer);
316 if (ret) {
317 goto end;
318 }
319 }
320end:
321 return ret;
322}
323
c7e35b03
JR		 324LTTNG_HIDDEN
325int mi_lttng_writer_write_element_unsigned_int(struct mi_writer *writer,
326 const char *element_name, uint64_t value)
327{
328 return config_writer_write_element_unsigned_int(writer->writer,
329 element_name, value);
330}
331
332LTTNG_HIDDEN
333int mi_lttng_writer_write_element_signed_int(struct mi_writer *writer,
334 const char *element_name, int64_t value)
335{
336 return config_writer_write_element_signed_int(writer->writer,
337 element_name, value);
338}
339
340LTTNG_HIDDEN
341int mi_lttng_writer_write_element_bool(struct mi_writer *writer,
342 const char *element_name, int value)
343{
344 return config_writer_write_element_bool(writer->writer,
345 element_name, value);
346}
347
348LTTNG_HIDDEN
349int mi_lttng_writer_write_element_string(struct mi_writer *writer,
350 const char *element_name, const char *value)
351{
352 return config_writer_write_element_string(writer->writer,
353 element_name, value);
354}
355
356LTTNG_HIDDEN
357int mi_lttng_version(struct mi_writer *writer, struct mi_lttng_version *version,
358 const char *lttng_description, const char *lttng_license)
359{
360 int ret;
361
362 /* Open version */
363 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_version);
364 if (ret) {
365 goto end;
366 }
367
368 /* Version string (contain info like rc etc.) */
369 ret = mi_lttng_writer_write_element_string(writer,
370 mi_lttng_element_version_str, VERSION);
371 if (ret) {
372 goto end;
373 }
374
375 /* Major version number */
376 ret = mi_lttng_writer_write_element_unsigned_int(writer,
377 mi_lttng_element_version_major, version->version_major);
378 if (ret) {
379 goto end;
380 }
381
382 /* Minor version number */
383 ret = mi_lttng_writer_write_element_unsigned_int(writer,
384 mi_lttng_element_version_minor, version->version_minor);
385 if (ret) {
386 goto end;
387 }
388
314d5222
JRJ		 389 /* Commit version number */
390 ret = mi_lttng_writer_write_element_string(writer,
391 mi_lttng_element_version_commit, version->version_commit);
392 if (ret) {
393 goto end;
394 }
395
c7e35b03
JR		 396 /* Patch number */
397 ret = mi_lttng_writer_write_element_unsigned_int(writer,
398 mi_lttng_element_version_patch_level, version->version_patchlevel);
399 if (ret) {
400 goto end;
401 }
402
403 /* Name of the version */
404 ret = mi_lttng_writer_write_element_string(writer,
405 config_element_name, version->version_name);
406 if (ret) {
407 goto end;
408 }
409
410 /* Description mostly related to beer... */
411 ret = mi_lttng_writer_write_element_string(writer,
412 mi_lttng_element_version_description, lttng_description);
413 if (ret) {
414 goto end;
415 }
416
417 /* url */
418 ret = mi_lttng_writer_write_element_string(writer,
419 mi_lttng_element_version_web, version->package_url);
420 if (ret) {
421 goto end;
422 }
423
424 /* License: free as in free beer...no...*speech* */
425 ret = mi_lttng_writer_write_element_string(writer,
426 mi_lttng_element_version_license, lttng_license);
427 if (ret) {
428 goto end;
429 }
430
431 /* Close version element */
432 ret = mi_lttng_writer_close_element(writer);
433
434end:
435 return ret;
436}
437
5e18ec73
JR		 438LTTNG_HIDDEN
439int mi_lttng_sessions_open(struct mi_writer *writer)
440{
441 return mi_lttng_writer_open_element(writer, config_element_sessions);
442}
443
c7e35b03
JR		 444LTTNG_HIDDEN
445int mi_lttng_session(struct mi_writer *writer,
446 struct lttng_session *session, int is_open)
447{
448 int ret;
449
5e18ec73
JR		 450 assert(session);
451
452 /* Open sessions element */
c7e35b03
JR		 453 ret = mi_lttng_writer_open_element(writer,
454 config_element_session);
455 if (ret) {
456 goto end;
457 }
458
459 /* Name of the session */
460 ret = mi_lttng_writer_write_element_string(writer,
461 config_element_name, session->name);
462 if (ret) {
463 goto end;
464 }
465
5e18ec73 466 /* Path */
c7e35b03
JR		 467 ret = mi_lttng_writer_write_element_string(writer,
468 config_element_path, session->path);
469 if (ret) {
470 goto end;
471 }
472
5e18ec73
JR		 473 /* Enabled ? */
474 ret = mi_lttng_writer_write_element_bool(writer,
c7e35b03
JR		 475 config_element_enabled, session->enabled);
476 if (ret) {
477 goto end;
478 }
479
5e18ec73 480 /* Snapshot mode */
c7e35b03
JR		 481 ret = mi_lttng_writer_write_element_unsigned_int(writer,
482 config_element_snapshot_mode, session->snapshot_mode);
483 if (ret) {
484 goto end;
485 }
486
5e18ec73 487 /* Live timer interval in usec */
c7e35b03
JR		 488 ret = mi_lttng_writer_write_element_unsigned_int(writer,
489 config_element_live_timer_interval,
490 session->live_timer_interval);
491 if (ret) {
492 goto end;
493 }
494
495 if (!is_open) {
496 /* Closing session element */
497 ret = mi_lttng_writer_close_element(writer);
498 }
499end:
500 return ret;
501
502}
5e18ec73
JR		 503
504LTTNG_HIDDEN
505int mi_lttng_domains_open(struct mi_writer *writer)
506{
507 return mi_lttng_writer_open_element(writer, config_element_domains);
508}
509
510LTTNG_HIDDEN
511int mi_lttng_domain(struct mi_writer *writer,
512 struct lttng_domain *domain, int is_open)
513{
514 int ret = 0;
515 const char *str_domain;
516 const char *str_buffer;
517
518 assert(domain);
519
520 /* Open domain element */
521 ret = mi_lttng_writer_open_element(writer, config_element_domain);
522 if (ret) {
523 goto end;
524 }
525
526 /* Domain Type */
527 str_domain = mi_lttng_domaintype_string(domain->type);
528 ret = mi_lttng_writer_write_element_string(writer, config_element_type,
529 str_domain);
530 if (ret) {
531 goto end;
532 }
533
534 /* Buffer Type */
535 str_buffer= mi_lttng_buffertype_string(domain->buf_type);
536 ret = mi_lttng_writer_write_element_string(writer,
537 config_element_buffer_type, str_buffer);
538 if (ret) {
539 goto end;
540 }
541
542 /* TODO: attr... not sure how to use the union.... */
543
544 if (!is_open) {
545 /* Closing domain element */
546 ret = mi_lttng_writer_close_element(writer);
547 }
548
549end:
550 return ret;
551
552}
553
554LTTNG_HIDDEN
555int mi_lttng_channels_open(struct mi_writer *writer)
556{
557 return mi_lttng_writer_open_element(writer, config_element_channels);
558}
559
560LTTNG_HIDDEN
561int mi_lttng_channel(struct mi_writer *writer,
562 struct lttng_channel *channel, int is_open)
563{
564 int ret = 0;
565
566 assert(channel);
567
568 /* Opening channel element */
569 ret = mi_lttng_writer_open_element(writer, config_element_channel);
570 if (ret) {
571 goto end;
572 }
573
574 /* Name */
575 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
576 channel->name);
577 if (ret) {
578 goto end;
579 }
580
581 /* Enabled ? */
582 ret = mi_lttng_writer_write_element_bool(writer,
583 config_element_enabled, channel->enabled);
584 if (ret) {
585 goto end;
586 }
587
588 /* Attribute */
589 ret = mi_lttng_channel_attr(writer, &channel->attr);
590 if (ret) {
591 goto end;
592 }
593
594 if (!is_open) {
595 /* Closing channel element */
596 ret = mi_lttng_writer_close_element(writer);
597 if (ret) {
598 goto end;
599 }
600 }
601end:
602 return ret;
603}
604
605LTTNG_HIDDEN
606int mi_lttng_channel_attr(struct mi_writer *writer,
607 struct lttng_channel_attr *attr)
608{
609 int ret = 0;
610
611 assert(attr);
612
613 /* Opening Attributes */
614 ret = mi_lttng_writer_open_element(writer, config_element_attributes);
615 if (ret) {
616 goto end;
617 }
618
619 /* Overwrite */
620 ret = mi_lttng_writer_write_element_string(writer,
621 config_element_overwrite_mode,
622 attr->overwrite ? config_overwrite_mode_overwrite :
623 config_overwrite_mode_discard);
624 if (ret) {
625 goto end;
626 }
627
628 /* Sub buffer size in byte */
629 ret = mi_lttng_writer_write_element_unsigned_int(writer,
630 config_element_subbuf_size, attr->subbuf_size);
631 if (ret) {
632 goto end;
633 }
634
635 /* Number of subbuffer (power of two) */
636 ret = mi_lttng_writer_write_element_unsigned_int(writer,
637 config_element_num_subbuf,
638 attr->num_subbuf);
639 if (ret) {
640 goto end;
641 }
642
643 /* Switch timer interval in usec */
644 ret = mi_lttng_writer_write_element_unsigned_int(writer,
645 config_element_switch_timer_interval,
646 attr->switch_timer_interval);
647 if (ret) {
648 goto end;
649 }
650
651 /* Read timer interval in usec */
652 ret = mi_lttng_writer_write_element_unsigned_int(writer,
653 config_element_read_timer_interval,
654 attr->read_timer_interval);
655 if (ret) {
656 goto end;
657 }
658
659 /* Event output */
660 ret = mi_lttng_writer_write_element_string(writer,
661 config_element_output_type,
662 attr->output == LTTNG_EVENT_SPLICE ?
663 config_output_type_splice : config_output_type_mmap);
664 if (ret) {
665 goto end;
666 }
667
668 /* Tracefile size in bytes */
669 ret = mi_lttng_writer_write_element_unsigned_int(writer,
670 config_element_tracefile_size, attr->tracefile_size);
671 if (ret) {
672 goto end;
673 }
674
675 /* Count of tracefiles */
676 ret = mi_lttng_writer_write_element_unsigned_int(writer,
677 config_element_tracefile_count,
678 attr->tracefile_count);
679 if (ret) {
680 goto end;
681 }
682
683 /* Live timer interval in usec*/
684 ret = mi_lttng_writer_write_element_unsigned_int(writer,
685 config_element_live_timer_interval,
686 attr->live_timer_interval);
687 if (ret) {
688 goto end;
689 }
690
691 /* Closing attributes */
692 ret = mi_lttng_writer_close_element(writer);
693 if (ret) {
694 goto end;
695 }
696end:
697 return ret;
698
699}
700
701LTTNG_HIDDEN
702int mi_lttng_event_common_attributes(struct mi_writer *writer,
703 struct lttng_event *event)
704{
705 int ret;
706
707 /* Open event element */
708 ret = mi_lttng_writer_open_element(writer, config_element_event);
709 if (ret) {
710 goto end;
711 }
712
713 /* event name */
714 ret = mi_lttng_writer_write_element_string(writer,
715 config_element_name, event->name);
716 if (ret) {
717 goto end;
718 }
719
720 /* event type */
721 ret = mi_lttng_writer_write_element_string(writer,
722 config_element_type, mi_lttng_eventtype_string(event->type));
723 if (ret) {
724 goto end;
725 }
726
727 /* is event enabled */
728 ret = mi_lttng_writer_write_element_bool(writer,
729 config_element_enabled, event->enabled);
730 if (ret) {
731 goto end;
732 }
733
734 /* event filter enabled? */
735 ret = mi_lttng_writer_write_element_bool(writer,
736 config_element_filter, event->filter);
737
738end:
739 return ret;
740}
741
742LTTNG_HIDDEN
743int mi_lttng_event_tracepoint_loglevel(struct mi_writer *writer,
744 struct lttng_event *event)
745{
746 int ret;
747
748 /* event loglevel */
749 ret = mi_lttng_writer_write_element_string(writer,
750 config_element_loglevel, mi_lttng_loglevel_string(event->loglevel));
751 if (ret) {
752 goto end;
753 }
754
755 ret = mi_lttng_writer_write_element_string(writer,
756 config_element_loglevel_type,
757 mi_lttng_logleveltype_string(event->loglevel_type));
758 if (ret) {
759 goto end;
760 }
761
762 /* event exclusion filter */
763 ret = mi_lttng_writer_write_element_bool(writer,
764 config_element_exclusion, event->exclusion);
765 if (ret) {
766 goto end;
767 }
768
769end:
770 return ret;
771}
772
773LTTNG_HIDDEN
774int mi_lttng_event_tracepoint_no_loglevel(struct mi_writer *writer,
775 struct lttng_event *event)
776{
777 /* event exclusion filter */
778 return mi_lttng_writer_write_element_bool(writer,
779 config_element_exclusion, event->exclusion);
780}
781
782LTTNG_HIDDEN
783int mi_lttng_event_function_probe(struct mi_writer *writer,
784 struct lttng_event *event)
785{
786 int ret;
787
788 if (event->attr.probe.addr != 0) {
789 /* event probe address */
790 ret = mi_lttng_writer_write_element_unsigned_int(writer,
791 config_element_address, event->attr.probe.addr);
792 if (ret) {
793 goto end;
794 }
795 } else {
796 /* event probe offset */
797 ret = mi_lttng_writer_write_element_unsigned_int(writer,
798 config_element_offset, event->attr.probe.offset);
799 if (ret) {
800 goto end;
801 }
802
803 /* event probe symbol_name */
804 ret = mi_lttng_writer_write_element_string(writer,
805 config_element_symbol_name, event->attr.probe.symbol_name);
806 if (ret) {
807 goto end;
808 }
809 }
810end:
811 return ret;
812}
813
814LTTNG_HIDDEN
815int mi_lttng_event_function_entry(struct mi_writer *writer,
816 struct lttng_event *event)
817{
818 /* event probe symbol_name */
819 return mi_lttng_writer_write_element_string(writer,
820 config_element_symbol_name, event->attr.ftrace.symbol_name);
821}
822
823LTTNG_HIDDEN
824int mi_lttng_events_open(struct mi_writer *writer)
825{
826 return mi_lttng_writer_open_element(writer, config_element_events);
827}
828
829LTTNG_HIDDEN
830int mi_lttng_event(struct mi_writer *writer,
831 struct lttng_event *event, int is_open)
832{
833 int ret;
834
835 ret = mi_lttng_event_common_attributes(writer, event);
836 if (ret) {
837 goto end;
838 }
839
840 switch (event->type) {
841 case LTTNG_EVENT_ALL:
842 /* We should never have "all" events in list. */
843 assert(0);
844 break;
845 case LTTNG_EVENT_TRACEPOINT:
846 {
847 if (event->loglevel != -1) {
848 ret = mi_lttng_event_tracepoint_loglevel(writer, event);
849 } else {
850 ret = mi_lttng_event_tracepoint_no_loglevel(writer, event);
851 }
852 break;
853 }
854 case LTTNG_EVENT_PROBE:
855 ret = mi_lttng_event_function_probe(writer, event);
856 break;
857 case LTTNG_EVENT_FUNCTION_ENTRY:
858 ret = mi_lttng_event_function_entry(writer, event);
859 break;
860 default:
861 break;
862 }
863
864 if (!is_open) {
865 ret = mi_lttng_writer_close_element(writer);
866 }
867
868end:
869 return ret;
870}
871
872LTTNG_HIDDEN
873int mi_lttng_pids_open(struct mi_writer *writer)
874{
875 return mi_lttng_writer_open_element(writer, mi_lttng_element_pids);
876}
877
878LTTNG_HIDDEN
879int mi_lttng_pid(struct mi_writer *writer, pid_t pid , const char *cmdline,
880 int is_open)
881{
882 int ret;
883
884 /* Open element pid */
885 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_pid);
886 if (ret) {
887 goto end;
888 }
889
890 /* Writing pid number */
891 ret = mi_lttng_writer_write_element_signed_int(writer,
892 mi_lttng_element_pid_id, (int)pid);
893 if (ret) {
894 goto end;
895 }
896
897 /* Writing name of the process */
898 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
899 cmdline);
900 if (ret) {
901 goto end;
902 }
903
904 if (!is_open) {
905 /* Closing Pid */
906 ret = mi_lttng_writer_close_element(writer);
907 }
908
909end:
910 return ret;
911}
912
913LTTNG_HIDDEN
914int mi_lttng_event_fields_open(struct mi_writer *writer)
915{
916 return mi_lttng_writer_open_element(writer, mi_lttng_element_event_fields);
917}
918
919LTTNG_HIDDEN
920int mi_lttng_event_field(struct mi_writer *writer,
921 struct lttng_event_field *field)
922{
923 int ret;
924
925 if (!field->field_name[0]) {
926 /* To Review: not sure if legal david ?
927 * how should this be handle ?
928 */
929 ret = 0;
930 goto end;
931 }
932
933 /* Open field */
934 ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_field);
935 if (ret) {
936 goto end;
937 }
938
939 if (!field->field_name[0]) {
940 goto close;
941 }
942
943 /* Name */
944 ret = mi_lttng_writer_write_element_string(writer, config_element_name,
945 field->field_name);
946 if (ret) {
947 goto end;
948 }
949
950 /* Type */
951 ret = mi_lttng_writer_write_element_string(writer, config_element_type,
952 mi_lttng_eventfieldtype_string(field->type));
953 if (ret) {
954 goto end;
955 }
956
957 /* nowrite */
958 ret = mi_lttng_writer_write_element_signed_int(writer,
959 mi_lttng_element_nowrite, field->nowrite);
960 if (ret) {
961 goto end;
962 }
963
964close:
965 /* Close field element */
966 ret = mi_lttng_writer_close_element(writer);
967
968end:
969 return ret;
970}
LTTng tools - Deliverables
This page took 0.066847 seconds and 5 git commands to generate.