main.h 13.5 KB
Newer Older
1
/* Copyright (C) 2007-2015 B.A.T.M.A.N. contributors:
2 3 4 5 6 7 8 9 10 11 12 13 14
 *
 * Marek Lindner, Simon Wunderlich
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
15
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 17 18 19 20
 */

#ifndef _NET_BATMAN_ADV_MAIN_H_
#define _NET_BATMAN_ADV_MAIN_H_

21
#define BATADV_DRIVER_AUTHOR "Marek Lindner <mareklindner@neomailbox.ch>, " \
22
			     "Simon Wunderlich <sw@simonwunderlich.de>"
23 24
#define BATADV_DRIVER_DESC   "B.A.T.M.A.N. advanced"
#define BATADV_DRIVER_DEVICE "batman-adv"
25

26
#ifndef BATADV_SOURCE_VERSION
27
#define BATADV_SOURCE_VERSION "2015.1"
28
#endif
29 30 31

/* B.A.T.M.A.N. parameters */

32 33
#define BATADV_TQ_MAX_VALUE 255
#define BATADV_JITTER 20
34

35
/* Time To Live of broadcast messages */
36
#define BATADV_TTL 50
37 38

/* purge originators after time in seconds if no valid packet comes in
39
 * -> TODO: check influence on BATADV_TQ_LOCAL_WINDOW_SIZE
40
 */
41
#define BATADV_PURGE_TIMEOUT 200000 /* 200 seconds */
42
#define BATADV_TT_LOCAL_TIMEOUT 600000 /* in milliseconds */
43
#define BATADV_TT_CLIENT_ROAM_TIMEOUT 600000 /* in milliseconds */
44
#define BATADV_TT_CLIENT_TEMP_TIMEOUT 600000 /* in milliseconds */
45 46
#define BATADV_TT_WORK_PERIOD 5000 /* 5 seconds */
#define BATADV_ORIG_WORK_PERIOD 1000 /* 1 second */
47
#define BATADV_DAT_ENTRY_TIMEOUT (5 * 60000) /* 5 mins in milliseconds */
48
/* sliding packet range of received originator messages in sequence numbers
49 50
 * (should be a multiple of our word size)
 */
51
#define BATADV_TQ_LOCAL_WINDOW_SIZE 64
52
/* milliseconds we have to keep pending tt_req */
53
#define BATADV_TT_REQUEST_TIMEOUT 3000
54

55 56 57 58
#define BATADV_TQ_GLOBAL_WINDOW_SIZE 5
#define BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM 1
#define BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM 1
#define BATADV_TQ_TOTAL_BIDRECT_LIMIT 1
59

60 61
/* number of OGMs sent with the last tt diff */
#define BATADV_TT_OGM_APPEND_MAX 3
62

63
/* Time in which a client can roam at most ROAMING_MAX_COUNT times in
64
 * milliseconds
65
 */
66 67
#define BATADV_ROAMING_MAX_TIME 20000
#define BATADV_ROAMING_MAX_COUNT 5
68

69
#define BATADV_NO_FLAGS 0
70

71
#define BATADV_NULL_IFINDEX 0 /* dummy ifindex used to avoid iface checks */
72

73 74
#define BATADV_NO_MARK 0

75 76 77 78 79 80
/* default interface for multi interface operation. The default interface is
 * used for communication which originated locally (i.e. is not forwarded)
 * or where special forwarding is not desired/necessary.
 */
#define BATADV_IF_DEFAULT	((struct batadv_hard_iface *)NULL)

81
#define BATADV_NUM_WORDS BITS_TO_LONGS(BATADV_TQ_LOCAL_WINDOW_SIZE)
82

83
#define BATADV_LOG_BUF_LEN 8192	  /* has to be a power of 2 */
84

85 86 87 88 89
/* number of packets to send for broadcasts on different interface types */
#define BATADV_NUM_BCASTS_DEFAULT 1
#define BATADV_NUM_BCASTS_WIRELESS 3
#define BATADV_NUM_BCASTS_MAX 3

90 91
/* msecs after which an ARP_REQUEST is sent in broadcast as fallback */
#define ARP_REQ_DELAY 250
92 93 94
/* numbers of originator to contact for any PUT/GET DHT operation */
#define BATADV_DAT_CANDIDATES_NUM 3

95 96
/* BATADV_TQ_SIMILARITY_THRESHOLD - TQ points that a secondary metric can differ
 * at most from the primary one in order to be still considered acceptable
97 98 99
 */
