tcp: bool conversions

bool conversions where possible.

__inline__ -> inline

space cleanups

Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 108 insertions, 106 deletions

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index eb97787be75..b961ef54b17 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -196,9 +196,10 @@ static void tcp_enter_quickack_mode(struct sock *sk)
  * and the session is not interactive.
  */
 
-static inline int tcp_in_quickack_mode(const struct sock *sk)
+static inline bool tcp_in_quickack_mode(const struct sock *sk)
 {
         const struct inet_connection_sock *icsk = inet_csk(sk);
+
         return icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong;
 }
 
@@ -253,11 +254,11 @@ static inline void TCP_ECN_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
                 tp->ecn_flags &= ~TCP_ECN_OK;
 }
 
-static inline int TCP_ECN_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
+static bool TCP_ECN_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
 {
         if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
-                return 1;
-        return 0;
+                return true;
+        return false;
 }
 
 /* Buffer size and advertised window tuning.
@@ -1123,36 +1124,36 @@ static void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp,
  * the exact amount is rather hard to quantify. However, tp->max_window can
  * be used as an exaggerated estimate.
  */
-static int tcp_is_sackblock_valid(struct tcp_sock *tp, int is_dsack,
-                                  u32 start_seq, u32 end_seq)
+static bool tcp_is_sackblock_valid(struct tcp_sock *tp, bool is_dsack,
+                                   u32 start_seq, u32 end_seq)
 {
         /* Too far in future, or reversed (interpretation is ambiguous) */
         if (after(end_seq, tp->snd_nxt) || !before(start_seq, end_seq))
-                return 0;
+                return false;
 
         /* Nasty start_seq wrap-around check (see comments above) */
         if (!before(start_seq, tp->snd_nxt))
-                return 0;
+                return false;
 
         /* In outstanding window? ...This is valid exit for D-SACKs too.
          * start_seq == snd_una is non-sensical (see comments above)
          */
         if (after(start_seq, tp->snd_una))
-                return 1;
+                return true;
 
         if (!is_dsack || !tp->undo_marker)
-                return 0;
+                return false;
 
         /* ...Then it's D-SACK, and must reside below snd_una completely */
         if (after(end_seq, tp->snd_una))
-                return 0;
+                return false;
 
         if (!before(start_seq, tp->undo_marker))
-                return 1;
+                return true;
 
         /* Too old */
         if (!after(end_seq, tp->undo_marker))
-                return 0;
+                return false;
 
         /* Undo_marker boundary crossing (overestimates a lot). Known already:
          *   start_seq < undo_marker and end_seq >= undo_marker.
@@ -1224,17 +1225,17 @@ static void tcp_mark_lost_retrans(struct sock *sk)
                 tp->lost_retrans_low = new_low_seq;
 }
 
-static int tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
-                           struct tcp_sack_block_wire *sp, int num_sacks,
-                           u32 prior_snd_una)
+static bool tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
+                            struct tcp_sack_block_wire *sp, int num_sacks,
+                            u32 prior_snd_una)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq);
         u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq);
-        int dup_sack = 0;
+        bool dup_sack = false;
 
         if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
-                dup_sack = 1;
+                dup_sack = true;
                 tcp_dsack_seen(tp);
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
         } else if (num_sacks > 1) {
@@ -1243,7 +1244,7 @@ static int tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
 
                 if (!after(end_seq_0, end_seq_1) &&
                     !before(start_seq_0, start_seq_1)) {
-                        dup_sack = 1;
+                        dup_sack = true;
                         tcp_dsack_seen(tp);
                         NET_INC_STATS_BH(sock_net(sk),
                                         LINUX_MIB_TCPDSACKOFORECV);
@@ -1274,9 +1275,10 @@ struct tcp_sacktag_state {
  * FIXME: this could be merged to shift decision code
  */
 static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
-                                 u32 start_seq, u32 end_seq)
+                                  u32 start_seq, u32 end_seq)
 {
-        int in_sack, err;
+        int err;
+        bool in_sack;
         unsigned int pkt_len;
         unsigned int mss;
 
@@ -1322,7 +1324,7 @@ static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
 static u8 tcp_sacktag_one(struct sock *sk,
                           struct tcp_sacktag_state *state, u8 sacked,
                           u32 start_seq, u32 end_seq,
-                          int dup_sack, int pcount)
+                          bool dup_sack, int pcount)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         int fack_count = state->fack_count;
@@ -1402,10 +1404,10 @@ static u8 tcp_sacktag_one(struct sock *sk,
 /* Shift newly-SACKed bytes from this skb to the immediately previous
  * already-SACKed sk_buff. Mark the newly-SACKed bytes as such.
  */
-static int tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
-                           struct tcp_sacktag_state *state,
-                           unsigned int pcount, int shifted, int mss,
-                           int dup_sack)
+static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
+                            struct tcp_sacktag_state *state,
+                            unsigned int pcount, int shifted, int mss,
+                            bool dup_sack)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct sk_buff *prev = tcp_write_queue_prev(sk, skb);
@@ -1455,7 +1457,7 @@ static int tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
         if (skb->len > 0) {
                 BUG_ON(!tcp_skb_pcount(skb));
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKSHIFTED);
-                return 0;
+                return false;
         }
 
         /* Whole SKB was eaten :-) */
