void pointer can be stored in eattr

No page flush before polling

The maximum amount of locally kept pages is 128 so we can just
well keep the half-meg of RAM allocated and prepared for future use.

Prefilter runs before generating feeds

Table cork now uses callbacks and direct flush to uncork

Configuration obstacles made a separate, explicit structure

With this, one can walk the obstacle list in a debugger and
easier see which specific object is holding the reference.

Global runtime values separated from config

CLI: Show symbols, route and mpls explicitly passes the actual config to the show function

Filter global values are not used directly from config

Config: Removed obsolete force_restart option when commiting

CLI keeps its active config pointer explicitly

Callback: bundling event with its target

BGP and HCU uncorking is processed in the right loop

closes #86

The uncork events are running from mainloop so these should just
dispatch the right event to the right loop. Doing anything long there
is bad for performance and latency as the uncork list may be huge.

Table: RCU synchronization moved to lfjour

the sync is actually needed when the pages get freed, not precisely
after every item cleanup, as the data technically stays intact until the
deferred free's are called.

Netindex cleanup calls synchronize_rcu() by batches

Table: fixed export_all flush when export_best is idle

Removed unnecessary recursion from rt_export_get()

Netindex rehash debug

TMP: table best-all cleanup debug

Memory allocator tweaking

TODO: make this configurable

Attributes: fix collision on free-lookup

Freeing the eattrs is tricky as somebody else may find them
via RTA-unlocked lookup inbetween.

Time accounting must be done by coarse timers

on some ARM, the precise timers are too slow to be actually useful

Every table has its own netindex now

It's obnoxiously slow to walk over sparse tables.

Netindex cleanup now doesn't need to unlock to synchronize RCU

Revert (partial) "Route attributes now use the common lockfree usecount"

This partially reverts commit d617801c31018926cccd75a64186ebb0597a6bcc.

The common lockfree doesn't work well for high-volume structures like
eattr cache because it expects the structure to be cleaned up by a
sweeper routine ... which is very ineffective for >1M records.

OTOH, we need the deferred ea_free in all cases ... so keeping that.

Table best feed collision fix

Dropped net_resolve_index from feeder fast path

Next hop update is split by time, not by number of routes

IO Loop: process socket reads only after timers and events are done

BGP: splitting TX by time, not number of messages sent

Table: pruning is deferred by task time, not by item count

Channel: postpone the export event when stopping

IO Threads: scheduler debug shows info on next loop to run

Threads: smoothening loop pickup and less aggressive dropping

IO loop picker fixed

Now if the thread finds out that it actually isn't busy,
it unsets the business status and picks something up right away.

Task-in-limit checker hacked for mainloop

Table: too fast export validity check replaced with just a retry

Thread IO: a little bit faster RX repeat

Netindex: fix absurd hash parameters

Converted ea cache to spinhash

Netindex: converted to spinlocked hash

Hash: Added a spinlocked variant

The spinlocked hash has a main rw spinlock for the data blocks
and then a rw spinlock for each hash chain. Rehashing is asynchronous,
running from an event, and it happens chain-wise, never blocking more
than one chain at a time.

Dropping netindex fragile manipulation

Now the netindex doesn't expose its internals and can be converted
to the spinlocked implementation much easier.

roa_check() uses the auxiliary table

ROA tables have now an auxiliary table

There is an IP table for every ROA table, holding special records
combining all known ROAs for every top-prefix.

The ROA digestor is now an IP digestor, running over the auxiliary
table.

Attributes: cleanup

Dropping EAF_TYPE__MAX and adding a check for forgotten
ea class registration

Threads shouldn't drop stopping loops

Loop scheduler tracing options configurable

Fixed nanoseconds in IO loop time limiter

Fixed deferred route freeing crash

The sending channel may be already gone when rte_free_deferred()
is finally called so we have to log about route freeing in the
synchronous call instead.

Fixed non-exporting protocol reload crash

Netindex: allow u32 -> netindex without locking

Proto: fix reimporter crash on shutdown

Channel transition to CS_STOP forgot to postpone the reimporter event,
thus reimport could theoretically run too late and cause trouble.

BGP: Dropping the netindex experiment, prefix hash is faster

RCU Unwinder can now retry without yielding

Read-write spinlocks

Netindex is now net-type specific

Combining all network types in one netindex was just a waste of memory
and too much complexity for no reason.

IO loop: fixed unassigned count

Table: Freeing routes deferred to save rcu synchronization

Route attributes now use the common lockfree usecount

Also route attributes are not freed immediately anymore.

Hash: dropped relics of hash iterators

Route attribute hash replaced with the generic one

Softened warning about too much time spent in loop

Now the warning needs at least 10 ms after the scheduled end time
to ever complain.

TODO: make this configurable

BGP: Freeing prefixes deferred to save rcu synchronization

