xnu-4903.270.47.tar.gz

[apple/xnu.git] / bsd / netinet / tcp_sack.c

diff --git a/bsd/netinet/tcp_sack.c b/bsd/netinet/tcp_sack.c
index 5d0bf9130056885aa63d7aef0128ea98bbd047b5..a7c8e38d20ad4b3ad928e7568ed291220d5d23af 100644 (file)
--- a/bsd/netinet/tcp_sack.c
+++ b/bsd/netinet/tcp_sack.c
@@ -1,8 +1,8 @@
 /*
 /*

- * Copyright (c) 2004-2015 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2016 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

- * 
+ *

  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in


@@ -11,10 +11,10 @@
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.

- * 
+ *

  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.

- * 
+ *

  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,


@@ -22,7 +22,7 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.

- * 
+ *

  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*


@@ -59,7 +59,7 @@
  *
  */
 
  *
  */
 

-#define        _IP_VHL
+#define _IP_VHL

 
 
 #include <sys/param.h>
 
 
 #include <sys/param.h>


@@ -93,6 +93,7 @@
 #include <netinet/tcp_timer.h>
 #include <netinet/tcp_var.h>
 #include <netinet/tcpip.h>
 #include <netinet/tcp_timer.h>
 #include <netinet/tcp_var.h>
 #include <netinet/tcpip.h>

+#include <netinet/tcp_cache.h>

 #if TCPDEBUG
 #include <netinet/tcp_debug.h>
 #endif
 #if TCPDEBUG
 #include <netinet/tcp_debug.h>
 #endif


@@ -104,17 +105,14 @@
 
 #include <libkern/OSAtomic.h>
 
 
 #include <libkern/OSAtomic.h>
 

-int    tcp_do_sack = 1;
-SYSCTL_INT(_net_inet_tcp, OID_AUTO, sack, CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_do_sack, 0,
-       "Enable/Disable TCP SACK support");
-static int tcp_sack_maxholes = 128;
-SYSCTL_INT(_net_inet_tcp, OID_AUTO, sack_maxholes, CTLFLAG_RW | CTLFLAG_LOCKED,
-       &tcp_sack_maxholes, 0, 
+SYSCTL_SKMEM_TCP_INT(OID_AUTO, sack, CTLFLAG_RW | CTLFLAG_LOCKED,
+    int, tcp_do_sack, 1, "Enable/Disable TCP SACK support");
+SYSCTL_SKMEM_TCP_INT(OID_AUTO, sack_maxholes, CTLFLAG_RW | CTLFLAG_LOCKED,
+    static int, tcp_sack_maxholes, 128,

     "Maximum number of TCP SACK holes allowed per connection");
 
     "Maximum number of TCP SACK holes allowed per connection");
 

-static int tcp_sack_globalmaxholes = 65536;
-SYSCTL_INT(_net_inet_tcp, OID_AUTO, sack_globalmaxholes, CTLFLAG_RW | CTLFLAG_LOCKED,
-       &tcp_sack_globalmaxholes, 0, 
+SYSCTL_SKMEM_TCP_INT(OID_AUTO, sack_globalmaxholes,
+    CTLFLAG_RW | CTLFLAG_LOCKED, static int, tcp_sack_globalmaxholes, 65536,

     "Global maximum number of TCP SACK holes");
 
 static SInt32 tcp_sack_globalholes = 0;
     "Global maximum number of TCP SACK holes");
 
 static SInt32 tcp_sack_globalholes = 0;