@@ -1478,7 +1480,7 @@ static int tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
 
         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKMERGED);
 
-        return 1;
+        return true;
 }
 
 /* I wish gso_size would have a bit more sane initialization than
@@ -1501,7 +1503,7 @@ static int skb_can_shift(const struct sk_buff *skb)
 static struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb,
                                           struct tcp_sacktag_state *state,
                                           u32 start_seq, u32 end_seq,
-                                          int dup_sack)
+                                          bool dup_sack)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct sk_buff *prev;
@@ -1640,14 +1642,14 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
                                         struct tcp_sack_block *next_dup,
                                         struct tcp_sacktag_state *state,
                                         u32 start_seq, u32 end_seq,
-                                        int dup_sack_in)
+                                        bool dup_sack_in)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct sk_buff *tmp;
 
         tcp_for_write_queue_from(skb, sk) {
                 int in_sack = 0;
-                int dup_sack = dup_sack_in;
+                bool dup_sack = dup_sack_in;
 
                 if (skb == tcp_send_head(sk))
                         break;
@@ -1662,7 +1664,7 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
                                                         next_dup->start_seq,
                                                         next_dup->end_seq);
                         if (in_sack > 0)
-                                dup_sack = 1;
+                                dup_sack = true;
                 }
 
                 /* skb reference here is a bit tricky to get right, since
@@ -1767,7 +1769,7 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
         struct sk_buff *skb;
         int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
         int used_sacks;
-        int found_dup_sack = 0;
+        bool found_dup_sack = false;
         int i, j;
         int first_sack_index;
 
@@ -1798,7 +1800,7 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
         used_sacks = 0;
         first_sack_index = 0;
         for (i = 0; i < num_sacks; i++) {
-                int dup_sack = !i && found_dup_sack;
+                bool dup_sack = !i && found_dup_sack;
 
                 sp[used_sacks].start_seq = get_unaligned_be32(&sp_wire[i].start_seq);
                 sp[used_sacks].end_seq = get_unaligned_be32(&sp_wire[i].end_seq);
@@ -1865,7 +1867,7 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
         while (i < used_sacks) {
                 u32 start_seq = sp[i].start_seq;
                 u32 end_seq = sp[i].end_seq;
-                int dup_sack = (found_dup_sack && (i == first_sack_index));
+                bool dup_sack = (found_dup_sack && (i == first_sack_index));
                 struct tcp_sack_block *next_dup = NULL;
 
                 if (found_dup_sack && ((i + 1) == first_sack_index))
@@ -1967,9 +1969,9 @@ out:
 }
 
 /* Limits sacked_out so that sum with lost_out isn't ever larger than
- * packets_out. Returns zero if sacked_out adjustement wasn't necessary.
+ * packets_out. Returns false if sacked_out adjustement wasn't necessary.
  */
