Refactoring: remove ring buffer channel pointer from struct lttng_ust_channel_buffer

This pointer can be moved to an internal data structure, and be
populated by the ring buffer client rather than the probes.

Also transition all ring buffer client callbacks to use buffer and
channel structures rather than shm handle.

Also remove the handle from struct ustctl_consumer_stream (internal to
ustctl.c) because it is redundant.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Change-Id: I9c389626de5a02cf2ac7377d9f1e2802128992c4

diff --git a/include/lttng/ringbuffer-context.h b/include/lttng/ringbuffer-context.h
index 228bc8aa5b6b35d322b0446408e0ac2e9604e556..8a7b5758a09cc26884cc3ac142838a4c280ef395 100644 (file)
--- a/include/lttng/ringbuffer-context.h
+++ b/include/lttng/ringbuffer-context.h
@@ -39,34 +39,35 @@ struct lttng_ust_lib_ring_buffer_ctx;
  * at the end of the structure.
  */
 struct lttng_ust_lib_ring_buffer_ctx {
-       uint32_t struct_size;           /* Size of this structure. */
+       uint32_t struct_size;                   /* Size of this structure. */
 
-       /* input received by lib_ring_buffer_reserve(), saved here. */
+       /* input received by lib_ring_buffer_reserve(). */
        struct lttng_ust_lib_ring_buffer_channel *chan; /* channel */
-       void *priv;                     /* client private data */
-       size_t data_size;               /* size of payload */
-       int largest_align;              /*
-                                        * alignment of the largest element
-                                        * in the payload
-                                        */
+       void *priv;                             /* client private data */
+       size_t data_size;                       /* size of payload */
+       int largest_align;                      /*
+                                                * alignment of the largest element
+                                                * in the payload
+                                                */
 
        /* output from lib_ring_buffer_reserve() */
-       int reserve_cpu;                /* processor id updated by the reserve */
+       int reserve_cpu;                        /* processor id updated by the reserve */
+       size_t slot_size;                       /* size of the reserved slot */
+       unsigned long buf_offset;               /* offset following the record header */
+       unsigned long pre_offset;               /*
+                                                * Initial offset position _before_
+                                                * the record is written. Positioned
+                                                * prior to record header alignment
+                                                * padding.
+                                                */
+       uint64_t tsc;                           /* time-stamp counter value */
+       unsigned int rflags;                    /* reservation flags */
+       void *ip;                               /* caller ip address */
+
        struct lttng_ust_lib_ring_buffer *buf;  /*
-                                        * buffer corresponding to processor id
-                                        * for this channel
-                                        */
-       size_t slot_size;               /* size of the reserved slot */
-       unsigned long buf_offset;       /* offset following the record header */
-       unsigned long pre_offset;       /*
-                                        * Initial offset position _before_
-                                        * the record is written. Positioned
-                                        * prior to record header alignment
-                                        * padding.
-                                        */
-       uint64_t tsc;                   /* time-stamp counter value */
-       unsigned int rflags;            /* reservation flags */
-       void *ip;                       /* caller ip address */
+                                                * buffer corresponding to processor id
+                                                * for this channel
+                                                */
        struct lttng_ust_lib_ring_buffer_backend_pages *backend_pages;
 
        /* End of base ABI. Fields below should be used after checking struct_size. */

diff --git a/include/lttng/ust-events.h b/include/lttng/ust-events.h
index 363805686f66d8804483a48c5def4baa9eca3c9f..96504940ec3669941dff17ec0a7753d45f230ddd 100644 (file)
--- a/include/lttng/ust-events.h
+++ b/include/lttng/ust-events.h
@@ -504,7 +504,6 @@ struct lttng_ust_channel_buffer {
        struct lttng_ust_channel_buffer_private *priv;  /* Private channel buffer interface */
 
        struct lttng_ust_channel_buffer_ops *ops;
-       struct lttng_ust_lib_ring_buffer_channel *chan; /* Channel buffers */
 
        /* End of base ABI. Fields below should be used after checking struct_size. */
 };

diff --git a/include/lttng/ust-tracepoint-event.h b/include/lttng/ust-tracepoint-event.h
index 3f774d1f1178b06ad6085f9937ba61750fb0b217..18f91c5f75b3e34d7a4d046bef809e0ac75d7c16 100644 (file)
--- a/include/lttng/ust-tracepoint-event.h
+++ b/include/lttng/ust-tracepoint-event.h
@@ -850,10 +850,9 @@ void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args))          \
                         _TP_ARGS_DATA_VAR(_args));                           \
                __event_align = __event_get_align__##_provider##___##_name(_TP_ARGS_VAR(_args)); \
                memset(&__lttng_ctx, 0, sizeof(__lttng_ctx));                 \
-               __lttng_ctx.struct_size = sizeof(struct lttng_ust_stack_ctx);     \
+               __lttng_ctx.struct_size = sizeof(struct lttng_ust_stack_ctx); \
                __lttng_ctx.event_recorder = __event_recorder;                \
-               lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_ctx, __event_len, \
-                                        __event_align);                      \
+               lib_ring_buffer_ctx_init(&__ctx, NULL, &__lttng_ctx, __event_len, __event_align); \
                __ctx.ip = _TP_IP_PARAM(TP_IP_PARAM);                         \
                __ret = __chan->ops->event_reserve(&__ctx, __event_recorder->id); \
                if (__ret < 0)                                                \

diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c
index 0a76437d8eb93871b3f33c33cdf46fdba1ea1262..eec3aeca5de38c086e9513b72cbaa1f6ca7574bc 100644 (file)
--- a/liblttng-ust-ctl/ustctl.c
+++ b/liblttng-ust-ctl/ustctl.c
@@ -57,7 +57,6 @@ struct ustctl_consumer_channel {
  * Stream representation within consumer.
  */
 struct ustctl_consumer_stream {
-       struct lttng_ust_shm_handle *handle;    /* shared-memory handle */
        struct lttng_ust_lib_ring_buffer *buf;
        struct ustctl_consumer_channel *chan;
        int shm_fd, wait_fd, wakeup_fd;
@@ -1314,7 +1313,7 @@ int ustctl_send_channel_to_sessiond(int sock,
 {
        struct shm_object_table *table;
 
-       table = channel->chan->chan->handle->table;
+       table = channel->chan->priv->rb_chan->handle->table;
        if (table->size <= 0)
                return -EINVAL;
        return ustctl_send_channel(sock,
@@ -1345,16 +1344,16 @@ int ustctl_write_metadata_to_channel(
 {
        struct lttng_ust_lib_ring_buffer_ctx ctx;
        struct lttng_ust_channel_buffer *lttng_chan_buf = channel->chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = lttng_chan_buf->priv->rb_chan;
        const char *str = metadata_str;
        int ret = 0, waitret;
        size_t reserve_len, pos;
 
        for (pos = 0; pos < len; pos += reserve_len) {
                reserve_len = min_t(size_t,
-                               lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf->chan,
-                                               lttng_chan_buf->chan->handle),
+                               lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf),
                                len - pos);
-               lib_ring_buffer_ctx_init(&ctx, lttng_chan_buf->chan, NULL, reserve_len, sizeof(char));
+               lib_ring_buffer_ctx_init(&ctx, rb_chan, NULL, reserve_len, sizeof(char));
                /*
                 * We don't care about metadata buffer's records lost
                 * count, because we always retry here. Report error if
@@ -1393,15 +1392,15 @@ ssize_t ustctl_write_one_packet_to_channel(
 {
        struct lttng_ust_lib_ring_buffer_ctx ctx;
        struct lttng_ust_channel_buffer *lttng_chan_buf = channel->chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = lttng_chan_buf->priv->rb_chan;
        const char *str = metadata_str;
        ssize_t reserve_len;
        int ret;
 
        reserve_len = min_t(ssize_t,
-                       lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf->chan,
-                                       lttng_chan_buf->chan->handle),
+                       lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf),
                        len);
-       lib_ring_buffer_ctx_init(&ctx, lttng_chan_buf->chan, NULL, reserve_len, sizeof(char));
+       lib_ring_buffer_ctx_init(&ctx, rb_chan, NULL, reserve_len, sizeof(char));
        ret = lttng_chan_buf->ops->event_reserve(&ctx, 0);
        if (ret != 0) {
                DBG("LTTng: event reservation failed");
@@ -1421,7 +1420,7 @@ int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan)
        struct lttng_ust_lib_ring_buffer_channel *chan;
        int ret;
 
-       chan = consumer_chan->chan->chan;
+       chan = consumer_chan->chan->priv->rb_chan;
        ret = ring_buffer_channel_close_wait_fd(&chan->backend.config,
                        chan, chan->handle);
        if (!ret)
@@ -1434,7 +1433,7 @@ int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan
        struct lttng_ust_lib_ring_buffer_channel *chan;
        int ret;
 
-       chan = consumer_chan->chan->chan;
+       chan = consumer_chan->chan->priv->rb_chan;
        ret = ring_buffer_channel_close_wakeup_fd(&chan->backend.config,
                        chan, chan->handle);
        if (!ret)
@@ -1446,18 +1445,18 @@ int ustctl_stream_close_wait_fd(struct ustctl_consumer_stream *stream)
 {
        struct lttng_ust_lib_ring_buffer_channel *chan;
 
-       chan = stream->chan->chan->chan;
+       chan = stream->chan->chan->priv->rb_chan;
        return ring_buffer_stream_close_wait_fd(&chan->backend.config,
-                       chan, stream->handle, stream->cpu);
+                       chan, chan->handle, stream->cpu);
 }
 
 int ustctl_stream_close_wakeup_fd(struct ustctl_consumer_stream *stream)
 {
        struct lttng_ust_lib_ring_buffer_channel *chan;
 
-       chan = stream->chan->chan->chan;
+       chan = stream->chan->chan->priv->rb_chan;
        return ring_buffer_stream_close_wakeup_fd(&chan->backend.config,
-                       chan, stream->handle, stream->cpu);
+                       chan, chan->handle, stream->cpu);
 }
 
 struct ustctl_consumer_stream *
@@ -1466,7 +1465,7 @@ struct ustctl_consumer_stream *
 {
        struct ustctl_consumer_stream *stream;
        struct lttng_ust_shm_handle *handle;
-       struct lttng_ust_lib_ring_buffer_channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;
        int shm_fd, wait_fd, wakeup_fd;
        uint64_t memory_map_size;
        struct lttng_ust_lib_ring_buffer *buf;
@@ -1474,13 +1473,13 @@ struct ustctl_consumer_stream *
 
        if (!channel)
                return NULL;
-       handle = channel->chan->chan->handle;
+       rb_chan = channel->chan->priv->rb_chan;
+       handle = rb_chan->handle;
        if (!handle)
                return NULL;
 
-       chan = channel->chan->chan;
-       buf = channel_get_ring_buffer(&chan->backend.config,
-               chan, cpu, handle, &shm_fd, &wait_fd,
+       buf = channel_get_ring_buffer(&rb_chan->backend.config,
+               rb_chan, cpu, handle, &shm_fd, &wait_fd,
                &wakeup_fd, &memory_map_size);
        if (!buf)
                return NULL;
@@ -1491,7 +1490,6 @@ struct ustctl_consumer_stream *
        stream = zmalloc(sizeof(*stream));
        if (!stream)
                goto alloc_error;
-       stream->handle = handle;
        stream->buf = buf;
        stream->chan = channel;
        stream->shm_fd = shm_fd;
@@ -1515,7 +1513,7 @@ void ustctl_destroy_stream(struct ustctl_consumer_stream *stream)
        consumer_chan = stream->chan;
        (void) ustctl_stream_close_wait_fd(stream);
        (void) ustctl_stream_close_wakeup_fd(stream);
-       lib_ring_buffer_release_read(buf, consumer_chan->chan->chan->handle);
+       lib_ring_buffer_release_read(buf, consumer_chan->chan->priv->rb_chan->handle);
        free(stream);
 }
 
@@ -1523,16 +1521,16 @@ int ustctl_channel_get_wait_fd(struct ustctl_consumer_channel *chan)
 {
        if (!chan)
                return -EINVAL;
-       return shm_get_wait_fd(chan->chan->chan->handle,
-               &chan->chan->chan->handle->chan._ref);
+       return shm_get_wait_fd(chan->chan->priv->rb_chan->handle,
+               &chan->chan->priv->rb_chan->handle->chan._ref);
 }
 
 int ustctl_channel_get_wakeup_fd(struct ustctl_consumer_channel *chan)
 {
        if (!chan)
                return -EINVAL;
-       return shm_get_wakeup_fd(chan->chan->chan->handle,
-               &chan->chan->chan->handle->chan._ref);
+       return shm_get_wakeup_fd(chan->chan->priv->rb_chan->handle,
+               &chan->chan->priv->rb_chan->handle->chan._ref);
 }
 
 int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream)
@@ -1544,7 +1542,7 @@ int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream)
                return -EINVAL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       return shm_get_wait_fd(consumer_chan->chan->chan->handle, &buf->self._ref);
+       return shm_get_wait_fd(consumer_chan->chan->priv->rb_chan->handle, &buf->self._ref);
 }
 
 int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream)
@@ -1556,7 +1554,7 @@ int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream)
                return -EINVAL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       return shm_get_wakeup_fd(consumer_chan->chan->chan->handle, &buf->self._ref);
+       return shm_get_wakeup_fd(consumer_chan->chan->priv->rb_chan->handle, &buf->self._ref);
 }
 
 /* For mmap mode, readable without "get" operation */
@@ -1570,7 +1568,7 @@ void *ustctl_get_mmap_base(struct ustctl_consumer_stream *stream)
                return NULL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       return shmp(consumer_chan->chan->chan->handle, buf->backend.memory_map);
+       return shmp(consumer_chan->chan->priv->rb_chan->handle, buf->backend.memory_map);
 }
 
 /* returns the length to mmap. */
@@ -1579,17 +1577,17 @@ int ustctl_get_mmap_len(struct ustctl_consumer_stream *stream,
 {
        struct ustctl_consumer_channel *consumer_chan;
        unsigned long mmap_buf_len;
-       struct lttng_ust_lib_ring_buffer_channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;
 
        if (!stream)
                return -EINVAL;
        consumer_chan = stream->chan;
-       chan = consumer_chan->chan->chan;
-       if (chan->backend.config.output != RING_BUFFER_MMAP)
+       rb_chan = consumer_chan->chan->priv->rb_chan;
+       if (rb_chan->backend.config.output != RING_BUFFER_MMAP)
                return -EINVAL;
-       mmap_buf_len = chan->backend.buf_size;
-       if (chan->backend.extra_reader_sb)
-               mmap_buf_len += chan->backend.subbuf_size;
+       mmap_buf_len = rb_chan->backend.buf_size;
+       if (rb_chan->backend.extra_reader_sb)
+               mmap_buf_len += rb_chan->backend.subbuf_size;
        if (mmap_buf_len > INT_MAX)
                return -EFBIG;
        *len = mmap_buf_len;
@@ -1601,13 +1599,13 @@ int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream,
                unsigned long *len)
 {
        struct ustctl_consumer_channel *consumer_chan;
-       struct lttng_ust_lib_ring_buffer_channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;
 
        if (!stream)
                return -EINVAL;
        consumer_chan = stream->chan;
-       chan = consumer_chan->chan->chan;
-       *len = chan->backend.subbuf_size;
+       rb_chan = consumer_chan->chan->priv->rb_chan;
+       *len = rb_chan->backend.subbuf_size;
        return 0;
 }
 
@@ -1620,7 +1618,7 @@ int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream,
 int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream,
                unsigned long *off)
 {
-       struct lttng_ust_lib_ring_buffer_channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;
        unsigned long sb_bindex;
        struct lttng_ust_lib_ring_buffer *buf;
        struct ustctl_consumer_channel *consumer_chan;
@@ -1631,16 +1629,16 @@ int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream,
                return -EINVAL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       chan = consumer_chan->chan->chan;
-       if (chan->backend.config.output != RING_BUFFER_MMAP)
+       rb_chan = consumer_chan->chan->priv->rb_chan;
+       if (rb_chan->backend.config.output != RING_BUFFER_MMAP)
                return -EINVAL;
-       sb_bindex = subbuffer_id_get_index(&chan->backend.config,
+       sb_bindex = subbuffer_id_get_index(&rb_chan->backend.config,
                                        buf->backend.buf_rsb.id);
-       barray_idx = shmp_index(consumer_chan->chan->chan->handle, buf->backend.array,
+       barray_idx = shmp_index(rb_chan->handle, buf->backend.array,
                        sb_bindex);
        if (!barray_idx)
                return -EINVAL;
-       pages = shmp(consumer_chan->chan->chan->handle, barray_idx->shmp);
+       pages = shmp(rb_chan->handle, barray_idx->shmp);
        if (!pages)
                return -EINVAL;
        *off = pages->mmap_offset;
@@ -1652,7 +1650,7 @@ int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream,
                unsigned long *len)
 {
        struct ustctl_consumer_channel *consumer_chan;
-       struct lttng_ust_lib_ring_buffer_channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;
        struct lttng_ust_lib_ring_buffer *buf;
 
        if (!stream)
@@ -1660,9 +1658,9 @@ int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream,
 
        buf = stream->buf;
        consumer_chan = stream->chan;
-       chan = consumer_chan->chan->chan;
-       *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
-               consumer_chan->chan->chan->handle);
+       rb_chan = consumer_chan->chan->priv->rb_chan;
+       *len = lib_ring_buffer_get_read_data_size(&rb_chan->backend.config, buf,
+               rb_chan->handle);
        return 0;
 }
 
@@ -1671,16 +1669,16 @@ int ustctl_get_padded_subbuf_size(struct ustctl_consumer_stream *stream,
                unsigned long *len)
 {
        struct ustctl_consumer_channel *consumer_chan;
-       struct lttng_ust_lib_ring_buffer_channel *chan;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;
        struct lttng_ust_lib_ring_buffer *buf;
 
        if (!stream)
                return -EINVAL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       chan = consumer_chan->chan->chan;
-       *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
-               consumer_chan->chan->chan->handle);
+       rb_chan = consumer_chan->chan->priv->rb_chan;
+       *len = lib_ring_buffer_get_read_data_size(&rb_chan->backend.config, buf,
+               rb_chan->handle);
        *len = LTTNG_UST_PAGE_ALIGN(*len);
        return 0;
 }
@@ -1696,7 +1694,7 @@ int ustctl_get_next_subbuf(struct ustctl_consumer_stream *stream)
        buf = stream->buf;
        consumer_chan = stream->chan;
        return lib_ring_buffer_get_next_subbuf(buf,
-                       consumer_chan->chan->chan->handle);
+                       consumer_chan->chan->priv->rb_chan->handle);
 }
 
 
@@ -1710,7 +1708,7 @@ int ustctl_put_next_subbuf(struct ustctl_consumer_stream *stream)
                return -EINVAL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->chan->handle);
+       lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->priv->rb_chan->handle);
        return 0;
 }
 
