[mirror_ovs.git] / lib / flow.h

/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef FLOW_H
#define FLOW_H 1

#include <sys/types.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "openflow/nicira-ext.h"
#include "openflow/openflow.h"
#include "hash.h"
#include "util.h"

struct dpif_flow_stats;
struct ds;
struct flow_wildcards;
struct miniflow;
struct minimask;
struct ofpbuf;

/* This sequence number should be incremented whenever anything involving flows
 * or the wildcarding of flows changes.  This will cause build assertion
 * failures in places which likely need to be updated. */
#define FLOW_WC_SEQ 17

#define FLOW_N_REGS 8
BUILD_ASSERT_DECL(FLOW_N_REGS <= NXM_NX_MAX_REGS);

/* Used for struct flow's dl_type member for frames that have no Ethernet
 * type, that is, pure 802.2 frames. */
#define FLOW_DL_TYPE_NONE 0x5ff

/* Fragment bits, used for IPv4 and IPv6, always zero for non-IP flows. */
#define FLOW_NW_FRAG_ANY   (1 << 0) /* Set for any IP frag. */
#define FLOW_NW_FRAG_LATER (1 << 1) /* Set for IP frag with nonzero offset. */
#define FLOW_NW_FRAG_MASK  (FLOW_NW_FRAG_ANY | FLOW_NW_FRAG_LATER)

BUILD_ASSERT_DECL(FLOW_NW_FRAG_ANY == NX_IP_FRAG_ANY);
BUILD_ASSERT_DECL(FLOW_NW_FRAG_LATER == NX_IP_FRAG_LATER);

#define FLOW_TNL_F_DONT_FRAGMENT (1 << 0)
#define FLOW_TNL_F_CSUM (1 << 1)
#define FLOW_TNL_F_KEY (1 << 2)
struct flow_tnl {
    ovs_be64 tun_id;
    ovs_be32 ip_src;
    ovs_be32 ip_dst;
    uint16_t flags;
    uint8_t ip_tos;
    uint8_t ip_ttl;
};

struct flow {
    struct flow_tnl tunnel;     /* Encapsulating tunnel parameters. */
    ovs_be64 metadata;          /* OpenFlow Metadata. */
    struct in6_addr ipv6_src;   /* IPv6 source address. */
    struct in6_addr ipv6_dst;   /* IPv6 destination address. */
    struct in6_addr nd_target;  /* IPv6 neighbor discovery (ND) target. */
    uint32_t skb_priority;      /* Packet priority for QoS. */
    uint32_t regs[FLOW_N_REGS]; /* Registers. */
    ovs_be32 nw_src;            /* IPv4 source address. */
    ovs_be32 nw_dst;            /* IPv4 destination address. */
    ovs_be32 ipv6_label;        /* IPv6 flow label. */
    uint16_t in_port;           /* OpenFlow port number of input port. */
    ovs_be16 vlan_tci;          /* If 802.1Q, TCI | VLAN_CFI; otherwise 0. */
    ovs_be16 dl_type;           /* Ethernet frame type. */
    ovs_be16 tp_src;            /* TCP/UDP source port. */
    ovs_be16 tp_dst;            /* TCP/UDP destination port. */
    uint8_t dl_src[6];          /* Ethernet source address. */
    uint8_t dl_dst[6];          /* Ethernet destination address. */
    uint8_t nw_proto;           /* IP protocol or low 8 bits of ARP opcode. */
    uint8_t nw_tos;             /* IP ToS (including DSCP and ECN). */
    uint8_t arp_sha[6];         /* ARP/ND source hardware address. */
    uint8_t arp_tha[6];         /* ARP/ND target hardware address. */
    uint8_t nw_ttl;             /* IP TTL/Hop Limit. */
    uint8_t nw_frag;            /* FLOW_FRAG_* flags. */
    uint8_t zeros[2];           /* Must be zero. */
};
BUILD_ASSERT_DECL(sizeof(struct flow) % 4 == 0);

#define FLOW_U32S (sizeof(struct flow) / 4)