-static int tcp_limit_reno_sacked(struct tcp_sock *tp)
+static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
 {
         u32 holes;
 
@@ -1978,9 +1980,9 @@ static int tcp_limit_reno_sacked(struct tcp_sock *tp)
 
         if ((tp->sacked_out + holes) > tp->packets_out) {
                 tp->sacked_out = tp->packets_out - holes;
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 /* If we receive more dupacks than we expected counting segments
@@ -2034,40 +2036,40 @@ static int tcp_is_sackfrto(const struct tcp_sock *tp)
 /* F-RTO can only be used if TCP has never retransmitted anything other than
  * head (SACK enhanced variant from Appendix B of RFC4138 is more robust here)
  */
-int tcp_use_frto(struct sock *sk)
+bool tcp_use_frto(struct sock *sk)
 {
         const struct tcp_sock *tp = tcp_sk(sk);
         const struct inet_connection_sock *icsk = inet_csk(sk);
         struct sk_buff *skb;
 
         if (!sysctl_tcp_frto)
-                return 0;
+                return false;
 
         /* MTU probe and F-RTO won't really play nicely along currently */
         if (icsk->icsk_mtup.probe_size)
-                return 0;
+                return false;
 
         if (tcp_is_sackfrto(tp))
-                return 1;
+                return true;
 
         /* Avoid expensive walking of rexmit queue if possible */
         if (tp->retrans_out > 1)
-                return 0;
+                return false;
 
         skb = tcp_write_queue_head(sk);
         if (tcp_skb_is_last(sk, skb))
-                return 1;
+                return true;
         skb = tcp_write_queue_next(sk, skb);    /* Skips head */
         tcp_for_write_queue_from(skb, sk) {
                 if (skb == tcp_send_head(sk))
                         break;
                 if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
-                        return 0;
+                        return false;
                 /* Short-circuit when first non-SACKed skb has been checked */
                 if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
                         break;
         }
-        return 1;
+        return true;
 }
 
 /* RTO occurred, but do not yet enter Loss state. Instead, defer RTO
@@ -2303,7 +2305,7 @@ void tcp_enter_loss(struct sock *sk, int how)
  *
  * Do processing similar to RTO timeout.
  */
-static int tcp_check_sack_reneging(struct sock *sk, int flag)
+static bool tcp_check_sack_reneging(struct sock *sk, int flag)
 {
         if (flag & FLAG_SACK_RENEGING) {
                 struct inet_connection_sock *icsk = inet_csk(sk);
@@ -2314,9 +2316,9 @@ static int tcp_check_sack_reneging(struct sock *sk, int flag)
                 tcp_retransmit_skb(sk, tcp_write_queue_head(sk));
                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
                                           icsk->icsk_rto, TCP_RTO_MAX);
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 static inline int tcp_fackets_out(const struct tcp_sock *tp)
@@ -2472,28 +2474,28 @@ static inline int tcp_head_timedout(const struct sock *sk)
  * Main question: may we further continue forward transmission
  * with the same cwnd?
  */
-static int tcp_time_to_recover(struct sock *sk, int flag)
+static bool tcp_time_to_recover(struct sock *sk, int flag)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         __u32 packets_out;
 
         /* Do not perform any recovery during F-RTO algorithm */
         if (tp->frto_counter)
-                return 0;
+                return false;
 
         /* Trick#1: The loss is proven. */
         if (tp->lost_out)
-                return 1;
+                return true;
 
         /* Not-A-Trick#2 : Classic rule... */
         if (tcp_dupack_heuristics(tp) > tp->reordering)
-                return 1;
+                return true;
 
         /* Trick#3 : when we use RFC2988 timer restart, fast
          * retransmit can be triggered by timeout of queue head.
          */
         if (tcp_is_fack(tp) && tcp_head_timedout(sk))
-                return 1;
+                return true;
 
         /* Trick#4: It is still not OK... But will it be useful to delay
          * recovery more?
@@ -2505,7 +2507,7 @@ static int tcp_time_to_recover(struct sock *sk, int flag)
                 /* We have nothing to send. This connection is limited
                  * either by receiver window or by application.
                  */
-                return 1;
+                return true;
         }
 
         /* If a thin stream is detected, retransmit after first
@@ -2516,7 +2518,7 @@ static int tcp_time_to_recover(struct sock *sk, int flag)
         if ((tp->thin_dupack || sysctl_tcp_thin_dupack) &&
             tcp_stream_is_thin(tp) && tcp_dupack_heuristics(tp) > 1 &&
             tcp_is_sack(tp) && !tcp_send_head(sk))
-                return 1;
+                return true;
 
         /* Trick#6: TCP early retransmit, per RFC5827.  To avoid spurious
          * retransmissions due to small network reorderings, we implement
@@ -2528,7 +2530,7 @@ static int tcp_time_to_recover(struct sock *sk, int flag)
             !tcp_may_send_now(sk))
                 return !tcp_pause_early_retransmit(sk, flag);
 
-        return 0;
+        return false;
 }
 
 /* New heuristics: it is possible only after we switched to restart timer
@@ -2767,7 +2769,7 @@ static inline int tcp_may_undo(const struct tcp_sock *tp)
 }
 
 /* People celebrate: "We love our President!" */
-static int tcp_try_undo_recovery(struct sock *sk)
+static bool tcp_try_undo_recovery(struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
@@ -2792,10 +2794,10 @@ static int tcp_try_undo_recovery(struct sock *sk)
                  * is ACKed. For Reno it is MUST to prevent false
                  * fast retransmits (RFC2582). SACK TCP is safe. */
                 tcp_moderate_cwnd(tp);
-                return 1;
+                return true;
         }
         tcp_set_ca_state(sk, TCP_CA_Open);
-        return 0;
+        return false;
 }
 
 /* Try to undo cwnd reduction, because D-SACKs acked all retransmitted data */
@@ -2825,19 +2827,19 @@ static void tcp_try_undo_dsack(struct sock *sk)
  * that successive retransmissions of a segment must not advance
  * retrans_stamp under any conditions.
  */
-static int tcp_any_retrans_done(const struct sock *sk)
+static bool tcp_any_retrans_done(const struct sock *sk)
 {
         const struct tcp_sock *tp = tcp_sk(sk);
         struct sk_buff *skb;
 
         if (tp->retrans_out)
-                return 1;
+                return true;
 
         skb = tcp_write_queue_head(sk);
         if (unlikely(skb && TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS))
-                return 1;
+                return true;
 
-        return 0;
+        return false;
 }
 
 /* Undo during fast recovery after partial ACK. */
@@ -2871,7 +2873,7 @@ static int tcp_try_undo_partial(struct sock *sk, int acked)
 }
 
 /* Undo during loss recovery after partial ACK. */
