--- filter/adapt.c | 107 ++++++++++++++++++++++++++++++++++++++++++++++++ filter/decl.m4 | 33 +++++++++++++++ filter/f-inst.c | 24 ++++++++++- filter/filter.h | 11 +++++ 4 files changed, 173 insertions(+), 2 deletions(-) diff --git a/filter/adapt.c b/filter/adapt.c index 13c090da..76367521 100644 --- a/filter/adapt.c +++ b/filter/adapt.c @@ -41,3 +41,110 @@ filter_validate_function(struct symbol *sym) if (f_has_typed_symbols(sym->function)) sym->flags |= SYM_FLAG_DO_ADAPT; } + +struct f_tree * +filter_tree_adapt(struct f_tree *t, const struct f_context ctx) +{ + if (!filter_tree_has_typed_symbols(t)) + return t; + + struct f_tree *rt = cfg_allocz(sizeof(struct f_tree)); + memcpy(rt, t, sizeof(struct f_tree)); + + if (filter_tree_has_typed_symbols(t->left)) + rt->left = filter_tree_adapt(t->left, ctx); + + if (filter_tree_has_typed_symbols(t->right)) + rt->right = filter_tree_adapt(t->right, ctx); + + if (t->data && f_has_typed_symbols(t->data)) + rt->data = filter_adapt_line(t->data, ctx); + + return rt; +} + +struct symbol * +filter_adapt_function(struct symbol *sym, const struct f_context ctx) +{ + const struct f_line *line; + struct symbol *tsym = cf_find_typed_symbol(adapt_config, sym->name, ctx.net_type); + if (tsym) { + if (tsym->flags & SYM_FLAG_DO_ADAPT) { + line = tsym->function; + } else { + return tsym; + } + } else if (sym->flags & SYM_FLAG_IS_TYPED && !(sym->flags & SYM_FLAG_DO_ADAPT)) { + cf_error("function %s is not defined for %s", sym->name, net_label[ctx.net_type]); + } else if (new_config) { + tsym = cf_define_typed_symbol(sym, SYM_FUNCTION, function, NULL, ctx.net_type); + line = sym->function; + } else { + tsym = cfg_allocz(sizeof(struct symbol)); + tsym->class = SYM_FUNCTION; + tsym->scope = sym->scope; + tsym->net_type = ctx.net_type; + line = sym->function; + } + tsym->function = filter_adapt_line(line, ctx); + tsym->flags &= ~SYM_FLAG_DO_ADAPT; + return tsym; +} + +const struct filter * +filter_adapt(const struct filter *filter, const struct f_context ctx) +{ + if (is_pseudo_filter(filter)) + return filter; + + const struct f_line *line = filter->root; + struct symbol *sym = filter->sym; + struct symbol *tsym; + + if (line && !f_has_typed_symbols(line)) + return filter; + + if (sym) { + tsym = cf_find_typed_symbol(adapt_config, sym->name, ctx.net_type); + if (tsym) { + line = tsym->filter->root; + if (!f_has_typed_symbols(line)) + return tsym->filter; + sym = tsym; + } else if (sym->flags & SYM_FLAG_IS_TYPED && !(sym->flags & SYM_FLAG_DO_ADAPT)) { + cf_error("filter %s is not defined for %s", sym->name, net_label[ctx.net_type]); + } else { + sym->flags |= SYM_FLAG_DO_ADAPT; + } + } + + struct filter *f = cfg_allocz(sizeof(struct filter)); + f->root = filter_adapt_line(line, ctx); + + if (f_has_typed_symbols(f->root)) + cf_error("failed to adapt the filter properly"); + + if (sym) { + if (tsym) + tsym->filter = f; + else if (new_config) + f->sym = cf_define_typed_symbol(sym, SYM_FILTER, filter, + f, ctx.net_type); + } + + return f; +} + +void +filters_adapt(const struct filter *(*filters)[NET_MAX], const struct filter *f, const u32 mask, const struct config *cfg) +{ + for (int net_type=1; net_type<NET_MAX; net_type++) { + if (net_val_match(net_type, mask)) { + struct f_context f_ctx = { + .net_type = net_type, + .cfg = cfg, + }; + (*filters)[net_type] = filter_adapt(f, f_ctx); + } + } +} diff --git a/filter/decl.m4 b/filter/decl.m4 index 23024d35..81b07bbe 100644 --- a/filter/decl.m4 +++ b/filter/decl.m4 @@ -41,6 +41,7 @@ m4_divert(-1)m4_dnl # 107 struct f_line_item content # 108 interpreter body # 109 f_has_typed_symbls +# 110 filter_adapt_line # # Here are macros to allow you to _divert to the right directions. m4_define(FID_STRUCT_IN, `m4_divert(101)') @@ -52,6 +53,7 @@ m4_define(FID_SAME_BODY, `m4_divert(106)') m4_define(FID_LINE_IN, `m4_divert(107)') m4_define(FID_INTERPRET_BODY, `m4_divert(108)') m4_define(FID_HAS_TYPED_BODY, `m4_divert(109)') +m4_define(FID_ADAPT_BODY, `m4_divert(110)') # Sometimes you want slightly different code versions in different # outputs. @@ -210,6 +212,9 @@ FID_SAME_BODY()m4_dnl if (!f_same(f1->fl$1, f2->fl$1)) return 0; FID_HAS_TYPED_BODY()m4_dnl if (f_has_typed_symbols(item->fl$1)) return 1; +FID_ADAPT_BODY()m4_dnl +if (f_has_typed_symbols(item->fl$1)) + item->fl$1 = filter_adapt_line(item->fl$1, ctx); FID_INTERPRET_EXEC()m4_dnl do { if (whati->fl$1) { LINEX_(whati->fl$1); @@ -265,6 +270,7 @@ m4_define(ACCESS_RTE, `FID_HIC(,[[do { if (!fs->rte) runtime("No route to access # 8 linearize # 9 same (filter comparator) # 10 f_has_typed_symbols +# 11 filter_adapt_line # 1 union in struct f_inst # 3 constructors + interpreter # @@ -286,6 +292,7 @@ m4_define(FID_DUMP_CALLER, `FID_ZONE(7, Dump line caller)') m4_define(FID_LINEARIZE, `FID_ZONE(8, Linearize)') m4_define(FID_SAME, `FID_ZONE(9, Comparison)') m4_define(FID_HAS_TYPED, `FID_ZONE(10, Has typed symbol)') +m4_define(FID_ADAPT, `FID_ZONE(11, Adapt filter line)') # This macro does all the code wrapping. See inline comments. m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[ @@ -380,6 +387,13 @@ m4_undivert(109)m4_dnl #undef item break; +FID_ADAPT()m4_dnl This code checks if a f_line used typed symbols +case INST_NAME(): +#define item (&(fl_item->i_]]INST_NAME()[[)) +m4_undivert(110)m4_dnl +#undef item +break; + m4_divert(-1)FID_FLUSH(101,200)m4_dnl And finally this flushes all the unused diversions ]])') @@ -605,6 +619,25 @@ FID_WR_PUT(10) return 0; } +/* adapt f_line to a specific context */ +struct f_line * +filter_adapt_line(const struct f_line *in, const struct f_context ctx) +{ + size_t sz = sizeof(struct f_line) + sizeof(struct f_line_item)*in->len; + struct f_line *out = cfg_allocz(sz); + memcpy(out, in, sz); + for (uint i=0; i<out->len; i++) { + struct f_line_item *fl_item = &out->items[i]; + struct symbol *sym; + struct symbol *tsym; + + switch (fl_item->fi_code) { +FID_WR_PUT(11) + } + } + return out; +} + #if defined(__GNUC__) && __GNUC__ >= 6 #pragma GCC diagnostic pop #endif diff --git a/filter/f-inst.c b/filter/f-inst.c index 46354aa2..7e4043d3 100644 --- a/filter/f-inst.c +++ b/filter/f-inst.c @@ -27,13 +27,18 @@ * stack; e.g. the + operation just takes two arguments from the value * stack and puts the result on there. * - * 3 Interpret + * 3 Adaptation + * The filter is adapted to the context in which it's being attached. + * In this step we make sure that all symbols involved is typed + * appropriately. + * + * 4 Interpret * The given line is put on a custom execution stack. If needed (FI_CALL, * FI_SWITCH, FI_AND, FI_OR, FI_CONDITION, ...), another line is put on top * of the stack; when that line finishes, the execution continues on the * older lines on the stack where it stopped before. * - * 4 Same + * 5 Same * On config reload, the filters have to be compared whether channel * reload is needed or not. The comparison is done by comparing the * struct f_line's recursively. @@ -445,6 +450,15 @@ FID_HAS_TYPED_BODY() return 1; + FID_ADAPT_BODY() + sym = item->sym; + tsym = cf_find_typed_symbol(adapt_config, sym->name, ctx.net_type); + if (!tsym) + cf_error("constant %s is not defined for %s", sym->name, net_label[ctx.net_type]); + fl_item->fi_code = FI_CONSTANT; + #define new_item (&(fl_item->i_FI_CONSTANT)) + new_item->val = *(tsym->val); + #undef new_item FID_INTERPRET_BODY() runtime("FI_TYPED_CONSTANT can't be interpreted", sym); } @@ -940,6 +954,9 @@ FID_HAS_TYPED_BODY() if (item->sym->flags & SYM_FLAGS_TYPED) return 1; + FID_ADAPT_BODY() + if (item->sym->flags & SYM_FLAGS_TYPED) + item->sym = filter_adapt_function(item->sym, ctx); FID_INTERPRET_BODY() /* Push the body on stack */ @@ -971,6 +988,9 @@ FID_HAS_TYPED_BODY() if (filter_tree_has_typed_symbols(item->tree)) return 1; + FID_ADAPT_BODY() + if (filter_tree_has_typed_symbols(item->tree)) + item->tree = filter_tree_adapt(item->tree, ctx); FID_INTERPRET_BODY() const struct f_tree *t = find_tree(tree, &v1); diff --git a/filter/filter.h b/filter/filter.h index 33c452e8..fcd12a3d 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -51,6 +51,11 @@ struct filter { const struct f_line *root; }; +struct f_context { + const u8 net_type; + const struct config *cfg; +}; + struct rte; enum filter_return f_run(const struct filter *filter, struct rte **rte, struct linpool *tmp_pool, int flags); @@ -66,6 +71,12 @@ int f_same(const struct f_line *f1, const struct f_line *f2); int f_has_typed_symbols(const struct f_line *line); int filter_tree_has_typed_symbols(const struct f_tree *t); void filter_validate_function(struct symbol *sym); +const struct filter *filter_adapt(const struct filter *filter, const struct f_context ctx); +void filters_adapt(const struct filter *(*filters)[NET_MAX], const struct filter *f, const u32 mask, const struct config *cfg); +struct f_tree *filter_tree_adapt(struct f_tree *t, const struct f_context ctx); +struct symbol *filter_adapt_function(struct symbol *sym, const struct f_context ctx); +struct f_line *filter_adapt_line(const struct f_line *in, const struct f_context ctx); +#define adapt_config (ctx.cfg ? ctx.cfg : new_config) void filter_commit(struct config *new, struct config *old); -- 2.24.0