@@ -1727,7 +1725,7 @@ int ustctl_snapshot(struct ustctl_consumer_stream *stream)
        buf = stream->buf;
        consumer_chan = stream->chan;
        return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
-                       &buf->prod_snapshot, consumer_chan->chan->chan->handle);
+                       &buf->prod_snapshot, consumer_chan->chan->priv->rb_chan->handle);
 }
 
 /*
@@ -1746,7 +1744,7 @@ int ustctl_snapshot_sample_positions(struct ustctl_consumer_stream *stream)
        consumer_chan = stream->chan;
        return lib_ring_buffer_snapshot_sample_positions(buf,
                        &buf->cons_snapshot, &buf->prod_snapshot,
-                       consumer_chan->chan->chan->handle);
+                       consumer_chan->chan->priv->rb_chan->handle);
 }
 
 /* Get the consumer position (iteration start) */
@@ -1787,7 +1785,7 @@ int ustctl_get_subbuf(struct ustctl_consumer_stream *stream,
        buf = stream->buf;
        consumer_chan = stream->chan;
        return lib_ring_buffer_get_subbuf(buf, *pos,
-                       consumer_chan->chan->chan->handle);
+                       consumer_chan->chan->priv->rb_chan->handle);
 }
 
 /* Release exclusive sub-buffer access */