#define BATADV_TQ_SIMILARITY_THRESHOLD 50

100
/* how much worse secondary interfaces may be to be considered as bonding
101 102
 * candidates
 */
103
#define BATADV_BONDING_TQ_THRESHOLD	50
104

105
/* should not be bigger than 512 bytes or change the size of
106 107
 * forw_packet->direct_link_flags
 */
108 109
#define BATADV_MAX_AGGREGATION_BYTES 512
#define BATADV_MAX_AGGREGATION_MS 100
110

111 112 113
#define BATADV_BLA_PERIOD_LENGTH	10000	/* 10 seconds */
#define BATADV_BLA_BACKBONE_TIMEOUT	(BATADV_BLA_PERIOD_LENGTH * 3)
#define BATADV_BLA_CLAIM_TIMEOUT	(BATADV_BLA_PERIOD_LENGTH * 10)
114
#define BATADV_BLA_WAIT_PERIODS		3
115

116 117
#define BATADV_DUPLIST_SIZE		16
#define BATADV_DUPLIST_TIMEOUT		500	/* 500 ms */
118
/* don't reset again within 30 seconds */
119 120
#define BATADV_RESET_PROTECTION_MS 30000
#define BATADV_EXPECTED_SEQNO_RANGE	65536
121

122 123
#define BATADV_NC_NODE_TIMEOUT 10000 /* Milliseconds */

124 125 126 127
enum batadv_mesh_state {
	BATADV_MESH_INACTIVE,
	BATADV_MESH_ACTIVE,
	BATADV_MESH_DEACTIVATING,
128
};
129

130 131
#define BATADV_BCAST_QUEUE_LEN		256
#define BATADV_BATMAN_QUEUE_LEN	256
132

133 134 135 136
enum batadv_uev_action {
	BATADV_UEV_ADD = 0,
	BATADV_UEV_DEL,
	BATADV_UEV_CHANGE,
137 138
};

139 140
enum batadv_uev_type {
	BATADV_UEV_GW = 0,
141 142
};

143
#define BATADV_GW_THRESHOLD	50
144

145 146 147 148 149 150 151 152 153
/* Number of fragment chains for each orig_node */
#define BATADV_FRAG_BUFFER_COUNT 8
/* Maximum number of fragments for one packet */
#define BATADV_FRAG_MAX_FRAGMENTS 16
/* Maxumim size of each fragment */
#define BATADV_FRAG_MAX_FRAG_SIZE 1400
/* Time to keep fragments while waiting for rest of the fragments */
#define BATADV_FRAG_TIMEOUT 10000

154 155 156
#define BATADV_DAT_CANDIDATE_NOT_FOUND	0
#define BATADV_DAT_CANDIDATE_ORIG	1

157
/* Debug Messages */
158 159 160
#ifdef pr_fmt
#undef pr_fmt
#endif
161 162
/* Append 'batman-adv: ' before kernel messages */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
163

164
/* Kernel headers */
165 166 167 168

#include <linux/mutex.h>	/* mutex */
#include <linux/module.h>	/* needed by all modules */
#include <linux/netdevice.h>	/* netdevice */
169
#include <linux/etherdevice.h>  /* ethernet address classification */
170 171 172 173 174
#include <linux/if_ether.h>	/* ethernet header */
#include <linux/poll.h>		/* poll_table */
#include <linux/kthread.h>	/* kernel threads */
#include <linux/pkt_sched.h>	/* schedule types */
#include <linux/workqueue.h>	/* workqueue */
175
#include <linux/percpu.h>
176
#include <linux/slab.h>
177
#include <linux/jhash.h>
178
#include <net/sock.h>		/* struct sock */
179
#include <net/addrconf.h>	/* ipv6 address stuff */
180
#include <linux/ip.h>
181
#include <net/rtnetlink.h>
182 183
#include <linux/jiffies.h>
#include <linux/seq_file.h>
184 185
#include <linux/if_vlan.h>

186 187
#include "types.h"

188 189 190
#define BATADV_PRINT_VID(vid) (vid & BATADV_VLAN_HAS_TAG ? \
			       (int)(vid & VLAN_VID_MASK) : -1)

191 192 193 194 195 196 197 198
extern char batadv_routing_algo[];
extern struct list_head batadv_hardif_list;

extern unsigned char batadv_broadcast_addr[];
extern struct workqueue_struct *batadv_event_workqueue;

