aboutsummaryrefslogtreecommitdiffstats
path: root/net/batman-adv/translation-table.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/batman-adv/translation-table.c')
-rw-r--r--net/batman-adv/translation-table.c417
1 files changed, 209 insertions, 208 deletions
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index f931830d630e..7b729660cbfd 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -26,40 +26,40 @@
26#include "hash.h" 26#include "hash.h"
27#include "originator.h" 27#include "originator.h"
28 28
29static void hna_local_purge(struct work_struct *work); 29static void tt_local_purge(struct work_struct *work);
30static void _hna_global_del_orig(struct bat_priv *bat_priv, 30static void _tt_global_del_orig(struct bat_priv *bat_priv,
31 struct hna_global_entry *hna_global_entry, 31 struct tt_global_entry *tt_global_entry,
32 char *message); 32 char *message);
33 33
34/* returns 1 if they are the same mac addr */ 34/* returns 1 if they are the same mac addr */
35static int compare_lhna(struct hlist_node *node, void *data2) 35static int compare_ltt(struct hlist_node *node, void *data2)
36{ 36{
37 void *data1 = container_of(node, struct hna_local_entry, hash_entry); 37 void *data1 = container_of(node, struct tt_local_entry, hash_entry);
38 38
39 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0); 39 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
40} 40}
41 41
42/* returns 1 if they are the same mac addr */ 42/* returns 1 if they are the same mac addr */
43static int compare_ghna(struct hlist_node *node, void *data2) 43static int compare_gtt(struct hlist_node *node, void *data2)
44{ 44{
45 void *data1 = container_of(node, struct hna_global_entry, hash_entry); 45 void *data1 = container_of(node, struct tt_global_entry, hash_entry);
46 46
47 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0); 47 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
48} 48}
49 49
50static void hna_local_start_timer(struct bat_priv *bat_priv) 50static void tt_local_start_timer(struct bat_priv *bat_priv)
51{ 51{
52 INIT_DELAYED_WORK(&bat_priv->hna_work, hna_local_purge); 52 INIT_DELAYED_WORK(&bat_priv->tt_work, tt_local_purge);
53 queue_delayed_work(bat_event_workqueue, &bat_priv->hna_work, 10 * HZ); 53 queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work, 10 * HZ);
54} 54}
55 55
56static struct hna_local_entry *hna_local_hash_find(struct bat_priv *bat_priv, 56static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
57 void *data) 57 void *data)
58{ 58{
59 struct hashtable_t *hash = bat_priv->hna_local_hash; 59 struct hashtable_t *hash = bat_priv->tt_local_hash;
60 struct hlist_head *head; 60 struct hlist_head *head;
61 struct hlist_node *node; 61 struct hlist_node *node;
62 struct hna_local_entry *hna_local_entry, *hna_local_entry_tmp = NULL; 62 struct tt_local_entry *tt_local_entry, *tt_local_entry_tmp = NULL;
63 int index; 63 int index;
64 64
65 if (!hash) 65 if (!hash)
@@ -69,26 +69,26 @@ static struct hna_local_entry *hna_local_hash_find(struct bat_priv *bat_priv,
69 head = &hash->table[index]; 69 head = &hash->table[index];
70 70
71 rcu_read_lock(); 71 rcu_read_lock();
72 hlist_for_each_entry_rcu(hna_local_entry, node, head, hash_entry) { 72 hlist_for_each_entry_rcu(tt_local_entry, node, head, hash_entry) {
73 if (!compare_eth(hna_local_entry, data)) 73 if (!compare_eth(tt_local_entry, data))
74 continue; 74 continue;
75 75
76 hna_local_entry_tmp = hna_local_entry; 76 tt_local_entry_tmp = tt_local_entry;
77 break; 77 break;
78 } 78 }
79 rcu_read_unlock(); 79 rcu_read_unlock();
80 80
81 return hna_local_entry_tmp; 81 return tt_local_entry_tmp;
82} 82}
83 83
84static struct hna_global_entry *hna_global_hash_find(struct bat_priv *bat_priv, 84static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
85 void *data) 85 void *data)
86{ 86{
87 struct hashtable_t *hash = bat_priv->hna_global_hash; 87 struct hashtable_t *hash = bat_priv->tt_global_hash;
88 struct hlist_head *head; 88 struct hlist_head *head;
89 struct hlist_node *node; 89 struct hlist_node *node;
90 struct hna_global_entry *hna_global_entry; 90 struct tt_global_entry *tt_global_entry;
91 struct hna_global_entry *hna_global_entry_tmp = NULL; 91 struct tt_global_entry *tt_global_entry_tmp = NULL;
92 int index; 92 int index;
93 93
94 if (!hash) 94 if (!hash)
@@ -98,125 +98,125 @@ static struct hna_global_entry *hna_global_hash_find(struct bat_priv *bat_priv,
98 head = &hash->table[index]; 98 head = &hash->table[index];
99 99
100 rcu_read_lock(); 100 rcu_read_lock();
101 hlist_for_each_entry_rcu(hna_global_entry, node, head, hash_entry) { 101 hlist_for_each_entry_rcu(tt_global_entry, node, head, hash_entry) {
102 if (!compare_eth(hna_global_entry, data)) 102 if (!compare_eth(tt_global_entry, data))
103 continue; 103 continue;
104 104
105 hna_global_entry_tmp = hna_global_entry; 105 tt_global_entry_tmp = tt_global_entry;
106 break; 106 break;
107 } 107 }
108 rcu_read_unlock(); 108 rcu_read_unlock();
109 109
110 return hna_global_entry_tmp; 110 return tt_global_entry_tmp;
111} 111}
112 112
113int hna_local_init(struct bat_priv *bat_priv) 113int tt_local_init(struct bat_priv *bat_priv)
114{ 114{
115 if (bat_priv->hna_local_hash) 115 if (bat_priv->tt_local_hash)
116 return 1; 116 return 1;
117 117
118 bat_priv->hna_local_hash = hash_new(1024); 118 bat_priv->tt_local_hash = hash_new(1024);
119 119
120 if (!bat_priv->hna_local_hash) 120 if (!bat_priv->tt_local_hash)
121 return 0; 121 return 0;
122 122
123 atomic_set(&bat_priv->hna_local_changed, 0); 123 atomic_set(&bat_priv->tt_local_changed, 0);
124 hna_local_start_timer(bat_priv); 124 tt_local_start_timer(bat_priv);
125 125
126 return 1; 126 return 1;
127} 127}
128 128
129void hna_local_add(struct net_device *soft_iface, uint8_t *addr) 129void tt_local_add(struct net_device *soft_iface, uint8_t *addr)
130{ 130{
131 struct bat_priv *bat_priv = netdev_priv(soft_iface); 131 struct bat_priv *bat_priv = netdev_priv(soft_iface);
132 struct hna_local_entry *hna_local_entry; 132 struct tt_local_entry *tt_local_entry;
133 struct hna_global_entry *hna_global_entry; 133 struct tt_global_entry *tt_global_entry;
134 int required_bytes; 134 int required_bytes;
135 135
136 spin_lock_bh(&bat_priv->hna_lhash_lock); 136 spin_lock_bh(&bat_priv->tt_lhash_lock);
137 hna_local_entry = hna_local_hash_find(bat_priv, addr); 137 tt_local_entry = tt_local_hash_find(bat_priv, addr);
138 spin_unlock_bh(&bat_priv->hna_lhash_lock); 138 spin_unlock_bh(&bat_priv->tt_lhash_lock);
139 139
140 if (hna_local_entry) { 140 if (tt_local_entry) {
141 hna_local_entry->last_seen = jiffies; 141 tt_local_entry->last_seen = jiffies;
142 return; 142 return;
143 } 143 }
144 144
145 /* only announce as many hosts as possible in the batman-packet and 145 /* only announce as many hosts as possible in the batman-packet and
146 space in batman_packet->num_hna That also should give a limit to 146 space in batman_packet->num_tt That also should give a limit to
147 MAC-flooding. */ 147 MAC-flooding. */
148 required_bytes = (bat_priv->num_local_hna + 1) * ETH_ALEN; 148 required_bytes = (bat_priv->num_local_tt + 1) * ETH_ALEN;
149 required_bytes += BAT_PACKET_LEN; 149 required_bytes += BAT_PACKET_LEN;
150 150
151 if ((required_bytes > ETH_DATA_LEN) || 151 if ((required_bytes > ETH_DATA_LEN) ||
152 (atomic_read(&bat_priv->aggregated_ogms) && 152 (atomic_read(&bat_priv->aggregated_ogms) &&
153 required_bytes > MAX_AGGREGATION_BYTES) || 153 required_bytes > MAX_AGGREGATION_BYTES) ||
154 (bat_priv->num_local_hna + 1 > 255)) { 154 (bat_priv->num_local_tt + 1 > 255)) {
155 bat_dbg(DBG_ROUTES, bat_priv, 155 bat_dbg(DBG_ROUTES, bat_priv,
156 "Can't add new local hna entry (%pM): " 156 "Can't add new local tt entry (%pM): "
157 "number of local hna entries exceeds packet size\n", 157 "number of local tt entries exceeds packet size\n",
158 addr); 158 addr);
159 return; 159 return;
160 } 160 }
161 161
162 bat_dbg(DBG_ROUTES, bat_priv, 162 bat_dbg(DBG_ROUTES, bat_priv,
163 "Creating new local hna entry: %pM\n", addr); 163 "Creating new local tt entry: %pM\n", addr);
164 164
165 hna_local_entry = kmalloc(sizeof(struct hna_local_entry), GFP_ATOMIC); 165 tt_local_entry = kmalloc(sizeof(struct tt_local_entry), GFP_ATOMIC);
166 if (!hna_local_entry) 166 if (!tt_local_entry)
167 return; 167 return;
168 168
169 memcpy(hna_local_entry->addr, addr, ETH_ALEN); 169 memcpy(tt_local_entry->addr, addr, ETH_ALEN);
170 hna_local_entry->last_seen = jiffies; 170 tt_local_entry->last_seen = jiffies;
171 171
172 /* the batman interface mac address should never be purged */ 172 /* the batman interface mac address should never be purged */
173 if (compare_eth(addr, soft_iface->dev_addr)) 173 if (compare_eth(addr, soft_iface->dev_addr))
174 hna_local_entry->never_purge = 1; 174 tt_local_entry->never_purge = 1;
175 else 175 else
176 hna_local_entry->never_purge = 0; 176 tt_local_entry->never_purge = 0;
177 177
178 spin_lock_bh(&bat_priv->hna_lhash_lock); 178 spin_lock_bh(&bat_priv->tt_lhash_lock);
179 179
180 hash_add(bat_priv->hna_local_hash, compare_lhna, choose_orig, 180 hash_add(bat_priv->tt_local_hash, compare_ltt, choose_orig,
181 hna_local_entry, &hna_local_entry->hash_entry); 181 tt_local_entry, &tt_local_entry->hash_entry);
182 bat_priv->num_local_hna++; 182 bat_priv->num_local_tt++;
183 atomic_set(&bat_priv->hna_local_changed, 1); 183 atomic_set(&bat_priv->tt_local_changed, 1);
184 184
185 spin_unlock_bh(&bat_priv->hna_lhash_lock); 185 spin_unlock_bh(&bat_priv->tt_lhash_lock);
186 186
187 /* remove address from global hash if present */ 187 /* remove address from global hash if present */
188 spin_lock_bh(&bat_priv->hna_ghash_lock); 188 spin_lock_bh(&bat_priv->tt_ghash_lock);
189 189
190 hna_global_entry = hna_global_hash_find(bat_priv, addr); 190 tt_global_entry = tt_global_hash_find(bat_priv, addr);
191 191
192 if (hna_global_entry) 192 if (tt_global_entry)
193 _hna_global_del_orig(bat_priv, hna_global_entry, 193 _tt_global_del_orig(bat_priv, tt_global_entry,
194 "local hna received"); 194 "local tt received");
195 195
196 spin_unlock_bh(&bat_priv->hna_ghash_lock); 196 spin_unlock_bh(&bat_priv->tt_ghash_lock);
197} 197}
198 198
199int hna_local_fill_buffer(struct bat_priv *bat_priv, 199int tt_local_fill_buffer(struct bat_priv *bat_priv,
200 unsigned char *buff, int buff_len) 200 unsigned char *buff, int buff_len)
201{ 201{
202 struct hashtable_t *hash = bat_priv->hna_local_hash; 202 struct hashtable_t *hash = bat_priv->tt_local_hash;
203 struct hna_local_entry *hna_local_entry; 203 struct tt_local_entry *tt_local_entry;
204 struct hlist_node *node; 204 struct hlist_node *node;
205 struct hlist_head *head; 205 struct hlist_head *head;
206 int i, count = 0; 206 int i, count = 0;
207 207
208 spin_lock_bh(&bat_priv->hna_lhash_lock); 208 spin_lock_bh(&bat_priv->tt_lhash_lock);
209 209
210 for (i = 0; i < hash->size; i++) { 210 for (i = 0; i < hash->size; i++) {
211 head = &hash->table[i]; 211 head = &hash->table[i];
212 212
213 rcu_read_lock(); 213 rcu_read_lock();
214 hlist_for_each_entry_rcu(hna_local_entry, node, 214 hlist_for_each_entry_rcu(tt_local_entry, node,
215 head, hash_entry) { 215 head, hash_entry) {
216 if (buff_len < (count + 1) * ETH_ALEN) 216 if (buff_len < (count + 1) * ETH_ALEN)
217 break; 217 break;
218 218
219 memcpy(buff + (count * ETH_ALEN), hna_local_entry->addr, 219 memcpy(buff + (count * ETH_ALEN), tt_local_entry->addr,
220 ETH_ALEN); 220 ETH_ALEN);
221 221
222 count++; 222 count++;
@@ -224,20 +224,20 @@ int hna_local_fill_buffer(struct bat_priv *bat_priv,
224 rcu_read_unlock(); 224 rcu_read_unlock();
225 } 225 }
226 226
227 /* if we did not get all new local hnas see you next time ;-) */ 227 /* if we did not get all new local tts see you next time ;-) */
228 if (count == bat_priv->num_local_hna) 228 if (count == bat_priv->num_local_tt)
229 atomic_set(&bat_priv->hna_local_changed, 0); 229 atomic_set(&bat_priv->tt_local_changed, 0);
230 230
231 spin_unlock_bh(&bat_priv->hna_lhash_lock); 231 spin_unlock_bh(&bat_priv->tt_lhash_lock);
232 return count; 232 return count;
233} 233}
234 234
235int hna_local_seq_print_text(struct seq_file *seq, void *offset) 235int tt_local_seq_print_text(struct seq_file *seq, void *offset)
236{ 236{
237 struct net_device *net_dev = (struct net_device *)seq->private; 237 struct net_device *net_dev = (struct net_device *)seq->private;
238 struct bat_priv *bat_priv = netdev_priv(net_dev); 238 struct bat_priv *bat_priv = netdev_priv(net_dev);
239 struct hashtable_t *hash = bat_priv->hna_local_hash; 239 struct hashtable_t *hash = bat_priv->tt_local_hash;
240 struct hna_local_entry *hna_local_entry; 240 struct tt_local_entry *tt_local_entry;
241 struct hard_iface *primary_if; 241 struct hard_iface *primary_if;
242 struct hlist_node *node; 242 struct hlist_node *node;
243 struct hlist_head *head; 243 struct hlist_head *head;
@@ -261,10 +261,10 @@ int hna_local_seq_print_text(struct seq_file *seq, void *offset)
261 } 261 }
262 262
263 seq_printf(seq, "Locally retrieved addresses (from %s) " 263 seq_printf(seq, "Locally retrieved addresses (from %s) "
264 "announced via HNA:\n", 264 "announced via TT:\n",
265 net_dev->name); 265 net_dev->name);
266 266
267 spin_lock_bh(&bat_priv->hna_lhash_lock); 267 spin_lock_bh(&bat_priv->tt_lhash_lock);
268 268
269 buf_size = 1; 269 buf_size = 1;
270 /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */ 270 /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
@@ -279,7 +279,7 @@ int hna_local_seq_print_text(struct seq_file *seq, void *offset)
279 279
280 buff = kmalloc(buf_size, GFP_ATOMIC); 280 buff = kmalloc(buf_size, GFP_ATOMIC);
281 if (!buff) { 281 if (!buff) {
282 spin_unlock_bh(&bat_priv->hna_lhash_lock); 282 spin_unlock_bh(&bat_priv->tt_lhash_lock);
283 ret = -ENOMEM; 283 ret = -ENOMEM;
284 goto out; 284 goto out;
285 } 285 }
@@ -291,15 +291,15 @@ int hna_local_seq_print_text(struct seq_file *seq, void *offset)
291 head = &hash->table[i]; 291 head = &hash->table[i];
292 292
293 rcu_read_lock(); 293 rcu_read_lock();
294 hlist_for_each_entry_rcu(hna_local_entry, node, 294 hlist_for_each_entry_rcu(tt_local_entry, node,
295 head, hash_entry) { 295 head, hash_entry) {
296 pos += snprintf(buff + pos, 22, " * %pM\n", 296 pos += snprintf(buff + pos, 22, " * %pM\n",
297 hna_local_entry->addr); 297 tt_local_entry->addr);
298 } 298 }
299 rcu_read_unlock(); 299 rcu_read_unlock();
300 } 300 }
301 301
302 spin_unlock_bh(&bat_priv->hna_lhash_lock); 302 spin_unlock_bh(&bat_priv->tt_lhash_lock);
303 303
304 seq_printf(seq, "%s", buff); 304 seq_printf(seq, "%s", buff);
305 kfree(buff); 305 kfree(buff);
@@ -309,180 +309,180 @@ out:
309 return ret; 309 return ret;
310} 310}
311 311
312static void _hna_local_del(struct hlist_node *node, void *arg) 312static void _tt_local_del(struct hlist_node *node, void *arg)
313{ 313{
314 struct bat_priv *bat_priv = (struct bat_priv *)arg; 314 struct bat_priv *bat_priv = (struct bat_priv *)arg;
315 void *data = container_of(node, struct hna_local_entry, hash_entry); 315 void *data = container_of(node, struct tt_local_entry, hash_entry);
316 316
317 kfree(data); 317 kfree(data);
318 bat_priv->num_local_hna--; 318 bat_priv->num_local_tt--;
319 atomic_set(&bat_priv->hna_local_changed, 1); 319 atomic_set(&bat_priv->tt_local_changed, 1);
320} 320}
321 321
322static void hna_local_del(struct bat_priv *bat_priv, 322static void tt_local_del(struct bat_priv *bat_priv,
323 struct hna_local_entry *hna_local_entry, 323 struct tt_local_entry *tt_local_entry,
324 char *message) 324 char *message)
325{ 325{
326 bat_dbg(DBG_ROUTES, bat_priv, "Deleting local hna entry (%pM): %s\n", 326 bat_dbg(DBG_ROUTES, bat_priv, "Deleting local tt entry (%pM): %s\n",
327 hna_local_entry->addr, message); 327 tt_local_entry->addr, message);
328 328
329 hash_remove(bat_priv->hna_local_hash, compare_lhna, choose_orig, 329 hash_remove(bat_priv->tt_local_hash, compare_ltt, choose_orig,
330 hna_local_entry->addr); 330 tt_local_entry->addr);
331 _hna_local_del(&hna_local_entry->hash_entry, bat_priv); 331 _tt_local_del(&tt_local_entry->hash_entry, bat_priv);
332} 332}
333 333
334void hna_local_remove(struct bat_priv *bat_priv, 334void tt_local_remove(struct bat_priv *bat_priv,
335 uint8_t *addr, char *message) 335 uint8_t *addr, char *message)
336{ 336{
337 struct hna_local_entry *hna_local_entry; 337 struct tt_local_entry *tt_local_entry;
338 338
339 spin_lock_bh(&bat_priv->hna_lhash_lock); 339 spin_lock_bh(&bat_priv->tt_lhash_lock);
340 340
341 hna_local_entry = hna_local_hash_find(bat_priv, addr); 341 tt_local_entry = tt_local_hash_find(bat_priv, addr);
342 342
343 if (hna_local_entry) 343 if (tt_local_entry)
344 hna_local_del(bat_priv, hna_local_entry, message); 344 tt_local_del(bat_priv, tt_local_entry, message);
345 345
346 spin_unlock_bh(&bat_priv->hna_lhash_lock); 346 spin_unlock_bh(&bat_priv->tt_lhash_lock);
347} 347}
348 348
349static void hna_local_purge(struct work_struct *work) 349static void tt_local_purge(struct work_struct *work)
350{ 350{
351 struct delayed_work *delayed_work = 351 struct delayed_work *delayed_work =
352 container_of(work, struct delayed_work, work); 352 container_of(work, struct delayed_work, work);
353 struct bat_priv *bat_priv = 353 struct bat_priv *bat_priv =
354 container_of(delayed_work, struct bat_priv, hna_work); 354 container_of(delayed_work, struct bat_priv, tt_work);
355 struct hashtable_t *hash = bat_priv->hna_local_hash; 355 struct hashtable_t *hash = bat_priv->tt_local_hash;
356 struct hna_local_entry *hna_local_entry; 356 struct tt_local_entry *tt_local_entry;
357 struct hlist_node *node, *node_tmp; 357 struct hlist_node *node, *node_tmp;
358 struct hlist_head *head; 358 struct hlist_head *head;
359 unsigned long timeout; 359 unsigned long timeout;
360 int i; 360 int i;
361 361
362 spin_lock_bh(&bat_priv->hna_lhash_lock); 362 spin_lock_bh(&bat_priv->tt_lhash_lock);
363 363
364 for (i = 0; i < hash->size; i++) { 364 for (i = 0; i < hash->size; i++) {
365 head = &hash->table[i]; 365 head = &hash->table[i];
366 366
367 hlist_for_each_entry_safe(hna_local_entry, node, node_tmp, 367 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
368 head, hash_entry) { 368 head, hash_entry) {
369 if (hna_local_entry->never_purge) 369 if (tt_local_entry->never_purge)
370 continue; 370 continue;
371 371
372 timeout = hna_local_entry->last_seen; 372 timeout = tt_local_entry->last_seen;
373 timeout += LOCAL_HNA_TIMEOUT * HZ; 373 timeout += TT_LOCAL_TIMEOUT * HZ;
374 374
375 if (time_before(jiffies, timeout)) 375 if (time_before(jiffies, timeout))
376 continue; 376 continue;
377 377
378 hna_local_del(bat_priv, hna_local_entry, 378 tt_local_del(bat_priv, tt_local_entry,
379 "address timed out"); 379 "address timed out");
380 } 380 }
381 } 381 }
382 382
383 spin_unlock_bh(&bat_priv->hna_lhash_lock); 383 spin_unlock_bh(&bat_priv->tt_lhash_lock);
384 hna_local_start_timer(bat_priv); 384 tt_local_start_timer(bat_priv);
385} 385}
386 386
387void hna_local_free(struct bat_priv *bat_priv) 387void tt_local_free(struct bat_priv *bat_priv)
388{ 388{
389 if (!bat_priv->hna_local_hash) 389 if (!bat_priv->tt_local_hash)
390 return; 390 return;
391 391
392 cancel_delayed_work_sync(&bat_priv->hna_work); 392 cancel_delayed_work_sync(&bat_priv->tt_work);
393 hash_delete(bat_priv->hna_local_hash, _hna_local_del, bat_priv); 393 hash_delete(bat_priv->tt_local_hash, _tt_local_del, bat_priv);
394 bat_priv->hna_local_hash = NULL; 394 bat_priv->tt_local_hash = NULL;
395} 395}
396 396
397int hna_global_init(struct bat_priv *bat_priv) 397int tt_global_init(struct bat_priv *bat_priv)
398{ 398{
399 if (bat_priv->hna_global_hash) 399 if (bat_priv->tt_global_hash)
400 return 1; 400 return 1;
401 401
402 bat_priv->hna_global_hash = hash_new(1024); 402 bat_priv->tt_global_hash = hash_new(1024);
403 403
404 if (!bat_priv->hna_global_hash) 404 if (!bat_priv->tt_global_hash)
405 return 0; 405 return 0;
406 406
407 return 1; 407 return 1;
408} 408}
409 409
410void hna_global_add_orig(struct bat_priv *bat_priv, 410void tt_global_add_orig(struct bat_priv *bat_priv,
411 struct orig_node *orig_node, 411 struct orig_node *orig_node,
412 unsigned char *hna_buff, int hna_buff_len) 412 unsigned char *tt_buff, int tt_buff_len)
413{ 413{
414 struct hna_global_entry *hna_global_entry; 414 struct tt_global_entry *tt_global_entry;
415 struct hna_local_entry *hna_local_entry; 415 struct tt_local_entry *tt_local_entry;
416 int hna_buff_count = 0; 416 int tt_buff_count = 0;
417 unsigned char *hna_ptr; 417 unsigned char *tt_ptr;
418 418
419 while ((hna_buff_count + 1) * ETH_ALEN <= hna_buff_len) { 419 while ((tt_buff_count + 1) * ETH_ALEN <= tt_buff_len) {
420 spin_lock_bh(&bat_priv->hna_ghash_lock); 420 spin_lock_bh(&bat_priv->tt_ghash_lock);
421 421
422 hna_ptr = hna_buff + (hna_buff_count * ETH_ALEN); 422 tt_ptr = tt_buff + (tt_buff_count * ETH_ALEN);
423 hna_global_entry = hna_global_hash_find(bat_priv, hna_ptr); 423 tt_global_entry = tt_global_hash_find(bat_priv, tt_ptr);
424 424
425 if (!hna_global_entry) { 425 if (!tt_global_entry) {
426 spin_unlock_bh(&bat_priv->hna_ghash_lock); 426 spin_unlock_bh(&bat_priv->tt_ghash_lock);
427 427
428 hna_global_entry = 428 tt_global_entry =
429 kmalloc(sizeof(struct hna_global_entry), 429 kmalloc(sizeof(struct tt_global_entry),
430 GFP_ATOMIC); 430 GFP_ATOMIC);
431 431
432 if (!hna_global_entry) 432 if (!tt_global_entry)
433 break; 433 break;
434 434
435 memcpy(hna_global_entry->addr, hna_ptr, ETH_ALEN); 435 memcpy(tt_global_entry->addr, tt_ptr, ETH_ALEN);
436 436
437 bat_dbg(DBG_ROUTES, bat_priv, 437 bat_dbg(DBG_ROUTES, bat_priv,
438 "Creating new global hna entry: " 438 "Creating new global tt entry: "
439 "%pM (via %pM)\n", 439 "%pM (via %pM)\n",
440 hna_global_entry->addr, orig_node->orig); 440 tt_global_entry->addr, orig_node->orig);
441 441
442 spin_lock_bh(&bat_priv->hna_ghash_lock); 442 spin_lock_bh(&bat_priv->tt_ghash_lock);
443 hash_add(bat_priv->hna_global_hash, compare_ghna, 443 hash_add(bat_priv->tt_global_hash, compare_gtt,
444 choose_orig, hna_global_entry, 444 choose_orig, tt_global_entry,
445 &hna_global_entry->hash_entry); 445 &tt_global_entry->hash_entry);
446 446
447 } 447 }
448 448
449 hna_global_entry->orig_node = orig_node; 449 tt_global_entry->orig_node = orig_node;
450 spin_unlock_bh(&bat_priv->hna_ghash_lock); 450 spin_unlock_bh(&bat_priv->tt_ghash_lock);
451 451
452 /* remove address from local hash if present */ 452 /* remove address from local hash if present */
453 spin_lock_bh(&bat_priv->hna_lhash_lock); 453 spin_lock_bh(&bat_priv->tt_lhash_lock);
454 454
455 hna_ptr = hna_buff + (hna_buff_count * ETH_ALEN); 455 tt_ptr = tt_buff + (tt_buff_count * ETH_ALEN);
456 hna_local_entry = hna_local_hash_find(bat_priv, hna_ptr); 456 tt_local_entry = tt_local_hash_find(bat_priv, tt_ptr);
457 457
458 if (hna_local_entry) 458 if (tt_local_entry)
459 hna_local_del(bat_priv, hna_local_entry, 459 tt_local_del(bat_priv, tt_local_entry,
460 "global hna received"); 460 "global tt received");
461 461
462 spin_unlock_bh(&bat_priv->hna_lhash_lock); 462 spin_unlock_bh(&bat_priv->tt_lhash_lock);
463 463
464 hna_buff_count++; 464 tt_buff_count++;
465 } 465 }
466 466
467 /* initialize, and overwrite if malloc succeeds */ 467 /* initialize, and overwrite if malloc succeeds */
468 orig_node->hna_buff = NULL; 468 orig_node->tt_buff = NULL;
469 orig_node->hna_buff_len = 0; 469 orig_node->tt_buff_len = 0;
470 470
471 if (hna_buff_len > 0) { 471 if (tt_buff_len > 0) {
472 orig_node->hna_buff = kmalloc(hna_buff_len, GFP_ATOMIC); 472 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
473 if (orig_node->hna_buff) { 473 if (orig_node->tt_buff) {
474 memcpy(orig_node->hna_buff, hna_buff, hna_buff_len); 474 memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
475 orig_node->hna_buff_len = hna_buff_len; 475 orig_node->tt_buff_len = tt_buff_len;
476 } 476 }
477 } 477 }
478} 478}
479 479
480int hna_global_seq_print_text(struct seq_file *seq, void *offset) 480int tt_global_seq_print_text(struct seq_file *seq, void *offset)
481{ 481{
482 struct net_device *net_dev = (struct net_device *)seq->private; 482 struct net_device *net_dev = (struct net_device *)seq->private;
483 struct bat_priv *bat_priv = netdev_priv(net_dev); 483 struct bat_priv *bat_priv = netdev_priv(net_dev);
484 struct hashtable_t *hash = bat_priv->hna_global_hash; 484 struct hashtable_t *hash = bat_priv->tt_global_hash;
485 struct hna_global_entry *hna_global_entry; 485 struct tt_global_entry *tt_global_entry;
486 struct hard_iface *primary_if; 486 struct hard_iface *primary_if;
487 struct hlist_node *node; 487 struct hlist_node *node;
488 struct hlist_head *head; 488 struct hlist_head *head;
@@ -505,10 +505,11 @@ int hna_global_seq_print_text(struct seq_file *seq, void *offset)
505 goto out; 505 goto out;
506 } 506 }
507 507
508 seq_printf(seq, "Globally announced HNAs received via the mesh %s\n", 508 seq_printf(seq,
509 "Globally announced TT entries received via the mesh %s\n",
509 net_dev->name); 510 net_dev->name);
510 511
511 spin_lock_bh(&bat_priv->hna_ghash_lock); 512 spin_lock_bh(&bat_priv->tt_ghash_lock);
512 513
513 buf_size = 1; 514 buf_size = 1;
514 /* Estimate length for: " * xx:xx:xx:xx:xx:xx via xx:xx:xx:xx:xx:xx\n"*/ 515 /* Estimate length for: " * xx:xx:xx:xx:xx:xx via xx:xx:xx:xx:xx:xx\n"*/
@@ -523,7 +524,7 @@ int hna_global_seq_print_text(struct seq_file *seq, void *offset)
523 524
524 buff = kmalloc(buf_size, GFP_ATOMIC); 525 buff = kmalloc(buf_size, GFP_ATOMIC);
525 if (!buff) { 526 if (!buff) {
526 spin_unlock_bh(&bat_priv->hna_ghash_lock); 527 spin_unlock_bh(&bat_priv->tt_ghash_lock);
527 ret = -ENOMEM; 528 ret = -ENOMEM;
528 goto out; 529 goto out;
529 } 530 }
@@ -534,17 +535,17 @@ int hna_global_seq_print_text(struct seq_file *seq, void *offset)
534 head = &hash->table[i]; 535 head = &hash->table[i];
535 536
536 rcu_read_lock(); 537 rcu_read_lock();
537 hlist_for_each_entry_rcu(hna_global_entry, node, 538 hlist_for_each_entry_rcu(tt_global_entry, node,
538 head, hash_entry) { 539 head, hash_entry) {
539 pos += snprintf(buff + pos, 44, 540 pos += snprintf(buff + pos, 44,
540 " * %pM via %pM\n", 541 " * %pM via %pM\n",
541 hna_global_entry->addr, 542 tt_global_entry->addr,
542 hna_global_entry->orig_node->orig); 543 tt_global_entry->orig_node->orig);
543 } 544 }
544 rcu_read_unlock(); 545 rcu_read_unlock();
545 } 546 }
546 547
547 spin_unlock_bh(&bat_priv->hna_ghash_lock); 548 spin_unlock_bh(&bat_priv->tt_ghash_lock);
548 549
549 seq_printf(seq, "%s", buff); 550 seq_printf(seq, "%s", buff);
550 kfree(buff); 551 kfree(buff);
@@ -554,84 +555,84 @@ out:
554 return ret; 555 return ret;
555} 556}
556 557
557static void _hna_global_del_orig(struct bat_priv *bat_priv, 558static void _tt_global_del_orig(struct bat_priv *bat_priv,
558 struct hna_global_entry *hna_global_entry, 559 struct tt_global_entry *tt_global_entry,
559 char *message) 560 char *message)
560{ 561{
561 bat_dbg(DBG_ROUTES, bat_priv, 562 bat_dbg(DBG_ROUTES, bat_priv,
562 "Deleting global hna entry %pM (via %pM): %s\n", 563 "Deleting global tt entry %pM (via %pM): %s\n",
563 hna_global_entry->addr, hna_global_entry->orig_node->orig, 564 tt_global_entry->addr, tt_global_entry->orig_node->orig,
564 message); 565 message);
565 566
566 hash_remove(bat_priv->hna_global_hash, compare_ghna, choose_orig, 567 hash_remove(bat_priv->tt_global_hash, compare_gtt, choose_orig,
567 hna_global_entry->addr); 568 tt_global_entry->addr);
568 kfree(hna_global_entry); 569 kfree(tt_global_entry);
569} 570}
570 571
571void hna_global_del_orig(struct bat_priv *bat_priv, 572void tt_global_del_orig(struct bat_priv *bat_priv,
572 struct orig_node *orig_node, char *message) 573 struct orig_node *orig_node, char *message)
573{ 574{
574 struct hna_global_entry *hna_global_entry; 575 struct tt_global_entry *tt_global_entry;
575 int hna_buff_count = 0; 576 int tt_buff_count = 0;
576 unsigned char *hna_ptr; 577 unsigned char *tt_ptr;
577 578
578 if (orig_node->hna_buff_len == 0) 579 if (orig_node->tt_buff_len == 0)
579 return; 580 return;
580 581
581 spin_lock_bh(&bat_priv->hna_ghash_lock); 582 spin_lock_bh(&bat_priv->tt_ghash_lock);
582 583
583 while ((hna_buff_count + 1) * ETH_ALEN <= orig_node->hna_buff_len) { 584 while ((tt_buff_count + 1) * ETH_ALEN <= orig_node->tt_buff_len) {
584 hna_ptr = orig_node->hna_buff + (hna_buff_count * ETH_ALEN); 585 tt_ptr = orig_node->tt_buff + (tt_buff_count * ETH_ALEN);
585 hna_global_entry = hna_global_hash_find(bat_priv, hna_ptr); 586 tt_global_entry = tt_global_hash_find(bat_priv, tt_ptr);
586 587
587 if ((hna_global_entry) && 588 if ((tt_global_entry) &&
588 (hna_global_entry->orig_node == orig_node)) 589 (tt_global_entry->orig_node == orig_node))
589 _hna_global_del_orig(bat_priv, hna_global_entry, 590 _tt_global_del_orig(bat_priv, tt_global_entry,
590 message); 591 message);
591 592
592 hna_buff_count++; 593 tt_buff_count++;
593 } 594 }
594 595
595 spin_unlock_bh(&bat_priv->hna_ghash_lock); 596 spin_unlock_bh(&bat_priv->tt_ghash_lock);
596 597
597 orig_node->hna_buff_len = 0; 598 orig_node->tt_buff_len = 0;
598 kfree(orig_node->hna_buff); 599 kfree(orig_node->tt_buff);
599 orig_node->hna_buff = NULL; 600 orig_node->tt_buff = NULL;
600} 601}
601 602
602static void hna_global_del(struct hlist_node *node, void *arg) 603static void tt_global_del(struct hlist_node *node, void *arg)
603{ 604{
604 void *data = container_of(node, struct hna_global_entry, hash_entry); 605 void *data = container_of(node, struct tt_global_entry, hash_entry);
605 606
606 kfree(data); 607 kfree(data);
607} 608}
608 609
609void hna_global_free(struct bat_priv *bat_priv) 610void tt_global_free(struct bat_priv *bat_priv)
610{ 611{
611 if (!bat_priv->hna_global_hash) 612 if (!bat_priv->tt_global_hash)
612 return; 613 return;
613 614
614 hash_delete(bat_priv->hna_global_hash, hna_global_del, NULL); 615 hash_delete(bat_priv->tt_global_hash, tt_global_del, NULL);
615 bat_priv->hna_global_hash = NULL; 616 bat_priv->tt_global_hash = NULL;
616} 617}
617 618
618struct orig_node *transtable_search(struct bat_priv *bat_priv, uint8_t *addr) 619struct orig_node *transtable_search(struct bat_priv *bat_priv, uint8_t *addr)
619{ 620{
620 struct hna_global_entry *hna_global_entry; 621 struct tt_global_entry *tt_global_entry;
621 struct orig_node *orig_node = NULL; 622 struct orig_node *orig_node = NULL;
622 623
623 spin_lock_bh(&bat_priv->hna_ghash_lock); 624 spin_lock_bh(&bat_priv->tt_ghash_lock);
624 hna_global_entry = hna_global_hash_find(bat_priv, addr); 625 tt_global_entry = tt_global_hash_find(bat_priv, addr);
625 626
626 if (!hna_global_entry) 627 if (!tt_global_entry)
627 goto out; 628 goto out;
628 629
629 if (!atomic_inc_not_zero(&hna_global_entry->orig_node->refcount)) 630 if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount))
630 goto out; 631 goto out;
631 632
632 orig_node = hna_global_entry->orig_node; 633 orig_node = tt_global_entry->orig_node;
633 634
634out: 635out:
635 spin_unlock_bh(&bat_priv->hna_ghash_lock); 636 spin_unlock_bh(&bat_priv->tt_ghash_lock);
636 return orig_node; 637 return orig_node;
637} 638}
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-09 05:01:55 -0500