SACK has been enabled in GENERIC kernels for over a decade and it's
time to make it an official part of the TCP stack.  This grows bsd.rd
on amd64 by 8k but Theo said it's within reasonable.  OK?

diff --git sys/conf/GENERIC sys/conf/GENERIC
index 87dd069f514..cd68ae9e651 100644
--- sys/conf/GENERIC
+++ sys/conf/GENERIC
@@ -43,11 +43,10 @@ option              MSDOSFS         # MS-DOS file system
 option         FIFO            # FIFOs; RECOMMENDED
 #option                TMPFS           # efficient memory file system
 option         FUSE            # FUSE
 
 option         SOCKET_SPLICE   # Socket Splicing for TCP and UDP
-option         TCP_SACK        # Selective Acknowledgements for TCP
 option         TCP_ECN         # Explicit Congestion Notification for TCP
 option         TCP_SIGNATURE   # TCP MD5 Signatures, for BGP routing sessions
 #option                TCP_FACK        # Forward Acknowledgements for TCP
 
 option         INET6           # IPv6
diff --git sys/netinet/tcp_input.c sys/netinet/tcp_input.c
index 52c206f0bf5..9951923bbdb 100644
--- sys/netinet/tcp_input.c
+++ sys/netinet/tcp_input.c
@@ -852,14 +852,12 @@ findpcb:
         */
        tp->t_rcvtime = tcp_now;
        if (TCPS_HAVEESTABLISHED(tp->t_state))
                TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);
 
-#ifdef TCP_SACK
        if (tp->sack_enable)
                tcp_del_sackholes(tp, th); /* Delete stale SACK holes */
-#endif /* TCP_SACK */
 
        /*
         * Process options.
         */
 #ifdef TCP_SIGNATURE
@@ -962,25 +960,23 @@ findpcb:
                                 */
                                if (tp->t_pmtud_mss_acked < acked)
                                        tp->t_pmtud_mss_acked = acked;
 
                                tp->snd_una = th->th_ack;
-#if defined(TCP_SACK) || defined(TCP_ECN)
                                /*
                                 * We want snd_last to track snd_una so
                                 * as to avoid sequence wraparound problems
                                 * for very large transfers.
                                 */
 #ifdef TCP_ECN
                                if (SEQ_GT(tp->snd_una, tp->snd_last))
 #endif
                                tp->snd_last = tp->snd_una;
-#endif /* TCP_SACK */
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                tp->snd_fack = tp->snd_una;
                                tp->retran_data = 0;
-#endif /* TCP_FACK */
+#endif
                                m_freem(m);
 
                                /*
                                 * If all outstanding data are acked, stop
                                 * retransmit timer, otherwise restart timer
@@ -1012,15 +1008,13 @@ findpcb:
                        /*
                         * This is a pure, in-sequence data packet
                         * with nothing on the reassembly queue and
                         * we have enough buffer space to take it.
                         */
-#ifdef TCP_SACK
                        /* Clean receiver SACK report if present */
                        if (tp->sack_enable && tp->rcv_numsacks)
                                tcp_clean_sackreport(tp);
-#endif /* TCP_SACK */
                        tcpstat_inc(tcps_preddat);
                        tp->rcv_nxt += tlen;
                        tcpstat_pkt(tcps_rcvpack, tcps_rcvbyte, tlen);
                        ND6_HINT(tp);
 
@@ -1137,19 +1131,17 @@ findpcb:
                /* Reset initial window to 1 segment for retransmit */
                if (tp->t_rxtshift > 0)
                        tp->snd_cwnd = tp->t_maxseg;
                tcp_rcvseqinit(tp);
                tp->t_flags |= TF_ACKNOW;
-#ifdef TCP_SACK
                 /*
                  * If we've sent a SACK_PERMITTED option, and the peer
                  * also replied with one, then TF_SACK_PERMIT should have
                  * been set in tcp_dooptions().  If it was not, disable SACKs.
                  */
                if (tp->sack_enable)
                        tp->sack_enable = tp->t_flags & TF_SACK_PERMIT;
-#endif
 #ifdef TCP_ECN
                /*
                 * if ECE is set but CWR is not set for SYN-ACK, or
                 * both ECE and CWR are set for simultaneous open,
                 * peer is ECN capable.
@@ -1569,11 +1561,11 @@ trimthenstep6:
                                 * to keep a constant cwnd packets in the
                                 * network.
                                 */
                                if (TCP_TIMER_ISARMED(tp, TCPT_REXMT) == 0)
                                        tp->t_dupacks = 0;
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                /*
                                 * In FACK, can enter fast rec. if the receiver
                                 * reports a reass. queue longer than 3 segs.
                                 */
                                else if (++tp->t_dupacks == tcprexmtthresh ||
@@ -1586,34 +1578,31 @@ trimthenstep6:
                                        tcp_seq onxt = tp->snd_nxt;
                                        u_long win =
                                            ulmin(tp->snd_wnd, tp->snd_cwnd) /
                                                2 / tp->t_maxseg;
 
-#if defined(TCP_SACK) || defined(TCP_ECN)
                                        if (SEQ_LT(th->th_ack, tp->snd_last)){
                                                /*
                                                 * False fast retx after
                                                 * timeout.  Do not cut window.
                                                 */
                                                tp->t_dupacks = 0;
                                                goto drop;
                                        }
-#endif
                                        if (win < 2)
                                                win = 2;
                                        tp->snd_ssthresh = win * tp->t_maxseg;
-#ifdef TCP_SACK
                                        tp->snd_last = tp->snd_max;
                                        if (tp->sack_enable) {
                                                TCP_TIMER_DISARM(tp, 
TCPT_REXMT);
                                                tp->t_rtttime = 0;
 #ifdef TCP_ECN
                                                tp->t_flags |= TF_SEND_CWR;
 #endif
                                                tcpstat_inc(tcps_cwr_frecovery);
                                                
tcpstat_inc(tcps_sack_recovery_episode);
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                                tp->t_dupacks = tcprexmtthresh;
                                                (void) tcp_output(tp);
                                                /*
                                                 * During FR, snd_cwnd is held
                                                 * constant for FACK.
@@ -1628,11 +1617,10 @@ trimthenstep6:
                                                tp->snd_cwnd = tp->snd_ssthresh+
                                                   tp->t_maxseg * tp->t_dupacks;
 #endif /* TCP_FACK */
                                                goto drop;
                                        }
-#endif /* TCP_SACK */
                                        TCP_TIMER_DISARM(tp, TCPT_REXMT);
                                        tp->t_rtttime = 0;
                                        tp->snd_nxt = th->th_ack;
                                        tp->snd_cwnd = tp->t_maxseg;
 #ifdef TCP_ECN
@@ -1646,11 +1634,11 @@ trimthenstep6:
                                            tp->t_maxseg * tp->t_dupacks;
                                        if (SEQ_GT(onxt, tp->snd_nxt))
                                                tp->snd_nxt = onxt;
                                        goto drop;
                                } else if (tp->t_dupacks > tcprexmtthresh) {
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                        /*
                                         * while (awnd < cwnd)
                                         *         sendsomething();
                                         */
                                        if (tp->sack_enable) {
@@ -1676,16 +1664,15 @@ trimthenstep6:
                }
                /*
                 * If the congestion window was inflated to account
                 * for the other side's cached packets, retract it.
                 */
-#if defined(TCP_SACK)
                if (tp->sack_enable) {
                        if (tp->t_dupacks >= tcprexmtthresh) {
                                /* Check for a partial ACK */
                                if (tcp_sack_partialack(tp, th)) {
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                        /* Force call to tcp_output */
                                        if (tp->snd_awnd < tp->snd_cwnd)
                                                tp->t_flags |= TF_NEEDOUTPUT;
 #else
                                        tp->snd_cwnd += tp->t_maxseg;
@@ -1698,14 +1685,14 @@ trimthenstep6:
                                            th->th_ack) < tp->snd_ssthresh)
                                                tp->snd_cwnd =
                                                   tcp_seq_subtract(tp->snd_max,
                                                   th->th_ack);
                                        tp->t_dupacks = 0;
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                        if (SEQ_GT(th->th_ack, tp->snd_fack))
                                                tp->snd_fack = th->th_ack;
-#endif /* TCP_FACK */
+#endif
                                }
                        }
                } else {
                        if (tp->t_dupacks >= tcprexmtthresh &&
                            !tcp_newreno(tp, th)) {
@@ -1719,16 +1706,10 @@ trimthenstep6:
                                tp->t_dupacks = 0;
                        }
                }
                if (tp->t_dupacks < tcprexmtthresh)
                        tp->t_dupacks = 0;
