blob: 5cfac6e56610a65f529144fb9bf0e55a88e76bbe [file] [log] [blame]
Sven Eckelmann7db7d9f2017-11-19 15:05:11 +01001// SPDX-License-Identifier: GPL-2.0
Sven Eckelmannac79cbb2017-01-01 00:00:00 +01002/* Copyright (C) 2012-2017 B.A.T.M.A.N. contributors:
Martin Hundebølld353d8d2013-01-25 11:12:38 +01003 *
4 * Martin Hundebøll, Jeppe Ledet-Pedersen
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
Antonio Quartulliebf38fb2013-11-03 20:40:48 +010016 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Martin Hundebølld353d8d2013-01-25 11:12:38 +010017 */
18
Martin Hundebølld353d8d2013-01-25 11:12:38 +010019#include "network-coding.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020020#include "main.h"
21
22#include <linux/atomic.h>
Linus Lüssing46354692015-06-16 17:10:23 +020023#include <linux/bitops.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020024#include <linux/byteorder/generic.h>
25#include <linux/compiler.h>
26#include <linux/debugfs.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/if_packet.h>
32#include <linux/init.h>
33#include <linux/jhash.h>
34#include <linux/jiffies.h>
35#include <linux/kernel.h>
Sven Eckelmanndaf99b42016-01-16 10:29:45 +010036#include <linux/kref.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020037#include <linux/list.h>
38#include <linux/lockdep.h>
39#include <linux/netdevice.h>
40#include <linux/printk.h>
41#include <linux/random.h>
42#include <linux/rculist.h>
43#include <linux/rcupdate.h>
44#include <linux/seq_file.h>
45#include <linux/skbuff.h>
46#include <linux/slab.h>
47#include <linux/spinlock.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020048#include <linux/stddef.h>
49#include <linux/string.h>
50#include <linux/workqueue.h>
51
Martin Hundebølld56b1702013-01-25 11:12:39 +010052#include "hard-interface.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020053#include "hash.h"
Sven Eckelmannba412082016-05-15 23:48:31 +020054#include "log.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020055#include "originator.h"
56#include "packet.h"
Martin Hundebøll2df52782013-01-25 11:12:43 +010057#include "routing.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020058#include "send.h"
Markus Pargmann1f8dce42016-05-15 11:07:43 +020059#include "tvlv.h"
Martin Hundebølld353d8d2013-01-25 11:12:38 +010060
Martin Hundebøll95332472013-01-25 11:12:40 +010061static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
Martin Hundebøll612d2b42013-01-25 11:12:42 +010062static struct lock_class_key batadv_nc_decoding_hash_lock_class_key;
Martin Hundebøll95332472013-01-25 11:12:40 +010063
Martin Hundebølld353d8d2013-01-25 11:12:38 +010064static void batadv_nc_worker(struct work_struct *work);
Martin Hundebøll2df52782013-01-25 11:12:43 +010065static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
66 struct batadv_hard_iface *recv_if);
Martin Hundebølld353d8d2013-01-25 11:12:38 +010067
68/**
Matthias Schiffer6c519ba2013-09-27 18:03:39 +020069 * batadv_nc_init - one-time initialization for network coding
Sven Eckelmann672e7972015-10-31 12:29:30 +010070 *
71 * Return: 0 on success or negative error number in case of failure
Matthias Schiffer6c519ba2013-09-27 18:03:39 +020072 */
73int __init batadv_nc_init(void)
74{
75 int ret;
76
77 /* Register our packet type */
78 ret = batadv_recv_handler_register(BATADV_CODED,
79 batadv_nc_recv_coded_packet);
80
81 return ret;
82}
83
84/**
Martin Hundebølld353d8d2013-01-25 11:12:38 +010085 * batadv_nc_start_timer - initialise the nc periodic worker
86 * @bat_priv: the bat priv with all the soft interface information
87 */
88static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
89{
90 queue_delayed_work(batadv_event_workqueue, &bat_priv->nc.work,
91 msecs_to_jiffies(10));
92}
93
94/**
Marek Lindner3f4841f2013-04-23 21:40:00 +080095 * batadv_nc_tvlv_container_update - update the network coding tvlv container
96 * after network coding setting change
97 * @bat_priv: the bat priv with all the soft interface information
98 */
99static void batadv_nc_tvlv_container_update(struct batadv_priv *bat_priv)
100{
101 char nc_mode;
102
103 nc_mode = atomic_read(&bat_priv->network_coding);
104
105 switch (nc_mode) {
106 case 0:
107 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_NC, 1);
108 break;
109 case 1:
110 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_NC, 1,
111 NULL, 0);
112 break;
113 }
114}
115
116/**
117 * batadv_nc_status_update - update the network coding tvlv container after
118 * network coding setting change
119 * @net_dev: the soft interface net device
120 */
121void batadv_nc_status_update(struct net_device *net_dev)
122{
123 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Antonio Quartullif1386942014-05-10 18:56:37 +0200124
Marek Lindner3f4841f2013-04-23 21:40:00 +0800125 batadv_nc_tvlv_container_update(bat_priv);
126}
127
128/**
129 * batadv_nc_tvlv_ogm_handler_v1 - process incoming nc tvlv container
130 * @bat_priv: the bat priv with all the soft interface information
131 * @orig: the orig_node of the ogm
132 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
133 * @tvlv_value: tvlv buffer containing the gateway data
134 * @tvlv_value_len: tvlv buffer length
135 */
136static void batadv_nc_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
137 struct batadv_orig_node *orig,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200138 u8 flags,
139 void *tvlv_value, u16 tvlv_value_len)
Marek Lindner3f4841f2013-04-23 21:40:00 +0800140{
141 if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
Linus Lüssing46354692015-06-16 17:10:23 +0200142 clear_bit(BATADV_ORIG_CAPA_HAS_NC, &orig->capabilities);
Marek Lindner3f4841f2013-04-23 21:40:00 +0800143 else
Linus Lüssing46354692015-06-16 17:10:23 +0200144 set_bit(BATADV_ORIG_CAPA_HAS_NC, &orig->capabilities);
Marek Lindner3f4841f2013-04-23 21:40:00 +0800145}
146
147/**
Matthias Schiffer6c519ba2013-09-27 18:03:39 +0200148 * batadv_nc_mesh_init - initialise coding hash table and start house keeping
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100149 * @bat_priv: the bat priv with all the soft interface information
Sven Eckelmann672e7972015-10-31 12:29:30 +0100150 *
151 * Return: 0 on success or negative error number in case of failure
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100152 */
Matthias Schiffer6c519ba2013-09-27 18:03:39 +0200153int batadv_nc_mesh_init(struct batadv_priv *bat_priv)
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100154{
Martin Hundebøll95332472013-01-25 11:12:40 +0100155 bat_priv->nc.timestamp_fwd_flush = jiffies;
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100156 bat_priv->nc.timestamp_sniffed_purge = jiffies;
Martin Hundebøll95332472013-01-25 11:12:40 +0100157
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100158 if (bat_priv->nc.coding_hash || bat_priv->nc.decoding_hash)
Martin Hundebøll95332472013-01-25 11:12:40 +0100159 return 0;
160
161 bat_priv->nc.coding_hash = batadv_hash_new(128);
162 if (!bat_priv->nc.coding_hash)
163 goto err;
164
165 batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
166 &batadv_nc_coding_hash_lock_class_key);
167
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100168 bat_priv->nc.decoding_hash = batadv_hash_new(128);
169 if (!bat_priv->nc.decoding_hash)
170 goto err;
171
Martin Hundebøllf44d5402014-11-11 16:22:23 +0100172 batadv_hash_set_lock_class(bat_priv->nc.decoding_hash,
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100173 &batadv_nc_decoding_hash_lock_class_key);
174
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100175 INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
176 batadv_nc_start_timer(bat_priv);
177
Marek Lindner3f4841f2013-04-23 21:40:00 +0800178 batadv_tvlv_handler_register(bat_priv, batadv_nc_tvlv_ogm_handler_v1,
179 NULL, BATADV_TVLV_NC, 1,
180 BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
181 batadv_nc_tvlv_container_update(bat_priv);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100182 return 0;
Martin Hundebøll95332472013-01-25 11:12:40 +0100183
184err:
185 return -ENOMEM;
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100186}
187
188/**
189 * batadv_nc_init_bat_priv - initialise the nc specific bat_priv variables
190 * @bat_priv: the bat priv with all the soft interface information
191 */
192void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
193{
Sven Eckelmanndab7b622015-02-18 18:20:24 +0100194 atomic_set(&bat_priv->network_coding, 0);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100195 bat_priv->nc.min_tq = 200;
Martin Hundebøll95332472013-01-25 11:12:40 +0100196 bat_priv->nc.max_fwd_delay = 10;
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100197 bat_priv->nc.max_buffer_time = 200;
Martin Hundebølld56b1702013-01-25 11:12:39 +0100198}
199
200/**
201 * batadv_nc_init_orig - initialise the nc fields of an orig_node
202 * @orig_node: the orig_node which is going to be initialised
203 */
204void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
205{
206 INIT_LIST_HEAD(&orig_node->in_coding_list);
207 INIT_LIST_HEAD(&orig_node->out_coding_list);
208 spin_lock_init(&orig_node->in_coding_list_lock);
209 spin_lock_init(&orig_node->out_coding_list_lock);
210}
211
212/**
Sven Eckelmann44e8e7e92016-01-05 12:06:19 +0100213 * batadv_nc_node_release - release nc_node from lists and queue for free after
214 * rcu grace period
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100215 * @ref: kref pointer of the nc_node
Martin Hundebølld56b1702013-01-25 11:12:39 +0100216 */
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100217static void batadv_nc_node_release(struct kref *ref)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100218{
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100219 struct batadv_nc_node *nc_node;
220
221 nc_node = container_of(ref, struct batadv_nc_node, refcount);
222
Sven Eckelmann5d967312016-01-17 11:01:09 +0100223 batadv_orig_node_put(nc_node->orig_node);
Sven Eckelmann44e8e7e92016-01-05 12:06:19 +0100224 kfree_rcu(nc_node, rcu);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100225}
226
227/**
Sven Eckelmann27ad7542016-01-17 11:01:22 +0100228 * batadv_nc_node_put - decrement the nc_node refcounter and possibly
Sven Eckelmann44e8e7e92016-01-05 12:06:19 +0100229 * release it
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100230 * @nc_node: nc_node to be free'd
Martin Hundebølld56b1702013-01-25 11:12:39 +0100231 */
Sven Eckelmann27ad7542016-01-17 11:01:22 +0100232static void batadv_nc_node_put(struct batadv_nc_node *nc_node)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100233{
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100234 kref_put(&nc_node->refcount, batadv_nc_node_release);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100235}
236
237/**
Sven Eckelmann727e0cd2016-01-16 10:29:46 +0100238 * batadv_nc_path_release - release nc_path from lists and queue for free after
239 * rcu grace period
240 * @ref: kref pointer of the nc_path
241 */
242static void batadv_nc_path_release(struct kref *ref)
243{
244 struct batadv_nc_path *nc_path;
245
246 nc_path = container_of(ref, struct batadv_nc_path, refcount);
247
248 kfree_rcu(nc_path, rcu);
249}
250
251/**
Sven Eckelmann5fff2822016-01-17 11:01:23 +0100252 * batadv_nc_path_put - decrement the nc_path refcounter and possibly
Sven Eckelmann727e0cd2016-01-16 10:29:46 +0100253 * release it
254 * @nc_path: nc_path to be free'd
Martin Hundebøll95332472013-01-25 11:12:40 +0100255 */
Sven Eckelmann5fff2822016-01-17 11:01:23 +0100256static void batadv_nc_path_put(struct batadv_nc_path *nc_path)
Martin Hundebøll95332472013-01-25 11:12:40 +0100257{
Sven Eckelmann727e0cd2016-01-16 10:29:46 +0100258 kref_put(&nc_path->refcount, batadv_nc_path_release);
Martin Hundebøll95332472013-01-25 11:12:40 +0100259}
260
261/**
262 * batadv_nc_packet_free - frees nc packet
263 * @nc_packet: the nc packet to free
Sven Eckelmannbd687fe2016-07-17 21:04:00 +0200264 * @dropped: whether the packet is freed because is is dropped
Martin Hundebøll95332472013-01-25 11:12:40 +0100265 */
Sven Eckelmannbd687fe2016-07-17 21:04:00 +0200266static void batadv_nc_packet_free(struct batadv_nc_packet *nc_packet,
267 bool dropped)
Martin Hundebøll95332472013-01-25 11:12:40 +0100268{
Sven Eckelmannbd687fe2016-07-17 21:04:00 +0200269 if (dropped)
270 kfree_skb(nc_packet->skb);
271 else
272 consume_skb(nc_packet->skb);
273
Sven Eckelmann5fff2822016-01-17 11:01:23 +0100274 batadv_nc_path_put(nc_packet->nc_path);
Martin Hundebøll95332472013-01-25 11:12:40 +0100275 kfree(nc_packet);
276}
277
278/**
Martin Hundebølld56b1702013-01-25 11:12:39 +0100279 * batadv_nc_to_purge_nc_node - checks whether an nc node has to be purged
280 * @bat_priv: the bat priv with all the soft interface information
281 * @nc_node: the nc node to check
282 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200283 * Return: true if the entry has to be purged now, false otherwise
Martin Hundebølld56b1702013-01-25 11:12:39 +0100284 */
285static bool batadv_nc_to_purge_nc_node(struct batadv_priv *bat_priv,
286 struct batadv_nc_node *nc_node)
287{
288 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
289 return true;
290
291 return batadv_has_timed_out(nc_node->last_seen, BATADV_NC_NODE_TIMEOUT);
292}
293
294/**
Martin Hundebøll95332472013-01-25 11:12:40 +0100295 * batadv_nc_to_purge_nc_path_coding - checks whether an nc path has timed out
296 * @bat_priv: the bat priv with all the soft interface information
297 * @nc_path: the nc path to check
298 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200299 * Return: true if the entry has to be purged now, false otherwise
Martin Hundebøll95332472013-01-25 11:12:40 +0100300 */
301static bool batadv_nc_to_purge_nc_path_coding(struct batadv_priv *bat_priv,
302 struct batadv_nc_path *nc_path)
303{
304 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
305 return true;
306
307 /* purge the path when no packets has been added for 10 times the
308 * max_fwd_delay time
309 */
310 return batadv_has_timed_out(nc_path->last_valid,
311 bat_priv->nc.max_fwd_delay * 10);
312}
313
314/**
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100315 * batadv_nc_to_purge_nc_path_decoding - checks whether an nc path has timed out
316 * @bat_priv: the bat priv with all the soft interface information
317 * @nc_path: the nc path to check
318 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200319 * Return: true if the entry has to be purged now, false otherwise
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100320 */
321static bool batadv_nc_to_purge_nc_path_decoding(struct batadv_priv *bat_priv,
322 struct batadv_nc_path *nc_path)
323{
324 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
325 return true;
326
327 /* purge the path when no packets has been added for 10 times the
328 * max_buffer time
329 */
330 return batadv_has_timed_out(nc_path->last_valid,
Marek Lindnerfc1f8692015-02-18 22:19:20 +0800331 bat_priv->nc.max_buffer_time * 10);
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100332}
333
334/**
Martin Hundebølld56b1702013-01-25 11:12:39 +0100335 * batadv_nc_purge_orig_nc_nodes - go through list of nc nodes and purge stale
336 * entries
337 * @bat_priv: the bat priv with all the soft interface information
338 * @list: list of nc nodes
339 * @lock: nc node list lock
340 * @to_purge: function in charge to decide whether an entry has to be purged or
341 * not. This function takes the nc node as argument and has to return
342 * a boolean value: true if the entry has to be deleted, false
343 * otherwise
344 */
345static void
346batadv_nc_purge_orig_nc_nodes(struct batadv_priv *bat_priv,
347 struct list_head *list,
348 spinlock_t *lock,
349 bool (*to_purge)(struct batadv_priv *,
350 struct batadv_nc_node *))
351{
352 struct batadv_nc_node *nc_node, *nc_node_tmp;
353
354 /* For each nc_node in list */
355 spin_lock_bh(lock);
356 list_for_each_entry_safe(nc_node, nc_node_tmp, list, list) {
357 /* if an helper function has been passed as parameter,
358 * ask it if the entry has to be purged or not
359 */
360 if (to_purge && !to_purge(bat_priv, nc_node))
361 continue;
362
363 batadv_dbg(BATADV_DBG_NC, bat_priv,
364 "Removing nc_node %pM -> %pM\n",
365 nc_node->addr, nc_node->orig_node->orig);
366 list_del_rcu(&nc_node->list);
Sven Eckelmann27ad7542016-01-17 11:01:22 +0100367 batadv_nc_node_put(nc_node);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100368 }
369 spin_unlock_bh(lock);
370}
371
372/**
373 * batadv_nc_purge_orig - purges all nc node data attached of the given
374 * originator
375 * @bat_priv: the bat priv with all the soft interface information
376 * @orig_node: orig_node with the nc node entries to be purged
377 * @to_purge: function in charge to decide whether an entry has to be purged or
378 * not. This function takes the nc node as argument and has to return
379 * a boolean value: true is the entry has to be deleted, false
380 * otherwise
381 */
382void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
383 struct batadv_orig_node *orig_node,
384 bool (*to_purge)(struct batadv_priv *,
385 struct batadv_nc_node *))
386{
387 /* Check ingoing nc_node's of this orig_node */
388 batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->in_coding_list,
389 &orig_node->in_coding_list_lock,
390 to_purge);
391
392 /* Check outgoing nc_node's of this orig_node */
393 batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->out_coding_list,
394 &orig_node->out_coding_list_lock,
395 to_purge);
396}
397
398/**
399 * batadv_nc_purge_orig_hash - traverse entire originator hash to check if they
400 * have timed out nc nodes
401 * @bat_priv: the bat priv with all the soft interface information
402 */
403static void batadv_nc_purge_orig_hash(struct batadv_priv *bat_priv)
404{
405 struct batadv_hashtable *hash = bat_priv->orig_hash;
406 struct hlist_head *head;
407 struct batadv_orig_node *orig_node;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200408 u32 i;
Martin Hundebølld56b1702013-01-25 11:12:39 +0100409
410 if (!hash)
411 return;
412
413 /* For each orig_node */
414 for (i = 0; i < hash->size; i++) {
415 head = &hash->table[i];
416
417 rcu_read_lock();
418 hlist_for_each_entry_rcu(orig_node, head, hash_entry)
419 batadv_nc_purge_orig(bat_priv, orig_node,
420 batadv_nc_to_purge_nc_node);
421 rcu_read_unlock();
422 }
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100423}
424
425/**
Martin Hundebøll95332472013-01-25 11:12:40 +0100426 * batadv_nc_purge_paths - traverse all nc paths part of the hash and remove
427 * unused ones
428 * @bat_priv: the bat priv with all the soft interface information
429 * @hash: hash table containing the nc paths to check
430 * @to_purge: function in charge to decide whether an entry has to be purged or
431 * not. This function takes the nc node as argument and has to return
432 * a boolean value: true is the entry has to be deleted, false
433 * otherwise
434 */
435static void batadv_nc_purge_paths(struct batadv_priv *bat_priv,
436 struct batadv_hashtable *hash,
437 bool (*to_purge)(struct batadv_priv *,
438 struct batadv_nc_path *))
439{
440 struct hlist_head *head;
441 struct hlist_node *node_tmp;
442 struct batadv_nc_path *nc_path;
443 spinlock_t *lock; /* Protects lists in hash */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200444 u32 i;
Martin Hundebøll95332472013-01-25 11:12:40 +0100445
446 for (i = 0; i < hash->size; i++) {
447 head = &hash->table[i];
448 lock = &hash->list_locks[i];
449
450 /* For each nc_path in this bin */
451 spin_lock_bh(lock);
452 hlist_for_each_entry_safe(nc_path, node_tmp, head, hash_entry) {
453 /* if an helper function has been passed as parameter,
454 * ask it if the entry has to be purged or not
455 */
456 if (to_purge && !to_purge(bat_priv, nc_path))
457 continue;
458
459 /* purging an non-empty nc_path should never happen, but
460 * is observed under high CPU load. Delay the purging
461 * until next iteration to allow the packet_list to be
462 * emptied first.
463 */
464 if (!unlikely(list_empty(&nc_path->packet_list))) {
465 net_ratelimited_function(printk,
466 KERN_WARNING
467 "Skipping free of non-empty nc_path (%pM -> %pM)!\n",
468 nc_path->prev_hop,
469 nc_path->next_hop);
470 continue;
471 }
472
473 /* nc_path is unused, so remove it */
474 batadv_dbg(BATADV_DBG_NC, bat_priv,
475 "Remove nc_path %pM -> %pM\n",
476 nc_path->prev_hop, nc_path->next_hop);
477 hlist_del_rcu(&nc_path->hash_entry);
Sven Eckelmann5fff2822016-01-17 11:01:23 +0100478 batadv_nc_path_put(nc_path);
Martin Hundebøll95332472013-01-25 11:12:40 +0100479 }
480 spin_unlock_bh(lock);
481 }
482}
483
484/**
485 * batadv_nc_hash_key_gen - computes the nc_path hash key
486 * @key: buffer to hold the final hash key
487 * @src: source ethernet mac address going into the hash key
488 * @dst: destination ethernet mac address going into the hash key
489 */
490static void batadv_nc_hash_key_gen(struct batadv_nc_path *key, const char *src,
491 const char *dst)
492{
493 memcpy(key->prev_hop, src, sizeof(key->prev_hop));
494 memcpy(key->next_hop, dst, sizeof(key->next_hop));
495}
496
497/**
498 * batadv_nc_hash_choose - compute the hash value for an nc path
499 * @data: data to hash
500 * @size: size of the hash table
501 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200502 * Return: the selected index in the hash table for the given data.
Martin Hundebøll95332472013-01-25 11:12:40 +0100503 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200504static u32 batadv_nc_hash_choose(const void *data, u32 size)
Martin Hundebøll95332472013-01-25 11:12:40 +0100505{
506 const struct batadv_nc_path *nc_path = data;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200507 u32 hash = 0;
Martin Hundebøll95332472013-01-25 11:12:40 +0100508
Sven Eckelmann36fd61c2015-03-01 09:46:18 +0100509 hash = jhash(&nc_path->prev_hop, sizeof(nc_path->prev_hop), hash);
510 hash = jhash(&nc_path->next_hop, sizeof(nc_path->next_hop), hash);
Martin Hundebøll95332472013-01-25 11:12:40 +0100511
512 return hash % size;
513}
514
515/**
516 * batadv_nc_hash_compare - comparing function used in the network coding hash
517 * tables
518 * @node: node in the local table
519 * @data2: second object to compare the node to
520 *
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100521 * Return: true if the two entry are the same, false otherwise
Martin Hundebøll95332472013-01-25 11:12:40 +0100522 */
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100523static bool batadv_nc_hash_compare(const struct hlist_node *node,
524 const void *data2)
Martin Hundebøll95332472013-01-25 11:12:40 +0100525{
526 const struct batadv_nc_path *nc_path1, *nc_path2;
527
528 nc_path1 = container_of(node, struct batadv_nc_path, hash_entry);
529 nc_path2 = data2;
530
531 /* Return 1 if the two keys are identical */
Antonio Quartulli676970e2016-03-11 14:01:10 +0100532 if (!batadv_compare_eth(nc_path1->prev_hop, nc_path2->prev_hop))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100533 return false;
Martin Hundebøll95332472013-01-25 11:12:40 +0100534
Antonio Quartulli676970e2016-03-11 14:01:10 +0100535 if (!batadv_compare_eth(nc_path1->next_hop, nc_path2->next_hop))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100536 return false;
Martin Hundebøll95332472013-01-25 11:12:40 +0100537
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100538 return true;
Martin Hundebøll95332472013-01-25 11:12:40 +0100539}
540
541/**
542 * batadv_nc_hash_find - search for an existing nc path and return it
543 * @hash: hash table containing the nc path
544 * @data: search key
545 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200546 * Return: the nc_path if found, NULL otherwise.
Martin Hundebøll95332472013-01-25 11:12:40 +0100547 */
548static struct batadv_nc_path *
549batadv_nc_hash_find(struct batadv_hashtable *hash,
550 void *data)
551{
552 struct hlist_head *head;
553 struct batadv_nc_path *nc_path, *nc_path_tmp = NULL;
554 int index;
555
556 if (!hash)
557 return NULL;
558
559 index = batadv_nc_hash_choose(data, hash->size);
560 head = &hash->table[index];
561
562 rcu_read_lock();
563 hlist_for_each_entry_rcu(nc_path, head, hash_entry) {
564 if (!batadv_nc_hash_compare(&nc_path->hash_entry, data))
565 continue;
566
Sven Eckelmann727e0cd2016-01-16 10:29:46 +0100567 if (!kref_get_unless_zero(&nc_path->refcount))
Martin Hundebøll95332472013-01-25 11:12:40 +0100568 continue;
569
570 nc_path_tmp = nc_path;
571 break;
572 }
573 rcu_read_unlock();
574
575 return nc_path_tmp;
576}
577
578/**
579 * batadv_nc_send_packet - send non-coded packet and free nc_packet struct
580 * @nc_packet: the nc packet to send
581 */
582static void batadv_nc_send_packet(struct batadv_nc_packet *nc_packet)
583{
Antonio Quartulli95d39272016-01-16 16:40:15 +0800584 batadv_send_unicast_skb(nc_packet->skb, nc_packet->neigh_node);
Martin Hundebøll95332472013-01-25 11:12:40 +0100585 nc_packet->skb = NULL;
Sven Eckelmannbd687fe2016-07-17 21:04:00 +0200586 batadv_nc_packet_free(nc_packet, false);
Martin Hundebøll95332472013-01-25 11:12:40 +0100587}
588
589/**
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100590 * batadv_nc_sniffed_purge - Checks timestamp of given sniffed nc_packet.
591 * @bat_priv: the bat priv with all the soft interface information
592 * @nc_path: the nc path the packet belongs to
593 * @nc_packet: the nc packet to be checked
594 *
595 * Checks whether the given sniffed (overheard) nc_packet has hit its buffering
596 * timeout. If so, the packet is no longer kept and the entry deleted from the
597 * queue. Has to be called with the appropriate locks.
598 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200599 * Return: false as soon as the entry in the fifo queue has not been timed out
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100600 * yet and true otherwise.
601 */
602static bool batadv_nc_sniffed_purge(struct batadv_priv *bat_priv,
603 struct batadv_nc_path *nc_path,
604 struct batadv_nc_packet *nc_packet)
605{
606 unsigned long timeout = bat_priv->nc.max_buffer_time;
607 bool res = false;
608
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200609 lockdep_assert_held(&nc_path->packet_list_lock);
610
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100611 /* Packets are added to tail, so the remaining packets did not time
612 * out and we can stop processing the current queue
613 */
614 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
615 !batadv_has_timed_out(nc_packet->timestamp, timeout))
616 goto out;
617
618 /* purge nc packet */
619 list_del(&nc_packet->list);
Sven Eckelmannbd687fe2016-07-17 21:04:00 +0200620 batadv_nc_packet_free(nc_packet, true);
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100621
622 res = true;
623
624out:
625 return res;
626}
627
628/**
Martin Hundebøll95332472013-01-25 11:12:40 +0100629 * batadv_nc_fwd_flush - Checks the timestamp of the given nc packet.
630 * @bat_priv: the bat priv with all the soft interface information
631 * @nc_path: the nc path the packet belongs to
632 * @nc_packet: the nc packet to be checked
633 *
634 * Checks whether the given nc packet has hit its forward timeout. If so, the
635 * packet is no longer delayed, immediately sent and the entry deleted from the
636 * queue. Has to be called with the appropriate locks.
637 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200638 * Return: false as soon as the entry in the fifo queue has not been timed out
Martin Hundebøll95332472013-01-25 11:12:40 +0100639 * yet and true otherwise.
640 */
641static bool batadv_nc_fwd_flush(struct batadv_priv *bat_priv,
642 struct batadv_nc_path *nc_path,
643 struct batadv_nc_packet *nc_packet)
644{
645 unsigned long timeout = bat_priv->nc.max_fwd_delay;
646
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200647 lockdep_assert_held(&nc_path->packet_list_lock);
648
Martin Hundebøll95332472013-01-25 11:12:40 +0100649 /* Packets are added to tail, so the remaining packets did not time
650 * out and we can stop processing the current queue
651 */
652 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
653 !batadv_has_timed_out(nc_packet->timestamp, timeout))
654 return false;
655
656 /* Send packet */
657 batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
658 batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
659 nc_packet->skb->len + ETH_HLEN);
660 list_del(&nc_packet->list);
661 batadv_nc_send_packet(nc_packet);
662
663 return true;
664}
665
666/**
667 * batadv_nc_process_nc_paths - traverse given nc packet pool and free timed out
668 * nc packets
669 * @bat_priv: the bat priv with all the soft interface information
670 * @hash: to be processed hash table
671 * @process_fn: Function called to process given nc packet. Should return true
672 * to encourage this function to proceed with the next packet.
673 * Otherwise the rest of the current queue is skipped.
674 */
675static void
676batadv_nc_process_nc_paths(struct batadv_priv *bat_priv,
677 struct batadv_hashtable *hash,
678 bool (*process_fn)(struct batadv_priv *,
679 struct batadv_nc_path *,
680 struct batadv_nc_packet *))
681{
682 struct hlist_head *head;
683 struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
684 struct batadv_nc_path *nc_path;
685 bool ret;
686 int i;
687
688 if (!hash)
689 return;
690
691 /* Loop hash table bins */
692 for (i = 0; i < hash->size; i++) {
693 head = &hash->table[i];
694
695 /* Loop coding paths */
696 rcu_read_lock();
697 hlist_for_each_entry_rcu(nc_path, head, hash_entry) {
698 /* Loop packets */
699 spin_lock_bh(&nc_path->packet_list_lock);
700 list_for_each_entry_safe(nc_packet, nc_packet_tmp,
701 &nc_path->packet_list, list) {
702 ret = process_fn(bat_priv, nc_path, nc_packet);
703 if (!ret)
704 break;
705 }
706 spin_unlock_bh(&nc_path->packet_list_lock);
707 }
708 rcu_read_unlock();
709 }
710}
711
712/**
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100713 * batadv_nc_worker - periodic task for house keeping related to network coding
714 * @work: kernel work struct
715 */
716static void batadv_nc_worker(struct work_struct *work)
717{
718 struct delayed_work *delayed_work;
719 struct batadv_priv_nc *priv_nc;
720 struct batadv_priv *bat_priv;
Martin Hundebøll95332472013-01-25 11:12:40 +0100721 unsigned long timeout;
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100722
Geliang Tang4ba4bc02015-12-28 23:43:37 +0800723 delayed_work = to_delayed_work(work);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100724 priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
725 bat_priv = container_of(priv_nc, struct batadv_priv, nc);
726
Martin Hundebølld56b1702013-01-25 11:12:39 +0100727 batadv_nc_purge_orig_hash(bat_priv);
Martin Hundebøll95332472013-01-25 11:12:40 +0100728 batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash,
729 batadv_nc_to_purge_nc_path_coding);
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100730 batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash,
731 batadv_nc_to_purge_nc_path_decoding);
Martin Hundebøll95332472013-01-25 11:12:40 +0100732
733 timeout = bat_priv->nc.max_fwd_delay;
734
735 if (batadv_has_timed_out(bat_priv->nc.timestamp_fwd_flush, timeout)) {
736 batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.coding_hash,
737 batadv_nc_fwd_flush);
738 bat_priv->nc.timestamp_fwd_flush = jiffies;
739 }
Martin Hundebølld56b1702013-01-25 11:12:39 +0100740
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100741 if (batadv_has_timed_out(bat_priv->nc.timestamp_sniffed_purge,
742 bat_priv->nc.max_buffer_time)) {
743 batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.decoding_hash,
744 batadv_nc_sniffed_purge);
745 bat_priv->nc.timestamp_sniffed_purge = jiffies;
746 }
747
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100748 /* Schedule a new check */
749 batadv_nc_start_timer(bat_priv);
750}
751
752/**
Martin Hundebølld56b1702013-01-25 11:12:39 +0100753 * batadv_can_nc_with_orig - checks whether the given orig node is suitable for
754 * coding or not
755 * @bat_priv: the bat priv with all the soft interface information
756 * @orig_node: neighboring orig node which may be used as nc candidate
757 * @ogm_packet: incoming ogm packet also used for the checks
758 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200759 * Return: true if:
Martin Hundebølld56b1702013-01-25 11:12:39 +0100760 * 1) The OGM must have the most recent sequence number.
761 * 2) The TTL must be decremented by one and only one.
762 * 3) The OGM must be received from the first hop from orig_node.
763 * 4) The TQ value of the OGM must be above bat_priv->nc.min_tq.
764 */
765static bool batadv_can_nc_with_orig(struct batadv_priv *bat_priv,
766 struct batadv_orig_node *orig_node,
767 struct batadv_ogm_packet *ogm_packet)
768{
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100769 struct batadv_orig_ifinfo *orig_ifinfo;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200770 u32 last_real_seqno;
771 u8 last_ttl;
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100772
773 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, BATADV_IF_DEFAULT);
774 if (!orig_ifinfo)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100775 return false;
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100776
777 last_ttl = orig_ifinfo->last_ttl;
778 last_real_seqno = orig_ifinfo->last_real_seqno;
Sven Eckelmann35f94772016-01-17 11:01:13 +0100779 batadv_orig_ifinfo_put(orig_ifinfo);
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100780
781 if (last_real_seqno != ntohl(ogm_packet->seqno))
782 return false;
783 if (last_ttl != ogm_packet->ttl + 1)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100784 return false;
785 if (!batadv_compare_eth(ogm_packet->orig, ogm_packet->prev_sender))
786 return false;
787 if (ogm_packet->tq < bat_priv->nc.min_tq)
788 return false;
789
790 return true;
791}
792
793/**
794 * batadv_nc_find_nc_node - search for an existing nc node and return it
795 * @orig_node: orig node originating the ogm packet
796 * @orig_neigh_node: neighboring orig node from which we received the ogm packet
797 * (can be equal to orig_node)
798 * @in_coding: traverse incoming or outgoing network coding list
799 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200800 * Return: the nc_node if found, NULL otherwise.
Martin Hundebølld56b1702013-01-25 11:12:39 +0100801 */
Sven Eckelmann6fc77a52016-03-05 15:56:01 +0100802static struct batadv_nc_node *
803batadv_nc_find_nc_node(struct batadv_orig_node *orig_node,
804 struct batadv_orig_node *orig_neigh_node,
805 bool in_coding)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100806{
807 struct batadv_nc_node *nc_node, *nc_node_out = NULL;
808 struct list_head *list;
809
810 if (in_coding)
811 list = &orig_neigh_node->in_coding_list;
812 else
813 list = &orig_neigh_node->out_coding_list;
814
815 /* Traverse list of nc_nodes to orig_node */
816 rcu_read_lock();
817 list_for_each_entry_rcu(nc_node, list, list) {
818 if (!batadv_compare_eth(nc_node->addr, orig_node->orig))
819 continue;
820
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100821 if (!kref_get_unless_zero(&nc_node->refcount))
Martin Hundebølld56b1702013-01-25 11:12:39 +0100822 continue;
823
824 /* Found a match */
825 nc_node_out = nc_node;
826 break;
827 }
828 rcu_read_unlock();
829
830 return nc_node_out;
831}
832
833/**
834 * batadv_nc_get_nc_node - retrieves an nc node or creates the entry if it was
835 * not found
836 * @bat_priv: the bat priv with all the soft interface information
837 * @orig_node: orig node originating the ogm packet
838 * @orig_neigh_node: neighboring orig node from which we received the ogm packet
839 * (can be equal to orig_node)
840 * @in_coding: traverse incoming or outgoing network coding list
841 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200842 * Return: the nc_node if found or created, NULL in case of an error.
Martin Hundebølld56b1702013-01-25 11:12:39 +0100843 */
Sven Eckelmann6fc77a52016-03-05 15:56:01 +0100844static struct batadv_nc_node *
845batadv_nc_get_nc_node(struct batadv_priv *bat_priv,
846 struct batadv_orig_node *orig_node,
847 struct batadv_orig_node *orig_neigh_node,
848 bool in_coding)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100849{
850 struct batadv_nc_node *nc_node;
851 spinlock_t *lock; /* Used to lock list selected by "int in_coding" */
852 struct list_head *list;
853
854 /* Check if nc_node is already added */
855 nc_node = batadv_nc_find_nc_node(orig_node, orig_neigh_node, in_coding);
856
857 /* Node found */
858 if (nc_node)
859 return nc_node;
860
861 nc_node = kzalloc(sizeof(*nc_node), GFP_ATOMIC);
862 if (!nc_node)
863 return NULL;
864
Martin Hundebølld56b1702013-01-25 11:12:39 +0100865 /* Initialize nc_node */
866 INIT_LIST_HEAD(&nc_node->list);
Sven Eckelmanndaf99b42016-01-16 10:29:45 +0100867 kref_init(&nc_node->refcount);
Sven Eckelmann55db2d52016-07-15 17:39:21 +0200868 ether_addr_copy(nc_node->addr, orig_node->orig);
869 kref_get(&orig_neigh_node->refcount);
870 nc_node->orig_node = orig_neigh_node;
Martin Hundebølld56b1702013-01-25 11:12:39 +0100871
872 /* Select ingoing or outgoing coding node */
873 if (in_coding) {
874 lock = &orig_neigh_node->in_coding_list_lock;
875 list = &orig_neigh_node->in_coding_list;
876 } else {
877 lock = &orig_neigh_node->out_coding_list_lock;
878 list = &orig_neigh_node->out_coding_list;
879 }
880
881 batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_node %pM -> %pM\n",
882 nc_node->addr, nc_node->orig_node->orig);
883
884 /* Add nc_node to orig_node */
885 spin_lock_bh(lock);
Sven Eckelmannda7a26a2016-07-15 17:39:30 +0200886 kref_get(&nc_node->refcount);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100887 list_add_tail_rcu(&nc_node->list, list);
888 spin_unlock_bh(lock);
889
890 return nc_node;
Martin Hundebølld56b1702013-01-25 11:12:39 +0100891}
892
893/**
Sven Eckelmann34473822015-05-31 10:10:20 +0200894 * batadv_nc_update_nc_node - updates stored incoming and outgoing nc node
895 * structs (best called on incoming OGMs)
Martin Hundebølld56b1702013-01-25 11:12:39 +0100896 * @bat_priv: the bat priv with all the soft interface information
897 * @orig_node: orig node originating the ogm packet
898 * @orig_neigh_node: neighboring orig node from which we received the ogm packet
899 * (can be equal to orig_node)
900 * @ogm_packet: incoming ogm packet
901 * @is_single_hop_neigh: orig_node is a single hop neighbor
902 */
903void batadv_nc_update_nc_node(struct batadv_priv *bat_priv,
904 struct batadv_orig_node *orig_node,
905 struct batadv_orig_node *orig_neigh_node,
906 struct batadv_ogm_packet *ogm_packet,
907 int is_single_hop_neigh)
908{
Sven Eckelmann4f248cf2015-06-09 20:50:49 +0200909 struct batadv_nc_node *in_nc_node = NULL;
910 struct batadv_nc_node *out_nc_node = NULL;
Martin Hundebølld56b1702013-01-25 11:12:39 +0100911
912 /* Check if network coding is enabled */
913 if (!atomic_read(&bat_priv->network_coding))
914 goto out;
915
Marek Lindner3f4841f2013-04-23 21:40:00 +0800916 /* check if orig node is network coding enabled */
Linus Lüssing46354692015-06-16 17:10:23 +0200917 if (!test_bit(BATADV_ORIG_CAPA_HAS_NC, &orig_node->capabilities))
Marek Lindner3f4841f2013-04-23 21:40:00 +0800918 goto out;
919
Martin Hundebølld56b1702013-01-25 11:12:39 +0100920 /* accept ogms from 'good' neighbors and single hop neighbors */
921 if (!batadv_can_nc_with_orig(bat_priv, orig_node, ogm_packet) &&
922 !is_single_hop_neigh)
923 goto out;
924
925 /* Add orig_node as in_nc_node on hop */
926 in_nc_node = batadv_nc_get_nc_node(bat_priv, orig_node,
927 orig_neigh_node, true);
928 if (!in_nc_node)
929 goto out;
930
931 in_nc_node->last_seen = jiffies;
932
933 /* Add hop as out_nc_node on orig_node */
934 out_nc_node = batadv_nc_get_nc_node(bat_priv, orig_neigh_node,
935 orig_node, false);
936 if (!out_nc_node)
937 goto out;
938
939 out_nc_node->last_seen = jiffies;
940
941out:
942 if (in_nc_node)
Sven Eckelmann27ad7542016-01-17 11:01:22 +0100943 batadv_nc_node_put(in_nc_node);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100944 if (out_nc_node)
Sven Eckelmann27ad7542016-01-17 11:01:22 +0100945 batadv_nc_node_put(out_nc_node);
Martin Hundebølld56b1702013-01-25 11:12:39 +0100946}
947
948/**
Martin Hundebøll95332472013-01-25 11:12:40 +0100949 * batadv_nc_get_path - get existing nc_path or allocate a new one
950 * @bat_priv: the bat priv with all the soft interface information
951 * @hash: hash table containing the nc path
952 * @src: ethernet source address - first half of the nc path search key
953 * @dst: ethernet destination address - second half of the nc path search key
954 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200955 * Return: pointer to nc_path if the path was found or created, returns NULL
Martin Hundebøll95332472013-01-25 11:12:40 +0100956 * on error.
957 */
958static struct batadv_nc_path *batadv_nc_get_path(struct batadv_priv *bat_priv,
959 struct batadv_hashtable *hash,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200960 u8 *src,
961 u8 *dst)
Martin Hundebøll95332472013-01-25 11:12:40 +0100962{
963 int hash_added;
964 struct batadv_nc_path *nc_path, nc_path_key;
965
966 batadv_nc_hash_key_gen(&nc_path_key, src, dst);
967
968 /* Search for existing nc_path */
969 nc_path = batadv_nc_hash_find(hash, (void *)&nc_path_key);
970
971 if (nc_path) {
972 /* Set timestamp to delay removal of nc_path */
973 nc_path->last_valid = jiffies;
974 return nc_path;
975 }
976
977 /* No existing nc_path was found; create a new */
978 nc_path = kzalloc(sizeof(*nc_path), GFP_ATOMIC);
979
980 if (!nc_path)
981 return NULL;
982
983 /* Initialize nc_path */
984 INIT_LIST_HEAD(&nc_path->packet_list);
985 spin_lock_init(&nc_path->packet_list_lock);
Sven Eckelmann727e0cd2016-01-16 10:29:46 +0100986 kref_init(&nc_path->refcount);
Martin Hundebøll95332472013-01-25 11:12:40 +0100987 nc_path->last_valid = jiffies;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100988 ether_addr_copy(nc_path->next_hop, dst);
989 ether_addr_copy(nc_path->prev_hop, src);
Martin Hundebøll95332472013-01-25 11:12:40 +0100990
991 batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_path %pM -> %pM\n",
992 nc_path->prev_hop,
993 nc_path->next_hop);
994
995 /* Add nc_path to hash table */
Sven Eckelmannf489eab2016-07-15 17:39:31 +0200996 kref_get(&nc_path->refcount);
Martin Hundebøll95332472013-01-25 11:12:40 +0100997 hash_added = batadv_hash_add(hash, batadv_nc_hash_compare,
998 batadv_nc_hash_choose, &nc_path_key,
999 &nc_path->hash_entry);
1000
1001 if (hash_added < 0) {
1002 kfree(nc_path);
1003 return NULL;
1004 }
1005
1006 return nc_path;
1007}
1008
1009/**
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001010 * batadv_nc_random_weight_tq - scale the receivers TQ-value to avoid unfair
1011 * selection of a receiver with slightly lower TQ than the other
1012 * @tq: to be weighted tq value
Sven Eckelmann672e7972015-10-31 12:29:30 +01001013 *
1014 * Return: scaled tq value
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001015 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001016static u8 batadv_nc_random_weight_tq(u8 tq)
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001017{
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001018 u8 rand_val, rand_tq;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001019
1020 get_random_bytes(&rand_val, sizeof(rand_val));
1021
1022 /* randomize the estimated packet loss (max TQ - estimated TQ) */
1023 rand_tq = rand_val * (BATADV_TQ_MAX_VALUE - tq);
1024
1025 /* normalize the randomized packet loss */
1026 rand_tq /= BATADV_TQ_MAX_VALUE;
1027
1028 /* convert to (randomized) estimated tq again */
1029 return BATADV_TQ_MAX_VALUE - rand_tq;
1030}
1031
1032/**
1033 * batadv_nc_memxor - XOR destination with source
1034 * @dst: byte array to XOR into
1035 * @src: byte array to XOR from
1036 * @len: length of destination array
1037 */
1038static void batadv_nc_memxor(char *dst, const char *src, unsigned int len)
1039{
1040 unsigned int i;
1041
1042 for (i = 0; i < len; ++i)
1043 dst[i] ^= src[i];
1044}
1045
1046/**
1047 * batadv_nc_code_packets - code a received unicast_packet with an nc packet
1048 * into a coded_packet and send it
1049 * @bat_priv: the bat priv with all the soft interface information
1050 * @skb: data skb to forward
1051 * @ethhdr: pointer to the ethernet header inside the skb
1052 * @nc_packet: structure containing the packet to the skb can be coded with
1053 * @neigh_node: next hop to forward packet to
1054 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001055 * Return: true if both packets are consumed, false otherwise.
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001056 */
1057static bool batadv_nc_code_packets(struct batadv_priv *bat_priv,
1058 struct sk_buff *skb,
1059 struct ethhdr *ethhdr,
1060 struct batadv_nc_packet *nc_packet,
1061 struct batadv_neigh_node *neigh_node)
1062{
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001063 u8 tq_weighted_neigh, tq_weighted_coding, tq_tmp;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001064 struct sk_buff *skb_dest, *skb_src;
1065 struct batadv_unicast_packet *packet1;
1066 struct batadv_unicast_packet *packet2;
1067 struct batadv_coded_packet *coded_packet;
Antonio Quartulli95d39272016-01-16 16:40:15 +08001068 struct batadv_neigh_node *neigh_tmp, *router_neigh, *first_dest;
1069 struct batadv_neigh_node *router_coding = NULL, *second_dest;
Simon Wunderlich89652332013-11-13 19:14:46 +01001070 struct batadv_neigh_ifinfo *router_neigh_ifinfo = NULL;
1071 struct batadv_neigh_ifinfo *router_coding_ifinfo = NULL;
Antonio Quartulli95d39272016-01-16 16:40:15 +08001072 u8 *first_source, *second_source;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001073 __be32 packet_id1, packet_id2;
1074 size_t count;
1075 bool res = false;
1076 int coding_len;
1077 int unicast_size = sizeof(*packet1);
1078 int coded_size = sizeof(*coded_packet);
1079 int header_add = coded_size - unicast_size;
1080
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001081 /* TODO: do we need to consider the outgoing interface for
1082 * coded packets?
1083 */
1084 router_neigh = batadv_orig_router_get(neigh_node->orig_node,
1085 BATADV_IF_DEFAULT);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001086 if (!router_neigh)
1087 goto out;
1088
Simon Wunderlich89652332013-11-13 19:14:46 +01001089 router_neigh_ifinfo = batadv_neigh_ifinfo_get(router_neigh,
1090 BATADV_IF_DEFAULT);
1091 if (!router_neigh_ifinfo)
1092 goto out;
1093
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001094 neigh_tmp = nc_packet->neigh_node;
Simon Wunderlich7351a4822013-11-13 19:14:47 +01001095 router_coding = batadv_orig_router_get(neigh_tmp->orig_node,
1096 BATADV_IF_DEFAULT);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001097 if (!router_coding)
1098 goto out;
1099
Simon Wunderlich89652332013-11-13 19:14:46 +01001100 router_coding_ifinfo = batadv_neigh_ifinfo_get(router_coding,
1101 BATADV_IF_DEFAULT);
1102 if (!router_coding_ifinfo)
1103 goto out;
1104
1105 tq_tmp = router_neigh_ifinfo->bat_iv.tq_avg;
1106 tq_weighted_neigh = batadv_nc_random_weight_tq(tq_tmp);
1107 tq_tmp = router_coding_ifinfo->bat_iv.tq_avg;
1108 tq_weighted_coding = batadv_nc_random_weight_tq(tq_tmp);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001109
1110 /* Select one destination for the MAC-header dst-field based on
1111 * weighted TQ-values.
1112 */
1113 if (tq_weighted_neigh >= tq_weighted_coding) {
1114 /* Destination from nc_packet is selected for MAC-header */
Antonio Quartulli95d39272016-01-16 16:40:15 +08001115 first_dest = nc_packet->neigh_node;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001116 first_source = nc_packet->nc_path->prev_hop;
Antonio Quartulli95d39272016-01-16 16:40:15 +08001117 second_dest = neigh_node;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001118 second_source = ethhdr->h_source;
1119 packet1 = (struct batadv_unicast_packet *)nc_packet->skb->data;
1120 packet2 = (struct batadv_unicast_packet *)skb->data;
1121 packet_id1 = nc_packet->packet_id;
1122 packet_id2 = batadv_skb_crc32(skb,
1123 skb->data + sizeof(*packet2));
1124 } else {
1125 /* Destination for skb is selected for MAC-header */
Antonio Quartulli95d39272016-01-16 16:40:15 +08001126 first_dest = neigh_node;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001127 first_source = ethhdr->h_source;
Antonio Quartulli95d39272016-01-16 16:40:15 +08001128 second_dest = nc_packet->neigh_node;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001129 second_source = nc_packet->nc_path->prev_hop;
1130 packet1 = (struct batadv_unicast_packet *)skb->data;
1131 packet2 = (struct batadv_unicast_packet *)nc_packet->skb->data;
1132 packet_id1 = batadv_skb_crc32(skb,
1133 skb->data + sizeof(*packet1));
1134 packet_id2 = nc_packet->packet_id;
1135 }
1136
1137 /* Instead of zero padding the smallest data buffer, we
1138 * code into the largest.
1139 */
1140 if (skb->len <= nc_packet->skb->len) {
1141 skb_dest = nc_packet->skb;
1142 skb_src = skb;
1143 } else {
1144 skb_dest = skb;
1145 skb_src = nc_packet->skb;
1146 }
1147
1148 /* coding_len is used when decoding the packet shorter packet */
1149 coding_len = skb_src->len - unicast_size;
1150
1151 if (skb_linearize(skb_dest) < 0 || skb_linearize(skb_src) < 0)
1152 goto out;
1153
1154 skb_push(skb_dest, header_add);
1155
1156 coded_packet = (struct batadv_coded_packet *)skb_dest->data;
1157 skb_reset_mac_header(skb_dest);
1158
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001159 coded_packet->packet_type = BATADV_CODED;
1160 coded_packet->version = BATADV_COMPAT_VERSION;
1161 coded_packet->ttl = packet1->ttl;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001162
1163 /* Info about first unicast packet */
Antonio Quartulli8fdd0152014-01-22 00:42:11 +01001164 ether_addr_copy(coded_packet->first_source, first_source);
1165 ether_addr_copy(coded_packet->first_orig_dest, packet1->dest);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001166 coded_packet->first_crc = packet_id1;
1167 coded_packet->first_ttvn = packet1->ttvn;
1168
1169 /* Info about second unicast packet */
Antonio Quartulli95d39272016-01-16 16:40:15 +08001170 ether_addr_copy(coded_packet->second_dest, second_dest->addr);
Antonio Quartulli8fdd0152014-01-22 00:42:11 +01001171 ether_addr_copy(coded_packet->second_source, second_source);
1172 ether_addr_copy(coded_packet->second_orig_dest, packet2->dest);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001173 coded_packet->second_crc = packet_id2;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001174 coded_packet->second_ttl = packet2->ttl;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001175 coded_packet->second_ttvn = packet2->ttvn;
1176 coded_packet->coded_len = htons(coding_len);
1177
1178 /* This is where the magic happens: Code skb_src into skb_dest */
1179 batadv_nc_memxor(skb_dest->data + coded_size,
1180 skb_src->data + unicast_size, coding_len);
1181
1182 /* Update counters accordingly */
1183 if (BATADV_SKB_CB(skb_src)->decoded &&
1184 BATADV_SKB_CB(skb_dest)->decoded) {
1185 /* Both packets are recoded */
1186 count = skb_src->len + ETH_HLEN;
1187 count += skb_dest->len + ETH_HLEN;
1188 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE, 2);
1189 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES, count);
1190 } else if (!BATADV_SKB_CB(skb_src)->decoded &&
1191 !BATADV_SKB_CB(skb_dest)->decoded) {
1192 /* Both packets are newly coded */
1193 count = skb_src->len + ETH_HLEN;
1194 count += skb_dest->len + ETH_HLEN;
1195 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE, 2);
1196 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES, count);
1197 } else if (BATADV_SKB_CB(skb_src)->decoded &&
1198 !BATADV_SKB_CB(skb_dest)->decoded) {
1199 /* skb_src recoded and skb_dest is newly coded */
1200 batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
1201 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
1202 skb_src->len + ETH_HLEN);
1203 batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
1204 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
1205 skb_dest->len + ETH_HLEN);
1206 } else if (!BATADV_SKB_CB(skb_src)->decoded &&
1207 BATADV_SKB_CB(skb_dest)->decoded) {
1208 /* skb_src is newly coded and skb_dest is recoded */
1209 batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
1210 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
1211 skb_src->len + ETH_HLEN);
1212 batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
1213 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
1214 skb_dest->len + ETH_HLEN);
1215 }
1216
1217 /* skb_src is now coded into skb_dest, so free it */
Sven Eckelmannbd687fe2016-07-17 21:04:00 +02001218 consume_skb(skb_src);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001219
1220 /* avoid duplicate free of skb from nc_packet */
1221 nc_packet->skb = NULL;
Sven Eckelmannbd687fe2016-07-17 21:04:00 +02001222 batadv_nc_packet_free(nc_packet, false);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001223
1224 /* Send the coded packet and return true */
Antonio Quartulli95d39272016-01-16 16:40:15 +08001225 batadv_send_unicast_skb(skb_dest, first_dest);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001226 res = true;
1227out:
1228 if (router_neigh)
Sven Eckelmann25bb2502016-01-17 11:01:11 +01001229 batadv_neigh_node_put(router_neigh);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001230 if (router_coding)
Sven Eckelmann25bb2502016-01-17 11:01:11 +01001231 batadv_neigh_node_put(router_coding);
Simon Wunderlich89652332013-11-13 19:14:46 +01001232 if (router_neigh_ifinfo)
Sven Eckelmann044fa3a2016-01-17 11:01:12 +01001233 batadv_neigh_ifinfo_put(router_neigh_ifinfo);
Simon Wunderlich89652332013-11-13 19:14:46 +01001234 if (router_coding_ifinfo)
Sven Eckelmann044fa3a2016-01-17 11:01:12 +01001235 batadv_neigh_ifinfo_put(router_coding_ifinfo);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001236 return res;
1237}
1238
1239/**
1240 * batadv_nc_skb_coding_possible - true if a decoded skb is available at dst.
1241 * @skb: data skb to forward
1242 * @dst: destination mac address of the other skb to code with
1243 * @src: source mac address of skb
1244 *
1245 * Whenever we network code a packet we have to check whether we received it in
1246 * a network coded form. If so, we may not be able to use it for coding because
1247 * some neighbors may also have received (overheard) the packet in the network
1248 * coded form without being able to decode it. It is hard to know which of the
1249 * neighboring nodes was able to decode the packet, therefore we can only
1250 * re-code the packet if the source of the previous encoded packet is involved.
1251 * Since the source encoded the packet we can be certain it has all necessary
1252 * decode information.
1253 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001254 * Return: true if coding of a decoded packet is allowed.
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001255 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001256static bool batadv_nc_skb_coding_possible(struct sk_buff *skb, u8 *dst, u8 *src)
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001257{
1258 if (BATADV_SKB_CB(skb)->decoded && !batadv_compare_eth(dst, src))
1259 return false;
Antonio Quartulli24820df2014-09-01 14:37:25 +02001260 return true;
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001261}
1262
1263/**
1264 * batadv_nc_path_search - Find the coding path matching in_nc_node and
1265 * out_nc_node to retrieve a buffered packet that can be used for coding.
1266 * @bat_priv: the bat priv with all the soft interface information
1267 * @in_nc_node: pointer to skb next hop's neighbor nc node
1268 * @out_nc_node: pointer to skb source's neighbor nc node
1269 * @skb: data skb to forward
1270 * @eth_dst: next hop mac address of skb
1271 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001272 * Return: true if coding of a decoded skb is allowed.
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001273 */
1274static struct batadv_nc_packet *
1275batadv_nc_path_search(struct batadv_priv *bat_priv,
1276 struct batadv_nc_node *in_nc_node,
1277 struct batadv_nc_node *out_nc_node,
1278 struct sk_buff *skb,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001279 u8 *eth_dst)
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001280{
1281 struct batadv_nc_path *nc_path, nc_path_key;
1282 struct batadv_nc_packet *nc_packet_out = NULL;
1283 struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
1284 struct batadv_hashtable *hash = bat_priv->nc.coding_hash;
1285 int idx;
1286
1287 if (!hash)
1288 return NULL;
1289
1290 /* Create almost path key */
1291 batadv_nc_hash_key_gen(&nc_path_key, in_nc_node->addr,
1292 out_nc_node->addr);
1293 idx = batadv_nc_hash_choose(&nc_path_key, hash->size);
1294
1295 /* Check for coding opportunities in this nc_path */
1296 rcu_read_lock();
1297 hlist_for_each_entry_rcu(nc_path, &hash->table[idx], hash_entry) {
1298 if (!batadv_compare_eth(nc_path->prev_hop, in_nc_node->addr))
1299 continue;
1300
1301 if (!batadv_compare_eth(nc_path->next_hop, out_nc_node->addr))
1302 continue;
1303
1304 spin_lock_bh(&nc_path->packet_list_lock);
1305 if (list_empty(&nc_path->packet_list)) {
1306 spin_unlock_bh(&nc_path->packet_list_lock);
1307 continue;
1308 }
1309
1310 list_for_each_entry_safe(nc_packet, nc_packet_tmp,
1311 &nc_path->packet_list, list) {
1312 if (!batadv_nc_skb_coding_possible(nc_packet->skb,
1313 eth_dst,
1314 in_nc_node->addr))
1315 continue;
1316
1317 /* Coding opportunity is found! */
1318 list_del(&nc_packet->list);
1319 nc_packet_out = nc_packet;
1320 break;
1321 }
1322
1323 spin_unlock_bh(&nc_path->packet_list_lock);
1324 break;
1325 }
1326 rcu_read_unlock();
1327
1328 return nc_packet_out;
1329}
1330
1331/**
1332 * batadv_nc_skb_src_search - Loops through the list of neighoring nodes of the
1333 * skb's sender (may be equal to the originator).
1334 * @bat_priv: the bat priv with all the soft interface information
1335 * @skb: data skb to forward
1336 * @eth_dst: next hop mac address of skb
1337 * @eth_src: source mac address of skb
1338 * @in_nc_node: pointer to skb next hop's neighbor nc node
1339 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001340 * Return: an nc packet if a suitable coding packet was found, NULL otherwise.
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001341 */
1342static struct batadv_nc_packet *
1343batadv_nc_skb_src_search(struct batadv_priv *bat_priv,
1344 struct sk_buff *skb,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001345 u8 *eth_dst,
1346 u8 *eth_src,
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001347 struct batadv_nc_node *in_nc_node)
1348{
1349 struct batadv_orig_node *orig_node;
1350 struct batadv_nc_node *out_nc_node;
1351 struct batadv_nc_packet *nc_packet = NULL;
1352
1353 orig_node = batadv_orig_hash_find(bat_priv, eth_src);
1354 if (!orig_node)
1355 return NULL;
1356
1357 rcu_read_lock();
1358 list_for_each_entry_rcu(out_nc_node,
1359 &orig_node->out_coding_list, list) {
1360 /* Check if the skb is decoded and if recoding is possible */
1361 if (!batadv_nc_skb_coding_possible(skb,
1362 out_nc_node->addr, eth_src))
1363 continue;
1364
1365 /* Search for an opportunity in this nc_path */
1366 nc_packet = batadv_nc_path_search(bat_priv, in_nc_node,
1367 out_nc_node, skb, eth_dst);
1368 if (nc_packet)
1369 break;
1370 }
1371 rcu_read_unlock();
1372
Sven Eckelmann5d967312016-01-17 11:01:09 +01001373 batadv_orig_node_put(orig_node);
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001374 return nc_packet;
1375}
1376
1377/**
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001378 * batadv_nc_skb_store_before_coding - set the ethernet src and dst of the
1379 * unicast skb before it is stored for use in later decoding
1380 * @bat_priv: the bat priv with all the soft interface information
1381 * @skb: data skb to store
1382 * @eth_dst_new: new destination mac address of skb
1383 */
1384static void batadv_nc_skb_store_before_coding(struct batadv_priv *bat_priv,
1385 struct sk_buff *skb,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001386 u8 *eth_dst_new)
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001387{
1388 struct ethhdr *ethhdr;
1389
1390 /* Copy skb header to change the mac header */
Octavian Purdilabad93e92014-06-12 01:36:26 +03001391 skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001392 if (!skb)
1393 return;
1394
1395 /* Set the mac header as if we actually sent the packet uncoded */
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001396 ethhdr = eth_hdr(skb);
Antonio Quartulli8fdd0152014-01-22 00:42:11 +01001397 ether_addr_copy(ethhdr->h_source, ethhdr->h_dest);
1398 ether_addr_copy(ethhdr->h_dest, eth_dst_new);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001399
1400 /* Set data pointer to MAC header to mimic packets from our tx path */
1401 skb_push(skb, ETH_HLEN);
1402
1403 /* Add the packet to the decoding packet pool */
1404 batadv_nc_skb_store_for_decoding(bat_priv, skb);
1405
1406 /* batadv_nc_skb_store_for_decoding() clones the skb, so we must free
1407 * our ref
1408 */
Sven Eckelmannbd687fe2016-07-17 21:04:00 +02001409 consume_skb(skb);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001410}
1411
1412/**
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001413 * batadv_nc_skb_dst_search - Loops through list of neighboring nodes to dst.
1414 * @skb: data skb to forward
1415 * @neigh_node: next hop to forward packet to
1416 * @ethhdr: pointer to the ethernet header inside the skb
1417 *
1418 * Loops through list of neighboring nodes the next hop has a good connection to
1419 * (receives OGMs with a sufficient quality). We need to find a neighbor of our
1420 * next hop that potentially sent a packet which our next hop also received
1421 * (overheard) and has stored for later decoding.
1422 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001423 * Return: true if the skb was consumed (encoded packet sent) or false otherwise
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001424 */
1425static bool batadv_nc_skb_dst_search(struct sk_buff *skb,
1426 struct batadv_neigh_node *neigh_node,
1427 struct ethhdr *ethhdr)
1428{
1429 struct net_device *netdev = neigh_node->if_incoming->soft_iface;
1430 struct batadv_priv *bat_priv = netdev_priv(netdev);
1431 struct batadv_orig_node *orig_node = neigh_node->orig_node;
1432 struct batadv_nc_node *nc_node;
1433 struct batadv_nc_packet *nc_packet = NULL;
1434
1435 rcu_read_lock();
1436 list_for_each_entry_rcu(nc_node, &orig_node->in_coding_list, list) {
1437 /* Search for coding opportunity with this in_nc_node */
1438 nc_packet = batadv_nc_skb_src_search(bat_priv, skb,
1439 neigh_node->addr,
1440 ethhdr->h_source, nc_node);
1441
1442 /* Opportunity was found, so stop searching */
1443 if (nc_packet)
1444 break;
1445 }
1446 rcu_read_unlock();
1447
1448 if (!nc_packet)
1449 return false;
1450
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001451 /* Save packets for later decoding */
1452 batadv_nc_skb_store_before_coding(bat_priv, skb,
1453 neigh_node->addr);
1454 batadv_nc_skb_store_before_coding(bat_priv, nc_packet->skb,
1455 nc_packet->neigh_node->addr);
1456
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001457 /* Code and send packets */
1458 if (batadv_nc_code_packets(bat_priv, skb, ethhdr, nc_packet,
1459 neigh_node))
1460 return true;
1461
1462 /* out of mem ? Coding failed - we have to free the buffered packet
1463 * to avoid memleaks. The skb passed as argument will be dealt with
1464 * by the calling function.
1465 */
1466 batadv_nc_send_packet(nc_packet);
1467 return false;
1468}
1469
1470/**
Martin Hundebøll95332472013-01-25 11:12:40 +01001471 * batadv_nc_skb_add_to_path - buffer skb for later encoding / decoding
1472 * @skb: skb to add to path
1473 * @nc_path: path to add skb to
1474 * @neigh_node: next hop to forward packet to
1475 * @packet_id: checksum to identify packet
1476 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001477 * Return: true if the packet was buffered or false in case of an error.
Martin Hundebøll95332472013-01-25 11:12:40 +01001478 */
1479static bool batadv_nc_skb_add_to_path(struct sk_buff *skb,
1480 struct batadv_nc_path *nc_path,
1481 struct batadv_neigh_node *neigh_node,
1482 __be32 packet_id)
1483{
1484 struct batadv_nc_packet *nc_packet;
1485
1486 nc_packet = kzalloc(sizeof(*nc_packet), GFP_ATOMIC);
1487 if (!nc_packet)
1488 return false;
1489
1490 /* Initialize nc_packet */
1491 nc_packet->timestamp = jiffies;
1492 nc_packet->packet_id = packet_id;
1493 nc_packet->skb = skb;
1494 nc_packet->neigh_node = neigh_node;
1495 nc_packet->nc_path = nc_path;
1496
1497 /* Add coding packet to list */
1498 spin_lock_bh(&nc_path->packet_list_lock);
1499 list_add_tail(&nc_packet->list, &nc_path->packet_list);
1500 spin_unlock_bh(&nc_path->packet_list_lock);
1501
1502 return true;
1503}
1504
1505/**
1506 * batadv_nc_skb_forward - try to code a packet or add it to the coding packet
1507 * buffer
1508 * @skb: data skb to forward
1509 * @neigh_node: next hop to forward packet to
Martin Hundebøll95332472013-01-25 11:12:40 +01001510 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001511 * Return: true if the skb was consumed (encoded packet sent) or false otherwise
Martin Hundebøll95332472013-01-25 11:12:40 +01001512 */
1513bool batadv_nc_skb_forward(struct sk_buff *skb,
Martin Hundebølle91ecfc2013-04-20 13:54:39 +02001514 struct batadv_neigh_node *neigh_node)
Martin Hundebøll95332472013-01-25 11:12:40 +01001515{
1516 const struct net_device *netdev = neigh_node->if_incoming->soft_iface;
1517 struct batadv_priv *bat_priv = netdev_priv(netdev);
1518 struct batadv_unicast_packet *packet;
1519 struct batadv_nc_path *nc_path;
Martin Hundebølle91ecfc2013-04-20 13:54:39 +02001520 struct ethhdr *ethhdr = eth_hdr(skb);
Martin Hundebøll95332472013-01-25 11:12:40 +01001521 __be32 packet_id;
1522 u8 *payload;
1523
1524 /* Check if network coding is enabled */
1525 if (!atomic_read(&bat_priv->network_coding))
1526 goto out;
1527
1528 /* We only handle unicast packets */
1529 payload = skb_network_header(skb);
1530 packet = (struct batadv_unicast_packet *)payload;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001531 if (packet->packet_type != BATADV_UNICAST)
Martin Hundebøll95332472013-01-25 11:12:40 +01001532 goto out;
1533
Martin Hundebøll3c12de92013-01-25 11:12:41 +01001534 /* Try to find a coding opportunity and send the skb if one is found */
1535 if (batadv_nc_skb_dst_search(skb, neigh_node, ethhdr))
1536 return true;
1537
Martin Hundebøll95332472013-01-25 11:12:40 +01001538 /* Find or create a nc_path for this src-dst pair */
1539 nc_path = batadv_nc_get_path(bat_priv,
1540 bat_priv->nc.coding_hash,
1541 ethhdr->h_source,
1542 neigh_node->addr);
1543
1544 if (!nc_path)
1545 goto out;
1546
1547 /* Add skb to nc_path */
1548 packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
1549 if (!batadv_nc_skb_add_to_path(skb, nc_path, neigh_node, packet_id))
1550 goto free_nc_path;
1551
1552 /* Packet is consumed */
1553 return true;
1554
1555free_nc_path:
Sven Eckelmann5fff2822016-01-17 11:01:23 +01001556 batadv_nc_path_put(nc_path);
Martin Hundebøll95332472013-01-25 11:12:40 +01001557out:
1558 /* Packet is not consumed */
1559 return false;
1560}
1561
1562/**
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001563 * batadv_nc_skb_store_for_decoding - save a clone of the skb which can be used
1564 * when decoding coded packets
1565 * @bat_priv: the bat priv with all the soft interface information
1566 * @skb: data skb to store
1567 */
1568void batadv_nc_skb_store_for_decoding(struct batadv_priv *bat_priv,
1569 struct sk_buff *skb)
1570{
1571 struct batadv_unicast_packet *packet;
1572 struct batadv_nc_path *nc_path;
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001573 struct ethhdr *ethhdr = eth_hdr(skb);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001574 __be32 packet_id;
1575 u8 *payload;
1576
1577 /* Check if network coding is enabled */
1578 if (!atomic_read(&bat_priv->network_coding))
1579 goto out;
1580
1581 /* Check for supported packet type */
1582 payload = skb_network_header(skb);
1583 packet = (struct batadv_unicast_packet *)payload;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001584 if (packet->packet_type != BATADV_UNICAST)
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001585 goto out;
1586
1587 /* Find existing nc_path or create a new */
1588 nc_path = batadv_nc_get_path(bat_priv,
1589 bat_priv->nc.decoding_hash,
1590 ethhdr->h_source,
1591 ethhdr->h_dest);
1592
1593 if (!nc_path)
1594 goto out;
1595
1596 /* Clone skb and adjust skb->data to point at batman header */
1597 skb = skb_clone(skb, GFP_ATOMIC);
1598 if (unlikely(!skb))
1599 goto free_nc_path;
1600
1601 if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
1602 goto free_skb;
1603
1604 if (unlikely(!skb_pull_rcsum(skb, ETH_HLEN)))
1605 goto free_skb;
1606
1607 /* Add skb to nc_path */
1608 packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
1609 if (!batadv_nc_skb_add_to_path(skb, nc_path, NULL, packet_id))
1610 goto free_skb;
1611
1612 batadv_inc_counter(bat_priv, BATADV_CNT_NC_BUFFER);
1613 return;
1614
1615free_skb:
1616 kfree_skb(skb);
1617free_nc_path:
Sven Eckelmann5fff2822016-01-17 11:01:23 +01001618 batadv_nc_path_put(nc_path);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001619out:
1620 return;
1621}
1622
1623/**
1624 * batadv_nc_skb_store_sniffed_unicast - check if a received unicast packet
1625 * should be saved in the decoding buffer and, if so, store it there
1626 * @bat_priv: the bat priv with all the soft interface information
1627 * @skb: unicast skb to store
1628 */
1629void batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
1630 struct sk_buff *skb)
1631{
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001632 struct ethhdr *ethhdr = eth_hdr(skb);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001633
David S. Miller6e0895c2013-04-22 20:32:51 -04001634 if (batadv_is_my_mac(bat_priv, ethhdr->h_dest))
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001635 return;
1636
1637 /* Set data pointer to MAC header to mimic packets from our tx path */
1638 skb_push(skb, ETH_HLEN);
1639
1640 batadv_nc_skb_store_for_decoding(bat_priv, skb);
1641}
1642
1643/**
Martin Hundebøll2df52782013-01-25 11:12:43 +01001644 * batadv_nc_skb_decode_packet - decode given skb using the decode data stored
1645 * in nc_packet
David S. Miller6e0895c2013-04-22 20:32:51 -04001646 * @bat_priv: the bat priv with all the soft interface information
Martin Hundebøll2df52782013-01-25 11:12:43 +01001647 * @skb: unicast skb to decode
1648 * @nc_packet: decode data needed to decode the skb
1649 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001650 * Return: pointer to decoded unicast packet if the packet was decoded or NULL
Martin Hundebøll2df52782013-01-25 11:12:43 +01001651 * in case of an error.
1652 */
1653static struct batadv_unicast_packet *
David S. Miller6e0895c2013-04-22 20:32:51 -04001654batadv_nc_skb_decode_packet(struct batadv_priv *bat_priv, struct sk_buff *skb,
Martin Hundebøll2df52782013-01-25 11:12:43 +01001655 struct batadv_nc_packet *nc_packet)
1656{
1657 const int h_size = sizeof(struct batadv_unicast_packet);
1658 const int h_diff = sizeof(struct batadv_coded_packet) - h_size;
1659 struct batadv_unicast_packet *unicast_packet;
1660 struct batadv_coded_packet coded_packet_tmp;
1661 struct ethhdr *ethhdr, ethhdr_tmp;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001662 u8 *orig_dest, ttl, ttvn;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001663 unsigned int coding_len;
Marek Lindner7da19972013-05-07 19:25:02 +08001664 int err;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001665
1666 /* Save headers temporarily */
1667 memcpy(&coded_packet_tmp, skb->data, sizeof(coded_packet_tmp));
1668 memcpy(&ethhdr_tmp, skb_mac_header(skb), sizeof(ethhdr_tmp));
1669
1670 if (skb_cow(skb, 0) < 0)
1671 return NULL;
1672
1673 if (unlikely(!skb_pull_rcsum(skb, h_diff)))
1674 return NULL;
1675
1676 /* Data points to batman header, so set mac header 14 bytes before
1677 * and network to data
1678 */
1679 skb_set_mac_header(skb, -ETH_HLEN);
1680 skb_reset_network_header(skb);
1681
1682 /* Reconstruct original mac header */
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001683 ethhdr = eth_hdr(skb);
Fengguang Wuabae9472014-01-06 17:09:46 +01001684 *ethhdr = ethhdr_tmp;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001685
1686 /* Select the correct unicast header information based on the location
1687 * of our mac address in the coded_packet header
1688 */
David S. Miller6e0895c2013-04-22 20:32:51 -04001689 if (batadv_is_my_mac(bat_priv, coded_packet_tmp.second_dest)) {
Martin Hundebøll2df52782013-01-25 11:12:43 +01001690 /* If we are the second destination the packet was overheard,
1691 * so the Ethernet address must be copied to h_dest and
1692 * pkt_type changed from PACKET_OTHERHOST to PACKET_HOST
1693 */
Antonio Quartulli8fdd0152014-01-22 00:42:11 +01001694 ether_addr_copy(ethhdr->h_dest, coded_packet_tmp.second_dest);
Martin Hundebøll2df52782013-01-25 11:12:43 +01001695 skb->pkt_type = PACKET_HOST;
1696
1697 orig_dest = coded_packet_tmp.second_orig_dest;
1698 ttl = coded_packet_tmp.second_ttl;
1699 ttvn = coded_packet_tmp.second_ttvn;
1700 } else {
1701 orig_dest = coded_packet_tmp.first_orig_dest;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001702 ttl = coded_packet_tmp.ttl;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001703 ttvn = coded_packet_tmp.first_ttvn;
1704 }
1705
1706 coding_len = ntohs(coded_packet_tmp.coded_len);
1707
1708 if (coding_len > skb->len)
1709 return NULL;
1710
1711 /* Here the magic is reversed:
1712 * extract the missing packet from the received coded packet
1713 */
1714 batadv_nc_memxor(skb->data + h_size,
1715 nc_packet->skb->data + h_size,
1716 coding_len);
1717
1718 /* Resize decoded skb if decoded with larger packet */
Marek Lindner7da19972013-05-07 19:25:02 +08001719 if (nc_packet->skb->len > coding_len + h_size) {
1720 err = pskb_trim_rcsum(skb, coding_len + h_size);
1721 if (err)
1722 return NULL;
1723 }
Martin Hundebøll2df52782013-01-25 11:12:43 +01001724
1725 /* Create decoded unicast packet */
1726 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001727 unicast_packet->packet_type = BATADV_UNICAST;
1728 unicast_packet->version = BATADV_COMPAT_VERSION;
1729 unicast_packet->ttl = ttl;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +01001730 ether_addr_copy(unicast_packet->dest, orig_dest);
Martin Hundebøll2df52782013-01-25 11:12:43 +01001731 unicast_packet->ttvn = ttvn;
1732
Sven Eckelmannbd687fe2016-07-17 21:04:00 +02001733 batadv_nc_packet_free(nc_packet, false);
Martin Hundebøll2df52782013-01-25 11:12:43 +01001734 return unicast_packet;
1735}
1736
1737/**
1738 * batadv_nc_find_decoding_packet - search through buffered decoding data to
1739 * find the data needed to decode the coded packet
1740 * @bat_priv: the bat priv with all the soft interface information
1741 * @ethhdr: pointer to the ethernet header inside the coded packet
1742 * @coded: coded packet we try to find decode data for
1743 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001744 * Return: pointer to nc packet if the needed data was found or NULL otherwise.
Martin Hundebøll2df52782013-01-25 11:12:43 +01001745 */
1746static struct batadv_nc_packet *
1747batadv_nc_find_decoding_packet(struct batadv_priv *bat_priv,
1748 struct ethhdr *ethhdr,
1749 struct batadv_coded_packet *coded)
1750{
1751 struct batadv_hashtable *hash = bat_priv->nc.decoding_hash;
1752 struct batadv_nc_packet *tmp_nc_packet, *nc_packet = NULL;
1753 struct batadv_nc_path *nc_path, nc_path_key;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001754 u8 *dest, *source;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001755 __be32 packet_id;
1756 int index;
1757
1758 if (!hash)
1759 return NULL;
1760
1761 /* Select the correct packet id based on the location of our mac-addr */
1762 dest = ethhdr->h_source;
David S. Miller6e0895c2013-04-22 20:32:51 -04001763 if (!batadv_is_my_mac(bat_priv, coded->second_dest)) {
Martin Hundebøll2df52782013-01-25 11:12:43 +01001764 source = coded->second_source;
1765 packet_id = coded->second_crc;
1766 } else {
1767 source = coded->first_source;
1768 packet_id = coded->first_crc;
1769 }
1770
1771 batadv_nc_hash_key_gen(&nc_path_key, source, dest);
1772 index = batadv_nc_hash_choose(&nc_path_key, hash->size);
1773
1774 /* Search for matching coding path */
1775 rcu_read_lock();
1776 hlist_for_each_entry_rcu(nc_path, &hash->table[index], hash_entry) {
1777 /* Find matching nc_packet */
1778 spin_lock_bh(&nc_path->packet_list_lock);
1779 list_for_each_entry(tmp_nc_packet,
1780 &nc_path->packet_list, list) {
1781 if (packet_id == tmp_nc_packet->packet_id) {
1782 list_del(&tmp_nc_packet->list);
1783
1784 nc_packet = tmp_nc_packet;
1785 break;
1786 }
1787 }
1788 spin_unlock_bh(&nc_path->packet_list_lock);
1789
1790 if (nc_packet)
1791 break;
1792 }
1793 rcu_read_unlock();
1794
1795 if (!nc_packet)
1796 batadv_dbg(BATADV_DBG_NC, bat_priv,
1797 "No decoding packet found for %u\n", packet_id);
1798
1799 return nc_packet;
1800}
1801
1802/**
1803 * batadv_nc_recv_coded_packet - try to decode coded packet and enqueue the
1804 * resulting unicast packet
1805 * @skb: incoming coded packet
1806 * @recv_if: pointer to interface this packet was received on
Sven Eckelmann672e7972015-10-31 12:29:30 +01001807 *
1808 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
1809 * otherwise.
Martin Hundebøll2df52782013-01-25 11:12:43 +01001810 */
1811static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
1812 struct batadv_hard_iface *recv_if)
1813{
1814 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1815 struct batadv_unicast_packet *unicast_packet;
1816 struct batadv_coded_packet *coded_packet;
1817 struct batadv_nc_packet *nc_packet;
1818 struct ethhdr *ethhdr;
1819 int hdr_size = sizeof(*coded_packet);
1820
1821 /* Check if network coding is enabled */
1822 if (!atomic_read(&bat_priv->network_coding))
Sven Eckelmannb91a2542016-07-17 21:04:04 +02001823 goto free_skb;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001824
1825 /* Make sure we can access (and remove) header */
1826 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Sven Eckelmannb91a2542016-07-17 21:04:04 +02001827 goto free_skb;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001828
1829 coded_packet = (struct batadv_coded_packet *)skb->data;
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001830 ethhdr = eth_hdr(skb);
Martin Hundebøll2df52782013-01-25 11:12:43 +01001831
1832 /* Verify frame is destined for us */
David S. Miller6e0895c2013-04-22 20:32:51 -04001833 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest) &&
1834 !batadv_is_my_mac(bat_priv, coded_packet->second_dest))
Sven Eckelmannb91a2542016-07-17 21:04:04 +02001835 goto free_skb;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001836
1837 /* Update stat counter */
David S. Miller6e0895c2013-04-22 20:32:51 -04001838 if (batadv_is_my_mac(bat_priv, coded_packet->second_dest))
Martin Hundebøll2df52782013-01-25 11:12:43 +01001839 batadv_inc_counter(bat_priv, BATADV_CNT_NC_SNIFFED);
1840
1841 nc_packet = batadv_nc_find_decoding_packet(bat_priv, ethhdr,
1842 coded_packet);
1843 if (!nc_packet) {
1844 batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
Sven Eckelmannb91a2542016-07-17 21:04:04 +02001845 goto free_skb;
Martin Hundebøll2df52782013-01-25 11:12:43 +01001846 }
1847
1848 /* Make skb's linear, because decoding accesses the entire buffer */
1849 if (skb_linearize(skb) < 0)
1850 goto free_nc_packet;
1851
1852 if (skb_linearize(nc_packet->skb) < 0)
1853 goto free_nc_packet;
1854
1855 /* Decode the packet */
David S. Miller6e0895c2013-04-22 20:32:51 -04001856 unicast_packet = batadv_nc_skb_decode_packet(bat_priv, skb, nc_packet);
Martin Hundebøll2df52782013-01-25 11:12:43 +01001857 if (!unicast_packet) {
1858 batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
1859 goto free_nc_packet;
1860 }
1861
1862 /* Mark packet as decoded to do correct recoding when forwarding */
1863 BATADV_SKB_CB(skb)->decoded = true;
1864 batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE);
1865 batadv_add_counter(bat_priv, BATADV_CNT_NC_DECODE_BYTES,
1866 skb->len + ETH_HLEN);
1867 return batadv_recv_unicast_packet(skb, recv_if);
1868
1869free_nc_packet:
Sven Eckelmannbd687fe2016-07-17 21:04:00 +02001870 batadv_nc_packet_free(nc_packet, true);
Sven Eckelmannb91a2542016-07-17 21:04:04 +02001871free_skb:
1872 kfree_skb(skb);
1873
Martin Hundebøll2df52782013-01-25 11:12:43 +01001874 return NET_RX_DROP;
1875}
1876
1877/**
Matthias Schiffer6c519ba2013-09-27 18:03:39 +02001878 * batadv_nc_mesh_free - clean up network coding memory
Martin Hundebølld353d8d2013-01-25 11:12:38 +01001879 * @bat_priv: the bat priv with all the soft interface information
1880 */
Matthias Schiffer6c519ba2013-09-27 18:03:39 +02001881void batadv_nc_mesh_free(struct batadv_priv *bat_priv)
Martin Hundebølld353d8d2013-01-25 11:12:38 +01001882{
Marek Lindner3f4841f2013-04-23 21:40:00 +08001883 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_NC, 1);
1884 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_NC, 1);
Martin Hundebølld353d8d2013-01-25 11:12:38 +01001885 cancel_delayed_work_sync(&bat_priv->nc.work);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001886
Martin Hundebøll95332472013-01-25 11:12:40 +01001887 batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
1888 batadv_hash_destroy(bat_priv->nc.coding_hash);
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001889 batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash, NULL);
1890 batadv_hash_destroy(bat_priv->nc.decoding_hash);
Martin Hundebølld353d8d2013-01-25 11:12:38 +01001891}
Martin Hundebølld56b1702013-01-25 11:12:39 +01001892
Sven Eckelmanndc1cbd12016-07-16 09:31:20 +02001893#ifdef CONFIG_BATMAN_ADV_DEBUGFS
Martin Hundebølld56b1702013-01-25 11:12:39 +01001894/**
1895 * batadv_nc_nodes_seq_print_text - print the nc node information
1896 * @seq: seq file to print on
1897 * @offset: not used
Sven Eckelmann672e7972015-10-31 12:29:30 +01001898 *
1899 * Return: always 0
Martin Hundebølld56b1702013-01-25 11:12:39 +01001900 */
1901int batadv_nc_nodes_seq_print_text(struct seq_file *seq, void *offset)
1902{
1903 struct net_device *net_dev = (struct net_device *)seq->private;
1904 struct batadv_priv *bat_priv = netdev_priv(net_dev);
1905 struct batadv_hashtable *hash = bat_priv->orig_hash;
1906 struct batadv_hard_iface *primary_if;
1907 struct hlist_head *head;
1908 struct batadv_orig_node *orig_node;
1909 struct batadv_nc_node *nc_node;
1910 int i;
1911
1912 primary_if = batadv_seq_print_text_primary_if_get(seq);
1913 if (!primary_if)
1914 goto out;
1915
1916 /* Traverse list of originators */
1917 for (i = 0; i < hash->size; i++) {
1918 head = &hash->table[i];
1919
1920 /* For each orig_node in this bin */
1921 rcu_read_lock();
1922 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
Marek Lindneraa27c3122013-04-18 04:56:03 +08001923 /* no need to print the orig node if it does not have
1924 * network coding neighbors
1925 */
1926 if (list_empty(&orig_node->in_coding_list) &&
1927 list_empty(&orig_node->out_coding_list))
1928 continue;
1929
Martin Hundebølld56b1702013-01-25 11:12:39 +01001930 seq_printf(seq, "Node: %pM\n", orig_node->orig);
1931
Antonio Quartulli0c814652013-03-21 09:23:29 +01001932 seq_puts(seq, " Ingoing: ");
Martin Hundebølld56b1702013-01-25 11:12:39 +01001933 /* For each in_nc_node to this orig_node */
1934 list_for_each_entry_rcu(nc_node,
1935 &orig_node->in_coding_list,
1936 list)
1937 seq_printf(seq, "%pM ",
1938 nc_node->addr);
Markus Elfring912eeed2017-05-06 17:57:36 +02001939 seq_puts(seq, "\n Outgoing: ");
Martin Hundebølld56b1702013-01-25 11:12:39 +01001940 /* For out_nc_node to this orig_node */
1941 list_for_each_entry_rcu(nc_node,
1942 &orig_node->out_coding_list,
1943 list)
1944 seq_printf(seq, "%pM ",
1945 nc_node->addr);
Antonio Quartulli0c814652013-03-21 09:23:29 +01001946 seq_puts(seq, "\n\n");
Martin Hundebølld56b1702013-01-25 11:12:39 +01001947 }
1948 rcu_read_unlock();
1949 }
1950
1951out:
1952 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +01001953 batadv_hardif_put(primary_if);
Martin Hundebølld56b1702013-01-25 11:12:39 +01001954 return 0;
1955}
1956
1957/**
1958 * batadv_nc_init_debugfs - create nc folder and related files in debugfs
1959 * @bat_priv: the bat priv with all the soft interface information
Sven Eckelmann672e7972015-10-31 12:29:30 +01001960 *
1961 * Return: 0 on success or negative error number in case of failure
Martin Hundebølld56b1702013-01-25 11:12:39 +01001962 */
1963int batadv_nc_init_debugfs(struct batadv_priv *bat_priv)
1964{
1965 struct dentry *nc_dir, *file;
1966
1967 nc_dir = debugfs_create_dir("nc", bat_priv->debug_dir);
1968 if (!nc_dir)
1969 goto out;
1970
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001971 file = debugfs_create_u8("min_tq", 0644, nc_dir, &bat_priv->nc.min_tq);
Martin Hundebølld56b1702013-01-25 11:12:39 +01001972 if (!file)
1973 goto out;
1974
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001975 file = debugfs_create_u32("max_fwd_delay", 0644, nc_dir,
Martin Hundebøll95332472013-01-25 11:12:40 +01001976 &bat_priv->nc.max_fwd_delay);
1977 if (!file)
1978 goto out;
1979
Sven Eckelmann507b37c2016-09-01 10:25:12 +02001980 file = debugfs_create_u32("max_buffer_time", 0644, nc_dir,
Martin Hundebøll612d2b42013-01-25 11:12:42 +01001981 &bat_priv->nc.max_buffer_time);
1982 if (!file)
1983 goto out;
1984
Martin Hundebølld56b1702013-01-25 11:12:39 +01001985 return 0;
1986
1987out:
1988 return -ENOMEM;
1989}
Sven Eckelmanndc1cbd12016-07-16 09:31:20 +02001990#endif