X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fnetflow.c;h=7366986f65c7639a7d1ad6f06829c404e451e7ce;hb=ec9f40dce11c7e81bc41d42e3bbfaaf8287165ce;hp=c237ef25f4f63ac79b3648cf290b0898368ec86d;hpb=007948177581f3b3dad188221593d0e4bdca6ba0;p=sliver-openvswitch.git diff --git a/ofproto/netflow.c b/ofproto/netflow.c index c237ef25f..7366986f6 100644 --- a/ofproto/netflow.c +++ b/ofproto/netflow.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,10 +23,12 @@ #include "byte-order.h" #include "collectors.h" #include "flow.h" -#include "netflow.h" +#include "lib/netflow.h" #include "ofpbuf.h" #include "ofproto.h" +#include "ofproto/netflow.h" #include "packets.h" +#include "poll-loop.h" #include "socket-util.h" #include "timeval.h" #include "util.h" @@ -34,77 +36,24 @@ VLOG_DEFINE_THIS_MODULE(netflow); -#define NETFLOW_V5_VERSION 5 - -/* Every NetFlow v5 message contains the header that follows. This is - * followed by up to thirty records that describe a terminating flow. - * We only send a single record per NetFlow message. - */ -struct netflow_v5_header { - 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. */ - ovs_be32 flow_seq; /* Number of flows since sending - messages began. */ - uint8_t engine_type; /* Engine type. */ - uint8_t engine_id; /* Engine id. */ - ovs_be16 sampling_interval; /* Set to zero. */ -}; -BUILD_ASSERT_DECL(sizeof(struct netflow_v5_header) == 24); - -/* A NetFlow v5 description of a terminating flow. It is preceded by a - * NetFlow v5 header. - */ -struct netflow_v5_record { - 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. */ - 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. */ - 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]; -}; -BUILD_ASSERT_DECL(sizeof(struct netflow_v5_record) == 48); - struct netflow { uint8_t engine_type; /* Value of engine_type to use. */ uint8_t engine_id; /* Value of engine_id to use. */ long long int boot_time; /* Time when netflow_create() was called. */ struct collectors *collectors; /* NetFlow collectors. */ - bool add_id_to_iface; /* Put the 7 least signficiant bits of - * 'engine_id' into the most signficant + bool add_id_to_iface; /* Put the 7 least significiant bits of + * 'engine_id' into the most significant * bits of the interface fields. */ uint32_t netflow_cnt; /* Flow sequence number for NetFlow. */ struct ofpbuf packet; /* NetFlow packet being accumulated. */ long long int active_timeout; /* Timeout for flows that are still active. */ + long long int next_timeout; /* Next scheduled active timeout. */ long long int reconfig_time; /* When we reconfigured the timeouts. */ }; 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; @@ -133,7 +82,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)); @@ -160,7 +109,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.nw_tos & IP_DSCP_MASK; /* NetFlow messages are limited to 30 records. */ if (ntohs(nf_hdr->count) >= 30) { @@ -221,13 +170,33 @@ netflow_expire(struct netflow *nf, struct netflow_flow *nf_flow, nf_flow->tcp_flags = 0; } -void +/* Returns true if it's time to send out a round of NetFlow active timeouts, + * false otherwise. */ +bool netflow_run(struct netflow *nf) { if (nf->packet.size) { collectors_send(nf->collectors, nf->packet.data, nf->packet.size); nf->packet.size = 0; } + + if (nf->active_timeout && time_msec() >= nf->next_timeout) { + nf->next_timeout = time_msec() + 1000; + return true; + } else { + return false; + } +} + +void +netflow_wait(struct netflow *nf) +{ + if (nf->active_timeout) { + poll_timer_wait_until(nf->next_timeout); + } + if (nf->packet.size) { + poll_immediate_wake(); + } } int @@ -253,6 +222,7 @@ netflow_set_options(struct netflow *nf, nf->active_timeout *= 1000; if (old_timeout != nf->active_timeout) { nf->reconfig_time = time_msec(); + nf->next_timeout = time_msec(); } return error; @@ -261,7 +231,7 @@ netflow_set_options(struct netflow *nf, struct netflow * netflow_create(void) { - struct netflow *nf = xmalloc(sizeof *nf); + struct netflow *nf = xzalloc(sizeof *nf); nf->engine_type = 0; nf->engine_id = 0; nf->boot_time = time_msec();