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