[mirror_ovs.git] / lib / netdev-tc-offloads.c

/*
 * Copyright (c) 2016 Mellanox Technologies, Ltd.
 *
 * 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.
 */

#include <config.h>
#include "netdev-tc-offloads.h"
#include <errno.h>
#include <linux/if_ether.h>
#include "openvswitch/hmap.h"
#include "openvswitch/match.h"
#include "openvswitch/ofpbuf.h"
#include "openvswitch/thread.h"
#include "openvswitch/types.h"
#include "openvswitch/vlog.h"
#include "netdev-provider.h"
#include "netlink.h"
#include "netlink-socket.h"
#include "odp-netlink.h"
#include "unaligned.h"
#include "util.h"
#include "hash.h"
#include "dpif.h"
#include "tc.h"

VLOG_DEFINE_THIS_MODULE(netdev_tc_offloads);

static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(60, 5);

static struct hmap ufid_tc = HMAP_INITIALIZER(&ufid_tc);
static struct ovs_mutex ufid_lock = OVS_MUTEX_INITIALIZER;

/**
 * struct ufid_tc_data - data entry for ufid_tc hmap.
 * @ufid_node: Element in @ufid_tc hash table by ufid key.
 * @tc_node: Element in @ufid_tc hash table by prio/handle/ifindex key.
 * @ufid: ufid assigned to the flow
 * @prio: tc priority
 * @handle: tc handle
 * @ifindex: netdev ifindex.
 * @netdev: netdev associated with the tc rule
 */
struct ufid_tc_data {
    struct hmap_node ufid_node;
    struct hmap_node tc_node;
    ovs_u128 ufid;
    uint16_t prio;
    uint32_t handle;
    int ifindex;
    struct netdev *netdev;
};

/* Remove matching ufid entry from ufid_tc hashmap. */
static void
del_ufid_tc_mapping(const ovs_u128 *ufid)
{
    size_t ufid_hash = hash_bytes(ufid, sizeof *ufid, 0);
    struct ufid_tc_data *data;

    ovs_mutex_lock(&ufid_lock);
    HMAP_FOR_EACH_WITH_HASH(data, ufid_node, ufid_hash, &ufid_tc) {
        if (ovs_u128_equals(*ufid, data->ufid)) {
            break;
        }
    }

    if (!data) {
        ovs_mutex_unlock(&ufid_lock);
        return;
    }

    hmap_remove(&ufid_tc, &data->ufid_node);
    hmap_remove(&ufid_tc, &data->tc_node);
    netdev_close(data->netdev);
    free(data);
    ovs_mutex_unlock(&ufid_lock);
}

/* Add ufid entry to ufid_tc hashmap.
 * If entry exists already it will be replaced. */
static void OVS_UNUSED
add_ufid_tc_mapping(const ovs_u128 *ufid, int prio, int handle,
                    struct netdev *netdev, int ifindex)
{
    size_t ufid_hash = hash_bytes(ufid, sizeof *ufid, 0);
    size_t tc_hash = hash_int(hash_int(prio, handle), ifindex);
    struct ufid_tc_data *new_data = xzalloc(sizeof *new_data);

    del_ufid_tc_mapping(ufid);

    new_data->ufid = *ufid;
    new_data->prio = prio;
    new_data->handle = handle;
    new_data->netdev = netdev_ref(netdev);
    new_data->ifindex = ifindex;

    ovs_mutex_lock(&ufid_lock);
    hmap_insert(&ufid_tc, &new_data->ufid_node, ufid_hash);
    hmap_insert(&ufid_tc, &new_data->tc_node, tc_hash);
    ovs_mutex_unlock(&ufid_lock);
}

/* Get ufid from ufid_tc hashmap.
 *
 * If netdev output param is not NULL then the function will return
 * associated netdev on success and a refcount is taken on that netdev.
 * The caller is then responsible to close the netdev.
 *
 * Returns handle if successful and fill prio and netdev for that ufid.
 * Otherwise returns 0.
 */
static int OVS_UNUSED
get_ufid_tc_mapping(const ovs_u128 *ufid, int *prio, struct netdev **netdev)
{
    size_t ufid_hash = hash_bytes(ufid, sizeof *ufid, 0);
    struct ufid_tc_data *data;
    int handle = 0;

    ovs_mutex_lock(&ufid_lock);
    HMAP_FOR_EACH_WITH_HASH(data, ufid_node, ufid_hash, &ufid_tc) {
        if (ovs_u128_equals(*ufid, data->ufid)) {
            if (prio) {
                *prio = data->prio;
            }
            if (netdev) {
                *netdev = netdev_ref(data->netdev);
            }
            handle = data->handle;
            break;
        }
    }
    ovs_mutex_unlock(&ufid_lock);

    return handle;
}

/* Find ufid entry in ufid_tc hashmap using prio, handle and netdev.
 * The result is saved in ufid.
 *
 * Returns true on success.
 */
static bool
find_ufid(int prio, int handle, struct netdev *netdev, ovs_u128 *ufid)
{
    int ifindex = netdev_get_ifindex(netdev);
    struct ufid_tc_data *data;
    size_t tc_hash = hash_int(hash_int(prio, handle), ifindex);

    ovs_mutex_lock(&ufid_lock);
    HMAP_FOR_EACH_WITH_HASH(data, tc_node, tc_hash,  &ufid_tc) {
        if (data->prio == prio && data->handle == handle
            && data->ifindex == ifindex) {
            *ufid = data->ufid;
            break;
        }
    }
    ovs_mutex_unlock(&ufid_lock);

    return (data != NULL);
}

int
netdev_tc_flow_flush(struct netdev *netdev)
{
    int ifindex = netdev_get_ifindex(netdev);

    if (ifindex < 0) {
        VLOG_ERR_RL(&error_rl, "failed to get ifindex for %s: %s",
                    netdev_get_name(netdev), ovs_strerror(-ifindex));
        return -ifindex;
    }

    return tc_flush(ifindex);
}

int
netdev_tc_flow_dump_create(struct netdev *netdev,
                           struct netdev_flow_dump **dump_out)
{
    struct netdev_flow_dump *dump;
    int ifindex;

    ifindex = netdev_get_ifindex(netdev);
    if (ifindex < 0) {
        VLOG_ERR_RL(&error_rl, "failed to get ifindex for %s: %s",
                    netdev_get_name(netdev), ovs_strerror(-ifindex));
        return -ifindex;
    }

    dump = xzalloc(sizeof *dump);
    dump->nl_dump = xzalloc(sizeof *dump->nl_dump);
    dump->netdev = netdev_ref(netdev);
    tc_dump_flower_start(ifindex, dump->nl_dump);

    *dump_out = dump;

    return 0;
}

int
netdev_tc_flow_dump_destroy(struct netdev_flow_dump *dump)
{
    nl_dump_done(dump->nl_dump);
    netdev_close(dump->netdev);
    free(dump->nl_dump);
    free(dump);
    return 0;
}