/* Remember to update FLOW_WC_SEQ when changing 'struct flow'. */
BUILD_ASSERT_DECL(sizeof(struct flow) == sizeof(struct flow_tnl) + 144 &&
                  FLOW_WC_SEQ == 17);

/* Represents the metadata fields of struct flow. */
struct flow_metadata {
    ovs_be64 tun_id;                 /* Encapsulating tunnel ID. */
    ovs_be64 metadata;               /* OpenFlow 1.1+ metadata field. */
    uint32_t regs[FLOW_N_REGS];      /* Registers. */
    uint16_t in_port;                /* OpenFlow port or zero. */
};

void flow_extract(struct ofpbuf *, uint32_t priority, const struct flow_tnl *,
                  uint16_t in_port, struct flow *);
void flow_zero_wildcards(struct flow *, const struct flow_wildcards *);
void flow_get_metadata(const struct flow *, struct flow_metadata *);

char *flow_to_string(const struct flow *);
void flow_format(struct ds *, const struct flow *);
void flow_print(FILE *, const struct flow *);
static inline int flow_compare_3way(const struct flow *, const struct flow *);
static inline bool flow_equal(const struct flow *, const struct flow *);
static inline size_t flow_hash(const struct flow *, uint32_t basis);

void flow_set_dl_vlan(struct flow *, ovs_be16 vid);
void flow_set_vlan_vid(struct flow *, ovs_be16 vid);
void flow_set_vlan_pcp(struct flow *, uint8_t pcp);

void flow_compose(struct ofpbuf *, const struct flow *);

static inline int
flow_compare_3way(const struct flow *a, const struct flow *b)
{
    return memcmp(a, b, sizeof *a);
}

static inline bool
flow_equal(const struct flow *a, const struct flow *b)
{
    return !flow_compare_3way(a, b);
}

static inline size_t
flow_hash(const struct flow *flow, uint32_t basis)
{
    return hash_words((const uint32_t *) flow, sizeof *flow / 4, basis);
}

uint32_t flow_hash_in_minimask(const struct flow *, const struct minimask *,
                               uint32_t basis);
\f
/* Wildcards for a flow.
 *
 * A 1-bit in each bit in 'masks' indicates that the corresponding bit of
 * the flow is significant (must match).  A 0-bit indicates that the
 * corresponding bit of the flow is wildcarded (need not match). */
struct flow_wildcards {
    struct flow masks;
};

void flow_wildcards_init_catchall(struct flow_wildcards *);
void flow_wildcards_init_exact(struct flow_wildcards *);

bool flow_wildcards_is_catchall(const struct flow_wildcards *);

void flow_wildcards_set_reg_mask(struct flow_wildcards *,
                                 int idx, uint32_t mask);

void flow_wildcards_combine(struct flow_wildcards *dst,
                            const struct flow_wildcards *src1,
                            const struct flow_wildcards *src2);
bool flow_wildcards_has_extra(const struct flow_wildcards *,
                              const struct flow_wildcards *);

uint32_t flow_wildcards_hash(const struct flow_wildcards *, uint32_t basis);
bool flow_wildcards_equal(const struct flow_wildcards *,
                          const struct flow_wildcards *);
uint32_t flow_hash_symmetric_l4(const struct flow *flow, uint32_t basis);

uint32_t flow_hash_fields(const struct flow *, enum nx_hash_fields,
                          uint16_t basis);
const char *flow_hash_fields_to_str(enum nx_hash_fields);
bool flow_hash_fields_valid(enum nx_hash_fields);

bool flow_equal_except(const struct flow *a, const struct flow *b,
                       const struct flow_wildcards *);
\f
/* Compressed flow. */

#define MINI_N_INLINE (sizeof(void *) == 4 ? 7 : 8)
#define MINI_N_MAPS DIV_ROUND_UP(FLOW_U32S, 32)

