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