static int
parse_tc_flower_to_match(struct tc_flower *flower,
                         struct match *match,
                         struct nlattr **actions,
                         struct dpif_flow_stats *stats,
                         struct ofpbuf *buf) {
    size_t act_off;
    struct tc_flower_key *key = &flower->key;
    struct tc_flower_key *mask = &flower->mask;
    odp_port_t outport = 0;

    if (flower->ifindex_out) {
        outport = netdev_ifindex_to_odp_port(flower->ifindex_out);
        if (!outport) {
            return ENOENT;
        }
    }

    ofpbuf_clear(buf);

    match_init_catchall(match);
    match_set_dl_src_masked(match, key->src_mac, mask->src_mac);
    match_set_dl_dst_masked(match, key->dst_mac, mask->dst_mac);

    if (key->eth_type == htons(ETH_TYPE_VLAN)) {
        match_set_dl_vlan(match, htons(key->vlan_id));
        match_set_dl_vlan_pcp(match, key->vlan_prio);
        match_set_dl_type(match, key->encap_eth_type);
        flow_fix_vlan_tpid(&match->flow);
    } else {
        match_set_dl_type(match, key->eth_type);
    }

    if (key->ip_proto && is_ip_any(&match->flow)) {
        match_set_nw_proto(match, key->ip_proto);
    }

    match_set_nw_src_masked(match, key->ipv4.ipv4_src, mask->ipv4.ipv4_src);
    match_set_nw_dst_masked(match, key->ipv4.ipv4_dst, mask->ipv4.ipv4_dst);

    match_set_ipv6_src_masked(match,
                              &key->ipv6.ipv6_src, &mask->ipv6.ipv6_src);
    match_set_ipv6_dst_masked(match,
                              &key->ipv6.ipv6_dst, &mask->ipv6.ipv6_dst);

    match_set_tp_dst_masked(match, key->dst_port, mask->dst_port);
    match_set_tp_src_masked(match, key->src_port, mask->src_port);

    if (flower->tunnel.tunnel) {
        match_set_tun_id(match, flower->tunnel.id);
        if (flower->tunnel.ipv4.ipv4_dst) {
            match_set_tun_src(match, flower->tunnel.ipv4.ipv4_src);
            match_set_tun_dst(match, flower->tunnel.ipv4.ipv4_dst);
        } else if (!is_all_zeros(&flower->tunnel.ipv6.ipv6_dst,
                   sizeof flower->tunnel.ipv6.ipv6_dst)) {
            match_set_tun_ipv6_src(match, &flower->tunnel.ipv6.ipv6_src);
            match_set_tun_ipv6_dst(match, &flower->tunnel.ipv6.ipv6_dst);
        }
        if (flower->tunnel.tp_dst) {
            match_set_tun_tp_dst(match, flower->tunnel.tp_dst);
        }
    }

    act_off = nl_msg_start_nested(buf, OVS_FLOW_ATTR_ACTIONS);
    {
        if (flower->vlan_pop) {
            nl_msg_put_flag(buf, OVS_ACTION_ATTR_POP_VLAN);
        }

        if (flower->vlan_push_id || flower->vlan_push_prio) {
            struct ovs_action_push_vlan *push;
            push = nl_msg_put_unspec_zero(buf, OVS_ACTION_ATTR_PUSH_VLAN,
                                          sizeof *push);

            push->vlan_tpid = htons(ETH_TYPE_VLAN);
            push->vlan_tci = htons(flower->vlan_push_id
                                   | (flower->vlan_push_prio << 13)
                                   | VLAN_CFI);
        }

        if (flower->set.set) {
            size_t set_offset = nl_msg_start_nested(buf, OVS_ACTION_ATTR_SET);
            size_t tunnel_offset =
                nl_msg_start_nested(buf, OVS_KEY_ATTR_TUNNEL);

            nl_msg_put_be64(buf, OVS_TUNNEL_KEY_ATTR_ID, flower->set.id);
            if (flower->set.ipv4.ipv4_src) {
                nl_msg_put_be32(buf, OVS_TUNNEL_KEY_ATTR_IPV4_SRC,
                                flower->set.ipv4.ipv4_src);
            }
            if (flower->set.ipv4.ipv4_dst) {
                nl_msg_put_be32(buf, OVS_TUNNEL_KEY_ATTR_IPV4_DST,
                                flower->set.ipv4.ipv4_dst);
            }
            if (!is_all_zeros(&flower->set.ipv6.ipv6_src,
                              sizeof flower->set.ipv6.ipv6_src)) {
                nl_msg_put_in6_addr(buf, OVS_TUNNEL_KEY_ATTR_IPV6_SRC,
                                    &flower->set.ipv6.ipv6_src);
            }
            if (!is_all_zeros(&flower->set.ipv6.ipv6_dst,
                              sizeof flower->set.ipv6.ipv6_dst)) {
                nl_msg_put_in6_addr(buf, OVS_TUNNEL_KEY_ATTR_IPV6_DST,
                                    &flower->set.ipv6.ipv6_dst);
            }
            nl_msg_put_be16(buf, OVS_TUNNEL_KEY_ATTR_TP_DST,
                            flower->set.tp_dst);

            nl_msg_end_nested(buf, tunnel_offset);
            nl_msg_end_nested(buf, set_offset);
        }

        if (flower->ifindex_out > 0) {
            nl_msg_put_u32(buf, OVS_ACTION_ATTR_OUTPUT, odp_to_u32(outport));
        }

    }
    nl_msg_end_nested(buf, act_off);

    *actions = ofpbuf_at_assert(buf, act_off, sizeof(struct nlattr));

    if (stats) {
        memset(stats, 0, sizeof *stats);
        stats->n_packets = get_32aligned_u64(&flower->stats.n_packets);
        stats->n_bytes = get_32aligned_u64(&flower->stats.n_bytes);
        stats->used = flower->lastused;
    }

    return 0;
}