@@ -137,7 +135,7 @@ SYSCTL_INT(_net_inet_tcp, OID_AUTO, ignore_hw_duplicates,
 
 extern struct zone *sack_hole_zone;
 
 
 extern struct zone *sack_hole_zone;
 

-#define        TCP_VALIDATE_SACK_SEQ_NUMBERS(_tp_, _sb_, _ack_) \
+#define TCP_VALIDATE_SACK_SEQ_NUMBERS(_tp_, _sb_, _ack_) \

     (SEQ_GT((_sb_)->end, (_sb_)->start) && \
     SEQ_GT((_sb_)->start, (_tp_)->snd_una) && \
     SEQ_GT((_sb_)->start, (_ack_)) && \
     (SEQ_GT((_sb_)->end, (_sb_)->start) && \
     SEQ_GT((_sb_)->start, (_tp_)->snd_una) && \
     SEQ_GT((_sb_)->start, (_ack_)) && \


@@ -179,15 +177,17 @@ tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_start, tcp_seq rcv_end)
                         * Discard this SACK block.
                         */
                } else if (SEQ_LEQ(head_blk.start, end) &&
                         * Discard this SACK block.
                         */
                } else if (SEQ_LEQ(head_blk.start, end) &&

-                          SEQ_GEQ(head_blk.end, start)) {
+                   SEQ_GEQ(head_blk.end, start)) {

                        /*
                         * Merge this SACK block into head_blk.
                         * This SACK block itself will be discarded.
                         */
                        /*
                         * Merge this SACK block into head_blk.
                         * This SACK block itself will be discarded.
                         */

-                       if (SEQ_GT(head_blk.start, start))
+                       if (SEQ_GT(head_blk.start, start)) {

                                head_blk.start = start;
                                head_blk.start = start;

-                       if (SEQ_LT(head_blk.end, end))
+                       }
+                       if (SEQ_LT(head_blk.end, end)) {

                                head_blk.end = end;
                                head_blk.end = end;

+                       }

                } else {
                        /*
                         * Save this SACK block.
                } else {
                        /*
                         * Save this SACK block.


@@ -213,15 +213,16 @@ tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_start, tcp_seq rcv_end)
                 * If the number of saved SACK blocks exceeds its limit,
                 * discard the last SACK block.
                 */
                 * If the number of saved SACK blocks exceeds its limit,
                 * discard the last SACK block.
                 */

-               if (num_saved >= MAX_SACK_BLKS)
+               if (num_saved >= MAX_SACK_BLKS) {

                        num_saved--;
                        num_saved--;

+               }

        }
        if (num_saved > 0) {
                /*
                 * Copy the saved SACK blocks back.
                 */
                bcopy(saved_blks, &tp->sackblks[num_head],
        }
        if (num_saved > 0) {
                /*
                 * Copy the saved SACK blocks back.
                 */
                bcopy(saved_blks, &tp->sackblks[num_head],

-                     sizeof(struct sackblk) * num_saved);
+                   sizeof(struct sackblk) * num_saved);

        }
 
        /* Save the number of SACK blocks. */
        }
 
        /* Save the number of SACK blocks. */


@@ -231,12 +232,14 @@ tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_start, tcp_seq rcv_end)
         * so that connection will generate more acks after recovery and
         * sender's cwnd will open.
         */
         * so that connection will generate more acks after recovery and
         * sender's cwnd will open.
         */

-       if ((tp->t_flags & TF_STRETCHACK) != 0 && tp->rcv_numsacks > 0)
+       if ((tp->t_flags & TF_STRETCHACK) != 0 && tp->rcv_numsacks > 0) {

                tcp_reset_stretch_ack(tp);
                tcp_reset_stretch_ack(tp);

+       }

 
 #if TRAFFIC_MGT
 
 #if TRAFFIC_MGT

-       if (tp->acc_iaj > 0 && tp->rcv_numsacks > 0) 
+       if (tp->acc_iaj > 0 && tp->rcv_numsacks > 0) {

                reset_acc_iaj(tp);
                reset_acc_iaj(tp);

+       }

 #endif /* TRAFFIC_MGT */
 }
 
 #endif /* TRAFFIC_MGT */
 }
 


