Refactoring: struct lttng_enum_desc and lttng_enum_entry

[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 2cab469eb7cf0558cfe71be942448a8549fd4267..656e170b100a8f0694b1ff3c37d2b324079204f2 100644 (file)
--- a/liblttng-ust-comm/lttng-ust-comm.c
+++ b/liblttng-ust-comm/lttng-ust-comm.c
@@ -37,16 +37,16 @@
 
 static
 ssize_t count_fields_recursive(size_t nr_fields,
-               const struct lttng_event_field *lttng_fields);
+               const struct lttng_ust_event_field **lttng_fields);
 static
 int serialize_one_field(struct lttng_session *session,
                struct ustctl_field *fields, size_t *iter_output,
-               const struct lttng_event_field *lf);
+               const struct lttng_ust_event_field *lf);
 static
 int serialize_fields(struct lttng_session *session,
                struct ustctl_field *ustctl_fields,
                size_t *iter_output, size_t nr_lttng_fields,
-               const struct lttng_event_field *lttng_fields);
+               const struct lttng_ust_event_field **lttng_fields);
 
 /*
  * Human readable error message.
@@ -606,7 +606,7 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
        ssize_t len, nr_fd;
        int wakeup_fd, ret;
 
-       if (var_len > LTTNG_UST_CHANNEL_DATA_MAX_LEN) {
+       if (var_len > LTTNG_UST_ABI_CHANNEL_DATA_MAX_LEN) {
                len = -EINVAL;
                goto error_check;
        }
@@ -761,7 +761,7 @@ ssize_t ustcomm_recv_counter_from_sessiond(int sock,
        void *counter_data;
        ssize_t len;
 
-       if (var_len > LTTNG_UST_COUNTER_DATA_MAX_LEN) {
+       if (var_len > LTTNG_UST_ABI_COUNTER_DATA_MAX_LEN) {
                len = -EINVAL;
                goto error_check;
        }
@@ -839,7 +839,7 @@ int ustcomm_send_reg_msg(int sock,
        ssize_t len;
        struct ustctl_reg_msg reg_msg;
 
-       reg_msg.magic = LTTNG_UST_COMM_MAGIC;
+       reg_msg.magic = LTTNG_UST_ABI_COMM_MAGIC;
        reg_msg.major = LTTNG_UST_ABI_MAJOR_VERSION;
        reg_msg.minor = LTTNG_UST_ABI_MINOR_VERSION;
        reg_msg.pid = getpid();
@@ -884,7 +884,7 @@ ssize_t count_one_type(const struct lttng_type *lt)
 
        case atype_dynamic:
        {
-               const struct lttng_event_field *choices;
+               const struct lttng_ust_event_field **choices;
                size_t nr_choices;
                int ret;
 
@@ -907,15 +907,15 @@ ssize_t count_one_type(const struct lttng_type *lt)
 
 static
 ssize_t count_fields_recursive(size_t nr_fields,
-               const struct lttng_event_field *lttng_fields)
+               const struct lttng_ust_event_field **lttng_fields)
 {
        int i;
        ssize_t ret, count = 0;
 
        for (i = 0; i < nr_fields; i++) {
-               const struct lttng_event_field *lf;
+               const struct lttng_ust_event_field *lf;
 
-               lf = &lttng_fields[i];
+               lf = lttng_fields[i];
                /* skip 'nowrite' fields */
                if (lf->nowrite)
                        continue;
