~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/hsr/hsr_framereg.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  * The HSR spec says never to forward the same frame twice on the same
 12  * interface. A frame is identified by its source MAC address and its HSR
 13  * sequence number. This code keeps track of senders and their sequence numbers
 14  * to allow filtering of duplicate frames, and to detect HSR ring errors.
 15  */
 16 
 17 #include <linux/if_ether.h>
 18 #include <linux/etherdevice.h>
 19 #include <linux/slab.h>
 20 #include <linux/rculist.h>
 21 #include "hsr_main.h"
 22 #include "hsr_framereg.h"
 23 #include "hsr_netlink.h"
 24 
 25 
 26 struct node_entry {
 27         struct list_head mac_list;
 28         unsigned char   MacAddressA[ETH_ALEN];
 29         unsigned char   MacAddressB[ETH_ALEN];
 30         enum hsr_dev_idx   AddrB_if;    /* The local slave through which AddrB
 31                                          * frames are received from this node
 32                                          */
 33         unsigned long   time_in[HSR_MAX_SLAVE];
 34         bool            time_in_stale[HSR_MAX_SLAVE];
 35         u16             seq_out[HSR_MAX_DEV];
 36         struct rcu_head rcu_head;
 37 };
 38 
 39 /*      TODO: use hash lists for mac addresses (linux/jhash.h)?    */
 40 
 41 
 42 
 43 /* Search for mac entry. Caller must hold rcu read lock.
 44  */
 45 static struct node_entry *find_node_by_AddrA(struct list_head *node_db,
 46                                              const unsigned char addr[ETH_ALEN])
 47 {
 48         struct node_entry *node;
 49 
 50         list_for_each_entry_rcu(node, node_db, mac_list) {
 51                 if (ether_addr_equal(node->MacAddressA, addr))
 52                         return node;
 53         }
 54 
 55         return NULL;
 56 }
 57 
 58 
 59 /* Search for mac entry. Caller must hold rcu read lock.
 60  */
 61 static struct node_entry *find_node_by_AddrB(struct list_head *node_db,
 62                                              const unsigned char addr[ETH_ALEN])
 63 {
 64         struct node_entry *node;
 65 
 66         list_for_each_entry_rcu(node, node_db, mac_list) {
 67                 if (ether_addr_equal(node->MacAddressB, addr))
 68                         return node;
 69         }
 70 
 71         return NULL;
 72 }
 73 
 74 
 75 /* Search for mac entry. Caller must hold rcu read lock.
 76  */
 77 struct node_entry *hsr_find_node(struct list_head *node_db, struct sk_buff *skb)
 78 {
 79         struct node_entry *node;
 80         struct ethhdr *ethhdr;
 81 
 82         if (!skb_mac_header_was_set(skb))
 83                 return NULL;
 84 
 85         ethhdr = (struct ethhdr *) skb_mac_header(skb);
 86 
 87         list_for_each_entry_rcu(node, node_db, mac_list) {
 88                 if (ether_addr_equal(node->MacAddressA, ethhdr->h_source))
 89                         return node;
 90                 if (ether_addr_equal(node->MacAddressB, ethhdr->h_source))
 91                         return node;
 92         }
 93 
 94         return NULL;
 95 }
 96 
 97 
 98 /* Helper for device init; the self_node_db is used in hsr_rcv() to recognize
 99  * frames from self that's been looped over the HSR ring.
100  */
101 int hsr_create_self_node(struct list_head *self_node_db,
102                          unsigned char addr_a[ETH_ALEN],
103                          unsigned char addr_b[ETH_ALEN])
104 {
105         struct node_entry *node, *oldnode;
106 
107         node = kmalloc(sizeof(*node), GFP_KERNEL);
108         if (!node)
109                 return -ENOMEM;
110 
111         memcpy(node->MacAddressA, addr_a, ETH_ALEN);
112         memcpy(node->MacAddressB, addr_b, ETH_ALEN);
113 
114         rcu_read_lock();
115         oldnode = list_first_or_null_rcu(self_node_db,
116                                                 struct node_entry, mac_list);
117         if (oldnode) {
118                 list_replace_rcu(&oldnode->mac_list, &node->mac_list);
119                 rcu_read_unlock();
120                 synchronize_rcu();
121                 kfree(oldnode);
122         } else {
123                 rcu_read_unlock();
124                 list_add_tail_rcu(&node->mac_list, self_node_db);
125         }
126 
127         return 0;
128 }
129 
130 
131 /* Add/merge node to the database of nodes. 'skb' must contain an HSR
132  * supervision frame.
133  * - If the supervision header's MacAddressA field is not yet in the database,
134  * this frame is from an hitherto unknown node - add it to the database.
135  * - If the sender's MAC address is not the same as its MacAddressA address,
136  * the node is using PICS_SUBS (address substitution). Record the sender's
137  * address as the node's MacAddressB.
138  *
139  * This function needs to work even if the sender node has changed one of its
140  * slaves' MAC addresses. In this case, there are four different cases described
141  * by (Addr-changed, received-from) pairs as follows. Note that changing the
142  * SlaveA address is equal to changing the node's own address:
143  *
144  * - (AddrB, SlaveB): The new AddrB will be recorded by PICS_SUBS code since
145  *                    node == NULL.
146  * - (AddrB, SlaveA): Will work as usual (the AddrB change won't be detected
147  *                    from this frame).
148  *
149  * - (AddrA, SlaveB): The old node will be found. We need to detect this and
150  *                    remove the node.
151  * - (AddrA, SlaveA): A new node will be registered (non-PICS_SUBS at first).
152  *                    The old one will be pruned after HSR_NODE_FORGET_TIME.
153  *
154  * We also need to detect if the sender's SlaveA and SlaveB cables have been
155  * swapped.
156  */
157 struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
158                                   struct node_entry *node,
159                                   struct sk_buff *skb,
160                                   enum hsr_dev_idx dev_idx)
161 {
162         struct hsr_sup_payload *hsr_sp;
163         struct hsr_ethhdr_sp *hsr_ethsup;
164         int i;
165         unsigned long now;
166 
167         hsr_ethsup = (struct hsr_ethhdr_sp *) skb_mac_header(skb);
168         hsr_sp = (struct hsr_sup_payload *) skb->data;
169 
170         if (node && !ether_addr_equal(node->MacAddressA, hsr_sp->MacAddressA)) {
171                 /* Node has changed its AddrA, frame was received from SlaveB */
172                 list_del_rcu(&node->mac_list);
173                 kfree_rcu(node, rcu_head);
174                 node = NULL;
175         }
176 
177         if (node && (dev_idx == node->AddrB_if) &&
178             !ether_addr_equal(node->MacAddressB, hsr_ethsup->ethhdr.h_source)) {
179                 /* Cables have been swapped */
180                 list_del_rcu(&node->mac_list);
181                 kfree_rcu(node, rcu_head);
182                 node = NULL;
183         }
184 
185         if (node && (dev_idx != node->AddrB_if) &&
186             (node->AddrB_if != HSR_DEV_NONE) &&
187             !ether_addr_equal(node->MacAddressA, hsr_ethsup->ethhdr.h_source)) {
188                 /* Cables have been swapped */
189                 list_del_rcu(&node->mac_list);
190                 kfree_rcu(node, rcu_head);
191                 node = NULL;
192         }
193 
194         if (node)
195                 return node;
196 
197         node = find_node_by_AddrA(&hsr_priv->node_db, hsr_sp->MacAddressA);
198         if (node) {
199                 /* Node is known, but frame was received from an unknown
200                  * address. Node is PICS_SUBS capable; merge its AddrB.
201                  */
202                 memcpy(node->MacAddressB, hsr_ethsup->ethhdr.h_source, ETH_ALEN);
203                 node->AddrB_if = dev_idx;
204                 return node;
205         }
206 
207         node = kzalloc(sizeof(*node), GFP_ATOMIC);
208         if (!node)
209                 return NULL;
210 
211         memcpy(node->MacAddressA, hsr_sp->MacAddressA, ETH_ALEN);
212         memcpy(node->MacAddressB, hsr_ethsup->ethhdr.h_source, ETH_ALEN);
213         if (!ether_addr_equal(hsr_sp->MacAddressA, hsr_ethsup->ethhdr.h_source))
214                 node->AddrB_if = dev_idx;
215         else
216                 node->AddrB_if = HSR_DEV_NONE;
217 
218         /* We are only interested in time diffs here, so use current jiffies
219          * as initialization. (0 could trigger an spurious ring error warning).
220          */
221         now = jiffies;
222         for (i = 0; i < HSR_MAX_SLAVE; i++)
223                 node->time_in[i] = now;
224         for (i = 0; i < HSR_MAX_DEV; i++)
225                 node->seq_out[i] = ntohs(hsr_ethsup->hsr_sup.sequence_nr) - 1;
226 
227         list_add_tail_rcu(&node->mac_list, &hsr_priv->node_db);
228 
229         return node;
230 }
231 
232 
233 /* 'skb' is a frame meant for this host, that is to be passed to upper layers.
234  *
235  * If the frame was sent by a node's B interface, replace the sender
236  * address with that node's "official" address (MacAddressA) so that upper
237  * layers recognize where it came from.
238  */
239 void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
240 {
241         struct ethhdr *ethhdr;
242         struct node_entry *node;
243 
244         if (!skb_mac_header_was_set(skb)) {
245                 WARN_ONCE(1, "%s: Mac header not set\n", __func__);
246                 return;
247         }
248         ethhdr = (struct ethhdr *) skb_mac_header(skb);
249 
250         rcu_read_lock();
251         node = find_node_by_AddrB(&hsr_priv->node_db, ethhdr->h_source);
252         if (node)
253                 memcpy(ethhdr->h_source, node->MacAddressA, ETH_ALEN);
254         rcu_read_unlock();
255 }
256 
257 
258 /* 'skb' is a frame meant for another host.
259  * 'hsr_dev_idx' is the HSR index of the outgoing device
260  *
261  * Substitute the target (dest) MAC address if necessary, so the it matches the
262  * recipient interface MAC address, regardless of whether that is the
263  * recipient's A or B interface.
264  * This is needed to keep the packets flowing through switches that learn on
265  * which "side" the different interfaces are.
266  */
267 void hsr_addr_subst_dest(struct hsr_priv *hsr_priv, struct ethhdr *ethhdr,
268                          enum hsr_dev_idx dev_idx)
269 {
270         struct node_entry *node;
271 
272         rcu_read_lock();
273         node = find_node_by_AddrA(&hsr_priv->node_db, ethhdr->h_dest);
274         if (node && (node->AddrB_if == dev_idx))
275                 memcpy(ethhdr->h_dest, node->MacAddressB, ETH_ALEN);
276         rcu_read_unlock();
277 }
278 
279 
280 /* seq_nr_after(a, b) - return true if a is after (higher in sequence than) b,
281  * false otherwise.
282  */
283 static bool seq_nr_after(u16 a, u16 b)
284 {
285         /* Remove inconsistency where
286          * seq_nr_after(a, b) == seq_nr_before(a, b)
287          */
288         if ((int) b - a == 32768)
289                 return false;
290 
291         return (((s16) (b - a)) < 0);
292 }
293 #define seq_nr_before(a, b)             seq_nr_after((b), (a))
294 #define seq_nr_after_or_eq(a, b)        (!seq_nr_before((a), (b)))
295 #define seq_nr_before_or_eq(a, b)       (!seq_nr_after((a), (b)))
296 
297 
298 void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx)
299 {
300         if ((dev_idx < 0) || (dev_idx >= HSR_MAX_SLAVE)) {
301                 WARN_ONCE(1, "%s: Invalid dev_idx (%d)\n", __func__, dev_idx);
302                 return;
303         }
304         node->time_in[dev_idx] = jiffies;
305         node->time_in_stale[dev_idx] = false;
306 }
307 
308 
309 /* 'skb' is a HSR Ethernet frame (with a HSR tag inserted), with a valid
310  * ethhdr->h_source address and skb->mac_header set.
311  *
312  * Return:
313  *       1 if frame can be shown to have been sent recently on this interface,
314  *       0 otherwise, or
315  *       negative error code on error
316  */
317 int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
318                            struct sk_buff *skb)
319 {
320         struct hsr_ethhdr *hsr_ethhdr;
321         u16 sequence_nr;
322 
323         if ((dev_idx < 0) || (dev_idx >= HSR_MAX_DEV)) {
324                 WARN_ONCE(1, "%s: Invalid dev_idx (%d)\n", __func__, dev_idx);
325                 return -EINVAL;
326         }
327         if (!skb_mac_header_was_set(skb)) {
328                 WARN_ONCE(1, "%s: Mac header not set\n", __func__);
329                 return -EINVAL;
330         }
331         hsr_ethhdr = (struct hsr_ethhdr *) skb_mac_header(skb);
332 
333         sequence_nr = ntohs(hsr_ethhdr->hsr_tag.sequence_nr);
334         if (seq_nr_before_or_eq(sequence_nr, node->seq_out[dev_idx]))
335                 return 1;
336 
337         node->seq_out[dev_idx] = sequence_nr;
338         return 0;
339 }
340 
341 
342 
343 static bool is_late(struct node_entry *node, enum hsr_dev_idx dev_idx)
344 {
345         enum hsr_dev_idx other;
346 
347         if (node->time_in_stale[dev_idx])
348                 return true;
349 
350         if (dev_idx == HSR_DEV_SLAVE_A)
351                 other = HSR_DEV_SLAVE_B;
352         else
353                 other = HSR_DEV_SLAVE_A;
354 
355         if (node->time_in_stale[other])
356                 return false;
357 
358         if (time_after(node->time_in[other], node->time_in[dev_idx] +
359                        msecs_to_jiffies(MAX_SLAVE_DIFF)))
360                 return true;
361 
362         return false;
363 }
364 
365 
366 /* Remove stale sequence_nr records. Called by timer every
367  * HSR_LIFE_CHECK_INTERVAL (two seconds or so).
368  */
369 void hsr_prune_nodes(struct hsr_priv *hsr_priv)
370 {
371         struct node_entry *node;
372         unsigned long timestamp;
373         unsigned long time_a, time_b;
374 
375         rcu_read_lock();
376         list_for_each_entry_rcu(node, &hsr_priv->node_db, mac_list) {
377                 /* Shorthand */
378                 time_a = node->time_in[HSR_DEV_SLAVE_A];
379                 time_b = node->time_in[HSR_DEV_SLAVE_B];
380 
381                 /* Check for timestamps old enough to risk wrap-around */
382                 if (time_after(jiffies, time_a + MAX_JIFFY_OFFSET/2))
383                         node->time_in_stale[HSR_DEV_SLAVE_A] = true;
384                 if (time_after(jiffies, time_b + MAX_JIFFY_OFFSET/2))
385                         node->time_in_stale[HSR_DEV_SLAVE_B] = true;
386 
387                 /* Get age of newest frame from node.
388                  * At least one time_in is OK here; nodes get pruned long
389                  * before both time_ins can get stale
390                  */
391                 timestamp = time_a;
392                 if (node->time_in_stale[HSR_DEV_SLAVE_A] ||
393                     (!node->time_in_stale[HSR_DEV_SLAVE_B] &&
394                     time_after(time_b, time_a)))
395                         timestamp = time_b;
396 
397                 /* Warn of ring error only as long as we get frames at all */
398                 if (time_is_after_jiffies(timestamp +
399                                         msecs_to_jiffies(1.5*MAX_SLAVE_DIFF))) {
400 
401                         if (is_late(node, HSR_DEV_SLAVE_A))
402                                 hsr_nl_ringerror(hsr_priv, node->MacAddressA,
403                                                  HSR_DEV_SLAVE_A);
404                         else if (is_late(node, HSR_DEV_SLAVE_B))
405                                 hsr_nl_ringerror(hsr_priv, node->MacAddressA,
406                                                  HSR_DEV_SLAVE_B);
407                 }
408 
409                 /* Prune old entries */
410                 if (time_is_before_jiffies(timestamp +
411                                         msecs_to_jiffies(HSR_NODE_FORGET_TIME))) {
412                         hsr_nl_nodedown(hsr_priv, node->MacAddressA);
413                         list_del_rcu(&node->mac_list);
414                         /* Note that we need to free this entry later: */
415                         kfree_rcu(node, rcu_head);
416                 }
417         }
418         rcu_read_unlock();
419 }
420 
421 
422 void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
423                         unsigned char addr[ETH_ALEN])
424 {
425         struct node_entry *node;
426 
427         if (!_pos) {
428                 node = list_first_or_null_rcu(&hsr_priv->node_db,
429                                                 struct node_entry, mac_list);
430                 if (node)
431                         memcpy(addr, node->MacAddressA, ETH_ALEN);
432                 return node;
433         }
434 
435         node = _pos;
436         list_for_each_entry_continue_rcu(node, &hsr_priv->node_db, mac_list) {
437                 memcpy(addr, node->MacAddressA, ETH_ALEN);
438                 return node;
439         }
440 
441         return NULL;
442 }
443 
444 
445 int hsr_get_node_data(struct hsr_priv *hsr_priv,
446                       const unsigned char *addr,
447                       unsigned char addr_b[ETH_ALEN],
448                       unsigned int *addr_b_ifindex,
449                       int *if1_age,
450                       u16 *if1_seq,
451                       int *if2_age,
452                       u16 *if2_seq)
453 {
454         struct node_entry *node;
455         unsigned long tdiff;
456 
457 
458         rcu_read_lock();
459         node = find_node_by_AddrA(&hsr_priv->node_db, addr);
460         if (!node) {
461                 rcu_read_unlock();
462                 return -ENOENT; /* No such entry */
463         }
464 
465         memcpy(addr_b, node->MacAddressB, ETH_ALEN);
466 
467         tdiff = jiffies - node->time_in[HSR_DEV_SLAVE_A];
468         if (node->time_in_stale[HSR_DEV_SLAVE_A])
469                 *if1_age = INT_MAX;
470 #if HZ <= MSEC_PER_SEC
471         else if (tdiff > msecs_to_jiffies(INT_MAX))
472                 *if1_age = INT_MAX;
473 #endif
474         else
475                 *if1_age = jiffies_to_msecs(tdiff);
476 
477         tdiff = jiffies - node->time_in[HSR_DEV_SLAVE_B];
478         if (node->time_in_stale[HSR_DEV_SLAVE_B])
479                 *if2_age = INT_MAX;
480 #if HZ <= MSEC_PER_SEC
481         else if (tdiff > msecs_to_jiffies(INT_MAX))
482                 *if2_age = INT_MAX;
483 #endif
484         else
485                 *if2_age = jiffies_to_msecs(tdiff);
486 
487         /* Present sequence numbers as if they were incoming on interface */
488         *if1_seq = node->seq_out[HSR_DEV_SLAVE_B];
489         *if2_seq = node->seq_out[HSR_DEV_SLAVE_A];
490 
491         if ((node->AddrB_if != HSR_DEV_NONE) && hsr_priv->slave[node->AddrB_if])
492                 *addr_b_ifindex = hsr_priv->slave[node->AddrB_if]->ifindex;
493         else
494                 *addr_b_ifindex = -1;
495 
496         rcu_read_unlock();
497 
498         return 0;
499 }
500 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp