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]) 141 ether_addr_copy(hsr_priv->dev->dev_addr, 142 hsr_priv->slave[0]->dev_addr); 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); 462 del_timer_sync(&prune_timer); 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"); 470