@@ -1800,7 +1798,7 @@ int ustctl_put_subbuf(struct ustctl_consumer_stream *stream)
                return -EINVAL;
        buf = stream->buf;
        consumer_chan = stream->chan;
-       lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->chan->handle);
+       lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->priv->rb_chan->handle);
        return 0;
 }
 
@@ -1815,7 +1813,7 @@ void ustctl_flush_buffer(struct ustctl_consumer_stream *stream,
        consumer_chan = stream->chan;
        lib_ring_buffer_switch_slow(buf,
                producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH,
-               consumer_chan->chan->chan->handle);
+               consumer_chan->chan->priv->rb_chan->handle);
 }
 
 void ustctl_clear_buffer(struct ustctl_consumer_stream *stream)
@@ -1827,22 +1825,18 @@ void ustctl_clear_buffer(struct ustctl_consumer_stream *stream)
        buf = stream->buf;
        consumer_chan = stream->chan;
        lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE,
-               consumer_chan->chan->chan->handle);
-       lib_ring_buffer_clear_reader(buf, consumer_chan->chan->chan->handle);
+               consumer_chan->chan->priv->rb_chan->handle);
+       lib_ring_buffer_clear_reader(buf, consumer_chan->chan->priv->rb_chan->handle);
 }
 
 static
 struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb(
                struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle)