-#else /* else no TCP_SACK */
-               if (tp->t_dupacks >= tcprexmtthresh &&
-                   tp->snd_cwnd > tp->snd_ssthresh)
-                       tp->snd_cwnd = tp->snd_ssthresh;
-               tp->t_dupacks = 0;
-#endif
                if (SEQ_GT(th->th_ack, tp->snd_max)) {
                        tcpstat_inc(tcps_rcvacktoomuch);
                        goto dropafterack_ratelim;
                }
                acked = th->th_ack - tp->snd_una;
@@ -1770,14 +1751,13 @@ trimthenstep6:
                u_int cw = tp->snd_cwnd;
                u_int incr = tp->t_maxseg;
 
                if (cw > tp->snd_ssthresh)
                        incr = incr * incr / cw;
-#if defined (TCP_SACK)
                if (tp->t_dupacks < tcprexmtthresh)
-#endif
-               tp->snd_cwnd = ulmin(cw + incr, TCP_MAXWIN<<tp->snd_scale);
+                       tp->snd_cwnd = ulmin(cw + incr,
+                           TCP_MAXWIN << tp->snd_scale);
                }
                ND6_HINT(tp);
                if (acked > so->so_snd.sb_cc) {
                        tp->snd_wnd -= so->so_snd.sb_cc;
                        sbdrop(so, &so->so_snd, (int)so->so_snd.sb_cc);
@@ -1817,11 +1797,11 @@ trimthenstep6:
                if (SEQ_GT(tp->snd_una, tp->snd_last))
                        tp->snd_last = tp->snd_una;
 #endif
                if (SEQ_LT(tp->snd_nxt, tp->snd_una))
                        tp->snd_nxt = tp->snd_una;
-#if defined (TCP_SACK) && defined (TCP_FACK)
+#ifdef TCP_FACK
                if (SEQ_GT(tp->snd_una, tp->snd_fack)) {
                        tp->snd_fack = tp->snd_una;
                        /* Update snd_awnd for partial ACK
                         * without any SACK blocks.
                         */
@@ -1980,14 +1960,13 @@ dodata:                                                 
/* XXX */
         * case PRU_RCVD).  If a FIN has already been received on this
         * connection then we just ignore the text.
         */
        if ((tlen || (tiflags & TH_FIN)) &&
            TCPS_HAVERCVDFIN(tp->t_state) == 0) {
-#ifdef TCP_SACK
                tcp_seq laststart = th->th_seq;
                tcp_seq lastend = th->th_seq + tlen;
-#endif
+
                if (th->th_seq == tp->rcv_nxt && TAILQ_EMPTY(&tp->t_segq) &&
                    tp->t_state == TCPS_ESTABLISHED) {
                        TCP_SETUP_ACK(tp, tiflags, m);
                        tp->rcv_nxt += tlen;
                        tiflags = th->th_flags & TH_FIN;
@@ -2005,14 +1984,12 @@ dodata:                                                 
/* XXX */
                } else {
                        m_adj(m, hdroptlen);
                        tiflags = tcp_reass(tp, th, m, &tlen);
                        tp->t_flags |= TF_ACKNOW;
                }
-#ifdef TCP_SACK
                if (tp->sack_enable)
                        tcp_update_sack_list(tp, laststart, lastend);
-#endif
 
                /*
                 * variable len never referenced again in modern BSD,
                 * so why bother computing it ??
                 */
@@ -2257,11 +2234,10 @@ tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt, 
struct tcphdr *th,
                        tp->t_flags |= TF_RCVD_TSTMP;
                        tp->ts_recent = oi->ts_val;
                        tp->ts_recent_age = tcp_now;
                        break;
 
-#ifdef TCP_SACK
                case TCPOPT_SACK_PERMITTED:
                        if (!tp->sack_enable || optlen!=TCPOLEN_SACK_PERMITTED)
                                continue;
                        if (!(th->th_flags & TH_SYN))
                                continue;
@@ -2271,11 +2247,10 @@ tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt, 
struct tcphdr *th,
                        tp->t_flags |= TF_SACK_PERMIT;
                        break;
                case TCPOPT_SACK:
                        tcp_sack_option(tp, th, cp, optlen);
                        break;
-#endif
 #ifdef TCP_SIGNATURE
                case TCPOPT_SIGNATURE:
                        if (optlen != TCPOLEN_SIGNATURE)
                                continue;
 
@@ -2355,20 +2330,16 @@ tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt, 
struct tcphdr *th,
 #endif /* TCP_SIGNATURE */
 
        return (0);
 }
 
-#if defined(TCP_SACK)
 u_long
 tcp_seq_subtract(u_long a, u_long b)
 {
        return ((long)(a - b));
 }
-#endif
 
-
-#ifdef TCP_SACK
 /*
  * This function is called upon receipt of new valid data (while not in header
  * prediction mode), and it updates the ordered list of sacks.
  */
 void
@@ -2504,15 +2475,15 @@ tcp_sack_option(struct tcpcb *tp, struct tcphdr *th, 
u_char *cp, int optlen)
                tmp_cp += TCPOLEN_SACK;
                if (SEQ_LEQ(sack.end, sack.start))
                        continue; /* bad SACK fields */
                if (SEQ_LEQ(sack.end, tp->snd_una))
                        continue; /* old block */
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                /* Updates snd_fack.  */
                if (SEQ_GT(sack.end, tp->snd_fack))
                        tp->snd_fack = sack.end;
-#endif /* TCP_FACK */
+#endif
                if (SEQ_GT(th->th_ack, tp->snd_una)) {
                        if (SEQ_LT(sack.start, th->th_ack))
                                continue;
                }
                if (SEQ_GT(sack.end, tp->snd_max))
@@ -2557,20 +2528,20 @@ tcp_sack_option(struct tcpcb *tp, struct tcphdr *th, 
u_char *cp, int optlen)
                                cur = cur->next;
                                continue;
                        }
                        if (SEQ_LEQ(sack.start, cur->start)) {
                                /* Data acks at least the beginning of hole */
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                if (SEQ_GT(sack.end, cur->rxmit))
                                        tp->retran_data -=
                                            tcp_seq_subtract(cur->rxmit,
                                            cur->start);
                                else
                                        tp->retran_data -=
                                            tcp_seq_subtract(sack.end,
                                            cur->start);
-#endif /* TCP_FACK */
+#endif
                                if (SEQ_GEQ(sack.end, cur->end)) {
                                        /* Acks entire hole, so delete hole */
                                        if (p != cur) {
                                                p->next = cur->next;
                                                pool_put(&sackhl_pool, cur);
@@ -2591,16 +2562,16 @@ tcp_sack_option(struct tcpcb *tp, struct tcphdr *th, 
u_char *cp, int optlen)
                                cur = cur->next;
                                continue;
                        }
                        /* move end of hole backward */
                        if (SEQ_GEQ(sack.end, cur->end)) {
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                if (SEQ_GT(cur->rxmit, sack.start))
                                        tp->retran_data -=
                                            tcp_seq_subtract(cur->rxmit,
                                            sack.start);
-#endif /* TCP_FACK */
+#endif
                                cur->end = sack.start;
                                cur->rxmit = SEQ_MIN(cur->rxmit, cur->end);
                                cur->dups++;
                                if (((sack.end - cur->end)/tp->t_maxseg) >=
                                    tcprexmtthresh)
@@ -2617,20 +2588,20 @@ tcp_sack_option(struct tcpcb *tp, struct tcphdr *th, 
u_char *cp, int optlen)
                                 */
                                temp = (struct sackhole *)
                                    pool_get(&sackhl_pool, PR_NOWAIT);
                                if (temp == NULL)
                                        goto done; /* ENOBUFS */
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                                if (SEQ_GT(cur->rxmit, sack.end))
                                        tp->retran_data -=
                                            tcp_seq_subtract(sack.end,
                                            sack.start);
                                else if (SEQ_GT(cur->rxmit, sack.start))
                                        tp->retran_data -=
                                            tcp_seq_subtract(cur->rxmit,
                                            sack.start);
-#endif /* TCP_FACK */
+#endif
                                temp->next = cur->next;
                                temp->start = sack.end;
                                temp->end = cur->end;
                                temp->dups = cur->dups;
                                temp->rxmit = SEQ_MAX(cur->rxmit, temp->start);
@@ -2668,11 +2639,11 @@ tcp_sack_option(struct tcpcb *tp, struct tcphdr *th, 
u_char *cp, int optlen)
                        tp->rcv_lastsack = sack.end;
                        tp->snd_numholes++;
                }
        }
 done:
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
        /*
         * Update retran_data and snd_awnd.  Go through the list of
         * holes.   Increment retran_data by (hole->rxmit - hole->start).
         */
        tp->retran_data = 0;
@@ -2681,11 +2652,11 @@ done:
                tp->retran_data += cur->rxmit - cur->start;
                cur = cur->next;
        }
        tp->snd_awnd = tcp_seq_subtract(tp->snd_nxt, tp->snd_fack) +
            tp->retran_data;