bool
netdev_tc_flow_dump_next(struct netdev_flow_dump *dump,
                         struct match *match,
                         struct nlattr **actions,
                         struct dpif_flow_stats *stats,
                         ovs_u128 *ufid,
                         struct ofpbuf *rbuffer,
                         struct ofpbuf *wbuffer)
{
    struct ofpbuf nl_flow;

    while (nl_dump_next(dump->nl_dump, &nl_flow, rbuffer)) {
        struct tc_flower flower;
        struct netdev *netdev = dump->netdev;

        if (parse_netlink_to_tc_flower(&nl_flow, &flower)) {
            continue;
        }

        if (parse_tc_flower_to_match(&flower, match, actions, stats,
                                     wbuffer)) {
            continue;
        }

        if (flower.act_cookie.len) {
            *ufid = *((ovs_u128 *) flower.act_cookie.data);
        } else if (!find_ufid(flower.prio, flower.handle, netdev, ufid)) {
            continue;
        }

        match->wc.masks.in_port.odp_port = u32_to_odp(UINT32_MAX);
        match->flow.in_port.odp_port = dump->port;

        return true;
    }

    return false;
}

int
netdev_tc_flow_put(struct netdev *netdev OVS_UNUSED,
                   struct match *match OVS_UNUSED,
                   struct nlattr *actions OVS_UNUSED,
                   size_t actions_len OVS_UNUSED,
                   const ovs_u128 *ufid OVS_UNUSED,
                   struct offload_info *info OVS_UNUSED,
                   struct dpif_flow_stats *stats OVS_UNUSED)
{
    return EOPNOTSUPP;
}

int
netdev_tc_flow_get(struct netdev *netdev OVS_UNUSED,
                   struct match *match OVS_UNUSED,
                   struct nlattr **actions OVS_UNUSED,
                   const ovs_u128 *ufid OVS_UNUSED,
                   struct dpif_flow_stats *stats OVS_UNUSED,
                   struct ofpbuf *buf OVS_UNUSED)
{
    return EOPNOTSUPP;
}

int
netdev_tc_flow_del(struct netdev *netdev OVS_UNUSED,
                   const ovs_u128 *ufid OVS_UNUSED,
                   struct dpif_flow_stats *stats OVS_UNUSED)
{
    return EOPNOTSUPP;
}

