From b06fa16c0efeacc453f96e5640124acdf980bae7 Mon Sep 17 00:00:00 2001

From: Numan Siddique <numans@ovn.org>

Date: Tue, 22 Oct 2019 12:28:36 +0530

Subject: [PATCH 11/12] Send service monitor health checks

ovn-controller will periodically sends out the service monitor packets

for the services configured in the SB DB Service_Monitor table. This

patch makes use of the action - handle_svc_check to handle the service

monitor reply packets from the service.

This patch supports IPv4 TCP and UDP service monitoring. For TCP services,

it sends out a TCP SYN packet and expects TCP ACK packet in response.

If the response is received on time, the status of the service is set to

"online", otherwise it is set to "offline".

For UDP services, it sends out a empty UDP packet and doesn't expect any

reply. In case the service is down, the host running the service, sends out

ICMP type 3 code 4 (destination unreachable) packet. If ovn-controller receives this

ICMP packet, it sets the status of the service to "offline".

Right now only IPv4 service monitoring is supported. An upcoming patch will add

the support for IPv6.

Change-Id: Ia8457c020b6d6cea15b1e5a73989a54430d8d9de

Acked-by: Mark Michelson <mmichels@redhat.com>

Signed-off-by: Numan Siddique <numans@ovn.org>

---

 ovn/controller/ovn-controller.c |   2 +

 ovn/controller/pinctrl.c        | 775 ++++++++++++++++++++++++++++++--

 ovn/controller/pinctrl.h        |   2 +

 ovn/northd/ovn-northd.8.xml     |  10 +

 ovn/northd/ovn-northd.c         |  18 +

 tests/ovn.at                    | 119 +++++

 tests/system-common-macros.at   |   1 +

 tests/system-ovn.at             | 180 ++++++++

 8 files changed, 1081 insertions(+), 26 deletions(-)

diff --git a/ovn/controller/ovn-controller.c b/ovn/controller/ovn-controller.c

index cb3d63cbb..f2378ab99 100644

--- a/ovn/controller/ovn-controller.c

+++ b/ovn/controller/ovn-controller.c

@@ -2046,6 +2046,8 @@ main(int argc, char *argv[])

                                 sbrec_dns_table_get(ovnsb_idl_loop.idl),

                                 sbrec_controller_event_table_get(

                                     ovnsb_idl_loop.idl),

+                                sbrec_service_monitor_table_get(

+                                    ovnsb_idl_loop.idl),

                                 br_int, chassis,

                                 &ed_runtime_data.local_datapaths,

                                 &ed_runtime_data.active_tunnels);

diff --git a/ovn/controller/pinctrl.c b/ovn/controller/pinctrl.c

index c6dd69fb3..ae1b8e1ca 100644

--- a/ovn/controller/pinctrl.c

+++ b/ovn/controller/pinctrl.c

@@ -38,6 +38,7 @@

 #include "openvswitch/ofp-switch.h"

 #include "openvswitch/ofp-util.h"

 #include "openvswitch/vlog.h"

+#include "lib/random.h"

 #include "lib/dhcp.h"

 #include "ovn-controller.h"

