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