Commit | Line | Data |
---|---|---|
f421436a AB |
1 | /* Copyright 2011-2013 Autronica Fire and Security AS |
2 | * | |
3 | * This program is free software; you can redistribute it and/or modify it | |
4 | * under the terms of the GNU General Public License as published by the Free | |
5 | * Software Foundation; either version 2 of the License, or (at your option) | |
6 | * any later version. | |
7 | * | |
8 | * Author(s): | |
9 | * 2011-2013 Arvid Brodin, arvid.brodin@xdin.com | |
10 | * | |
11 | * In addition to routines for registering and unregistering HSR support, this | |
12 | * file also contains the receive routine that handles all incoming frames with | |
13 | * Ethertype (protocol) ETH_P_PRP (HSRv0), and network device event handling. | |
14 | */ | |
15 | ||
16 | #include <linux/netdevice.h> | |
17 | #include <linux/rculist.h> | |
18 | #include <linux/timer.h> | |
19 | #include <linux/etherdevice.h> | |
20 | #include "hsr_main.h" | |
21 | #include "hsr_device.h" | |
22 | #include "hsr_netlink.h" | |
23 | #include "hsr_framereg.h" | |
24 | ||
25 | ||
26 | /* List of all registered virtual HSR devices */ | |
27 | static LIST_HEAD(hsr_list); | |
28 | ||
29 | void register_hsr_master(struct hsr_priv *hsr_priv) | |
30 | { | |
31 | list_add_tail_rcu(&hsr_priv->hsr_list, &hsr_list); | |
32 | } | |
33 | ||
34 | void unregister_hsr_master(struct hsr_priv *hsr_priv) | |
35 | { | |
36 | struct hsr_priv *hsr_priv_it; | |
37 | ||
38 | list_for_each_entry(hsr_priv_it, &hsr_list, hsr_list) | |
39 | if (hsr_priv_it == hsr_priv) { | |
40 | list_del_rcu(&hsr_priv_it->hsr_list); | |
41 | return; | |
42 | } | |
43 | } | |
44 | ||
45 | bool is_hsr_slave(struct net_device *dev) | |
46 | { | |
47 | struct hsr_priv *hsr_priv_it; | |
48 | ||
49 | list_for_each_entry_rcu(hsr_priv_it, &hsr_list, hsr_list) { | |
50 | if (dev == hsr_priv_it->slave[0]) | |
51 | return true; | |
52 | if (dev == hsr_priv_it->slave[1]) | |
53 | return true; | |
54 | } | |
55 | ||
56 | return false; | |
57 | } | |
58 | ||
59 | ||
60 | /* If dev is a HSR slave device, return the virtual master device. Return NULL | |
61 | * otherwise. | |
62 | */ | |
63 | static struct hsr_priv *get_hsr_master(struct net_device *dev) | |
64 | { | |
65 | struct hsr_priv *hsr_priv; | |
66 | ||
67 | rcu_read_lock(); | |
68 | list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list) | |
69 | if ((dev == hsr_priv->slave[0]) || | |
70 | (dev == hsr_priv->slave[1])) { | |
71 | rcu_read_unlock(); | |
72 | return hsr_priv; | |
73 | } | |
74 | ||
75 | rcu_read_unlock(); | |
76 | return NULL; | |
77 | } | |
78 | ||
79 | ||
80 | /* If dev is a HSR slave device, return the other slave device. Return NULL | |
81 | * otherwise. | |
82 | */ | |
83 | static struct net_device *get_other_slave(struct hsr_priv *hsr_priv, | |
84 | struct net_device *dev) | |
85 | { | |
86 | if (dev == hsr_priv->slave[0]) | |
87 | return hsr_priv->slave[1]; | |
88 | if (dev == hsr_priv->slave[1]) | |
89 | return hsr_priv->slave[0]; | |
90 | ||
91 | return NULL; | |
92 | } | |
93 | ||
94 | ||
95 | static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event, | |
96 | void *ptr) | |
97 | { | |
98 | struct net_device *slave, *other_slave; | |
99 | struct hsr_priv *hsr_priv; | |
100 | int old_operstate; | |
101 | int mtu_max; | |
102 | int res; | |
103 | struct net_device *dev; | |
104 | ||
105 | dev = netdev_notifier_info_to_dev(ptr); | |
106 | ||
107 | hsr_priv = get_hsr_master(dev); | |
108 | if (hsr_priv) { | |
109 | /* dev is a slave device */ | |
110 | slave = dev; | |
111 | other_slave = get_other_slave(hsr_priv, slave); | |
112 | } else { | |
113 | if (!is_hsr_master(dev)) | |
114 | return NOTIFY_DONE; | |
115 | hsr_priv = netdev_priv(dev); | |
116 | slave = hsr_priv->slave[0]; | |
117 | other_slave = hsr_priv->slave[1]; | |
118 | } | |
119 | ||
120 | switch (event) { | |
121 | case NETDEV_UP: /* Administrative state DOWN */ | |
122 | case NETDEV_DOWN: /* Administrative state UP */ | |
123 | case NETDEV_CHANGE: /* Link (carrier) state changes */ | |
124 | old_operstate = hsr_priv->dev->operstate; | |
125 | hsr_set_carrier(hsr_priv->dev, slave, other_slave); | |
126 | /* netif_stacked_transfer_operstate() cannot be used here since | |
127 | * it doesn't set IF_OPER_LOWERLAYERDOWN (?) | |
128 | */ | |
129 | hsr_set_operstate(hsr_priv->dev, slave, other_slave); | |
130 | hsr_check_announce(hsr_priv->dev, old_operstate); | |
131 | break; | |
132 | case NETDEV_CHANGEADDR: | |
133 | ||
134 | /* This should not happen since there's no ndo_set_mac_address() | |
135 | * for HSR devices - i.e. not supported. | |
136 | */ | |
137 | if (dev == hsr_priv->dev) | |
138 | break; | |
139 | ||
140 | if (dev == hsr_priv->slave[0]) | |
e83abe37 JP |
141 | ether_addr_copy(hsr_priv->dev->dev_addr, |
142 | hsr_priv->slave[0]->dev_addr); | |
f421436a AB |
143 | |
144 | /* Make sure we recognize frames from ourselves in hsr_rcv() */ | |
145 | res = hsr_create_self_node(&hsr_priv->self_node_db, | |
146 | hsr_priv->dev->dev_addr, | |
147 | hsr_priv->slave[1] ? | |
148 | hsr_priv->slave[1]->dev_addr : | |
149 | hsr_priv->dev->dev_addr); | |
150 | if (res) | |
151 | netdev_warn(hsr_priv->dev, | |
152 | "Could not update HSR node address.\n"); | |
153 | ||
154 | if (dev == hsr_priv->slave[0]) | |
155 | call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr_priv->dev); | |
156 | break; | |
157 | case NETDEV_CHANGEMTU: | |
158 | if (dev == hsr_priv->dev) | |
159 | break; /* Handled in ndo_change_mtu() */ | |
160 | mtu_max = hsr_get_max_mtu(hsr_priv); | |
161 | if (hsr_priv->dev->mtu > mtu_max) | |
162 | dev_set_mtu(hsr_priv->dev, mtu_max); | |
163 | break; | |
164 | case NETDEV_UNREGISTER: | |
165 | if (dev == hsr_priv->slave[0]) | |
166 | hsr_priv->slave[0] = NULL; | |
167 | if (dev == hsr_priv->slave[1]) | |
168 | hsr_priv->slave[1] = NULL; | |
169 | ||
170 | /* There should really be a way to set a new slave device... */ | |
171 | ||
172 | break; | |
173 | case NETDEV_PRE_TYPE_CHANGE: | |
174 | /* HSR works only on Ethernet devices. Refuse slave to change | |
175 | * its type. | |
176 | */ | |
177 | return NOTIFY_BAD; | |
178 | } | |
179 | ||
180 | return NOTIFY_DONE; | |
181 | } | |
182 | ||
183 | ||
184 | static struct timer_list prune_timer; | |
185 | ||
186 | static void prune_nodes_all(unsigned long data) | |
187 | { | |
188 | struct hsr_priv *hsr_priv; | |
189 | ||
190 | rcu_read_lock(); | |
191 | list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list) | |
192 | hsr_prune_nodes(hsr_priv); | |
193 | rcu_read_unlock(); | |
194 | ||
195 | prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD); | |
196 | add_timer(&prune_timer); | |
197 | } | |
198 | ||
199 | ||
200 | static struct sk_buff *hsr_pull_tag(struct sk_buff *skb) | |
201 | { | |
202 | struct hsr_tag *hsr_tag; | |
203 | struct sk_buff *skb2; | |
204 | ||
205 | skb2 = skb_share_check(skb, GFP_ATOMIC); | |
206 | if (unlikely(!skb2)) | |
207 | goto err_free; | |
208 | skb = skb2; | |
209 | ||
210 | if (unlikely(!pskb_may_pull(skb, HSR_TAGLEN))) | |
211 | goto err_free; | |
212 | ||
213 | hsr_tag = (struct hsr_tag *) skb->data; | |
214 | skb->protocol = hsr_tag->encap_proto; | |
215 | skb_pull(skb, HSR_TAGLEN); | |
216 | ||
217 | return skb; | |
218 | ||
219 | err_free: | |
220 | kfree_skb(skb); | |
221 | return NULL; | |
222 | } | |
223 | ||
224 | ||
225 | /* The uses I can see for these HSR supervision frames are: | |
226 | * 1) Use the frames that are sent after node initialization ("HSR_TLV.Type = | |
227 | * 22") to reset any sequence_nr counters belonging to that node. Useful if | |
228 | * the other node's counter has been reset for some reason. | |
229 | * -- | |
230 | * Or not - resetting the counter and bridging the frame would create a | |
231 | * loop, unfortunately. | |
232 | * | |
233 | * 2) Use the LifeCheck frames to detect ring breaks. I.e. if no LifeCheck | |
234 | * frame is received from a particular node, we know something is wrong. | |
235 | * We just register these (as with normal frames) and throw them away. | |
236 | * | |
237 | * 3) Allow different MAC addresses for the two slave interfaces, using the | |
238 | * MacAddressA field. | |
239 | */ | |
240 | static bool is_supervision_frame(struct hsr_priv *hsr_priv, struct sk_buff *skb) | |
241 | { | |
242 | struct hsr_sup_tag *hsr_stag; | |
243 | ||
244 | if (!ether_addr_equal(eth_hdr(skb)->h_dest, | |
245 | hsr_priv->sup_multicast_addr)) | |
246 | return false; | |
247 | ||
248 | hsr_stag = (struct hsr_sup_tag *) skb->data; | |
249 | if (get_hsr_stag_path(hsr_stag) != 0x0f) | |
250 | return false; | |
251 | if ((hsr_stag->HSR_TLV_Type != HSR_TLV_ANNOUNCE) && | |
252 | (hsr_stag->HSR_TLV_Type != HSR_TLV_LIFE_CHECK)) | |
253 | return false; | |
254 | if (hsr_stag->HSR_TLV_Length != 12) | |
255 | return false; | |
256 | ||
257 | return true; | |
258 | } | |
259 | ||
260 | ||
261 | /* Implementation somewhat according to IEC-62439-3, p. 43 | |
262 | */ | |
263 | static int hsr_rcv(struct sk_buff *skb, struct net_device *dev, | |
264 | struct packet_type *pt, struct net_device *orig_dev) | |
265 | { | |
266 | struct hsr_priv *hsr_priv; | |
267 | struct net_device *other_slave; | |
268 | struct node_entry *node; | |
269 | bool deliver_to_self; | |
270 | struct sk_buff *skb_deliver; | |
271 | enum hsr_dev_idx dev_in_idx, dev_other_idx; | |
272 | bool dup_out; | |
273 | int ret; | |
274 | ||
275 | hsr_priv = get_hsr_master(dev); | |
276 | ||
277 | if (!hsr_priv) { | |
278 | /* Non-HSR-slave device 'dev' is connected to a HSR network */ | |
279 | kfree_skb(skb); | |
280 | dev->stats.rx_errors++; | |
281 | return NET_RX_SUCCESS; | |
282 | } | |
283 | ||
284 | if (dev == hsr_priv->slave[0]) { | |
285 | dev_in_idx = HSR_DEV_SLAVE_A; | |
286 | dev_other_idx = HSR_DEV_SLAVE_B; | |
287 | } else { | |
288 | dev_in_idx = HSR_DEV_SLAVE_B; | |
289 | dev_other_idx = HSR_DEV_SLAVE_A; | |
290 | } | |
291 | ||
292 | node = hsr_find_node(&hsr_priv->self_node_db, skb); | |
293 | if (node) { | |
294 | /* Always kill frames sent by ourselves */ | |
295 | kfree_skb(skb); | |
296 | return NET_RX_SUCCESS; | |
297 | } | |
298 | ||
299 | /* Is this frame a candidate for local reception? */ | |
300 | deliver_to_self = false; | |
301 | if ((skb->pkt_type == PACKET_HOST) || | |
302 | (skb->pkt_type == PACKET_MULTICAST) || | |
303 | (skb->pkt_type == PACKET_BROADCAST)) | |
304 | deliver_to_self = true; | |
305 | else if (ether_addr_equal(eth_hdr(skb)->h_dest, | |
306 | hsr_priv->dev->dev_addr)) { | |
307 | skb->pkt_type = PACKET_HOST; | |
308 | deliver_to_self = true; | |
309 | } | |
310 | ||
311 | ||
312 | rcu_read_lock(); /* node_db */ | |
313 | node = hsr_find_node(&hsr_priv->node_db, skb); | |
314 | ||
315 | if (is_supervision_frame(hsr_priv, skb)) { | |
316 | skb_pull(skb, sizeof(struct hsr_sup_tag)); | |
317 | node = hsr_merge_node(hsr_priv, node, skb, dev_in_idx); | |
318 | if (!node) { | |
319 | rcu_read_unlock(); /* node_db */ | |
320 | kfree_skb(skb); | |
321 | hsr_priv->dev->stats.rx_dropped++; | |
322 | return NET_RX_DROP; | |
323 | } | |
324 | skb_push(skb, sizeof(struct hsr_sup_tag)); | |
325 | deliver_to_self = false; | |
326 | } | |
327 | ||
328 | if (!node) { | |
329 | /* Source node unknown; this might be a HSR frame from | |
330 | * another net (different multicast address). Ignore it. | |
331 | */ | |
332 | rcu_read_unlock(); /* node_db */ | |
333 | kfree_skb(skb); | |
334 | return NET_RX_SUCCESS; | |
335 | } | |
336 | ||
337 | /* Register ALL incoming frames as outgoing through the other interface. | |
338 | * This allows us to register frames as incoming only if they are valid | |
339 | * for the receiving interface, without using a specific counter for | |
340 | * incoming frames. | |
341 | */ | |
342 | dup_out = hsr_register_frame_out(node, dev_other_idx, skb); | |
343 | if (!dup_out) | |
344 | hsr_register_frame_in(node, dev_in_idx); | |
345 | ||
346 | /* Forward this frame? */ | |
347 | if (!dup_out && (skb->pkt_type != PACKET_HOST)) | |
348 | other_slave = get_other_slave(hsr_priv, dev); | |
349 | else | |
350 | other_slave = NULL; | |
351 | ||
352 | if (hsr_register_frame_out(node, HSR_DEV_MASTER, skb)) | |
353 | deliver_to_self = false; | |
354 | ||
355 | rcu_read_unlock(); /* node_db */ | |
356 | ||
357 | if (!deliver_to_self && !other_slave) { | |
358 | kfree_skb(skb); | |
359 | /* Circulated frame; silently remove it. */ | |
360 | return NET_RX_SUCCESS; | |
361 | } | |
362 | ||
363 | skb_deliver = skb; | |
364 | if (deliver_to_self && other_slave) { | |
365 | /* skb_clone() is not enough since we will strip the hsr tag | |
366 | * and do address substitution below | |
367 | */ | |
368 | skb_deliver = pskb_copy(skb, GFP_ATOMIC); | |
369 | if (!skb_deliver) { | |
370 | deliver_to_self = false; | |
371 | hsr_priv->dev->stats.rx_dropped++; | |
372 | } | |
373 | } | |
374 | ||
375 | if (deliver_to_self) { | |
376 | bool multicast_frame; | |
377 | ||
378 | skb_deliver = hsr_pull_tag(skb_deliver); | |
379 | if (!skb_deliver) { | |
380 | hsr_priv->dev->stats.rx_dropped++; | |
381 | goto forward; | |
382 | } | |
383 | #if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) | |
384 | /* Move everything in the header that is after the HSR tag, | |
385 | * to work around alignment problems caused by the 6-byte HSR | |
386 | * tag. In practice, this removes/overwrites the HSR tag in | |
387 | * the header and restores a "standard" packet. | |
388 | */ | |
389 | memmove(skb_deliver->data - HSR_TAGLEN, skb_deliver->data, | |
390 | skb_headlen(skb_deliver)); | |
391 | ||
392 | /* Adjust skb members so they correspond with the move above. | |
393 | * This cannot possibly underflow skb->data since hsr_pull_tag() | |
394 | * above succeeded. | |
395 | * At this point in the protocol stack, the transport and | |
396 | * network headers have not been set yet, and we haven't touched | |
397 | * the mac header nor the head. So we only need to adjust data | |
398 | * and tail: | |
399 | */ | |
400 | skb_deliver->data -= HSR_TAGLEN; | |
401 | skb_deliver->tail -= HSR_TAGLEN; | |
402 | #endif | |
403 | skb_deliver->dev = hsr_priv->dev; | |
404 | hsr_addr_subst_source(hsr_priv, skb_deliver); | |
405 | multicast_frame = (skb_deliver->pkt_type == PACKET_MULTICAST); | |
406 | ret = netif_rx(skb_deliver); | |
407 | if (ret == NET_RX_DROP) { | |
408 | hsr_priv->dev->stats.rx_dropped++; | |
409 | } else { | |
410 | hsr_priv->dev->stats.rx_packets++; | |
411 | hsr_priv->dev->stats.rx_bytes += skb->len; | |
412 | if (multicast_frame) | |
413 | hsr_priv->dev->stats.multicast++; | |
414 | } | |
415 | } | |
416 | ||
417 | forward: | |
418 | if (other_slave) { | |
419 | skb_push(skb, ETH_HLEN); | |
420 | skb->dev = other_slave; | |
421 | dev_queue_xmit(skb); | |
422 | } | |
423 | ||
424 | return NET_RX_SUCCESS; | |
425 | } | |
426 | ||
427 | ||
428 | static struct packet_type hsr_pt __read_mostly = { | |
429 | .type = htons(ETH_P_PRP), | |
430 | .func = hsr_rcv, | |
431 | }; | |
432 | ||
433 | static struct notifier_block hsr_nb = { | |
434 | .notifier_call = hsr_netdev_notify, /* Slave event notifications */ | |
435 | }; | |
436 | ||
437 | ||
438 | static int __init hsr_init(void) | |
439 | { | |
440 | int res; | |
441 | ||
442 | BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_TAGLEN); | |
443 | ||
444 | dev_add_pack(&hsr_pt); | |
445 | ||
446 | init_timer(&prune_timer); | |
447 | prune_timer.function = prune_nodes_all; | |
448 | prune_timer.data = 0; | |
449 | prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD); | |
450 | add_timer(&prune_timer); | |
451 | ||
452 | register_netdevice_notifier(&hsr_nb); | |
453 | ||
454 | res = hsr_netlink_init(); | |
455 | ||
456 | return res; | |
457 | } | |
458 | ||
459 | static void __exit hsr_exit(void) | |
460 | { | |
461 | unregister_netdevice_notifier(&hsr_nb); | |
02f2d5a0 | 462 | del_timer_sync(&prune_timer); |
f421436a AB |
463 | hsr_netlink_exit(); |
464 | dev_remove_pack(&hsr_pt); | |
465 | } | |
466 | ||
467 | module_init(hsr_init); | |
468 | module_exit(hsr_exit); | |
469 | MODULE_LICENSE("GPL"); |