RIP fixup + dropping the tmp_attrs mechanism as obsolete (541881be) · Commits · 戴 / Bird

nest/proto-hooks.c

+0 −30

Original line number	Diff line number	Diff line
		@@ -227,36 +227,6 @@ void rt_notify(struct proto p, net net, rte new, rte old, ea_list *attrs)
		void neigh_notify(neighbor *neigh)
		{ 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
		* @p: protocol instance the route is going to be exported to

nest/protocol.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -198,8 +198,6 @@ struct proto {
		* ifa_notify Notify protocol about interface address changes.
		* rt_notify Notify protocol about routing table updates.
		* 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.
		* It can decide whether the route shall be exported:
		* -1 = reject,
		@@ -216,8 +214,6 @@ struct proto {
		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 (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);
		void (reload_routes)(struct channel );
		void (feed_begin)(struct channel , int initial);

nest/route.h

+0 −8

Original line number	Diff line number	Diff line
		@@ -243,8 +243,6 @@ typedef struct rte {
		byte flags; /* Flags (REF_...) */
		byte pflags; /* Protocol-specific flags */
		btime lastmod; /* Last modified */
		union { /* Protocol-dependent data (metrics etc.) */
		} u;
		} rte;

		#define REF_COW 1 /* Copy this rte on write */
		@@ -307,10 +305,6 @@ void rte_free(rte *);
		rte rte_do_cow(rte );
		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);
		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_all(void);
		int rt_feed_channel(struct channel *c);
		@@ -475,7 +469,6 @@ typedef struct eattr {
		#define EA_CODE(proto,id) (((proto) << 8) \| (id))
		#define EA_ID(ea) ((ea) & 0xff)
		#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_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT)
		#define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT)
		@@ -537,7 +530,6 @@ typedef struct ea_list {
		#define EALF_SORTED 1 /* Attributes are sorted by code */
		#define EALF_BISECT 2 /* Use interval bisection for searching */
		#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_get_source(struct proto p, u32 id);

nest/rt-show.c

+0 −1

Original line number	Diff line number	Diff line
		@@ -127,7 +127,6 @@ rt_show_net(struct cli c, net n, struct rt_show_data *d)
		continue;

		ee = e;
		rte_make_tmp_attrs(&e, c->show_pool, NULL);

		/* Export channel is down, do not try to export routes to it */
		if (ec && (ec->export_state == ES_DOWN))

nest/rt-table.c

+0 −184

Original line number	Diff line number	Diff line
		@@ -354,175 +354,6 @@ rte_free_quick(rte *e)
		sl_free(rte_slab, e);
		}

		/**
		* 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)->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->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 */
		rte_better(rte new, rte old)
		{
		@@ -623,8 +454,6 @@ export_filter_(struct channel c, rte rt0, rte *rt_free, linpool pool, int si
		goto accept;
		}

		rte_make_tmp_attrs(&rt, pool, NULL);

		v = filter && ((filter == FILTER_REJECT) \|\|
		(f_run(filter, &rt, pool,
		(silent ? FF_SILENT : 0)) > F_ACCEPT));
		@@ -1469,9 +1298,6 @@ rte_update2(struct channel c, const net_addr n, rte new, struct rte_src src)
		}
		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);
		if (fr > F_ACCEPT)
		{
		@@ -1479,15 +1305,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");

		if (! c->in_keep_filtered)
		{
		rta_free(old_attrs);
		goto drop;
		}

		new->flags \|= REF_FILTERED;
		}

		rte_store_tmp_attrs(new, rte_update_pool, old_attrs);
		}
		if (!rta_is_cached(new->attrs)) /* Need to copy attributes */
		new->attrs = rta_lookup(new->attrs);
		@@ -1581,10 +1402,7 @@ rt_examine(rtable t, net_addr a, struct proto p, const struct filter filter)
		/* Rest is stripped down export_filter() */
		int v = p->preexport ? p->preexport(p, rt) : 0;
		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);
		}

		/* Discard temporary rte */
		if (rt != n->routes)
		@@ -2754,8 +2572,6 @@ rte_update_out(struct channel c, const net_addr n, rte new, rte old0, rte **
		net = net_get(tab, n);
		src = new->src;

		rte_store_tmp_attrs(new, rte_update_pool, NULL);

		if (!rta_is_cached(new->attrs))
		new->attrs = rta_lookup(new->attrs);
		}

Admin message