1 // SPDX-License-Identifier: GPL-2.0+
2 /* Microchip VCAP TC
3  *
4  * Copyright (c) 2023 Microchip Technology Inc. and its subsidiaries.
5  */
6 
7 #include <net/flow_offload.h>
8 #include <net/ipv6.h>
9 #include <net/tcp.h>
10 
11 #include "vcap_api_client.h"
12 #include "vcap_tc.h"
13 
14 enum vcap_is2_arp_opcode {
15 	VCAP_IS2_ARP_REQUEST,
16 	VCAP_IS2_ARP_REPLY,
17 	VCAP_IS2_RARP_REQUEST,
18 	VCAP_IS2_RARP_REPLY,
19 };
20 
21 enum vcap_arp_opcode {
22 	VCAP_ARP_OP_RESERVED,
23 	VCAP_ARP_OP_REQUEST,
24 	VCAP_ARP_OP_REPLY,
25 };
26 
27 int vcap_tc_flower_handler_ethaddr_usage(struct vcap_tc_flower_parse_usage *st)
28 {
29 	enum vcap_key_field smac_key = VCAP_KF_L2_SMAC;
30 	enum vcap_key_field dmac_key = VCAP_KF_L2_DMAC;
31 	struct flow_match_eth_addrs match;
32 	struct vcap_u48_key smac, dmac;
33 	int err = 0;
34 
35 	flow_rule_match_eth_addrs(st->frule, &match);
36 
37 	if (!is_zero_ether_addr(match.mask->src)) {
38 		vcap_netbytes_copy(smac.value, match.key->src, ETH_ALEN);
39 		vcap_netbytes_copy(smac.mask, match.mask->src, ETH_ALEN);
40 		err = vcap_rule_add_key_u48(st->vrule, smac_key, &smac);
41 		if (err)
42 			goto out;
43 	}
44 
45 	if (!is_zero_ether_addr(match.mask->dst)) {
46 		vcap_netbytes_copy(dmac.value, match.key->dst, ETH_ALEN);
47 		vcap_netbytes_copy(dmac.mask, match.mask->dst, ETH_ALEN);
48 		err = vcap_rule_add_key_u48(st->vrule, dmac_key, &dmac);
49 		if (err)
50 			goto out;
51 	}
52 
53 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS);
54 
55 	return err;
56 
57 out:
58 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "eth_addr parse error");
59 	return err;
60 }
61 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_ethaddr_usage);
62 
63 int vcap_tc_flower_handler_ipv4_usage(struct vcap_tc_flower_parse_usage *st)
64 {
65 	int err = 0;
66 
67 	if (st->l3_proto == ETH_P_IP) {
68 		struct flow_match_ipv4_addrs mt;
69 
70 		flow_rule_match_ipv4_addrs(st->frule, &mt);
71 		if (mt.mask->src) {
72 			err = vcap_rule_add_key_u32(st->vrule,
73 						    VCAP_KF_L3_IP4_SIP,
74 						    be32_to_cpu(mt.key->src),
75 						    be32_to_cpu(mt.mask->src));
76 			if (err)
77 				goto out;
78 		}
79 		if (mt.mask->dst) {
80 			err = vcap_rule_add_key_u32(st->vrule,
81 						    VCAP_KF_L3_IP4_DIP,
82 						    be32_to_cpu(mt.key->dst),
83 						    be32_to_cpu(mt.mask->dst));
84 			if (err)
85 				goto out;
86 		}
87 	}
88 
89 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS);
90 
91 	return err;
92 
93 out:
94 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ipv4_addr parse error");
95 	return err;
96 }
97 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_ipv4_usage);
98 
99 int vcap_tc_flower_handler_ipv6_usage(struct vcap_tc_flower_parse_usage *st)
100 {
101 	int err = 0;
102 
103 	if (st->l3_proto == ETH_P_IPV6) {
104 		struct flow_match_ipv6_addrs mt;
105 		struct vcap_u128_key sip;
106 		struct vcap_u128_key dip;
107 
108 		flow_rule_match_ipv6_addrs(st->frule, &mt);
109 		/* Check if address masks are non-zero */
110 		if (!ipv6_addr_any(&mt.mask->src)) {
111 			vcap_netbytes_copy(sip.value, mt.key->src.s6_addr, 16);
112 			vcap_netbytes_copy(sip.mask, mt.mask->src.s6_addr, 16);
113 			err = vcap_rule_add_key_u128(st->vrule,
114 						     VCAP_KF_L3_IP6_SIP, &sip);
115 			if (err)
116 				goto out;
117 		}
118 		if (!ipv6_addr_any(&mt.mask->dst)) {
119 			vcap_netbytes_copy(dip.value, mt.key->dst.s6_addr, 16);
120 			vcap_netbytes_copy(dip.mask, mt.mask->dst.s6_addr, 16);
121 			err = vcap_rule_add_key_u128(st->vrule,
122 						     VCAP_KF_L3_IP6_DIP, &dip);
123 			if (err)
124 				goto out;
125 		}
126 	}
127 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS);
128 	return err;
129 out:
130 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ipv6_addr parse error");
131 	return err;
132 }
133 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_ipv6_usage);
134 
135 int vcap_tc_flower_handler_portnum_usage(struct vcap_tc_flower_parse_usage *st)
136 {
137 	struct flow_match_ports mt;
138 	u16 value, mask;
139 	int err = 0;
140 
141 	flow_rule_match_ports(st->frule, &mt);
142 
143 	if (mt.mask->src) {
144 		value = be16_to_cpu(mt.key->src);
145 		mask = be16_to_cpu(mt.mask->src);
146 		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L4_SPORT, value,
147 					    mask);
148 		if (err)
149 			goto out;
150 	}
151 
152 	if (mt.mask->dst) {
153 		value = be16_to_cpu(mt.key->dst);
154 		mask = be16_to_cpu(mt.mask->dst);
155 		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L4_DPORT, value,
156 					    mask);
157 		if (err)
158 			goto out;
159 	}
160 
161 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_PORTS);
162 
163 	return err;
164 
165 out:
166 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "port parse error");
167 	return err;
168 }
169 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_portnum_usage);
170 
171 int vcap_tc_flower_handler_cvlan_usage(struct vcap_tc_flower_parse_usage *st)
172 {
173 	enum vcap_key_field vid_key = VCAP_KF_8021Q_VID0;
174 	enum vcap_key_field pcp_key = VCAP_KF_8021Q_PCP0;
175 	struct flow_match_vlan mt;
176 	u16 tpid;
177 	int err;
178 
179 	flow_rule_match_cvlan(st->frule, &mt);
180 
181 	tpid = be16_to_cpu(mt.key->vlan_tpid);
182 
183 	if (tpid == ETH_P_8021Q) {
184 		vid_key = VCAP_KF_8021Q_VID1;
185 		pcp_key = VCAP_KF_8021Q_PCP1;
186 	}
187 
188 	if (mt.mask->vlan_id) {
189 		err = vcap_rule_add_key_u32(st->vrule, vid_key,
190 					    mt.key->vlan_id,
191 					    mt.mask->vlan_id);
192 		if (err)
193 			goto out;
194 	}
195 
196 	if (mt.mask->vlan_priority) {
197 		err = vcap_rule_add_key_u32(st->vrule, pcp_key,
198 					    mt.key->vlan_priority,
199 					    mt.mask->vlan_priority);
200 		if (err)
201 			goto out;
202 	}
203 
204 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_CVLAN);
205 
206 	return 0;
207 out:
208 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "cvlan parse error");
209 	return err;
210 }
211 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_cvlan_usage);
212 
213 int vcap_tc_flower_handler_vlan_usage(struct vcap_tc_flower_parse_usage *st,
214 				      enum vcap_key_field vid_key,
215 				      enum vcap_key_field pcp_key)
216 {
217 	struct flow_match_vlan mt;
218 	int err;
219 
220 	flow_rule_match_vlan(st->frule, &mt);
221 
222 	if (mt.mask->vlan_id) {
223 		err = vcap_rule_add_key_u32(st->vrule, vid_key,
224 					    mt.key->vlan_id,
225 					    mt.mask->vlan_id);
226 		if (err)
227 			goto out;
228 	}
229 
230 	if (mt.mask->vlan_priority) {
231 		err = vcap_rule_add_key_u32(st->vrule, pcp_key,
232 					    mt.key->vlan_priority,
233 					    mt.mask->vlan_priority);
234 		if (err)
235 			goto out;
236 	}
237 
238 	if (mt.mask->vlan_tpid)
239 		st->tpid = be16_to_cpu(mt.key->vlan_tpid);
240 
241 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_VLAN);
242 
243 	return 0;
244 out:
245 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "vlan parse error");
246 	return err;
247 }
248 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_vlan_usage);
249 
250 int vcap_tc_flower_handler_tcp_usage(struct vcap_tc_flower_parse_usage *st)
251 {
252 	struct flow_match_tcp mt;
253 	u16 tcp_flags_mask;
254 	u16 tcp_flags_key;
255 	enum vcap_bit val;
256 	int err = 0;
257 
258 	flow_rule_match_tcp(st->frule, &mt);
259 	tcp_flags_key = be16_to_cpu(mt.key->flags);
260 	tcp_flags_mask = be16_to_cpu(mt.mask->flags);
261 
262 	if (tcp_flags_mask & TCPHDR_FIN) {
263 		val = VCAP_BIT_0;
264 		if (tcp_flags_key & TCPHDR_FIN)
265 			val = VCAP_BIT_1;
266 		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_FIN, val);
267 		if (err)
268 			goto out;
269 	}
270 
271 	if (tcp_flags_mask & TCPHDR_SYN) {
272 		val = VCAP_BIT_0;
273 		if (tcp_flags_key & TCPHDR_SYN)
274 			val = VCAP_BIT_1;
275 		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_SYN, val);
276 		if (err)
277 			goto out;
278 	}
279 
280 	if (tcp_flags_mask & TCPHDR_RST) {
281 		val = VCAP_BIT_0;
282 		if (tcp_flags_key & TCPHDR_RST)
283 			val = VCAP_BIT_1;
284 		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_RST, val);
285 		if (err)
286 			goto out;
287 	}
288 
289 	if (tcp_flags_mask & TCPHDR_PSH) {
290 		val = VCAP_BIT_0;
291 		if (tcp_flags_key & TCPHDR_PSH)
292 			val = VCAP_BIT_1;
293 		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_PSH, val);
294 		if (err)
295 			goto out;
296 	}
297 
298 	if (tcp_flags_mask & TCPHDR_ACK) {
299 		val = VCAP_BIT_0;
300 		if (tcp_flags_key & TCPHDR_ACK)
301 			val = VCAP_BIT_1;
302 		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_ACK, val);
303 		if (err)
304 			goto out;
305 	}
306 
307 	if (tcp_flags_mask & TCPHDR_URG) {
308 		val = VCAP_BIT_0;
309 		if (tcp_flags_key & TCPHDR_URG)
310 			val = VCAP_BIT_1;
311 		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_URG, val);
312 		if (err)
313 			goto out;
314 	}
315 
316 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_TCP);
317 
318 	return err;
319 
320 out:
321 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "tcp_flags parse error");
322 	return err;
323 }
324 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_tcp_usage);
325 
326 int vcap_tc_flower_handler_arp_usage(struct vcap_tc_flower_parse_usage *st)
327 {
328 	struct flow_match_arp mt;
329 	u16 value, mask;
330 	u32 ipval, ipmsk;
331 	int err;
332 
333 	flow_rule_match_arp(st->frule, &mt);
334 
335 	if (mt.mask->op) {
336 		mask = 0x3;
337 		if (st->l3_proto == ETH_P_ARP) {
338 			value = mt.key->op == VCAP_ARP_OP_REQUEST ?
339 					VCAP_IS2_ARP_REQUEST :
340 					VCAP_IS2_ARP_REPLY;
341 		} else { /* RARP */
342 			value = mt.key->op == VCAP_ARP_OP_REQUEST ?
343 					VCAP_IS2_RARP_REQUEST :
344 					VCAP_IS2_RARP_REPLY;
345 		}
346 		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_ARP_OPCODE,
347 					    value, mask);
348 		if (err)
349 			goto out;
350 	}
351 
352 	/* The IS2 ARP keyset does not support ARP hardware addresses */
353 	if (!is_zero_ether_addr(mt.mask->sha) ||
354 	    !is_zero_ether_addr(mt.mask->tha)) {
355 		err = -EINVAL;
356 		goto out;
357 	}
358 
359 	if (mt.mask->sip) {
360 		ipval = be32_to_cpu((__force __be32)mt.key->sip);
361 		ipmsk = be32_to_cpu((__force __be32)mt.mask->sip);
362 
363 		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L3_IP4_SIP,
364 					    ipval, ipmsk);
365 		if (err)
366 			goto out;
367 	}
368 
369 	if (mt.mask->tip) {
370 		ipval = be32_to_cpu((__force __be32)mt.key->tip);
371 		ipmsk = be32_to_cpu((__force __be32)mt.mask->tip);
372 
373 		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L3_IP4_DIP,
374 					    ipval, ipmsk);
375 		if (err)
376 			goto out;
377 	}
378 
379 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_ARP);
380 
381 	return 0;
382 
383 out:
384 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "arp parse error");
385 	return err;
386 }
387 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_arp_usage);
388 
389 int vcap_tc_flower_handler_ip_usage(struct vcap_tc_flower_parse_usage *st)
390 {
391 	struct flow_match_ip mt;
392 	int err = 0;
393 
394 	flow_rule_match_ip(st->frule, &mt);
395 
396 	if (mt.mask->tos) {
397 		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L3_TOS,
398 					    mt.key->tos,
399 					    mt.mask->tos);
400 		if (err)
401 			goto out;
402 	}
403 
404 	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_IP);
405 
406 	return err;
407 
408 out:
409 	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ip_tos parse error");
410 	return err;
411 }
412 EXPORT_SYMBOL_GPL(vcap_tc_flower_handler_ip_usage);
413