2 * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
4 * Marek Lindner, Simon Wunderlich
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.
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.
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
23 #include "aggregation.h"
27 /* calculate the size of the hna information for a given packet */
28 static int hna_len(struct batman_packet *batman_packet)
30 return batman_packet->num_hna * ETH_ALEN;
33 /* return true if new_packet can be aggregated with forw_packet */
34 static bool can_aggregate_with(struct batman_packet *new_batman_packet,
36 unsigned long send_time,
38 struct batman_if *if_incoming,
39 struct forw_packet *forw_packet)
41 struct batman_packet *batman_packet =
42 (struct batman_packet *)forw_packet->packet_buff;
43 int aggregated_bytes = forw_packet->packet_len + packet_len;
46 * we can aggregate the current packet to this aggregated packet
49 * - the send time is within our MAX_AGGREGATION_MS time
50 * - the resulting packet wont be bigger than
51 * MAX_AGGREGATION_BYTES
54 if (time_before(send_time, forw_packet->send_time) &&
55 time_after_eq(send_time + msecs_to_jiffies(MAX_AGGREGATION_MS),
56 forw_packet->send_time) &&
57 (aggregated_bytes <= MAX_AGGREGATION_BYTES)) {
60 * check aggregation compatibility
61 * -> direct link packets are broadcasted on
62 * their interface only
63 * -> aggregate packet if the current packet is
64 * a "global" packet as well as the base
68 /* packets without direct link flag and high TTL
69 * are flooded through the net */
71 (!(batman_packet->flags & DIRECTLINK)) &&
72 (batman_packet->ttl != 1) &&
74 /* own packets originating non-primary
75 * interfaces leave only that interface */
76 ((!forw_packet->own) ||
77 (forw_packet->if_incoming->if_num == 0)))
80 /* if the incoming packet is sent via this one
81 * interface only - we still can aggregate */
83 (new_batman_packet->ttl == 1) &&
84 (forw_packet->if_incoming == if_incoming) &&
86 /* packets from direct neighbors or
87 * own secondary interface packets
88 * (= secondary interface packets in general) */
89 (batman_packet->flags & DIRECTLINK ||
91 forw_packet->if_incoming->if_num != 0)))
98 /* create a new aggregated packet and add this packet to it */
99 static void new_aggregated_packet(unsigned char *packet_buff,
101 unsigned long send_time,
103 struct batman_if *if_incoming,
106 struct forw_packet *forw_packet_aggr;
109 forw_packet_aggr = kmalloc(sizeof(struct forw_packet), GFP_ATOMIC);
110 if (!forw_packet_aggr)
113 forw_packet_aggr->packet_buff = kmalloc(MAX_AGGREGATION_BYTES,
115 if (!forw_packet_aggr->packet_buff) {
116 kfree(forw_packet_aggr);
120 INIT_HLIST_NODE(&forw_packet_aggr->list);
122 forw_packet_aggr->packet_len = packet_len;
123 memcpy(forw_packet_aggr->packet_buff,
125 forw_packet_aggr->packet_len);
127 forw_packet_aggr->skb = NULL;
128 forw_packet_aggr->own = own_packet;
129 forw_packet_aggr->if_incoming = if_incoming;
130 forw_packet_aggr->num_packets = 0;
131 forw_packet_aggr->direct_link_flags = 0;
132 forw_packet_aggr->send_time = send_time;
134 /* save packet direct link flag status */
136 forw_packet_aggr->direct_link_flags |= 1;
138 /* add new packet to packet list */
139 spin_lock_irqsave(&forw_bat_list_lock, flags);
140 hlist_add_head(&forw_packet_aggr->list, &forw_bat_list);
141 spin_unlock_irqrestore(&forw_bat_list_lock, flags);
143 /* start timer for this packet */
144 INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
145 send_outstanding_bat_packet);
146 queue_delayed_work(bat_event_workqueue,
147 &forw_packet_aggr->delayed_work,
148 send_time - jiffies);
151 /* aggregate a new packet into the existing aggregation */
152 static void aggregate(struct forw_packet *forw_packet_aggr,
153 unsigned char *packet_buff,
157 memcpy((forw_packet_aggr->packet_buff + forw_packet_aggr->packet_len),
158 packet_buff, packet_len);
159 forw_packet_aggr->packet_len += packet_len;
160 forw_packet_aggr->num_packets++;
162 /* save packet direct link flag status */
164 forw_packet_aggr->direct_link_flags |=
165 (1 << forw_packet_aggr->num_packets);
168 void add_bat_packet_to_list(unsigned char *packet_buff, int packet_len,
169 struct batman_if *if_incoming, char own_packet,
170 unsigned long send_time,
171 struct bat_priv *bat_priv)
174 * _aggr -> pointer to the packet we want to aggregate with
175 * _pos -> pointer to the position in the queue
177 struct forw_packet *forw_packet_aggr = NULL, *forw_packet_pos = NULL;
178 struct hlist_node *tmp_node;
179 struct batman_packet *batman_packet =
180 (struct batman_packet *)packet_buff;
181 bool direct_link = batman_packet->flags & DIRECTLINK ? 1 : 0;
184 /* find position for the packet in the forward queue */
185 spin_lock_irqsave(&forw_bat_list_lock, flags);
186 /* own packets are not to be aggregated */
187 if ((atomic_read(&bat_priv->aggregation_enabled)) && (!own_packet)) {
188 hlist_for_each_entry(forw_packet_pos, tmp_node, &forw_bat_list,
190 if (can_aggregate_with(batman_packet,
196 forw_packet_aggr = forw_packet_pos;
202 /* nothing to aggregate with - either aggregation disabled or no
203 * suitable aggregation packet found */
204 if (forw_packet_aggr == NULL) {
205 /* the following section can run without the lock */
206 spin_unlock_irqrestore(&forw_bat_list_lock, flags);
209 * if we could not aggregate this packet with one of the others
210 * we hold it back for a while, so that it might be aggregated
214 (atomic_read(&bat_priv->aggregation_enabled)))
215 send_time += msecs_to_jiffies(MAX_AGGREGATION_MS);
217 new_aggregated_packet(packet_buff, packet_len,
218 send_time, direct_link,
219 if_incoming, own_packet);
221 aggregate(forw_packet_aggr,
222 packet_buff, packet_len,
224 spin_unlock_irqrestore(&forw_bat_list_lock, flags);
228 /* unpack the aggregated packets and process them one by one */
229 void receive_aggr_bat_packet(struct ethhdr *ethhdr, unsigned char *packet_buff,
230 int packet_len, struct batman_if *if_incoming)
232 struct batman_packet *batman_packet;
234 unsigned char *hna_buff;
236 batman_packet = (struct batman_packet *)packet_buff;
238 while (aggregated_packet(buff_pos, packet_len,
239 batman_packet->num_hna)) {
241 /* network to host order for our 16bit seqno, and the
243 batman_packet->seqno = ntohs(batman_packet->seqno);
245 hna_buff = packet_buff + buff_pos + BAT_PACKET_LEN;
246 receive_bat_packet(ethhdr, batman_packet,
247 hna_buff, hna_len(batman_packet),
250 buff_pos += BAT_PACKET_LEN + hna_len(batman_packet);
251 batman_packet = (struct batman_packet *)
252 (packet_buff + buff_pos);