liblttng-ust-ctl/ustctl.c

   1 /*
   2  * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
   3  * Copyright (C) 2011-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; version 2 of the License only.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <string.h>
  21 #include <lttng/ust-config.h>
  22 #include <lttng/ust-ctl.h>
  23 #include <lttng/ust-abi.h>
  24 #include <lttng/ust-events.h>
  25 #include <sys/mman.h>
  26 #include <byteswap.h>
  27
  28 #include <usterr-signal-safe.h>
  29 #include <ust-comm.h>
  30 #include <helper.h>
  31
  32 #include "../libringbuffer/backend.h"
  33 #include "../libringbuffer/frontend.h"
  34 #include "../liblttng-ust/wait.h"
  35 #include "../liblttng-ust/lttng-rb-clients.h"
  36 #include "../liblttng-ust/clock.h"
  37 #include "../liblttng-ust/getenv.h"
  38
  39 /*
  40  * Number of milliseconds to retry before failing metadata writes on
  41  * buffer full condition. (10 seconds)
  42  */
  43 #define LTTNG_METADATA_TIMEOUT_MSEC     10000
  44
  45 /*
  46  * Channel representation within consumer.
  47  */
  48 struct ustctl_consumer_channel {
  49         struct lttng_channel *chan;             /* lttng channel buffers */
  50
  51         /* initial attributes */
  52         struct ustctl_consumer_channel_attr attr;
  53         int wait_fd;                            /* monitor close() */
  54         int wakeup_fd;                          /* monitor close() */
  55 };
  56
  57 /*
  58  * Stream representation within consumer.
  59  */
  60 struct ustctl_consumer_stream {
  61         struct lttng_ust_shm_handle *handle;    /* shared-memory handle */
  62         struct lttng_ust_lib_ring_buffer *buf;
  63         struct ustctl_consumer_channel *chan;
  64         int shm_fd, wait_fd, wakeup_fd;
  65         int cpu;
  66         uint64_t memory_map_size;
  67 };
  68
  69 extern void lttng_ring_buffer_client_overwrite_init(void);
  70 extern void lttng_ring_buffer_client_overwrite_rt_init(void);
  71 extern void lttng_ring_buffer_client_discard_init(void);
  72 extern void lttng_ring_buffer_client_discard_rt_init(void);
  73 extern void lttng_ring_buffer_metadata_client_init(void);
  74 extern void lttng_ring_buffer_client_overwrite_exit(void);
  75 extern void lttng_ring_buffer_client_overwrite_rt_exit(void);
  76 extern void lttng_ring_buffer_client_discard_exit(void);
  77 extern void lttng_ring_buffer_client_discard_rt_exit(void);
  78 extern void lttng_ring_buffer_metadata_client_exit(void);
  79
  80 volatile enum ust_loglevel ust_loglevel;
  81
  82 int ustctl_release_handle(int sock, int handle)
  83 {
  84         struct ustcomm_ust_msg lum;
  85         struct ustcomm_ust_reply lur;
  86
  87         if (sock < 0 || handle < 0)
  88                 return 0;
  89         memset(&lum, 0, sizeof(lum));
  90         lum.handle = handle;
  91         lum.cmd = LTTNG_UST_RELEASE;
  92         return ustcomm_send_app_cmd(sock, &lum, &lur);
  93 }
  94
  95 /*
  96  * If sock is negative, it means we don't have to notify the other side
  97  * (e.g. application has already vanished).
  98  */
  99 int ustctl_release_object(int sock, struct lttng_ust_object_data *data)
 100 {
 101         int ret;
 102
 103         if (!data)
 104                 return -EINVAL;
 105
 106         switch (data->type) {
 107         case LTTNG_UST_OBJECT_TYPE_CHANNEL:
 108                 if (data->u.channel.wakeup_fd >= 0) {
 109                         ret = close(data->u.channel.wakeup_fd);
 110                         if (ret < 0) {
 111                                 ret = -errno;
 112                                 return ret;
 113                         }
 114                 }
 115                 free(data->u.channel.data);
 116                 break;
 117         case LTTNG_UST_OBJECT_TYPE_STREAM:
 118                 if (data->u.stream.shm_fd >= 0) {
 119                         ret = close(data->u.stream.shm_fd);
 120                         if (ret < 0) {
 121                                 ret = -errno;
 122                                 return ret;
 123                         }
 124                 }
 125                 if (data->u.stream.wakeup_fd >= 0) {
 126                         ret = close(data->u.stream.wakeup_fd);
 127                         if (ret < 0) {
 128                                 ret = -errno;
 129                                 return ret;
 130                         }
 131                 }
 132                 break;
 133         case LTTNG_UST_OBJECT_TYPE_EVENT:
 134         case LTTNG_UST_OBJECT_TYPE_CONTEXT:
 135                 break;
 136         default:
 137                 assert(0);
 138         }
 139         return ustctl_release_handle(sock, data->handle);
 140 }
 141
 142 /*
 143  * Send registration done packet to the application.
 144  */
 145 int ustctl_register_done(int sock)
 146 {
 147         struct ustcomm_ust_msg lum;
 148         struct ustcomm_ust_reply lur;
 149         int ret;
 150
 151         DBG("Sending register done command to %d", sock);
 152         memset(&lum, 0, sizeof(lum));
 153         lum.handle = LTTNG_UST_ROOT_HANDLE;
 154         lum.cmd = LTTNG_UST_REGISTER_DONE;
 155         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 156         if (ret)
 157                 return ret;
 158         return 0;
 159 }
 160
 161 /*
 162  * returns session handle.
 163  */
 164 int ustctl_create_session(int sock)
 165 {
 166         struct ustcomm_ust_msg lum;
 167         struct ustcomm_ust_reply lur;
 168         int ret, session_handle;
 169
 170         /* Create session */
 171         memset(&lum, 0, sizeof(lum));
 172         lum.handle = LTTNG_UST_ROOT_HANDLE;
 173         lum.cmd = LTTNG_UST_SESSION;
 174         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 175         if (ret)
 176                 return ret;
 177         session_handle = lur.ret_val;
 178         DBG("received session handle %u", session_handle);
 179         return session_handle;
 180 }
 181
 182 int ustctl_create_event(int sock, struct lttng_ust_event *ev,
 183                 struct lttng_ust_object_data *channel_data,
 184                 struct lttng_ust_object_data **_event_data)
 185 {
 186         struct ustcomm_ust_msg lum;
 187         struct ustcomm_ust_reply lur;
 188         struct lttng_ust_object_data *event_data;
 189         int ret;
 190
 191         if (!channel_data || !_event_data)
 192                 return -EINVAL;
 193
 194         event_data = zmalloc(sizeof(*event_data));
 195         if (!event_data)
 196                 return -ENOMEM;
 197         event_data->type = LTTNG_UST_OBJECT_TYPE_EVENT;
 198         memset(&lum, 0, sizeof(lum));
 199         lum.handle = channel_data->handle;
 200         lum.cmd = LTTNG_UST_EVENT;
 201         strncpy(lum.u.event.name, ev->name,
 202                 LTTNG_UST_SYM_NAME_LEN);
 203         lum.u.event.instrumentation = ev->instrumentation;
 204         lum.u.event.loglevel_type = ev->loglevel_type;
 205         lum.u.event.loglevel = ev->loglevel;
 206         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 207         if (ret) {
 208                 free(event_data);
 209                 return ret;
 210         }
 211         event_data->handle = lur.ret_val;
 212         DBG("received event handle %u", event_data->handle);
 213         *_event_data = event_data;
 214         return 0;
 215 }
 216
 217 int ustctl_add_context(int sock, struct lttng_ust_context_attr *ctx,
 218                 struct lttng_ust_object_data *obj_data,
 219                 struct lttng_ust_object_data **_context_data)
 220 {
 221         struct ustcomm_ust_msg lum;
 222         struct ustcomm_ust_reply lur;
 223         struct lttng_ust_object_data *context_data = NULL;
 224         char *buf = NULL;
 225         size_t len;
 226         int ret;
 227
 228         if (!obj_data || !_context_data) {
 229                 ret = -EINVAL;
 230                 goto end;
 231         }
 232
 233         context_data = zmalloc(sizeof(*context_data));
 234         if (!context_data) {
 235                 ret = -ENOMEM;
 236                 goto end;
 237         }
 238         context_data->type = LTTNG_UST_OBJECT_TYPE_CONTEXT;
 239         memset(&lum, 0, sizeof(lum));
 240         lum.handle = obj_data->handle;
 241         lum.cmd = LTTNG_UST_CONTEXT;
 242
 243         lum.u.context.ctx = ctx->ctx;
 244         switch (ctx->ctx) {
 245         case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
 246                 lum.u.context.u.perf_counter = ctx->u.perf_counter;
 247                 break;
 248         case LTTNG_UST_CONTEXT_APP_CONTEXT:
 249         {
 250                 size_t provider_name_len = strlen(
 251                                 ctx->u.app_ctx.provider_name) + 1;
 252                 size_t ctx_name_len = strlen(ctx->u.app_ctx.ctx_name) + 1;
 253
 254                 lum.u.context.u.app_ctx.provider_name_len = provider_name_len;
 255                 lum.u.context.u.app_ctx.ctx_name_len = ctx_name_len;
 256
 257                 len = provider_name_len + ctx_name_len;
 258                 buf = zmalloc(len);
 259                 if (!buf) {
 260                         ret = -ENOMEM;
 261                         goto end;
 262                 }
 263                 memcpy(buf, ctx->u.app_ctx.provider_name,
 264                                 provider_name_len);
 265                 memcpy(buf + provider_name_len, ctx->u.app_ctx.ctx_name,
 266                                 ctx_name_len);
 267                 break;
 268         }
 269         default:
 270                 break;
 271         }
 272         ret = ustcomm_send_app_msg(sock, &lum);
 273         if (ret)
 274                 goto end;
 275         if (buf) {
 276                 /* send var len ctx_name */
 277                 ret = ustcomm_send_unix_sock(sock, buf, len);
 278                 if (ret < 0) {
 279                         goto end;
 280                 }
 281                 if (ret != len) {
 282                         ret = -EINVAL;
 283                         goto end;
 284                 }
 285         }
 286         ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
 287         if (ret < 0) {
 288                 goto end;
 289         }
 290         context_data->handle = -1;
 291         DBG("Context created successfully");
 292         *_context_data = context_data;
 293         context_data = NULL;
 294 end:
 295         free(context_data);
 296         free(buf);
 297         return ret;
 298 }
 299
 300 int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode,
 301                 struct lttng_ust_object_data *obj_data)
 302 {
 303         struct ustcomm_ust_msg lum;
 304         struct ustcomm_ust_reply lur;
 305         int ret;
 306
 307         if (!obj_data)
 308                 return -EINVAL;
 309
 310         memset(&lum, 0, sizeof(lum));
 311         lum.handle = obj_data->handle;
 312         lum.cmd = LTTNG_UST_FILTER;
 313         lum.u.filter.data_size = bytecode->len;
 314         lum.u.filter.reloc_offset = bytecode->reloc_offset;
 315         lum.u.filter.seqnum = bytecode->seqnum;
 316
 317         ret = ustcomm_send_app_msg(sock, &lum);
 318         if (ret)
 319                 return ret;
 320         /* send var len bytecode */
 321         ret = ustcomm_send_unix_sock(sock, bytecode->data,
 322                                 bytecode->len);
 323         if (ret < 0) {
 324                 return ret;
 325         }
 326         if (ret != bytecode->len)
 327                 return -EINVAL;
 328         return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
 329 }
 330
 331 int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion,
 332                 struct lttng_ust_object_data *obj_data)
 333 {
 334         struct ustcomm_ust_msg lum;
 335         struct ustcomm_ust_reply lur;
 336         int ret;
 337
 338         if (!obj_data) {
 339                 return -EINVAL;
 340         }
 341
 342         memset(&lum, 0, sizeof(lum));
 343         lum.handle = obj_data->handle;
 344         lum.cmd = LTTNG_UST_EXCLUSION;
 345         lum.u.exclusion.count = exclusion->count;
 346
 347         ret = ustcomm_send_app_msg(sock, &lum);
 348         if (ret) {
 349                 return ret;
 350         }
 351
 352         /* send var len exclusion names */
 353         ret = ustcomm_send_unix_sock(sock,
 354                         exclusion->names,
 355                         exclusion->count * LTTNG_UST_SYM_NAME_LEN);
 356         if (ret < 0) {
 357                 return ret;
 358         }
 359         if (ret != exclusion->count * LTTNG_UST_SYM_NAME_LEN) {
 360                 return -EINVAL;
 361         }
 362         return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
 363 }
 364
 365 /* Enable event, channel and session ioctl */
 366 int ustctl_enable(int sock, struct lttng_ust_object_data *object)
 367 {
 368         struct ustcomm_ust_msg lum;
 369         struct ustcomm_ust_reply lur;
 370         int ret;
 371
 372         if (!object)
 373                 return -EINVAL;
 374
 375         memset(&lum, 0, sizeof(lum));
 376         lum.handle = object->handle;
 377         lum.cmd = LTTNG_UST_ENABLE;
 378         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 379         if (ret)
 380                 return ret;
 381         DBG("enabled handle %u", object->handle);
 382         return 0;
 383 }
 384
 385 /* Disable event, channel and session ioctl */
 386 int ustctl_disable(int sock, struct lttng_ust_object_data *object)
 387 {
 388         struct ustcomm_ust_msg lum;
 389         struct ustcomm_ust_reply lur;
 390         int ret;
 391
 392         if (!object)
 393                 return -EINVAL;
 394
 395         memset(&lum, 0, sizeof(lum));
 396         lum.handle = object->handle;
 397         lum.cmd = LTTNG_UST_DISABLE;
 398         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 399         if (ret)
 400                 return ret;
 401         DBG("disable handle %u", object->handle);
 402         return 0;
 403 }
 404
 405 int ustctl_start_session(int sock, int handle)
 406 {
 407         struct lttng_ust_object_data obj;
 408
 409         obj.handle = handle;
 410         return ustctl_enable(sock, &obj);
 411 }
 412
 413 int ustctl_stop_session(int sock, int handle)
 414 {
 415         struct lttng_ust_object_data obj;
 416
 417         obj.handle = handle;
 418         return ustctl_disable(sock, &obj);
 419 }
 420
 421 int ustctl_tracepoint_list(int sock)
 422 {
 423         struct ustcomm_ust_msg lum;
 424         struct ustcomm_ust_reply lur;
 425         int ret, tp_list_handle;
 426
 427         memset(&lum, 0, sizeof(lum));
 428         lum.handle = LTTNG_UST_ROOT_HANDLE;
 429         lum.cmd = LTTNG_UST_TRACEPOINT_LIST;
 430         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 431         if (ret)
 432                 return ret;
 433         tp_list_handle = lur.ret_val;
 434         DBG("received tracepoint list handle %u", tp_list_handle);
 435         return tp_list_handle;
 436 }
 437
 438 int ustctl_tracepoint_list_get(int sock, int tp_list_handle,
 439                 struct lttng_ust_tracepoint_iter *iter)
 440 {
 441         struct ustcomm_ust_msg lum;
 442         struct ustcomm_ust_reply lur;
 443         int ret;
 444
 445         if (!iter)
 446                 return -EINVAL;
 447
 448         memset(&lum, 0, sizeof(lum));
 449         lum.handle = tp_list_handle;
 450         lum.cmd = LTTNG_UST_TRACEPOINT_LIST_GET;
 451         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 452         if (ret)
 453                 return ret;
 454         DBG("received tracepoint list entry name %s loglevel %d",
 455                 lur.u.tracepoint.name,
 456                 lur.u.tracepoint.loglevel);
 457         memcpy(iter, &lur.u.tracepoint, sizeof(*iter));
 458         return 0;
 459 }
 460
 461 int ustctl_tracepoint_field_list(int sock)
 462 {
 463         struct ustcomm_ust_msg lum;
 464         struct ustcomm_ust_reply lur;
 465         int ret, tp_field_list_handle;
 466
 467         memset(&lum, 0, sizeof(lum));
 468         lum.handle = LTTNG_UST_ROOT_HANDLE;
 469         lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST;
 470         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 471         if (ret)
 472                 return ret;
 473         tp_field_list_handle = lur.ret_val;
 474         DBG("received tracepoint field list handle %u", tp_field_list_handle);
 475         return tp_field_list_handle;
 476 }
 477
 478 int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle,
 479                 struct lttng_ust_field_iter *iter)
 480 {
 481         struct ustcomm_ust_msg lum;
 482         struct ustcomm_ust_reply lur;
 483         int ret;
 484         ssize_t len;
 485
 486         if (!iter)
 487                 return -EINVAL;
 488
 489         memset(&lum, 0, sizeof(lum));
 490         lum.handle = tp_field_list_handle;
 491         lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST_GET;
 492         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 493         if (ret)
 494                 return ret;
 495         len = ustcomm_recv_unix_sock(sock, iter, sizeof(*iter));
 496         if (len != sizeof(*iter)) {
 497                 return -EINVAL;
 498         }
 499         DBG("received tracepoint field list entry event_name %s event_loglevel %d field_name %s field_type %d",
 500                 iter->event_name,
 501                 iter->loglevel,
 502                 iter->field_name,
 503                 iter->type);
 504         return 0;
 505 }
 506
 507 int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v)
 508 {
 509         struct ustcomm_ust_msg lum;
 510         struct ustcomm_ust_reply lur;
 511         int ret;
 512
 513         if (!v)
 514                 return -EINVAL;
 515
 516         memset(&lum, 0, sizeof(lum));
 517         lum.handle = LTTNG_UST_ROOT_HANDLE;
 518         lum.cmd = LTTNG_UST_TRACER_VERSION;
 519         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 520         if (ret)
 521                 return ret;
 522         memcpy(v, &lur.u.version, sizeof(*v));
 523         DBG("received tracer version");
 524         return 0;
 525 }
 526
 527 int ustctl_wait_quiescent(int sock)
 528 {
 529         struct ustcomm_ust_msg lum;
 530         struct ustcomm_ust_reply lur;
 531         int ret;
 532
 533         memset(&lum, 0, sizeof(lum));
 534         lum.handle = LTTNG_UST_ROOT_HANDLE;
 535         lum.cmd = LTTNG_UST_WAIT_QUIESCENT;
 536         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 537         if (ret)
 538                 return ret;
 539         DBG("waited for quiescent state");
 540         return 0;
 541 }
 542
 543 int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate)
 544 {
 545         if (!calibrate)
 546                 return -EINVAL;
 547
 548         return -ENOSYS;
 549 }
 550
 551 int ustctl_sock_flush_buffer(int sock, struct lttng_ust_object_data *object)
 552 {
 553         struct ustcomm_ust_msg lum;
 554         struct ustcomm_ust_reply lur;
 555         int ret;
 556
 557         if (!object)
 558                 return -EINVAL;
 559
 560         memset(&lum, 0, sizeof(lum));
 561         lum.handle = object->handle;
 562         lum.cmd = LTTNG_UST_FLUSH_BUFFER;
 563         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 564         if (ret)
 565                 return ret;
 566         DBG("flushed buffer handle %u", object->handle);
 567         return 0;
 568 }
 569
 570 static
 571 int ustctl_send_channel(int sock,
 572                 enum lttng_ust_chan_type type,
 573                 void *data,
 574                 uint64_t size,
 575                 int wakeup_fd,
 576                 int send_fd_only)
 577 {
 578         ssize_t len;
 579
 580         if (!send_fd_only) {
 581                 /* Send mmap size */
 582                 len = ustcomm_send_unix_sock(sock, &size, sizeof(size));
 583                 if (len != sizeof(size)) {
 584                         if (len < 0)
 585                                 return len;
 586                         else
 587                                 return -EIO;
 588                 }
 589
 590                 /* Send channel type */
 591                 len = ustcomm_send_unix_sock(sock, &type, sizeof(type));
 592                 if (len != sizeof(type)) {
 593                         if (len < 0)
 594                                 return len;
 595                         else
 596                                 return -EIO;
 597                 }
 598         }
 599
 600         /* Send channel data */
 601         len = ustcomm_send_unix_sock(sock, data, size);
 602         if (len != size) {
 603                 if (len < 0)
 604                         return len;
 605                 else
 606                         return -EIO;
 607         }
 608
 609         /* Send wakeup fd */
 610         len = ustcomm_send_fds_unix_sock(sock, &wakeup_fd, 1);
 611         if (len <= 0) {
 612                 if (len < 0)
 613                         return len;
 614                 else
 615                         return -EIO;
 616         }
 617         return 0;
 618 }
 619
 620 static
 621 int ustctl_send_stream(int sock,
 622                 uint32_t stream_nr,
 623                 uint64_t memory_map_size,
 624                 int shm_fd, int wakeup_fd,
 625                 int send_fd_only)
 626 {
 627         ssize_t len;
 628         int fds[2];
 629
 630         if (!send_fd_only) {
 631                 if (shm_fd < 0) {
 632                         /* finish iteration */
 633                         uint64_t v = -1;
 634
 635                         len = ustcomm_send_unix_sock(sock, &v, sizeof(v));
 636                         if (len != sizeof(v)) {
 637                                 if (len < 0)
 638                                         return len;
 639                                 else
 640                                         return -EIO;
 641                         }
 642                         return 0;
 643                 }
 644
 645                 /* Send mmap size */
 646                 len = ustcomm_send_unix_sock(sock, &memory_map_size,
 647                         sizeof(memory_map_size));
 648                 if (len != sizeof(memory_map_size)) {
 649                         if (len < 0)
 650                                 return len;
 651                         else
 652                                 return -EIO;
 653                 }
 654
 655                 /* Send stream nr */
 656                 len = ustcomm_send_unix_sock(sock, &stream_nr,
 657                         sizeof(stream_nr));
 658                 if (len != sizeof(stream_nr)) {
 659                         if (len < 0)
 660                                 return len;
 661                         else
 662                                 return -EIO;
 663                 }
 664         }
 665
 666         /* Send shm fd and wakeup fd */
 667         fds[0] = shm_fd;
 668         fds[1] = wakeup_fd;
 669         len = ustcomm_send_fds_unix_sock(sock, fds, 2);
 670         if (len <= 0) {
 671                 if (len < 0)
 672                         return len;
 673                 else
 674                         return -EIO;
 675         }
 676         return 0;
 677 }
 678
 679 int ustctl_recv_channel_from_consumer(int sock,
 680                 struct lttng_ust_object_data **_channel_data)
 681 {
 682         struct lttng_ust_object_data *channel_data;
 683         ssize_t len;
 684         int wakeup_fd;
 685         int ret;
 686
 687         channel_data = zmalloc(sizeof(*channel_data));
 688         if (!channel_data) {
 689                 ret = -ENOMEM;
 690                 goto error_alloc;
 691         }
 692         channel_data->type = LTTNG_UST_OBJECT_TYPE_CHANNEL;
 693         channel_data->handle = -1;
 694
 695         /* recv mmap size */
 696         len = ustcomm_recv_unix_sock(sock, &channel_data->size,
 697                         sizeof(channel_data->size));
 698         if (len != sizeof(channel_data->size)) {
 699                 if (len < 0)
 700                         ret = len;
 701                 else
 702                         ret = -EINVAL;
 703                 goto error;
 704         }
 705
 706         /* recv channel type */
 707         len = ustcomm_recv_unix_sock(sock, &channel_data->u.channel.type,
 708                         sizeof(channel_data->u.channel.type));
 709         if (len != sizeof(channel_data->u.channel.type)) {
 710                 if (len < 0)
 711                         ret = len;
 712                 else
 713                         ret = -EINVAL;
 714                 goto error;
 715         }
 716
 717         /* recv channel data */
 718         channel_data->u.channel.data = zmalloc(channel_data->size);
 719         if (!channel_data->u.channel.data) {
 720                 ret = -ENOMEM;
 721                 goto error;
 722         }
 723         len = ustcomm_recv_unix_sock(sock, channel_data->u.channel.data,
 724                         channel_data->size);
 725         if (len != channel_data->size) {
 726                 if (len < 0)
 727                         ret = len;
 728                 else
 729                         ret = -EINVAL;
 730                 goto error_recv_data;
 731         }
 732         /* recv wakeup fd */
 733         len = ustcomm_recv_fds_unix_sock(sock, &wakeup_fd, 1);
 734         if (len <= 0) {
 735                 if (len < 0) {
 736                         ret = len;
 737                         goto error_recv_data;
 738                 } else {
 739                         ret = -EIO;
 740                         goto error_recv_data;
 741                 }
 742         }
 743         channel_data->u.channel.wakeup_fd = wakeup_fd;
 744         *_channel_data = channel_data;
 745         return 0;
 746
 747 error_recv_data:
 748         free(channel_data->u.channel.data);
 749 error:
 750         free(channel_data);
 751 error_alloc:
 752         return ret;
 753 }
 754
 755 int ustctl_recv_stream_from_consumer(int sock,
 756                 struct lttng_ust_object_data **_stream_data)
 757 {
 758         struct lttng_ust_object_data *stream_data;
 759         ssize_t len;
 760         int ret;
 761         int fds[2];
 762
 763         stream_data = zmalloc(sizeof(*stream_data));
 764         if (!stream_data) {
 765                 ret = -ENOMEM;
 766                 goto error_alloc;
 767         }
 768
 769         stream_data->type = LTTNG_UST_OBJECT_TYPE_STREAM;
 770         stream_data->handle = -1;
 771
 772         /* recv mmap size */
 773         len = ustcomm_recv_unix_sock(sock, &stream_data->size,
 774                         sizeof(stream_data->size));
 775         if (len != sizeof(stream_data->size)) {
 776                 if (len < 0)
 777                         ret = len;
 778                 else
 779                         ret = -EINVAL;
 780                 goto error;
 781         }
 782         if (stream_data->size == -1) {
 783                 ret = -LTTNG_UST_ERR_NOENT;
 784                 goto error;
 785         }
 786
 787         /* recv stream nr */
 788         len = ustcomm_recv_unix_sock(sock, &stream_data->u.stream.stream_nr,
 789                         sizeof(stream_data->u.stream.stream_nr));
 790         if (len != sizeof(stream_data->u.stream.stream_nr)) {
 791                 if (len < 0)
 792                         ret = len;
 793                 else
 794                         ret = -EINVAL;
 795                 goto error;
 796         }
 797
 798         /* recv shm fd and wakeup fd */
 799         len = ustcomm_recv_fds_unix_sock(sock, fds, 2);
 800         if (len <= 0) {
 801                 if (len < 0) {
 802                         ret = len;
 803                         goto error;
 804                 } else {
 805                         ret = -EIO;
 806                         goto error;
 807                 }
 808         }
 809         stream_data->u.stream.shm_fd = fds[0];
 810         stream_data->u.stream.wakeup_fd = fds[1];
 811         *_stream_data = stream_data;
 812         return 0;
 813
 814 error:
 815         free(stream_data);
 816 error_alloc:
 817         return ret;
 818 }
 819
 820 int ustctl_send_channel_to_ust(int sock, int session_handle,
 821                 struct lttng_ust_object_data *channel_data)
 822 {
 823         struct ustcomm_ust_msg lum;
 824         struct ustcomm_ust_reply lur;
 825         int ret;
 826
 827         if (!channel_data)
 828                 return -EINVAL;
 829
 830         memset(&lum, 0, sizeof(lum));
 831         lum.handle = session_handle;
 832         lum.cmd = LTTNG_UST_CHANNEL;
 833         lum.u.channel.len = channel_data->size;
 834         lum.u.channel.type = channel_data->u.channel.type;
 835         ret = ustcomm_send_app_msg(sock, &lum);
 836         if (ret)
 837                 return ret;
 838
 839         ret = ustctl_send_channel(sock,
 840                         channel_data->u.channel.type,
 841                         channel_data->u.channel.data,
 842                         channel_data->size,
 843                         channel_data->u.channel.wakeup_fd,
 844                         1);
 845         if (ret)
 846                 return ret;
 847         ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
 848         if (!ret) {
 849                 channel_data->handle = lur.ret_val;
 850         }
 851         return ret;
 852 }
 853
 854 int ustctl_send_stream_to_ust(int sock,
 855                 struct lttng_ust_object_data *channel_data,
 856                 struct lttng_ust_object_data *stream_data)
 857 {
 858         struct ustcomm_ust_msg lum;
 859         struct ustcomm_ust_reply lur;
 860         int ret;
 861
 862         memset(&lum, 0, sizeof(lum));
 863         lum.handle = channel_data->handle;
 864         lum.cmd = LTTNG_UST_STREAM;
 865         lum.u.stream.len = stream_data->size;
 866         lum.u.stream.stream_nr = stream_data->u.stream.stream_nr;
 867         ret = ustcomm_send_app_msg(sock, &lum);
 868         if (ret)
 869                 return ret;
 870
 871         assert(stream_data);
 872         assert(stream_data->type == LTTNG_UST_OBJECT_TYPE_STREAM);
 873
 874         ret = ustctl_send_stream(sock,
 875                         stream_data->u.stream.stream_nr,
 876                         stream_data->size,
 877                         stream_data->u.stream.shm_fd,
 878                         stream_data->u.stream.wakeup_fd, 1);
 879         if (ret)
 880                 return ret;
 881         return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
 882 }
 883
 884 int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest,
 885                 struct lttng_ust_object_data *src)
 886 {
 887         struct lttng_ust_object_data *obj;
 888         int ret;
 889
 890         if (src->handle != -1) {
 891                 ret = -EINVAL;
 892                 goto error;
 893         }
 894
 895         obj = zmalloc(sizeof(*obj));
 896         if (!obj) {
 897                 ret = -ENOMEM;
 898                 goto error;
 899         }
 900
 901         obj->type = src->type;
 902         obj->handle = src->handle;
 903         obj->size = src->size;
 904
 905         switch (obj->type) {
 906         case LTTNG_UST_OBJECT_TYPE_CHANNEL:
 907         {
 908                 obj->u.channel.type = src->u.channel.type;
 909                 if (src->u.channel.wakeup_fd >= 0) {
 910                         obj->u.channel.wakeup_fd =
 911                                 dup(src->u.channel.wakeup_fd);
 912                         if (obj->u.channel.wakeup_fd < 0) {
 913                                 ret = errno;
 914                                 goto chan_error_wakeup_fd;
 915                         }
 916                 } else {
 917                         obj->u.channel.wakeup_fd =
 918                                 src->u.channel.wakeup_fd;
 919                 }
 920                 obj->u.channel.data = zmalloc(obj->size);
 921                 if (!obj->u.channel.data) {
 922                         ret = -ENOMEM;
 923                         goto chan_error_alloc;
 924                 }
 925                 memcpy(obj->u.channel.data, src->u.channel.data, obj->size);
 926                 break;
 927
 928         chan_error_alloc:
 929                 if (src->u.channel.wakeup_fd >= 0) {
 930                         int closeret;
 931
 932                         closeret = close(obj->u.channel.wakeup_fd);
 933                         if (closeret) {
 934                                 PERROR("close");
 935                         }
 936                 }
 937         chan_error_wakeup_fd:
 938                 goto error_type;
 939
 940         }
 941
 942         case LTTNG_UST_OBJECT_TYPE_STREAM:
 943         {
 944                 obj->u.stream.stream_nr = src->u.stream.stream_nr;
 945                 if (src->u.stream.wakeup_fd >= 0) {
 946                         obj->u.stream.wakeup_fd =
 947                                 dup(src->u.stream.wakeup_fd);
 948                         if (obj->u.stream.wakeup_fd < 0) {
 949                                 ret = errno;
 950                                 goto stream_error_wakeup_fd;
 951                         }
 952                 } else {
 953                         obj->u.stream.wakeup_fd =
 954                                 src->u.stream.wakeup_fd;
 955                 }
 956
 957                 if (src->u.stream.shm_fd >= 0) {
 958                         obj->u.stream.shm_fd =
 959                                 dup(src->u.stream.shm_fd);
 960                         if (obj->u.stream.shm_fd < 0) {
 961                                 ret = errno;
 962                                 goto stream_error_shm_fd;
 963                         }
 964                 } else {
 965                         obj->u.stream.shm_fd =
 966                                 src->u.stream.shm_fd;
 967                 }
 968                 break;
 969
 970         stream_error_shm_fd:
 971                 if (src->u.stream.wakeup_fd >= 0) {
 972                         int closeret;
 973
 974                         closeret = close(obj->u.stream.wakeup_fd);
 975                         if (closeret) {
 976                                 PERROR("close");
 977                         }
 978                 }
 979         stream_error_wakeup_fd:
 980                 goto error_type;
 981         }
 982
 983         default:
 984                 ret = -EINVAL;
 985                 goto error_type;
 986         }
 987
 988         *dest = obj;
 989         return 0;
 990
 991 error_type:
 992         free(obj);
 993 error:
 994         return ret;
 995 }
 996
 997
 998 /* Buffer operations */
 999
