fixup! added a long commentary on how the roa autoreload works

added a long commentary on how the roa autoreload works

partial reload doc update

fixup! fixup! fixup! fixup! fixup! fixup! partial import seems working

fixup! fixup! fixup! fixup! fixup! partial import seems working

fixup! fixup! fixup! fixup! partial import seems working

fixup! fixup! fixup! partial import seems working

fixup! fixup! partial import seems working

fixup! partial import seems working

partial import seems working

not working

fixup! fixup! partial reload for RPKI - not working

fixup! partial reload for RPKI - not working

partial reload for RPKI - not working

fixup! fixup! fixup! Partial import reload looks working

fixup! fixup! Partial import reload looks working

fixup! Partial import reload looks working

Partial import reload looks working

Partial import reload looks working for cli

Partial import reload

fixup! Prefiltering routes by net and custom hook for partial reloads

fixup! Partial reloads of channels

Channel reload: don't reload if export is down

Partial reloads of channels

Now it's possible to reload only part of routes, e.g. when ROA has
changed.

Prefiltering routes by net and custom hook for partial reloads

Channel feeding request respects the subnet tries

Channel feeding request has a done-hook

BGP: Splitting Route Refresh and Enhanced Route Refresh toggles

Merge commit '93509af4' into HEAD

Table preexport net-filter refactoring

Also added a possibility for filtering by trie.

ROA notifications store the affected nets into trie

Channel: Refeeding by an auxiliary request if needed.

If the protocol supports route refresh on export, we keep the stop-start
method of route refeed. This applies for BGP with ERR or with export
table on, for OSPF, Babel, RIP or Pipe.

For BGP without ERR or for future selective ROA reloads, we're adding an
auxiliary export request, doing the refeed while the main export request
is running, somehow resembling the original method of BIRD 2 refeed.

There is also a refeed request queue to keep track of different refeed
requests.

Babel: Properly handle route refeed

RIP: Properly handle route refeed

Babel: Remove interfaces on shutdown

This avoids calling interface timer between Babel going
PS_DOWN and finally cleaning up the resource pool.

Kernel: refeed routes and delete them from kernel before actual shutdown

Protocols have now assigned startup phases

For now, there are 4 phases: Necessary (device), Connector (kernel, pipe), Generator (static, rpki) and Regular.
Started and reconfigured are from Necessary to Regular, shutdown backwards.

This way, kernel can flush routes before actually being shutdown.

Iface: trace log messages cleanup

Table: Added some journal and export tracing

Table: Fixed feed race condition

The problem happened like this:

1. Single route for the given net in table
2. A feed is started
3. The route is deleted (from another thread)
4. The feed finds an empty net, exports nothing, ignores journal (here is bug)
5. The route is added
6. The export transitions from FEEDING to READY
7. While processing the journal, the route deletion and addition combines into noop.

This way routes mysteriously disappeared in specific cases of link instability.

Problem fixed by explicitly marking the empty-net journal entries as processed in step 4.

Export: More strict export state checking on change

Properly consted routes inside table

Filter iterator accepts lines instead of filter

Renamed channel class pointers

The channel class pointers were strangely named , not .

Logging: fixed size logfiles behaving as mmapped ringbuffers

This variant of logging avoids calling write() for every log line,
allowing for waitless logging. This makes heavy logging less heavy
and more useful for race condition debugging.

Logging limit enforcement moved into the rfile structure

Logging now doesn't lock with each message

The original logging routines were locking a common mutex. This led to
massive underperformance and unwanted serialization when heavily logging
due to lock contention. Now the logging is lockless, though still
serializing on write() syscalls to the same filedescriptor.

This change also brings in a persistent logging channel structures and
thus avoids writing into active configuration data structures during
regular run.

Threads: added a generic method to run in all threads

Logging: Abolished stdio in favor of write() to make the logging faster.

CLI: Dropping the mechanism of echoing log messages

This is better done by running tail -f on a logfile.

BGP: When debug { routes } is set, updates considered as loop are logged

Enhanced tracing of route refresh state

Hostentry application locking

Due to a race condition between rta_apply_hostentry() and rt_update_hostentry(),
happening when a new route is inserted to a table, this commit makes it mandatory
to lock the next hop resolution table while resolving the next hop.

This may be slow, we'll fix it better in some future release

Config obstacles are lockless now

BFD: Fixed reconfiguration issues

After converting BFD to the new IO loop system, reconfiguration never
really worked. Sadly, we missed this case in our testing suite so it
passed under the radar for quite a while.

