Fix: lttng-ust-comm.c: return number of fd rather size of array

[lttng-ust.git] / liblttng-ust-comm / lttng-ust-comm.c

diff --git a/liblttng-ust-comm/lttng-ust-comm.c b/liblttng-ust-comm/lttng-ust-comm.c
index 9fe6d288d633a2ec67c8d78a82cf90d2e52dc2c2..5b9cb85381fcb815998c7ecaa733a52a7d2a31e7 100644 (file)
--- a/liblttng-ust-comm/lttng-ust-comm.c
+++ b/liblttng-ust-comm/lttng-ust-comm.c
@@ -19,6 +19,7 @@
 
 #define _GNU_SOURCE
 #include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -438,8 +439,6 @@ ssize_t ustcomm_send_fds_unix_sock(int sock, int *fds, size_t nb_fd)
 /*
  * Recv a message accompanied by fd(s) from a unix socket.
  *
- * Returns the size of received data, or negative error value.
- *
  * Expect at most "nb_fd" file descriptors. Returns the number of fd
  * actually received in nb_fd.
  * Returns -EPIPE on orderly shutdown.
@@ -509,7 +508,7 @@ ssize_t ustcomm_recv_fds_unix_sock(int sock, int *fds, size_t nb_fd)
                goto end;
        }
        memcpy(fds, CMSG_DATA(cmsg), sizeof_fds);
-       ret = sizeof_fds;
+       ret = nb_fd;
 end:
        return ret;
 }
@@ -598,7 +597,7 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
 {
        void *chan_data;
        ssize_t len, nr_fd;
-       int wakeup_fd;
+       int wakeup_fd, ret;
 
        if (var_len > LTTNG_UST_CHANNEL_DATA_MAX_LEN) {
                len = -EINVAL;
@@ -627,9 +626,21 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
                        goto error_recv;
                }
        }
-       *_wakeup_fd = wakeup_fd;
-       lttng_ust_add_fd_to_tracker(wakeup_fd);
+
+       ret = lttng_ust_add_fd_to_tracker(wakeup_fd);
+       if (ret < 0) {
+               ret = close(wakeup_fd);
+               if (ret) {
+                       PERROR("close on wakeup_fd");
+               }
+               len = -EIO;
+               lttng_ust_unlock_fd_tracker();
+               goto error_recv;
+       }
+
+       *_wakeup_fd = ret;
        lttng_ust_unlock_fd_tracker();
+
        *_chan_data = chan_data;
        return len;
 
@@ -661,10 +672,35 @@ int ustcomm_recv_stream_from_sessiond(int sock,
                        goto error;
                }
        }
-       *shm_fd = fds[0];
-       *wakeup_fd = fds[1];
-       lttng_ust_add_fd_to_tracker(fds[0]);
-       lttng_ust_add_fd_to_tracker(fds[1]);
+
+       ret = lttng_ust_add_fd_to_tracker(fds[0]);
+       if (ret < 0) {
+               ret = close(fds[0]);
+               if (ret) {
+                       PERROR("close on received shm_fd");
+               }
+               ret = -EIO;
+               lttng_ust_unlock_fd_tracker();
+               goto error;
+       }
+       *shm_fd = ret;
+
+       ret = lttng_ust_add_fd_to_tracker(fds[1]);
+       if (ret < 0) {
+               ret = close(*shm_fd);
+               if (ret) {
+                       PERROR("close on shm_fd");
+               }
+               *shm_fd = -1;
+               ret = close(fds[1]);
+               if (ret) {
+                       PERROR("close on received wakeup_fd");
+               }
+               ret = -EIO;
+               lttng_ust_unlock_fd_tracker();
+               goto error;
+       }
+       *wakeup_fd = ret;
        lttng_ust_unlock_fd_tracker();
        return 0;
 
@@ -816,12 +852,15 @@ static
 int serialize_integer_type(struct ustctl_integer_type *uit,
                const struct lttng_integer_type *lit)
 {
+       int32_t encoding;
+
        uit->size = lit->size;
        uit->signedness = lit->signedness;
        uit->reverse_byte_order = lit->reverse_byte_order;
        uit->base = lit->base;
-       if (serialize_string_encoding(&uit->encoding, lit->encoding))
+       if (serialize_string_encoding(&encoding, lit->encoding))
                return -EINVAL;
+       uit->encoding = encoding;
        uit->alignment = lit->alignment;
        return 0;
 }
@@ -843,9 +882,11 @@ int serialize_basic_type(struct lttng_session *session,
        }
        case atype_string:
        {
-               if (serialize_string_encoding(&ubt->string.encoding,
-                               lbt->string.encoding))
+               int32_t encoding;
+
+               if (serialize_string_encoding(&encoding, lbt->string.encoding))
                        return -EINVAL;
+               ubt->string.encoding = encoding;
                *uatype = ustctl_atype_string;
                break;
        }
@@ -874,8 +915,7 @@ int serialize_basic_type(struct lttng_session *session,
                if (session) {
                        const struct lttng_enum *_enum;
 
-                       _enum = lttng_ust_enum_get(session,
-                                       lbt->enumeration.desc->name);
+                       _enum = lttng_ust_enum_get_from_desc(session, lbt->enumeration.desc);
                        if (!_enum)
                                return -EINVAL;
                        ubt->enumeration.id = _enum->id;
@@ -971,13 +1011,15 @@ int serialize_one_field(struct lttng_session *session,
        {
                struct ustctl_field *uf = &fields[*iter_output];
                struct ustctl_type *ut = &uf->type;
+               enum ustctl_abstract_types atype;
 
                strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
                uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-               ret = serialize_basic_type(session, &ut->atype, lt->atype,
+               ret = serialize_basic_type(session, &atype, lt->atype,
                        &ut->u.basic, &lt->u.basic);
                if (ret)
                        return ret;
+               ut->atype = atype;
                (*iter_output)++;
                break;
        }
@@ -987,6 +1029,7 @@ int serialize_one_field(struct lttng_session *session,
                struct ustctl_type *ut = &uf->type;
                struct ustctl_basic_type *ubt;
                const struct lttng_basic_type *lbt;
+               enum ustctl_abstract_types atype;
 
                strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
                uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
@@ -994,10 +1037,11 @@ int serialize_one_field(struct lttng_session *session,
                ubt = &ut->u.array.elem_type;
                lbt = &lt->u.array.elem_type;
                ut->u.array.length = lt->u.array.length;
-               ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
+               ret = serialize_basic_type(session, &atype, lbt->atype,
                        &ubt->u.basic, &lbt->u.basic);
                if (ret)
                        return -EINVAL;
+               ubt->atype = atype;
                ut->atype = ustctl_atype_array;
                (*iter_output)++;
                break;
@@ -1008,6 +1052,7 @@ int serialize_one_field(struct lttng_session *session,
                struct ustctl_type *ut = &uf->type;
                struct ustctl_basic_type *ubt;
                const struct lttng_basic_type *lbt;
+               enum ustctl_abstract_types atype;
                int ret;
 
                strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
@@ -1015,16 +1060,18 @@ int serialize_one_field(struct lttng_session *session,
                uf->type.atype = ustctl_atype_sequence;
                ubt = &ut->u.sequence.length_type;
                lbt = &lt->u.sequence.length_type;
-               ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
+               ret = serialize_basic_type(session, &atype, lbt->atype,
                        &ubt->u.basic, &lbt->u.basic);
                if (ret)
                        return -EINVAL;
+               ubt->atype = atype;
                ubt = &ut->u.sequence.elem_type;
                lbt = &lt->u.sequence.elem_type;
-               ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
+               ret = serialize_basic_type(session, &atype, lbt->atype,
                        &ubt->u.basic, &lbt->u.basic);
                if (ret)
                        return -EINVAL;
+               ubt->atype = atype;
                ut->atype = ustctl_atype_sequence;
                (*iter_output)++;
                break;