1 /*
2  *  net/dccp/packet_history.c
3  *
4  *  Copyright (c) 2007   The University of Aberdeen, Scotland, UK
5  *  Copyright (c) 2005-7 The University of Waikato, Hamilton, New Zealand.
6  *
7  *  An implementation of the DCCP protocol
8  *
9  *  This code has been developed by the University of Waikato WAND
10  *  research group. For further information please see http://www.wand.net.nz/
11  *  or e-mail Ian McDonald - ian.mcdonald@jandi.co.nz
12  *
13  *  This code also uses code from Lulea University, rereleased as GPL by its
14  *  authors:
15  *  Copyright (c) 2003 Nils-Erik Mattsson, Joacim Haggmark, Magnus Erixzon
16  *
17  *  Changes to meet Linux coding standards, to make it meet latest ccid3 draft
18  *  and to make it work as a loadable module in the DCCP stack written by
19  *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>.
20  *
21  *  Copyright (c) 2005 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
22  *
23  *  This program is free software; you can redistribute it and/or modify
24  *  it under the terms of the GNU General Public License as published by
25  *  the Free Software Foundation; either version 2 of the License, or
26  *  (at your option) any later version.
27  *
28  *  This program is distributed in the hope that it will be useful,
29  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
30  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
31  *  GNU General Public License for more details.
32  *
33  *  You should have received a copy of the GNU General Public License
34  *  along with this program; if not, write to the Free Software
35  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
36  */
37 
38 #include <linux/string.h>
39 #include <linux/slab.h>
40 #include "packet_history.h"
41 #include "../../dccp.h"
42 
43 /**
44  *  tfrc_tx_hist_entry  -  Simple singly-linked TX history list
45  *  @next:  next oldest entry (LIFO order)
46  *  @seqno: sequence number of this entry
47  *  @stamp: send time of packet with sequence number @seqno
48  */
49 struct tfrc_tx_hist_entry {
50 	struct tfrc_tx_hist_entry *next;
51 	u64			  seqno;
52 	ktime_t			  stamp;
53 };
54 
55 /*
56  * Transmitter History Routines
57  */
58 static struct kmem_cache *tfrc_tx_hist_slab;
59 
60 int __init tfrc_tx_packet_history_init(void)
61 {
62 	tfrc_tx_hist_slab = kmem_cache_create("tfrc_tx_hist",
63 					      sizeof(struct tfrc_tx_hist_entry),
64 					      0, SLAB_HWCACHE_ALIGN, NULL);
65 	return tfrc_tx_hist_slab == NULL ? -ENOBUFS : 0;
66 }
67 
68 void tfrc_tx_packet_history_exit(void)
69 {
70 	if (tfrc_tx_hist_slab != NULL) {
71 		kmem_cache_destroy(tfrc_tx_hist_slab);
72 		tfrc_tx_hist_slab = NULL;
73 	}
74 }
75 
76 static struct tfrc_tx_hist_entry *
77 	tfrc_tx_hist_find_entry(struct tfrc_tx_hist_entry *head, u64 seqno)
78 {
79 	while (head != NULL && head->seqno != seqno)
80 		head = head->next;
81 
82 	return head;
83 }
84 
85 int tfrc_tx_hist_add(struct tfrc_tx_hist_entry **headp, u64 seqno)
86 {
87 	struct tfrc_tx_hist_entry *entry = kmem_cache_alloc(tfrc_tx_hist_slab, gfp_any());
88 
89 	if (entry == NULL)
90 		return -ENOBUFS;
91 	entry->seqno = seqno;
92 	entry->stamp = ktime_get_real();
93 	entry->next  = *headp;
94 	*headp	     = entry;
95 	return 0;
96 }
97 EXPORT_SYMBOL_GPL(tfrc_tx_hist_add);
98 
99 void tfrc_tx_hist_purge(struct tfrc_tx_hist_entry **headp)
100 {
101 	struct tfrc_tx_hist_entry *head = *headp;
102 
103 	while (head != NULL) {
104 		struct tfrc_tx_hist_entry *next = head->next;
105 
106 		kmem_cache_free(tfrc_tx_hist_slab, head);
107 		head = next;
108 	}
109 
110 	*headp = NULL;
111 }
112 EXPORT_SYMBOL_GPL(tfrc_tx_hist_purge);
113 
114 u32 tfrc_tx_hist_rtt(struct tfrc_tx_hist_entry *head, const u64 seqno,
115 		     const ktime_t now)
116 {
117 	u32 rtt = 0;
118 	struct tfrc_tx_hist_entry *packet = tfrc_tx_hist_find_entry(head, seqno);
119 
120 	if (packet != NULL) {
121 		rtt = ktime_us_delta(now, packet->stamp);
122 		/*
123 		 * Garbage-collect older (irrelevant) entries:
124 		 */
125 		tfrc_tx_hist_purge(&packet->next);
126 	}
127 
128 	return rtt;
129 }
130 EXPORT_SYMBOL_GPL(tfrc_tx_hist_rtt);
131 
132 
133 /*
134  * 	Receiver History Routines
135  */
136 static struct kmem_cache *tfrc_rx_hist_slab;
137 
138 int __init tfrc_rx_packet_history_init(void)
139 {
140 	tfrc_rx_hist_slab = kmem_cache_create("tfrc_rxh_cache",
141 					      sizeof(struct tfrc_rx_hist_entry),
142 					      0, SLAB_HWCACHE_ALIGN, NULL);
143 	return tfrc_rx_hist_slab == NULL ? -ENOBUFS : 0;
144 }
145 
146 void tfrc_rx_packet_history_exit(void)
147 {
148 	if (tfrc_rx_hist_slab != NULL) {
149 		kmem_cache_destroy(tfrc_rx_hist_slab);
150 		tfrc_rx_hist_slab = NULL;
151 	}
152 }
153 
154 static inline void tfrc_rx_hist_entry_from_skb(struct tfrc_rx_hist_entry *entry,
155 					       const struct sk_buff *skb,
156 					       const u32 ndp)
157 {
158 	const struct dccp_hdr *dh = dccp_hdr(skb);
159 
160 	entry->tfrchrx_seqno = DCCP_SKB_CB(skb)->dccpd_seq;
161 	entry->tfrchrx_ccval = dh->dccph_ccval;
162 	entry->tfrchrx_type  = dh->dccph_type;
163 	entry->tfrchrx_ndp   = ndp;
164 	entry->tfrchrx_tstamp = ktime_get_real();
165 }
166 
167 void tfrc_rx_hist_add_packet(struct tfrc_rx_hist *h,
168 			     const struct sk_buff *skb,
169 			     const u32 ndp)
170 {
171 	struct tfrc_rx_hist_entry *entry = tfrc_rx_hist_last_rcv(h);
172 
173 	tfrc_rx_hist_entry_from_skb(entry, skb, ndp);
174 }
175 EXPORT_SYMBOL_GPL(tfrc_rx_hist_add_packet);
176 
177 /* has the packet contained in skb been seen before? */
178 int tfrc_rx_hist_duplicate(struct tfrc_rx_hist *h, struct sk_buff *skb)
179 {
180 	const u64 seq = DCCP_SKB_CB(skb)->dccpd_seq;
181 	int i;
182 
183 	if (dccp_delta_seqno(tfrc_rx_hist_loss_prev(h)->tfrchrx_seqno, seq) <= 0)
184 		return 1;
185 
186 	for (i = 1; i <= h->loss_count; i++)
187 		if (tfrc_rx_hist_entry(h, i)->tfrchrx_seqno == seq)
188 			return 1;
189 
190 	return 0;
191 }
192 EXPORT_SYMBOL_GPL(tfrc_rx_hist_duplicate);
193 
194 static void tfrc_rx_hist_swap(struct tfrc_rx_hist *h, const u8 a, const u8 b)
195 {
196 	const u8 idx_a = tfrc_rx_hist_index(h, a),
197 		 idx_b = tfrc_rx_hist_index(h, b);
198 	struct tfrc_rx_hist_entry *tmp = h->ring[idx_a];
199 
200 	h->ring[idx_a] = h->ring[idx_b];
201 	h->ring[idx_b] = tmp;
202 }
203 
204 /*
205  * Private helper functions for loss detection.
206  *
207  * In the descriptions, `Si' refers to the sequence number of entry number i,
208  * whose NDP count is `Ni' (lower case is used for variables).
209  * Note: All __after_loss functions expect that a test against duplicates has
210  *       been performed already: the seqno of the skb must not be less than the
211  *       seqno of loss_prev; and it must not equal that of any valid hist_entry.
212  */
213 static void __one_after_loss(struct tfrc_rx_hist *h, struct sk_buff *skb, u32 n2)
214 {
215 	u64 s0 = tfrc_rx_hist_loss_prev(h)->tfrchrx_seqno,
216 	    s1 = tfrc_rx_hist_entry(h, 1)->tfrchrx_seqno,
217 	    s2 = DCCP_SKB_CB(skb)->dccpd_seq;
218 	int n1 = tfrc_rx_hist_entry(h, 1)->tfrchrx_ndp,
219 	   d12 = dccp_delta_seqno(s1, s2), d2;
220 
221 	if (d12 > 0) {			/* S1  <  S2 */
222 		h->loss_count = 2;
223 		tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_entry(h, 2), skb, n2);
224 		return;
225 	}
226 
227 	/* S0  <  S2  <  S1 */
228 	d2 = dccp_delta_seqno(s0, s2);
229 
230 	if (d2 == 1 || n2 >= d2) {	/* S2 is direct successor of S0 */
231 		int d21 = -d12;
232 
233 		if (d21 == 1 || n1 >= d21) {
234 			/* hole is filled: S0, S2, and S1 are consecutive */
235 			h->loss_count = 0;
236 			h->loss_start = tfrc_rx_hist_index(h, 1);
237 		} else
238 			/* gap between S2 and S1: just update loss_prev */
239 			tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_loss_prev(h), skb, n2);
240 
241 	} else {			/* hole between S0 and S2 */
242 		/*
243 		 * Reorder history to insert S2 between S0 and s1
244 		 */
245 		tfrc_rx_hist_swap(h, 0, 3);
246 		h->loss_start = tfrc_rx_hist_index(h, 3);
247 		tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_entry(h, 1), skb, n2);
248 		h->loss_count = 2;
249 	}
250 }
251 
252 /* return 1 if a new loss event has been identified */
253 static int __two_after_loss(struct tfrc_rx_hist *h, struct sk_buff *skb, u32 n3)
254 {
255 	u64 s0 = tfrc_rx_hist_loss_prev(h)->tfrchrx_seqno,
256 	    s1 = tfrc_rx_hist_entry(h, 1)->tfrchrx_seqno,
257 	    s2 = tfrc_rx_hist_entry(h, 2)->tfrchrx_seqno,
258 	    s3 = DCCP_SKB_CB(skb)->dccpd_seq;
259 	int n1 = tfrc_rx_hist_entry(h, 1)->tfrchrx_ndp,
260 	   d23 = dccp_delta_seqno(s2, s3), d13, d3, d31;
261 
262 	if (d23 > 0) {			/* S2  <  S3 */
263 		h->loss_count = 3;
264 		tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_entry(h, 3), skb, n3);
265 		return 1;
266 	}
267 
268 	/* S3  <  S2 */
269 	d13 = dccp_delta_seqno(s1, s3);
270 
271 	if (d13 > 0) {
272 		/*
273 		 * The sequence number order is S1, S3, S2
274 		 * Reorder history to insert entry between S1 and S2
275 		 */
276 		tfrc_rx_hist_swap(h, 2, 3);
277 		tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_entry(h, 2), skb, n3);
278 		h->loss_count = 3;
279 		return 1;
280 	}
281 
282 	/* S0  <  S3  <  S1 */
283 	d31 = -d13;
284 	d3  = dccp_delta_seqno(s0, s3);
285 
286 	if (d3 == 1 || n3 >= d3) {	/* S3 is a successor of S0 */
287 
288 		if (d31 == 1 || n1 >= d31) {
289 			/* hole between S0 and S1 filled by S3 */
290 			int  d2 = dccp_delta_seqno(s1, s2),
291 			     n2 = tfrc_rx_hist_entry(h, 2)->tfrchrx_ndp;
292 
293 			if (d2 == 1 || n2 >= d2) {
294 				/* entire hole filled by S0, S3, S1, S2 */
295 				h->loss_start = tfrc_rx_hist_index(h, 2);
296 				h->loss_count = 0;
297 			} else {
298 				/* gap remains between S1 and S2 */
299 				h->loss_start = tfrc_rx_hist_index(h, 1);
300 				h->loss_count = 1;
301 			}
302 
303 		} else /* gap exists between S3 and S1, loss_count stays at 2 */
304 			tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_loss_prev(h), skb, n3);
305 
306 		return 0;
307 	}
308 
309 	/*
310 	 * The remaining case: S3 is not a successor of S0.
311 	 * Sequence order is S0, S3, S1, S2; reorder to insert between S0 and S1
312 	 */
313 	tfrc_rx_hist_swap(h, 0, 3);
314 	h->loss_start = tfrc_rx_hist_index(h, 3);
315 	tfrc_rx_hist_entry_from_skb(tfrc_rx_hist_entry(h, 1), skb, n3);
316 	h->loss_count = 3;
317 
318 	return 1;
319 }
320 
321 /* return the signed modulo-2^48 sequence number distance from entry e1 to e2 */
322 static s64 tfrc_rx_hist_delta_seqno(struct tfrc_rx_hist *h, u8 e1, u8 e2)
323 {
324 	DCCP_BUG_ON(e1 > h->loss_count || e2 > h->loss_count);
325 
326 	return dccp_delta_seqno(tfrc_rx_hist_entry(h, e1)->tfrchrx_seqno,
327 				tfrc_rx_hist_entry(h, e2)->tfrchrx_seqno);
328 }
329 
330 /* recycle RX history records to continue loss detection if necessary */
331 static void __three_after_loss(struct tfrc_rx_hist *h)
332 {
333 	/*
334 	 * The distance between S0 and S1 is always greater than 1 and the NDP
335 	 * count of S1 is smaller than this distance. Otherwise there would
336 	 * have been no loss. Hence it is only necessary to see whether there
337 	 * are further missing data packets between S1/S2 and S2/S3.
338 	 */
339 	int d2 = tfrc_rx_hist_delta_seqno(h, 1, 2),
340 	    d3 = tfrc_rx_hist_delta_seqno(h, 2, 3),
341 	    n2 = tfrc_rx_hist_entry(h, 2)->tfrchrx_ndp,
342 	    n3 = tfrc_rx_hist_entry(h, 3)->tfrchrx_ndp;
343 
344 	if (d2 == 1 || n2 >= d2) {	/* S2 is successor to S1 */
345 
346 		if (d3 == 1 || n3 >= d3) {
347 			/* S3 is successor of S2: entire hole is filled */
348 			h->loss_start = tfrc_rx_hist_index(h, 3);
349 			h->loss_count = 0;
350 		} else {
351 			/* gap between S2 and S3 */
352 			h->loss_start = tfrc_rx_hist_index(h, 2);
353 			h->loss_count = 1;
354 		}
355 
356 	} else {			/* gap between S1 and S2 */
357 		h->loss_start = tfrc_rx_hist_index(h, 1);
358 		h->loss_count = 2;
359 	}
360 }
361 
362 /**
363  *  tfrc_rx_handle_loss  -  Loss detection and further processing
364  *  @h:		    The non-empty RX history object
365  *  @lh:	    Loss Intervals database to update
366  *  @skb:	    Currently received packet
367  *  @ndp:	    The NDP count belonging to @skb
368  *  @calc_first_li: Caller-dependent computation of first loss interval in @lh
369  *  @sk:	    Used by @calc_first_li (see tfrc_lh_interval_add)
370  *  Chooses action according to pending loss, updates LI database when a new
371  *  loss was detected, and does required post-processing. Returns 1 when caller
372  *  should send feedback, 0 otherwise.
373  */
374 int tfrc_rx_handle_loss(struct tfrc_rx_hist *h,
375 			struct tfrc_loss_hist *lh,
376 			struct sk_buff *skb, u32 ndp,
377 			u32 (*calc_first_li)(struct sock *), struct sock *sk)
378 {
379 	int is_new_loss = 0;
380 
381 	if (h->loss_count == 1) {
382 		__one_after_loss(h, skb, ndp);
383 	} else if (h->loss_count != 2) {
384 		DCCP_BUG("invalid loss_count %d", h->loss_count);
385 	} else if (__two_after_loss(h, skb, ndp)) {
386 		/*
387 		 * Update Loss Interval database and recycle RX records
388 		 */
389 		is_new_loss = tfrc_lh_interval_add(lh, h, calc_first_li, sk);
390 		__three_after_loss(h);
391 	}
392 	return is_new_loss;
393 }
394 EXPORT_SYMBOL_GPL(tfrc_rx_handle_loss);
395 
396 int tfrc_rx_hist_alloc(struct tfrc_rx_hist *h)
397 {
398 	int i;
399 
400 	for (i = 0; i <= TFRC_NDUPACK; i++) {
401 		h->ring[i] = kmem_cache_alloc(tfrc_rx_hist_slab, GFP_ATOMIC);
402 		if (h->ring[i] == NULL)
403 			goto out_free;
404 	}
405 
406 	h->loss_count = h->loss_start = 0;
407 	return 0;
408 
409 out_free:
410 	while (i-- != 0) {
411 		kmem_cache_free(tfrc_rx_hist_slab, h->ring[i]);
412 		h->ring[i] = NULL;
413 	}
414 	return -ENOBUFS;
415 }
416 EXPORT_SYMBOL_GPL(tfrc_rx_hist_alloc);
417 
418 void tfrc_rx_hist_purge(struct tfrc_rx_hist *h)
419 {
420 	int i;
421 
422 	for (i = 0; i <= TFRC_NDUPACK; ++i)
423 		if (h->ring[i] != NULL) {
424 			kmem_cache_free(tfrc_rx_hist_slab, h->ring[i]);
425 			h->ring[i] = NULL;
426 		}
427 }
428 EXPORT_SYMBOL_GPL(tfrc_rx_hist_purge);
429 
430 /**
431  * tfrc_rx_hist_rtt_last_s - reference entry to compute RTT samples against
432  */
433 static inline struct tfrc_rx_hist_entry *
434 			tfrc_rx_hist_rtt_last_s(const struct tfrc_rx_hist *h)
435 {
436 	return h->ring[0];
437 }
438 
439 /**
440  * tfrc_rx_hist_rtt_prev_s: previously suitable (wrt rtt_last_s) RTT-sampling entry
441  */
442 static inline struct tfrc_rx_hist_entry *
443 			tfrc_rx_hist_rtt_prev_s(const struct tfrc_rx_hist *h)
444 {
445 	return h->ring[h->rtt_sample_prev];
446 }
447 
448 /**
449  * tfrc_rx_hist_sample_rtt  -  Sample RTT from timestamp / CCVal
450  * Based on ideas presented in RFC 4342, 8.1. Returns 0 if it was not able
451  * to compute a sample with given data - calling function should check this.
452  */
453 u32 tfrc_rx_hist_sample_rtt(struct tfrc_rx_hist *h, const struct sk_buff *skb)
454 {
455 	u32 sample = 0,
456 	    delta_v = SUB16(dccp_hdr(skb)->dccph_ccval,
457 			    tfrc_rx_hist_rtt_last_s(h)->tfrchrx_ccval);
458 
459 	if (delta_v < 1 || delta_v > 4) {	/* unsuitable CCVal delta */
460 		if (h->rtt_sample_prev == 2) {	/* previous candidate stored */
461 			sample = SUB16(tfrc_rx_hist_rtt_prev_s(h)->tfrchrx_ccval,
462 				       tfrc_rx_hist_rtt_last_s(h)->tfrchrx_ccval);
463 			if (sample)
464 				sample = 4 / sample *
465 				         ktime_us_delta(tfrc_rx_hist_rtt_prev_s(h)->tfrchrx_tstamp,
466 							tfrc_rx_hist_rtt_last_s(h)->tfrchrx_tstamp);
467 			else    /*
468 				 * FIXME: This condition is in principle not
469 				 * possible but occurs when CCID is used for
470 				 * two-way data traffic. I have tried to trace
471 				 * it, but the cause does not seem to be here.
472 				 */
473 				DCCP_BUG("please report to dccp@vger.kernel.org"
474 					 " => prev = %u, last = %u",
475 					 tfrc_rx_hist_rtt_prev_s(h)->tfrchrx_ccval,
476 					 tfrc_rx_hist_rtt_last_s(h)->tfrchrx_ccval);
477 		} else if (delta_v < 1) {
478 			h->rtt_sample_prev = 1;
479 			goto keep_ref_for_next_time;
480 		}
481 
482 	} else if (delta_v == 4) /* optimal match */
483 		sample = ktime_to_us(net_timedelta(tfrc_rx_hist_rtt_last_s(h)->tfrchrx_tstamp));
484 	else {			 /* suboptimal match */
485 		h->rtt_sample_prev = 2;
486 		goto keep_ref_for_next_time;
487 	}
488 
489 	if (unlikely(sample > DCCP_SANE_RTT_MAX)) {
490 		DCCP_WARN("RTT sample %u too large, using max\n", sample);
491 		sample = DCCP_SANE_RTT_MAX;
492 	}
493 
494 	h->rtt_sample_prev = 0;	       /* use current entry as next reference */
495 keep_ref_for_next_time:
496 
497 	return sample;
498 }
499 EXPORT_SYMBOL_GPL(tfrc_rx_hist_sample_rtt);
500