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