lib/librte_stack/rte_stack.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6
   7 #include <rte_atomic.h>
   8 #include <rte_eal.h>
   9 #include <rte_eal_memconfig.h>
  10 #include <rte_errno.h>
  11 #include <rte_malloc.h>
  12 #include <rte_memzone.h>
  13 #include <rte_rwlock.h>
  14 #include <rte_tailq.h>
  15
  16 #include "rte_stack.h"
  17 #include "rte_stack_pvt.h"
  18
  19 int stack_logtype;
  20
  21 TAILQ_HEAD(rte_stack_list, rte_tailq_entry);
  22
  23 static struct rte_tailq_elem rte_stack_tailq = {
  24         .name = RTE_TAILQ_STACK_NAME,
  25 };
  26 EAL_REGISTER_TAILQ(rte_stack_tailq)
  27
  28
  29 static void
  30 rte_stack_init(struct rte_stack *s, unsigned int count, uint32_t flags)
  31 {
  32         memset(s, 0, sizeof(*s));
  33
  34         if (flags & RTE_STACK_F_LF)
  35                 rte_stack_lf_init(s, count);
  36         else
  37                 rte_stack_std_init(s);
  38 }
  39
  40 static ssize_t
  41 rte_stack_get_memsize(unsigned int count, uint32_t flags)
  42 {
  43         if (flags & RTE_STACK_F_LF)
  44                 return rte_stack_lf_get_memsize(count);
  45         else
  46                 return rte_stack_std_get_memsize(count);
  47 }
  48
  49 struct rte_stack *
  50 rte_stack_create(const char *name, unsigned int count, int socket_id,
  51                  uint32_t flags)
  52 {
  53         char mz_name[RTE_MEMZONE_NAMESIZE];
  54         struct rte_stack_list *stack_list;
  55         const struct rte_memzone *mz;
  56         struct rte_tailq_entry *te;
  57         struct rte_stack *s;
  58         unsigned int sz;
  59         int ret;
  60
  61 #ifdef RTE_ARCH_64
  62         RTE_BUILD_BUG_ON(sizeof(struct rte_stack_lf_head) != 16);
  63 #else
  64         if (flags & RTE_STACK_F_LF) {
  65                 STACK_LOG_ERR("Lock-free stack is not supported on your platform\n");
  66                 return NULL;
  67         }
  68 #endif
  69
  70         sz = rte_stack_get_memsize(count, flags);
  71
  72         ret = snprintf(mz_name, sizeof(mz_name), "%s%s",
  73                        RTE_STACK_MZ_PREFIX, name);
  74         if (ret < 0 || ret >= (int)sizeof(mz_name)) {
  75                 rte_errno = ENAMETOOLONG;
  76                 return NULL;
  77         }
  78
  79         te = rte_zmalloc("STACK_TAILQ_ENTRY", sizeof(*te), 0);
  80         if (te == NULL) {
  81                 STACK_LOG_ERR("Cannot reserve memory for tailq\n");
  82                 rte_errno = ENOMEM;
  83                 return NULL;
  84         }
  85
  86         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
  87
  88         mz = rte_memzone_reserve_aligned(mz_name, sz, socket_id,
  89                                          0, __alignof__(*s));
  90         if (mz == NULL) {
  91                 STACK_LOG_ERR("Cannot reserve stack memzone!\n");
  92                 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
  93                 rte_free(te);
  94                 return NULL;
  95         }
  96
  97         s = mz->addr;
  98
  99         rte_stack_init(s, count, flags);
 100
 101         /* Store the name for later lookups */
 102         ret = snprintf(s->name, sizeof(s->name), "%s", name);
 103         if (ret < 0 || ret >= (int)sizeof(s->name)) {
 104                 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 105
 106                 rte_errno = ENAMETOOLONG;
 107                 rte_free(te);
 108                 rte_memzone_free(mz);
 109                 return NULL;
 110         }
 111
 112         s->memzone = mz;
 113         s->capacity = count;
 114         s->flags = flags;
 115
 116         te->data = s;
 117
 118         stack_list = RTE_TAILQ_CAST(rte_stack_tailq.head, rte_stack_list);
 119
 120         TAILQ_INSERT_TAIL(stack_list, te, next);
 121
 122         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 123
 124         return s;
 125 }
 126
 127 void
 128 rte_stack_free(struct rte_stack *s)
 129 {
 130         struct rte_stack_list *stack_list;
 131         struct rte_tailq_entry *te;
 132
 133         if (s == NULL)
 134                 return;
 135
 136         stack_list = RTE_TAILQ_CAST(rte_stack_tailq.head, rte_stack_list);
 137         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 138
 139         /* find out tailq entry */
 140         TAILQ_FOREACH(te, stack_list, next) {
 141                 if (te->data == s)
 142                         break;
 143         }
 144
 145         if (te == NULL) {
 146                 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 147                 return;
 148         }
 149
 150         TAILQ_REMOVE(stack_list, te, next);
 151
 152         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 153
 154         rte_free(te);
 155
 156         rte_memzone_free(s->memzone);
 157 }
 158
 159 struct rte_stack *
 160 rte_stack_lookup(const char *name)
 161 {
 162         struct rte_stack_list *stack_list;
 163         struct rte_tailq_entry *te;
 164         struct rte_stack *r = NULL;
 165
 166         if (name == NULL) {
 167                 rte_errno = EINVAL;
 168                 return NULL;
 169         }
 170
 171         stack_list = RTE_TAILQ_CAST(rte_stack_tailq.head, rte_stack_list);
 172
 173         rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
 174
 175         TAILQ_FOREACH(te, stack_list, next) {
 176                 r = (struct rte_stack *) te->data;
 177                 if (strncmp(name, r->name, RTE_STACK_NAMESIZE) == 0)
 178                         break;
 179         }
 180
 181         rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
 182
 183         if (te == NULL) {
 184                 rte_errno = ENOENT;
 185                 return NULL;
 186         }
 187
 188         return r;
 189 }
 190
 191 RTE_INIT(librte_stack_init_log)
 192 {
 193         stack_logtype = rte_log_register("lib.stack");
 194         if (stack_logtype >= 0)
 195                 rte_log_set_level(stack_logtype, RTE_LOG_NOTICE);
 196 }