X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fnetflow.c;h=9d9ef19809a7919f661f2dfe34a32726c5ffd79a;hb=765899376740486ca111c62a851b6120864f5698;hp=a70b2fce8e545d3ed9221b39aead45759728394d;hpb=48f846e66ef06c39228fb1d3f8d8bfd1c695c93d;p=openvswitch diff --git a/ofproto/netflow.c b/ofproto/netflow.c index a70b2fce..9d9ef198 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]; @@ -105,7 +104,7 @@ struct netflow { static void gen_netflow_rec(struct netflow *nf, struct netflow_flow *nf_flow, - struct ofexpired *expired, + struct ofexpired *expired, uint32_t packet_count, uint32_t byte_count) { struct netflow_v5_header *nf_hdr; @@ -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); @@ -161,7 +160,7 @@ gen_netflow_rec(struct netflow *nf, struct netflow_flow *nf_flow, } nf_rec->tcp_flags = nf_flow->tcp_flags; nf_rec->ip_proto = expired->flow.nw_proto; - nf_rec->ip_tos = expired->flow.nw_tos; + nf_rec->ip_tos = expired->flow.tos_frag & IP_DSCP_MASK; /* NetFlow messages are limited to 30 records. */ if (ntohs(nf_hdr->count) >= 30) { @@ -184,23 +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 > UINT32_MAX) { - uint32_t n_recs = byte_delta >> 32; - 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 > 0) { - gen_netflow_rec(nf, nf_flow, expired, pkt_delta, byte_delta); + 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. */ @@ -271,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) {