mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-12-23 02:01:55 +00:00
Code Releases Activity

Dropping the tmp_attrs mechanism as obsolete

Browse Source 
There are no protocol-specific fields in rte now.
This commit is contained in:
Maria Matejka 2020-02-17 12:40:09 +01:00
parent c32410fb40
commit 5ceaec93f7
8 changed files with 0 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
nest/proto-hooks.c
View File

@ -227,36 +227,6 @@ void rt_notify(struct proto *p, net *net, rte *new, rte *old, ea_list *attrs)
void neigh_notify(neighbor *neigh) void neigh_notify(neighbor *neigh)
{ DUMMY; } { DUMMY; }
/**
* make_tmp_attrs - convert embedded attributes to temporary ones
* @e: route entry
* @pool: linear pool to allocate attribute memory in
*
* This hook is called by the routing table functions if they need
* to convert the protocol attributes embedded directly in the &rte
* to temporary extended attributes in order to distribute them
* to other protocols or to filters. make_tmp_attrs() creates
* an &ea_list in the linear pool @pool, fills it with values of the
* temporary attributes and returns a pointer to it.
*/
ea_list *make_tmp_attrs(rte *e, struct linpool *pool)
{ DUMMY; }
/**
* store_tmp_attrs - convert temporary attributes to embedded ones
* @e: route entry
* @attrs: temporary attributes to be converted
*
* This hook is an exact opposite of make_tmp_attrs() -- it takes
* a list of extended attributes and converts them to attributes
* embedded in the &rte corresponding to this protocol.
*
* You must be prepared for any of the attributes being missing
* from the list and use default values instead.
*/
void store_tmp_attrs(rte *e, ea_list *attrs)
{ DUMMY; }
/** /**
* preexport - pre-filtering decisions before route export * preexport - pre-filtering decisions before route export
* @p: protocol instance the route is going to be exported to * @p: protocol instance the route is going to be exported to

4
nest/protocol.h
View File

@ -198,8 +198,6 @@ struct proto {
* ifa_notify Notify protocol about interface address changes. * ifa_notify Notify protocol about interface address changes.
* rt_notify Notify protocol about routing table updates. * rt_notify Notify protocol about routing table updates.
* neigh_notify Notify protocol about neighbor cache events. * neigh_notify Notify protocol about neighbor cache events.
* make_tmp_attrs Add attributes to rta from from private attrs stored in rte. The route and rta MUST NOT be cached.
* store_tmp_attrs Store private attrs back to rte and undef added attributes. The route and rta MUST NOT be cached.
* preexport Called as the first step of the route exporting process. * preexport Called as the first step of the route exporting process.
* It can construct a new rte, add private attributes and * It can construct a new rte, add private attributes and
* decide whether the route shall be exported: 1=yes, -1=no, * decide whether the route shall be exported: 1=yes, -1=no,
@ -215,8 +213,6 @@ struct proto {
void (*ifa_notify)(struct proto *, unsigned flags, struct ifa *a); void (*ifa_notify)(struct proto *, unsigned flags, struct ifa *a);
void (*rt_notify)(struct proto *, struct channel *, struct network *net, struct rte *new, struct rte *old); void (*rt_notify)(struct proto *, struct channel *, struct network *net, struct rte *new, struct rte *old);
void (*neigh_notify)(struct neighbor *neigh); void (*neigh_notify)(struct neighbor *neigh);
void (*make_tmp_attrs)(struct rte *rt, struct linpool *pool);
void (*store_tmp_attrs)(struct rte *rt, struct linpool *pool);
int (*preexport)(struct proto *, struct rte **rt, struct linpool *pool); int (*preexport)(struct proto *, struct rte **rt, struct linpool *pool);
void (*reload_routes)(struct channel *); void (*reload_routes)(struct channel *);
void (*feed_begin)(struct channel *, int initial); void (*feed_begin)(struct channel *, int initial);

8
nest/route.h
View File

@ -236,8 +236,6 @@ typedef struct rte {
byte flags; /* Flags (REF_...) */ byte flags; /* Flags (REF_...) */
byte pflags; /* Protocol-specific flags */ byte pflags; /* Protocol-specific flags */
btime lastmod; /* Last modified */ btime lastmod; /* Last modified */
union { /* Protocol-dependent data (metrics etc.) */
} u;
} rte; } rte;
#define REF_COW 1 /* Copy this rte on write */ #define REF_COW 1 /* Copy this rte on write */
@ -341,10 +339,6 @@ rte *rte_do_cow(rte *);
rte *rte_store(rte *); rte *rte_store(rte *);
static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; } static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
rte *rte_cow_rta(rte *r, linpool *lp); rte *rte_cow_rta(rte *r, linpool *lp);
void rte_init_tmp_attrs(struct rte *r, linpool *lp, uint max);
void rte_make_tmp_attr(struct rte *r, uint id, uint type, uintptr_t val);
void rte_make_tmp_attrs(struct rte **r, struct linpool *pool, struct rta **old_attrs);
uintptr_t rte_store_tmp_attr(struct rte *r, uint id);
void rt_dump(rtable *); void rt_dump(rtable *);
void rt_dump_all(void); void rt_dump_all(void);
int rt_feed_channel(struct channel *c); int rt_feed_channel(struct channel *c);
@ -509,7 +503,6 @@ typedef struct eattr {
#define EA_CODE(proto,id) (((proto) << 8) | (id)) #define EA_CODE(proto,id) (((proto) << 8) | (id))
#define EA_ID(ea) ((ea) & 0xff) #define EA_ID(ea) ((ea) & 0xff)
#define EA_PROTO(ea) ((ea) >> 8) #define EA_PROTO(ea) ((ea) >> 8)
#define EA_ID_FLAG(ea) (1 << EA_ID(ea))
#define EA_CUSTOM(id) ((id) | EA_CUSTOM_BIT) #define EA_CUSTOM(id) ((id) | EA_CUSTOM_BIT)
#define EA_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT) #define EA_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT)
#define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT) #define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT)
@ -571,7 +564,6 @@ typedef struct ea_list {
#define EALF_SORTED 1 /* Attributes are sorted by code */ #define EALF_SORTED 1 /* Attributes are sorted by code */
#define EALF_BISECT 2 /* Use interval bisection for searching */ #define EALF_BISECT 2 /* Use interval bisection for searching */
#define EALF_CACHED 4 /* Attributes belonging to cached rta */ #define EALF_CACHED 4 /* Attributes belonging to cached rta */
#define EALF_TEMP 8 /* Temporary ea_list added by make_tmp_attrs hooks */
struct rte_src *rt_find_source(struct proto *p, u32 id); struct rte_src *rt_find_source(struct proto *p, u32 id);
struct rte_src *rt_get_source(struct proto *p, u32 id); struct rte_src *rt_get_source(struct proto *p, u32 id);

1
nest/rt-show.c
View File

@ -127,7 +127,6 @@ rt_show_net(struct cli *c, net *n, struct rt_show_data *d)
continue; continue;
ee = e; ee = e;
rte_make_tmp_attrs(&e, c->show_pool, NULL);
/* Export channel is down, do not try to export routes to it */ /* Export channel is down, do not try to export routes to it */
if (ec && (ec->export_state == ES_DOWN)) if (ec && (ec->export_state == ES_DOWN))

185
nest/rt-table.c
View File

@ -336,176 +336,6 @@ rte_cow_rta(rte *r, linpool *lp)
return r; return r;
} }
/**
* rte_init_tmp_attrs - initialize temporary ea_list for route
* @r: route entry to be modified
* @lp: linpool from which to allocate attributes
* @max: maximum number of added temporary attribus
*
* This function is supposed to be called from make_tmp_attrs() and
* store_tmp_attrs() hooks before rte_make_tmp_attr() / rte_store_tmp_attr()
* functions. It allocates &ea_list with length for @max items for temporary
* attributes and puts it on top of eattrs stack.
*/
void
rte_init_tmp_attrs(rte *r, linpool *lp, uint max)
{
struct ea_list *e = lp_alloc(lp, sizeof(struct ea_list) + max * sizeof(eattr));
e->next = r->attrs->eattrs;
e->flags = EALF_SORTED | EALF_TEMP;
e->count = 0;
r->attrs->eattrs = e;
}
/**
* rte_make_tmp_attr - make temporary eattr from private route fields
* @r: route entry to be modified
* @id: attribute ID
* @type: attribute type
* @val: attribute value (u32 or adata ptr)
*
* This function is supposed to be called from make_tmp_attrs() hook for
* each temporary attribute, after temporary &ea_list was initialized by
* rte_init_tmp_attrs(). It checks whether temporary attribute is supposed to
* be defined (based on route pflags) and if so then it fills &eattr field in
* preallocated temporary &ea_list on top of route @r eattrs stack.
*
* Note that it may require free &eattr in temporary &ea_list, so it must not be
* called more times than @max argument of rte_init_tmp_attrs().
*/
void
rte_make_tmp_attr(rte *r, uint id, uint type, uintptr_t val)
{
if (r->pflags & EA_ID_FLAG(id))
{
ea_list *e = r->attrs->eattrs;
eattr *a = &e->attrs[e->count++];
a->id = id;
a->type = type;
a->flags = 0;
if (type & EAF_EMBEDDED)
a->u.data = (u32) val;
else
a->u.ptr = (struct adata *) val;
}
}
/**
* rte_store_tmp_attr - store temporary eattr to private route fields
* @r: route entry to be modified
* @id: attribute ID
*
* This function is supposed to be called from store_tmp_attrs() hook for
* each temporary attribute, after temporary &ea_list was initialized by
* rte_init_tmp_attrs(). It checks whether temporary attribute is defined in
* route @r eattrs stack, updates route pflags accordingly, undefines it by
* filling &eattr field in preallocated temporary &ea_list on top of the eattrs
* stack, and returns the value. Caller is supposed to store it in the
* appropriate private field.
*
* Note that it may require free &eattr in temporary &ea_list, so it must not be
* called more times than @max argument of rte_init_tmp_attrs()
*/
uintptr_t
rte_store_tmp_attr(rte *r, uint id)
{
ea_list *e = r->attrs->eattrs;
eattr *a = ea_find(e->next, id);
if (a)
{
e->attrs[e->count++] = (struct eattr) { .id = id, .type = EAF_TYPE_UNDEF };
r->pflags |= EA_ID_FLAG(id);
return (a->type & EAF_EMBEDDED) ? a->u.data : (uintptr_t) a->u.ptr;
}
else
{
r->pflags &= ~EA_ID_FLAG(id);
return 0;
}
}
/**
* rte_make_tmp_attrs - prepare route by adding all relevant temporary route attributes
* @r: route entry to be modified (may be replaced if COW)
* @lp: linpool from which to allocate attributes
* @old_attrs: temporary ref to old &rta (may be NULL)
*
* This function expands privately stored protocol-dependent route attributes
* to a uniform &eattr / &ea_list representation. It is essentially a wrapper
* around protocol make_tmp_attrs() hook, which does some additional work like
* ensuring that route @r is writable.
*
* The route @r may be read-only (with %REF_COW flag), in that case rw copy is
* obtained by rte_cow() and @r is replaced. If @rte is originally rw, it may be
* directly modified (and it is never copied).
*
* If the @old_attrs ptr is supplied, the function obtains another reference of
* old cached &rta, that is necessary in some cases (see rte_cow_rta() for
* details). It is freed by rte_store_tmp_attrs(), or manually by rta_free().
*
* Generally, if caller ensures that @r is read-only (e.g. in route export) then
* it may ignore @old_attrs (and set it to NULL), but must handle replacement of
* @r. If caller ensures that @r is writable (e.g. in route import) then it may
* ignore replacement of @r, but it must handle @old_attrs.
*/
void
rte_make_tmp_attrs(rte **r, linpool *lp, rta **old_attrs)
{
void (*make_tmp_attrs)(rte *r, linpool *lp);
make_tmp_attrs = (*r)->attrs->src->proto->make_tmp_attrs;
if (!make_tmp_attrs)
return;
/* We may need to keep ref to old attributes, will be freed in rte_store_tmp_attrs() */
if (old_attrs)
*old_attrs = rta_is_cached((*r)->attrs) ? rta_clone((*r)->attrs) : NULL;
*r = rte_cow_rta(*r, lp);
make_tmp_attrs(*r, lp);
}
/**
* rte_store_tmp_attrs - store temporary route attributes back to private route fields
* @r: route entry to be modified
* @lp: linpool from which to allocate attributes
* @old_attrs: temporary ref to old &rta
*
* This function stores temporary route attributes that were expanded by
* rte_make_tmp_attrs() back to private route fields and also undefines them.
* It is essentially a wrapper around protocol store_tmp_attrs() hook, which
* does some additional work like shortcut if there is no change and cleanup
* of @old_attrs reference obtained by rte_make_tmp_attrs().
*/
static void
rte_store_tmp_attrs(rte *r, linpool *lp, rta *old_attrs)
{
void (*store_tmp_attrs)(rte *rt, linpool *lp);
store_tmp_attrs = r->attrs->src->proto->store_tmp_attrs;
if (!store_tmp_attrs)
return;
ASSERT(!rta_is_cached(r->attrs));
/* If there is no new ea_list, we just skip the temporary ea_list */
ea_list *ea = r->attrs->eattrs;
if (ea && (ea->flags & EALF_TEMP))
r->attrs->eattrs = ea->next;
else
store_tmp_attrs(r, lp);
/* Free ref we got in rte_make_tmp_attrs(), have to do rta_lookup() first */
r->attrs = rta_lookup(r->attrs);
rta_free(old_attrs);
}
static int /* Actually better or at least as good as */ static int /* Actually better or at least as good as */
rte_better(rte *new, rte *old) rte_better(rte *new, rte *old)
{ {
@ -606,8 +436,6 @@ export_filter_(struct channel *c, rte *rt0, rte **rt_free, linpool *pool, int si
goto accept; goto accept;
} }
rte_make_tmp_attrs(&rt, pool, NULL);
v = filter && ((filter == FILTER_REJECT) || v = filter && ((filter == FILTER_REJECT) ||
(f_run(filter, &rt, pool, (f_run(filter, &rt, pool,
(silent ? FF_SILENT : 0)) > F_ACCEPT)); (silent ? FF_SILENT : 0)) > F_ACCEPT));
@ -1421,9 +1249,6 @@ rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
} }
else if (filter) else if (filter)
{ {
rta *old_attrs = NULL;
rte_make_tmp_attrs(&new, rte_update_pool, &old_attrs);
int fr = f_run(filter, &new, rte_update_pool, 0); int fr = f_run(filter, &new, rte_update_pool, 0);
if (fr > F_ACCEPT) if (fr > F_ACCEPT)
{ {
@ -1431,15 +1256,10 @@ rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src)
rte_trace_in(D_FILTERS, c, new, "filtered out"); rte_trace_in(D_FILTERS, c, new, "filtered out");
if (! c->in_keep_filtered) if (! c->in_keep_filtered)
{
rta_free(old_attrs);
goto drop; goto drop;
}
new->flags |= REF_FILTERED; new->flags |= REF_FILTERED;
} }
rte_store_tmp_attrs(new, rte_update_pool, old_attrs);
} }
if (!rta_is_cached(new->attrs)) /* Need to copy attributes */ if (!rta_is_cached(new->attrs)) /* Need to copy attributes */
new->attrs = rta_lookup(new->attrs); new->attrs = rta_lookup(new->attrs);
@ -1562,10 +1382,7 @@ rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter)
/* Rest is stripped down export_filter() */ /* Rest is stripped down export_filter() */
int v = p->preexport ? p->preexport(p, &rt, rte_update_pool) : 0; int v = p->preexport ? p->preexport(p, &rt, rte_update_pool) : 0;
if (v == RIC_PROCESS) if (v == RIC_PROCESS)
{
rte_make_tmp_attrs(&rt, rte_update_pool, NULL);
v = (f_run(filter, &rt, rte_update_pool, FF_SILENT) <= F_ACCEPT); v = (f_run(filter, &rt, rte_update_pool, FF_SILENT) <= F_ACCEPT);
}
/* Discard temporary rte */ /* Discard temporary rte */
if (rt != n->routes) if (rt != n->routes)
@ -2664,8 +2481,6 @@ rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old0, int re
net = net_get(tab, n); net = net_get(tab, n);
src = new->attrs->src; src = new->attrs->src;
rte_store_tmp_attrs(new, rte_update_pool, NULL);
if (!rta_is_cached(new->attrs)) if (!rta_is_cached(new->attrs))
new->attrs = rta_lookup(new->attrs); new->attrs = rta_lookup(new->attrs);
} }