Common parts of the ROA updater moved into the table

Channel is now just subscribing to yet another journal announcing
digested tries from the ROA table.

Creating tries in every channel on-the-fly was too slow to handle
and it ate obnoxious amounts of memory. Instead, the tries are
constructed directly in the table and the channels are notified
with the completed tries.

The delayed export-release mechanism is used to keep the tries allocated
until routes get reloaded.

Task deferrer: kinda more dumb-resistant macro

Originally, this mechanism required to check whether there's enough time to work
and then to send an event. This macro combines all the logic and goes more straightforwardly
to the _end_ of the export processing loop.

One should note that there were two cases where the export processing loop
was deferred at the _beginning_, which led to ignoring some routes on
reimports. This wasn't easily noticeable in the tests until the one-task
limit got a ceiling on 300 ms to keep reasonable latency.

Never allow more than 300 ms per loop

BGP: export table stores routes, reloads and shows in CLI.

In future, this and rtable's data structures should be probably merged
but it isn't a good idea to do now. The used data structure is similar
to rtable -- an array of pointers to linked lists.

Feed is lockless, as with all tables.

Full export (receiving updates) is not supported yet but we don't have
any method how to use it anyway. Gonna implement it later.

BGP: Prefix table uses a pointer array instead of hash

RCU: Rewritten to be more straightforward

Unit test for RCU

Netindex: consistency checks and deletion of whole hash

If debugging, store a malloc circular log for easier debugging

Hostentry: made src ea_list atomic to help with consistency

Slab: can be deleted as a single object

Export: Next feed step-up is now internal

There is no much reason to do anything else than the netindex technique.

BGP: Simpler hashing in export table

We need a hashing simple enough to allow for feeding by netindex.

BGP: Export uses common attribute cache

There is no real need for storing bucket attributes locally and we may
save some memory by caching the attributes in one central place.

If this becomes a contention problem, we should reduce the lock load
of the central attribute cache.

BGP: pending TX prefixes link netindex instead of copying net_addr

This helps with memory consumption, allows for removal of multiple
slab/mblock ifs and prepares for easier feeds.

BGP: refactored pending TX back into channel

Real almost-lockless feeds and more pull-like exports

Introducing a new omnipotent internal API to just pass route updates
from whatever point wherever we want.

From now on, all the exports should be processed by RT_WALK_EXPORTS
macro, and you can also issue a separate feed-only request to just get a
feed and finish.

The exporters can now also stop and the readers must expect that to
happen and recover. Main tables don't stop, though.

BGP: explicitly sending route refresh from CLI

Protocol filter reload is now done by 'reload filters'

This prepares for the separate 'reload bgp' command triggering BGP Route Refresh

Static: Fixed undefined nexthop padding problems

Netindex: fixed resolving net by index

RIP partial reload never worked properly, running full reload always

Dropping obsolete protocol Perf

We have now better methods how to measure overall performance
and this obsolete protocol has basically rotten away. If anybody
needs its features, feel free to revive it in future.

OSPF partial reload never worked properly, running full reload always

Simplified temporary resources

Also TMP_SAVED now uses the CLEANUP hook to allow for breaks and returns

SKIP_BACK_DECLARE: easier embedded-to-parent typecasting

Lockless feed of a single net

Using ea_lookup_tmp() for temporarily keeping attribute references

To avoid needs for keeping local temporary references for attributes,
now one can use ea_lookup_tmp() to ensure that the attributes are
valid and stored until the task ends. After that, the attributes are
automatically unref'd and also deallocated if needed.

Refactored the deferring framework into a separate structure

Avoiding RCU synchronization deadlock when locking in critical section

Explicitly marking domains eligible for RCU synchronization. It's then
forbidden to lock these domains in RCU critical section to avoid
possible deadlock.

RCU Unwinder refactored from route table to a separate structure

Table feeds are now lockless

This commit makes the route chains in the tables atomic. This allows not
only standard exports but also feeds and bulk exports to be processed
without ever locking the table.

Design note: the overall data structures are quite brittle. We're using
RCU read-locks to keep track about readers, and we're indicating ongoing
work on the data structures by prepending a REF_OBSOLETE sentinel node
to make every reader go waiting.

All the operations are intended to stay inside nest/rt-table.c and it
may be even best to further refactor the code to hide the routing table
internal structure inside there. Nobody shall definitely write any
routines manipulating live routes in tables from outside.

Fixed flush condition when stale cycle valid/set indicators wrap around

Kernel: replaced synchronous prune by a refeed

Lockless hostentry resolution

Now the hostentry doesn't need to lock table, instead it tracks the
hostentry version and retries if the hostentry changed while updating.

Cached route attributes now have explicitly marked layers

Also the rta_* functions renamed to ea_* functions

Netindex: Dropping tmp handle mechanism in favor of deferred lfuc_unlock