2 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved.
3 * Copyright (c) 2003, 2004 The DragonFly Project. All rights reserved.
5 * This code is derived from software contributed to The DragonFly Project
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of The DragonFly Project nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific, prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * $DragonFly: src/sys/netinet/tcp_sack.c,v 1.6 2007/04/22 01:13:14 dillon Exp $
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/malloc.h>
40 #include <sys/queue.h>
41 #include <sys/thread.h>
42 #include <sys/types.h>
43 #include <sys/socket.h>
44 #include <sys/socketvar.h>
48 #include <netinet/in.h>
49 #include <netinet/in_systm.h>
50 #include <netinet/ip.h>
51 #include <netinet/in_var.h>
52 #include <netinet/in_pcb.h>
53 #include <netinet/ip_var.h>
54 #include <netinet/tcp.h>
55 #include <netinet/tcp_seq.h>
56 #include <netinet/tcp_var.h>
58 #include <vm/vm_zone.h>
63 TAILQ_ENTRY(sackblock
) sblk_list
;
66 #define MAXSAVEDBLOCKS 8 /* per connection limit */
68 static void insert_block(struct scoreboard
*scb
, struct sackblock
*newblock
);
69 static void update_lostseq(struct scoreboard
*scb
, tcp_seq snd_una
,
72 static vm_zone_t sackblock_zone
;
75 * Initialize SACK module.
80 sackblock_zone
= zinit("sack blocks", sizeof(struct sackblock
),
81 maxsockets
, ZONE_INTERRUPT
, 0);
85 * Per-tcpcb initialization.
88 tcp_sack_tcpcb_init(struct tcpcb
*tp
)
90 struct scoreboard
*scb
= &tp
->scb
;
93 TAILQ_INIT(&scb
->sackblocks
);
94 scb
->lastfound
= NULL
;
98 * Find the SACK block containing or immediately preceding "seq".
99 * The boolean result indicates whether the sequence is actually
100 * contained in the SACK block.
103 sack_block_lookup(struct scoreboard
*scb
, tcp_seq seq
, struct sackblock
**sb
)
105 struct sackblock
*hint
= scb
->lastfound
;
106 struct sackblock
*cur
, *last
, *prev
;
108 if (TAILQ_EMPTY(&scb
->sackblocks
)) {
114 /* No hint. Search from start to end. */
115 cur
= TAILQ_FIRST(&scb
->sackblocks
);
117 prev
= TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
119 if (SEQ_GEQ(seq
, hint
->sblk_start
)) {
120 /* Search from hint to end of list. */
123 prev
= TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
125 /* Search from front of list to hint. */
126 cur
= TAILQ_FIRST(&scb
->sackblocks
);
128 prev
= TAILQ_PREV(hint
, sackblock_list
, sblk_list
);
133 if (SEQ_GT(cur
->sblk_end
, seq
)) {
134 if (SEQ_GEQ(seq
, cur
->sblk_start
)) {
135 *sb
= scb
->lastfound
= cur
;
138 *sb
= scb
->lastfound
=
139 TAILQ_PREV(cur
, sackblock_list
, sblk_list
);
143 cur
= TAILQ_NEXT(cur
, sblk_list
);
144 } while (cur
!= last
);
146 *sb
= scb
->lastfound
= prev
;
151 * Allocate a SACK block.
153 static __inline
struct sackblock
*
154 alloc_sackblock(void)
156 return zalloc(sackblock_zone
);
163 free_sackblock(struct sackblock
*s
)
165 zfree(sackblock_zone
, s
);
169 * Free up SACK blocks for data that's been acked.
172 tcp_sack_ack_blocks(struct scoreboard
*scb
, tcp_seq th_ack
)
174 struct sackblock
*sb
, *nb
;
176 sb
= TAILQ_FIRST(&scb
->sackblocks
);
177 while (sb
&& SEQ_LEQ(sb
->sblk_end
, th_ack
)) {
178 nb
= TAILQ_NEXT(sb
, sblk_list
);
179 if (sb
== scb
->lastfound
)
180 scb
->lastfound
= NULL
;
181 TAILQ_REMOVE(&scb
->sackblocks
, sb
, sblk_list
);
184 KASSERT(scb
->nblocks
>= 0,
185 ("SACK block count underflow: %d < 0", scb
->nblocks
));
188 if (sb
&& SEQ_GT(th_ack
, sb
->sblk_start
))
189 sb
->sblk_start
= th_ack
; /* other side reneged? XXX */
193 * Delete and free SACK blocks saved in scoreboard.
196 tcp_sack_cleanup(struct scoreboard
*scb
)
198 struct sackblock
*sb
, *nb
;
200 TAILQ_FOREACH_MUTABLE(sb
, &scb
->sackblocks
, sblk_list
, nb
) {
204 KASSERT(scb
->nblocks
== 0,
205 ("SACK block %d count not zero", scb
->nblocks
));
206 TAILQ_INIT(&scb
->sackblocks
);
207 scb
->lastfound
= NULL
;
211 * Returns 0 if not D-SACK block,
213 * 2 if duplicate of out-of-order D-SACK block.
216 tcp_sack_ndsack_blocks(struct raw_sackblock
*blocks
, const int numblocks
,
222 if (SEQ_LT(blocks
[0].rblk_start
, snd_una
))
225 /* block 0 inside block 1 */
227 SEQ_GEQ(blocks
[0].rblk_start
, blocks
[1].rblk_start
) &&
228 SEQ_LEQ(blocks
[0].rblk_end
, blocks
[1].rblk_end
))
235 * Update scoreboard on new incoming ACK.
238 tcp_sack_add_blocks(struct tcpcb
*tp
, struct tcpopt
*to
)
240 const int numblocks
= to
->to_nsackblocks
;
241 struct raw_sackblock
*blocks
= to
->to_sackblocks
;
242 struct scoreboard
*scb
= &tp
->scb
;
243 struct sackblock
*sb
;
247 if (tcp_sack_ndsack_blocks(blocks
, numblocks
, tp
->snd_una
) > 0)
252 for (i
= startblock
; i
< numblocks
; i
++) {
253 struct raw_sackblock
*newsackblock
= &blocks
[i
];
255 /* don't accept bad SACK blocks */
256 if (SEQ_GT(newsackblock
->rblk_end
, tp
->snd_max
))
257 break; /* skip all other blocks */
259 sb
= alloc_sackblock();
260 if (sb
== NULL
) /* do some sort of cleanup? XXX */
261 break; /* just skip rest of blocks */
262 sb
->sblk_start
= newsackblock
->rblk_start
;
263 sb
->sblk_end
= newsackblock
->rblk_end
;
264 if (TAILQ_EMPTY(&scb
->sackblocks
)) {
265 KASSERT(scb
->nblocks
== 0, ("emply scb w/ blocks"));
267 TAILQ_INSERT_HEAD(&scb
->sackblocks
, sb
, sblk_list
);
269 insert_block(scb
, sb
);
275 tcp_sack_update_scoreboard(struct tcpcb
*tp
, struct tcpopt
*to
)
277 struct scoreboard
*scb
= &tp
->scb
;
279 tcp_sack_ack_blocks(scb
, tp
->snd_una
);
280 tcp_sack_add_blocks(tp
, to
);
281 update_lostseq(scb
, tp
->snd_una
, tp
->t_maxseg
);
282 if (SEQ_LT(tp
->rexmt_high
, tp
->snd_una
))
283 tp
->rexmt_high
= tp
->snd_una
;
287 * Insert SACK block into sender's scoreboard.
290 insert_block(struct scoreboard
*scb
, struct sackblock
*newblock
)
292 struct sackblock
*sb
, *workingblock
;
293 boolean_t overlap_front
;
295 KASSERT(scb
->nblocks
> 0, ("insert_block() called w/ no blocks"));
297 if (scb
->nblocks
== MAXSAVEDBLOCKS
) {
299 * Should try to kick out older blocks XXX JH
300 * May be able to coalesce with existing block.
301 * Or, go other way and free all blocks if we hit this limit.
303 free_sackblock(newblock
);
306 KASSERT(scb
->nblocks
< MAXSAVEDBLOCKS
,
307 ("too many SACK blocks %d", scb
->nblocks
));
309 overlap_front
= sack_block_lookup(scb
, newblock
->sblk_start
, &sb
);
312 workingblock
= newblock
;
313 TAILQ_INSERT_HEAD(&scb
->sackblocks
, newblock
, sblk_list
);
316 if (overlap_front
|| sb
->sblk_end
== newblock
->sblk_start
) {
317 /* extend old block and discard new one */
319 if (SEQ_GT(newblock
->sblk_end
, sb
->sblk_end
))
320 sb
->sblk_end
= newblock
->sblk_end
;
321 free_sackblock(newblock
);
323 workingblock
= newblock
;
324 TAILQ_INSERT_AFTER(&scb
->sackblocks
, sb
, newblock
,
330 /* Consolidate right-hand side. */
331 sb
= TAILQ_NEXT(workingblock
, sblk_list
);
333 SEQ_GEQ(workingblock
->sblk_end
, sb
->sblk_end
)) {
334 struct sackblock
*nextblock
;
336 nextblock
= TAILQ_NEXT(sb
, sblk_list
);
337 /* Remove completely overlapped block */
338 TAILQ_REMOVE(&scb
->sackblocks
, sb
, sblk_list
);
341 KASSERT(scb
->nblocks
> 0,
342 ("removed overlapped block: %d blocks left", scb
->nblocks
));
346 SEQ_GEQ(workingblock
->sblk_end
, sb
->sblk_start
)) {
347 /* Extend new block to cover partially overlapped old block. */
348 workingblock
->sblk_end
= sb
->sblk_end
;
349 TAILQ_REMOVE(&scb
->sackblocks
, sb
, sblk_list
);
352 KASSERT(scb
->nblocks
> 0,
353 ("removed partial right: %d blocks left", scb
->nblocks
));
357 #ifdef DEBUG_SACK_BLOCKS
359 tcp_sack_dump_blocks(struct scoreboard
*scb
)
361 struct sackblock
*sb
;
363 kprintf("%d blocks:", scb
->nblocks
);
364 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
)
365 kprintf(" [%u, %u)", sb
->sblk_start
, sb
->sblk_end
);
370 tcp_sack_dump_blocks(struct scoreboard
*scb
)
376 * Optimization to quickly determine which packets are lost.
379 update_lostseq(struct scoreboard
*scb
, tcp_seq snd_una
, u_int maxseg
)
381 struct sackblock
*sb
;
383 int bytes_sacked
= 0;
385 sb
= TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
388 bytes_sacked
+= sb
->sblk_end
- sb
->sblk_start
;
389 if (nsackblocks
== tcprexmtthresh
||
390 bytes_sacked
>= tcprexmtthresh
* maxseg
) {
391 scb
->lostseq
= sb
->sblk_start
;
394 sb
= TAILQ_PREV(sb
, sackblock_list
, sblk_list
);
396 scb
->lostseq
= snd_una
;
400 * Return whether the given sequence number is considered lost.
403 scb_islost(struct scoreboard
*scb
, tcp_seq seqnum
)
405 return SEQ_LT(seqnum
, scb
->lostseq
);
409 * True if at least "amount" has been SACKed. Used by Early Retransmit.
412 tcp_sack_has_sacked(struct scoreboard
*scb
, u_int amount
)
414 struct sackblock
*sb
;
415 int bytes_sacked
= 0;
417 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
) {
418 bytes_sacked
+= sb
->sblk_end
- sb
->sblk_start
;
419 if (bytes_sacked
>= amount
)
426 * Number of bytes SACKed below seq.
429 tcp_sack_bytes_below(struct scoreboard
*scb
, tcp_seq seq
)
431 struct sackblock
*sb
;
432 int bytes_sacked
= 0;
434 sb
= TAILQ_FIRST(&scb
->sackblocks
);
435 while (sb
&& SEQ_GT(seq
, sb
->sblk_start
)) {
436 bytes_sacked
+= seq_min(seq
, sb
->sblk_end
) - sb
->sblk_start
;
437 sb
= TAILQ_NEXT(sb
, sblk_list
);
443 * Return estimate of the number of bytes outstanding in the network.
446 tcp_sack_compute_pipe(struct tcpcb
*tp
)
448 struct scoreboard
*scb
= &tp
->scb
;
449 struct sackblock
*sb
;
450 int nlost
, nretransmitted
;
453 nlost
= tp
->snd_max
- scb
->lostseq
;
454 nretransmitted
= tp
->rexmt_high
- tp
->snd_una
;
456 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
) {
457 if (SEQ_LT(sb
->sblk_start
, tp
->rexmt_high
)) {
458 end
= seq_min(sb
->sblk_end
, tp
->rexmt_high
);
459 nretransmitted
-= end
- sb
->sblk_start
;
461 if (SEQ_GEQ(sb
->sblk_start
, scb
->lostseq
))
462 nlost
-= sb
->sblk_end
- sb
->sblk_start
;
465 return (nlost
+ nretransmitted
);
469 * Return the sequence number and length of the next segment to transmit
470 * when in Fast Recovery.
473 tcp_sack_nextseg(struct tcpcb
*tp
, tcp_seq
*nextrexmt
, uint32_t *plen
,
476 struct scoreboard
*scb
= &tp
->scb
;
477 struct socket
*so
= tp
->t_inpcb
->inp_socket
;
478 struct sackblock
*sb
;
479 const struct sackblock
*lastblock
=
480 TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
484 /* skip SACKed data */
485 tcp_sack_skip_sacked(scb
, &tp
->rexmt_high
);
487 /* Look for lost data. */
488 torexmt
= tp
->rexmt_high
;
490 if (lastblock
!= NULL
) {
491 if (SEQ_LT(torexmt
, lastblock
->sblk_end
) &&
492 scb_islost(scb
, torexmt
)) {
494 *nextrexmt
= torexmt
;
495 /* If the left-hand edge has been SACKed, pull it in. */
496 if (sack_block_lookup(scb
, torexmt
+ tp
->t_maxseg
, &sb
))
497 *plen
= sb
->sblk_start
- torexmt
;
499 *plen
= tp
->t_maxseg
;
504 /* See if unsent data available within send window. */
505 off
= tp
->snd_max
- tp
->snd_una
;
506 len
= (long) ulmin(so
->so_snd
.ssb_cc
, tp
->snd_wnd
) - off
;
508 *nextrexmt
= tp
->snd_max
; /* Send new data. */
509 *plen
= tp
->t_maxseg
;
513 /* We're less certain this data has been lost. */
514 if (lastblock
== NULL
|| SEQ_LT(torexmt
, lastblock
->sblk_end
))
521 * Return the next sequence number higher than "*prexmt" that has
525 tcp_sack_skip_sacked(struct scoreboard
*scb
, tcp_seq
*prexmt
)
527 struct sackblock
*sb
;
529 /* skip SACKed data */
530 if (sack_block_lookup(scb
, *prexmt
, &sb
))
531 *prexmt
= sb
->sblk_end
;
536 tcp_sack_save_scoreboard(struct scoreboard
*scb
)
538 struct scoreboard
*scb
= &tp
->scb
;
540 scb
->sackblocks_prev
= scb
->sackblocks
;
541 TAILQ_INIT(&scb
->sackblocks
);
545 tcp_sack_revert_scoreboard(struct scoreboard
*scb
, tcp_seq snd_una
,
548 struct sackblock
*sb
;
550 scb
->sackblocks
= scb
->sackblocks_prev
;
552 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
)
554 tcp_sack_ack_blocks(scb
, snd_una
);
555 scb
->lastfound
= NULL
;
559 #ifdef DEBUG_SACK_HISTORY
561 tcp_sack_dump_history(char *msg
, struct tcpcb
*tp
)
566 /* only need a couple of these to debug most problems */
570 kprintf("%s:\tnsackhistory %d: ", msg
, tp
->nsackhistory
);
571 for (i
= 0; i
< tp
->nsackhistory
; ++i
)
572 kprintf("[%u, %u) ", tp
->sackhistory
[i
].rblk_start
,
573 tp
->sackhistory
[i
].rblk_end
);
578 tcp_sack_dump_history(char *msg
, struct tcpcb
*tp
)
584 * Remove old SACK blocks from the SACK history that have already been ACKed.
587 tcp_sack_ack_history(struct tcpcb
*tp
)
589 int i
, nblocks
, openslot
;
591 tcp_sack_dump_history("before tcp_sack_ack_history", tp
);
592 nblocks
= tp
->nsackhistory
;
593 for (i
= openslot
= 0; i
< nblocks
; ++i
) {
594 if (SEQ_LEQ(tp
->sackhistory
[i
].rblk_end
, tp
->rcv_nxt
)) {
598 if (SEQ_LT(tp
->sackhistory
[i
].rblk_start
, tp
->rcv_nxt
))
599 tp
->sackhistory
[i
].rblk_start
= tp
->rcv_nxt
;
603 tp
->sackhistory
[openslot
++] = tp
->sackhistory
[i
];
605 tcp_sack_dump_history("after tcp_sack_ack_history", tp
);
606 KASSERT(openslot
== tp
->nsackhistory
,
607 ("tcp_sack_ack_history miscounted: %d != %d",
608 openslot
, tp
->nsackhistory
));
612 * Add or merge newblock into reported history.
613 * Also remove or update SACK blocks that will be acked.
616 tcp_sack_update_reported_history(struct tcpcb
*tp
, tcp_seq start
, tcp_seq end
)
618 struct raw_sackblock copy
[MAX_SACK_REPORT_BLOCKS
];
621 tcp_sack_dump_history("before tcp_sack_update_reported_history", tp
);
625 * 1) newblock == oldblock
626 * 2) oldblock contains newblock
627 * 3) newblock contains oldblock
628 * 4) tail of oldblock overlaps or abuts start of newblock
629 * 5) tail of newblock overlaps or abuts head of oldblock
631 for (i
= cindex
= 0; i
< tp
->nsackhistory
; ++i
) {
632 struct raw_sackblock
*oldblock
= &tp
->sackhistory
[i
];
633 tcp_seq old_start
= oldblock
->rblk_start
;
634 tcp_seq old_end
= oldblock
->rblk_end
;
636 if (SEQ_LT(end
, old_start
) || SEQ_GT(start
, old_end
)) {
637 /* Case 0: no overlap. Copy old block. */
638 copy
[cindex
++] = *oldblock
;
642 if (SEQ_GEQ(start
, old_start
) && SEQ_LEQ(end
, old_end
)) {
643 /* Cases 1 & 2. Move block to front of history. */
648 /* no need to check rest of blocks */
649 for (j
= i
+ 1; j
< tp
->nsackhistory
; ++j
)
650 copy
[cindex
++] = tp
->sackhistory
[j
];
654 if (SEQ_GEQ(old_end
, start
) && SEQ_LT(old_start
, start
)) {
655 /* Case 4: extend start of new block. */
657 } else if (SEQ_GEQ(end
, old_start
) && SEQ_GT(old_end
, end
)) {
658 /* Case 5: extend end of new block */
661 /* Case 3. Delete old block by not copying it. */
662 KASSERT(SEQ_LEQ(start
, old_start
) &&
663 SEQ_GEQ(end
, old_end
),
664 ("bad logic: old [%u, %u), new [%u, %u)",
665 old_start
, old_end
, start
, end
));
669 /* insert new block */
670 tp
->sackhistory
[0].rblk_start
= start
;
671 tp
->sackhistory
[0].rblk_end
= end
;
672 cindex
= min(cindex
, MAX_SACK_REPORT_BLOCKS
- 1);
673 for (i
= 0; i
< cindex
; ++i
)
674 tp
->sackhistory
[i
+ 1] = copy
[i
];
675 tp
->nsackhistory
= cindex
+ 1;
676 tcp_sack_dump_history("after tcp_sack_update_reported_history", tp
);
680 * Fill in SACK report to return to data sender.
683 tcp_sack_fill_report(struct tcpcb
*tp
, u_char
*opt
, u_int
*plen
)
685 u_int optlen
= *plen
;
686 uint32_t *lp
= (uint32_t *)(opt
+ optlen
);
688 tcp_seq hstart
= tp
->rcv_nxt
, hend
;
691 KASSERT(TCP_MAXOLEN
- optlen
>=
692 TCPOLEN_SACK_ALIGNED
+ TCPOLEN_SACK_BLOCK
,
693 ("no room for SACK header and one block: optlen %d", optlen
));
696 optlen
+= TCPOLEN_SACK_ALIGNED
;
698 tcp_sack_ack_history(tp
);
699 if (tp
->reportblk
.rblk_start
!= tp
->reportblk
.rblk_end
) {
700 *lp
++ = htonl(tp
->reportblk
.rblk_start
);
701 *lp
++ = htonl(tp
->reportblk
.rblk_end
);
702 optlen
+= TCPOLEN_SACK_BLOCK
;
703 hstart
= tp
->reportblk
.rblk_start
;
704 hend
= tp
->reportblk
.rblk_end
;
705 if (tp
->t_flags
& TF_ENCLOSESEG
) {
706 KASSERT(TCP_MAXOLEN
- optlen
>= TCPOLEN_SACK_BLOCK
,
707 ("no room for enclosing SACK block: oplen %d",
709 *lp
++ = htonl(tp
->encloseblk
.rblk_start
);
710 *lp
++ = htonl(tp
->encloseblk
.rblk_end
);
711 optlen
+= TCPOLEN_SACK_BLOCK
;
712 hstart
= tp
->encloseblk
.rblk_start
;
713 hend
= tp
->encloseblk
.rblk_end
;
715 if (SEQ_GT(hstart
, tp
->rcv_nxt
))
716 tcp_sack_update_reported_history(tp
, hstart
, hend
);
718 if (tcp_do_smartsack
&& (tp
->t_flags
& TF_SACKLEFT
)) {
719 /* Fill in from left! Walk re-assembly queue. */
722 q
= LIST_FIRST(&tp
->t_segq
);
724 TCP_MAXOLEN
- optlen
>= TCPOLEN_SACK_BLOCK
) {
725 *lp
++ = htonl(q
->tqe_th
->th_seq
);
726 *lp
++ = htonl(q
->tqe_th
->th_seq
+ q
->tqe_len
);
727 optlen
+= TCPOLEN_SACK_BLOCK
;
728 q
= LIST_NEXT(q
, tqe_q
);
733 /* Fill in SACK blocks from right side. */
734 while (n
< tp
->nsackhistory
&&
735 TCP_MAXOLEN
- optlen
>= TCPOLEN_SACK_BLOCK
) {
736 if (tp
->sackhistory
[n
].rblk_start
!= hstart
) {
737 *lp
++ = htonl(tp
->sackhistory
[n
].rblk_start
);
738 *lp
++ = htonl(tp
->sackhistory
[n
].rblk_end
);
739 optlen
+= TCPOLEN_SACK_BLOCK
;
744 tp
->reportblk
.rblk_start
= tp
->reportblk
.rblk_end
;
745 tp
->t_flags
&= ~(TF_DUPSEG
| TF_ENCLOSESEG
| TF_SACKLEFT
);
746 nblocks
= (lp
- olp
- 1) / 2;
747 *olp
= htonl(TCPOPT_SACK_ALIGNED
|
748 (TCPOLEN_SACK
+ nblocks
* TCPOLEN_SACK_BLOCK
));