liblttng-ust-ctl/ustctl.c

   1 /*
   2  * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
   3  *                      Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; only version 2
   8  * of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18  */
  19
  20 #include <string.h>
  21 #include <lttng/ust-ctl.h>
  22 #include <lttng/ust-abi.h>
  23 #include <lttng/ust-events.h>
  24 #include <sys/mman.h>
  25
  26 #include <usterr-signal-safe.h>
  27 #include <ust-comm.h>
  28
  29 #include "../libringbuffer/backend.h"
  30 #include "../libringbuffer/frontend.h"
  31
  32 volatile enum ust_loglevel ust_loglevel;
  33
  34 static
  35 void init_object(struct lttng_ust_object_data *data)
  36 {
  37         data->handle = -1;
  38         data->shm_fd = -1;
  39         data->wait_fd = -1;
  40         data->memory_map_size = 0;
  41 }
  42
  43 /*
  44  * If sock is negative, it means we don't have to notify the other side
  45  * (e.g. application has already vanished).
  46  */
  47 int ustctl_release_object(int sock, struct lttng_ust_object_data *data)
  48 {
  49         struct ustcomm_ust_msg lum;
  50         struct ustcomm_ust_reply lur;
  51         int ret;
  52
  53         if (data->shm_fd >= 0) {
  54                 ret = close(data->shm_fd);
  55                 if (ret < 0) {
  56                         return ret;
  57                 }
  58         }
  59         if (data->wait_fd >= 0) {
  60                 ret = close(data->wait_fd);
  61                 if (ret < 0) {
  62                         return ret;
  63                 }
  64         }
  65         if (sock >= 0) {
  66                 memset(&lum, 0, sizeof(lum));
  67                 lum.handle = data->handle;
  68                 lum.cmd = LTTNG_UST_RELEASE;
  69                 ret = ustcomm_send_app_cmd(sock, &lum, &lur);
  70                 if (ret < 0) {
  71                         return ret;
  72                 }
  73         }
  74         return 0;
  75 }
  76
  77 /*
  78  * Send registration done packet to the application.
  79  */
  80 int ustctl_register_done(int sock)
  81 {
  82         struct ustcomm_ust_msg lum;
  83         struct ustcomm_ust_reply lur;
  84         int ret;
  85
  86         DBG("Sending register done command to %d", sock);
  87         memset(&lum, 0, sizeof(lum));
  88         lum.handle = LTTNG_UST_ROOT_HANDLE;
  89         lum.cmd = LTTNG_UST_REGISTER_DONE;
  90         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
  91         if (ret)
  92                 return ret;
  93         if (lur.ret_code != USTCOMM_OK) {
  94                 DBG("Return code: %s", ustcomm_get_readable_code(lur.ret_code));
  95                 goto error;
  96         }
  97         return 0;
  98
  99 error:
 100         return -1;
 101 }
 102
 103 /*
 104  * returns session handle.
 105  */
 106 int ustctl_create_session(int sock)
 107 {
 108         struct ustcomm_ust_msg lum;
 109         struct ustcomm_ust_reply lur;
 110         int ret, session_handle;
 111
 112         /* Create session */
 113         memset(&lum, 0, sizeof(lum));
 114         lum.handle = LTTNG_UST_ROOT_HANDLE;
 115         lum.cmd = LTTNG_UST_SESSION;
 116         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 117         if (ret)
 118                 return ret;
 119         session_handle = lur.ret_val;
 120         DBG("received session handle %u", session_handle);
 121         return session_handle;
 122 }
 123
 124 /* open the metadata global channel */
 125 int ustctl_open_metadata(int sock, int session_handle,
 126                 struct lttng_ust_channel_attr *chops,
 127                 struct lttng_ust_object_data **_metadata_data)
 128 {
 129         struct ustcomm_ust_msg lum;
 130         struct ustcomm_ust_reply lur;
 131         struct lttng_ust_object_data *metadata_data;
 132         int ret;
 133
 134         metadata_data = malloc(sizeof(*metadata_data));
 135         if (!metadata_data)
 136                 return -ENOMEM;
 137         init_object(metadata_data);
 138         /* Create metadata channel */
 139         memset(&lum, 0, sizeof(lum));
 140         lum.handle = session_handle;
 141         lum.cmd = LTTNG_UST_METADATA;
 142         lum.u.channel.overwrite = chops->overwrite;
 143         lum.u.channel.subbuf_size = chops->subbuf_size;
 144         lum.u.channel.num_subbuf = chops->num_subbuf;
 145         lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
 146         lum.u.channel.read_timer_interval = chops->read_timer_interval;
 147         lum.u.channel.output = chops->output;
 148         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 149         if (ret) {
 150                 free(metadata_data);
 151                 return ret;
 152         }
 153         if (lur.ret_code != USTCOMM_OK) {
 154                 free(metadata_data);
 155                 return lur.ret_code;
 156         }
 157         metadata_data->handle = lur.ret_val;
 158         DBG("received metadata handle %u", metadata_data->handle);
 159         metadata_data->memory_map_size = lur.u.channel.memory_map_size;
 160         /* get shm fd */
 161         ret = ustcomm_recv_fd(sock);
 162         if (ret < 0)
 163                 goto error;
 164         metadata_data->shm_fd = ret;
 165         /* get wait fd */
 166         ret = ustcomm_recv_fd(sock);
 167         if (ret < 0)
 168                 goto error;
 169         metadata_data->wait_fd = ret;
 170         *_metadata_data = metadata_data;
 171         return 0;
 172
 173 error:
 174         (void) ustctl_release_object(sock, metadata_data);
 175         free(metadata_data);
 176         return -EINVAL;
 177 }
 178
 179 int ustctl_create_channel(int sock, int session_handle,
 180                 struct lttng_ust_channel_attr *chops,
 181                 struct lttng_ust_object_data **_channel_data)
 182 {
 183         struct ustcomm_ust_msg lum;
 184         struct ustcomm_ust_reply lur;
 185         struct lttng_ust_object_data *channel_data;
 186         int ret;
 187
 188         channel_data = malloc(sizeof(*channel_data));
 189         if (!channel_data)
 190                 return -ENOMEM;
 191         init_object(channel_data);
 192         /* Create metadata channel */
 193         memset(&lum, 0, sizeof(lum));
 194         lum.handle = session_handle;
 195         lum.cmd = LTTNG_UST_CHANNEL;
 196         lum.u.channel.overwrite = chops->overwrite;
 197         lum.u.channel.subbuf_size = chops->subbuf_size;
 198         lum.u.channel.num_subbuf = chops->num_subbuf;
 199         lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
 200         lum.u.channel.read_timer_interval = chops->read_timer_interval;
 201         lum.u.channel.output = chops->output;
 202         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 203         if (ret) {
 204                 free(channel_data);
 205                 return ret;
 206         }
 207         if (lur.ret_code != USTCOMM_OK) {
 208                 free(channel_data);
 209                 return lur.ret_code;
 210         }
 211         channel_data->handle = lur.ret_val;
 212         DBG("received channel handle %u", channel_data->handle);
 213         channel_data->memory_map_size = lur.u.channel.memory_map_size;
 214         /* get shm fd */
 215         ret = ustcomm_recv_fd(sock);
 216         if (ret < 0)
 217                 goto error;
 218         channel_data->shm_fd = ret;
 219         /* get wait fd */
 220         ret = ustcomm_recv_fd(sock);
 221         if (ret < 0)
 222                 goto error;
 223         channel_data->wait_fd = ret;
 224         *_channel_data = channel_data;
 225         return 0;
 226
 227 error:
 228         (void) ustctl_release_object(sock, channel_data);
 229         free(channel_data);
 230         return -EINVAL;
 231 }
 232
 233 /*
 234  * Return -ENOENT if no more stream is available for creation.
 235  * Return 0 on success.
 236  * Return negative error value on error.
 237  */
 238 int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
 239                 struct lttng_ust_object_data **_stream_data)
 240 {
 241         struct ustcomm_ust_msg lum;
 242         struct ustcomm_ust_reply lur;
 243         struct lttng_ust_object_data *stream_data;
 244         int ret, fd;
 245
 246         stream_data = malloc(sizeof(*stream_data));
 247         if (!stream_data)
 248                 return -ENOMEM;
 249         init_object(stream_data);
 250         memset(&lum, 0, sizeof(lum));
 251         lum.handle = channel_data->handle;
 252         lum.cmd = LTTNG_UST_STREAM;
 253         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 254         if (ret) {
 255                 free(stream_data);
 256                 return ret;
 257         }
 258         if (lur.ret_code != USTCOMM_OK) {
 259                 free(stream_data);
 260                 return lur.ret_code;
 261         }
 262
 263         stream_data->handle = lur.ret_val;
 264         DBG("received stream handle %u", stream_data->handle);
 265         stream_data->memory_map_size = lur.u.stream.memory_map_size;
 266         /* get shm fd */
 267         fd = ustcomm_recv_fd(sock);
 268         if (fd < 0)
 269                 goto error;
 270         stream_data->shm_fd = fd;
 271         /* get wait fd */
 272         fd = ustcomm_recv_fd(sock);
 273         if (fd < 0)
 274                 goto error;
 275         stream_data->wait_fd = fd;
 276         *_stream_data = stream_data;
 277         return ret;
 278
 279 error:
 280         (void) ustctl_release_object(sock, stream_data);
 281         free(stream_data);
 282         return -EINVAL;
 283 }
 284
 285 int ustctl_create_event(int sock, struct lttng_ust_event *ev,
 286                 struct lttng_ust_object_data *channel_data,
 287                 struct lttng_ust_object_data **_event_data)
 288 {
 289         struct ustcomm_ust_msg lum;
 290         struct ustcomm_ust_reply lur;
 291         struct lttng_ust_object_data *event_data;
 292         int ret;
 293
 294         event_data = malloc(sizeof(*event_data));
 295         if (!event_data)
 296                 return -ENOMEM;
 297         init_object(event_data);
 298         memset(&lum, 0, sizeof(lum));
 299         lum.handle = channel_data->handle;
 300         lum.cmd = LTTNG_UST_EVENT;
 301         strncpy(lum.u.event.name, ev->name,
 302                 LTTNG_UST_SYM_NAME_LEN);
 303         lum.u.event.instrumentation = ev->instrumentation;
 304         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 305         if (ret) {
 306                 free(event_data);
 307                 return ret;
 308         }
 309         event_data->handle = lur.ret_val;
 310         DBG("received event handle %u", event_data->handle);
 311         *_event_data = event_data;
 312         return 0;
 313 }
 314
 315 int ustctl_add_context(int sock, struct lttng_ust_context *ctx,
 316                 struct lttng_ust_object_data *obj_data,
 317                 struct lttng_ust_object_data **_context_data)
 318 {
 319         struct ustcomm_ust_msg lum;
 320         struct ustcomm_ust_reply lur;
 321         struct lttng_ust_object_data *context_data;
 322         int ret;
 323
 324         context_data = malloc(sizeof(*context_data));
 325         if (!context_data)
 326                 return -ENOMEM;
 327         init_object(context_data);
 328         memset(&lum, 0, sizeof(lum));
 329         lum.handle = obj_data->handle;
 330         lum.cmd = LTTNG_UST_CONTEXT;
 331         lum.u.context.ctx = ctx->ctx;
 332         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 333         if (ret) {
 334                 free(context_data);
 335                 return ret;
 336         }
 337         context_data->handle = lur.ret_val;
 338         DBG("received context handle %u", context_data->handle);
 339         *_context_data = context_data;
 340         return ret;
 341 }
 342
 343 /* Enable event, channel and session ioctl */
 344 int ustctl_enable(int sock, struct lttng_ust_object_data *object)
 345 {
 346         struct ustcomm_ust_msg lum;
 347         struct ustcomm_ust_reply lur;
 348         int ret;
 349
 350         memset(&lum, 0, sizeof(lum));
 351         lum.handle = object->handle;
 352         lum.cmd = LTTNG_UST_ENABLE;
 353         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 354         if (ret)
 355                 return ret;
 356         DBG("enabled handle %u", object->handle);
 357         return 0;
 358 }
 359
 360 /* Disable event, channel and session ioctl */
 361 int ustctl_disable(int sock, struct lttng_ust_object_data *object)
 362 {
 363         struct ustcomm_ust_msg lum;
 364         struct ustcomm_ust_reply lur;
 365         int ret;
 366
 367         memset(&lum, 0, sizeof(lum));
 368         lum.handle = object->handle;
 369         lum.cmd = LTTNG_UST_DISABLE;
 370         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 371         if (ret)
 372                 return ret;
 373         DBG("disable handle %u", object->handle);
 374         return 0;
 375 }
 376
 377 int ustctl_start_session(int sock, int handle)
 378 {
 379         struct lttng_ust_object_data obj;
 380
 381         obj.handle = handle;
 382         return ustctl_enable(sock, &obj);
 383 }
 384
 385 int ustctl_stop_session(int sock, int handle)
 386 {
 387         struct lttng_ust_object_data obj;
 388
 389         obj.handle = handle;
 390         return ustctl_disable(sock, &obj);
 391 }
 392
 393 int ustctl_tracepoint_list(int sock)
 394 {
 395         struct ustcomm_ust_msg lum;
 396         struct ustcomm_ust_reply lur;
 397         int ret, tp_list_handle;
 398
 399         memset(&lum, 0, sizeof(lum));
 400         lum.handle = LTTNG_UST_ROOT_HANDLE;
 401         lum.cmd = LTTNG_UST_TRACEPOINT_LIST;
 402         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 403         if (ret)
 404                 return ret;
 405         tp_list_handle = lur.ret_val;
 406         DBG("received tracepoint list handle %u", tp_list_handle);
 407         return tp_list_handle;
 408 }
 409
 410 int ustctl_tracepoint_list_get(int sock, int tp_list_handle,
 411                 struct lttng_ust_tracepoint_iter *iter)
 412 {
 413         struct ustcomm_ust_msg lum;
 414         struct ustcomm_ust_reply lur;
 415         int ret;
 416
 417         memset(&lum, 0, sizeof(lum));
 418         lum.handle = tp_list_handle;
 419         lum.cmd = LTTNG_UST_TRACEPOINT_LIST_GET;
 420         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 421         if (ret)
 422                 return ret;
 423         DBG("received tracepoint list entry name %s loglevel %s loglevel_value %lld",
 424                 lur.u.tracepoint.name,
 425                 lur.u.tracepoint.loglevel,
 426                 (unsigned long long) lur.u.tracepoint.loglevel_value);
 427         memcpy(iter, &lur.u.tracepoint, sizeof(*iter));
 428         return 0;
 429 }
 430
 431 int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v)
 432 {
 433         struct ustcomm_ust_msg lum;
 434         struct ustcomm_ust_reply lur;
 435         int ret;
 436
 437         memset(&lum, 0, sizeof(lum));
 438         lum.handle = LTTNG_UST_ROOT_HANDLE;
 439         lum.cmd = LTTNG_UST_TRACER_VERSION;
 440         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 441         if (ret)
 442                 return ret;
 443         memcpy(v, &lur.u.version, sizeof(*v));
 444         DBG("received tracer version");
 445         return 0;
 446 }
 447
 448 int ustctl_wait_quiescent(int sock)
 449 {
 450         struct ustcomm_ust_msg lum;
 451         struct ustcomm_ust_reply lur;
 452         int ret;
 453
 454         memset(&lum, 0, sizeof(lum));
 455         lum.handle = LTTNG_UST_ROOT_HANDLE;
 456         lum.cmd = LTTNG_UST_WAIT_QUIESCENT;
 457         ret = ustcomm_send_app_cmd(sock, &lum, &lur);
 458         if (ret)
 459                 return ret;
 460         DBG("waited for quiescent state");
 461         return 0;
 462 }
 463
 464 int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate)
 465 {
 466         return -ENOSYS;
 467 }
 468
 469 /* Buffer operations */
 470
 471 /* Map channel shm into process memory */
 472 struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *chan_data)
 473 {
 474         struct lttng_ust_shm_handle *handle;
 475         struct channel *chan;
 476         size_t chan_size;
 477         struct lttng_ust_lib_ring_buffer_config *config;
 478         int ret;
 479
 480         handle = channel_handle_create(chan_data->shm_fd,
 481                 chan_data->wait_fd,
 482                 chan_data->memory_map_size);
 483         if (!handle) {
 484                 ERR("create handle error");
 485                 return NULL;
 486         }
 487         /*
 488          * Set to -1 because the lttng_ust_shm_handle destruction will take care
 489          * of closing shm_fd and wait_fd.
 490          */
 491         chan_data->shm_fd = -1;
 492         chan_data->wait_fd = -1;
 493
 494         /*
 495          * TODO: add consistency checks to be resilient if the
 496          * application try to feed us with incoherent channel structure
 497          * values.
 498          */
 499         chan = shmp(handle, handle->chan);
 500         /* chan is object 0. This is hardcoded. */
 501         chan_size = handle->table->objects[0].allocated_len;
 502         handle->shadow_chan = malloc(chan_size);
 503         if (!handle->shadow_chan) {
 504                 channel_destroy(chan, handle, 1);
 505                 return NULL;
 506         }
 507         memcpy(handle->shadow_chan, chan, chan_size);
 508         /*
 509          * The callback pointers in the producer are invalid in the
 510          * consumer. We need to look them up here.
 511          */
 512         config = &handle->shadow_chan->backend.config;
 513         switch (config->client_type) {
 514         case LTTNG_CLIENT_METADATA:
 515                 memcpy(&config->cb, lttng_client_callbacks_metadata,
 516                         sizeof(config->cb));
 517                 break;
 518         case LTTNG_CLIENT_DISCARD:
 519                 memcpy(&config->cb, lttng_client_callbacks_discard,
 520                         sizeof(config->cb));
 521                 break;
 522         case LTTNG_CLIENT_OVERWRITE:
 523                 memcpy(&config->cb, lttng_client_callbacks_overwrite,
 524                         sizeof(config->cb));
 525                 break;
 526         default:
 527                 ERR("Unknown client type %d", config->client_type);
 528                 channel_destroy(chan, handle, 1);
 529                 return NULL;
 530         }
 531         /* Replace the object table pointer. */
 532         ret = munmap(handle->table->objects[0].memory_map,
 533                 handle->table->objects[0].memory_map_size);
 534         if (ret) {
 535                 perror("munmap");
 536                 assert(0);
 537         }
 538         handle->table->objects[0].memory_map = (char *) handle->shadow_chan;
 539         handle->table->objects[0].is_shadow = 1;
 540         return handle;
 541 }
 542
 543 /* Add stream to channel shm and map its shm into process memory */
 544 int ustctl_add_stream(struct lttng_ust_shm_handle *handle,
 545                 struct lttng_ust_object_data *stream_data)
 546 {
 547         int ret;
 548
 549         if (!stream_data->handle)
 550                 return -ENOENT;
 551         /* map stream */
 552         ret = channel_handle_add_stream(handle,
 553                 stream_data->shm_fd,
 554                 stream_data->wait_fd,
 555                 stream_data->memory_map_size);
 556         if (ret) {
 557                 ERR("add stream error\n");
 558                 return ret;
 559         }
 560         /*
 561          * Set to -1 because the lttng_ust_shm_handle destruction will take care
 562          * of closing shm_fd and wait_fd.
 563          */
 564         stream_data->shm_fd = -1;
 565         stream_data->wait_fd = -1;
 566         return 0;
 567 }
 568
 569 void ustctl_unmap_channel(struct lttng_ust_shm_handle *handle)
 570 {
 571         struct channel *chan;
 572
 573         chan = shmp(handle, handle->chan);
 574         channel_destroy(chan, handle, 1);
 575 }
 576
 577 struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_handle *handle,
 578         int cpu)
 579 {
 580         struct channel *chan = handle->shadow_chan;
 581         int shm_fd, wait_fd;
 582         uint64_t memory_map_size;
 583         struct lttng_ust_lib_ring_buffer *buf;
 584         int ret;
 585
 586         buf = channel_get_ring_buffer(&chan->backend.config,
 587                 chan, cpu, handle, &shm_fd, &wait_fd, &memory_map_size);
 588         if (!buf)
 589                 return NULL;
 590         ret = lib_ring_buffer_open_read(buf, handle, 1);
 591         if (ret)
 592                 return NULL;
 593         return buf;
 594 }
 595
 596 void ustctl_close_stream_read(struct lttng_ust_shm_handle *handle,
 597                 struct lttng_ust_lib_ring_buffer *buf)
 598 {
 599         lib_ring_buffer_release_read(buf, handle, 1);
 600 }
 601
 602 /* For mmap mode, readable without "get" operation */
 603
 604 void *ustctl_get_mmap_base(struct lttng_ust_shm_handle *handle,
 605                 struct lttng_ust_lib_ring_buffer *buf)
 606 {
 607         return shmp(handle, buf->backend.memory_map);
 608 }
 609
 610 /* returns the length to mmap. */
 611 int ustctl_get_mmap_len(struct lttng_ust_shm_handle *handle,
 612                 struct lttng_ust_lib_ring_buffer *buf,
 613                 unsigned long *len)
 614 {
 615         unsigned long mmap_buf_len;
 616         struct channel *chan = handle->shadow_chan;
 617
 618         if (chan->backend.config.output != RING_BUFFER_MMAP)
 619                 return -EINVAL;
 620         mmap_buf_len = chan->backend.buf_size;
 621         if (chan->backend.extra_reader_sb)
 622                 mmap_buf_len += chan->backend.subbuf_size;
 623         if (mmap_buf_len > INT_MAX)
 624                 return -EFBIG;
 625         *len = mmap_buf_len;
 626         return 0;
 627 }
 628
 629 /* returns the maximum size for sub-buffers. */
 630 int ustctl_get_max_subbuf_size(struct lttng_ust_shm_handle *handle,
 631                 struct lttng_ust_lib_ring_buffer *buf,
 632                 unsigned long *len)
 633 {
 634         struct channel *chan = handle->shadow_chan;
 635
 636         *len = chan->backend.subbuf_size;
 637         return 0;
 638 }
 639
 640 /*
 641  * For mmap mode, operate on the current packet (between get/put or
 642  * get_next/put_next).
 643  */
 644
 645 /* returns the offset of the subbuffer belonging to the mmap reader. */
 646 int ustctl_get_mmap_read_offset(struct lttng_ust_shm_handle *handle,
 647                 struct lttng_ust_lib_ring_buffer *buf, unsigned long *off)
 648 {
 649         struct channel *chan = handle->shadow_chan;
 650         unsigned long sb_bindex;
 651
 652         if (chan->backend.config.output != RING_BUFFER_MMAP)
 653                 return -EINVAL;
 654         sb_bindex = subbuffer_id_get_index(&chan->backend.config,
 655                                            buf->backend.buf_rsb.id);
 656         *off = shmp(handle, shmp_index(handle, buf->backend.array, sb_bindex)->shmp)->mmap_offset;
 657         return 0;
 658 }
 659
 660 /* returns the size of the current sub-buffer, without padding (for mmap). */
 661 int ustctl_get_subbuf_size(struct lttng_ust_shm_handle *handle,
 662                 struct lttng_ust_lib_ring_buffer *buf, unsigned long *len)
 663 {
 664         struct channel *chan = handle->shadow_chan;
 665
 666         *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
 667                 handle);
 668         return 0;
 669 }
 670
 671 /* returns the size of the current sub-buffer, without padding (for mmap). */
 672 int ustctl_get_padded_subbuf_size(struct lttng_ust_shm_handle *handle,
 673                 struct lttng_ust_lib_ring_buffer *buf, unsigned long *len)
 674 {
 675         struct channel *chan = handle->shadow_chan;
 676
 677         *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
 678                 handle);
 679         *len = PAGE_ALIGN(*len);
 680         return 0;
 681 }
 682
 683 /* Get exclusive read access to the next sub-buffer that can be read. */
 684 int ustctl_get_next_subbuf(struct lttng_ust_shm_handle *handle,
 685                 struct lttng_ust_lib_ring_buffer *buf)
 686 {
 687         return lib_ring_buffer_get_next_subbuf(buf, handle);
 688 }
 689
 690
 691 /* Release exclusive sub-buffer access, move consumer forward. */
 692 int ustctl_put_next_subbuf(struct lttng_ust_shm_handle *handle,
 693                 struct lttng_ust_lib_ring_buffer *buf)
 694 {
 695         lib_ring_buffer_put_next_subbuf(buf, handle);
 696         return 0;
 697 }
 698
 699 /* snapshot */
 700
 701 /* Get a snapshot of the current ring buffer producer and consumer positions */
 702 int ustctl_snapshot(struct lttng_ust_shm_handle *handle,
 703                 struct lttng_ust_lib_ring_buffer *buf)
 704 {
 705         return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
 706                         &buf->prod_snapshot, handle);
 707 }
 708
 709 /* Get the consumer position (iteration start) */
 710 int ustctl_snapshot_get_consumed(struct lttng_ust_shm_handle *handle,
 711                 struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos)
 712 {
 713         *pos = buf->cons_snapshot;
 714         return 0;
 715 }
 716
 717 /* Get the producer position (iteration end) */
 718 int ustctl_snapshot_get_produced(struct lttng_ust_shm_handle *handle,
 719                 struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos)
 720 {
 721         *pos = buf->prod_snapshot;
 722         return 0;
 723 }
 724
 725 /* Get exclusive read access to the specified sub-buffer position */
 726 int ustctl_get_subbuf(struct lttng_ust_shm_handle *handle,
 727                 struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos)
 728 {
 729         return lib_ring_buffer_get_subbuf(buf, *pos, handle);
 730 }
 731
 732 /* Release exclusive sub-buffer access */
 733 int ustctl_put_subbuf(struct lttng_ust_shm_handle *handle,
 734                 struct lttng_ust_lib_ring_buffer *buf)
 735 {
 736         lib_ring_buffer_put_subbuf(buf, handle);
 737         return 0;
 738 }
 739
 740 void ustctl_flush_buffer(struct lttng_ust_shm_handle *handle,
 741                 struct lttng_ust_lib_ring_buffer *buf,
 742                 int producer_active)
 743 {
 744         lib_ring_buffer_switch_slow(buf,
 745                 producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH,
 746                 handle);
 747 }