Version 2.2.3

[lttng-ust.git] / liblttng-ust-ctl / ustctl.c

diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c
index e00caf15ec3ed57b187d56fd915a538daf720aca..c22f578536e873873a1b813efe8b311d39d74e29 100644 (file)
--- a/liblttng-ust-ctl/ustctl.c
+++ b/liblttng-ust-ctl/ustctl.c
@@ -63,10 +63,14 @@ struct ustctl_consumer_stream {
 };
 
 extern void lttng_ring_buffer_client_overwrite_init(void);
+extern void lttng_ring_buffer_client_overwrite_rt_init(void);
 extern void lttng_ring_buffer_client_discard_init(void);
+extern void lttng_ring_buffer_client_discard_rt_init(void);
 extern void lttng_ring_buffer_metadata_client_init(void);
 extern void lttng_ring_buffer_client_overwrite_exit(void);
+extern void lttng_ring_buffer_client_overwrite_rt_exit(void);
 extern void lttng_ring_buffer_client_discard_exit(void);
+extern void lttng_ring_buffer_client_discard_rt_exit(void);
 extern void lttng_ring_buffer_metadata_client_exit(void);
 
 volatile enum ust_loglevel ust_loglevel;
@@ -752,9 +756,7 @@ int ustctl_send_channel_to_ust(int sock, int session_handle,
                return ret;
        ret = ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd);
        if (!ret) {
-               if (lur.ret_val >= 0) {
-                       channel_data->handle = lur.ret_val;
-               }
+               channel_data->handle = lur.ret_val;
        }
        return ret;
 }
@@ -915,8 +917,19 @@ struct ustctl_consumer_channel *
        switch (attr->type) {
        case LTTNG_UST_CHAN_PER_CPU:
                if (attr->output == LTTNG_UST_MMAP) {
-                       transport_name = attr->overwrite ?
-                               "relay-overwrite-mmap" : "relay-discard-mmap";
+                       if (attr->overwrite) {
+                               if (attr->read_timer_interval == 0) {
+                                       transport_name = "relay-overwrite-mmap";
+                               } else {
+                                       transport_name = "relay-overwrite-rt-mmap";
+                               }
+                       } else {
+                               if (attr->read_timer_interval == 0) {
+                                       transport_name = "relay-discard-mmap";
+                               } else {
+                                       transport_name = "relay-discard-rt-mmap";
+                               }
+                       }
                } else {
                        return NULL;
                }
@@ -947,12 +960,14 @@ struct ustctl_consumer_channel *
                        attr->subbuf_size, attr->num_subbuf,
                        attr->switch_timer_interval,
                        attr->read_timer_interval,
-                       attr->uuid);
+                       attr->uuid, attr->chan_id);
        if (!chan->chan) {
                goto chan_error;
        }
        chan->chan->ops = &transport->ops;
        memcpy(&chan->attr, attr, sizeof(chan->attr));
+       chan->wait_fd = ustctl_channel_get_wait_fd(chan);
+       chan->wakeup_fd = ustctl_channel_get_wakeup_fd(chan);
        return chan;
 
 chan_error:
@@ -962,6 +977,8 @@ chan_error:
 
 void ustctl_destroy_channel(struct ustctl_consumer_channel *chan)
 {
+       (void) ustctl_channel_close_wait_fd(chan);
+       (void) ustctl_channel_close_wakeup_fd(chan);
        chan->chan->ops->channel_destroy(chan->chan);
        free(chan);
 }
@@ -1042,19 +1059,27 @@ end:
 int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan)
 {
        struct channel *chan;
+       int ret;
 
        chan = consumer_chan->chan->chan;
-       return ring_buffer_channel_close_wait_fd(&chan->backend.config,
+       ret = ring_buffer_channel_close_wait_fd(&chan->backend.config,
                        chan, chan->handle);
+       if (!ret)
+               consumer_chan->wait_fd = -1;
+       return ret;
 }
 
 int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan)
 {
        struct channel *chan;
+       int ret;
 
        chan = consumer_chan->chan->chan;
-       return ring_buffer_channel_close_wakeup_fd(&chan->backend.config,
+       ret = ring_buffer_channel_close_wakeup_fd(&chan->backend.config,
                        chan, chan->handle);
+       if (!ret)
+               consumer_chan->wakeup_fd = -1;
+       return ret;
 }
 
 int ustctl_stream_close_wait_fd(struct ustctl_consumer_stream *stream)
@@ -1128,6 +1153,8 @@ void ustctl_destroy_stream(struct ustctl_consumer_stream *stream)
        assert(stream);
        buf = stream->buf;
        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->handle);
        free(stream);
 }
@@ -1555,7 +1582,7 @@ int ustctl_recv_register_event(int sock,
                goto signature_error;
        }
        /* Enforce end of string */
-       signature[signature_len - 1] = '\0';
+       a_sign[signature_len - 1] = '\0';
 
        /* recv fields */
        if (fields_len) {
@@ -1748,14 +1775,18 @@ void ustctl_init(void)
        init_usterr();
        lttng_ring_buffer_metadata_client_init();
        lttng_ring_buffer_client_overwrite_init();
+       lttng_ring_buffer_client_overwrite_rt_init();
        lttng_ring_buffer_client_discard_init();
+       lttng_ring_buffer_client_discard_rt_init();
        lib_ringbuffer_signal_init();
 }
 
 static __attribute__((destructor))
 void ustctl_exit(void)
 {
+       lttng_ring_buffer_client_discard_rt_exit();
        lttng_ring_buffer_client_discard_exit();
+       lttng_ring_buffer_client_overwrite_rt_exit();
        lttng_ring_buffer_client_overwrite_exit();
        lttng_ring_buffer_metadata_client_exit();
 }