@@ -246,9 +249,8 @@ tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_start, tcp_seq rcv_end)
 void
 tcp_clean_sackreport( struct tcpcb *tp)
 {
 void
 tcp_clean_sackreport( struct tcpcb *tp)
 {

-

        tp->rcv_numsacks = 0;
        tp->rcv_numsacks = 0;

-       bzero(&tp->sackblks[0], sizeof (struct sackblk) * MAX_SACK_BLKS);
+       bzero(&tp->sackblks[0], sizeof(struct sackblk) * MAX_SACK_BLKS);

 }
 
 /*
 }
 
 /*


@@ -266,8 +268,9 @@ tcp_sackhole_alloc(struct tcpcb *tp, tcp_seq start, tcp_seq end)
        }
 
        hole = (struct sackhole *)zalloc(sack_hole_zone);
        }
 
        hole = (struct sackhole *)zalloc(sack_hole_zone);

-       if (hole == NULL)
+       if (hole == NULL) {

                return NULL;
                return NULL;

+       }

 
        hole->start = start;
        hole->end = end;
 
        hole->start = start;
        hole->end = end;


@@ -296,26 +299,29 @@ tcp_sackhole_free(struct tcpcb *tp, struct sackhole *hole)
  */
 static struct sackhole *
 tcp_sackhole_insert(struct tcpcb *tp, tcp_seq start, tcp_seq end,
  */
 static struct sackhole *
 tcp_sackhole_insert(struct tcpcb *tp, tcp_seq start, tcp_seq end,

-                   struct sackhole *after)
+    struct sackhole *after)

 {
        struct sackhole *hole;
 
        /* Allocate a new SACK hole. */
        hole = tcp_sackhole_alloc(tp, start, end);
 {
        struct sackhole *hole;
 
        /* Allocate a new SACK hole. */
        hole = tcp_sackhole_alloc(tp, start, end);

-       if (hole == NULL)
+       if (hole == NULL) {

                return NULL;
                return NULL;

+       }

        hole->rxmit_start = tcp_now;
        /* Insert the new SACK hole into scoreboard */
        hole->rxmit_start = tcp_now;
        /* Insert the new SACK hole into scoreboard */

-       if (after != NULL)
+       if (after != NULL) {

                TAILQ_INSERT_AFTER(&tp->snd_holes, after, hole, scblink);
                TAILQ_INSERT_AFTER(&tp->snd_holes, after, hole, scblink);

-       else
+       } else {

                TAILQ_INSERT_TAIL(&tp->snd_holes, hole, scblink);
                TAILQ_INSERT_TAIL(&tp->snd_holes, hole, scblink);

+       }

 
        /* Update SACK hint. */
 
        /* Update SACK hint. */

-       if (tp->sackhint.nexthole == NULL)
+       if (tp->sackhint.nexthole == NULL) {

                tp->sackhint.nexthole = hole;
                tp->sackhint.nexthole = hole;

+       }

 
 

-       return(hole);
+       return hole;

 }
 
 /*
 }
 
 /*


@@ -325,8 +331,9 @@ static void
 tcp_sackhole_remove(struct tcpcb *tp, struct sackhole *hole)
 {
        /* Update SACK hint. */
 tcp_sackhole_remove(struct tcpcb *tp, struct sackhole *hole)
 {
        /* Update SACK hint. */

-       if (tp->sackhint.nexthole == hole)
+       if (tp->sackhint.nexthole == hole) {

                tp->sackhint.nexthole = TAILQ_NEXT(hole, scblink);
                tp->sackhint.nexthole = TAILQ_NEXT(hole, scblink);

+       }

 
        /* Remove this SACK hole. */
        TAILQ_REMOVE(&tp->snd_holes, hole, scblink);
 
        /* Remove this SACK hole. */
        TAILQ_REMOVE(&tp->snd_holes, hole, scblink);


@@ -350,15 +357,17 @@ tcp_sack_detect_reordering(struct tcpcb *tp, struct sackhole *s,
         * If the SACK hole is past snd_fack, this is from new SACK
         * information, so we can ignore it.
         */
         * If the SACK hole is past snd_fack, this is from new SACK
         * information, so we can ignore it.
         */

-       if (SEQ_GT(s->end, snd_fack))
+       if (SEQ_GT(s->end, snd_fack)) {

                return;
                return;

+       }

        /*
        /*

-        * If there has been a retransmit timeout, then the timestamp on 
+        * If there has been a retransmit timeout, then the timestamp on

         * the SACK segment will be newer. This might lead to a
         * false-positive. Avoid re-ordering detection in this case.
         */
         * the SACK segment will be newer. This might lead to a
         * false-positive. Avoid re-ordering detection in this case.
         */

-       if (tp->t_rxtshift > 0)
+       if (tp->t_rxtshift > 0) {

                return;
                return;

+       }

 
        /*
         * Detect reordering from SACK information by checking
 
        /*
         * Detect reordering from SACK information by checking


@@ -379,12 +388,23 @@ tcp_sack_detect_reordering(struct tcpcb *tp, struct sackhole *s,
                tcpstat.tcps_reordered_pkts++;
                tp->t_reordered_pkts++;
 
                tcpstat.tcps_reordered_pkts++;
                tp->t_reordered_pkts++;
 

+               /*
+                * If reordering is seen on a connection wth ECN enabled,
+                * increment the heuristic
+                */
+               if (TCP_ECN_ENABLED(tp)) {
+                       INP_INC_IFNET_STAT(tp->t_inpcb, ecn_fallback_reorder);
+                       tcpstat.tcps_ecn_fallback_reorder++;
+                       tcp_heuristic_ecn_aggressive(tp);
+               }
+

                VERIFY(SEQ_GEQ(snd_fack, s->rxmit));
 
                if (s->rxmit_start > 0) {
                        rext = timer_diff(tcp_now, 0, s->rxmit_start, 0);
                VERIFY(SEQ_GEQ(snd_fack, s->rxmit));
 
                if (s->rxmit_start > 0) {
                        rext = timer_diff(tcp_now, 0, s->rxmit_start, 0);

-                       if (rext < 0)
+                       if (rext < 0) {

                                return;
                                return;

+                       }

 
                        /*
                         * We take the maximum reorder window to schedule
 
                        /*
                         * We take the maximum reorder window to schedule


@@ -412,8 +432,8 @@ tcp_sack_detect_reordering(struct tcpcb *tp, struct sackhole *s,
  * the sequence space).
  */
 void
  * the sequence space).
  */
 void

-tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th, 
-       u_int32_t *newbytes_acked)
+tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
+    u_int32_t *newbytes_acked)

 {
        struct sackhole *cur, *temp;
        struct sackblk sack, sack_blocks[TCP_MAX_SACK + 1], *sblkp;
 {
        struct sackhole *cur, *temp;
        struct sackblk sack, sack_blocks[TCP_MAX_SACK + 1], *sblkp;


@@ -438,16 +458,18 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
                    &sack, sizeof(sack));
                sack.start = ntohl(sack.start);
                sack.end = ntohl(sack.end);
                    &sack, sizeof(sack));
                sack.start = ntohl(sack.start);
                sack.end = ntohl(sack.end);

-               if (TCP_VALIDATE_SACK_SEQ_NUMBERS(tp, &sack, th_ack))
+               if (TCP_VALIDATE_SACK_SEQ_NUMBERS(tp, &sack, th_ack)) {

                        sack_blocks[num_sack_blks++] = sack;
                        sack_blocks[num_sack_blks++] = sack;

+               }

        }
 
        /*
         * Return if SND.UNA is not advanced and no valid SACK block
         * is received.
         */
        }
 
        /*
         * Return if SND.UNA is not advanced and no valid SACK block
         * is received.
         */

-       if (num_sack_blks == 0)
+       if (num_sack_blks == 0) {

                return;
                return;

+       }

 
        VERIFY(num_sack_blks <= (TCP_MAX_SACK + 1));
        /*
 
        VERIFY(num_sack_blks <= (TCP_MAX_SACK + 1));
        /*


@@ -487,7 +509,7 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
         * the highest three or four SACK blocks with ack number advancing
         * are received.
         */
         * the highest three or four SACK blocks with ack number advancing
         * are received.
         */

-       sblkp = &sack_blocks[num_sack_blks - 1];        /* Last SACK block */
+       sblkp = &sack_blocks[num_sack_blks - 1];        /* Last SACK block */

        if (SEQ_LT(tp->snd_fack, sblkp->start)) {
                /*
                 * The highest SACK block is beyond fack.
        if (SEQ_LT(tp->snd_fack, sblkp->start)) {
                /*
                 * The highest SACK block is beyond fack.


@@ -496,7 +518,7 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
                 * beyond the current fack, they will be inserted by
                 * way of hole splitting in the while-loop below.
                 */
                 * beyond the current fack, they will be inserted by
                 * way of hole splitting in the while-loop below.
                 */

-               temp = tcp_sackhole_insert(tp, tp->snd_fack,sblkp->start,NULL);
+               temp = tcp_sackhole_insert(tp, tp->snd_fack, sblkp->start, NULL);

                if (temp != NULL) {
                        tp->snd_fack = sblkp->end;
                        *newbytes_acked += (sblkp->end - sblkp->start);
                if (temp != NULL) {
                        tp->snd_fack = sblkp->end;
                        *newbytes_acked += (sblkp->end - sblkp->start);


@@ -504,18 +526,19 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
                        /* Go to the previous sack block. */
                        sblkp--;
                } else {
                        /* Go to the previous sack block. */
                        sblkp--;
                } else {

-                       /* 
-                        * We failed to add a new hole based on the current 
-                        * sack block.  Skip over all the sack blocks that 
+                       /*
+                        * We failed to add a new hole based on the current
+                        * sack block.  Skip over all the sack blocks that

                         * fall completely to the right of snd_fack and proceed
                         * to trim the scoreboard based on the remaining sack
                         * fall completely to the right of snd_fack and proceed
                         * to trim the scoreboard based on the remaining sack

-                        * blocks. This also trims the scoreboard for th_ack 
+                        * blocks. This also trims the scoreboard for th_ack

                         * (which is sack_blocks[0]).
                         */
                         * (which is sack_blocks[0]).
                         */

-                       while (sblkp >= sack_blocks && 
-                              SEQ_LT(tp->snd_fack, sblkp->start))
+                       while (sblkp >= sack_blocks &&
+                           SEQ_LT(tp->snd_fack, sblkp->start)) {

                                sblkp--;
                                sblkp--;

-                       if (sblkp >= sack_blocks && 
+                       }
+                       if (sblkp >= sack_blocks &&

                            SEQ_LT(tp->snd_fack, sblkp->end)) {
                                *newbytes_acked += (sblkp->end - tp->snd_fack);
                                tp->snd_fack = sblkp->end;
                            SEQ_LT(tp->snd_fack, sblkp->end)) {
                                *newbytes_acked += (sblkp->end - tp->snd_fack);
                                tp->snd_fack = sblkp->end;


@@ -532,7 +555,7 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
         * Since the incoming sack blocks are sorted, we can process them
         * making one sweep of the scoreboard.
         */
         * Since the incoming sack blocks are sorted, we can process them
         * making one sweep of the scoreboard.
         */

-       while (sblkp >= sack_blocks  && cur != NULL) {
+       while (sblkp >= sack_blocks && cur != NULL) {

                if (SEQ_GEQ(sblkp->start, cur->end)) {
                        /*
                         * SACKs data beyond the current hole.
                if (SEQ_GEQ(sblkp->start, cur->end)) {
                        /*
                         * SACKs data beyond the current hole.


@@ -597,12 +620,12 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
                                        if (SEQ_GT(cur->rxmit, temp->rxmit)) {
                                                temp->rxmit = cur->rxmit;
                                                tp->sackhint.sack_bytes_rexmit
                                        if (SEQ_GT(cur->rxmit, temp->rxmit)) {
                                                temp->rxmit = cur->rxmit;
                                                tp->sackhint.sack_bytes_rexmit

-                                                       += (temp->rxmit
-                                                           - temp->start);
+                                                       += (temp->rxmit
+                                                   - temp->start);

                                        }
                                        cur->end = sblkp->start;
                                        cur->rxmit = SEQ_MIN(cur->rxmit,
                                        }
                                        cur->end = sblkp->start;
                                        cur->rxmit = SEQ_MIN(cur->rxmit,

-                                                            cur->end);
+                                           cur->end);

                                        /*
                                         * Reset the rxmit_start to that of
                                         * the current hole as that will
                                        /*
                                         * Reset the rxmit_start to that of
                                         * the current hole as that will


@@ -619,10 +642,11 @@ tcp_sack_doack(struct tcpcb *tp, struct tcpopt *to, struct tcphdr *th,
                 * we're done with the sack block or the sack hole.
                 * Accordingly, we advance one or the other.
                 */
                 * we're done with the sack block or the sack hole.
                 * Accordingly, we advance one or the other.
                 */

-               if (SEQ_LEQ(sblkp->start, cur->start))
+               if (SEQ_LEQ(sblkp->start, cur->start)) {

                        cur = TAILQ_PREV(cur, sackhole_head, scblink);
                        cur = TAILQ_PREV(cur, sackhole_head, scblink);

-               else
+               } else {

                        sblkp--;
                        sblkp--;

+               }

        }
 }
 
        }
 }
 


@@ -634,41 +658,41 @@ tcp_free_sackholes(struct tcpcb *tp)
 {
        struct sackhole *q;
 
 {
        struct sackhole *q;
 

-       while ((q = TAILQ_FIRST(&tp->snd_holes)) != NULL)
+       while ((q = TAILQ_FIRST(&tp->snd_holes)) != NULL) {

                tcp_sackhole_remove(tp, q);
                tcp_sackhole_remove(tp, q);

+       }

        tp->sackhint.sack_bytes_rexmit = 0;
        tp->sackhint.nexthole = NULL;
        tp->sack_newdata = 0;
        tp->sackhint.sack_bytes_rexmit = 0;
        tp->sackhint.nexthole = NULL;
        tp->sack_newdata = 0;

-

 }
 
 /*
 }
 
 /*

- * Partial ack handling within a sack recovery episode. 
+ * Partial ack handling within a sack recovery episode.

  * Keeping this very simple for now. When a partial ack
  * is received, force snd_cwnd to a value that will allow
  * the sender to transmit no more than 2 segments.
  * Keeping this very simple for now. When a partial ack
  * is received, force snd_cwnd to a value that will allow
  * the sender to transmit no more than 2 segments.

- * If necessary, a better scheme can be adopted at a 
+ * If necessary, a better scheme can be adopted at a

  * later point, but for now, the goal is to prevent the
  * sender from bursting a large amount of data in the midst
  * of sack recovery.
  */
 void
  * later point, but for now, the goal is to prevent the
  * sender from bursting a large amount of data in the midst
  * of sack recovery.
  */
 void

-tcp_sack_partialack(tp, th)
-       struct tcpcb *tp;
-       struct tcphdr *th;
+tcp_sack_partialack(struct tcpcb *tp, struct tcphdr *th)

 {
        int num_segs = 1;
 
        tp->t_timer[TCPT_REXMT] = 0;
        tp->t_rtttime = 0;
        /* send one or 2 segments based on how much new data was acked */
 {
        int num_segs = 1;
 
        tp->t_timer[TCPT_REXMT] = 0;
        tp->t_rtttime = 0;
        /* send one or 2 segments based on how much new data was acked */

-       if (((BYTES_ACKED(th, tp)) / tp->t_maxseg) > 2)
+       if (((BYTES_ACKED(th, tp)) / tp->t_maxseg) > 2) {

                num_segs = 2;
                num_segs = 2;

+       }

        tp->snd_cwnd = (tp->sackhint.sack_bytes_rexmit +
        tp->snd_cwnd = (tp->sackhint.sack_bytes_rexmit +

-               (tp->snd_nxt - tp->sack_newdata) +
-               num_segs * tp->t_maxseg);
-       if (tp->snd_cwnd > tp->snd_ssthresh)
+           (tp->snd_nxt - tp->sack_newdata) +
+           num_segs * tp->t_maxseg);
+       if (tp->snd_cwnd > tp->snd_ssthresh) {

                tp->snd_cwnd = tp->snd_ssthresh;
                tp->snd_cwnd = tp->snd_ssthresh;

+       }

        if (SEQ_LT(tp->snd_fack, tp->snd_recover) &&
            tp->snd_fack == th->th_ack && TAILQ_EMPTY(&tp->snd_holes)) {
                struct sackhole *temp;
        if (SEQ_LT(tp->snd_fack, tp->snd_recover) &&
            tp->snd_fack == th->th_ack && TAILQ_EMPTY(&tp->snd_holes)) {
                struct sackhole *temp;


@@ -680,8 +704,9 @@ tcp_sack_partialack(tp, th)
                 */
                temp = tcp_sackhole_insert(tp, tp->snd_fack,
                    tp->snd_recover, NULL);
                 */
                temp = tcp_sackhole_insert(tp, tp->snd_fack,
                    tp->snd_recover, NULL);

-               if (temp != NULL)
+               if (temp != NULL) {

                        tp->snd_fack = tp->snd_recover;
                        tp->snd_fack = tp->snd_recover;

+               }

        }
        (void) tcp_output(tp);
 }
        }
        (void) tcp_output(tp);
 }


@@ -706,7 +731,7 @@ tcp_sack_output_debug(struct tcpcb *tp, int *sack_bytes_rexmt)
                }
                *sack_bytes_rexmt += (p->rxmit - p->start);
        }
                }
                *sack_bytes_rexmt += (p->rxmit - p->start);
        }

-       return (p);
+       return p;

 }
 
 /*
 }
 
 /*


@@ -735,8 +760,9 @@ tcp_sack_output(struct tcpcb *tp, int *sack_bytes_rexmt)
        dbg_hole = tcp_sack_output_debug(tp, &dbg_bytes_rexmt);
        *sack_bytes_rexmt = tp->sackhint.sack_bytes_rexmit;
        hole = tp->sackhint.nexthole;
        dbg_hole = tcp_sack_output_debug(tp, &dbg_bytes_rexmt);
        *sack_bytes_rexmt = tp->sackhint.sack_bytes_rexmit;
        hole = tp->sackhint.nexthole;

-       if (hole == NULL || SEQ_LT(hole->rxmit, hole->end))
+       if (hole == NULL || SEQ_LT(hole->rxmit, hole->end)) {

                goto out;
                goto out;

+       }

        while ((hole = TAILQ_NEXT(hole, scblink)) != NULL) {
                if (SEQ_LT(hole->rxmit, hole->end)) {
                        tp->sackhint.nexthole = hole;
        while ((hole = TAILQ_NEXT(hole, scblink)) != NULL) {
                if (SEQ_LT(hole->rxmit, hole->end)) {
                        tp->sackhint.nexthole = hole;


@@ -750,11 +776,11 @@ out:
        }
        if (*sack_bytes_rexmt != dbg_bytes_rexmt) {
                printf("%s: Computed sack_bytes_retransmitted (%d) not "
        }
        if (*sack_bytes_rexmt != dbg_bytes_rexmt) {
                printf("%s: Computed sack_bytes_retransmitted (%d) not "

-                      "the same as cached value (%d)\n",
-                      __func__, dbg_bytes_rexmt, *sack_bytes_rexmt);
+                   "the same as cached value (%d)\n",
+                   __func__, dbg_bytes_rexmt, *sack_bytes_rexmt);

                *sack_bytes_rexmt = dbg_bytes_rexmt;
        }
                *sack_bytes_rexmt = dbg_bytes_rexmt;
        }

-       return (hole);
+       return hole;

 }
 
 /*
 }
 
 /*


@@ -767,34 +793,38 @@ tcp_sack_adjust(struct tcpcb *tp)
 {
        struct sackhole *p, *cur = TAILQ_FIRST(&tp->snd_holes);
 
 {
        struct sackhole *p, *cur = TAILQ_FIRST(&tp->snd_holes);
 

-       if (cur == NULL)
+       if (cur == NULL) {

                return; /* No holes */
                return; /* No holes */

-       if (SEQ_GEQ(tp->snd_nxt, tp->snd_fack))
+       }
+       if (SEQ_GEQ(tp->snd_nxt, tp->snd_fack)) {

                return; /* We're already beyond any SACKed blocks */
                return; /* We're already beyond any SACKed blocks */

+       }

        /*
         * Two cases for which we want to advance snd_nxt:
         * i) snd_nxt lies between end of one hole and beginning of another
         * ii) snd_nxt lies between end of last hole and snd_fack
         */
        while ((p = TAILQ_NEXT(cur, scblink)) != NULL) {
        /*
         * Two cases for which we want to advance snd_nxt:
         * i) snd_nxt lies between end of one hole and beginning of another
         * ii) snd_nxt lies between end of last hole and snd_fack
         */
        while ((p = TAILQ_NEXT(cur, scblink)) != NULL) {

-               if (SEQ_LT(tp->snd_nxt, cur->end))
+               if (SEQ_LT(tp->snd_nxt, cur->end)) {

                        return;
                        return;

-               if (SEQ_GEQ(tp->snd_nxt, p->start))
+               }
+               if (SEQ_GEQ(tp->snd_nxt, p->start)) {

                        cur = p;
                        cur = p;

-               else {
+               } else {

                        tp->snd_nxt = p->start;
                        return;
                }
        }
                        tp->snd_nxt = p->start;
                        return;
                }
        }