@@ -284,6 +285,22 @@ static void run_put_vport_bindings(

 static void wait_put_vport_bindings(struct ovsdb_idl_txn *ovnsb_idl_txn);

 static void pinctrl_handle_bind_vport(const struct flow *md,

                                       struct ofpbuf *userdata);

+static void pinctrl_handle_svc_check(struct rconn *swconn,

+                                     const struct flow *ip_flow,

+                                     struct dp_packet *pkt_in,

+                                     const struct match *md);

+static void init_svc_monitors(void);

+static void destroy_svc_monitors(void);

+static void sync_svc_monitors(

+    struct ovsdb_idl_txn *ovnsb_idl_txn,

+    const struct sbrec_service_monitor_table *svc_mon_table,

+    struct ovsdb_idl_index *sbrec_port_binding_by_name,

+    const struct sbrec_chassis *our_chassis)

+    OVS_REQUIRES(pinctrl_mutex);

+static void svc_monitors_run(struct rconn *swconn,

+                             long long int *svc_monitors_next_run_time)

+    OVS_REQUIRES(pinctrl_mutex);

+static void svc_monitors_wait(long long int svc_monitors_next_run_time);

 COVERAGE_DEFINE(pinctrl_drop_put_mac_binding);

 COVERAGE_DEFINE(pinctrl_drop_buffered_packets_map);

@@ -446,6 +463,7 @@ pinctrl_init(void)

     init_event_table();

     ip_mcast_snoop_init();

     init_put_vport_bindings();

+    init_svc_monitors();

     pinctrl.br_int_name = NULL;

     pinctrl_handler_seq = seq_create();

     pinctrl_main_seq = seq_create();

@@ -1983,6 +2001,13 @@ process_packet_in(struct rconn *swconn, const struct ofp_header *msg)

         ovs_mutex_unlock(&pinctrl_mutex);

         break;

+    case ACTION_OPCODE_HANDLE_SVC_CHECK:

+        ovs_mutex_lock(&pinctrl_mutex);

+        pinctrl_handle_svc_check(swconn, &headers, &packet,

+                                 &pin.flow_metadata);

+        ovs_mutex_unlock(&pinctrl_mutex);

+        break;

+

     default:

         VLOG_WARN_RL(&rl, "unrecognized packet-in opcode %"PRIu32,

                      ntohl(ah->opcode));

@@ -2052,6 +2077,7 @@ pinctrl_handler(void *arg_)

     static long long int send_garp_time = LLONG_MAX;

     /* Next multicast query (IGMP) in ms. */

     static long long int send_mcast_query_time = LLONG_MAX;

+    static long long int svc_monitors_next_run_time = LLONG_MAX;

     swconn = rconn_create(5, 0, DSCP_DEFAULT, 1 << OFP13_VERSION);

@@ -2112,11 +2138,16 @@ pinctrl_handler(void *arg_)

             }

         }

+        ovs_mutex_lock(&pinctrl_mutex);

+        svc_monitors_run(swconn, &svc_monitors_next_run_time);

+        ovs_mutex_unlock(&pinctrl_mutex);

+

         rconn_run_wait(swconn);

         rconn_recv_wait(swconn);

         send_garp_wait(send_garp_time);

         ipv6_ra_wait(send_ipv6_ra_time);

         ip_mcast_querier_wait(send_mcast_query_time);

+        svc_monitors_wait(svc_monitors_next_run_time);

         new_seq = seq_read(pinctrl_handler_seq);

         seq_wait(pinctrl_handler_seq, new_seq);

@@ -2142,6 +2173,7 @@ pinctrl_run(struct ovsdb_idl_txn *ovnsb_idl_txn,

             struct ovsdb_idl_index *sbrec_ip_multicast_opts,

             const struct sbrec_dns_table *dns_table,

             const struct sbrec_controller_event_table *ce_table,

+            const struct sbrec_service_monitor_table *svc_mon_table,

             const struct ovsrec_bridge *br_int,

             const struct sbrec_chassis *chassis,

             const struct hmap *local_datapaths,

@@ -2178,6 +2210,8 @@ pinctrl_run(struct ovsdb_idl_txn *ovnsb_idl_txn,

     run_buffered_binding(sbrec_port_binding_by_datapath,

                          sbrec_mac_binding_by_lport_ip,

                          local_datapaths);

+    sync_svc_monitors(ovnsb_idl_txn, svc_mon_table, sbrec_port_binding_by_name,

+                      chassis);

     ovs_mutex_unlock(&pinctrl_mutex);

 }

@@ -2726,6 +2760,7 @@ pinctrl_destroy(void)

     destroy_put_vport_bindings();

     destroy_dns_cache();

     ip_mcast_snoop_destroy();

+    destroy_svc_monitors();

     seq_destroy(pinctrl_main_seq);

     seq_destroy(pinctrl_handler_seq);

 }

