blob: 912d9c36fb1c9e63d1358bd044f5a0218f2f4d77 [file] [log] [blame]
Sven Eckelmann9f6446c2015-04-23 13:16:35 +02001/* Copyright (C) 2007-2015 B.A.T.M.A.N. contributors:
Marek Lindnerfc957272011-07-30 12:04:12 +02002 *
3 * Marek Lindner, Simon Wunderlich
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
Antonio Quartulliebf38fb2013-11-03 20:40:48 +010015 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Marek Lindnerfc957272011-07-30 12:04:12 +020016 */
17
Marek Lindner1c280472011-11-28 17:40:17 +080018#include "bat_algo.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020019#include "main.h"
20
21#include <linux/atomic.h>
22#include <linux/bitmap.h>
23#include <linux/bitops.h>
24#include <linux/bug.h>
25#include <linux/byteorder/generic.h>
26#include <linux/cache.h>
27#include <linux/errno.h>
28#include <linux/etherdevice.h>
29#include <linux/fs.h>
30#include <linux/if_ether.h>
31#include <linux/init.h>
32#include <linux/jiffies.h>
33#include <linux/list.h>
34#include <linux/netdevice.h>
35#include <linux/pkt_sched.h>
36#include <linux/printk.h>
37#include <linux/random.h>
38#include <linux/rculist.h>
39#include <linux/rcupdate.h>
40#include <linux/seq_file.h>
41#include <linux/skbuff.h>
42#include <linux/slab.h>
43#include <linux/spinlock.h>
44#include <linux/stddef.h>
45#include <linux/string.h>
46#include <linux/types.h>
47#include <linux/workqueue.h>
48
49#include "bitarray.h"
50#include "hard-interface.h"
51#include "hash.h"
Martin Hundebølld56b1702013-01-25 11:12:39 +010052#include "network-coding.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020053#include "originator.h"
54#include "packet.h"
55#include "routing.h"
56#include "send.h"
57#include "translation-table.h"
Marek Lindnerfc957272011-07-30 12:04:12 +020058
Antonio Quartulli791c2a22013-08-17 12:44:44 +020059/**
Martin Hundebøll95298a92014-07-15 09:41:05 +020060 * enum batadv_dup_status - duplicate status
Markus Pargmann9f52ee12014-12-26 12:41:34 +010061 * @BATADV_NO_DUP: the packet is no duplicate
Antonio Quartulli791c2a22013-08-17 12:44:44 +020062 * @BATADV_ORIG_DUP: OGM is a duplicate in the originator (but not for the
63 * neighbor)
64 * @BATADV_NEIGH_DUP: OGM is a duplicate for the neighbor
65 * @BATADV_PROTECTED: originator is currently protected (after reboot)
66 */
67enum batadv_dup_status {
68 BATADV_NO_DUP = 0,
69 BATADV_ORIG_DUP,
70 BATADV_NEIGH_DUP,
71 BATADV_PROTECTED,
72};
73
Antonio Quartulli24a5dee2013-04-08 09:38:12 +020074/**
75 * batadv_ring_buffer_set - update the ring buffer with the given value
76 * @lq_recv: pointer to the ring buffer
77 * @lq_index: index to store the value at
78 * @value: value to store in the ring buffer
79 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +020080static void batadv_ring_buffer_set(u8 lq_recv[], u8 *lq_index, u8 value)
Antonio Quartulli24a5dee2013-04-08 09:38:12 +020081{
82 lq_recv[*lq_index] = value;
83 *lq_index = (*lq_index + 1) % BATADV_TQ_GLOBAL_WINDOW_SIZE;
84}
85
86/**
Markus Pargmannd491dbb2014-12-26 12:41:36 +010087 * batadv_ring_buffer_avg - compute the average of all non-zero values stored
Antonio Quartulli24a5dee2013-04-08 09:38:12 +020088 * in the given ring buffer
89 * @lq_recv: pointer to the ring buffer
90 *
91 * Returns computed average value.
92 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +020093static u8 batadv_ring_buffer_avg(const u8 lq_recv[])
Antonio Quartulli24a5dee2013-04-08 09:38:12 +020094{
Sven Eckelmann6b5e9712015-05-26 18:34:26 +020095 const u8 *ptr;
96 u16 count = 0;
97 u16 i = 0;
98 u16 sum = 0;
Antonio Quartulli24a5dee2013-04-08 09:38:12 +020099
100 ptr = lq_recv;
101
102 while (i < BATADV_TQ_GLOBAL_WINDOW_SIZE) {
103 if (*ptr != 0) {
104 count++;
105 sum += *ptr;
106 }
107
108 i++;
109 ptr++;
110 }
111
112 if (count == 0)
113 return 0;
114
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200115 return (u8)(sum / count);
Antonio Quartulli24a5dee2013-04-08 09:38:12 +0200116}
David S. Millerd98cae64e2013-06-19 16:49:39 -0700117
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200118/**
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200119 * batadv_iv_ogm_orig_free - free the private resources allocated for this
120 * orig_node
121 * @orig_node: the orig_node for which the resources have to be free'd
122 */
123static void batadv_iv_ogm_orig_free(struct batadv_orig_node *orig_node)
124{
125 kfree(orig_node->bat_iv.bcast_own);
126 kfree(orig_node->bat_iv.bcast_own_sum);
127}
128
129/**
130 * batadv_iv_ogm_orig_add_if - change the private structures of the orig_node to
131 * include the new hard-interface
132 * @orig_node: the orig_node that has to be changed
133 * @max_if_num: the current amount of interfaces
134 *
135 * Returns 0 on success, a negative error code otherwise.
136 */
137static int batadv_iv_ogm_orig_add_if(struct batadv_orig_node *orig_node,
138 int max_if_num)
139{
140 void *data_ptr;
Antonio Quartulli0185dda2014-05-24 06:43:47 +0200141 size_t old_size;
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200142 int ret = -ENOMEM;
143
144 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
145
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200146 old_size = (max_if_num - 1) * sizeof(unsigned long) * BATADV_NUM_WORDS;
Antonio Quartulli0185dda2014-05-24 06:43:47 +0200147 data_ptr = kmalloc_array(max_if_num,
148 BATADV_NUM_WORDS * sizeof(unsigned long),
149 GFP_ATOMIC);
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200150 if (!data_ptr)
151 goto unlock;
152
153 memcpy(data_ptr, orig_node->bat_iv.bcast_own, old_size);
154 kfree(orig_node->bat_iv.bcast_own);
155 orig_node->bat_iv.bcast_own = data_ptr;
156
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200157 data_ptr = kmalloc_array(max_if_num, sizeof(u8), GFP_ATOMIC);
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200158 if (!data_ptr) {
159 kfree(orig_node->bat_iv.bcast_own);
160 goto unlock;
161 }
162
163 memcpy(data_ptr, orig_node->bat_iv.bcast_own_sum,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200164 (max_if_num - 1) * sizeof(u8));
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200165 kfree(orig_node->bat_iv.bcast_own_sum);
166 orig_node->bat_iv.bcast_own_sum = data_ptr;
167
168 ret = 0;
169
170unlock:
171 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
172
173 return ret;
174}
175
176/**
177 * batadv_iv_ogm_orig_del_if - change the private structures of the orig_node to
178 * exclude the removed interface
179 * @orig_node: the orig_node that has to be changed
180 * @max_if_num: the current amount of interfaces
181 * @del_if_num: the index of the interface being removed
182 *
183 * Returns 0 on success, a negative error code otherwise.
184 */
185static int batadv_iv_ogm_orig_del_if(struct batadv_orig_node *orig_node,
186 int max_if_num, int del_if_num)
187{
188 int chunk_size, ret = -ENOMEM, if_offset;
189 void *data_ptr = NULL;
190
191 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
192
193 /* last interface was removed */
194 if (max_if_num == 0)
195 goto free_bcast_own;
196
197 chunk_size = sizeof(unsigned long) * BATADV_NUM_WORDS;
Antonio Quartulli0185dda2014-05-24 06:43:47 +0200198 data_ptr = kmalloc_array(max_if_num, chunk_size, GFP_ATOMIC);
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200199 if (!data_ptr)
200 goto unlock;
201
202 /* copy first part */
203 memcpy(data_ptr, orig_node->bat_iv.bcast_own, del_if_num * chunk_size);
204
205 /* copy second part */
206 memcpy((char *)data_ptr + del_if_num * chunk_size,
207 orig_node->bat_iv.bcast_own + ((del_if_num + 1) * chunk_size),
208 (max_if_num - del_if_num) * chunk_size);
209
210free_bcast_own:
211 kfree(orig_node->bat_iv.bcast_own);
212 orig_node->bat_iv.bcast_own = data_ptr;
213
214 if (max_if_num == 0)
215 goto free_own_sum;
216
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200217 data_ptr = kmalloc_array(max_if_num, sizeof(u8), GFP_ATOMIC);
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200218 if (!data_ptr) {
219 kfree(orig_node->bat_iv.bcast_own);
220 goto unlock;
221 }
222
223 memcpy(data_ptr, orig_node->bat_iv.bcast_own_sum,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200224 del_if_num * sizeof(u8));
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200225
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200226 if_offset = (del_if_num + 1) * sizeof(u8);
227 memcpy((char *)data_ptr + del_if_num * sizeof(u8),
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200228 orig_node->bat_iv.bcast_own_sum + if_offset,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200229 (max_if_num - del_if_num) * sizeof(u8));
Antonio Quartullid0015fd2013-09-03 11:10:23 +0200230
231free_own_sum:
232 kfree(orig_node->bat_iv.bcast_own_sum);
233 orig_node->bat_iv.bcast_own_sum = data_ptr;
234
235 ret = 0;
236unlock:
237 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
238
239 return ret;
240}
241
242/**
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200243 * batadv_iv_ogm_orig_get - retrieve or create (if does not exist) an originator
244 * @bat_priv: the bat priv with all the soft interface information
245 * @addr: mac address of the originator
246 *
247 * Returns the originator object corresponding to the passed mac address or NULL
248 * on failure.
249 * If the object does not exists it is created an initialised.
250 */
251static struct batadv_orig_node *
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200252batadv_iv_ogm_orig_get(struct batadv_priv *bat_priv, const u8 *addr)
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200253{
254 struct batadv_orig_node *orig_node;
255 int size, hash_added;
256
257 orig_node = batadv_orig_hash_find(bat_priv, addr);
258 if (orig_node)
259 return orig_node;
260
261 orig_node = batadv_orig_node_new(bat_priv, addr);
262 if (!orig_node)
263 return NULL;
264
265 spin_lock_init(&orig_node->bat_iv.ogm_cnt_lock);
266
267 size = bat_priv->num_ifaces * sizeof(unsigned long) * BATADV_NUM_WORDS;
268 orig_node->bat_iv.bcast_own = kzalloc(size, GFP_ATOMIC);
269 if (!orig_node->bat_iv.bcast_own)
270 goto free_orig_node;
271
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200272 size = bat_priv->num_ifaces * sizeof(u8);
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200273 orig_node->bat_iv.bcast_own_sum = kzalloc(size, GFP_ATOMIC);
274 if (!orig_node->bat_iv.bcast_own_sum)
Antonio Quartullia5a5cb82014-02-15 02:17:20 +0100275 goto free_orig_node;
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200276
277 hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,
278 batadv_choose_orig, orig_node,
279 &orig_node->hash_entry);
280 if (hash_added != 0)
Antonio Quartullia5a5cb82014-02-15 02:17:20 +0100281 goto free_orig_node;
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200282
283 return orig_node;
284
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200285free_orig_node:
Simon Wunderlichb2262df2014-02-08 16:45:06 +0100286 /* free twice, as batadv_orig_node_new sets refcount to 2 */
287 batadv_orig_node_free_ref(orig_node);
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200288 batadv_orig_node_free_ref(orig_node);
289
290 return NULL;
291}
292
Sven Eckelmann56303d32012-06-05 22:31:31 +0200293static struct batadv_neigh_node *
294batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200295 const u8 *neigh_addr,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200296 struct batadv_orig_node *orig_node,
Antonio Quartulli863dd7a2013-03-25 13:49:46 +0100297 struct batadv_orig_node *orig_neigh)
Marek Lindner7ae8b282012-03-01 15:35:21 +0800298{
Marek Lindner741aa062015-07-26 04:57:43 +0800299 struct batadv_neigh_node *neigh_node;
Marek Lindner7ae8b282012-03-01 15:35:21 +0800300
Marek Lindner3f32f8a2015-07-26 04:59:15 +0800301 neigh_node = batadv_neigh_node_new(orig_node, hard_iface, neigh_addr);
Marek Lindner7ae8b282012-03-01 15:35:21 +0800302 if (!neigh_node)
303 goto out;
304
Simon Wunderlich89652332013-11-13 19:14:46 +0100305 neigh_node->orig_node = orig_neigh;
Marek Lindner7ae8b282012-03-01 15:35:21 +0800306
Marek Lindner7ae8b282012-03-01 15:35:21 +0800307out:
308 return neigh_node;
309}
310
Sven Eckelmann56303d32012-06-05 22:31:31 +0200311static int batadv_iv_ogm_iface_enable(struct batadv_hard_iface *hard_iface)
Marek Lindnerd0b9fd82011-07-30 12:33:33 +0200312{
Sven Eckelmann96412692012-06-05 22:31:30 +0200313 struct batadv_ogm_packet *batadv_ogm_packet;
Marek Lindner14511512012-08-02 17:20:26 +0200314 unsigned char *ogm_buff;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200315 u32 random_seqno;
Marek Lindnerd7d32ec2012-02-07 17:20:46 +0800316
317 /* randomize initial seqno to avoid collision */
318 get_random_bytes(&random_seqno, sizeof(random_seqno));
Marek Lindner14511512012-08-02 17:20:26 +0200319 atomic_set(&hard_iface->bat_iv.ogm_seqno, random_seqno);
Marek Lindnerd0b9fd82011-07-30 12:33:33 +0200320
Marek Lindner14511512012-08-02 17:20:26 +0200321 hard_iface->bat_iv.ogm_buff_len = BATADV_OGM_HLEN;
322 ogm_buff = kmalloc(hard_iface->bat_iv.ogm_buff_len, GFP_ATOMIC);
323 if (!ogm_buff)
Markus Pargmann42d9f2c2014-12-26 12:41:26 +0100324 return -ENOMEM;
Marek Lindner77af7572012-02-07 17:20:48 +0800325
Marek Lindner14511512012-08-02 17:20:26 +0200326 hard_iface->bat_iv.ogm_buff = ogm_buff;
327
328 batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100329 batadv_ogm_packet->packet_type = BATADV_IV_OGM;
330 batadv_ogm_packet->version = BATADV_COMPAT_VERSION;
331 batadv_ogm_packet->ttl = 2;
Sven Eckelmann96412692012-06-05 22:31:30 +0200332 batadv_ogm_packet->flags = BATADV_NO_FLAGS;
Marek Lindner414254e2013-04-23 21:39:58 +0800333 batadv_ogm_packet->reserved = 0;
Sven Eckelmann96412692012-06-05 22:31:30 +0200334 batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE;
Marek Lindner77af7572012-02-07 17:20:48 +0800335
Markus Pargmann42d9f2c2014-12-26 12:41:26 +0100336 return 0;
Marek Lindnerd0b9fd82011-07-30 12:33:33 +0200337}
338
Sven Eckelmann56303d32012-06-05 22:31:31 +0200339static void batadv_iv_ogm_iface_disable(struct batadv_hard_iface *hard_iface)
Marek Lindner00a50072012-02-07 17:20:47 +0800340{
Marek Lindner14511512012-08-02 17:20:26 +0200341 kfree(hard_iface->bat_iv.ogm_buff);
342 hard_iface->bat_iv.ogm_buff = NULL;
Marek Lindner00a50072012-02-07 17:20:47 +0800343}
344
Sven Eckelmann56303d32012-06-05 22:31:31 +0200345static void batadv_iv_ogm_iface_update_mac(struct batadv_hard_iface *hard_iface)
Marek Lindnerd0b9fd82011-07-30 12:33:33 +0200346{
Sven Eckelmann96412692012-06-05 22:31:30 +0200347 struct batadv_ogm_packet *batadv_ogm_packet;
Marek Lindner14511512012-08-02 17:20:26 +0200348 unsigned char *ogm_buff = hard_iface->bat_iv.ogm_buff;
Marek Lindnerd0b9fd82011-07-30 12:33:33 +0200349
Marek Lindner14511512012-08-02 17:20:26 +0200350 batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100351 ether_addr_copy(batadv_ogm_packet->orig,
352 hard_iface->net_dev->dev_addr);
353 ether_addr_copy(batadv_ogm_packet->prev_sender,
354 hard_iface->net_dev->dev_addr);
Marek Lindnerd0b9fd82011-07-30 12:33:33 +0200355}
356
Sven Eckelmann56303d32012-06-05 22:31:31 +0200357static void
358batadv_iv_ogm_primary_iface_set(struct batadv_hard_iface *hard_iface)
Marek Lindnerc3229392012-03-11 06:17:50 +0800359{
Sven Eckelmann96412692012-06-05 22:31:30 +0200360 struct batadv_ogm_packet *batadv_ogm_packet;
Marek Lindner14511512012-08-02 17:20:26 +0200361 unsigned char *ogm_buff = hard_iface->bat_iv.ogm_buff;
Marek Lindnerc3229392012-03-11 06:17:50 +0800362
Marek Lindner14511512012-08-02 17:20:26 +0200363 batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
Sven Eckelmann96412692012-06-05 22:31:30 +0200364 batadv_ogm_packet->flags = BATADV_PRIMARIES_FIRST_HOP;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100365 batadv_ogm_packet->ttl = BATADV_TTL;
Marek Lindnerc3229392012-03-11 06:17:50 +0800366}
367
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200368/* when do we schedule our own ogm to be sent */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200369static unsigned long
Sven Eckelmann56303d32012-06-05 22:31:31 +0200370batadv_iv_ogm_emit_send_time(const struct batadv_priv *bat_priv)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200371{
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200372 unsigned int msecs;
373
374 msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER;
Akinobu Mitae76e4322012-12-24 11:14:07 +0900375 msecs += prandom_u32() % (2 * BATADV_JITTER);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200376
377 return jiffies + msecs_to_jiffies(msecs);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200378}
379
380/* when do we schedule a ogm packet to be sent */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200381static unsigned long batadv_iv_ogm_fwd_send_time(void)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200382{
Akinobu Mitae76e4322012-12-24 11:14:07 +0900383 return jiffies + msecs_to_jiffies(prandom_u32() % (BATADV_JITTER / 2));
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200384}
385
386/* apply hop penalty for a normal link */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200387static u8 batadv_hop_penalty(u8 tq, const struct batadv_priv *bat_priv)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200388{
389 int hop_penalty = atomic_read(&bat_priv->hop_penalty);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200390 int new_tq;
391
392 new_tq = tq * (BATADV_TQ_MAX_VALUE - hop_penalty);
393 new_tq /= BATADV_TQ_MAX_VALUE;
394
395 return new_tq;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200396}
397
Marek Lindnerfc957272011-07-30 12:04:12 +0200398/* is there another aggregated packet here? */
Markus Pargmann9fd9b192014-12-26 12:41:27 +0100399static bool batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len,
400 __be16 tvlv_len)
Marek Lindnerfc957272011-07-30 12:04:12 +0200401{
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200402 int next_buff_pos = 0;
403
Sven Eckelmann7e071c72012-06-03 22:19:13 +0200404 next_buff_pos += buff_pos + BATADV_OGM_HLEN;
Marek Lindneref261572013-04-23 21:39:57 +0800405 next_buff_pos += ntohs(tvlv_len);
Marek Lindnerfc957272011-07-30 12:04:12 +0200406
407 return (next_buff_pos <= packet_len) &&
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200408 (next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES);
Marek Lindnerfc957272011-07-30 12:04:12 +0200409}
410
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200411/* send a batman ogm to a given interface */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200412static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,
413 struct batadv_hard_iface *hard_iface)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200414{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200415 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Markus Pargmannde12bae2014-12-26 12:41:28 +0100416 const char *fwd_str;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200417 u8 packet_num;
418 s16 buff_pos;
Sven Eckelmann96412692012-06-05 22:31:30 +0200419 struct batadv_ogm_packet *batadv_ogm_packet;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200420 struct sk_buff *skb;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200421 u8 *packet_pos;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200422
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200423 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200424 return;
425
426 packet_num = 0;
427 buff_pos = 0;
Sven Eckelmannc67893d2012-07-08 18:33:51 +0200428 packet_pos = forw_packet->skb->data;
429 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200430
431 /* adjust all flags and log packets */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200432 while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
Marek Lindneref261572013-04-23 21:39:57 +0800433 batadv_ogm_packet->tvlv_len)) {
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200434 /* we might have aggregated direct link packets with an
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200435 * ordinary base packet
436 */
Sven Eckelmann8de47de2012-07-08 16:32:09 +0200437 if (forw_packet->direct_link_flags & BIT(packet_num) &&
438 forw_packet->if_incoming == hard_iface)
Sven Eckelmann96412692012-06-05 22:31:30 +0200439 batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200440 else
Sven Eckelmann96412692012-06-05 22:31:30 +0200441 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200442
Sven Eckelmannc67893d2012-07-08 18:33:51 +0200443 if (packet_num > 0 || !forw_packet->own)
444 fwd_str = "Forwarding";
445 else
446 fwd_str = "Sending own";
447
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200448 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Marek Lindnere1bf0c12013-04-23 21:40:01 +0800449 "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s) on interface %s [%pM]\n",
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200450 fwd_str, (packet_num > 0 ? "aggregated " : ""),
Sven Eckelmann96412692012-06-05 22:31:30 +0200451 batadv_ogm_packet->orig,
452 ntohl(batadv_ogm_packet->seqno),
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100453 batadv_ogm_packet->tq, batadv_ogm_packet->ttl,
Sven Eckelmanna2f2b6c2015-04-23 18:22:24 +0200454 ((batadv_ogm_packet->flags & BATADV_DIRECTLINK) ?
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200455 "on" : "off"),
Marek Lindnere1bf0c12013-04-23 21:40:01 +0800456 hard_iface->net_dev->name,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200457 hard_iface->net_dev->dev_addr);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200458
Sven Eckelmann7e071c72012-06-03 22:19:13 +0200459 buff_pos += BATADV_OGM_HLEN;
Marek Lindneref261572013-04-23 21:39:57 +0800460 buff_pos += ntohs(batadv_ogm_packet->tvlv_len);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200461 packet_num++;
Sven Eckelmannc67893d2012-07-08 18:33:51 +0200462 packet_pos = forw_packet->skb->data + buff_pos;
463 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200464 }
465
466 /* create clone because function is called more than once */
467 skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
Martin Hundebøllf8214862012-04-20 17:02:45 +0200468 if (skb) {
Sven Eckelmannd69909d2012-06-03 22:19:20 +0200469 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_TX);
470 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_TX_BYTES,
Martin Hundebøllf8214862012-04-20 17:02:45 +0200471 skb->len + ETH_HLEN);
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200472 batadv_send_skb_packet(skb, hard_iface, batadv_broadcast_addr);
Martin Hundebøllf8214862012-04-20 17:02:45 +0200473 }
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200474}
475
476/* send a batman ogm packet */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200477static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200478{
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200479 struct net_device *soft_iface;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200480 struct batadv_priv *bat_priv;
481 struct batadv_hard_iface *primary_if = NULL;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200482
483 if (!forw_packet->if_incoming) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100484 pr_err("Error - can't forward packet: incoming iface not specified\n");
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200485 goto out;
486 }
487
488 soft_iface = forw_packet->if_incoming->soft_iface;
489 bat_priv = netdev_priv(soft_iface);
490
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100491 if (WARN_ON(!forw_packet->if_outgoing))
492 goto out;
493
494 if (WARN_ON(forw_packet->if_outgoing->soft_iface != soft_iface))
495 goto out;
496
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200497 if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200498 goto out;
499
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200500 primary_if = batadv_primary_if_get_selected(bat_priv);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200501 if (!primary_if)
502 goto out;
503
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100504 /* only for one specific outgoing interface */
505 batadv_iv_ogm_send_to_if(forw_packet, forw_packet->if_outgoing);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200506
507out:
508 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200509 batadv_hardif_free_ref(primary_if);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200510}
511
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100512/**
513 * batadv_iv_ogm_can_aggregate - find out if an OGM can be aggregated on an
514 * existing forward packet
515 * @new_bat_ogm_packet: OGM packet to be aggregated
516 * @bat_priv: the bat priv with all the soft interface information
517 * @packet_len: (total) length of the OGM
518 * @send_time: timestamp (jiffies) when the packet is to be sent
Martin Hundebøll95298a92014-07-15 09:41:05 +0200519 * @directlink: true if this is a direct link packet
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100520 * @if_incoming: interface where the packet was received
521 * @if_outgoing: interface for which the retransmission should be considered
522 * @forw_packet: the forwarded packet which should be checked
523 *
524 * Returns true if new_packet can be aggregated with forw_packet
525 */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200526static bool
Sven Eckelmann96412692012-06-05 22:31:30 +0200527batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200528 struct batadv_priv *bat_priv,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200529 int packet_len, unsigned long send_time,
530 bool directlink,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200531 const struct batadv_hard_iface *if_incoming,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100532 const struct batadv_hard_iface *if_outgoing,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200533 const struct batadv_forw_packet *forw_packet)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200534{
Sven Eckelmann96412692012-06-05 22:31:30 +0200535 struct batadv_ogm_packet *batadv_ogm_packet;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200536 int aggregated_bytes = forw_packet->packet_len + packet_len;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200537 struct batadv_hard_iface *primary_if = NULL;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200538 bool res = false;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200539 unsigned long aggregation_end_time;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200540
Sven Eckelmann96412692012-06-05 22:31:30 +0200541 batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200542 aggregation_end_time = send_time;
543 aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200544
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200545 /* we can aggregate the current packet to this aggregated packet
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200546 * if:
547 *
548 * - the send time is within our MAX_AGGREGATION_MS time
549 * - the resulting packet wont be bigger than
550 * MAX_AGGREGATION_BYTES
Markus Pargmann8f34b382014-12-26 12:41:29 +0100551 * otherwise aggregation is not possible
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200552 */
Markus Pargmann8f34b382014-12-26 12:41:29 +0100553 if (!time_before(send_time, forw_packet->send_time) ||
554 !time_after_eq(aggregation_end_time, forw_packet->send_time))
555 return false;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200556
Markus Pargmann8f34b382014-12-26 12:41:29 +0100557 if (aggregated_bytes > BATADV_MAX_AGGREGATION_BYTES)
558 return false;
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100559
Markus Pargmann8f34b382014-12-26 12:41:29 +0100560 /* packet is not leaving on the same interface. */
561 if (forw_packet->if_outgoing != if_outgoing)
562 return false;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200563
Markus Pargmann8f34b382014-12-26 12:41:29 +0100564 /* check aggregation compatibility
565 * -> direct link packets are broadcasted on
566 * their interface only
567 * -> aggregate packet if the current packet is
568 * a "global" packet as well as the base
569 * packet
570 */
571 primary_if = batadv_primary_if_get_selected(bat_priv);
572 if (!primary_if)
573 return false;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200574
Markus Pargmann8f34b382014-12-26 12:41:29 +0100575 /* packets without direct link flag and high TTL
576 * are flooded through the net
577 */
578 if (!directlink &&
579 !(batadv_ogm_packet->flags & BATADV_DIRECTLINK) &&
580 batadv_ogm_packet->ttl != 1 &&
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200581
Markus Pargmann8f34b382014-12-26 12:41:29 +0100582 /* own packets originating non-primary
583 * interfaces leave only that interface
584 */
585 (!forw_packet->own ||
586 forw_packet->if_incoming == primary_if)) {
587 res = true;
588 goto out;
589 }
590
591 /* if the incoming packet is sent via this one
592 * interface only - we still can aggregate
593 */
594 if (directlink &&
595 new_bat_ogm_packet->ttl == 1 &&
596 forw_packet->if_incoming == if_incoming &&
597
598 /* packets from direct neighbors or
599 * own secondary interface packets
600 * (= secondary interface packets in general)
601 */
602 (batadv_ogm_packet->flags & BATADV_DIRECTLINK ||
603 (forw_packet->own &&
604 forw_packet->if_incoming != primary_if))) {
605 res = true;
606 goto out;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200607 }
608
609out:
610 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200611 batadv_hardif_free_ref(primary_if);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200612 return res;
613}
614
Simon Wunderlich1b371d12014-01-15 21:17:54 +0100615/**
616 * batadv_iv_ogm_aggregate_new - create a new aggregated packet and add this
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100617 * packet to it.
618 * @packet_buff: pointer to the OGM
619 * @packet_len: (total) length of the OGM
620 * @send_time: timestamp (jiffies) when the packet is to be sent
621 * @direct_link: whether this OGM has direct link status
622 * @if_incoming: interface where the packet was received
623 * @if_outgoing: interface for which the retransmission should be considered
624 * @own_packet: true if it is a self-generated ogm
625 */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200626static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
627 int packet_len, unsigned long send_time,
628 bool direct_link,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200629 struct batadv_hard_iface *if_incoming,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100630 struct batadv_hard_iface *if_outgoing,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200631 int own_packet)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200632{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200633 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
634 struct batadv_forw_packet *forw_packet_aggr;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200635 unsigned char *skb_buff;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200636 unsigned int skb_size;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200637
638 if (!atomic_inc_not_zero(&if_incoming->refcount))
639 return;
640
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100641 if (!atomic_inc_not_zero(&if_outgoing->refcount))
642 goto out_free_incoming;
643
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200644 /* own packet should always be scheduled */
645 if (!own_packet) {
Sven Eckelmann3e348192012-05-16 20:23:22 +0200646 if (!batadv_atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200647 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200648 "batman packet queue full\n");
Markus Pargmann940d1562014-12-26 12:41:31 +0100649 goto out_free_outgoing;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200650 }
651 }
652
653 forw_packet_aggr = kmalloc(sizeof(*forw_packet_aggr), GFP_ATOMIC);
Markus Pargmann940d1562014-12-26 12:41:31 +0100654 if (!forw_packet_aggr)
655 goto out_nomem;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200656
Markus Pargmann940d1562014-12-26 12:41:31 +0100657 if (atomic_read(&bat_priv->aggregated_ogms) &&
658 packet_len < BATADV_MAX_AGGREGATION_BYTES)
Sven Eckelmann5b246572012-11-04 17:11:45 +0100659 skb_size = BATADV_MAX_AGGREGATION_BYTES;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200660 else
Sven Eckelmann5b246572012-11-04 17:11:45 +0100661 skb_size = packet_len;
662
Antonio Quartulli41ab6c42013-04-02 22:28:44 +0200663 skb_size += ETH_HLEN;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200664
Antonio Quartulli41ab6c42013-04-02 22:28:44 +0200665 forw_packet_aggr->skb = netdev_alloc_skb_ip_align(NULL, skb_size);
Markus Pargmann940d1562014-12-26 12:41:31 +0100666 if (!forw_packet_aggr->skb)
667 goto out_free_forw_packet;
Simon Wunderlichc54f38c2013-07-29 17:56:44 +0200668 forw_packet_aggr->skb->priority = TC_PRIO_CONTROL;
Antonio Quartulli41ab6c42013-04-02 22:28:44 +0200669 skb_reserve(forw_packet_aggr->skb, ETH_HLEN);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200670
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200671 skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
672 forw_packet_aggr->packet_len = packet_len;
673 memcpy(skb_buff, packet_buff, packet_len);
674
675 forw_packet_aggr->own = own_packet;
676 forw_packet_aggr->if_incoming = if_incoming;
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100677 forw_packet_aggr->if_outgoing = if_outgoing;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200678 forw_packet_aggr->num_packets = 0;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200679 forw_packet_aggr->direct_link_flags = BATADV_NO_FLAGS;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200680 forw_packet_aggr->send_time = send_time;
681
682 /* save packet direct link flag status */
683 if (direct_link)
684 forw_packet_aggr->direct_link_flags |= 1;
685
686 /* add new packet to packet list */
687 spin_lock_bh(&bat_priv->forw_bat_list_lock);
688 hlist_add_head(&forw_packet_aggr->list, &bat_priv->forw_bat_list);
689 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
690
691 /* start timer for this packet */
692 INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
Sven Eckelmann9455e342012-05-12 02:09:37 +0200693 batadv_send_outstanding_bat_ogm_packet);
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200694 queue_delayed_work(batadv_event_workqueue,
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200695 &forw_packet_aggr->delayed_work,
696 send_time - jiffies);
697
698 return;
Markus Pargmann940d1562014-12-26 12:41:31 +0100699out_free_forw_packet:
700 kfree(forw_packet_aggr);
701out_nomem:
702 if (!own_packet)
703 atomic_inc(&bat_priv->batman_queue_left);
704out_free_outgoing:
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100705 batadv_hardif_free_ref(if_outgoing);
706out_free_incoming:
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200707 batadv_hardif_free_ref(if_incoming);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200708}
709
710/* aggregate a new packet into the existing ogm packet */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200711static void batadv_iv_ogm_aggregate(struct batadv_forw_packet *forw_packet_aggr,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200712 const unsigned char *packet_buff,
713 int packet_len, bool direct_link)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200714{
715 unsigned char *skb_buff;
Sven Eckelmann8de47de2012-07-08 16:32:09 +0200716 unsigned long new_direct_link_flag;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200717
718 skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
719 memcpy(skb_buff, packet_buff, packet_len);
720 forw_packet_aggr->packet_len += packet_len;
721 forw_packet_aggr->num_packets++;
722
723 /* save packet direct link flag status */
Sven Eckelmann8de47de2012-07-08 16:32:09 +0200724 if (direct_link) {
725 new_direct_link_flag = BIT(forw_packet_aggr->num_packets);
726 forw_packet_aggr->direct_link_flags |= new_direct_link_flag;
727 }
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200728}
729
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100730/**
731 * batadv_iv_ogm_queue_add - queue up an OGM for transmission
732 * @bat_priv: the bat priv with all the soft interface information
733 * @packet_buff: pointer to the OGM
734 * @packet_len: (total) length of the OGM
735 * @if_incoming: interface where the packet was received
736 * @if_outgoing: interface for which the retransmission should be considered
737 * @own_packet: true if it is a self-generated ogm
738 * @send_time: timestamp (jiffies) when the packet is to be sent
739 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200740static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200741 unsigned char *packet_buff,
742 int packet_len,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200743 struct batadv_hard_iface *if_incoming,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100744 struct batadv_hard_iface *if_outgoing,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200745 int own_packet, unsigned long send_time)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200746{
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200747 /* _aggr -> pointer to the packet we want to aggregate with
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200748 * _pos -> pointer to the position in the queue
749 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200750 struct batadv_forw_packet *forw_packet_aggr = NULL;
751 struct batadv_forw_packet *forw_packet_pos = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +0200752 struct batadv_ogm_packet *batadv_ogm_packet;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200753 bool direct_link;
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200754 unsigned long max_aggregation_jiffies;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200755
Sven Eckelmann96412692012-06-05 22:31:30 +0200756 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff;
Markus Pargmann56489152014-12-26 12:41:32 +0100757 direct_link = !!(batadv_ogm_packet->flags & BATADV_DIRECTLINK);
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200758 max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200759
760 /* find position for the packet in the forward queue */
761 spin_lock_bh(&bat_priv->forw_bat_list_lock);
762 /* own packets are not to be aggregated */
Markus Pargmann56489152014-12-26 12:41:32 +0100763 if (atomic_read(&bat_priv->aggregated_ogms) && !own_packet) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800764 hlist_for_each_entry(forw_packet_pos,
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200765 &bat_priv->forw_bat_list, list) {
Sven Eckelmann96412692012-06-05 22:31:30 +0200766 if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200767 bat_priv, packet_len,
768 send_time, direct_link,
769 if_incoming,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100770 if_outgoing,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200771 forw_packet_pos)) {
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200772 forw_packet_aggr = forw_packet_pos;
773 break;
774 }
775 }
776 }
777
778 /* nothing to aggregate with - either aggregation disabled or no
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200779 * suitable aggregation packet found
780 */
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200781 if (!forw_packet_aggr) {
782 /* the following section can run without the lock */
783 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
784
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200785 /* if we could not aggregate this packet with one of the others
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200786 * we hold it back for a while, so that it might be aggregated
787 * later on
788 */
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200789 if (!own_packet && atomic_read(&bat_priv->aggregated_ogms))
790 send_time += max_aggregation_jiffies;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200791
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200792 batadv_iv_ogm_aggregate_new(packet_buff, packet_len,
793 send_time, direct_link,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100794 if_incoming, if_outgoing,
795 own_packet);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200796 } else {
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200797 batadv_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
798 packet_len, direct_link);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200799 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
800 }
801}
802
Sven Eckelmann56303d32012-06-05 22:31:31 +0200803static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200804 const struct ethhdr *ethhdr,
Sven Eckelmann96412692012-06-05 22:31:30 +0200805 struct batadv_ogm_packet *batadv_ogm_packet,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200806 bool is_single_hop_neigh,
807 bool is_from_best_next_hop,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100808 struct batadv_hard_iface *if_incoming,
809 struct batadv_hard_iface *if_outgoing)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200810{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200811 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200812 u16 tvlv_len;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200813
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100814 if (batadv_ogm_packet->ttl <= 1) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200815 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n");
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200816 return;
817 }
818
Marek Lindner13b25412012-03-11 06:17:53 +0800819 if (!is_from_best_next_hop) {
820 /* Mark the forwarded packet when it is not coming from our
821 * best next hop. We still need to forward the packet for our
822 * neighbor link quality detection to work in case the packet
823 * originated from a single hop neighbor. Otherwise we can
824 * simply drop the ogm.
825 */
826 if (is_single_hop_neigh)
Sven Eckelmann96412692012-06-05 22:31:30 +0200827 batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP;
Marek Lindner13b25412012-03-11 06:17:53 +0800828 else
829 return;
830 }
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200831
Marek Lindneref261572013-04-23 21:39:57 +0800832 tvlv_len = ntohs(batadv_ogm_packet->tvlv_len);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200833
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100834 batadv_ogm_packet->ttl--;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100835 ether_addr_copy(batadv_ogm_packet->prev_sender, ethhdr->h_source);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200836
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200837 /* apply hop penalty */
Sven Eckelmann96412692012-06-05 22:31:30 +0200838 batadv_ogm_packet->tq = batadv_hop_penalty(batadv_ogm_packet->tq,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200839 bat_priv);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200840
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200841 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200842 "Forwarding packet: tq: %i, ttl: %i\n",
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100843 batadv_ogm_packet->tq, batadv_ogm_packet->ttl);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200844
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200845 /* switch of primaries first hop flag when forwarding */
Sven Eckelmann96412692012-06-05 22:31:30 +0200846 batadv_ogm_packet->flags &= ~BATADV_PRIMARIES_FIRST_HOP;
Marek Lindner75cd33f2012-03-01 15:35:16 +0800847 if (is_single_hop_neigh)
Sven Eckelmann96412692012-06-05 22:31:30 +0200848 batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200849 else
Sven Eckelmann96412692012-06-05 22:31:30 +0200850 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200851
Sven Eckelmann96412692012-06-05 22:31:30 +0200852 batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet,
Marek Lindneref261572013-04-23 21:39:57 +0800853 BATADV_OGM_HLEN + tvlv_len,
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100854 if_incoming, if_outgoing, 0,
855 batadv_iv_ogm_fwd_send_time());
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200856}
857
Antonio Quartullid9896612013-04-17 17:44:43 +0200858/**
859 * batadv_iv_ogm_slide_own_bcast_window - bitshift own OGM broadcast windows for
860 * the given interface
861 * @hard_iface: the interface for which the windows have to be shifted
862 */
863static void
864batadv_iv_ogm_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
865{
866 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
867 struct batadv_hashtable *hash = bat_priv->orig_hash;
868 struct hlist_head *head;
869 struct batadv_orig_node *orig_node;
870 unsigned long *word;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200871 u32 i;
Antonio Quartullid9896612013-04-17 17:44:43 +0200872 size_t word_index;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200873 u8 *w;
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200874 int if_num;
Antonio Quartullid9896612013-04-17 17:44:43 +0200875
876 for (i = 0; i < hash->size; i++) {
877 head = &hash->table[i];
878
879 rcu_read_lock();
880 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200881 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
Antonio Quartullid9896612013-04-17 17:44:43 +0200882 word_index = hard_iface->if_num * BATADV_NUM_WORDS;
Antonio Quartulli32db6aa2014-09-01 14:37:29 +0200883 word = &orig_node->bat_iv.bcast_own[word_index];
Antonio Quartullid9896612013-04-17 17:44:43 +0200884
885 batadv_bit_get_packet(bat_priv, word, 1, 0);
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200886 if_num = hard_iface->if_num;
887 w = &orig_node->bat_iv.bcast_own_sum[if_num];
Antonio Quartullid9896612013-04-17 17:44:43 +0200888 *w = bitmap_weight(word, BATADV_TQ_LOCAL_WINDOW_SIZE);
Antonio Quartullibbad0a52013-09-02 12:15:02 +0200889 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
Antonio Quartullid9896612013-04-17 17:44:43 +0200890 }
891 rcu_read_unlock();
892 }
893}
894
Sven Eckelmann56303d32012-06-05 22:31:31 +0200895static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface)
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200896{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200897 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
Marek Lindner14511512012-08-02 17:20:26 +0200898 unsigned char **ogm_buff = &hard_iface->bat_iv.ogm_buff;
Sven Eckelmann96412692012-06-05 22:31:30 +0200899 struct batadv_ogm_packet *batadv_ogm_packet;
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100900 struct batadv_hard_iface *primary_if, *tmp_hard_iface;
Marek Lindner14511512012-08-02 17:20:26 +0200901 int *ogm_buff_len = &hard_iface->bat_iv.ogm_buff_len;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200902 u32 seqno;
903 u16 tvlv_len = 0;
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100904 unsigned long send_time;
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200905
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200906 primary_if = batadv_primary_if_get_selected(bat_priv);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200907
Marek Lindnere1bf0c12013-04-23 21:40:01 +0800908 if (hard_iface == primary_if) {
909 /* tt changes have to be committed before the tvlv data is
910 * appended as it may alter the tt tvlv container
911 */
912 batadv_tt_local_commit_changes(bat_priv);
Marek Lindneref261572013-04-23 21:39:57 +0800913 tvlv_len = batadv_tvlv_container_ogm_append(bat_priv, ogm_buff,
914 ogm_buff_len,
915 BATADV_OGM_HLEN);
Marek Lindnere1bf0c12013-04-23 21:40:01 +0800916 }
Marek Lindnerbe9aa4c2012-05-07 04:22:05 +0800917
Marek Lindner14511512012-08-02 17:20:26 +0200918 batadv_ogm_packet = (struct batadv_ogm_packet *)(*ogm_buff);
Marek Lindneref261572013-04-23 21:39:57 +0800919 batadv_ogm_packet->tvlv_len = htons(tvlv_len);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200920
921 /* change sequence number to network order */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200922 seqno = (u32)atomic_read(&hard_iface->bat_iv.ogm_seqno);
Sven Eckelmannbbb1f902012-07-08 17:13:15 +0200923 batadv_ogm_packet->seqno = htonl(seqno);
Marek Lindner14511512012-08-02 17:20:26 +0200924 atomic_inc(&hard_iface->bat_iv.ogm_seqno);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200925
Antonio Quartullid9896612013-04-17 17:44:43 +0200926 batadv_iv_ogm_slide_own_bcast_window(hard_iface);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200927
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100928 send_time = batadv_iv_ogm_emit_send_time(bat_priv);
929
930 if (hard_iface != primary_if) {
931 /* OGMs from secondary interfaces are only scheduled on their
932 * respective interfaces.
933 */
934 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff, *ogm_buff_len,
935 hard_iface, hard_iface, 1, send_time);
936 goto out;
937 }
938
939 /* OGMs from primary interfaces are scheduled on all
940 * interfaces.
941 */
942 rcu_read_lock();
943 list_for_each_entry_rcu(tmp_hard_iface, &batadv_hardif_list, list) {
944 if (tmp_hard_iface->soft_iface != hard_iface->soft_iface)
Sven Eckelmann87b40f52015-07-17 10:03:42 +0200945 continue;
Simon Wunderlichef0a9372013-11-13 19:14:49 +0100946 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff,
947 *ogm_buff_len, hard_iface,
948 tmp_hard_iface, 1, send_time);
949 }
950 rcu_read_unlock();
951
952out:
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200953 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200954 batadv_hardif_free_ref(primary_if);
Marek Lindnerb9dacc52011-08-03 09:09:30 +0200955}
956
Simon Wunderlich89652332013-11-13 19:14:46 +0100957/**
958 * batadv_iv_ogm_orig_update - use OGM to update corresponding data in an
959 * originator
960 * @bat_priv: the bat priv with all the soft interface information
961 * @orig_node: the orig node who originally emitted the ogm packet
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100962 * @orig_ifinfo: ifinfo for the outgoing interface of the orig_node
Simon Wunderlich89652332013-11-13 19:14:46 +0100963 * @ethhdr: Ethernet header of the OGM
964 * @batadv_ogm_packet: the ogm packet
965 * @if_incoming: interface where the packet was received
966 * @if_outgoing: interface for which the retransmission should be considered
Simon Wunderlich89652332013-11-13 19:14:46 +0100967 * @dup_status: the duplicate status of this ogm packet.
968 */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200969static void
Sven Eckelmann56303d32012-06-05 22:31:31 +0200970batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
971 struct batadv_orig_node *orig_node,
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100972 struct batadv_orig_ifinfo *orig_ifinfo,
Sven Eckelmannfe8bc392012-05-12 18:33:51 +0200973 const struct ethhdr *ethhdr,
Sven Eckelmann96412692012-06-05 22:31:30 +0200974 const struct batadv_ogm_packet *batadv_ogm_packet,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200975 struct batadv_hard_iface *if_incoming,
Simon Wunderlich89652332013-11-13 19:14:46 +0100976 struct batadv_hard_iface *if_outgoing,
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +0200977 enum batadv_dup_status dup_status)
Marek Lindnerfc957272011-07-30 12:04:12 +0200978{
Simon Wunderlich89652332013-11-13 19:14:46 +0100979 struct batadv_neigh_ifinfo *neigh_ifinfo = NULL;
980 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
Sven Eckelmann4f248cf2015-06-09 20:50:49 +0200981 struct batadv_neigh_node *neigh_node = NULL;
982 struct batadv_neigh_node *tmp_neigh_node = NULL;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200983 struct batadv_neigh_node *router = NULL;
984 struct batadv_orig_node *orig_node_tmp;
Linus Lüssing7caf69f2012-09-18 03:01:08 +0200985 int if_num;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200986 u8 sum_orig, sum_neigh;
987 u8 *neigh_addr;
988 u8 tq_avg;
Marek Lindnerfc957272011-07-30 12:04:12 +0200989
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200990 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200991 "update_originator(): Searching and updating originator entry of received packet\n");
Marek Lindnerfc957272011-07-30 12:04:12 +0200992
993 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800994 hlist_for_each_entry_rcu(tmp_neigh_node,
Marek Lindnerfc957272011-07-30 12:04:12 +0200995 &orig_node->neigh_list, list) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200996 neigh_addr = tmp_neigh_node->addr;
997 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
998 tmp_neigh_node->if_incoming == if_incoming &&
999 atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
Antonio Quartulli38dc40e2013-03-30 17:22:00 +01001000 if (WARN(neigh_node, "too many matching neigh_nodes"))
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001001 batadv_neigh_node_free_ref(neigh_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001002 neigh_node = tmp_neigh_node;
1003 continue;
1004 }
1005
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001006 if (dup_status != BATADV_NO_DUP)
Marek Lindnerfc957272011-07-30 12:04:12 +02001007 continue;
1008
Simon Wunderlich89652332013-11-13 19:14:46 +01001009 /* only update the entry for this outgoing interface */
1010 neigh_ifinfo = batadv_neigh_ifinfo_get(tmp_neigh_node,
1011 if_outgoing);
1012 if (!neigh_ifinfo)
1013 continue;
1014
1015 spin_lock_bh(&tmp_neigh_node->ifinfo_lock);
1016 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
1017 &neigh_ifinfo->bat_iv.tq_index, 0);
1018 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
1019 neigh_ifinfo->bat_iv.tq_avg = tq_avg;
1020 spin_unlock_bh(&tmp_neigh_node->ifinfo_lock);
1021
1022 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1023 neigh_ifinfo = NULL;
Marek Lindnerfc957272011-07-30 12:04:12 +02001024 }
1025
1026 if (!neigh_node) {
Sven Eckelmann56303d32012-06-05 22:31:31 +02001027 struct batadv_orig_node *orig_tmp;
Marek Lindnerfc957272011-07-30 12:04:12 +02001028
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001029 orig_tmp = batadv_iv_ogm_orig_get(bat_priv, ethhdr->h_source);
Marek Lindnerfc957272011-07-30 12:04:12 +02001030 if (!orig_tmp)
1031 goto unlock;
1032
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001033 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
1034 ethhdr->h_source,
Antonio Quartulli863dd7a2013-03-25 13:49:46 +01001035 orig_node, orig_tmp);
Marek Lindnerfc957272011-07-30 12:04:12 +02001036
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001037 batadv_orig_node_free_ref(orig_tmp);
Marek Lindnerfc957272011-07-30 12:04:12 +02001038 if (!neigh_node)
1039 goto unlock;
Markus Pargmann23badd62014-12-26 12:41:33 +01001040 } else {
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001041 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001042 "Updating existing last-hop neighbor of originator\n");
Markus Pargmann23badd62014-12-26 12:41:33 +01001043 }
Marek Lindnerfc957272011-07-30 12:04:12 +02001044
1045 rcu_read_unlock();
Simon Wunderlich89652332013-11-13 19:14:46 +01001046 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
1047 if (!neigh_ifinfo)
1048 goto out;
Marek Lindnerfc957272011-07-30 12:04:12 +02001049
Marek Lindnerd7b2a972012-03-01 15:35:19 +08001050 neigh_node->last_seen = jiffies;
Marek Lindnerfc957272011-07-30 12:04:12 +02001051
Simon Wunderlich89652332013-11-13 19:14:46 +01001052 spin_lock_bh(&neigh_node->ifinfo_lock);
1053 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
1054 &neigh_ifinfo->bat_iv.tq_index,
Sven Eckelmann96412692012-06-05 22:31:30 +02001055 batadv_ogm_packet->tq);
Simon Wunderlich89652332013-11-13 19:14:46 +01001056 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
1057 neigh_ifinfo->bat_iv.tq_avg = tq_avg;
1058 spin_unlock_bh(&neigh_node->ifinfo_lock);
Marek Lindnerfc957272011-07-30 12:04:12 +02001059
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001060 if (dup_status == BATADV_NO_DUP) {
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001061 orig_ifinfo->last_ttl = batadv_ogm_packet->ttl;
Simon Wunderlich89652332013-11-13 19:14:46 +01001062 neigh_ifinfo->last_ttl = batadv_ogm_packet->ttl;
Marek Lindnerfc957272011-07-30 12:04:12 +02001063 }
1064
Marek Lindnerfc957272011-07-30 12:04:12 +02001065 /* if this neighbor already is our next hop there is nothing
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001066 * to change
1067 */
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001068 router = batadv_orig_router_get(orig_node, if_outgoing);
Marek Lindnerfc957272011-07-30 12:04:12 +02001069 if (router == neigh_node)
Marek Lindnere1bf0c12013-04-23 21:40:01 +08001070 goto out;
Marek Lindnerfc957272011-07-30 12:04:12 +02001071
Simon Wunderlich89652332013-11-13 19:14:46 +01001072 if (router) {
1073 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1074 if (!router_ifinfo)
1075 goto out;
1076
1077 /* if this neighbor does not offer a better TQ we won't
1078 * consider it
1079 */
1080 if (router_ifinfo->bat_iv.tq_avg > neigh_ifinfo->bat_iv.tq_avg)
1081 goto out;
1082 }
Marek Lindnerfc957272011-07-30 12:04:12 +02001083
1084 /* if the TQ is the same and the link not more symmetric we
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001085 * won't consider it either
1086 */
Simon Wunderlich89652332013-11-13 19:14:46 +01001087 if (router_ifinfo &&
Markus Pargmann01b97a32014-12-26 12:41:30 +01001088 neigh_ifinfo->bat_iv.tq_avg == router_ifinfo->bat_iv.tq_avg) {
Marek Lindnerfc957272011-07-30 12:04:12 +02001089 orig_node_tmp = router->orig_node;
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001090 spin_lock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
Linus Lüssing7caf69f2012-09-18 03:01:08 +02001091 if_num = router->if_incoming->if_num;
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001092 sum_orig = orig_node_tmp->bat_iv.bcast_own_sum[if_num];
1093 spin_unlock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
Marek Lindnerfc957272011-07-30 12:04:12 +02001094
1095 orig_node_tmp = neigh_node->orig_node;
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001096 spin_lock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
Linus Lüssing7caf69f2012-09-18 03:01:08 +02001097 if_num = neigh_node->if_incoming->if_num;
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001098 sum_neigh = orig_node_tmp->bat_iv.bcast_own_sum[if_num];
1099 spin_unlock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
Marek Lindnerfc957272011-07-30 12:04:12 +02001100
Sven Eckelmannbbb1f902012-07-08 17:13:15 +02001101 if (sum_orig >= sum_neigh)
Marek Lindnere1bf0c12013-04-23 21:40:01 +08001102 goto out;
Marek Lindnerfc957272011-07-30 12:04:12 +02001103 }
1104
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001105 batadv_update_route(bat_priv, orig_node, if_outgoing, neigh_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001106 goto out;
1107
1108unlock:
1109 rcu_read_unlock();
1110out:
1111 if (neigh_node)
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001112 batadv_neigh_node_free_ref(neigh_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001113 if (router)
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001114 batadv_neigh_node_free_ref(router);
Simon Wunderlich89652332013-11-13 19:14:46 +01001115 if (neigh_ifinfo)
1116 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1117 if (router_ifinfo)
1118 batadv_neigh_ifinfo_free_ref(router_ifinfo);
Marek Lindnerfc957272011-07-30 12:04:12 +02001119}
1120
Simon Wunderlich89652332013-11-13 19:14:46 +01001121/**
1122 * batadv_iv_ogm_calc_tq - calculate tq for current received ogm packet
1123 * @orig_node: the orig node who originally emitted the ogm packet
1124 * @orig_neigh_node: the orig node struct of the neighbor who sent the packet
1125 * @batadv_ogm_packet: the ogm packet
1126 * @if_incoming: interface where the packet was received
1127 * @if_outgoing: interface for which the retransmission should be considered
1128 *
1129 * Returns 1 if the link can be considered bidirectional, 0 otherwise
1130 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001131static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
1132 struct batadv_orig_node *orig_neigh_node,
Sven Eckelmann96412692012-06-05 22:31:30 +02001133 struct batadv_ogm_packet *batadv_ogm_packet,
Simon Wunderlich89652332013-11-13 19:14:46 +01001134 struct batadv_hard_iface *if_incoming,
1135 struct batadv_hard_iface *if_outgoing)
Marek Lindnerfc957272011-07-30 12:04:12 +02001136{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001137 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1138 struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;
Simon Wunderlich89652332013-11-13 19:14:46 +01001139 struct batadv_neigh_ifinfo *neigh_ifinfo;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001140 u8 total_count;
1141 u8 orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own;
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001142 unsigned int neigh_rq_inv_cube, neigh_rq_max_cube;
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001143 int tq_asym_penalty, inv_asym_penalty, if_num, ret = 0;
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001144 unsigned int combined_tq;
Simon Wunderlichc0398762013-11-13 19:14:48 +01001145 int tq_iface_penalty;
Marek Lindnerfc957272011-07-30 12:04:12 +02001146
1147 /* find corresponding one hop neighbor */
1148 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -08001149 hlist_for_each_entry_rcu(tmp_neigh_node,
Marek Lindnerfc957272011-07-30 12:04:12 +02001150 &orig_neigh_node->neigh_list, list) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001151 if (!batadv_compare_eth(tmp_neigh_node->addr,
1152 orig_neigh_node->orig))
Marek Lindnerfc957272011-07-30 12:04:12 +02001153 continue;
1154
1155 if (tmp_neigh_node->if_incoming != if_incoming)
1156 continue;
1157
1158 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
1159 continue;
1160
1161 neigh_node = tmp_neigh_node;
1162 break;
1163 }
1164 rcu_read_unlock();
1165
1166 if (!neigh_node)
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001167 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
1168 orig_neigh_node->orig,
1169 orig_neigh_node,
Antonio Quartulli863dd7a2013-03-25 13:49:46 +01001170 orig_neigh_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001171
1172 if (!neigh_node)
1173 goto out;
1174
Marek Lindnerd7b2a972012-03-01 15:35:19 +08001175 /* if orig_node is direct neighbor update neigh_node last_seen */
Marek Lindnerfc957272011-07-30 12:04:12 +02001176 if (orig_node == orig_neigh_node)
Marek Lindnerd7b2a972012-03-01 15:35:19 +08001177 neigh_node->last_seen = jiffies;
Marek Lindnerfc957272011-07-30 12:04:12 +02001178
Marek Lindnerd7b2a972012-03-01 15:35:19 +08001179 orig_node->last_seen = jiffies;
Marek Lindnerfc957272011-07-30 12:04:12 +02001180
1181 /* find packet count of corresponding one hop neighbor */
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001182 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1183 if_num = if_incoming->if_num;
1184 orig_eq_count = orig_neigh_node->bat_iv.bcast_own_sum[if_num];
Simon Wunderlich89652332013-11-13 19:14:46 +01001185 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
1186 if (neigh_ifinfo) {
1187 neigh_rq_count = neigh_ifinfo->bat_iv.real_packet_count;
1188 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1189 } else {
1190 neigh_rq_count = 0;
1191 }
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001192 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
Marek Lindnerfc957272011-07-30 12:04:12 +02001193
1194 /* pay attention to not get a value bigger than 100 % */
Sven Eckelmannc67893d2012-07-08 18:33:51 +02001195 if (orig_eq_count > neigh_rq_count)
1196 total_count = neigh_rq_count;
1197 else
1198 total_count = orig_eq_count;
Marek Lindnerfc957272011-07-30 12:04:12 +02001199
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001200 /* if we have too few packets (too less data) we set tq_own to zero
1201 * if we receive too few packets it is not considered bidirectional
1202 */
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001203 if (total_count < BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM ||
1204 neigh_rq_count < BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM)
Marek Lindnerfc957272011-07-30 12:04:12 +02001205 tq_own = 0;
1206 else
1207 /* neigh_node->real_packet_count is never zero as we
1208 * only purge old information when getting new
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001209 * information
1210 */
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001211 tq_own = (BATADV_TQ_MAX_VALUE * total_count) / neigh_rq_count;
Marek Lindnerfc957272011-07-30 12:04:12 +02001212
Sven Eckelmann21a12362012-03-07 09:07:46 +01001213 /* 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
Marek Lindnerfc957272011-07-30 12:04:12 +02001214 * affect the nearly-symmetric links only a little, but
1215 * punishes asymmetric links more. This will give a value
1216 * between 0 and TQ_MAX_VALUE
1217 */
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001218 neigh_rq_inv = BATADV_TQ_LOCAL_WINDOW_SIZE - neigh_rq_count;
1219 neigh_rq_inv_cube = neigh_rq_inv * neigh_rq_inv * neigh_rq_inv;
1220 neigh_rq_max_cube = BATADV_TQ_LOCAL_WINDOW_SIZE *
1221 BATADV_TQ_LOCAL_WINDOW_SIZE *
1222 BATADV_TQ_LOCAL_WINDOW_SIZE;
1223 inv_asym_penalty = BATADV_TQ_MAX_VALUE * neigh_rq_inv_cube;
1224 inv_asym_penalty /= neigh_rq_max_cube;
1225 tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty;
Marek Lindnerfc957272011-07-30 12:04:12 +02001226
Simon Wunderlichc0398762013-11-13 19:14:48 +01001227 /* penalize if the OGM is forwarded on the same interface. WiFi
1228 * interfaces and other half duplex devices suffer from throughput
1229 * drops as they can't send and receive at the same time.
1230 */
1231 tq_iface_penalty = BATADV_TQ_MAX_VALUE;
1232 if (if_outgoing && (if_incoming == if_outgoing) &&
1233 batadv_is_wifi_netdev(if_outgoing->net_dev))
1234 tq_iface_penalty = batadv_hop_penalty(BATADV_TQ_MAX_VALUE,
1235 bat_priv);
1236
1237 combined_tq = batadv_ogm_packet->tq *
1238 tq_own *
1239 tq_asym_penalty *
1240 tq_iface_penalty;
1241 combined_tq /= BATADV_TQ_MAX_VALUE *
1242 BATADV_TQ_MAX_VALUE *
1243 BATADV_TQ_MAX_VALUE;
Sven Eckelmann96412692012-06-05 22:31:30 +02001244 batadv_ogm_packet->tq = combined_tq;
Marek Lindnerfc957272011-07-30 12:04:12 +02001245
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001246 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Simon Wunderlichc0398762013-11-13 19:14:48 +01001247 "bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, iface_penalty: %3i, total tq: %3i, if_incoming = %s, if_outgoing = %s\n",
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001248 orig_node->orig, orig_neigh_node->orig, total_count,
Simon Wunderlichc0398762013-11-13 19:14:48 +01001249 neigh_rq_count, tq_own, tq_asym_penalty, tq_iface_penalty,
1250 batadv_ogm_packet->tq, if_incoming->net_dev->name,
1251 if_outgoing ? if_outgoing->net_dev->name : "DEFAULT");
Marek Lindnerfc957272011-07-30 12:04:12 +02001252
1253 /* if link has the minimum required transmission quality
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001254 * consider it bidirectional
1255 */
Sven Eckelmann96412692012-06-05 22:31:30 +02001256 if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
Marek Lindnerfc957272011-07-30 12:04:12 +02001257 ret = 1;
1258
1259out:
1260 if (neigh_node)
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001261 batadv_neigh_node_free_ref(neigh_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001262 return ret;
1263}
1264
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001265/**
1266 * batadv_iv_ogm_update_seqnos - process a batman packet for all interfaces,
1267 * adjust the sequence number and find out whether it is a duplicate
1268 * @ethhdr: ethernet header of the packet
1269 * @batadv_ogm_packet: OGM packet to be considered
1270 * @if_incoming: interface on which the OGM packet was received
Simon Wunderlich89652332013-11-13 19:14:46 +01001271 * @if_outgoing: interface for which the retransmission should be considered
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001272 *
1273 * Returns duplicate status as enum batadv_dup_status
Marek Lindnerfc957272011-07-30 12:04:12 +02001274 */
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001275static enum batadv_dup_status
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001276batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
Sven Eckelmann96412692012-06-05 22:31:30 +02001277 const struct batadv_ogm_packet *batadv_ogm_packet,
Simon Wunderlich89652332013-11-13 19:14:46 +01001278 const struct batadv_hard_iface *if_incoming,
1279 struct batadv_hard_iface *if_outgoing)
Marek Lindnerfc957272011-07-30 12:04:12 +02001280{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001281 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1282 struct batadv_orig_node *orig_node;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001283 struct batadv_orig_ifinfo *orig_ifinfo = NULL;
Simon Wunderlich89652332013-11-13 19:14:46 +01001284 struct batadv_neigh_node *neigh_node;
1285 struct batadv_neigh_ifinfo *neigh_ifinfo;
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001286 int is_dup;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001287 s32 seq_diff;
Marek Lindnerfc957272011-07-30 12:04:12 +02001288 int need_update = 0;
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001289 int set_mark;
1290 enum batadv_dup_status ret = BATADV_NO_DUP;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001291 u32 seqno = ntohl(batadv_ogm_packet->seqno);
1292 u8 *neigh_addr;
1293 u8 packet_count;
Antonio Quartulli0538f752013-09-02 12:15:01 +02001294 unsigned long *bitmap;
Marek Lindnerfc957272011-07-30 12:04:12 +02001295
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001296 orig_node = batadv_iv_ogm_orig_get(bat_priv, batadv_ogm_packet->orig);
Marek Lindnerfc957272011-07-30 12:04:12 +02001297 if (!orig_node)
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001298 return BATADV_NO_DUP;
Marek Lindnerfc957272011-07-30 12:04:12 +02001299
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001300 orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1301 if (WARN_ON(!orig_ifinfo)) {
1302 batadv_orig_node_free_ref(orig_node);
1303 return 0;
1304 }
1305
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001306 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001307 seq_diff = seqno - orig_ifinfo->last_real_seqno;
Marek Lindnerfc957272011-07-30 12:04:12 +02001308
1309 /* signalize caller that the packet is to be dropped. */
Antonio Quartulli1e5cc262012-02-26 15:39:42 +01001310 if (!hlist_empty(&orig_node->neigh_list) &&
Sven Eckelmann30d3c512012-05-12 02:09:36 +02001311 batadv_window_protected(bat_priv, seq_diff,
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001312 &orig_ifinfo->batman_seqno_reset)) {
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001313 ret = BATADV_PROTECTED;
Marek Lindnerfc957272011-07-30 12:04:12 +02001314 goto out;
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001315 }
Marek Lindnerfc957272011-07-30 12:04:12 +02001316
1317 rcu_read_lock();
Simon Wunderlich89652332013-11-13 19:14:46 +01001318 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1319 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node,
1320 if_outgoing);
1321 if (!neigh_ifinfo)
1322 continue;
1323
1324 neigh_addr = neigh_node->addr;
1325 is_dup = batadv_test_bit(neigh_ifinfo->bat_iv.real_bits,
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001326 orig_ifinfo->last_real_seqno,
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001327 seqno);
1328
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001329 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
Simon Wunderlich89652332013-11-13 19:14:46 +01001330 neigh_node->if_incoming == if_incoming) {
Marek Lindnerfc957272011-07-30 12:04:12 +02001331 set_mark = 1;
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001332 if (is_dup)
1333 ret = BATADV_NEIGH_DUP;
1334 } else {
Marek Lindnerfc957272011-07-30 12:04:12 +02001335 set_mark = 0;
Simon Wunderlich7c24bbb2013-05-23 13:07:42 +02001336 if (is_dup && (ret != BATADV_NEIGH_DUP))
1337 ret = BATADV_ORIG_DUP;
1338 }
Marek Lindnerfc957272011-07-30 12:04:12 +02001339
1340 /* if the window moved, set the update flag. */
Simon Wunderlich89652332013-11-13 19:14:46 +01001341 bitmap = neigh_ifinfo->bat_iv.real_bits;
Antonio Quartulli0538f752013-09-02 12:15:01 +02001342 need_update |= batadv_bit_get_packet(bat_priv, bitmap,
Sven Eckelmann0f5f9322012-05-12 02:09:25 +02001343 seq_diff, set_mark);
Marek Lindnerfc957272011-07-30 12:04:12 +02001344
Simon Wunderlich89652332013-11-13 19:14:46 +01001345 packet_count = bitmap_weight(bitmap,
Sven Eckelmannbbb1f902012-07-08 17:13:15 +02001346 BATADV_TQ_LOCAL_WINDOW_SIZE);
Simon Wunderlich89652332013-11-13 19:14:46 +01001347 neigh_ifinfo->bat_iv.real_packet_count = packet_count;
1348 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
Marek Lindnerfc957272011-07-30 12:04:12 +02001349 }
1350 rcu_read_unlock();
1351
1352 if (need_update) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001353 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001354 "%s updating last_seqno: old %u, new %u\n",
1355 if_outgoing ? if_outgoing->net_dev->name : "DEFAULT",
1356 orig_ifinfo->last_real_seqno, seqno);
1357 orig_ifinfo->last_real_seqno = seqno;
Marek Lindnerfc957272011-07-30 12:04:12 +02001358 }
1359
Marek Lindnerfc957272011-07-30 12:04:12 +02001360out:
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001361 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001362 batadv_orig_node_free_ref(orig_node);
Sven Eckelmanna0c77222015-03-01 16:56:26 +01001363 batadv_orig_ifinfo_free_ref(orig_ifinfo);
Marek Lindnerfc957272011-07-30 12:04:12 +02001364 return ret;
1365}
1366
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001367/**
1368 * batadv_iv_ogm_process_per_outif - process a batman iv OGM for an outgoing if
1369 * @skb: the skb containing the OGM
Martin Hundebøll95298a92014-07-15 09:41:05 +02001370 * @ogm_offset: offset from skb->data to start of ogm header
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001371 * @orig_node: the (cached) orig node for the originator of this OGM
1372 * @if_incoming: the interface where this packet was received
1373 * @if_outgoing: the interface for which the packet should be considered
1374 */
1375static void
1376batadv_iv_ogm_process_per_outif(const struct sk_buff *skb, int ogm_offset,
1377 struct batadv_orig_node *orig_node,
1378 struct batadv_hard_iface *if_incoming,
1379 struct batadv_hard_iface *if_outgoing)
1380{
1381 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
Sven Eckelmann4f248cf2015-06-09 20:50:49 +02001382 struct batadv_neigh_node *router = NULL;
1383 struct batadv_neigh_node *router_router = NULL;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001384 struct batadv_orig_node *orig_neigh_node;
1385 struct batadv_orig_ifinfo *orig_ifinfo;
1386 struct batadv_neigh_node *orig_neigh_router = NULL;
1387 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
1388 struct batadv_ogm_packet *ogm_packet;
1389 enum batadv_dup_status dup_status;
1390 bool is_from_best_next_hop = false;
1391 bool is_single_hop_neigh = false;
1392 bool sameseq, similar_ttl;
1393 struct sk_buff *skb_priv;
1394 struct ethhdr *ethhdr;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001395 u8 *prev_sender;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001396 int is_bidirect;
1397
1398 /* create a private copy of the skb, as some functions change tq value
1399 * and/or flags.
1400 */
1401 skb_priv = skb_copy(skb, GFP_ATOMIC);
1402 if (!skb_priv)
1403 return;
1404
1405 ethhdr = eth_hdr(skb_priv);
1406 ogm_packet = (struct batadv_ogm_packet *)(skb_priv->data + ogm_offset);
1407
1408 dup_status = batadv_iv_ogm_update_seqnos(ethhdr, ogm_packet,
1409 if_incoming, if_outgoing);
1410 if (batadv_compare_eth(ethhdr->h_source, ogm_packet->orig))
1411 is_single_hop_neigh = true;
1412
1413 if (dup_status == BATADV_PROTECTED) {
1414 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1415 "Drop packet: packet within seqno protection time (sender: %pM)\n",
1416 ethhdr->h_source);
1417 goto out;
1418 }
1419
1420 if (ogm_packet->tq == 0) {
1421 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1422 "Drop packet: originator packet with tq equal 0\n");
1423 goto out;
1424 }
1425
1426 router = batadv_orig_router_get(orig_node, if_outgoing);
1427 if (router) {
1428 router_router = batadv_orig_router_get(router->orig_node,
1429 if_outgoing);
1430 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1431 }
1432
1433 if ((router_ifinfo && router_ifinfo->bat_iv.tq_avg != 0) &&
1434 (batadv_compare_eth(router->addr, ethhdr->h_source)))
1435 is_from_best_next_hop = true;
1436
1437 prev_sender = ogm_packet->prev_sender;
1438 /* avoid temporary routing loops */
1439 if (router && router_router &&
1440 (batadv_compare_eth(router->addr, prev_sender)) &&
1441 !(batadv_compare_eth(ogm_packet->orig, prev_sender)) &&
1442 (batadv_compare_eth(router->addr, router_router->addr))) {
1443 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1444 "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
1445 ethhdr->h_source);
1446 goto out;
1447 }
1448
1449 if (if_outgoing == BATADV_IF_DEFAULT)
1450 batadv_tvlv_ogm_receive(bat_priv, ogm_packet, orig_node);
1451
1452 /* if sender is a direct neighbor the sender mac equals
1453 * originator mac
1454 */
1455 if (is_single_hop_neigh)
1456 orig_neigh_node = orig_node;
1457 else
1458 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1459 ethhdr->h_source);
1460
1461 if (!orig_neigh_node)
1462 goto out;
1463
1464 /* Update nc_nodes of the originator */
1465 batadv_nc_update_nc_node(bat_priv, orig_node, orig_neigh_node,
1466 ogm_packet, is_single_hop_neigh);
1467
1468 orig_neigh_router = batadv_orig_router_get(orig_neigh_node,
1469 if_outgoing);
1470
1471 /* drop packet if sender is not a direct neighbor and if we
1472 * don't route towards it
1473 */
1474 if (!is_single_hop_neigh && (!orig_neigh_router)) {
1475 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1476 "Drop packet: OGM via unknown neighbor!\n");
1477 goto out_neigh;
1478 }
1479
1480 is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node,
1481 ogm_packet, if_incoming,
1482 if_outgoing);
1483
1484 /* update ranking if it is not a duplicate or has the same
1485 * seqno and similar ttl as the non-duplicate
1486 */
1487 orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1488 if (!orig_ifinfo)
1489 goto out_neigh;
1490
1491 sameseq = orig_ifinfo->last_real_seqno == ntohl(ogm_packet->seqno);
1492 similar_ttl = (orig_ifinfo->last_ttl - 3) <= ogm_packet->ttl;
1493
1494 if (is_bidirect && ((dup_status == BATADV_NO_DUP) ||
1495 (sameseq && similar_ttl))) {
1496 batadv_iv_ogm_orig_update(bat_priv, orig_node,
1497 orig_ifinfo, ethhdr,
1498 ogm_packet, if_incoming,
1499 if_outgoing, dup_status);
1500 }
1501 batadv_orig_ifinfo_free_ref(orig_ifinfo);
1502
Simon Wunderlichef0a9372013-11-13 19:14:49 +01001503 /* only forward for specific interface, not for the default one. */
1504 if (if_outgoing == BATADV_IF_DEFAULT)
1505 goto out_neigh;
1506
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001507 /* is single hop (direct) neighbor */
1508 if (is_single_hop_neigh) {
1509 /* OGMs from secondary interfaces should only scheduled once
1510 * per interface where it has been received, not multiple times
1511 */
1512 if ((ogm_packet->ttl <= 2) &&
1513 (if_incoming != if_outgoing)) {
1514 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1515 "Drop packet: OGM from secondary interface and wrong outgoing interface\n");
1516 goto out_neigh;
1517 }
1518 /* mark direct link on incoming interface */
1519 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1520 is_single_hop_neigh,
Simon Wunderlichef0a9372013-11-13 19:14:49 +01001521 is_from_best_next_hop, if_incoming,
1522 if_outgoing);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001523
1524 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1525 "Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
1526 goto out_neigh;
1527 }
1528
1529 /* multihop originator */
1530 if (!is_bidirect) {
1531 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1532 "Drop packet: not received via bidirectional link\n");
1533 goto out_neigh;
1534 }
1535
1536 if (dup_status == BATADV_NEIGH_DUP) {
1537 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1538 "Drop packet: duplicate packet received\n");
1539 goto out_neigh;
1540 }
1541
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001542 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1543 "Forwarding packet: rebroadcast originator packet\n");
1544 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1545 is_single_hop_neigh, is_from_best_next_hop,
Simon Wunderlichef0a9372013-11-13 19:14:49 +01001546 if_incoming, if_outgoing);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001547
1548out_neigh:
1549 if ((orig_neigh_node) && (!is_single_hop_neigh))
1550 batadv_orig_node_free_ref(orig_neigh_node);
1551out:
Simon Wunderlichc1e517f2014-03-26 15:46:21 +01001552 if (router_ifinfo)
1553 batadv_neigh_ifinfo_free_ref(router_ifinfo);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001554 if (router)
1555 batadv_neigh_node_free_ref(router);
1556 if (router_router)
1557 batadv_neigh_node_free_ref(router_router);
1558 if (orig_neigh_router)
1559 batadv_neigh_node_free_ref(orig_neigh_router);
1560
1561 kfree_skb(skb_priv);
1562}
1563
1564/**
1565 * batadv_iv_ogm_process - process an incoming batman iv OGM
1566 * @skb: the skb containing the OGM
1567 * @ogm_offset: offset to the OGM which should be processed (for aggregates)
1568 * @if_incoming: the interface where this packet was receved
1569 */
1570static void batadv_iv_ogm_process(const struct sk_buff *skb, int ogm_offset,
Sven Eckelmann56303d32012-06-05 22:31:31 +02001571 struct batadv_hard_iface *if_incoming)
Marek Lindnerfc957272011-07-30 12:04:12 +02001572{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001573 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001574 struct batadv_orig_node *orig_neigh_node, *orig_node;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001575 struct batadv_hard_iface *hard_iface;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001576 struct batadv_ogm_packet *ogm_packet;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001577 u32 if_incoming_seqno;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001578 bool has_directlink_flag;
1579 struct ethhdr *ethhdr;
1580 bool is_my_oldorig = false;
1581 bool is_my_addr = false;
1582 bool is_my_orig = false;
1583
1584 ogm_packet = (struct batadv_ogm_packet *)(skb->data + ogm_offset);
1585 ethhdr = eth_hdr(skb);
Marek Lindnerfc957272011-07-30 12:04:12 +02001586
1587 /* Silently drop when the batman packet is actually not a
1588 * correct packet.
1589 *
1590 * This might happen if a packet is padded (e.g. Ethernet has a
1591 * minimum frame length of 64 byte) and the aggregation interprets
1592 * it as an additional length.
1593 *
1594 * TODO: A more sane solution would be to have a bit in the
Sven Eckelmann96412692012-06-05 22:31:30 +02001595 * batadv_ogm_packet to detect whether the packet is the last
Marek Lindnerfc957272011-07-30 12:04:12 +02001596 * packet in an aggregation. Here we expect that the padding
1597 * is always zero (or not 0x01)
1598 */
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001599 if (ogm_packet->packet_type != BATADV_IV_OGM)
Marek Lindnerfc957272011-07-30 12:04:12 +02001600 return;
1601
1602 /* could be changed by schedule_own_packet() */
Marek Lindner14511512012-08-02 17:20:26 +02001603 if_incoming_seqno = atomic_read(&if_incoming->bat_iv.ogm_seqno);
Marek Lindnerfc957272011-07-30 12:04:12 +02001604
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001605 if (ogm_packet->flags & BATADV_DIRECTLINK)
1606 has_directlink_flag = true;
Sven Eckelmannacd34af2012-06-03 22:19:21 +02001607 else
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001608 has_directlink_flag = false;
Marek Lindnerfc957272011-07-30 12:04:12 +02001609
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001610 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Marek Lindnere1bf0c12013-04-23 21:40:01 +08001611 "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, tq %d, TTL %d, V %d, IDF %d)\n",
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001612 ethhdr->h_source, if_incoming->net_dev->name,
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001613 if_incoming->net_dev->dev_addr, ogm_packet->orig,
1614 ogm_packet->prev_sender, ntohl(ogm_packet->seqno),
1615 ogm_packet->tq, ogm_packet->ttl,
1616 ogm_packet->version, has_directlink_flag);
Marek Lindnerfc957272011-07-30 12:04:12 +02001617
1618 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +02001619 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +02001620 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Marek Lindnerfc957272011-07-30 12:04:12 +02001621 continue;
1622
1623 if (hard_iface->soft_iface != if_incoming->soft_iface)
1624 continue;
1625
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001626 if (batadv_compare_eth(ethhdr->h_source,
1627 hard_iface->net_dev->dev_addr))
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001628 is_my_addr = true;
Marek Lindnerfc957272011-07-30 12:04:12 +02001629
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001630 if (batadv_compare_eth(ogm_packet->orig,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001631 hard_iface->net_dev->dev_addr))
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001632 is_my_orig = true;
Marek Lindnerfc957272011-07-30 12:04:12 +02001633
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001634 if (batadv_compare_eth(ogm_packet->prev_sender,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001635 hard_iface->net_dev->dev_addr))
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001636 is_my_oldorig = true;
Marek Lindnerfc957272011-07-30 12:04:12 +02001637 }
1638 rcu_read_unlock();
1639
Marek Lindnerfc957272011-07-30 12:04:12 +02001640 if (is_my_addr) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001641 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001642 "Drop packet: received my own broadcast (sender: %pM)\n",
1643 ethhdr->h_source);
Marek Lindnerfc957272011-07-30 12:04:12 +02001644 return;
1645 }
1646
Marek Lindnerfc957272011-07-30 12:04:12 +02001647 if (is_my_orig) {
1648 unsigned long *word;
1649 int offset;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001650 s32 bit_pos;
1651 s16 if_num;
1652 u8 *weight;
Marek Lindnerfc957272011-07-30 12:04:12 +02001653
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001654 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1655 ethhdr->h_source);
Marek Lindnerfc957272011-07-30 12:04:12 +02001656 if (!orig_neigh_node)
1657 return;
1658
1659 /* neighbor has to indicate direct link and it has to
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001660 * come via the corresponding interface
1661 * save packet seqno for bidirectional check
1662 */
Marek Lindnerfc957272011-07-30 12:04:12 +02001663 if (has_directlink_flag &&
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001664 batadv_compare_eth(if_incoming->net_dev->dev_addr,
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001665 ogm_packet->orig)) {
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001666 if_num = if_incoming->if_num;
1667 offset = if_num * BATADV_NUM_WORDS;
Marek Lindnerfc957272011-07-30 12:04:12 +02001668
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001669 spin_lock_bh(&orig_neigh_node->bat_iv.ogm_cnt_lock);
Antonio Quartulli32db6aa2014-09-01 14:37:29 +02001670 word = &orig_neigh_node->bat_iv.bcast_own[offset];
Sven Eckelmann9b4a1152012-05-12 13:48:53 +02001671 bit_pos = if_incoming_seqno - 2;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001672 bit_pos -= ntohl(ogm_packet->seqno);
Sven Eckelmann9b4a1152012-05-12 13:48:53 +02001673 batadv_set_bit(word, bit_pos);
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001674 weight = &orig_neigh_node->bat_iv.bcast_own_sum[if_num];
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001675 *weight = bitmap_weight(word,
1676 BATADV_TQ_LOCAL_WINDOW_SIZE);
Antonio Quartullibbad0a52013-09-02 12:15:02 +02001677 spin_unlock_bh(&orig_neigh_node->bat_iv.ogm_cnt_lock);
Marek Lindnerfc957272011-07-30 12:04:12 +02001678 }
1679
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001680 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001681 "Drop packet: originator packet from myself (via neighbor)\n");
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001682 batadv_orig_node_free_ref(orig_neigh_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001683 return;
1684 }
1685
1686 if (is_my_oldorig) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001687 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001688 "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
1689 ethhdr->h_source);
Marek Lindnerfc957272011-07-30 12:04:12 +02001690 return;
1691 }
1692
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001693 if (ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001694 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001695 "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
1696 ethhdr->h_source);
Marek Lindner13b25412012-03-11 06:17:53 +08001697 return;
1698 }
1699
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001700 orig_node = batadv_iv_ogm_orig_get(bat_priv, ogm_packet->orig);
Marek Lindnerfc957272011-07-30 12:04:12 +02001701 if (!orig_node)
1702 return;
1703
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001704 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1705 if_incoming, BATADV_IF_DEFAULT);
Marek Lindnerfc957272011-07-30 12:04:12 +02001706
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001707 rcu_read_lock();
1708 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1709 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1710 continue;
1711
1712 if (hard_iface->soft_iface != bat_priv->soft_iface)
1713 continue;
1714
1715 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1716 if_incoming, hard_iface);
Marek Lindnerfc957272011-07-30 12:04:12 +02001717 }
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001718 rcu_read_unlock();
Marek Lindnerfc957272011-07-30 12:04:12 +02001719
Sven Eckelmann7d211ef2012-05-12 02:09:34 +02001720 batadv_orig_node_free_ref(orig_node);
Marek Lindnerfc957272011-07-30 12:04:12 +02001721}
1722
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001723static int batadv_iv_ogm_receive(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +02001724 struct batadv_hard_iface *if_incoming)
Marek Lindnerfc957272011-07-30 12:04:12 +02001725{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001726 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001727 struct batadv_ogm_packet *ogm_packet;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001728 u8 *packet_pos;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001729 int ogm_offset;
Marek Lindneref261572013-04-23 21:39:57 +08001730 bool ret;
Marek Lindnerc3e29312012-03-04 16:56:25 +08001731
Sven Eckelmann7e071c72012-06-03 22:19:13 +02001732 ret = batadv_check_management_packet(skb, if_incoming, BATADV_OGM_HLEN);
Marek Lindnerc3e29312012-03-04 16:56:25 +08001733 if (!ret)
1734 return NET_RX_DROP;
Marek Lindnerfc957272011-07-30 12:04:12 +02001735
Marek Lindneredbf12b2012-03-11 06:17:49 +08001736 /* did we receive a B.A.T.M.A.N. IV OGM packet on an interface
1737 * that does not have B.A.T.M.A.N. IV enabled ?
1738 */
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001739 if (bat_priv->bat_algo_ops->bat_ogm_emit != batadv_iv_ogm_emit)
Marek Lindneredbf12b2012-03-11 06:17:49 +08001740 return NET_RX_DROP;
1741
Sven Eckelmannd69909d2012-06-03 22:19:20 +02001742 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_RX);
1743 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_RX_BYTES,
Martin Hundebøllf8214862012-04-20 17:02:45 +02001744 skb->len + ETH_HLEN);
1745
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001746 ogm_offset = 0;
1747 ogm_packet = (struct batadv_ogm_packet *)skb->data;
Marek Lindnerfc957272011-07-30 12:04:12 +02001748
1749 /* unpack the aggregated packets and process them one by one */
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001750 while (batadv_iv_ogm_aggr_packet(ogm_offset, skb_headlen(skb),
1751 ogm_packet->tvlv_len)) {
1752 batadv_iv_ogm_process(skb, ogm_offset, if_incoming);
Marek Lindnerfc957272011-07-30 12:04:12 +02001753
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001754 ogm_offset += BATADV_OGM_HLEN;
1755 ogm_offset += ntohs(ogm_packet->tvlv_len);
Marek Lindnerfc957272011-07-30 12:04:12 +02001756
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001757 packet_pos = skb->data + ogm_offset;
1758 ogm_packet = (struct batadv_ogm_packet *)packet_pos;
Marek Lindnerb47506d2013-03-04 10:39:49 +08001759 }
Marek Lindnerc3e29312012-03-04 16:56:25 +08001760
1761 kfree_skb(skb);
1762 return NET_RX_SUCCESS;
Marek Lindnerfc957272011-07-30 12:04:12 +02001763}
Marek Lindner1c280472011-11-28 17:40:17 +08001764
Simon Wunderlich1b371d12014-01-15 21:17:54 +01001765/**
1766 * batadv_iv_ogm_orig_print_neigh - print neighbors for the originator table
Simon Wunderlich89652332013-11-13 19:14:46 +01001767 * @orig_node: the orig_node for which the neighbors are printed
1768 * @if_outgoing: outgoing interface for these entries
1769 * @seq: debugfs table seq_file struct
1770 *
1771 * Must be called while holding an rcu lock.
1772 */
1773static void
1774batadv_iv_ogm_orig_print_neigh(struct batadv_orig_node *orig_node,
1775 struct batadv_hard_iface *if_outgoing,
1776 struct seq_file *seq)
1777{
1778 struct batadv_neigh_node *neigh_node;
1779 struct batadv_neigh_ifinfo *n_ifinfo;
1780
1781 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1782 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
1783 if (!n_ifinfo)
1784 continue;
1785
1786 seq_printf(seq, " %pM (%3i)",
1787 neigh_node->addr,
1788 n_ifinfo->bat_iv.tq_avg);
1789
1790 batadv_neigh_ifinfo_free_ref(n_ifinfo);
1791 }
1792}
1793
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001794/**
1795 * batadv_iv_ogm_orig_print - print the originator table
1796 * @bat_priv: the bat priv with all the soft interface information
1797 * @seq: debugfs table seq_file struct
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001798 * @if_outgoing: the outgoing interface for which this should be printed
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001799 */
1800static void batadv_iv_ogm_orig_print(struct batadv_priv *bat_priv,
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001801 struct seq_file *seq,
1802 struct batadv_hard_iface *if_outgoing)
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001803{
Simon Wunderlich89652332013-11-13 19:14:46 +01001804 struct batadv_neigh_node *neigh_node;
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001805 struct batadv_hashtable *hash = bat_priv->orig_hash;
1806 int last_seen_msecs, last_seen_secs;
1807 struct batadv_orig_node *orig_node;
Simon Wunderlich89652332013-11-13 19:14:46 +01001808 struct batadv_neigh_ifinfo *n_ifinfo;
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001809 unsigned long last_seen_jiffies;
1810 struct hlist_head *head;
1811 int batman_count = 0;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001812 u32 i;
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001813
1814 seq_printf(seq, " %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
1815 "Originator", "last-seen", "#", BATADV_TQ_MAX_VALUE,
1816 "Nexthop", "outgoingIF", "Potential nexthops");
1817
1818 for (i = 0; i < hash->size; i++) {
1819 head = &hash->table[i];
1820
1821 rcu_read_lock();
1822 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001823 neigh_node = batadv_orig_router_get(orig_node,
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001824 if_outgoing);
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001825 if (!neigh_node)
1826 continue;
1827
Simon Wunderlich89652332013-11-13 19:14:46 +01001828 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node,
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001829 if_outgoing);
Simon Wunderlich89652332013-11-13 19:14:46 +01001830 if (!n_ifinfo)
1831 goto next;
1832
1833 if (n_ifinfo->bat_iv.tq_avg == 0)
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001834 goto next;
1835
1836 last_seen_jiffies = jiffies - orig_node->last_seen;
1837 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
1838 last_seen_secs = last_seen_msecs / 1000;
1839 last_seen_msecs = last_seen_msecs % 1000;
1840
1841 seq_printf(seq, "%pM %4i.%03is (%3i) %pM [%10s]:",
1842 orig_node->orig, last_seen_secs,
Simon Wunderlich89652332013-11-13 19:14:46 +01001843 last_seen_msecs, n_ifinfo->bat_iv.tq_avg,
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001844 neigh_node->addr,
1845 neigh_node->if_incoming->net_dev->name);
1846
Simon Wunderlichcb1c92e2013-11-21 11:52:16 +01001847 batadv_iv_ogm_orig_print_neigh(orig_node, if_outgoing,
1848 seq);
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001849 seq_puts(seq, "\n");
1850 batman_count++;
1851
1852next:
1853 batadv_neigh_node_free_ref(neigh_node);
Simon Wunderlich89652332013-11-13 19:14:46 +01001854 if (n_ifinfo)
1855 batadv_neigh_ifinfo_free_ref(n_ifinfo);
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001856 }
1857 rcu_read_unlock();
1858 }
1859
1860 if (batman_count == 0)
1861 seq_puts(seq, "No batman nodes in range ...\n");
1862}
1863
Antonio Quartullia3285a82013-09-02 12:15:04 +02001864/**
1865 * batadv_iv_ogm_neigh_cmp - compare the metrics of two neighbors
1866 * @neigh1: the first neighbor object of the comparison
Simon Wunderlich89652332013-11-13 19:14:46 +01001867 * @if_outgoing1: outgoing interface for the first neighbor
Antonio Quartullia3285a82013-09-02 12:15:04 +02001868 * @neigh2: the second neighbor object of the comparison
Simon Wunderlich89652332013-11-13 19:14:46 +01001869 * @if_outgoing2: outgoing interface for the second neighbor
Antonio Quartullia3285a82013-09-02 12:15:04 +02001870 *
1871 * Returns a value less, equal to or greater than 0 if the metric via neigh1 is
1872 * lower, the same as or higher than the metric via neigh2
1873 */
1874static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1,
Simon Wunderlich89652332013-11-13 19:14:46 +01001875 struct batadv_hard_iface *if_outgoing1,
1876 struct batadv_neigh_node *neigh2,
1877 struct batadv_hard_iface *if_outgoing2)
Antonio Quartullia3285a82013-09-02 12:15:04 +02001878{
Simon Wunderlich89652332013-11-13 19:14:46 +01001879 struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001880 u8 tq1, tq2;
Simon Wunderlich89652332013-11-13 19:14:46 +01001881 int diff;
Antonio Quartullia3285a82013-09-02 12:15:04 +02001882
Simon Wunderlich89652332013-11-13 19:14:46 +01001883 neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
1884 neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
Antonio Quartullia3285a82013-09-02 12:15:04 +02001885
Simon Wunderlich89652332013-11-13 19:14:46 +01001886 if (!neigh1_ifinfo || !neigh2_ifinfo) {
1887 diff = 0;
1888 goto out;
1889 }
1890
1891 tq1 = neigh1_ifinfo->bat_iv.tq_avg;
1892 tq2 = neigh2_ifinfo->bat_iv.tq_avg;
1893 diff = tq1 - tq2;
1894
1895out:
1896 if (neigh1_ifinfo)
1897 batadv_neigh_ifinfo_free_ref(neigh1_ifinfo);
1898 if (neigh2_ifinfo)
1899 batadv_neigh_ifinfo_free_ref(neigh2_ifinfo);
1900
1901 return diff;
Antonio Quartullia3285a82013-09-02 12:15:04 +02001902}
1903
Antonio Quartullic43c9812013-09-02 12:15:05 +02001904/**
1905 * batadv_iv_ogm_neigh_is_eob - check if neigh1 is equally good or better than
1906 * neigh2 from the metric prospective
1907 * @neigh1: the first neighbor object of the comparison
Martin Hundebøll95298a92014-07-15 09:41:05 +02001908 * @if_outgoing1: outgoing interface for the first neighbor
Antonio Quartullic43c9812013-09-02 12:15:05 +02001909 * @neigh2: the second neighbor object of the comparison
Simon Wunderlich89652332013-11-13 19:14:46 +01001910 * @if_outgoing2: outgoing interface for the second neighbor
Martin Hundebøll95298a92014-07-15 09:41:05 +02001911 *
Simon Wunderlich89652332013-11-13 19:14:46 +01001912 * Returns true if the metric via neigh1 is equally good or better than
1913 * the metric via neigh2, false otherwise.
1914 */
1915static bool
1916batadv_iv_ogm_neigh_is_eob(struct batadv_neigh_node *neigh1,
1917 struct batadv_hard_iface *if_outgoing1,
1918 struct batadv_neigh_node *neigh2,
1919 struct batadv_hard_iface *if_outgoing2)
1920{
1921 struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001922 u8 tq1, tq2;
Simon Wunderlich89652332013-11-13 19:14:46 +01001923 bool ret;
1924
1925 neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
1926 neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
1927
1928 /* we can't say that the metric is better */
1929 if (!neigh1_ifinfo || !neigh2_ifinfo) {
1930 ret = false;
1931 goto out;
1932 }
1933
1934 tq1 = neigh1_ifinfo->bat_iv.tq_avg;
1935 tq2 = neigh2_ifinfo->bat_iv.tq_avg;
1936 ret = (tq1 - tq2) > -BATADV_TQ_SIMILARITY_THRESHOLD;
1937
1938out:
1939 if (neigh1_ifinfo)
1940 batadv_neigh_ifinfo_free_ref(neigh1_ifinfo);
1941 if (neigh2_ifinfo)
1942 batadv_neigh_ifinfo_free_ref(neigh2_ifinfo);
1943
1944 return ret;
Antonio Quartullic43c9812013-09-02 12:15:05 +02001945}
1946
Sven Eckelmann56303d32012-06-05 22:31:31 +02001947static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
Marek Lindner519d3492012-04-18 17:15:57 +08001948 .name = "BATMAN_IV",
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001949 .bat_iface_enable = batadv_iv_ogm_iface_enable,
1950 .bat_iface_disable = batadv_iv_ogm_iface_disable,
1951 .bat_iface_update_mac = batadv_iv_ogm_iface_update_mac,
1952 .bat_primary_iface_set = batadv_iv_ogm_primary_iface_set,
1953 .bat_ogm_schedule = batadv_iv_ogm_schedule,
1954 .bat_ogm_emit = batadv_iv_ogm_emit,
Antonio Quartullia3285a82013-09-02 12:15:04 +02001955 .bat_neigh_cmp = batadv_iv_ogm_neigh_cmp,
Antonio Quartullic43c9812013-09-02 12:15:05 +02001956 .bat_neigh_is_equiv_or_better = batadv_iv_ogm_neigh_is_eob,
Antonio Quartulli737a2a222013-09-02 12:15:03 +02001957 .bat_orig_print = batadv_iv_ogm_orig_print,
Antonio Quartullid0015fd2013-09-03 11:10:23 +02001958 .bat_orig_free = batadv_iv_ogm_orig_free,
1959 .bat_orig_add_if = batadv_iv_ogm_orig_add_if,
1960 .bat_orig_del_if = batadv_iv_ogm_orig_del_if,
Marek Lindner1c280472011-11-28 17:40:17 +08001961};
1962
Sven Eckelmann81c524f2012-05-12 02:09:22 +02001963int __init batadv_iv_init(void)
Marek Lindner1c280472011-11-28 17:40:17 +08001964{
Marek Lindnerc3e29312012-03-04 16:56:25 +08001965 int ret;
1966
1967 /* batman originator packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +02001968 ret = batadv_recv_handler_register(BATADV_IV_OGM,
1969 batadv_iv_ogm_receive);
Marek Lindnerc3e29312012-03-04 16:56:25 +08001970 if (ret < 0)
1971 goto out;
1972
Sven Eckelmannfe8bc392012-05-12 18:33:51 +02001973 ret = batadv_algo_register(&batadv_batman_iv);
Marek Lindnerc3e29312012-03-04 16:56:25 +08001974 if (ret < 0)
1975 goto handler_unregister;
1976
1977 goto out;
1978
1979handler_unregister:
Sven Eckelmannacd34af2012-06-03 22:19:21 +02001980 batadv_recv_handler_unregister(BATADV_IV_OGM);
Marek Lindnerc3e29312012-03-04 16:56:25 +08001981out:
1982 return ret;
Marek Lindner1c280472011-11-28 17:40:17 +08001983}