+               struct lttng_ust_lib_ring_buffer_channel *chan)
 {
-       struct lttng_ust_lib_ring_buffer_channel *chan;
        const struct lttng_ust_lib_ring_buffer_config *config;
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
 
-       chan = shmp(handle, buf->backend.chan);
-       if (!chan)
-               return NULL;
        config = &chan->backend.config;
        if (!config->cb_ptr)
                return NULL;
@@ -1856,153 +1850,153 @@ int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream,
                uint64_t *timestamp_begin)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !timestamp_begin)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->timestamp_begin(buf, handle, timestamp_begin);
+       return client_cb->timestamp_begin(buf, chan, timestamp_begin);
 }
 
 int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream,
        uint64_t *timestamp_end)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !timestamp_end)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->timestamp_end(buf, handle, timestamp_end);
+       return client_cb->timestamp_end(buf, chan, timestamp_end);
 }
 
 int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream,
        uint64_t *events_discarded)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !events_discarded)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->events_discarded(buf, handle, events_discarded);
+       return client_cb->events_discarded(buf, chan, events_discarded);
 }
 
 int ustctl_get_content_size(struct ustctl_consumer_stream *stream,
        uint64_t *content_size)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !content_size)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->content_size(buf, handle, content_size);
+       return client_cb->content_size(buf, chan, content_size);
 }
 
 int ustctl_get_packet_size(struct ustctl_consumer_stream *stream,
        uint64_t *packet_size)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !packet_size)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->packet_size(buf, handle, packet_size);
+       return client_cb->packet_size(buf, chan, packet_size);
 }
 
 int ustctl_get_stream_id(struct ustctl_consumer_stream *stream,
                uint64_t *stream_id)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !stream_id)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->stream_id(buf, handle, stream_id);
+       return client_cb->stream_id(buf, chan, stream_id);
 }
 
 int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream,
                uint64_t *ts)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !ts)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb || !client_cb->current_timestamp)
                return -ENOSYS;
-       return client_cb->current_timestamp(buf, handle, ts);
+       return client_cb->current_timestamp(buf, chan, ts);
 }
 
 int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream,
                uint64_t *seq)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !seq)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb || !client_cb->sequence_number)
                return -ENOSYS;
-       return client_cb->sequence_number(buf, handle, seq);
+       return client_cb->sequence_number(buf, chan, seq);
 }
 
 int ustctl_get_instance_id(struct ustctl_consumer_stream *stream,
                uint64_t *id)
 {
        struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb;
+       struct lttng_ust_lib_ring_buffer_channel *chan;
        struct lttng_ust_lib_ring_buffer *buf;
-       struct lttng_ust_shm_handle *handle;
 
        if (!stream || !id)
                return -EINVAL;
        buf = stream->buf;
-       handle = stream->chan->chan->chan->handle;
-       client_cb = get_client_cb(buf, handle);
+       chan = stream->chan->chan->priv->rb_chan;
+       client_cb = get_client_cb(buf, chan);
        if (!client_cb)
                return -ENOSYS;
-       return client_cb->instance_id(buf, handle, id);
+       return client_cb->instance_id(buf, chan, id);
 }
 
 #ifdef HAVE_LINUX_PERF_EVENT_H

diff --git a/liblttng-ust/lttng-events.c b/liblttng-ust/lttng-events.c
index e489357421c92e3a4c3a0500451ca2daab746194..c81581b228e960ae2f1ae4ff2b44517cb842fca7 100644 (file)
--- a/liblttng-ust/lttng-events.c
+++ b/liblttng-ust/lttng-events.c
@@ -238,7 +238,7 @@ void _lttng_channel_unmap(struct lttng_ust_channel_buffer *lttng_chan)
 
        cds_list_del(&lttng_chan->priv->node);
        lttng_destroy_context(lttng_chan->priv->ctx);
-       chan = lttng_chan->chan;
+       chan = lttng_chan->priv->rb_chan;
        handle = chan->handle;
        channel_destroy(chan, handle, 0);
        free(lttng_chan->parent);

diff --git a/liblttng-ust/lttng-rb-clients.h b/liblttng-ust/lttng-rb-clients.h
index faa384aeeb136137126d5df601594c88970c774b..57d7cdfe46146a1cec034489088f5ad698261df9 100644 (file)
--- a/liblttng-ust/lttng-rb-clients.h
+++ b/liblttng-ust/lttng-rb-clients.h
@@ -13,30 +13,30 @@ struct lttng_ust_client_lib_ring_buffer_client_cb {
        struct lttng_ust_lib_ring_buffer_client_cb parent;
 
        int (*timestamp_begin) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *timestamp_begin);
        int (*timestamp_end) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *timestamp_end);
        int (*events_discarded) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *events_discarded);
        int (*content_size) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *content_size);
        int (*packet_size) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *packet_size);
        int (*stream_id) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *stream_id);
        int (*current_timestamp) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle,
+                       struct lttng_ust_lib_ring_buffer_channel *chan,
                        uint64_t *ts);
        int (*sequence_number) (struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle, uint64_t *seq);
+               struct lttng_ust_lib_ring_buffer_channel *chan, uint64_t *seq);
        int (*instance_id) (struct lttng_ust_lib_ring_buffer *buf,
-                       struct lttng_ust_shm_handle *handle, uint64_t *id);
+                       struct lttng_ust_lib_ring_buffer_channel *chan, uint64_t *id);
 };
 
 #endif /* _LTTNG_RB_CLIENT_H */

