tc_tun_geneve.c

  1// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
  2/* Copyright (c) 2018 Mellanox Technologies. */
  3
  4#include <net/geneve.h>
  5#include "lib/geneve.h"
  6#include "en/tc_tun.h"
  7
  8#define MLX5E_GENEVE_VER 0
  9
 10static bool mlx5e_tc_tun_can_offload_geneve(struct mlx5e_priv *priv)
 11{
 12	return !!(MLX5_CAP_GEN(priv->mdev, flex_parser_protocols) & MLX5_FLEX_PROTO_GENEVE);
 13}
 14
 15static int mlx5e_tc_tun_calc_hlen_geneve(struct mlx5e_encap_entry *e)
 16{
 17	return sizeof(struct udphdr) +
 18	       sizeof(struct genevehdr) +
 19	       e->tun_info->options_len;
 20}
 21
 22static int mlx5e_tc_tun_check_udp_dport_geneve(struct mlx5e_priv *priv,
 23					       struct flow_cls_offload *f)
 24{
 25	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
 26	struct netlink_ext_ack *extack = f->common.extack;
 27	struct flow_match_ports enc_ports;
 28
 29	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS))
 30		return -EOPNOTSUPP;
 31
 32	flow_rule_match_enc_ports(rule, &enc_ports);
 33
 34	/* Currently we support only default GENEVE
 35	 * port, so udp dst port must match.
 36	 */
 37	if (be16_to_cpu(enc_ports.key->dst) != GENEVE_UDP_PORT) {
 38		NL_SET_ERR_MSG_MOD(extack,
 39				   "Matched UDP dst port is not registered as a GENEVE port");
 40		netdev_warn(priv->netdev,
 41			    "UDP port %d is not registered as a GENEVE port\n",
 42			    be16_to_cpu(enc_ports.key->dst));
 43		return -EOPNOTSUPP;
 44	}
 45
 46	return 0;
 47}
 48
 49static int mlx5e_tc_tun_parse_udp_ports_geneve(struct mlx5e_priv *priv,
 50					       struct mlx5_flow_spec *spec,
 51					       struct flow_cls_offload *f,
 52					       void *headers_c,
 53					       void *headers_v)
 54{
 55	int err;
 56
 57	err = mlx5e_tc_tun_parse_udp_ports(priv, spec, f, headers_c, headers_v);
 58	if (err)
 59		return err;
 60
 61	return mlx5e_tc_tun_check_udp_dport_geneve(priv, f);
 62}
 63
 64static int mlx5e_tc_tun_init_encap_attr_geneve(struct net_device *tunnel_dev,
 65					       struct mlx5e_priv *priv,
 66					       struct mlx5e_encap_entry *e,
 67					       struct netlink_ext_ack *extack)
 68{
 69	e->tunnel = &geneve_tunnel;
 70
 71	/* Reformat type for GENEVE encap is similar to VXLAN:
 72	 * in both cases the HW adds in the same place a
 73	 * defined encapsulation header that the SW provides.
 74	 */
 75	e->reformat_type = MLX5_REFORMAT_TYPE_L2_TO_VXLAN;
 76	return 0;
 77}
 78
 79static void mlx5e_tunnel_id_to_vni(__be64 tun_id, __u8 *vni)
 80{
 81#ifdef __BIG_ENDIAN
 82	vni[0] = (__force __u8)(tun_id >> 16);
 83	vni[1] = (__force __u8)(tun_id >> 8);
 84	vni[2] = (__force __u8)tun_id;
 85#else
 86	vni[0] = (__force __u8)((__force u64)tun_id >> 40);
 87	vni[1] = (__force __u8)((__force u64)tun_id >> 48);
 88	vni[2] = (__force __u8)((__force u64)tun_id >> 56);
 89#endif
 90}
 91
 92static int mlx5e_gen_ip_tunnel_header_geneve(char buf[],
 93					     __u8 *ip_proto,
 94					     struct mlx5e_encap_entry *e)
 95{
 96	const struct ip_tunnel_info *tun_info = e->tun_info;
 97	struct udphdr *udp = (struct udphdr *)(buf);
 98	struct genevehdr *geneveh;
 99
100	geneveh = (struct genevehdr *)((char *)udp + sizeof(struct udphdr));
101
102	*ip_proto = IPPROTO_UDP;
103
104	udp->dest = tun_info->key.tp_dst;
105
106	memset(geneveh, 0, sizeof(*geneveh));
107	geneveh->ver = MLX5E_GENEVE_VER;
108	geneveh->opt_len = tun_info->options_len / 4;
109	geneveh->oam = test_bit(IP_TUNNEL_OAM_BIT, tun_info->key.tun_flags);
110	geneveh->critical = test_bit(IP_TUNNEL_CRIT_OPT_BIT,
111				     tun_info->key.tun_flags);
112	mlx5e_tunnel_id_to_vni(tun_info->key.tun_id, geneveh->vni);
113	geneveh->proto_type = htons(ETH_P_TEB);
114
115	if (test_bit(IP_TUNNEL_GENEVE_OPT_BIT, tun_info->key.tun_flags)) {
116		if (!geneveh->opt_len)
117			return -EOPNOTSUPP;
118		ip_tunnel_info_opts_get(geneveh->options, tun_info);
119	}
120
121	return 0;
122}
123
124static int mlx5e_tc_tun_parse_geneve_vni(struct mlx5e_priv *priv,
125					 struct mlx5_flow_spec *spec,
126					 struct flow_cls_offload *f)
127{
128	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
129	struct netlink_ext_ack *extack = f->common.extack;
130	struct flow_match_enc_keyid enc_keyid;
131	void *misc_c, *misc_v;
132
133	misc_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
134	misc_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
135
136	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID))
137		return 0;
138
139	flow_rule_match_enc_keyid(rule, &enc_keyid);
140
141	if (!enc_keyid.mask->keyid)
142		return 0;
143
144	if (!MLX5_CAP_ESW_FLOWTABLE_FDB(priv->mdev, ft_field_support.outer_geneve_vni)) {
145		NL_SET_ERR_MSG_MOD(extack, "Matching on GENEVE VNI is not supported");
146		netdev_warn(priv->netdev, "Matching on GENEVE VNI is not supported\n");
147		return -EOPNOTSUPP;
148	}
149
150	MLX5_SET(fte_match_set_misc, misc_c, geneve_vni, be32_to_cpu(enc_keyid.mask->keyid));
151	MLX5_SET(fte_match_set_misc, misc_v, geneve_vni, be32_to_cpu(enc_keyid.key->keyid));
152
153	return 0;
154}
155
156static int mlx5e_tc_tun_parse_geneve_options(struct mlx5e_priv *priv,
157					     struct mlx5_flow_spec *spec,
158					     struct flow_cls_offload *f)
159{
160	u8 max_tlv_option_data_len = MLX5_CAP_GEN(priv->mdev, max_geneve_tlv_option_data_len);
161	u8 max_tlv_options = MLX5_CAP_GEN(priv->mdev, max_geneve_tlv_options);
162	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
163	struct netlink_ext_ack *extack = f->common.extack;
164	void *misc_c, *misc_v, *misc_3_c, *misc_3_v;
165	struct geneve_opt *option_key, *option_mask;
166	__be32 opt_data_key = 0, opt_data_mask = 0;
167	struct flow_match_enc_opts enc_opts;
168	int res = 0;
169
170	misc_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
171	misc_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters);
172	misc_3_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters_3);
173	misc_3_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, misc_parameters_3);
174
175	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_OPTS))
176		return 0;
177
178	flow_rule_match_enc_opts(rule, &enc_opts);
179
180	if (memchr_inv(&enc_opts.mask->data, 0, sizeof(enc_opts.mask->data)) &&
181	    !MLX5_CAP_ESW_FLOWTABLE_FDB(priv->mdev,
182					ft_field_support.geneve_tlv_option_0_data)) {
183		NL_SET_ERR_MSG_MOD(extack,
184				   "Matching on GENEVE options is not supported");
185		netdev_warn(priv->netdev,
186			    "Matching on GENEVE options is not supported\n");
187		return -EOPNOTSUPP;
188	}
189
190	/* make sure that we're talking about GENEVE options */
191
192	if (enc_opts.key->dst_opt_type != IP_TUNNEL_GENEVE_OPT_BIT) {
193		NL_SET_ERR_MSG_MOD(extack,
194				   "Matching on GENEVE options: option type is not GENEVE");
195		netdev_warn(priv->netdev,
196			    "Matching on GENEVE options: option type is not GENEVE\n");
197		return -EOPNOTSUPP;
198	}
199
200	if (enc_opts.mask->len &&
201	    !MLX5_CAP_ESW_FLOWTABLE_FDB(priv->mdev,
202					ft_field_support.outer_geneve_opt_len)) {
203		NL_SET_ERR_MSG_MOD(extack, "Matching on GENEVE options len is not supported");
204		netdev_warn(priv->netdev,
205			    "Matching on GENEVE options len is not supported\n");
206		return -EOPNOTSUPP;
207	}
208
209	/* max_geneve_tlv_option_data_len comes in multiples of 4 bytes, and it
210	 * doesn't include the TLV option header. 'geneve_opt_len' is a total
211	 * len of all the options, including the headers, also multiples of 4
212	 * bytes. Len that comes from the dissector is in bytes.
213	 */
214
215	if ((enc_opts.key->len / 4) > ((max_tlv_option_data_len + 1) * max_tlv_options)) {
216		NL_SET_ERR_MSG_MOD(extack,
217				   "Matching on GENEVE options: unsupported options len");
218		netdev_warn(priv->netdev,
219			    "Matching on GENEVE options: unsupported options len (len=%d)\n",
220			    enc_opts.key->len);
221		return -EOPNOTSUPP;
222	}
223
224	MLX5_SET(fte_match_set_misc, misc_c, geneve_opt_len, enc_opts.mask->len / 4);
225	MLX5_SET(fte_match_set_misc, misc_v, geneve_opt_len, enc_opts.key->len / 4);
226
227	/* we support matching on one option only, so just get it */
228	option_key = (struct geneve_opt *)&enc_opts.key->data[0];
229	option_mask = (struct geneve_opt *)&enc_opts.mask->data[0];
230
231	if (option_mask->opt_class == 0 && option_mask->type == 0 &&
232	    !memchr_inv(option_mask->opt_data, 0, option_mask->length * 4))
233		return 0;
234
235	if (option_key->length > max_tlv_option_data_len) {
236		NL_SET_ERR_MSG_MOD(extack,
237				   "Matching on GENEVE options: unsupported option len");
238		netdev_warn(priv->netdev,
239			    "Matching on GENEVE options: unsupported option len (key=%d, mask=%d)\n",
240			    option_key->length, option_mask->length);
241		return -EOPNOTSUPP;
242	}
243
244	/* data can't be all 0 - fail to offload such rule */
245	if (!memchr_inv(option_key->opt_data, 0, option_key->length * 4)) {
246		NL_SET_ERR_MSG_MOD(extack,
247				   "Matching on GENEVE options: can't match on 0 data field");
248		netdev_warn(priv->netdev,
249			    "Matching on GENEVE options: can't match on 0 data field\n");
250		return -EOPNOTSUPP;
251	}
252
253	/* add new GENEVE TLV options object */
254	res = mlx5_geneve_tlv_option_add(priv->mdev->geneve, option_key);
255	if (res) {
256		NL_SET_ERR_MSG_MOD(extack,
257				   "Matching on GENEVE options: failed creating TLV opt object");
258		netdev_warn(priv->netdev,
259			    "Matching on GENEVE options: failed creating TLV opt object (class:type:len = 0x%x:0x%x:%d)\n",
260			    be16_to_cpu(option_key->opt_class),
261			    option_key->type, option_key->length);
262		return res;
263	}
264
265	/* In general, after creating the object, need to query it
266	 * in order to check which option data to set in misc3.
267	 * But we support only geneve_tlv_option_0_data, so no
268	 * point querying at this stage.
269	 */
270
271	memcpy(&opt_data_key, option_key->opt_data, option_key->length * 4);
272	memcpy(&opt_data_mask, option_mask->opt_data, option_mask->length * 4);
273	MLX5_SET(fte_match_set_misc3, misc_3_v,
274		 geneve_tlv_option_0_data, be32_to_cpu(opt_data_key));
275	MLX5_SET(fte_match_set_misc3, misc_3_c,
276		 geneve_tlv_option_0_data, be32_to_cpu(opt_data_mask));
277	if (MLX5_CAP_ESW_FLOWTABLE_FDB(priv->mdev,
278				       ft_field_support.geneve_tlv_option_0_exist)) {
279		MLX5_SET_TO_ONES(fte_match_set_misc, misc_c, geneve_tlv_option_0_exist);
280		MLX5_SET_TO_ONES(fte_match_set_misc, misc_v, geneve_tlv_option_0_exist);
281	}
282
283	spec->match_criteria_enable |= MLX5_MATCH_MISC_PARAMETERS_3;
284
285	return 0;
286}
287
288static int mlx5e_tc_tun_parse_geneve_params(struct mlx5e_priv *priv,
289					    struct mlx5_flow_spec *spec,
290					    struct flow_cls_offload *f)
291{
292	void *misc_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, misc_parameters);
293	void *misc_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,  misc_parameters);
294	struct netlink_ext_ack *extack = f->common.extack;
295
296	/* match on OAM - packets with OAM bit on should NOT be offloaded */
297
298	if (!MLX5_CAP_ESW_FLOWTABLE_FDB(priv->mdev, ft_field_support.outer_geneve_oam)) {
299		NL_SET_ERR_MSG_MOD(extack, "Matching on GENEVE OAM is not supported");
300		netdev_warn(priv->netdev, "Matching on GENEVE OAM is not supported\n");
301		return -EOPNOTSUPP;
302	}
303	MLX5_SET_TO_ONES(fte_match_set_misc, misc_c, geneve_oam);
304	MLX5_SET(fte_match_set_misc, misc_v, geneve_oam, 0);
305
306	/* Match on GENEVE protocol. We support only Transparent Eth Bridge. */
307
308	if (MLX5_CAP_ESW_FLOWTABLE_FDB(priv->mdev,
309				       ft_field_support.outer_geneve_protocol_type)) {
310		MLX5_SET_TO_ONES(fte_match_set_misc, misc_c, geneve_protocol_type);
311		MLX5_SET(fte_match_set_misc, misc_v, geneve_protocol_type, ETH_P_TEB);
312	}
313
314	spec->match_criteria_enable |= MLX5_MATCH_MISC_PARAMETERS;
315
316	return 0;
317}
318
319static int mlx5e_tc_tun_parse_geneve(struct mlx5e_priv *priv,
320				     struct mlx5_flow_spec *spec,
321				     struct flow_cls_offload *f,
322				     void *headers_c,
323				     void *headers_v)
324{
325	int err;
326
327	err = mlx5e_tc_tun_parse_geneve_params(priv, spec, f);
328	if (err)
329		return err;
330
331	err = mlx5e_tc_tun_parse_geneve_vni(priv, spec, f);
332	if (err)
333		return err;
334
335	return mlx5e_tc_tun_parse_geneve_options(priv, spec, f);
336}
337
338static bool mlx5e_tc_tun_encap_info_equal_geneve(struct mlx5e_encap_key *a,
339						 struct mlx5e_encap_key *b)
340{
341	return mlx5e_tc_tun_encap_info_equal_options(a, b,
342						     IP_TUNNEL_GENEVE_OPT_BIT);
343}
344
345struct mlx5e_tc_tunnel geneve_tunnel = {
346	.tunnel_type          = MLX5E_TC_TUNNEL_TYPE_GENEVE,
347	.match_level          = MLX5_MATCH_L4,
348	.can_offload          = mlx5e_tc_tun_can_offload_geneve,
349	.calc_hlen            = mlx5e_tc_tun_calc_hlen_geneve,
350	.init_encap_attr      = mlx5e_tc_tun_init_encap_attr_geneve,
351	.generate_ip_tun_hdr  = mlx5e_gen_ip_tunnel_header_geneve,
352	.parse_udp_ports      = mlx5e_tc_tun_parse_udp_ports_geneve,
353	.parse_tunnel         = mlx5e_tc_tun_parse_geneve,
354	.encap_info_equal     = mlx5e_tc_tun_encap_info_equal_geneve,
355};