-static int tcp_try_undo_loss(struct sock *sk)
+static bool tcp_try_undo_loss(struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
@@ -2893,9 +2895,9 @@ static int tcp_try_undo_loss(struct sock *sk)
                 tp->undo_marker = 0;
                 if (tcp_is_sack(tp))
                         tcp_set_ca_state(sk, TCP_CA_Open);
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 static inline void tcp_complete_cwr(struct sock *sk)
@@ -3370,7 +3372,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
         const struct inet_connection_sock *icsk = inet_csk(sk);
         struct sk_buff *skb;
         u32 now = tcp_time_stamp;
-        int fully_acked = 1;
+        int fully_acked = true;
         int flag = 0;
         u32 pkts_acked = 0;
         u32 reord = tp->packets_out;
@@ -3394,7 +3396,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
                         if (!acked_pcount)
                                 break;
 
-                        fully_acked = 0;
+                        fully_acked = false;
                 } else {
                         acked_pcount = tcp_skb_pcount(skb);
                 }
@@ -3673,7 +3675,7 @@ static void tcp_undo_spur_to_response(struct sock *sk, int flag)
  *     to prove that the RTO is indeed spurious. It transfers the control
  *     from F-RTO to the conventional RTO recovery
  */
-static int tcp_process_frto(struct sock *sk, int flag)
+static bool tcp_process_frto(struct sock *sk, int flag)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
@@ -3689,7 +3691,7 @@ static int tcp_process_frto(struct sock *sk, int flag)
 
         if (!before(tp->snd_una, tp->frto_highmark)) {
                 tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 2 : 3), flag);
