lib/librte_telemetry/telemetry_data.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Intel Corporation
   3  */
   4
   5 #undef RTE_USE_LIBBSD
   6 #include <rte_string_fns.h>
   7
   8 #include "telemetry_data.h"
   9
  10 int
  11 rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type)
  12 {
  13         enum tel_container_types array_types[] = {
  14                         RTE_TEL_ARRAY_STRING, /* RTE_TEL_STRING_VAL = 0 */
  15                         RTE_TEL_ARRAY_INT,    /* RTE_TEL_INT_VAL = 1 */
  16                         RTE_TEL_ARRAY_U64,    /* RTE_TEL_u64_VAL = 2 */
  17         };
  18         d->type = array_types[type];
  19         d->data_len = 0;
  20         return 0;
  21 }
  22
  23 int
  24 rte_tel_data_start_dict(struct rte_tel_data *d)
  25 {
  26         d->type = RTE_TEL_DICT;
  27         d->data_len = 0;
  28         return 0;
  29 }
  30
  31 int
  32 rte_tel_data_string(struct rte_tel_data *d, const char *str)
  33 {
  34         d->type = RTE_TEL_STRING;
  35         d->data_len = strlcpy(d->data.str, str, sizeof(d->data.str));
  36         if (d->data_len >= RTE_TEL_MAX_SINGLE_STRING_LEN) {
  37                 d->data_len = RTE_TEL_MAX_SINGLE_STRING_LEN - 1;
  38                 return E2BIG; /* not necessarily and error, just truncation */
  39         }
  40         return 0;
  41 }
  42
  43 int
  44 rte_tel_data_add_array_string(struct rte_tel_data *d, const char *str)
  45 {
  46         if (d->type != RTE_TEL_ARRAY_STRING)
  47                 return -EINVAL;
  48         if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
  49                 return -ENOSPC;
  50         const size_t bytes = strlcpy(d->data.array[d->data_len++].sval,
  51                         str, RTE_TEL_MAX_STRING_LEN);
  52         return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
  53 }
  54
  55 int
  56 rte_tel_data_add_array_int(struct rte_tel_data *d, int x)
  57 {
  58         if (d->type != RTE_TEL_ARRAY_INT)
  59                 return -EINVAL;
  60         if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
  61                 return -ENOSPC;
  62         d->data.array[d->data_len++].ival = x;
  63         return 0;
  64 }
  65
  66 int
  67 rte_tel_data_add_array_u64(struct rte_tel_data *d, uint64_t x)
  68 {
  69         if (d->type != RTE_TEL_ARRAY_U64)
  70                 return -EINVAL;
  71         if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
  72                 return -ENOSPC;
  73         d->data.array[d->data_len++].u64val = x;
  74         return 0;
  75 }
  76
  77 int
  78 rte_tel_data_add_dict_string(struct rte_tel_data *d, const char *name,
  79                 const char *val)
  80 {
  81         struct tel_dict_entry *e = &d->data.dict[d->data_len];
  82         size_t nbytes, vbytes;
  83
  84         if (d->type != RTE_TEL_DICT)
  85                 return -EINVAL;
  86         if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
  87                 return -ENOSPC;
  88
  89         d->data_len++;
  90         e->type = RTE_TEL_STRING_VAL;
  91         vbytes = strlcpy(e->value.sval, val, RTE_TEL_MAX_STRING_LEN);
  92         nbytes = strlcpy(e->name, name, RTE_TEL_MAX_STRING_LEN);
  93         if (vbytes >= RTE_TEL_MAX_STRING_LEN ||
  94                         nbytes >= RTE_TEL_MAX_STRING_LEN)
  95                 return E2BIG;
  96         return 0;
  97 }
  98
  99 int
 100 rte_tel_data_add_dict_int(struct rte_tel_data *d, const char *name, int val)
 101 {
 102         struct tel_dict_entry *e = &d->data.dict[d->data_len];
 103         if (d->type != RTE_TEL_DICT)
 104                 return -EINVAL;
 105         if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
 106                 return -ENOSPC;
 107
 108         d->data_len++;
 109         e->type = RTE_TEL_INT_VAL;
 110         e->value.ival = val;
 111         const size_t bytes = strlcpy(e->name, name, RTE_TEL_MAX_STRING_LEN);
 112         return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
 113 }
 114
 115 int
 116 rte_tel_data_add_dict_u64(struct rte_tel_data *d,
 117                 const char *name, uint64_t val)
 118 {
 119         struct tel_dict_entry *e = &d->data.dict[d->data_len];
 120         if (d->type != RTE_TEL_DICT)
 121                 return -EINVAL;
 122         if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
 123                 return -ENOSPC;
 124
 125         d->data_len++;
 126         e->type = RTE_TEL_U64_VAL;
 127         e->value.u64val = val;
 128         const size_t bytes = strlcpy(e->name, name, RTE_TEL_MAX_STRING_LEN);
 129         return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
 130 }