Merge commit '280daed5' into thread-merge-2.16

Merge commit 'bc10975a' into thread-merge-2.16

Merge commit '08571b20' into thread-merge-2.16

Netlink: Fixed handling of undefined bitfields in filters

The default value is obviously false everywhere so we just return zero
if nothing is found, instead of undef.

Filter: multi-command case branches now need braces.

Removing an exception from the otherwise quite systematic syntax.
Closes #111.

rt-show.c: fixed OBSREF_SET after cf_error(), changed message when 'show route export' called on static protocol

Protocol restart timer reworked.

The restart timer was racy and didn't allow for immediate restarts
from limits. Now the protocols stores the last restart time and in case
of too frequent autorestarts caused by exceeded limits, the protocol
gets disabled with an error message.

Also now there is a configuration knob for this.

Hash test spurious fail fixed

There was a race condition in the test itself,
causing the test reader access data after free.

Protocol and BGP state information cleanup and fixes

There were some nasty problems with deferred protocol state updates and
race conditions on BGP startup, shutdown, and also with referencing the
cached states.

Now it looks fixed.

Debug option for ea_free

Deferred call may need to be returned for future cleanups

BMP: updated to v3 API

BGP: protocol specific state information cleanup

Proto: The active flag converted to actual fifth protocol state

What was PS_DOWN before, is now PS_DOWN and PS_FLUSH.

Neighbor locking: forgotten neighbors to unlink are actually a bug.

These may cause runaway pointers.

nest/cli: fixup - empty printing in birdc does not freeze

MRT: buildable and running again for BIRD 3

Tests for MRT are scarce and not automated for now, so it may behave
weirdly in corner cases.

Neighbor cache: fixed neighbor referencing

Defer: fixup missing include guards

BGP: exporting protocol-specific state information

BGP: Start state is now using extended state

Proto: adding lockless state table and journal

To allow reading of protocol states from other protocols or completely
different routines, we have to export these states to data structures
not requiring to lock the protocol loops.

On one hand, this doesn't give the reader the actual state "right now",
on the other hand, getting that is impossible in a properly
multithreaded environment and you will always get the information with
some (little but noteworthy) delay.

This implementation handles only the basic state information of the
protocols, common for all the protocols. Adding protocol-specific state
information should be done by implementing the protocol hook init_state().

Channel information is stored but not announced, as we don't need the
announcements for now.

More attribute types: pointers, strings, btime

For the upcoming rework of protocol state information propagation,
we need some more eattr types to be defined.

These types are probably not defined completely and before using
them for route attributes, you should check that they don't lack
some crucial methods.

Table: tame warnings around unused debug messages

Kernel: protocol shuts down synchronously

Before this commit, on kernel shutdown, the routes were re-exported by
the regular export but treated as withdraw. This was too hairy and
caused unnecessary complexity of the protocol's state machine.

Instead of that, we found out that it makes more sense to just refeed
the routes synchronously and convert to withdraw. This is done by the
direct export access instead of the channel.

It would (maybe) make more sense to run export filters on this in case
the export filter updates the krt_metric attribute, but as this doesn't
work on regular withdraw anyway, it's better for now to just let it be
and maybe somebody in the future fixes this issue.

NEWS and version update

Fixed secondary route export

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

Export: Throw a warning instead of crashing on export_accepted_map inconsistency

Config undo queuing bug fixed

BGP runs TX as a deferred routine

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

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