-#endif /* TCP_FACK */
+#endif
 
        return;
 }
 
 /*
@@ -2759,11 +2730,10 @@ tcp_sack_partialack(struct tcpcb *tp, struct tcphdr *th)
 #endif
                return (1);
        }
        return (0);
 }
-#endif /* TCP_SACK */
 
 /*
  * Pull out of band byte out of a segment so
  * it doesn't appear in the user's data queue.
  * It is still reflected in the segment length for
@@ -3118,11 +3088,10 @@ tcp_mss_update(struct tcpcb *tp)
                (void)sbreserve(so, &so->so_rcv, bufsize);
        }
 
 }
 
-#if defined (TCP_SACK)
 /*
  * Checks for partial ack.  If partial ack arrives, force the retransmission
  * of the next unacknowledged segment, do not clear tp->t_dupacks, and return
  * 1.  By setting snd_nxt to ti_ack, this forces retransmission timer to
  * be started again.  If the ack advances at least to tp->snd_last, return 0.
@@ -3163,11 +3132,10 @@ tcp_newreno(struct tcpcb *tp, struct tcphdr *th)
 
                return 1;
        }
        return 0;
 }
-#endif /* TCP_SACK */
 
 int
 tcp_mss_adv(struct mbuf *m, int af)
 {
        int mss = 0;
@@ -3738,37 +3706,30 @@ syn_cache_get(struct sockaddr *src, struct sockaddr 
*dst, struct tcphdr *th,
                tp = tcp_drop(tp, ENOBUFS);     /* destroys socket */
                so = NULL;
                m_freem(m);
                goto abort;
        }
-#ifdef TCP_SACK
        tp->sack_enable = sc->sc_flags & SCF_SACK_PERMIT;
-#endif
-
        tp->ts_modulate = sc->sc_modulate;
        tp->ts_recent = sc->sc_timestamp;
        tp->iss = sc->sc_iss;
        tp->irs = sc->sc_irs;
        tcp_sendseqinit(tp);
-#if defined (TCP_SACK) || defined(TCP_ECN)
        tp->snd_last = tp->snd_una;
-#endif /* TCP_SACK */
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
        tp->snd_fack = tp->snd_una;
        tp->retran_data = 0;
        tp->snd_awnd = 0;
-#endif /* TCP_FACK */
+#endif
 #ifdef TCP_ECN
        if (sc->sc_flags & SCF_ECN_PERMIT) {
                tp->t_flags |= TF_ECN_PERMIT;
                tcpstat_inc(tcps_ecn_accepts);
        }
 #endif
-#ifdef TCP_SACK
        if (sc->sc_flags & SCF_SACK_PERMIT)
                tp->t_flags |= TF_SACK_PERMIT;
-#endif
 #ifdef TCP_SIGNATURE
        if (sc->sc_flags & SCF_SIGNATURE)
                tp->t_flags |= TF_SIGNATURE;
 #endif
        tcp_rcvseqinit(tp);
@@ -3917,13 +3878,11 @@ syn_cache_add(struct sockaddr *src, struct sockaddr 
*dst, struct tcphdr *th,
        if (optp || (tp->t_flags & TF_SIGNATURE)) {
 #else
        if (optp) {
 #endif
                tb.pf = tp->pf;
-#ifdef TCP_SACK
                tb.sack_enable = tp->sack_enable;
-#endif
                tb.t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
 #ifdef TCP_SIGNATURE
                if (tp->t_flags & TF_SIGNATURE)
                        tb.t_flags |= TF_SIGNATURE;
 #endif
@@ -4032,18 +3991,16 @@ syn_cache_add(struct sockaddr *src, struct sockaddr 
*dst, struct tcphdr *th,
         */
        if (tcp_do_ecn &&
            (th->th_flags & (TH_ECE|TH_CWR)) == (TH_ECE|TH_CWR))
                sc->sc_flags |= SCF_ECN_PERMIT;
 #endif
-#ifdef TCP_SACK
        /*
         * Set SCF_SACK_PERMIT if peer did send a SACK_PERMITTED option
         * (i.e., if tcp_dooptions() did set TF_SACK_PERMIT).
         */
        if (tb.sack_enable && (tb.t_flags & TF_SACK_PERMIT))
                sc->sc_flags |= SCF_SACK_PERMIT;
-#endif
 #ifdef TCP_SIGNATURE
        if (tb.t_flags & TF_SIGNATURE)
                sc->sc_flags |= SCF_SIGNATURE;
 #endif
        sc->sc_tp = tp;
@@ -4087,13 +4044,11 @@ syn_cache_respond(struct syn_cache *sc, struct mbuf *m)
                return (EAFNOSUPPORT);
        }
 
        /* Compute the size of the TCP options. */
        optlen = 4 + (sc->sc_request_r_scale != 15 ? 4 : 0) +
-#ifdef TCP_SACK
            ((sc->sc_flags & SCF_SACK_PERMIT) ? 4 : 0) +
-#endif
 #ifdef TCP_SIGNATURE
            ((sc->sc_flags & SCF_SIGNATURE) ? TCPOLEN_SIGLEN : 0) +
 #endif
            ((sc->sc_flags & SCF_TIMESTAMP) ? TCPOLEN_TSTAMP_APPA : 0);
 
@@ -4169,17 +4124,15 @@ syn_cache_respond(struct syn_cache *sc, struct mbuf *m)
        *optp++ = TCPOPT_MAXSEG;
        *optp++ = 4;
        *optp++ = (sc->sc_ourmaxseg >> 8) & 0xff;
        *optp++ = sc->sc_ourmaxseg & 0xff;
 
-#ifdef TCP_SACK
        /* Include SACK_PERMIT_HDR option if peer has already done so. */
        if (sc->sc_flags & SCF_SACK_PERMIT) {
                *((u_int32_t *)optp) = htonl(TCPOPT_SACK_PERMIT_HDR);
                optp += 4;
        }
-#endif
 
        if (sc->sc_request_r_scale != 15) {
                *((u_int32_t *)optp) = htonl(TCPOPT_NOP << 24 |
                    TCPOPT_WINDOW << 16 | TCPOLEN_WINDOW << 8 |
                    sc->sc_request_r_scale);
diff --git sys/netinet/tcp_output.c sys/netinet/tcp_output.c
index d2510bf83e1..f3bf0b8b7a1 100644
--- sys/netinet/tcp_output.c
+++ sys/netinet/tcp_output.c
@@ -94,15 +94,12 @@
 
 #ifdef notyet
 extern struct mbuf *m_copypack();
 #endif
 
-#ifdef TCP_SACK
 extern int tcprexmtthresh;
-#endif
 
-#ifdef TCP_SACK
 #ifdef TCP_SACK_DEBUG
 void tcp_print_holes(struct tcpcb *tp);
 
 void
 tcp_print_holes(struct tcpcb *tp)
@@ -191,11 +188,10 @@ tcp_sack_adjust(struct tcpcb *tp)
        if (SEQ_LT(tp->snd_nxt, cur->end))
                return;
        tp->snd_nxt = tp->rcv_lastsack;
        return;
 }
-#endif /* TCP_SACK */
 
 /*
  * Tcp output routine: figure out what should be sent and send it.
  */
 int
@@ -208,15 +204,13 @@ tcp_output(struct tcpcb *tp)
        struct tcphdr *th;
        u_int32_t optbuf[howmany(MAX_TCPOPTLEN, sizeof(u_int32_t))];
        u_char *opt = (u_char *)optbuf;
        unsigned int optlen, hdrlen, packetlen;
        int idle, sendalot = 0;
-#ifdef TCP_SACK
        int i, sack_rxmit = 0;
        struct sackhole *p;
        int maxburst = TCP_MAXBURST;
-#endif
 #ifdef TCP_SIGNATURE
        unsigned int sigoff;
 #endif /* TCP_SIGNATURE */
 #ifdef TCP_ECN
        int needect;
@@ -226,14 +220,14 @@ tcp_output(struct tcpcb *tp)
                tp->t_flags |= TF_NEEDOUTPUT;
                return (0);
        } else
                tp->t_flags &= ~TF_NEEDOUTPUT;
 
-#if defined(TCP_SACK) && defined(TCP_SIGNATURE) && defined(DIAGNOSTIC)
+#if defined(TCP_SIGNATURE) && defined(DIAGNOSTIC)
        if (tp->sack_enable && (tp->t_flags & TF_SIGNATURE))
                return (EINVAL);
-#endif /* defined(TCP_SACK) && defined(TCP_SIGNATURE) && defined(DIAGNOSTIC) */
+#endif /* defined(TCP_SIGNATURE) && defined(DIAGNOSTIC) */
 
        /*
         * Determine length of data that should be transmitted,
         * and flags that will be used.
         * If there is some data or critical controls (SYN, RST)
@@ -254,21 +248,19 @@ tcp_output(struct tcpcb *tp)
                idle = 0;
        } else
                tp->t_flags &= ~TF_LASTIDLE;
 
 again:
-#ifdef TCP_SACK
        /*
         * If we've recently taken a timeout, snd_max will be greater than
         * snd_nxt.  There may be SACK information that allows us to avoid
         * resending already delivered data.  Adjust snd_nxt accordingly.
         */
        if (tp->sack_enable && SEQ_LT(tp->snd_nxt, tp->snd_max))
                tcp_sack_adjust(tp);
-#endif
        off = tp->snd_nxt - tp->snd_una;
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
        /* Normally, sendable data is limited by off < tp->snd_cwnd.
         * But in FACK, sendable data is limited by snd_awnd < snd_cwnd,
         * regardless of offset.
         */
        if (tp->sack_enable && (tp->t_dupacks > tcprexmtthresh))
@@ -277,11 +269,10 @@ again:
 #endif
        win = ulmin(tp->snd_wnd, tp->snd_cwnd);
 
        flags = tcp_outflags[tp->t_state];
 
-#ifdef TCP_SACK
        /*
         * Send any SACK-generated retransmissions.  If we're explicitly trying
         * to send out new data (when sendalot is 1), bypass this function.
         * If we retransmit in fast recovery mode, decrement snd_cwnd, since
         * we're replacing a (future) new transmission with a retransmission
@@ -299,11 +290,10 @@ again:
                        if (SEQ_LT(tp->snd_una, tp->snd_last))
                                tp->snd_cwnd -= tp->t_maxseg;
 #endif
                }
        }
-#endif /* TCP_SACK */
 
        sendalot = 0;
        /*
         * If in persist timeout with window of 0, send 1 byte.
         * Otherwise, if window is small but nonzero
@@ -335,28 +325,24 @@ again:
                        TCP_TIMER_DISARM(tp, TCPT_PERSIST);
                        tp->t_rxtshift = 0;
                }
        }
 
-#ifdef TCP_SACK
        if (!sack_rxmit) {
-#endif
-       len = ulmin(so->so_snd.sb_cc, win) - off;
+               len = ulmin(so->so_snd.sb_cc, win) - off;
 
-#if defined(TCP_SACK) && defined(TCP_FACK)
-       /*
-        * If we're in fast recovery (SEQ_GT(tp->snd_last, tp->snd_una)), and
-        * amount of outstanding data (snd_awnd) is >= snd_cwnd, then
-        * do not send data (like zero window conditions)
-        */
-       if (tp->sack_enable && len && SEQ_GT(tp->snd_last, tp->snd_una) &&
-           (tp->snd_awnd >= tp->snd_cwnd))
-               len = 0;
+#ifdef TCP_FACK
+               /*
+                * If we're in fast recovery (SEQ_GT(tp->snd_last, 
tp->snd_una)),
+                * and amount of outstanding data (snd_awnd) is >= snd_cwnd, 
then
+                * do not send data (like zero window conditions)
+                */
+               if (tp->sack_enable && SEQ_GT(tp->snd_last, tp->snd_una) &&
+                   len && (tp->snd_awnd >= tp->snd_cwnd))
+                       len = 0;
 #endif /* TCP_FACK */
-#ifdef TCP_SACK
        }
-#endif
 
        if (len < 0) {
                /*
                 * If FIN has been sent but not acked,
                 * but we haven't been called to retransmit,
@@ -415,14 +401,12 @@ again:
                        goto send;
                if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
                        goto send;
                if (SEQ_LT(tp->snd_nxt, tp->snd_max))
                        goto send;
-#ifdef TCP_SACK
                if (sack_rxmit)
                        goto send;
-#endif
        }
 
        /*
         * Compare available window to amount of window
         * known to peer (as advertised window less
@@ -460,11 +444,10 @@ again:
         * then we need to send.
         */
        if (flags & TH_FIN &&
            ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
                goto send;
-#ifdef TCP_SACK
        /*
         * In SACK, it is possible for tcp_output to fail to send a segment
         * after the retransmission timer has been turned off.  Make sure
         * that the retransmission timer is set.
         */
@@ -472,11 +455,10 @@ again:
            TCP_TIMER_ISARMED(tp, TCPT_REXMT) == 0 &&
            TCP_TIMER_ISARMED(tp, TCPT_PERSIST) == 0) {
                TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
                return (0);
        }
-#endif /* TCP_SACK */
 
        /*
         * TCP window updates are not reliable, rather a polling protocol
         * using ``persist'' packets is used to insure receipt of window
         * updates.  The three ``states'' for the output side are:
@@ -546,11 +528,10 @@ send:
                        memcpy(opt + 2, &mss, sizeof(mss));
                        optlen = 4;
 
                        if (flags & TH_ACK)
                                tcp_mss_update(tp);
-#ifdef TCP_SACK
                        /*
                         * If this is the first SYN of connection (not a SYN
                         * ACK), include SACK_PERMIT_HDR option.  If this is a
                         * SYN ACK, include SACK_PERMIT_HDR option if peer has
                         * already done so.
@@ -559,12 +540,10 @@ send:
                            (tp->t_flags & TF_SACK_PERMIT))) {
                                *((u_int32_t *) (opt + optlen)) =
                                    htonl(TCPOPT_SACK_PERMIT_HDR);
                                optlen += 4;
                        }
-#endif
-
                        if ((tp->t_flags & TF_REQ_SCALE) &&
                            ((flags & TH_ACK) == 0 ||
                            (tp->t_flags & TF_RCVD_SCALE))) {
                                *((u_int32_t *) (opt + optlen)) = htonl(
                                        TCPOPT_NOP << 24 |
@@ -624,11 +603,10 @@ send:
 
                optlen += TCPOLEN_SIGLEN;
        }
 #endif /* TCP_SIGNATURE */
 
-#ifdef TCP_SACK
        /*
         * Send SACKs if necessary.  This should be the last option processed.
         * Only as many SACKs are sent as are permitted by the maximum options
         * size.  No more than three SACKs are sent.
         */
@@ -651,11 +629,10 @@ send:
                        count++;
                }
                *olp = htonl(TCPOPT_SACK_HDR|(TCPOLEN_SACK*count+2));
                optlen += TCPOLEN_SACK*count + 4; /* including leading NOPs */
        }
-#endif /* TCP_SACK */
 
 #ifdef DIAGNOSTIC
        if (optlen > MAX_TCPOPTLEN)
                panic("tcp_output: options too long");
 #endif /* DIAGNOSTIC */
@@ -805,27 +782,25 @@ send:
        if (len || (flags & (TH_SYN|TH_FIN)) || TCP_TIMER_ISARMED(tp, 
TCPT_PERSIST))
                th->th_seq = htonl(tp->snd_nxt);
        else
                th->th_seq = htonl(tp->snd_max);
 
-#ifdef TCP_SACK
        if (sack_rxmit) {
                /*
                 * If sendalot was turned on (due to option stuffing), turn it
                 * off. Properly set th_seq field.  Advance the ret'x pointer
                 * by len.
                 */
                if (sendalot)
                        sendalot = 0;
                th->th_seq = htonl(p->rxmit);
                p->rxmit += len;
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                tp->retran_data += len;
-#endif /* TCP_FACK */
+#endif
                tcpstat_pkt(tcps_sack_rexmits, tcps_sack_rexmit_bytes, len);
        }
-#endif /* TCP_SACK */
 
        th->th_ack = htonl(tp->rcv_nxt);
        if (optlen) {
                memcpy(th + 1, opt, optlen);
                th->th_off = (sizeof (struct tcphdr) + optlen) >> 2;
@@ -960,17 +935,15 @@ send:
                        if (flags & TH_FIN) {
                                tp->snd_nxt++;
                                tp->t_flags |= TF_SENTFIN;
                        }
                }
-#ifdef TCP_SACK
                if (tp->sack_enable) {
                        if (sack_rxmit && (p->rxmit != tp->snd_nxt)) {
                                goto timer;
                        }
                }
-#endif
                tp->snd_nxt += len;
                if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
                        tp->snd_max = tp->snd_nxt;
                        /*
                         * Time this transmission if not a retransmission and
@@ -989,22 +962,20 @@ send:
                 * Initial value for retransmit timer is smoothed
                 * round-trip time + 2 * round-trip time variance.
                 * Initialize shift counter which is used for backoff
                 * of retransmit time.
                 */
-#ifdef TCP_SACK
  timer:
                if (tp->sack_enable && sack_rxmit &&
                    TCP_TIMER_ISARMED(tp, TCPT_REXMT) == 0 &&
                    tp->snd_nxt != tp->snd_max) {
                        TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
                        if (TCP_TIMER_ISARMED(tp, TCPT_PERSIST)) {
                                TCP_TIMER_DISARM(tp, TCPT_PERSIST);
                                tp->t_rxtshift = 0;
                        }
                }
-#endif
 
                if (TCP_TIMER_ISARMED(tp, TCPT_REXMT) == 0 &&
                    tp->snd_nxt != tp->snd_una) {
                        TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);
                        if (TCP_TIMER_ISARMED(tp, TCPT_PERSIST)) {
@@ -1123,15 +1094,15 @@ send:
                          0, NULL, tp->t_inpcb);
                break;
 #endif /* INET6 */
        }
 
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
        /* Update snd_awnd to reflect the new data that was sent.  */
        tp->snd_awnd = tcp_seq_subtract(tp->snd_max, tp->snd_fack) +
                tp->retran_data;
