Let's find a better name for it.
Signed-off-by: Donald Sharp <sharpd@nvidia.com>
static void babel_save_state_file(void);
-struct event_master *master; /* quagga's threads handler */
+struct event_loop *master; /* quagga's threads handler */
struct timeval babel_now; /* current time */
unsigned char myid[8]; /* unique id (mac address of an interface) */
#include "vty.h"
extern struct timeval babel_now; /* current time */
-extern struct event_master *master; /* quagga's threads handler */
+extern struct event_loop *master; /* quagga's threads handler */
extern int debug;
extern int resend_delay;
unsigned long bfd_get_session_count(void);
/* Export callback functions for `event.c`. */
-extern struct event_master *master;
+extern struct event_loop *master;
void bfd_recvtimer_cb(struct event *t);
void bfd_echo_recvtimer_cb(struct event *t);
DEFINE_MTYPE(BFDD, BFDD_NOTIFICATION, "short-lived control notification data");
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/* BFDd privileges */
static zebra_capabilities_t _caps_p[] = {ZCAP_BIND, ZCAP_SYS_ADMIN, ZCAP_NET_RAW};
}
#endif /* HAVE_BFDD */
-void bgp_bfd_init(struct event_master *tm)
+void bgp_bfd_init(struct event_loop *tm)
{
/* Initialize BFD client functions */
bfd_protocol_integration_init(zclient, tm);
((((peer)->sort == BGP_PEER_IBGP) && !(peer)->shared_network) \
|| is_ebgp_multihop_configured((peer)))
-extern void bgp_bfd_init(struct event_master *tm);
+extern void bgp_bfd_init(struct event_loop *tm);
extern void bgp_bfd_peer_config_write(struct vty *vty, const struct peer *peer,
const char *addr);
return 0;
}
-static int bgp_bmp_init(struct event_master *tm)
+static int bgp_bmp_init(struct event_loop *tm)
{
install_node(&bmp_node);
install_default(BMP_NODE);
XFREE(MTYPE_BGP_LABEL_CHUNK, goner);
}
-void bgp_lp_init(struct event_master *master, struct labelpool *pool)
+void bgp_lp_init(struct event_loop *master, struct labelpool *pool)
{
if (BGP_DEBUG(labelpool, LABELPOOL))
zlog_debug("%s: entry", __func__);
uint32_t next_chunksize; /* request this many labels */
};
-extern void bgp_lp_init(struct event_master *master, struct labelpool *pool);
+extern void bgp_lp_init(struct event_loop *master, struct labelpool *pool);
extern void bgp_lp_finish(void);
extern void bgp_lp_get(int type, void *labelid,
int (*cbfunc)(mpls_label_t label, void *labelid, bool allocated));
}
-static int bgp_rpki_init(struct event_master *master)
+static int bgp_rpki_init(struct event_loop *master)
{
rpki_debug = false;
rtr_is_running = false;
#include "bgpd/bgp_snmp_bgp4v2.h"
#include "bgpd/bgp_mplsvpn_snmp.h"
-static int bgp_snmp_init(struct event_master *tm)
+static int bgp_snmp_init(struct event_loop *tm)
{
smux_init(tm);
bgp_snmp_bgp4_init(tm);
return 0;
}
-int bgp_snmp_bgp4_init(struct event_master *tm)
+int bgp_snmp_bgp4_init(struct event_loop *tm)
{
REGISTER_MIB("mibII/bgp", bgp_variables, variable, bgp_oid);
return 0;
extern int bgpTrapEstablished(struct peer *peer);
extern int bgpTrapBackwardTransition(struct peer *peer);
-extern int bgp_snmp_bgp4_init(struct event_master *tm);
+extern int bgp_snmp_bgp4_init(struct event_loop *tm);
#endif /* _FRR_BGP_SNMP_BGP4_H_ */
{1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 2, 16}},
};
-int bgp_snmp_bgp4v2_init(struct event_master *tm)
+int bgp_snmp_bgp4v2_init(struct event_loop *tm)
{
REGISTER_MIB("mibII/bgpv2", bgpv2_variables, variable, bgpv2_oid);
return 0;
#define BGP4V2_ESTABLISHED_NOTIFICATION 1
#define BGP4V2_BACKWARD_TRANSITION_NOTIFICATION 2
-extern int bgp_snmp_bgp4v2_init(struct event_master *tm);
+extern int bgp_snmp_bgp4v2_init(struct event_loop *tm);
#endif /* _FRR_BGP_SNMP_BGP4V2_H_ */
hook_register_prio(if_del, 0, bgp_if_delete_hook);
}
-void bgp_zebra_init(struct event_master *master, unsigned short instance)
+void bgp_zebra_init(struct event_loop *master, unsigned short instance)
{
zclient_num_connects = 0;
/* Default weight for next hop, if doing weighted ECMP. */
#define BGP_ZEBRA_DEFAULT_NHOP_WEIGHT 1
-extern void bgp_zebra_init(struct event_master *master,
- unsigned short instance);
+extern void bgp_zebra_init(struct event_loop *master, unsigned short instance);
extern void bgp_if_init(void);
extern void bgp_zebra_init_tm_connect(struct bgp *bgp);
extern uint32_t bgp_zebra_tm_get_id(void);
return buf;
}
-void bgp_master_init(struct event_master *master, const int buffer_size,
+void bgp_master_init(struct event_loop *master, const int buffer_size,
struct list *addresses)
{
qobj_init();
struct list *bgp;
/* BGP thread master. */
- struct event_master *master;
+ struct event_loop *master;
/* Listening sockets */
struct list *listen_sockets;
extern int bgp_config_write(struct vty *);
-extern void bgp_master_init(struct event_master *master, const int buffer_size,
+extern void bgp_master_init(struct event_loop *master, const int buffer_size,
struct list *addresses);
extern void bgp_init(unsigned short instance);
* return value:
* rfp_start_val rfp returned value passed on rfp_stop and other rfapi calls
--------------------------------------------*/
-extern void *rfp_start(struct event_master *master, struct rfapi_rfp_cfg **cfgp,
+extern void *rfp_start(struct event_loop *master, struct rfapi_rfp_cfg **cfgp,
struct rfapi_rfp_cb_methods **cbmp);
/*------------------------------------------
#include "bgpd/bgp_nexthop.h"
extern void rfapi_init(void);
-extern void vnc_zebra_init(struct event_master *master);
+extern void vnc_zebra_init(struct event_loop *master);
extern void vnc_zebra_destroy(void);
extern void rfapi_delete(struct bgp *);
* Modeled after bgp_zebra.c'bgp_zebra_init()
* Charriere asks, "Is it possible to carry two?"
*/
-void vnc_zebra_init(struct event_master *master)
+void vnc_zebra_init(struct event_loop *master)
{
/* Set default values. */
zclient_vnc = zclient_new(master, &zclient_options_default,
struct rfp_instance_t {
struct rfapi_rfp_cfg rfapi_config;
struct rfapi_rfp_cb_methods rfapi_callbacks;
- struct event_master *master;
+ struct event_loop *master;
uint32_t config_var;
};
* rfp_start_val rfp returned value passed on rfp_stop and rfp_cfg_write
*
--------------------------------------------*/
-void *rfp_start(struct event_master *master, struct rfapi_rfp_cfg **cfgp,
+void *rfp_start(struct event_loop *master, struct rfapi_rfp_cfg **cfgp,
struct rfapi_rfp_cb_methods **cbmp)
{
memset(&global_rfi, 0, sizeof(global_rfi));
#include "libfrr.h"
#include "event.h"
- static int module_late_init(struct event_master *master)
+ static int module_late_init(struct event_loop *master)
{
/* Do initialization stuff here */
return 0;
interplay between the event system and kernel threads.
The core event system is implemented in :file:`lib/thread.[ch]`. The primary
-structure is ``struct event_master``, hereafter referred to as a
+structure is ``struct event_loop``, hereafter referred to as a
``threadmaster``. A ``threadmaster`` is a global state object, or context, that
holds all the tasks currently pending execution as well as statistics on tasks
that have already executed. The event system is driven by adding tasks to this
::
- event_add_read(struct event_master *master, int (*handler)(struct event *), void *arg, int fd, struct event **ref);
+ event_add_read(struct event_loop *master, int (*handler)(struct event *), void *arg, int fd, struct event **ref);
The ``struct event`` is then created and added to the appropriate internal
datastructure within the ``threadmaster``. Note that the ``READ`` and
struct option longopts[] = {{0}};
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/* Forward declaration of daemon info structure. */
static struct frr_daemon_info eigrpd_di;
struct zclient *zclient = NULL;
/* For registering threads. */
-extern struct event_master *master;
+extern struct event_loop *master;
struct in_addr router_id_zebra;
/* Router-id update message from zebra. */
struct list *eigrp;
/* EIGRP thread master. */
- struct event_master *master;
+ struct event_loop *master;
/* Zebra interface list. */
struct list *iflist;
/* Extern variables. */
extern struct zclient *zclient;
-extern struct event_master *master;
+extern struct event_loop *master;
extern struct eigrp_master *eigrp_om;
extern struct zebra_privs_t eigrpd_privs;
return 0;
}
-void isis_bfd_init(struct event_master *tm)
+void isis_bfd_init(struct event_loop *tm)
{
bfd_protocol_integration_init(zclient, tm);
#define ISIS_BFD_H
struct isis_circuit;
-struct event_master;
+struct event_loop;
void isis_bfd_circuit_cmd(struct isis_circuit *circuit);
-void isis_bfd_init(struct event_master *tm);
+void isis_bfd_init(struct event_loop *tm);
#endif
{0}};
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/*
* Prototypes.
/* Register ISIS-MIB. */
-static int isis_snmp_init(struct event_master *tm)
+static int isis_snmp_init(struct event_loop *tm)
{
struct isis_func_to_prefix *h2f = isis_func_to_prefix_arr;
struct variable *v;
[ZEBRA_CLIENT_CLOSE_NOTIFY] = isis_zebra_client_close_notify,
};
-void isis_zebra_init(struct event_master *master, int instance)
+void isis_zebra_init(struct event_loop *master, int instance)
{
/* Initialize asynchronous zclient. */
zclient = zclient_new(master, &zclient_options_default, isis_handlers,
};
#define CHUNK_SIZE 64
-void isis_zebra_init(struct event_master *master, int instance);
+void isis_zebra_init(struct event_loop *master, int instance);
void isis_zebra_stop(void);
struct isis_route_info;
return NULL;
}
-void isis_master_init(struct event_master *master)
+void isis_master_init(struct event_loop *master)
{
memset(&isis_master, 0, sizeof(isis_master));
im = &isis_master;
/* ISIS instance. */
struct list *isis;
/* ISIS thread master. */
- struct event_master *master;
+ struct event_loop *master;
uint8_t options;
};
#define F_ISIS_UNIT_TEST 0x01
DECLARE_HOOK(isis_area_overload_bit_update, (struct isis_area * area), (area));
void isis_terminate(void);
-void isis_master_init(struct event_master *master);
+void isis_master_init(struct event_loop *master);
void isis_vrf_link(struct isis *isis, struct vrf *vrf);
void isis_vrf_unlink(struct isis *isis, struct vrf *vrf);
struct isis *isis_lookup_by_vrfid(vrf_id_t vrf_id);
#define ISIS_SR "/frr-isisd:isis/instance/segment-routing"
/* Master of threads. */
-extern struct event_master *master;
+extern struct event_loop *master;
extern unsigned long debug_adj_pkt;
extern unsigned long debug_snp_pkt;
return 0;
}
-static int ldp_snmp_init(struct event_master *tm)
+static int ldp_snmp_init(struct event_loop *tm)
{
hook_register(agentx_enabled, ldp_snmp_agentx_enabled);
return 0;
}
-static int ldp_snmp_register_mib(struct event_master *tm)
+static int ldp_snmp_register_mib(struct event_loop *tm)
{
static int registered = 0;
[ZEBRA_OPAQUE_MESSAGE] = ldp_zebra_opaque_msg_handler,
};
-void ldp_zebra_init(struct event_master *master)
+void ldp_zebra_init(struct event_loop *master)
{
if_zapi_callbacks(ldp_ifp_create, ldp_ifp_up,
ldp_ifp_down, ldp_ifp_destroy);
static struct frr_daemon_info ldpd_di;
-DEFINE_HOOK(ldp_register_mib, (struct event_master * tm), (tm));
+DEFINE_HOOK(ldp_register_mib, (struct event_loop * tm), (tm));
static void ldp_load_module(const char *name)
{
#define LDP_VTY_PORT 2612
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/* ldpd privileges */
static zebra_capabilities_t _caps_p [] =
const char *pw_error_code(uint8_t);
/* quagga */
-extern struct event_master *master;
+extern struct event_loop *master;
extern char ctl_sock_path[MAXPATHLEN];
/* ldp_zebra.c */
-void ldp_zebra_init(struct event_master *m);
+void ldp_zebra_init(struct event_loop *m);
void ldp_zebra_destroy(void);
int ldp_sync_zebra_send_state_update(struct ldp_igp_sync_if_state *);
int ldp_zebra_send_rlfa_labels(struct zapi_rlfa_response *
(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_INTFACELOCAL))
#endif
-DECLARE_HOOK(ldp_register_mib, (struct event_master * tm), (tm));
+DECLARE_HOOK(ldp_register_mib, (struct event_loop * tm), (tm));
extern void ldp_agentx_enabled(void);
static bool agentx_enabled = false;
-static struct event_master *agentx_tm;
+static struct event_loop *agentx_tm;
static struct event *timeout_thr = NULL;
static struct list *events = NULL;
return agentx_enabled;
}
-void smux_init(struct event_master *tm)
+void smux_init(struct event_loop *tm)
{
agentx_tm = tm;
struct bfd_source_list source_list;
/** Pointer to FRR's event manager. */
- struct event_master *tm;
+ struct event_loop *tm;
/** Pointer to zebra client data structure. */
struct zclient *zc;
return 0;
}
-void bfd_protocol_integration_init(struct zclient *zc, struct event_master *tm)
+void bfd_protocol_integration_init(struct zclient *zc, struct event_loop *tm)
{
/* Initialize data structure. */
TAILQ_INIT(&bsglobal.bsplist);
* Initializes the BFD integration library. This function executes the
* following actions:
*
- * - Copy the `struct event_master` pointer to use as "thread" to execute
+ * - Copy the `struct event_loop` pointer to use as "thread" to execute
* the BFD session parameters installation.
* - Copy the `struct zclient` pointer to install its callbacks.
* - Initializes internal data structures.
* \param tm normally the daemon main thread event manager.
* \param zc the zebra client of the daemon.
*/
-void bfd_protocol_integration_init(struct zclient *zc, struct event_master *tm);
+void bfd_protocol_integration_init(struct zclient *zc, struct event_loop *tm);
/**
* BFD session registration arguments.
static pthread_mutex_t masters_mtx = PTHREAD_MUTEX_INITIALIZER;
static struct list *masters;
-static void thread_free(struct event_master *master, struct event *thread);
+static void thread_free(struct event_loop *master, struct event *thread);
#ifndef EXCLUDE_CPU_TIME
#define EXCLUDE_CPU_TIME 0
{
struct cpu_event_history tmp;
void *args[3] = {&tmp, vty, &filter};
- struct event_master *m;
+ struct event_loop *m;
struct listnode *ln;
if (!cputime_enabled)
static void cpu_record_clear(uint8_t filter)
{
uint8_t *tmp = &filter;
- struct event_master *m;
+ struct event_loop *m;
struct listnode *ln;
frr_with_mutex (&masters_mtx) {
"Set up miscellaneous service\n"
"Warn for tasks exceeding total wallclock threshold\n")
-static void show_thread_poll_helper(struct vty *vty, struct event_master *m)
+static void show_thread_poll_helper(struct vty *vty, struct event_loop *m)
{
const char *name = m->name ? m->name : "main";
char underline[strlen(name) + 1];
"Show poll FD's and information\n")
{
struct listnode *node;
- struct event_master *m;
+ struct event_loop *m;
frr_with_mutex (&masters_mtx) {
for (ALL_LIST_ELEMENTS_RO(masters, node, m)) {
return CMD_SUCCESS;
}
-static void show_thread_timers_helper(struct vty *vty, struct event_master *m)
+static void show_thread_timers_helper(struct vty *vty, struct event_loop *m)
{
const char *name = m->name ? m->name : "main";
char underline[strlen(name) + 1];
"Show all timers and how long they have in the system\n")
{
struct listnode *node;
- struct event_master *m;
+ struct event_loop *m;
frr_with_mutex (&masters_mtx) {
for (ALL_LIST_ELEMENTS_RO(masters, node, m))
pthread_key_create(&thread_current, NULL);
}
-struct event_master *event_master_create(const char *name)
+struct event_loop *event_master_create(const char *name)
{
- struct event_master *rv;
+ struct event_loop *rv;
struct rlimit limit;
pthread_once(&init_once, &initializer);
- rv = XCALLOC(MTYPE_EVENT_MASTER, sizeof(struct event_master));
+ rv = XCALLOC(MTYPE_EVENT_MASTER, sizeof(struct event_loop));
/* Initialize master mutex */
pthread_mutex_init(&rv->mtx, NULL);
return rv;
}
-void event_master_set_name(struct event_master *master, const char *name)
+void event_master_set_name(struct event_loop *master, const char *name)
{
frr_with_mutex (&master->mtx) {
XFREE(MTYPE_EVENT_MASTER, master->name);
#define EVENT_UNUSED_DEPTH 10
/* Move thread to unuse list. */
-static void thread_add_unuse(struct event_master *m, struct event *thread)
+static void thread_add_unuse(struct event_loop *m, struct event *thread)
{
pthread_mutex_t mtxc = thread->mtx;
}
/* Free all unused thread. */
-static void thread_list_free(struct event_master *m,
- struct event_list_head *list)
+static void thread_list_free(struct event_loop *m, struct event_list_head *list)
{
struct event *t;
thread_free(m, t);
}
-static void thread_array_free(struct event_master *m,
- struct event **thread_array)
+static void thread_array_free(struct event_loop *m, struct event **thread_array)
{
struct event *t;
int index;
* If we are shutting down, Free up unused threads
* So we can see if we forget to shut anything off
*/
-void event_master_free_unused(struct event_master *m)
+void event_master_free_unused(struct event_loop *m)
{
frr_with_mutex (&m->mtx) {
struct event *t;
}
/* Stop thread scheduler. */
-void event_master_free(struct event_master *m)
+void event_master_free(struct event_loop *m)
{
struct event *t;
}
/* Get new thread. */
-static struct event *thread_get(struct event_master *m, uint8_t type,
+static struct event *thread_get(struct event_loop *m, uint8_t type,
void (*func)(struct event *), void *arg,
const struct xref_eventsched *xref)
{
return thread;
}
-static void thread_free(struct event_master *master, struct event *thread)
+static void thread_free(struct event_loop *master, struct event *thread)
{
/* Update statistics. */
assert(master->alloc > 0);
XFREE(MTYPE_THREAD, thread);
}
-static int fd_poll(struct event_master *m, const struct timeval *timer_wait,
+static int fd_poll(struct event_loop *m, const struct timeval *timer_wait,
bool *eintr_p)
{
sigset_t origsigs;
/* Add new read thread. */
void _event_add_read_write(const struct xref_eventsched *xref,
- struct event_master *m, void (*func)(struct event *),
+ struct event_loop *m, void (*func)(struct event *),
void *arg, int fd, struct event **t_ptr)
{
int dir = xref->event_type;
}
static void _event_add_timer_timeval(const struct xref_eventsched *xref,
- struct event_master *m,
+ struct event_loop *m,
void (*func)(struct event *), void *arg,
struct timeval *time_relative,
struct event **t_ptr)
/* Add timer event thread. */
-void _event_add_timer(const struct xref_eventsched *xref,
- struct event_master *m, void (*func)(struct event *),
- void *arg, long timer, struct event **t_ptr)
+void _event_add_timer(const struct xref_eventsched *xref, struct event_loop *m,
+ void (*func)(struct event *), void *arg, long timer,
+ struct event **t_ptr)
{
struct timeval trel;
/* Add timer event thread with "millisecond" resolution */
void _event_add_timer_msec(const struct xref_eventsched *xref,
- struct event_master *m, void (*func)(struct event *),
+ struct event_loop *m, void (*func)(struct event *),
void *arg, long timer, struct event **t_ptr)
{
struct timeval trel;
/* Add timer event thread with "timeval" resolution */
void _event_add_timer_tv(const struct xref_eventsched *xref,
- struct event_master *m, void (*func)(struct event *),
+ struct event_loop *m, void (*func)(struct event *),
void *arg, struct timeval *tv, struct event **t_ptr)
{
_event_add_timer_timeval(xref, m, func, arg, tv, t_ptr);
}
/* Add simple event thread. */
-void _event_add_event(const struct xref_eventsched *xref,
- struct event_master *m, void (*func)(struct event *),
- void *arg, int val, struct event **t_ptr)
+void _event_add_event(const struct xref_eventsched *xref, struct event_loop *m,
+ void (*func)(struct event *), void *arg, int val,
+ struct event **t_ptr)
{
struct event *thread = NULL;
* - POLLIN
* - POLLOUT
*/
-static void event_cancel_rw(struct event_master *master, int fd, short state,
+static void event_cancel_rw(struct event_loop *master, int fd, short state,
int idx_hint)
{
bool found = false;
* Process task cancellation given a task argument: iterate through the
* various lists of tasks, looking for any that match the argument.
*/
-static void cancel_arg_helper(struct event_master *master,
+static void cancel_arg_helper(struct event_loop *master,
const struct cancel_req *cr)
{
struct event *t;
* @param master the thread master to process
* @REQUIRE master->mtx
*/
-static void do_event_cancel(struct event_master *master)
+static void do_event_cancel(struct event_loop *master)
{
struct event_list_head *list = NULL;
struct event **thread_array = NULL;
/*
* Helper function used for multiple flavors of arg-based cancellation.
*/
-static void cancel_event_helper(struct event_master *m, void *arg, int flags)
+static void cancel_event_helper(struct event_loop *m, void *arg, int flags)
{
struct cancel_req *cr;
* @param m the event_master to cancel from
* @param arg the argument passed when creating the event
*/
-void event_cancel_event(struct event_master *master, void *arg)
+void event_cancel_event(struct event_loop *master, void *arg)
{
cancel_event_helper(master, arg, 0);
}
* @param m the event_master to cancel from
* @param arg the argument passed when creating the event
*/
-void event_cancel_event_ready(struct event_master *m, void *arg)
+void event_cancel_event_ready(struct event_loop *m, void *arg)
{
/* Only cancel ready/event tasks */
*/
void event_cancel(struct event **thread)
{
- struct event_master *master;
+ struct event_loop *master;
if (thread == NULL || *thread == NULL)
return;
* @param thread pointer to thread to cancel
* @param eventobj the event
*/
-void event_cancel_async(struct event_master *master, struct event **thread,
+void event_cancel_async(struct event_loop *master, struct event **thread,
void *eventobj)
{
assert(!(thread && eventobj) && (thread || eventobj));
return timer_val;
}
-static struct event *thread_run(struct event_master *m, struct event *thread,
+static struct event *thread_run(struct event_loop *m, struct event *thread,
struct event *fetch)
{
*fetch = *thread;
return fetch;
}
-static int thread_process_io_helper(struct event_master *m,
- struct event *thread, short state,
- short actual_state, int pos)
+static int thread_process_io_helper(struct event_loop *m, struct event *thread,
+ short state, short actual_state, int pos)
{
struct event **thread_array;
* @param m the thread master
* @param num the number of active file descriptors (return value of poll())
*/
-static void thread_process_io(struct event_master *m, unsigned int num)
+static void thread_process_io(struct event_loop *m, unsigned int num)
{
unsigned int ready = 0;
struct pollfd *pfds = m->handler.copy;
}
/* Add all timers that have popped to the ready list. */
-static unsigned int thread_process_timers(struct event_master *m,
+static unsigned int thread_process_timers(struct event_loop *m,
struct timeval *timenow)
{
struct timeval prev = *timenow;
/* Fetch next ready thread. */
-struct event *event_fetch(struct event_master *m, struct event *fetch)
+struct event *event_fetch(struct event_loop *m, struct event *fetch)
{
struct event *thread = NULL;
struct timeval now;
}
/* Execute thread */
-void _event_execute(const struct xref_eventsched *xref, struct event_master *m,
+void _event_execute(const struct xref_eventsched *xref, struct event_loop *m,
void (*func)(struct event *), void *arg, int val)
{
struct event *thread;
};
/* Master of the theads. */
-struct event_master {
+struct event_loop {
char *name;
struct event **read;
struct event_list_item eventitem;
struct event_timer_list_item timeritem;
struct event **ref; /* external reference (if given) */
- struct event_master *master; /* pointer to the struct event_master */
+ struct event_loop *master; /* pointer to the struct event_loop */
void (*func)(struct event *); /* event function */
void *arg; /* event argument */
union {
}) /* end */
/* Prototypes. */
-extern struct event_master *event_master_create(const char *name);
-void event_master_set_name(struct event_master *master, const char *name);
-extern void event_master_free(struct event_master *m);
-extern void event_master_free_unused(struct event_master *m);
+extern struct event_loop *event_master_create(const char *name);
+void event_master_set_name(struct event_loop *master, const char *name);
+extern void event_master_free(struct event_loop *m);
+extern void event_master_free_unused(struct event_loop *m);
extern void _event_add_read_write(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*fn)(struct event *), void *arg, int fd,
struct event **tref);
extern void _event_add_timer(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*fn)(struct event *), void *arg, long t,
struct event **tref);
extern void _event_add_timer_msec(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*fn)(struct event *), void *arg, long t,
struct event **tref);
extern void _event_add_timer_tv(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*fn)(struct event *), void *arg,
struct timeval *tv, struct event **tref);
extern void _event_add_event(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*fn)(struct event *), void *arg, int val,
struct event **tref);
extern void _event_execute(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*fn)(struct event *), void *arg, int val);
extern void event_cancel(struct event **event);
-extern void event_cancel_async(struct event_master *m, struct event **eptr,
+extern void event_cancel_async(struct event_loop *m, struct event **eptr,
void *data);
/* Cancel ready tasks with an arg matching 'arg' */
-extern void event_cancel_event_ready(struct event_master *m, void *arg);
+extern void event_cancel_event_ready(struct event_loop *m, void *arg);
/* Cancel all tasks with an arg matching 'arg', including timers and io */
-extern void event_cancel_event(struct event_master *m, void *arg);
-extern struct event *event_fetch(struct event_master *m, struct event *event);
+extern void event_cancel_event(struct event_loop *m, void *arg);
+extern struct event *event_fetch(struct event_loop *m, struct event *event);
extern void event_call(struct event *event);
extern unsigned long event_timer_remain_second(struct event *event);
extern struct timeval event_timer_remain(struct event *event);
struct rcu_thread *rcu_thread;
/* thread master for this pthread's thread.c event loop */
- struct event_master *master;
+ struct event_loop *master;
/* caller-specified data; start & stop funcs, name, id */
struct frr_pthread_attr attr;
}
int _frrzmq_event_add_read(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*msgfunc)(void *arg, void *zmqsock),
void (*partfunc)(void *arg, void *zmqsock,
zmq_msg_t *msg, unsigned partnum),
}
int _frrzmq_event_add_write(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*msgfunc)(void *arg, void *zmqsock),
void (*errfunc)(void *arg, void *zmqsock),
void *arg, void *zmqsock, struct frrzmq_cb **cbp)
if (zmq_getsockopt(cb->zmqsock, ZMQ_EVENTS, &events, &len))
return;
if ((events & event) && core->thread && !core->cancelled) {
- struct event_master *tm = core->thread->master;
+ struct event_loop *tm = core->thread->master;
event_cancel(&core->thread);
*/
extern int
_frrzmq_event_add_read(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*msgfunc)(void *arg, void *zmqsock),
void (*partfunc)(void *arg, void *zmqsock,
zmq_msg_t *msg, unsigned partnum),
void (*errfunc)(void *arg, void *zmqsock), void *arg,
void *zmqsock, struct frrzmq_cb **cb);
extern int _frrzmq_event_add_write(const struct xref_eventsched *xref,
- struct event_master *master,
+ struct event_loop *master,
void (*msgfunc)(void *arg, void *zmqsock),
void (*errfunc)(void *arg, void *zmqsock),
void *arg, void *zmqsock,
exit(0);
}
-struct event_master *master;
+struct event_loop *master;
int main(int argc, char **argv)
{
#include "frrscript.h"
#include "systemd.h"
-DEFINE_HOOK(frr_early_init, (struct event_master * tm), (tm));
-DEFINE_HOOK(frr_late_init, (struct event_master * tm), (tm));
-DEFINE_HOOK(frr_config_pre, (struct event_master * tm), (tm));
-DEFINE_HOOK(frr_config_post, (struct event_master * tm), (tm));
+DEFINE_HOOK(frr_early_init, (struct event_loop * tm), (tm));
+DEFINE_HOOK(frr_late_init, (struct event_loop * tm), (tm));
+DEFINE_HOOK(frr_config_pre, (struct event_loop * tm), (tm));
+DEFINE_HOOK(frr_config_post, (struct event_loop * tm), (tm));
DEFINE_KOOH(frr_early_fini, (), ());
DEFINE_KOOH(frr_fini, (), ());
fprintf(stderr, "%s: %s\n", prefix, errstr);
}
-static struct event_master *master;
-struct event_master *frr_init(void)
+static struct event_loop *master;
+struct event_loop *frr_init(void)
{
struct option_chain *oc;
struct log_arg *log_arg;
frr_check_detach();
}
-void frr_run(struct event_master *master)
+void frr_run(struct event_loop *master)
{
char instanceinfo[64] = "";
extern __attribute__((__noreturn__)) void frr_help_exit(int status);
-extern struct event_master *frr_init(void);
+extern struct event_loop *frr_init(void);
extern const char *frr_get_progname(void);
extern enum frr_cli_mode frr_get_cli_mode(void);
extern uint32_t frr_get_fd_limit(void);
extern bool frr_is_startup_fd(int fd);
/* call order of these hooks is as ordered here */
-DECLARE_HOOK(frr_early_init, (struct event_master * tm), (tm));
-DECLARE_HOOK(frr_late_init, (struct event_master * tm), (tm));
+DECLARE_HOOK(frr_early_init, (struct event_loop * tm), (tm));
+DECLARE_HOOK(frr_late_init, (struct event_loop * tm), (tm));
/* fork() happens between late_init and config_pre */
-DECLARE_HOOK(frr_config_pre, (struct event_master * tm), (tm));
-DECLARE_HOOK(frr_config_post, (struct event_master * tm), (tm));
+DECLARE_HOOK(frr_config_pre, (struct event_loop * tm), (tm));
+DECLARE_HOOK(frr_config_post, (struct event_loop * tm), (tm));
extern void frr_config_fork(void);
-extern void frr_run(struct event_master *master);
+extern void frr_run(struct event_loop *master);
extern void frr_detach(void);
extern bool frr_zclient_addr(struct sockaddr_storage *sa, socklen_t *sa_len,
TRACEPOINT_LOGLEVEL(frr_libfrr, hash_release, TRACE_INFO)
#define THREAD_SCHEDULE_ARGS \
- TP_ARGS(struct event_master *, master, const char *, funcname, \
+ TP_ARGS(struct event_loop *, master, const char *, funcname, \
const char *, schedfrom, int, fromln, struct event **, \
thread_ptr, int, fd, int, val, void *, arg, long, time)
struct mgmt_be_client_ctx {
int conn_fd;
- struct event_master *tm;
+ struct event_loop *tm;
struct event *conn_retry_tmr;
struct event *conn_read_ev;
struct event *conn_write_ev;
* Initialize library and try connecting with MGMTD.
*/
uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params,
- struct event_master *master_thread)
+ struct event_loop *master_thread)
{
assert(master_thread && params && strlen(params->name)
&& !mgmt_be_client_ctx.tm);
* Backend client lib handler (nothing but address of mgmt_be_client_ctx)
*/
extern uintptr_t mgmt_be_client_lib_init(struct mgmt_be_client_params *params,
- struct event_master *master_thread);
+ struct event_loop *master_thread);
/*
* Subscribe with MGMTD for one or more YANG subtree(s).
struct mgmt_fe_client_ctx {
int conn_fd;
- struct event_master *tm;
+ struct event_loop *tm;
struct event *conn_retry_tmr;
struct event *conn_read_ev;
struct event *conn_write_ev;
* Initialize library and try connecting with MGMTD.
*/
uintptr_t mgmt_fe_client_lib_init(struct mgmt_fe_client_params *params,
- struct event_master *master_thread)
+ struct event_loop *master_thread)
{
assert(master_thread && params && strlen(params->name)
&& !mgmt_fe_client_ctx.tm);
* Frontend client lib handler (nothing but address of mgmt_fe_client_ctx)
*/
extern uintptr_t mgmt_fe_client_lib_init(struct mgmt_fe_client_params *params,
- struct event_master *master_thread);
+ struct event_loop *master_thread);
/*
* Create a new Session for a Frontend Client connection.
}
-void nb_init(struct event_master *tm,
+void nb_init(struct event_loop *tm,
const struct frr_yang_module_info *const modules[],
size_t nmodules, bool db_enabled)
{
* db_enabled
* Set this to record the transactions in the transaction log.
*/
-extern void nb_init(struct event_master *tm,
+extern void nb_init(struct event_loop *tm,
const struct frr_yang_module_info *const modules[],
size_t nmodules, bool db_enabled);
struct debug nb_dbg_libyang = {0, "libyang debugging"};
struct nb_config *vty_shared_candidate_config;
-static struct event_master *master;
+static struct event_loop *master;
static void vty_show_nb_errors(struct vty *vty, int error, const char *errmsg)
{
.completions = yang_translator_autocomplete},
{.completions = NULL}};
-void nb_cli_init(struct event_master *tm)
+void nb_cli_init(struct event_loop *tm)
{
master = tm;
extern void nb_cli_confirmed_commit_clean(struct vty *vty);
extern int nb_cli_confirmed_commit_rollback(struct vty *vty);
extern void nb_cli_install_default(int node);
-extern void nb_cli_init(struct event_master *tm);
+extern void nb_cli_init(struct event_loop *tm);
extern void nb_cli_terminate(void);
#ifdef __cplusplus
static struct debug nb_dbg_client_confd = {0, "Northbound client: ConfD"};
-static struct event_master *master;
+static struct event_loop *master;
static struct sockaddr confd_addr;
static int cdb_sub_sock, dp_ctl_sock, dp_worker_sock;
static struct event *t_cdb_sub, *t_dp_ctl, *t_dp_worker;
return 0;
}
-static int frr_confd_module_late_init(struct event_master *tm)
+static int frr_confd_module_late_init(struct event_loop *tm)
{
master = tm;
*/
static bool nb_dbg_client_grpc = 0;
-static struct event_master *main_master;
+static struct event_loop *main_master;
static struct frr_pthread *fpt;
flog_err(EC_LIB_GRPC_INIT, "failed to initialize the gRPC module");
}
-static int frr_grpc_module_late_init(struct event_master *tm)
+static int frr_grpc_module_late_init(struct event_loop *tm)
{
main_master = tm;
hook_register(frr_fini, frr_grpc_finish);
static struct debug nb_dbg_client_sysrepo = {0, "Northbound client: Sysrepo"};
-static struct event_master *master;
+static struct event_loop *master;
static sr_session_ctx_t *session;
static sr_conn_ctx_t *connection;
static struct nb_transaction *transaction;
return 0;
}
-static int frr_sr_module_config_loaded(struct event_master *tm)
+static int frr_sr_module_config_loaded(struct event_loop *tm)
{
master = tm;
return 0;
}
-static int frr_sr_module_late_init(struct event_master *tm)
+static int frr_sr_module_late_init(struct event_loop *tm)
{
frr_sr_cli_init();
struct pullwr {
int fd;
- struct event_master *tm;
+ struct event_loop *tm;
/* writer == NULL <=> we're idle */
struct event *writer;
static void pullwr_run(struct event *t);
-struct pullwr *_pullwr_new(struct event_master *tm, int fd, void *arg,
+struct pullwr *_pullwr_new(struct event_loop *tm, int fd, void *arg,
void (*fill)(void *, struct pullwr *),
void (*err)(void *, struct pullwr *, bool))
{
* and released with pullwr_del(). This can be done from inside the callback,
* the pullwr code holds no more references on it when calling err().
*/
-extern struct pullwr *_pullwr_new(struct event_master *tm, int fd, void *arg,
+extern struct pullwr *_pullwr_new(struct event_loop *tm, int fd, void *arg,
void (*fill)(void *, struct pullwr *),
void (*err)(void *, struct pullwr *,
bool eof));
struct resolver_state {
ares_channel channel;
- struct event_master *master;
+ struct event_loop *master;
struct event *timeout;
};
}
-void resolver_init(struct event_master *tm)
+void resolver_init(struct event_loop *tm)
{
struct ares_options ares_opts;
struct event *literal_cb;
};
-void resolver_init(struct event_master *tm);
+void resolver_init(struct event_loop *tm);
void resolver_resolve(struct resolver_query *query, int af, vrf_id_t vrf_id,
const char *hostname,
void (*cb)(struct resolver_query *, const char *, int,
}
}
-void signal_init(struct event_master *m, int sigc,
- struct frr_signal_t signals[])
+void signal_init(struct event_loop *m, int sigc, struct frr_signal_t signals[])
{
int i = 0;
/* initialise sigevent system
* takes:
- * - pointer to valid struct event_master
+ * - pointer to valid struct event_loop
* - number of elements in passed in signals array
* - array of frr_signal_t's describing signals to handle
* and handlers to use for each signal
*/
-extern void signal_init(struct event_master *m, int sigc,
+extern void signal_init(struct event_loop *m, int sigc,
struct frr_signal_t *signals);
*/
extern bool smux_enabled(void);
-extern void smux_init(struct event_master *tm);
+extern void smux_init(struct event_loop *tm);
extern void smux_agentx_enable(void);
extern void smux_register_mib(const char *, struct variable *, size_t, int,
oid[], size_t);
};
struct spf_backoff {
- struct event_master *m;
+ struct event_loop *m;
/* Timers as per draft */
long init_delay;
return "???";
}
-struct spf_backoff *spf_backoff_new(struct event_master *m, const char *name,
+struct spf_backoff *spf_backoff_new(struct event_loop *m, const char *name,
long init_delay, long short_delay,
long long_delay, long holddown,
long timetolearn)
#endif
struct spf_backoff;
-struct event_master;
+struct event_loop;
struct vty;
-struct spf_backoff *spf_backoff_new(struct event_master *m, const char *name,
+struct spf_backoff *spf_backoff_new(struct event_loop *m, const char *name,
long init_delay, long short_delay,
long long_delay, long holddown,
long timetolearn);
systemd_send_information("STOPPING=1");
}
-static struct event_master *systemd_master = NULL;
+static struct event_loop *systemd_master = NULL;
static void systemd_send_watchdog(struct event *t)
{
watchdog_msec, NULL);
}
-void systemd_send_started(struct event_master *m)
+void systemd_send_started(struct event_loop *m)
{
assert(m != NULL);
void systemd_send_stopping(void);
/*
- * master - The struct event_master * to use to schedule ourself
+ * master - The struct event_loop * to use to schedule ourself
* the_process - Should we send watchdog if we are not the requested
* process?
*/
-void systemd_send_started(struct event_master *master);
+void systemd_send_started(struct event_loop *master);
/*
* status - A status string to send to systemd
}
/* Master of the threads. */
-static struct event_master *vty_master;
+static struct event_loop *vty_master;
static void vty_event_serv(enum vty_event event, struct vty_serv *vty_serv)
{
}
/* Install vty's own commands like `who' command. */
-void vty_init(struct event_master *master_thread, bool do_command_logging)
+void vty_init(struct event_loop *master_thread, bool do_command_logging)
{
/* For further configuration read, preserve current directory. */
vty_save_cwd();
extern struct nb_config *vty_mgmt_candidate_config;
/* Prototypes. */
-extern void vty_init(struct event_master *m, bool do_command_logging);
+extern void vty_init(struct event_loop *m, bool do_command_logging);
extern void vty_init_vtysh(void);
extern void vty_terminate(void);
extern void vty_reset(void);
event_execute(wheel->master, wheel_timer_thread_helper, wheel, 0);
}
-struct timer_wheel *wheel_init(struct event_master *master, int period,
+struct timer_wheel *wheel_init(struct event_loop *master, int period,
size_t slots,
unsigned int (*slot_key)(const void *),
void (*slot_run)(void *), const char *run_name)
struct timer_wheel {
char *name;
- struct event_master *master;
+ struct event_loop *master;
int slots;
long long curr_slot;
unsigned int period;
* and cause significant amount of time handling thread events instead
* of running your code.
*/
-struct timer_wheel *wheel_init(struct event_master *master, int period,
+struct timer_wheel *wheel_init(struct event_loop *master, int period,
size_t slots,
unsigned int (*slot_key)(const void *),
void (*slot_run)(void *), const char *run_name);
}
/* create new work queue */
-struct work_queue *work_queue_new(struct event_master *m,
- const char *queue_name)
+struct work_queue *work_queue_new(struct event_loop *m, const char *queue_name)
{
struct work_queue *new;
/* Everything but the specification struct is private
* the following may be read
*/
- struct event_master *master; /* thread master */
+ struct event_loop *master; /* thread master */
struct event *thread; /* thread, if one is active */
char *name; /* work queue name */
* user must fill in the spec of the returned work queue before adding
* anything to it
*/
-extern struct work_queue *work_queue_new(struct event_master *m,
+extern struct work_queue *work_queue_new(struct event_loop *m,
const char *queue_name);
/* destroy work queue */
static int zclient_debug;
/* Allocate zclient structure. */
-struct zclient *zclient_new(struct event_master *master,
+struct zclient *zclient_new(struct event_loop *master,
struct zclient_options *opt,
zclient_handler *const *handlers, size_t n_handlers)
{
/* Structure for the zebra client. */
struct zclient {
/* The thread master we schedule ourselves on */
- struct event_master *master;
+ struct event_loop *master;
/* Privileges to change socket values */
struct zebra_privs_t *privs;
extern uint32_t zclient_get_nhg_start(uint32_t proto);
-extern struct zclient *zclient_new(struct event_master *m,
+extern struct zclient *zclient_new(struct event_loop *m,
struct zclient_options *opt,
zclient_handler *const *handlers,
size_t n_handlers);
#include "qobj.h"
struct event;
-struct event_master;
+struct event_loop;
enum zlog_5424_dst {
/* can be used to disable a target temporarily */
*/
/* sockets only - read handler to reconnect on errors */
- struct event_master *master;
+ struct event_loop *master;
struct event *t_reconnect;
unsigned int reconn_backoff, reconn_backoff_cur, reconn_backoff_max;
int sock_type;
DEFINE_QOBJ_TYPE(zlog_cfg_5424_user);
static struct targets_head targets = INIT_RBTREE_UNIQ(targets);
-static struct event_master *log_5424_master;
+static struct event_loop *log_5424_master;
static void clear_dst(struct zlog_cfg_5424_user *cfg);
/* hooks */
-static int log_5424_early_init(struct event_master *master);
+static int log_5424_early_init(struct event_loop *master);
static int log_5424_rotate(void);
static int log_5424_fini(void);
hook_register(frr_fini, log_5424_fini);
}
-static int log_5424_early_init(struct event_master *master)
+static int log_5424_early_init(struct event_loop *master)
{
log_5424_master = master;
/* MGMTD process wide configuration pointer to export. */
struct mgmt_master *mm;
-void mgmt_master_init(struct event_master *master, const int buffer_size)
+void mgmt_master_init(struct event_loop *master, const int buffer_size)
{
memset(&mgmt_master, 0, sizeof(struct mgmt_master));
* MGMTD master for system wide configurations and variables.
*/
struct mgmt_master {
- struct event_master *master;
+ struct event_loop *master;
/* How big should we set the socket buffer size */
uint32_t socket_buffer;
extern int mgmt_config_write(struct vty *vty);
-extern void mgmt_master_init(struct event_master *master,
- const int buffer_size);
+extern void mgmt_master_init(struct event_loop *master, const int buffer_size);
extern void mgmt_init(void);
extern void mgmt_vty_init(void);
mgmt_xpath_map[MGMTD_BE_MAX_NUM_XPATH_MAP];
static int mgmt_num_xpath_maps;
-static struct event_master *mgmt_be_adapter_tm;
+static struct event_loop *mgmt_be_adapter_tm;
static struct mgmt_be_adapters_head mgmt_be_adapters;
*adapter = NULL;
}
-int mgmt_be_adapter_init(struct event_master *tm)
+int mgmt_be_adapter_init(struct event_loop *tm)
{
if (!mgmt_be_adapter_tm) {
mgmt_be_adapter_tm = tm;
};
/* Initialise backend adapter module. */
-extern int mgmt_be_adapter_init(struct event_master *tm);
+extern int mgmt_be_adapter_init(struct event_loop *tm);
/* Destroy the backend adapter module. */
extern void mgmt_be_adapter_destroy(void);
#endif /* REDIRECT_DEBUG_TO_STDERR */
static int mgmt_be_listen_fd = -1;
-static struct event_master *mgmt_be_listen_tm;
+static struct event_loop *mgmt_be_listen_tm;
static struct event *mgmt_be_listen_ev;
static void mgmt_be_server_register_event(enum mgmt_be_event event);
exit(-1);
}
-int mgmt_be_server_init(struct event_master *master)
+int mgmt_be_server_init(struct event_loop *master)
{
if (mgmt_be_listen_tm) {
MGMTD_BE_SRVR_DBG("MGMTD Backend Server already running!");
#define MGMTD_BE_MAX_CONN 32
/* Initialise backend server */
-extern int mgmt_be_server_init(struct event_master *master);
+extern int mgmt_be_server_init(struct event_loop *master);
/* Destroy backend server */
extern void mgmt_be_server_destroy(void);
#define FOREACH_SESSION_IN_LIST(adapter, session) \
frr_each_safe (mgmt_fe_sessions, &(adapter)->fe_sessions, (session))
-static struct event_master *mgmt_fe_adapter_tm;
+static struct event_loop *mgmt_fe_adapter_tm;
static struct mgmt_master *mgmt_fe_adapter_mm;
static struct mgmt_fe_adapters_head mgmt_fe_adapters;
*adapter = NULL;
}
-int mgmt_fe_adapter_init(struct event_master *tm, struct mgmt_master *mm)
+int mgmt_fe_adapter_init(struct event_loop *tm, struct mgmt_master *mm)
{
if (!mgmt_fe_adapter_tm) {
mgmt_fe_adapter_tm = tm;
DECLARE_LIST(mgmt_fe_adapters, struct mgmt_fe_client_adapter, list_linkage);
/* Initialise frontend adapter module */
-extern int mgmt_fe_adapter_init(struct event_master *tm,
- struct mgmt_master *cm);
+extern int mgmt_fe_adapter_init(struct event_loop *tm, struct mgmt_master *cm);
/* Destroy frontend adapter module */
extern void mgmt_fe_adapter_destroy(void);
#endif /* REDIRECT_DEBUG_TO_STDERR */
static int mgmt_fe_listen_fd = -1;
-static struct event_master *mgmt_fe_listen_tm;
+static struct event_loop *mgmt_fe_listen_tm;
static struct event *mgmt_fe_listen_ev;
static void mgmt_fe_server_register_event(enum mgmt_fe_event event);
exit(-1);
}
-int mgmt_fe_server_init(struct event_master *master)
+int mgmt_fe_server_init(struct event_loop *master)
{
if (mgmt_fe_listen_tm) {
MGMTD_FE_SRVR_DBG("MGMTD Frontend Server already running!");
#define MGMTD_FE_MAX_CONN 32
/* Initialise frontend server */
-extern int mgmt_fe_server_init(struct event_master *master);
+extern int mgmt_fe_server_init(struct event_loop *master);
/* Destroy frontend server */
extern void mgmt_fe_server_destroy(void);
mgmt_txn_send_be_txn_delete(struct mgmt_txn_ctx *txn,
struct mgmt_be_client_adapter *adapter);
-static struct event_master *mgmt_txn_tm;
+static struct event_loop *mgmt_txn_tm;
static struct mgmt_master *mgmt_txn_mm;
static void mgmt_txn_register_event(struct mgmt_txn_ctx *txn,
}
}
-int mgmt_txn_init(struct mgmt_master *mm, struct event_master *tm)
+int mgmt_txn_init(struct mgmt_master *mm, struct event_loop *tm)
{
if (mgmt_txn_mm || mgmt_txn_tm)
assert(!"MGMTD TXN: Call txn_init() only once");
}
/* Initialise transaction module. */
-extern int mgmt_txn_init(struct mgmt_master *cm, struct event_master *tm);
+extern int mgmt_txn_init(struct mgmt_master *cm, struct event_loop *tm);
/* Destroy the transaction module. */
extern void mgmt_txn_destroy(void);
unsigned int debug_flags = 0;
-struct event_master *master;
+struct event_loop *master;
struct timeval current_time;
/* nhrpd options. */
#define NHRP_VTY_PORT 2610
#define NHRP_DEFAULT_CONFIG "nhrpd.conf"
-extern struct event_master *master;
+extern struct event_loop *master;
enum { NHRP_OK = 0,
NHRP_ERR_FAIL,
struct option longopts[] = {{0}};
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
static void __attribute__((noreturn)) ospf6_exit(int status)
{
}
/* Register OSPFv3-MIB. */
-static int ospf6_snmp_init(struct event_master *master)
+static int ospf6_snmp_init(struct event_loop *master)
{
smux_init(master);
REGISTER_MIB("OSPFv3MIB", ospfv3_variables, variable, ospfv3_oid);
}
}
-void ospf6_master_init(struct event_master *master)
+void ospf6_master_init(struct event_loop *master)
{
memset(&ospf6_master, 0, sizeof(ospf6_master));
/* OSPFv3 instance. */
struct list *ospf6;
/* OSPFv3 thread master. */
- struct event_master *master;
+ struct event_loop *master;
};
/* ospf6->config_flags */
extern struct ospf6_master *om6;
/* prototypes */
-extern void ospf6_master_init(struct event_master *master);
+extern void ospf6_master_init(struct event_loop *master);
extern void install_element_ospf6_clear_process(void);
extern void ospf6_top_init(void);
extern void ospf6_delete(struct ospf6 *o);
[ZEBRA_NEXTHOP_UPDATE] = ospf6_zebra_import_check_update,
};
-void ospf6_zebra_init(struct event_master *master)
+void ospf6_zebra_init(struct event_loop *master)
{
/* Allocate zebra structure. */
zclient = zclient_new(master, &zclient_options_default, ospf6_handlers,
extern void ospf6_zebra_no_redistribute(int, vrf_id_t vrf_id);
#define ospf6_zebra_is_redistribute(type, vrf_id) \
vrf_bitmap_check(zclient->redist[AFI_IP6][type], vrf_id)
-extern void ospf6_zebra_init(struct event_master *tm);
+extern void ospf6_zebra_init(struct event_loop *tm);
extern void ospf6_zebra_import_default_route(struct ospf6 *ospf6, bool unreg);
extern void ospf6_zebra_add_discard(struct ospf6_route *request,
struct ospf6 *ospf6);
}
/* Install ospf related commands. */
-void ospf6_init(struct event_master *master)
+void ospf6_init(struct event_loop *master)
{
ospf6_top_init();
ospf6_area_init();
DECLARE_MGROUP(OSPF6D);
/* global variables */
-extern struct event_master *master;
+extern struct event_loop *master;
/* Historical for KAME. */
#ifndef IPV6_JOIN_GROUP
extern struct route_node *route_prev(struct route_node *node);
extern void ospf6_debug(void);
-extern void ospf6_init(struct event_master *master);
+extern void ospf6_init(struct event_loop *master);
#endif /* OSPF6D_H */
#define ASYNCPORT 4000
/* Master thread */
-struct event_master *master;
+struct event_loop *master;
/* Global variables */
struct ospf_apiclient *oclient;
#include <sys/types.h>
-#include "ospfd/ospfd.h" /* for "struct event_master" */
+#include "ospfd/ospfd.h" /* for "struct event_loop" */
#include "ospfd/ospf_interface.h"
#include "ospfd/ospf_ism.h"
#include "ospfd/ospf_asbr.h"
return CMD_SUCCESS;
}
-void ospf_bfd_init(struct event_master *tm)
+void ospf_bfd_init(struct event_loop *tm)
{
bfd_protocol_integration_init(zclient, tm);
#include "ospfd/ospf_interface.h"
#include "json.h"
-extern void ospf_bfd_init(struct event_master *tm);
+extern void ospf_bfd_init(struct event_loop *tm);
extern void ospf_bfd_write_config(struct vty *vty,
const struct ospf_if_params *params);
/* OSPFd program name */
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
#ifdef SUPPORT_OSPF_API
extern int ospf_apiserver_enable;
}
/* Register OSPF2-MIB. */
-static int ospf_snmp_init(struct event_master *tm)
+static int ospf_snmp_init(struct event_loop *tm)
{
ospf_snmp_iflist = list_new();
ospf_snmp_vl_table = route_table_init();
static struct zclient *zclient_sync;
/* For registering threads. */
-extern struct event_master *master;
+extern struct event_loop *master;
/* Router-id update message from zebra. */
static int ospf_router_id_update_zebra(ZAPI_CALLBACK_ARGS)
[ZEBRA_CLIENT_CLOSE_NOTIFY] = ospf_zebra_client_close_notify,
};
-void ospf_zebra_init(struct event_master *master, unsigned short instance)
+void ospf_zebra_init(struct event_loop *master, unsigned short instance)
{
/* Allocate zebra structure. */
zclient = zclient_new(master, &zclient_options_default, ospf_handlers,
const char *, const char *);
extern int ospf_distance_unset(struct vty *, struct ospf *, const char *,
const char *, const char *);
-extern void ospf_zebra_init(struct event_master *m, unsigned short instance);
+extern void ospf_zebra_init(struct event_loop *m, unsigned short instance);
extern void ospf_zebra_vrf_register(struct ospf *ospf);
extern void ospf_zebra_vrf_deregister(struct ospf *ospf);
bool ospf_external_default_routemap_apply_walk(
return 1;
}
-void ospf_master_init(struct event_master *master)
+void ospf_master_init(struct event_loop *master)
{
memset(&ospf_master, 0, sizeof(ospf_master));
struct list *ospf;
/* OSPF thread master. */
- struct event_master *master;
+ struct event_loop *master;
/* Various OSPF global configuration. */
uint8_t options;
extern unsigned short ospf_instance;
extern const int ospf_redistributed_proto_max;
extern struct zclient *zclient;
-extern struct event_master *master;
+extern struct event_loop *master;
extern int ospf_zlog;
extern struct zebra_privs_t ospfd_privs;
extern void ospf_route_map_init(void);
-extern void ospf_master_init(struct event_master *master);
+extern void ospf_master_init(struct event_loop *master);
extern void ospf_vrf_init(void);
extern void ospf_vrf_terminate(void);
extern void ospf_vrf_link(struct ospf *ospf, struct vrf *vrf);
struct option longopts[] = {{0}};
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
static struct frr_daemon_info pathd_di;
/* Module Functions */
static int pcep_module_finish(void);
-static int pcep_module_late_init(struct event_master *tm);
+static int pcep_module_late_init(struct event_loop *tm);
static int pcep_module_init(void);
/* ------------ Path Helper Functions ------------ */
* run before config load, so the CLI commands don't try to touch things that
* aren't set up yet...
*/
-static int pcep_module_config_pre(struct event_master *tm)
+static int pcep_module_config_pre(struct event_loop *tm)
{
assert(pcep_g->fpt == NULL);
assert(pcep_g->master == NULL);
return 0;
}
-static int pcep_module_late_init(struct event_master *tm)
+static int pcep_module_late_init(struct event_loop *tm)
{
hook_register(pathd_candidate_created, pathd_candidate_created_handler);
hook_register(pathd_candidate_updated, pathd_candidate_updated_handler);
struct pcep_glob {
struct debug dbg;
- struct event_master *master;
+ struct event_loop *master;
struct frr_pthread *fpt;
uint8_t num_pce_opts_cli;
struct pce_opts_cli *pce_opts_cli[MAX_PCE];
/* ------------ API Functions Called from Main Thread ------------ */
-int pcep_ctrl_initialize(struct event_master *main_thread,
+int pcep_ctrl_initialize(struct event_loop *main_thread,
struct frr_pthread **fpt,
pcep_main_event_handler_t event_handler)
{
};
struct ctrl_state {
- struct event_master *main;
- struct event_master *self;
+ struct event_loop *main;
+ struct event_loop *self;
pcep_main_event_handler_t main_event_handler;
struct pcc_opts *pcc_opts;
int pcc_count;
};
/* Functions called from the main thread */
-int pcep_ctrl_initialize(struct event_master *main_thread,
+int pcep_ctrl_initialize(struct event_loop *main_thread,
struct frr_pthread **fpt,
pcep_main_event_handler_t event_handler);
int pcep_ctrl_finalize(struct frr_pthread **fpt);
* path_path_ted public API function implementations
*/
-void path_ted_init(struct event_master *master)
+void path_ted_init(struct event_loop *master)
{
ted_state_g.main = master;
ted_state_g.link_state_delay_interval = TIMER_RETRY_DELAY;
IMPORT_OSPFv3
};
struct ted_state {
- struct event_master *main;
+ struct event_loop *main;
/* Status of TED: enable or disable */
bool enabled;
/* From which igp is going to receive data */
/* TED management functions */
bool path_ted_is_initialized(void);
-void path_ted_init(struct event_master *master);
+void path_ted_init(struct event_loop *master);
uint32_t path_ted_teardown(void);
void path_ted_timer_sync_cancel(void);
void path_ted_timer_refresh_cancel(void);
*
* @param master The master thread
*/
-void path_zebra_init(struct event_master *master)
+void path_zebra_init(struct event_loop *master)
{
struct zclient_options options = zclient_options_default;
options.synchronous = true;
void path_zebra_delete_sr_policy(struct srte_policy *policy);
int path_zebra_request_label(mpls_label_t label);
void path_zebra_release_label(mpls_label_t label);
-void path_zebra_init(struct event_master *master);
+void path_zebra_init(struct event_loop *master);
void path_zebra_stop(void);
#endif /* _FRR_PATH_MPLS_H_ */
extern struct zebra_privs_t pathd_privs;
/* master thread, defined in path_main.c */
-extern struct event_master *master;
+extern struct event_loop *master;
/* pathd.c */
struct srte_segment_list *srte_segment_list_add(const char *name);
struct option longopts[] = { { 0 } };
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/* SIGHUP handler. */
static void sighup(void)
char mapname[100];
};
-extern struct event_master *master;
+extern struct event_loop *master;
extern void pbr_zebra_init(void);
};
struct pim_router {
- struct event_master *master;
+ struct event_loop *master;
uint32_t debugs;
}
/* MSDP init */
-void pim_msdp_init(struct pim_instance *pim, struct event_master *master)
+void pim_msdp_init(struct pim_instance *pim, struct event_loop *master)
{
pim->msdp.master = master;
char hash_name[64];
struct pim_msdp {
enum pim_msdp_flags flags;
- struct event_master *master;
+ struct event_loop *master;
struct pim_msdp_listener listener;
uint32_t rejected_accepts;
#if PIM_IPV != 6
// struct pim_msdp *msdp;
struct pim_instance;
-void pim_msdp_init(struct pim_instance *pim, struct event_master *master);
+void pim_msdp_init(struct pim_instance *pim, struct event_loop *master);
void pim_msdp_exit(struct pim_instance *pim);
char *pim_msdp_state_dump(enum pim_msdp_peer_state state, char *buf,
int buf_size);
#else /* PIM_IPV == 6 */
static inline void pim_msdp_init(struct pim_instance *pim,
- struct event_master *master)
+ struct event_loop *master)
{
}
.cap_num_i = 0};
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
static struct frr_daemon_info ripd_di;
{RIP2PEERRCVBADPACKETS, COUNTER, RONLY, rip2PeerTable, 3, {4, 1, 5}},
{RIP2PEERRCVBADROUTES, COUNTER, RONLY, rip2PeerTable, 3, {4, 1, 6}}};
-extern struct event_master *master;
+extern struct event_loop *master;
static uint8_t *rip2Globals(struct variable *v, oid name[], size_t *length,
int exact, size_t *var_len,
}
/* Register RIPv2-MIB. */
-static int rip_snmp_init(struct event_master *master)
+static int rip_snmp_init(struct event_loop *master)
{
rip_ifaddr_table = route_table_init();
[ZEBRA_REDISTRIBUTE_ROUTE_DEL] = rip_zebra_read_route,
};
-void rip_zclient_init(struct event_master *master)
+void rip_zclient_init(struct event_loop *master)
{
/* Set default value to the zebra client structure. */
zclient = zclient_new(master, &zclient_options_default, rip_handlers,
extern void rip_route_map_init(void);
extern void rip_zebra_vrf_register(struct vrf *vrf);
extern void rip_zebra_vrf_deregister(struct vrf *vrf);
-extern void rip_zclient_init(struct event_master *);
+extern void rip_zclient_init(struct event_loop *);
extern void rip_zclient_stop(void);
extern int if_check_address(struct rip *rip, struct in_addr addr);
extern struct rip *rip_lookup_by_vrf_id(vrf_id_t vrf_id);
extern struct rip_instance_head rip_instances;
/* Master thread structure. */
-extern struct event_master *master;
+extern struct event_loop *master;
DECLARE_HOOK(rip_ifaddr_add, (struct connected * ifc), (ifc));
DECLARE_HOOK(rip_ifaddr_del, (struct connected * ifc), (ifc));
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
static struct frr_daemon_info ripngd_di;
};
/* Initialize zebra structure and it's commands. */
-void zebra_init(struct event_master *master)
+void zebra_init(struct event_loop *master)
{
/* Allocate zebra structure. */
zclient = zclient_new(master, &zclient_options_default, ripng_handlers,
/* Extern variables. */
extern struct zebra_privs_t ripngd_privs;
-extern struct event_master *master;
+extern struct event_loop *master;
extern struct ripng_instance_head ripng_instances;
/* Prototypes. */
extern void ripng_zebra_vrf_deregister(struct vrf *vrf);
extern void ripng_terminate(void);
/* zclient_init() is done by ripng_zebra.c:zebra_init() */
-extern void zebra_init(struct event_master *master);
+extern void zebra_init(struct event_loop *master);
extern void ripng_zebra_stop(void);
extern void ripng_redistribute_conf_update(struct ripng *ripng, int type);
extern void ripng_redistribute_conf_delete(struct ripng *ripng, int type);
static struct rusage lp_rusage;
static struct vty *lp_vty;
-extern struct event_master *master;
+extern struct event_loop *master;
static void logpump_done(struct event *thread)
{
struct option longopts[] = {{0}};
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/* SIGHUP handler. */
static void sighup(void)
struct zclient *zclient = NULL;
/* For registering threads. */
-extern struct event_master *master;
+extern struct event_loop *master;
/* Privs info */
extern struct zebra_privs_t sharp_privs;
bfd_sess_install(sn->bsp);
}
-void static_bfd_initialize(struct zclient *zc, struct event_master *tm)
+void static_bfd_initialize(struct zclient *zc, struct event_loop *tm)
{
/* Initialize BFD integration library. */
bfd_protocol_integration_init(zc, tm);
struct option longopts[] = { { 0 } };
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
uintptr_t mgmt_lib_hndl;
extern void static_next_hop_bfd_multi_hop(struct static_nexthop *sn, bool mhop);
/** Call this function after zebra client initialization. */
-extern void static_bfd_initialize(struct zclient *zc, struct event_master *tm);
+extern void static_bfd_initialize(struct zclient *zc, struct event_loop *tm);
extern void static_bfd_show(struct vty *vty, bool isjson);
extern "C" {
#endif
-extern struct event_master *master;
+extern struct event_loop *master;
extern void static_zebra_nht_register(struct static_nexthop *nh, bool reg);
/* need these to link in libbgp */
struct zebra_privs_t bgpd_privs = {};
-struct event_master *master = NULL;
+struct event_loop *master = NULL;
static int failed = 0;
/* need these to link in libbgp */
struct zebra_privs_t bgpd_privs = {};
-struct event_master *master = NULL;
+struct event_loop *master = NULL;
static int failed = 0;
static int tty = 0;
/* need these to link in libbgp */
struct zebra_privs_t bgpd_privs = {};
-struct event_master *master = NULL;
+struct event_loop *master = NULL;
static int failed = 0;
/* need these to link in libbgp */
struct zebra_privs_t bgpd_privs = {};
-struct event_master *master = NULL;
+struct event_loop *master = NULL;
static int failed = 0;
static int tty = 0;
};
/* need these to link in libbgp */
-struct event_master *master = NULL;
+struct event_loop *master = NULL;
extern struct zclient *zclient;
struct zebra_privs_t bgpd_privs = {
.user = NULL,
/* need these to link in libbgp */
struct zebra_privs_t bgpd_privs = {};
-struct event_master *master = NULL;
+struct event_loop *master = NULL;
static struct bgp *bgp;
static as_t asn = 100;
/* Required variables to link in libbgp */
struct zebra_privs_t bgpd_privs = {0};
-struct event_master *master;
+struct event_loop *master;
enum test_state {
TEST_SUCCESS,
extern void test_init(void);
-struct event_master *master;
+struct event_loop *master;
struct option longopts[] = {{"daemon", no_argument, NULL, 'd'},
{"config_file", required_argument, NULL, 'f'},
#include "test_common.h"
-struct event_master *master;
+struct event_loop *master;
struct zebra_privs_t isisd_privs;
int isis_sock_init(struct isis_circuit *circuit)
struct lspdb_head lspdb[]);
/* Global variables. */
-extern struct event_master *master;
+extern struct event_loop *master;
extern struct zebra_privs_t isisd_privs;
extern struct isis_topology test_topologies[];
#include "common_cli.h"
-struct event_master *master;
+struct event_loop *master;
int dump_args(struct vty *vty, const char *descr, int argc,
struct cmd_token *argv[])
/* functions provided by common cli
* (includes main())
*/
-extern struct event_master *master;
+extern struct event_loop *master;
extern int test_log_prio;
extern struct cmd_node vty_node;
extern void test_init_cmd(void); /* provided in test-commands-defun.c */
-struct event_master *master; /* dummy for libfrr*/
+struct event_loop *master; /* dummy for libfrr*/
static vector test_cmds;
static char test_buf[32768];
#include "log.h"
#include "northbound.h"
-static struct event_master *master;
+static struct event_loop *master;
struct troute {
struct prefix_ipv4 prefix;
int main(int argc, char **argv)
{
int number = 10;
- struct event_master *master;
+ struct event_loop *master;
zlog_aux_init("NONE: ", LOG_DEBUG);
#include <lib_vty.h>
#include <buffer.h>
-struct event_master *master;
+struct event_loop *master;
int main(int argc, char **argv)
{
#include "network.h"
#include "prng.h"
-struct event_master *master;
+struct event_loop *master;
struct acc_vals {
int c0;
#include <grpcpp/security/credentials.h>
#include "grpc/frr-northbound.grpc.pb.h"
-DEFINE_HOOK(frr_late_init, (struct event_master * tm), (tm));
+DEFINE_HOOK(frr_late_init, (struct event_loop * tm), (tm));
DEFINE_KOOH(frr_fini, (), ());
struct vty *vty;
bool mpls_enabled;
-struct event_master *master;
+struct event_loop *master;
struct zebra_privs_t static_privs = {0};
struct frrmod_runtime *grpc_module;
char binpath[2 * MAXPATHLEN + 1];
#include "tests.h"
-extern struct event_master *master;
+extern struct event_loop *master;
enum { ITERS_FIRST = 0,
ITERS_ERR = 100,
DEFINE_MTYPE_STATIC(TEST_HEAVYWQ, WQ_NODE, "heavy_wq_node");
DEFINE_MTYPE_STATIC(TEST_HEAVYWQ, WQ_NODE_STR, "heavy_wq_node->str");
-extern struct event_master *master;
+extern struct event_loop *master;
static struct work_queue *heavy_wq;
struct heavy_wq_node {
* CVS
*/
-struct event_master *master;
+struct event_loop *master;
#if 0 /* set to 1 to use system alloc directly */
#undef XMALLOC
#include "zebra/rib.h"
#include "prng.h"
-struct event_master *master;
+struct event_loop *master;
static int verbose;
static void str_append(char **buf, const char *repr)
exit(status);
}
-struct event_master *master;
+struct event_loop *master;
/* main routine. */
int main(int argc, char **argv)
{
#include "tests/lib/cli/common_cli.h"
-extern struct event_master *master;
+extern struct event_loop *master;
static void resolver_result(struct resolver_query *resq, const char *errstr,
int numaddrs, union sockunion *addr)
struct frr_signal_t sigs[] = {};
-struct event_master *master;
+struct event_loop *master;
void func1(int *arg);
void func3(void);
.handler = &sigusr2,
}};
-struct event_master *master;
+struct event_loop *master;
struct event t;
int main(void)
#define s6_addr32 __u6_addr.__u6_addr32
#endif /*s6_addr32*/
-struct event_master *master;
+struct event_loop *master;
/* This structure is copied from lib/srcdest_table.c to which it is
* private as far as other parts of Quagga are concerned.
#include "printfrr.h"
static unsigned long long ham = 0xdeadbeefdeadbeef;
-struct event_master *master;
+struct event_loop *master;
static void print_stream(struct stream *s)
{
char *prefix_str;
} test_node_t;
-struct event_master *master;
+struct event_loop *master;
/*
* add_node
#define TIMESTR_LEN strlen("4294967296.999999")
-struct event_master *master;
+struct event_loop *master;
static size_t log_buf_len;
static size_t log_buf_pos;
#define SCHEDULE_TIMERS 1000000
#define REMOVE_TIMERS 500000
-struct event_master *master;
+struct event_loop *master;
static void dummy_func(struct event *thread)
{
DEFINE_MTYPE_STATIC(LIB, TESTBUF, "zmq test buffer");
DEFINE_MTYPE_STATIC(LIB, ZMQMSG, "zmq message");
-static struct event_master *master;
+static struct event_loop *master;
static void msg_buf_free(void *data, void *hint)
{
#include "common.h"
-struct event_master *master;
+struct event_loop *master;
struct zebra_privs_t ospfd_privs;
struct ospf_test_node *root, struct ospf *ospf);
/* Global variables. */
-extern struct event_master *master;
+extern struct event_loop *master;
extern struct ospf_topology topo1;
extern struct ospf_topology topo2;
extern struct ospf_topology topo3;
extern struct vrrp_defaults vd;
/* threadmaster */
-extern struct event_master *master;
+extern struct event_loop *master;
/* privileges */
extern struct zebra_privs_t vrrp_privs;
struct option longopts[] = { {0} };
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
static struct frr_daemon_info vrrpd_di;
#include "memory.h"
DECLARE_MGROUP(MVTYSH);
-struct event_master;
+struct event_loop;
-extern struct event_master *master;
+extern struct event_loop *master;
#define VTYSH_ZEBRA 0x00001
#define VTYSH_RIPD 0x00002
int user_mode;
/* Master of threads. */
-struct event_master *master;
+struct event_loop *master;
/* Command logging */
FILE *logfile;
DEFINE_MTYPE_STATIC(WATCHFRR, WATCHFRR_DAEMON, "watchfrr daemon entry");
/* Needs to be global, referenced somewhere inside libfrr. */
-struct event_master *master;
+struct event_loop *master;
static bool watch_only = false;
const char *pathspace;
}
-static int zd_dpdk_plugin_init(struct event_master *tm)
+static int zd_dpdk_plugin_init(struct event_loop *tm)
{
int ret;
return 0;
}
-static int fpm_nl_new(struct event_master *tm)
+static int fpm_nl_new(struct event_loop *tm)
{
struct zebra_dplane_provider *prov = NULL;
int rv;
return 0;
}
-static int irdp_init(struct event_master *master)
+static int irdp_init(struct event_loop *master)
{
irdp_if_init();
{RTN_XRESOLVE, "resolver"},
{0}};
-extern struct event_master *master;
+extern struct event_loop *master;
extern struct zebra_privs_t zserv_privs;
pid_t pid;
/* Pacify zclient.o in libfrr, which expects this variable. */
-struct event_master *master;
+struct event_loop *master;
/* Route retain mode flag. */
int retain_mode = 0;
* Init entry point called during zebra startup. This is registered during
* module init.
*/
-static int init_sample_plugin(struct event_master *tm)
+static int init_sample_plugin(struct event_loop *tm)
{
int ret;
struct frr_pthread *dg_pthread;
/* Event-delivery context 'master' for the dplane */
- struct event_master *dg_master;
+ struct event_loop *dg_master;
/* Event/'thread' pointer for queued updates */
struct event *dg_t_update;
*/
/* Obtain thread_master for dataplane thread */
-struct event_master *dplane_get_thread_master(void)
+struct event_loop *dplane_get_thread_master(void)
{
return zdplane_info.dg_master;
}
void dplane_provider_unlock(struct zebra_dplane_provider *prov);
/* Obtain thread_master for dataplane thread */
-struct event_master *dplane_get_thread_master(void);
+struct event_loop *dplane_get_thread_master(void);
/* Providers should (generally) limit number of updates per work cycle */
int dplane_provider_get_work_limit(const struct zebra_dplane_provider *prov);
*/
enum zfpm_msg_format message_format;
- struct event_master *master;
+ struct event_loop *master;
enum zfpm_state state;
*
* Returns true on success.
*/
-static int zfpm_init(struct event_master *master)
+static int zfpm_init(struct event_loop *master)
{
int enable = 1;
uint16_t port = 0;
*
*/
-static struct event_master *zmlag_master;
+static struct event_loop *zmlag_master;
static int mlag_socket;
static void zebra_mlag_connect(struct event *thread);
struct frr_pthread *pthread;
/* Event-delivery context 'master' for the module */
- struct event_master *master;
+ struct event_loop *master;
/* Event/'thread' pointer for queued zapi messages */
struct event *t_msgs;
struct frr_pthread *zebra_pth_mlag;
/* MLAG Thread context 'master' */
- struct event_master *th_master;
+ struct event_loop *th_master;
/*
* Event for Initial MLAG Connection setup & Data Read
atomic_bool in_shutdown;
/* Thread master */
- struct event_master *master;
+ struct event_loop *master;
/* Lists of clients who have connected to us */
struct list *client_list;
return NULL;
}
-static int zebra_snmp_init(struct event_master *tm)
+static int zebra_snmp_init(struct event_loop *tm)
{
smux_init(tm);
REGISTER_MIB("mibII/ipforward", zebra_variables, variable, ipfw_oid);
projects / mirror_frr.git / commitdiff