#include <rte_common.h>
#include "rte_swx_pipeline.h"
+#include "rte_swx_ctl.h"
#define CHECK(condition, err_code) \
do { \
void *obj;
};
+/*
+ * Extern object.
+ */
+struct extern_type_member_func {
+ TAILQ_ENTRY(extern_type_member_func) node;
+ char name[RTE_SWX_NAME_SIZE];
+ rte_swx_extern_type_member_func_t func;
+ uint32_t id;
+};
+
+TAILQ_HEAD(extern_type_member_func_tailq, extern_type_member_func);
+
+struct extern_type {
+ TAILQ_ENTRY(extern_type) node;
+ char name[RTE_SWX_NAME_SIZE];
+ struct struct_type *mailbox_struct_type;
+ rte_swx_extern_type_constructor_t constructor;
+ rte_swx_extern_type_destructor_t destructor;
+ struct extern_type_member_func_tailq funcs;
+ uint32_t n_funcs;
+};
+
+TAILQ_HEAD(extern_type_tailq, extern_type);
+
+struct extern_obj {
+ TAILQ_ENTRY(extern_obj) node;
+ char name[RTE_SWX_NAME_SIZE];
+ struct extern_type *type;
+ void *obj;
+ uint32_t struct_id;
+ uint32_t id;
+};
+
+TAILQ_HEAD(extern_obj_tailq, extern_obj);
+
+#ifndef RTE_SWX_EXTERN_TYPE_MEMBER_FUNCS_MAX
+#define RTE_SWX_EXTERN_TYPE_MEMBER_FUNCS_MAX 8
+#endif
+
+struct extern_obj_runtime {
+ void *obj;
+ uint8_t *mailbox;
+ rte_swx_extern_type_member_func_t funcs[RTE_SWX_EXTERN_TYPE_MEMBER_FUNCS_MAX];
+};
+
+/*
+ * Extern function.
+ */
+struct extern_func {
+ TAILQ_ENTRY(extern_func) node;
+ char name[RTE_SWX_NAME_SIZE];
+ struct struct_type *mailbox_struct_type;
+ rte_swx_extern_func_t func;
+ uint32_t struct_id;
+ uint32_t id;
+};
+
+TAILQ_HEAD(extern_func_tailq, extern_func);
+
+struct extern_func_runtime {
+ uint8_t *mailbox;
+ rte_swx_extern_func_t func;
+};
+
/*
* Header.
*/
uint32_t n_bytes;
};
+/*
+ * Instruction.
+ */
+struct instruction {
+};
+
+/*
+ * Action.
+ */
+struct action {
+ TAILQ_ENTRY(action) node;
+ char name[RTE_SWX_NAME_SIZE];
+ struct struct_type *st;
+ struct instruction *instructions;
+ uint32_t n_instructions;
+ uint32_t id;
+};
+
+TAILQ_HEAD(action_tailq, action);
+
+/*
+ * Table.
+ */
+struct table_type {
+ TAILQ_ENTRY(table_type) node;
+ char name[RTE_SWX_NAME_SIZE];
+ enum rte_swx_table_match_type match_type;
+ struct rte_swx_table_ops ops;
+};
+
+TAILQ_HEAD(table_type_tailq, table_type);
+
+struct match_field {
+ enum rte_swx_table_match_type match_type;
+ struct field *field;
+};
+
+struct table {
+ TAILQ_ENTRY(table) node;
+ char name[RTE_SWX_NAME_SIZE];
+ char args[RTE_SWX_NAME_SIZE];
+ struct table_type *type; /* NULL when n_fields == 0. */
+
+ /* Match. */
+ struct match_field *fields;
+ uint32_t n_fields;
+ int is_header; /* Only valid when n_fields > 0. */
+ struct header *header; /* Only valid when n_fields > 0. */
+
+ /* Action. */
+ struct action **actions;
+ struct action *default_action;
+ uint8_t *default_action_data;
+ uint32_t n_actions;
+ int default_action_is_const;
+ uint32_t action_data_size_max;
+
+ uint32_t size;
+ uint32_t id;
+};
+
+TAILQ_HEAD(table_tailq, table);
+
+struct table_runtime {
+ rte_swx_table_lookup_t func;
+ void *mailbox;
+ uint8_t **key;
+};
+
/*
* Pipeline.
*/
/* Packet meta-data. */
uint8_t *metadata;
+
+ /* Tables. */
+ struct table_runtime *tables;
+ struct rte_swx_table_state *table_state;
+ uint64_t action_id;
+ int hit; /* 0 = Miss, 1 = Hit. */
+
+ /* Extern objects and functions. */
+ struct extern_obj_runtime *extern_objs;
+ struct extern_func_runtime *extern_funcs;
+
+ /* Instructions. */
+ struct instruction *ip;
+ struct instruction *ret;
};
#ifndef RTE_SWX_PIPELINE_THREADS_MAX
struct port_in_tailq ports_in;
struct port_out_type_tailq port_out_types;
struct port_out_tailq ports_out;
+ struct extern_type_tailq extern_types;
+ struct extern_obj_tailq extern_objs;
+ struct extern_func_tailq extern_funcs;
struct header_tailq headers;
struct struct_type *metadata_st;
uint32_t metadata_struct_id;
+ struct action_tailq actions;
+ struct table_type_tailq table_types;
+ struct table_tailq tables;
struct port_in_runtime *in;
struct port_out_runtime *out;
+ struct instruction **action_instructions;
+ struct rte_swx_table_state *table_state;
+ struct instruction *instructions;
struct thread threads[RTE_SWX_PIPELINE_THREADS_MAX];
uint32_t n_structs;
uint32_t n_ports_in;
uint32_t n_ports_out;
+ uint32_t n_extern_objs;
+ uint32_t n_extern_funcs;
+ uint32_t n_actions;
+ uint32_t n_tables;
uint32_t n_headers;
+ uint32_t n_instructions;
int build_done;
int numa_node;
};
return NULL;
}
+static struct field *
+struct_type_field_find(struct struct_type *st, const char *name)
+{
+ uint32_t i;
+
+ for (i = 0; i < st->n_fields; i++) {
+ struct field *f = &st->fields[i];
+
+ if (strcmp(f->name, name) == 0)
+ return f;
+ }
+
+ return NULL;
+}
+
int
rte_swx_pipeline_struct_type_register(struct rte_swx_pipeline *p,
const char *name,
}
/*
- * Header.
+ * Extern object.
*/
-static struct header *
-header_find(struct rte_swx_pipeline *p, const char *name)
+static struct extern_type *
+extern_type_find(struct rte_swx_pipeline *p, const char *name)
{
- struct header *elem;
+ struct extern_type *elem;
- TAILQ_FOREACH(elem, &p->headers, node)
+ TAILQ_FOREACH(elem, &p->extern_types, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
+static struct extern_type_member_func *
+extern_type_member_func_find(struct extern_type *type, const char *name)
+{
+ struct extern_type_member_func *elem;
+
+ TAILQ_FOREACH(elem, &type->funcs, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
+static struct extern_obj *
+extern_obj_find(struct rte_swx_pipeline *p, const char *name)
+{
+ struct extern_obj *elem;
+
+ TAILQ_FOREACH(elem, &p->extern_objs, node)
if (strcmp(elem->name, name) == 0)
return elem;
}
int
-rte_swx_pipeline_packet_header_register(struct rte_swx_pipeline *p,
- const char *name,
- const char *struct_type_name)
+rte_swx_pipeline_extern_type_register(struct rte_swx_pipeline *p,
+ const char *name,
+ const char *mailbox_struct_type_name,
+ rte_swx_extern_type_constructor_t constructor,
+ rte_swx_extern_type_destructor_t destructor)
{
- struct struct_type *st;
- struct header *h;
- size_t n_headers_max;
+ struct extern_type *elem;
+ struct struct_type *mailbox_struct_type;
CHECK(p, EINVAL);
+
CHECK_NAME(name, EINVAL);
- CHECK_NAME(struct_type_name, EINVAL);
+ CHECK(!extern_type_find(p, name), EEXIST);
- CHECK(!header_find(p, name), EEXIST);
+ CHECK_NAME(mailbox_struct_type_name, EINVAL);
+ mailbox_struct_type = struct_type_find(p, mailbox_struct_type_name);
+ CHECK(mailbox_struct_type, EINVAL);
- st = struct_type_find(p, struct_type_name);
- CHECK(st, EINVAL);
+ CHECK(constructor, EINVAL);
+ CHECK(destructor, EINVAL);
- n_headers_max = RTE_SIZEOF_FIELD(struct thread, valid_headers) * 8;
- CHECK(p->n_headers < n_headers_max, ENOSPC);
+ /* Node allocation. */
+ elem = calloc(1, sizeof(struct extern_type));
+ CHECK(elem, ENOMEM);
+
+ /* Node initialization. */
+ strcpy(elem->name, name);
+ elem->mailbox_struct_type = mailbox_struct_type;
+ elem->constructor = constructor;
+ elem->destructor = destructor;
+ TAILQ_INIT(&elem->funcs);
+
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->extern_types, elem, node);
+
+ return 0;
+}
+
+int
+rte_swx_pipeline_extern_type_member_func_register(struct rte_swx_pipeline *p,
+ const char *extern_type_name,
+ const char *name,
+ rte_swx_extern_type_member_func_t member_func)
+{
+ struct extern_type *type;
+ struct extern_type_member_func *type_member;
+
+ CHECK(p, EINVAL);
+
+ CHECK(extern_type_name, EINVAL);
+ type = extern_type_find(p, extern_type_name);
+ CHECK(type, EINVAL);
+ CHECK(type->n_funcs < RTE_SWX_EXTERN_TYPE_MEMBER_FUNCS_MAX, ENOSPC);
+
+ CHECK(name, EINVAL);
+ CHECK(!extern_type_member_func_find(type, name), EEXIST);
+
+ CHECK(member_func, EINVAL);
/* Node allocation. */
- h = calloc(1, sizeof(struct header));
- CHECK(h, ENOMEM);
+ type_member = calloc(1, sizeof(struct extern_type_member_func));
+ CHECK(type_member, ENOMEM);
/* Node initialization. */
- strcpy(h->name, name);
- h->st = st;
- h->struct_id = p->n_structs;
- h->id = p->n_headers;
+ strcpy(type_member->name, name);
+ type_member->func = member_func;
+ type_member->id = type->n_funcs;
/* Node add to tailq. */
- TAILQ_INSERT_TAIL(&p->headers, h, node);
- p->n_headers++;
- p->n_structs++;
+ TAILQ_INSERT_TAIL(&type->funcs, type_member, node);
+ type->n_funcs++;
return 0;
}
-static int
-header_build(struct rte_swx_pipeline *p)
+int
+rte_swx_pipeline_extern_object_config(struct rte_swx_pipeline *p,
+ const char *extern_type_name,
+ const char *name,
+ const char *args)
{
- struct header *h;
- uint32_t n_bytes = 0, i;
+ struct extern_type *type;
+ struct extern_obj *obj;
+ void *obj_handle;
- TAILQ_FOREACH(h, &p->headers, node) {
- n_bytes += h->st->n_bits / 8;
+ CHECK(p, EINVAL);
+
+ CHECK_NAME(extern_type_name, EINVAL);
+ type = extern_type_find(p, extern_type_name);
+ CHECK(type, EINVAL);
+
+ CHECK_NAME(name, EINVAL);
+ CHECK(!extern_obj_find(p, name), EEXIST);
+
+ /* Node allocation. */
+ obj = calloc(1, sizeof(struct extern_obj));
+ CHECK(obj, ENOMEM);
+
+ /* Object construction. */
+ obj_handle = type->constructor(args);
+ if (!obj_handle) {
+ free(obj);
+ CHECK(0, ENODEV);
}
+ /* Node initialization. */
+ strcpy(obj->name, name);
+ obj->type = type;
+ obj->obj = obj_handle;
+ obj->struct_id = p->n_structs;
+ obj->id = p->n_extern_objs;
+
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->extern_objs, obj, node);
+ p->n_extern_objs++;
+ p->n_structs++;
+
+ return 0;
+}
+
+static int
+extern_obj_build(struct rte_swx_pipeline *p)
+{
+ uint32_t i;
+
for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
struct thread *t = &p->threads[i];
- uint32_t offset = 0;
-
- t->headers = calloc(p->n_headers,
- sizeof(struct header_runtime));
- CHECK(t->headers, ENOMEM);
+ struct extern_obj *obj;
- t->headers_out = calloc(p->n_headers,
- sizeof(struct header_out_runtime));
- CHECK(t->headers_out, ENOMEM);
+ t->extern_objs = calloc(p->n_extern_objs,
+ sizeof(struct extern_obj_runtime));
+ CHECK(t->extern_objs, ENOMEM);
- t->header_storage = calloc(1, n_bytes);
- CHECK(t->header_storage, ENOMEM);
+ TAILQ_FOREACH(obj, &p->extern_objs, node) {
+ struct extern_obj_runtime *r =
+ &t->extern_objs[obj->id];
+ struct extern_type_member_func *func;
+ uint32_t mailbox_size =
+ obj->type->mailbox_struct_type->n_bits / 8;
- t->header_out_storage = calloc(1, n_bytes);
- CHECK(t->header_out_storage, ENOMEM);
+ r->obj = obj->obj;
- TAILQ_FOREACH(h, &p->headers, node) {
- uint8_t *header_storage;
+ r->mailbox = calloc(1, mailbox_size);
+ CHECK(r->mailbox, ENOMEM);
- header_storage = &t->header_storage[offset];
- offset += h->st->n_bits / 8;
+ TAILQ_FOREACH(func, &obj->type->funcs, node)
+ r->funcs[func->id] = func->func;
- t->headers[h->id].ptr0 = header_storage;
- t->structs[h->struct_id] = header_storage;
+ t->structs[obj->struct_id] = r->mailbox;
}
}
}
static void
-header_build_free(struct rte_swx_pipeline *p)
+extern_obj_build_free(struct rte_swx_pipeline *p)
{
uint32_t i;
for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
struct thread *t = &p->threads[i];
+ uint32_t j;
- free(t->headers_out);
- t->headers_out = NULL;
+ if (!t->extern_objs)
+ continue;
- free(t->headers);
- t->headers = NULL;
+ for (j = 0; j < p->n_extern_objs; j++) {
+ struct extern_obj_runtime *r = &t->extern_objs[j];
- free(t->header_out_storage);
- t->header_out_storage = NULL;
+ free(r->mailbox);
+ }
- free(t->header_storage);
- t->header_storage = NULL;
+ free(t->extern_objs);
+ t->extern_objs = NULL;
}
}
static void
-header_free(struct rte_swx_pipeline *p)
+extern_obj_free(struct rte_swx_pipeline *p)
{
- header_build_free(p);
+ extern_obj_build_free(p);
+ /* Extern objects. */
for ( ; ; ) {
- struct header *elem;
+ struct extern_obj *elem;
- elem = TAILQ_FIRST(&p->headers);
+ elem = TAILQ_FIRST(&p->extern_objs);
if (!elem)
break;
- TAILQ_REMOVE(&p->headers, elem, node);
+ TAILQ_REMOVE(&p->extern_objs, elem, node);
+ if (elem->obj)
+ elem->type->destructor(elem->obj);
+ free(elem);
+ }
+
+ /* Extern types. */
+ for ( ; ; ) {
+ struct extern_type *elem;
+
+ elem = TAILQ_FIRST(&p->extern_types);
+ if (!elem)
+ break;
+
+ TAILQ_REMOVE(&p->extern_types, elem, node);
+
+ for ( ; ; ) {
+ struct extern_type_member_func *func;
+
+ func = TAILQ_FIRST(&elem->funcs);
+ if (!func)
+ break;
+
+ TAILQ_REMOVE(&elem->funcs, func, node);
+ free(func);
+ }
+
free(elem);
}
}
/*
- * Meta-data.
+ * Extern function.
*/
+static struct extern_func *
+extern_func_find(struct rte_swx_pipeline *p, const char *name)
+{
+ struct extern_func *elem;
+
+ TAILQ_FOREACH(elem, &p->extern_funcs, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
int
-rte_swx_pipeline_packet_metadata_register(struct rte_swx_pipeline *p,
- const char *struct_type_name)
+rte_swx_pipeline_extern_func_register(struct rte_swx_pipeline *p,
+ const char *name,
+ const char *mailbox_struct_type_name,
+ rte_swx_extern_func_t func)
{
- struct struct_type *st = NULL;
+ struct extern_func *f;
+ struct struct_type *mailbox_struct_type;
CHECK(p, EINVAL);
- CHECK_NAME(struct_type_name, EINVAL);
- st = struct_type_find(p, struct_type_name);
- CHECK(st, EINVAL);
- CHECK(!p->metadata_st, EINVAL);
+ CHECK_NAME(name, EINVAL);
+ CHECK(!extern_func_find(p, name), EEXIST);
- p->metadata_st = st;
- p->metadata_struct_id = p->n_structs;
+ CHECK_NAME(mailbox_struct_type_name, EINVAL);
+ mailbox_struct_type = struct_type_find(p, mailbox_struct_type_name);
+ CHECK(mailbox_struct_type, EINVAL);
+
+ CHECK(func, EINVAL);
+
+ /* Node allocation. */
+ f = calloc(1, sizeof(struct extern_func));
+ CHECK(func, ENOMEM);
+
+ /* Node initialization. */
+ strcpy(f->name, name);
+ f->mailbox_struct_type = mailbox_struct_type;
+ f->func = func;
+ f->struct_id = p->n_structs;
+ f->id = p->n_extern_funcs;
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->extern_funcs, f, node);
+ p->n_extern_funcs++;
p->n_structs++;
return 0;
}
static int
-metadata_build(struct rte_swx_pipeline *p)
+extern_func_build(struct rte_swx_pipeline *p)
{
- uint32_t n_bytes = p->metadata_st->n_bits / 8;
uint32_t i;
- /* Thread-level initialization. */
for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
struct thread *t = &p->threads[i];
- uint8_t *metadata;
+ struct extern_func *func;
- metadata = calloc(1, n_bytes);
- CHECK(metadata, ENOMEM);
+ /* Memory allocation. */
+ t->extern_funcs = calloc(p->n_extern_funcs,
+ sizeof(struct extern_func_runtime));
+ CHECK(t->extern_funcs, ENOMEM);
- t->metadata = metadata;
- t->structs[p->metadata_struct_id] = metadata;
+ /* Extern function. */
+ TAILQ_FOREACH(func, &p->extern_funcs, node) {
+ struct extern_func_runtime *r =
+ &t->extern_funcs[func->id];
+ uint32_t mailbox_size =
+ func->mailbox_struct_type->n_bits / 8;
+
+ r->func = func->func;
+
+ r->mailbox = calloc(1, mailbox_size);
+ CHECK(r->mailbox, ENOMEM);
+
+ t->structs[func->struct_id] = r->mailbox;
+ }
}
return 0;
}
static void
-metadata_build_free(struct rte_swx_pipeline *p)
+extern_func_build_free(struct rte_swx_pipeline *p)
{
uint32_t i;
for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
struct thread *t = &p->threads[i];
+ uint32_t j;
- free(t->metadata);
- t->metadata = NULL;
+ if (!t->extern_funcs)
+ continue;
+
+ for (j = 0; j < p->n_extern_funcs; j++) {
+ struct extern_func_runtime *r = &t->extern_funcs[j];
+
+ free(r->mailbox);
+ }
+
+ free(t->extern_funcs);
+ t->extern_funcs = NULL;
+ }
+}
+
+static void
+extern_func_free(struct rte_swx_pipeline *p)
+{
+ extern_func_build_free(p);
+
+ for ( ; ; ) {
+ struct extern_func *elem;
+
+ elem = TAILQ_FIRST(&p->extern_funcs);
+ if (!elem)
+ break;
+
+ TAILQ_REMOVE(&p->extern_funcs, elem, node);
+ free(elem);
+ }
+}
+
+/*
+ * Header.
+ */
+static struct header *
+header_find(struct rte_swx_pipeline *p, const char *name)
+{
+ struct header *elem;
+
+ TAILQ_FOREACH(elem, &p->headers, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
+static struct field *
+header_field_parse(struct rte_swx_pipeline *p,
+ const char *name,
+ struct header **header)
+{
+ struct header *h;
+ struct field *f;
+ char *header_name, *field_name;
+
+ if ((name[0] != 'h') || (name[1] != '.'))
+ return NULL;
+
+ header_name = strdup(&name[2]);
+ if (!header_name)
+ return NULL;
+
+ field_name = strchr(header_name, '.');
+ if (!field_name) {
+ free(header_name);
+ return NULL;
+ }
+
+ *field_name = 0;
+ field_name++;
+
+ h = header_find(p, header_name);
+ if (!h) {
+ free(header_name);
+ return NULL;
+ }
+
+ f = struct_type_field_find(h->st, field_name);
+ if (!f) {
+ free(header_name);
+ return NULL;
+ }
+
+ if (header)
+ *header = h;
+
+ free(header_name);
+ return f;
+}
+
+int
+rte_swx_pipeline_packet_header_register(struct rte_swx_pipeline *p,
+ const char *name,
+ const char *struct_type_name)
+{
+ struct struct_type *st;
+ struct header *h;
+ size_t n_headers_max;
+
+ CHECK(p, EINVAL);
+ CHECK_NAME(name, EINVAL);
+ CHECK_NAME(struct_type_name, EINVAL);
+
+ CHECK(!header_find(p, name), EEXIST);
+
+ st = struct_type_find(p, struct_type_name);
+ CHECK(st, EINVAL);
+
+ n_headers_max = RTE_SIZEOF_FIELD(struct thread, valid_headers) * 8;
+ CHECK(p->n_headers < n_headers_max, ENOSPC);
+
+ /* Node allocation. */
+ h = calloc(1, sizeof(struct header));
+ CHECK(h, ENOMEM);
+
+ /* Node initialization. */
+ strcpy(h->name, name);
+ h->st = st;
+ h->struct_id = p->n_structs;
+ h->id = p->n_headers;
+
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->headers, h, node);
+ p->n_headers++;
+ p->n_structs++;
+
+ return 0;
+}
+
+static int
+header_build(struct rte_swx_pipeline *p)
+{
+ struct header *h;
+ uint32_t n_bytes = 0, i;
+
+ TAILQ_FOREACH(h, &p->headers, node) {
+ n_bytes += h->st->n_bits / 8;
+ }
+
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+ uint32_t offset = 0;
+
+ t->headers = calloc(p->n_headers,
+ sizeof(struct header_runtime));
+ CHECK(t->headers, ENOMEM);
+
+ t->headers_out = calloc(p->n_headers,
+ sizeof(struct header_out_runtime));
+ CHECK(t->headers_out, ENOMEM);
+
+ t->header_storage = calloc(1, n_bytes);
+ CHECK(t->header_storage, ENOMEM);
+
+ t->header_out_storage = calloc(1, n_bytes);
+ CHECK(t->header_out_storage, ENOMEM);
+
+ TAILQ_FOREACH(h, &p->headers, node) {
+ uint8_t *header_storage;
+
+ header_storage = &t->header_storage[offset];
+ offset += h->st->n_bits / 8;
+
+ t->headers[h->id].ptr0 = header_storage;
+ t->structs[h->struct_id] = header_storage;
+ }
+ }
+
+ return 0;
+}
+
+static void
+header_build_free(struct rte_swx_pipeline *p)
+{
+ uint32_t i;
+
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+
+ free(t->headers_out);
+ t->headers_out = NULL;
+
+ free(t->headers);
+ t->headers = NULL;
+
+ free(t->header_out_storage);
+ t->header_out_storage = NULL;
+
+ free(t->header_storage);
+ t->header_storage = NULL;
+ }
+}
+
+static void
+header_free(struct rte_swx_pipeline *p)
+{
+ header_build_free(p);
+
+ for ( ; ; ) {
+ struct header *elem;
+
+ elem = TAILQ_FIRST(&p->headers);
+ if (!elem)
+ break;
+
+ TAILQ_REMOVE(&p->headers, elem, node);
+ free(elem);
+ }
+}
+
+/*
+ * Meta-data.
+ */
+static struct field *
+metadata_field_parse(struct rte_swx_pipeline *p, const char *name)
+{
+ if (!p->metadata_st)
+ return NULL;
+
+ if (name[0] != 'm' || name[1] != '.')
+ return NULL;
+
+ return struct_type_field_find(p->metadata_st, &name[2]);
+}
+
+int
+rte_swx_pipeline_packet_metadata_register(struct rte_swx_pipeline *p,
+ const char *struct_type_name)
+{
+ struct struct_type *st = NULL;
+
+ CHECK(p, EINVAL);
+
+ CHECK_NAME(struct_type_name, EINVAL);
+ st = struct_type_find(p, struct_type_name);
+ CHECK(st, EINVAL);
+ CHECK(!p->metadata_st, EINVAL);
+
+ p->metadata_st = st;
+ p->metadata_struct_id = p->n_structs;
+
+ p->n_structs++;
+
+ return 0;
+}
+
+static int
+metadata_build(struct rte_swx_pipeline *p)
+{
+ uint32_t n_bytes = p->metadata_st->n_bits / 8;
+ uint32_t i;
+
+ /* Thread-level initialization. */
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+ uint8_t *metadata;
+
+ metadata = calloc(1, n_bytes);
+ CHECK(metadata, ENOMEM);
+
+ t->metadata = metadata;
+ t->structs[p->metadata_struct_id] = metadata;
+ }
+
+ return 0;
+}
+
+static void
+metadata_build_free(struct rte_swx_pipeline *p)
+{
+ uint32_t i;
+
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+
+ free(t->metadata);
+ t->metadata = NULL;
}
}
static void
metadata_free(struct rte_swx_pipeline *p)
{
- metadata_build_free(p);
+ metadata_build_free(p);
+}
+
+/*
+ * Instruction.
+ */
+static inline void
+thread_ip_reset(struct rte_swx_pipeline *p, struct thread *t)
+{
+ t->ip = p->instructions;
+}
+
+static int
+instruction_config(struct rte_swx_pipeline *p __rte_unused,
+ struct action *a __rte_unused,
+ const char **instructions __rte_unused,
+ uint32_t n_instructions __rte_unused)
+{
+ return 0;
+}
+
+/*
+ * Action.
+ */
+static struct action *
+action_find(struct rte_swx_pipeline *p, const char *name)
+{
+ struct action *elem;
+
+ if (!name)
+ return NULL;
+
+ TAILQ_FOREACH(elem, &p->actions, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
+int
+rte_swx_pipeline_action_config(struct rte_swx_pipeline *p,
+ const char *name,
+ const char *args_struct_type_name,
+ const char **instructions,
+ uint32_t n_instructions)
+{
+ struct struct_type *args_struct_type;
+ struct action *a;
+ int err;
+
+ CHECK(p, EINVAL);
+
+ CHECK_NAME(name, EINVAL);
+ CHECK(!action_find(p, name), EEXIST);
+
+ if (args_struct_type_name) {
+ CHECK_NAME(args_struct_type_name, EINVAL);
+ args_struct_type = struct_type_find(p, args_struct_type_name);
+ CHECK(args_struct_type, EINVAL);
+ } else {
+ args_struct_type = NULL;
+ }
+
+ /* Node allocation. */
+ a = calloc(1, sizeof(struct action));
+ CHECK(a, ENOMEM);
+
+ /* Node initialization. */
+ strcpy(a->name, name);
+ a->st = args_struct_type;
+ a->id = p->n_actions;
+
+ /* Instruction translation. */
+ err = instruction_config(p, a, instructions, n_instructions);
+ if (err) {
+ free(a);
+ return err;
+ }
+
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->actions, a, node);
+ p->n_actions++;
+
+ return 0;
+}
+
+static int
+action_build(struct rte_swx_pipeline *p)
+{
+ struct action *action;
+
+ p->action_instructions = calloc(p->n_actions,
+ sizeof(struct instruction *));
+ CHECK(p->action_instructions, ENOMEM);
+
+ TAILQ_FOREACH(action, &p->actions, node)
+ p->action_instructions[action->id] = action->instructions;
+
+ return 0;
+}
+
+static void
+action_build_free(struct rte_swx_pipeline *p)
+{
+ free(p->action_instructions);
+ p->action_instructions = NULL;
+}
+
+static void
+action_free(struct rte_swx_pipeline *p)
+{
+ action_build_free(p);
+
+ for ( ; ; ) {
+ struct action *action;
+
+ action = TAILQ_FIRST(&p->actions);
+ if (!action)
+ break;
+
+ TAILQ_REMOVE(&p->actions, action, node);
+ free(action->instructions);
+ free(action);
+ }
+}
+
+/*
+ * Table.
+ */
+static struct table_type *
+table_type_find(struct rte_swx_pipeline *p, const char *name)
+{
+ struct table_type *elem;
+
+ TAILQ_FOREACH(elem, &p->table_types, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
+static struct table_type *
+table_type_resolve(struct rte_swx_pipeline *p,
+ const char *recommended_type_name,
+ enum rte_swx_table_match_type match_type)
+{
+ struct table_type *elem;
+
+ /* Only consider the recommended type if the match type is correct. */
+ if (recommended_type_name)
+ TAILQ_FOREACH(elem, &p->table_types, node)
+ if (!strcmp(elem->name, recommended_type_name) &&
+ (elem->match_type == match_type))
+ return elem;
+
+ /* Ignore the recommended type and get the first element with this match
+ * type.
+ */
+ TAILQ_FOREACH(elem, &p->table_types, node)
+ if (elem->match_type == match_type)
+ return elem;
+
+ return NULL;
+}
+
+static struct table *
+table_find(struct rte_swx_pipeline *p, const char *name)
+{
+ struct table *elem;
+
+ TAILQ_FOREACH(elem, &p->tables, node)
+ if (strcmp(elem->name, name) == 0)
+ return elem;
+
+ return NULL;
+}
+
+static struct table *
+table_find_by_id(struct rte_swx_pipeline *p, uint32_t id)
+{
+ struct table *table = NULL;
+
+ TAILQ_FOREACH(table, &p->tables, node)
+ if (table->id == id)
+ return table;
+
+ return NULL;
+}
+
+int
+rte_swx_pipeline_table_type_register(struct rte_swx_pipeline *p,
+ const char *name,
+ enum rte_swx_table_match_type match_type,
+ struct rte_swx_table_ops *ops)
+{
+ struct table_type *elem;
+
+ CHECK(p, EINVAL);
+
+ CHECK_NAME(name, EINVAL);
+ CHECK(!table_type_find(p, name), EEXIST);
+
+ CHECK(ops, EINVAL);
+ CHECK(ops->create, EINVAL);
+ CHECK(ops->lkp, EINVAL);
+ CHECK(ops->free, EINVAL);
+
+ /* Node allocation. */
+ elem = calloc(1, sizeof(struct table_type));
+ CHECK(elem, ENOMEM);
+
+ /* Node initialization. */
+ strcpy(elem->name, name);
+ elem->match_type = match_type;
+ memcpy(&elem->ops, ops, sizeof(*ops));
+
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->table_types, elem, node);
+
+ return 0;
+}
+
+static enum rte_swx_table_match_type
+table_match_type_resolve(struct rte_swx_match_field_params *fields,
+ uint32_t n_fields)
+{
+ uint32_t i;
+
+ for (i = 0; i < n_fields; i++)
+ if (fields[i].match_type != RTE_SWX_TABLE_MATCH_EXACT)
+ break;
+
+ if (i == n_fields)
+ return RTE_SWX_TABLE_MATCH_EXACT;
+
+ if ((i == n_fields - 1) &&
+ (fields[i].match_type == RTE_SWX_TABLE_MATCH_LPM))
+ return RTE_SWX_TABLE_MATCH_LPM;
+
+ return RTE_SWX_TABLE_MATCH_WILDCARD;
+}
+
+int
+rte_swx_pipeline_table_config(struct rte_swx_pipeline *p,
+ const char *name,
+ struct rte_swx_pipeline_table_params *params,
+ const char *recommended_table_type_name,
+ const char *args,
+ uint32_t size)
+{
+ struct table_type *type;
+ struct table *t;
+ struct action *default_action;
+ struct header *header = NULL;
+ int is_header = 0;
+ uint32_t offset_prev = 0, action_data_size_max = 0, i;
+
+ CHECK(p, EINVAL);
+
+ CHECK_NAME(name, EINVAL);
+ CHECK(!table_find(p, name), EEXIST);
+
+ CHECK(params, EINVAL);
+
+ /* Match checks. */
+ CHECK(!params->n_fields || params->fields, EINVAL);
+ for (i = 0; i < params->n_fields; i++) {
+ struct rte_swx_match_field_params *field = ¶ms->fields[i];
+ struct header *h;
+ struct field *hf, *mf;
+ uint32_t offset;
+
+ CHECK_NAME(field->name, EINVAL);
+
+ hf = header_field_parse(p, field->name, &h);
+ mf = metadata_field_parse(p, field->name);
+ CHECK(hf || mf, EINVAL);
+
+ offset = hf ? hf->offset : mf->offset;
+
+ if (i == 0) {
+ is_header = hf ? 1 : 0;
+ header = hf ? h : NULL;
+ offset_prev = offset;
+
+ continue;
+ }
+
+ CHECK((is_header && hf && (h->id == header->id)) ||
+ (!is_header && mf), EINVAL);
+
+ CHECK(offset > offset_prev, EINVAL);
+ offset_prev = offset;
+ }
+
+ /* Action checks. */
+ CHECK(params->n_actions, EINVAL);
+ CHECK(params->action_names, EINVAL);
+ for (i = 0; i < params->n_actions; i++) {
+ const char *action_name = params->action_names[i];
+ struct action *a;
+ uint32_t action_data_size;
+
+ CHECK(action_name, EINVAL);
+
+ a = action_find(p, action_name);
+ CHECK(a, EINVAL);
+
+ action_data_size = a->st ? a->st->n_bits / 8 : 0;
+ if (action_data_size > action_data_size_max)
+ action_data_size_max = action_data_size;
+ }
+
+ CHECK(params->default_action_name, EINVAL);
+ for (i = 0; i < p->n_actions; i++)
+ if (!strcmp(params->action_names[i],
+ params->default_action_name))
+ break;
+ CHECK(i < params->n_actions, EINVAL);
+ default_action = action_find(p, params->default_action_name);
+ CHECK((default_action->st && params->default_action_data) ||
+ !params->default_action_data, EINVAL);
+
+ /* Table type checks. */
+ if (params->n_fields) {
+ enum rte_swx_table_match_type match_type;
+
+ match_type = table_match_type_resolve(params->fields,
+ params->n_fields);
+ type = table_type_resolve(p,
+ recommended_table_type_name,
+ match_type);
+ CHECK(type, EINVAL);
+ } else {
+ type = NULL;
+ }
+
+ /* Memory allocation. */
+ t = calloc(1, sizeof(struct table));
+ CHECK(t, ENOMEM);
+
+ t->fields = calloc(params->n_fields, sizeof(struct match_field));
+ if (!t->fields) {
+ free(t);
+ CHECK(0, ENOMEM);
+ }
+
+ t->actions = calloc(params->n_actions, sizeof(struct action *));
+ if (!t->actions) {
+ free(t->fields);
+ free(t);
+ CHECK(0, ENOMEM);
+ }
+
+ if (action_data_size_max) {
+ t->default_action_data = calloc(1, action_data_size_max);
+ if (!t->default_action_data) {
+ free(t->actions);
+ free(t->fields);
+ free(t);
+ CHECK(0, ENOMEM);
+ }
+ }
+
+ /* Node initialization. */
+ strcpy(t->name, name);
+ if (args && args[0])
+ strcpy(t->args, args);
+ t->type = type;
+
+ for (i = 0; i < params->n_fields; i++) {
+ struct rte_swx_match_field_params *field = ¶ms->fields[i];
+ struct match_field *f = &t->fields[i];
+
+ f->match_type = field->match_type;
+ f->field = is_header ?
+ header_field_parse(p, field->name, NULL) :
+ metadata_field_parse(p, field->name);
+ }
+ t->n_fields = params->n_fields;
+ t->is_header = is_header;
+ t->header = header;
+
+ for (i = 0; i < params->n_actions; i++)
+ t->actions[i] = action_find(p, params->action_names[i]);
+ t->default_action = default_action;
+ if (default_action->st)
+ memcpy(t->default_action_data,
+ params->default_action_data,
+ default_action->st->n_bits / 8);
+ t->n_actions = params->n_actions;
+ t->default_action_is_const = params->default_action_is_const;
+ t->action_data_size_max = action_data_size_max;
+
+ t->size = size;
+ t->id = p->n_tables;
+
+ /* Node add to tailq. */
+ TAILQ_INSERT_TAIL(&p->tables, t, node);
+ p->n_tables++;
+
+ return 0;
+}
+
+static struct rte_swx_table_params *
+table_params_get(struct table *table)
+{
+ struct rte_swx_table_params *params;
+ struct field *first, *last;
+ uint8_t *key_mask;
+ uint32_t key_size, key_offset, action_data_size, i;
+
+ /* Memory allocation. */
+ params = calloc(1, sizeof(struct rte_swx_table_params));
+ if (!params)
+ return NULL;
+
+ /* Key offset and size. */
+ first = table->fields[0].field;
+ last = table->fields[table->n_fields - 1].field;
+ key_offset = first->offset / 8;
+ key_size = (last->offset + last->n_bits - first->offset) / 8;
+
+ /* Memory allocation. */
+ key_mask = calloc(1, key_size);
+ if (!key_mask) {
+ free(params);
+ return NULL;
+ }
+
+ /* Key mask. */
+ for (i = 0; i < table->n_fields; i++) {
+ struct field *f = table->fields[i].field;
+ uint32_t start = (f->offset - first->offset) / 8;
+ size_t size = f->n_bits / 8;
+
+ memset(&key_mask[start], 0xFF, size);
+ }
+
+ /* Action data size. */
+ action_data_size = 0;
+ for (i = 0; i < table->n_actions; i++) {
+ struct action *action = table->actions[i];
+ uint32_t ads = action->st ? action->st->n_bits / 8 : 0;
+
+ if (ads > action_data_size)
+ action_data_size = ads;
+ }
+
+ /* Fill in. */
+ params->match_type = table->type->match_type;
+ params->key_size = key_size;
+ params->key_offset = key_offset;
+ params->key_mask0 = key_mask;
+ params->action_data_size = action_data_size;
+ params->n_keys_max = table->size;
+
+ return params;
+}
+
+static void
+table_params_free(struct rte_swx_table_params *params)
+{
+ if (!params)
+ return;
+
+ free(params->key_mask0);
+ free(params);
+}
+
+static int
+table_state_build(struct rte_swx_pipeline *p)
+{
+ struct table *table;
+
+ p->table_state = calloc(p->n_tables,
+ sizeof(struct rte_swx_table_state));
+ CHECK(p->table_state, ENOMEM);
+
+ TAILQ_FOREACH(table, &p->tables, node) {
+ struct rte_swx_table_state *ts = &p->table_state[table->id];
+
+ if (table->type) {
+ struct rte_swx_table_params *params;
+
+ /* ts->obj. */
+ params = table_params_get(table);
+ CHECK(params, ENOMEM);
+
+ ts->obj = table->type->ops.create(params,
+ NULL,
+ table->args,
+ p->numa_node);
+
+ table_params_free(params);
+ CHECK(ts->obj, ENODEV);
+ }
+
+ /* ts->default_action_data. */
+ if (table->action_data_size_max) {
+ ts->default_action_data =
+ malloc(table->action_data_size_max);
+ CHECK(ts->default_action_data, ENOMEM);
+
+ memcpy(ts->default_action_data,
+ table->default_action_data,
+ table->action_data_size_max);
+ }
+
+ /* ts->default_action_id. */
+ ts->default_action_id = table->default_action->id;
+ }
+
+ return 0;
+}
+
+static void
+table_state_build_free(struct rte_swx_pipeline *p)
+{
+ uint32_t i;
+
+ if (!p->table_state)
+ return;
+
+ for (i = 0; i < p->n_tables; i++) {
+ struct rte_swx_table_state *ts = &p->table_state[i];
+ struct table *table = table_find_by_id(p, i);
+
+ /* ts->obj. */
+ if (table->type && ts->obj)
+ table->type->ops.free(ts->obj);
+
+ /* ts->default_action_data. */
+ free(ts->default_action_data);
+ }
+
+ free(p->table_state);
+ p->table_state = NULL;
+}
+
+static void
+table_state_free(struct rte_swx_pipeline *p)
+{
+ table_state_build_free(p);
+}
+
+static int
+table_stub_lkp(void *table __rte_unused,
+ void *mailbox __rte_unused,
+ uint8_t **key __rte_unused,
+ uint64_t *action_id __rte_unused,
+ uint8_t **action_data __rte_unused,
+ int *hit)
+{
+ *hit = 0;
+ return 1; /* DONE. */
+}
+
+static int
+table_build(struct rte_swx_pipeline *p)
+{
+ uint32_t i;
+
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+ struct table *table;
+
+ t->tables = calloc(p->n_tables, sizeof(struct table_runtime));
+ CHECK(t->tables, ENOMEM);
+
+ TAILQ_FOREACH(table, &p->tables, node) {
+ struct table_runtime *r = &t->tables[table->id];
+
+ if (table->type) {
+ uint64_t size;
+
+ size = table->type->ops.mailbox_size_get();
+
+ /* r->func. */
+ r->func = table->type->ops.lkp;
+
+ /* r->mailbox. */
+ if (size) {
+ r->mailbox = calloc(1, size);
+ CHECK(r->mailbox, ENOMEM);
+ }
+
+ /* r->key. */
+ r->key = table->is_header ?
+ &t->structs[table->header->struct_id] :
+ &t->structs[p->metadata_struct_id];
+ } else {
+ r->func = table_stub_lkp;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static void
+table_build_free(struct rte_swx_pipeline *p)
+{
+ uint32_t i;
+
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+ uint32_t j;
+
+ if (!t->tables)
+ continue;
+
+ for (j = 0; j < p->n_tables; j++) {
+ struct table_runtime *r = &t->tables[j];
+
+ free(r->mailbox);
+ }
+
+ free(t->tables);
+ t->tables = NULL;
+ }
+}
+
+static void
+table_free(struct rte_swx_pipeline *p)
+{
+ table_build_free(p);
+
+ /* Tables. */
+ for ( ; ; ) {
+ struct table *elem;
+
+ elem = TAILQ_FIRST(&p->tables);
+ if (!elem)
+ break;
+
+ TAILQ_REMOVE(&p->tables, elem, node);
+ free(elem->fields);
+ free(elem->actions);
+ free(elem->default_action_data);
+ free(elem);
+ }
+
+ /* Table types. */
+ for ( ; ; ) {
+ struct table_type *elem;
+
+ elem = TAILQ_FIRST(&p->table_types);
+ if (!elem)
+ break;
+
+ TAILQ_REMOVE(&p->table_types, elem, node);
+ free(elem);
+ }
}
/*
TAILQ_INIT(&pipeline->ports_in);
TAILQ_INIT(&pipeline->port_out_types);
TAILQ_INIT(&pipeline->ports_out);
+ TAILQ_INIT(&pipeline->extern_types);
+ TAILQ_INIT(&pipeline->extern_objs);
+ TAILQ_INIT(&pipeline->extern_funcs);
TAILQ_INIT(&pipeline->headers);
+ TAILQ_INIT(&pipeline->actions);
+ TAILQ_INIT(&pipeline->table_types);
+ TAILQ_INIT(&pipeline->tables);
pipeline->n_structs = 1; /* Struct 0 is reserved for action_data. */
pipeline->numa_node = numa_node;
if (!p)
return;
+ free(p->instructions);
+
+ table_state_free(p);
+ table_free(p);
+ action_free(p);
metadata_free(p);
header_free(p);
+ extern_func_free(p);
+ extern_obj_free(p);
port_out_free(p);
port_in_free(p);
struct_free(p);
free(p);
}
+int
+rte_swx_pipeline_instructions_config(struct rte_swx_pipeline *p,
+ const char **instructions,
+ uint32_t n_instructions)
+{
+ int err;
+ uint32_t i;
+
+ err = instruction_config(p, NULL, instructions, n_instructions);
+ if (err)
+ return err;
+
+ /* Thread instruction pointer reset. */
+ for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) {
+ struct thread *t = &p->threads[i];
+
+ thread_ip_reset(p, t);
+ }
+
+ return 0;
+}
+
int
rte_swx_pipeline_build(struct rte_swx_pipeline *p)
{
if (status)
goto error;
+ status = extern_obj_build(p);
+ if (status)
+ goto error;
+
+ status = extern_func_build(p);
+ if (status)
+ goto error;
+
status = header_build(p);
if (status)
goto error;
if (status)
goto error;
+ status = action_build(p);
+ if (status)
+ goto error;
+
+ status = table_build(p);
+ if (status)
+ goto error;
+
+ status = table_state_build(p);
+ if (status)
+ goto error;
+
p->build_done = 1;
return 0;
error:
+ table_state_build_free(p);
+ table_build_free(p);
+ action_build_free(p);
metadata_build_free(p);
header_build_free(p);
+ extern_func_build_free(p);
+ extern_obj_build_free(p);
port_out_build_free(p);
port_in_build_free(p);
struct_build_free(p);
return status;
}
+
+/*
+ * Control.
+ */
+int
+rte_swx_pipeline_table_state_get(struct rte_swx_pipeline *p,
+ struct rte_swx_table_state **table_state)
+{
+ if (!p || !table_state || !p->build_done)
+ return -EINVAL;
+
+ *table_state = p->table_state;
+ return 0;
+}
+
+int
+rte_swx_pipeline_table_state_set(struct rte_swx_pipeline *p,
+ struct rte_swx_table_state *table_state)
+{
+ if (!p || !table_state || !p->build_done)
+ return -EINVAL;
+
+ p->table_state = table_state;
+ return 0;
+}