2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c
3 * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2017 Jiri Pirko <jiri@mellanox.com>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the names of the copyright holders nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
18 * Alternatively, this software may be distributed under the terms of the
19 * GNU General Public License ("GPL") version 2 as published by the Free
20 * Software Foundation.
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
35 #include <linux/kernel.h>
36 #include <linux/errno.h>
37 #include <linux/netdevice.h>
38 #include <net/flow_dissector.h>
39 #include <net/pkt_cls.h>
40 #include <net/tc_act/tc_gact.h>
41 #include <net/tc_act/tc_mirred.h>
44 #include "core_acl_flex_keys.h"
46 static int mlxsw_sp_flower_parse_actions(struct mlxsw_sp
*mlxsw_sp
,
47 struct net_device
*dev
,
48 struct mlxsw_sp_acl_rule_info
*rulei
,
49 struct tcf_exts
*exts
)
51 const struct tc_action
*a
;
55 if (tc_no_actions(exts
))
58 tcf_exts_to_list(exts
, &actions
);
59 list_for_each_entry(a
, &actions
, list
) {
60 if (is_tcf_gact_shot(a
)) {
61 err
= mlxsw_sp_acl_rulei_act_drop(rulei
);
64 } else if (is_tcf_mirred_egress_redirect(a
)) {
65 int ifindex
= tcf_mirred_ifindex(a
);
66 struct net_device
*out_dev
;
68 out_dev
= __dev_get_by_index(dev_net(dev
), ifindex
);
72 err
= mlxsw_sp_acl_rulei_act_fwd(mlxsw_sp
, rulei
,
77 dev_err(mlxsw_sp
->bus_info
->dev
, "Unsupported action\n");
84 static void mlxsw_sp_flower_parse_ipv4(struct mlxsw_sp_acl_rule_info
*rulei
,
85 struct tc_cls_flower_offload
*f
)
87 struct flow_dissector_key_ipv4_addrs
*key
=
88 skb_flow_dissector_target(f
->dissector
,
89 FLOW_DISSECTOR_KEY_IPV4_ADDRS
,
91 struct flow_dissector_key_ipv4_addrs
*mask
=
92 skb_flow_dissector_target(f
->dissector
,
93 FLOW_DISSECTOR_KEY_IPV4_ADDRS
,
96 mlxsw_sp_acl_rulei_keymask_u32(rulei
, MLXSW_AFK_ELEMENT_SRC_IP4
,
97 ntohl(key
->src
), ntohl(mask
->src
));
98 mlxsw_sp_acl_rulei_keymask_u32(rulei
, MLXSW_AFK_ELEMENT_DST_IP4
,
99 ntohl(key
->dst
), ntohl(mask
->dst
));
102 static void mlxsw_sp_flower_parse_ipv6(struct mlxsw_sp_acl_rule_info
*rulei
,
103 struct tc_cls_flower_offload
*f
)
105 struct flow_dissector_key_ipv6_addrs
*key
=
106 skb_flow_dissector_target(f
->dissector
,
107 FLOW_DISSECTOR_KEY_IPV6_ADDRS
,
109 struct flow_dissector_key_ipv6_addrs
*mask
=
110 skb_flow_dissector_target(f
->dissector
,
111 FLOW_DISSECTOR_KEY_IPV6_ADDRS
,
113 size_t addr_half_size
= sizeof(key
->src
) / 2;
115 mlxsw_sp_acl_rulei_keymask_buf(rulei
, MLXSW_AFK_ELEMENT_SRC_IP6_HI
,
116 &key
->src
.s6_addr
[0],
117 &mask
->src
.s6_addr
[0],
119 mlxsw_sp_acl_rulei_keymask_buf(rulei
, MLXSW_AFK_ELEMENT_SRC_IP6_LO
,
120 &key
->src
.s6_addr
[addr_half_size
],
121 &mask
->src
.s6_addr
[addr_half_size
],
123 mlxsw_sp_acl_rulei_keymask_buf(rulei
, MLXSW_AFK_ELEMENT_DST_IP6_HI
,
124 &key
->dst
.s6_addr
[0],
125 &mask
->dst
.s6_addr
[0],
127 mlxsw_sp_acl_rulei_keymask_buf(rulei
, MLXSW_AFK_ELEMENT_DST_IP6_LO
,
128 &key
->dst
.s6_addr
[addr_half_size
],
129 &mask
->dst
.s6_addr
[addr_half_size
],
133 static int mlxsw_sp_flower_parse_ports(struct mlxsw_sp
*mlxsw_sp
,
134 struct mlxsw_sp_acl_rule_info
*rulei
,
135 struct tc_cls_flower_offload
*f
,
138 struct flow_dissector_key_ports
*key
, *mask
;
140 if (!dissector_uses_key(f
->dissector
, FLOW_DISSECTOR_KEY_PORTS
))
143 if (ip_proto
!= IPPROTO_TCP
&& ip_proto
!= IPPROTO_UDP
) {
144 dev_err(mlxsw_sp
->bus_info
->dev
, "Only UDP and TCP keys are supported\n");
148 key
= skb_flow_dissector_target(f
->dissector
,
149 FLOW_DISSECTOR_KEY_PORTS
,
151 mask
= skb_flow_dissector_target(f
->dissector
,
152 FLOW_DISSECTOR_KEY_PORTS
,
154 mlxsw_sp_acl_rulei_keymask_u32(rulei
, MLXSW_AFK_ELEMENT_DST_L4_PORT
,
155 ntohs(key
->dst
), ntohs(mask
->dst
));
156 mlxsw_sp_acl_rulei_keymask_u32(rulei
, MLXSW_AFK_ELEMENT_SRC_L4_PORT
,
157 ntohs(key
->src
), ntohs(mask
->src
));
161 static int mlxsw_sp_flower_parse(struct mlxsw_sp
*mlxsw_sp
,
162 struct net_device
*dev
,
163 struct mlxsw_sp_acl_rule_info
*rulei
,
164 struct tc_cls_flower_offload
*f
)
170 if (f
->dissector
->used_keys
&
171 ~(BIT(FLOW_DISSECTOR_KEY_CONTROL
) |
172 BIT(FLOW_DISSECTOR_KEY_BASIC
) |
173 BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS
) |
174 BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS
) |
175 BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS
) |
176 BIT(FLOW_DISSECTOR_KEY_PORTS
))) {
177 dev_err(mlxsw_sp
->bus_info
->dev
, "Unsupported key\n");
181 mlxsw_sp_acl_rulei_priority(rulei
, f
->prio
);
183 if (dissector_uses_key(f
->dissector
, FLOW_DISSECTOR_KEY_CONTROL
)) {
184 struct flow_dissector_key_control
*key
=
185 skb_flow_dissector_target(f
->dissector
,
186 FLOW_DISSECTOR_KEY_CONTROL
,
188 addr_type
= key
->addr_type
;
191 if (dissector_uses_key(f
->dissector
, FLOW_DISSECTOR_KEY_BASIC
)) {
192 struct flow_dissector_key_basic
*key
=
193 skb_flow_dissector_target(f
->dissector
,
194 FLOW_DISSECTOR_KEY_BASIC
,
196 struct flow_dissector_key_basic
*mask
=
197 skb_flow_dissector_target(f
->dissector
,
198 FLOW_DISSECTOR_KEY_BASIC
,
200 u16 n_proto_key
= ntohs(key
->n_proto
);
201 u16 n_proto_mask
= ntohs(mask
->n_proto
);
203 if (n_proto_key
== ETH_P_ALL
) {
207 mlxsw_sp_acl_rulei_keymask_u32(rulei
,
208 MLXSW_AFK_ELEMENT_ETHERTYPE
,
209 n_proto_key
, n_proto_mask
);
211 ip_proto
= key
->ip_proto
;
212 mlxsw_sp_acl_rulei_keymask_u32(rulei
,
213 MLXSW_AFK_ELEMENT_IP_PROTO
,
214 key
->ip_proto
, mask
->ip_proto
);
217 if (dissector_uses_key(f
->dissector
, FLOW_DISSECTOR_KEY_ETH_ADDRS
)) {
218 struct flow_dissector_key_eth_addrs
*key
=
219 skb_flow_dissector_target(f
->dissector
,
220 FLOW_DISSECTOR_KEY_ETH_ADDRS
,
222 struct flow_dissector_key_eth_addrs
*mask
=
223 skb_flow_dissector_target(f
->dissector
,
224 FLOW_DISSECTOR_KEY_ETH_ADDRS
,
227 mlxsw_sp_acl_rulei_keymask_buf(rulei
,
228 MLXSW_AFK_ELEMENT_DMAC
,
231 mlxsw_sp_acl_rulei_keymask_buf(rulei
,
232 MLXSW_AFK_ELEMENT_SMAC
,
237 if (addr_type
== FLOW_DISSECTOR_KEY_IPV4_ADDRS
)
238 mlxsw_sp_flower_parse_ipv4(rulei
, f
);
240 if (addr_type
== FLOW_DISSECTOR_KEY_IPV6_ADDRS
)
241 mlxsw_sp_flower_parse_ipv6(rulei
, f
);
243 err
= mlxsw_sp_flower_parse_ports(mlxsw_sp
, rulei
, f
, ip_proto
);
247 return mlxsw_sp_flower_parse_actions(mlxsw_sp
, dev
, rulei
, f
->exts
);
250 int mlxsw_sp_flower_replace(struct mlxsw_sp_port
*mlxsw_sp_port
, bool ingress
,
251 __be16 protocol
, struct tc_cls_flower_offload
*f
)
253 struct mlxsw_sp
*mlxsw_sp
= mlxsw_sp_port
->mlxsw_sp
;
254 struct net_device
*dev
= mlxsw_sp_port
->dev
;
255 struct mlxsw_sp_acl_rule_info
*rulei
;
256 struct mlxsw_sp_acl_ruleset
*ruleset
;
257 struct mlxsw_sp_acl_rule
*rule
;
260 ruleset
= mlxsw_sp_acl_ruleset_get(mlxsw_sp
, dev
, ingress
,
261 MLXSW_SP_ACL_PROFILE_FLOWER
);
263 return PTR_ERR(ruleset
);
265 rule
= mlxsw_sp_acl_rule_create(mlxsw_sp
, ruleset
, f
->cookie
);
268 goto err_rule_create
;
271 rulei
= mlxsw_sp_acl_rule_rulei(rule
);
272 err
= mlxsw_sp_flower_parse(mlxsw_sp
, dev
, rulei
, f
);
274 goto err_flower_parse
;
276 err
= mlxsw_sp_acl_rulei_commit(rulei
);
278 goto err_rulei_commit
;
280 err
= mlxsw_sp_acl_rule_add(mlxsw_sp
, rule
);
284 mlxsw_sp_acl_ruleset_put(mlxsw_sp
, ruleset
);
290 mlxsw_sp_acl_rule_destroy(mlxsw_sp
, rule
);
292 mlxsw_sp_acl_ruleset_put(mlxsw_sp
, ruleset
);
296 void mlxsw_sp_flower_destroy(struct mlxsw_sp_port
*mlxsw_sp_port
, bool ingress
,
297 struct tc_cls_flower_offload
*f
)
299 struct mlxsw_sp
*mlxsw_sp
= mlxsw_sp_port
->mlxsw_sp
;
300 struct mlxsw_sp_acl_ruleset
*ruleset
;
301 struct mlxsw_sp_acl_rule
*rule
;
303 ruleset
= mlxsw_sp_acl_ruleset_get(mlxsw_sp
, mlxsw_sp_port
->dev
,
305 MLXSW_SP_ACL_PROFILE_FLOWER
);
306 if (WARN_ON(IS_ERR(ruleset
)))
309 rule
= mlxsw_sp_acl_rule_lookup(mlxsw_sp
, ruleset
, f
->cookie
);
310 if (!WARN_ON(!rule
)) {
311 mlxsw_sp_acl_rule_del(mlxsw_sp
, rule
);
312 mlxsw_sp_acl_rule_destroy(mlxsw_sp
, rule
);
315 mlxsw_sp_acl_ruleset_put(mlxsw_sp
, ruleset
);