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 /* Get the consumer position (iteration start) */
1505 int ustctl_snapshot_get_consumed(struct ustctl_consumer_stream *stream,
1506                 unsigned long *pos)
1507 {
1508         struct lttng_ust_lib_ring_buffer *buf;
1509
1510         if (!stream)
1511                 return -EINVAL;
1512         buf = stream->buf;
1513         *pos = buf->cons_snapshot;
1514         return 0;
1515 }
1516
1517 /* Get the producer position (iteration end) */
1518 int ustctl_snapshot_get_produced(struct ustctl_consumer_stream *stream,
1519                 unsigned long *pos)
1520 {
1521         struct lttng_ust_lib_ring_buffer *buf;
1522
1523         if (!stream)
1524                 return -EINVAL;
1525         buf = stream->buf;
1526         *pos = buf->prod_snapshot;
1527         return 0;
1528 }
1529
1530 /* Get exclusive read access to the specified sub-buffer position */
1531 int ustctl_get_subbuf(struct ustctl_consumer_stream *stream,
1532                 unsigned long *pos)
1533 {
1534         struct lttng_ust_lib_ring_buffer *buf;
1535         struct ustctl_consumer_channel *consumer_chan;
1536
1537         if (!stream)
1538                 return -EINVAL;
1539         buf = stream->buf;
1540         consumer_chan = stream->chan;
1541         return lib_ring_buffer_get_subbuf(buf, *pos,
1542                         consumer_chan->chan->handle);
1543 }
1544
1545 /* Release exclusive sub-buffer access */
1546 int ustctl_put_subbuf(struct ustctl_consumer_stream *stream)
1547 {
1548         struct lttng_ust_lib_ring_buffer *buf;
1549         struct ustctl_consumer_channel *consumer_chan;
1550
1551         if (!stream)
1552                 return -EINVAL;
1553         buf = stream->buf;
1554         consumer_chan = stream->chan;
1555         lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->handle);
1556         return 0;
1557 }
1558
1559 void ustctl_flush_buffer(struct ustctl_consumer_stream *stream,
1560                 int producer_active)
1561 {
1562         struct lttng_ust_lib_ring_buffer *buf;
1563         struct ustctl_consumer_channel *consumer_chan;
1564
1565         assert(stream);
1566         buf = stream->buf;
1567         consumer_chan = stream->chan;
1568         lib_ring_buffer_switch_slow(buf,
1569                 producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH,
1570                 consumer_chan->chan->handle);
1571 }
1572
1573 static
1574 struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb(
1575                 struct lttng_ust_lib_ring_buffer *buf,
1576                 struct lttng_ust_shm_handle *handle)
1577 {
1578         struct channel *chan;
1579         const struct lttng_ust_lib_ring_buffer_config *config;
1580         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1581
1582         chan = shmp(handle, buf->backend.chan);
1583         if (!chan)
1584                 return NULL;
1585         config = &chan->backend.config;
1586         if (!config->cb_ptr)
1587                 return NULL;
1588         client_cb = caa_container_of(config->cb_ptr,
1589                         struct lttng_ust_client_lib_ring_buffer_client_cb,
1590                         parent);
1591         return client_cb;
1592 }
1593
1594 int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream,
1595                 uint64_t *timestamp_begin)
1596 {
1597         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1598         struct lttng_ust_lib_ring_buffer *buf;
1599         struct lttng_ust_shm_handle *handle;
1600
1601         if (!stream || !timestamp_begin)
1602                 return -EINVAL;
1603         buf = stream->buf;
1604         handle = stream->chan->chan->handle;
1605         client_cb = get_client_cb(buf, handle);
1606         if (!client_cb)
1607                 return -ENOSYS;
1608         return client_cb->timestamp_begin(buf, handle, timestamp_begin);
1609 }
1610
1611 int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream,
1612         uint64_t *timestamp_end)
1613 {
1614         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1615         struct lttng_ust_lib_ring_buffer *buf;
1616         struct lttng_ust_shm_handle *handle;
1617
1618         if (!stream || !timestamp_end)
1619                 return -EINVAL;
1620         buf = stream->buf;
1621         handle = stream->chan->chan->handle;
1622         client_cb = get_client_cb(buf, handle);
1623         if (!client_cb)
1624                 return -ENOSYS;
1625         return client_cb->timestamp_end(buf, handle, timestamp_end);
1626 }
1627
1628 int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream,
1629         uint64_t *events_discarded)
1630 {
1631         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1632         struct lttng_ust_lib_ring_buffer *buf;
1633         struct lttng_ust_shm_handle *handle;
1634
1635         if (!stream || !events_discarded)
1636                 return -EINVAL;
1637         buf = stream->buf;
1638         handle = stream->chan->chan->handle;
1639         client_cb = get_client_cb(buf, handle);
1640         if (!client_cb)
1641                 return -ENOSYS;
1642         return client_cb->events_discarded(buf, handle, events_discarded);
1643 }
1644
1645 int ustctl_get_content_size(struct ustctl_consumer_stream *stream,
1646         uint64_t *content_size)
1647 {
1648         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1649         struct lttng_ust_lib_ring_buffer *buf;
1650         struct lttng_ust_shm_handle *handle;
1651
1652         if (!stream || !content_size)
1653                 return -EINVAL;
1654         buf = stream->buf;
1655         handle = stream->chan->chan->handle;
1656         client_cb = get_client_cb(buf, handle);
1657         if (!client_cb)
1658                 return -ENOSYS;
1659         return client_cb->content_size(buf, handle, content_size);
1660 }
1661
1662 int ustctl_get_packet_size(struct ustctl_consumer_stream *stream,
1663         uint64_t *packet_size)
1664 {
1665         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1666         struct lttng_ust_lib_ring_buffer *buf;
1667         struct lttng_ust_shm_handle *handle;
1668
1669         if (!stream || !packet_size)
1670                 return -EINVAL;
1671         buf = stream->buf;
1672         handle = stream->chan->chan->handle;
1673         client_cb = get_client_cb(buf, handle);
1674         if (!client_cb)
1675                 return -ENOSYS;
1676         return client_cb->packet_size(buf, handle, packet_size);
1677 }
1678
1679 int ustctl_get_stream_id(struct ustctl_consumer_stream *stream,
1680                 uint64_t *stream_id)
1681 {
1682         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1683         struct lttng_ust_lib_ring_buffer *buf;
1684         struct lttng_ust_shm_handle *handle;
1685
1686         if (!stream || !stream_id)
1687                 return -EINVAL;
1688         buf = stream->buf;
1689         handle = stream->chan->chan->handle;
1690         client_cb = get_client_cb(buf, handle);
1691         if (!client_cb)
1692                 return -ENOSYS;
1693         return client_cb->stream_id(buf, handle, stream_id);
1694 }
1695
1696 int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream,
1697                 uint64_t *ts)
1698 {
1699         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1700         struct lttng_ust_lib_ring_buffer *buf;
1701         struct lttng_ust_shm_handle *handle;
1702
1703         if (!stream || !ts)
1704                 return -EINVAL;
1705         buf = stream->buf;
1706         handle = stream->chan->chan->handle;
1707         client_cb = get_client_cb(buf, handle);
1708         if (!client_cb || !client_cb->current_timestamp)
1709                 return -ENOSYS;
1710         return client_cb->current_timestamp(buf, handle, ts);
1711 }
1712
1713 int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream,
1714                 uint64_t *seq)
1715 {
1716         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1717         struct lttng_ust_lib_ring_buffer *buf;
1718         struct lttng_ust_shm_handle *handle;
1719
1720         if (!stream || !seq)
1721                 return -EINVAL;
1722         buf = stream->buf;
1723         handle = stream->chan->chan->handle;
1724         client_cb = get_client_cb(buf, handle);
1725         if (!client_cb || !client_cb->sequence_number)
1726                 return -ENOSYS;
1727         return client_cb->sequence_number(buf, handle, seq);
1728 }
1729
1730 int ustctl_get_instance_id(struct ustctl_consumer_stream *stream,
1731                 uint64_t *id)
1732 {
1733         struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
1734         struct lttng_ust_lib_ring_buffer *buf;
1735         struct lttng_ust_shm_handle *handle;
1736
1737         if (!stream || !id)
1738                 return -EINVAL;
1739         buf = stream->buf;
1740         handle = stream->chan->chan->handle;
1741         client_cb = get_client_cb(buf, handle);
1742         if (!client_cb)
1743                 return -ENOSYS;
1744         return client_cb->instance_id(buf, handle, id);
1745 }
1746
1747 #ifdef LTTNG_UST_HAVE_PERF_EVENT
1748
1749 int ustctl_has_perf_counters(void)
1750 {
1751         return 1;
1752 }
1753
1754 #else
1755
1756 int ustctl_has_perf_counters(void)
1757 {
1758         return 0;
1759 }
1760
1761 #endif
1762
1763 /*
1764  * Returns 0 on success, negative error value on error.
1765  */
1766 int ustctl_recv_reg_msg(int sock,
1767         enum ustctl_socket_type *type,
1768         uint32_t *major,
1769         uint32_t *minor,
1770         uint32_t *pid,
1771         uint32_t *ppid,
1772         uint32_t *uid,
1773         uint32_t *gid,
1774         uint32_t *bits_per_long,
1775         uint32_t *uint8_t_alignment,
1776         uint32_t *uint16_t_alignment,
1777         uint32_t *uint32_t_alignment,
1778         uint32_t *uint64_t_alignment,
1779         uint32_t *long_alignment,
1780         int *byte_order,
1781         char *name)
1782 {
1783         ssize_t len;
1784         struct ustctl_reg_msg reg_msg;
1785
1786         len = ustcomm_recv_unix_sock(sock, &reg_msg, sizeof(reg_msg));
1787         if (len > 0 && len != sizeof(reg_msg))
1788                 return -EIO;
1789         if (len == 0)
1790                 return -EPIPE;
1791         if (len < 0)
1792                 return len;
1793
1794         if (reg_msg.magic == LTTNG_UST_COMM_MAGIC) {
1795                 *byte_order = BYTE_ORDER == BIG_ENDIAN ?
1796                                 BIG_ENDIAN : LITTLE_ENDIAN;
1797         } else if (reg_msg.magic == bswap_32(LTTNG_UST_COMM_MAGIC)) {
1798                 *byte_order = BYTE_ORDER == BIG_ENDIAN ?
1799                                 LITTLE_ENDIAN : BIG_ENDIAN;
1800         } else {
1801                 return -LTTNG_UST_ERR_INVAL_MAGIC;
1802         }
1803         switch (reg_msg.socket_type) {
1804         case 0: *type = USTCTL_SOCKET_CMD;
1805                 break;
1806         case 1: *type = USTCTL_SOCKET_NOTIFY;
1807                 break;
1808         default:
1809                 return -LTTNG_UST_ERR_INVAL_SOCKET_TYPE;
1810         }
1811         *major = reg_msg.major;
1812         *minor = reg_msg.minor;
1813         *pid = reg_msg.pid;
1814         *ppid = reg_msg.ppid;
1815         *uid = reg_msg.uid;
1816         *gid = reg_msg.gid;
1817         *bits_per_long = reg_msg.bits_per_long;
1818         *uint8_t_alignment = reg_msg.uint8_t_alignment;
1819         *uint16_t_alignment = reg_msg.uint16_t_alignment;
1820         *uint32_t_alignment = reg_msg.uint32_t_alignment;
1821         *uint64_t_alignment = reg_msg.uint64_t_alignment;
1822         *long_alignment = reg_msg.long_alignment;
1823         memcpy(name, reg_msg.name, LTTNG_UST_ABI_PROCNAME_LEN);
1824         if (reg_msg.major != LTTNG_UST_ABI_MAJOR_VERSION) {
1825                 return -LTTNG_UST_ERR_UNSUP_MAJOR;
1826         }
1827
1828         return 0;
1829 }
1830
1831 int ustctl_recv_notify(int sock, enum ustctl_notify_cmd *notify_cmd)
1832 {
1833         struct ustcomm_notify_hdr header;
1834         ssize_t len;
1835
1836         len = ustcomm_recv_unix_sock(sock, &header, sizeof(header));
1837         if (len > 0 && len != sizeof(header))
1838                 return -EIO;
1839         if (len == 0)
1840                 return -EPIPE;
1841         if (len < 0)
1842                 return len;
1843         switch (header.notify_cmd) {
1844         case 0:
1845                 *notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
1846                 break;
1847         case 1:
1848                 *notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL;
1849                 break;
1850         case 2:
1851                 *notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
1852                 break;
1853         default:
1854                 return -EINVAL;
1855         }
1856         return 0;
1857 }
1858
1859 /*
1860  * Returns 0 on success, negative error value on error.
1861  */
1862 int ustctl_recv_register_event(int sock,
1863         int *session_objd,
1864         int *channel_objd,
1865         char *event_name,
1866         int *loglevel,
1867         char **signature,
1868         size_t *nr_fields,
1869         struct ustctl_field **fields,
1870         char **model_emf_uri)
1871 {
1872         ssize_t len;
1873         struct ustcomm_notify_event_msg msg;
1874         size_t signature_len, fields_len, model_emf_uri_len;
1875         char *a_sign = NULL, *a_model_emf_uri = NULL;
1876         struct ustctl_field *a_fields = NULL;
1877
1878         len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
1879         if (len > 0 && len != sizeof(msg))
1880                 return -EIO;
1881         if (len == 0)
1882                 return -EPIPE;
1883         if (len < 0)
1884                 return len;
1885
1886         *session_objd = msg.session_objd;
1887         *channel_objd = msg.channel_objd;
1888         strncpy(event_name, msg.event_name, LTTNG_UST_SYM_NAME_LEN);
1889         event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
1890         *loglevel = msg.loglevel;
1891         signature_len = msg.signature_len;
1892         fields_len = msg.fields_len;
1893
1894         if (fields_len % sizeof(*a_fields) != 0) {
1895                 return -EINVAL;
1896         }
1897
1898         model_emf_uri_len = msg.model_emf_uri_len;
1899
1900         /* recv signature. contains at least \0. */
1901         a_sign = zmalloc(signature_len);
1902         if (!a_sign)
1903                 return -ENOMEM;
1904         len = ustcomm_recv_unix_sock(sock, a_sign, signature_len);
1905         if (len > 0 && len != signature_len) {
1906                 len = -EIO;
1907                 goto signature_error;
1908         }
1909         if (len == 0) {
1910                 len = -EPIPE;
1911                 goto signature_error;
1912         }
1913         if (len < 0) {
1914                 goto signature_error;
1915         }
1916         /* Enforce end of string */
1917         a_sign[signature_len - 1] = '\0';
1918
1919         /* recv fields */
1920         if (fields_len) {
1921                 a_fields = zmalloc(fields_len);
1922                 if (!a_fields) {
1923                         len = -ENOMEM;
1924                         goto signature_error;
1925                 }
1926                 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
1927                 if (len > 0 && len != fields_len) {
1928                         len = -EIO;
1929                         goto fields_error;
1930                 }
1931                 if (len == 0) {
1932                         len = -EPIPE;
1933                         goto fields_error;
1934                 }
1935                 if (len < 0) {
1936                         goto fields_error;
1937                 }
1938         }
1939
1940         if (model_emf_uri_len) {
1941                 /* recv model_emf_uri_len */
1942                 a_model_emf_uri = zmalloc(model_emf_uri_len);
1943                 if (!a_model_emf_uri) {
1944                         len = -ENOMEM;
1945                         goto fields_error;
1946                 }
1947                 len = ustcomm_recv_unix_sock(sock, a_model_emf_uri,
1948                                 model_emf_uri_len);
1949                 if (len > 0 && len != model_emf_uri_len) {
1950                         len = -EIO;
1951                         goto model_error;
1952                 }
1953                 if (len == 0) {
1954                         len = -EPIPE;
1955                         goto model_error;
1956                 }
1957                 if (len < 0) {
1958                         goto model_error;
1959                 }
1960                 /* Enforce end of string */
1961                 a_model_emf_uri[model_emf_uri_len - 1] = '\0';
1962         }
1963
1964         *signature = a_sign;
1965         *nr_fields = fields_len / sizeof(*a_fields);
1966         *fields = a_fields;
1967         *model_emf_uri = a_model_emf_uri;
1968
1969         return 0;
1970
1971 model_error:
1972         free(a_model_emf_uri);
1973 fields_error:
1974         free(a_fields);
1975 signature_error:
1976         free(a_sign);
1977         return len;
1978 }
1979
1980 /*
1981  * Returns 0 on success, negative error value on error.
1982  */
1983 int ustctl_reply_register_event(int sock,
1984         uint32_t id,
1985         int ret_code)
1986 {
1987         ssize_t len;
1988         struct {
1989                 struct ustcomm_notify_hdr header;
1990                 struct ustcomm_notify_event_reply r;
1991         } reply;
1992
1993         memset(&reply, 0, sizeof(reply));
1994         reply.header.notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
1995         reply.r.ret_code = ret_code;
1996         reply.r.event_id = id;
1997         len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
1998         if (len > 0 && len != sizeof(reply))
1999                 return -EIO;
2000         if (len < 0)
2001                 return len;
2002         return 0;
2003 }
2004
2005 /*
2006  * Returns 0 on success, negative UST or system error value on error.
2007  */
2008 int ustctl_recv_register_enum(int sock,
2009         int *session_objd,
2010         char *enum_name,
2011         struct ustctl_enum_entry **entries,
2012         size_t *nr_entries)
2013 {
2014         ssize_t len;
2015         struct ustcomm_notify_enum_msg msg;
2016         size_t entries_len;
2017         struct ustctl_enum_entry *a_entries = NULL;
2018
2019         len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2020         if (len > 0 && len != sizeof(msg))
2021                 return -EIO;
2022         if (len == 0)
2023                 return -EPIPE;
2024         if (len < 0)
2025                 return len;
2026
2027         *session_objd = msg.session_objd;
2028         strncpy(enum_name, msg.enum_name, LTTNG_UST_SYM_NAME_LEN);
2029         enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
2030         entries_len = msg.entries_len;
2031
2032         if (entries_len % sizeof(*a_entries) != 0) {
2033                 return -EINVAL;
2034         }
2035
2036         /* recv entries */
2037         if (entries_len) {
2038                 a_entries = zmalloc(entries_len);
2039                 if (!a_entries)
2040                         return -ENOMEM;
2041                 len = ustcomm_recv_unix_sock(sock, a_entries, entries_len);
2042                 if (len > 0 && len != entries_len) {
2043                         len = -EIO;
2044                         goto entries_error;
2045                 }
2046                 if (len == 0) {
2047                         len = -EPIPE;
2048                         goto entries_error;
2049                 }
2050                 if (len < 0) {
2051                         goto entries_error;
2052                 }
2053         }
2054         *nr_entries = entries_len / sizeof(*a_entries);
2055         *entries = a_entries;
2056
2057         return 0;
2058
2059 entries_error:
2060         free(a_entries);
2061         return len;
2062 }
2063
2064 /*
2065  * Returns 0 on success, negative error value on error.
2066  */
2067 int ustctl_reply_register_enum(int sock,
2068         uint64_t id,
2069         int ret_code)
2070 {
2071         ssize_t len;
2072         struct {
2073                 struct ustcomm_notify_hdr header;
2074                 struct ustcomm_notify_enum_reply r;
2075         } reply;
2076
2077         memset(&reply, 0, sizeof(reply));
2078         reply.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
2079         reply.r.ret_code = ret_code;
2080         reply.r.enum_id = id;
2081         len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2082         if (len > 0 && len != sizeof(reply))
2083                 return -EIO;
2084         if (len < 0)
2085                 return len;
2086         return 0;
2087 }
2088
2089 /*
2090  * Returns 0 on success, negative UST or system error value on error.
2091  */
2092 int ustctl_recv_register_channel(int sock,
2093         int *session_objd,              /* session descriptor (output) */
2094         int *channel_objd,              /* channel descriptor (output) */
2095         size_t *nr_fields,
2096         struct ustctl_field **fields)
2097 {
2098         ssize_t len;
2099         struct ustcomm_notify_channel_msg msg;
2100         size_t fields_len;
2101         struct ustctl_field *a_fields;
2102
2103         len = ustcomm_recv_unix_sock(sock, &msg, sizeof(msg));
2104         if (len > 0 && len != sizeof(msg))
2105                 return -EIO;
2106         if (len == 0)
2107                 return -EPIPE;
2108         if (len < 0)
2109                 return len;
2110
2111         *session_objd = msg.session_objd;
2112         *channel_objd = msg.channel_objd;
2113         fields_len = msg.ctx_fields_len;
2114
2115         if (fields_len % sizeof(*a_fields) != 0) {
2116                 return -EINVAL;
2117         }
2118
2119         /* recv fields */
2120         if (fields_len) {
2121                 a_fields = zmalloc(fields_len);
2122                 if (!a_fields) {
2123                         len = -ENOMEM;
2124                         goto alloc_error;
2125                 }
2126                 len = ustcomm_recv_unix_sock(sock, a_fields, fields_len);
2127                 if (len > 0 && len != fields_len) {
2128                         len = -EIO;
2129                         goto fields_error;
2130                 }
2131                 if (len == 0) {
2132                         len = -EPIPE;
2133                         goto fields_error;
2134                 }
2135                 if (len < 0) {
2136                         goto fields_error;
2137                 }
2138                 *fields = a_fields;
2139         } else {
2140                 *fields = NULL;
2141         }
2142         *nr_fields = fields_len / sizeof(*a_fields);
2143         return 0;
2144
2145 fields_error:
2146         free(a_fields);
2147 alloc_error:
2148         return len;
2149 }
2150
2151 /*
2152  * Returns 0 on success, negative error value on error.
2153  */
2154 int ustctl_reply_register_channel(int sock,
2155         uint32_t chan_id,
2156         enum ustctl_channel_header header_type,
2157         int ret_code)
2158 {
2159         ssize_t len;
2160         struct {
2161                 struct ustcomm_notify_hdr header;
2162                 struct ustcomm_notify_channel_reply r;
2163         } reply;
2164
2165         memset(&reply, 0, sizeof(reply));
2166         reply.header.notify_cmd = USTCTL_NOTIFY_CMD_CHANNEL;
2167         reply.r.ret_code = ret_code;
2168         reply.r.chan_id = chan_id;
2169         switch (header_type) {
2170         case USTCTL_CHANNEL_HEADER_COMPACT:
2171                 reply.r.header_type = 1;
2172                 break;
2173         case USTCTL_CHANNEL_HEADER_LARGE:
2174                 reply.r.header_type = 2;
2175                 break;
2176         default:
2177                 reply.r.header_type = 0;
2178                 break;
2179         }
2180         len = ustcomm_send_unix_sock(sock, &reply, sizeof(reply));
2181         if (len > 0 && len != sizeof(reply))
2182                 return -EIO;
2183         if (len < 0)
2184                 return len;
2185         return 0;
2186 }
2187
2188 /* Regenerate the statedump. */
2189 int ustctl_regenerate_statedump(int sock, int handle)
2190 {
2191         struct ustcomm_ust_msg lum;
2192         struct ustcomm_ust_reply lur;
2193         int ret;
2194
2195         memset(&lum, 0, sizeof(lum));
2196         lum.handle = handle;
2197         lum.cmd = LTTNG_UST_SESSION_STATEDUMP;
2198         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
2199         if (ret)
2200                 return ret;
2201         DBG("Regenerated statedump for handle %u", handle);
2202         return 0;
2203 }
2204
2205 static __attribute__((constructor))
2206 void ustctl_init(void)
2207 {
2208         init_usterr();
2209         lttng_ust_getenv_init();        /* Needs init_usterr() to be completed. */
2210         lttng_ust_clock_init();
2211         lttng_ring_buffer_metadata_client_init();
2212         lttng_ring_buffer_client_overwrite_init();
2213         lttng_ring_buffer_client_overwrite_rt_init();
2214         lttng_ring_buffer_client_discard_init();
2215         lttng_ring_buffer_client_discard_rt_init();
2216         lib_ringbuffer_signal_init();
2217 }
2218
2219 static __attribute__((destructor))
2220 void ustctl_exit(void)
2221 {
2222         lttng_ring_buffer_client_discard_rt_exit();
2223         lttng_ring_buffer_client_discard_exit();
2224         lttng_ring_buffer_client_overwrite_rt_exit();
2225         lttng_ring_buffer_client_overwrite_exit();
2226         lttng_ring_buffer_metadata_client_exit();
2227 }