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

TOMOYO Linux Cross Reference
Linux/net/batman-adv/translation-table.c

Version: ~ [ linux-5.5-rc6 ] ~ [ linux-5.4.11 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.95 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.164 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.209 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.209 ] ~ [ 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.81 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
  3  *
  4  * Marek Lindner, Simon Wunderlich
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of version 2 of the GNU General Public
  8  * License as published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful, but
 11  * WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 13  * General Public License for more details.
 14  *
 15  * You should have received a copy of the GNU General Public License
 16  * along with this program; if not, write to the Free Software
 17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 18  * 02110-1301, USA
 19  *
 20  */
 21 
 22 #include "main.h"
 23 #include "translation-table.h"
 24 #include "soft-interface.h"
 25 #include "hard-interface.h"
 26 #include "send.h"
 27 #include "hash.h"
 28 #include "originator.h"
 29 #include "routing.h"
 30 
 31 #include <linux/crc16.h>
 32 
 33 static void _tt_global_del(struct bat_priv *bat_priv,
 34                            struct tt_global_entry *tt_global_entry,
 35                            const char *message);
 36 static void tt_purge(struct work_struct *work);
 37 
 38 /* returns 1 if they are the same mac addr */
 39 static int compare_tt(const struct hlist_node *node, const void *data2)
 40 {
 41         const void *data1 = container_of(node, struct tt_common_entry,
 42                                          hash_entry);
 43 
 44         return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
 45 }
 46 
 47 static void tt_start_timer(struct bat_priv *bat_priv)
 48 {
 49         INIT_DELAYED_WORK(&bat_priv->tt_work, tt_purge);
 50         queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work,
 51                            msecs_to_jiffies(5000));
 52 }
 53 
 54 static struct tt_common_entry *tt_hash_find(struct hashtable_t *hash,
 55                                             const void *data)
 56 {
 57         struct hlist_head *head;
 58         struct hlist_node *node;
 59         struct tt_common_entry *tt_common_entry, *tt_common_entry_tmp = NULL;
 60         uint32_t index;
 61 
 62         if (!hash)
 63                 return NULL;
 64 
 65         index = choose_orig(data, hash->size);
 66         head = &hash->table[index];
 67 
 68         rcu_read_lock();
 69         hlist_for_each_entry_rcu(tt_common_entry, node, head, hash_entry) {
 70                 if (!compare_eth(tt_common_entry, data))
 71                         continue;
 72 
 73                 if (!atomic_inc_not_zero(&tt_common_entry->refcount))
 74                         continue;
 75 
 76                 tt_common_entry_tmp = tt_common_entry;
 77                 break;
 78         }
 79         rcu_read_unlock();
 80 
 81         return tt_common_entry_tmp;
 82 }
 83 
 84 static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
 85                                                  const void *data)
 86 {
 87         struct tt_common_entry *tt_common_entry;
 88         struct tt_local_entry *tt_local_entry = NULL;
 89 
 90         tt_common_entry = tt_hash_find(bat_priv->tt_local_hash, data);
 91         if (tt_common_entry)
 92                 tt_local_entry = container_of(tt_common_entry,
 93                                               struct tt_local_entry, common);
 94         return tt_local_entry;
 95 }
 96 
 97 static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
 98                                                    const void *data)
 99 {
100         struct tt_common_entry *tt_common_entry;
101         struct tt_global_entry *tt_global_entry = NULL;
102 
103         tt_common_entry = tt_hash_find(bat_priv->tt_global_hash, data);
104         if (tt_common_entry)
105                 tt_global_entry = container_of(tt_common_entry,
106                                                struct tt_global_entry, common);
107         return tt_global_entry;
108 
109 }
110 
111 static void tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry)
112 {
113         if (atomic_dec_and_test(&tt_local_entry->common.refcount))
114                 kfree_rcu(tt_local_entry, common.rcu);
115 }
116 
117 static void tt_global_entry_free_rcu(struct rcu_head *rcu)
118 {
119         struct tt_common_entry *tt_common_entry;
120         struct tt_global_entry *tt_global_entry;
121 
122         tt_common_entry = container_of(rcu, struct tt_common_entry, rcu);
123         tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
124                                        common);
125 
126         if (tt_global_entry->orig_node)
127                 orig_node_free_ref(tt_global_entry->orig_node);
128 
129         kfree(tt_global_entry);
130 }
131 
132 static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry)
133 {
134         if (atomic_dec_and_test(&tt_global_entry->common.refcount))
135                 call_rcu(&tt_global_entry->common.rcu,
136                          tt_global_entry_free_rcu);
137 }
138 
139 static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr,
140                            uint8_t flags)
141 {
142         struct tt_change_node *tt_change_node;
143 
144         tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
145 
146         if (!tt_change_node)
147                 return;
148 
149         tt_change_node->change.flags = flags;
150         memcpy(tt_change_node->change.addr, addr, ETH_ALEN);
151 
152         spin_lock_bh(&bat_priv->tt_changes_list_lock);
153         /* track the change in the OGMinterval list */
154         list_add_tail(&tt_change_node->list, &bat_priv->tt_changes_list);
155         atomic_inc(&bat_priv->tt_local_changes);
156         spin_unlock_bh(&bat_priv->tt_changes_list_lock);
157 
158         atomic_set(&bat_priv->tt_ogm_append_cnt, 0);
159 }
160 
161 int tt_len(int changes_num)
162 {
163         return changes_num * sizeof(struct tt_change);
164 }
165 
166 static int tt_local_init(struct bat_priv *bat_priv)
167 {
168         if (bat_priv->tt_local_hash)
169                 return 1;
170 
171         bat_priv->tt_local_hash = hash_new(1024);
172 
173         if (!bat_priv->tt_local_hash)
174                 return 0;
175 
176         return 1;
177 }
178 
179 void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
180                   int ifindex)
181 {
182         struct bat_priv *bat_priv = netdev_priv(soft_iface);
183         struct tt_local_entry *tt_local_entry = NULL;
184         struct tt_global_entry *tt_global_entry = NULL;
185         int hash_added;
186 
187         tt_local_entry = tt_local_hash_find(bat_priv, addr);
188 
189         if (tt_local_entry) {
190                 tt_local_entry->last_seen = jiffies;
191                 goto out;
192         }
193 
194         tt_local_entry = kmalloc(sizeof(*tt_local_entry), GFP_ATOMIC);
195         if (!tt_local_entry)
196                 goto out;
197 
198         bat_dbg(DBG_TT, bat_priv,
199                 "Creating new local tt entry: %pM (ttvn: %d)\n", addr,
200                 (uint8_t)atomic_read(&bat_priv->ttvn));
201 
202         memcpy(tt_local_entry->common.addr, addr, ETH_ALEN);
203         tt_local_entry->common.flags = NO_FLAGS;
204         if (is_wifi_iface(ifindex))
205                 tt_local_entry->common.flags |= TT_CLIENT_WIFI;
206         atomic_set(&tt_local_entry->common.refcount, 2);
207         tt_local_entry->last_seen = jiffies;
208 
209         /* the batman interface mac address should never be purged */
210         if (compare_eth(addr, soft_iface->dev_addr))
211                 tt_local_entry->common.flags |= TT_CLIENT_NOPURGE;
212 
213         /* The local entry has to be marked as NEW to avoid to send it in
214          * a full table response going out before the next ttvn increment
215          * (consistency check) */
216         tt_local_entry->common.flags |= TT_CLIENT_NEW;
217 
218         hash_added = hash_add(bat_priv->tt_local_hash, compare_tt, choose_orig,
219                          &tt_local_entry->common,
220                          &tt_local_entry->common.hash_entry);
221 
222         if (unlikely(hash_added != 0)) {
223                 /* remove the reference for the hash */
224                 tt_local_entry_free_ref(tt_local_entry);
225                 goto out;
226         }
227 
228         tt_local_event(bat_priv, addr, tt_local_entry->common.flags);
229 
230         /* remove address from global hash if present */
231         tt_global_entry = tt_global_hash_find(bat_priv, addr);
232 
233         /* Check whether it is a roaming! */
234         if (tt_global_entry) {
235                 /* This node is probably going to update its tt table */
236                 tt_global_entry->orig_node->tt_poss_change = true;
237                 /* The global entry has to be marked as ROAMING and has to be
238                  * kept for consistency purpose */
239                 tt_global_entry->common.flags |= TT_CLIENT_ROAM;
240                 tt_global_entry->roam_at = jiffies;
241                 send_roam_adv(bat_priv, tt_global_entry->common.addr,
242                               tt_global_entry->orig_node);
243         }
244 out:
245         if (tt_local_entry)
246                 tt_local_entry_free_ref(tt_local_entry);
247         if (tt_global_entry)
248                 tt_global_entry_free_ref(tt_global_entry);
249 }
250 
251 int tt_changes_fill_buffer(struct bat_priv *bat_priv,
252                            unsigned char *buff, int buff_len)
253 {
254         int count = 0, tot_changes = 0;
255         struct tt_change_node *entry, *safe;
256 
257         if (buff_len > 0)
258                 tot_changes = buff_len / tt_len(1);
259 
260         spin_lock_bh(&bat_priv->tt_changes_list_lock);
261         atomic_set(&bat_priv->tt_local_changes, 0);
262 
263         list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
264                                  list) {
265                 if (count < tot_changes) {
266                         memcpy(buff + tt_len(count),
267                                &entry->change, sizeof(struct tt_change));
268                         count++;
269                 }
270                 list_del(&entry->list);
271                 kfree(entry);
272         }
273         spin_unlock_bh(&bat_priv->tt_changes_list_lock);
274 
275         /* Keep the buffer for possible tt_request */
276         spin_lock_bh(&bat_priv->tt_buff_lock);
277         kfree(bat_priv->tt_buff);
278         bat_priv->tt_buff_len = 0;
279         bat_priv->tt_buff = NULL;
280         /* We check whether this new OGM has no changes due to size
281          * problems */
282         if (buff_len > 0) {
283                 /**
284                  * if kmalloc() fails we will reply with the full table
285                  * instead of providing the diff
286                  */
287                 bat_priv->tt_buff = kmalloc(buff_len, GFP_ATOMIC);
288                 if (bat_priv->tt_buff) {
289                         memcpy(bat_priv->tt_buff, buff, buff_len);
290                         bat_priv->tt_buff_len = buff_len;
291                 }
292         }
293         spin_unlock_bh(&bat_priv->tt_buff_lock);
294 
295         return tot_changes;
296 }
297 
298 int tt_local_seq_print_text(struct seq_file *seq, void *offset)
299 {
300         struct net_device *net_dev = (struct net_device *)seq->private;
301         struct bat_priv *bat_priv = netdev_priv(net_dev);
302         struct hashtable_t *hash = bat_priv->tt_local_hash;
303         struct tt_common_entry *tt_common_entry;
304         struct hard_iface *primary_if;
305         struct hlist_node *node;
306         struct hlist_head *head;
307         uint32_t i;
308         int ret = 0;
309 
310         primary_if = primary_if_get_selected(bat_priv);
311         if (!primary_if) {
312                 ret = seq_printf(seq,
313                                  "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
314                                  net_dev->name);
315                 goto out;
316         }
317 
318         if (primary_if->if_status != IF_ACTIVE) {
319                 ret = seq_printf(seq,
320                                  "BATMAN mesh %s disabled - primary interface not active\n",
321                                  net_dev->name);
322                 goto out;
323         }
324 
325         seq_printf(seq,
326                    "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
327                    net_dev->name, (uint8_t)atomic_read(&bat_priv->ttvn));
328 
329         for (i = 0; i < hash->size; i++) {
330                 head = &hash->table[i];
331 
332                 rcu_read_lock();
333                 hlist_for_each_entry_rcu(tt_common_entry, node,
334                                          head, hash_entry) {
335                         seq_printf(seq, " * %pM [%c%c%c%c%c]\n",
336                                    tt_common_entry->addr,
337                                    (tt_common_entry->flags &
338                                     TT_CLIENT_ROAM ? 'R' : '.'),
339                                    (tt_common_entry->flags &
340                                     TT_CLIENT_NOPURGE ? 'P' : '.'),
341                                    (tt_common_entry->flags &
342                                     TT_CLIENT_NEW ? 'N' : '.'),
343                                    (tt_common_entry->flags &
344                                     TT_CLIENT_PENDING ? 'X' : '.'),
345                                    (tt_common_entry->flags &
346                                     TT_CLIENT_WIFI ? 'W' : '.'));
347                 }
348                 rcu_read_unlock();
349         }
350 out:
351         if (primary_if)
352                 hardif_free_ref(primary_if);
353         return ret;
354 }
355 
356 static void tt_local_set_pending(struct bat_priv *bat_priv,
357                                  struct tt_local_entry *tt_local_entry,
358                                  uint16_t flags, const char *message)
359 {
360         tt_local_event(bat_priv, tt_local_entry->common.addr,
361                        tt_local_entry->common.flags | flags);
362 
363         /* The local client has to be marked as "pending to be removed" but has
364          * to be kept in the table in order to send it in a full table
365          * response issued before the net ttvn increment (consistency check) */
366         tt_local_entry->common.flags |= TT_CLIENT_PENDING;
367 
368         bat_dbg(DBG_TT, bat_priv,
369                 "Local tt entry (%pM) pending to be removed: %s\n",
370                 tt_local_entry->common.addr, message);
371 }
372 
373 void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
374                      const char *message, bool roaming)
375 {
376         struct tt_local_entry *tt_local_entry = NULL;
377 
378         tt_local_entry = tt_local_hash_find(bat_priv, addr);
379         if (!tt_local_entry)
380                 goto out;
381 
382         tt_local_set_pending(bat_priv, tt_local_entry, TT_CLIENT_DEL |
383                              (roaming ? TT_CLIENT_ROAM : NO_FLAGS), message);
384 out:
385         if (tt_local_entry)
386                 tt_local_entry_free_ref(tt_local_entry);
387 }
388 
389 static void tt_local_purge(struct bat_priv *bat_priv)
390 {
391         struct hashtable_t *hash = bat_priv->tt_local_hash;
392         struct tt_local_entry *tt_local_entry;
393         struct tt_common_entry *tt_common_entry;
394         struct hlist_node *node, *node_tmp;
395         struct hlist_head *head;
396         spinlock_t *list_lock; /* protects write access to the hash lists */
397         uint32_t i;
398 
399         for (i = 0; i < hash->size; i++) {
400                 head = &hash->table[i];
401                 list_lock = &hash->list_locks[i];
402 
403                 spin_lock_bh(list_lock);
404                 hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
405                                           head, hash_entry) {
406                         tt_local_entry = container_of(tt_common_entry,
407                                                       struct tt_local_entry,
408                                                       common);
409                         if (tt_local_entry->common.flags & TT_CLIENT_NOPURGE)
410                                 continue;
411 
412                         /* entry already marked for deletion */
413                         if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
414                                 continue;
415 
416                         if (!has_timed_out(tt_local_entry->last_seen,
417                                            TT_LOCAL_TIMEOUT))
418                                 continue;
419 
420                         tt_local_set_pending(bat_priv, tt_local_entry,
421                                              TT_CLIENT_DEL, "timed out");
422                 }
423                 spin_unlock_bh(list_lock);
424         }
425 
426 }
427 
428 static void tt_local_table_free(struct bat_priv *bat_priv)
429 {
430         struct hashtable_t *hash;
431         spinlock_t *list_lock; /* protects write access to the hash lists */
432         struct tt_common_entry *tt_common_entry;
433         struct tt_local_entry *tt_local_entry;
434         struct hlist_node *node, *node_tmp;
435         struct hlist_head *head;
436         uint32_t i;
437 
438         if (!bat_priv->tt_local_hash)
439                 return;
440 
441         hash = bat_priv->tt_local_hash;
442 
443         for (i = 0; i < hash->size; i++) {
444                 head = &hash->table[i];
445                 list_lock = &hash->list_locks[i];
446 
447                 spin_lock_bh(list_lock);
448                 hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
449                                           head, hash_entry) {
450                         hlist_del_rcu(node);
451                         tt_local_entry = container_of(tt_common_entry,
452                                                       struct tt_local_entry,
453                                                       common);
454                         tt_local_entry_free_ref(tt_local_entry);
455                 }
456                 spin_unlock_bh(list_lock);
457         }
458 
459         hash_destroy(hash);
460 
461         bat_priv->tt_local_hash = NULL;
462 }
463 
464 static int tt_global_init(struct bat_priv *bat_priv)
465 {
466         if (bat_priv->tt_global_hash)
467                 return 1;
468 
469         bat_priv->tt_global_hash = hash_new(1024);
470 
471         if (!bat_priv->tt_global_hash)
472                 return 0;
473 
474         return 1;
475 }
476 
477 static void tt_changes_list_free(struct bat_priv *bat_priv)
478 {
479         struct tt_change_node *entry, *safe;
480 
481         spin_lock_bh(&bat_priv->tt_changes_list_lock);
482 
483         list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
484                                  list) {
485                 list_del(&entry->list);
486                 kfree(entry);
487         }
488 
489         atomic_set(&bat_priv->tt_local_changes, 0);
490         spin_unlock_bh(&bat_priv->tt_changes_list_lock);
491 }
492 
493 /* caller must hold orig_node refcount */
494 int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
495                   const unsigned char *tt_addr, uint8_t ttvn, bool roaming,
496                   bool wifi)
497 {
498         struct tt_global_entry *tt_global_entry;
499         struct orig_node *orig_node_tmp;
500         int ret = 0;
501         int hash_added;
502 
503         tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
504 
505         if (!tt_global_entry) {
506                 tt_global_entry =
507                         kmalloc(sizeof(*tt_global_entry),
508                                 GFP_ATOMIC);
509                 if (!tt_global_entry)
510                         goto out;
511 
512                 memcpy(tt_global_entry->common.addr, tt_addr, ETH_ALEN);
513                 tt_global_entry->common.flags = NO_FLAGS;
514                 atomic_set(&tt_global_entry->common.refcount, 2);
515                 /* Assign the new orig_node */
516                 atomic_inc(&orig_node->refcount);
517                 tt_global_entry->orig_node = orig_node;
518                 tt_global_entry->ttvn = ttvn;
519                 tt_global_entry->roam_at = 0;
520 
521                 hash_added = hash_add(bat_priv->tt_global_hash, compare_tt,
522                                  choose_orig, &tt_global_entry->common,
523                                  &tt_global_entry->common.hash_entry);
524 
525                 if (unlikely(hash_added != 0)) {
526                         /* remove the reference for the hash */
527                         tt_global_entry_free_ref(tt_global_entry);
528                         goto out_remove;
529                 }
530                 atomic_inc(&orig_node->tt_size);
531         } else {
532                 if (tt_global_entry->orig_node != orig_node) {
533                         atomic_dec(&tt_global_entry->orig_node->tt_size);
534                         orig_node_tmp = tt_global_entry->orig_node;
535                         atomic_inc(&orig_node->refcount);
536                         tt_global_entry->orig_node = orig_node;
537                         orig_node_free_ref(orig_node_tmp);
538                         atomic_inc(&orig_node->tt_size);
539                 }
540                 tt_global_entry->common.flags = NO_FLAGS;
541                 tt_global_entry->ttvn = ttvn;
542                 tt_global_entry->roam_at = 0;
543         }
544 
545         if (wifi)
546                 tt_global_entry->common.flags |= TT_CLIENT_WIFI;
547 
548         bat_dbg(DBG_TT, bat_priv,
549                 "Creating new global tt entry: %pM (via %pM)\n",
550                 tt_global_entry->common.addr, orig_node->orig);
551 
552 out_remove:
553         /* remove address from local hash if present */
554         tt_local_remove(bat_priv, tt_global_entry->common.addr,
555                         "global tt received", roaming);
556         ret = 1;
557 out:
558         if (tt_global_entry)
559                 tt_global_entry_free_ref(tt_global_entry);
560         return ret;
561 }
562 
563 int tt_global_seq_print_text(struct seq_file *seq, void *offset)
564 {
565         struct net_device *net_dev = (struct net_device *)seq->private;
566         struct bat_priv *bat_priv = netdev_priv(net_dev);
567         struct hashtable_t *hash = bat_priv->tt_global_hash;
568         struct tt_common_entry *tt_common_entry;
569         struct tt_global_entry *tt_global_entry;
570         struct hard_iface *primary_if;
571         struct hlist_node *node;
572         struct hlist_head *head;
573         uint32_t i;
574         int ret = 0;
575 
576         primary_if = primary_if_get_selected(bat_priv);
577         if (!primary_if) {
578                 ret = seq_printf(seq,
579                                  "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
580                                  net_dev->name);
581                 goto out;
582         }
583 
584         if (primary_if->if_status != IF_ACTIVE) {
585                 ret = seq_printf(seq,
586                                  "BATMAN mesh %s disabled - primary interface not active\n",
587                                  net_dev->name);
588                 goto out;
589         }
590 
591         seq_printf(seq,
592                    "Globally announced TT entries received via the mesh %s\n",
593                    net_dev->name);
594         seq_printf(seq, "       %-13s %s       %-15s %s %s\n",
595                    "Client", "(TTVN)", "Originator", "(Curr TTVN)", "Flags");
596 
597         for (i = 0; i < hash->size; i++) {
598                 head = &hash->table[i];
599 
600                 rcu_read_lock();
601                 hlist_for_each_entry_rcu(tt_common_entry, node,
602                                          head, hash_entry) {
603                         tt_global_entry = container_of(tt_common_entry,
604                                                        struct tt_global_entry,
605                                                        common);
606                         seq_printf(seq,
607                                    " * %pM  (%3u) via %pM     (%3u)   [%c%c]\n",
608                                    tt_global_entry->common.addr,
609                                    tt_global_entry->ttvn,
610                                    tt_global_entry->orig_node->orig,
611                                    (uint8_t) atomic_read(
612                                                 &tt_global_entry->orig_node->
613                                                 last_ttvn),
614                                    (tt_global_entry->common.flags &
615                                     TT_CLIENT_ROAM ? 'R' : '.'),
616                                    (tt_global_entry->common.flags &
617                                     TT_CLIENT_WIFI ? 'W' : '.'));
618                 }
619                 rcu_read_unlock();
620         }
621 out:
622         if (primary_if)
623                 hardif_free_ref(primary_if);
624         return ret;
625 }
626 
627 static void _tt_global_del(struct bat_priv *bat_priv,
628                            struct tt_global_entry *tt_global_entry,
629                            const char *message)
630 {
631         if (!tt_global_entry)
632                 goto out;
633 
634         bat_dbg(DBG_TT, bat_priv,
635                 "Deleting global tt entry %pM (via %pM): %s\n",
636                 tt_global_entry->common.addr, tt_global_entry->orig_node->orig,
637                 message);
638 
639         atomic_dec(&tt_global_entry->orig_node->tt_size);
640 
641         hash_remove(bat_priv->tt_global_hash, compare_tt, choose_orig,
642                     tt_global_entry->common.addr);
643 out:
644         if (tt_global_entry)
645                 tt_global_entry_free_ref(tt_global_entry);
646 }
647 
648 void tt_global_del(struct bat_priv *bat_priv,
649                    struct orig_node *orig_node, const unsigned char *addr,
650                    const char *message, bool roaming)
651 {
652         struct tt_global_entry *tt_global_entry = NULL;
653         struct tt_local_entry *tt_local_entry = NULL;
654 
655         tt_global_entry = tt_global_hash_find(bat_priv, addr);
656         if (!tt_global_entry || tt_global_entry->orig_node != orig_node)
657                 goto out;
658 
659         if (!roaming)
660                 goto out_del;
661 
662         /* if we are deleting a global entry due to a roam
663          * event, there are two possibilities:
664          * 1) the client roamed from node A to node B => we mark
665          *    it with TT_CLIENT_ROAM, we start a timer and we
666          *    wait for node B to claim it. In case of timeout
667          *    the entry is purged.
668          * 2) the client roamed to us => we can directly delete
669          *    the global entry, since it is useless now. */
670         tt_local_entry = tt_local_hash_find(bat_priv,
671                                             tt_global_entry->common.addr);
672         if (!tt_local_entry) {
673                 tt_global_entry->common.flags |= TT_CLIENT_ROAM;
674                 tt_global_entry->roam_at = jiffies;
675                 goto out;
676         }
677 
678 out_del:
679         _tt_global_del(bat_priv, tt_global_entry, message);
680 
681 out:
682         if (tt_global_entry)
683                 tt_global_entry_free_ref(tt_global_entry);
684         if (tt_local_entry)
685                 tt_local_entry_free_ref(tt_local_entry);
686 }
687 
688 void tt_global_del_orig(struct bat_priv *bat_priv,
689                         struct orig_node *orig_node, const char *message)
690 {
691         struct tt_global_entry *tt_global_entry;
692         struct tt_common_entry *tt_common_entry;
693         uint32_t i;
694         struct hashtable_t *hash = bat_priv->tt_global_hash;
695         struct hlist_node *node, *safe;
696         struct hlist_head *head;
697         spinlock_t *list_lock; /* protects write access to the hash lists */
698 
699         if (!hash)
700                 return;
701 
702         for (i = 0; i < hash->size; i++) {
703                 head = &hash->table[i];
704                 list_lock = &hash->list_locks[i];
705 
706                 spin_lock_bh(list_lock);
707                 hlist_for_each_entry_safe(tt_common_entry, node, safe,
708                                           head, hash_entry) {
709                         tt_global_entry = container_of(tt_common_entry,
710                                                        struct tt_global_entry,
711                                                        common);
712                         if (tt_global_entry->orig_node == orig_node) {
713                                 bat_dbg(DBG_TT, bat_priv,
714                                         "Deleting global tt entry %pM (via %pM): %s\n",
715                                         tt_global_entry->common.addr,
716                                         tt_global_entry->orig_node->orig,
717                                         message);
718                                 hlist_del_rcu(node);
719                                 tt_global_entry_free_ref(tt_global_entry);
720                         }
721                 }
722                 spin_unlock_bh(list_lock);
723         }
724         atomic_set(&orig_node->tt_size, 0);
725         orig_node->tt_initialised = false;
726 }
727 
728 static void tt_global_roam_purge(struct bat_priv *bat_priv)
729 {
730         struct hashtable_t *hash = bat_priv->tt_global_hash;
731         struct tt_common_entry *tt_common_entry;
732         struct tt_global_entry *tt_global_entry;
733         struct hlist_node *node, *node_tmp;
734         struct hlist_head *head;
735         spinlock_t *list_lock; /* protects write access to the hash lists */
736         uint32_t i;
737 
738         for (i = 0; i < hash->size; i++) {
739                 head = &hash->table[i];
740                 list_lock = &hash->list_locks[i];
741 
742                 spin_lock_bh(list_lock);
743                 hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
744                                           head, hash_entry) {
745                         tt_global_entry = container_of(tt_common_entry,
746                                                        struct tt_global_entry,
747                                                        common);
748                         if (!(tt_global_entry->common.flags & TT_CLIENT_ROAM))
749                                 continue;
750                         if (!has_timed_out(tt_global_entry->roam_at,
751                                            TT_CLIENT_ROAM_TIMEOUT))
752                                 continue;
753 
754                         bat_dbg(DBG_TT, bat_priv,
755                                 "Deleting global tt entry (%pM): Roaming timeout\n",
756                                 tt_global_entry->common.addr);
757                         atomic_dec(&tt_global_entry->orig_node->tt_size);
758                         hlist_del_rcu(node);
759                         tt_global_entry_free_ref(tt_global_entry);
760                 }
761                 spin_unlock_bh(list_lock);
762         }
763 
764 }
765 
766 static void tt_global_table_free(struct bat_priv *bat_priv)
767 {
768         struct hashtable_t *hash;
769         spinlock_t *list_lock; /* protects write access to the hash lists */
770         struct tt_common_entry *tt_common_entry;
771         struct tt_global_entry *tt_global_entry;
772         struct hlist_node *node, *node_tmp;
773         struct hlist_head *head;
774         uint32_t i;
775 
776         if (!bat_priv->tt_global_hash)
777                 return;
778 
779         hash = bat_priv->tt_global_hash;
780 
781         for (i = 0; i < hash->size; i++) {
782                 head = &hash->table[i];
783                 list_lock = &hash->list_locks[i];
784 
785                 spin_lock_bh(list_lock);
786                 hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
787                                           head, hash_entry) {
788                         hlist_del_rcu(node);
789                         tt_global_entry = container_of(tt_common_entry,
790                                                        struct tt_global_entry,
791                                                        common);
792                         tt_global_entry_free_ref(tt_global_entry);
793                 }
794                 spin_unlock_bh(list_lock);
795         }
796 
797         hash_destroy(hash);
798 
799         bat_priv->tt_global_hash = NULL;
800 }
801 
802 static bool _is_ap_isolated(struct tt_local_entry *tt_local_entry,
803                             struct tt_global_entry *tt_global_entry)
804 {
805         bool ret = false;
806 
807         if (tt_local_entry->common.flags & TT_CLIENT_WIFI &&
808             tt_global_entry->common.flags & TT_CLIENT_WIFI)
809                 ret = true;
810 
811         return ret;
812 }
813 
814 struct orig_node *transtable_search(struct bat_priv *bat_priv,
815                                     const uint8_t *src, const uint8_t *addr)
816 {
817         struct tt_local_entry *tt_local_entry = NULL;
818         struct tt_global_entry *tt_global_entry = NULL;
819         struct orig_node *orig_node = NULL;
820 
821         if (src && atomic_read(&bat_priv->ap_isolation)) {
822                 tt_local_entry = tt_local_hash_find(bat_priv, src);
823                 if (!tt_local_entry)
824                         goto out;
825         }
826 
827         tt_global_entry = tt_global_hash_find(bat_priv, addr);
828         if (!tt_global_entry)
829                 goto out;
830 
831         /* check whether the clients should not communicate due to AP
832          * isolation */
833         if (tt_local_entry && _is_ap_isolated(tt_local_entry, tt_global_entry))
834                 goto out;
835 
836         if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount))
837                 goto out;
838 
839         orig_node = tt_global_entry->orig_node;
840 
841 out:
842         if (tt_global_entry)
843                 tt_global_entry_free_ref(tt_global_entry);
844         if (tt_local_entry)
845                 tt_local_entry_free_ref(tt_local_entry);
846 
847         return orig_node;
848 }
849 
850 /* Calculates the checksum of the local table of a given orig_node */
851 uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node)
852 {
853         uint16_t total = 0, total_one;
854         struct hashtable_t *hash = bat_priv->tt_global_hash;
855         struct tt_common_entry *tt_common_entry;
856         struct tt_global_entry *tt_global_entry;
857         struct hlist_node *node;
858         struct hlist_head *head;
859         uint32_t i;
860         int j;
861 
862         for (i = 0; i < hash->size; i++) {
863                 head = &hash->table[i];
864 
865                 rcu_read_lock();
866                 hlist_for_each_entry_rcu(tt_common_entry, node,
867                                          head, hash_entry) {
868                         tt_global_entry = container_of(tt_common_entry,
869                                                        struct tt_global_entry,
870                                                        common);
871                         if (compare_eth(tt_global_entry->orig_node,
872                                         orig_node)) {
873                                 /* Roaming clients are in the global table for
874                                  * consistency only. They don't have to be
875                                  * taken into account while computing the
876                                  * global crc */
877                                 if (tt_common_entry->flags & TT_CLIENT_ROAM)
878                                         continue;
879                                 total_one = 0;
880                                 for (j = 0; j < ETH_ALEN; j++)
881                                         total_one = crc16_byte(total_one,
882                                                 tt_common_entry->addr[j]);
883                                 total ^= total_one;
884                         }
885                 }
886                 rcu_read_unlock();
887         }
888 
889         return total;
890 }
891 
892 /* Calculates the checksum of the local table */
893 uint16_t tt_local_crc(struct bat_priv *bat_priv)
894 {
895         uint16_t total = 0, total_one;
896         struct hashtable_t *hash = bat_priv->tt_local_hash;
897         struct tt_common_entry *tt_common_entry;
898         struct hlist_node *node;
899         struct hlist_head *head;
900         uint32_t i;
901         int j;
902 
903         for (i = 0; i < hash->size; i++) {
904                 head = &hash->table[i];
905 
906                 rcu_read_lock();
907                 hlist_for_each_entry_rcu(tt_common_entry, node,
908                                          head, hash_entry) {
909                         /* not yet committed clients have not to be taken into
910                          * account while computing the CRC */
911                         if (tt_common_entry->flags & TT_CLIENT_NEW)
912                                 continue;
913                         total_one = 0;
914                         for (j = 0; j < ETH_ALEN; j++)
915                                 total_one = crc16_byte(total_one,
916                                                    tt_common_entry->addr[j]);
917                         total ^= total_one;
918                 }
919                 rcu_read_unlock();
920         }
921 
922         return total;
923 }
924 
925 static void tt_req_list_free(struct bat_priv *bat_priv)
926 {
927         struct tt_req_node *node, *safe;
928 
929         spin_lock_bh(&bat_priv->tt_req_list_lock);
930 
931         list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
932                 list_del(&node->list);
933                 kfree(node);
934         }
935 
936         spin_unlock_bh(&bat_priv->tt_req_list_lock);
937 }
938 
939 void tt_save_orig_buffer(struct bat_priv *bat_priv, struct orig_node *orig_node,
940                          const unsigned char *tt_buff, uint8_t tt_num_changes)
941 {
942         uint16_t tt_buff_len = tt_len(tt_num_changes);
943 
944         /* Replace the old buffer only if I received something in the
945          * last OGM (the OGM could carry no changes) */
946         spin_lock_bh(&orig_node->tt_buff_lock);
947         if (tt_buff_len > 0) {
948                 kfree(orig_node->tt_buff);
949                 orig_node->tt_buff_len = 0;
950                 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
951                 if (orig_node->tt_buff) {
952                         memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
953                         orig_node->tt_buff_len = tt_buff_len;
954                 }
955         }
956         spin_unlock_bh(&orig_node->tt_buff_lock);
957 }
958 
959 static void tt_req_purge(struct bat_priv *bat_priv)
960 {
961         struct tt_req_node *node, *safe;
962 
963         spin_lock_bh(&bat_priv->tt_req_list_lock);
964         list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
965                 if (has_timed_out(node->issued_at, TT_REQUEST_TIMEOUT)) {
966                         list_del(&node->list);
967                         kfree(node);
968                 }
969         }
970         spin_unlock_bh(&bat_priv->tt_req_list_lock);
971 }
972 
973 /* returns the pointer to the new tt_req_node struct if no request
974  * has already been issued for this orig_node, NULL otherwise */
975 static struct tt_req_node *new_tt_req_node(struct bat_priv *bat_priv,
976                                           struct orig_node *orig_node)
977 {
978         struct tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
979 
980         spin_lock_bh(&bat_priv->tt_req_list_lock);
981         list_for_each_entry(tt_req_node_tmp, &bat_priv->tt_req_list, list) {
982                 if (compare_eth(tt_req_node_tmp, orig_node) &&
983                     !has_timed_out(tt_req_node_tmp->issued_at,
984                                    TT_REQUEST_TIMEOUT))
985                         goto unlock;
986         }
987 
988         tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
989         if (!tt_req_node)
990                 goto unlock;
991 
992         memcpy(tt_req_node->addr, orig_node->orig, ETH_ALEN);
993         tt_req_node->issued_at = jiffies;
994 
995         list_add(&tt_req_node->list, &bat_priv->tt_req_list);
996 unlock:
997         spin_unlock_bh(&bat_priv->tt_req_list_lock);
998         return tt_req_node;
999 }
1000 
1001 /* data_ptr is useless here, but has to be kept to respect the prototype */
1002 static int tt_local_valid_entry(const void *entry_ptr, const void *data_ptr)
1003 {
1004         const struct tt_common_entry *tt_common_entry = entry_ptr;
1005 
1006         if (tt_common_entry->flags & TT_CLIENT_NEW)
1007                 return 0;
1008         return 1;
1009 }
1010 
1011 static int tt_global_valid_entry(const void *entry_ptr, const void *data_ptr)
1012 {
1013         const struct tt_common_entry *tt_common_entry = entry_ptr;
1014         const struct tt_global_entry *tt_global_entry;
1015         const struct orig_node *orig_node = data_ptr;
1016 
1017         if (tt_common_entry->flags & TT_CLIENT_ROAM)
1018                 return 0;
1019 
1020         tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
1021                                        common);
1022 
1023         return (tt_global_entry->orig_node == orig_node);
1024 }
1025 
1026 static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
1027                                               struct hashtable_t *hash,
1028                                               struct hard_iface *primary_if,
1029                                               int (*valid_cb)(const void *,
1030                                                               const void *),
1031                                               void *cb_data)
1032 {
1033         struct tt_common_entry *tt_common_entry;
1034         struct tt_query_packet *tt_response;
1035         struct tt_change *tt_change;
1036         struct hlist_node *node;
1037         struct hlist_head *head;
1038         struct sk_buff *skb = NULL;
1039         uint16_t tt_tot, tt_count;
1040         ssize_t tt_query_size = sizeof(struct tt_query_packet);
1041         uint32_t i;
1042 
1043         if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
1044                 tt_len = primary_if->soft_iface->mtu - tt_query_size;
1045                 tt_len -= tt_len % sizeof(struct tt_change);
1046         }
1047         tt_tot = tt_len / sizeof(struct tt_change);
1048 
1049         skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN);
1050         if (!skb)
1051                 goto out;
1052 
1053         skb_reserve(skb, ETH_HLEN);
1054         tt_response = (struct tt_query_packet *)skb_put(skb,
1055                                                      tt_query_size + tt_len);
1056         tt_response->ttvn = ttvn;
1057 
1058         tt_change = (struct tt_change *)(skb->data + tt_query_size);
1059         tt_count = 0;
1060 
1061         rcu_read_lock();
1062         for (i = 0; i < hash->size; i++) {
1063                 head = &hash->table[i];
1064 
1065                 hlist_for_each_entry_rcu(tt_common_entry, node,
1066                                          head, hash_entry) {
1067                         if (tt_count == tt_tot)
1068                                 break;
1069 
1070                         if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
1071                                 continue;
1072 
1073                         memcpy(tt_change->addr, tt_common_entry->addr,
1074                                ETH_ALEN);
1075                         tt_change->flags = NO_FLAGS;
1076 
1077                         tt_count++;
1078                         tt_change++;
1079                 }
1080         }
1081         rcu_read_unlock();
1082 
1083         /* store in the message the number of entries we have successfully
1084          * copied */
1085         tt_response->tt_data = htons(tt_count);
1086 
1087 out:
1088         return skb;
1089 }
1090 
1091 static int send_tt_request(struct bat_priv *bat_priv,
1092                            struct orig_node *dst_orig_node,
1093                            uint8_t ttvn, uint16_t tt_crc, bool full_table)
1094 {
1095         struct sk_buff *skb = NULL;
1096         struct tt_query_packet *tt_request;
1097         struct neigh_node *neigh_node = NULL;
1098         struct hard_iface *primary_if;
1099         struct tt_req_node *tt_req_node = NULL;
1100         int ret = 1;
1101 
1102         primary_if = primary_if_get_selected(bat_priv);
1103         if (!primary_if)
1104                 goto out;
1105 
1106         /* The new tt_req will be issued only if I'm not waiting for a
1107          * reply from the same orig_node yet */
1108         tt_req_node = new_tt_req_node(bat_priv, dst_orig_node);
1109         if (!tt_req_node)
1110                 goto out;
1111 
1112         skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN);
1113         if (!skb)
1114                 goto out;
1115 
1116         skb_reserve(skb, ETH_HLEN);
1117 
1118         tt_request = (struct tt_query_packet *)skb_put(skb,
1119                                 sizeof(struct tt_query_packet));
1120 
1121         tt_request->header.packet_type = BAT_TT_QUERY;
1122         tt_request->header.version = COMPAT_VERSION;
1123         memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1124         memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN);
1125         tt_request->header.ttl = TTL;
1126         tt_request->ttvn = ttvn;
1127         tt_request->tt_data = tt_crc;
1128         tt_request->flags = TT_REQUEST;
1129 
1130         if (full_table)
1131                 tt_request->flags |= TT_FULL_TABLE;
1132 
1133         neigh_node = orig_node_get_router(dst_orig_node);
1134         if (!neigh_node)
1135                 goto out;
1136 
1137         bat_dbg(DBG_TT, bat_priv,
1138                 "Sending TT_REQUEST to %pM via %pM [%c]\n",
1139                 dst_orig_node->orig, neigh_node->addr,
1140                 (full_table ? 'F' : '.'));
1141 
1142         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1143         ret = 0;
1144 
1145 out:
1146         if (neigh_node)
1147                 neigh_node_free_ref(neigh_node);
1148         if (primary_if)
1149                 hardif_free_ref(primary_if);
1150         if (ret)
1151                 kfree_skb(skb);
1152         if (ret && tt_req_node) {
1153                 spin_lock_bh(&bat_priv->tt_req_list_lock);
1154                 list_del(&tt_req_node->list);
1155                 spin_unlock_bh(&bat_priv->tt_req_list_lock);
1156                 kfree(tt_req_node);
1157         }
1158         return ret;
1159 }
1160 
1161 static bool send_other_tt_response(struct bat_priv *bat_priv,
1162                                    struct tt_query_packet *tt_request)
1163 {
1164         struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
1165         struct neigh_node *neigh_node = NULL;
1166         struct hard_iface *primary_if = NULL;
1167         uint8_t orig_ttvn, req_ttvn, ttvn;
1168         int ret = false;
1169         unsigned char *tt_buff;
1170         bool full_table;
1171         uint16_t tt_len, tt_tot;
1172         struct sk_buff *skb = NULL;
1173         struct tt_query_packet *tt_response;
1174 
1175         bat_dbg(DBG_TT, bat_priv,
1176                 "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
1177                 tt_request->src, tt_request->ttvn, tt_request->dst,
1178                 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
1179 
1180         /* Let's get the orig node of the REAL destination */
1181         req_dst_orig_node = orig_hash_find(bat_priv, tt_request->dst);
1182         if (!req_dst_orig_node)
1183                 goto out;
1184 
1185         res_dst_orig_node = orig_hash_find(bat_priv, tt_request->src);
1186         if (!res_dst_orig_node)
1187                 goto out;
1188 
1189         neigh_node = orig_node_get_router(res_dst_orig_node);
1190         if (!neigh_node)
1191                 goto out;
1192 
1193         primary_if = primary_if_get_selected(bat_priv);
1194         if (!primary_if)
1195                 goto out;
1196 
1197         orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
1198         req_ttvn = tt_request->ttvn;
1199 
1200         /* I don't have the requested data */
1201         if (orig_ttvn != req_ttvn ||
1202             tt_request->tt_data != req_dst_orig_node->tt_crc)
1203                 goto out;
1204 
1205         /* If the full table has been explicitly requested */
1206         if (tt_request->flags & TT_FULL_TABLE ||
1207             !req_dst_orig_node->tt_buff)
1208                 full_table = true;
1209         else
1210                 full_table = false;
1211 
1212         /* In this version, fragmentation is not implemented, then
1213          * I'll send only one packet with as much TT entries as I can */
1214         if (!full_table) {
1215                 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
1216                 tt_len = req_dst_orig_node->tt_buff_len;
1217                 tt_tot = tt_len / sizeof(struct tt_change);
1218 
1219                 skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
1220                                     tt_len + ETH_HLEN);
1221                 if (!skb)
1222                         goto unlock;
1223 
1224                 skb_reserve(skb, ETH_HLEN);
1225                 tt_response = (struct tt_query_packet *)skb_put(skb,
1226                                 sizeof(struct tt_query_packet) + tt_len);
1227                 tt_response->ttvn = req_ttvn;
1228                 tt_response->tt_data = htons(tt_tot);
1229 
1230                 tt_buff = skb->data + sizeof(struct tt_query_packet);
1231                 /* Copy the last orig_node's OGM buffer */
1232                 memcpy(tt_buff, req_dst_orig_node->tt_buff,
1233                        req_dst_orig_node->tt_buff_len);
1234 
1235                 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
1236         } else {
1237                 tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) *
1238                                                 sizeof(struct tt_change);
1239                 ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
1240 
1241                 skb = tt_response_fill_table(tt_len, ttvn,
1242                                              bat_priv->tt_global_hash,
1243                                              primary_if, tt_global_valid_entry,
1244                                              req_dst_orig_node);
1245                 if (!skb)
1246                         goto out;
1247 
1248                 tt_response = (struct tt_query_packet *)skb->data;
1249         }
1250 
1251         tt_response->header.packet_type = BAT_TT_QUERY;
1252         tt_response->header.version = COMPAT_VERSION;
1253         tt_response->header.ttl = TTL;
1254         memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN);
1255         memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
1256         tt_response->flags = TT_RESPONSE;
1257 
1258         if (full_table)
1259                 tt_response->flags |= TT_FULL_TABLE;
1260 
1261         bat_dbg(DBG_TT, bat_priv,
1262                 "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
1263                 res_dst_orig_node->orig, neigh_node->addr,
1264                 req_dst_orig_node->orig, req_ttvn);
1265 
1266         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1267         ret = true;
1268         goto out;
1269 
1270 unlock:
1271         spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
1272 
1273 out:
1274         if (res_dst_orig_node)
1275                 orig_node_free_ref(res_dst_orig_node);
1276         if (req_dst_orig_node)
1277                 orig_node_free_ref(req_dst_orig_node);
1278         if (neigh_node)
1279                 neigh_node_free_ref(neigh_node);
1280         if (primary_if)
1281                 hardif_free_ref(primary_if);
1282         if (!ret)
1283                 kfree_skb(skb);
1284         return ret;
1285 
1286 }
1287 static bool send_my_tt_response(struct bat_priv *bat_priv,
1288                                 struct tt_query_packet *tt_request)
1289 {
1290         struct orig_node *orig_node = NULL;
1291         struct neigh_node *neigh_node = NULL;
1292         struct hard_iface *primary_if = NULL;
1293         uint8_t my_ttvn, req_ttvn, ttvn;
1294         int ret = false;
1295         unsigned char *tt_buff;
1296         bool full_table;
1297         uint16_t tt_len, tt_tot;
1298         struct sk_buff *skb = NULL;
1299         struct tt_query_packet *tt_response;
1300 
1301         bat_dbg(DBG_TT, bat_priv,
1302                 "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
1303                 tt_request->src, tt_request->ttvn,
1304                 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
1305 
1306 
1307         my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
1308         req_ttvn = tt_request->ttvn;
1309 
1310         orig_node = orig_hash_find(bat_priv, tt_request->src);
1311         if (!orig_node)
1312                 goto out;
1313 
1314         neigh_node = orig_node_get_router(orig_node);
1315         if (!neigh_node)
1316                 goto out;
1317 
1318         primary_if = primary_if_get_selected(bat_priv);
1319         if (!primary_if)
1320                 goto out;
1321 
1322         /* If the full table has been explicitly requested or the gap
1323          * is too big send the whole local translation table */
1324         if (tt_request->flags & TT_FULL_TABLE || my_ttvn != req_ttvn ||
1325             !bat_priv->tt_buff)
1326                 full_table = true;
1327         else
1328                 full_table = false;
1329 
1330         /* In this version, fragmentation is not implemented, then
1331          * I'll send only one packet with as much TT entries as I can */
1332         if (!full_table) {
1333                 spin_lock_bh(&bat_priv->tt_buff_lock);
1334                 tt_len = bat_priv->tt_buff_len;
1335                 tt_tot = tt_len / sizeof(struct tt_change);
1336 
1337                 skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
1338                                     tt_len + ETH_HLEN);
1339                 if (!skb)
1340                         goto unlock;
1341 
1342                 skb_reserve(skb, ETH_HLEN);
1343                 tt_response = (struct tt_query_packet *)skb_put(skb,
1344                                 sizeof(struct tt_query_packet) + tt_len);
1345                 tt_response->ttvn = req_ttvn;
1346                 tt_response->tt_data = htons(tt_tot);
1347 
1348                 tt_buff = skb->data + sizeof(struct tt_query_packet);
1349                 memcpy(tt_buff, bat_priv->tt_buff,
1350                        bat_priv->tt_buff_len);
1351                 spin_unlock_bh(&bat_priv->tt_buff_lock);
1352         } else {
1353                 tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) *
1354                                                 sizeof(struct tt_change);
1355                 ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
1356 
1357                 skb = tt_response_fill_table(tt_len, ttvn,
1358                                              bat_priv->tt_local_hash,
1359                                              primary_if, tt_local_valid_entry,
1360                                              NULL);
1361                 if (!skb)
1362                         goto out;
1363 
1364                 tt_response = (struct tt_query_packet *)skb->data;
1365         }
1366 
1367         tt_response->header.packet_type = BAT_TT_QUERY;
1368         tt_response->header.version = COMPAT_VERSION;
1369         tt_response->header.ttl = TTL;
1370         memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1371         memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
1372         tt_response->flags = TT_RESPONSE;
1373 
1374         if (full_table)
1375                 tt_response->flags |= TT_FULL_TABLE;
1376 
1377         bat_dbg(DBG_TT, bat_priv,
1378                 "Sending TT_RESPONSE to %pM via %pM [%c]\n",
1379                 orig_node->orig, neigh_node->addr,
1380                 (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
1381 
1382         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1383         ret = true;
1384         goto out;
1385 
1386 unlock:
1387         spin_unlock_bh(&bat_priv->tt_buff_lock);
1388 out:
1389         if (orig_node)
1390                 orig_node_free_ref(orig_node);
1391         if (neigh_node)
1392                 neigh_node_free_ref(neigh_node);
1393         if (primary_if)
1394                 hardif_free_ref(primary_if);
1395         if (!ret)
1396                 kfree_skb(skb);
1397         /* This packet was for me, so it doesn't need to be re-routed */
1398         return true;
1399 }
1400 
1401 bool send_tt_response(struct bat_priv *bat_priv,
1402                       struct tt_query_packet *tt_request)
1403 {
1404         if (is_my_mac(tt_request->dst))
1405                 return send_my_tt_response(bat_priv, tt_request);
1406         else
1407                 return send_other_tt_response(bat_priv, tt_request);
1408 }
1409 
1410 static void _tt_update_changes(struct bat_priv *bat_priv,
1411                                struct orig_node *orig_node,
1412                                struct tt_change *tt_change,
1413                                uint16_t tt_num_changes, uint8_t ttvn)
1414 {
1415         int i;
1416 
1417         for (i = 0; i < tt_num_changes; i++) {
1418                 if ((tt_change + i)->flags & TT_CLIENT_DEL)
1419                         tt_global_del(bat_priv, orig_node,
1420                                       (tt_change + i)->addr,
1421                                       "tt removed by changes",
1422                                       (tt_change + i)->flags & TT_CLIENT_ROAM);
1423                 else
1424                         if (!tt_global_add(bat_priv, orig_node,
1425                                            (tt_change + i)->addr, ttvn, false,
1426                                            (tt_change + i)->flags &
1427                                                         TT_CLIENT_WIFI))
1428                                 /* In case of problem while storing a
1429                                  * global_entry, we stop the updating
1430                                  * procedure without committing the
1431                                  * ttvn change. This will avoid to send
1432                                  * corrupted data on tt_request
1433                                  */
1434                                 return;
1435         }
1436         orig_node->tt_initialised = true;
1437 }
1438 
1439 static void tt_fill_gtable(struct bat_priv *bat_priv,
1440                            struct tt_query_packet *tt_response)
1441 {
1442         struct orig_node *orig_node = NULL;
1443 
1444         orig_node = orig_hash_find(bat_priv, tt_response->src);
1445         if (!orig_node)
1446                 goto out;
1447 
1448         /* Purge the old table first.. */
1449         tt_global_del_orig(bat_priv, orig_node, "Received full table");
1450 
1451         _tt_update_changes(bat_priv, orig_node,
1452                            (struct tt_change *)(tt_response + 1),
1453                            tt_response->tt_data, tt_response->ttvn);
1454 
1455         spin_lock_bh(&orig_node->tt_buff_lock);
1456         kfree(orig_node->tt_buff);
1457         orig_node->tt_buff_len = 0;
1458         orig_node->tt_buff = NULL;
1459         spin_unlock_bh(&orig_node->tt_buff_lock);
1460 
1461         atomic_set(&orig_node->last_ttvn, tt_response->ttvn);
1462 
1463 out:
1464         if (orig_node)
1465                 orig_node_free_ref(orig_node);
1466 }
1467 
1468 static void tt_update_changes(struct bat_priv *bat_priv,
1469                               struct orig_node *orig_node,
1470                               uint16_t tt_num_changes, uint8_t ttvn,
1471                               struct tt_change *tt_change)
1472 {
1473         _tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes,
1474                            ttvn);
1475 
1476         tt_save_orig_buffer(bat_priv, orig_node, (unsigned char *)tt_change,
1477                             tt_num_changes);
1478         atomic_set(&orig_node->last_ttvn, ttvn);
1479 }
1480 
1481 bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr)
1482 {
1483         struct tt_local_entry *tt_local_entry = NULL;
1484         bool ret = false;
1485 
1486         tt_local_entry = tt_local_hash_find(bat_priv, addr);
1487         if (!tt_local_entry)
1488                 goto out;
1489         /* Check if the client has been logically deleted (but is kept for
1490          * consistency purpose) */
1491         if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
1492                 goto out;
1493         ret = true;
1494 out:
1495         if (tt_local_entry)
1496                 tt_local_entry_free_ref(tt_local_entry);
1497         return ret;
1498 }
1499 
1500 void handle_tt_response(struct bat_priv *bat_priv,
1501                         struct tt_query_packet *tt_response)
1502 {
1503         struct tt_req_node *node, *safe;
1504         struct orig_node *orig_node = NULL;
1505 
1506         bat_dbg(DBG_TT, bat_priv,
1507                 "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
1508                 tt_response->src, tt_response->ttvn, tt_response->tt_data,
1509                 (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
1510 
1511         orig_node = orig_hash_find(bat_priv, tt_response->src);
1512         if (!orig_node)
1513                 goto out;
1514 
1515         if (tt_response->flags & TT_FULL_TABLE)
1516                 tt_fill_gtable(bat_priv, tt_response);
1517         else
1518                 tt_update_changes(bat_priv, orig_node, tt_response->tt_data,
1519                                   tt_response->ttvn,
1520                                   (struct tt_change *)(tt_response + 1));
1521 
1522         /* Delete the tt_req_node from pending tt_requests list */
1523         spin_lock_bh(&bat_priv->tt_req_list_lock);
1524         list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
1525                 if (!compare_eth(node->addr, tt_response->src))
1526                         continue;
1527                 list_del(&node->list);
1528                 kfree(node);
1529         }
1530         spin_unlock_bh(&bat_priv->tt_req_list_lock);
1531 
1532         /* Recalculate the CRC for this orig_node and store it */
1533         orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
1534         /* Roaming phase is over: tables are in sync again. I can
1535          * unset the flag */
1536         orig_node->tt_poss_change = false;
1537 out:
1538         if (orig_node)
1539                 orig_node_free_ref(orig_node);
1540 }
1541 
1542 int tt_init(struct bat_priv *bat_priv)
1543 {
1544         if (!tt_local_init(bat_priv))
1545                 return 0;
1546 
1547         if (!tt_global_init(bat_priv))
1548                 return 0;
1549 
1550         tt_start_timer(bat_priv);
1551 
1552         return 1;
1553 }
1554 
1555 static void tt_roam_list_free(struct bat_priv *bat_priv)
1556 {
1557         struct tt_roam_node *node, *safe;
1558 
1559         spin_lock_bh(&bat_priv->tt_roam_list_lock);
1560 
1561         list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
1562                 list_del(&node->list);
1563                 kfree(node);
1564         }
1565 
1566         spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1567 }
1568 
1569 static void tt_roam_purge(struct bat_priv *bat_priv)
1570 {
1571         struct tt_roam_node *node, *safe;
1572 
1573         spin_lock_bh(&bat_priv->tt_roam_list_lock);
1574         list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
1575                 if (!has_timed_out(node->first_time, ROAMING_MAX_TIME))
1576                         continue;
1577 
1578                 list_del(&node->list);
1579                 kfree(node);
1580         }
1581         spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1582 }
1583 
1584 /* This function checks whether the client already reached the
1585  * maximum number of possible roaming phases. In this case the ROAMING_ADV
1586  * will not be sent.
1587  *
1588  * returns true if the ROAMING_ADV can be sent, false otherwise */
1589 static bool tt_check_roam_count(struct bat_priv *bat_priv,
1590                                 uint8_t *client)
1591 {
1592         struct tt_roam_node *tt_roam_node;
1593         bool ret = false;
1594 
1595         spin_lock_bh(&bat_priv->tt_roam_list_lock);
1596         /* The new tt_req will be issued only if I'm not waiting for a
1597          * reply from the same orig_node yet */
1598         list_for_each_entry(tt_roam_node, &bat_priv->tt_roam_list, list) {
1599                 if (!compare_eth(tt_roam_node->addr, client))
1600                         continue;
1601 
1602                 if (has_timed_out(tt_roam_node->first_time, ROAMING_MAX_TIME))
1603                         continue;
1604 
1605                 if (!atomic_dec_not_zero(&tt_roam_node->counter))
1606                         /* Sorry, you roamed too many times! */
1607                         goto unlock;
1608                 ret = true;
1609                 break;
1610         }
1611 
1612         if (!ret) {
1613                 tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
1614                 if (!tt_roam_node)
1615                         goto unlock;
1616 
1617                 tt_roam_node->first_time = jiffies;
1618                 atomic_set(&tt_roam_node->counter, ROAMING_MAX_COUNT - 1);
1619                 memcpy(tt_roam_node->addr, client, ETH_ALEN);
1620 
1621                 list_add(&tt_roam_node->list, &bat_priv->tt_roam_list);
1622                 ret = true;
1623         }
1624 
1625 unlock:
1626         spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1627         return ret;
1628 }
1629 
1630 void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
1631                    struct orig_node *orig_node)
1632 {
1633         struct neigh_node *neigh_node = NULL;
1634         struct sk_buff *skb = NULL;
1635         struct roam_adv_packet *roam_adv_packet;
1636         int ret = 1;
1637         struct hard_iface *primary_if;
1638 
1639         /* before going on we have to check whether the client has
1640          * already roamed to us too many times */
1641         if (!tt_check_roam_count(bat_priv, client))
1642                 goto out;
1643 
1644         skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN);
1645         if (!skb)
1646                 goto out;
1647 
1648         skb_reserve(skb, ETH_HLEN);
1649 
1650         roam_adv_packet = (struct roam_adv_packet *)skb_put(skb,
1651                                         sizeof(struct roam_adv_packet));
1652 
1653         roam_adv_packet->header.packet_type = BAT_ROAM_ADV;
1654         roam_adv_packet->header.version = COMPAT_VERSION;
1655         roam_adv_packet->header.ttl = TTL;
1656         primary_if = primary_if_get_selected(bat_priv);
1657         if (!primary_if)
1658                 goto out;
1659         memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1660         hardif_free_ref(primary_if);
1661         memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN);
1662         memcpy(roam_adv_packet->client, client, ETH_ALEN);
1663 
1664         neigh_node = orig_node_get_router(orig_node);
1665         if (!neigh_node)
1666                 goto out;
1667 
1668         bat_dbg(DBG_TT, bat_priv,
1669                 "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
1670                 orig_node->orig, client, neigh_node->addr);
1671 
1672         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1673         ret = 0;
1674 
1675 out:
1676         if (neigh_node)
1677                 neigh_node_free_ref(neigh_node);
1678         if (ret)
1679                 kfree_skb(skb);
1680         return;
1681 }
1682 
1683 static void tt_purge(struct work_struct *work)
1684 {
1685         struct delayed_work *delayed_work =
1686                 container_of(work, struct delayed_work, work);
1687         struct bat_priv *bat_priv =
1688                 container_of(delayed_work, struct bat_priv, tt_work);
1689 
1690         tt_local_purge(bat_priv);
1691         tt_global_roam_purge(bat_priv);
1692         tt_req_purge(bat_priv);
1693         tt_roam_purge(bat_priv);
1694 
1695         tt_start_timer(bat_priv);
1696 }
1697 
1698 void tt_free(struct bat_priv *bat_priv)
1699 {
1700         cancel_delayed_work_sync(&bat_priv->tt_work);
1701 
1702         tt_local_table_free(bat_priv);
1703         tt_global_table_free(bat_priv);
1704         tt_req_list_free(bat_priv);
1705         tt_changes_list_free(bat_priv);
1706         tt_roam_list_free(bat_priv);
1707 
1708         kfree(bat_priv->tt_buff);
1709 }
1710 
1711 /* This function will enable or disable the specified flags for all the entries
1712  * in the given hash table and returns the number of modified entries */
1713 static uint16_t tt_set_flags(struct hashtable_t *hash, uint16_t flags,
1714                              bool enable)
1715 {
1716         uint32_t i;
1717         uint16_t changed_num = 0;
1718         struct hlist_head *head;
1719         struct hlist_node *node;
1720         struct tt_common_entry *tt_common_entry;
1721 
1722         if (!hash)
1723                 goto out;
1724 
1725         for (i = 0; i < hash->size; i++) {
1726                 head = &hash->table[i];
1727 
1728                 rcu_read_lock();
1729                 hlist_for_each_entry_rcu(tt_common_entry, node,
1730                                          head, hash_entry) {
1731                         if (enable) {
1732                                 if ((tt_common_entry->flags & flags) == flags)
1733                                         continue;
1734                                 tt_common_entry->flags |= flags;
1735                         } else {
1736                                 if (!(tt_common_entry->flags & flags))
1737                                         continue;
1738                                 tt_common_entry->flags &= ~flags;
1739                         }
1740                         changed_num++;
1741                 }
1742                 rcu_read_unlock();
1743         }
1744 out:
1745         return changed_num;
1746 }
1747 
1748 /* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
1749 static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
1750 {
1751         struct hashtable_t *hash = bat_priv->tt_local_hash;
1752         struct tt_common_entry *tt_common_entry;
1753         struct tt_local_entry *tt_local_entry;
1754         struct hlist_node *node, *node_tmp;
1755         struct hlist_head *head;
1756         spinlock_t *list_lock; /* protects write access to the hash lists */
1757         uint32_t i;
1758 
1759         if (!hash)
1760                 return;
1761 
1762         for (i = 0; i < hash->size; i++) {
1763                 head = &hash->table[i];
1764                 list_lock = &hash->list_locks[i];
1765 
1766                 spin_lock_bh(list_lock);
1767                 hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
1768                                           head, hash_entry) {
1769                         if (!(tt_common_entry->flags & TT_CLIENT_PENDING))
1770                                 continue;
1771 
1772                         bat_dbg(DBG_TT, bat_priv,
1773                                 "Deleting local tt entry (%pM): pending\n",
1774                                 tt_common_entry->addr);
1775 
1776                         atomic_dec(&bat_priv->num_local_tt);
1777                         hlist_del_rcu(node);
1778                         tt_local_entry = container_of(tt_common_entry,
1779                                                       struct tt_local_entry,
1780                                                       common);
1781                         tt_local_entry_free_ref(tt_local_entry);
1782                 }
1783                 spin_unlock_bh(list_lock);
1784         }
1785 
1786 }
1787 
1788 void tt_commit_changes(struct bat_priv *bat_priv)
1789 {
1790         uint16_t changed_num = tt_set_flags(bat_priv->tt_local_hash,
1791                                             TT_CLIENT_NEW, false);
1792         /* all the reset entries have now to be effectively counted as local
1793          * entries */
1794         atomic_add(changed_num, &bat_priv->num_local_tt);
1795         tt_local_purge_pending_clients(bat_priv);
1796 
1797         /* Increment the TTVN only once per OGM interval */
1798         atomic_inc(&bat_priv->ttvn);
1799         bat_priv->tt_poss_change = false;
1800 }
1801 
1802 bool is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, uint8_t *dst)
1803 {
1804         struct tt_local_entry *tt_local_entry = NULL;
1805         struct tt_global_entry *tt_global_entry = NULL;
1806         bool ret = false;
1807 
1808         if (!atomic_read(&bat_priv->ap_isolation))
1809                 goto out;
1810 
1811         tt_local_entry = tt_local_hash_find(bat_priv, dst);
1812         if (!tt_local_entry)
1813                 goto out;
1814 
1815         tt_global_entry = tt_global_hash_find(bat_priv, src);
1816         if (!tt_global_entry)
1817                 goto out;
1818 
1819         if (!_is_ap_isolated(tt_local_entry, tt_global_entry))
1820                 goto out;
1821 
1822         ret = true;
1823 
1824 out:
1825         if (tt_global_entry)
1826                 tt_global_entry_free_ref(tt_global_entry);
1827         if (tt_local_entry)
1828                 tt_local_entry_free_ref(tt_local_entry);
1829         return ret;
1830 }
1831 
1832 void tt_update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
1833                     const unsigned char *tt_buff, uint8_t tt_num_changes,
1834                     uint8_t ttvn, uint16_t tt_crc)
1835 {
1836         uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
1837         bool full_table = true;
1838 
1839         /* orig table not initialised AND first diff is in the OGM OR the ttvn
1840          * increased by one -> we can apply the attached changes */
1841         if ((!orig_node->tt_initialised && ttvn == 1) ||
1842             ttvn - orig_ttvn == 1) {
1843                 /* the OGM could not contain the changes due to their size or
1844                  * because they have already been sent TT_OGM_APPEND_MAX times.
1845                  * In this case send a tt request */
1846                 if (!tt_num_changes) {
1847                         full_table = false;
1848                         goto request_table;
1849                 }
1850 
1851                 tt_update_changes(bat_priv, orig_node, tt_num_changes, ttvn,
1852                                   (struct tt_change *)tt_buff);
1853 
1854                 /* Even if we received the precomputed crc with the OGM, we
1855                  * prefer to recompute it to spot any possible inconsistency
1856                  * in the global table */
1857                 orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
1858 
1859                 /* The ttvn alone is not enough to guarantee consistency
1860                  * because a single value could represent different states
1861                  * (due to the wrap around). Thus a node has to check whether
1862                  * the resulting table (after applying the changes) is still
1863                  * consistent or not. E.g. a node could disconnect while its
1864                  * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
1865                  * checking the CRC value is mandatory to detect the
1866                  * inconsistency */
1867                 if (orig_node->tt_crc != tt_crc)
1868                         goto request_table;
1869 
1870                 /* Roaming phase is over: tables are in sync again. I can
1871                  * unset the flag */
1872                 orig_node->tt_poss_change = false;
1873         } else {
1874                 /* if we missed more than one change or our tables are not
1875                  * in sync anymore -> request fresh tt data */
1876                 if (!orig_node->tt_initialised || ttvn != orig_ttvn ||
1877                     orig_node->tt_crc != tt_crc) {
1878 request_table:
1879                         bat_dbg(DBG_TT, bat_priv,
1880                                 "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u crc: %u last_crc: %u num_changes: %u)\n",
1881                                 orig_node->orig, ttvn, orig_ttvn, tt_crc,
1882                                 orig_node->tt_crc, tt_num_changes);
1883                         send_tt_request(bat_priv, orig_node, ttvn, tt_crc,
1884                                         full_table);
1885                         return;
1886                 }
1887         }
1888 }
1889 

~ [ 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