@@ -935,7 +935,7 @@ ssize_t count_ctx_fields_recursive(size_t nr_fields,
        ssize_t ret, count = 0;
 
        for (i = 0; i < nr_fields; i++) {
-               const struct lttng_event_field *lf;
+               const struct lttng_ust_event_field *lf;
 
                lf = &lttng_fields[i].event_field;
                /* skip 'nowrite' fields */
@@ -949,16 +949,53 @@ ssize_t count_ctx_fields_recursive(size_t nr_fields,
        return count;
 }
 
+static
+int serialize_string_encoding(int32_t *ue,
+               enum lttng_string_encodings le)
+{
+       switch (le) {
+       case lttng_encode_none:
+               *ue = ustctl_encode_none;
+               break;
+       case lttng_encode_UTF8:
+               *ue = ustctl_encode_UTF8;
+               break;
+       case lttng_encode_ASCII:
+               *ue = ustctl_encode_ASCII;
+               break;
+       default:
+               return -EINVAL;
+       }
+       return 0;
+}
+
+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(&encoding, lit->encoding))
+               return -EINVAL;
+       uit->encoding = encoding;
+       uit->alignment = lit->alignment;
+       return 0;
+}
+
 static
 int serialize_dynamic_type(struct lttng_session *session,
                struct ustctl_field *fields, size_t *iter_output,
                const char *field_name)
 {
-       const struct lttng_event_field *choices;
-       char tag_field_name[LTTNG_UST_SYM_NAME_LEN];
+       const struct lttng_ust_event_field **choices;
+       char tag_field_name[LTTNG_UST_ABI_SYM_NAME_LEN];
        const struct lttng_type *tag_type;
-       const struct lttng_event_field *tag_field_generic;
-       struct lttng_event_field tag_field = {
+       const struct lttng_ust_event_field *tag_field_generic;
+       struct lttng_ust_event_field tag_field = {
                .name = tag_field_name,
                .nowrite = 0,
        };
@@ -970,11 +1007,11 @@ int serialize_dynamic_type(struct lttng_session *session,
        tag_type = &tag_field_generic->type;
 
        /* Serialize enum field. */
-       strncpy(tag_field_name, field_name, LTTNG_UST_SYM_NAME_LEN);
-       tag_field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+       strncpy(tag_field_name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+       tag_field_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
        strncat(tag_field_name,
                "_tag",
-               LTTNG_UST_SYM_NAME_LEN - strlen(tag_field_name) - 1);
+               LTTNG_UST_ABI_SYM_NAME_LEN - strlen(tag_field_name) - 1);
        tag_field.type = *tag_type;
        ret = serialize_one_field(session, fields, iter_output,
                &tag_field);
@@ -987,21 +1024,21 @@ int serialize_dynamic_type(struct lttng_session *session,
        if (ret)
                return ret;
 
-       strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
-       uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
        uf->type.atype = ustctl_atype_variant;
        uf->type.u.variant_nestable.nr_choices = nr_choices;
        strncpy(uf->type.u.variant_nestable.tag_name,
                tag_field_name,
-               LTTNG_UST_SYM_NAME_LEN);
-       uf->type.u.variant_nestable.tag_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+               LTTNG_UST_ABI_SYM_NAME_LEN);
+       uf->type.u.variant_nestable.tag_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
        uf->type.u.variant_nestable.alignment = 0;
        (*iter_output)++;
 
        /* Serialize choice fields after variant. */
        for (i = 0; i < nr_choices; i++) {
                ret = serialize_one_field(session, fields,
-                       iter_output, &choices[i]);
+                       iter_output, choices[i]);
                if (ret)
                        return ret;
        }
@@ -1022,16 +1059,74 @@ int serialize_one_type(struct lttng_session *session,
 
        switch (lt->atype) {
        case atype_integer:
+       {
+               struct ustctl_field *uf = &fields[*iter_output];
+               struct ustctl_type *ut = &uf->type;
+
+               if (field_name) {
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+               } else {
+                       uf->name[0] = '\0';
+               }
+               ret = serialize_integer_type(&ut->u.integer, &lt->u.integer);
+               if (ret)
+                       return ret;
+               ut->atype = ustctl_atype_integer;
+               (*iter_output)++;
+               break;
+       }
        case atype_float:
+       {
+               struct ustctl_field *uf = &fields[*iter_output];
+               struct ustctl_type *ut = &uf->type;
+               struct ustctl_float_type *uft;
+               const struct lttng_float_type *lft;
+
+               if (field_name) {
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+               } else {
+                       uf->name[0] = '\0';
+               }
+               uft = &ut->u._float;
+               lft = &lt->u._float;
+               uft->exp_dig = lft->exp_dig;
+               uft->mant_dig = lft->mant_dig;
+               uft->alignment = lft->alignment;
+               uft->reverse_byte_order = lft->reverse_byte_order;
+               ut->atype = ustctl_atype_float;
+               (*iter_output)++;
+               break;
+       }
        case atype_string:
+       {
+               struct ustctl_field *uf = &fields[*iter_output];
+               struct ustctl_type *ut = &uf->type;
+               int32_t encoding;
+
+               if (field_name) {
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+               } else {
+                       uf->name[0] = '\0';
+               }
+               ret = serialize_string_encoding(&encoding, lt->u.string.encoding);
+               if (ret)
+                       return ret;
+               ut->u.string.encoding = encoding;
+               ut->atype = ustctl_atype_string;
+               (*iter_output)++;
+               break;
+       }
        case atype_array_nestable:
        {
                struct ustctl_field *uf = &fields[*iter_output];
                struct ustctl_type *ut = &uf->type;
 
                if (field_name) {
-                       strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
-                       uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
                } else {
                        uf->name[0] = '\0';
                }
@@ -1052,16 +1147,16 @@ int serialize_one_type(struct lttng_session *session,
                struct ustctl_type *ut = &uf->type;
 
                if (field_name) {
-                       strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
-                       uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
                } else {
                        uf->name[0] = '\0';
                }
                ut->atype = ustctl_atype_sequence_nestable;
                strncpy(ut->u.sequence_nestable.length_name,
                        lt->u.sequence_nestable.length_name,
-                       LTTNG_UST_SYM_NAME_LEN);
-               ut->u.sequence_nestable.length_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+                       LTTNG_UST_ABI_SYM_NAME_LEN);
+               ut->u.sequence_nestable.length_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
                ut->u.sequence_nestable.alignment = lt->u.sequence_nestable.alignment;
                (*iter_output)++;
 
@@ -1084,8 +1179,8 @@ int serialize_one_type(struct lttng_session *session,
                struct ustctl_field *uf = &fields[*iter_output];
 
                if (field_name) {
-                       strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
-                       uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
                } else {
                        uf->name[0] = '\0';
                }
@@ -1107,14 +1202,14 @@ int serialize_one_type(struct lttng_session *session,
                struct ustctl_type *ut = &uf->type;
 
                if (field_name) {
-                       strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
-                       uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+                       strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+                       uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
                } else {
                        uf->name[0] = '\0';
                }
                strncpy(ut->u.enum_nestable.name, lt->u.enum_nestable.desc->name,
-                               LTTNG_UST_SYM_NAME_LEN);
-               ut->u.enum_nestable.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+                               LTTNG_UST_ABI_SYM_NAME_LEN);
+               ut->u.enum_nestable.name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
                ut->atype = ustctl_atype_enum_nestable;
                (*iter_output)++;
 
@@ -1143,7 +1238,7 @@ int serialize_one_type(struct lttng_session *session,
 static
 int serialize_one_field(struct lttng_session *session,
                struct ustctl_field *fields, size_t *iter_output,
-               const struct lttng_event_field *lf)
+               const struct lttng_ust_event_field *lf)
 {
        /* skip 'nowrite' fields */
        if (lf->nowrite)
@@ -1156,14 +1251,14 @@ static
 int serialize_fields(struct lttng_session *session,
                struct ustctl_field *ustctl_fields,
                size_t *iter_output, size_t nr_lttng_fields,
-               const struct lttng_event_field *lttng_fields)
+               const struct lttng_ust_event_field **lttng_fields)
 {
        int ret;
        size_t i;
 
        for (i = 0; i < nr_lttng_fields; i++) {
                ret = serialize_one_field(session, ustctl_fields,
-                               iter_output, &lttng_fields[i]);
+                               iter_output, lttng_fields[i]);
                if (ret)
                        return ret;
        }
@@ -1175,7 +1270,7 @@ int alloc_serialize_fields(struct lttng_session *session,
                size_t *_nr_write_fields,
                struct ustctl_field **ustctl_fields,
                size_t nr_fields,
-               const struct lttng_event_field *lttng_fields)
+               const struct lttng_ust_event_field **lttng_fields)
 {
        struct ustctl_field *fields;
        int ret;
@@ -1208,7 +1303,7 @@ error_type:
 static
 int serialize_entries(struct ustctl_enum_entry **_entries,
                size_t nr_entries,
-               const struct lttng_enum_entry *lttng_entries)
+               const struct lttng_ust_enum_entry **lttng_entries)
 {
        struct ustctl_enum_entry *entries;
        int i;
@@ -1219,19 +1314,19 @@ int serialize_entries(struct ustctl_enum_entry **_entries,
                return -ENOMEM;
        for (i = 0; i < nr_entries; i++) {
                struct ustctl_enum_entry *uentry;
-               const struct lttng_enum_entry *lentry;
+               const struct lttng_ust_enum_entry *lentry;
 
                uentry = &entries[i];
-               lentry = &lttng_entries[i];
+               lentry = lttng_entries[i];
 
                uentry->start.value = lentry->start.value;
                uentry->start.signedness = lentry->start.signedness;
                uentry->end.value = lentry->end.value;
                uentry->end.signedness = lentry->end.signedness;
-               strncpy(uentry->string, lentry->string, LTTNG_UST_SYM_NAME_LEN);
-               uentry->string[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+               strncpy(uentry->string, lentry->string, LTTNG_UST_ABI_SYM_NAME_LEN);
+               uentry->string[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
 
-               if (lentry->u.extra.options & LTTNG_ENUM_ENTRY_OPTION_IS_AUTO) {
+               if (lentry->options & LTTNG_ENUM_ENTRY_OPTION_IS_AUTO) {
                        uentry->u.extra.options |=
                                USTCTL_UST_ENUM_ENTRY_OPTION_IS_AUTO;
                }
@@ -1289,7 +1384,7 @@ int ustcomm_register_event(int sock,
        int loglevel,
        const char *signature,          /* event signature (input) */
        size_t nr_fields,               /* fields */
-       const struct lttng_event_field *lttng_fields,
+       const struct lttng_ust_event_field **lttng_fields,
        const char *model_emf_uri,
        uint32_t *id)                   /* event id (output) */
 {
@@ -1311,8 +1406,8 @@ int ustcomm_register_event(int sock,
        msg.header.notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
        msg.m.session_objd = session_objd;
        msg.m.channel_objd = channel_objd;
-       strncpy(msg.m.event_name, event_name, LTTNG_UST_SYM_NAME_LEN);
-       msg.m.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+       strncpy(msg.m.event_name, event_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+       msg.m.event_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
        msg.m.loglevel = loglevel;
        signature_len = strlen(signature) + 1;
        msg.m.signature_len = signature_len;
@@ -1428,7 +1523,7 @@ int ustcomm_register_enum(int sock,
        int session_objd,               /* session descriptor */
        const char *enum_name,          /* enum name (input) */
        size_t nr_entries,              /* entries */
-       const struct lttng_enum_entry *lttng_entries,
+       const struct lttng_ust_enum_entry **lttng_entries,
        uint64_t *id)
 {
        ssize_t len;
@@ -1447,8 +1542,8 @@ int ustcomm_register_enum(int sock,
        memset(&msg, 0, sizeof(msg));
        msg.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
        msg.m.session_objd = session_objd;
-       strncpy(msg.m.enum_name, enum_name, LTTNG_UST_SYM_NAME_LEN);
-       msg.m.enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+       strncpy(msg.m.enum_name, enum_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+       msg.m.enum_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
 
        /* Calculate entries len, serialize entries. */
        if (nr_entries > 0) {