Implement loglevels as event and wildcard attributes

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

diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c
index f7e13a1a06e8618823899e8a49286278d8f4ce5a..32fa2ebc33e92e054a7591435fa9aadffef47009 100644 (file)
--- a/liblttng-ust-ctl/ustctl.c
+++ b/liblttng-ust-ctl/ustctl.c
@@ -135,7 +135,7 @@ int ustctl_open_metadata(int sock, int session_handle,
        struct ustcomm_ust_msg lum;
        struct ustcomm_ust_reply lur;
        struct lttng_ust_object_data *metadata_data;
-       int ret;
+       int ret, err = 0;
 
        metadata_data = malloc(sizeof(*metadata_data));
        if (!metadata_data)
@@ -166,13 +166,21 @@ int ustctl_open_metadata(int sock, int session_handle,
        /* get shm fd */
        ret = ustcomm_recv_fd(sock);
        if (ret < 0)
-               goto error;
-       metadata_data->shm_fd = ret;
+               err = 1;
+       else
+               metadata_data->shm_fd = ret;
+       /*
+        * We need to get the second FD even if the first fails, because
+        * libust expects us to read the two FDs.
+        */
        /* get wait fd */
        ret = ustcomm_recv_fd(sock);
        if (ret < 0)
+               err = 1;
+       else
+               metadata_data->wait_fd = ret;
+       if (err)
                goto error;
-       metadata_data->wait_fd = ret;
        *_metadata_data = metadata_data;
        return 0;
 
@@ -189,7 +197,7 @@ int ustctl_create_channel(int sock, int session_handle,
        struct ustcomm_ust_msg lum;
        struct ustcomm_ust_reply lur;
        struct lttng_ust_object_data *channel_data;
-       int ret;
+       int ret, err = 0;
 
        channel_data = malloc(sizeof(*channel_data));
        if (!channel_data)
@@ -220,13 +228,21 @@ int ustctl_create_channel(int sock, int session_handle,
        /* get shm fd */
        ret = ustcomm_recv_fd(sock);
        if (ret < 0)
-               goto error;
-       channel_data->shm_fd = ret;
+               err = 1;
+       else
+               channel_data->shm_fd = ret;
+       /*
+        * We need to get the second FD even if the first fails, because
+        * libust expects us to read the two FDs.
+        */
        /* get wait fd */
        ret = ustcomm_recv_fd(sock);
        if (ret < 0)
+               err = 1;
+       else
+               channel_data->wait_fd = ret;
+       if (err)
                goto error;
-       channel_data->wait_fd = ret;
        *_channel_data = channel_data;
        return 0;
 
@@ -247,7 +263,7 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
        struct ustcomm_ust_msg lum;
        struct ustcomm_ust_reply lur;
        struct lttng_ust_object_data *stream_data;
-       int ret, fd;
+       int ret, fd, err = 0;
 
        stream_data = malloc(sizeof(*stream_data));
        if (!stream_data)
@@ -272,13 +288,21 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
        /* get shm fd */
        fd = ustcomm_recv_fd(sock);
        if (fd < 0)
-               goto error;
-       stream_data->shm_fd = fd;
+               err = 1;
+       else
+               stream_data->shm_fd = fd;
+       /*
+        * We need to get the second FD even if the first fails, because
+        * libust expects us to read the two FDs.
+        */
        /* get wait fd */
        fd = ustcomm_recv_fd(sock);
        if (fd < 0)
+               err = 1;
+       else
+               stream_data->wait_fd = fd;
+       if (err)
                goto error;
-       stream_data->wait_fd = fd;
        *_stream_data = stream_data;
        return ret;
 
@@ -307,6 +331,8 @@ int ustctl_create_event(int sock, struct lttng_ust_event *ev,
        strncpy(lum.u.event.name, ev->name,
                LTTNG_UST_SYM_NAME_LEN);
        lum.u.event.instrumentation = ev->instrumentation;
+       lum.u.event.loglevel_type = ev->loglevel_type;
+       lum.u.event.loglevel = ev->loglevel;
        ret = ustcomm_send_app_cmd(sock, &lum, &lur);
        if (ret) {
                free(event_data);
@@ -426,10 +452,9 @@ int ustctl_tracepoint_list_get(int sock, int tp_list_handle,
        ret = ustcomm_send_app_cmd(sock, &lum, &lur);
        if (ret)
                return ret;
-       DBG("received tracepoint list entry name %s loglevel %s loglevel_value %lld",
+       DBG("received tracepoint list entry name %s loglevel %d",
                lur.u.tracepoint.name,
-               lur.u.tracepoint.loglevel,
-               (unsigned long long) lur.u.tracepoint.loglevel_value);
+               lur.u.tracepoint.loglevel);
        memcpy(iter, &lur.u.tracepoint, sizeof(*iter));
        return 0;
 }
@@ -507,12 +532,24 @@ struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *ch
                return NULL;
        }
        /*
-        * Set to -1 because the lttng_ust_shm_handle destruction will take care
-        * of closing shm_fd and wait_fd.
+        * Set to -1, and then close the shm fd, and set the handle shm
+        * fd to -1 too. We don't need the shm fds after they have been
+        * mapped.
+        * The wait_fd is set to -1 in chan_data because it is now owned
+        * by the handle.
         */
        chan_data->shm_fd = -1;
        chan_data->wait_fd = -1;
 
+       /* chan is object 0. This is hardcoded. */
+       if (handle->table->objects[0].shm_fd >= 0) {
+               ret = close(handle->table->objects[0].shm_fd);
+               if (ret) {
+                       perror("Error closing shm_fd");
+               }
+               handle->table->objects[0].shm_fd = -1;
+       }
+
        /*
         * TODO: add consistency checks to be resilient if the
         * application try to feed us with incoherent channel structure
@@ -596,6 +633,9 @@ void ustctl_unmap_channel(struct lttng_ust_shm_handle *handle)
        channel_destroy(chan, handle, 1);
 }
 
+/*
+ * ustctl closes the shm_fd fds after mapping it.
+ */
 struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_handle *handle,
        int cpu)
 {
@@ -612,6 +652,16 @@ struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_h
        ret = lib_ring_buffer_open_read(buf, handle, 1);
        if (ret)
                return NULL;
+       /*
+        * We can close shm_fd early, right after is has been mapped.
+        */
+       if (*shm_fd >= 0) {
+               ret = close(*shm_fd);
+               if (ret) {
+                       perror("Error closing shm_fd");
+               }
+               *shm_fd = -1;
+       }
        return buf;
 }