src/lib/lttng-ctl/lttng-ctl.c

   1 /*
   2  * liblttngctl.c
   3  *
   4  * Linux Trace Toolkit Control Library
   5  *
   6  * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
   7  *
   8  * This library is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License, version 2.1 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this library; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <assert.h>
  24 #include <grp.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include <common/common.h>
  32 #include <common/defaults.h>
  33 #include <common/sessiond-comm/sessiond-comm.h>
  34 #include <common/uri.h>
  35 #include <common/utils.h>
  36 #include <lttng/lttng.h>
  37
  38 #include "filter/filter-ast.h"
  39 #include "filter/filter-parser.h"
  40 #include "filter/filter-bytecode.h"
  41 #include "filter/memstream.h"
  42 #include "lttng-ctl-helper.h"
  43
  44 #ifdef DEBUG
  45 static const int print_xml = 1;
  46 #define dbg_printf(fmt, args...)        \
  47         printf("[debug liblttng-ctl] " fmt, ## args)
  48 #else
  49 static const int print_xml = 0;
  50 #define dbg_printf(fmt, args...)                                \
  51 do {                                                            \
  52         /* do nothing but check printf format */                \
  53         if (0)                                                  \
  54                 printf("[debug liblttnctl] " fmt, ## args);     \
  55 } while (0)
  56 #endif
  57
  58
  59 /* Socket to session daemon for communication */
  60 static int sessiond_socket;
  61 static char sessiond_sock_path[PATH_MAX];
  62 static char health_sock_path[PATH_MAX];
  63
  64 /* Variables */
  65 static char *tracing_group;
  66 static int connected;
  67
  68 /* Global */
  69
  70 /*
  71  * Those two variables are used by error.h to silent or control the verbosity of
  72  * error message. They are global to the library so application linking with it
  73  * are able to compile correctly and also control verbosity of the library.
  74  */
  75 int lttng_opt_quiet;
  76 int lttng_opt_verbose;
  77
  78 /*
  79  * Copy string from src to dst and enforce null terminated byte.
  80  */
  81 LTTNG_HIDDEN
  82 void lttng_ctl_copy_string(char *dst, const char *src, size_t len)
  83 {
  84         if (src && dst) {
  85                 strncpy(dst, src, len);
  86                 /* Enforce the NULL terminated byte */
  87                 dst[len - 1] = '\0';
  88         } else if (dst) {
  89                 dst[0] = '\0';
  90         }
  91 }
  92
  93 /*
  94  * Copy domain to lttcomm_session_msg domain.
  95  *
  96  * If domain is unknown, default domain will be the kernel.
  97  */
  98 LTTNG_HIDDEN
  99 void lttng_ctl_copy_lttng_domain(struct lttng_domain *dst,
 100                 struct lttng_domain *src)
 101 {
 102         if (src && dst) {
 103                 switch (src->type) {
 104                 case LTTNG_DOMAIN_KERNEL:
 105                 case LTTNG_DOMAIN_UST:
 106                         memcpy(dst, src, sizeof(struct lttng_domain));
 107                         break;
 108                 default:
 109                         memset(dst, 0, sizeof(struct lttng_domain));
 110                         break;
 111                 }
 112         }
 113 }
 114
 115 /*
 116  * Send lttcomm_session_msg to the session daemon.
 117  *
 118  * On success, returns the number of bytes sent (>=0)
 119  * On error, returns -1
 120  */
 121 static int send_session_msg(struct lttcomm_session_msg *lsm)
 122 {
 123         int ret;
 124
 125         if (!connected) {
 126                 ret = -LTTNG_ERR_NO_SESSIOND;
 127                 goto end;
 128         }
 129
 130         DBG("LSM cmd type : %d", lsm->cmd_type);
 131
 132         ret = lttcomm_send_creds_unix_sock(sessiond_socket, lsm,
 133                         sizeof(struct lttcomm_session_msg));
 134         if (ret < 0) {
 135                 ret = -LTTNG_ERR_FATAL;
 136         }
 137
 138 end:
 139         return ret;
 140 }
 141
 142 /*
 143  * Send var len data to the session daemon.
 144  *
 145  * On success, returns the number of bytes sent (>=0)
 146  * On error, returns -1
 147  */
 148 static int send_session_varlen(void *data, size_t len)
 149 {
 150         int ret;
 151
 152         if (!connected) {
 153                 ret = -LTTNG_ERR_NO_SESSIOND;
 154                 goto end;
 155         }
 156
 157         if (!data || !len) {
 158                 ret = 0;
 159                 goto end;
 160         }
 161
 162         ret = lttcomm_send_unix_sock(sessiond_socket, data, len);
 163         if (ret < 0) {
 164                 ret = -LTTNG_ERR_FATAL;
 165         }
 166
 167 end:
 168         return ret;
 169 }
 170
 171 /*
 172  * Receive data from the sessiond socket.
 173  *
 174  * On success, returns the number of bytes received (>=0)
 175  * On error, returns -1 (recvmsg() error) or -ENOTCONN
 176  */
 177 static int recv_data_sessiond(void *buf, size_t len)
 178 {
 179         int ret;
 180
 181         if (!connected) {
 182                 ret = -LTTNG_ERR_NO_SESSIOND;
 183                 goto end;
 184         }
 185
 186         ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len);
 187         if (ret < 0) {
 188                 ret = -LTTNG_ERR_FATAL;
 189         }
 190
 191 end:
 192         return ret;
 193 }
 194
 195 /*
 196  *  Check if we are in the specified group.
 197  *
 198  *  If yes return 1, else return -1.
 199  */
 200 static int check_tracing_group(const char *grp_name)
 201 {
 202         struct group *grp_tracing;      /* no free(). See getgrnam(3) */
 203         gid_t *grp_list;
 204         int grp_list_size, grp_id, i;
 205         int ret = -1;
 206
 207         /* Get GID of group 'tracing' */
 208         grp_tracing = getgrnam(grp_name);
 209         if (!grp_tracing) {
 210                 /* If grp_tracing is NULL, the group does not exist. */
 211                 goto end;
 212         }
 213
 214         /* Get number of supplementary group IDs */
 215         grp_list_size = getgroups(0, NULL);
 216         if (grp_list_size < 0) {
 217                 perror("getgroups");
 218                 goto end;
 219         }
 220
 221         /* Alloc group list of the right size */
 222         grp_list = malloc(grp_list_size * sizeof(gid_t));
 223         if (!grp_list) {
 224                 perror("malloc");
 225                 goto end;
 226         }
 227         grp_id = getgroups(grp_list_size, grp_list);
 228         if (grp_id < 0) {
 229                 perror("getgroups");
 230                 goto free_list;
 231         }
 232
 233         for (i = 0; i < grp_list_size; i++) {
 234                 if (grp_list[i] == grp_tracing->gr_gid) {
 235                         ret = 1;
 236                         break;
 237                 }
 238         }
 239
 240 free_list:
 241         free(grp_list);
 242
 243 end:
 244         return ret;
 245 }
 246
 247 /*
 248  * Try connect to session daemon with sock_path.
 249  *
 250  * Return 0 on success, else -1
 251  */
 252 static int try_connect_sessiond(const char *sock_path)
 253 {
 254         int ret;
 255
 256         /* If socket exist, we check if the daemon listens for connect. */
 257         ret = access(sock_path, F_OK);
 258         if (ret < 0) {
 259                 /* Not alive */
 260                 goto error;
 261         }
 262
 263         ret = lttcomm_connect_unix_sock(sock_path);
 264         if (ret < 0) {
 265                 /* Not alive */
 266                 goto error;
 267         }
 268
 269         ret = lttcomm_close_unix_sock(ret);
 270         if (ret < 0) {
 271                 perror("lttcomm_close_unix_sock");
 272         }
 273
 274         return 0;
 275
 276 error:
 277         return -1;
 278 }
 279
 280 /*
 281  * Set sessiond socket path by putting it in the global sessiond_sock_path
 282  * variable.
 283  *
 284  * Returns 0 on success, negative value on failure (the sessiond socket path
 285  * is somehow too long or ENOMEM).
 286  */
 287 static int set_session_daemon_path(void)
 288 {
 289         int in_tgroup = 0;      /* In tracing group */
 290         uid_t uid;
 291
 292         uid = getuid();
 293
 294         if (uid != 0) {
 295                 /* Are we in the tracing group ? */
 296                 in_tgroup = check_tracing_group(tracing_group);
 297         }
 298
 299         if ((uid == 0) || in_tgroup) {
 300                 lttng_ctl_copy_string(sessiond_sock_path,
 301                                 DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, sizeof(sessiond_sock_path));
 302         }
 303
 304         if (uid != 0) {
 305                 int ret;
 306
 307                 if (in_tgroup) {
 308                         /* Tracing group */
 309                         ret = try_connect_sessiond(sessiond_sock_path);
 310                         if (ret >= 0) {
 311                                 goto end;
 312                         }
 313                         /* Global session daemon not available... */
 314                 }
 315                 /* ...or not in tracing group (and not root), default */
 316
 317                 /*
 318                  * With GNU C <  2.1, snprintf returns -1 if the target buffer is too small;
 319                  * With GNU C >= 2.1, snprintf returns the required size (excluding closing null)
 320                  */
 321                 ret = snprintf(sessiond_sock_path, sizeof(sessiond_sock_path),
 322                                 DEFAULT_HOME_CLIENT_UNIX_SOCK, utils_get_home_dir());
 323                 if ((ret < 0) || (ret >= sizeof(sessiond_sock_path))) {
 324                         goto error;
 325                 }
 326         }
 327 end:
 328         return 0;
 329
 330 error:
 331         return -1;
 332 }
 333
 334 /*
 335  *  Connect to the LTTng session daemon.
 336  *
 337  *  On success, return 0. On error, return -1.
 338  */
 339 static int connect_sessiond(void)
 340 {
 341         int ret;
 342
 343         /* Don't try to connect if already connected. */
 344         if (connected) {
 345                 return 0;
 346         }
 347
 348         ret = set_session_daemon_path();
 349         if (ret < 0) {
 350                 goto error;
 351         }
 352
 353         /* Connect to the sesssion daemon */
 354         ret = lttcomm_connect_unix_sock(sessiond_sock_path);
 355         if (ret < 0) {
 356                 goto error;
 357         }
 358
 359         sessiond_socket = ret;
 360         connected = 1;
 361
 362         return 0;
 363
 364 error:
 365         return -1;
 366 }
 367
 368 /*
 369  *  Clean disconnect from the session daemon.
 370  *  On success, return 0. On error, return -1.
 371  */
 372 static int disconnect_sessiond(void)
 373 {
 374         int ret = 0;
 375
 376         if (connected) {
 377                 ret = lttcomm_close_unix_sock(sessiond_socket);
 378                 sessiond_socket = 0;
 379                 connected = 0;
 380         }
 381
 382         return ret;
 383 }
 384
 385 /*
 386  * Ask the session daemon a specific command and put the data into buf.
 387  * Takes extra var. len. data as input to send to the session daemon.
 388  *
 389  * Return size of data (only payload, not header) or a negative error code.
 390  */
 391 LTTNG_HIDDEN
 392 int lttng_ctl_ask_sessiond_varlen(struct lttcomm_session_msg *lsm,
 393                 void *vardata, size_t varlen, void **buf)
 394 {
 395         int ret;
 396         size_t size;
 397         void *data = NULL;
 398         struct lttcomm_lttng_msg llm;
 399
 400         ret = connect_sessiond();
 401         if (ret < 0) {
 402                 ret = -LTTNG_ERR_NO_SESSIOND;
 403                 goto end;
 404         }
 405
 406         /* Send command to session daemon */
 407         ret = send_session_msg(lsm);
 408         if (ret < 0) {
 409                 /* Ret value is a valid lttng error code. */
 410                 goto end;
 411         }
 412         /* Send var len data */
 413         ret = send_session_varlen(vardata, varlen);
 414         if (ret < 0) {
 415                 /* Ret value is a valid lttng error code. */
 416                 goto end;
 417         }
 418
 419         /* Get header from data transmission */
 420         ret = recv_data_sessiond(&llm, sizeof(llm));
 421         if (ret < 0) {
 422                 /* Ret value is a valid lttng error code. */
 423                 goto end;
 424         }
 425
 426         /* Check error code if OK */
 427         if (llm.ret_code != LTTNG_OK) {
 428                 ret = -llm.ret_code;
 429                 goto end;
 430         }
 431
 432         size = llm.data_size;
 433         if (size == 0) {
 434                 /* If client free with size 0 */
 435                 if (buf != NULL) {
 436                         *buf = NULL;
 437                 }
 438                 ret = 0;
 439                 goto end;
 440         }
 441
 442         data = (void*) malloc(size);
 443
 444         /* Get payload data */
 445         ret = recv_data_sessiond(data, size);
 446         if (ret < 0) {
 447                 free(data);
 448                 goto end;
 449         }
 450
 451         /*
 452          * Extra protection not to dereference a NULL pointer. If buf is NULL at
 453          * this point, an error is returned and data is freed.
 454          */
 455         if (buf == NULL) {
 456                 ret = -LTTNG_ERR_INVALID;
 457                 free(data);
 458                 goto end;
 459         }
 460
 461         *buf = data;
 462         ret = size;
 463
 464 end:
 465         disconnect_sessiond();
 466         return ret;
 467 }
 468
 469 /*
 470  * Create lttng handle and return pointer.
 471  * The returned pointer will be NULL in case of malloc() error.
 472  */
 473 struct lttng_handle *lttng_create_handle(const char *session_name,
 474                 struct lttng_domain *domain)
 475 {
 476         struct lttng_handle *handle = NULL;
 477
 478         if (domain == NULL) {
 479                 goto end;
 480         }
 481
 482         handle = malloc(sizeof(struct lttng_handle));
 483         if (handle == NULL) {
 484                 PERROR("malloc handle");
 485                 goto end;
 486         }
 487
 488         /* Copy session name */
 489         lttng_ctl_copy_string(handle->session_name, session_name,
 490                         sizeof(handle->session_name));
 491
 492         /* Copy lttng domain */
 493         lttng_ctl_copy_lttng_domain(&handle->domain, domain);
 494
 495 end:
 496         return handle;
 497 }
 498
 499 /*
 500  * Destroy handle by free(3) the pointer.
 501  */
 502 void lttng_destroy_handle(struct lttng_handle *handle)
 503 {
 504         free(handle);
 505 }
 506
 507 /*
 508  * Register an outside consumer.
 509  * Returns size of returned session payload data or a negative error code.
 510  */
 511 int lttng_register_consumer(struct lttng_handle *handle,
 512                 const char *socket_path)
 513 {
 514         struct lttcomm_session_msg lsm;
 515
 516         if (handle == NULL || socket_path == NULL) {
 517                 return -LTTNG_ERR_INVALID;
 518         }
 519
 520         lsm.cmd_type = LTTNG_REGISTER_CONSUMER;
 521         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 522                         sizeof(lsm.session.name));
 523         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 524
 525         lttng_ctl_copy_string(lsm.u.reg.path, socket_path, sizeof(lsm.u.reg.path));
 526
 527         return lttng_ctl_ask_sessiond(&lsm, NULL);
 528 }
 529
 530 /*
 531  *  Start tracing for all traces of the session.
 532  *  Returns size of returned session payload data or a negative error code.
 533  */
 534 int lttng_start_tracing(const char *session_name)
 535 {
 536         struct lttcomm_session_msg lsm;
 537
 538         if (session_name == NULL) {
 539                 return -LTTNG_ERR_INVALID;
 540         }
 541
 542         lsm.cmd_type = LTTNG_START_TRACE;
 543
 544         lttng_ctl_copy_string(lsm.session.name, session_name,
 545                         sizeof(lsm.session.name));
 546
 547         return lttng_ctl_ask_sessiond(&lsm, NULL);
 548 }
 549
 550 /*
 551  * Stop tracing for all traces of the session.
 552  */
 553 static int _lttng_stop_tracing(const char *session_name, int wait)
 554 {
 555         int ret, data_ret;
 556         struct lttcomm_session_msg lsm;
 557
 558         if (session_name == NULL) {
 559                 return -LTTNG_ERR_INVALID;
 560         }
 561
 562         lsm.cmd_type = LTTNG_STOP_TRACE;
 563
 564         lttng_ctl_copy_string(lsm.session.name, session_name,
 565                         sizeof(lsm.session.name));
 566
 567         ret = lttng_ctl_ask_sessiond(&lsm, NULL);
 568         if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
 569                 goto error;
 570         }
 571
 572         if (!wait) {
 573                 goto end;
 574         }
 575
 576         _MSG("Waiting for data availability");
 577
 578         /* Check for data availability */
 579         do {
 580                 data_ret = lttng_data_pending(session_name);
 581                 if (data_ret < 0) {
 582                         /* Return the data available call error. */
 583                         ret = data_ret;
 584                         goto error;
 585                 }
 586
 587                 /*
 588                  * Data sleep time before retrying (in usec). Don't sleep if the call
 589                  * returned value indicates availability.
 590                  */
 591                 if (data_ret) {
 592                         usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
 593                         _MSG(".");
 594                 }
 595         } while (data_ret != 0);
 596
 597         MSG("");
 598
 599 end:
 600 error:
 601         return ret;
 602 }
 603
 604 /*
 605  * Stop tracing and wait for data availability.
 606  */
 607 int lttng_stop_tracing(const char *session_name)
 608 {
 609         return _lttng_stop_tracing(session_name, 1);
 610 }
 611
 612 /*
 613  * Stop tracing but _don't_ wait for data availability.
 614  */
 615 int lttng_stop_tracing_no_wait(const char *session_name)
 616 {
 617         return _lttng_stop_tracing(session_name, 0);
 618 }
 619
 620 /*
 621  * Add context to a channel.
 622  *
 623  * If the given channel is NULL, add the contexts to all channels.
 624  * The event_name param is ignored.
 625  *
 626  * Returns the size of the returned payload data or a negative error code.
 627  */
 628 int lttng_add_context(struct lttng_handle *handle,
 629                 struct lttng_event_context *ctx, const char *event_name,
 630                 const char *channel_name)
 631 {
 632         struct lttcomm_session_msg lsm;
 633
 634         /* Safety check. Both are mandatory */
 635         if (handle == NULL || ctx == NULL) {
 636                 return -LTTNG_ERR_INVALID;
 637         }
 638
 639         memset(&lsm, 0, sizeof(lsm));
 640
 641         lsm.cmd_type = LTTNG_ADD_CONTEXT;
 642
 643         /* If no channel name, send empty string. */
 644         if (channel_name == NULL) {
 645                 lttng_ctl_copy_string(lsm.u.context.channel_name, "",
 646                                 sizeof(lsm.u.context.channel_name));
 647         } else {
 648                 lttng_ctl_copy_string(lsm.u.context.channel_name, channel_name,
 649                                 sizeof(lsm.u.context.channel_name));
 650         }
 651
 652         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 653
 654         memcpy(&lsm.u.context.ctx, ctx, sizeof(struct lttng_event_context));
 655
 656         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 657                         sizeof(lsm.session.name));
 658
 659         return lttng_ctl_ask_sessiond(&lsm, NULL);
 660 }
 661
 662 /*
 663  *  Enable event(s) for a channel.
 664  *  If no event name is specified, all events are enabled.
 665  *  If no channel name is specified, the default 'channel0' is used.
 666  *  Returns size of returned session payload data or a negative error code.
 667  */
 668 int lttng_enable_event(struct lttng_handle *handle,
 669                 struct lttng_event *ev, const char *channel_name)
 670 {
 671         struct lttcomm_session_msg lsm;
 672
 673         if (handle == NULL || ev == NULL) {
 674                 return -LTTNG_ERR_INVALID;
 675         }
 676
 677         memset(&lsm, 0, sizeof(lsm));
 678
 679         /* If no channel name, send empty string. */
 680         if (channel_name == NULL) {
 681                 lttng_ctl_copy_string(lsm.u.enable.channel_name, "",
 682                                 sizeof(lsm.u.enable.channel_name));
 683         } else {
 684                 lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name,
 685                                 sizeof(lsm.u.enable.channel_name));
 686         }
 687
 688         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 689
 690         if (ev->name[0] != '\0') {
 691                 lsm.cmd_type = LTTNG_ENABLE_EVENT;
 692         } else {
 693                 lsm.cmd_type = LTTNG_ENABLE_ALL_EVENT;
 694         }
 695         memcpy(&lsm.u.enable.event, ev, sizeof(lsm.u.enable.event));
 696
 697         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 698                         sizeof(lsm.session.name));
 699
 700         return lttng_ctl_ask_sessiond(&lsm, NULL);
 701 }
 702
 703 /*
 704  * Create or enable an event with a filter expression.
 705  *
 706  * Return negative error value on error.
 707  * Return size of returned session payload data if OK.
 708  */
 709 int lttng_enable_event_with_filter(struct lttng_handle *handle,
 710                 struct lttng_event *event, const char *channel_name,
 711                 const char *filter_expression)
 712 {
 713         struct lttcomm_session_msg lsm;
 714         struct filter_parser_ctx *ctx;
 715         FILE *fmem;
 716         int ret = 0;
 717
 718         if (!filter_expression) {
 719                 /*
 720                  * Fall back to normal event enabling if no filter
 721                  * specified.
 722                  */
 723                 return lttng_enable_event(handle, event, channel_name);
 724         }
 725
 726         /*
 727          * Empty filter string will always be rejected by the parser
 728          * anyway, so treat this corner-case early to eliminate
 729          * lttng_fmemopen error for 0-byte allocation.
 730          */
 731         if (handle == NULL || filter_expression[0] == '\0') {
 732                 return -LTTNG_ERR_INVALID;
 733         }
 734
 735         /*
 736          * casting const to non-const, as the underlying function will
 737          * use it in read-only mode.
 738          */
 739         fmem = lttng_fmemopen((void *) filter_expression,
 740                         strlen(filter_expression), "r");
 741         if (!fmem) {
 742                 fprintf(stderr, "Error opening memory as stream\n");
 743                 return -LTTNG_ERR_FILTER_NOMEM;
 744         }
 745         ctx = filter_parser_ctx_alloc(fmem);
 746         if (!ctx) {
 747                 fprintf(stderr, "Error allocating parser\n");
 748                 ret = -LTTNG_ERR_FILTER_NOMEM;
 749                 goto alloc_error;
 750         }
 751         ret = filter_parser_ctx_append_ast(ctx);
 752         if (ret) {
 753                 fprintf(stderr, "Parse error\n");
 754                 ret = -LTTNG_ERR_FILTER_INVAL;
 755                 goto parse_error;
 756         }
 757         ret = filter_visitor_set_parent(ctx);
 758         if (ret) {
 759                 fprintf(stderr, "Set parent error\n");
 760                 ret = -LTTNG_ERR_FILTER_INVAL;
 761                 goto parse_error;
 762         }
 763         if (print_xml) {
 764                 ret = filter_visitor_print_xml(ctx, stdout, 0);
 765                 if (ret) {
 766                         fflush(stdout);
 767                         fprintf(stderr, "XML print error\n");
 768                         ret = -LTTNG_ERR_FILTER_INVAL;
 769                         goto parse_error;
 770                 }
 771         }
 772
 773         dbg_printf("Generating IR... ");
 774         fflush(stdout);
 775         ret = filter_visitor_ir_generate(ctx);
 776         if (ret) {
 777                 fprintf(stderr, "Generate IR error\n");
 778                 ret = -LTTNG_ERR_FILTER_INVAL;
 779                 goto parse_error;
 780         }
 781         dbg_printf("done\n");
 782
 783         dbg_printf("Validating IR... ");
 784         fflush(stdout);
 785         ret = filter_visitor_ir_check_binary_op_nesting(ctx);
 786         if (ret) {
 787                 ret = -LTTNG_ERR_FILTER_INVAL;
 788                 goto parse_error;
 789         }
 790         dbg_printf("done\n");
 791
 792         dbg_printf("Generating bytecode... ");
 793         fflush(stdout);
 794         ret = filter_visitor_bytecode_generate(ctx);
 795         if (ret) {
 796                 fprintf(stderr, "Generate bytecode error\n");
 797                 ret = -LTTNG_ERR_FILTER_INVAL;
 798                 goto parse_error;
 799         }
 800         dbg_printf("done\n");
 801         dbg_printf("Size of bytecode generated: %u bytes.\n",
 802                 bytecode_get_len(&ctx->bytecode->b));
 803
 804         memset(&lsm, 0, sizeof(lsm));
 805
 806         lsm.cmd_type = LTTNG_ENABLE_EVENT_WITH_FILTER;
 807
 808         /* If no channel name, send empty string. */
 809         if (channel_name == NULL) {
 810                 lttng_ctl_copy_string(lsm.u.enable.channel_name, "",
 811                                 sizeof(lsm.u.enable.channel_name));
 812         } else {
 813                 lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name,
 814                                 sizeof(lsm.u.enable.channel_name));
 815         }
 816
 817         /* Copy event name */
 818         if (event) {
 819                 memcpy(&lsm.u.enable.event, event, sizeof(lsm.u.enable.event));
 820         }
 821
 822         lsm.u.enable.bytecode_len = sizeof(ctx->bytecode->b)
 823                         + bytecode_get_len(&ctx->bytecode->b);
 824
 825         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 826
 827         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 828                         sizeof(lsm.session.name));
 829
 830         ret = lttng_ctl_ask_sessiond_varlen(&lsm, &ctx->bytecode->b,
 831                                 lsm.u.enable.bytecode_len, NULL);
 832
 833         filter_bytecode_free(ctx);
 834         filter_ir_free(ctx);
 835         filter_parser_ctx_free(ctx);
 836         if (fclose(fmem) != 0) {
 837                 perror("fclose");
 838         }
 839         return ret;
 840
 841 parse_error:
 842         filter_bytecode_free(ctx);
 843         filter_ir_free(ctx);
 844         filter_parser_ctx_free(ctx);
 845 alloc_error:
 846         if (fclose(fmem) != 0) {
 847                 perror("fclose");
 848         }
 849         return ret;
 850 }
 851
 852 /*
 853  *  Disable event(s) of a channel and domain.
 854  *  If no event name is specified, all events are disabled.
 855  *  If no channel name is specified, the default 'channel0' is used.
 856  *  Returns size of returned session payload data or a negative error code.
 857  */
 858 int lttng_disable_event(struct lttng_handle *handle, const char *name,
 859                 const char *channel_name)
 860 {
 861         struct lttcomm_session_msg lsm;
 862
 863         if (handle == NULL) {
 864                 return -LTTNG_ERR_INVALID;
 865         }
 866
 867         memset(&lsm, 0, sizeof(lsm));
 868
 869         /* If no channel name, send empty string. */
 870         if (channel_name == NULL) {
 871                 lttng_ctl_copy_string(lsm.u.disable.channel_name, "",
 872                                 sizeof(lsm.u.disable.channel_name));
 873         } else {
 874                 lttng_ctl_copy_string(lsm.u.disable.channel_name, channel_name,
 875                                 sizeof(lsm.u.disable.channel_name));
 876         }
 877
 878         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 879
 880         if (name != NULL) {
 881                 lttng_ctl_copy_string(lsm.u.disable.name, name,
 882                                 sizeof(lsm.u.disable.name));
 883                 lsm.cmd_type = LTTNG_DISABLE_EVENT;
 884         } else {
 885                 lsm.cmd_type = LTTNG_DISABLE_ALL_EVENT;
 886         }
 887
 888         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 889                         sizeof(lsm.session.name));
 890
 891         return lttng_ctl_ask_sessiond(&lsm, NULL);
 892 }
 893
 894 /*
 895  *  Enable channel per domain
 896  *  Returns size of returned session payload data or a negative error code.
 897  */
 898 int lttng_enable_channel(struct lttng_handle *handle,
 899                 struct lttng_channel *chan)
 900 {
 901         struct lttcomm_session_msg lsm;
 902
 903         /*
 904          * NULL arguments are forbidden. No default values.
 905          */
 906         if (handle == NULL || chan == NULL) {
 907                 return -LTTNG_ERR_INVALID;
 908         }
 909
 910         memset(&lsm, 0, sizeof(lsm));
 911
 912         memcpy(&lsm.u.channel.chan, chan, sizeof(lsm.u.channel.chan));
 913
 914         lsm.cmd_type = LTTNG_ENABLE_CHANNEL;
 915
 916         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 917
 918         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 919                         sizeof(lsm.session.name));
 920
 921         return lttng_ctl_ask_sessiond(&lsm, NULL);
 922 }
 923
 924 /*
 925  *  All tracing will be stopped for registered events of the channel.
 926  *  Returns size of returned session payload data or a negative error code.
 927  */
 928 int lttng_disable_channel(struct lttng_handle *handle, const char *name)
 929 {
 930         struct lttcomm_session_msg lsm;
 931
 932         /* Safety check. Both are mandatory */
 933         if (handle == NULL || name == NULL) {
 934                 return -LTTNG_ERR_INVALID;
 935         }
 936
 937         memset(&lsm, 0, sizeof(lsm));
 938
 939         lsm.cmd_type = LTTNG_DISABLE_CHANNEL;
 940
 941         lttng_ctl_copy_string(lsm.u.disable.channel_name, name,
 942                         sizeof(lsm.u.disable.channel_name));
 943
 944         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 945
 946         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
 947                         sizeof(lsm.session.name));
 948
 949         return lttng_ctl_ask_sessiond(&lsm, NULL);
 950 }
 951
 952 /*
 953  *  Lists all available tracepoints of domain.
 954  *  Sets the contents of the events array.
 955  *  Returns the number of lttng_event entries in events;
 956  *  on error, returns a negative value.
 957  */
 958 int lttng_list_tracepoints(struct lttng_handle *handle,
 959                 struct lttng_event **events)
 960 {
 961         int ret;
 962         struct lttcomm_session_msg lsm;
 963
 964         if (handle == NULL) {
 965                 return -LTTNG_ERR_INVALID;
 966         }
 967
 968         lsm.cmd_type = LTTNG_LIST_TRACEPOINTS;
 969         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 970
 971         ret = lttng_ctl_ask_sessiond(&lsm, (void **) events);
 972         if (ret < 0) {
 973                 return ret;
 974         }
 975
 976         return ret / sizeof(struct lttng_event);
 977 }
 978
 979 /*
 980  *  Lists all available tracepoint fields of domain.
 981  *  Sets the contents of the event field array.
 982  *  Returns the number of lttng_event_field entries in events;
 983  *  on error, returns a negative value.
 984  */
 985 int lttng_list_tracepoint_fields(struct lttng_handle *handle,
 986                 struct lttng_event_field **fields)
 987 {
 988         int ret;
 989         struct lttcomm_session_msg lsm;
 990
 991         if (handle == NULL) {
 992                 return -LTTNG_ERR_INVALID;
 993         }
 994
 995         lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS;
 996         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 997
 998         ret = lttng_ctl_ask_sessiond(&lsm, (void **) fields);
 999         if (ret < 0) {
1000                 return ret;
1001         }
1002
1003         return ret / sizeof(struct lttng_event_field);
1004 }
1005
1006 /*
1007  *  Returns a human readable string describing
1008  *  the error code (a negative value).
1009  */
1010 const char *lttng_strerror(int code)
1011 {
1012         return error_get_str(code);
1013 }
1014
1015 /*
1016  * Create a brand new session using name and url for destination.
1017  *
1018  * Returns LTTNG_OK on success or a negative error code.
1019  */
1020 int lttng_create_session(const char *name, const char *url)
1021 {
1022         int ret;
1023         ssize_t size;
1024         struct lttcomm_session_msg lsm;
1025         struct lttng_uri *uris = NULL;
1026
1027         if (name == NULL) {
1028                 return -LTTNG_ERR_INVALID;
1029         }
1030
1031         memset(&lsm, 0, sizeof(lsm));
1032
1033         lsm.cmd_type = LTTNG_CREATE_SESSION;
1034         lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name));
1035
1036         /* There should never be a data URL */
1037         size = uri_parse_str_urls(url, NULL, &uris);
1038         if (size < 0) {
1039                 return -LTTNG_ERR_INVALID;
1040         }
1041
1042         lsm.u.uri.size = size;
1043
1044         ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris,
1045                         sizeof(struct lttng_uri) * size, NULL);
1046
1047         free(uris);
1048         return ret;
1049 }
1050
1051 /*
1052  *  Destroy session using name.
1053  *  Returns size of returned session payload data or a negative error code.
1054  */
1055 int lttng_destroy_session(const char *session_name)
1056 {
1057         struct lttcomm_session_msg lsm;
1058
1059         if (session_name == NULL) {
1060                 return -LTTNG_ERR_INVALID;
1061         }
1062
1063         lsm.cmd_type = LTTNG_DESTROY_SESSION;
1064
1065         lttng_ctl_copy_string(lsm.session.name, session_name,
1066                         sizeof(lsm.session.name));
1067
1068         return lttng_ctl_ask_sessiond(&lsm, NULL);
1069 }
1070
1071 /*
1072  *  Ask the session daemon for all available sessions.
1073  *  Sets the contents of the sessions array.
1074  *  Returns the number of lttng_session entries in sessions;
1075  *  on error, returns a negative value.
1076  */
1077 int lttng_list_sessions(struct lttng_session **sessions)
1078 {
1079         int ret;
1080         struct lttcomm_session_msg lsm;
1081
1082         lsm.cmd_type = LTTNG_LIST_SESSIONS;
1083         ret = lttng_ctl_ask_sessiond(&lsm, (void**) sessions);
1084         if (ret < 0) {
1085                 return ret;
1086         }
1087
1088         return ret / sizeof(struct lttng_session);
1089 }
1090
1091 /*
1092  *  Ask the session daemon for all available domains of a session.
1093  *  Sets the contents of the domains array.
1094  *  Returns the number of lttng_domain entries in domains;
1095  *  on error, returns a negative value.
1096  */
1097 int lttng_list_domains(const char *session_name,
1098                 struct lttng_domain **domains)
1099 {
1100         int ret;
1101         struct lttcomm_session_msg lsm;
1102
1103         if (session_name == NULL) {
1104                 return -LTTNG_ERR_INVALID;
1105         }
1106
1107         lsm.cmd_type = LTTNG_LIST_DOMAINS;
1108
1109         lttng_ctl_copy_string(lsm.session.name, session_name,
1110                         sizeof(lsm.session.name));
1111
1112         ret = lttng_ctl_ask_sessiond(&lsm, (void**) domains);
1113         if (ret < 0) {
1114                 return ret;
1115         }
1116
1117         return ret / sizeof(struct lttng_domain);
1118 }
1119
1120 /*
1121  *  Ask the session daemon for all available channels of a session.
1122  *  Sets the contents of the channels array.
1123  *  Returns the number of lttng_channel entries in channels;
1124  *  on error, returns a negative value.
1125  */
1126 int lttng_list_channels(struct lttng_handle *handle,
1127                 struct lttng_channel **channels)
1128 {
1129         int ret;
1130         struct lttcomm_session_msg lsm;
1131
1132         if (handle == NULL) {
1133                 return -LTTNG_ERR_INVALID;
1134         }
1135
1136         lsm.cmd_type = LTTNG_LIST_CHANNELS;
1137         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
1138                         sizeof(lsm.session.name));
1139
1140         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
1141
1142         ret = lttng_ctl_ask_sessiond(&lsm, (void**) channels);
1143         if (ret < 0) {
1144                 return ret;
1145         }
1146
1147         return ret / sizeof(struct lttng_channel);
1148 }
1149
1150 /*
1151  *  Ask the session daemon for all available events of a session channel.
1152  *  Sets the contents of the events array.
1153  *  Returns the number of lttng_event entries in events;
1154  *  on error, returns a negative value.
1155  */
1156 int lttng_list_events(struct lttng_handle *handle,
1157                 const char *channel_name, struct lttng_event **events)
1158 {
1159         int ret;
1160         struct lttcomm_session_msg lsm;
1161
1162         /* Safety check. An handle and channel name are mandatory */
1163         if (handle == NULL || channel_name == NULL) {
1164                 return -LTTNG_ERR_INVALID;
1165         }
1166
1167         lsm.cmd_type = LTTNG_LIST_EVENTS;
1168         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
1169                         sizeof(lsm.session.name));
1170         lttng_ctl_copy_string(lsm.u.list.channel_name, channel_name,
1171                         sizeof(lsm.u.list.channel_name));
1172
1173         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
1174
1175         ret = lttng_ctl_ask_sessiond(&lsm, (void**) events);
1176         if (ret < 0) {
1177                 return ret;
1178         }
1179
1180         return ret / sizeof(struct lttng_event);
1181 }
1182
1183 /*
1184  * Sets the tracing_group variable with name.
1185  * This function allocates memory pointed to by tracing_group.
1186  * On success, returns 0, on error, returns -1 (null name) or -ENOMEM.
1187  */
1188 int lttng_set_tracing_group(const char *name)
1189 {
1190         if (name == NULL) {
1191                 return -LTTNG_ERR_INVALID;
1192         }
1193
1194         if (asprintf(&tracing_group, "%s", name) < 0) {
1195                 return -LTTNG_ERR_FATAL;
1196         }
1197
1198         return 0;
1199 }
1200
1201 /*
1202  * Returns size of returned session payload data or a negative error code.
1203  */
1204 int lttng_calibrate(struct lttng_handle *handle,
1205                 struct lttng_calibrate *calibrate)
1206 {
1207         struct lttcomm_session_msg lsm;
1208
1209         /* Safety check. NULL pointer are forbidden */
1210         if (handle == NULL || calibrate == NULL) {
1211                 return -LTTNG_ERR_INVALID;
1212         }
1213
1214         lsm.cmd_type = LTTNG_CALIBRATE;
1215         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
1216
1217         memcpy(&lsm.u.calibrate, calibrate, sizeof(lsm.u.calibrate));
1218
1219         return lttng_ctl_ask_sessiond(&lsm, NULL);
1220 }
1221
1222 /*
1223  * Set default channel attributes.
1224  * If either or both of the arguments are null, attr content is zeroe'd.
1225  */
1226 void lttng_channel_set_default_attr(struct lttng_domain *domain,
1227                 struct lttng_channel_attr *attr)
1228 {
1229         /* Safety check */
1230         if (attr == NULL || domain == NULL) {
1231                 return;
1232         }
1233
1234         memset(attr, 0, sizeof(struct lttng_channel_attr));
1235
1236         /* Same for all domains. */
1237         attr->overwrite = DEFAULT_CHANNEL_OVERWRITE;
1238         attr->tracefile_size = DEFAULT_CHANNEL_TRACEFILE_SIZE;
1239         attr->tracefile_count = DEFAULT_CHANNEL_TRACEFILE_COUNT;
1240
1241         switch (domain->type) {
1242         case LTTNG_DOMAIN_KERNEL:
1243                 attr->switch_timer_interval = DEFAULT_KERNEL_CHANNEL_SWITCH_TIMER;
1244                 attr->read_timer_interval = DEFAULT_KERNEL_CHANNEL_READ_TIMER;
1245                 attr->subbuf_size = default_get_kernel_channel_subbuf_size();
1246                 attr->num_subbuf = DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM;
1247                 attr->output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
1248                 break;
1249         case LTTNG_DOMAIN_UST:
1250                 switch (domain->buf_type) {
1251                 case LTTNG_BUFFER_PER_UID:
1252                         attr->subbuf_size = default_get_ust_uid_channel_subbuf_size();
1253                         attr->num_subbuf = DEFAULT_UST_UID_CHANNEL_SUBBUF_NUM;
1254                         attr->output = DEFAULT_UST_UID_CHANNEL_OUTPUT;
1255                         attr->switch_timer_interval = DEFAULT_UST_UID_CHANNEL_SWITCH_TIMER;
1256                         attr->read_timer_interval = DEFAULT_UST_UID_CHANNEL_READ_TIMER;
1257                         break;
1258                 case LTTNG_BUFFER_PER_PID:
1259                 default:
1260                         attr->subbuf_size = default_get_ust_pid_channel_subbuf_size();
1261                         attr->num_subbuf = DEFAULT_UST_PID_CHANNEL_SUBBUF_NUM;
1262                         attr->output = DEFAULT_UST_PID_CHANNEL_OUTPUT;
1263                         attr->switch_timer_interval = DEFAULT_UST_PID_CHANNEL_SWITCH_TIMER;
1264                         attr->read_timer_interval = DEFAULT_UST_PID_CHANNEL_READ_TIMER;
1265                         break;
1266                 }
1267         default:
1268                 /* Default behavior: leave set to 0. */
1269                 break;
1270         }
1271 }
1272
1273 /*
1274  * Check if session daemon is alive.
1275  *
1276  * Return 1 if alive or 0 if not.
1277  * On error returns a negative value.
1278  */
1279 int lttng_session_daemon_alive(void)
1280 {
1281         int ret;
1282
1283         ret = set_session_daemon_path();
1284         if (ret < 0) {
1285                 /* Error */
1286                 return ret;
1287         }
1288
1289         if (*sessiond_sock_path == '\0') {
1290                 /*
1291                  * No socket path set. Weird error which means the constructor was not
1292                  * called.
1293                  */
1294                 assert(0);
1295         }
1296
1297         ret = try_connect_sessiond(sessiond_sock_path);
1298         if (ret < 0) {
1299                 /* Not alive */
1300                 return 0;
1301         }
1302
1303         /* Is alive */
1304         return 1;
1305 }
1306
1307 /*
1308  * Set URL for a consumer for a session and domain.
1309  *
1310  * Return 0 on success, else a negative value.
1311  */
1312 int lttng_set_consumer_url(struct lttng_handle *handle,
1313                 const char *control_url, const char *data_url)
1314 {
1315         int ret;
1316         ssize_t size;
1317         struct lttcomm_session_msg lsm;
1318         struct lttng_uri *uris = NULL;
1319
1320         if (handle == NULL || (control_url == NULL && data_url == NULL)) {
1321                 return -LTTNG_ERR_INVALID;
1322         }
1323
1324         memset(&lsm, 0, sizeof(lsm));
1325
1326         lsm.cmd_type = LTTNG_SET_CONSUMER_URI;
1327
1328         lttng_ctl_copy_string(lsm.session.name, handle->session_name,
1329                         sizeof(lsm.session.name));
1330         lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
1331
1332         size = uri_parse_str_urls(control_url, data_url, &uris);
1333         if (size < 0) {
1334                 return -LTTNG_ERR_INVALID;
1335         }
1336
1337         lsm.u.uri.size = size;
1338
1339         ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris,
1340                         sizeof(struct lttng_uri) * size, NULL);
1341
1342         free(uris);
1343         return ret;
1344 }
1345
1346 /*
1347  * [OBSOLETE]
1348  */
1349 int lttng_enable_consumer(struct lttng_handle *handle)
1350 {
1351         return -ENOSYS;
1352 }
1353
1354 /*
1355  * [OBSOLETE]
1356  */
1357 int lttng_disable_consumer(struct lttng_handle *handle)
1358 {
1359         return -ENOSYS;
1360 }
1361
1362 /*
1363  * Set health socket path by putting it in the global health_sock_path
1364  * variable.
1365  *
1366  * Returns 0 on success or assert(0) on ENOMEM.
1367  */
1368 static int set_health_socket_path(void)
1369 {
1370         int in_tgroup = 0;      /* In tracing group */
1371         uid_t uid;
1372         const char *home;
1373
1374         uid = getuid();
1375
1376         if (uid != 0) {
1377                 /* Are we in the tracing group ? */
1378                 in_tgroup = check_tracing_group(tracing_group);
1379         }
1380
1381         if ((uid == 0) || in_tgroup) {
1382                 lttng_ctl_copy_string(health_sock_path,
1383                                 DEFAULT_GLOBAL_HEALTH_UNIX_SOCK, sizeof(health_sock_path));
1384         }
1385
1386         if (uid != 0) {
1387                 int ret;
1388
1389                 /*
1390                  * With GNU C <  2.1, snprintf returns -1 if the target buffer is too small;
1391                  * With GNU C >= 2.1, snprintf returns the required size (excluding closing null)
1392                  */
1393                 home = utils_get_home_dir();
1394                 if (home == NULL) {
1395                         /* Fallback in /tmp .. */
1396                         home = "/tmp";
1397                 }
1398
1399                 ret = snprintf(health_sock_path, sizeof(health_sock_path),
1400                                 DEFAULT_HOME_HEALTH_UNIX_SOCK, home);
1401                 if ((ret < 0) || (ret >= sizeof(health_sock_path))) {
1402                         /* ENOMEM at this point... just kill the control lib. */
1403                         assert(0);
1404                 }
1405         }
1406
1407         return 0;
1408 }
1409
1410 /*
1411  * Check session daemon health for a specific health component.
1412  *
1413  * Return 0 if health is OK or else 1 if BAD.
1414  *
1415  * Any other negative value is a lttng error code which can be translated with
1416  * lttng_strerror().
1417  */
1418 int lttng_health_check(enum lttng_health_component c)
1419 {
1420         int sock, ret;
1421         struct lttcomm_health_msg msg;
1422         struct lttcomm_health_data reply;
1423
1424         /* Connect to the sesssion daemon */
1425         sock = lttcomm_connect_unix_sock(health_sock_path);
1426         if (sock < 0) {
1427                 ret = -LTTNG_ERR_NO_SESSIOND;
1428                 goto error;
1429         }
1430
1431         msg.cmd = LTTNG_HEALTH_CHECK;
1432         msg.component = c;
1433
1434         ret = lttcomm_send_unix_sock(sock, (void *)&msg, sizeof(msg));
1435         if (ret < 0) {
1436                 ret = -LTTNG_ERR_FATAL;
1437                 goto close_error;
1438         }
1439
1440         ret = lttcomm_recv_unix_sock(sock, (void *)&reply, sizeof(reply));
1441         if (ret < 0) {
1442                 ret = -LTTNG_ERR_FATAL;
1443                 goto close_error;
1444         }
1445
1446         ret = reply.ret_code;
1447
1448 close_error:
1449         {
1450                 int closeret;
1451
1452                 closeret = close(sock);
1453                 assert(!closeret);
1454         }
1455
1456 error:
1457         return ret;
1458 }
1459
1460 /*
1461  * This is an extension of create session that is ONLY and SHOULD only be used
1462  * by the lttng command line program. It exists to avoid using URI parsing in
1463  * the lttng client.
1464  *
1465  * We need the date and time for the trace path subdirectory for the case where
1466  * the user does NOT define one using either -o or -U. Using the normal
1467  * lttng_create_session API call, we have no clue on the session daemon side if
1468  * the URL was generated automatically by the client or define by the user.
1469  *
1470  * So this function "wrapper" is hidden from the public API, takes the datetime
1471  * string and appends it if necessary to the URI subdirectory before sending it
1472  * to the session daemon.
1473  *
1474  * With this extra function, the lttng_create_session call behavior is not
1475  * changed and the timestamp is appended to the URI on the session daemon side
1476  * if necessary.
1477  */
1478 int _lttng_create_session_ext(const char *name, const char *url,
1479                 const char *datetime)
1480 {
1481         int ret;
1482         ssize_t size;
1483         struct lttcomm_session_msg lsm;
1484         struct lttng_uri *uris = NULL;
1485
1486         if (name == NULL || datetime == NULL) {
1487                 return -LTTNG_ERR_INVALID;
1488         }
1489
1490         memset(&lsm, 0, sizeof(lsm));
1491
1492         lsm.cmd_type = LTTNG_CREATE_SESSION;
1493         lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name));
1494
1495         /* There should never be a data URL */
1496         size = uri_parse_str_urls(url, NULL, &uris);
1497         if (size < 0) {
1498                 ret = -LTTNG_ERR_INVALID;
1499                 goto error;
1500         }
1501
1502         lsm.u.uri.size = size;
1503
1504         if (size > 0 && uris[0].dtype != LTTNG_DST_PATH && strlen(uris[0].subdir) == 0) {
1505                 /* Don't append datetime if the name was automatically created. */
1506                 if (strncmp(name, DEFAULT_SESSION_NAME "-",
1507                                         strlen(DEFAULT_SESSION_NAME) + 1)) {
1508                         ret = snprintf(uris[0].subdir, sizeof(uris[0].subdir), "%s-%s",
1509                                         name, datetime);
1510                 } else {
1511                         ret = snprintf(uris[0].subdir, sizeof(uris[0].subdir), "%s", name);
1512                 }
1513                 if (ret < 0) {
1514                         PERROR("snprintf uri subdir");
1515                         ret = -LTTNG_ERR_FATAL;
1516                         goto error;
1517                 }
1518         }
1519
1520         ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris,
1521                         sizeof(struct lttng_uri) * size, NULL);
1522
1523 error:
1524         free(uris);
1525         return ret;
1526 }
1527
1528 /*
1529  * For a given session name, this call checks if the data is ready to be read
1530  * or is still being extracted by the consumer(s) hence not ready to be used by
1531  * any readers.
1532  */
1533 int lttng_data_pending(const char *session_name)
1534 {
1535         int ret;
1536         struct lttcomm_session_msg lsm;
1537
1538         if (session_name == NULL) {
1539                 return -LTTNG_ERR_INVALID;
1540         }
1541
1542         lsm.cmd_type = LTTNG_DATA_PENDING;
1543
1544         lttng_ctl_copy_string(lsm.session.name, session_name,
1545                         sizeof(lsm.session.name));
1546
1547         ret = lttng_ctl_ask_sessiond(&lsm, NULL);
1548
1549         /*
1550          * The lttng_ctl_ask_sessiond function negate the return code if it's not
1551          * LTTNG_OK so getting -1 means that the reply ret_code was 1 thus meaning
1552          * that the data is available. Yes it is hackish but for now this is the
1553          * only way.
1554          */
1555         if (ret == -1) {
1556                 ret = 1;
1557         }
1558
1559         return ret;
1560 }
1561
1562 /*
1563  * Create a session exclusively used for snapshot.
1564  *
1565  * Returns LTTNG_OK on success or a negative error code.
1566  */
1567 int lttng_create_session_snapshot(const char *name, const char *snapshot_url)
1568 {
1569         int ret;
1570         ssize_t size;
1571         struct lttcomm_session_msg lsm;
1572         struct lttng_uri *uris = NULL;
1573
1574         if (name == NULL) {
1575                 return -LTTNG_ERR_INVALID;
1576         }
1577
1578         memset(&lsm, 0, sizeof(lsm));
1579
1580         lsm.cmd_type = LTTNG_CREATE_SESSION_SNAPSHOT;
1581         lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name));
1582
1583         size = uri_parse_str_urls(snapshot_url, NULL, &uris);
1584         if (size < 0) {
1585                 return -LTTNG_ERR_INVALID;
1586         }
1587
1588         lsm.u.uri.size = size;
1589
1590         ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris,
1591                         sizeof(struct lttng_uri) * size, NULL);
1592
1593         free(uris);
1594         return ret;
1595 }
1596
1597 /*
1598  * lib constructor
1599  */
1600 static void __attribute__((constructor)) init()
1601 {
1602         /* Set default session group */
1603         lttng_set_tracing_group(DEFAULT_TRACING_GROUP);
1604         /* Set socket for health check */
1605         (void) set_health_socket_path();
1606 }
1607
1608 /*
1609  * lib destructor
1610  */
1611 static void __attribute__((destructor)) lttng_ctl_exit()
1612 {
1613         free(tracing_group);
1614 }