/* A sparse representation of a "struct flow".
 *
 * A "struct flow" is fairly large and tends to be mostly zeros.  Sparse
 * representation has two advantages.  First, it saves memory.  Second, it
 * saves time when the goal is to iterate over only the nonzero parts of the
 * struct.
 *
 * The 'map' member holds one bit for each uint32_t in a "struct flow".  Each
 * 0-bit indicates that the corresponding uint32_t is zero, each 1-bit that it
 * is nonzero.
 *
 * 'values' points to the start of an array that has one element for each 1-bit
 * in 'map'.  The least-numbered 1-bit is in values[0], the next 1-bit is in
 * values[1], and so on.
 *
 * 'values' may point to a few different locations:
 *
 *     - If 'map' has MINI_N_INLINE or fewer 1-bits, it may point to
 *       'inline_values'.  One hopes that this is the common case.
 *
 *     - If 'map' has more than MINI_N_INLINE 1-bits, it may point to memory
 *       allocated with malloc().
 *
 *     - The caller could provide storage on the stack for situations where
 *       that makes sense.  So far that's only proved useful for
 *       minimask_combine(), but the principle works elsewhere.
 *
 * The implementation maintains and depends on the invariant that every element
 * in 'values' is nonzero; that is, wherever a 1-bit appears in 'map', the
 * corresponding element of 'values' must be nonzero.
 */
struct miniflow {
    uint32_t *values;
    uint32_t inline_values[MINI_N_INLINE];
    uint32_t map[MINI_N_MAPS];
};

void miniflow_init(struct miniflow *, const struct flow *);
void miniflow_clone(struct miniflow *, const struct miniflow *);
void miniflow_destroy(struct miniflow *);

void miniflow_expand(const struct miniflow *, struct flow *);

uint32_t miniflow_get(const struct miniflow *, unsigned int u32_ofs);
uint16_t miniflow_get_vid(const struct miniflow *);

bool miniflow_equal(const struct miniflow *a, const struct miniflow *b);
bool miniflow_equal_in_minimask(const struct miniflow *a,
                                const struct miniflow *b,
                                const struct minimask *);
bool miniflow_equal_flow_in_minimask(const struct miniflow *a,
                                     const struct flow *b,
                                     const struct minimask *);
uint32_t miniflow_hash(const struct miniflow *, uint32_t basis);
uint32_t miniflow_hash_in_minimask(const struct miniflow *,
                                   const struct minimask *, uint32_t basis);
\f
/* Compressed flow wildcards. */

/* A sparse representation of a "struct flow_wildcards".
 *
 * See the large comment on struct miniflow for details. */
struct minimask {
    struct miniflow masks;
};

void minimask_init(struct minimask *, const struct flow_wildcards *);
void minimask_clone(struct minimask *, const struct minimask *);
void minimask_combine(struct minimask *dst,
                      const struct minimask *a, const struct minimask *b,
                      uint32_t storage[FLOW_U32S]);
void minimask_destroy(struct minimask *);

void minimask_expand(const struct minimask *, struct flow_wildcards *);

uint32_t minimask_get(const struct minimask *, unsigned int u32_ofs);
uint16_t minimask_get_vid_mask(const struct minimask *);

bool minimask_equal(const struct minimask *a, const struct minimask *b);
uint32_t minimask_hash(const struct minimask *, uint32_t basis);

bool minimask_has_extra(const struct minimask *, const struct minimask *);
bool minimask_is_catchall(const struct minimask *);

