Fixed secondary route export

fixup! fixup! fixup! IO: Allow to take new loops if the thread is hot, but only one at time

fixup! fixup! IO: Allow to take new loops if the thread is hot, but only one at time

fixup! IO: Allow to take new loops if the thread is hot, but only one at time

fixup! fixup! show threads: displaying the same thread id's as in log

fixup! show threads: displaying the same thread id's as in log

show threads: displaying the same thread id's as in log

Export: Throw a warning instead of crashing on export_accepted_map inconsistency

fixup! fixup! BGP runs TX as a deferred routine

Config undo queuing bug fixed

fixup! BGP runs TX as a deferred routine

BGP runs TX as a deferred routine

This should help flushing the tx buffers as soon as possible.

fixup! Forbid locking altogether when RCU reader is active

Forbid locking altogether when RCU reader is active

Flush deferred calls directly after the loop finished its one run

IO: Allow to take new loops if the thread is hot, but only one at time

Even on shutdown we should try to pass the freed memory to others

Allocator now reports cold pages

Filter unit test uncertainty hack

Tame improper xmalloc warning

Merge commit 'b95dc8f29f18eb177f91fdc4bf0716fac9b15366' into mq-config-ref

Also converted all _Bool's to bool.

channel roa reload debug message

IO: allow for faster loop dropping

Revert "BGP: Export uses common attribute cache"

This reverts commit d01a7c2bdaf50aff23cf5e1b4e494328c5294960.

It seems that the performance penalty in global ea cache is actually
very high so returning back to local attribute caches in every BGP.

Fixed fast subsequent reconfigurations bug

Remove spinlock debug structures in production build

BGP: show proto info crash fix if BGP is down

BGP: using closer pointer for netindex hash than all the way to the table

Linpool: allocation split to fast and slow

ROA aggregator uses its own rte source instead of recycling

RCU read lock optimization

ROA: Switching off digestor splitting

Route attribute usecount doesn't need to synchronize on unlock

RPKI socket read is prioritized over other sockets

Refeed done hooks are called in the same order as the requests came in

Conflating multiple partial ROA reload requests together

Spinhash main lock removed

Spinhash now uses RCU instead to guard cur-new exchanges to avoid
excessive synchronization and cache misses on the main spinlock.

Moved the cork thresholds massively up

This allows for more efficient import and export bundling, including
best route export and next hop resolution.

Fixed a race condition in rcu-domain blocking

Safer cleanup of table auxiliary routines

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