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.2 2005/03/09 06:54:34 hsu Exp $
37 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved.
39 * License terms: all terms for the DragonFly license above plus the following:
41 * 4. All advertising materials mentioning features or use of this software
42 * must display the following acknowledgement:
44 * This product includes software developed by Jeffrey M. Hsu
45 * for the DragonFly Project.
47 * This requirement may be waived with permission from Jeffrey Hsu.
48 * This requirement will sunset and may be removed on November 13, 2005,
49 * after which the standard DragonFly license (as shown above) will
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/kernel.h>
56 #include <sys/malloc.h>
57 #include <sys/queue.h>
58 #include <sys/thread.h>
59 #include <sys/types.h>
60 #include <sys/socket.h>
61 #include <sys/socketvar.h>
65 #include <netinet/in.h>
66 #include <netinet/in_systm.h>
67 #include <netinet/ip.h>
68 #include <netinet/in_var.h>
69 #include <netinet/in_pcb.h>
70 #include <netinet/ip_var.h>
71 #include <netinet/tcp.h>
72 #include <netinet/tcp_seq.h>
73 #include <netinet/tcp_var.h>
75 #include <vm/vm_zone.h>
80 TAILQ_ENTRY(sackblock
) sblk_list
;
83 #define MAXSAVEDBLOCKS 8 /* per connection limit */
85 static void insert_block(struct scoreboard
*scb
, struct sackblock
*newblock
);
86 static void update_lostseq(struct scoreboard
*scb
, tcp_seq snd_una
,
89 static vm_zone_t sackblock_zone
;
92 * Initialize SACK module.
97 sackblock_zone
= zinit("sack blocks", sizeof(struct sackblock
),
98 maxsockets
, ZONE_INTERRUPT
, 0);
102 * Per-tcpcb initialization.
105 tcp_sack_tcpcb_init(struct tcpcb
*tp
)
107 struct scoreboard
*scb
= &tp
->scb
;
110 TAILQ_INIT(&scb
->sackblocks
);
111 scb
->lastfound
= NULL
;
115 * Find the SACK block containing or immediately preceding "seq".
116 * The boolean result indicates whether the sequence is actually
117 * contained in the SACK block.
120 sack_block_lookup(struct scoreboard
*scb
, tcp_seq seq
, struct sackblock
**sb
)
122 struct sackblock
*hint
= scb
->lastfound
;
123 struct sackblock
*cur
, *last
, *prev
;
125 if (TAILQ_EMPTY(&scb
->sackblocks
)) {
131 /* No hint. Search from start to end. */
132 cur
= TAILQ_FIRST(&scb
->sackblocks
);
134 prev
= TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
136 if (SEQ_GEQ(seq
, hint
->sblk_start
)) {
137 /* Search from hint to end of list. */
140 prev
= TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
142 /* Search from front of list to hint. */
143 cur
= TAILQ_FIRST(&scb
->sackblocks
);
145 prev
= TAILQ_PREV(hint
, sackblock_list
, sblk_list
);
150 if (SEQ_GT(cur
->sblk_end
, seq
)) {
151 if (SEQ_GEQ(seq
, cur
->sblk_start
)) {
152 *sb
= scb
->lastfound
= cur
;
155 *sb
= scb
->lastfound
=
156 TAILQ_PREV(cur
, sackblock_list
, sblk_list
);
160 cur
= TAILQ_NEXT(cur
, sblk_list
);
161 } while (cur
!= last
);
163 *sb
= scb
->lastfound
= prev
;
168 * Allocate a SACK block.
170 static __inline
struct sackblock
*
171 alloc_sackblock(void)
173 return zalloc(sackblock_zone
);
180 free_sackblock(struct sackblock
*s
)
182 zfree(sackblock_zone
, s
);
186 * Free up SACK blocks for data that's been acked.
189 tcp_sack_ack_blocks(struct scoreboard
*scb
, tcp_seq th_ack
)
191 struct sackblock
*sb
, *nb
;
193 sb
= TAILQ_FIRST(&scb
->sackblocks
);
194 while (sb
&& SEQ_LEQ(sb
->sblk_end
, th_ack
)) {
195 nb
= TAILQ_NEXT(sb
, sblk_list
);
196 if (sb
== scb
->lastfound
)
197 scb
->lastfound
= NULL
;
198 TAILQ_REMOVE(&scb
->sackblocks
, sb
, sblk_list
);
201 KASSERT(scb
->nblocks
>= 0,
202 ("SACK block count underflow: %d < 0", scb
->nblocks
));
205 if (sb
&& SEQ_GT(th_ack
, sb
->sblk_start
))
206 sb
->sblk_start
= th_ack
; /* other side reneged? XXX */
210 * Delete and free SACK blocks saved in scoreboard.
213 tcp_sack_cleanup(struct scoreboard
*scb
)
215 struct sackblock
*sb
, *nb
;
217 TAILQ_FOREACH_MUTABLE(sb
, &scb
->sackblocks
, sblk_list
, nb
) {
221 KASSERT(scb
->nblocks
== 0,
222 ("SACK block %d count not zero", scb
->nblocks
));
223 TAILQ_INIT(&scb
->sackblocks
);
224 scb
->lastfound
= NULL
;
228 * Returns 0 if not D-SACK block,
230 * 2 if duplicate of out-of-order D-SACK block.
233 tcp_sack_ndsack_blocks(struct raw_sackblock
*blocks
, const int numblocks
,
239 if (SEQ_LT(blocks
[0].rblk_start
, snd_una
))
242 /* block 0 inside block 1 */
244 SEQ_GEQ(blocks
[0].rblk_start
, blocks
[1].rblk_start
) &&
245 SEQ_LEQ(blocks
[0].rblk_end
, blocks
[1].rblk_end
))
252 * Update scoreboard on new incoming ACK.
255 tcp_sack_add_blocks(struct tcpcb
*tp
, struct tcpopt
*to
)
257 const int numblocks
= to
->to_nsackblocks
;
258 struct raw_sackblock
*blocks
= to
->to_sackblocks
;
259 struct scoreboard
*scb
= &tp
->scb
;
260 struct sackblock
*sb
;
264 if (tcp_sack_ndsack_blocks(blocks
, numblocks
, tp
->snd_una
) > 0)
269 for (i
= startblock
; i
< numblocks
; i
++) {
270 struct raw_sackblock
*newsackblock
= &blocks
[i
];
272 /* don't accept bad SACK blocks */
273 if (SEQ_GT(newsackblock
->rblk_end
, tp
->snd_max
))
274 break; /* skip all other blocks */
276 sb
= alloc_sackblock();
277 if (sb
== NULL
) /* do some sort of cleanup? XXX */
278 break; /* just skip rest of blocks */
279 sb
->sblk_start
= newsackblock
->rblk_start
;
280 sb
->sblk_end
= newsackblock
->rblk_end
;
281 if (TAILQ_EMPTY(&scb
->sackblocks
)) {
282 KASSERT(scb
->nblocks
== 0, ("emply scb w/ blocks"));
284 TAILQ_INSERT_HEAD(&scb
->sackblocks
, sb
, sblk_list
);
286 insert_block(scb
, sb
);
292 tcp_sack_update_scoreboard(struct tcpcb
*tp
, struct tcpopt
*to
)
294 struct scoreboard
*scb
= &tp
->scb
;
296 tcp_sack_ack_blocks(scb
, tp
->snd_una
);
297 tcp_sack_add_blocks(tp
, to
);
298 update_lostseq(scb
, tp
->snd_una
, tp
->t_maxseg
);
299 if (SEQ_LT(tp
->rexmt_high
, tp
->snd_una
))
300 tp
->rexmt_high
= tp
->snd_una
;
304 * Insert SACK block into sender's scoreboard.
307 insert_block(struct scoreboard
*scb
, struct sackblock
*newblock
)
309 struct sackblock
*sb
, *workingblock
;
310 boolean_t overlap_front
;
312 KASSERT(scb
->nblocks
> 0, ("insert_block() called w/ no blocks"));
314 if (scb
->nblocks
== MAXSAVEDBLOCKS
) {
316 * Should try to kick out older blocks XXX JH
317 * May be able to coalesce with existing block.
318 * Or, go other way and free all blocks if we hit this limit.
320 free_sackblock(newblock
);
323 KASSERT(scb
->nblocks
< MAXSAVEDBLOCKS
,
324 ("too many SACK blocks %d", scb
->nblocks
));
326 overlap_front
= sack_block_lookup(scb
, newblock
->sblk_start
, &sb
);
329 workingblock
= newblock
;
330 TAILQ_INSERT_HEAD(&scb
->sackblocks
, newblock
, sblk_list
);
333 if (overlap_front
|| sb
->sblk_end
== newblock
->sblk_start
) {
334 /* extend old block and discard new one */
336 if (SEQ_GT(newblock
->sblk_end
, sb
->sblk_end
))
337 sb
->sblk_end
= newblock
->sblk_end
;
338 free_sackblock(newblock
);
340 workingblock
= newblock
;
341 TAILQ_INSERT_AFTER(&scb
->sackblocks
, sb
, newblock
,
347 /* Consolidate right-hand side. */
348 sb
= TAILQ_NEXT(workingblock
, sblk_list
);
350 SEQ_GEQ(workingblock
->sblk_end
, sb
->sblk_end
)) {
351 struct sackblock
*nextblock
;
353 nextblock
= TAILQ_NEXT(sb
, sblk_list
);
354 /* Remove completely overlapped block */
355 TAILQ_REMOVE(&scb
->sackblocks
, sb
, sblk_list
);
358 KASSERT(scb
->nblocks
> 0,
359 ("removed overlapped block: %d blocks left", scb
->nblocks
));
363 SEQ_GEQ(workingblock
->sblk_end
, sb
->sblk_start
)) {
364 /* Extend new block to cover partially overlapped old block. */
365 workingblock
->sblk_end
= sb
->sblk_end
;
366 TAILQ_REMOVE(&scb
->sackblocks
, sb
, sblk_list
);
369 KASSERT(scb
->nblocks
> 0,
370 ("removed partial right: %d blocks left", scb
->nblocks
));
374 #ifdef DEBUG_SACK_BLOCKS
376 tcp_sack_dump_blocks(struct scoreboard
*scb
)
378 struct sackblock
*sb
;
380 printf("%d blocks:", scb
->nblocks
);
381 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
)
382 printf(" [%u, %u)", sb
->sblk_start
, sb
->sblk_end
);
387 tcp_sack_dump_blocks(struct scoreboard
*scb
)
393 * Optimization to quickly determine which packets are lost.
396 update_lostseq(struct scoreboard
*scb
, tcp_seq snd_una
, u_int maxseg
)
398 struct sackblock
*sb
;
400 int bytes_sacked
= 0;
402 sb
= TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
405 bytes_sacked
+= sb
->sblk_end
- sb
->sblk_start
;
406 if (nsackblocks
== tcprexmtthresh
||
407 bytes_sacked
>= tcprexmtthresh
* maxseg
) {
408 scb
->lostseq
= sb
->sblk_start
;
411 sb
= TAILQ_PREV(sb
, sackblock_list
, sblk_list
);
413 scb
->lostseq
= snd_una
;
417 * Return whether the given sequence number is considered lost.
420 scb_islost(struct scoreboard
*scb
, tcp_seq seqnum
)
422 return SEQ_LT(seqnum
, scb
->lostseq
);
426 * True if at least "amount" has been SACKed. Used by Early Retransmit.
429 tcp_sack_has_sacked(struct scoreboard
*scb
, u_int amount
)
431 struct sackblock
*sb
;
432 int bytes_sacked
= 0;
434 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
) {
435 bytes_sacked
+= sb
->sblk_end
- sb
->sblk_start
;
436 if (bytes_sacked
>= amount
)
443 * Number of bytes SACKed below seq.
446 tcp_sack_bytes_below(struct scoreboard
*scb
, tcp_seq seq
)
448 struct sackblock
*sb
;
449 int bytes_sacked
= 0;
451 sb
= TAILQ_FIRST(&scb
->sackblocks
);
452 while (sb
&& SEQ_GT(seq
, sb
->sblk_start
)) {
453 bytes_sacked
+= seq_min(seq
, sb
->sblk_end
) - sb
->sblk_start
;
454 sb
= TAILQ_NEXT(sb
, sblk_list
);
460 * Return estimate of the number of bytes outstanding in the network.
463 tcp_sack_compute_pipe(struct tcpcb
*tp
)
465 struct scoreboard
*scb
= &tp
->scb
;
466 struct sackblock
*sb
;
467 int nlost
, nretransmitted
;
470 nlost
= tp
->snd_max
- scb
->lostseq
;
471 nretransmitted
= tp
->rexmt_high
- tp
->snd_una
;
473 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
) {
474 if (SEQ_LT(sb
->sblk_start
, tp
->rexmt_high
)) {
475 end
= seq_min(sb
->sblk_end
, tp
->rexmt_high
);
476 nretransmitted
-= end
- sb
->sblk_start
;
478 if (SEQ_GEQ(sb
->sblk_start
, scb
->lostseq
))
479 nlost
-= sb
->sblk_end
- sb
->sblk_start
;
482 return (nlost
+ nretransmitted
);
486 * Return the sequence number and length of the next segment to transmit
487 * when in Fast Recovery.
490 tcp_sack_nextseg(struct tcpcb
*tp
, tcp_seq
*nextrexmt
, uint32_t *plen
,
493 struct scoreboard
*scb
= &tp
->scb
;
494 struct socket
*so
= tp
->t_inpcb
->inp_socket
;
495 struct sackblock
*sb
;
496 const struct sackblock
*lastblock
=
497 TAILQ_LAST(&scb
->sackblocks
, sackblock_list
);
501 /* skip SACKed data */
502 tcp_sack_skip_sacked(scb
, &tp
->rexmt_high
);
504 /* Look for lost data. */
505 torexmt
= tp
->rexmt_high
;
507 if (lastblock
!= NULL
) {
508 if (SEQ_LT(torexmt
, lastblock
->sblk_end
) &&
509 scb_islost(scb
, torexmt
)) {
511 *nextrexmt
= torexmt
;
512 /* If the left-hand edge has been SACKed, pull it in. */
513 if (sack_block_lookup(scb
, torexmt
+ tp
->t_maxseg
, &sb
))
514 *plen
= sb
->sblk_start
- torexmt
;
516 *plen
= tp
->t_maxseg
;
521 /* See if unsent data available within send window. */
522 off
= tp
->snd_max
- tp
->snd_una
;
523 len
= (long) ulmin(so
->so_snd
.sb_cc
, tp
->snd_wnd
) - off
;
525 *nextrexmt
= tp
->snd_max
; /* Send new data. */
526 *plen
= tp
->t_maxseg
;
530 /* We're less certain this data has been lost. */
531 if (lastblock
== NULL
|| SEQ_LT(torexmt
, lastblock
->sblk_end
))
538 * Return the next sequence number higher than "*prexmt" that has
542 tcp_sack_skip_sacked(struct scoreboard
*scb
, tcp_seq
*prexmt
)
544 struct sackblock
*sb
;
546 /* skip SACKed data */
547 if (sack_block_lookup(scb
, *prexmt
, &sb
))
548 *prexmt
= sb
->sblk_end
;
553 tcp_sack_save_scoreboard(struct scoreboard
*scb
)
555 struct scoreboard
*scb
= &tp
->scb
;
557 scb
->sackblocks_prev
= scb
->sackblocks
;
558 TAILQ_INIT(&scb
->sackblocks
);
562 tcp_sack_revert_scoreboard(struct scoreboard
*scb
, tcp_seq snd_una
,
565 struct sackblock
*sb
;
567 scb
->sackblocks
= scb
->sackblocks_prev
;
569 TAILQ_FOREACH(sb
, &scb
->sackblocks
, sblk_list
)
571 tcp_sack_ack_blocks(scb
, snd_una
);
572 scb
->lastfound
= NULL
;
576 #ifdef DEBUG_SACK_HISTORY
578 tcp_sack_dump_history(char *msg
, struct tcpcb
*tp
)
583 /* only need a couple of these to debug most problems */
587 printf("%s:\tnsackhistory %d: ", msg
, tp
->nsackhistory
);
588 for (i
= 0; i
< tp
->nsackhistory
; ++i
)
589 printf("[%u, %u) ", tp
->sackhistory
[i
].rblk_start
,
590 tp
->sackhistory
[i
].rblk_end
);
595 tcp_sack_dump_history(char *msg
, struct tcpcb
*tp
)
601 * Remove old SACK blocks from the SACK history that have already been ACKed.
604 tcp_sack_ack_history(struct tcpcb
*tp
)
606 int i
, nblocks
, openslot
;
608 tcp_sack_dump_history("before tcp_sack_ack_history", tp
);
609 nblocks
= tp
->nsackhistory
;
610 for (i
= openslot
= 0; i
< nblocks
; ++i
) {
611 if (SEQ_LEQ(tp
->sackhistory
[i
].rblk_end
, tp
->rcv_nxt
)) {
615 if (SEQ_LT(tp
->sackhistory
[i
].rblk_start
, tp
->rcv_nxt
))
616 tp
->sackhistory
[i
].rblk_start
= tp
->rcv_nxt
;
620 tp
->sackhistory
[openslot
++] = tp
->sackhistory
[i
];
622 tcp_sack_dump_history("after tcp_sack_ack_history", tp
);
623 KASSERT(openslot
== tp
->nsackhistory
,
624 ("tcp_sack_ack_history miscounted: %d != %d",
625 openslot
, tp
->nsackhistory
));
629 * Add or merge newblock into reported history.
630 * Also remove or update SACK blocks that will be acked.
633 tcp_sack_update_reported_history(struct tcpcb
*tp
, tcp_seq start
, tcp_seq end
)
635 struct raw_sackblock copy
[MAX_SACK_REPORT_BLOCKS
];
638 tcp_sack_dump_history("before tcp_sack_update_reported_history", tp
);
642 * 1) newblock == oldblock
643 * 2) oldblock contains newblock
644 * 3) newblock contains oldblock
645 * 4) tail of oldblock overlaps or abuts start of newblock
646 * 5) tail of newblock overlaps or abuts head of oldblock
648 for (i
= cindex
= 0; i
< tp
->nsackhistory
; ++i
) {
649 struct raw_sackblock
*oldblock
= &tp
->sackhistory
[i
];
650 tcp_seq old_start
= oldblock
->rblk_start
;
651 tcp_seq old_end
= oldblock
->rblk_end
;
653 if (SEQ_LT(end
, old_start
) || SEQ_GT(start
, old_end
)) {
654 /* Case 0: no overlap. Copy old block. */
655 copy
[cindex
++] = *oldblock
;
659 if (SEQ_GEQ(start
, old_start
) && SEQ_LEQ(end
, old_end
)) {
660 /* Cases 1 & 2. Move block to front of history. */
665 /* no need to check rest of blocks */
666 for (j
= i
+ 1; j
< tp
->nsackhistory
; ++j
)
667 copy
[cindex
++] = tp
->sackhistory
[j
];
671 if (SEQ_GEQ(old_end
, start
) && SEQ_LT(old_start
, start
)) {
672 /* Case 4: extend start of new block. */
674 } else if (SEQ_GEQ(end
, old_start
) && SEQ_GT(old_end
, end
)) {
675 /* Case 5: extend end of new block */
678 /* Case 3. Delete old block by not copying it. */
679 KASSERT(SEQ_LEQ(start
, old_start
) &&
680 SEQ_GEQ(end
, old_end
),
681 ("bad logic: old [%u, %u), new [%u, %u)",
682 old_start
, old_end
, start
, end
));
686 /* insert new block */
687 tp
->sackhistory
[0].rblk_start
= start
;
688 tp
->sackhistory
[0].rblk_end
= end
;
689 cindex
= min(cindex
, MAX_SACK_REPORT_BLOCKS
- 1);
690 for (i
= 0; i
< cindex
; ++i
)
691 tp
->sackhistory
[i
+ 1] = copy
[i
];
692 tp
->nsackhistory
= cindex
+ 1;
693 tcp_sack_dump_history("after tcp_sack_update_reported_history", tp
);
697 * Fill in SACK report to return to data sender.
700 tcp_sack_fill_report(struct tcpcb
*tp
, u_char
*opt
, u_int
*plen
)
702 u_int optlen
= *plen
;
703 uint32_t *lp
= (uint32_t *)(opt
+ optlen
);
705 tcp_seq hstart
= tp
->rcv_nxt
, hend
;
708 KASSERT(TCP_MAXOLEN
- optlen
>=
709 TCPOLEN_SACK_ALIGNED
+ TCPOLEN_SACK_BLOCK
,
710 ("no room for SACK header and one block: optlen %d", optlen
));
713 optlen
+= TCPOLEN_SACK_ALIGNED
;
715 tcp_sack_ack_history(tp
);
716 if (tp
->reportblk
.rblk_start
!= tp
->reportblk
.rblk_end
) {
717 *lp
++ = htonl(tp
->reportblk
.rblk_start
);
718 *lp
++ = htonl(tp
->reportblk
.rblk_end
);
719 optlen
+= TCPOLEN_SACK_BLOCK
;
720 hstart
= tp
->reportblk
.rblk_start
;
721 hend
= tp
->reportblk
.rblk_end
;
722 if (tp
->t_flags
& TF_ENCLOSESEG
) {
723 KASSERT(TCP_MAXOLEN
- optlen
>= TCPOLEN_SACK_BLOCK
,
724 ("no room for enclosing SACK block: oplen %d",
726 *lp
++ = htonl(tp
->encloseblk
.rblk_start
);
727 *lp
++ = htonl(tp
->encloseblk
.rblk_end
);
728 optlen
+= TCPOLEN_SACK_BLOCK
;
729 hstart
= tp
->encloseblk
.rblk_start
;
730 hend
= tp
->encloseblk
.rblk_end
;
732 if (SEQ_GT(hstart
, tp
->rcv_nxt
))
733 tcp_sack_update_reported_history(tp
, hstart
, hend
);
735 if (tcp_do_smartsack
&& (tp
->t_flags
& TF_SACKLEFT
)) {
736 /* Fill in from left! Walk re-assembly queue. */
739 q
= LIST_FIRST(&tp
->t_segq
);
741 TCP_MAXOLEN
- optlen
>= TCPOLEN_SACK_BLOCK
) {
742 *lp
++ = htonl(q
->tqe_th
->th_seq
);
743 *lp
++ = htonl(q
->tqe_th
->th_seq
+ q
->tqe_len
);
744 optlen
+= TCPOLEN_SACK_BLOCK
;
745 q
= LIST_NEXT(q
, tqe_q
);
750 /* Fill in SACK blocks from right side. */
751 while (n
< tp
->nsackhistory
&&
752 TCP_MAXOLEN
- optlen
>= TCPOLEN_SACK_BLOCK
) {
753 if (tp
->sackhistory
[n
].rblk_start
!= hstart
) {
754 *lp
++ = htonl(tp
->sackhistory
[n
].rblk_start
);
755 *lp
++ = htonl(tp
->sackhistory
[n
].rblk_end
);
756 optlen
+= TCPOLEN_SACK_BLOCK
;
761 tp
->reportblk
.rblk_start
= tp
->reportblk
.rblk_end
;
762 tp
->t_flags
&= ~(TF_DUPSEG
| TF_ENCLOSESEG
| TF_SACKLEFT
);
763 nblocks
= (lp
- olp
- 1) / 2;
764 *olp
= htonl(TCPOPT_SACK_ALIGNED
|
765 (TCPOLEN_SACK
+ nblocks
* TCPOLEN_SACK_BLOCK
));