-       if (SEQ_LT(tp->snd_nxt, cur->end))
+       if (SEQ_LT(tp->snd_nxt, cur->end)) {

                return;
                return;

+       }

        tp->snd_nxt = tp->snd_fack;
        return;
 }
 
 /*
  * This function returns TRUE if more than (tcprexmtthresh - 1) * SMSS
        tp->snd_nxt = tp->snd_fack;
        return;
 }
 
 /*
  * This function returns TRUE if more than (tcprexmtthresh - 1) * SMSS

- * bytes with sequence numbers greater than snd_una have been SACKed. 
+ * bytes with sequence numbers greater than snd_una have been SACKed.

  */
 boolean_t
 tcp_sack_byte_islost(struct tcpcb *tp)
  */
 boolean_t
 tcp_sack_byte_islost(struct tcpcb *tp)


@@ -803,8 +833,9 @@ tcp_sack_byte_islost(struct tcpcb *tp)
        struct sackhole *sndhole;
        if (!SACK_ENABLED(tp) || IN_FASTRECOVERY(tp) ||
            TAILQ_EMPTY(&tp->snd_holes) ||
        struct sackhole *sndhole;
        if (!SACK_ENABLED(tp) || IN_FASTRECOVERY(tp) ||
            TAILQ_EMPTY(&tp->snd_holes) ||

-           (tp->t_flagsext & TF_PKTS_REORDERED))
-               return (FALSE);
+           (tp->t_flagsext & TF_PKTS_REORDERED)) {
+               return FALSE;
+       }

 
        unacked_bytes = tp->snd_max - tp->snd_una;
 
 
        unacked_bytes = tp->snd_max - tp->snd_una;
 


