ofproto/ofproto-dpif-monitor.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "ofproto-dpif-monitor.h"
  19
  20 #include <string.h>
  21
  22 #include "bfd.h"
  23 #include "cfm.h"
  24 #include "hash.h"
  25 #include "heap.h"
  26 #include "hmap.h"
  27 #include "latch.h"
  28 #include "ofpbuf.h"
  29 #include "ofproto-dpif.h"
  30 #include "ovs-thread.h"
  31 #include "poll-loop.h"
  32 #include "seq.h"
  33 #include "timeval.h"
  34 #include "util.h"
  35 #include "vlog.h"
  36
  37 VLOG_DEFINE_THIS_MODULE(ofproto_dpif_monitor);
  38
  39 /* Converts the time in millisecond to heap priority. */
  40 #define MSEC_TO_PRIO(TIME) (LLONG_MAX - (TIME))
  41 /* Converts the heap priority to time in millisecond. */
  42 #define PRIO_TO_MSEC(PRIO) (LLONG_MAX - (PRIO))
  43
  44 /* Monitored port.  It owns references to ofport, bfd, cfm structs. */
  45 struct mport {
  46     struct hmap_node hmap_node;       /* In monitor_hmap. */
  47     struct heap_node heap_node;       /* In monitor_heap. */
  48     const struct ofport_dpif *ofport; /* The corresponding ofport. */
  49
  50     struct cfm *cfm;                  /* Reference to cfm. */
  51     struct bfd *bfd;                  /* Reference to bfd. */
  52     uint8_t hw_addr[OFP_ETH_ALEN];    /* Hardware address. */
  53 };
  54
  55 /* hmap that contains "struct mport"s. */
  56 static struct hmap monitor_hmap = HMAP_INITIALIZER(&monitor_hmap);
  57
  58 /* heap for ordering mport based on bfd/cfm wakeup time. */
  59 static struct heap monitor_heap;
  60
  61 /* The monitor thread id. */
  62 static pthread_t monitor_tid;
  63 /* True if the monitor thread is running. */
  64 static bool monitor_running;
  65
  66 static struct latch monitor_exit_latch;
  67 static struct ovs_mutex monitor_mutex = OVS_MUTEX_INITIALIZER;
  68
  69 static void *monitor_main(void *);
  70 static void monitor_run(void);
  71
  72 static void mport_register(const struct ofport_dpif *, struct bfd *,
  73                            struct cfm *, uint8_t[ETH_ADDR_LEN])
  74     OVS_REQUIRES(monitor_mutex);
  75 static void mport_unregister(const struct ofport_dpif *)
  76     OVS_REQUIRES(monitor_mutex);
  77 static void mport_update(struct mport *, struct bfd *, struct cfm *,
  78                          uint8_t[ETH_ADDR_LEN]) OVS_REQUIRES(monitor_mutex);
  79 static struct mport *mport_find(const struct ofport_dpif *)
  80     OVS_REQUIRES(monitor_mutex);
  81
  82 /* Tries finding and returning the 'mport' from the monitor_hmap.
  83  * If there is no such 'mport', returns NULL. */
  84 static struct mport *
  85 mport_find(const struct ofport_dpif *ofport) OVS_REQUIRES(monitor_mutex)
  86 {
  87     struct mport *node;
  88
  89     HMAP_FOR_EACH_WITH_HASH (node, hmap_node, hash_pointer(ofport, 0),
  90                              &monitor_hmap) {
  91         if (node->ofport == ofport) {
  92             return node;
  93         }
  94     }
  95     return NULL;
  96 }
  97
  98 /* Creates a new mport and inserts it into monitor_hmap and monitor_heap,
  99  * if it doesn't exist.  Otherwise, just updates its fields. */
 100 static void
 101 mport_register(const struct ofport_dpif *ofport, struct bfd *bfd,
 102                struct cfm *cfm, uint8_t *hw_addr)
 103     OVS_REQUIRES(monitor_mutex)
 104 {
 105     struct mport *mport = mport_find(ofport);
 106
 107     if (!mport) {
 108         mport = xzalloc(sizeof *mport);
 109         mport->ofport = ofport;
 110         hmap_insert(&monitor_hmap, &mport->hmap_node, hash_pointer(ofport, 0));
 111         heap_insert(&monitor_heap, &mport->heap_node, 0);
 112     }
 113     mport_update(mport, bfd, cfm, hw_addr);
 114 }
 115
 116 /* Removes mport from monitor_hmap and monitor_heap and frees it. */
 117 static void
 118 mport_unregister(const struct ofport_dpif *ofport)
 119     OVS_REQUIRES(monitor_mutex)
 120 {
 121     struct mport *mport = mport_find(ofport);
 122
 123     if (mport) {
 124         mport_update(mport, NULL, NULL, NULL);
 125         hmap_remove(&monitor_hmap, &mport->hmap_node);
 126         heap_remove(&monitor_heap, &mport->heap_node);
 127         free(mport);
 128     }
 129 }
 130
 131 /* Updates the fields of an existing mport struct. */
 132 static void
 133 mport_update(struct mport *mport, struct bfd *bfd, struct cfm *cfm,
 134              uint8_t hw_addr[ETH_ADDR_LEN]) OVS_REQUIRES(monitor_mutex)
 135 {
 136     ovs_assert(mport);
 137
 138     if (mport->cfm != cfm) {
 139         cfm_unref(mport->cfm);
 140         mport->cfm = cfm_ref(cfm);
 141     }
 142     if (mport->bfd != bfd) {
 143         bfd_unref(mport->bfd);
 144         mport->bfd = bfd_ref(bfd);
 145     }
 146     if (hw_addr && memcmp(mport->hw_addr, hw_addr, ETH_ADDR_LEN)) {
 147         memcpy(mport->hw_addr, hw_addr, ETH_ADDR_LEN);
 148     }
 149     /* If bfd/cfm is added or reconfigured, move the mport on top of the heap
 150      * so that the monitor thread can run the mport next time it wakes up. */
 151     if (mport->bfd || mport->cfm) {
 152         heap_change(&monitor_heap, &mport->heap_node, LLONG_MAX);
 153     }
 154 }
 155 \f
 156
 157 /* The 'main' function for the monitor thread. */
 158 static void *
 159 monitor_main(void * args OVS_UNUSED)
 160 {
 161     VLOG_INFO("monitor thread created");
 162     while (!latch_is_set(&monitor_exit_latch)) {
 163         monitor_run();
 164         latch_wait(&monitor_exit_latch);
 165         poll_block();
 166     }
 167     VLOG_INFO("monitor thread terminated");
 168     return NULL;
 169 }
 170
 171 /* The monitor thread should wake up this often to ensure that newly added or
 172  * reconfigured monitoring ports are run in a timely manner. */
 173 #define MONITOR_INTERVAL_MSEC 100
 174
 175 /* Checks the sending of control packets on mports that have timed out.
 176  * Sends the control packets if needed.  Executes bfd and cfm periodic
 177  * functions (run, wait) on those mports. */
 178 static void
 179 monitor_run(void)
 180 {
 181     uint32_t stub[512 / 4];
 182     long long int prio_now;
 183     struct ofpbuf packet;
 184
 185     ofpbuf_use_stub(&packet, stub, sizeof stub);
 186     ovs_mutex_lock(&monitor_mutex);
 187     prio_now = MSEC_TO_PRIO(time_msec());
 188     /* Peeks the top of heap and checks if we should run this mport. */
 189     while (!heap_is_empty(&monitor_heap)
 190            && heap_max(&monitor_heap)->priority >= prio_now) {
 191         long long int next_wake_time;
 192         struct mport *mport;
 193
 194         mport = CONTAINER_OF(heap_max(&monitor_heap), struct mport, heap_node);
 195         if (mport->cfm && cfm_should_send_ccm(mport->cfm)) {
 196             ofpbuf_clear(&packet);
 197             cfm_compose_ccm(mport->cfm, &packet, mport->hw_addr);
 198             ofproto_dpif_send_packet(mport->ofport, &packet);
 199         }
 200         if (mport->bfd && bfd_should_send_packet(mport->bfd)) {
 201             ofpbuf_clear(&packet);
 202             bfd_put_packet(mport->bfd, &packet, mport->hw_addr);
 203             ofproto_dpif_send_packet(mport->ofport, &packet);
 204         }
 205         if (mport->cfm) {
 206             cfm_run(mport->cfm);
 207             cfm_wait(mport->cfm);
 208         }
 209         if (mport->bfd) {
 210             bfd_run(mport->bfd);
 211             bfd_wait(mport->bfd);
 212         }
 213         /* Computes the next wakeup time for this mport. */
 214         next_wake_time = MIN(bfd_wake_time(mport->bfd),
 215                              cfm_wake_time(mport->cfm));
 216         heap_change(&monitor_heap, &mport->heap_node,
 217                     MSEC_TO_PRIO(next_wake_time));
 218     }
 219
 220     /* Waits on the earliest next wakeup time. */
 221     if (!heap_is_empty(&monitor_heap)) {
 222         long long int next_timeout, next_mport_wakeup;
 223
 224         next_timeout = time_msec() + MONITOR_INTERVAL_MSEC;
 225         next_mport_wakeup = PRIO_TO_MSEC(heap_max(&monitor_heap)->priority);
 226         poll_timer_wait_until(MIN(next_timeout, next_mport_wakeup));
 227     }
 228     ovs_mutex_unlock(&monitor_mutex);
 229     ofpbuf_uninit(&packet);
 230 }
 231 \f
 232
 233 /* Creates the mport in monitor module if either bfd or cfm
 234  * is configured.  Otherwise, deletes the mport.
 235  * Also checks whether the monitor thread should be started
 236  * or terminated. */
 237 void
 238 ofproto_dpif_monitor_port_update(const struct ofport_dpif *ofport,
 239                                  struct bfd *bfd, struct cfm *cfm,
 240                                  uint8_t hw_addr[ETH_ADDR_LEN])
 241 {
 242     ovs_mutex_lock(&monitor_mutex);
 243     if (!cfm && !bfd) {
 244         mport_unregister(ofport);
 245     } else {
 246         mport_register(ofport, bfd, cfm, hw_addr);
 247     }
 248     ovs_mutex_unlock(&monitor_mutex);
 249
 250     /* If the monitor thread is not running and the hmap
 251      * is not empty, starts it.  If it is and the hmap is empty,
 252      * terminates it. */
 253     if (!monitor_running && !hmap_is_empty(&monitor_hmap))  {
 254         latch_init(&monitor_exit_latch);
 255         monitor_tid = ovs_thread_create("monitor", monitor_main, NULL);
 256         monitor_running = true;
 257     } else if (monitor_running && hmap_is_empty(&monitor_hmap))  {
 258         latch_set(&monitor_exit_latch);
 259         xpthread_join(monitor_tid, NULL);
 260         latch_destroy(&monitor_exit_latch);
 261         monitor_running = false;
 262     }
 263 }
 264
 265 /* Moves the mport on top of the heap.  This is necessary when
 266  * for example, bfd POLL is received and the mport should
 267  * immediately send FINAL back. */
 268 void
 269 ofproto_dpif_monitor_port_send_soon_safe(const struct ofport_dpif *ofport)
 270 {
 271     ovs_mutex_lock(&monitor_mutex);
 272     ofproto_dpif_monitor_port_send_soon(ofport);
 273     ovs_mutex_unlock(&monitor_mutex);
 274 }
 275
 276 void
 277 ofproto_dpif_monitor_port_send_soon(const struct ofport_dpif *ofport)
 278     OVS_REQUIRES(monitor_mutex)
 279 {
 280     struct mport *mport;
 281
 282     mport = mport_find(ofport);
 283     if (mport) {
 284         heap_change(&monitor_heap, &mport->heap_node, LLONG_MAX);
 285     }
 286 }