diff --git a/liblttng-ust/lttng-ring-buffer-client.h b/liblttng-ust/lttng-ring-buffer-client.h
index 0be36aa2d932793c43bce1fc5d955acbe11b714c..9ecf452498435185c1f80cbe9553fde6ca3cbd11 100644 (file)
--- a/liblttng-ust/lttng-ring-buffer-client.h
+++ b/liblttng-ust/lttng-ring-buffer-client.h
@@ -481,9 +481,10 @@ static struct packet_header *client_packet_header(struct lttng_ust_lib_ring_buff
 }
 
 static int client_timestamp_begin(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *timestamp_begin)
 {
+       struct lttng_ust_shm_handle *handle = chan->handle;
        struct packet_header *header;
 
        header = client_packet_header(buf, handle);
@@ -494,9 +495,10 @@ static int client_timestamp_begin(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_timestamp_end(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *timestamp_end)
 {
+       struct lttng_ust_shm_handle *handle = chan->handle;
        struct packet_header *header;
 
        header = client_packet_header(buf, handle);
@@ -507,9 +509,10 @@ static int client_timestamp_end(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_events_discarded(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *events_discarded)
 {
+       struct lttng_ust_shm_handle *handle = chan->handle;
        struct packet_header *header;
 
        header = client_packet_header(buf, handle);
@@ -520,9 +523,10 @@ static int client_events_discarded(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_content_size(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *content_size)
 {
+       struct lttng_ust_shm_handle *handle = chan->handle;
        struct packet_header *header;
 
        header = client_packet_header(buf, handle);
@@ -533,9 +537,10 @@ static int client_content_size(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_packet_size(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *packet_size)
 {
+       struct lttng_ust_shm_handle *handle = chan->handle;
        struct packet_header *header;
 
        header = client_packet_header(buf, handle);
@@ -546,11 +551,9 @@ static int client_packet_size(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_stream_id(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *stream_id)
 {
-       struct lttng_ust_lib_ring_buffer_channel *chan = shmp(handle,
-                       buf->backend.chan);
        struct lttng_ust_channel_buffer *lttng_chan = channel_get_private(chan);
 
        *stream_id = lttng_chan->priv->id;
@@ -559,21 +562,19 @@ static int client_stream_id(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_current_timestamp(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *ts)
 {
-       struct lttng_ust_lib_ring_buffer_channel *chan;
-
-       chan = shmp(handle, handle->chan);
        *ts = client_ring_buffer_clock_read(chan);
 
        return 0;
 }
 
 static int client_sequence_number(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *seq)
 {
+       struct lttng_ust_shm_handle *handle = chan->handle;
        struct packet_header *header;
 
        header = client_packet_header(buf, handle);
@@ -584,7 +585,7 @@ static int client_sequence_number(struct lttng_ust_lib_ring_buffer *buf,
 }
 
 static int client_instance_id(struct lttng_ust_lib_ring_buffer *buf,
-               struct lttng_ust_shm_handle *handle,
+               struct lttng_ust_lib_ring_buffer_channel *chan,
                uint64_t *id)
 {
        *id = buf->backend.cpu;
@@ -675,7 +676,7 @@ struct lttng_ust_channel_buffer *_channel_create(const char *name,
                        stream_fds, nr_stream_fds, blocking_timeout);
        if (!handle)
                goto error;
-       lttng_chan_buf->chan = shmp(handle, handle->chan);
+       lttng_chan_buf->priv->rb_chan = shmp(handle, handle->chan);
        return lttng_chan_buf;
 
 error:
@@ -686,7 +687,7 @@ error:
 static
 void lttng_channel_destroy(struct lttng_ust_channel_buffer *lttng_chan_buf)
 {
-       channel_destroy(lttng_chan_buf->chan, lttng_chan_buf->chan->handle, 1);
+       channel_destroy(lttng_chan_buf->priv->rb_chan, lttng_chan_buf->priv->rb_chan->handle, 1);
        lttng_ust_free_channel_common(lttng_chan_buf->parent);
 }
 
@@ -694,12 +695,13 @@ static
 int lttng_event_reserve(struct lttng_ust_lib_ring_buffer_ctx *ctx,
                      uint32_t event_id)
 {
-       struct lttng_ust_channel_buffer *lttng_chan = channel_get_private(ctx->chan);
        struct lttng_ust_stack_ctx *lttng_ctx = ctx->priv;
        struct lttng_ust_event_recorder *event_recorder = lttng_ctx->event_recorder;
+       struct lttng_ust_channel_buffer *lttng_chan = event_recorder->chan;
        struct lttng_client_ctx client_ctx;
        int ret;
 
+       ctx->chan = lttng_chan->priv->rb_chan;
        client_ctx.chan_ctx = lttng_ust_rcu_dereference(lttng_chan->priv->ctx);
        client_ctx.event_ctx = lttng_ust_rcu_dereference(event_recorder->priv->ctx);
        /* Compute internal size of context structures. */
@@ -767,48 +769,38 @@ void lttng_event_pstrcpy_pad(struct lttng_ust_lib_ring_buffer_ctx *ctx,
        lib_ring_buffer_pstrcpy(&client_config, ctx, src, len, '\0');
 }
 
-#if 0
 static
-wait_queue_head_t *lttng_get_reader_wait_queue(struct lttng_ust_lib_ring_buffer_channel *chan)
+int lttng_is_finalized(struct lttng_ust_channel_buffer *chan)
 {
-       return &chan->read_wait;
-}
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
 
-static
-wait_queue_head_t *lttng_get_hp_wait_queue(struct lttng_ust_lib_ring_buffer_channel *chan)
-{
-       return &chan->hp_wait;
+       return lib_ring_buffer_channel_is_finalized(rb_chan);
 }
-#endif //0
 
 static
-int lttng_is_finalized(struct lttng_ust_lib_ring_buffer_channel *chan)
+int lttng_is_disabled(struct lttng_ust_channel_buffer *chan)
 {
-       return lib_ring_buffer_channel_is_finalized(chan);
-}
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
 
-static
-int lttng_is_disabled(struct lttng_ust_lib_ring_buffer_channel *chan)
-{
-       return lib_ring_buffer_channel_is_disabled(chan);
+       return lib_ring_buffer_channel_is_disabled(rb_chan);
 }
 
 static
-int lttng_flush_buffer(struct lttng_ust_lib_ring_buffer_channel *chan,
-               struct lttng_ust_shm_handle *handle)
+int lttng_flush_buffer(struct lttng_ust_channel_buffer *chan)
 {
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
        struct lttng_ust_lib_ring_buffer *buf;
        int cpu;
 
-       for_each_channel_cpu(cpu, chan) {
+       for_each_channel_cpu(cpu, rb_chan) {
                int shm_fd, wait_fd, wakeup_fd;
                uint64_t memory_map_size;
 
-               buf = channel_get_ring_buffer(&client_config, chan,
-                               cpu, handle, &shm_fd, &wait_fd,
+               buf = channel_get_ring_buffer(&client_config, rb_chan,
+                               cpu, rb_chan->handle, &shm_fd, &wait_fd,
                                &wakeup_fd, &memory_map_size);
                lib_ring_buffer_switch(&client_config, buf,
-                               SWITCH_ACTIVE, handle);
+                               SWITCH_ACTIVE, rb_chan->handle);
        }
        return 0;
 }

diff --git a/liblttng-ust/lttng-ring-buffer-metadata-client.h b/liblttng-ust/lttng-ring-buffer-metadata-client.h
index 403652031ae1a3645376ce6d020de2d1a9b177d0..ed2dcb67509701d99b7d8155d6a77adea502ebbf 100644 (file)
--- a/liblttng-ust/lttng-ring-buffer-metadata-client.h
+++ b/liblttng-ust/lttng-ring-buffer-metadata-client.h
@@ -223,7 +223,7 @@ struct lttng_ust_channel_buffer *_channel_create(const char *name,
                        stream_fds, nr_stream_fds, blocking_timeout);
        if (!handle)
                goto error;
-       lttng_chan_buf->chan = shmp(handle, handle->chan);
+       lttng_chan_buf->priv->rb_chan = shmp(handle, handle->chan);
        return lttng_chan_buf;
 
 error:
@@ -234,7 +234,7 @@ error:
 static
 void lttng_channel_destroy(struct lttng_ust_channel_buffer *lttng_chan_buf)
 {
-       channel_destroy(lttng_chan_buf->chan, lttng_chan_buf->chan->handle, 1);
+       channel_destroy(lttng_chan_buf->priv->rb_chan, lttng_chan_buf->priv->rb_chan->handle, 1);
        lttng_ust_free_channel_common(lttng_chan_buf->parent);
 }
 
@@ -266,61 +266,51 @@ void lttng_event_write(struct lttng_ust_lib_ring_buffer_ctx *ctx, const void *sr
 }
 
 static
-size_t lttng_packet_avail_size(struct lttng_ust_lib_ring_buffer_channel *chan,
-               struct lttng_ust_shm_handle *handle)
+size_t lttng_packet_avail_size(struct lttng_ust_channel_buffer *chan)
 {
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
        unsigned long o_begin;
        struct lttng_ust_lib_ring_buffer *buf;
 
-       buf = shmp(handle, chan->backend.buf[0].shmp);  /* Only for global buffer ! */
+       buf = shmp(rb_chan->handle, rb_chan->backend.buf[0].shmp);      /* Only for global buffer ! */
        o_begin = v_read(&client_config, &buf->offset);
-       if (subbuf_offset(o_begin, chan) != 0) {
-               return chan->backend.subbuf_size - subbuf_offset(o_begin, chan);
+       if (subbuf_offset(o_begin, rb_chan) != 0) {
+               return rb_chan->backend.subbuf_size - subbuf_offset(o_begin, rb_chan);
        } else {
-               return chan->backend.subbuf_size - subbuf_offset(o_begin, chan)
+               return rb_chan->backend.subbuf_size - subbuf_offset(o_begin, rb_chan)
                        - sizeof(struct metadata_packet_header);
        }
 }
 
-#if 0
 static
-wait_queue_head_t *lttng_get_reader_wait_queue(struct lttng_ust_lib_ring_buffer_channel *chan)
+int lttng_is_finalized(struct lttng_ust_channel_buffer *chan)
 {
-       return &chan->read_wait;
-}
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
 
-static
-wait_queue_head_t *lttng_get_hp_wait_queue(struct lttng_ust_lib_ring_buffer_channel *chan)
-{
-       return &chan->hp_wait;
+       return lib_ring_buffer_channel_is_finalized(rb_chan);
 }
-#endif //0
 
 static
-int lttng_is_finalized(struct lttng_ust_lib_ring_buffer_channel *chan)
+int lttng_is_disabled(struct lttng_ust_channel_buffer *chan)
 {
-       return lib_ring_buffer_channel_is_finalized(chan);
-}
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
 
-static
-int lttng_is_disabled(struct lttng_ust_lib_ring_buffer_channel *chan)
-{
-       return lib_ring_buffer_channel_is_disabled(chan);
+       return lib_ring_buffer_channel_is_disabled(rb_chan);
 }
 
 static
-int lttng_flush_buffer(struct lttng_ust_lib_ring_buffer_channel *chan,
-               struct lttng_ust_shm_handle *handle)
+int lttng_flush_buffer(struct lttng_ust_channel_buffer *chan)
 {
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan = chan->priv->rb_chan;
        struct lttng_ust_lib_ring_buffer *buf;
        int shm_fd, wait_fd, wakeup_fd;
        uint64_t memory_map_size;
 
-       buf = channel_get_ring_buffer(&client_config, chan,
-                       0, handle, &shm_fd, &wait_fd, &wakeup_fd,
+       buf = channel_get_ring_buffer(&client_config, rb_chan,
+                       0, rb_chan->handle, &shm_fd, &wait_fd, &wakeup_fd,
                        &memory_map_size);
        lib_ring_buffer_switch(&client_config, buf,
-                       SWITCH_ACTIVE, handle);
+                       SWITCH_ACTIVE, rb_chan->handle);
        return 0;
 }
 

diff --git a/liblttng-ust/lttng-ust-abi.c b/liblttng-ust/lttng-ust-abi.c
index 323e6a22672ae6b0edd12ae15658872dab8c74fe..df404de77e76d5a1c876a27e9a6c34819bc637b4 100644 (file)
--- a/liblttng-ust/lttng-ust-abi.c
+++ b/liblttng-ust/lttng-ust-abi.c
@@ -292,8 +292,8 @@ int lttng_is_channel_ready(struct lttng_ust_channel_buffer *lttng_chan)
        struct lttng_ust_lib_ring_buffer_channel *chan;
        unsigned int nr_streams, exp_streams;
 
-       chan = lttng_chan->chan;
-       nr_streams = channel_handle_get_nr_streams(lttng_chan->chan->handle);
+       chan = lttng_chan->priv->rb_chan;
+       nr_streams = channel_handle_get_nr_streams(lttng_chan->priv->rb_chan->handle);
        exp_streams = chan->nr_streams;
        return nr_streams == exp_streams;
 }
@@ -554,9 +554,9 @@ int lttng_abi_map_channel(int session_objd,
 
        lttng_chan_buf->priv->parent.tstate = 1;
        lttng_chan_buf->priv->ctx = NULL;
+       lttng_chan_buf->priv->rb_chan = chan;
 
        lttng_chan_buf->ops = &transport->ops;
-       lttng_chan_buf->chan = chan;
 
        memcpy(&chan->backend.config,
                transport->client_config,
@@ -1119,7 +1119,7 @@ int lttng_abi_map_stream(int channel_objd, struct lttng_ust_abi_stream *info,
        struct lttng_ust_channel_buffer *lttng_chan_buf = objd_private(channel_objd);
        int ret;
 
-       ret = channel_handle_add_stream(lttng_chan_buf->chan->handle,
+       ret = channel_handle_add_stream(lttng_chan_buf->priv->rb_chan->handle,
                uargs->stream.shm_fd, uargs->stream.wakeup_fd,
                info->stream_nr, info->len);
        if (ret)
@@ -1250,8 +1250,7 @@ long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg,
        case LTTNG_UST_ABI_DISABLE:
                return lttng_channel_disable(lttng_chan_buf->parent);
        case LTTNG_UST_ABI_FLUSH_BUFFER:
-               return lttng_chan_buf->ops->priv->flush_buffer(lttng_chan_buf->chan,
-                               lttng_chan_buf->chan->handle);
+               return lttng_chan_buf->ops->priv->flush_buffer(lttng_chan_buf);
        default:
                return -EINVAL;
        }

diff --git a/liblttng-ust/ust-events-internal.h b/liblttng-ust/ust-events-internal.h
index d0facc1e241ce18765a5796cd5e36d70fd741904..0a5d213ce9e2ed5b481a415692a61a431d730b61 100644 (file)
--- a/liblttng-ust/ust-events-internal.h
+++ b/liblttng-ust/ust-events-internal.h
@@ -365,12 +365,10 @@ struct lttng_ust_channel_buffer_ops_private {
         * packet. Note that the size returned is only a hint, since it
         * may change due to concurrent writes.
         */
-       size_t (*packet_avail_size)(struct lttng_ust_lib_ring_buffer_channel *chan,
-                                   struct lttng_ust_shm_handle *handle);
-       int (*is_finalized)(struct lttng_ust_lib_ring_buffer_channel *chan);
-       int (*is_disabled)(struct lttng_ust_lib_ring_buffer_channel *chan);
-       int (*flush_buffer)(struct lttng_ust_lib_ring_buffer_channel *chan,
-                           struct lttng_ust_shm_handle *handle);
+       size_t (*packet_avail_size)(struct lttng_ust_channel_buffer *chan);
+       int (*is_finalized)(struct lttng_ust_channel_buffer *chan);
+       int (*is_disabled)(struct lttng_ust_channel_buffer *chan);
+       int (*flush_buffer)(struct lttng_ust_channel_buffer *chan);
 };
 
 struct lttng_ust_channel_common_private {
@@ -389,6 +387,7 @@ struct lttng_ust_channel_buffer_private {
        unsigned int id;                        /* Channel ID */
        enum lttng_ust_abi_chan_type type;
        struct lttng_ust_ctx *ctx;
+       struct lttng_ust_lib_ring_buffer_channel *rb_chan;      /* Ring buffer channel */
        unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
 };