@@ -813,8 +844,8 @@ tcp_sack_byte_islost(struct tcpcb *tp)
        }
 
        VERIFY(unacked_bytes >= sndhole_bytes);
        }
 
        VERIFY(unacked_bytes >= sndhole_bytes);

-       return ((unacked_bytes - sndhole_bytes) >
-           ((tcprexmtthresh - 1) * tp->t_maxseg));
+       return (unacked_bytes - sndhole_bytes) >
+              ((tcprexmtthresh - 1) * tp->t_maxseg);

 }
 
 /*
 }
 
 /*


@@ -861,7 +892,7 @@ tcp_sack_process_dsack(struct tcpcb *tp, struct tcpopt *to,
                         * returning true here so that the ack will not be
                         * treated as duplicate ack.
                         */
                         * returning true here so that the ack will not be
                         * treated as duplicate ack.
                         */

-                       return (TRUE);
+                       return TRUE;

                }
        } else if (to->to_nsacks > 1 &&
            SEQ_LEQ(second_sack.start, first_sack.start) &&
                }
        } else if (to->to_nsacks > 1 &&
            SEQ_LEQ(second_sack.start, first_sack.start) &&


@@ -880,11 +911,11 @@ tcp_sack_process_dsack(struct tcpcb *tp, struct tcpopt *to,
                        to->to_nsacks--;
                        to->to_sacks += TCPOLEN_SACK;
                        tcpstat.tcps_dsack_recvd_old++;
                        to->to_nsacks--;
                        to->to_sacks += TCPOLEN_SACK;
                        tcpstat.tcps_dsack_recvd_old++;

-                       return (TRUE);
+                       return TRUE;

                }
        } else {
                /* no dsack options, proceed with processing the sack */
                }
        } else {
                /* no dsack options, proceed with processing the sack */

-               return (FALSE);
+               return FALSE;

        }
 
        /* Update the tcpopt pointer to exclude dsack block */
        }
 
        /* Update the tcpopt pointer to exclude dsack block */