-                return 1;
+                return true;
         }
 
         if (!tcp_is_sackfrto(tp)) {
@@ -3698,19 +3700,19 @@ static int tcp_process_frto(struct sock *sk, int flag)
                  * data, winupdate
                  */
                 if (!(flag & FLAG_ANY_PROGRESS) && (flag & FLAG_NOT_DUP))
-                        return 1;
+                        return true;
 
                 if (!(flag & FLAG_DATA_ACKED)) {
                         tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 0 : 3),
                                             flag);
-                        return 1;
+                        return true;
                 }
         } else {
                 if (!(flag & FLAG_DATA_ACKED) && (tp->frto_counter == 1)) {
                         /* Prevent sending of new data. */
                         tp->snd_cwnd = min(tp->snd_cwnd,
                                            tcp_packets_in_flight(tp));
-                        return 1;
+                        return true;
                 }
 
                 if ((tp->frto_counter >= 2) &&
@@ -3720,10 +3722,10 @@ static int tcp_process_frto(struct sock *sk, int flag)
                         /* RFC4138 shortcoming (see comment above) */
                         if (!(flag & FLAG_FORWARD_PROGRESS) &&
                             (flag & FLAG_NOT_DUP))
-                                return 1;
+                                return true;
 
                         tcp_enter_frto_loss(sk, 3, flag);
-                        return 1;
+                        return true;
                 }
         }
 
@@ -3735,7 +3737,7 @@ static int tcp_process_frto(struct sock *sk, int flag)
                 if (!tcp_may_send_now(sk))
                         tcp_enter_frto_loss(sk, 2, flag);
 
-                return 1;
+                return true;
         } else {
                 switch (sysctl_tcp_frto_response) {
                 case 2:
@@ -3752,7 +3754,7 @@ static int tcp_process_frto(struct sock *sk, int flag)
                 tp->undo_marker = 0;
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSPURIOUSRTOS);
         }
-        return 0;
+        return false;
 }
 
 /* This routine deals with incoming acks, but not outgoing ones. */
@@ -3770,7 +3772,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
         int prior_sacked = tp->sacked_out;
         int pkts_acked = 0;
         int newly_acked_sacked = 0;
-        int frto_cwnd = 0;
+        bool frto_cwnd = false;
 
         /* If the ack is older than previous acks
          * then we can probably ignore it.
@@ -4025,7 +4027,7 @@ void tcp_parse_options(const struct sk_buff *skb, struct tcp_options_received *o
 }
 EXPORT_SYMBOL(tcp_parse_options);
 
-static int tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
+static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
 {
         const __be32 *ptr = (const __be32 *)(th + 1);
 
@@ -4036,31 +4038,31 @@ static int tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr
                 tp->rx_opt.rcv_tsval = ntohl(*ptr);
                 ++ptr;
                 tp->rx_opt.rcv_tsecr = ntohl(*ptr);
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 /* Fast parse options. This hopes to only see timestamps.
  * If it is wrong it falls back on tcp_parse_options().
  */
-static int tcp_fast_parse_options(const struct sk_buff *skb,
-                                  const struct tcphdr *th,
-                                  struct tcp_sock *tp, const u8 **hvpp)
+static bool tcp_fast_parse_options(const struct sk_buff *skb,
+                                   const struct tcphdr *th,
+                                   struct tcp_sock *tp, const u8 **hvpp)
 {
         /* In the spirit of fast parsing, compare doff directly to constant
          * values.  Because equality is used, short doff can be ignored here.
          */
         if (th->doff == (sizeof(*th) / 4)) {
                 tp->rx_opt.saw_tstamp = 0;
-                return 0;
+                return false;
         } else if (tp->rx_opt.tstamp_ok &&
                    th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
                 if (tcp_parse_aligned_timestamp(tp, th))
-                        return 1;
+                        return true;
         }
         tcp_parse_options(skb, &tp->rx_opt, hvpp, 1);
-        return 1;
+        return true;
 }
 
 #ifdef CONFIG_TCP_MD5SIG