int batadv_mesh_init(struct net_device *soft_iface);
void batadv_mesh_free(struct net_device *soft_iface);
199
bool batadv_is_my_mac(struct batadv_priv *bat_priv, const uint8_t *addr);
200 201
struct batadv_hard_iface *
batadv_seq_print_text_primary_if_get(struct seq_file *seq);
202
int batadv_max_header_len(void);
203
void batadv_skb_set_priority(struct sk_buff *skb, int offset);
204 205 206
int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
			   struct packet_type *ptype,
			   struct net_device *orig_dev);
207 208 209 210
int
batadv_recv_handler_register(uint8_t packet_type,
			     int (*recv_handler)(struct sk_buff *,
						 struct batadv_hard_iface *));
211
void batadv_recv_handler_unregister(uint8_t packet_type);
212 213
int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops);
int batadv_algo_select(struct batadv_priv *bat_priv, char *name);
214
int batadv_algo_seq_print_text(struct seq_file *seq, void *offset);
215
__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr);
216

217 218 219 220 221 222
/**
 * enum batadv_dbg_level - available log levels
 * @BATADV_DBG_BATMAN: OGM and TQ computations related messages
 * @BATADV_DBG_ROUTES: route added / changed / deleted
 * @BATADV_DBG_TT: translation table messages
 * @BATADV_DBG_BLA: bridge loop avoidance messages
223
 * @BATADV_DBG_DAT: ARP snooping and DAT related messages
224
 * @BATADV_DBG_NC: network coding related messages
225 226
 * @BATADV_DBG_ALL: the union of all the above log levels
 */
227 228
enum batadv_dbg_level {
	BATADV_DBG_BATMAN = BIT(0),
229 230 231
	BATADV_DBG_ROUTES = BIT(1),
	BATADV_DBG_TT	  = BIT(2),
	BATADV_DBG_BLA    = BIT(3),
232
	BATADV_DBG_DAT    = BIT(4),
233 234
	BATADV_DBG_NC	  = BIT(5),
	BATADV_DBG_ALL    = 63,
235 236
};

237
#ifdef CONFIG_BATMAN_ADV_DEBUG
238
int batadv_debug_log(struct batadv_priv *bat_priv, const char *fmt, ...)
239
__printf(2, 3);
240

