Line data Source code
1 : /*
2 : * Copyright (c) 2020 Cisco and/or its affiliates.
3 : * Licensed under the Apache License, Version 2.0 (the "License");
4 : * you may not use this file except in compliance with the License.
5 : * You may obtain a copy of the License at:
6 : *
7 : * http://www.apache.org/licenses/LICENSE-2.0
8 : *
9 : * Unless required by applicable law or agreed to in writing, software
10 : * distributed under the License is distributed on an "AS IS" BASIS,
11 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 : * See the License for the specific language governing permissions and
13 : * limitations under the License.
14 : */
15 :
16 : #include <vnet/tcp/tcp_sack.h>
17 :
18 : static void
19 22 : scoreboard_remove_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole)
20 : {
21 : sack_scoreboard_hole_t *next, *prev;
22 :
23 22 : if (hole->next != TCP_INVALID_SACK_HOLE_INDEX)
24 : {
25 15 : next = pool_elt_at_index (sb->holes, hole->next);
26 15 : next->prev = hole->prev;
27 : }
28 : else
29 : {
30 7 : sb->tail = hole->prev;
31 : }
32 :
33 22 : if (hole->prev != TCP_INVALID_SACK_HOLE_INDEX)
34 : {
35 3 : prev = pool_elt_at_index (sb->holes, hole->prev);
36 3 : prev->next = hole->next;
37 : }
38 : else
39 : {
40 19 : sb->head = hole->next;
41 : }
42 :
43 22 : if (scoreboard_hole_index (sb, hole) == sb->cur_rxt_hole)
44 0 : sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
45 :
46 : /* Poison the entry */
47 : if (CLIB_DEBUG > 0)
48 22 : clib_memset (hole, 0xfe, sizeof (*hole));
49 :
50 22 : pool_put (sb->holes, hole);
51 22 : }
52 :
53 : static sack_scoreboard_hole_t *
54 22 : scoreboard_insert_hole (sack_scoreboard_t * sb, u32 prev_index,
55 : u32 start, u32 end)
56 : {
57 : sack_scoreboard_hole_t *hole, *next, *prev;
58 : u32 hole_index;
59 :
60 22 : pool_get (sb->holes, hole);
61 22 : clib_memset (hole, 0, sizeof (*hole));
62 :
63 22 : hole->start = start;
64 22 : hole->end = end;
65 22 : hole_index = scoreboard_hole_index (sb, hole);
66 :
67 22 : prev = scoreboard_get_hole (sb, prev_index);
68 22 : if (prev)
69 : {
70 15 : hole->prev = prev_index;
71 15 : hole->next = prev->next;
72 :
73 15 : if ((next = scoreboard_next_hole (sb, hole)))
74 0 : next->prev = hole_index;
75 : else
76 15 : sb->tail = hole_index;
77 :
78 15 : prev->next = hole_index;
79 : }
80 : else
81 : {
82 7 : sb->head = hole_index;
83 7 : hole->prev = TCP_INVALID_SACK_HOLE_INDEX;
84 7 : hole->next = TCP_INVALID_SACK_HOLE_INDEX;
85 : }
86 :
87 22 : return hole;
88 : }
89 :
90 : always_inline void
91 42 : scoreboard_update_sacked (sack_scoreboard_t * sb, u32 start, u32 end,
92 : u8 has_rxt, u16 snd_mss)
93 : {
94 42 : if (!has_rxt)
95 : {
96 : /* Sequence was not retransmitted but it was sacked. Estimate reorder
97 : * only if not in congestion recovery */
98 23 : if (seq_lt (start, sb->high_sacked))
99 : {
100 12 : u32 reord = (sb->high_sacked - start + snd_mss - 1) / snd_mss;
101 12 : reord = clib_min (reord, TCP_MAX_SACK_REORDER);
102 12 : sb->reorder = clib_max (sb->reorder, reord);
103 : }
104 23 : return;
105 : }
106 :
107 19 : if (seq_geq (start, sb->high_rxt))
108 11 : return;
109 :
110 8 : sb->rxt_sacked +=
111 8 : seq_lt (end, sb->high_rxt) ? (end - start) : (sb->high_rxt - start);
112 : }
113 :
114 : always_inline void
115 24 : scoreboard_update_bytes (sack_scoreboard_t * sb, u32 ack, u32 snd_mss)
116 : {
117 : sack_scoreboard_hole_t *left, *right;
118 24 : u32 sacked = 0, blks = 0, old_sacked;
119 :
120 24 : old_sacked = sb->sacked_bytes;
121 :
122 24 : sb->last_lost_bytes = 0;
123 24 : sb->lost_bytes = 0;
124 24 : sb->sacked_bytes = 0;
125 :
126 24 : right = scoreboard_last_hole (sb);
127 24 : if (!right)
128 : {
129 5 : sb->sacked_bytes = sb->high_sacked - ack;
130 5 : sb->last_sacked_bytes = sb->sacked_bytes
131 5 : - (old_sacked - sb->last_bytes_delivered);
132 5 : return;
133 : }
134 :
135 19 : if (seq_gt (sb->high_sacked, right->end))
136 : {
137 5 : sacked = sb->high_sacked - right->end;
138 5 : blks = 1;
139 : }
140 :
141 : /* As per RFC 6675 a sequence number is lost if:
142 : * DupThresh discontiguous SACKed sequences have arrived above
143 : * 'SeqNum' or more than (DupThresh - 1) * SMSS bytes with sequence
144 : * numbers greater than 'SeqNum' have been SACKed.
145 : * To avoid spurious retransmits, use reordering estimate instead of
146 : * DupThresh to detect loss.
147 : */
148 34 : while (sacked <= (sb->reorder - 1) * snd_mss && blks < sb->reorder)
149 : {
150 28 : if (right->is_lost)
151 5 : sb->lost_bytes += scoreboard_hole_bytes (right);
152 :
153 28 : left = scoreboard_prev_hole (sb, right);
154 28 : if (!left)
155 : {
156 13 : ASSERT (right->start == ack || sb->is_reneging);
157 13 : sacked += right->start - ack;
158 13 : right = 0;
159 13 : break;
160 : }
161 :
162 15 : sacked += right->start - left->end;
163 15 : blks++;
164 15 : right = left;
165 : }
166 :
167 : /* right is first lost */
168 22 : while (right)
169 : {
170 9 : sb->lost_bytes += scoreboard_hole_bytes (right);
171 9 : sb->last_lost_bytes += right->is_lost ? 0 : (right->end - right->start);
172 9 : right->is_lost = 1;
173 9 : left = scoreboard_prev_hole (sb, right);
174 9 : if (!left)
175 : {
176 6 : ASSERT (right->start == ack || sb->is_reneging);
177 6 : sacked += right->start - ack;
178 6 : break;
179 : }
180 3 : sacked += right->start - left->end;
181 3 : right = left;
182 : }
183 :
184 19 : sb->sacked_bytes = sacked;
185 19 : sb->last_sacked_bytes = sacked - (old_sacked - sb->last_bytes_delivered);
186 : }
187 :
188 : /**
189 : * Figure out the next hole to retransmit
190 : *
191 : * Follows logic proposed in RFC6675 Sec. 4, NextSeg()
192 : */
193 : sack_scoreboard_hole_t *
194 0 : scoreboard_next_rxt_hole (sack_scoreboard_t * sb,
195 : sack_scoreboard_hole_t * start,
196 : u8 have_unsent, u8 * can_rescue, u8 * snd_limited)
197 : {
198 0 : sack_scoreboard_hole_t *hole = 0;
199 :
200 0 : hole = start ? start : scoreboard_first_hole (sb);
201 0 : while (hole && seq_leq (hole->end, sb->high_rxt) && hole->is_lost)
202 0 : hole = scoreboard_next_hole (sb, hole);
203 :
204 : /* Nothing, return */
205 0 : if (!hole)
206 : {
207 0 : sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
208 0 : return 0;
209 : }
210 :
211 : /* Rule (1): if higher than rxt, less than high_sacked and lost */
212 0 : if (hole->is_lost && seq_lt (hole->start, sb->high_sacked))
213 : {
214 0 : sb->cur_rxt_hole = scoreboard_hole_index (sb, hole);
215 : }
216 : else
217 : {
218 : /* Rule (2): available unsent data */
219 0 : if (have_unsent)
220 : {
221 0 : sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
222 0 : return 0;
223 : }
224 : /* Rule (3): if hole not lost */
225 0 : else if (seq_lt (hole->start, sb->high_sacked))
226 : {
227 : /* And we didn't already retransmit it */
228 0 : if (seq_leq (hole->end, sb->high_rxt))
229 : {
230 0 : sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
231 0 : return 0;
232 : }
233 0 : *snd_limited = 0;
234 0 : sb->cur_rxt_hole = scoreboard_hole_index (sb, hole);
235 : }
236 : /* Rule (4): if hole beyond high_sacked */
237 : else
238 : {
239 0 : ASSERT (seq_geq (hole->start, sb->high_sacked));
240 0 : *snd_limited = 1;
241 0 : *can_rescue = 1;
242 : /* HighRxt MUST NOT be updated */
243 0 : return 0;
244 : }
245 : }
246 :
247 0 : if (hole && seq_lt (sb->high_rxt, hole->start))
248 0 : sb->high_rxt = hole->start;
249 :
250 0 : return hole;
251 : }
252 :
253 : void
254 0 : scoreboard_init_rxt (sack_scoreboard_t * sb, u32 snd_una)
255 : {
256 : sack_scoreboard_hole_t *hole;
257 0 : hole = scoreboard_first_hole (sb);
258 0 : if (hole)
259 : {
260 0 : snd_una = seq_gt (snd_una, hole->start) ? snd_una : hole->start;
261 0 : sb->cur_rxt_hole = sb->head;
262 : }
263 0 : sb->high_rxt = snd_una;
264 0 : sb->rescue_rxt = snd_una - 1;
265 0 : }
266 :
267 : void
268 0 : scoreboard_rxt_mark_lost (sack_scoreboard_t *sb, u32 snd_una, u32 snd_nxt)
269 : {
270 : sack_scoreboard_hole_t *hole;
271 :
272 0 : hole = scoreboard_first_hole (sb);
273 0 : if (!hole)
274 : {
275 0 : hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX, snd_una,
276 : snd_nxt);
277 0 : sb->tail = scoreboard_hole_index (sb, hole);
278 0 : sb->high_sacked = snd_una;
279 : }
280 :
281 0 : if (hole->is_lost)
282 0 : return;
283 :
284 0 : hole->is_lost = 1;
285 0 : sb->lost_bytes += scoreboard_hole_bytes (hole);
286 : }
287 :
288 : void
289 268 : scoreboard_init (sack_scoreboard_t * sb)
290 : {
291 268 : sb->head = TCP_INVALID_SACK_HOLE_INDEX;
292 268 : sb->tail = TCP_INVALID_SACK_HOLE_INDEX;
293 268 : sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
294 268 : sb->reorder = TCP_DUPACK_THRESHOLD;
295 268 : }
296 :
297 : void
298 6 : scoreboard_clear (sack_scoreboard_t * sb)
299 : {
300 : sack_scoreboard_hole_t *hole;
301 9 : while ((hole = scoreboard_first_hole (sb)))
302 : {
303 3 : scoreboard_remove_hole (sb, hole);
304 : }
305 6 : ASSERT (sb->head == sb->tail && sb->head == TCP_INVALID_SACK_HOLE_INDEX);
306 6 : ASSERT (pool_elts (sb->holes) == 0);
307 6 : sb->sacked_bytes = 0;
308 6 : sb->last_sacked_bytes = 0;
309 6 : sb->last_bytes_delivered = 0;
310 6 : sb->lost_bytes = 0;
311 6 : sb->last_lost_bytes = 0;
312 6 : sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX;
313 6 : sb->is_reneging = 0;
314 6 : sb->reorder = TCP_DUPACK_THRESHOLD;
315 6 : }
316 :
317 : void
318 0 : scoreboard_clear_reneging (sack_scoreboard_t * sb, u32 start, u32 end)
319 : {
320 : sack_scoreboard_hole_t *last_hole;
321 :
322 0 : scoreboard_clear (sb);
323 0 : last_hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX,
324 : start, end);
325 0 : last_hole->is_lost = 1;
326 0 : sb->tail = scoreboard_hole_index (sb, last_hole);
327 0 : sb->high_sacked = start;
328 0 : scoreboard_init_rxt (sb, start);
329 0 : }
330 :
331 : /**
332 : * Test that scoreboard is sane after recovery
333 : *
334 : * Returns 1 if scoreboard is empty or if first hole beyond
335 : * snd_una.
336 : */
337 : u8
338 0 : tcp_scoreboard_is_sane_post_recovery (tcp_connection_t * tc)
339 : {
340 : sack_scoreboard_hole_t *hole;
341 0 : hole = scoreboard_first_hole (&tc->sack_sb);
342 0 : return (!hole || (seq_geq (hole->start, tc->snd_una)
343 0 : && seq_lt (hole->end, tc->snd_nxt)));
344 : }
345 :
346 : void
347 1020180 : tcp_rcv_sacks (tcp_connection_t * tc, u32 ack)
348 : {
349 : sack_scoreboard_hole_t *hole, *next_hole;
350 1020180 : sack_scoreboard_t *sb = &tc->sack_sb;
351 : sack_block_t *blk, *rcv_sacks;
352 1020180 : u32 blk_index = 0, i, j, high_sacked;
353 : u8 has_rxt;
354 :
355 1020180 : sb->last_sacked_bytes = 0;
356 1020180 : sb->last_bytes_delivered = 0;
357 1020180 : sb->rxt_sacked = 0;
358 :
359 1020180 : if (!tcp_opts_sack (&tc->rcv_opts) && !sb->sacked_bytes
360 1020150 : && sb->head == TCP_INVALID_SACK_HOLE_INDEX)
361 1020160 : return;
362 :
363 28 : has_rxt = tcp_in_cong_recovery (tc);
364 :
365 : /* Remove invalid blocks */
366 28 : blk = tc->rcv_opts.sacks;
367 93 : while (blk < vec_end (tc->rcv_opts.sacks))
368 : {
369 65 : if (seq_lt (blk->start, blk->end)
370 65 : && seq_gt (blk->start, tc->snd_una)
371 54 : && seq_gt (blk->start, ack)
372 39 : && seq_lt (blk->start, tc->snd_nxt)
373 38 : && seq_leq (blk->end, tc->snd_nxt))
374 : {
375 38 : blk++;
376 38 : continue;
377 : }
378 27 : vec_del1 (tc->rcv_opts.sacks, blk - tc->rcv_opts.sacks);
379 : }
380 :
381 : /* Add block for cumulative ack */
382 28 : if (seq_gt (ack, tc->snd_una))
383 : {
384 15 : vec_add2 (tc->rcv_opts.sacks, blk, 1);
385 15 : blk->start = tc->snd_una;
386 15 : blk->end = ack;
387 : }
388 :
389 28 : if (vec_len (tc->rcv_opts.sacks) == 0)
390 1 : return;
391 :
392 : tcp_scoreboard_trace_add (tc, ack);
393 :
394 : /* Make sure blocks are ordered */
395 27 : rcv_sacks = tc->rcv_opts.sacks;
396 80 : for (i = 0; i < vec_len (rcv_sacks); i++)
397 100 : for (j = i + 1; j < vec_len (rcv_sacks); j++)
398 47 : if (seq_lt (rcv_sacks[j].start, rcv_sacks[i].start))
399 : {
400 18 : sack_block_t tmp = rcv_sacks[i];
401 18 : rcv_sacks[i] = rcv_sacks[j];
402 18 : rcv_sacks[j] = tmp;
403 : }
404 :
405 27 : if (sb->head == TCP_INVALID_SACK_HOLE_INDEX)
406 : {
407 : /* Handle reneging as a special case */
408 10 : if (PREDICT_FALSE (sb->is_reneging))
409 : {
410 : /* No holes, only sacked bytes */
411 3 : if (seq_leq (tc->snd_nxt, sb->high_sacked))
412 : {
413 : /* No progress made so return */
414 3 : if (seq_leq (ack, tc->snd_una))
415 0 : return;
416 :
417 : /* Update sacked bytes delivered and return */
418 3 : sb->last_bytes_delivered = ack - tc->snd_una;
419 3 : sb->sacked_bytes -= sb->last_bytes_delivered;
420 3 : sb->is_reneging = seq_lt (ack, sb->high_sacked);
421 3 : return;
422 : }
423 :
424 : /* New hole above high sacked. Add it and process normally */
425 0 : hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX,
426 : sb->high_sacked, tc->snd_nxt);
427 0 : sb->tail = scoreboard_hole_index (sb, hole);
428 : }
429 : /* Not reneging and no holes. Insert the first that covers all
430 : * outstanding bytes */
431 : else
432 : {
433 7 : hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX,
434 : tc->snd_una, tc->snd_nxt);
435 7 : sb->tail = scoreboard_hole_index (sb, hole);
436 7 : sb->high_sacked = tc->snd_una;
437 : }
438 7 : high_sacked = rcv_sacks[vec_len (rcv_sacks) - 1].end;
439 : }
440 : else
441 : {
442 : /* If we have holes but snd_nxt is beyond the last hole, update
443 : * last hole end or add new hole after high sacked */
444 17 : hole = scoreboard_last_hole (sb);
445 17 : if (seq_gt (tc->snd_nxt, hole->end))
446 : {
447 6 : if (seq_geq (hole->start, sb->high_sacked))
448 : {
449 1 : hole->end = tc->snd_nxt;
450 : }
451 : /* New hole after high sacked block */
452 5 : else if (seq_lt (sb->high_sacked, tc->snd_nxt))
453 : {
454 0 : scoreboard_insert_hole (sb, sb->tail, sb->high_sacked,
455 : tc->snd_nxt);
456 : }
457 : }
458 : /* Keep track of max byte sacked for when the last hole
459 : * is acked */
460 17 : high_sacked = seq_max (rcv_sacks[vec_len (rcv_sacks) - 1].end,
461 : sb->high_sacked);
462 : }
463 :
464 : /* Walk the holes with the SACK blocks */
465 24 : hole = pool_elt_at_index (sb->holes, sb->head);
466 :
467 24 : if (PREDICT_FALSE (sb->is_reneging))
468 : {
469 5 : sb->last_bytes_delivered += clib_min (hole->start - tc->snd_una,
470 : ack - tc->snd_una);
471 5 : sb->is_reneging = seq_lt (ack, hole->start);
472 : }
473 :
474 91 : while (hole && blk_index < vec_len (rcv_sacks))
475 : {
476 67 : blk = &rcv_sacks[blk_index];
477 67 : if (seq_leq (blk->start, hole->start))
478 : {
479 : /* Block covers hole. Remove hole */
480 47 : if (seq_geq (blk->end, hole->end))
481 : {
482 19 : next_hole = scoreboard_next_hole (sb, hole);
483 :
484 : /* If covered by ack, compute delivered bytes */
485 19 : if (blk->end == ack)
486 : {
487 16 : u32 sacked = next_hole ? next_hole->start :
488 3 : seq_max (sb->high_sacked, hole->end);
489 13 : if (PREDICT_FALSE (seq_lt (ack, sacked)))
490 : {
491 6 : sb->last_bytes_delivered += ack - hole->end;
492 6 : sb->is_reneging = 1;
493 : }
494 : else
495 : {
496 7 : sb->last_bytes_delivered += sacked - hole->end;
497 7 : sb->is_reneging = 0;
498 : }
499 : }
500 19 : scoreboard_update_sacked (sb, hole->start, hole->end,
501 19 : has_rxt, tc->snd_mss);
502 19 : scoreboard_remove_hole (sb, hole);
503 19 : hole = next_hole;
504 : }
505 : /* Partial 'head' overlap */
506 : else
507 : {
508 28 : if (seq_gt (blk->end, hole->start))
509 : {
510 5 : scoreboard_update_sacked (sb, hole->start, blk->end,
511 5 : has_rxt, tc->snd_mss);
512 5 : hole->start = blk->end;
513 : }
514 28 : blk_index++;
515 : }
516 : }
517 : else
518 : {
519 : /* Hole must be split */
520 20 : if (seq_lt (blk->end, hole->end))
521 : {
522 15 : u32 hole_index = scoreboard_hole_index (sb, hole);
523 15 : next_hole = scoreboard_insert_hole (sb, hole_index, blk->end,
524 : hole->end);
525 : /* Pool might've moved */
526 15 : hole = scoreboard_get_hole (sb, hole_index);
527 15 : hole->end = blk->start;
528 15 : next_hole->is_lost = hole->is_lost;
529 :
530 15 : scoreboard_update_sacked (sb, blk->start, blk->end,
531 15 : has_rxt, tc->snd_mss);
532 :
533 15 : blk_index++;
534 15 : ASSERT (hole->next == scoreboard_hole_index (sb, next_hole));
535 : }
536 5 : else if (seq_lt (blk->start, hole->end))
537 : {
538 3 : scoreboard_update_sacked (sb, blk->start, hole->end,
539 3 : has_rxt, tc->snd_mss);
540 3 : hole->end = blk->start;
541 : }
542 20 : hole = scoreboard_next_hole (sb, hole);
543 : }
544 : }
545 :
546 24 : sb->high_sacked = high_sacked;
547 24 : scoreboard_update_bytes (sb, ack, tc->snd_mss);
548 :
549 24 : ASSERT (sb->last_sacked_bytes <= sb->sacked_bytes || tcp_in_recovery (tc));
550 24 : ASSERT (sb->sacked_bytes == 0 || tcp_in_recovery (tc)
551 : || sb->sacked_bytes <= tc->snd_nxt - seq_max (tc->snd_una, ack));
552 24 : ASSERT (sb->last_sacked_bytes + sb->lost_bytes <= tc->snd_nxt
553 : - seq_max (tc->snd_una, ack) || tcp_in_recovery (tc));
554 24 : ASSERT (sb->head == TCP_INVALID_SACK_HOLE_INDEX || tcp_in_recovery (tc)
555 : || sb->is_reneging || sb->holes[sb->head].start == ack);
556 24 : ASSERT (sb->last_lost_bytes <= sb->lost_bytes);
557 24 : ASSERT ((ack - tc->snd_una) + sb->last_sacked_bytes
558 : - sb->last_bytes_delivered >= sb->rxt_sacked);
559 24 : ASSERT ((ack - tc->snd_una) >= tc->sack_sb.last_bytes_delivered
560 : || (tc->flags & TCP_CONN_FINSNT));
561 :
562 : TCP_EVT (TCP_EVT_CC_SCOREBOARD, tc);
563 : }
564 :
565 : static u8
566 13 : tcp_sack_vector_is_sane (sack_block_t * sacks)
567 : {
568 : int i;
569 36 : for (i = 1; i < vec_len (sacks); i++)
570 : {
571 23 : if (sacks[i - 1].end == sacks[i].start)
572 0 : return 0;
573 : }
574 13 : return 1;
575 : }
576 :
577 : /**
578 : * Build SACK list as per RFC2018.
579 : *
580 : * Makes sure the first block contains the segment that generated the current
581 : * ACK and the following ones are the ones most recently reported in SACK
582 : * blocks.
583 : *
584 : * @param tc TCP connection for which the SACK list is updated
585 : * @param start Start sequence number of the newest SACK block
586 : * @param end End sequence of the newest SACK block
587 : */
588 : void
589 13 : tcp_update_sack_list (tcp_connection_t * tc, u32 start, u32 end)
590 : {
591 13 : sack_block_t *new_list = tc->snd_sacks_fl, *block = 0;
592 : int i;
593 :
594 : /* If the first segment is ooo add it to the list. Last write might've moved
595 : * rcv_nxt over the first segment. */
596 13 : if (seq_lt (tc->rcv_nxt, start))
597 : {
598 10 : vec_add2 (new_list, block, 1);
599 10 : block->start = start;
600 10 : block->end = end;
601 : }
602 :
603 : /* Find the blocks still worth keeping. */
604 46 : for (i = 0; i < vec_len (tc->snd_sacks); i++)
605 : {
606 : /* Discard if rcv_nxt advanced beyond current block */
607 33 : if (seq_leq (tc->snd_sacks[i].start, tc->rcv_nxt))
608 6 : continue;
609 :
610 : /* Merge or drop if segment overlapped by the new segment */
611 27 : if (block && (seq_geq (tc->snd_sacks[i].end, new_list[0].start)
612 3 : && seq_leq (tc->snd_sacks[i].start, new_list[0].end)))
613 : {
614 2 : if (seq_lt (tc->snd_sacks[i].start, new_list[0].start))
615 1 : new_list[0].start = tc->snd_sacks[i].start;
616 2 : if (seq_lt (new_list[0].end, tc->snd_sacks[i].end))
617 1 : new_list[0].end = tc->snd_sacks[i].end;
618 2 : continue;
619 : }
620 :
621 : /* Save to new SACK list if we have space. */
622 25 : if (vec_len (new_list) < TCP_MAX_SACK_BLOCKS)
623 25 : vec_add1 (new_list, tc->snd_sacks[i]);
624 : }
625 :
626 13 : ASSERT (vec_len (new_list) <= TCP_MAX_SACK_BLOCKS);
627 :
628 : /* Replace old vector with new one */
629 13 : vec_reset_length (tc->snd_sacks);
630 13 : tc->snd_sacks_fl = tc->snd_sacks;
631 13 : tc->snd_sacks = new_list;
632 :
633 : /* Segments should not 'touch' */
634 13 : ASSERT (tcp_sack_vector_is_sane (tc->snd_sacks));
635 13 : }
636 :
637 : u32
638 0 : tcp_sack_list_bytes (tcp_connection_t * tc)
639 : {
640 0 : u32 bytes = 0, i;
641 0 : for (i = 0; i < vec_len (tc->snd_sacks); i++)
642 0 : bytes += tc->snd_sacks[i].end - tc->snd_sacks[i].start;
643 0 : return bytes;
644 : }
645 :
646 : /*
647 : * fd.io coding-style-patch-verification: ON
648 : *
649 : * Local Variables:
650 : * eval: (c-set-style "gnu")
651 : * End:
652 : */
|