int
netdev_tc_init_flow_api(struct netdev *netdev OVS_UNUSED)
{
    return 0;
}
Commit	Line	Data
18ebd48c PB	1	/*
	2	* Copyright (c) 2016 Mellanox Technologies, Ltd.
	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
	17	#include <config.h>
	18	#include "netdev-tc-offloads.h"
	19	#include <errno.h>
	20	#include <linux/if_ether.h>
	21	#include "openvswitch/hmap.h"
	22	#include "openvswitch/match.h"
	23	#include "openvswitch/ofpbuf.h"
	24	#include "openvswitch/thread.h"
	25	#include "openvswitch/types.h"
	26	#include "openvswitch/vlog.h"
	27	#include "netdev-provider.h"
	28	#include "netlink.h"
	29	#include "netlink-socket.h"
	30	#include "odp-netlink.h"
	31	#include "unaligned.h"
	32	#include "util.h"
	33	#include "hash.h"
	34	#include "dpif.h"
	35	#include "tc.h"
	36
	37	VLOG_DEFINE_THIS_MODULE(netdev_tc_offloads);
	38
8140a5ff PB	39	static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(60, 5);
8140a5ff PB	40
9116730d PB	41	static struct hmap ufid_tc = HMAP_INITIALIZER(&ufid_tc);
	42	static struct ovs_mutex ufid_lock = OVS_MUTEX_INITIALIZER;
	43
	44	/**
	45	* struct ufid_tc_data - data entry for ufid_tc hmap.
	46	* @ufid_node: Element in @ufid_tc hash table by ufid key.
	47	* @tc_node: Element in @ufid_tc hash table by prio/handle/ifindex key.
	48	* @ufid: ufid assigned to the flow
	49	* @prio: tc priority
	50	* @handle: tc handle
	51	* @ifindex: netdev ifindex.
	52	* @netdev: netdev associated with the tc rule
	53	*/
	54	struct ufid_tc_data {
	55	struct hmap_node ufid_node;
	56	struct hmap_node tc_node;
	57	ovs_u128 ufid;
	58	uint16_t prio;
	59	uint32_t handle;
	60	int ifindex;
	61	struct netdev *netdev;
	62	};
	63
	64	/* Remove matching ufid entry from ufid_tc hashmap. */
	65	static void
	66	del_ufid_tc_mapping(const ovs_u128 *ufid)
	67	{
	68	size_t ufid_hash = hash_bytes(ufid, sizeof *ufid, 0);
	69	struct ufid_tc_data *data;
	70
	71	ovs_mutex_lock(&ufid_lock);
	72	HMAP_FOR_EACH_WITH_HASH(data, ufid_node, ufid_hash, &ufid_tc) {
	73	if (ovs_u128_equals(*ufid, data->ufid)) {
	74	break;
	75	}
	76	}
	77
	78	if (!data) {
	79	ovs_mutex_unlock(&ufid_lock);
	80	return;
	81	}
	82
	83	hmap_remove(&ufid_tc, &data->ufid_node);
	84	hmap_remove(&ufid_tc, &data->tc_node);
	85	netdev_close(data->netdev);
	86	free(data);
	87	ovs_mutex_unlock(&ufid_lock);
	88	}
	89
	90	/* Add ufid entry to ufid_tc hashmap.
	91	* If entry exists already it will be replaced. */
	92	static void OVS_UNUSED
	93	add_ufid_tc_mapping(const ovs_u128 *ufid, int prio, int handle,
	94	struct netdev *netdev, int ifindex)
	95	{
	96	size_t ufid_hash = hash_bytes(ufid, sizeof *ufid, 0);
	97	size_t tc_hash = hash_int(hash_int(prio, handle), ifindex);
	98	struct ufid_tc_data new_data = xzalloc(sizeof new_data);
	99
	100	del_ufid_tc_mapping(ufid);
	101
	102	new_data->ufid = *ufid;
	103	new_data->prio = prio;
	104	new_data->handle = handle;
105	new_data->netdev = netdev_ref(netdev);
106	new_data->ifindex = ifindex;
107
108	ovs_mutex_lock(&ufid_lock);
109	hmap_insert(&ufid_tc, &new_data->ufid_node, ufid_hash);
110	hmap_insert(&ufid_tc, &new_data->tc_node, tc_hash);
111	ovs_mutex_unlock(&ufid_lock);
112	}
113
114	/* Get ufid from ufid_tc hashmap.
115	*
116	* If netdev output param is not NULL then the function will return
117	* associated netdev on success and a refcount is taken on that netdev.
118	* The caller is then responsible to close the netdev.
119	*
120	* Returns handle if successful and fill prio and netdev for that ufid.
121	* Otherwise returns 0.
122	*/
123	static int OVS_UNUSED
124	get_ufid_tc_mapping(const ovs_u128 ufid, int prio, struct netdev **netdev)
125	{
126	size_t ufid_hash = hash_bytes(ufid, sizeof *ufid, 0);
127	struct ufid_tc_data *data;
128	int handle = 0;
129
130	ovs_mutex_lock(&ufid_lock);
131	HMAP_FOR_EACH_WITH_HASH(data, ufid_node, ufid_hash, &ufid_tc) {
132	if (ovs_u128_equals(*ufid, data->ufid)) {
133	if (prio) {
134	*prio = data->prio;
135	}
136	if (netdev) {
137	*netdev = netdev_ref(data->netdev);
138	}
139	handle = data->handle;
140	break;
141	}
142	}
143	ovs_mutex_unlock(&ufid_lock);
144
145	return handle;
146	}
147
148	/* Find ufid entry in ufid_tc hashmap using prio, handle and netdev.
149	* The result is saved in ufid.
150	*
151	* Returns true on success.
152	*/
8f7620e6	153	static bool
9116730d PB	154	find_ufid(int prio, int handle, struct netdev netdev, ovs_u128 ufid)
	155	{
	156	int ifindex = netdev_get_ifindex(netdev);
	157	struct ufid_tc_data *data;
	158	size_t tc_hash = hash_int(hash_int(prio, handle), ifindex);
	159
	160	ovs_mutex_lock(&ufid_lock);
	161	HMAP_FOR_EACH_WITH_HASH(data, tc_node, tc_hash, &ufid_tc) {
	162	if (data->prio == prio && data->handle == handle
	163	&& data->ifindex == ifindex) {
	164	*ufid = data->ufid;
	165	break;
	166	}
	167	}
	168	ovs_mutex_unlock(&ufid_lock);
	169
	170	return (data != NULL);
	171	}
	172