#endif /* flow.h */
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at:
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*/
	16	#ifndef FLOW_H
	17	#define FLOW_H 1
	18
	19	#include <sys/types.h>
	20	#include <netinet/in.h>
	21	#include <stdbool.h>
	22	#include <stdint.h>
	23	#include <string.h>
	24	#include "openflow/nicira-ext.h"
	25	#include "openflow/openflow.h"
	26	#include "hash.h"
	27	#include "util.h"
	28
	29	struct dpif_flow_stats;
	30	struct ds;
	31	struct flow_wildcards;
	32	struct miniflow;
	33	struct minimask;
	34	struct ofpbuf;
	35
	36	/* This sequence number should be incremented whenever anything involving flows
	37	* or the wildcarding of flows changes. This will cause build assertion
	38	* failures in places which likely need to be updated. */
	39	#define FLOW_WC_SEQ 17
	40
	41	#define FLOW_N_REGS 8
	42	BUILD_ASSERT_DECL(FLOW_N_REGS <= NXM_NX_MAX_REGS);
	43
	44	/* Used for struct flow's dl_type member for frames that have no Ethernet
	45	* type, that is, pure 802.2 frames. */
	46	#define FLOW_DL_TYPE_NONE 0x5ff
	47
	48	/* Fragment bits, used for IPv4 and IPv6, always zero for non-IP flows. */
	49	#define FLOW_NW_FRAG_ANY (1 << 0) /* Set for any IP frag. */
	50	#define FLOW_NW_FRAG_LATER (1 << 1) /* Set for IP frag with nonzero offset. */
	51	#define FLOW_NW_FRAG_MASK (FLOW_NW_FRAG_ANY \| FLOW_NW_FRAG_LATER)
	52
	53	BUILD_ASSERT_DECL(FLOW_NW_FRAG_ANY == NX_IP_FRAG_ANY);
	54	BUILD_ASSERT_DECL(FLOW_NW_FRAG_LATER == NX_IP_FRAG_LATER);
	55
	56	#define FLOW_TNL_F_DONT_FRAGMENT (1 << 0)
	57	#define FLOW_TNL_F_CSUM (1 << 1)
	58	#define FLOW_TNL_F_KEY (1 << 2)
	59	struct flow_tnl {
	60	ovs_be64 tun_id;
	61	ovs_be32 ip_src;
	62	ovs_be32 ip_dst;
	63	uint16_t flags;
	64	uint8_t ip_tos;
	65	uint8_t ip_ttl;
	66	};
	67
	68	struct flow {
	69	struct flow_tnl tunnel; /* Encapsulating tunnel parameters. */
	70	ovs_be64 metadata; /* OpenFlow Metadata. */
	71	struct in6_addr ipv6_src; /* IPv6 source address. */
	72	struct in6_addr ipv6_dst; /* IPv6 destination address. */
	73	struct in6_addr nd_target; /* IPv6 neighbor discovery (ND) target. */
	74	uint32_t skb_priority; /* Packet priority for QoS. */
	75	uint32_t regs[FLOW_N_REGS]; /* Registers. */
	76	ovs_be32 nw_src; /* IPv4 source address. */
	77	ovs_be32 nw_dst; /* IPv4 destination address. */
	78	ovs_be32 ipv6_label; /* IPv6 flow label. */
	79	uint16_t in_port; /* OpenFlow port number of input port. */
	80	ovs_be16 vlan_tci; /* If 802.1Q, TCI \| VLAN_CFI; otherwise 0. */
	81	ovs_be16 dl_type; /* Ethernet frame type. */
	82	ovs_be16 tp_src; /* TCP/UDP source port. */
	83	ovs_be16 tp_dst; /* TCP/UDP destination port. */
	84	uint8_t dl_src[6]; /* Ethernet source address. */
	85	uint8_t dl_dst[6]; /* Ethernet destination address. */
	86	uint8_t nw_proto; /* IP protocol or low 8 bits of ARP opcode. */
	87	uint8_t nw_tos; /* IP ToS (including DSCP and ECN). */
	88	uint8_t arp_sha[6]; /* ARP/ND source hardware address. */
	89	uint8_t arp_tha[6]; /* ARP/ND target hardware address. */
	90	uint8_t nw_ttl; /* IP TTL/Hop Limit. */
	91	uint8_t nw_frag; /* FLOW_FRAG_* flags. */
	92	uint8_t zeros[2]; /* Must be zero. */
	93	};
	94	BUILD_ASSERT_DECL(sizeof(struct flow) % 4 == 0);
	95
	96	#define FLOW_U32S (sizeof(struct flow) / 4)
	97
	98	/* Remember to update FLOW_WC_SEQ when changing 'struct flow'. */
	99	BUILD_ASSERT_DECL(sizeof(struct flow) == sizeof(struct flow_tnl) + 144 &&
	100	FLOW_WC_SEQ == 17);
	101
	102	/* Represents the metadata fields of struct flow. */
	103	struct flow_metadata {
	104	ovs_be64 tun_id; /* Encapsulating tunnel ID. */
	105	ovs_be64 metadata; /* OpenFlow 1.1+ metadata field. */
	106	uint32_t regs[FLOW_N_REGS]; /* Registers. */
	107	uint16_t in_port; /* OpenFlow port or zero. */
	108	};
	109
	110	void flow_extract(struct ofpbuf , uint32_t priority, const struct flow_tnl ,
	111	uint16_t in_port, struct flow *);
	112	void flow_zero_wildcards(struct flow , const struct flow_wildcards );
	113	void flow_get_metadata(const struct flow , struct flow_metadata );
	114
	115	char flow_to_string(const struct flow );
	116	void flow_format(struct ds , const struct flow );
	117	void flow_print(FILE , const struct flow );
	118	static inline int flow_compare_3way(const struct flow , const struct flow );
	119	static inline bool flow_equal(const struct flow , const struct flow );
	120	static inline size_t flow_hash(const struct flow *, uint32_t basis);
	121
	122	void flow_set_dl_vlan(struct flow *, ovs_be16 vid);
	123	void flow_set_vlan_vid(struct flow *, ovs_be16 vid);
	124	void flow_set_vlan_pcp(struct flow *, uint8_t pcp);
	125
	126	void flow_compose(struct ofpbuf , const struct flow );
	127
	128	static inline int
	129	flow_compare_3way(const struct flow a, const struct flow b)
	130	{
	131	return memcmp(a, b, sizeof *a);
	132	}
	133
	134	static inline bool
	135	flow_equal(const struct flow a, const struct flow b)
	136	{
	137	return !flow_compare_3way(a, b);
	138	}
	139
	140	static inline size_t
	141	flow_hash(const struct flow *flow, uint32_t basis)
	142	{
	143	return hash_words((const uint32_t ) flow, sizeof flow / 4, basis);
	144	}
	145
	146	uint32_t flow_hash_in_minimask(const struct flow , const struct minimask ,
	147	uint32_t basis);
	148	\f
	149	/* Wildcards for a flow.
	150	*
	151	* A 1-bit in each bit in 'masks' indicates that the corresponding bit of
	152	* the flow is significant (must match). A 0-bit indicates that the
	153	* corresponding bit of the flow is wildcarded (need not match). */
	154	struct flow_wildcards {
	155	struct flow masks;
	156	};
	157
	158	void flow_wildcards_init_catchall(struct flow_wildcards *);
	159	void flow_wildcards_init_exact(struct flow_wildcards *);
	160
	161	bool flow_wildcards_is_catchall(const struct flow_wildcards *);
	162
	163	void flow_wildcards_set_reg_mask(struct flow_wildcards *,
	164	int idx, uint32_t mask);
	165
	166	void flow_wildcards_combine(struct flow_wildcards *dst,
	167	const struct flow_wildcards *src1,
	168	const struct flow_wildcards *src2);
	169	bool flow_wildcards_has_extra(const struct flow_wildcards *,
	170	const struct flow_wildcards *);
	171
	172	uint32_t flow_wildcards_hash(const struct flow_wildcards *, uint32_t basis);
	173	bool flow_wildcards_equal(const struct flow_wildcards *,
	174	const struct flow_wildcards *);
	175	uint32_t flow_hash_symmetric_l4(const struct flow *flow, uint32_t basis);
	176
	177	uint32_t flow_hash_fields(const struct flow *, enum nx_hash_fields,
	178	uint16_t basis);
	179	const char *flow_hash_fields_to_str(enum nx_hash_fields);
	180	bool flow_hash_fields_valid(enum nx_hash_fields);
	181
	182	bool flow_equal_except(const struct flow a, const struct flow b,
	183	const struct flow_wildcards *);
	184	\f
	185	/* Compressed flow. */
	186
	187	#define MINI_N_INLINE (sizeof(void *) == 4 ? 7 : 8)
	188	#define MINI_N_MAPS DIV_ROUND_UP(FLOW_U32S, 32)
	189
	190	/* A sparse representation of a "struct flow".
	191	*
	192	* A "struct flow" is fairly large and tends to be mostly zeros. Sparse
	193	* representation has two advantages. First, it saves memory. Second, it
	194	* saves time when the goal is to iterate over only the nonzero parts of the
	195	* struct.
	196	*
	197	* The 'map' member holds one bit for each uint32_t in a "struct flow". Each
	198	* 0-bit indicates that the corresponding uint32_t is zero, each 1-bit that it
	199	* is nonzero.
	200	*
	201	* 'values' points to the start of an array that has one element for each 1-bit
	202	* in 'map'. The least-numbered 1-bit is in values[0], the next 1-bit is in
	203	* values[1], and so on.
	204	*
	205	* 'values' may point to a few different locations:
	206	*
	207	* - If 'map' has MINI_N_INLINE or fewer 1-bits, it may point to
	208	* 'inline_values'. One hopes that this is the common case.
	209	*
	210	* - If 'map' has more than MINI_N_INLINE 1-bits, it may point to memory
	211	* allocated with malloc().
	212	*
	213	* - The caller could provide storage on the stack for situations where
	214	* that makes sense. So far that's only proved useful for
	215	* minimask_combine(), but the principle works elsewhere.
	216	*
	217	* The implementation maintains and depends on the invariant that every element
	218	* in 'values' is nonzero; that is, wherever a 1-bit appears in 'map', the
	219	* corresponding element of 'values' must be nonzero.
	220	*/
	221	struct miniflow {
	222	uint32_t *values;
	223	uint32_t inline_values[MINI_N_INLINE];
	224	uint32_t map[MINI_N_MAPS];
	225	};
	226
	227	void miniflow_init(struct miniflow , const struct flow );
	228	void miniflow_clone(struct miniflow , const struct miniflow );
	229	void miniflow_destroy(struct miniflow *);
	230
	231	void miniflow_expand(const struct miniflow , struct flow );
	232
	233	uint32_t miniflow_get(const struct miniflow *, unsigned int u32_ofs);
	234	uint16_t miniflow_get_vid(const struct miniflow *);
	235
	236	bool miniflow_equal(const struct miniflow a, const struct miniflow b);
	237	bool miniflow_equal_in_minimask(const struct miniflow *a,
	238	const struct miniflow *b,
	239	const struct minimask *);
	240	bool miniflow_equal_flow_in_minimask(const struct miniflow *a,
	241	const struct flow *b,
	242	const struct minimask *);
	243	uint32_t miniflow_hash(const struct miniflow *, uint32_t basis);
	244	uint32_t miniflow_hash_in_minimask(const struct miniflow *,
	245	const struct minimask *, uint32_t basis);
	246	\f
	247	/* Compressed flow wildcards. */
	248
	249	/* A sparse representation of a "struct flow_wildcards".
	250	*
	251	* See the large comment on struct miniflow for details. */
	252	struct minimask {
	253	struct miniflow masks;
	254	};
	255
	256	void minimask_init(struct minimask , const struct flow_wildcards );
	257	void minimask_clone(struct minimask , const struct minimask );
	258	void minimask_combine(struct minimask *dst,
	259	const struct minimask a, const struct minimask b,
	260	uint32_t storage[FLOW_U32S]);
	261	void minimask_destroy(struct minimask *);
	262
	263	void minimask_expand(const struct minimask , struct flow_wildcards );
	264
	265	uint32_t minimask_get(const struct minimask *, unsigned int u32_ofs);
	266	uint16_t minimask_get_vid_mask(const struct minimask *);
	267
	268	bool minimask_equal(const struct minimask a, const struct minimask b);
	269	uint32_t minimask_hash(const struct minimask *, uint32_t basis);
	270
	271	bool minimask_has_extra(const struct minimask , const struct minimask );
	272	bool minimask_is_catchall(const struct minimask *);
	273
	274	#endif /* flow.h */