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