Thanks to Andrei Dinu <andrei.dinu@digitalit.ro> for reporting and
isolating this issue.

Fixed abort when running in foreground but stdin is closed

A forgotten else-clause caused BIRD to treat some pseudo-random place in
memory as fd-pair. This was happening only on startup of the first
thread in group and the value there in memory was typically zero ... and
writing to stdin succeeded.

When running BIRD with stdin not present (like systemd does), it died on
this spurious write. Now it seems to work correctly.

Thanks to Daniel Suchy <danny@danysek.cz> for reporting.

http://trubka.network.cz/pipermail/bird-users/2023-May/016929.html

NEWS and version update

Fix use-after free in thread stopping code

BGP: fix listen socket cleanup

ID Maps are checking whether their pool is locked

Properly protecting the route src global index by RCU read lock and atomic operations

There was a bug occuring when one thread sought for a src by its global id
and another one was allocating another src with such an ID that it caused
route src global index reallocation. This brief moment of inconsistency
led to a rare use-after-free of the old global index block.

Threads take loops faster

Channel: configurable feed block size

BGP: proactively rehash prefix hash up to shorten collision lists

OLocks in BGP must be freed early

IO Loop / Thread Groups Lock moved to level -attrs- to allow for page allocation while locked

Fixed loop movement to not collide on LTT_MOVE

Fix loop dropping routines

Fixed a bug in hot page global storage

The original algorithm was suffering from an ABA race condition:

A: fp = page_stack
B: completely allocates the same page and writes into it some data
A: unsuspecting, loads (invalid) next = fp->next
B: finishes working with the page and returns it back to page_stack
A: compare-exchange page_stack: fp => next succeeds and writes garbage
to page_stack

Fixed this by using an implicit spinlock in hot page allocator.

Debug: keep a circular log of memory page operations

Fixed cold page cache leak

The empty_pages pointer wasn't being propagated into the ->next pointer
when more empty_pages were to be stored

Hostentry: fix pool locking

Linpool state save and restore refactoring

Debug: Explicit mprotect() on freed pages to better locate use-after-free bugs

Page allocator: indentation of messy ifdef blocks

First try of loop balancing

If a thread encounters timeout == 0 for poll, it considers itself
"busy" and with some hysteresis it tries to drop loops for others to
pick and thus better distribute work between threads.

Allocation from linpools and slabs requires the appropriate lock to be taken

Linpool flushes unused pages even on lp_restore()

Fixed race condition in hostentry allocation

Show threads: Fixed problems with CLI buffer reallocation

... by allocating all the output locally and then sending it out at
once.

Explicitly counting loops and threads

Loop spent time refactored to separate structures and functions

Loops track also locking time

IO loops now actually measuring their time (show threads all works)

Refactoring of domains connected to pools

Fix of failing show threads command

Merge commit 'd61505b039bf0aa6697e28b2a4e07907c89ba1fb' into thread-next

Merge branch 'mq-resource-locking' into thread-next

Removed duplicate version 3.0-alpha0 news

Resource pools are now bound with domains.

Memory allocation is a fragile part of BIRD and we need checking that
everybody is using the resource pools in an appropriate way. To assure
this, all the resource pools are associated with locking domains and
every resource manipulation is thoroughly checked whether the
appropriate locking domain is locked.

With transitive resource manipulation like resource dumping or mass free
operations, domains are locked and unlocked on the go, thus we require
pool domains to have higher order than their parent to allow for this
transitive operations.

Adding pool locking revealed some cases of insecure memory manipulation
and this commit fixes that as well.

Protocols and tables now use the birdloop pools as primary

Resource pool closing has its dedicated function

Socket closing has its dedicated function

Global protocol list is typed to avoid typecast confusion

Typed lists: added add_after() and unit tests

Alpha0 news added

BSD: IPv4 over IPv6 nexthop support on FreeBSD

The support for IPv4 routes with IPv6 nexthops was implemented in FreeBSD
13.1, this patch allows to import and export such routes from/to kernel.

Minor change from committer.

Linpool: Fix lp_restore()

When lp_save() is called on an empty linpool, then some allocation is
done, then lp_restore() is called, the linpool is restored but the used
chunks are inaccessible. Fix it.

Typed lists keep an explicit pointer to the list head.

This change adds one pointer worth of memory to every list node.
Keeping this information helps auditing the lists, checking that the
node indeed is outside of list or inside the right one.

The typed lists shouldn't be used anywhere with memory pressure anyway,
thus the one added pointer isn't significant.

Updated the version number to not include dash (breaks RPM)