X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Fofproto-dpif-sflow.c;h=b146f5d78e17eeaabb68253ba53c5f57617ee8b0;hb=58b11928efb7de6fc8356e05dcf17fe9851bb90f;hp=35667ca7983d3dad0cad3c721a22756982cd9d5c;hpb=b772066ffd066d59d9ebce092f6665150723d2ad;p=cascardo%2Fovs.git diff --git a/ofproto/ofproto-dpif-sflow.c b/ofproto/ofproto-dpif-sflow.c index 35667ca79..b146f5d78 100644 --- a/ofproto/ofproto-dpif-sflow.c +++ b/ofproto/ofproto-dpif-sflow.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. * Copyright (c) 2009 InMon Corp. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,6 +18,7 @@ #include #include "ofproto-dpif-sflow.h" #include +#include #include #include #include @@ -37,7 +38,7 @@ #include "sflow_api.h" #include "socket-util.h" #include "timeval.h" -#include "vlog.h" +#include "openvswitch/vlog.h" #include "lib/odp-util.h" #include "ofproto-provider.h" #include "lacp.h" @@ -46,6 +47,11 @@ VLOG_DEFINE_THIS_MODULE(sflow); static struct ovs_mutex mutex; +/* This global var is used to determine which sFlow + sub-agent should send the datapath counters. */ +#define SFLOW_GC_SUBID_UNCLAIMED (uint32_t)-1 +static uint32_t sflow_global_counters_subid = SFLOW_GC_SUBID_UNCLAIMED; + struct dpif_sflow_port { struct hmap_node hmap_node; /* In struct dpif_sflow's "ports" hmap. */ SFLDataSource_instance dsi; /* sFlow library's notion of port number. */ @@ -161,6 +167,123 @@ dpif_sflow_find_port(const struct dpif_sflow *ds, odp_port_t odp_port) return NULL; } +/* Call to get the datapath stats. Modeled after the dpctl utility. + * + * It might be more efficient for this module to be given a handle it can use + * to get these stats more efficiently, but this is only going to be called + * once every 20-30 seconds. Return number of datapaths found (normally expect + * 1). */ +static int +sflow_get_dp_stats(struct dpif_sflow *ds OVS_UNUSED, + struct dpif_dp_stats *dp_totals) +{ + struct sset types; + const char *type; + int count = 0; + + memset(dp_totals, 0, sizeof *dp_totals); + sset_init(&types); + dp_enumerate_types(&types); + SSET_FOR_EACH (type, &types) { + struct sset names; + const char *name; + sset_init(&names); + if (dp_enumerate_names(type, &names) == 0) { + SSET_FOR_EACH (name, &names) { + struct dpif *dpif; + if (dpif_open(name, type, &dpif) == 0) { + struct dpif_dp_stats dp_stats; + if (dpif_get_dp_stats(dpif, &dp_stats) == 0) { + count++; + dp_totals->n_hit += dp_stats.n_hit; + dp_totals->n_missed += dp_stats.n_missed; + dp_totals->n_lost += dp_stats.n_lost; + dp_totals->n_flows += dp_stats.n_flows; + dp_totals->n_mask_hit += dp_stats.n_mask_hit; + dp_totals->n_masks += dp_stats.n_masks; + } + dpif_close(dpif); + } + } + sset_destroy(&names); + } + } + sset_destroy(&types); + return count; +} + +/* If there are multiple bridges defined then we need some + minimal artibration to decide which one should send the + global counters. This function allows each sub-agent to + ask if he should do it or not. */ +static bool +sflow_global_counters_subid_test(uint32_t subid) + OVS_REQUIRES(mutex) +{ + if (sflow_global_counters_subid == SFLOW_GC_SUBID_UNCLAIMED) { + /* The role is up for grabs. */ + sflow_global_counters_subid = subid; + } + return (sflow_global_counters_subid == subid); +} + +static void +sflow_global_counters_subid_clear(uint32_t subid) + OVS_REQUIRES(mutex) +{ + if (sflow_global_counters_subid == subid) { + /* The sub-agent that was sending global counters + is going away, so reset to allow another + to take over. */ + sflow_global_counters_subid = SFLOW_GC_SUBID_UNCLAIMED; + } +} + +static void +sflow_agent_get_global_counters(void *ds_, SFLPoller *poller, + SFL_COUNTERS_SAMPLE_TYPE *cs) + OVS_REQUIRES(mutex) +{ + struct dpif_sflow *ds = ds_; + SFLCounters_sample_element dp_elem, res_elem; + struct dpif_dp_stats dp_totals; + struct rusage usage; + + if (!sflow_global_counters_subid_test(poller->agent->subId)) { + /* Another sub-agent is currently responsible for this. */ + return; + } + + /* datapath stats */ + if (sflow_get_dp_stats(ds, &dp_totals)) { + dp_elem.tag = SFLCOUNTERS_OVSDP; + dp_elem.counterBlock.ovsdp.n_hit = dp_totals.n_hit; + dp_elem.counterBlock.ovsdp.n_missed = dp_totals.n_missed; + dp_elem.counterBlock.ovsdp.n_lost = dp_totals.n_lost; + dp_elem.counterBlock.ovsdp.n_mask_hit = dp_totals.n_mask_hit; + dp_elem.counterBlock.ovsdp.n_flows = dp_totals.n_flows; + dp_elem.counterBlock.ovsdp.n_masks = dp_totals.n_masks; + SFLADD_ELEMENT(cs, &dp_elem); + } + + /* resource usage */ + getrusage(RUSAGE_SELF, &usage); + res_elem.tag = SFLCOUNTERS_APP_RESOURCES; + res_elem.counterBlock.appResources.user_time + = timeval_to_msec(&usage.ru_utime); + res_elem.counterBlock.appResources.system_time + = timeval_to_msec(&usage.ru_stime); + res_elem.counterBlock.appResources.mem_used = (usage.ru_maxrss * 1024); + SFL_UNDEF_GAUGE(res_elem.counterBlock.appResources.mem_max); + SFL_UNDEF_GAUGE(res_elem.counterBlock.appResources.fd_open); + SFL_UNDEF_GAUGE(res_elem.counterBlock.appResources.fd_max); + SFL_UNDEF_GAUGE(res_elem.counterBlock.appResources.conn_open); + SFL_UNDEF_GAUGE(res_elem.counterBlock.appResources.conn_max); + + SFLADD_ELEMENT(cs, &res_elem); + sfl_poller_writeCountersSample(poller, cs); +} + static void sflow_agent_get_counters(void *ds_, SFLPoller *poller, SFL_COUNTERS_SAMPLE_TYPE *cs) @@ -343,6 +466,7 @@ static void dpif_sflow_clear__(struct dpif_sflow *ds) OVS_REQUIRES(mutex) { if (ds->sflow_agent) { + sflow_global_counters_subid_clear(ds->sflow_agent->subId); sfl_agent_release(ds->sflow_agent); free(ds->sflow_agent); ds->sflow_agent = NULL; @@ -516,6 +640,7 @@ dpif_sflow_set_options(struct dpif_sflow *ds, SFLDataSource_instance dsi; uint32_t dsIndex; SFLSampler *sampler; + SFLPoller *poller; ovs_mutex_lock(&mutex); if (sset_is_empty(&options->targets) || !options->sampling_rate) { @@ -562,6 +687,7 @@ dpif_sflow_set_options(struct dpif_sflow *ds, /* Create agent. */ VLOG_INFO("creating sFlow agent %d", options->sub_id); if (ds->sflow_agent) { + sflow_global_counters_subid_clear(ds->sflow_agent->subId); sfl_agent_release(ds->sflow_agent); } ds->sflow_agent = xcalloc(1, sizeof *ds->sflow_agent); @@ -595,6 +721,13 @@ dpif_sflow_set_options(struct dpif_sflow *ds, sfl_sampler_set_sFlowFsMaximumHeaderSize(sampler, ds->options->header_len); sfl_sampler_set_sFlowFsReceiver(sampler, RECEIVER_INDEX); + /* Add a counter poller for the bridge so we can use it to send + global counters such as datapath cache hit/miss stats. */ + poller = sfl_agent_addPoller(ds->sflow_agent, &dsi, ds, + sflow_agent_get_global_counters); + sfl_poller_set_sFlowCpInterval(poller, ds->options->polling_interval); + sfl_poller_set_sFlowCpReceiver(poller, RECEIVER_INDEX); + /* Add pollers for the currently known ifindex-ports */ HMAP_FOR_EACH (dsp, hmap_node, &ds->ports) { dpif_sflow_add_poller(ds, dsp); @@ -620,7 +753,7 @@ dpif_sflow_odp_port_to_ifindex(const struct dpif_sflow *ds, } void -dpif_sflow_received(struct dpif_sflow *ds, const struct ofpbuf *packet, +dpif_sflow_received(struct dpif_sflow *ds, const struct dp_packet *packet, const struct flow *flow, odp_port_t odp_in_port, const union user_action_cookie *cookie) OVS_EXCLUDED(mutex) @@ -661,12 +794,12 @@ dpif_sflow_received(struct dpif_sflow *ds, const struct ofpbuf *packet, header->header_protocol = SFLHEADER_ETHERNET_ISO8023; /* 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 = ofpbuf_size(packet) + 4; + header->frame_length = dp_packet_size(packet) + 4; /* Ethernet FCS stripped off. */ header->stripped = 4; - header->header_length = MIN(ofpbuf_size(packet), + header->header_length = MIN(dp_packet_size(packet), sampler->sFlowFsMaximumHeaderSize); - header->header_bytes = ofpbuf_data(packet); + header->header_bytes = dp_packet_data(packet); /* Add extended switch element. */ memset(&switchElem, 0, sizeof(switchElem));