1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(C) 2020 Marvell International Ltd.
3 */
4
5 #include <stdbool.h>
6 #include <stdio.h>
7 #include <string.h>
8
9 #include <rte_common.h>
10 #include <rte_debug.h>
11 #include <rte_errno.h>
12 #include <rte_string_fns.h>
13
14 #include "graph_private.h"
15
16 static struct node_head node_list = STAILQ_HEAD_INITIALIZER(node_list);
17 static rte_node_t node_id;
18
19 #define NODE_ID_CHECK(id) ID_CHECK(id, node_id)
20
21 /* Private functions */
22 struct node_head *
node_list_head_get(void)23 node_list_head_get(void)
24 {
25 return &node_list;
26 }
27
28 struct node *
node_from_name(const char * name)29 node_from_name(const char *name)
30 {
31 struct node *node;
32
33 STAILQ_FOREACH(node, &node_list, next)
34 if (strncmp(node->name, name, RTE_NODE_NAMESIZE) == 0)
35 return node;
36
37 return NULL;
38 }
39
40 static bool
node_has_duplicate_entry(const char * name)41 node_has_duplicate_entry(const char *name)
42 {
43 struct node *node;
44
45 /* Is duplicate name registered */
46 STAILQ_FOREACH(node, &node_list, next) {
47 if (strncmp(node->name, name, RTE_NODE_NAMESIZE) == 0) {
48 rte_errno = EEXIST;
49 return 1;
50 }
51 }
52 return 0;
53 }
54
55 /* Public functions */
56 rte_node_t
__rte_node_register(const struct rte_node_register * reg)57 __rte_node_register(const struct rte_node_register *reg)
58 {
59 struct node *node;
60 rte_edge_t i;
61 size_t sz;
62
63 /* Limit Node specific metadata to one cacheline on 64B CL machine */
64 RTE_BUILD_BUG_ON((offsetof(struct rte_node, nodes) -
65 offsetof(struct rte_node, ctx)) !=
66 RTE_CACHE_LINE_MIN_SIZE);
67
68 graph_spinlock_lock();
69
70 /* Check sanity */
71 if (reg == NULL || reg->process == NULL) {
72 rte_errno = EINVAL;
73 goto fail;
74 }
75
76 /* Check for duplicate name */
77 if (node_has_duplicate_entry(reg->name))
78 goto fail;
79
80 sz = sizeof(struct node) + (reg->nb_edges * RTE_NODE_NAMESIZE);
81 node = calloc(1, sz);
82 if (node == NULL) {
83 rte_errno = ENOMEM;
84 goto fail;
85 }
86
87 /* Initialize the node */
88 if (rte_strscpy(node->name, reg->name, RTE_NODE_NAMESIZE) < 0)
89 goto free;
90 node->flags = reg->flags;
91 node->process = reg->process;
92 node->init = reg->init;
93 node->fini = reg->fini;
94 node->nb_edges = reg->nb_edges;
95 node->parent_id = reg->parent_id;
96 for (i = 0; i < reg->nb_edges; i++) {
97 if (rte_strscpy(node->next_nodes[i], reg->next_nodes[i],
98 RTE_NODE_NAMESIZE) < 0)
99 goto free;
100 }
101
102 node->id = node_id++;
103
104 /* Add the node at tail */
105 STAILQ_INSERT_TAIL(&node_list, node, next);
106 graph_spinlock_unlock();
107
108 return node->id;
109 free:
110 free(node);
111 fail:
112 graph_spinlock_unlock();
113 return RTE_NODE_ID_INVALID;
114 }
115
116 static int
clone_name(struct rte_node_register * reg,struct node * node,const char * name)117 clone_name(struct rte_node_register *reg, struct node *node, const char *name)
118 {
119 ssize_t sz, rc;
120
121 #define SZ RTE_NODE_NAMESIZE
122 rc = rte_strscpy(reg->name, node->name, SZ);
123 if (rc < 0)
124 goto fail;
125 sz = rc;
126 rc = rte_strscpy(reg->name + sz, "-", RTE_MAX((int16_t)(SZ - sz), 0));
127 if (rc < 0)
128 goto fail;
129 sz += rc;
130 sz = rte_strscpy(reg->name + sz, name, RTE_MAX((int16_t)(SZ - sz), 0));
131 if (sz < 0)
132 goto fail;
133
134 return 0;
135 fail:
136 rte_errno = E2BIG;
137 return -rte_errno;
138 }
139
140 static rte_node_t
node_clone(struct node * node,const char * name)141 node_clone(struct node *node, const char *name)
142 {
143 rte_node_t rc = RTE_NODE_ID_INVALID;
144 struct rte_node_register *reg;
145 rte_edge_t i;
146
147 /* Don't allow to clone a node from a cloned node */
148 if (node->parent_id != RTE_NODE_ID_INVALID) {
149 rte_errno = EEXIST;
150 goto fail;
151 }
152
153 reg = calloc(1, sizeof(*reg) + (sizeof(char *) * node->nb_edges));
154 if (reg == NULL) {
155 rte_errno = ENOMEM;
156 goto fail;
157 }
158
159 /* Clone the source node */
160 reg->flags = node->flags;
161 reg->process = node->process;
162 reg->init = node->init;
163 reg->fini = node->fini;
164 reg->nb_edges = node->nb_edges;
165 reg->parent_id = node->id;
166
167 for (i = 0; i < node->nb_edges; i++)
168 reg->next_nodes[i] = node->next_nodes[i];
169
170 /* Naming ceremony of the new node. name is node->name + "-" + name */
171 if (clone_name(reg, node, name))
172 goto free;
173
174 rc = __rte_node_register(reg);
175 free:
176 free(reg);
177 fail:
178 return rc;
179 }
180
181 rte_node_t
rte_node_clone(rte_node_t id,const char * name)182 rte_node_clone(rte_node_t id, const char *name)
183 {
184 struct node *node;
185
186 NODE_ID_CHECK(id);
187 STAILQ_FOREACH(node, &node_list, next)
188 if (node->id == id)
189 return node_clone(node, name);
190
191 fail:
192 return RTE_NODE_ID_INVALID;
193 }
194
195 rte_node_t
rte_node_from_name(const char * name)196 rte_node_from_name(const char *name)
197 {
198 struct node *node;
199
200 STAILQ_FOREACH(node, &node_list, next)
201 if (strncmp(node->name, name, RTE_NODE_NAMESIZE) == 0)
202 return node->id;
203
204 return RTE_NODE_ID_INVALID;
205 }
206
207 char *
rte_node_id_to_name(rte_node_t id)208 rte_node_id_to_name(rte_node_t id)
209 {
210 struct node *node;
211
212 NODE_ID_CHECK(id);
213 STAILQ_FOREACH(node, &node_list, next)
214 if (node->id == id)
215 return node->name;
216
217 fail:
218 return NULL;
219 }
220
221 rte_edge_t
rte_node_edge_count(rte_node_t id)222 rte_node_edge_count(rte_node_t id)
223 {
224 struct node *node;
225
226 NODE_ID_CHECK(id);
227 STAILQ_FOREACH(node, &node_list, next)
228 if (node->id == id)
229 return node->nb_edges;
230 fail:
231 return RTE_EDGE_ID_INVALID;
232 }
233
234 static rte_edge_t
edge_update(struct node * node,struct node * prev,rte_edge_t from,const char ** next_nodes,rte_edge_t nb_edges)235 edge_update(struct node *node, struct node *prev, rte_edge_t from,
236 const char **next_nodes, rte_edge_t nb_edges)
237 {
238 rte_edge_t i, max_edges, count = 0;
239 struct node *new_node;
240 bool need_realloc;
241 size_t sz;
242
243 if (from == RTE_EDGE_ID_INVALID)
244 from = node->nb_edges;
245
246 /* Don't create hole in next_nodes[] list */
247 if (from > node->nb_edges) {
248 rte_errno = ENOMEM;
249 goto fail;
250 }
251
252 /* Remove me from list */
253 STAILQ_REMOVE(&node_list, node, node, next);
254
255 /* Allocate the storage space for new node if required */
256 max_edges = from + nb_edges;
257 need_realloc = max_edges > node->nb_edges;
258 if (need_realloc) {
259 sz = sizeof(struct node) + (max_edges * RTE_NODE_NAMESIZE);
260 new_node = realloc(node, sz);
261 if (new_node == NULL) {
262 rte_errno = ENOMEM;
263 goto restore;
264 } else {
265 node = new_node;
266 }
267 }
268
269 /* Update the new nodes name */
270 for (i = from; i < max_edges; i++, count++) {
271 if (rte_strscpy(node->next_nodes[i], next_nodes[count],
272 RTE_NODE_NAMESIZE) < 0)
273 goto restore;
274 }
275 restore:
276 /* Update the linked list to point new node address in prev node */
277 if (prev)
278 STAILQ_INSERT_AFTER(&node_list, prev, node, next);
279 else
280 STAILQ_INSERT_HEAD(&node_list, node, next);
281
282 if (need_realloc)
283 node->nb_edges = max_edges;
284
285 fail:
286 return count;
287 }
288
289 rte_edge_t
rte_node_edge_shrink(rte_node_t id,rte_edge_t size)290 rte_node_edge_shrink(rte_node_t id, rte_edge_t size)
291 {
292 rte_edge_t rc = RTE_EDGE_ID_INVALID;
293 struct node *node;
294
295 NODE_ID_CHECK(id);
296 graph_spinlock_lock();
297
298 STAILQ_FOREACH(node, &node_list, next) {
299 if (node->id == id) {
300 if (node->nb_edges < size) {
301 rte_errno = E2BIG;
302 goto fail;
303 }
304 node->nb_edges = size;
305 rc = size;
306 break;
307 }
308 }
309
310 fail:
311 graph_spinlock_unlock();
312 return rc;
313 }
314
315 rte_edge_t
rte_node_edge_update(rte_node_t id,rte_edge_t from,const char ** next_nodes,uint16_t nb_edges)316 rte_node_edge_update(rte_node_t id, rte_edge_t from, const char **next_nodes,
317 uint16_t nb_edges)
318 {
319 rte_edge_t rc = RTE_EDGE_ID_INVALID;
320 struct node *n, *prev;
321
322 NODE_ID_CHECK(id);
323 graph_spinlock_lock();
324
325 prev = NULL;
326 STAILQ_FOREACH(n, &node_list, next) {
327 if (n->id == id) {
328 rc = edge_update(n, prev, from, next_nodes, nb_edges);
329 break;
330 }
331 prev = n;
332 }
333
334 graph_spinlock_unlock();
335 fail:
336 return rc;
337 }
338
339 static rte_node_t
node_copy_edges(struct node * node,char * next_nodes[])340 node_copy_edges(struct node *node, char *next_nodes[])
341 {
342 rte_edge_t i;
343
344 for (i = 0; i < node->nb_edges; i++)
345 next_nodes[i] = node->next_nodes[i];
346
347 return i;
348 }
349
350 rte_node_t
rte_node_edge_get(rte_node_t id,char * next_nodes[])351 rte_node_edge_get(rte_node_t id, char *next_nodes[])
352 {
353 rte_node_t rc = RTE_NODE_ID_INVALID;
354 struct node *node;
355
356 NODE_ID_CHECK(id);
357 graph_spinlock_lock();
358
359 STAILQ_FOREACH(node, &node_list, next) {
360 if (node->id == id) {
361 if (next_nodes == NULL)
362 rc = sizeof(char *) * node->nb_edges;
363 else
364 rc = node_copy_edges(node, next_nodes);
365 break;
366 }
367 }
368
369 graph_spinlock_unlock();
370 fail:
371 return rc;
372 }
373
374 static void
node_scan_dump(FILE * f,rte_node_t id,bool all)375 node_scan_dump(FILE *f, rte_node_t id, bool all)
376 {
377 struct node *node;
378
379 RTE_ASSERT(f != NULL);
380 NODE_ID_CHECK(id);
381
382 STAILQ_FOREACH(node, &node_list, next) {
383 if (all == true) {
384 node_dump(f, node);
385 } else if (node->id == id) {
386 node_dump(f, node);
387 return;
388 }
389 }
390 fail:
391 return;
392 }
393
394 void
rte_node_dump(FILE * f,rte_node_t id)395 rte_node_dump(FILE *f, rte_node_t id)
396 {
397 node_scan_dump(f, id, false);
398 }
399
400 void
rte_node_list_dump(FILE * f)401 rte_node_list_dump(FILE *f)
402 {
403 node_scan_dump(f, 0, true);
404 }
405
406 rte_node_t
rte_node_max_count(void)407 rte_node_max_count(void)
408 {
409 return node_id;
410 }
411