Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vis.c
Go to the documentation of this file.
1 /* Copyright (C) 2008-2012 B.A.T.M.A.N. contributors:
2  *
3  * Simon Wunderlich
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of version 2 of the GNU General Public
7  * License as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA
18  */
19 
20 #include "main.h"
21 #include "send.h"
22 #include "translation-table.h"
23 #include "vis.h"
24 #include "soft-interface.h"
25 #include "hard-interface.h"
26 #include "hash.h"
27 #include "originator.h"
28 
29 #define BATADV_MAX_VIS_PACKET_SIZE 1000
30 
31 static void batadv_start_vis_timer(struct batadv_priv *bat_priv);
32 
33 /* free the info */
34 static void batadv_free_info(struct kref *ref)
35 {
36  struct batadv_vis_info *info;
37  struct batadv_priv *bat_priv;
38  struct batadv_recvlist_node *entry, *tmp;
39 
40  info = container_of(ref, struct batadv_vis_info, refcount);
41  bat_priv = info->bat_priv;
42 
43  list_del_init(&info->send_list);
44  spin_lock_bh(&bat_priv->vis.list_lock);
45  list_for_each_entry_safe(entry, tmp, &info->recv_list, list) {
46  list_del(&entry->list);
47  kfree(entry);
48  }
49 
50  spin_unlock_bh(&bat_priv->vis.list_lock);
51  kfree_skb(info->skb_packet);
52  kfree(info);
53 }
54 
55 /* Compare two vis packets, used by the hashing algorithm */
56 static int batadv_vis_info_cmp(const struct hlist_node *node, const void *data2)
57 {
58  const struct batadv_vis_info *d1, *d2;
59  const struct batadv_vis_packet *p1, *p2;
60 
61  d1 = container_of(node, struct batadv_vis_info, hash_entry);
62  d2 = data2;
63  p1 = (struct batadv_vis_packet *)d1->skb_packet->data;
64  p2 = (struct batadv_vis_packet *)d2->skb_packet->data;
65  return batadv_compare_eth(p1->vis_orig, p2->vis_orig);
66 }
67 
68 /* hash function to choose an entry in a hash table of given size
69  * hash algorithm from http://en.wikipedia.org/wiki/Hash_table
70  */
71 static uint32_t batadv_vis_info_choose(const void *data, uint32_t size)
72 {
73  const struct batadv_vis_info *vis_info = data;
74  const struct batadv_vis_packet *packet;
75  const unsigned char *key;
76  uint32_t hash = 0;
77  size_t i;
78 
79  packet = (struct batadv_vis_packet *)vis_info->skb_packet->data;
80  key = packet->vis_orig;
81  for (i = 0; i < ETH_ALEN; i++) {
82  hash += key[i];
83  hash += (hash << 10);
84  hash ^= (hash >> 6);
85  }
86 
87  hash += (hash << 3);
88  hash ^= (hash >> 11);
89  hash += (hash << 15);
90 
91  return hash % size;
92 }
93 
94 static struct batadv_vis_info *
95 batadv_vis_hash_find(struct batadv_priv *bat_priv, const void *data)
96 {
97  struct batadv_hashtable *hash = bat_priv->vis.hash;
98  struct hlist_head *head;
99  struct hlist_node *node;
100  struct batadv_vis_info *vis_info, *vis_info_tmp = NULL;
101  uint32_t index;
102 
103  if (!hash)
104  return NULL;
105 
106  index = batadv_vis_info_choose(data, hash->size);
107  head = &hash->table[index];
108 
109  rcu_read_lock();
110  hlist_for_each_entry_rcu(vis_info, node, head, hash_entry) {
111  if (!batadv_vis_info_cmp(node, data))
112  continue;
113 
114  vis_info_tmp = vis_info;
115  break;
116  }
117  rcu_read_unlock();
118 
119  return vis_info_tmp;
120 }
121 
122 /* insert interface to the list of interfaces of one originator, if it
123  * does not already exist in the list
124  */
125 static void batadv_vis_data_insert_interface(const uint8_t *interface,
126  struct hlist_head *if_list,
127  bool primary)
128 {
129  struct batadv_if_list_entry *entry;
130  struct hlist_node *pos;
131 
132  hlist_for_each_entry(entry, pos, if_list, list) {
133  if (batadv_compare_eth(entry->addr, interface))
134  return;
135  }
136 
137  /* it's a new address, add it to the list */
138  entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
139  if (!entry)
140  return;
141  memcpy(entry->addr, interface, ETH_ALEN);
142  entry->primary = primary;
143  hlist_add_head(&entry->list, if_list);
144 }
145 
146 static void batadv_vis_data_read_prim_sec(struct seq_file *seq,
147  const struct hlist_head *if_list)
148 {
149  struct batadv_if_list_entry *entry;
150  struct hlist_node *pos;
151 
152  hlist_for_each_entry(entry, pos, if_list, list) {
153  if (entry->primary)
154  seq_printf(seq, "PRIMARY, ");
155  else
156  seq_printf(seq, "SEC %pM, ", entry->addr);
157  }
158 }
159 
160 /* read an entry */
161 static ssize_t
162 batadv_vis_data_read_entry(struct seq_file *seq,
163  const struct batadv_vis_info_entry *entry,
164  const uint8_t *src, bool primary)
165 {
166  if (primary && entry->quality == 0)
167  return seq_printf(seq, "TT %pM, ", entry->dest);
168  else if (batadv_compare_eth(entry->src, src))
169  return seq_printf(seq, "TQ %pM %d, ", entry->dest,
170  entry->quality);
171 
172  return 0;
173 }
174 
175 static void
176 batadv_vis_data_insert_interfaces(struct hlist_head *list,
177  struct batadv_vis_packet *packet,
179 {
180  int i;
181 
182  for (i = 0; i < packet->entries; i++) {
183  if (entries[i].quality == 0)
184  continue;
185 
186  if (batadv_compare_eth(entries[i].src, packet->vis_orig))
187  continue;
188 
189  batadv_vis_data_insert_interface(entries[i].src, list, false);
190  }
191 }
192 
193 static void batadv_vis_data_read_entries(struct seq_file *seq,
194  struct hlist_head *list,
195  struct batadv_vis_packet *packet,
196  struct batadv_vis_info_entry *entries)
197 {
198  int i;
199  struct batadv_if_list_entry *entry;
200  struct hlist_node *pos;
201 
202  hlist_for_each_entry(entry, pos, list, list) {
203  seq_printf(seq, "%pM,", entry->addr);
204 
205  for (i = 0; i < packet->entries; i++)
206  batadv_vis_data_read_entry(seq, &entries[i],
207  entry->addr, entry->primary);
208 
209  /* add primary/secondary records */
210  if (batadv_compare_eth(entry->addr, packet->vis_orig))
211  batadv_vis_data_read_prim_sec(seq, list);
212 
213  seq_printf(seq, "\n");
214  }
215 }
216 
217 static void batadv_vis_seq_print_text_bucket(struct seq_file *seq,
218  const struct hlist_head *head)
219 {
220  struct hlist_node *node;
221  struct batadv_vis_info *info;
222  struct batadv_vis_packet *packet;
223  uint8_t *entries_pos;
225  struct batadv_if_list_entry *entry;
226  struct hlist_node *pos, *n;
227 
228  HLIST_HEAD(vis_if_list);
229 
230  hlist_for_each_entry_rcu(info, node, head, hash_entry) {
231  packet = (struct batadv_vis_packet *)info->skb_packet->data;
232  entries_pos = (uint8_t *)packet + sizeof(*packet);
233  entries = (struct batadv_vis_info_entry *)entries_pos;
234 
235  batadv_vis_data_insert_interface(packet->vis_orig, &vis_if_list,
236  true);
237  batadv_vis_data_insert_interfaces(&vis_if_list, packet,
238  entries);
239  batadv_vis_data_read_entries(seq, &vis_if_list, packet,
240  entries);
241 
242  hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
243  hlist_del(&entry->list);
244  kfree(entry);
245  }
246  }
247 }
248 
250 {
251  struct batadv_hard_iface *primary_if;
252  struct hlist_head *head;
253  struct net_device *net_dev = (struct net_device *)seq->private;
254  struct batadv_priv *bat_priv = netdev_priv(net_dev);
255  struct batadv_hashtable *hash = bat_priv->vis.hash;
256  uint32_t i;
257  int ret = 0;
258  int vis_server = atomic_read(&bat_priv->vis_mode);
259 
260  primary_if = batadv_primary_if_get_selected(bat_priv);
261  if (!primary_if)
262  goto out;
263 
264  if (vis_server == BATADV_VIS_TYPE_CLIENT_UPDATE)
265  goto out;
266 
267  spin_lock_bh(&bat_priv->vis.hash_lock);
268  for (i = 0; i < hash->size; i++) {
269  head = &hash->table[i];
270  batadv_vis_seq_print_text_bucket(seq, head);
271  }
272  spin_unlock_bh(&bat_priv->vis.hash_lock);
273 
274 out:
275  if (primary_if)
276  batadv_hardif_free_ref(primary_if);
277  return ret;
278 }
279 
280 /* add the info packet to the send list, if it was not
281  * already linked in.
282  */
283 static void batadv_send_list_add(struct batadv_priv *bat_priv,
284  struct batadv_vis_info *info)
285 {
286  if (list_empty(&info->send_list)) {
287  kref_get(&info->refcount);
288  list_add_tail(&info->send_list, &bat_priv->vis.send_list);
289  }
290 }
291 
292 /* delete the info packet from the send list, if it was
293  * linked in.
294  */
295 static void batadv_send_list_del(struct batadv_vis_info *info)
296 {
297  if (!list_empty(&info->send_list)) {
298  list_del_init(&info->send_list);
299  kref_put(&info->refcount, batadv_free_info);
300  }
301 }
302 
303 /* tries to add one entry to the receive list. */
304 static void batadv_recv_list_add(struct batadv_priv *bat_priv,
305  struct list_head *recv_list, const char *mac)
306 {
307  struct batadv_recvlist_node *entry;
308 
309  entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
310  if (!entry)
311  return;
312 
313  memcpy(entry->mac, mac, ETH_ALEN);
314  spin_lock_bh(&bat_priv->vis.list_lock);
315  list_add_tail(&entry->list, recv_list);
316  spin_unlock_bh(&bat_priv->vis.list_lock);
317 }
318 
319 /* returns 1 if this mac is in the recv_list */
320 static int batadv_recv_list_is_in(struct batadv_priv *bat_priv,
321  const struct list_head *recv_list,
322  const char *mac)
323 {
324  const struct batadv_recvlist_node *entry;
325 
326  spin_lock_bh(&bat_priv->vis.list_lock);
327  list_for_each_entry(entry, recv_list, list) {
328  if (batadv_compare_eth(entry->mac, mac)) {
329  spin_unlock_bh(&bat_priv->vis.list_lock);
330  return 1;
331  }
332  }
333  spin_unlock_bh(&bat_priv->vis.list_lock);
334  return 0;
335 }
336 
337 /* try to add the packet to the vis_hash. return NULL if invalid (e.g. too old,
338  * broken.. ). vis hash must be locked outside. is_new is set when the packet
339  * is newer than old entries in the hash.
340  */
341 static struct batadv_vis_info *
342 batadv_add_packet(struct batadv_priv *bat_priv,
343  struct batadv_vis_packet *vis_packet, int vis_info_len,
344  int *is_new, int make_broadcast)
345 {
346  struct batadv_vis_info *info, *old_info;
347  struct batadv_vis_packet *search_packet, *old_packet;
348  struct batadv_vis_info search_elem;
349  struct batadv_vis_packet *packet;
350  struct sk_buff *tmp_skb;
351  int hash_added;
352  size_t len;
353  size_t max_entries;
354 
355  *is_new = 0;
356  /* sanity check */
357  if (!bat_priv->vis.hash)
358  return NULL;
359 
360  /* see if the packet is already in vis_hash */
361  search_elem.skb_packet = dev_alloc_skb(sizeof(*search_packet));
362  if (!search_elem.skb_packet)
363  return NULL;
364  len = sizeof(*search_packet);
365  tmp_skb = search_elem.skb_packet;
366  search_packet = (struct batadv_vis_packet *)skb_put(tmp_skb, len);
367 
368  memcpy(search_packet->vis_orig, vis_packet->vis_orig, ETH_ALEN);
369  old_info = batadv_vis_hash_find(bat_priv, &search_elem);
370  kfree_skb(search_elem.skb_packet);
371 
372  if (old_info) {
373  tmp_skb = old_info->skb_packet;
374  old_packet = (struct batadv_vis_packet *)tmp_skb->data;
375  if (!batadv_seq_after(ntohl(vis_packet->seqno),
376  ntohl(old_packet->seqno))) {
377  if (old_packet->seqno == vis_packet->seqno) {
378  batadv_recv_list_add(bat_priv,
379  &old_info->recv_list,
380  vis_packet->sender_orig);
381  return old_info;
382  } else {
383  /* newer packet is already in hash. */
384  return NULL;
385  }
386  }
387  /* remove old entry */
388  batadv_hash_remove(bat_priv->vis.hash, batadv_vis_info_cmp,
389  batadv_vis_info_choose, old_info);
390  batadv_send_list_del(old_info);
391  kref_put(&old_info->refcount, batadv_free_info);
392  }
393 
394  info = kmalloc(sizeof(*info), GFP_ATOMIC);
395  if (!info)
396  return NULL;
397 
398  len = sizeof(*packet) + vis_info_len;
399  info->skb_packet = dev_alloc_skb(len + ETH_HLEN);
400  if (!info->skb_packet) {
401  kfree(info);
402  return NULL;
403  }
404  skb_reserve(info->skb_packet, ETH_HLEN);
405  packet = (struct batadv_vis_packet *)skb_put(info->skb_packet, len);
406 
407  kref_init(&info->refcount);
408  INIT_LIST_HEAD(&info->send_list);
409  INIT_LIST_HEAD(&info->recv_list);
410  info->first_seen = jiffies;
411  info->bat_priv = bat_priv;
412  memcpy(packet, vis_packet, len);
413 
414  /* initialize and add new packet. */
415  *is_new = 1;
416 
417  /* Make it a broadcast packet, if required */
418  if (make_broadcast)
420 
421  /* repair if entries is longer than packet. */
422  max_entries = vis_info_len / sizeof(struct batadv_vis_info_entry);
423  if (packet->entries > max_entries)
424  packet->entries = max_entries;
425 
426  batadv_recv_list_add(bat_priv, &info->recv_list, packet->sender_orig);
427 
428  /* try to add it */
429  hash_added = batadv_hash_add(bat_priv->vis.hash, batadv_vis_info_cmp,
430  batadv_vis_info_choose, info,
431  &info->hash_entry);
432  if (hash_added != 0) {
433  /* did not work (for some reason) */
434  kref_put(&info->refcount, batadv_free_info);
435  info = NULL;
436  }
437 
438  return info;
439 }
440 
441 /* handle the server sync packet, forward if needed. */
443  struct batadv_vis_packet *vis_packet,
444  int vis_info_len)
445 {
446  struct batadv_vis_info *info;
447  int is_new, make_broadcast;
448  int vis_server = atomic_read(&bat_priv->vis_mode);
449 
450  make_broadcast = (vis_server == BATADV_VIS_TYPE_SERVER_SYNC);
451 
452  spin_lock_bh(&bat_priv->vis.hash_lock);
453  info = batadv_add_packet(bat_priv, vis_packet, vis_info_len,
454  &is_new, make_broadcast);
455  if (!info)
456  goto end;
457 
458  /* only if we are server ourselves and packet is newer than the one in
459  * hash.
460  */
461  if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC && is_new)
462  batadv_send_list_add(bat_priv, info);
463 end:
464  spin_unlock_bh(&bat_priv->vis.hash_lock);
465 }
466 
467 /* handle an incoming client update packet and schedule forward if needed. */
469  struct batadv_vis_packet *vis_packet,
470  int vis_info_len)
471 {
472  struct batadv_vis_info *info;
473  struct batadv_vis_packet *packet;
474  int is_new;
475  int vis_server = atomic_read(&bat_priv->vis_mode);
476  int are_target = 0;
477 
478  /* clients shall not broadcast. */
479  if (is_broadcast_ether_addr(vis_packet->target_orig))
480  return;
481 
482  /* Are we the target for this VIS packet? */
483  if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC &&
484  batadv_is_my_mac(vis_packet->target_orig))
485  are_target = 1;
486 
487  spin_lock_bh(&bat_priv->vis.hash_lock);
488  info = batadv_add_packet(bat_priv, vis_packet, vis_info_len,
489  &is_new, are_target);
490 
491  if (!info)
492  goto end;
493  /* note that outdated packets will be dropped at this point. */
494 
495  packet = (struct batadv_vis_packet *)info->skb_packet->data;
496 
497  /* send only if we're the target server or ... */
498  if (are_target && is_new) {
499  packet->vis_type = BATADV_VIS_TYPE_SERVER_SYNC; /* upgrade! */
500  batadv_send_list_add(bat_priv, info);
501 
502  /* ... we're not the recipient (and thus need to forward). */
503  } else if (!batadv_is_my_mac(packet->target_orig)) {
504  batadv_send_list_add(bat_priv, info);
505  }
506 
507 end:
508  spin_unlock_bh(&bat_priv->vis.hash_lock);
509 }
510 
511 /* Walk the originators and find the VIS server with the best tq. Set the packet
512  * address to its address and return the best_tq.
513  *
514  * Must be called with the originator hash locked
515  */
516 static int batadv_find_best_vis_server(struct batadv_priv *bat_priv,
517  struct batadv_vis_info *info)
518 {
519  struct batadv_hashtable *hash = bat_priv->orig_hash;
520  struct batadv_neigh_node *router;
521  struct hlist_node *node;
522  struct hlist_head *head;
523  struct batadv_orig_node *orig_node;
524  struct batadv_vis_packet *packet;
525  int best_tq = -1;
526  uint32_t i;
527 
528  packet = (struct batadv_vis_packet *)info->skb_packet->data;
529 
530  for (i = 0; i < hash->size; i++) {
531  head = &hash->table[i];
532 
533  rcu_read_lock();
534  hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
535  router = batadv_orig_node_get_router(orig_node);
536  if (!router)
537  continue;
538 
539  if ((orig_node->flags & BATADV_VIS_SERVER) &&
540  (router->tq_avg > best_tq)) {
541  best_tq = router->tq_avg;
542  memcpy(packet->target_orig, orig_node->orig,
543  ETH_ALEN);
544  }
546  }
547  rcu_read_unlock();
548  }
549 
550  return best_tq;
551 }
552 
553 /* Return true if the vis packet is full. */
554 static bool batadv_vis_packet_full(const struct batadv_vis_info *info)
555 {
556  const struct batadv_vis_packet *packet;
557  size_t num;
558 
559  packet = (struct batadv_vis_packet *)info->skb_packet->data;
560  num = BATADV_MAX_VIS_PACKET_SIZE / sizeof(struct batadv_vis_info_entry);
561 
562  if (num < packet->entries + 1)
563  return true;
564  return false;
565 }
566 
567 /* generates a packet of own vis data,
568  * returns 0 on success, -1 if no packet could be generated
569  */
570 static int batadv_generate_vis_packet(struct batadv_priv *bat_priv)
571 {
572  struct batadv_hashtable *hash = bat_priv->orig_hash;
573  struct hlist_node *node;
574  struct hlist_head *head;
575  struct batadv_orig_node *orig_node;
576  struct batadv_neigh_node *router;
577  struct batadv_vis_info *info = bat_priv->vis.my_info;
578  struct batadv_vis_packet *packet;
580  struct batadv_tt_common_entry *tt_common_entry;
581  uint8_t *packet_pos;
582  int best_tq = -1;
583  uint32_t i;
584 
585  info->first_seen = jiffies;
586  packet = (struct batadv_vis_packet *)info->skb_packet->data;
587  packet->vis_type = atomic_read(&bat_priv->vis_mode);
588 
590  packet->header.ttl = BATADV_TTL;
591  packet->seqno = htonl(ntohl(packet->seqno) + 1);
592  packet->entries = 0;
593  packet->reserved = 0;
594  skb_trim(info->skb_packet, sizeof(*packet));
595 
596  if (packet->vis_type == BATADV_VIS_TYPE_CLIENT_UPDATE) {
597  best_tq = batadv_find_best_vis_server(bat_priv, info);
598 
599  if (best_tq < 0)
600  return best_tq;
601  }
602 
603  for (i = 0; i < hash->size; i++) {
604  head = &hash->table[i];
605 
606  rcu_read_lock();
607  hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
608  router = batadv_orig_node_get_router(orig_node);
609  if (!router)
610  continue;
611 
612  if (!batadv_compare_eth(router->addr, orig_node->orig))
613  goto next;
614 
615  if (router->if_incoming->if_status != BATADV_IF_ACTIVE)
616  goto next;
617 
618  if (router->tq_avg < 1)
619  goto next;
620 
621  /* fill one entry into buffer. */
622  packet_pos = skb_put(info->skb_packet, sizeof(*entry));
623  entry = (struct batadv_vis_info_entry *)packet_pos;
624  memcpy(entry->src,
625  router->if_incoming->net_dev->dev_addr,
626  ETH_ALEN);
627  memcpy(entry->dest, orig_node->orig, ETH_ALEN);
628  entry->quality = router->tq_avg;
629  packet->entries++;
630 
631 next:
633 
634  if (batadv_vis_packet_full(info))
635  goto unlock;
636  }
637  rcu_read_unlock();
638  }
639 
640  hash = bat_priv->tt.local_hash;
641 
642  for (i = 0; i < hash->size; i++) {
643  head = &hash->table[i];
644 
645  rcu_read_lock();
646  hlist_for_each_entry_rcu(tt_common_entry, node, head,
647  hash_entry) {
648  packet_pos = skb_put(info->skb_packet, sizeof(*entry));
649  entry = (struct batadv_vis_info_entry *)packet_pos;
650  memset(entry->src, 0, ETH_ALEN);
651  memcpy(entry->dest, tt_common_entry->addr, ETH_ALEN);
652  entry->quality = 0; /* 0 means TT */
653  packet->entries++;
654 
655  if (batadv_vis_packet_full(info))
656  goto unlock;
657  }
658  rcu_read_unlock();
659  }
660 
661  return 0;
662 
663 unlock:
664  rcu_read_unlock();
665  return 0;
666 }
667 
668 /* free old vis packets. Must be called with this vis_hash_lock
669  * held
670  */
671 static void batadv_purge_vis_packets(struct batadv_priv *bat_priv)
672 {
673  uint32_t i;
674  struct batadv_hashtable *hash = bat_priv->vis.hash;
675  struct hlist_node *node, *node_tmp;
676  struct hlist_head *head;
677  struct batadv_vis_info *info;
678 
679  for (i = 0; i < hash->size; i++) {
680  head = &hash->table[i];
681 
682  hlist_for_each_entry_safe(info, node, node_tmp,
683  head, hash_entry) {
684  /* never purge own data. */
685  if (info == bat_priv->vis.my_info)
686  continue;
687 
688  if (batadv_has_timed_out(info->first_seen,
690  hlist_del(node);
691  batadv_send_list_del(info);
692  kref_put(&info->refcount, batadv_free_info);
693  }
694  }
695  }
696 }
697 
698 static void batadv_broadcast_vis_packet(struct batadv_priv *bat_priv,
699  struct batadv_vis_info *info)
700 {
701  struct batadv_neigh_node *router;
702  struct batadv_hashtable *hash = bat_priv->orig_hash;
703  struct hlist_node *node;
704  struct hlist_head *head;
705  struct batadv_orig_node *orig_node;
706  struct batadv_vis_packet *packet;
707  struct sk_buff *skb;
708  struct batadv_hard_iface *hard_iface;
709  uint8_t dstaddr[ETH_ALEN];
710  uint32_t i;
711 
712 
713  packet = (struct batadv_vis_packet *)info->skb_packet->data;
714 
715  /* send to all routers in range. */
716  for (i = 0; i < hash->size; i++) {
717  head = &hash->table[i];
718 
719  rcu_read_lock();
720  hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
721  /* if it's a vis server and reachable, send it. */
722  if (!(orig_node->flags & BATADV_VIS_SERVER))
723  continue;
724 
725  router = batadv_orig_node_get_router(orig_node);
726  if (!router)
727  continue;
728 
729  /* don't send it if we already received the packet from
730  * this node.
731  */
732  if (batadv_recv_list_is_in(bat_priv, &info->recv_list,
733  orig_node->orig)) {
735  continue;
736  }
737 
738  memcpy(packet->target_orig, orig_node->orig, ETH_ALEN);
739  hard_iface = router->if_incoming;
740  memcpy(dstaddr, router->addr, ETH_ALEN);
741 
743 
744  skb = skb_clone(info->skb_packet, GFP_ATOMIC);
745  if (skb)
746  batadv_send_skb_packet(skb, hard_iface,
747  dstaddr);
748 
749  }
750  rcu_read_unlock();
751  }
752 }
753 
754 static void batadv_unicast_vis_packet(struct batadv_priv *bat_priv,
755  struct batadv_vis_info *info)
756 {
757  struct batadv_orig_node *orig_node;
758  struct batadv_neigh_node *router = NULL;
759  struct sk_buff *skb;
760  struct batadv_vis_packet *packet;
761 
762  packet = (struct batadv_vis_packet *)info->skb_packet->data;
763 
764  orig_node = batadv_orig_hash_find(bat_priv, packet->target_orig);
765  if (!orig_node)
766  goto out;
767 
768  router = batadv_orig_node_get_router(orig_node);
769  if (!router)
770  goto out;
771 
772  skb = skb_clone(info->skb_packet, GFP_ATOMIC);
773  if (skb)
774  batadv_send_skb_packet(skb, router->if_incoming, router->addr);
775 
776 out:
777  if (router)
779  if (orig_node)
780  batadv_orig_node_free_ref(orig_node);
781 }
782 
783 /* only send one vis packet. called from batadv_send_vis_packets() */
784 static void batadv_send_vis_packet(struct batadv_priv *bat_priv,
785  struct batadv_vis_info *info)
786 {
787  struct batadv_hard_iface *primary_if;
788  struct batadv_vis_packet *packet;
789 
790  primary_if = batadv_primary_if_get_selected(bat_priv);
791  if (!primary_if)
792  goto out;
793 
794  packet = (struct batadv_vis_packet *)info->skb_packet->data;
795  if (packet->header.ttl < 2) {
796  pr_debug("Error - can't send vis packet: ttl exceeded\n");
797  goto out;
798  }
799 
800  memcpy(packet->sender_orig, primary_if->net_dev->dev_addr, ETH_ALEN);
801  packet->header.ttl--;
802 
803  if (is_broadcast_ether_addr(packet->target_orig))
804  batadv_broadcast_vis_packet(bat_priv, info);
805  else
806  batadv_unicast_vis_packet(bat_priv, info);
807  packet->header.ttl++; /* restore TTL */
808 
809 out:
810  if (primary_if)
811  batadv_hardif_free_ref(primary_if);
812 }
813 
814 /* called from timer; send (and maybe generate) vis packet. */
815 static void batadv_send_vis_packets(struct work_struct *work)
816 {
817  struct delayed_work *delayed_work;
818  struct batadv_priv *bat_priv;
819  struct batadv_priv_vis *priv_vis;
820  struct batadv_vis_info *info;
821 
822  delayed_work = container_of(work, struct delayed_work, work);
823  priv_vis = container_of(delayed_work, struct batadv_priv_vis, work);
824  bat_priv = container_of(priv_vis, struct batadv_priv, vis);
825  spin_lock_bh(&bat_priv->vis.hash_lock);
826  batadv_purge_vis_packets(bat_priv);
827 
828  if (batadv_generate_vis_packet(bat_priv) == 0) {
829  /* schedule if generation was successful */
830  batadv_send_list_add(bat_priv, bat_priv->vis.my_info);
831  }
832 
833  while (!list_empty(&bat_priv->vis.send_list)) {
834  info = list_first_entry(&bat_priv->vis.send_list,
835  typeof(*info), send_list);
836 
837  kref_get(&info->refcount);
838  spin_unlock_bh(&bat_priv->vis.hash_lock);
839 
840  batadv_send_vis_packet(bat_priv, info);
841 
842  spin_lock_bh(&bat_priv->vis.hash_lock);
843  batadv_send_list_del(info);
844  kref_put(&info->refcount, batadv_free_info);
845  }
846  spin_unlock_bh(&bat_priv->vis.hash_lock);
847  batadv_start_vis_timer(bat_priv);
848 }
849 
850 /* init the vis server. this may only be called when if_list is already
851  * initialized (e.g. bat0 is initialized, interfaces have been added)
852  */
853 int batadv_vis_init(struct batadv_priv *bat_priv)
854 {
855  struct batadv_vis_packet *packet;
856  int hash_added;
857  unsigned int len;
858  unsigned long first_seen;
859  struct sk_buff *tmp_skb;
860 
861  if (bat_priv->vis.hash)
862  return 0;
863 
864  spin_lock_bh(&bat_priv->vis.hash_lock);
865 
866  bat_priv->vis.hash = batadv_hash_new(256);
867  if (!bat_priv->vis.hash) {
868  pr_err("Can't initialize vis_hash\n");
869  goto err;
870  }
871 
872  bat_priv->vis.my_info = kmalloc(BATADV_MAX_VIS_PACKET_SIZE, GFP_ATOMIC);
873  if (!bat_priv->vis.my_info)
874  goto err;
875 
876  len = sizeof(*packet) + BATADV_MAX_VIS_PACKET_SIZE + ETH_HLEN;
877  bat_priv->vis.my_info->skb_packet = dev_alloc_skb(len);
878  if (!bat_priv->vis.my_info->skb_packet)
879  goto free_info;
880 
881  skb_reserve(bat_priv->vis.my_info->skb_packet, ETH_HLEN);
882  tmp_skb = bat_priv->vis.my_info->skb_packet;
883  packet = (struct batadv_vis_packet *)skb_put(tmp_skb, sizeof(*packet));
884 
885  /* prefill the vis info */
887  bat_priv->vis.my_info->first_seen = first_seen;
888  INIT_LIST_HEAD(&bat_priv->vis.my_info->recv_list);
889  INIT_LIST_HEAD(&bat_priv->vis.my_info->send_list);
890  kref_init(&bat_priv->vis.my_info->refcount);
891  bat_priv->vis.my_info->bat_priv = bat_priv;
892  packet->header.version = BATADV_COMPAT_VERSION;
893  packet->header.packet_type = BATADV_VIS;
894  packet->header.ttl = BATADV_TTL;
895  packet->seqno = 0;
896  packet->reserved = 0;
897  packet->entries = 0;
898 
899  INIT_LIST_HEAD(&bat_priv->vis.send_list);
900 
901  hash_added = batadv_hash_add(bat_priv->vis.hash, batadv_vis_info_cmp,
902  batadv_vis_info_choose,
903  bat_priv->vis.my_info,
904  &bat_priv->vis.my_info->hash_entry);
905  if (hash_added != 0) {
906  pr_err("Can't add own vis packet into hash\n");
907  /* not in hash, need to remove it manually. */
908  kref_put(&bat_priv->vis.my_info->refcount, batadv_free_info);
909  goto err;
910  }
911 
912  spin_unlock_bh(&bat_priv->vis.hash_lock);
913  batadv_start_vis_timer(bat_priv);
914  return 0;
915 
916 free_info:
917  kfree(bat_priv->vis.my_info);
918  bat_priv->vis.my_info = NULL;
919 err:
920  spin_unlock_bh(&bat_priv->vis.hash_lock);
921  batadv_vis_quit(bat_priv);
922  return -ENOMEM;
923 }
924 
925 /* Decrease the reference count on a hash item info */
926 static void batadv_free_info_ref(struct hlist_node *node, void *arg)
927 {
928  struct batadv_vis_info *info;
929 
930  info = container_of(node, struct batadv_vis_info, hash_entry);
931  batadv_send_list_del(info);
932  kref_put(&info->refcount, batadv_free_info);
933 }
934 
935 /* shutdown vis-server */
936 void batadv_vis_quit(struct batadv_priv *bat_priv)
937 {
938  if (!bat_priv->vis.hash)
939  return;
940 
941  cancel_delayed_work_sync(&bat_priv->vis.work);
942 
943  spin_lock_bh(&bat_priv->vis.hash_lock);
944  /* properly remove, kill timers ... */
945  batadv_hash_delete(bat_priv->vis.hash, batadv_free_info_ref, NULL);
946  bat_priv->vis.hash = NULL;
947  bat_priv->vis.my_info = NULL;
948  spin_unlock_bh(&bat_priv->vis.hash_lock);
949 }
950 
951 /* schedule packets for (re)transmission */
952 static void batadv_start_vis_timer(struct batadv_priv *bat_priv)
953 {
954  INIT_DELAYED_WORK(&bat_priv->vis.work, batadv_send_vis_packets);
957 }