1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright 2011-2014 Autronica Fire and Security AS |
3 | * |
4 | * Author(s): |
5 | * 2011-2014 Arvid Brodin, arvid.brodin@alten.se |
6 | * This file contains device methods for creating, using and destroying |
7 | * virtual HSR or PRP devices. |
8 | */ |
9 | |
10 | #include <linux/netdevice.h> |
11 | #include <linux/skbuff.h> |
12 | #include <linux/etherdevice.h> |
13 | #include <linux/rtnetlink.h> |
14 | #include <linux/pkt_sched.h> |
15 | #include "hsr_device.h" |
16 | #include "hsr_slave.h" |
17 | #include "hsr_framereg.h" |
18 | #include "hsr_main.h" |
19 | #include "hsr_forward.h" |
20 | |
21 | static bool is_admin_up(struct net_device *dev) |
22 | { |
23 | return dev && (dev->flags & IFF_UP); |
24 | } |
25 | |
26 | static bool is_slave_up(struct net_device *dev) |
27 | { |
28 | return dev && is_admin_up(dev) && netif_oper_up(dev); |
29 | } |
30 | |
31 | static void __hsr_set_operstate(struct net_device *dev, int transition) |
32 | { |
33 | write_lock(&dev_base_lock); |
34 | if (dev->operstate != transition) { |
35 | dev->operstate = transition; |
36 | write_unlock(&dev_base_lock); |
37 | netdev_state_change(dev); |
38 | } else { |
39 | write_unlock(&dev_base_lock); |
40 | } |
41 | } |
42 | |
43 | static void hsr_set_operstate(struct hsr_port *master, bool has_carrier) |
44 | { |
45 | if (!is_admin_up(dev: master->dev)) { |
46 | __hsr_set_operstate(dev: master->dev, transition: IF_OPER_DOWN); |
47 | return; |
48 | } |
49 | |
50 | if (has_carrier) |
51 | __hsr_set_operstate(dev: master->dev, transition: IF_OPER_UP); |
52 | else |
53 | __hsr_set_operstate(dev: master->dev, transition: IF_OPER_LOWERLAYERDOWN); |
54 | } |
55 | |
56 | static bool hsr_check_carrier(struct hsr_port *master) |
57 | { |
58 | struct hsr_port *port; |
59 | |
60 | ASSERT_RTNL(); |
61 | |
62 | hsr_for_each_port(master->hsr, port) { |
63 | if (port->type != HSR_PT_MASTER && is_slave_up(dev: port->dev)) { |
64 | netif_carrier_on(dev: master->dev); |
65 | return true; |
66 | } |
67 | } |
68 | |
69 | netif_carrier_off(dev: master->dev); |
70 | |
71 | return false; |
72 | } |
73 | |
74 | static void hsr_check_announce(struct net_device *hsr_dev, |
75 | unsigned char old_operstate) |
76 | { |
77 | struct hsr_priv *hsr; |
78 | |
79 | hsr = netdev_priv(dev: hsr_dev); |
80 | |
81 | if (hsr_dev->operstate == IF_OPER_UP && old_operstate != IF_OPER_UP) { |
82 | /* Went up */ |
83 | hsr->announce_count = 0; |
84 | mod_timer(timer: &hsr->announce_timer, |
85 | expires: jiffies + msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL)); |
86 | } |
87 | |
88 | if (hsr_dev->operstate != IF_OPER_UP && old_operstate == IF_OPER_UP) |
89 | /* Went down */ |
90 | del_timer(timer: &hsr->announce_timer); |
91 | } |
92 | |
93 | void hsr_check_carrier_and_operstate(struct hsr_priv *hsr) |
94 | { |
95 | struct hsr_port *master; |
96 | unsigned char old_operstate; |
97 | bool has_carrier; |
98 | |
99 | master = hsr_port_get_hsr(hsr, pt: HSR_PT_MASTER); |
100 | /* netif_stacked_transfer_operstate() cannot be used here since |
101 | * it doesn't set IF_OPER_LOWERLAYERDOWN (?) |
102 | */ |
103 | old_operstate = master->dev->operstate; |
104 | has_carrier = hsr_check_carrier(master); |
105 | hsr_set_operstate(master, has_carrier); |
106 | hsr_check_announce(hsr_dev: master->dev, old_operstate); |
107 | } |
108 | |
109 | int hsr_get_max_mtu(struct hsr_priv *hsr) |
110 | { |
111 | unsigned int mtu_max; |
112 | struct hsr_port *port; |
113 | |
114 | mtu_max = ETH_DATA_LEN; |
115 | hsr_for_each_port(hsr, port) |
116 | if (port->type != HSR_PT_MASTER) |
117 | mtu_max = min(port->dev->mtu, mtu_max); |
118 | |
119 | if (mtu_max < HSR_HLEN) |
120 | return 0; |
121 | return mtu_max - HSR_HLEN; |
122 | } |
123 | |
124 | static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu) |
125 | { |
126 | struct hsr_priv *hsr; |
127 | |
128 | hsr = netdev_priv(dev); |
129 | |
130 | if (new_mtu > hsr_get_max_mtu(hsr)) { |
131 | netdev_info(dev, format: "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n" , |
132 | HSR_HLEN); |
133 | return -EINVAL; |
134 | } |
135 | |
136 | dev->mtu = new_mtu; |
137 | |
138 | return 0; |
139 | } |
140 | |
141 | static int hsr_dev_open(struct net_device *dev) |
142 | { |
143 | struct hsr_priv *hsr; |
144 | struct hsr_port *port; |
145 | char designation; |
146 | |
147 | hsr = netdev_priv(dev); |
148 | designation = '\0'; |
149 | |
150 | hsr_for_each_port(hsr, port) { |
151 | if (port->type == HSR_PT_MASTER) |
152 | continue; |
153 | switch (port->type) { |
154 | case HSR_PT_SLAVE_A: |
155 | designation = 'A'; |
156 | break; |
157 | case HSR_PT_SLAVE_B: |
158 | designation = 'B'; |
159 | break; |
160 | default: |
161 | designation = '?'; |
162 | } |
163 | if (!is_slave_up(dev: port->dev)) |
164 | netdev_warn(dev, format: "Slave %c (%s) is not up; please bring it up to get a fully working HSR network\n" , |
165 | designation, port->dev->name); |
166 | } |
167 | |
168 | if (designation == '\0') |
169 | netdev_warn(dev, format: "No slave devices configured\n" ); |
170 | |
171 | return 0; |
172 | } |
173 | |
174 | static int hsr_dev_close(struct net_device *dev) |
175 | { |
176 | /* Nothing to do here. */ |
177 | return 0; |
178 | } |
179 | |
180 | static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr, |
181 | netdev_features_t features) |
182 | { |
183 | netdev_features_t mask; |
184 | struct hsr_port *port; |
185 | |
186 | mask = features; |
187 | |
188 | /* Mask out all features that, if supported by one device, should be |
189 | * enabled for all devices (see NETIF_F_ONE_FOR_ALL). |
190 | * |
191 | * Anything that's off in mask will not be enabled - so only things |
192 | * that were in features originally, and also is in NETIF_F_ONE_FOR_ALL, |
193 | * may become enabled. |
194 | */ |
195 | features &= ~NETIF_F_ONE_FOR_ALL; |
196 | hsr_for_each_port(hsr, port) |
197 | features = netdev_increment_features(all: features, |
198 | one: port->dev->features, |
199 | mask); |
200 | |
201 | return features; |
202 | } |
203 | |
204 | static netdev_features_t hsr_fix_features(struct net_device *dev, |
205 | netdev_features_t features) |
206 | { |
207 | struct hsr_priv *hsr = netdev_priv(dev); |
208 | |
209 | return hsr_features_recompute(hsr, features); |
210 | } |
211 | |
212 | static netdev_tx_t hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev) |
213 | { |
214 | struct hsr_priv *hsr = netdev_priv(dev); |
215 | struct hsr_port *master; |
216 | |
217 | master = hsr_port_get_hsr(hsr, pt: HSR_PT_MASTER); |
218 | if (master) { |
219 | skb->dev = master->dev; |
220 | skb_reset_mac_header(skb); |
221 | skb_reset_mac_len(skb); |
222 | spin_lock_bh(lock: &hsr->seqnr_lock); |
223 | hsr_forward_skb(skb, port: master); |
224 | spin_unlock_bh(lock: &hsr->seqnr_lock); |
225 | } else { |
226 | dev_core_stats_tx_dropped_inc(dev); |
227 | dev_kfree_skb_any(skb); |
228 | } |
229 | return NETDEV_TX_OK; |
230 | } |
231 | |
232 | static const struct header_ops = { |
233 | .create = eth_header, |
234 | .parse = eth_header_parse, |
235 | }; |
236 | |
237 | static struct sk_buff *hsr_init_skb(struct hsr_port *master) |
238 | { |
239 | struct hsr_priv *hsr = master->hsr; |
240 | struct sk_buff *skb; |
241 | int hlen, tlen; |
242 | |
243 | hlen = LL_RESERVED_SPACE(master->dev); |
244 | tlen = master->dev->needed_tailroom; |
245 | /* skb size is same for PRP/HSR frames, only difference |
246 | * being, for PRP it is a trailer and for HSR it is a |
247 | * header |
248 | */ |
249 | skb = dev_alloc_skb(length: sizeof(struct hsr_sup_tag) + |
250 | sizeof(struct hsr_sup_payload) + hlen + tlen); |
251 | |
252 | if (!skb) |
253 | return skb; |
254 | |
255 | skb_reserve(skb, len: hlen); |
256 | skb->dev = master->dev; |
257 | skb->priority = TC_PRIO_CONTROL; |
258 | |
259 | if (dev_hard_header(skb, dev: skb->dev, ETH_P_PRP, |
260 | daddr: hsr->sup_multicast_addr, |
261 | saddr: skb->dev->dev_addr, len: skb->len) <= 0) |
262 | goto out; |
263 | |
264 | skb_reset_mac_header(skb); |
265 | skb_reset_mac_len(skb); |
266 | skb_reset_network_header(skb); |
267 | skb_reset_transport_header(skb); |
268 | |
269 | return skb; |
270 | out: |
271 | kfree_skb(skb); |
272 | |
273 | return NULL; |
274 | } |
275 | |
276 | static void send_hsr_supervision_frame(struct hsr_port *master, |
277 | unsigned long *interval) |
278 | { |
279 | struct hsr_priv *hsr = master->hsr; |
280 | __u8 type = HSR_TLV_LIFE_CHECK; |
281 | struct hsr_sup_payload *hsr_sp; |
282 | struct hsr_sup_tag *hsr_stag; |
283 | struct sk_buff *skb; |
284 | |
285 | *interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL); |
286 | if (hsr->announce_count < 3 && hsr->prot_version == 0) { |
287 | type = HSR_TLV_ANNOUNCE; |
288 | *interval = msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL); |
289 | hsr->announce_count++; |
290 | } |
291 | |
292 | skb = hsr_init_skb(master); |
293 | if (!skb) { |
294 | WARN_ONCE(1, "HSR: Could not send supervision frame\n" ); |
295 | return; |
296 | } |
297 | |
298 | hsr_stag = skb_put(skb, len: sizeof(struct hsr_sup_tag)); |
299 | set_hsr_stag_path(hst: hsr_stag, path: (hsr->prot_version ? 0x0 : 0xf)); |
300 | set_hsr_stag_HSR_ver(hst: hsr_stag, HSR_ver: hsr->prot_version); |
301 | |
302 | /* From HSRv1 on we have separate supervision sequence numbers. */ |
303 | spin_lock_bh(lock: &hsr->seqnr_lock); |
304 | if (hsr->prot_version > 0) { |
305 | hsr_stag->sequence_nr = htons(hsr->sup_sequence_nr); |
306 | hsr->sup_sequence_nr++; |
307 | } else { |
308 | hsr_stag->sequence_nr = htons(hsr->sequence_nr); |
309 | hsr->sequence_nr++; |
310 | } |
311 | |
312 | hsr_stag->tlv.HSR_TLV_type = type; |
313 | /* TODO: Why 12 in HSRv0? */ |
314 | hsr_stag->tlv.HSR_TLV_length = hsr->prot_version ? |
315 | sizeof(struct hsr_sup_payload) : 12; |
316 | |
317 | /* Payload: MacAddressA */ |
318 | hsr_sp = skb_put(skb, len: sizeof(struct hsr_sup_payload)); |
319 | ether_addr_copy(dst: hsr_sp->macaddress_A, src: master->dev->dev_addr); |
320 | |
321 | if (skb_put_padto(skb, ETH_ZLEN)) { |
322 | spin_unlock_bh(lock: &hsr->seqnr_lock); |
323 | return; |
324 | } |
325 | |
326 | hsr_forward_skb(skb, port: master); |
327 | spin_unlock_bh(lock: &hsr->seqnr_lock); |
328 | return; |
329 | } |
330 | |
331 | static void send_prp_supervision_frame(struct hsr_port *master, |
332 | unsigned long *interval) |
333 | { |
334 | struct hsr_priv *hsr = master->hsr; |
335 | struct hsr_sup_payload *hsr_sp; |
336 | struct hsr_sup_tag *hsr_stag; |
337 | struct sk_buff *skb; |
338 | |
339 | skb = hsr_init_skb(master); |
340 | if (!skb) { |
341 | WARN_ONCE(1, "PRP: Could not send supervision frame\n" ); |
342 | return; |
343 | } |
344 | |
345 | *interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL); |
346 | hsr_stag = skb_put(skb, len: sizeof(struct hsr_sup_tag)); |
347 | set_hsr_stag_path(hst: hsr_stag, path: (hsr->prot_version ? 0x0 : 0xf)); |
348 | set_hsr_stag_HSR_ver(hst: hsr_stag, HSR_ver: (hsr->prot_version ? 1 : 0)); |
349 | |
350 | /* From HSRv1 on we have separate supervision sequence numbers. */ |
351 | spin_lock_bh(lock: &hsr->seqnr_lock); |
352 | hsr_stag->sequence_nr = htons(hsr->sup_sequence_nr); |
353 | hsr->sup_sequence_nr++; |
354 | hsr_stag->tlv.HSR_TLV_type = PRP_TLV_LIFE_CHECK_DD; |
355 | hsr_stag->tlv.HSR_TLV_length = sizeof(struct hsr_sup_payload); |
356 | |
357 | /* Payload: MacAddressA */ |
358 | hsr_sp = skb_put(skb, len: sizeof(struct hsr_sup_payload)); |
359 | ether_addr_copy(dst: hsr_sp->macaddress_A, src: master->dev->dev_addr); |
360 | |
361 | if (skb_put_padto(skb, ETH_ZLEN)) { |
362 | spin_unlock_bh(lock: &hsr->seqnr_lock); |
363 | return; |
364 | } |
365 | |
366 | hsr_forward_skb(skb, port: master); |
367 | spin_unlock_bh(lock: &hsr->seqnr_lock); |
368 | } |
369 | |
370 | /* Announce (supervision frame) timer function |
371 | */ |
372 | static void hsr_announce(struct timer_list *t) |
373 | { |
374 | struct hsr_priv *hsr; |
375 | struct hsr_port *master; |
376 | unsigned long interval; |
377 | |
378 | hsr = from_timer(hsr, t, announce_timer); |
379 | |
380 | rcu_read_lock(); |
381 | master = hsr_port_get_hsr(hsr, pt: HSR_PT_MASTER); |
382 | hsr->proto_ops->send_sv_frame(master, &interval); |
383 | |
384 | if (is_admin_up(dev: master->dev)) |
385 | mod_timer(timer: &hsr->announce_timer, expires: jiffies + interval); |
386 | |
387 | rcu_read_unlock(); |
388 | } |
389 | |
390 | void hsr_del_ports(struct hsr_priv *hsr) |
391 | { |
392 | struct hsr_port *port; |
393 | |
394 | port = hsr_port_get_hsr(hsr, pt: HSR_PT_SLAVE_A); |
395 | if (port) |
396 | hsr_del_port(port); |
397 | |
398 | port = hsr_port_get_hsr(hsr, pt: HSR_PT_SLAVE_B); |
399 | if (port) |
400 | hsr_del_port(port); |
401 | |
402 | port = hsr_port_get_hsr(hsr, pt: HSR_PT_MASTER); |
403 | if (port) |
404 | hsr_del_port(port); |
405 | } |
406 | |
407 | static const struct net_device_ops hsr_device_ops = { |
408 | .ndo_change_mtu = hsr_dev_change_mtu, |
409 | .ndo_open = hsr_dev_open, |
410 | .ndo_stop = hsr_dev_close, |
411 | .ndo_start_xmit = hsr_dev_xmit, |
412 | .ndo_fix_features = hsr_fix_features, |
413 | }; |
414 | |
415 | static struct device_type hsr_type = { |
416 | .name = "hsr" , |
417 | }; |
418 | |
419 | static struct hsr_proto_ops hsr_ops = { |
420 | .send_sv_frame = send_hsr_supervision_frame, |
421 | .create_tagged_frame = hsr_create_tagged_frame, |
422 | .get_untagged_frame = hsr_get_untagged_frame, |
423 | .drop_frame = hsr_drop_frame, |
424 | .fill_frame_info = hsr_fill_frame_info, |
425 | .invalid_dan_ingress_frame = hsr_invalid_dan_ingress_frame, |
426 | }; |
427 | |
428 | static struct hsr_proto_ops prp_ops = { |
429 | .send_sv_frame = send_prp_supervision_frame, |
430 | .create_tagged_frame = prp_create_tagged_frame, |
431 | .get_untagged_frame = prp_get_untagged_frame, |
432 | .drop_frame = prp_drop_frame, |
433 | .fill_frame_info = prp_fill_frame_info, |
434 | .handle_san_frame = prp_handle_san_frame, |
435 | .update_san_info = prp_update_san_info, |
436 | }; |
437 | |
438 | void hsr_dev_setup(struct net_device *dev) |
439 | { |
440 | eth_hw_addr_random(dev); |
441 | |
442 | ether_setup(dev); |
443 | dev->min_mtu = 0; |
444 | dev->header_ops = &hsr_header_ops; |
445 | dev->netdev_ops = &hsr_device_ops; |
446 | SET_NETDEV_DEVTYPE(dev, &hsr_type); |
447 | dev->priv_flags |= IFF_NO_QUEUE | IFF_DISABLE_NETPOLL; |
448 | |
449 | dev->needs_free_netdev = true; |
450 | |
451 | dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | |
452 | NETIF_F_GSO_MASK | NETIF_F_HW_CSUM | |
453 | NETIF_F_HW_VLAN_CTAG_TX; |
454 | |
455 | dev->features = dev->hw_features; |
456 | |
457 | /* Prevent recursive tx locking */ |
458 | dev->features |= NETIF_F_LLTX; |
459 | /* VLAN on top of HSR needs testing and probably some work on |
460 | * hsr_header_create() etc. |
461 | */ |
462 | dev->features |= NETIF_F_VLAN_CHALLENGED; |
463 | /* Not sure about this. Taken from bridge code. netdev_features.h says |
464 | * it means "Does not change network namespaces". |
465 | */ |
466 | dev->features |= NETIF_F_NETNS_LOCAL; |
467 | } |
468 | |
469 | /* Return true if dev is a HSR master; return false otherwise. |
470 | */ |
471 | bool is_hsr_master(struct net_device *dev) |
472 | { |
473 | return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit); |
474 | } |
475 | EXPORT_SYMBOL(is_hsr_master); |
476 | |
477 | /* Default multicast address for HSR Supervision frames */ |
478 | static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = { |
479 | 0x01, 0x15, 0x4e, 0x00, 0x01, 0x00 |
480 | }; |
481 | |
482 | int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2], |
483 | unsigned char multicast_spec, u8 protocol_version, |
484 | struct netlink_ext_ack *extack) |
485 | { |
486 | bool unregister = false; |
487 | struct hsr_priv *hsr; |
488 | int res; |
489 | |
490 | hsr = netdev_priv(dev: hsr_dev); |
491 | INIT_LIST_HEAD(list: &hsr->ports); |
492 | INIT_LIST_HEAD(list: &hsr->node_db); |
493 | spin_lock_init(&hsr->list_lock); |
494 | |
495 | eth_hw_addr_set(dev: hsr_dev, addr: slave[0]->dev_addr); |
496 | |
497 | /* initialize protocol specific functions */ |
498 | if (protocol_version == PRP_V1) { |
499 | /* For PRP, lan_id has most significant 3 bits holding |
500 | * the net_id of PRP_LAN_ID |
501 | */ |
502 | hsr->net_id = PRP_LAN_ID << 1; |
503 | hsr->proto_ops = &prp_ops; |
504 | } else { |
505 | hsr->proto_ops = &hsr_ops; |
506 | } |
507 | |
508 | /* Make sure we recognize frames from ourselves in hsr_rcv() */ |
509 | res = hsr_create_self_node(hsr, addr_a: hsr_dev->dev_addr, |
510 | addr_b: slave[1]->dev_addr); |
511 | if (res < 0) |
512 | return res; |
513 | |
514 | spin_lock_init(&hsr->seqnr_lock); |
515 | /* Overflow soon to find bugs easier: */ |
516 | hsr->sequence_nr = HSR_SEQNR_START; |
517 | hsr->sup_sequence_nr = HSR_SUP_SEQNR_START; |
518 | |
519 | timer_setup(&hsr->announce_timer, hsr_announce, 0); |
520 | timer_setup(&hsr->prune_timer, hsr_prune_nodes, 0); |
521 | |
522 | ether_addr_copy(dst: hsr->sup_multicast_addr, src: def_multicast_addr); |
523 | hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec; |
524 | |
525 | hsr->prot_version = protocol_version; |
526 | |
527 | /* Make sure the 1st call to netif_carrier_on() gets through */ |
528 | netif_carrier_off(dev: hsr_dev); |
529 | |
530 | res = hsr_add_port(hsr, dev: hsr_dev, pt: HSR_PT_MASTER, extack); |
531 | if (res) |
532 | goto err_add_master; |
533 | |
534 | /* HSR forwarding offload supported in lower device? */ |
535 | if ((slave[0]->features & NETIF_F_HW_HSR_FWD) && |
536 | (slave[1]->features & NETIF_F_HW_HSR_FWD)) |
537 | hsr->fwd_offloaded = true; |
538 | |
539 | res = register_netdevice(dev: hsr_dev); |
540 | if (res) |
541 | goto err_unregister; |
542 | |
543 | unregister = true; |
544 | |
545 | res = hsr_add_port(hsr, dev: slave[0], pt: HSR_PT_SLAVE_A, extack); |
546 | if (res) |
547 | goto err_unregister; |
548 | |
549 | res = hsr_add_port(hsr, dev: slave[1], pt: HSR_PT_SLAVE_B, extack); |
550 | if (res) |
551 | goto err_unregister; |
552 | |
553 | hsr_debugfs_init(priv: hsr, hsr_dev); |
554 | mod_timer(timer: &hsr->prune_timer, expires: jiffies + msecs_to_jiffies(PRUNE_PERIOD)); |
555 | |
556 | return 0; |
557 | |
558 | err_unregister: |
559 | hsr_del_ports(hsr); |
560 | err_add_master: |
561 | hsr_del_self_node(hsr); |
562 | |
563 | if (unregister) |
564 | unregister_netdevice(dev: hsr_dev); |
565 | return res; |
566 | } |
567 | |