@@ -3158,6 +3193,36 @@ send_garp(struct rconn *swconn, struct garp_data *garp,

     return garp->announce_time;

 }

+static void

+pinctrl_compose_ipv4(struct dp_packet *packet, struct eth_addr eth_src,

+                     struct eth_addr eth_dst, ovs_be32 ipv4_src,

+                     ovs_be32 ipv4_dst, uint8_t ip_proto, uint8_t ttl,

+                     uint16_t ip_payload_len)

+{

+    dp_packet_clear(packet);

+    packet->packet_type = htonl(PT_ETH);

+

+    struct eth_header *eh = dp_packet_put_zeros(packet, sizeof *eh);

+    eh->eth_dst = eth_dst;

+    eh->eth_src = eth_src;

+

+    struct ip_header *nh = dp_packet_put_zeros(packet, sizeof *nh);

+

+    eh->eth_type = htons(ETH_TYPE_IP);

+    dp_packet_set_l3(packet, nh);

+    nh->ip_ihl_ver = IP_IHL_VER(5, 4);

+    nh->ip_tot_len = htons(sizeof(struct ip_header) + ip_payload_len);

+    nh->ip_tos = IP_DSCP_CS6;

+    nh->ip_proto = ip_proto;

+    nh->ip_frag_off = htons(IP_DF);

+

+    /* Setting tos and ttl to 0 and 1 respectively. */

+    packet_set_ipv4(packet, ipv4_src, ipv4_dst, 0, ttl);

+

+    nh->ip_csum = 0;

+    nh->ip_csum = csum(nh, sizeof *nh);

+}

+

 /*

  * Multicast snooping configuration.

  */