@@ -894,15 +925,17 @@ tcp_sack_process_dsack(struct tcpcb *tp, struct tcpopt *to,
        tp->t_dsack_recvd++;
 
        /* ignore DSACK option, if DSACK is disabled */
        tp->t_dsack_recvd++;
 
        /* ignore DSACK option, if DSACK is disabled */

-       if (tp->t_flagsext & TF_DISABLE_DSACK)
-               return (TRUE);
+       if (tp->t_flagsext & TF_DISABLE_DSACK) {
+               return TRUE;
+       }

 
        /* If the DSACK is for TLP mark it as such */
        if ((tp->t_flagsext & TF_SENT_TLPROBE) &&
            first_sack.end == tp->t_tlphighrxt) {
                if ((rxseg = tcp_rxtseg_find(tp, first_sack.start,
 
        /* If the DSACK is for TLP mark it as such */
        if ((tp->t_flagsext & TF_SENT_TLPROBE) &&
            first_sack.end == tp->t_tlphighrxt) {
                if ((rxseg = tcp_rxtseg_find(tp, first_sack.start,

-                   (first_sack.end - 1))) != NULL)
+                   (first_sack.end - 1))) != NULL) {

                        rxseg->rx_flags |= TCP_RXT_DSACK_FOR_TLP;
                        rxseg->rx_flags |= TCP_RXT_DSACK_FOR_TLP;

+               }

        }
        /* Update the sender's retransmit segment state */
        if (((tp->t_rxtshift == 1 && first_sack.start == tp->snd_una) ||
        }
        /* Update the sender's retransmit segment state */
        if (((tp->t_rxtshift == 1 && first_sack.start == tp->snd_una) ||


@@ -921,7 +954,7 @@ tcp_sack_process_dsack(struct tcpcb *tp, struct tcpopt *to,
                 */
                tcpstat.tcps_dsack_ackloss++;
 
                 */
                tcpstat.tcps_dsack_ackloss++;
 

-               return (TRUE);
+               return TRUE;

        } else if ((rxseg = tcp_rxtseg_find(tp, first_sack.start,
            (first_sack.end - 1))) == NULL) {
                /*
        } else if ((rxseg = tcp_rxtseg_find(tp, first_sack.start,
            (first_sack.end - 1))) == NULL) {
                /*


@@ -938,10 +971,11 @@ tcp_sack_process_dsack(struct tcpcb *tp, struct tcpopt *to,
                 * If the segment was retransmitted only once, mark it as
                 * spurious. Otherwise ignore the duplicate notification.
                 */
                 * If the segment was retransmitted only once, mark it as
                 * spurious. Otherwise ignore the duplicate notification.
                 */

-               if (rxseg->rx_count == 1)
+               if (rxseg->rx_count == 1) {

                        rxseg->rx_flags |= TCP_RXT_SPURIOUS;
                        rxseg->rx_flags |= TCP_RXT_SPURIOUS;

-               else
+               } else {

                        rxseg->rx_flags &= ~TCP_RXT_SPURIOUS;
                        rxseg->rx_flags &= ~TCP_RXT_SPURIOUS;

+               }

        }
        }

-       return (TRUE);
+       return TRUE;

 }
 }