X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Fofproto-dpif-monitor.c;h=054840016b2bd9c87479e5b13c13b7c8942c1078;hb=9167fc1ae524e6ef33e706daf38e77af9188d8d2;hp=b5217357a8926793605f978d6674632abf182f69;hpb=69555fc1014349e6044ecd67846a18140bd5b954;p=cascardo%2Fovs.git

diff --git a/ofproto/ofproto-dpif-monitor.c b/ofproto/ofproto-dpif-monitor.c
index b5217357a..054840016 100644
--- a/ofproto/ofproto-dpif-monitor.c
+++ b/ofproto/ofproto-dpif-monitor.c
@@ -21,18 +21,21 @@
 
 #include "bfd.h"
 #include "cfm.h"
+#include "dp-packet.h"
+#include "guarded-list.h"
 #include "hash.h"
 #include "heap.h"
 #include "hmap.h"
 #include "latch.h"
 #include "ofpbuf.h"
 #include "ofproto-dpif.h"
+#include "ovs-lldp.h"
 #include "ovs-thread.h"
 #include "poll-loop.h"
 #include "seq.h"
 #include "timeval.h"
 #include "util.h"
-#include "vlog.h"
+#include "openvswitch/vlog.h"
 
 VLOG_DEFINE_THIS_MODULE(ofproto_dpif_monitor);
 
@@ -41,7 +44,7 @@ VLOG_DEFINE_THIS_MODULE(ofproto_dpif_monitor);
 /* 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. */
+/* Monitored port.  It owns references to ofport, bfd, cfm, and lldp structs. */
 struct mport {
     struct hmap_node hmap_node;       /* In monitor_hmap. */
     struct heap_node heap_node;       /* In monitor_heap. */
@@ -49,7 +52,16 @@ struct mport {
 
     struct cfm *cfm;                  /* Reference to cfm. */
     struct bfd *bfd;                  /* Reference to bfd. */
-    uint8_t hw_addr[OFP_ETH_ALEN];    /* Hardware address. */
+    struct lldp *lldp;                /* Reference to lldp. */
+    struct eth_addr hw_addr;          /* Hardware address. */
+};
+
+/* Entry of the 'send_soon' list.  Contains the pointer to the
+ * 'ofport_dpif'.  Note, the pointed object is not protected, so
+ * users should always use the mport_find() to convert it to 'mport'. */
+struct send_soon_entry {
+    struct ovs_list list_node;        /* In send_soon. */
+    const struct ofport_dpif *ofport;
 };
 
 /* hmap that contains "struct mport"s. */
@@ -58,6 +70,10 @@ static struct hmap monitor_hmap = HMAP_INITIALIZER(&monitor_hmap);
 /* heap for ordering mport based on bfd/cfm wakeup time. */
 static struct heap monitor_heap;
 
+/* guarded-list for storing the mports that need to send bfd/cfm control
+ * packet soon. */
+static struct guarded_list send_soon = GUARDED_OVS_LIST_INITIALIZER(&send_soon);
+
 /* The monitor thread id. */
 static pthread_t monitor_tid;
 /* True if the monitor thread is running. */
@@ -67,15 +83,19 @@ static struct latch monitor_exit_latch;
 static struct ovs_mutex monitor_mutex = OVS_MUTEX_INITIALIZER;
 
 static void *monitor_main(void *);
+static void monitor_check_send_soon(struct dp_packet *);
 static void monitor_run(void);
+static void monitor_mport_run(struct mport *, struct dp_packet *);
 
 static void mport_register(const struct ofport_dpif *, struct bfd *,
-                           struct cfm *, uint8_t[ETH_ADDR_LEN])
+                           struct cfm *, struct lldp *,
+                           const struct eth_addr *)
     OVS_REQUIRES(monitor_mutex);
 static void mport_unregister(const struct ofport_dpif *)
     OVS_REQUIRES(monitor_mutex);
 static void mport_update(struct mport *, struct bfd *, struct cfm *,
-                         uint8_t[ETH_ADDR_LEN]) OVS_REQUIRES(monitor_mutex);
+                         struct lldp *, const struct eth_addr *)
+    OVS_REQUIRES(monitor_mutex);
 static struct mport *mport_find(const struct ofport_dpif *)
     OVS_REQUIRES(monitor_mutex);
 
@@ -99,7 +119,8 @@ mport_find(const struct ofport_dpif *ofport) OVS_REQUIRES(monitor_mutex)
  * 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)
+               struct cfm *cfm, struct lldp *lldp,
+               const struct eth_addr *hw_addr)
     OVS_REQUIRES(monitor_mutex)
 {
     struct mport *mport = mport_find(ofport);
@@ -110,7 +131,7 @@ mport_register(const struct ofport_dpif *ofport, struct bfd *bfd,
         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);
+    mport_update(mport, bfd, cfm, lldp, hw_addr);
 }
 
 /* Removes mport from monitor_hmap and monitor_heap and frees it. */
