X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fnetflow.c;h=381ff8efcf23a7a895e48d64e19f8ffb6738e67a;hb=3e42dfdc39de77a408afc4f812e01d9be5ceda66;hp=015208ac9569a559a6731ec84671bff94f87487d;hpb=f79cb67e689566cfbf3071e0ac0e29923ada5a97;p=sliver-openvswitch.git diff --git a/ofproto/netflow.c b/ofproto/netflow.c index 015208ac9..381ff8efc 100644 --- a/ofproto/netflow.c +++ b/ofproto/netflow.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,6 +20,7 @@ #include #include #include +#include "byte-order.h" #include "collectors.h" #include "flow.h" #include "netflow.h" @@ -27,13 +28,11 @@ #include "ofproto.h" #include "packets.h" #include "socket-util.h" -#include "svec.h" #include "timeval.h" #include "util.h" #include "vlog.h" -#include "xtoxll.h" -VLOG_DEFINE_THIS_MODULE(netflow) +VLOG_DEFINE_THIS_MODULE(netflow); #define NETFLOW_V5_VERSION 5 @@ -42,17 +41,17 @@ VLOG_DEFINE_THIS_MODULE(netflow) * We only send a single record per NetFlow message. */ struct netflow_v5_header { - uint16_t version; /* NetFlow version is 5. */ - uint16_t count; /* Number of records in this message. */ - uint32_t sysuptime; /* System uptime in milliseconds. */ - uint32_t unix_secs; /* Number of seconds since Unix epoch. */ - uint32_t unix_nsecs; /* Number of residual nanoseconds + ovs_be16 version; /* NetFlow version is 5. */ + ovs_be16 count; /* Number of records in this message. */ + ovs_be32 sysuptime; /* System uptime in milliseconds. */ + ovs_be32 unix_secs; /* Number of seconds since Unix epoch. */ + ovs_be32 unix_nsecs; /* Number of residual nanoseconds after epoch seconds. */ - uint32_t flow_seq; /* Number of flows since sending + ovs_be32 flow_seq; /* Number of flows since sending messages began. */ uint8_t engine_type; /* Engine type. */ uint8_t engine_id; /* Engine id. */ - uint16_t sampling_interval; /* Set to zero. */ + ovs_be16 sampling_interval; /* Set to zero. */ }; BUILD_ASSERT_DECL(sizeof(struct netflow_v5_header) == 24); @@ -60,29 +59,29 @@ BUILD_ASSERT_DECL(sizeof(struct netflow_v5_header) == 24); * NetFlow v5 header. */ struct netflow_v5_record { - uint32_t src_addr; /* Source IP address. */ - uint32_t dst_addr; /* Destination IP address. */ - uint32_t nexthop; /* IP address of next hop. Set to 0. */ - uint16_t input; /* Input interface index. */ - uint16_t output; /* Output interface index. */ - uint32_t packet_count; /* Number of packets. */ - uint32_t byte_count; /* Number of bytes. */ - uint32_t init_time; /* Value of sysuptime on first packet. */ - uint32_t used_time; /* Value of sysuptime on last packet. */ + ovs_be32 src_addr; /* Source IP address. */ + ovs_be32 dst_addr; /* Destination IP address. */ + ovs_be32 nexthop; /* IP address of next hop. Set to 0. */ + ovs_be16 input; /* Input interface index. */ + ovs_be16 output; /* Output interface index. */ + ovs_be32 packet_count; /* Number of packets. */ + ovs_be32 byte_count; /* Number of bytes. */ + ovs_be32 init_time; /* Value of sysuptime on first packet. */ + ovs_be32 used_time; /* Value of sysuptime on last packet. */ /* The 'src_port' and 'dst_port' identify the source and destination * port, respectively, for TCP and UDP. For ICMP, the high-order * byte identifies the type and low-order byte identifies the code * in the 'dst_port' field. */ - uint16_t src_port; - uint16_t dst_port; + ovs_be16 src_port; + ovs_be16 dst_port; uint8_t pad1; uint8_t tcp_flags; /* Union of seen TCP flags. */ uint8_t ip_proto; /* IP protocol. */ uint8_t ip_tos; /* IP TOS value. */ - uint16_t src_as; /* Source AS ID. Set to 0. */ - uint16_t dst_as; /* Destination AS ID. Set to 0. */ + ovs_be16 src_as; /* Source AS ID. Set to 0. */ + ovs_be16 dst_as; /* Destination AS ID. Set to 0. */ uint8_t src_mask; /* Source mask bits. Set to 0. */ uint8_t dst_mask; /* Destination mask bits. Set to 0. */ uint8_t pad[2]; @@ -134,7 +133,7 @@ gen_netflow_rec(struct netflow *nf, struct netflow_flow *nf_flow, nf_rec = ofpbuf_put_zeros(&nf->packet, sizeof *nf_rec); nf_rec->src_addr = expired->flow.nw_src; nf_rec->dst_addr = expired->flow.nw_dst; - nf_rec->nexthop = htons(0); + nf_rec->nexthop = htonl(0); if (nf->add_id_to_iface) { uint16_t iface = (nf->engine_id & 0x7f) << 9; nf_rec->input = htons(iface | (expired->flow.in_port & 0x1ff)); @@ -148,7 +147,7 @@ gen_netflow_rec(struct netflow *nf, struct netflow_flow *nf_flow, nf_rec->init_time = htonl(nf_flow->created - nf->boot_time); nf_rec->used_time = htonl(MAX(nf_flow->created, expired->used) - nf->boot_time); - if (expired->flow.nw_proto == IP_TYPE_ICMP) { + if (expired->flow.nw_proto == IPPROTO_ICMP) { /* In NetFlow, the ICMP type and code are concatenated and * placed in the 'dst_port' field. */ uint8_t type = ntohs(expired->flow.tp_src); @@ -184,20 +183,35 @@ netflow_expire(struct netflow *nf, struct netflow_flow *nf_flow, return; } - /* NetFlow v5 records are limited to 32-bit counters. If we've - * wrapped a counter, send as multiple records so we don't lose - * track of any traffic. We try to evenly distribute the packet and - * byte counters, so that the bytes-per-packet lengths don't look - * wonky across the records. */ - while (byte_delta) { - int n_recs = (byte_delta + UINT32_MAX - 1) / UINT32_MAX; - uint32_t pkt_count = pkt_delta / n_recs; - uint32_t byte_count = byte_delta / n_recs; - - gen_netflow_rec(nf, nf_flow, expired, pkt_count, byte_count); - - pkt_delta -= pkt_count; - byte_delta -= byte_count; + if ((byte_delta >> 32) <= 175) { + /* NetFlow v5 records are limited to 32-bit counters. If we've wrapped + * a counter, send as multiple records so we don't lose track of any + * traffic. We try to evenly distribute the packet and byte counters, + * so that the bytes-per-packet lengths don't look wonky across the + * records. */ + while (byte_delta) { + int n_recs = (byte_delta + UINT32_MAX - 1) / UINT32_MAX; + uint32_t pkt_count = pkt_delta / n_recs; + uint32_t byte_count = byte_delta / n_recs; + + gen_netflow_rec(nf, nf_flow, expired, pkt_count, byte_count); + + pkt_delta -= pkt_count; + byte_delta -= byte_count; + } + } else { + /* In 600 seconds, a 10GbE link can theoretically transmit 75 * 10**10 + * == 175 * 2**32 bytes. The byte counter is bigger than that, so it's + * probably a bug--for example, the netdev code uses UINT64_MAX to + * report "unknown value", and perhaps that has leaked through to here. + * + * We wouldn't want to hit the loop above in this case, because it + * would try to send up to UINT32_MAX netflow records, which would take + * a long time. + */ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + + VLOG_WARN_RL(&rl, "impossible byte counter %"PRIu64, byte_delta); } /* Update flow tracking data. */ @@ -268,6 +282,14 @@ netflow_destroy(struct netflow *nf) } } +/* Initializes a new 'nf_flow' given that the caller has already cleared it to + * all-zero-bits. */ +void +netflow_flow_init(struct netflow_flow *nf_flow OVS_UNUSED) +{ + /* Nothing to do. */ +} + void netflow_flow_clear(struct netflow_flow *nf_flow) {