1000 int ustctl_get_nr_stream_per_channel(void)
1001 {
1002         return num_possible_cpus();
1003 }
1004
1005 struct ustctl_consumer_channel *
1006         ustctl_create_channel(struct ustctl_consumer_channel_attr *attr,
1007                 const int *stream_fds, int nr_stream_fds)
1008 {
1009         struct ustctl_consumer_channel *chan;
1010         const char *transport_name;
1011         struct lttng_transport *transport;
1012
1013         switch (attr->type) {
1014         case LTTNG_UST_CHAN_PER_CPU:
1015                 if (attr->output == LTTNG_UST_MMAP) {
1016                         if (attr->overwrite) {
1017                                 if (attr->read_timer_interval == 0) {
1018                                         transport_name = "relay-overwrite-mmap";
1019                                 } else {
1020                                         transport_name = "relay-overwrite-rt-mmap";
1021                                 }
1022                         } else {
1023                                 if (attr->read_timer_interval == 0) {
1024                                         transport_name = "relay-discard-mmap";
1025                                 } else {
1026                                         transport_name = "relay-discard-rt-mmap";
1027                                 }
1028                         }
1029                 } else {
1030                         return NULL;
1031                 }
1032                 break;
1033         case LTTNG_UST_CHAN_METADATA:
1034                 if (attr->output == LTTNG_UST_MMAP)
1035                         transport_name = "relay-metadata-mmap";
1036                 else
1037                         return NULL;
1038                 break;
1039         default:
1040                 transport_name = "<unknown>";
1041                 return NULL;
1042         }
1043
1044         transport = lttng_transport_find(transport_name);
1045         if (!transport) {
1046                 DBG("LTTng transport %s not found\n",
1047                         transport_name);
1048                 return NULL;
1049         }
1050
1051         chan = zmalloc(sizeof(*chan));
1052         if (!chan)
1053                 return NULL;
1054
1055         chan->chan = transport->ops.channel_create(transport_name, NULL,
1056                         attr->subbuf_size, attr->num_subbuf,
1057                         attr->switch_timer_interval,
1058                         attr->read_timer_interval,
1059                         attr->uuid, attr->chan_id,
1060                         stream_fds, nr_stream_fds);
1061         if (!chan->chan) {
1062                 goto chan_error;
1063         }
1064         chan->chan->ops = &transport->ops;
1065         memcpy(&chan->attr, attr, sizeof(chan->attr));
1066         chan->wait_fd = ustctl_channel_get_wait_fd(chan);
1067         chan->wakeup_fd = ustctl_channel_get_wakeup_fd(chan);
1068         return chan;
1069
1070 chan_error:
1071         free(chan);
1072         return NULL;
1073 }
1074
1075 void ustctl_destroy_channel(struct ustctl_consumer_channel *chan)
1076 {
1077         (void) ustctl_channel_close_wait_fd(chan);
1078         (void) ustctl_channel_close_wakeup_fd(chan);
1079         chan->chan->ops->channel_destroy(chan->chan);
1080         free(chan);
1081 }
1082
1083 int ustctl_send_channel_to_sessiond(int sock,
1084                 struct ustctl_consumer_channel *channel)
1085 {
1086         struct shm_object_table *table;
1087
1088         table = channel->chan->handle->table;
1089         if (table->size <= 0)
1090                 return -EINVAL;
1091         return ustctl_send_channel(sock,
1092                         channel->attr.type,
1093                         table->objects[0].memory_map,
1094                         table->objects[0].memory_map_size,
1095                         channel->wakeup_fd,
1096                         0);
1097 }
1098
1099 int ustctl_send_stream_to_sessiond(int sock,
1100                 struct ustctl_consumer_stream *stream)
1101 {
1102         if (!stream)
1103                 return ustctl_send_stream(sock, -1U, -1U, -1, -1, 0);
1104
1105         return ustctl_send_stream(sock,
1106                         stream->cpu,
1107                         stream->memory_map_size,
1108                         stream->shm_fd, stream->wakeup_fd,
1109                         0);
1110 }
1111
1112 int ustctl_write_metadata_to_channel(
1113                 struct ustctl_consumer_channel *channel,
1114                 const char *metadata_str,       /* NOT null-terminated */
1115                 size_t len)                     /* metadata length */
1116 {
1117         struct lttng_ust_lib_ring_buffer_ctx ctx;
1118         struct lttng_channel *chan = channel->chan;
1119         const char *str = metadata_str;
1120         int ret = 0, waitret;
1121         size_t reserve_len, pos;
1122
1123         for (pos = 0; pos < len; pos += reserve_len) {
1124                 reserve_len = min_t(size_t,
1125                                 chan->ops->packet_avail_size(chan->chan, chan->handle),
1126                                 len - pos);
1127                 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
1128                                          sizeof(char), -1, chan->handle, NULL);
1129                 /*
1130                  * We don't care about metadata buffer's records lost
1131                  * count, because we always retry here. Report error if
1132                  * we need to bail out after timeout or being
1133                  * interrupted.
1134                  */
1135                 waitret = wait_cond_interruptible_timeout(
1136                         ({
1137                                 ret = chan->ops->event_reserve(&ctx, 0);
1138                                 ret != -ENOBUFS || !ret;
1139                         }),
1140                         LTTNG_METADATA_TIMEOUT_MSEC);
1141                 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
1142                         DBG("LTTng: Failure to write metadata to buffers (%s)\n",
1143                                 waitret == -EINTR ? "interrupted" :
1144                                         (ret == -ENOBUFS ? "timeout" : "I/O error"));
1145                         if (waitret == -EINTR)
1146                                 ret = waitret;
1147                         goto end;
1148                 }
1149                 chan->ops->event_write(&ctx, &str[pos], reserve_len);
1150                 chan->ops->event_commit(&ctx);
1151         }
1152 end:
1153         return ret;
1154 }
1155
1156 /*
1157  * Write at most one packet in the channel.
1158  * Returns the number of bytes written on success, < 0 on error.
1159  */
1160 ssize_t ustctl_write_one_packet_to_channel(
1161                 struct ustctl_consumer_channel *channel,
1162                 const char *metadata_str,       /* NOT null-terminated */
1163                 size_t len)                     /* metadata length */
1164 {
1165         struct lttng_ust_lib_ring_buffer_ctx ctx;
1166         struct lttng_channel *chan = channel->chan;
1167         const char *str = metadata_str;
1168         ssize_t reserve_len;
1169         int ret;
1170
1171         reserve_len = min_t(ssize_t,
1172                         chan->ops->packet_avail_size(chan->chan, chan->handle),
1173                         len);
1174         lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
1175                         sizeof(char), -1, chan->handle, NULL);
1176         ret = chan->ops->event_reserve(&ctx, 0);
1177         if (ret != 0) {
1178                 DBG("LTTng: event reservation failed");
1179                 assert(ret < 0);
1180                 reserve_len = ret;
1181                 goto end;
1182         }
1183         chan->ops->event_write(&ctx, str, reserve_len);
1184         chan->ops->event_commit(&ctx);
1185
1186 end:
1187         return reserve_len;
1188 }
1189
1190 int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan)
1191 {
1192         struct channel *chan;
1193         int ret;
1194
1195         chan = consumer_chan->chan->chan;
1196         ret = ring_buffer_channel_close_wait_fd(&chan->backend.config,
1197                         chan, chan->handle);
1198         if (!ret)
1199                 consumer_chan->wait_fd = -1;
1200         return ret;
1201 }
1202
1203 int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan)
1204 {
1205         struct channel *chan;
1206         int ret;
1207
1208         chan = consumer_chan->chan->chan;
1209         ret = ring_buffer_channel_close_wakeup_fd(&chan->backend.config,
1210                         chan, chan->handle);
1211         if (!ret)
1212                 consumer_chan->wakeup_fd = -1;
1213         return ret;
1214 }
1215
1216 int ustctl_stream_close_wait_fd(struct ustctl_consumer_stream *stream)
1217 {
1218         struct channel *chan;
1219
1220         chan = stream->chan->chan->chan;
1221         return ring_buffer_stream_close_wait_fd(&chan->backend.config,
1222                         chan, stream->handle, stream->cpu);
1223 }
1224
1225 int ustctl_stream_close_wakeup_fd(struct ustctl_consumer_stream *stream)
1226 {
1227         struct channel *chan;
1228
1229         chan = stream->chan->chan->chan;
1230         return ring_buffer_stream_close_wakeup_fd(&chan->backend.config,
1231                         chan, stream->handle, stream->cpu);
1232 }
1233
1234 struct ustctl_consumer_stream *
1235         ustctl_create_stream(struct ustctl_consumer_channel *channel,
1236                         int cpu)
1237 {
1238         struct ustctl_consumer_stream *stream;
1239         struct lttng_ust_shm_handle *handle;
1240         struct channel *chan;
1241         int shm_fd, wait_fd, wakeup_fd;
1242         uint64_t memory_map_size;
1243         struct lttng_ust_lib_ring_buffer *buf;
1244         int ret;
1245
1246         if (!channel)
1247                 return NULL;
1248         handle = channel->chan->handle;
1249         if (!handle)
1250                 return NULL;
1251
1252         chan = channel->chan->chan;
1253         buf = channel_get_ring_buffer(&chan->backend.config,
1254                 chan, cpu, handle, &shm_fd, &wait_fd,
1255                 &wakeup_fd, &memory_map_size);
1256         if (!buf)
1257                 return NULL;
1258         ret = lib_ring_buffer_open_read(buf, handle);
1259         if (ret)
1260                 return NULL;
1261
1262         stream = zmalloc(sizeof(*stream));
1263         if (!stream)
1264                 goto alloc_error;
1265         stream->handle = handle;
1266         stream->buf = buf;
1267         stream->chan = channel;
1268         stream->shm_fd = shm_fd;
1269         stream->wait_fd = wait_fd;
1270         stream->wakeup_fd = wakeup_fd;
1271         stream->memory_map_size = memory_map_size;
1272         stream->cpu = cpu;
1273         return stream;
1274
1275 alloc_error:
1276         return NULL;
1277 }
1278
1279 void ustctl_destroy_stream(struct ustctl_consumer_stream *stream)
1280 {
1281         struct lttng_ust_lib_ring_buffer *buf;
1282         struct ustctl_consumer_channel *consumer_chan;
1283
1284         assert(stream);
1285         buf = stream->buf;
1286         consumer_chan = stream->chan;
1287         (void) ustctl_stream_close_wait_fd(stream);
1288         (void) ustctl_stream_close_wakeup_fd(stream);
1289         lib_ring_buffer_release_read(buf, consumer_chan->chan->handle);
1290         free(stream);
1291 }
1292
1293 int ustctl_channel_get_wait_fd(struct ustctl_consumer_channel *chan)
1294 {
1295         if (!chan)
1296                 return -EINVAL;
1297         return shm_get_wait_fd(chan->chan->handle,
1298                 &chan->chan->handle->chan._ref);
1299 }
1300
1301 int ustctl_channel_get_wakeup_fd(struct ustctl_consumer_channel *chan)
1302 {
1303         if (!chan)
1304                 return -EINVAL;
1305         return shm_get_wakeup_fd(chan->chan->handle,
1306                 &chan->chan->handle->chan._ref);
1307 }
1308
1309 int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream)
1310 {
1311         struct lttng_ust_lib_ring_buffer *buf;
1312         struct ustctl_consumer_channel *consumer_chan;
1313
1314         if (!stream)
1315                 return -EINVAL;
1316         buf = stream->buf;
1317         consumer_chan = stream->chan;
1318         return shm_get_wait_fd(consumer_chan->chan->handle, &buf->self._ref);
1319 }
1320
1321 int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream)
1322 {
1323         struct lttng_ust_lib_ring_buffer *buf;
1324         struct ustctl_consumer_channel *consumer_chan;
1325
1326         if (!stream)
1327                 return -EINVAL;
1328         buf = stream->buf;
1329         consumer_chan = stream->chan;
1330         return shm_get_wakeup_fd(consumer_chan->chan->handle, &buf->self._ref);
1331 }
1332
1333 /* For mmap mode, readable without "get" operation */
1334
1335 void *ustctl_get_mmap_base(struct ustctl_consumer_stream *stream)
1336 {
1337         struct lttng_ust_lib_ring_buffer *buf;
1338         struct ustctl_consumer_channel *consumer_chan;
1339
1340         if (!stream)
1341                 return NULL;
1342         buf = stream->buf;
1343         consumer_chan = stream->chan;
1344         return shmp(consumer_chan->chan->handle, buf->backend.memory_map);
1345 }
1346
1347 /* returns the length to mmap. */
1348 int ustctl_get_mmap_len(struct ustctl_consumer_stream *stream,
1349                 unsigned long *len)
1350 {
1351         struct ustctl_consumer_channel *consumer_chan;
1352         unsigned long mmap_buf_len;
1353         struct channel *chan;
1354
1355         if (!stream)
1356                 return -EINVAL;
1357         consumer_chan = stream->chan;
1358         chan = consumer_chan->chan->chan;
1359         if (chan->backend.config.output != RING_BUFFER_MMAP)
1360                 return -EINVAL;
1361         mmap_buf_len = chan->backend.buf_size;
1362         if (chan->backend.extra_reader_sb)
1363                 mmap_buf_len += chan->backend.subbuf_size;
1364         if (mmap_buf_len > INT_MAX)
1365                 return -EFBIG;
1366         *len = mmap_buf_len;
1367         return 0;
1368 }
1369
1370 /* returns the maximum size for sub-buffers. */
1371 int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream,
1372                 unsigned long *len)
1373 {
1374         struct ustctl_consumer_channel *consumer_chan;
1375         struct channel *chan;
1376
1377         if (!stream)
1378                 return -EINVAL;
1379         consumer_chan = stream->chan;
1380         chan = consumer_chan->chan->chan;
1381         *len = chan->backend.subbuf_size;
1382         return 0;
1383 }
1384
1385 /*
1386  * For mmap mode, operate on the current packet (between get/put or
1387  * get_next/put_next).
1388  */
1389
1390 /* returns the offset of the subbuffer belonging to the mmap reader. */
1391 int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream,
1392                 unsigned long *off)
1393 {
1394         struct channel *chan;
1395         unsigned long sb_bindex;
1396         struct lttng_ust_lib_ring_buffer *buf;
1397         struct ustctl_consumer_channel *consumer_chan;
1398         struct lttng_ust_lib_ring_buffer_backend_pages_shmp *barray_idx;
1399         struct lttng_ust_lib_ring_buffer_backend_pages *pages;
1400
1401         if (!stream)
1402                 return -EINVAL;
1403         buf = stream->buf;
1404         consumer_chan = stream->chan;
1405         chan = consumer_chan->chan->chan;
1406         if (chan->backend.config.output != RING_BUFFER_MMAP)
1407                 return -EINVAL;
1408         sb_bindex = subbuffer_id_get_index(&chan->backend.config,
1409                                         buf->backend.buf_rsb.id);
1410         barray_idx = shmp_index(consumer_chan->chan->handle, buf->backend.array,
1411                         sb_bindex);
1412         if (!barray_idx)
1413                 return -EINVAL;
1414         pages = shmp(consumer_chan->chan->handle, barray_idx->shmp);
1415         if (!pages)
1416                 return -EINVAL;
1417         *off = pages->mmap_offset;
1418         return 0;
1419 }
1420
1421 /* returns the size of the current sub-buffer, without padding (for mmap). */
1422 int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream,
1423                 unsigned long *len)
1424 {
1425         struct ustctl_consumer_channel *consumer_chan;
1426         struct channel *chan;
1427         struct lttng_ust_lib_ring_buffer *buf;
1428
1429         if (!stream)
1430                 return -EINVAL;
1431
1432         buf = stream->buf;
1433         consumer_chan = stream->chan;
1434         chan = consumer_chan->chan->chan;
1435         *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
1436                 consumer_chan->chan->handle);
1437         return 0;
1438 }
1439
1440 /* returns the size of the current sub-buffer, without padding (for mmap). */
1441 int ustctl_get_padded_subbuf_size(struct ustctl_consumer_stream *stream,
1442                 unsigned long *len)
1443 {
1444         struct ustctl_consumer_channel *consumer_chan;
1445         struct channel *chan;
1446         struct lttng_ust_lib_ring_buffer *buf;
1447
1448         if (!stream)
1449                 return -EINVAL;
1450         buf = stream->buf;
1451         consumer_chan = stream->chan;
1452         chan = consumer_chan->chan->chan;
1453         *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
1454                 consumer_chan->chan->handle);
1455         *len = PAGE_ALIGN(*len);
1456         return 0;
1457 }
1458
1459 /* Get exclusive read access to the next sub-buffer that can be read. */
1460 int ustctl_get_next_subbuf(struct ustctl_consumer_stream *stream)
1461 {
1462         struct lttng_ust_lib_ring_buffer *buf;
1463         struct ustctl_consumer_channel *consumer_chan;
1464
1465         if (!stream)
1466                 return -EINVAL;
1467         buf = stream->buf;
1468         consumer_chan = stream->chan;
1469         return lib_ring_buffer_get_next_subbuf(buf,
1470                         consumer_chan->chan->handle);
1471 }
1472
1473
1474 /* Release exclusive sub-buffer access, move consumer forward. */
1475 int ustctl_put_next_subbuf(struct ustctl_consumer_stream *stream)
1476 {
1477         struct lttng_ust_lib_ring_buffer *buf;
1478         struct ustctl_consumer_channel *consumer_chan;
1479
1480         if (!stream)
1481                 return -EINVAL;
1482         buf = stream->buf;
1483         consumer_chan = stream->chan;
1484         lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->handle);
1485         return 0;
1486 }
1487
1488 /* snapshot */
1489
1490 /* Get a snapshot of the current ring buffer producer and consumer positions */
1491 int ustctl_snapshot(struct ustctl_consumer_stream *stream)
1492 {
1493         struct lttng_ust_lib_ring_buffer *buf;
1494         struct ustctl_consumer_channel *consumer_chan;
1495
1496         if (!stream)
1497                 return -EINVAL;
1498         buf = stream->buf;
1499         consumer_chan = stream->chan;
1500         return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
1501                         &buf->prod_snapshot, consumer_chan->chan->handle);
1502 }
1503
1504 /*
1505  * Get a snapshot of the current ring buffer producer and consumer positions
1506  * even if the consumed and produced positions are contained within the same
1507  * subbuffer.
1508  */
1509 int ustctl_snapshot_sample_positions(struct ustctl_consumer_stream *stream)
1510 {
1511         struct lttng_ust_lib_ring_buffer *buf;
1512         struct ustctl_consumer_channel *consumer_chan;
1513
1514         if (!stream)
1515                 return -EINVAL;
1516         buf = stream->buf;
1517         consumer_chan = stream->chan;
1518         return lib_ring_buffer_snapshot_sample_positions(buf,
1519                         &buf->cons_snapshot, &buf->prod_snapshot,
1520                         consumer_chan->chan->handle);
1521 }
1522
1523 /* Get the consumer position (iteration start) */
1524 int ustctl_snapshot_get_consumed(struct ustctl_consumer_stream *stream,
1525                 unsigned long *pos)
1526 {
1527         struct lttng_ust_lib_ring_buffer *buf;
1528
1529         if (!stream)
1530                 return -EINVAL;
1531         buf = stream->buf;
1532         *pos = buf->cons_snapshot;
1533         return 0;
1534 }
1535
1536 /* Get the producer position (iteration end) */
1537 int ustctl_snapshot_get_produced(struct ustctl_consumer_stream *stream,
1538                 unsigned long *pos)
1539 {
1540         struct lttng_ust_lib_ring_buffer *buf;
1541
1542         if (!stream)
1543                 return -EINVAL;
1544         buf = stream->buf;
1545         *pos = buf->prod_snapshot;
1546         return 0;
1547 }
1548
1549 /* Get exclusive read access to the specified sub-buffer position */
1550 int ustctl_get_subbuf(struct ustctl_consumer_stream *stream,
1551                 unsigned long *pos)
1552 {
1553         struct lttng_ust_lib_ring_buffer *buf;
1554         struct ustctl_consumer_channel *consumer_chan;
1555
1556         if (!stream)
1557                 return -EINVAL;
1558         buf = stream->buf;
1559         consumer_chan = stream->chan;
1560         return lib_ring_buffer_get_subbuf(buf, *pos,
1561                         consumer_chan->chan->handle);
1562 }
1563
1564 /* Release exclusive sub-buffer access */
1565 int ustctl_put_subbuf(struct ustctl_consumer_stream *stream)
1566 {
1567         struct lttng_ust_lib_ring_buffer *buf;
1568         struct ustctl_consumer_channel *consumer_chan;
1569
1570         if (!stream)
1571                 return -EINVAL;
1572         buf = stream->buf;
1573         consumer_chan = stream->chan;
1574         lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->handle);
1575         return 0;
1576 }
1577
1578 void ustctl_flush_buffer(struct ustctl_consumer_stream *stream,
1579                 int producer_active)
1580 {
1581         struct lttng_ust_lib_ring_buffer *buf;
1582         struct ustctl_consumer_channel *consumer_chan;
1583
1584         assert(stream);
1585         buf = stream->buf;
1586         consumer_chan = stream->chan;
1587         lib_ring_buffer_switch_slow(buf,
1588                 producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH,
1589                 consumer_chan->chan->handle);
1590 }
1591
1592 static
1593 struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb(
1594                 struct lttng_ust_lib_ring_buffer *buf,
1595                 struct lttng_ust_shm_handle *handle)
1596 {
1597         struct channel *chan;
1598         const struct lttng_ust_lib_ring_buffer_config *config;
1599         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1600
1601         chan = shmp(handle, buf->backend.chan);
1602         if (!chan)
1603                 return NULL;
1604         config = &chan->backend.config;
1605         if (!config->cb_ptr)
1606                 return NULL;
1607         client_cb = caa_container_of(config->cb_ptr,
1608                         struct lttng_ust_client_lib_ring_buffer_client_cb,
1609                         parent);
1610         return client_cb;
1611 }
1612
1613 int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream,
1614                 uint64_t *timestamp_begin)
1615 {
1616         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1617         struct lttng_ust_lib_ring_buffer *buf;
1618         struct lttng_ust_shm_handle *handle;
1619
1620         if (!stream || !timestamp_begin)
1621                 return -EINVAL;
1622         buf = stream->buf;
1623         handle = stream->chan->chan->handle;
1624         client_cb = get_client_cb(buf, handle);
1625         if (!client_cb)
1626                 return -ENOSYS;
1627         return client_cb->timestamp_begin(buf, handle, timestamp_begin);
1628 }
1629
1630 int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream,
1631         uint64_t *timestamp_end)
1632 {
1633         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1634         struct lttng_ust_lib_ring_buffer *buf;
1635         struct lttng_ust_shm_handle *handle;
1636
1637         if (!stream || !timestamp_end)
1638                 return -EINVAL;
1639         buf = stream->buf;
1640         handle = stream->chan->chan->handle;
1641         client_cb = get_client_cb(buf, handle);
1642         if (!client_cb)
1643                 return -ENOSYS;
1644         return client_cb->timestamp_end(buf, handle, timestamp_end);
1645 }
1646
1647 int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream,
1648         uint64_t *events_discarded)
1649 {
1650         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1651         struct lttng_ust_lib_ring_buffer *buf;
1652         struct lttng_ust_shm_handle *handle;
1653
1654         if (!stream || !events_discarded)
1655                 return -EINVAL;
1656         buf = stream->buf;
1657         handle = stream->chan->chan->handle;
1658         client_cb = get_client_cb(buf, handle);
1659         if (!client_cb)
1660                 return -ENOSYS;
1661         return client_cb->events_discarded(buf, handle, events_discarded);
1662 }
1663
1664 int ustctl_get_content_size(struct ustctl_consumer_stream *stream,
1665         uint64_t *content_size)
1666 {
1667         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1668         struct lttng_ust_lib_ring_buffer *buf;
1669         struct lttng_ust_shm_handle *handle;
1670
1671         if (!stream || !content_size)
1672                 return -EINVAL;
1673         buf = stream->buf;
1674         handle = stream->chan->chan->handle;
1675         client_cb = get_client_cb(buf, handle);
1676         if (!client_cb)
1677                 return -ENOSYS;
1678         return client_cb->content_size(buf, handle, content_size);
1679 }
1680
1681 int ustctl_get_packet_size(struct ustctl_consumer_stream *stream,
1682         uint64_t *packet_size)
1683 {
1684         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1685         struct lttng_ust_lib_ring_buffer *buf;
1686         struct lttng_ust_shm_handle *handle;
1687
1688         if (!stream || !packet_size)
1689                 return -EINVAL;
1690         buf = stream->buf;
1691         handle = stream->chan->chan->handle;
1692         client_cb = get_client_cb(buf, handle);
1693         if (!client_cb)
1694                 return -ENOSYS;
1695         return client_cb->packet_size(buf, handle, packet_size);
1696 }
1697
1698 int ustctl_get_stream_id(struct ustctl_consumer_stream *stream,
1699                 uint64_t *stream_id)
1700 {
1701         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1702         struct lttng_ust_lib_ring_buffer *buf;
1703         struct lttng_ust_shm_handle *handle;
1704
1705         if (!stream || !stream_id)
1706                 return -EINVAL;
1707         buf = stream->buf;
1708         handle = stream->chan->chan->handle;
1709         client_cb = get_client_cb(buf, handle);
1710         if (!client_cb)
1711                 return -ENOSYS;
1712         return client_cb->stream_id(buf, handle, stream_id);
1713 }
1714
1715 int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream,
1716                 uint64_t *ts)
1717 {
1718         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1719         struct lttng_ust_lib_ring_buffer *buf;
1720         struct lttng_ust_shm_handle *handle;
1721
1722         if (!stream || !ts)
1723                 return -EINVAL;
1724         buf = stream->buf;
1725         handle = stream->chan->chan->handle;
1726         client_cb = get_client_cb(buf, handle);
1727         if (!client_cb || !client_cb->current_timestamp)
1728                 return -ENOSYS;
1729         return client_cb->current_timestamp(buf, handle, ts);
1730 }
1731
1732 int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream,
1733                 uint64_t *seq)
1734 {
1735         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1736         struct lttng_ust_lib_ring_buffer *buf;
1737         struct lttng_ust_shm_handle *handle;
1738
1739         if (!stream || !seq)
1740                 return -EINVAL;
1741         buf = stream->buf;
1742         handle = stream->chan->chan->handle;
1743         client_cb = get_client_cb(buf, handle);
1744         if (!client_cb || !client_cb->sequence_number)
1745                 return -ENOSYS;
1746         return client_cb->sequence_number(buf, handle, seq);
1747 }
1748
1749 int ustctl_get_instance_id(struct ustctl_consumer_stream *stream,
1750                 uint64_t *id)
1751 {
1752         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1753         struct lttng_ust_lib_ring_buffer *buf;
1754         struct lttng_ust_shm_handle *handle;
1755
1756         if (!stream || !id)
1757                 return -EINVAL;
1758         buf = stream->buf;
1759         handle = stream->chan->chan->handle;
1760         client_cb = get_client_cb(buf, handle);
1761         if (!client_cb)
1762                 return -ENOSYS;
1763         return client_cb->instance_id(buf, handle, id);
1764 }
1765
1766 #ifdef LTTNG_UST_HAVE_PERF_EVENT
1767
1768 int ustctl_has_perf_counters(void)
1769 {
1770         return 1;
1771 }
1772
1773 #else
1774
1775 int ustctl_has_perf_counters(void)
1776 {
1777         return 0;
1778 }
1779
1780 #endif
1781
1782 /*
1783  * Returns 0 on success, negative error value on error.
1784  */
1785 int ustctl_recv_reg_msg(int sock,
1786         enum ustctl_socket_type *type,
1787         uint32_t *major,
1788         uint32_t *minor,
1789         uint32_t *pid,
1790         uint32_t *ppid,
1791         uint32_t *uid,
1792         uint32_t *gid,
1793         uint32_t *bits_per_long,
1794         uint32_t *uint8_t_alignment,
1795         uint32_t *uint16_t_alignment,
1796         uint32_t *uint32_t_alignment,
1797         uint32_t *uint64_t_alignment,
1798         uint32_t *long_alignment,
1799         int *byte_order,
1800         char *name)
1801 {
1802         ssize_t len;
1803         struct ustctl_reg_msg reg_msg;
1804
1805         len = ustcomm_recv_unix_sock(sock, &reg_msg, sizeof(reg_msg));
1806         if (len > 0 && len != sizeof(reg_msg))
1807                 return -EIO;
1808         if (len == 0)
1809                 return -EPIPE;
1810         if (len < 0)
1811                 return len;
1812
1813         if (reg_msg.magic == LTTNG_UST_COMM_MAGIC) {
1814                 *byte_order = BYTE_ORDER == BIG_ENDIAN ?
1815                                 BIG_ENDIAN : LITTLE_ENDIAN;
1816         } else if (reg_msg.magic == bswap_32(LTTNG_UST_COMM_MAGIC)) {
1817                 *byte_order = BYTE_ORDER == BIG_ENDIAN ?
1818                                 LITTLE_ENDIAN : BIG_ENDIAN;
1819         } else {
1820                 return -LTTNG_UST_ERR_INVAL_MAGIC;
1821         }
1822         switch (reg_msg.socket_type) {
1823         case 0: *type = USTCTL_SOCKET_CMD;
1824                 break;
1825         case 1: *type = USTCTL_SOCKET_NOTIFY;
1826                 break;
1827         default:
1828                 return -LTTNG_UST_ERR_INVAL_SOCKET_TYPE;
1829         }
1830         *major = reg_msg.major;
1831         *minor = reg_msg.minor;
1832         *pid = reg_msg.pid;
1833         *ppid = reg_msg.ppid;
1834         *uid = reg_msg.uid;
1835         *gid = reg_msg.gid;
1836         *bits_per_long = reg_msg.bits_per_long;
1837         *uint8_t_alignment = reg_msg.uint8_t_alignment;
1838         *uint16_t_alignment = reg_msg.uint16_t_alignment;
1839         *uint32_t_alignment = reg_msg.uint32_t_alignment;
1840         *uint64_t_alignment = reg_msg.uint64_t_alignment;
1841         *long_alignment = reg_msg.long_alignment;
1842         memcpy(name, reg_msg.name, LTTNG_UST_ABI_PROCNAME_LEN);
1843         if (reg_msg.major != LTTNG_UST_ABI_MAJOR_VERSION) {
1844                 return -LTTNG_UST_ERR_UNSUP_MAJOR;
1845         }
1846
1847         return 0;
1848 }
1849
1850 int ustctl_recv_notify(int sock, enum ustctl_notify_cmd *notify_cmd)
1851 {
1852         struct ustcomm_notify_hdr header;
1853         ssize_t len;
1854
1855         len = ustcomm_recv_unix_sock(sock, &header, sizeof(header));
1856         if (len > 0 && len != sizeof(header))
1857                 return -EIO;
1858         if (len == 0)
1859                 return -EPIPE;
1860         if (len < 0)
1861                 return len;
1862         switch (header.notify_cmd) {
1863         case 0:
1864                 *notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
1865                 break;
1866         case 1:
1867                 *notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL;
1868                 break;
1869         case 2:
1870                 *notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
1871                 break;
1872         default:
1873                 return -EINVAL;
1874         }
1875         return 0;
1876 }
1877
1878 /*
1879  * Returns 0 on success, negative error value on error.
1880  */
1881 int ustctl_recv_register_event(int sock,
1882         int *session_objd,
1883         int *channel_objd,
1884         char *event_name,
1885         int *loglevel,
1886         char **signature,
1887         size_t *nr_fields,
1888         struct ustctl_field **fields,
1889         char **model_emf_uri)
1890 {
1891         ssize_t len;
1892         struct ustcomm_notify_event_msg msg;
1893         size_t signature_len, fields_len, model_emf_uri_len;
1894         char *a_sign = NULL, *a_model_emf_uri = NULL;
1895         struct ustctl_field *a_fields = NULL;
1896
1897         len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
1898         if (len > 0 && len != sizeof(msg))
1899                 return -EIO;
1900         if (len == 0)
1901                 return -EPIPE;
1902         if (len < 0)
1903                 return len;
1904
1905         *session_objd = msg.session_objd;
1906         *channel_objd = msg.channel_objd;
1907         strncpy(event_name, msg.event_name, LTTNG_UST_SYM_NAME_LEN);
1908         event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
1909         *loglevel = msg.loglevel;
1910         signature_len = msg.signature_len;
1911         fields_len = msg.fields_len;
1912
1913         if (fields_len % sizeof(*a_fields) != 0) {
1914                 return -EINVAL;
1915         }
1916
1917         model_emf_uri_len = msg.model_emf_uri_len;
1918
1919         /* recv signature. contains at least \0. */
1920         a_sign = zmalloc(signature_len);
1921         if (!a_sign)
1922                 return -ENOMEM;
1923         len = ustcomm_recv_unix_sock(sock, a_sign, signature_len);
1924         if (len > 0 && len != signature_len) {
1925                 len = -EIO;
1926                 goto signature_error;
1927         }
1928         if (len == 0) {
1929                 len = -EPIPE;
1930                 goto signature_error;
1931         }
1932         if (len < 0) {
1933                 goto signature_error;
1934         }
1935         /* Enforce end of string */
1936         a_sign[signature_len - 1] = '\0';
1937
1938         /* recv fields */
1939         if (fields_len) {
1940                 a_fields = zmalloc(fields_len);
1941                 if (!a_fields) {
1942                         len = -ENOMEM;
1943                         goto signature_error;
1944                 }
1945                 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
1946                 if (len > 0 && len != fields_len) {
1947                         len = -EIO;
1948                         goto fields_error;
1949                 }
1950                 if (len == 0) {
1951                         len = -EPIPE;
1952                         goto fields_error;
1953                 }
1954                 if (len < 0) {
1955                         goto fields_error;
1956                 }
1957         }
1958
1959         if (model_emf_uri_len) {
1960                 /* recv model_emf_uri_len */
1961                 a_model_emf_uri = zmalloc(model_emf_uri_len);
1962                 if (!a_model_emf_uri) {
1963                         len = -ENOMEM;
1964                         goto fields_error;
1965                 }
1966                 len = ustcomm_recv_unix_sock(sock, a_model_emf_uri,
1967                                 model_emf_uri_len);
1968                 if (len > 0 && len != model_emf_uri_len) {
1969                         len = -EIO;
1970                         goto model_error;
1971                 }
1972                 if (len == 0) {
1973                         len = -EPIPE;
1974                         goto model_error;
1975                 }
1976                 if (len < 0) {
1977                         goto model_error;
1978                 }
1979                 /* Enforce end of string */
1980                 a_model_emf_uri[model_emf_uri_len - 1] = '\0';
1981         }
1982
1983         *signature = a_sign;
1984         *nr_fields = fields_len / sizeof(*a_fields);
1985         *fields = a_fields;
1986         *model_emf_uri = a_model_emf_uri;
1987
1988         return 0;
1989
1990 model_error:
1991         free(a_model_emf_uri);
1992 fields_error:
1993         free(a_fields);
1994 signature_error:
1995         free(a_sign);
1996         return len;
1997 }
1998
1999 /*
2000  * Returns 0 on success, negative error value on error.
2001  */
2002 int ustctl_reply_register_event(int sock,
2003         uint32_t id,
2004         int ret_code)
2005 {
2006         ssize_t len;
2007         struct {
2008                 struct ustcomm_notify_hdr header;
2009                 struct ustcomm_notify_event_reply r;
2010         } reply;
2011
2012         memset(&reply, 0, sizeof(reply));
2013         reply.header.notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
2014         reply.r.ret_code = ret_code;
2015         reply.r.event_id = id;
2016         len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2017         if (len > 0 && len != sizeof(reply))
2018                 return -EIO;
2019         if (len < 0)
2020                 return len;
2021         return 0;
2022 }
2023
2024 /*
2025  * Returns 0 on success, negative UST or system error value on error.
2026  */
2027 int ustctl_recv_register_enum(int sock,
2028         int *session_objd,
2029         char *enum_name,
2030         struct ustctl_enum_entry **entries,
2031         size_t *nr_entries)
2032 {
2033         ssize_t len;
2034         struct ustcomm_notify_enum_msg msg;
2035         size_t entries_len;
2036         struct ustctl_enum_entry *a_entries = NULL;
2037
2038         len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2039         if (len > 0 && len != sizeof(msg))
2040                 return -EIO;
2041         if (len == 0)
2042                 return -EPIPE;
2043         if (len < 0)
2044                 return len;
2045
2046         *session_objd = msg.session_objd;
2047         strncpy(enum_name, msg.enum_name, LTTNG_UST_SYM_NAME_LEN);
2048         enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
2049         entries_len = msg.entries_len;
2050
2051         if (entries_len % sizeof(*a_entries) != 0) {
2052                 return -EINVAL;
2053         }
2054
2055         /* recv entries */
2056         if (entries_len) {
2057                 a_entries = zmalloc(entries_len);
2058                 if (!a_entries)
2059                         return -ENOMEM;
2060                 len = ustcomm_recv_unix_sock(sock, a_entries, entries_len);
2061                 if (len > 0 && len != entries_len) {
2062                         len = -EIO;
2063                         goto entries_error;
2064                 }
2065                 if (len == 0) {
2066                         len = -EPIPE;
2067                         goto entries_error;
2068                 }
2069                 if (len < 0) {
2070                         goto entries_error;
2071                 }
2072         }
2073         *nr_entries = entries_len / sizeof(*a_entries);
2074         *entries = a_entries;
2075
2076         return 0;
2077
2078 entries_error:
2079         free(a_entries);
2080         return len;
2081 }
2082
2083 /*
2084  * Returns 0 on success, negative error value on error.
2085  */
2086 int ustctl_reply_register_enum(int sock,
2087         uint64_t id,
2088         int ret_code)
2089 {
2090         ssize_t len;
2091         struct {
2092                 struct ustcomm_notify_hdr header;
2093                 struct ustcomm_notify_enum_reply r;
2094         } reply;
2095
2096         memset(&reply, 0, sizeof(reply));
2097         reply.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
2098         reply.r.ret_code = ret_code;
2099         reply.r.enum_id = id;
2100         len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2101         if (len > 0 && len != sizeof(reply))
2102                 return -EIO;
2103         if (len < 0)
2104                 return len;
2105         return 0;
2106 }
2107
2108 /*
2109  * Returns 0 on success, negative UST or system error value on error.
2110  */
2111 int ustctl_recv_register_channel(int sock,
2112         int *session_objd,              /* session descriptor (output) */
2113         int *channel_objd,              /* channel descriptor (output) */
2114         size_t *nr_fields,
2115         struct ustctl_field **fields)
2116 {
2117         ssize_t len;
2118         struct ustcomm_notify_channel_msg msg;
2119         size_t fields_len;
2120         struct ustctl_field *a_fields;
2121
2122         len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2123         if (len > 0 && len != sizeof(msg))
2124                 return -EIO;
2125         if (len == 0)
2126                 return -EPIPE;
2127         if (len < 0)
2128                 return len;
2129
2130         *session_objd = msg.session_objd;
2131         *channel_objd = msg.channel_objd;
2132         fields_len = msg.ctx_fields_len;
2133
2134         if (fields_len % sizeof(*a_fields) != 0) {
2135                 return -EINVAL;
2136         }
2137
2138         /* recv fields */
2139         if (fields_len) {
2140                 a_fields = zmalloc(fields_len);
2141                 if (!a_fields) {
2142                         len = -ENOMEM;
2143                         goto alloc_error;
2144                 }
2145                 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
2146                 if (len > 0 && len != fields_len) {
2147                         len = -EIO;
2148                         goto fields_error;
2149                 }
2150                 if (len == 0) {
2151                         len = -EPIPE;
2152                         goto fields_error;
2153                 }
2154                 if (len < 0) {
2155                         goto fields_error;
2156                 }
2157                 *fields = a_fields;
2158         } else {
2159                 *fields = NULL;
2160         }
2161         *nr_fields = fields_len / sizeof(*a_fields);
2162         return 0;
2163
2164 fields_error:
2165         free(a_fields);
2166 alloc_error:
2167         return len;
2168 }
2169
2170 /*
2171  * Returns 0 on success, negative error value on error.
2172  */
2173 int ustctl_reply_register_channel(int sock,
2174         uint32_t chan_id,
2175         enum ustctl_channel_header header_type,
2176         int ret_code)
2177 {
2178         ssize_t len;
2179         struct {
2180                 struct ustcomm_notify_hdr header;
2181                 struct ustcomm_notify_channel_reply r;
2182         } reply;
2183
2184         memset(&reply, 0, sizeof(reply));
2185         reply.header.notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL;
2186         reply.r.ret_code = ret_code;
2187         reply.r.chan_id = chan_id;
2188         switch (header_type) {
2189         case USTCTL_CHANNEL_HEADER_COMPACT:
2190                 reply.r.header_type = 1;
2191                 break;
2192         case USTCTL_CHANNEL_HEADER_LARGE:
2193                 reply.r.header_type = 2;
2194                 break;
2195         default:
2196                 reply.r.header_type = 0;
2197                 break;
2198         }
2199         len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2200         if (len > 0 && len != sizeof(reply))
2201                 return -EIO;
2202         if (len < 0)
2203                 return len;
2204         return 0;
2205 }
2206
2207 /* Regenerate the statedump. */
2208 int ustctl_regenerate_statedump(int sock, int handle)
2209 {
2210         struct ustcomm_ust_msg lum;
2211         struct ustcomm_ust_reply lur;
2212         int ret;
2213
2214         memset(&lum, 0, sizeof(lum));
2215         lum.handle = handle;
2216         lum.cmd = LTTNG_UST_SESSION_STATEDUMP;
2217         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
2218         if (ret)
2219                 return ret;
2220         DBG("Regenerated statedump for handle %u", handle);
2221         return 0;
2222 }
2223
2224 static __attribute__((constructor))
2225 void ustctl_init(void)
2226 {
2227         init_usterr();
2228         lttng_ust_getenv_init();        /* Needs init_usterr() to be completed. */
2229         lttng_ust_clock_init();
2230         lttng_ring_buffer_metadata_client_init();
2231         lttng_ring_buffer_client_overwrite_init();
2232         lttng_ring_buffer_client_overwrite_rt_init();
2233         lttng_ring_buffer_client_discard_init();
2234         lttng_ring_buffer_client_discard_rt_init();
2235         lib_ringbuffer_signal_init();
2236 }
2237
2238 static __attribute__((destructor))
2239 void ustctl_exit(void)
2240 {
2241         lttng_ring_buffer_client_discard_rt_exit();
2242         lttng_ring_buffer_client_discard_exit();
2243         lttng_ring_buffer_client_overwrite_rt_exit();
2244         lttng_ring_buffer_client_overwrite_exit();
2245         lttng_ring_buffer_metadata_client_exit();
2246 }