Commit | Line | Data |
---|---|---|
c6c8fea2 | 1 | /* |
64afe353 | 2 | * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors: |
c6c8fea2 SE |
3 | * |
4 | * Marek Lindner, Simon Wunderlich | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of version 2 of the GNU General Public | |
8 | * License as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but | |
11 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | * General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
18 | * 02110-1301, USA | |
19 | * | |
20 | */ | |
21 | ||
22 | #include "main.h" | |
23 | #include "send.h" | |
24 | #include "routing.h" | |
25 | #include "translation-table.h" | |
26 | #include "soft-interface.h" | |
27 | #include "hard-interface.h" | |
c6c8fea2 | 28 | #include "vis.h" |
c6c8fea2 SE |
29 | #include "gateway_common.h" |
30 | #include "originator.h" | |
b9dacc52 | 31 | #include "bat_ogm.h" |
c6c8fea2 SE |
32 | |
33 | static void send_outstanding_bcast_packet(struct work_struct *work); | |
34 | ||
c6c8fea2 SE |
35 | /* send out an already prepared packet to the given address via the |
36 | * specified batman interface */ | |
747e4221 SE |
37 | int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface, |
38 | const uint8_t *dst_addr) | |
c6c8fea2 SE |
39 | { |
40 | struct ethhdr *ethhdr; | |
41 | ||
e6c10f43 | 42 | if (hard_iface->if_status != IF_ACTIVE) |
c6c8fea2 SE |
43 | goto send_skb_err; |
44 | ||
e6c10f43 | 45 | if (unlikely(!hard_iface->net_dev)) |
c6c8fea2 SE |
46 | goto send_skb_err; |
47 | ||
e6c10f43 | 48 | if (!(hard_iface->net_dev->flags & IFF_UP)) { |
c6c8fea2 | 49 | pr_warning("Interface %s is not up - can't send packet via " |
e6c10f43 | 50 | "that interface!\n", hard_iface->net_dev->name); |
c6c8fea2 SE |
51 | goto send_skb_err; |
52 | } | |
53 | ||
54 | /* push to the ethernet header. */ | |
704509b8 | 55 | if (my_skb_head_push(skb, sizeof(*ethhdr)) < 0) |
c6c8fea2 SE |
56 | goto send_skb_err; |
57 | ||
58 | skb_reset_mac_header(skb); | |
59 | ||
60 | ethhdr = (struct ethhdr *) skb_mac_header(skb); | |
e6c10f43 | 61 | memcpy(ethhdr->h_source, hard_iface->net_dev->dev_addr, ETH_ALEN); |
c6c8fea2 SE |
62 | memcpy(ethhdr->h_dest, dst_addr, ETH_ALEN); |
63 | ethhdr->h_proto = __constant_htons(ETH_P_BATMAN); | |
64 | ||
65 | skb_set_network_header(skb, ETH_HLEN); | |
66 | skb->priority = TC_PRIO_CONTROL; | |
67 | skb->protocol = __constant_htons(ETH_P_BATMAN); | |
68 | ||
e6c10f43 | 69 | skb->dev = hard_iface->net_dev; |
c6c8fea2 SE |
70 | |
71 | /* dev_queue_xmit() returns a negative result on error. However on | |
72 | * congestion and traffic shaping, it drops and returns NET_XMIT_DROP | |
73 | * (which is > 0). This will not be treated as an error. */ | |
74 | ||
75 | return dev_queue_xmit(skb); | |
76 | send_skb_err: | |
77 | kfree_skb(skb); | |
78 | return NET_XMIT_DROP; | |
79 | } | |
80 | ||
a73105b8 | 81 | static void realloc_packet_buffer(struct hard_iface *hard_iface, |
b6da4bf5 | 82 | int new_len) |
c6c8fea2 | 83 | { |
c6c8fea2 | 84 | unsigned char *new_buff; |
c6c8fea2 | 85 | |
c6c8fea2 SE |
86 | new_buff = kmalloc(new_len, GFP_ATOMIC); |
87 | ||
88 | /* keep old buffer if kmalloc should fail */ | |
89 | if (new_buff) { | |
e6c10f43 | 90 | memcpy(new_buff, hard_iface->packet_buff, |
b6da4bf5 | 91 | BATMAN_OGM_LEN); |
c6c8fea2 | 92 | |
e6c10f43 ML |
93 | kfree(hard_iface->packet_buff); |
94 | hard_iface->packet_buff = new_buff; | |
95 | hard_iface->packet_len = new_len; | |
c6c8fea2 SE |
96 | } |
97 | } | |
98 | ||
a73105b8 | 99 | /* when calling this function (hard_iface == primary_if) has to be true */ |
b9dacc52 | 100 | static int prepare_packet_buffer(struct bat_priv *bat_priv, |
a73105b8 AQ |
101 | struct hard_iface *hard_iface) |
102 | { | |
103 | int new_len; | |
a73105b8 | 104 | |
b6da4bf5 | 105 | new_len = BATMAN_OGM_LEN + |
a73105b8 AQ |
106 | tt_len((uint8_t)atomic_read(&bat_priv->tt_local_changes)); |
107 | ||
108 | /* if we have too many changes for one packet don't send any | |
109 | * and wait for the tt table request which will be fragmented */ | |
110 | if (new_len > hard_iface->soft_iface->mtu) | |
b6da4bf5 | 111 | new_len = BATMAN_OGM_LEN; |
a73105b8 AQ |
112 | |
113 | realloc_packet_buffer(hard_iface, new_len); | |
a73105b8 AQ |
114 | |
115 | atomic_set(&bat_priv->tt_crc, tt_local_crc(bat_priv)); | |
116 | ||
117 | /* reset the sending counter */ | |
118 | atomic_set(&bat_priv->tt_ogm_append_cnt, TT_OGM_APPEND_MAX); | |
119 | ||
b9dacc52 ML |
120 | return tt_changes_fill_buffer(bat_priv, |
121 | hard_iface->packet_buff + BATMAN_OGM_LEN, | |
122 | hard_iface->packet_len - BATMAN_OGM_LEN); | |
a73105b8 AQ |
123 | } |
124 | ||
b9dacc52 | 125 | static int reset_packet_buffer(struct bat_priv *bat_priv, |
b6da4bf5 | 126 | struct hard_iface *hard_iface) |
a73105b8 | 127 | { |
b6da4bf5 | 128 | realloc_packet_buffer(hard_iface, BATMAN_OGM_LEN); |
b9dacc52 | 129 | return 0; |
a73105b8 AQ |
130 | } |
131 | ||
b9dacc52 | 132 | void schedule_bat_ogm(struct hard_iface *hard_iface) |
c6c8fea2 | 133 | { |
e6c10f43 | 134 | struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); |
32ae9b22 | 135 | struct hard_iface *primary_if; |
b9dacc52 | 136 | int tt_num_changes = -1; |
c6c8fea2 | 137 | |
e6c10f43 ML |
138 | if ((hard_iface->if_status == IF_NOT_IN_USE) || |
139 | (hard_iface->if_status == IF_TO_BE_REMOVED)) | |
c6c8fea2 SE |
140 | return; |
141 | ||
c6c8fea2 SE |
142 | /** |
143 | * the interface gets activated here to avoid race conditions between | |
144 | * the moment of activating the interface in | |
145 | * hardif_activate_interface() where the originator mac is set and | |
146 | * outdated packets (especially uninitialized mac addresses) in the | |
147 | * packet queue | |
148 | */ | |
e6c10f43 ML |
149 | if (hard_iface->if_status == IF_TO_BE_ACTIVATED) |
150 | hard_iface->if_status = IF_ACTIVE; | |
c6c8fea2 | 151 | |
b9dacc52 ML |
152 | primary_if = primary_if_get_selected(bat_priv); |
153 | ||
a73105b8 AQ |
154 | if (hard_iface == primary_if) { |
155 | /* if at least one change happened */ | |
156 | if (atomic_read(&bat_priv->tt_local_changes) > 0) { | |
058d0e26 | 157 | tt_commit_changes(bat_priv); |
b9dacc52 ML |
158 | tt_num_changes = prepare_packet_buffer(bat_priv, |
159 | hard_iface); | |
a73105b8 AQ |
160 | } |
161 | ||
015758d0 | 162 | /* if the changes have been sent often enough */ |
a73105b8 | 163 | if (!atomic_dec_not_zero(&bat_priv->tt_ogm_append_cnt)) |
b9dacc52 ML |
164 | tt_num_changes = reset_packet_buffer(bat_priv, |
165 | hard_iface); | |
a73105b8 | 166 | } |
c6c8fea2 | 167 | |
32ae9b22 ML |
168 | if (primary_if) |
169 | hardif_free_ref(primary_if); | |
c6c8fea2 | 170 | |
b9dacc52 | 171 | bat_ogm_schedule(hard_iface, tt_num_changes); |
c6c8fea2 SE |
172 | } |
173 | ||
174 | static void forw_packet_free(struct forw_packet *forw_packet) | |
175 | { | |
176 | if (forw_packet->skb) | |
177 | kfree_skb(forw_packet->skb); | |
6d5808d4 SE |
178 | if (forw_packet->if_incoming) |
179 | hardif_free_ref(forw_packet->if_incoming); | |
c6c8fea2 SE |
180 | kfree(forw_packet); |
181 | } | |
182 | ||
183 | static void _add_bcast_packet_to_list(struct bat_priv *bat_priv, | |
184 | struct forw_packet *forw_packet, | |
185 | unsigned long send_time) | |
186 | { | |
187 | INIT_HLIST_NODE(&forw_packet->list); | |
188 | ||
189 | /* add new packet to packet list */ | |
190 | spin_lock_bh(&bat_priv->forw_bcast_list_lock); | |
191 | hlist_add_head(&forw_packet->list, &bat_priv->forw_bcast_list); | |
192 | spin_unlock_bh(&bat_priv->forw_bcast_list_lock); | |
193 | ||
194 | /* start timer for this packet */ | |
195 | INIT_DELAYED_WORK(&forw_packet->delayed_work, | |
196 | send_outstanding_bcast_packet); | |
197 | queue_delayed_work(bat_event_workqueue, &forw_packet->delayed_work, | |
198 | send_time); | |
199 | } | |
200 | ||
c6c8fea2 | 201 | /* add a broadcast packet to the queue and setup timers. broadcast packets |
015758d0 | 202 | * are sent multiple times to increase probability for being received. |
c6c8fea2 SE |
203 | * |
204 | * This function returns NETDEV_TX_OK on success and NETDEV_TX_BUSY on | |
205 | * errors. | |
206 | * | |
207 | * The skb is not consumed, so the caller should make sure that the | |
208 | * skb is freed. */ | |
747e4221 | 209 | int add_bcast_packet_to_list(struct bat_priv *bat_priv, |
8698529d | 210 | const struct sk_buff *skb, unsigned long delay) |
c6c8fea2 | 211 | { |
32ae9b22 | 212 | struct hard_iface *primary_if = NULL; |
c6c8fea2 SE |
213 | struct forw_packet *forw_packet; |
214 | struct bcast_packet *bcast_packet; | |
747e4221 | 215 | struct sk_buff *newskb; |
c6c8fea2 SE |
216 | |
217 | if (!atomic_dec_not_zero(&bat_priv->bcast_queue_left)) { | |
218 | bat_dbg(DBG_BATMAN, bat_priv, "bcast packet queue full\n"); | |
219 | goto out; | |
220 | } | |
221 | ||
32ae9b22 ML |
222 | primary_if = primary_if_get_selected(bat_priv); |
223 | if (!primary_if) | |
ca06c6eb | 224 | goto out_and_inc; |
c6c8fea2 | 225 | |
704509b8 | 226 | forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC); |
c6c8fea2 SE |
227 | |
228 | if (!forw_packet) | |
229 | goto out_and_inc; | |
230 | ||
747e4221 SE |
231 | newskb = skb_copy(skb, GFP_ATOMIC); |
232 | if (!newskb) | |
c6c8fea2 SE |
233 | goto packet_free; |
234 | ||
235 | /* as we have a copy now, it is safe to decrease the TTL */ | |
747e4221 | 236 | bcast_packet = (struct bcast_packet *)newskb->data; |
76543d14 | 237 | bcast_packet->header.ttl--; |
c6c8fea2 | 238 | |
747e4221 | 239 | skb_reset_mac_header(newskb); |
c6c8fea2 | 240 | |
747e4221 | 241 | forw_packet->skb = newskb; |
32ae9b22 | 242 | forw_packet->if_incoming = primary_if; |
c6c8fea2 SE |
243 | |
244 | /* how often did we send the bcast packet ? */ | |
245 | forw_packet->num_packets = 0; | |
246 | ||
8698529d | 247 | _add_bcast_packet_to_list(bat_priv, forw_packet, delay); |
c6c8fea2 SE |
248 | return NETDEV_TX_OK; |
249 | ||
250 | packet_free: | |
251 | kfree(forw_packet); | |
252 | out_and_inc: | |
253 | atomic_inc(&bat_priv->bcast_queue_left); | |
254 | out: | |
32ae9b22 ML |
255 | if (primary_if) |
256 | hardif_free_ref(primary_if); | |
c6c8fea2 SE |
257 | return NETDEV_TX_BUSY; |
258 | } | |
259 | ||
260 | static void send_outstanding_bcast_packet(struct work_struct *work) | |
261 | { | |
e6c10f43 | 262 | struct hard_iface *hard_iface; |
c6c8fea2 SE |
263 | struct delayed_work *delayed_work = |
264 | container_of(work, struct delayed_work, work); | |
265 | struct forw_packet *forw_packet = | |
266 | container_of(delayed_work, struct forw_packet, delayed_work); | |
267 | struct sk_buff *skb1; | |
268 | struct net_device *soft_iface = forw_packet->if_incoming->soft_iface; | |
269 | struct bat_priv *bat_priv = netdev_priv(soft_iface); | |
270 | ||
271 | spin_lock_bh(&bat_priv->forw_bcast_list_lock); | |
272 | hlist_del(&forw_packet->list); | |
273 | spin_unlock_bh(&bat_priv->forw_bcast_list_lock); | |
274 | ||
275 | if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING) | |
276 | goto out; | |
277 | ||
278 | /* rebroadcast packet */ | |
279 | rcu_read_lock(); | |
e6c10f43 ML |
280 | list_for_each_entry_rcu(hard_iface, &hardif_list, list) { |
281 | if (hard_iface->soft_iface != soft_iface) | |
c6c8fea2 SE |
282 | continue; |
283 | ||
284 | /* send a copy of the saved skb */ | |
285 | skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC); | |
286 | if (skb1) | |
e6c10f43 | 287 | send_skb_packet(skb1, hard_iface, broadcast_addr); |
c6c8fea2 SE |
288 | } |
289 | rcu_read_unlock(); | |
290 | ||
291 | forw_packet->num_packets++; | |
292 | ||
293 | /* if we still have some more bcasts to send */ | |
294 | if (forw_packet->num_packets < 3) { | |
295 | _add_bcast_packet_to_list(bat_priv, forw_packet, | |
296 | ((5 * HZ) / 1000)); | |
297 | return; | |
298 | } | |
299 | ||
300 | out: | |
301 | forw_packet_free(forw_packet); | |
302 | atomic_inc(&bat_priv->bcast_queue_left); | |
303 | } | |
304 | ||
b9dacc52 | 305 | void send_outstanding_bat_ogm_packet(struct work_struct *work) |
c6c8fea2 SE |
306 | { |
307 | struct delayed_work *delayed_work = | |
308 | container_of(work, struct delayed_work, work); | |
309 | struct forw_packet *forw_packet = | |
310 | container_of(delayed_work, struct forw_packet, delayed_work); | |
311 | struct bat_priv *bat_priv; | |
312 | ||
313 | bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface); | |
314 | spin_lock_bh(&bat_priv->forw_bat_list_lock); | |
315 | hlist_del(&forw_packet->list); | |
316 | spin_unlock_bh(&bat_priv->forw_bat_list_lock); | |
317 | ||
318 | if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING) | |
319 | goto out; | |
320 | ||
b9dacc52 | 321 | bat_ogm_emit(forw_packet); |
c6c8fea2 SE |
322 | |
323 | /** | |
324 | * we have to have at least one packet in the queue | |
325 | * to determine the queues wake up time unless we are | |
326 | * shutting down | |
327 | */ | |
328 | if (forw_packet->own) | |
b9dacc52 | 329 | schedule_bat_ogm(forw_packet->if_incoming); |
c6c8fea2 SE |
330 | |
331 | out: | |
332 | /* don't count own packet */ | |
333 | if (!forw_packet->own) | |
334 | atomic_inc(&bat_priv->batman_queue_left); | |
335 | ||
336 | forw_packet_free(forw_packet); | |
337 | } | |
338 | ||
339 | void purge_outstanding_packets(struct bat_priv *bat_priv, | |
747e4221 | 340 | const struct hard_iface *hard_iface) |
c6c8fea2 SE |
341 | { |
342 | struct forw_packet *forw_packet; | |
343 | struct hlist_node *tmp_node, *safe_tmp_node; | |
6d5808d4 | 344 | bool pending; |
c6c8fea2 | 345 | |
e6c10f43 | 346 | if (hard_iface) |
c6c8fea2 SE |
347 | bat_dbg(DBG_BATMAN, bat_priv, |
348 | "purge_outstanding_packets(): %s\n", | |
e6c10f43 | 349 | hard_iface->net_dev->name); |
c6c8fea2 SE |
350 | else |
351 | bat_dbg(DBG_BATMAN, bat_priv, | |
352 | "purge_outstanding_packets()\n"); | |
353 | ||
354 | /* free bcast list */ | |
355 | spin_lock_bh(&bat_priv->forw_bcast_list_lock); | |
356 | hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node, | |
357 | &bat_priv->forw_bcast_list, list) { | |
358 | ||
359 | /** | |
015758d0 | 360 | * if purge_outstanding_packets() was called with an argument |
c6c8fea2 SE |
361 | * we delete only packets belonging to the given interface |
362 | */ | |
e6c10f43 ML |
363 | if ((hard_iface) && |
364 | (forw_packet->if_incoming != hard_iface)) | |
c6c8fea2 SE |
365 | continue; |
366 | ||
367 | spin_unlock_bh(&bat_priv->forw_bcast_list_lock); | |
368 | ||
369 | /** | |
370 | * send_outstanding_bcast_packet() will lock the list to | |
371 | * delete the item from the list | |
372 | */ | |
6d5808d4 | 373 | pending = cancel_delayed_work_sync(&forw_packet->delayed_work); |
c6c8fea2 | 374 | spin_lock_bh(&bat_priv->forw_bcast_list_lock); |
6d5808d4 SE |
375 | |
376 | if (pending) { | |
377 | hlist_del(&forw_packet->list); | |
378 | forw_packet_free(forw_packet); | |
379 | } | |
c6c8fea2 SE |
380 | } |
381 | spin_unlock_bh(&bat_priv->forw_bcast_list_lock); | |
382 | ||
383 | /* free batman packet list */ | |
384 | spin_lock_bh(&bat_priv->forw_bat_list_lock); | |
385 | hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node, | |
386 | &bat_priv->forw_bat_list, list) { | |
387 | ||
388 | /** | |
015758d0 | 389 | * if purge_outstanding_packets() was called with an argument |
c6c8fea2 SE |
390 | * we delete only packets belonging to the given interface |
391 | */ | |
e6c10f43 ML |
392 | if ((hard_iface) && |
393 | (forw_packet->if_incoming != hard_iface)) | |
c6c8fea2 SE |
394 | continue; |
395 | ||
396 | spin_unlock_bh(&bat_priv->forw_bat_list_lock); | |
397 | ||
398 | /** | |
399 | * send_outstanding_bat_packet() will lock the list to | |
400 | * delete the item from the list | |
401 | */ | |
6d5808d4 | 402 | pending = cancel_delayed_work_sync(&forw_packet->delayed_work); |
c6c8fea2 | 403 | spin_lock_bh(&bat_priv->forw_bat_list_lock); |
6d5808d4 SE |
404 | |
405 | if (pending) { | |
406 | hlist_del(&forw_packet->list); | |
407 | forw_packet_free(forw_packet); | |
408 | } | |
c6c8fea2 SE |
409 | } |
410 | spin_unlock_bh(&bat_priv->forw_bat_list_lock); | |
411 | } |