@@ -3775,32 +3840,11 @@ ip_mcast_querier_send(struct rconn *swconn, struct ip_mcast_snoop *ip_ms,

     struct dp_packet packet;

     dp_packet_use_stub(&packet, packet_stub, sizeof packet_stub);

-

-    uint8_t ip_tos = 0;

-    uint8_t igmp_ttl = 1;

-

-    dp_packet_clear(&packet);

-    packet.packet_type = htonl(PT_ETH);

-

-    struct eth_header *eh = dp_packet_put_zeros(&packet, sizeof *eh);

-    eh->eth_dst = ip_ms->cfg.query_eth_dst;

-    eh->eth_src = ip_ms->cfg.query_eth_src;

-

-    struct ip_header *nh = dp_packet_put_zeros(&packet, sizeof *nh);

-

-    eh->eth_type = htons(ETH_TYPE_IP);

-    dp_packet_set_l3(&packet, nh);

-    nh->ip_ihl_ver = IP_IHL_VER(5, 4);

-    nh->ip_tot_len = htons(sizeof(struct ip_header) +

-                            sizeof(struct igmpv3_query_header));

-    nh->ip_tos = IP_DSCP_CS6;

-    nh->ip_proto = IPPROTO_IGMP;

-    nh->ip_frag_off = htons(IP_DF);

-    packet_set_ipv4(&packet, ip_ms->cfg.query_ipv4_src,

-                    ip_ms->cfg.query_ipv4_dst, ip_tos, igmp_ttl);

-

-    nh->ip_csum = 0;

-    nh->ip_csum = csum(nh, sizeof *nh);

+    pinctrl_compose_ipv4(&packet, ip_ms->cfg.query_eth_src,

+                         ip_ms->cfg.query_eth_dst,

+                         ip_ms->cfg.query_ipv4_src,

+                         ip_ms->cfg.query_ipv4_dst,

+                         IPPROTO_IGMP, 1, sizeof(struct igmpv3_query_header));

     struct igmpv3_query_header *igh =

         dp_packet_put_zeros(&packet, sizeof *igh);

@@ -4693,3 +4737,682 @@ pinctrl_handle_bind_vport(

     notify_pinctrl_main();

 }

+

+enum svc_monitor_state {

+    SVC_MON_S_INIT,

+    SVC_MON_S_WAITING,

+    SVC_MON_S_ONLINE,

+    SVC_MON_S_OFFLINE,

+};

+

+enum svc_monitor_status {

+    SVC_MON_ST_UNKNOWN,

+    SVC_MON_ST_OFFLINE,

+    SVC_MON_ST_ONLINE,

+};

+

+enum svc_monitor_protocol {

+    SVC_MON_PROTO_TCP,

+    SVC_MON_PROTO_UDP,

+};

+

+/* Service monitor health checks. */

+struct svc_monitor {

+    struct hmap_node hmap_node;

+    struct ovs_list list_node;

+

+    /* Should be accessed only with in the main ovn-controller

+     * thread. */

+    const struct sbrec_service_monitor *sb_svc_mon;

+

+    /* key */

+    struct in6_addr ip;

+    uint32_t dp_key;

+    uint32_t port_key;

+    uint32_t proto_port; /* tcp/udp port */

+

+    struct eth_addr ea;

+    long long int timestamp;

+    bool is_ip6;

+

+    long long int wait_time;

+    long long int next_send_time;

+

+    struct smap options;

+    /* The interval, in milli seconds, between service monitor checks. */

+    int interval;

+

+    /* The time, in milli seconds, after which the service monitor check

+     * times out. */

+    int svc_timeout;

+

+    /* The number of successful checks after which the service is

+     * considered online. */

+    int success_count;

+    int n_success;

+

+    /* The number of failure checks after which the service is

+     * considered offline. */

+    int failure_count;

+    int n_failures;

+

+    enum svc_monitor_protocol protocol;

+    enum svc_monitor_state state;

+    enum svc_monitor_status status;

+    struct dp_packet pkt;

+

+    uint32_t seq_no;

+    ovs_be16 tp_src;

+

+    bool delete;

+};

+

+static struct hmap svc_monitors_map;

+static struct ovs_list svc_monitors;

+

+static void

+init_svc_monitors(void)

+{

+    hmap_init(&svc_monitors_map);

+    ovs_list_init(&svc_monitors);

+}

+

+static void

+destroy_svc_monitors(void)

+{

+    struct svc_monitor *svc;

+    HMAP_FOR_EACH_POP (svc, hmap_node, &svc_monitors_map) {

+

+    }

+

+    hmap_destroy(&svc_monitors_map);

+

+    LIST_FOR_EACH_POP (svc, list_node, &svc_monitors) {

+        smap_destroy(&svc->options);

+        free(svc);

+    }

+}

+

+

+static struct svc_monitor *

+pinctrl_find_svc_monitor(uint32_t dp_key, uint32_t port_key,

+                         const struct in6_addr *ip_key, uint32_t port,

+                         enum svc_monitor_protocol protocol,

+                         uint32_t hash)

+{

+    struct svc_monitor *svc;

+    HMAP_FOR_EACH_WITH_HASH (svc, hmap_node, hash, &svc_monitors_map) {

+        if (svc->dp_key == dp_key

+            && svc->port_key == port_key

+            && svc->proto_port == port

+            && IN6_ARE_ADDR_EQUAL(&svc->ip, ip_key)

+            && svc->protocol == protocol) {

+            return svc;

+        }

+    }

+    return NULL;

+}

+

+static void

+sync_svc_monitors(struct ovsdb_idl_txn *ovnsb_idl_txn,

+                  const struct sbrec_service_monitor_table *svc_mon_table,

+                  struct ovsdb_idl_index *sbrec_port_binding_by_name,

+                  const struct sbrec_chassis *our_chassis)

+    OVS_REQUIRES(pinctrl_mutex)

+{

+    bool changed = false;

+    struct svc_monitor *svc_mon;

+

+    LIST_FOR_EACH (svc_mon, list_node, &svc_monitors) {

+        svc_mon->delete = true;

+    }

+

+    const struct sbrec_service_monitor *sb_svc_mon;

+    SBREC_SERVICE_MONITOR_TABLE_FOR_EACH (sb_svc_mon, svc_mon_table) {

+        const struct sbrec_port_binding *pb

+            = lport_lookup_by_name(sbrec_port_binding_by_name,

+                                   sb_svc_mon->logical_port);

+        if (!pb) {

+            continue;

+        }

+

+        if (pb->chassis != our_chassis) {

+            continue;

+        }

+

+        struct in6_addr ip_addr;

+        ovs_be32 ip4;

+        if (ip_parse(sb_svc_mon->ip, &ip4)) {

+            ip_addr = in6_addr_mapped_ipv4(ip4);

+        } else {

+            continue;

+        }

+

+        struct eth_addr ea;

+        bool mac_found = false;

+        for (size_t i = 0; i < pb->n_mac; i++) {

+            struct lport_addresses laddrs;

+            if (!extract_lsp_addresses(pb->mac[i], &laddrs)) {

+                continue;

+            }

+

+            for (size_t j = 0; j < laddrs.n_ipv4_addrs; j++) {

+                if (ip4 == laddrs.ipv4_addrs[j].addr) {

+                    ea = laddrs.ea;

+                    mac_found = true;

+                    break;

+                }

+            }

+

+            if (mac_found) {

+                break;

+            }

+        }

+

+        if (!mac_found) {

+            continue;

+        }

+

+        uint32_t dp_key = pb->datapath->tunnel_key;

+        uint32_t port_key = pb->tunnel_key;

+        uint32_t hash =

+            hash_bytes(&ip_addr, sizeof ip_addr,

+                       hash_3words(dp_key, port_key, sb_svc_mon->port));

+

+        enum svc_monitor_protocol protocol;

+        if (!sb_svc_mon->protocol || strcmp(sb_svc_mon->protocol, "udp")) {

+            protocol = SVC_MON_PROTO_TCP;

+        } else {

+            protocol = SVC_MON_PROTO_UDP;

+        }

+

+        svc_mon = pinctrl_find_svc_monitor(dp_key, port_key, &ip_addr,

+                                           sb_svc_mon->port, protocol, hash);

+

+        if (!svc_mon) {

+            svc_mon = xmalloc(sizeof *svc_mon);

+            svc_mon->dp_key = dp_key;

+            svc_mon->port_key = port_key;

+            svc_mon->proto_port = sb_svc_mon->port;

+            svc_mon->ip = ip_addr;

+            svc_mon->is_ip6 = false;

+            svc_mon->state = SVC_MON_S_INIT;

+            svc_mon->status = SVC_MON_ST_UNKNOWN;

+            svc_mon->protocol = protocol;

+

+            smap_init(&svc_mon->options);

+            svc_mon->interval =

+                smap_get_int(&svc_mon->options, "interval", 5) * 1000;

+            svc_mon->svc_timeout =

+                smap_get_int(&svc_mon->options, "timeout", 3) * 1000;

+            svc_mon->success_count =

+                smap_get_int(&svc_mon->options, "success_count", 1);

+            svc_mon->failure_count =

+                smap_get_int(&svc_mon->options, "failure_count", 1);

+            svc_mon->n_success = 0;

+            svc_mon->n_failures = 0;

+

+            hmap_insert(&svc_monitors_map, &svc_mon->hmap_node, hash);

+            ovs_list_push_back(&svc_monitors, &svc_mon->list_node);

+            changed = true;

+        }

+

+        svc_mon->sb_svc_mon = sb_svc_mon;

+        svc_mon->ea = ea;

+        if (!smap_equal(&svc_mon->options, &sb_svc_mon->options)) {

+            smap_destroy(&svc_mon->options);

+            smap_clone(&svc_mon->options, &sb_svc_mon->options);

+            svc_mon->interval =

+                smap_get_int(&svc_mon->options, "interval", 5) * 1000;

+            svc_mon->svc_timeout =

+                smap_get_int(&svc_mon->options, "timeout", 3) * 1000;

+            svc_mon->success_count =

+                smap_get_int(&svc_mon->options, "success_count", 1);

+            svc_mon->failure_count =

+                smap_get_int(&svc_mon->options, "failure_count", 1);

+            changed = true;

+        }

+

+        svc_mon->delete = false;

+    }

+

+    struct svc_monitor *next;

+    LIST_FOR_EACH_SAFE (svc_mon, next, list_node, &svc_monitors) {

+        if (svc_mon->delete) {

+            hmap_remove(&svc_monitors_map, &svc_mon->hmap_node);

+            ovs_list_remove(&svc_mon->list_node);

+            smap_destroy(&svc_mon->options);

+            free(svc_mon);

+            changed = true;

+        } else if (ovnsb_idl_txn) {

+            /* Update the status of the service monitor. */

+            if (svc_mon->status != SVC_MON_ST_UNKNOWN) {

+                if (svc_mon->status == SVC_MON_ST_ONLINE) {

+                    sbrec_service_monitor_set_status(svc_mon->sb_svc_mon,

+                                                     "online");

+                } else {

+                    sbrec_service_monitor_set_status(svc_mon->sb_svc_mon,

+                                                     "offline");

+                }

+            }

+        }

+    }

+

+    if (changed) {

+        notify_pinctrl_handler();

+    }

+

+}

+

+static uint16_t

+get_random_src_port(void)

+{

+    uint16_t random_src_port = random_uint16();

+    while (random_src_port < 1024) {

+        random_src_port = random_uint16();

+    }

+

+    return random_src_port;

+}

+

+static void

+svc_monitor_send_tcp_health_check__(struct rconn *swconn,

+                                    struct svc_monitor *svc_mon,

+                                    uint16_t ctl_flags,

+                                    ovs_be32 tcp_seq,

+                                    ovs_be32 tcp_ack,

+                                    ovs_be16 tcp_src)

+{

+    if (svc_mon->is_ip6) {

+        return;

+    }

+

+    /* Compose a TCP-SYN packet. */

+    uint64_t packet_stub[128 / 8];

+    struct dp_packet packet;

+

+    struct eth_addr eth_src;

+    eth_addr_from_string(svc_mon->sb_svc_mon->src_mac, &eth_src);

+    ovs_be32 ip4_src;

+    ip_parse(svc_mon->sb_svc_mon->src_ip, &ip4_src);

+

+    dp_packet_use_stub(&packet, packet_stub, sizeof packet_stub);

+    pinctrl_compose_ipv4(&packet, eth_src, svc_mon->ea,

+                         ip4_src, in6_addr_get_mapped_ipv4(&svc_mon->ip),

+                         IPPROTO_TCP, 63, TCP_HEADER_LEN);

+

+    struct tcp_header *th = dp_packet_put_zeros(&packet, sizeof *th);

+    dp_packet_set_l4(&packet, th);

+    th->tcp_dst = htons(svc_mon->proto_port);

+    th->tcp_src = tcp_src;

+

+    th->tcp_ctl = htons((5 << 12) | ctl_flags);

+    put_16aligned_be32(&th->tcp_seq, tcp_seq);

+    put_16aligned_be32(&th->tcp_ack, tcp_ack);

+

+    th->tcp_winsz = htons(65160);

+

+    uint32_t csum;

+    csum = packet_csum_pseudoheader(dp_packet_l3(&packet));

+    csum = csum_continue(csum, th, dp_packet_size(&packet) -

+                         ((const unsigned char *)th -

+                         (const unsigned char *)dp_packet_eth(&packet)));

+    th->tcp_csum = csum_finish(csum);

+

+    uint64_t ofpacts_stub[4096 / 8];

+    struct ofpbuf ofpacts = OFPBUF_STUB_INITIALIZER(ofpacts_stub);

+    enum ofp_version version = rconn_get_version(swconn);

+    put_load(svc_mon->dp_key, MFF_LOG_DATAPATH, 0, 64, &ofpacts);

+    put_load(svc_mon->port_key, MFF_LOG_OUTPORT, 0, 32, &ofpacts);

+    put_load(1, MFF_LOG_FLAGS, MLF_LOCAL_ONLY, 1, &ofpacts);

+    struct ofpact_resubmit *resubmit = ofpact_put_RESUBMIT(&ofpacts);

+    resubmit->in_port = OFPP_CONTROLLER;

+    resubmit->table_id = OFTABLE_LOCAL_OUTPUT;

+

+    struct ofputil_packet_out po = {

+        .packet = dp_packet_data(&packet),

+        .packet_len = dp_packet_size(&packet),

+        .buffer_id = UINT32_MAX,

+        .ofpacts = ofpacts.data,

+        .ofpacts_len = ofpacts.size,

+    };

+    match_set_in_port(&po.flow_metadata, OFPP_CONTROLLER);

+    enum ofputil_protocol proto = ofputil_protocol_from_ofp_version(version);

+    queue_msg(swconn, ofputil_encode_packet_out(&po, proto));

+    dp_packet_uninit(&packet);

+    ofpbuf_uninit(&ofpacts);

+}

+

+static void

+svc_monitor_send_udp_health_check(struct rconn *swconn,

+                                  struct svc_monitor *svc_mon,

+                                  ovs_be16 udp_src)

+{

+    if (svc_mon->is_ip6) {

+        return;

+    }

+

+    struct eth_addr eth_src;

+    eth_addr_from_string(svc_mon->sb_svc_mon->src_mac, &eth_src);

+    ovs_be32 ip4_src;

+    ip_parse(svc_mon->sb_svc_mon->src_ip, &ip4_src);

+

+    uint64_t packet_stub[128 / 8];

+    struct dp_packet packet;

+    dp_packet_use_stub(&packet, packet_stub, sizeof packet_stub);

+    pinctrl_compose_ipv4(&packet, eth_src, svc_mon->ea,

+                         ip4_src, in6_addr_get_mapped_ipv4(&svc_mon->ip),

+                         IPPROTO_UDP, 63, UDP_HEADER_LEN + 8);

+

+    struct udp_header *uh = dp_packet_put_zeros(&packet, sizeof *uh);

+    dp_packet_set_l4(&packet, uh);

+    uh->udp_dst = htons(svc_mon->proto_port);

+    uh->udp_src = udp_src;

+    uh->udp_len = htons(UDP_HEADER_LEN + 8);

+    uh->udp_csum = 0;

+    dp_packet_put_zeros(&packet, 8);

+

+    uint64_t ofpacts_stub[4096 / 8];

+    struct ofpbuf ofpacts = OFPBUF_STUB_INITIALIZER(ofpacts_stub);

+    enum ofp_version version = rconn_get_version(swconn);

+    put_load(svc_mon->dp_key, MFF_LOG_DATAPATH, 0, 64, &ofpacts);

+    put_load(svc_mon->port_key, MFF_LOG_OUTPORT, 0, 32, &ofpacts);

+    put_load(1, MFF_LOG_FLAGS, MLF_LOCAL_ONLY, 1, &ofpacts);

+    struct ofpact_resubmit *resubmit = ofpact_put_RESUBMIT(&ofpacts);

+    resubmit->in_port = OFPP_CONTROLLER;

+    resubmit->table_id = OFTABLE_LOCAL_OUTPUT;

+

+    struct ofputil_packet_out po = {

+        .packet = dp_packet_data(&packet),

+        .packet_len = dp_packet_size(&packet),

+        .buffer_id = UINT32_MAX,

+        .ofpacts = ofpacts.data,

+        .ofpacts_len = ofpacts.size,

+    };

+    match_set_in_port(&po.flow_metadata, OFPP_CONTROLLER);

+    enum ofputil_protocol proto = ofputil_protocol_from_ofp_version(version);

+    queue_msg(swconn, ofputil_encode_packet_out(&po, proto));

+    dp_packet_uninit(&packet);

+    ofpbuf_uninit(&ofpacts);

+}

+

+static void

+svc_monitor_send_health_check(struct rconn *swconn,

+                              struct svc_monitor *svc_mon)

+{

+    if (svc_mon->protocol == SVC_MON_PROTO_TCP) {

+        svc_mon->seq_no = random_uint32();

+        svc_mon->tp_src = htons(get_random_src_port());

+        svc_monitor_send_tcp_health_check__(swconn, svc_mon,

+                                            TCP_SYN,

+                                            htonl(svc_mon->seq_no), htonl(0),

+                                            svc_mon->tp_src);

+    } else {

+        if (!svc_mon->tp_src) {

+            svc_mon->tp_src = htons(get_random_src_port());

+        }

+        svc_monitor_send_udp_health_check(swconn, svc_mon, svc_mon->tp_src);

+    }

+

+    svc_mon->wait_time = time_msec() + svc_mon->svc_timeout;

+    svc_mon->state = SVC_MON_S_WAITING;

+}

+

+static void

+svc_monitors_run(struct rconn *swconn,

+                 long long int *svc_monitors_next_run_time)

+    OVS_REQUIRES(pinctrl_mutex)

+{

+    *svc_monitors_next_run_time = LLONG_MAX;

+    struct svc_monitor *svc_mon;

+    LIST_FOR_EACH (svc_mon, list_node, &svc_monitors) {

+        char ip_[INET6_ADDRSTRLEN + 1];

+        memset(ip_, 0, INET6_ADDRSTRLEN + 1);

+        ipv6_string_mapped(ip_, &svc_mon->ip);

+

+        long long int current_time = time_msec();

+        long long int next_run_time = LLONG_MAX;

+        enum svc_monitor_status old_status = svc_mon->status;

+        switch (svc_mon->state) {

+        case SVC_MON_S_INIT:

+            svc_monitor_send_health_check(swconn, svc_mon);

+            next_run_time = svc_mon->wait_time;

+            break;

+

+        case SVC_MON_S_WAITING:

+            if (current_time > svc_mon->wait_time) {

+                if (svc_mon->protocol ==  SVC_MON_PROTO_TCP) {

+                    svc_mon->n_failures++;

+                    svc_mon->state = SVC_MON_S_OFFLINE;

+                } else {

+                    svc_mon->n_success++;

+                    svc_mon->state = SVC_MON_S_ONLINE;

+                }

+                svc_mon->next_send_time = current_time + svc_mon->interval;

+                next_run_time = svc_mon->next_send_time;

+            } else {

+                next_run_time = svc_mon->wait_time - current_time;

+                next_run_time = svc_mon->wait_time;

+            }

+            break;

+

+        case SVC_MON_S_ONLINE:

+            if (svc_mon->n_success >= svc_mon->success_count) {

+                svc_mon->status = SVC_MON_ST_ONLINE;

+                svc_mon->n_success = 0;

+            }

+            if (current_time >= svc_mon->next_send_time) {

+                svc_monitor_send_health_check(swconn, svc_mon);

+                next_run_time = svc_mon->wait_time;

+            } else {

+                next_run_time = svc_mon->next_send_time;

+            }

+            break;

+

+        case SVC_MON_S_OFFLINE:

+            if (svc_mon->n_failures >= svc_mon->failure_count) {

+                svc_mon->status = SVC_MON_ST_OFFLINE;

+                svc_mon->n_failures = 0;

+            }

+

+            if (current_time >= svc_mon->next_send_time) {

+                svc_monitor_send_health_check(swconn, svc_mon);

+                next_run_time = svc_mon->wait_time;

+            } else {

+                next_run_time = svc_mon->next_send_time;