Commit | Line | Data |
---|---|---|
c6c8fea2 | 1 | /* |
64afe353 | 2 | * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors: |
c6c8fea2 SE |
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" | |
c6c8fea2 SE |
25 | #include "hash.h" |
26 | #include "originator.h" | |
27 | ||
28 | static void hna_local_purge(struct work_struct *work); | |
29 | static void _hna_global_del_orig(struct bat_priv *bat_priv, | |
30 | struct hna_global_entry *hna_global_entry, | |
31 | char *message); | |
32 | ||
7aadf889 ML |
33 | /* returns 1 if they are the same mac addr */ |
34 | static int compare_lhna(struct hlist_node *node, void *data2) | |
35 | { | |
36 | void *data1 = container_of(node, struct hna_local_entry, hash_entry); | |
37 | ||
38 | return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0); | |
39 | } | |
40 | ||
41 | /* returns 1 if they are the same mac addr */ | |
42 | static int compare_ghna(struct hlist_node *node, void *data2) | |
43 | { | |
44 | void *data1 = container_of(node, struct hna_global_entry, hash_entry); | |
45 | ||
46 | return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0); | |
47 | } | |
48 | ||
c6c8fea2 SE |
49 | static void hna_local_start_timer(struct bat_priv *bat_priv) |
50 | { | |
51 | INIT_DELAYED_WORK(&bat_priv->hna_work, hna_local_purge); | |
52 | queue_delayed_work(bat_event_workqueue, &bat_priv->hna_work, 10 * HZ); | |
53 | } | |
54 | ||
7aadf889 ML |
55 | static struct hna_local_entry *hna_local_hash_find(struct bat_priv *bat_priv, |
56 | void *data) | |
57 | { | |
58 | struct hashtable_t *hash = bat_priv->hna_local_hash; | |
59 | struct hlist_head *head; | |
60 | struct hlist_node *node; | |
61 | struct hna_local_entry *hna_local_entry, *hna_local_entry_tmp = NULL; | |
62 | int index; | |
63 | ||
64 | if (!hash) | |
65 | return NULL; | |
66 | ||
67 | index = choose_orig(data, hash->size); | |
68 | head = &hash->table[index]; | |
69 | ||
70 | rcu_read_lock(); | |
71 | hlist_for_each_entry_rcu(hna_local_entry, node, head, hash_entry) { | |
72 | if (!compare_eth(hna_local_entry, data)) | |
73 | continue; | |
74 | ||
75 | hna_local_entry_tmp = hna_local_entry; | |
76 | break; | |
77 | } | |
78 | rcu_read_unlock(); | |
79 | ||
80 | return hna_local_entry_tmp; | |
81 | } | |
82 | ||
83 | static struct hna_global_entry *hna_global_hash_find(struct bat_priv *bat_priv, | |
84 | void *data) | |
85 | { | |
86 | struct hashtable_t *hash = bat_priv->hna_global_hash; | |
87 | struct hlist_head *head; | |
88 | struct hlist_node *node; | |
89 | struct hna_global_entry *hna_global_entry; | |
90 | struct hna_global_entry *hna_global_entry_tmp = NULL; | |
91 | int index; | |
92 | ||
93 | if (!hash) | |
94 | return NULL; | |
95 | ||
96 | index = choose_orig(data, hash->size); | |
97 | head = &hash->table[index]; | |
98 | ||
99 | rcu_read_lock(); | |
100 | hlist_for_each_entry_rcu(hna_global_entry, node, head, hash_entry) { | |
101 | if (!compare_eth(hna_global_entry, data)) | |
102 | continue; | |
103 | ||
104 | hna_global_entry_tmp = hna_global_entry; | |
105 | break; | |
106 | } | |
107 | rcu_read_unlock(); | |
108 | ||
109 | return hna_global_entry_tmp; | |
110 | } | |
111 | ||
c6c8fea2 SE |
112 | int hna_local_init(struct bat_priv *bat_priv) |
113 | { | |
114 | if (bat_priv->hna_local_hash) | |
115 | return 1; | |
116 | ||
117 | bat_priv->hna_local_hash = hash_new(1024); | |
118 | ||
119 | if (!bat_priv->hna_local_hash) | |
120 | return 0; | |
121 | ||
122 | atomic_set(&bat_priv->hna_local_changed, 0); | |
123 | hna_local_start_timer(bat_priv); | |
124 | ||
125 | return 1; | |
126 | } | |
127 | ||
128 | void hna_local_add(struct net_device *soft_iface, uint8_t *addr) | |
129 | { | |
130 | struct bat_priv *bat_priv = netdev_priv(soft_iface); | |
131 | struct hna_local_entry *hna_local_entry; | |
132 | struct hna_global_entry *hna_global_entry; | |
133 | int required_bytes; | |
134 | ||
135 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
7aadf889 | 136 | hna_local_entry = hna_local_hash_find(bat_priv, addr); |
c6c8fea2 SE |
137 | spin_unlock_bh(&bat_priv->hna_lhash_lock); |
138 | ||
139 | if (hna_local_entry) { | |
140 | hna_local_entry->last_seen = jiffies; | |
141 | return; | |
142 | } | |
143 | ||
144 | /* only announce as many hosts as possible in the batman-packet and | |
145 | space in batman_packet->num_hna That also should give a limit to | |
146 | MAC-flooding. */ | |
147 | required_bytes = (bat_priv->num_local_hna + 1) * ETH_ALEN; | |
148 | required_bytes += BAT_PACKET_LEN; | |
149 | ||
150 | if ((required_bytes > ETH_DATA_LEN) || | |
151 | (atomic_read(&bat_priv->aggregated_ogms) && | |
152 | required_bytes > MAX_AGGREGATION_BYTES) || | |
153 | (bat_priv->num_local_hna + 1 > 255)) { | |
154 | bat_dbg(DBG_ROUTES, bat_priv, | |
155 | "Can't add new local hna entry (%pM): " | |
156 | "number of local hna entries exceeds packet size\n", | |
157 | addr); | |
158 | return; | |
159 | } | |
160 | ||
161 | bat_dbg(DBG_ROUTES, bat_priv, | |
162 | "Creating new local hna entry: %pM\n", addr); | |
163 | ||
164 | hna_local_entry = kmalloc(sizeof(struct hna_local_entry), GFP_ATOMIC); | |
165 | if (!hna_local_entry) | |
166 | return; | |
167 | ||
168 | memcpy(hna_local_entry->addr, addr, ETH_ALEN); | |
169 | hna_local_entry->last_seen = jiffies; | |
170 | ||
171 | /* the batman interface mac address should never be purged */ | |
39901e71 | 172 | if (compare_eth(addr, soft_iface->dev_addr)) |
c6c8fea2 SE |
173 | hna_local_entry->never_purge = 1; |
174 | else | |
175 | hna_local_entry->never_purge = 0; | |
176 | ||
177 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
178 | ||
7aadf889 ML |
179 | hash_add(bat_priv->hna_local_hash, compare_lhna, choose_orig, |
180 | hna_local_entry, &hna_local_entry->hash_entry); | |
c6c8fea2 SE |
181 | bat_priv->num_local_hna++; |
182 | atomic_set(&bat_priv->hna_local_changed, 1); | |
183 | ||
184 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
185 | ||
186 | /* remove address from global hash if present */ | |
187 | spin_lock_bh(&bat_priv->hna_ghash_lock); | |
188 | ||
7aadf889 | 189 | hna_global_entry = hna_global_hash_find(bat_priv, addr); |
c6c8fea2 SE |
190 | |
191 | if (hna_global_entry) | |
192 | _hna_global_del_orig(bat_priv, hna_global_entry, | |
193 | "local hna received"); | |
194 | ||
195 | spin_unlock_bh(&bat_priv->hna_ghash_lock); | |
196 | } | |
197 | ||
198 | int hna_local_fill_buffer(struct bat_priv *bat_priv, | |
199 | unsigned char *buff, int buff_len) | |
200 | { | |
201 | struct hashtable_t *hash = bat_priv->hna_local_hash; | |
202 | struct hna_local_entry *hna_local_entry; | |
7aadf889 | 203 | struct hlist_node *node; |
c6c8fea2 | 204 | struct hlist_head *head; |
7aadf889 | 205 | int i, count = 0; |
c6c8fea2 SE |
206 | |
207 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
208 | ||
209 | for (i = 0; i < hash->size; i++) { | |
210 | head = &hash->table[i]; | |
211 | ||
7aadf889 ML |
212 | rcu_read_lock(); |
213 | hlist_for_each_entry_rcu(hna_local_entry, node, | |
214 | head, hash_entry) { | |
c6c8fea2 SE |
215 | if (buff_len < (count + 1) * ETH_ALEN) |
216 | break; | |
217 | ||
c6c8fea2 SE |
218 | memcpy(buff + (count * ETH_ALEN), hna_local_entry->addr, |
219 | ETH_ALEN); | |
220 | ||
221 | count++; | |
222 | } | |
7aadf889 | 223 | rcu_read_unlock(); |
c6c8fea2 SE |
224 | } |
225 | ||
226 | /* if we did not get all new local hnas see you next time ;-) */ | |
227 | if (count == bat_priv->num_local_hna) | |
228 | atomic_set(&bat_priv->hna_local_changed, 0); | |
229 | ||
230 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
53320fe3 | 231 | return count; |
c6c8fea2 SE |
232 | } |
233 | ||
234 | int hna_local_seq_print_text(struct seq_file *seq, void *offset) | |
235 | { | |
236 | struct net_device *net_dev = (struct net_device *)seq->private; | |
237 | struct bat_priv *bat_priv = netdev_priv(net_dev); | |
238 | struct hashtable_t *hash = bat_priv->hna_local_hash; | |
239 | struct hna_local_entry *hna_local_entry; | |
7aadf889 | 240 | struct hlist_node *node; |
c6c8fea2 | 241 | struct hlist_head *head; |
c6c8fea2 SE |
242 | size_t buf_size, pos; |
243 | char *buff; | |
7aadf889 | 244 | int i; |
c6c8fea2 SE |
245 | |
246 | if (!bat_priv->primary_if) { | |
247 | return seq_printf(seq, "BATMAN mesh %s disabled - " | |
248 | "please specify interfaces to enable it\n", | |
249 | net_dev->name); | |
250 | } | |
251 | ||
252 | seq_printf(seq, "Locally retrieved addresses (from %s) " | |
253 | "announced via HNA:\n", | |
254 | net_dev->name); | |
255 | ||
256 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
257 | ||
258 | buf_size = 1; | |
259 | /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */ | |
260 | for (i = 0; i < hash->size; i++) { | |
261 | head = &hash->table[i]; | |
262 | ||
7aadf889 ML |
263 | rcu_read_lock(); |
264 | __hlist_for_each_rcu(node, head) | |
c6c8fea2 | 265 | buf_size += 21; |
7aadf889 | 266 | rcu_read_unlock(); |
c6c8fea2 SE |
267 | } |
268 | ||
269 | buff = kmalloc(buf_size, GFP_ATOMIC); | |
270 | if (!buff) { | |
271 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
272 | return -ENOMEM; | |
273 | } | |
7aadf889 | 274 | |
c6c8fea2 SE |
275 | buff[0] = '\0'; |
276 | pos = 0; | |
277 | ||
278 | for (i = 0; i < hash->size; i++) { | |
279 | head = &hash->table[i]; | |
280 | ||
7aadf889 ML |
281 | rcu_read_lock(); |
282 | hlist_for_each_entry_rcu(hna_local_entry, node, | |
283 | head, hash_entry) { | |
c6c8fea2 SE |
284 | pos += snprintf(buff + pos, 22, " * %pM\n", |
285 | hna_local_entry->addr); | |
286 | } | |
7aadf889 | 287 | rcu_read_unlock(); |
c6c8fea2 SE |
288 | } |
289 | ||
290 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
291 | ||
292 | seq_printf(seq, "%s", buff); | |
293 | kfree(buff); | |
294 | return 0; | |
295 | } | |
296 | ||
7aadf889 | 297 | static void _hna_local_del(struct hlist_node *node, void *arg) |
c6c8fea2 SE |
298 | { |
299 | struct bat_priv *bat_priv = (struct bat_priv *)arg; | |
7aadf889 | 300 | void *data = container_of(node, struct hna_local_entry, hash_entry); |
c6c8fea2 SE |
301 | |
302 | kfree(data); | |
303 | bat_priv->num_local_hna--; | |
304 | atomic_set(&bat_priv->hna_local_changed, 1); | |
305 | } | |
306 | ||
307 | static void hna_local_del(struct bat_priv *bat_priv, | |
308 | struct hna_local_entry *hna_local_entry, | |
309 | char *message) | |
310 | { | |
311 | bat_dbg(DBG_ROUTES, bat_priv, "Deleting local hna entry (%pM): %s\n", | |
312 | hna_local_entry->addr, message); | |
313 | ||
7aadf889 | 314 | hash_remove(bat_priv->hna_local_hash, compare_lhna, choose_orig, |
c6c8fea2 | 315 | hna_local_entry->addr); |
7aadf889 | 316 | _hna_local_del(&hna_local_entry->hash_entry, bat_priv); |
c6c8fea2 SE |
317 | } |
318 | ||
319 | void hna_local_remove(struct bat_priv *bat_priv, | |
320 | uint8_t *addr, char *message) | |
321 | { | |
322 | struct hna_local_entry *hna_local_entry; | |
323 | ||
324 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
325 | ||
7aadf889 | 326 | hna_local_entry = hna_local_hash_find(bat_priv, addr); |
c6c8fea2 SE |
327 | |
328 | if (hna_local_entry) | |
329 | hna_local_del(bat_priv, hna_local_entry, message); | |
330 | ||
331 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
332 | } | |
333 | ||
334 | static void hna_local_purge(struct work_struct *work) | |
335 | { | |
336 | struct delayed_work *delayed_work = | |
337 | container_of(work, struct delayed_work, work); | |
338 | struct bat_priv *bat_priv = | |
339 | container_of(delayed_work, struct bat_priv, hna_work); | |
340 | struct hashtable_t *hash = bat_priv->hna_local_hash; | |
341 | struct hna_local_entry *hna_local_entry; | |
7aadf889 | 342 | struct hlist_node *node, *node_tmp; |
c6c8fea2 | 343 | struct hlist_head *head; |
c6c8fea2 | 344 | unsigned long timeout; |
7aadf889 | 345 | int i; |
c6c8fea2 SE |
346 | |
347 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
348 | ||
349 | for (i = 0; i < hash->size; i++) { | |
350 | head = &hash->table[i]; | |
351 | ||
7aadf889 ML |
352 | hlist_for_each_entry_safe(hna_local_entry, node, node_tmp, |
353 | head, hash_entry) { | |
354 | if (hna_local_entry->never_purge) | |
355 | continue; | |
c6c8fea2 SE |
356 | |
357 | timeout = hna_local_entry->last_seen; | |
358 | timeout += LOCAL_HNA_TIMEOUT * HZ; | |
359 | ||
7aadf889 ML |
360 | if (time_before(jiffies, timeout)) |
361 | continue; | |
362 | ||
363 | hna_local_del(bat_priv, hna_local_entry, | |
364 | "address timed out"); | |
c6c8fea2 SE |
365 | } |
366 | } | |
367 | ||
368 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
369 | hna_local_start_timer(bat_priv); | |
370 | } | |
371 | ||
372 | void hna_local_free(struct bat_priv *bat_priv) | |
373 | { | |
374 | if (!bat_priv->hna_local_hash) | |
375 | return; | |
376 | ||
377 | cancel_delayed_work_sync(&bat_priv->hna_work); | |
378 | hash_delete(bat_priv->hna_local_hash, _hna_local_del, bat_priv); | |
379 | bat_priv->hna_local_hash = NULL; | |
380 | } | |
381 | ||
382 | int hna_global_init(struct bat_priv *bat_priv) | |
383 | { | |
384 | if (bat_priv->hna_global_hash) | |
385 | return 1; | |
386 | ||
387 | bat_priv->hna_global_hash = hash_new(1024); | |
388 | ||
389 | if (!bat_priv->hna_global_hash) | |
390 | return 0; | |
391 | ||
392 | return 1; | |
393 | } | |
394 | ||
395 | void hna_global_add_orig(struct bat_priv *bat_priv, | |
396 | struct orig_node *orig_node, | |
397 | unsigned char *hna_buff, int hna_buff_len) | |
398 | { | |
399 | struct hna_global_entry *hna_global_entry; | |
400 | struct hna_local_entry *hna_local_entry; | |
401 | int hna_buff_count = 0; | |
402 | unsigned char *hna_ptr; | |
403 | ||
404 | while ((hna_buff_count + 1) * ETH_ALEN <= hna_buff_len) { | |
405 | spin_lock_bh(&bat_priv->hna_ghash_lock); | |
406 | ||
407 | hna_ptr = hna_buff + (hna_buff_count * ETH_ALEN); | |
7aadf889 | 408 | hna_global_entry = hna_global_hash_find(bat_priv, hna_ptr); |
c6c8fea2 SE |
409 | |
410 | if (!hna_global_entry) { | |
411 | spin_unlock_bh(&bat_priv->hna_ghash_lock); | |
412 | ||
413 | hna_global_entry = | |
414 | kmalloc(sizeof(struct hna_global_entry), | |
415 | GFP_ATOMIC); | |
416 | ||
417 | if (!hna_global_entry) | |
418 | break; | |
419 | ||
420 | memcpy(hna_global_entry->addr, hna_ptr, ETH_ALEN); | |
421 | ||
422 | bat_dbg(DBG_ROUTES, bat_priv, | |
423 | "Creating new global hna entry: " | |
424 | "%pM (via %pM)\n", | |
425 | hna_global_entry->addr, orig_node->orig); | |
426 | ||
427 | spin_lock_bh(&bat_priv->hna_ghash_lock); | |
7aadf889 ML |
428 | hash_add(bat_priv->hna_global_hash, compare_ghna, |
429 | choose_orig, hna_global_entry, | |
430 | &hna_global_entry->hash_entry); | |
c6c8fea2 SE |
431 | |
432 | } | |
433 | ||
434 | hna_global_entry->orig_node = orig_node; | |
435 | spin_unlock_bh(&bat_priv->hna_ghash_lock); | |
436 | ||
437 | /* remove address from local hash if present */ | |
438 | spin_lock_bh(&bat_priv->hna_lhash_lock); | |
439 | ||
440 | hna_ptr = hna_buff + (hna_buff_count * ETH_ALEN); | |
7aadf889 | 441 | hna_local_entry = hna_local_hash_find(bat_priv, hna_ptr); |
c6c8fea2 SE |
442 | |
443 | if (hna_local_entry) | |
444 | hna_local_del(bat_priv, hna_local_entry, | |
445 | "global hna received"); | |
446 | ||
447 | spin_unlock_bh(&bat_priv->hna_lhash_lock); | |
448 | ||
449 | hna_buff_count++; | |
450 | } | |
451 | ||
452 | /* initialize, and overwrite if malloc succeeds */ | |
453 | orig_node->hna_buff = NULL; | |
454 | orig_node->hna_buff_len = 0; | |
455 | ||
456 | if (hna_buff_len > 0) { | |
457 | orig_node->hna_buff = kmalloc(hna_buff_len, GFP_ATOMIC); | |
458 | if (orig_node->hna_buff) { | |
459 | memcpy(orig_node->hna_buff, hna_buff, hna_buff_len); | |
460 | orig_node->hna_buff_len = hna_buff_len; | |
461 | } | |
462 | } | |
463 | } | |
464 | ||
465 | int hna_global_seq_print_text(struct seq_file *seq, void *offset) | |
466 | { | |
467 | struct net_device *net_dev = (struct net_device *)seq->private; | |
468 | struct bat_priv *bat_priv = netdev_priv(net_dev); | |
469 | struct hashtable_t *hash = bat_priv->hna_global_hash; | |
470 | struct hna_global_entry *hna_global_entry; | |
7aadf889 | 471 | struct hlist_node *node; |
c6c8fea2 | 472 | struct hlist_head *head; |
c6c8fea2 SE |
473 | size_t buf_size, pos; |
474 | char *buff; | |
7aadf889 | 475 | int i; |
c6c8fea2 SE |
476 | |
477 | if (!bat_priv->primary_if) { | |
478 | return seq_printf(seq, "BATMAN mesh %s disabled - " | |
479 | "please specify interfaces to enable it\n", | |
480 | net_dev->name); | |
481 | } | |
482 | ||
483 | seq_printf(seq, "Globally announced HNAs received via the mesh %s\n", | |
484 | net_dev->name); | |
485 | ||
486 | spin_lock_bh(&bat_priv->hna_ghash_lock); | |
487 | ||
488 | buf_size = 1; | |
489 | /* Estimate length for: " * xx:xx:xx:xx:xx:xx via xx:xx:xx:xx:xx:xx\n"*/ | |
490 | for (i = 0; i < hash->size; i++) { | |
491 | head = &hash->table[i]; | |
492 | ||
7aadf889 ML |
493 | rcu_read_lock(); |
494 | __hlist_for_each_rcu(node, head) | |
c6c8fea2 | 495 | buf_size += 43; |
7aadf889 | 496 | rcu_read_unlock(); |
c6c8fea2 SE |
497 | } |
498 | ||
499 | buff = kmalloc(buf_size, GFP_ATOMIC); | |
500 | if (!buff) { | |
501 | spin_unlock_bh(&bat_priv->hna_ghash_lock); | |
502 | return -ENOMEM; | |
503 | } | |
504 | buff[0] = '\0'; | |
505 | pos = 0; | |
506 | ||
507 | for (i = 0; i < hash->size; i++) { | |
508 | head = &hash->table[i]; | |
509 | ||
7aadf889 ML |
510 | rcu_read_lock(); |
511 | hlist_for_each_entry_rcu(hna_global_entry, node, | |
512 | head, hash_entry) { | |
c6c8fea2 SE |
513 | pos += snprintf(buff + pos, 44, |
514 | " * %pM via %pM\n", | |
515 | hna_global_entry->addr, | |
516 | hna_global_entry->orig_node->orig); | |
517 | } | |
7aadf889 | 518 | rcu_read_unlock(); |
c6c8fea2 SE |
519 | } |
520 | ||
521 | spin_unlock_bh(&bat_priv->hna_ghash_lock); | |
522 | ||
523 | seq_printf(seq, "%s", buff); | |
524 | kfree(buff); | |
525 | return 0; | |
526 | } | |
527 | ||
528 | static void _hna_global_del_orig(struct bat_priv *bat_priv, | |
529 | struct hna_global_entry *hna_global_entry, | |
530 | char *message) | |
531 | { | |
532 | bat_dbg(DBG_ROUTES, bat_priv, | |
533 | "Deleting global hna entry %pM (via %pM): %s\n", | |
534 | hna_global_entry->addr, hna_global_entry->orig_node->orig, | |
535 | message); | |
536 | ||
7aadf889 | 537 | hash_remove(bat_priv->hna_global_hash, compare_ghna, choose_orig, |
c6c8fea2 SE |
538 | hna_global_entry->addr); |
539 | kfree(hna_global_entry); | |
540 | } | |
541 | ||
542 | void hna_global_del_orig(struct bat_priv *bat_priv, | |
543 | struct orig_node *orig_node, char *message) | |
544 | { | |
545 | struct hna_global_entry *hna_global_entry; | |
546 | int hna_buff_count = 0; | |
547 | unsigned char *hna_ptr; | |
548 | ||
549 | if (orig_node->hna_buff_len == 0) | |
550 | return; | |
551 | ||
552 | spin_lock_bh(&bat_priv->hna_ghash_lock); | |
553 | ||
554 | while ((hna_buff_count + 1) * ETH_ALEN <= orig_node->hna_buff_len) { | |
555 | hna_ptr = orig_node->hna_buff + (hna_buff_count * ETH_ALEN); | |
7aadf889 | 556 | hna_global_entry = hna_global_hash_find(bat_priv, hna_ptr); |
c6c8fea2 SE |
557 | |
558 | if ((hna_global_entry) && | |
559 | (hna_global_entry->orig_node == orig_node)) | |
560 | _hna_global_del_orig(bat_priv, hna_global_entry, | |
561 | message); | |
562 | ||
563 | hna_buff_count++; | |
564 | } | |
565 | ||
566 | spin_unlock_bh(&bat_priv->hna_ghash_lock); | |
567 | ||
568 | orig_node->hna_buff_len = 0; | |
569 | kfree(orig_node->hna_buff); | |
570 | orig_node->hna_buff = NULL; | |
571 | } | |
572 | ||
7aadf889 | 573 | static void hna_global_del(struct hlist_node *node, void *arg) |
c6c8fea2 | 574 | { |
7aadf889 ML |
575 | void *data = container_of(node, struct hna_global_entry, hash_entry); |
576 | ||
c6c8fea2 SE |
577 | kfree(data); |
578 | } | |
579 | ||
580 | void hna_global_free(struct bat_priv *bat_priv) | |
581 | { | |
582 | if (!bat_priv->hna_global_hash) | |
583 | return; | |
584 | ||
585 | hash_delete(bat_priv->hna_global_hash, hna_global_del, NULL); | |
586 | bat_priv->hna_global_hash = NULL; | |
587 | } | |
588 | ||
589 | struct orig_node *transtable_search(struct bat_priv *bat_priv, uint8_t *addr) | |
590 | { | |
591 | struct hna_global_entry *hna_global_entry; | |
592 | ||
593 | spin_lock_bh(&bat_priv->hna_ghash_lock); | |
7aadf889 ML |
594 | hna_global_entry = hna_global_hash_find(bat_priv, addr); |
595 | ||
596 | if (hna_global_entry) | |
597 | kref_get(&hna_global_entry->orig_node->refcount); | |
598 | ||
c6c8fea2 SE |
599 | spin_unlock_bh(&bat_priv->hna_ghash_lock); |
600 | ||
601 | if (!hna_global_entry) | |
602 | return NULL; | |
603 | ||
604 | return hna_global_entry->orig_node; | |
605 | } |