+uint32_t flow_hash_in_wildcards(const struct flow *,
+ const struct flow_wildcards *,
+ uint32_t basis);
+
+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)
+BUILD_ASSERT_DECL(FLOW_U32S <= 64);
+
+/* 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
+ * *may* be 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.
+ *
+ * Elements in 'values' are allowed to be zero. This is useful for "struct
+ * minimatch", for which ensuring that the miniflow and minimask members have
+ * same 'map' allows optimization. This allowance applies only to a miniflow
+ * that is not a mask. That is, a minimask may NOT have zero elements in
+ * its 'values'.
+ */
+struct miniflow {
+ uint64_t map;
+ uint32_t *values;
+ uint32_t inline_values[MINI_N_INLINE];
+};
+
+/* This is useful for initializing a miniflow for a miniflow_extract() call. */
+static inline void miniflow_initialize(struct miniflow *mf,
+ uint32_t buf[FLOW_U32S])
+{
+ mf->map = 0;
+ mf->values = buf;
+}
+
+struct pkt_metadata;
+
+/* The 'dst->values' must be initialized with a buffer with space for
+ * FLOW_U32S. 'dst->map' is ignored on input and set on output to
+ * indicate which fields were extracted. */
+void miniflow_extract(struct ofpbuf *packet, const struct pkt_metadata *,
+ struct miniflow *dst);
+void miniflow_init(struct miniflow *, const struct flow *);
+void miniflow_init_with_minimask(struct miniflow *, const struct flow *,
+ const struct minimask *);
+void miniflow_clone(struct miniflow *, const struct miniflow *);
+void miniflow_move(struct miniflow *dst, struct miniflow *);
+void miniflow_destroy(struct miniflow *);
+
+void miniflow_expand(const struct miniflow *, struct flow *);
+
+static inline uint32_t
+mf_get_next_in_map(uint64_t *fmap, uint64_t rm1bit, const uint32_t **fp,
+ uint32_t *value)
+{
+ *value = 0;
+ if (*fmap & rm1bit) {
+ uint64_t trash = *fmap & (rm1bit - 1);
+
+ if (trash) {
+ *fmap -= trash;
+ *fp += count_1bits(trash);
+ }
+ *value = **fp;
+ }
+ return rm1bit != 0;
+}
+
+/* Iterate through all miniflow u32 values specified by the 'MAP'.
+ * This works as the first statement in a block.*/
+#define MINIFLOW_FOR_EACH_IN_MAP(VALUE, FLOW, MAP) \
+ const uint32_t *fp_ = (FLOW)->values; \
+ uint64_t rm1bit_, fmap_, map_; \
+ for (fmap_ = (FLOW)->map, map_ = (MAP), rm1bit_ = rightmost_1bit(map_); \
+ mf_get_next_in_map(&fmap_, rm1bit_, &fp_, &(VALUE)); \
+ map_ -= rm1bit_, rm1bit_ = rightmost_1bit(map_))
+
+/* These accessors use byte offsets, which are assumed to be compile-time
+ * constants. */
+static inline uint8_t miniflow_get_u8(const struct miniflow *,
+ unsigned int ofs);
+static inline uint16_t miniflow_get_u16(const struct miniflow *,
+ unsigned int ofs);
+static inline ovs_be16 miniflow_get_be16(const struct miniflow *,
+ unsigned int ofs);
+static inline uint32_t miniflow_get_u32(const struct miniflow *,
+ unsigned int ofs);
+static inline ovs_be32 miniflow_get_be32(const struct miniflow *,
+ unsigned int ofs);
+
+static inline uint16_t miniflow_get_vid(const struct miniflow *);
+static inline uint16_t miniflow_get_tcp_flags(const struct miniflow *);
+static inline ovs_be64 miniflow_get_metadata(const struct miniflow *);
+static inline uint8_t miniflow_get_u8(const struct miniflow *, unsigned int ofs);
+
+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);
+uint64_t miniflow_get_map_in_range(const struct miniflow *miniflow,
+ uint8_t start, uint8_t end,
+ unsigned int *offset);
+uint32_t miniflow_hash_5tuple(const struct miniflow *flow, uint32_t basis);
+
+\f
+/* Compressed flow wildcards. */
+
+/* A sparse representation of a "struct flow_wildcards".
+ *
+ * See the large comment on struct miniflow for details.
+ *
+ * Note: While miniflow can have zero data for a 1-bit in the map,
+ * a minimask may not! We rely on this in the implementation. */
+struct minimask {
+ struct miniflow masks;
+};
+
+void minimask_init(struct minimask *, const struct flow_wildcards *);
+void minimask_clone(struct minimask *, const struct minimask *);
+void minimask_move(struct minimask *dst, struct minimask *src);
+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);
+static inline uint16_t minimask_get_vid_mask(const struct minimask *);
+static inline ovs_be64 minimask_get_metadata_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 *);
+\f
+
+/* 'OFS' is a compile-time constant. */
+#define MINIFLOW_GET_TYPE(MF, TYPE, OFS) \
+ (MF->map & UINT64_C(1) << OFS / 4) \
+ ? ((OVS_FORCE const TYPE *) \
+ (MF->values + count_1bits(MF->map & ((UINT64_C(1) << OFS / 4) - 1)))) \
+ [OFS % 4 / sizeof(TYPE)] \
+ : 0
+
+static inline uint8_t
+miniflow_get_u8(const struct miniflow *flow, unsigned int ofs)
+{
+ return MINIFLOW_GET_TYPE(flow, uint8_t, ofs);
+}
+
+static inline uint16_t
+miniflow_get_u16(const struct miniflow *flow, unsigned int ofs)
+{
+ return MINIFLOW_GET_TYPE(flow, uint16_t, ofs);
+}
+
+/* Returns the ovs_be16 that would be at byte offset 'u8_ofs' if 'flow' were
+ * expanded into a "struct flow". */
+static inline ovs_be16
+miniflow_get_be16(const struct miniflow *flow, unsigned int ofs)
+{
+ return MINIFLOW_GET_TYPE(flow, ovs_be16, ofs);
+}
+
+static inline uint32_t
+miniflow_get_u32(const struct miniflow *flow, unsigned int ofs)
+{
+ return MINIFLOW_GET_TYPE(flow, uint32_t, ofs);
+}
+
+static inline ovs_be32
+miniflow_get_be32(const struct miniflow *flow, unsigned int ofs)
+{
+ return MINIFLOW_GET_TYPE(flow, ovs_be32, ofs);
+}
+
+#undef MINIFLOW_GET_TYPE
+
+/* Returns the VID within the vlan_tci member of the "struct flow" represented
+ * by 'flow'. */
+static inline uint16_t
+miniflow_get_vid(const struct miniflow *flow)
+{
+ ovs_be16 tci = miniflow_get_be16(flow, offsetof(struct flow, vlan_tci));
+ return vlan_tci_to_vid(tci);
+}
+
+/* Returns the VID mask within the vlan_tci member of the "struct
+ * flow_wildcards" represented by 'mask'. */
+static inline uint16_t
+minimask_get_vid_mask(const struct minimask *mask)
+{
+ return miniflow_get_vid(&mask->masks);
+}
+
+/* Returns the value of the "tcp_flags" field in 'flow'. */
+static inline uint16_t
+miniflow_get_tcp_flags(const struct miniflow *flow)
+{
+ return ntohs(miniflow_get_be16(flow, offsetof(struct flow, tcp_flags)));
+}
+
+/* Returns the value of the OpenFlow 1.1+ "metadata" field in 'flow'. */
+static inline ovs_be64
+miniflow_get_metadata(const struct miniflow *flow)
+{
+ enum { MD_OFS = offsetof(struct flow, metadata) };
+ BUILD_ASSERT_DECL(MD_OFS % sizeof(uint32_t) == 0);
+ ovs_be32 hi = miniflow_get_be32(flow, MD_OFS);
+ ovs_be32 lo = miniflow_get_be32(flow, MD_OFS + 4);
+
+ return htonll(((uint64_t) ntohl(hi) << 32) | ntohl(lo));
+}
+
+/* Returns the mask for the OpenFlow 1.1+ "metadata" field in 'mask'.
+ *
+ * The return value is all-1-bits if 'mask' matches on the whole value of the
+ * metadata field, all-0-bits if 'mask' entirely wildcards the metadata field,
+ * or some other value if the metadata field is partially matched, partially
+ * wildcarded. */
+static inline ovs_be64
+minimask_get_metadata_mask(const struct minimask *mask)
+{
+ return miniflow_get_metadata(&mask->masks);
+}
+
+static inline struct pkt_metadata
+pkt_metadata_from_flow(const struct flow *flow)
+{
+ struct pkt_metadata md;
+
+ md.recirc_id = flow->recirc_id;
+ md.dp_hash = flow->dp_hash;
+ md.tunnel = flow->tunnel;
+ md.skb_priority = flow->skb_priority;
+ md.pkt_mark = flow->pkt_mark;
+ md.in_port = flow->in_port;
+
+ return md;
+}
+
+static inline bool is_ip_any(const struct flow *flow)
+{
+ return dl_type_is_ip_any(flow->dl_type);
+}
+
+static inline bool is_icmpv4(const struct flow *flow)
+{
+ return (flow->dl_type == htons(ETH_TYPE_IP)
+ && flow->nw_proto == IPPROTO_ICMP);
+}
+
+static inline bool is_icmpv6(const struct flow *flow)
+{
+ return (flow->dl_type == htons(ETH_TYPE_IPV6)
+ && flow->nw_proto == IPPROTO_ICMPV6);
+}
+
+static inline bool is_stp(const struct flow *flow)
+{
+ return (eth_addr_equals(flow->dl_dst, eth_addr_stp)
+ && flow->dl_type == htons(FLOW_DL_TYPE_NONE));
+}
+