-#endif /* defined(TCP_SACK) && defined(TCP_FACK) */
+#endif
 
        if (error) {
 out:
                if (error == ENOBUFS) {
                        /*
@@ -1182,15 +1153,11 @@ out:
        if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv))
                tp->rcv_adv = tp->rcv_nxt + win;
        tp->last_ack_sent = tp->rcv_nxt;
        tp->t_flags &= ~TF_ACKNOW;
        TCP_CLEAR_DELACK(tp);
-#if defined(TCP_SACK)
        if (sendalot && --maxburst)
-#else
-       if (sendalot)
-#endif
                goto again;
        return (0);
 }
 
 void
diff --git sys/netinet/tcp_subr.c sys/netinet/tcp_subr.c
index 27cab0e05bb..0a426fc4db1 100644
--- sys/netinet/tcp_subr.c
+++ sys/netinet/tcp_subr.c
@@ -102,13 +102,11 @@
 int    tcp_mssdflt = TCP_MSS;
 int    tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
 
 /* values controllable via sysctl */
 int    tcp_do_rfc1323 = 1;
-#ifdef TCP_SACK
 int    tcp_do_sack = 1;        /* RFC 2018 selective ACKs */
-#endif
 int    tcp_ack_on_push = 0;    /* set to enable immediate ACK-on-PUSH */
 #ifdef TCP_ECN
 int    tcp_do_ecn = 0;         /* RFC3168 ECN enabled/disabled? */
 #endif
 int    tcp_do_rfc3390 = 2;     /* Increase TCP's Initial Window to 10*mss */
@@ -118,19 +116,15 @@ u_int32_t tcp_now = 1;
 #ifndef TCB_INITIAL_HASH_SIZE
 #define        TCB_INITIAL_HASH_SIZE   128
 #endif
 
 int tcp_reass_limit = NMBCLUSTERS / 8; /* hardlimit for tcpqe_pool */
-#ifdef TCP_SACK
 int tcp_sackhole_limit = 32*1024; /* hardlimit for sackhl_pool */
-#endif
 
 struct pool tcpcb_pool;
 struct pool tcpqe_pool;
-#ifdef TCP_SACK
 struct pool sackhl_pool;
-#endif
 
 struct cpumem *tcpcounters;            /* tcp statistics */
 tcp_seq  tcp_iss;
 
 /*
@@ -143,15 +137,13 @@ tcp_init(void)
        pool_init(&tcpcb_pool, sizeof(struct tcpcb), 0, IPL_SOFTNET, 0,
            "tcpcb", NULL);
        pool_init(&tcpqe_pool, sizeof(struct tcpqent), 0, IPL_SOFTNET, 0,
            "tcpqe", NULL);
        pool_sethardlimit(&tcpqe_pool, tcp_reass_limit, NULL, 0);
-#ifdef TCP_SACK
        pool_init(&sackhl_pool, sizeof(struct sackhole), 0, IPL_SOFTNET, 0,
            "sackhl", NULL);
        pool_sethardlimit(&sackhl_pool, tcp_sackhole_limit, NULL, 0);
-#endif /* TCP_SACK */
        in_pcbinit(&tcbtable, TCB_INITIAL_HASH_SIZE);
        tcpcounters = counters_alloc(tcps_ncounters);
 
 #ifdef INET6
        /*
@@ -437,13 +429,11 @@ tcp_newtcpcb(struct inpcb *inp)
        TCP_INIT_DELACK(tp);
        for (i = 0; i < TCPT_NTIMERS; i++)
                TCP_TIMER_INIT(tp, i);
        timeout_set(&tp->t_reap_to, tcp_reaper, tp);
 
-#ifdef TCP_SACK
        tp->sack_enable = tcp_do_sack;
-#endif
        tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
        tp->t_inpcb = inp;
        /*
         * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
         * rtt estimate.  Set rttvar so that srtt + 2 * rttvar gives
@@ -513,30 +503,27 @@ tcp_drop(struct tcpcb *tp, int errno)
 struct tcpcb *
 tcp_close(struct tcpcb *tp)
 {
        struct inpcb *inp = tp->t_inpcb;
        struct socket *so = inp->inp_socket;
-#ifdef TCP_SACK
        struct sackhole *p, *q;
-#endif
 
        /* free the reassembly queue, if any */
        tcp_freeq(tp);
 
        tcp_canceltimers(tp);
        TCP_CLEAR_DELACK(tp);
        syn_cache_cleanup(tp);
 
-#ifdef TCP_SACK
        /* Free SACK holes. */
        q = p = tp->snd_holes;
        while (p != 0) {
                q = p->next;
                pool_put(&sackhl_pool, p);
                p = q;
        }
-#endif
+
        m_free(tp->t_template);
 
        tp->t_flags |= TF_DEAD;
        timeout_add(&tp->t_reap_to, 0);
 
diff --git sys/netinet/tcp_timer.c sys/netinet/tcp_timer.c
index 3f063ed9936..9c40693acb6 100644
--- sys/netinet/tcp_timer.c
+++ sys/netinet/tcp_timer.c
@@ -154,11 +154,10 @@ int tcp_totbackoff = 511; /* sum of tcp_backoff[] */
 
 /*
  * TCP timer processing.
  */
 
-#ifdef TCP_SACK
 void   tcp_timer_freesack(struct tcpcb *);
 
 void
 tcp_timer_freesack(struct tcpcb *tp)
 {
@@ -175,13 +174,12 @@ tcp_timer_freesack(struct tcpcb *tp)
        tp->snd_holes = 0;
 #ifdef TCP_FACK
        tp->snd_fack = tp->snd_una;
        tp->retran_data = 0;
        tp->snd_awnd = 0;
-#endif /* TCP_FACK */
+#endif
 }
-#endif /* TCP_SACK */
 
 void
 tcp_timer_rexmt(void *arg)
 {
        struct tcpcb *tp = arg;
@@ -217,13 +215,11 @@ tcp_timer_rexmt(void *arg)
                in_pcbnotifyall(&tcbtable, sintosa(&sin),
                    tp->t_inpcb->inp_rtableid, EMSGSIZE, tcp_mtudisc);
                goto out;
        }
 
-#ifdef TCP_SACK
        tcp_timer_freesack(tp);
-#endif
        if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
                tp->t_rxtshift = TCP_MAXRXTSHIFT;
                tcpstat_inc(tcps_timeoutdrop);
                (void)tcp_drop(tp, tp->t_softerror ?
                    tp->t_softerror : ETIMEDOUT);
@@ -303,17 +299,15 @@ tcp_timer_rexmt(void *arg)
                in_losing(tp->t_inpcb);
                tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
                tp->t_srtt = 0;
        }
        tp->snd_nxt = tp->snd_una;
-#if defined(TCP_SACK)
        /*
         * Note:  We overload snd_last to function also as the
         * snd_last variable described in RFC 2582
         */
        tp->snd_last = tp->snd_max;
-#endif /* TCP_SACK */
        /*
         * If timing a segment in this window, stop the timer.
         */
        tp->t_rtttime = 0;
 #ifdef TCP_ECN
@@ -460,13 +454,11 @@ tcp_timer_2msl(void *arg)
 
        NET_LOCK();
        if (tp->t_flags & TF_DEAD)
                goto out;
 
-#ifdef TCP_SACK
        tcp_timer_freesack(tp);
-#endif
 
        if (tp->t_state != TCPS_TIME_WAIT &&
            ((tcp_maxidle == 0) || ((tcp_now - tp->t_rcvtime) <= tcp_maxidle)))
                TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_keepintvl);
        else
