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
vcap_tc_flower_handler_ethaddr_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_ipv4_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_ipv6_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_portnum_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_cvlan_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_vlan_usage(struct vcap_tc_flower_parse_usage * st,enum vcap_key_field vid_key,enum vcap_key_field pcp_key)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_ULL(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
vcap_tc_flower_handler_tcp_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_arp_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
vcap_tc_flower_handler_ip_usage(struct vcap_tc_flower_parse_usage * st)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_ULL(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