@@ -121,7 +142,7 @@ mport_unregister(const struct ofport_dpif *ofport)
     struct mport *mport = mport_find(ofport);
 
     if (mport) {
-        mport_update(mport, NULL, NULL, NULL);
+        mport_update(mport, NULL, NULL, NULL, NULL);
         hmap_remove(&monitor_hmap, &mport->hmap_node);
         heap_remove(&monitor_heap, &mport->heap_node);
         free(mport);
@@ -131,7 +152,8 @@ mport_unregister(const struct ofport_dpif *ofport)
 /* Updates the fields of an existing mport struct. */
 static void
 mport_update(struct mport *mport, struct bfd *bfd, struct cfm *cfm,
-             uint8_t hw_addr[ETH_ADDR_LEN]) OVS_REQUIRES(monitor_mutex)
+             struct lldp *lldp, const struct eth_addr *hw_addr)
+    OVS_REQUIRES(monitor_mutex)
 {
     ovs_assert(mport);
 
@@ -143,12 +165,16 @@ mport_update(struct mport *mport, struct bfd *bfd, struct cfm *cfm,
         bfd_unref(mport->bfd);
         mport->bfd = bfd_ref(bfd);
     }
-    if (hw_addr && memcmp(mport->hw_addr, hw_addr, ETH_ADDR_LEN)) {
-        memcpy(mport->hw_addr, hw_addr, ETH_ADDR_LEN);
+    if (mport->lldp != lldp) {
+        lldp_unref(mport->lldp);
+        mport->lldp = lldp_ref(lldp);
+    }
+    if (hw_addr && !eth_addr_equals(mport->hw_addr, *hw_addr)) {
+        mport->hw_addr = *hw_addr;
     }
-    /* If bfd/cfm is added or reconfigured, move the mport on top of the heap
+    /* If bfd/cfm/lldp 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) {
+    if (mport->bfd || mport->cfm || mport->lldp) {
         heap_change(&monitor_heap, &mport->heap_node, LLONG_MAX);
     }
 }
@@ -158,7 +184,6 @@ mport_update(struct mport *mport, struct bfd *bfd, struct cfm *cfm,
 static void *
 monitor_main(void * args OVS_UNUSED)
 {
-    set_subprogram_name("monitor");
     VLOG_INFO("monitor thread created");
     while (!latch_is_set(&monitor_exit_latch)) {
         monitor_run();
@@ -173,51 +198,37 @@ monitor_main(void * args OVS_UNUSED)
  * 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. */
+/* Checks the 'send_soon' list and the heap for mports that have timed
+ * out bfd/cfm sessions. */
 static void
 monitor_run(void)
 {
     uint32_t stub[512 / 4];
     long long int prio_now;
-    struct ofpbuf packet;
+    struct dp_packet packet;
 
-    ofpbuf_use_stub(&packet, stub, sizeof stub);
+    dp_packet_use_stub(&packet, stub, sizeof stub);
     ovs_mutex_lock(&monitor_mutex);
+
+    /* The monitor_check_send_soon() needs to be run twice.  The first
+     * time is for preventing the same 'mport' from being processed twice
+     * (i.e. once from heap, the other from the 'send_soon' array).
+     * The second run is to cover the case when the control packet is sent
+     * via patch port and the other end needs to send back immediately. */
+    monitor_check_send_soon(&packet);
+
     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);
-            ofproto_dpif_send_packet(mport->ofport, &packet);
-        }
-        if (mport->bfd && bfd_should_send_packet(mport->bfd)) {
-            ofpbuf_clear(&packet);
-            bfd_put_packet(mport->bfd, &packet, mport->hw_addr);
-            ofproto_dpif_send_packet(mport->ofport, &packet);
-        }
-        if (mport->cfm) {
-            cfm_run(mport->cfm);
-            cfm_wait(mport->cfm);
-        }
-        if (mport->bfd) {
-            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, &mport->heap_node,
-                    MSEC_TO_PRIO(next_wake_time));
+        monitor_mport_run(mport, &packet);
     }
 
+    monitor_check_send_soon(&packet);
+
     /* Waits on the earliest next wakeup time. */
     if (!heap_is_empty(&monitor_heap)) {
         long long int next_timeout, next_mport_wakeup;
@@ -227,7 +238,75 @@ monitor_run(void)
         poll_timer_wait_until(MIN(next_timeout, next_mport_wakeup));
     }
     ovs_mutex_unlock(&monitor_mutex);