diff --git sys/netinet/tcp_usrreq.c sys/netinet/tcp_usrreq.c
index 1e70b9e07c9..2d784ff52ea 100644
--- sys/netinet/tcp_usrreq.c
+++ sys/netinet/tcp_usrreq.c
@@ -266,14 +266,12 @@ tcp_usrreq(struct socket *so, int req, struct mbuf *m, 
struct mbuf *nam,
                tcpstat_inc(tcps_connattempt);
                tp->t_state = TCPS_SYN_SENT;
                TCP_TIMER_ARM(tp, TCPT_KEEP, tcptv_keep_init);
                tcp_set_iss_tsm(tp);
                tcp_sendseqinit(tp);
-#if defined(TCP_SACK)
                tp->snd_last = tp->snd_una;
-#endif
-#if defined(TCP_SACK) && defined(TCP_FACK)
+#ifdef TCP_FACK
                tp->snd_fack = tp->snd_una;
                tp->retran_data = 0;
                tp->snd_awnd = 0;
 #endif
                error = tcp_output(tp);
@@ -494,11 +492,10 @@ tcp_ctloutput(int op, struct socket *so, int level, int 
optname,
                                tp->t_maxseg = i;
                        else
                                error = EINVAL;
                        break;
 
-#ifdef TCP_SACK
                case TCP_SACK_ENABLE:
                        if (m == NULL || m->m_len < sizeof (int)) {
                                error = EINVAL;
                                break;
                        }
@@ -516,11 +513,10 @@ tcp_ctloutput(int op, struct socket *so, int level, int 
optname,
                        if (*mtod(m, int *))
                                tp->sack_enable = 1;
                        else
                                tp->sack_enable = 0;
                        break;
-#endif
 #ifdef TCP_SIGNATURE
                case TCP_MD5SIG:
                        if (m == NULL || m->m_len < sizeof (int)) {
                                error = EINVAL;
                                break;
@@ -531,13 +527,11 @@ tcp_ctloutput(int op, struct socket *so, int level, int 
optname,
                                break;
                        }
 
                        if (*mtod(m, int *)) {
                                tp->t_flags |= TF_SIGNATURE;
-#ifdef TCP_SACK
                                tp->sack_enable = 0;
-#endif /* TCP_SACK */
                        } else
                                tp->t_flags &= ~TF_SIGNATURE;
                        break;
 #endif /* TCP_SIGNATURE */
                default:
@@ -557,15 +551,13 @@ tcp_ctloutput(int op, struct socket *so, int level, int 
optname,
                        *mtod(m, int *) = tp->t_flags & TF_NOPUSH;
                        break;
                case TCP_MAXSEG:
                        *mtod(m, int *) = tp->t_maxseg;
                        break;
-#ifdef TCP_SACK
                case TCP_SACK_ENABLE:
                        *mtod(m, int *) = tp->sack_enable;
                        break;
-#endif
 #ifdef TCP_SIGNATURE
                case TCP_MD5SIG:
                        *mtod(m, int *) = tp->t_flags & TF_SIGNATURE;
                        break;
 #endif
@@ -958,18 +950,17 @@ tcp_sysctl(int *name, u_int namelen, void *oldp, size_t 
*oldlenp, void *newp,
        /* All sysctl names at this level are terminal. */
        if (namelen != 1)
                return (ENOTDIR);
 
        switch (name[0]) {
-#ifdef TCP_SACK
        case TCPCTL_SACK:
                NET_LOCK();
                error = sysctl_int(oldp, oldlenp, newp, newlen,
                    &tcp_do_sack);
                NET_UNLOCK();
                return (error);
-#endif
+
        case TCPCTL_SLOWHZ:
                return (sysctl_rdint(oldp, oldlenp, newp, PR_SLOWHZ));
 
        case TCPCTL_BADDYNAMIC:
                NET_LOCK();
@@ -1023,11 +1014,11 @@ tcp_sysctl(int *name, u_int namelen, void *oldp, size_t 
*oldlenp, void *newp,
                        if (!error)
                                tcp_reass_limit = nval;
                }
                NET_UNLOCK();
                return (error);
-#ifdef TCP_SACK
+
        case TCPCTL_SACKHOLE_LIMIT:
                NET_LOCK();
                nval = tcp_sackhole_limit;
                error = sysctl_int(oldp, oldlenp, newp, newlen, &nval);
                if (!error && nval != tcp_sackhole_limit) {
@@ -1035,11 +1026,10 @@ tcp_sysctl(int *name, u_int namelen, void *oldp, size_t 
*oldlenp, void *newp,
                        if (!error)
                                tcp_sackhole_limit = nval;
                }
                NET_UNLOCK();
                return (error);
-#endif
 
        case TCPCTL_STATS:
                return (tcp_sysctl_tcpstat(oldp, oldlenp, newp));
 
        case TCPCTL_SYN_USE_LIMIT:
diff --git sys/netinet/tcp_var.h sys/netinet/tcp_var.h
index de3390b61f1..bc2b77d188b 100644
--- sys/netinet/tcp_var.h
+++ sys/netinet/tcp_var.h
@@ -114,34 +114,28 @@ struct tcpcb {
        tcp_seq snd_up;                 /* send urgent pointer */
        tcp_seq snd_wl1;                /* window update seg seq number */
        tcp_seq snd_wl2;                /* window update seg ack number */
        tcp_seq iss;                    /* initial send sequence number */
        u_long  snd_wnd;                /* send window */
-#if 1 /*def TCP_SACK*/
        int     sack_enable;            /* enable SACK for this connection */
        int     snd_numholes;           /* number of holes seen by sender */
        struct sackhole *snd_holes;     /* linked list of holes (sorted) */
-#if 1 /*defined(TCP_SACK) && defined(TCP_FACK)*/
+#if 1 /*defined(TCP_FACK)*/
        tcp_seq snd_fack;               /* for FACK congestion control */
        u_long  snd_awnd;               /* snd_nxt - snd_fack + */
                                        /* retransmitted data */
        int retran_data;                /* amount of outstanding retx. data  */
 #endif /* TCP_FACK */
-#endif /* TCP_SACK */
-#if 1 /*defined(TCP_SACK) || defined(TCP_ECN)*/
        tcp_seq snd_last;               /* for use in fast recovery */
-#endif
 /* receive sequence variables */
        u_long  rcv_wnd;                /* receive window */
        tcp_seq rcv_nxt;                /* receive next */
        tcp_seq rcv_up;                 /* receive urgent pointer */
        tcp_seq irs;                    /* initial receive sequence number */
-#if 1 /*def TCP_SACK*/
        tcp_seq rcv_lastsack;           /* last seq number(+1) sack'd by rcv'r*/
        int     rcv_numsacks;           /* # distinct sack blks present */
        struct sackblk sackblks[MAX_SACK_BLKS]; /* seq nos. of sack blocks */
-#endif
 
 /*
  * Additional variables for this implementation.
  */
 /* receive variables */
@@ -696,15 +690,13 @@ extern    u_int32_t tcp_now;              /* for RFC 1323 
timestamps */
 extern int tcp_do_rfc1323;     /* enabled/disabled? */
 extern int tcptv_keep_init;    /* time to keep alive the initial SYN packet */
 extern int tcp_mssdflt;        /* default maximum segment size */
 extern int tcp_rst_ppslim;     /* maximum outgoing RST packet per second */
 extern int tcp_ack_on_push;    /* ACK immediately on PUSH */
-#ifdef TCP_SACK
 extern int tcp_do_sack;        /* SACK enabled/disabled */
 extern struct pool sackhl_pool;
 extern int tcp_sackhole_limit; /* max entries for tcp sack queues */
-#endif
 extern int tcp_do_ecn;         /* RFC3168 ECN enabled/disabled? */
 extern int tcp_do_rfc3390;     /* RFC3390 Increasing TCP's Initial Window */
 
 extern struct pool tcpqe_pool;
 extern int tcp_reass_limit;    /* max entries for tcp reass queues */
@@ -765,11 +757,10 @@ int        tcp_sysctl(int *, u_int, void *, size_t *, 
void *, size_t);
 int     tcp_usrreq(struct socket *,
            int, struct mbuf *, struct mbuf *, struct mbuf *, struct proc *);
 int     tcp_attach(struct socket *, int);
 void    tcp_xmit_timer(struct tcpcb *, int);
 void    tcpdropoldhalfopen(struct tcpcb *, u_int16_t);
-#ifdef TCP_SACK
 void    tcp_sack_option(struct tcpcb *,struct tcphdr *,u_char *,int);
 void    tcp_update_sack_list(struct tcpcb *tp, tcp_seq, tcp_seq);
 void    tcp_del_sackholes(struct tcpcb *, struct tcphdr *);
 void    tcp_clean_sackreport(struct tcpcb *tp);
 void    tcp_sack_adjust(struct tcpcb *tp);
@@ -777,15 +768,12 @@ struct sackhole *
         tcp_sack_output(struct tcpcb *tp);
 int     tcp_sack_partialack(struct tcpcb *, struct tcphdr *);
 #ifdef DEBUG
 void    tcp_print_holes(struct tcpcb *tp);
 #endif
-#endif /* TCP_SACK */
-#if defined(TCP_SACK)
 int     tcp_newreno(struct tcpcb *, struct tcphdr *);
 u_long  tcp_seq_subtract(u_long, u_long );
-#endif /* TCP_SACK */
 #ifdef TCP_SIGNATURE
 int    tcp_signature_apply(caddr_t, caddr_t, unsigned int);
 int    tcp_signature(struct tdb *, int, struct mbuf *, struct tcphdr *,
            int, int, char *);
 #endif /* TCP_SIGNATURE */

Reply via email to