2
proto/mrt/mrt.c
View File

@ -522,8 +522,6 @@ mrt_rib_table_dump(struct mrt_table_dump_state *s, net *n, int add_path)
continue; continue;
} }
rte_make_tmp_attrs(&rt, s->linpool, NULL);
if (f_run(s->filter, &rt, s->linpool, 0) <= F_ACCEPT) if (f_run(s->filter, &rt, s->linpool, 0) <= F_ACCEPT)
mrt_rib_table_entry(s, rt); mrt_rib_table_entry(s, rt);

10
proto/pipe/pipe.c
View File

@ -78,16 +78,6 @@ pipe_rt_notify(struct proto *P, struct channel *src_ch, net *n, rte *new, rte *o
e->attrs = rta_lookup(a); e->attrs = rta_lookup(a);
e->pflags = 0; e->pflags = 0;
/* Copy protocol specific embedded attributes. */
memcpy(&(e->u), &(new->u), sizeof(e->u));
e->pflags = new->pflags;
#ifdef CONFIG_BGP
/* Hack to cleanup cached value */
if (e->attrs->src->proto->proto == &proto_bgp)
e->pflags &= ~(BGP_REF_STALE | BGP_REF_NOT_STALE);
#endif
src = a->src; src = a->src;
} }
else else

2
sysdep/unix/krt.c
View File

@ -577,8 +577,6 @@ krt_export_net(struct krt_proto *p, net *net, rte **rt_free)
if (filter == FILTER_REJECT) if (filter == FILTER_REJECT)
return NULL; return NULL;
rte_make_tmp_attrs(&rt, krt_filter_lp, NULL);
/* We could run krt_preexport() here, but it is already handled by krt_is_installed() */ /* We could run krt_preexport() here, but it is already handled by krt_is_installed() */
if (filter == FILTER_ACCEPT) if (filter == FILTER_ACCEPT)