-    ofpbuf_uninit(&packet);
+    dp_packet_uninit(&packet);
+}
+
+/* Checks the 'send_soon' list for any mport that needs to send cfm/bfd
+ * control packet immediately, and calls monitor_mport_run(). */
+static void
+monitor_check_send_soon(struct dp_packet *packet)
+    OVS_REQUIRES(monitor_mutex)
+{
+    while (!guarded_list_is_empty(&send_soon)) {
+        struct send_soon_entry *entry;
+        struct mport *mport;
+
+        entry = CONTAINER_OF(guarded_list_pop_front(&send_soon),
+                             struct send_soon_entry, list_node);
+        mport = mport_find(entry->ofport);
+        if (mport) {
+            monitor_mport_run(mport, packet);
+        }
+        free(entry);
+    }
+}
+
+/* Checks the sending of control packet on 'mport'.  Sends the control
+ * packet if needed.  Executes bfd and cfm periodic functions (run, wait)
+ * on 'mport'.  And changes the location of 'mport' in heap based on next
+ * timeout. */
+static void
+monitor_mport_run(struct mport *mport, struct dp_packet *packet)
+    OVS_REQUIRES(monitor_mutex)
+{
+    long long int next_wake_time;
+    long long int bfd_wake_time = LLONG_MAX;
+    long long int cfm_wake_time = LLONG_MAX;
+    long long int lldp_wake_time = LLONG_MAX;
+
+    if (mport->cfm && cfm_should_send_ccm(mport->cfm)) {
+        dp_packet_clear(packet);
+        cfm_compose_ccm(mport->cfm, packet, mport->hw_addr);
+        ofproto_dpif_send_packet(mport->ofport, packet);
+    }
+    if (mport->bfd && bfd_should_send_packet(mport->bfd)) {
+        dp_packet_clear(packet);
+        bfd_put_packet(mport->bfd, packet, mport->hw_addr);
+        ofproto_dpif_send_packet(mport->ofport, packet);
+    }
+    if (mport->lldp && lldp_should_send_packet(mport->lldp)) {
+        dp_packet_clear(packet);
+        lldp_put_packet(mport->lldp, packet, mport->hw_addr);
+        ofproto_dpif_send_packet(mport->ofport, packet);
+    }
+
+    if (mport->cfm) {
+        cfm_run(mport->cfm);
+        cfm_wake_time = cfm_wait(mport->cfm);
+    }
+    if (mport->bfd) {
+        bfd_run(mport->bfd);
+        bfd_wake_time = bfd_wait(mport->bfd);
+    }
+    if (mport->lldp) {
+        lldp_wake_time = lldp_wait(mport->lldp);
+    }
+    /* Computes the next wakeup time for this mport. */
+    next_wake_time = MIN(bfd_wake_time,
+                         cfm_wake_time);
+    next_wake_time = MIN(next_wake_time, lldp_wake_time);
+    heap_change(&monitor_heap, &mport->heap_node,
+                MSEC_TO_PRIO(next_wake_time));
 }
 
 
@@ -238,13 +317,14 @@ monitor_run(void)
 void
 ofproto_dpif_monitor_port_update(const struct ofport_dpif *ofport,
                                  struct bfd *bfd, struct cfm *cfm,
-                                 uint8_t hw_addr[ETH_ADDR_LEN])
+                                 struct lldp *lldp,
+                                 const struct eth_addr *hw_addr)
 {
     ovs_mutex_lock(&monitor_mutex);
-    if (!cfm && !bfd) {
+    if (!cfm && !bfd && !lldp) {
         mport_unregister(ofport);
     } else {
-        mport_register(ofport, bfd, cfm, hw_addr);
+        mport_register(ofport, bfd, cfm, lldp, hw_addr);
     }
     ovs_mutex_unlock(&monitor_mutex);
 
@@ -253,7 +333,7 @@ ofproto_dpif_monitor_port_update(const struct ofport_dpif *ofport,
      * terminates it. */
     if (!monitor_running && !hmap_is_empty(&monitor_hmap))  {
         latch_init(&monitor_exit_latch);
-        xpthread_create(&monitor_tid, NULL, monitor_main, NULL);
+        monitor_tid = ovs_thread_create("monitor", monitor_main, NULL);
         monitor_running = true;
     } else if (monitor_running && hmap_is_empty(&monitor_hmap))  {
         latch_set(&monitor_exit_latch);
@@ -263,25 +343,16 @@ ofproto_dpif_monitor_port_update(const struct ofport_dpif *ofport,
     }
 }
 
-/* Moves the mport on top of the heap.  This is necessary when
- * for example, bfd POLL is received and the mport should
- * immediately send FINAL back. */
-void
-ofproto_dpif_monitor_port_send_soon_safe(const struct ofport_dpif *ofport)
-{
-    ovs_mutex_lock(&monitor_mutex);
-    ofproto_dpif_monitor_port_send_soon(ofport);
-    ovs_mutex_unlock(&monitor_mutex);
-}
-
+/* Registers the 'ofport' in the 'send_soon' list.  We cannot directly
+ * insert the corresponding mport to the 'send_soon' list, since the
+ * 'send_soon' list is not updated when the mport is removed.
+ *
+ * Reader of the 'send_soon' list is responsible for freeing the entry. */
 void
 ofproto_dpif_monitor_port_send_soon(const struct ofport_dpif *ofport)
-    OVS_REQUIRES(monitor_mutex)
 {
-    struct mport *mport;
+    struct send_soon_entry *entry = xzalloc(sizeof *entry);
+    entry->ofport = ofport;
 
-    mport = mport_find(ofport);
-    if (mport) {
-        heap_change(&monitor_heap, &mport->heap_node, LLONG_MAX);
-    }
+    guarded_list_push_back(&send_soon, &entry->list_node, SIZE_MAX);
 }