Commit | Line | Data |
---|---|---|
0e7623bd | 1 | // SPDX-License-Identifier: GPL-2.0 |
f266a683 | 2 | /* Copyright 2011-2014 Autronica Fire and Security AS |
f266a683 AB |
3 | * |
4 | * Author(s): | |
5 | * 2011-2014 Arvid Brodin, arvid.brodin@alten.se | |
8f4c0e01 MK |
6 | * |
7 | * Frame router for HSR and PRP. | |
f266a683 AB |
8 | */ |
9 | ||
10 | #include "hsr_forward.h" | |
11 | #include <linux/types.h> | |
12 | #include <linux/skbuff.h> | |
13 | #include <linux/etherdevice.h> | |
14 | #include <linux/if_vlan.h> | |
15 | #include "hsr_main.h" | |
16 | #include "hsr_framereg.h" | |
17 | ||
f266a683 AB |
18 | struct hsr_node; |
19 | ||
f266a683 AB |
20 | /* The uses I can see for these HSR supervision frames are: |
21 | * 1) Use the frames that are sent after node initialization ("HSR_TLV.Type = | |
22 | * 22") to reset any sequence_nr counters belonging to that node. Useful if | |
23 | * the other node's counter has been reset for some reason. | |
24 | * -- | |
25 | * Or not - resetting the counter and bridging the frame would create a | |
26 | * loop, unfortunately. | |
27 | * | |
28 | * 2) Use the LifeCheck frames to detect ring breaks. I.e. if no LifeCheck | |
29 | * frame is received from a particular node, we know something is wrong. | |
30 | * We just register these (as with normal frames) and throw them away. | |
31 | * | |
32 | * 3) Allow different MAC addresses for the two slave interfaces, using the | |
33 | * MacAddressA field. | |
34 | */ | |
35 | static bool is_supervision_frame(struct hsr_priv *hsr, struct sk_buff *skb) | |
36 | { | |
b1b4aa91 MK |
37 | struct ethhdr *eth_hdr; |
38 | struct hsr_sup_tag *hsr_sup_tag; | |
39 | struct hsrv1_ethhdr_sp *hsr_V1_hdr; | |
eafaa88b AO |
40 | struct hsr_sup_tlv *hsr_sup_tlv; |
41 | u16 total_length = 0; | |
f266a683 AB |
42 | |
43 | WARN_ON_ONCE(!skb_mac_header_was_set(skb)); | |
b1b4aa91 | 44 | eth_hdr = (struct ethhdr *)skb_mac_header(skb); |
f266a683 | 45 | |
ee1c2797 | 46 | /* Correct addr? */ |
b1b4aa91 | 47 | if (!ether_addr_equal(eth_hdr->h_dest, |
f266a683 AB |
48 | hsr->sup_multicast_addr)) |
49 | return false; | |
50 | ||
ee1c2797 | 51 | /* Correct ether type?. */ |
b1b4aa91 MK |
52 | if (!(eth_hdr->h_proto == htons(ETH_P_PRP) || |
53 | eth_hdr->h_proto == htons(ETH_P_HSR))) | |
f266a683 | 54 | return false; |
ee1c2797 PH |
55 | |
56 | /* Get the supervision header from correct location. */ | |
b1b4aa91 | 57 | if (eth_hdr->h_proto == htons(ETH_P_HSR)) { /* Okay HSRv1. */ |
eafaa88b AO |
58 | total_length = sizeof(struct hsrv1_ethhdr_sp); |
59 | if (!pskb_may_pull(skb, total_length)) | |
60 | return false; | |
61 | ||
b1b4aa91 MK |
62 | hsr_V1_hdr = (struct hsrv1_ethhdr_sp *)skb_mac_header(skb); |
63 | if (hsr_V1_hdr->hsr.encap_proto != htons(ETH_P_PRP)) | |
ee1c2797 PH |
64 | return false; |
65 | ||
b1b4aa91 | 66 | hsr_sup_tag = &hsr_V1_hdr->hsr_sup; |
ee1c2797 | 67 | } else { |
eafaa88b AO |
68 | total_length = sizeof(struct hsrv0_ethhdr_sp); |
69 | if (!pskb_may_pull(skb, total_length)) | |
70 | return false; | |
71 | ||
b1b4aa91 | 72 | hsr_sup_tag = |
5fa96778 | 73 | &((struct hsrv0_ethhdr_sp *)skb_mac_header(skb))->hsr_sup; |
ee1c2797 PH |
74 | } |
75 | ||
eafaa88b AO |
76 | if (hsr_sup_tag->tlv.HSR_TLV_type != HSR_TLV_ANNOUNCE && |
77 | hsr_sup_tag->tlv.HSR_TLV_type != HSR_TLV_LIFE_CHECK && | |
78 | hsr_sup_tag->tlv.HSR_TLV_type != PRP_TLV_LIFE_CHECK_DD && | |
79 | hsr_sup_tag->tlv.HSR_TLV_type != PRP_TLV_LIFE_CHECK_DA) | |
80 | return false; | |
81 | if (hsr_sup_tag->tlv.HSR_TLV_length != 12 && | |
82 | hsr_sup_tag->tlv.HSR_TLV_length != sizeof(struct hsr_sup_payload)) | |
83 | return false; | |
84 | ||
85 | /* Get next tlv */ | |
51dd4ee0 | 86 | total_length += hsr_sup_tag->tlv.HSR_TLV_length; |
eafaa88b | 87 | if (!pskb_may_pull(skb, total_length)) |
f266a683 | 88 | return false; |
eafaa88b AO |
89 | skb_pull(skb, total_length); |
90 | hsr_sup_tlv = (struct hsr_sup_tlv *)skb->data; | |
91 | skb_push(skb, total_length); | |
92 | ||
93 | /* if this is a redbox supervision frame we need to verify | |
94 | * that more data is available | |
95 | */ | |
96 | if (hsr_sup_tlv->HSR_TLV_type == PRP_TLV_REDBOX_MAC) { | |
97 | /* tlv length must be a length of a mac address */ | |
98 | if (hsr_sup_tlv->HSR_TLV_length != sizeof(struct hsr_sup_payload)) | |
99 | return false; | |
100 | ||
101 | /* make sure another tlv follows */ | |
102 | total_length += sizeof(struct hsr_sup_tlv) + hsr_sup_tlv->HSR_TLV_length; | |
103 | if (!pskb_may_pull(skb, total_length)) | |
104 | return false; | |
105 | ||
106 | /* get next tlv */ | |
107 | skb_pull(skb, total_length); | |
108 | hsr_sup_tlv = (struct hsr_sup_tlv *)skb->data; | |
109 | skb_push(skb, total_length); | |
110 | } | |
111 | ||
112 | /* end of tlvs must follow at the end */ | |
113 | if (hsr_sup_tlv->HSR_TLV_type == HSR_TLV_EOT && | |
114 | hsr_sup_tlv->HSR_TLV_length != 0) | |
f266a683 AB |
115 | return false; |
116 | ||
117 | return true; | |
118 | } | |
119 | ||
5f703ce5 LM |
120 | static bool is_proxy_supervision_frame(struct hsr_priv *hsr, |
121 | struct sk_buff *skb) | |
122 | { | |
123 | struct hsr_sup_payload *payload; | |
124 | struct ethhdr *eth_hdr; | |
125 | u16 total_length = 0; | |
126 | ||
127 | eth_hdr = (struct ethhdr *)skb_mac_header(skb); | |
128 | ||
129 | /* Get the HSR protocol revision. */ | |
130 | if (eth_hdr->h_proto == htons(ETH_P_HSR)) | |
131 | total_length = sizeof(struct hsrv1_ethhdr_sp); | |
132 | else | |
133 | total_length = sizeof(struct hsrv0_ethhdr_sp); | |
134 | ||
135 | if (!pskb_may_pull(skb, total_length + sizeof(struct hsr_sup_payload))) | |
136 | return false; | |
137 | ||
138 | skb_pull(skb, total_length); | |
139 | payload = (struct hsr_sup_payload *)skb->data; | |
140 | skb_push(skb, total_length); | |
141 | ||
142 | /* For RedBox (HSR-SAN) check if we have received the supervision | |
143 | * frame with MAC addresses from own ProxyNodeTable. | |
144 | */ | |
145 | return hsr_is_node_in_db(&hsr->proxy_node_db, | |
146 | payload->macaddress_A); | |
147 | } | |
148 | ||
451d8123 MK |
149 | static struct sk_buff *create_stripped_skb_hsr(struct sk_buff *skb_in, |
150 | struct hsr_frame_info *frame) | |
f266a683 AB |
151 | { |
152 | struct sk_buff *skb; | |
153 | int copylen; | |
154 | unsigned char *dst, *src; | |
155 | ||
156 | skb_pull(skb_in, HSR_HLEN); | |
157 | skb = __pskb_copy(skb_in, skb_headroom(skb_in) - HSR_HLEN, GFP_ATOMIC); | |
158 | skb_push(skb_in, HSR_HLEN); | |
05ca6e64 | 159 | if (!skb) |
f266a683 AB |
160 | return NULL; |
161 | ||
162 | skb_reset_mac_header(skb); | |
163 | ||
164 | if (skb->ip_summed == CHECKSUM_PARTIAL) | |
165 | skb->csum_start -= HSR_HLEN; | |
166 | ||
d131fcc6 | 167 | copylen = 2 * ETH_ALEN; |
f266a683 AB |
168 | if (frame->is_vlan) |
169 | copylen += VLAN_HLEN; | |
170 | src = skb_mac_header(skb_in); | |
171 | dst = skb_mac_header(skb); | |
172 | memcpy(dst, src, copylen); | |
173 | ||
174 | skb->protocol = eth_hdr(skb)->h_proto; | |
175 | return skb; | |
176 | } | |
177 | ||
fa4dc895 MK |
178 | struct sk_buff *hsr_get_untagged_frame(struct hsr_frame_info *frame, |
179 | struct hsr_port *port) | |
f266a683 | 180 | { |
451d8123 | 181 | if (!frame->skb_std) { |
d8b57135 | 182 | if (frame->skb_hsr) |
451d8123 MK |
183 | frame->skb_std = |
184 | create_stripped_skb_hsr(frame->skb_hsr, frame); | |
d8b57135 ED |
185 | else |
186 | netdev_warn_once(port->dev, | |
187 | "Unexpected frame received in hsr_get_untagged_frame()\n"); | |
188 | ||
189 | if (!frame->skb_std) | |
451d8123 | 190 | return NULL; |
451d8123 MK |
191 | } |
192 | ||
f266a683 AB |
193 | return skb_clone(frame->skb_std, GFP_ATOMIC); |
194 | } | |
195 | ||
451d8123 MK |
196 | struct sk_buff *prp_get_untagged_frame(struct hsr_frame_info *frame, |
197 | struct hsr_port *port) | |
198 | { | |
199 | if (!frame->skb_std) { | |
200 | if (frame->skb_prp) { | |
201 | /* trim the skb by len - HSR_HLEN to exclude RCT */ | |
202 | skb_trim(frame->skb_prp, | |
203 | frame->skb_prp->len - HSR_HLEN); | |
204 | frame->skb_std = | |
205 | __pskb_copy(frame->skb_prp, | |
206 | skb_headroom(frame->skb_prp), | |
207 | GFP_ATOMIC); | |
208 | } else { | |
209 | /* Unexpected */ | |
210 | WARN_ONCE(1, "%s:%d: Unexpected frame received (port_src %s)\n", | |
211 | __FILE__, __LINE__, port->dev->name); | |
212 | return NULL; | |
213 | } | |
214 | } | |
215 | ||
216 | return skb_clone(frame->skb_std, GFP_ATOMIC); | |
217 | } | |
218 | ||
219 | static void prp_set_lan_id(struct prp_rct *trailer, | |
220 | struct hsr_port *port) | |
221 | { | |
222 | int lane_id; | |
223 | ||
224 | if (port->type == HSR_PT_SLAVE_A) | |
225 | lane_id = 0; | |
226 | else | |
227 | lane_id = 1; | |
228 | ||
229 | /* Add net_id in the upper 3 bits of lane_id */ | |
230 | lane_id |= port->hsr->net_id; | |
231 | set_prp_lan_id(trailer, lane_id); | |
232 | } | |
233 | ||
234 | /* Tailroom for PRP rct should have been created before calling this */ | |
235 | static struct sk_buff *prp_fill_rct(struct sk_buff *skb, | |
236 | struct hsr_frame_info *frame, | |
237 | struct hsr_port *port) | |
238 | { | |
239 | struct prp_rct *trailer; | |
240 | int min_size = ETH_ZLEN; | |
241 | int lsdu_size; | |
242 | ||
243 | if (!skb) | |
244 | return skb; | |
245 | ||
246 | if (frame->is_vlan) | |
247 | min_size = VLAN_ETH_ZLEN; | |
248 | ||
249 | if (skb_put_padto(skb, min_size)) | |
250 | return NULL; | |
251 | ||
252 | trailer = (struct prp_rct *)skb_put(skb, HSR_HLEN); | |
253 | lsdu_size = skb->len - 14; | |
254 | if (frame->is_vlan) | |
255 | lsdu_size -= 4; | |
256 | prp_set_lan_id(trailer, port); | |
257 | set_prp_LSDU_size(trailer, lsdu_size); | |
258 | trailer->sequence_nr = htons(frame->sequence_nr); | |
259 | trailer->PRP_suffix = htons(ETH_P_PRP); | |
78be9217 | 260 | skb->protocol = eth_hdr(skb)->h_proto; |
451d8123 MK |
261 | |
262 | return skb; | |
263 | } | |
264 | ||
265 | static void hsr_set_path_id(struct hsr_ethhdr *hsr_ethhdr, | |
266 | struct hsr_port *port) | |
267 | { | |
268 | int path_id; | |
269 | ||
270 | if (port->type == HSR_PT_SLAVE_A) | |
271 | path_id = 0; | |
272 | else | |
273 | path_id = 1; | |
274 | ||
275 | set_hsr_tag_path(&hsr_ethhdr->hsr_tag, path_id); | |
276 | } | |
277 | ||
5d93518e MK |
278 | static struct sk_buff *hsr_fill_tag(struct sk_buff *skb, |
279 | struct hsr_frame_info *frame, | |
280 | struct hsr_port *port, u8 proto_version) | |
f266a683 AB |
281 | { |
282 | struct hsr_ethhdr *hsr_ethhdr; | |
f266a683 AB |
283 | int lsdu_size; |
284 | ||
6d6148bc | 285 | /* pad to minimum packet size which is 60 + 6 (HSR tag) */ |
5d93518e MK |
286 | if (skb_put_padto(skb, ETH_ZLEN + HSR_HLEN)) |
287 | return NULL; | |
6d6148bc | 288 | |
f266a683 AB |
289 | lsdu_size = skb->len - 14; |
290 | if (frame->is_vlan) | |
291 | lsdu_size -= 4; | |
292 | ||
5fa96778 | 293 | hsr_ethhdr = (struct hsr_ethhdr *)skb_mac_header(skb); |
f266a683 | 294 | |
451d8123 | 295 | hsr_set_path_id(hsr_ethhdr, port); |
f266a683 AB |
296 | set_hsr_tag_LSDU_size(&hsr_ethhdr->hsr_tag, lsdu_size); |
297 | hsr_ethhdr->hsr_tag.sequence_nr = htons(frame->sequence_nr); | |
298 | hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto; | |
b1b4aa91 | 299 | hsr_ethhdr->ethhdr.h_proto = htons(proto_version ? |
ee1c2797 | 300 | ETH_P_HSR : ETH_P_PRP); |
78be9217 | 301 | skb->protocol = hsr_ethhdr->ethhdr.h_proto; |
5d93518e MK |
302 | |
303 | return skb; | |
f266a683 AB |
304 | } |
305 | ||
451d8123 MK |
306 | /* If the original frame was an HSR tagged frame, just clone it to be sent |
307 | * unchanged. Otherwise, create a private frame especially tagged for 'port'. | |
308 | */ | |
309 | struct sk_buff *hsr_create_tagged_frame(struct hsr_frame_info *frame, | |
310 | struct hsr_port *port) | |
f266a683 | 311 | { |
f266a683 AB |
312 | unsigned char *dst, *src; |
313 | struct sk_buff *skb; | |
451d8123 MK |
314 | int movelen; |
315 | ||
316 | if (frame->skb_hsr) { | |
317 | struct hsr_ethhdr *hsr_ethhdr = | |
318 | (struct hsr_ethhdr *)skb_mac_header(frame->skb_hsr); | |
319 | ||
320 | /* set the lane id properly */ | |
321 | hsr_set_path_id(hsr_ethhdr, port); | |
322 | return skb_clone(frame->skb_hsr, GFP_ATOMIC); | |
dcf0cd1c GM |
323 | } else if (port->dev->features & NETIF_F_HW_HSR_TAG_INS) { |
324 | return skb_clone(frame->skb_std, GFP_ATOMIC); | |
451d8123 | 325 | } |
f266a683 AB |
326 | |
327 | /* Create the new skb with enough headroom to fit the HSR tag */ | |
451d8123 MK |
328 | skb = __pskb_copy(frame->skb_std, |
329 | skb_headroom(frame->skb_std) + HSR_HLEN, GFP_ATOMIC); | |
05ca6e64 | 330 | if (!skb) |
f266a683 AB |
331 | return NULL; |
332 | skb_reset_mac_header(skb); | |
333 | ||
334 | if (skb->ip_summed == CHECKSUM_PARTIAL) | |
335 | skb->csum_start += HSR_HLEN; | |
336 | ||
337 | movelen = ETH_HLEN; | |
338 | if (frame->is_vlan) | |
339 | movelen += VLAN_HLEN; | |
340 | ||
341 | src = skb_mac_header(skb); | |
342 | dst = skb_push(skb, HSR_HLEN); | |
343 | memmove(dst, src, movelen); | |
344 | skb_reset_mac_header(skb); | |
345 | ||
5d93518e MK |
346 | /* skb_put_padto free skb on error and hsr_fill_tag returns NULL in |
347 | * that case | |
348 | */ | |
349 | return hsr_fill_tag(skb, frame, port, port->hsr->prot_version); | |
f266a683 AB |
350 | } |
351 | ||
451d8123 | 352 | struct sk_buff *prp_create_tagged_frame(struct hsr_frame_info *frame, |
fa4dc895 | 353 | struct hsr_port *port) |
f266a683 | 354 | { |
451d8123 | 355 | struct sk_buff *skb; |
f266a683 | 356 | |
451d8123 MK |
357 | if (frame->skb_prp) { |
358 | struct prp_rct *trailer = skb_get_PRP_rct(frame->skb_prp); | |
359 | ||
360 | if (trailer) { | |
361 | prp_set_lan_id(trailer, port); | |
362 | } else { | |
363 | WARN_ONCE(!trailer, "errored PRP skb"); | |
364 | return NULL; | |
365 | } | |
366 | return skb_clone(frame->skb_prp, GFP_ATOMIC); | |
dcf0cd1c GM |
367 | } else if (port->dev->features & NETIF_F_HW_HSR_TAG_INS) { |
368 | return skb_clone(frame->skb_std, GFP_ATOMIC); | |
f266a683 AB |
369 | } |
370 | ||
451d8123 MK |
371 | skb = skb_copy_expand(frame->skb_std, 0, |
372 | skb_tailroom(frame->skb_std) + HSR_HLEN, | |
373 | GFP_ATOMIC); | |
876f8ab5 | 374 | return prp_fill_rct(skb, frame, port); |
f266a683 AB |
375 | } |
376 | ||
f266a683 AB |
377 | static void hsr_deliver_master(struct sk_buff *skb, struct net_device *dev, |
378 | struct hsr_node *node_src) | |
379 | { | |
380 | bool was_multicast_frame; | |
7e177d32 | 381 | int res, recv_len; |
f266a683 AB |
382 | |
383 | was_multicast_frame = (skb->pkt_type == PACKET_MULTICAST); | |
384 | hsr_addr_subst_source(node_src, skb); | |
385 | skb_pull(skb, ETH_HLEN); | |
7e177d32 | 386 | recv_len = skb->len; |
f266a683 AB |
387 | res = netif_rx(skb); |
388 | if (res == NET_RX_DROP) { | |
389 | dev->stats.rx_dropped++; | |
390 | } else { | |
391 | dev->stats.rx_packets++; | |
7e177d32 | 392 | dev->stats.rx_bytes += recv_len; |
f266a683 AB |
393 | if (was_multicast_frame) |
394 | dev->stats.multicast++; | |
395 | } | |
396 | } | |
397 | ||
398 | static int hsr_xmit(struct sk_buff *skb, struct hsr_port *port, | |
399 | struct hsr_frame_info *frame) | |
400 | { | |
401 | if (frame->port_rcv->type == HSR_PT_MASTER) { | |
402 | hsr_addr_subst_dest(frame->node_src, skb, port); | |
403 | ||
404 | /* Address substitution (IEC62439-3 pp 26, 50): replace mac | |
405 | * address of outgoing frame with that of the outgoing slave's. | |
406 | */ | |
407 | ether_addr_copy(eth_hdr(skb)->h_source, port->dev->dev_addr); | |
408 | } | |
5055cccf LM |
409 | |
410 | /* When HSR node is used as RedBox - the frame received from HSR ring | |
411 | * requires source MAC address (SA) replacement to one which can be | |
412 | * recognized by SAN devices (otherwise, frames are dropped by switch) | |
413 | */ | |
414 | if (port->type == HSR_PT_INTERLINK) | |
415 | ether_addr_copy(eth_hdr(skb)->h_source, | |
416 | port->hsr->macaddress_redbox); | |
417 | ||
f266a683 AB |
418 | return dev_queue_xmit(skb); |
419 | } | |
420 | ||
451d8123 MK |
421 | bool prp_drop_frame(struct hsr_frame_info *frame, struct hsr_port *port) |
422 | { | |
423 | return ((frame->port_rcv->type == HSR_PT_SLAVE_A && | |
89f5e607 | 424 | port->type == HSR_PT_SLAVE_B) || |
451d8123 | 425 | (frame->port_rcv->type == HSR_PT_SLAVE_B && |
89f5e607 | 426 | port->type == HSR_PT_SLAVE_A)); |
451d8123 MK |
427 | } |
428 | ||
dcf0cd1c GM |
429 | bool hsr_drop_frame(struct hsr_frame_info *frame, struct hsr_port *port) |
430 | { | |
5055cccf LM |
431 | struct sk_buff *skb; |
432 | ||
dcf0cd1c GM |
433 | if (port->dev->features & NETIF_F_HW_HSR_FWD) |
434 | return prp_drop_frame(frame, port); | |
435 | ||
5055cccf LM |
436 | /* RedBox specific frames dropping policies |
437 | * | |
438 | * Do not send HSR supervisory frames to SAN devices | |
439 | */ | |
440 | if (frame->is_supervision && port->type == HSR_PT_INTERLINK) | |
441 | return true; | |
442 | ||
443 | /* Do not forward to other HSR port (A or B) unicast frames which | |
444 | * are addressed to interlink port (and are in the ProxyNodeTable). | |
445 | */ | |
446 | skb = frame->skb_hsr; | |
447 | if (skb && prp_drop_frame(frame, port) && | |
448 | is_unicast_ether_addr(eth_hdr(skb)->h_dest) && | |
449 | hsr_is_node_in_db(&port->hsr->proxy_node_db, | |
450 | eth_hdr(skb)->h_dest)) { | |
451 | return true; | |
452 | } | |
453 | ||
454 | /* Do not forward to port C (Interlink) frames from nodes A and B | |
455 | * if DA is in NodeTable. | |
456 | */ | |
457 | if ((frame->port_rcv->type == HSR_PT_SLAVE_A || | |
458 | frame->port_rcv->type == HSR_PT_SLAVE_B) && | |
459 | port->type == HSR_PT_INTERLINK) { | |
460 | skb = frame->skb_hsr; | |
461 | if (skb && is_unicast_ether_addr(eth_hdr(skb)->h_dest) && | |
462 | hsr_is_node_in_db(&port->hsr->node_db, | |
463 | eth_hdr(skb)->h_dest)) { | |
464 | return true; | |
465 | } | |
466 | } | |
467 | ||
468 | /* Do not forward to port A and B unicast frames received on the | |
469 | * interlink port if it is addressed to one of nodes registered in | |
470 | * the ProxyNodeTable. | |
471 | */ | |
472 | if ((port->type == HSR_PT_SLAVE_A || port->type == HSR_PT_SLAVE_B) && | |
473 | frame->port_rcv->type == HSR_PT_INTERLINK) { | |
474 | skb = frame->skb_std; | |
475 | if (skb && is_unicast_ether_addr(eth_hdr(skb)->h_dest) && | |
476 | hsr_is_node_in_db(&port->hsr->proxy_node_db, | |
477 | eth_hdr(skb)->h_dest)) { | |
478 | return true; | |
479 | } | |
480 | } | |
481 | ||
dcf0cd1c GM |
482 | return false; |
483 | } | |
484 | ||
f266a683 AB |
485 | /* Forward the frame through all devices except: |
486 | * - Back through the receiving device | |
487 | * - If it's a HSR frame: through a device where it has passed before | |
451d8123 | 488 | * - if it's a PRP frame: through another PRP slave device (no bridge) |
f266a683 AB |
489 | * - To the local HSR master only if the frame is directly addressed to it, or |
490 | * a non-supervision multicast or broadcast frame. | |
491 | * | |
492 | * HSR slave devices should insert a HSR tag into the frame, or forward the | |
493 | * frame unchanged if it's already tagged. Interlink devices should strip HSR | |
494 | * tags if they're of the non-HSR type (but only after duplicate discard). The | |
495 | * master device always strips HSR tags. | |
496 | */ | |
497 | static void hsr_forward_do(struct hsr_frame_info *frame) | |
498 | { | |
499 | struct hsr_port *port; | |
500 | struct sk_buff *skb; | |
dcf0cd1c | 501 | bool sent = false; |
f266a683 AB |
502 | |
503 | hsr_for_each_port(frame->port_rcv->hsr, port) { | |
fa4dc895 | 504 | struct hsr_priv *hsr = port->hsr; |
f266a683 AB |
505 | /* Don't send frame back the way it came */ |
506 | if (port == frame->port_rcv) | |
507 | continue; | |
508 | ||
509 | /* Don't deliver locally unless we should */ | |
5670342c | 510 | if (port->type == HSR_PT_MASTER && !frame->is_local_dest) |
f266a683 AB |
511 | continue; |
512 | ||
513 | /* Deliver frames directly addressed to us to master only */ | |
5670342c | 514 | if (port->type != HSR_PT_MASTER && frame->is_local_exclusive) |
f266a683 AB |
515 | continue; |
516 | ||
dcf0cd1c GM |
517 | /* If hardware duplicate generation is enabled, only send out |
518 | * one port. | |
519 | */ | |
520 | if ((port->dev->features & NETIF_F_HW_HSR_DUP) && sent) | |
521 | continue; | |
522 | ||
451d8123 | 523 | /* Don't send frame over port where it has been sent before. |
995161ed | 524 | * Also for SAN, this shouldn't be done. |
451d8123 MK |
525 | */ |
526 | if (!frame->is_from_san && | |
527 | hsr_register_frame_out(port, frame->node_src, | |
f266a683 AB |
528 | frame->sequence_nr)) |
529 | continue; | |
530 | ||
5f703ce5 LM |
531 | if (frame->is_supervision && port->type == HSR_PT_MASTER && |
532 | !frame->is_proxy_supervision) { | |
451d8123 | 533 | hsr_handle_sup_frame(frame); |
f266a683 AB |
534 | continue; |
535 | } | |
536 | ||
451d8123 | 537 | /* Check if frame is to be dropped. Eg. for PRP no forward |
5055cccf | 538 | * between ports, or sending HSR supervision to RedBox. |
451d8123 MK |
539 | */ |
540 | if (hsr->proto_ops->drop_frame && | |
541 | hsr->proto_ops->drop_frame(frame, port)) | |
542 | continue; | |
543 | ||
5055cccf LM |
544 | if (port->type == HSR_PT_SLAVE_A || |
545 | port->type == HSR_PT_SLAVE_B) | |
fa4dc895 | 546 | skb = hsr->proto_ops->create_tagged_frame(frame, port); |
f266a683 | 547 | else |
fa4dc895 MK |
548 | skb = hsr->proto_ops->get_untagged_frame(frame, port); |
549 | ||
05ca6e64 | 550 | if (!skb) { |
451d8123 | 551 | frame->port_rcv->dev->stats.rx_dropped++; |
f266a683 AB |
552 | continue; |
553 | } | |
554 | ||
555 | skb->dev = port->dev; | |
dcf0cd1c | 556 | if (port->type == HSR_PT_MASTER) { |
f266a683 | 557 | hsr_deliver_master(skb, port->dev, frame->node_src); |
dcf0cd1c GM |
558 | } else { |
559 | if (!hsr_xmit(skb, port, frame)) | |
5055cccf LM |
560 | if (port->type == HSR_PT_SLAVE_A || |
561 | port->type == HSR_PT_SLAVE_B) | |
562 | sent = true; | |
dcf0cd1c | 563 | } |
f266a683 AB |
564 | } |
565 | } | |
566 | ||
f266a683 AB |
567 | static void check_local_dest(struct hsr_priv *hsr, struct sk_buff *skb, |
568 | struct hsr_frame_info *frame) | |
569 | { | |
f266a683 AB |
570 | if (hsr_addr_is_self(hsr, eth_hdr(skb)->h_dest)) { |
571 | frame->is_local_exclusive = true; | |
572 | skb->pkt_type = PACKET_HOST; | |
573 | } else { | |
574 | frame->is_local_exclusive = false; | |
575 | } | |
576 | ||
5670342c MK |
577 | if (skb->pkt_type == PACKET_HOST || |
578 | skb->pkt_type == PACKET_MULTICAST || | |
579 | skb->pkt_type == PACKET_BROADCAST) { | |
f266a683 AB |
580 | frame->is_local_dest = true; |
581 | } else { | |
582 | frame->is_local_dest = false; | |
583 | } | |
584 | } | |
585 | ||
451d8123 MK |
586 | static void handle_std_frame(struct sk_buff *skb, |
587 | struct hsr_frame_info *frame) | |
f266a683 | 588 | { |
451d8123 MK |
589 | struct hsr_port *port = frame->port_rcv; |
590 | struct hsr_priv *hsr = port->hsr; | |
f266a683 | 591 | |
451d8123 MK |
592 | frame->skb_hsr = NULL; |
593 | frame->skb_prp = NULL; | |
594 | frame->skb_std = skb; | |
595 | ||
5055cccf | 596 | if (port->type != HSR_PT_MASTER) |
451d8123 | 597 | frame->is_from_san = true; |
5055cccf LM |
598 | |
599 | if (port->type == HSR_PT_MASTER || | |
600 | port->type == HSR_PT_INTERLINK) { | |
601 | /* Sequence nr for the master/interlink node */ | |
06afd2c3 | 602 | lockdep_assert_held(&hsr->seqnr_lock); |
fa4dc895 MK |
603 | frame->sequence_nr = hsr->sequence_nr; |
604 | hsr->sequence_nr++; | |
fa4dc895 MK |
605 | } |
606 | } | |
607 | ||
48b491a5 GM |
608 | int hsr_fill_frame_info(__be16 proto, struct sk_buff *skb, |
609 | struct hsr_frame_info *frame) | |
451d8123 | 610 | { |
78be9217 GM |
611 | struct hsr_port *port = frame->port_rcv; |
612 | struct hsr_priv *hsr = port->hsr; | |
613 | ||
614 | /* HSRv0 supervisory frames double as a tag so treat them as tagged. */ | |
615 | if ((!hsr->prot_version && proto == htons(ETH_P_PRP)) || | |
451d8123 | 616 | proto == htons(ETH_P_HSR)) { |
48b491a5 GM |
617 | /* Check if skb contains hsr_ethhdr */ |
618 | if (skb->mac_len < sizeof(struct hsr_ethhdr)) | |
619 | return -EINVAL; | |
620 | ||
451d8123 MK |
621 | /* HSR tagged frame :- Data or Supervision */ |
622 | frame->skb_std = NULL; | |
623 | frame->skb_prp = NULL; | |
624 | frame->skb_hsr = skb; | |
625 | frame->sequence_nr = hsr_get_skb_sequence_nr(skb); | |
48b491a5 | 626 | return 0; |
451d8123 MK |
627 | } |
628 | ||
629 | /* Standard frame or PRP from master port */ | |
630 | handle_std_frame(skb, frame); | |
48b491a5 GM |
631 | |
632 | return 0; | |
451d8123 MK |
633 | } |
634 | ||
48b491a5 GM |
635 | int prp_fill_frame_info(__be16 proto, struct sk_buff *skb, |
636 | struct hsr_frame_info *frame) | |
451d8123 MK |
637 | { |
638 | /* Supervision frame */ | |
639 | struct prp_rct *rct = skb_get_PRP_rct(skb); | |
640 | ||
641 | if (rct && | |
642 | prp_check_lsdu_size(skb, rct, frame->is_supervision)) { | |
643 | frame->skb_hsr = NULL; | |
644 | frame->skb_std = NULL; | |
645 | frame->skb_prp = skb; | |
646 | frame->sequence_nr = prp_get_skb_sequence_nr(rct); | |
48b491a5 | 647 | return 0; |
451d8123 MK |
648 | } |
649 | handle_std_frame(skb, frame); | |
48b491a5 GM |
650 | |
651 | return 0; | |
451d8123 MK |
652 | } |
653 | ||
fa4dc895 MK |
654 | static int fill_frame_info(struct hsr_frame_info *frame, |
655 | struct sk_buff *skb, struct hsr_port *port) | |
656 | { | |
657 | struct hsr_priv *hsr = port->hsr; | |
451d8123 | 658 | struct hsr_vlan_ethhdr *vlan_hdr; |
5055cccf | 659 | struct list_head *n_db; |
fa4dc895 MK |
660 | struct ethhdr *ethhdr; |
661 | __be16 proto; | |
48b491a5 | 662 | int ret; |
fa4dc895 | 663 | |
48b491a5 GM |
664 | /* Check if skb contains ethhdr */ |
665 | if (skb->mac_len < sizeof(struct ethhdr)) | |
2e9f6093 PP |
666 | return -EINVAL; |
667 | ||
451d8123 | 668 | memset(frame, 0, sizeof(*frame)); |
f266a683 | 669 | frame->is_supervision = is_supervision_frame(port->hsr, skb); |
5f703ce5 LM |
670 | if (frame->is_supervision && hsr->redbox) |
671 | frame->is_proxy_supervision = | |
672 | is_proxy_supervision_frame(port->hsr, skb); | |
5055cccf LM |
673 | |
674 | n_db = &hsr->node_db; | |
675 | if (port->type == HSR_PT_INTERLINK) | |
676 | n_db = &hsr->proxy_node_db; | |
677 | ||
678 | frame->node_src = hsr_get_node(port, n_db, skb, | |
679 | frame->is_supervision, port->type); | |
05ca6e64 | 680 | if (!frame->node_src) |
f266a683 AB |
681 | return -1; /* Unknown node and !is_supervision, or no mem */ |
682 | ||
e012764c | 683 | ethhdr = (struct ethhdr *)skb_mac_header(skb); |
f266a683 | 684 | frame->is_vlan = false; |
451d8123 MK |
685 | proto = ethhdr->h_proto; |
686 | ||
687 | if (proto == htons(ETH_P_8021Q)) | |
f266a683 | 688 | frame->is_vlan = true; |
451d8123 MK |
689 | |
690 | if (frame->is_vlan) { | |
691 | vlan_hdr = (struct hsr_vlan_ethhdr *)ethhdr; | |
692 | proto = vlan_hdr->vlanhdr.h_vlan_encapsulated_proto; | |
f266a683 | 693 | /* FIXME: */ |
f96e8717 | 694 | netdev_warn_once(skb->dev, "VLAN not yet supported"); |
484b4833 | 695 | return -EINVAL; |
f266a683 | 696 | } |
451d8123 MK |
697 | |
698 | frame->is_from_san = false; | |
f266a683 | 699 | frame->port_rcv = port; |
48b491a5 GM |
700 | ret = hsr->proto_ops->fill_frame_info(proto, skb, frame); |
701 | if (ret) | |
702 | return ret; | |
703 | ||
451d8123 | 704 | check_local_dest(port->hsr, skb, frame); |
f266a683 AB |
705 | |
706 | return 0; | |
707 | } | |
708 | ||
709 | /* Must be called holding rcu read lock (because of the port parameter) */ | |
710 | void hsr_forward_skb(struct sk_buff *skb, struct hsr_port *port) | |
711 | { | |
712 | struct hsr_frame_info frame; | |
713 | ||
5aa28201 | 714 | rcu_read_lock(); |
fa4dc895 | 715 | if (fill_frame_info(&frame, skb, port) < 0) |
f266a683 | 716 | goto out_drop; |
451d8123 | 717 | |
f266a683 AB |
718 | hsr_register_frame_in(frame.node_src, port, frame.sequence_nr); |
719 | hsr_forward_do(&frame); | |
5aa28201 | 720 | rcu_read_unlock(); |
ee2c46f3 MK |
721 | /* Gets called for ingress frames as well as egress from master port. |
722 | * So check and increment stats for master port only here. | |
723 | */ | |
5f703ce5 | 724 | if (port->type == HSR_PT_MASTER || port->type == HSR_PT_INTERLINK) { |
ee2c46f3 MK |
725 | port->dev->stats.tx_packets++; |
726 | port->dev->stats.tx_bytes += skb->len; | |
727 | } | |
f266a683 | 728 | |
2b96692b | 729 | kfree_skb(frame.skb_hsr); |
451d8123 | 730 | kfree_skb(frame.skb_prp); |
2b96692b | 731 | kfree_skb(frame.skb_std); |
f266a683 AB |
732 | return; |
733 | ||
734 | out_drop: | |
5aa28201 | 735 | rcu_read_unlock(); |
f266a683 AB |
736 | port->dev->stats.tx_dropped++; |
737 | kfree_skb(skb); | |
738 | } |