Merge pull request #12837 from donaldsharp/unlikely_routemap

[mirror_frr.git] / lib / resolver.c

diff --git a/lib/resolver.c b/lib/resolver.c
index 2918576c03a779537eb87347effbec4e4b210c82..99bf356eb3e648c5a3a7e68c4806051041e2aa5a 100644 (file)
--- a/lib/resolver.c
+++ b/lib/resolver.c
@@ -12,7 +12,7 @@
 
 #include "typesafe.h"
 #include "jhash.h"
-#include "thread.h"
+#include "frrevent.h"
 #include "lib_errors.h"
 #include "resolver.h"
 #include "command.h"
@@ -23,8 +23,8 @@ XREF_SETUP();
 
 struct resolver_state {
        ares_channel channel;
-       struct thread_master *master;
-       struct thread *timeout;
+       struct event_loop *master;
+       struct event *timeout;
 };
 
 static struct resolver_state state;
@@ -47,7 +47,7 @@ struct resolver_fd {
 
        int fd;
        struct resolver_state *state;
-       struct thread *t_read, *t_write;
+       struct event *t_read, *t_write;
 };
 
 static int resolver_fd_cmp(const struct resolver_fd *a,
@@ -100,38 +100,38 @@ static void resolver_fd_drop_maybe(struct resolver_fd *resfd)
 
 static void resolver_update_timeouts(struct resolver_state *r);
 
-static void resolver_cb_timeout(struct thread *t)
+static void resolver_cb_timeout(struct event *t)
 {
-       struct resolver_state *r = THREAD_ARG(t);
+       struct resolver_state *r = EVENT_ARG(t);
 
        ares_process(r->channel, NULL, NULL);
        resolver_update_timeouts(r);
 }
 
-static void resolver_cb_socket_readable(struct thread *t)
+static void resolver_cb_socket_readable(struct event *t)
 {
-       struct resolver_fd *resfd = THREAD_ARG(t);
+       struct resolver_fd *resfd = EVENT_ARG(t);
        struct resolver_state *r = resfd->state;
 
-       thread_add_read(r->master, resolver_cb_socket_readable, resfd,
-                       resfd->fd, &resfd->t_read);
+       event_add_read(r->master, resolver_cb_socket_readable, resfd, resfd->fd,
+                      &resfd->t_read);
        /* ^ ordering important:
-        * ares_process_fd may transitively call THREAD_OFF(resfd->t_read)
+        * ares_process_fd may transitively call EVENT_OFF(resfd->t_read)
         * combined with resolver_fd_drop_maybe, so resfd may be free'd after!
         */
        ares_process_fd(r->channel, resfd->fd, ARES_SOCKET_BAD);
        resolver_update_timeouts(r);
 }
 
-static void resolver_cb_socket_writable(struct thread *t)
+static void resolver_cb_socket_writable(struct event *t)
 {
-       struct resolver_fd *resfd = THREAD_ARG(t);
+       struct resolver_fd *resfd = EVENT_ARG(t);
        struct resolver_state *r = resfd->state;
 
-       thread_add_write(r->master, resolver_cb_socket_writable, resfd,
-                        resfd->fd, &resfd->t_write);
+       event_add_write(r->master, resolver_cb_socket_writable, resfd,
+                       resfd->fd, &resfd->t_write);
        /* ^ ordering important:
-        * ares_process_fd may transitively call THREAD_OFF(resfd->t_write)
+        * ares_process_fd may transitively call EVENT_OFF(resfd->t_write)
         * combined with resolver_fd_drop_maybe, so resfd may be free'd after!
         */
        ares_process_fd(r->channel, ARES_SOCKET_BAD, resfd->fd);
@@ -142,13 +142,13 @@ static void resolver_update_timeouts(struct resolver_state *r)
 {
        struct timeval *tv, tvbuf;
 
-       THREAD_OFF(r->timeout);
+       EVENT_OFF(r->timeout);
        tv = ares_timeout(r->channel, NULL, &tvbuf);
        if (tv) {
                unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
 
-               thread_add_timer_msec(r->master, resolver_cb_timeout, r,
-                                     timeoutms, &r->timeout);
+               event_add_timer_msec(r->master, resolver_cb_timeout, r,
+                                    timeoutms, &r->timeout);
        }
 }
 
@@ -165,16 +165,16 @@ static void ares_socket_cb(void *data, ares_socket_t fd, int readable,
        assert(resfd->state == r);
 
        if (!readable)
-               THREAD_OFF(resfd->t_read);
+               EVENT_OFF(resfd->t_read);
        else if (!resfd->t_read)
-               thread_add_read(r->master, resolver_cb_socket_readable, resfd,
-                               fd, &resfd->t_read);
+               event_add_read(r->master, resolver_cb_socket_readable, resfd,
+                              fd, &resfd->t_read);
 
        if (!writable)
-               THREAD_OFF(resfd->t_write);
+               EVENT_OFF(resfd->t_write);
        else if (!resfd->t_write)
-               thread_add_write(r->master, resolver_cb_socket_writable, resfd,
-                                fd, &resfd->t_write);
+               event_add_write(r->master, resolver_cb_socket_writable, resfd,
+                               fd, &resfd->t_write);
 
        resolver_fd_drop_maybe(resfd);
 }
@@ -222,9 +222,9 @@ static void ares_address_cb(void *arg, int status, int timeouts,
        callback(query, NULL, i, &addr[0]);
 }
 
-static void resolver_cb_literal(struct thread *t)
+static void resolver_cb_literal(struct event *t)
 {
-       struct resolver_query *query = THREAD_ARG(t);
+       struct resolver_query *query = EVENT_ARG(t);
        void (*callback)(struct resolver_query *, const char *, int,
                         union sockunion *);
 
@@ -264,8 +264,8 @@ void resolver_resolve(struct resolver_query *query, int af, vrf_id_t vrf_id,
                /* for consistency with proper name lookup, don't call the
                 * callback immediately; defer to thread loop
                 */
-               thread_add_timer_msec(state.master, resolver_cb_literal,
-                                     query, 0, &query->literal_cb);
+               event_add_timer_msec(state.master, resolver_cb_literal, query,
+                                    0, &query->literal_cb);
                return;
        }
 
@@ -314,7 +314,7 @@ static int resolver_config_write_debug(struct vty *vty)
 }
 
 
-void resolver_init(struct thread_master *tm)
+void resolver_init(struct event_loop *tm)
 {
        struct ares_options ares_opts;