1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(C) 2020 Marvell International Ltd.
9 #include <rte_common.h>
10 #include <rte_debug.h>
11 #include <rte_errno.h>
12 #include <rte_string_fns.h>
14 #include "graph_private.h"
16 static struct node_head node_list = STAILQ_HEAD_INITIALIZER(node_list);
17 static rte_node_t node_id;
19 #define NODE_ID_CHECK(id) ID_CHECK(id, node_id)
21 /* Private functions */
23 node_list_head_get(void)
29 node_from_name(const char *name)
33 STAILQ_FOREACH(node, &node_list, next)
34 if (strncmp(node->name, name, RTE_NODE_NAMESIZE) == 0)
41 node_has_duplicate_entry(const char *name)
45 /* Is duplicate name registered */
46 STAILQ_FOREACH(node, &node_list, next) {
47 if (strncmp(node->name, name, RTE_NODE_NAMESIZE) == 0) {
55 /* Public functions */
57 __rte_node_register(const struct rte_node_register *reg)
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);
68 graph_spinlock_lock();
71 if (reg == NULL || reg->process == NULL) {
76 /* Check for duplicate name */
77 if (node_has_duplicate_entry(reg->name))
80 sz = sizeof(struct node) + (reg->nb_edges * RTE_NODE_NAMESIZE);
87 /* Initialize the node */
88 if (rte_strscpy(node->name, reg->name, RTE_NODE_NAMESIZE) < 0)
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)
102 node->id = node_id++;
104 /* Add the node at tail */
105 STAILQ_INSERT_TAIL(&node_list, node, next);
106 graph_spinlock_unlock();
112 graph_spinlock_unlock();
113 return RTE_NODE_ID_INVALID;
117 clone_name(struct rte_node_register *reg, struct node *node, const char *name)
121 #define SZ RTE_NODE_NAMESIZE
122 rc = rte_strscpy(reg->name, node->name, SZ);
126 rc = rte_strscpy(reg->name + sz, "-", RTE_MAX((int16_t)(SZ - sz), 0));
130 sz = rte_strscpy(reg->name + sz, name, RTE_MAX((int16_t)(SZ - sz), 0));
141 node_clone(struct node *node, const char *name)
143 rte_node_t rc = RTE_NODE_ID_INVALID;
144 struct rte_node_register *reg;
147 /* Don't allow to clone a node from a cloned node */
148 if (node->parent_id != RTE_NODE_ID_INVALID) {
153 /* Check for duplicate name */
154 if (node_has_duplicate_entry(name))
157 reg = calloc(1, sizeof(*reg) + (sizeof(char *) * node->nb_edges));
163 /* Clone the source node */
164 reg->flags = node->flags;
165 reg->process = node->process;
166 reg->init = node->init;
167 reg->fini = node->fini;
168 reg->nb_edges = node->nb_edges;
169 reg->parent_id = node->id;
171 for (i = 0; i < node->nb_edges; i++)
172 reg->next_nodes[i] = node->next_nodes[i];
174 /* Naming ceremony of the new node. name is node->name + "-" + name */
175 if (clone_name(reg, node, name))
178 rc = __rte_node_register(reg);
186 rte_node_clone(rte_node_t id, const char *name)
191 STAILQ_FOREACH(node, &node_list, next)
193 return node_clone(node, name);
196 return RTE_NODE_ID_INVALID;
200 rte_node_from_name(const char *name)
204 STAILQ_FOREACH(node, &node_list, next)
205 if (strncmp(node->name, name, RTE_NODE_NAMESIZE) == 0)
208 return RTE_NODE_ID_INVALID;
212 rte_node_id_to_name(rte_node_t id)
217 STAILQ_FOREACH(node, &node_list, next)
226 rte_node_edge_count(rte_node_t id)
231 STAILQ_FOREACH(node, &node_list, next)
233 return node->nb_edges;
235 return RTE_EDGE_ID_INVALID;
239 edge_update(struct node *node, struct node *prev, rte_edge_t from,
240 const char **next_nodes, rte_edge_t nb_edges)
242 rte_edge_t i, max_edges, count = 0;
243 struct node *new_node;
247 if (from == RTE_EDGE_ID_INVALID)
248 from = node->nb_edges;
250 /* Don't create hole in next_nodes[] list */
251 if (from > node->nb_edges) {
256 /* Remove me from list */
257 STAILQ_REMOVE(&node_list, node, node, next);
259 /* Allocate the storage space for new node if required */
260 max_edges = from + nb_edges;
261 need_realloc = max_edges > node->nb_edges;
263 sz = sizeof(struct node) + (max_edges * RTE_NODE_NAMESIZE);
264 new_node = realloc(node, sz);
265 if (new_node == NULL) {
273 /* Update the new nodes name */
274 for (i = from; i < max_edges; i++, count++) {
275 if (rte_strscpy(node->next_nodes[i], next_nodes[count],
276 RTE_NODE_NAMESIZE) < 0)
280 /* Update the linked list to point new node address in prev node */
282 STAILQ_INSERT_AFTER(&node_list, prev, node, next);
284 STAILQ_INSERT_HEAD(&node_list, node, next);
287 node->nb_edges = max_edges;
294 rte_node_edge_shrink(rte_node_t id, rte_edge_t size)
296 rte_edge_t rc = RTE_EDGE_ID_INVALID;
300 graph_spinlock_lock();
302 STAILQ_FOREACH(node, &node_list, next) {
303 if (node->id == id) {
304 if (node->nb_edges < size) {
308 node->nb_edges = size;
315 graph_spinlock_unlock();
320 rte_node_edge_update(rte_node_t id, rte_edge_t from, const char **next_nodes,
323 rte_edge_t rc = RTE_EDGE_ID_INVALID;
324 struct node *n, *prev;
327 graph_spinlock_lock();
330 STAILQ_FOREACH(n, &node_list, next) {
332 rc = edge_update(n, prev, from, next_nodes, nb_edges);
338 graph_spinlock_unlock();
344 node_copy_edges(struct node *node, char *next_nodes[])
348 for (i = 0; i < node->nb_edges; i++)
349 next_nodes[i] = node->next_nodes[i];
355 rte_node_edge_get(rte_node_t id, char *next_nodes[])
357 rte_node_t rc = RTE_NODE_ID_INVALID;
361 graph_spinlock_lock();
363 STAILQ_FOREACH(node, &node_list, next) {
364 if (node->id == id) {
365 if (next_nodes == NULL)
366 rc = sizeof(char *) * node->nb_edges;
368 rc = node_copy_edges(node, next_nodes);
373 graph_spinlock_unlock();
379 node_scan_dump(FILE *f, rte_node_t id, bool all)
383 RTE_ASSERT(f != NULL);
386 STAILQ_FOREACH(node, &node_list, next) {
389 } else if (node->id == id) {
399 rte_node_dump(FILE *f, rte_node_t id)
401 node_scan_dump(f, id, false);
405 rte_node_list_dump(FILE *f)
407 node_scan_dump(f, 0, true);
411 rte_node_max_count(void)