18ebd48c	173	int
8140a5ff	174	netdev_tc_flow_flush(struct netdev *netdev)
18ebd48c	175	{
8140a5ff PB	176	int ifindex = netdev_get_ifindex(netdev);
	177
	178	if (ifindex < 0) {
	179	VLOG_ERR_RL(&error_rl, "failed to get ifindex for %s: %s",
	180	netdev_get_name(netdev), ovs_strerror(-ifindex));
	181	return -ifindex;
	182	}
	183
	184	return tc_flush(ifindex);
18ebd48c PB	185	}
	186
	187	int
	188	netdev_tc_flow_dump_create(struct netdev *netdev,
	189	struct netdev_flow_dump **dump_out)
	190	{
8f7620e6 PB	191	struct netdev_flow_dump *dump;
	192	int ifindex;
	193
	194	ifindex = netdev_get_ifindex(netdev);
	195	if (ifindex < 0) {
	196	VLOG_ERR_RL(&error_rl, "failed to get ifindex for %s: %s",
	197	netdev_get_name(netdev), ovs_strerror(-ifindex));
	198	return -ifindex;
	199	}
18ebd48c	200
8f7620e6 PB	201	dump = xzalloc(sizeof *dump);
8f7620e6 PB	202	dump->nl_dump = xzalloc(sizeof *dump->nl_dump);
18ebd48c	203	dump->netdev = netdev_ref(netdev);
8f7620e6	204	tc_dump_flower_start(ifindex, dump->nl_dump);
18ebd48c PB	205
	206	*dump_out = dump;
	207
	208	return 0;
	209	}
	210
	211	int
	212	netdev_tc_flow_dump_destroy(struct netdev_flow_dump *dump)
	213	{
8f7620e6	214	nl_dump_done(dump->nl_dump);
18ebd48c	215	netdev_close(dump->netdev);
8f7620e6	216	free(dump->nl_dump);
18ebd48c	217	free(dump);
8f7620e6 PB	218	return 0;
	219	}
	220
	221	static int
	222	parse_tc_flower_to_match(struct tc_flower *flower,
	223	struct match *match,
	224	struct nlattr **actions,
	225	struct dpif_flow_stats *stats,
	226	struct ofpbuf *buf) {
	227	size_t act_off;
	228	struct tc_flower_key *key = &flower->key;
	229	struct tc_flower_key *mask = &flower->mask;
	230	odp_port_t outport = 0;
	231
	232	if (flower->ifindex_out) {
	233	outport = netdev_ifindex_to_odp_port(flower->ifindex_out);
	234	if (!outport) {
	235	return ENOENT;
	236	}
	237	}
	238
	239	ofpbuf_clear(buf);
	240
	241	match_init_catchall(match);
	242	match_set_dl_src_masked(match, key->src_mac, mask->src_mac);
	243	match_set_dl_dst_masked(match, key->dst_mac, mask->dst_mac);
	244
	245	if (key->eth_type == htons(ETH_TYPE_VLAN)) {
	246	match_set_dl_vlan(match, htons(key->vlan_id));
	247	match_set_dl_vlan_pcp(match, key->vlan_prio);
	248	match_set_dl_type(match, key->encap_eth_type);
	249	flow_fix_vlan_tpid(&match->flow);
	250	} else {
	251	match_set_dl_type(match, key->eth_type);
	252	}
	253
	254	if (key->ip_proto && is_ip_any(&match->flow)) {
	255	match_set_nw_proto(match, key->ip_proto);
	256	}
	257
	258	match_set_nw_src_masked(match, key->ipv4.ipv4_src, mask->ipv4.ipv4_src);
	259	match_set_nw_dst_masked(match, key->ipv4.ipv4_dst, mask->ipv4.ipv4_dst);
	260
	261	match_set_ipv6_src_masked(match,
	262	&key->ipv6.ipv6_src, &mask->ipv6.ipv6_src);
	263	match_set_ipv6_dst_masked(match,
	264	&key->ipv6.ipv6_dst, &mask->ipv6.ipv6_dst);
	265
	266	match_set_tp_dst_masked(match, key->dst_port, mask->dst_port);
	267	match_set_tp_src_masked(match, key->src_port, mask->src_port);
	268
	269	if (flower->tunnel.tunnel) {
	270	match_set_tun_id(match, flower->tunnel.id);
	271	if (flower->tunnel.ipv4.ipv4_dst) {
	272	match_set_tun_src(match, flower->tunnel.ipv4.ipv4_src);
	273	match_set_tun_dst(match, flower->tunnel.ipv4.ipv4_dst);
	274	} else if (!is_all_zeros(&flower->tunnel.ipv6.ipv6_dst,
	275	sizeof flower->tunnel.ipv6.ipv6_dst)) {
	276	match_set_tun_ipv6_src(match, &flower->tunnel.ipv6.ipv6_src);
	277	match_set_tun_ipv6_dst(match, &flower->tunnel.ipv6.ipv6_dst);
	278	}
	279	if (flower->tunnel.tp_dst) {
	280	match_set_tun_tp_dst(match, flower->tunnel.tp_dst);
	281	}
282	}
283
284	act_off = nl_msg_start_nested(buf, OVS_FLOW_ATTR_ACTIONS);
285	{
286	if (flower->vlan_pop) {
287	nl_msg_put_flag(buf, OVS_ACTION_ATTR_POP_VLAN);
288	}
289
290	if (flower->vlan_push_id \|\| flower->vlan_push_prio) {
291	struct ovs_action_push_vlan *push;
292	push = nl_msg_put_unspec_zero(buf, OVS_ACTION_ATTR_PUSH_VLAN,
293	sizeof *push);
294
295	push->vlan_tpid = htons(ETH_TYPE_VLAN);
296	push->vlan_tci = htons(flower->vlan_push_id
297	\| (flower->vlan_push_prio << 13)
298	\| VLAN_CFI);
299	}
300
301	if (flower->set.set) {
302	size_t set_offset = nl_msg_start_nested(buf, OVS_ACTION_ATTR_SET);
303	size_t tunnel_offset =
304	nl_msg_start_nested(buf, OVS_KEY_ATTR_TUNNEL);
305
306	nl_msg_put_be64(buf, OVS_TUNNEL_KEY_ATTR_ID, flower->set.id);
307	if (flower->set.ipv4.ipv4_src) {
308	nl_msg_put_be32(buf, OVS_TUNNEL_KEY_ATTR_IPV4_SRC,
309	flower->set.ipv4.ipv4_src);
310	}
311	if (flower->set.ipv4.ipv4_dst) {
312	nl_msg_put_be32(buf, OVS_TUNNEL_KEY_ATTR_IPV4_DST,
313	flower->set.ipv4.ipv4_dst);
314	}
315	if (!is_all_zeros(&flower->set.ipv6.ipv6_src,
316	sizeof flower->set.ipv6.ipv6_src)) {
317	nl_msg_put_in6_addr(buf, OVS_TUNNEL_KEY_ATTR_IPV6_SRC,
318	&flower->set.ipv6.ipv6_src);
319	}
320	if (!is_all_zeros(&flower->set.ipv6.ipv6_dst,
321	sizeof flower->set.ipv6.ipv6_dst)) {
322	nl_msg_put_in6_addr(buf, OVS_TUNNEL_KEY_ATTR_IPV6_DST,
323	&flower->set.ipv6.ipv6_dst);
324	}
325	nl_msg_put_be16(buf, OVS_TUNNEL_KEY_ATTR_TP_DST,
326	flower->set.tp_dst);
327
328	nl_msg_end_nested(buf, tunnel_offset);
329	nl_msg_end_nested(buf, set_offset);
330	}
331
332	if (flower->ifindex_out > 0) {
333	nl_msg_put_u32(buf, OVS_ACTION_ATTR_OUTPUT, odp_to_u32(outport));
334	}
335
336	}
337	nl_msg_end_nested(buf, act_off);
338
339	*actions = ofpbuf_at_assert(buf, act_off, sizeof(struct nlattr));
340
341	if (stats) {
342	memset(stats, 0, sizeof *stats);
343	stats->n_packets = get_32aligned_u64(&flower->stats.n_packets);
344	stats->n_bytes = get_32aligned_u64(&flower->stats.n_bytes);
345	stats->used = flower->lastused;
346	}
18ebd48c PB	347
	348	return 0;
	349	}
	350
	351	bool