@@ -4301,7 +4303,7 @@ static void tcp_fin(struct sock *sk)
         }
 }
 
-static inline int tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
+static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
                                   u32 end_seq)
 {
         if (!after(seq, sp->end_seq) && !after(sp->start_seq, end_seq)) {
@@ -4309,9 +4311,9 @@ static inline int tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
                         sp->start_seq = seq;
                 if (after(end_seq, sp->end_seq))
                         sp->end_seq = end_seq;
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
@@ -4507,7 +4509,7 @@ static void tcp_ofo_queue(struct sock *sk)
         }
 }
 
-static int tcp_prune_ofo_queue(struct sock *sk);
+static bool tcp_prune_ofo_queue(struct sock *sk);
 static int tcp_prune_queue(struct sock *sk);
 
 static int tcp_try_rmem_schedule(struct sock *sk, unsigned int size)
@@ -5092,10 +5094,10 @@ static void tcp_collapse_ofo_queue(struct sock *sk)
  * Purge the out-of-order queue.
  * Return true if queue was pruned.
  */
-static int tcp_prune_ofo_queue(struct sock *sk)
+static bool tcp_prune_ofo_queue(struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
-        int res = 0;
+        bool res = false;
 
         if (!skb_queue_empty(&tp->out_of_order_queue)) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_OFOPRUNED);
@@ -5109,7 +5111,7 @@ static int tcp_prune_ofo_queue(struct sock *sk)
                 if (tp->rx_opt.sack_ok)
                         tcp_sack_reset(&tp->rx_opt);
                 sk_mem_reclaim(sk);
-                res = 1;
+                res = true;
         }
         return res;
 }
@@ -5186,7 +5188,7 @@ void tcp_cwnd_application_limited(struct sock *sk)
         tp->snd_cwnd_stamp = tcp_time_stamp;
 }
 
-static int tcp_should_expand_sndbuf(const struct sock *sk)
+static bool tcp_should_expand_sndbuf(const struct sock *sk)
 {
         const struct tcp_sock *tp = tcp_sk(sk);
 
@@ -5194,21 +5196,21 @@ static int tcp_should_expand_sndbuf(const struct sock *sk)
          * not modify it.
          */
         if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
-                return 0;
+                return false;
 
         /* If we are under global TCP memory pressure, do not expand.  */
         if (sk_under_memory_pressure(sk))
-                return 0;
+                return false;
 
         /* If we are under soft global TCP memory pressure, do not expand.  */
         if (sk_memory_allocated(sk) >= sk_prot_mem_limits(sk, 0))
-                return 0;
+                return false;
 
         /* If we filled the congestion window, do not expand.  */
         if (tp->packets_out >= tp->snd_cwnd)
-                return 0;
+                return false;
 
-        return 1;
+        return true;
 }
 
 /* When incoming ACK allowed to free some skb from write_queue,
@@ -5434,16 +5436,16 @@ static inline int tcp_checksum_complete_user(struct sock *sk,
 }
 
 #ifdef CONFIG_NET_DMA
-static int tcp_dma_try_early_copy(struct sock *sk, struct sk_buff *skb,
+static bool tcp_dma_try_early_copy(struct sock *sk, struct sk_buff *skb,
                                   int hlen)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         int chunk = skb->len - hlen;
         int dma_cookie;
-        int copied_early = 0;
+        bool copied_early = false;
 
         if (tp->ucopy.wakeup)
-                return 0;
+                return false;
 
         if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
                 tp->ucopy.dma_chan = net_dma_find_channel();
@@ -5459,7 +5461,7 @@ static int tcp_dma_try_early_copy(struct sock *sk, struct sk_buff *skb,
                         goto out;
 
                 tp->ucopy.dma_cookie = dma_cookie;
-                copied_early = 1;
+                copied_early = true;
 
                 tp->ucopy.len -= chunk;
                 tp->copied_seq += chunk;