241 242
/* possibly ratelimited debug output */
#define _batadv_dbg(type, bat_priv, ratelimited, fmt, arg...)	\
243
	do {							\
244 245
		if (atomic_read(&bat_priv->log_level) & type && \
		    (!ratelimited || net_ratelimit()))		\
246
			batadv_debug_log(bat_priv, fmt, ## arg);\
247 248 249
	}							\
	while (0)
#else /* !CONFIG_BATMAN_ADV_DEBUG */
250 251 252 253 254
__printf(4, 5)
static inline void _batadv_dbg(int type __always_unused,
			       struct batadv_priv *bat_priv __always_unused,
			       int ratelimited __always_unused,
			       const char *fmt __always_unused, ...)
255 256 257 258
{
}
#endif

259 260 261 262 263
#define batadv_dbg(type, bat_priv, arg...) \
	_batadv_dbg(type, bat_priv, 0, ## arg)
#define batadv_dbg_ratelimited(type, bat_priv, arg...) \
	_batadv_dbg(type, bat_priv, 1, ## arg)

264
#define batadv_info(net_dev, fmt, arg...)				\
265 266
	do {								\
		struct net_device *_netdev = (net_dev);                 \
267
		struct batadv_priv *_batpriv = netdev_priv(_netdev);    \
268
		batadv_dbg(BATADV_DBG_ALL, _batpriv, fmt, ## arg);	\
269 270
		pr_info("%s: " fmt, _netdev->name, ## arg);		\
	} while (0)
271
#define batadv_err(net_dev, fmt, arg...)				\
272 273
	do {								\
		struct net_device *_netdev = (net_dev);                 \
274
		struct batadv_priv *_batpriv = netdev_priv(_netdev);    \
275
		batadv_dbg(BATADV_DBG_ALL, _batpriv, fmt, ## arg);	\
276 277 278
		pr_err("%s: " fmt, _netdev->name, ## arg);		\
	} while (0)

279
/* returns 1 if they are the same ethernet addr
280
 *
281
 * note: can't use ether_addr_equal() as it requires aligned memory
282
 */
283
static inline bool batadv_compare_eth(const void *data1, const void *data2)
284
{
285
	return ether_addr_equal_unaligned(data1, data2);
286 287
}

288 289
/**
 * has_timed_out - compares current time (jiffies) and timestamp + timeout
290 291 292 293 294
 * @timestamp:		base value to compare with (in jiffies)
 * @timeout:		added to base value before comparing (in milliseconds)
 *
 * Returns true if current time is after timestamp + timeout
 */
295 296
static inline bool batadv_has_timed_out(unsigned long timestamp,
					unsigned int timeout)
297 298 299
{
	return time_is_before_jiffies(timestamp + msecs_to_jiffies(timeout));
}
300

301
#define batadv_atomic_dec_not_zero(v)	atomic_add_unless((v), -1, 0)
302

303
/* Returns the smallest signed integer in two's complement with the sizeof x */
304
#define batadv_smallest_signed_int(x) (1u << (7u + 8u * (sizeof(x) - 1u)))
305 306 307 308 309 310 311 312 313

/* Checks if a sequence number x is a predecessor/successor of y.
 * they handle overflows/underflows and can correctly check for a
 * predecessor/successor unless the variable sequence number has grown by
 * more then 2**(bitwidth(x)-1)-1.
 * This means that for a uint8_t with the maximum value 255, it would think:
 *  - when adding nothing - it is neither a predecessor nor a successor
 *  - before adding more than 127 to the starting value - it is a predecessor,
 *  - when adding 128 - it is neither a predecessor nor a successor,
314 315
 *  - after adding more than 127 to the starting value - it is a successor
 */
316 317 318 319
#define batadv_seq_before(x, y) ({typeof(x)_d1 = (x); \
				 typeof(y)_d2 = (y); \
				 typeof(x)_dummy = (_d1 - _d2); \
				 (void)(&_d1 == &_d2); \
320 321
				 _dummy > batadv_smallest_signed_int(_dummy); })
#define batadv_seq_after(x, y) batadv_seq_before(y, x)
322

323
/* Stop preemption on local cpu while incrementing the counter */
324
static inline void batadv_add_counter(struct batadv_priv *bat_priv, size_t idx,
325 326
				      size_t count)
{
S
Shan Wei 已提交
327
	this_cpu_add(bat_priv->bat_counters[idx], count);
328 329 330 331 332
}

#define batadv_inc_counter(b, i) batadv_add_counter(b, i, 1)

/* Sum and return the cpu-local counters for index 'idx' */
333 334
static inline uint64_t batadv_sum_counter(struct batadv_priv *bat_priv,
					  size_t idx)
335
{
336
	uint64_t *counters, sum = 0;
337 338 339 340 341 342 343 344 345 346
	int cpu;

	for_each_possible_cpu(cpu) {
		counters = per_cpu_ptr(bat_priv->bat_counters, cpu);
		sum += counters[idx];
	}

	return sum;
}

347 348 349 350 351 352
/* Define a macro to reach the control buffer of the skb. The members of the
 * control buffer are defined in struct batadv_skb_cb in types.h.
 * The macro is inspired by the similar macro TCP_SKB_CB() in tcp.h.
 */
#define BATADV_SKB_CB(__skb)       ((struct batadv_skb_cb *)&((__skb)->cb[0]))

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
				    uint8_t type, uint8_t version,
				    void *tvlv_value, uint16_t tvlv_value_len);
uint16_t batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
					  unsigned char **packet_buff,
					  int *packet_buff_len,
					  int packet_min_len);
void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
			     struct batadv_ogm_packet *batadv_ogm_packet,
			     struct batadv_orig_node *orig_node);
void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
				      uint8_t type, uint8_t version);

void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
				  void (*optr)(struct batadv_priv *bat_priv,
					       struct batadv_orig_node *orig,
					       uint8_t flags,
					       void *tvlv_value,
					       uint16_t tvlv_value_len),
				  int (*uptr)(struct batadv_priv *bat_priv,
					      uint8_t *src, uint8_t *dst,
					      void *tvlv_value,
					      uint16_t tvlv_value_len),
				  uint8_t type, uint8_t version, uint8_t flags);
void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
				    uint8_t type, uint8_t version);
int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
				   bool ogm_source,
				   struct batadv_orig_node *orig_node,
				   uint8_t *src, uint8_t *dst,
				   void *tvlv_buff, uint16_t tvlv_buff_len);
void batadv_tvlv_unicast_send(struct batadv_priv *bat_priv, uint8_t *src,
			      uint8_t *dst, uint8_t type, uint8_t version,
			      void *tvlv_value, uint16_t tvlv_value_len);
387
unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len);
388
bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid);
389

390
#endif /* _NET_BATMAN_ADV_MAIN_H_ */