mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-11-14 15:18:44 +00:00
Code Releases Activity
d9ed03394d
bird/lib/io-loop.h

89 lines
2.6 KiB
C
Raw Normal View History

Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
/*
* BIRD -- I/O and event loop
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_IO_LOOP_H_
#define _BIRD_IO_LOOP_H_
Displaced show threads command to its own file
2024-08-29 08:10:37 +00:00
extern struct birdloop main_birdloop;
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
#include "nest/bird.h"
#include "lib/lists.h"
#include "lib/locking.h"
#include "lib/resource.h"
Displaced show threads command to its own file
2024-08-29 08:10:37 +00:00
#include "lib/buffer.h"
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
#include "lib/event.h"
Displaced show threads command to its own file
2024-08-29 08:10:37 +00:00
#include "lib/timer.h"
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
#include "lib/socket.h"
IO Loop: provide information about current loop and task time limit
2024-04-03 10:05:02 +00:00
/* Currently running birdloop */
extern _Thread_local struct birdloop *this_birdloop;
Flush deferred calls directly after the loop finished its one run
2024-06-27 06:37:05 +00:00
/* Lowest entered birdloop */
extern _Thread_local struct birdloop *birdloop_current;
IO Loop: provide information about current loop and task time limit
2024-04-03 10:05:02 +00:00
/* Check that the task has enough time to do a bit more */
Merge commit 'b95dc8f29f18eb177f91fdc4bf0716fac9b15366' into mq-config-ref Also converted all _Bool's to bool.
2024-06-26 15:19:24 +00:00
bool task_still_in_limit(void);
bool task_before_halftime(void);
IO Loop: provide information about current loop and task time limit
2024-04-03 10:05:02 +00:00
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.
2024-06-03 09:12:20 +00:00
#define MAYBE_DEFER_TASK(target, event, fmt, args...) do { \
if (!task_still_in_limit()) { \
Global runtime values separated from config
2024-06-13 14:30:51 +00:00
if (atomic_load_explicit(&global_runtime, memory_order_relaxed)->latency_debug & DL_SCHEDULING) \
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.
2024-06-03 09:12:20 +00:00
log(L_TRACE "Deferring " fmt, ##args); \
return ev_send(target, event); \
} } while (0)
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
/* Start a new birdloop owned by given pool and domain */
Protocols and tables now use the birdloop pools as primary
2023-04-22 19:20:19 +00:00
struct birdloop *birdloop_new(pool *p, uint order, btime max_latency, const char *fmt, ...);
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
/* Stop the loop. At the end, the @stopped callback is called unlocked in tail
* position to finish cleanup. Run birdloop_free() from that callback to free
* the loop itself. */
void birdloop_stop(struct birdloop *loop, void (*stopped)(void *data), void *data);
void birdloop_stop_self(struct birdloop *loop, void (*stopped)(void *data), void *data);
void birdloop_free(struct birdloop *loop);
Flush deferred calls directly after the loop finished its one run
2024-06-27 06:37:05 +00:00
/* Run this event in the running loop's priority event list to run asap */
void ev_send_defer(event *e);
Allowing to send events to the metaloop's priority list
2024-04-05 12:11:38 +00:00
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
/* Get birdloop's time heap */
struct timeloop *birdloop_time_loop(struct birdloop *loop);
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.
2023-04-21 13:26:06 +00:00
#define birdloop_domain(l) (birdloop_time_loop((l))->domain)
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
Protocols and tables now use the birdloop pools as primary
2023-04-22 19:20:19 +00:00
/* Get birdloop's pool */
pool *birdloop_pool(struct birdloop *loop);
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
/* Enter and exit the birdloop */
void birdloop_enter(struct birdloop *loop);
void birdloop_leave(struct birdloop *loop);
Merge commit 'b95dc8f29f18eb177f91fdc4bf0716fac9b15366' into mq-config-ref Also converted all _Bool's to bool.
2024-06-26 15:19:24 +00:00
bool birdloop_inside(struct birdloop *loop);
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
void birdloop_mask_wakeups(struct birdloop *loop);
void birdloop_unmask_wakeups(struct birdloop *loop);
void birdloop_link(struct birdloop *loop);
void birdloop_unlink(struct birdloop *loop);
void birdloop_ping(struct birdloop *loop);
Sockets: Unified API for main and other loops Now sk_open() requires an explicit IO loop to open the socket in. Also specific functions for socket RX pause / resume are added to allow for BGP corking. And last but not least, socket reloop is now synchronous to resolve weird cases of the target loop stopping before actually picking up the relooped socket. Now the caller must ensure that both loops are locked while relooping, and this way all sockets always have their respective loop.
2023-04-02 17:15:22 +00:00
/* Setup sockets */
void birdloop_add_socket(struct birdloop *, struct birdsock *);
void birdloop_remove_socket(struct birdloop *, struct birdsock *);
Thread config has an explicit structure
2024-09-03 10:24:27 +00:00
/* Initializations */
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
void birdloop_init(void);
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
Thread config has an explicit structure
2024-09-03 10:24:27 +00:00
struct thread_config {
uint count;
};
void bird_thread_commit(struct thread_config *new);
Minimalist mainloop implementation
2024-09-10 09:25:59 +00:00
/* Minimalist main */
void birdloop_minimalist_main(void) NORET;
Thread config has an explicit structure
2024-09-03 10:24:27 +00:00
Converting the former BFD loop to a universal IO loop and protocol loop. There is a simple universal IO loop, taking care of events, timers and sockets. Primarily, one instance of a protocol should use exactly one IO loop to do all its work, as is now done in BFD. Contrary to previous versions, the loop is now launched and cleaned by the nest/proto.c code, allowing for a protocol to just request its own loop by setting the loop's lock order in config higher than the_bird. It is not supported nor checked if any protocol changed the requested lock order in reconfigure. No protocol should do it at all.
2021-06-19 18:50:18 +00:00
#endif /* _BIRD_IO_LOOP_H_ */
Copy Permalink