8f7620e6 PB	352	netdev_tc_flow_dump_next(struct netdev_flow_dump *dump,
	353	struct match *match,
	354	struct nlattr **actions,
	355	struct dpif_flow_stats *stats,
	356	ovs_u128 *ufid,
	357	struct ofpbuf *rbuffer,
	358	struct ofpbuf *wbuffer)
18ebd48c	359	{
8f7620e6 PB	360	struct ofpbuf nl_flow;
	361
	362	while (nl_dump_next(dump->nl_dump, &nl_flow, rbuffer)) {
	363	struct tc_flower flower;
	364	struct netdev *netdev = dump->netdev;
	365
	366	if (parse_netlink_to_tc_flower(&nl_flow, &flower)) {
	367	continue;
	368	}
	369
	370	if (parse_tc_flower_to_match(&flower, match, actions, stats,
	371	wbuffer)) {
	372	continue;
	373	}
	374
	375	if (flower.act_cookie.len) {
	376	ufid = ((ovs_u128 *) flower.act_cookie.data);
	377	} else if (!find_ufid(flower.prio, flower.handle, netdev, ufid)) {
	378	continue;
	379	}
	380
	381	match->wc.masks.in_port.odp_port = u32_to_odp(UINT32_MAX);
	382	match->flow.in_port.odp_port = dump->port;
	383
	384	return true;
	385	}
	386
18ebd48c PB	387	return false;
	388	}
	389
	390	int
	391	netdev_tc_flow_put(struct netdev *netdev OVS_UNUSED,
	392	struct match *match OVS_UNUSED,
	393	struct nlattr *actions OVS_UNUSED,
	394	size_t actions_len OVS_UNUSED,
	395	const ovs_u128 *ufid OVS_UNUSED,
	396	struct offload_info *info OVS_UNUSED,
	397	struct dpif_flow_stats *stats OVS_UNUSED)
	398	{
	399	return EOPNOTSUPP;
	400	}
	401
	402	int
	403	netdev_tc_flow_get(struct netdev *netdev OVS_UNUSED,
	404	struct match *match OVS_UNUSED,
	405	struct nlattr **actions OVS_UNUSED,
	406	const ovs_u128 *ufid OVS_UNUSED,
	407	struct dpif_flow_stats *stats OVS_UNUSED,
	408	struct ofpbuf *buf OVS_UNUSED)
	409	{
	410	return EOPNOTSUPP;
	411	}
	412
	413	int
	414	netdev_tc_flow_del(struct netdev *netdev OVS_UNUSED,
	415	const ovs_u128 *ufid OVS_UNUSED,
	416	struct dpif_flow_stats *stats OVS_UNUSED)
	417	{
	418	return EOPNOTSUPP;
	419	}
	420
	421	int
	422	netdev_tc_init_flow_api(struct netdev *netdev OVS_UNUSED)
	423	{
	424	return 0;
	425	}