#include "bfd.h"
#include "cfm.h"
#include "hash.h"
+#include "heap.h"
#include "hmap.h"
#include "latch.h"
#include "ofpbuf.h"
#include "ovs-thread.h"
#include "poll-loop.h"
#include "seq.h"
+#include "timeval.h"
#include "util.h"
#include "vlog.h"
VLOG_DEFINE_THIS_MODULE(ofproto_dpif_monitor);
+/* Converts the time in millisecond to heap priority. */
+#define MSEC_TO_PRIO(TIME) (LLONG_MAX - (TIME))
+/* Converts the heap priority to time in millisecond. */
+#define PRIO_TO_MSEC(PRIO) (LLONG_MAX - (PRIO))
+
/* Monitored port. It owns references to ofport, bfd, cfm structs. */
struct mport {
struct hmap_node hmap_node; /* In monitor_hmap. */
+ struct heap_node heap_node; /* In monitor_heap. */
const struct ofport_dpif *ofport; /* The corresponding ofport. */
struct cfm *cfm; /* Reference to cfm. */
};
/* hmap that contains "struct mport"s. */
-static struct hmap monitor_hmap = HMAP_INITIALIZER(&monitor_hmap);
+static struct hmap monitor_hmap;
+
+/* heap for ordering mport based on bfd/cfm wakeup time. */
+static struct heap monitor_heap;
/* The monitor thread id. */
static pthread_t monitor_tid;
/* True if the monitor thread is running. */
static bool monitor_running;
-static struct seq *monitor_seq;
static struct latch monitor_exit_latch;
static struct ovs_rwlock monitor_rwlock = OVS_RWLOCK_INITIALIZER;
return NULL;
}
-/* Creates a new mport and inserts it into monitor_hmap, if it doesn't exist.
- * Otherwise, just updates its fields. */
+/* Creates a new mport and inserts it into monitor_hmap and monitor_heap,
+ * if it doesn't exist. Otherwise, just updates its fields. */
static void
mport_register(const struct ofport_dpif *ofport, struct bfd *bfd,
struct cfm *cfm, uint8_t *hw_addr)
mport = xzalloc(sizeof *mport);
mport->ofport = ofport;
hmap_insert(&monitor_hmap, &mport->hmap_node, hash_pointer(ofport, 0));
+ heap_insert(&monitor_heap, &mport->heap_node, 0);
}
mport_update(mport, bfd, cfm, hw_addr);
}
-/* Removes mport from monitor_hmap and frees it. */
+/* Removes mport from monitor_hmap and monitor_heap and frees it. */
static void
mport_unregister(const struct ofport_dpif *ofport)
OVS_REQ_WRLOCK(monitor_rwlock)
if (mport) {
mport_update(mport, NULL, NULL, NULL);
hmap_remove(&monitor_hmap, &mport->hmap_node);
+ heap_remove(&monitor_heap, &mport->heap_node);
free(mport);
}
}
if (hw_addr && memcmp(mport->hw_addr, hw_addr, ETH_ADDR_LEN)) {
memcpy(mport->hw_addr, hw_addr, ETH_ADDR_LEN);
}
- /* If bfd/cfm is added or reconfigured, wakes up the monitor thread. */
+ /* If bfd/cfm is added or reconfigured, move the mport on top of the heap
+ * so that the monitor thread can run the mport next time it wakes up. */
if (mport->bfd || mport->cfm) {
- seq_change(monitor_seq);
+ heap_change(&monitor_heap, &mport->heap_node, LLONG_MAX);
}
}
\f
if (ovsthread_once_start(&once)) {
hmap_init(&monitor_hmap);
- monitor_seq = seq_create();
ovsthread_once_done(&once);
}
}
set_subprogram_name("monitor");
VLOG_INFO("monitor thread created");
while (!latch_is_set(&monitor_exit_latch)) {
- uint64_t seq = seq_read(monitor_seq);
-
monitor_run();
latch_wait(&monitor_exit_latch);
- seq_wait(monitor_seq, seq);
poll_block();
}
VLOG_INFO("monitor thread terminated");
return NULL;
}
-/* Checks the sending of control packets on all mports. Sends the control
- * packets if needed. Executes bfd and cfm periodic functions (run, wait)
- * on all mports. */
+/* The monitor thread should wake up this often to ensure that newly added or
+ * reconfigured monitoring ports are run in a timely manner. */
+#define MONITOR_INTERVAL_MSEC 100
+
+/* Checks the sending of control packets on mports that have timed out.
+ * Sends the control packets if needed. Executes bfd and cfm periodic
+ * functions (run, wait) on those mports. */
static void
monitor_run(void)
{
uint32_t stub[512 / 4];
+ long long int prio_now;
struct ofpbuf packet;
- struct mport *mport;
ofpbuf_use_stub(&packet, stub, sizeof stub);
ovs_rwlock_rdlock(&monitor_rwlock);
- HMAP_FOR_EACH (mport, hmap_node, &monitor_hmap) {
+ prio_now = MSEC_TO_PRIO(time_msec());
+ /* Peeks the top of heap and checks if we should run this mport. */
+ while (!heap_is_empty(&monitor_heap)
+ && heap_max(&monitor_heap)->priority >= prio_now) {
+ long long int next_wake_time;
+ struct mport *mport;
+
+ mport = CONTAINER_OF(heap_max(&monitor_heap), struct mport, heap_node);
if (mport->cfm && cfm_should_send_ccm(mport->cfm)) {
ofpbuf_clear(&packet);
cfm_compose_ccm(mport->cfm, &packet, mport->hw_addr);
bfd_run(mport->bfd);
bfd_wait(mport->bfd);
}
+ /* Computes the next wakeup time for this mport. */
+ next_wake_time = MIN(bfd_wake_time(mport->bfd), cfm_wake_time(mport->cfm));
+ heap_change(&monitor_heap, heap_max(&monitor_heap),
+ MSEC_TO_PRIO(next_wake_time));
+ }
+
+ /* Waits on the earliest next wakeup time. */
+ if (!heap_is_empty(&monitor_heap)) {
+ long long int next_timeout, next_mport_wakeup;
+
+ next_timeout = time_msec() + MONITOR_INTERVAL_MSEC;
+ next_mport_wakeup = PRIO_TO_MSEC(heap_max(&monitor_heap)->priority);
+ poll_timer_wait_until(MIN(next_timeout, next_mport_wakeup));
}
ovs_rwlock_unlock(&monitor_rwlock);
ofpbuf_uninit(&packet);
git://git.onelab.eu / sliver-openvswitch.git / blobdiff