X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto-sflow.c;h=a3f4d810f1e8aa78ebcbb999cd6053d498a1b4b5;hb=93b8df3853659238df58b1e1e69a0c5608e208f8;hp=1b659d1ab850f92b26d11077bc94cafab6abcf52;hpb=a4af00400a835eb87569ba40e21874c05e872c0f;p=openvswitch

diff --git a/ofproto/ofproto-sflow.c b/ofproto/ofproto-sflow.c
index 1b659d1a..a3f4d810 100644
--- a/ofproto/ofproto-sflow.c
+++ b/ofproto/ofproto-sflow.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2009, 2010 InMon Corp.
- * Copyright (c) 2009 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2009 InMon Corp.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,21 +22,26 @@
 #include "collectors.h"
 #include "dpif.h"
 #include "compiler.h"
+#include "hash.h"
+#include "hmap.h"
 #include "netdev.h"
+#include "netlink.h"
 #include "ofpbuf.h"
 #include "ofproto.h"
+#include "packets.h"
 #include "poll-loop.h"
-#include "port-array.h"
 #include "sflow_api.h"
 #include "socket-util.h"
 #include "timeval.h"
-
-#define THIS_MODULE VLM_sflow
 #include "vlog.h"
 
+VLOG_DEFINE_THIS_MODULE(sflow);
+
 struct ofproto_sflow_port {
+    struct hmap_node hmap_node; /* In struct ofproto_sflow's "ports" hmap. */
     struct netdev *netdev;      /* Underlying network device, for stats. */
     SFLDataSource_instance dsi; /* sFlow library's notion of port number. */
+    uint16_t odp_port;          /* ODP port number. */
 };
 
 struct ofproto_sflow {
@@ -47,9 +52,12 @@ struct ofproto_sflow {
     struct dpif *dpif;
     time_t next_tick;
     size_t n_flood, n_all;
-    struct port_array ports;    /* Indexed by ODP port number. */
+    struct hmap ports;          /* Contains "struct ofproto_sflow_port"s. */
 };
 
+static void ofproto_sflow_del_port__(struct ofproto_sflow *,
+                                     struct ofproto_sflow_port *);
+
 #define RECEIVER_INDEX 1
 
 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
@@ -64,7 +72,7 @@ static bool
 ofproto_sflow_options_equal(const struct ofproto_sflow_options *a,
                             const struct ofproto_sflow_options *b)
 {
-    return (svec_equal(&a->targets, &b->targets)
+    return (sset_equals(&a->targets, &b->targets)
             && a->sampling_rate == b->sampling_rate
             && a->polling_interval == b->polling_interval
             && a->header_len == b->header_len
@@ -77,7 +85,7 @@ static struct ofproto_sflow_options *
 ofproto_sflow_options_clone(const struct ofproto_sflow_options *old)
 {
     struct ofproto_sflow_options *new = xmemdup(old, sizeof *old);
-    svec_clone(&new->targets, &old->targets);
+    sset_clone(&new->targets, &old->targets);
     new->agent_device = old->agent_device ? xstrdup(old->agent_device) : NULL;
     new->control_ip = old->control_ip ? xstrdup(old->control_ip) : NULL;
     return new;
@@ -87,7 +95,7 @@ static void
 ofproto_sflow_options_destroy(struct ofproto_sflow_options *options)
 {
     if (options) {
-        svec_destroy(&options->targets);
+        sset_destroy(&options->targets);
         free(options->agent_device);
         free(options->control_ip);
         free(options);
@@ -96,14 +104,16 @@ ofproto_sflow_options_destroy(struct ofproto_sflow_options *options)
 
 /* sFlow library callback to allocate memory. */
 static void *
-sflow_agent_alloc_cb(void *magic UNUSED, SFLAgent *agent UNUSED, size_t bytes)
+sflow_agent_alloc_cb(void *magic OVS_UNUSED, SFLAgent *agent OVS_UNUSED,
+                     size_t bytes)
 {
     return calloc(1, bytes);
 }
 
 /* sFlow library callback to free memory. */
 static int
-sflow_agent_free_cb(void *magic UNUSED, SFLAgent *agent UNUSED, void *obj)
+sflow_agent_free_cb(void *magic OVS_UNUSED, SFLAgent *agent OVS_UNUSED,
+                    void *obj)
 {
     free(obj);
     return 0;
@@ -111,21 +121,36 @@ sflow_agent_free_cb(void *magic UNUSED, SFLAgent *agent UNUSED, void *obj)
 
 /* sFlow library callback to report error. */
 static void
-sflow_agent_error_cb(void *magic UNUSED, SFLAgent *agent UNUSED, char *msg)
+sflow_agent_error_cb(void *magic OVS_UNUSED, SFLAgent *agent OVS_UNUSED,
+                     char *msg)
 {
     VLOG_WARN("sFlow agent error: %s", msg);
 }
 
 /* sFlow library callback to send datagram. */
 static void
-sflow_agent_send_packet_cb(void *os_, SFLAgent *agent UNUSED,
-                           SFLReceiver *receiver UNUSED, u_char *pkt,
+sflow_agent_send_packet_cb(void *os_, SFLAgent *agent OVS_UNUSED,
+                           SFLReceiver *receiver OVS_UNUSED, u_char *pkt,
                            uint32_t pktLen)
 {
     struct ofproto_sflow *os = os_;
     collectors_send(os->collectors, pkt, pktLen);
 }
 
+static struct ofproto_sflow_port *
+ofproto_sflow_find_port(const struct ofproto_sflow *os, uint16_t odp_port)
+{
+    struct ofproto_sflow_port *osp;
+
+    HMAP_FOR_EACH_IN_BUCKET (osp, hmap_node,
+                             hash_int(odp_port, 0), &os->ports) {
+        if (osp->odp_port == odp_port) {
+            return osp;
+        }
+    }
+    return NULL;
+}
+
 static void
 sflow_agent_get_counters(void *os_, SFLPoller *poller,
                          SFL_COUNTERS_SAMPLE_TYPE *cs)
@@ -138,7 +163,7 @@ sflow_agent_get_counters(void *os_, SFLPoller *poller,
     enum netdev_flags flags;
     uint32_t current;
 
-    osp = port_array_get(&os->ports, poller->bridgePort);
+    osp = ofproto_sflow_find_port(os, poller->bridgePort);
     if (!osp) {
         return;
     }
@@ -158,10 +183,8 @@ sflow_agent_get_counters(void *os_, SFLPoller *poller,
         counters->ifDirection = 0;
     }
     if (!netdev_get_flags(osp->netdev, &flags) && flags & NETDEV_UP) {
-        bool carrier;
-
         counters->ifStatus = 1; /* ifAdminStatus up. */
-        if (!netdev_get_carrier(osp->netdev, &carrier) && carrier) {
+        if (netdev_get_carrier(osp->netdev)) {
             counters->ifStatus |= 2; /* ifOperStatus us. */
         }
     } else {
@@ -229,16 +252,13 @@ sflow_choose_agent_address(const char *agent_device, const char *control_ip,
     return false;
 
 success:
-    agent_addr->address.ip_v4.addr = in4.s_addr;
+    agent_addr->address.ip_v4.addr = (OVS_FORCE uint32_t) in4.s_addr;
     return true;
 }
 
 void
 ofproto_sflow_clear(struct ofproto_sflow *os)
 {
-    struct ofproto_sflow_port *osp;
-    unsigned int odp_port;
-
     if (os->sflow_agent) {
         sfl_agent_release(os->sflow_agent);
         os->sflow_agent = NULL;
@@ -248,11 +268,6 @@ ofproto_sflow_clear(struct ofproto_sflow *os)
     ofproto_sflow_options_destroy(os->options);
     os->options = NULL;
 
-    PORT_ARRAY_FOR_EACH (osp, &os->ports, odp_port) {
-        ofproto_sflow_del_port(os, odp_port);
-    }
-    port_array_clear(&os->ports);
-
     /* Turn off sampling to save CPU cycles. */
     dpif_set_sflow_probability(os->dpif, 0);
 }
@@ -271,7 +286,7 @@ ofproto_sflow_create(struct dpif *dpif)
     os = xcalloc(1, sizeof *os);
     os->dpif = dpif;
     os->next_tick = time_now() + 1;
-    port_array_init(&os->ports);
+    hmap_init(&os->ports);
     return os;
 }
 
@@ -279,8 +294,13 @@ void
 ofproto_sflow_destroy(struct ofproto_sflow *os)
 {
     if (os) {
+        struct ofproto_sflow_port *osp, *next;
+
         ofproto_sflow_clear(os);
-        port_array_destroy(&os->ports);
+        HMAP_FOR_EACH_SAFE (osp, next, hmap_node, &os->ports) {
+            ofproto_sflow_del_port__(os, osp);
+        }
+        hmap_destroy(&os->ports);
         free(os);
     }
 }
@@ -298,12 +318,11 @@ ofproto_sflow_add_poller(struct ofproto_sflow *os,
 
 static void
 ofproto_sflow_add_sampler(struct ofproto_sflow *os,
-			  struct ofproto_sflow_port *osp,
-			  u_int32_t sampling_rate, u_int32_t header_len)
+			  struct ofproto_sflow_port *osp)
 {
     SFLSampler *sampler = sfl_agent_addSampler(os->sflow_agent, &osp->dsi);
-    sfl_sampler_set_sFlowFsPacketSamplingRate(sampler, sampling_rate);
-    sfl_sampler_set_sFlowFsMaximumHeaderSize(sampler, header_len);
+    sfl_sampler_set_sFlowFsPacketSamplingRate(sampler, os->options->sampling_rate);
+    sfl_sampler_set_sFlowFsMaximumHeaderSize(sampler, os->options->header_len);
     sfl_sampler_set_sFlowFsReceiver(sampler, RECEIVER_INDEX);
 }
 
@@ -334,26 +353,35 @@ ofproto_sflow_add_port(struct ofproto_sflow *os, uint16_t odp_port,
         ifindex = (os->sflow_agent->subId << 16) + odp_port;
     }
     SFL_DS_SET(osp->dsi, 0, ifindex, 0);
-    port_array_set(&os->ports, odp_port, osp);
+    osp->odp_port = odp_port;
+    hmap_insert(&os->ports, &osp->hmap_node, hash_int(odp_port, 0));
 
-    /* Add poller. */
+    /* Add poller and sampler. */
     if (os->sflow_agent) {
         ofproto_sflow_add_poller(os, osp, odp_port);
+        ofproto_sflow_add_sampler(os, osp);
     }
 }
 
+static void
+ofproto_sflow_del_port__(struct ofproto_sflow *os,
+                         struct ofproto_sflow_port *osp)
+{
+    if (os->sflow_agent) {
+        sfl_agent_removePoller(os->sflow_agent, &osp->dsi);
+        sfl_agent_removeSampler(os->sflow_agent, &osp->dsi);
+    }
+    netdev_close(osp->netdev);
+    hmap_remove(&os->ports, &osp->hmap_node);
+    free(osp);
+}
+
 void
 ofproto_sflow_del_port(struct ofproto_sflow *os, uint16_t odp_port)
 {
-    struct ofproto_sflow_port *osp = port_array_get(&os->ports, odp_port);
+    struct ofproto_sflow_port *osp = ofproto_sflow_find_port(os, odp_port);
     if (osp) {
-        if (os->sflow_agent) {
-            sfl_agent_removePoller(os->sflow_agent, &osp->dsi);
-            sfl_agent_removeSampler(os->sflow_agent, &osp->dsi);
-        }
-        netdev_close(osp->netdev);
-        free(osp);
-        port_array_set(&os->ports, odp_port, NULL);
+        ofproto_sflow_del_port__(os, osp);
     }
 }
 
@@ -364,12 +392,10 @@ ofproto_sflow_set_options(struct ofproto_sflow *os,
     struct ofproto_sflow_port *osp;
     bool options_changed;
     SFLReceiver *receiver;
-    unsigned int odp_port;
     SFLAddress agentIP;
     time_t now;
-    int error;
 
-    if (!options->targets.n || !options->sampling_rate) {
+    if (sset_is_empty(&options->targets) || !options->sampling_rate) {
         /* No point in doing any work if there are no targets or nothing to
          * sample. */
         ofproto_sflow_clear(os);
@@ -383,10 +409,10 @@ ofproto_sflow_set_options(struct ofproto_sflow *os,
      * collectors (which indicates that opening one or more of the configured
      * collectors failed, so that we should retry). */
     if (options_changed
-        || collectors_count(os->collectors) < options->targets.n) {
+        || collectors_count(os->collectors) < sset_count(&options->targets)) {
         collectors_destroy(os->collectors);
-        error = collectors_create(&options->targets,
-                                  SFL_DEFAULT_COLLECTOR_PORT, &os->collectors);
+        collectors_create(&options->targets, SFL_DEFAULT_COLLECTOR_PORT,
+                          &os->collectors);
         if (os->collectors == NULL) {
             VLOG_WARN_RL(&rl, "no collectors could be initialized, "
                          "sFlow disabled");
@@ -415,7 +441,7 @@ ofproto_sflow_set_options(struct ofproto_sflow *os,
         sfl_agent_release(os->sflow_agent);
     }
     os->sflow_agent = xcalloc(1, sizeof *os->sflow_agent);
-    now = time_now();
+    now = time_wall();
     sfl_agent_init(os->sflow_agent,
                    &agentIP,
                    options->sub_id,
@@ -436,9 +462,9 @@ ofproto_sflow_set_options(struct ofproto_sflow *os,
                                MAX(1, UINT32_MAX / options->sampling_rate));
 
     /* Add samplers and pollers for the currently known ports. */
-    PORT_ARRAY_FOR_EACH (osp, &os->ports, odp_port) {
-        ofproto_sflow_add_sampler(os, osp,
-                                  options->sampling_rate, options->header_len);
+    HMAP_FOR_EACH (osp, hmap_node, &os->ports) {
+        ofproto_sflow_add_poller(os, osp, osp->odp_port);
+        ofproto_sflow_add_sampler(os, osp);
     }
 }
 
@@ -446,61 +472,29 @@ static int
 ofproto_sflow_odp_port_to_ifindex(const struct ofproto_sflow *os,
                                   uint16_t odp_port)
 {
-    struct ofproto_sflow_port *osp = port_array_get(&os->ports, odp_port);
+    struct ofproto_sflow_port *osp = ofproto_sflow_find_port(os, odp_port);
     return osp ? SFL_DS_INDEX(osp->dsi) : 0;
 }
 
 void
-ofproto_sflow_received(struct ofproto_sflow *os, struct odp_msg *msg)
+ofproto_sflow_received(struct ofproto_sflow *os,
+                       const struct dpif_upcall *upcall,
+                       const struct flow *flow)
 {
     SFL_FLOW_SAMPLE_TYPE fs;
     SFLFlow_sample_element hdrElem;
     SFLSampled_header *header;
     SFLFlow_sample_element switchElem;
     SFLSampler *sampler;
-    const struct odp_sflow_sample_header *hdr;
-    const union odp_action *actions;
-    struct ofpbuf payload;
-    size_t n_actions, n_outputs;
-    size_t min_size;
-    flow_t flow;
-    size_t i;
-
-    /* Get odp_sflow_sample_header. */
-    min_size = sizeof *msg + sizeof *hdr;
-    if (min_size > msg->length) {
-        VLOG_WARN_RL(&rl, "sFlow packet too small (%"PRIu32" < %zu)",
-                     msg->length, min_size);
-        return;
-    }
-    hdr = (const struct odp_sflow_sample_header *) (msg + 1);
-
-    /* Get actions. */
-    n_actions = hdr->n_actions;
-    if (n_actions > 65536 / sizeof *actions) {
-        VLOG_WARN_RL(&rl, "too many actions in sFlow packet (%zu > %zu)",
-                     65536 / sizeof *actions, n_actions);
-        return;
-    }
-    min_size += n_actions * sizeof *actions;
-    if (min_size > msg->length) {
-        VLOG_WARN_RL(&rl, "sFlow packet with %zu actions too small "
-                     "(%"PRIu32" < %zu)",
-                     n_actions, msg->length, min_size);
-        return;
-    }
-    actions = (const union odp_action *) (hdr + 1);
-
-    /* Get packet payload and extract flow. */
-    payload.data = (union odp_action *) (actions + n_actions);
-    payload.size = msg->length - min_size;
-    flow_extract(&payload, msg->port, &flow);
+    unsigned int left;
+    struct nlattr *a;
+    size_t n_outputs;
 
     /* Build a flow sample */
     memset(&fs, 0, sizeof fs);
-    fs.input = ofproto_sflow_odp_port_to_ifindex(os, msg->port);
+    fs.input = ofproto_sflow_odp_port_to_ifindex(os, flow->in_port);
     fs.output = 0;              /* Filled in correctly below. */
-    fs.sample_pool = hdr->sample_pool;
+    fs.sample_pool = upcall->sample_pool;
 
     /* We are going to give it to the sampler that represents this input port.
      * By implementing "ingress-only" sampling like this we ensure that we
@@ -517,43 +511,41 @@ ofproto_sflow_received(struct ofproto_sflow *os, struct odp_msg *msg)
     hdrElem.tag = SFLFLOW_HEADER;
     header = &hdrElem.flowType.header;
     header->header_protocol = SFLHEADER_ETHERNET_ISO8023;
-    header->frame_length = payload.size;
-    header->stripped = 4; /* Ethernet FCS stripped off. */
-    header->header_length = MIN(payload.size,
+    /* The frame_length should include the Ethernet FCS (4 bytes),
+       but it has already been stripped,  so we need to add 4 here. */
+    header->frame_length = upcall->packet->size + 4;
+    /* Ethernet FCS stripped off. */
+    header->stripped = 4;
+    header->header_length = MIN(upcall->packet->size,
                                 sampler->sFlowFsMaximumHeaderSize);
-    header->header_bytes = payload.data;
+    header->header_bytes = upcall->packet->data;
 
     /* Add extended switch element. */
     memset(&switchElem, 0, sizeof(switchElem));
     switchElem.tag = SFLFLOW_EX_SWITCH;
-    switchElem.flowType.sw.src_vlan = ntohs(flow.dl_vlan);
-    switchElem.flowType.sw.src_priority = -1; /* XXX */
-    switchElem.flowType.sw.dst_vlan = -1;     /* Filled in correctly below. */
+    switchElem.flowType.sw.src_vlan = vlan_tci_to_vid(flow->vlan_tci);
+    switchElem.flowType.sw.src_priority = vlan_tci_to_pcp(flow->vlan_tci);
+     /* Initialize the output VLAN and priority to be the same as the input,
+        but these fields can be overriden below if affected by an action. */
+    switchElem.flowType.sw.dst_vlan = switchElem.flowType.sw.src_vlan;
     switchElem.flowType.sw.dst_priority = switchElem.flowType.sw.src_priority;
 
     /* Figure out the output ports. */
     n_outputs = 0;
-    for (i = 0; i < n_actions; i++) {
-        const union odp_action *a = &actions[i];
+    NL_ATTR_FOR_EACH_UNSAFE (a, left, upcall->actions, upcall->actions_len) {
+        ovs_be16 tci;
 
-        switch (a->type) {
-        case ODPAT_OUTPUT:
-            fs.output = ofproto_sflow_odp_port_to_ifindex(os, a->output.port);
+        switch (nl_attr_type(a)) {
+        case ODP_ACTION_ATTR_OUTPUT:
+            fs.output = ofproto_sflow_odp_port_to_ifindex(os,
+                                                          nl_attr_get_u32(a));
             n_outputs++;
             break;
 
-        case ODPAT_OUTPUT_GROUP:
-            n_outputs += (a->output_group.group == DP_GROUP_FLOOD ? os->n_flood
-                          : a->output_group.group == DP_GROUP_ALL ? os->n_all
-                          : 0);
-            break;
-
-        case ODPAT_SET_VLAN_VID:
-            switchElem.flowType.sw.dst_vlan = ntohs(a->vlan_vid.vlan_vid);
-            break;
-
-        case ODPAT_SET_VLAN_PCP:
-            switchElem.flowType.sw.dst_priority = a->vlan_pcp.vlan_pcp;
+        case ODP_ACTION_ATTR_SET_DL_TCI:
+            tci = nl_attr_get_be16(a);
+            switchElem.flowType.sw.dst_vlan = vlan_tci_to_vid(tci);
+            switchElem.flowType.sw.dst_priority = vlan_tci_to_pcp(tci);
             break;
 
         default:
@@ -578,21 +570,13 @@ ofproto_sflow_received(struct ofproto_sflow *os, struct odp_msg *msg)
     sfl_sampler_writeFlowSample(sampler, &fs);
 }
 
-void
-ofproto_sflow_set_group_sizes(struct ofproto_sflow *os,
-                              size_t n_flood, size_t n_all)
-{
-    os->n_flood = n_flood;
-    os->n_all = n_all;
-}
-
 void
 ofproto_sflow_run(struct ofproto_sflow *os)
 {
     if (ofproto_sflow_is_enabled(os)) {
         time_t now = time_now();
         if (now >= os->next_tick) {
-            sfl_agent_tick(os->sflow_agent, now);
+            sfl_agent_tick(os->sflow_agent, time_wall());
             os->next_tick = now + 1;
         }
     }
@@ -602,6 +586,6 @@ void
 ofproto_sflow_wait(struct ofproto_sflow *os)
 {
     if (ofproto_sflow_is_enabled(os)) {
-        poll_timer_wait(os->next_tick * 1000 - time_msec());
+        poll_timer_wait_until(os->next_tick * 1000LL);
     }
 }