18 files changed, 205 insertions, 199 deletions

diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index eb3435de54b5..7f98a9d39883 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -1168,13 +1168,13 @@ out:
  * @if_incoming: interface where the packet was received
  * @if_outgoing: interface for which the retransmission should be considered
  *
- * Return: 1 if the link can be considered bidirectional, 0 otherwise
+ * Return: true if the link can be considered bidirectional, false otherwise
  */
-static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
-                                 struct batadv_orig_node *orig_neigh_node,
-                                 struct batadv_ogm_packet *batadv_ogm_packet,
-                                 struct batadv_hard_iface *if_incoming,
-                                 struct batadv_hard_iface *if_outgoing)
+static bool batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
+                                  struct batadv_orig_node *orig_neigh_node,
+                                  struct batadv_ogm_packet *batadv_ogm_packet,
+                                  struct batadv_hard_iface *if_incoming,
+                                  struct batadv_hard_iface *if_outgoing)
 {
         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;
@@ -1182,9 +1182,10 @@ static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
         u8 total_count;
         u8 orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own;
         unsigned int neigh_rq_inv_cube, neigh_rq_max_cube;
-        int tq_asym_penalty, inv_asym_penalty, if_num, ret = 0;
+        int tq_asym_penalty, inv_asym_penalty, if_num;
         unsigned int combined_tq;
         int tq_iface_penalty;
+        bool ret = false;
 
         /* find corresponding one hop neighbor */
         rcu_read_lock();
@@ -1296,7 +1297,7 @@ static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
          * consider it bidirectional
          */
         if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
-                ret = 1;
+                ret = true;
 
 out:
         if (neigh_node)
@@ -1325,9 +1326,9 @@ batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
         struct batadv_orig_ifinfo *orig_ifinfo = NULL;
         struct batadv_neigh_node *neigh_node;
         struct batadv_neigh_ifinfo *neigh_ifinfo;
-        int is_dup;
+        bool is_dup;
         s32 seq_diff;
-        int need_update = 0;
+        bool need_update = false;
         int set_mark;
         enum batadv_dup_status ret = BATADV_NO_DUP;
         u32 seqno = ntohl(batadv_ogm_packet->seqno);
@@ -1437,7 +1438,7 @@ batadv_iv_ogm_process_per_outif(const struct sk_buff *skb, int ogm_offset,
         struct sk_buff *skb_priv;
         struct ethhdr *ethhdr;
         u8 *prev_sender;
-        int is_bidirect;
+        bool is_bidirect;
 
         /* create a private copy of the skb, as some functions change tq value
          * and/or flags.
diff --git a/net/batman-adv/bitarray.c b/net/batman-adv/bitarray.c
index b56bb000a0ab..a0c7913837a5 100644
--- a/net/batman-adv/bitarray.c
+++ b/net/batman-adv/bitarray.c
@@ -38,11 +38,11 @@ static void batadv_bitmap_shift_left(unsigned long *seq_bits, s32 n)
  *  the last sequence number
  * @set_mark: whether this packet should be marked in seq_bits
  *
- * Return: 1 if the window was moved (either new or very old),
- *  0 if the window was not moved/shifted.
+ * Return: true if the window was moved (either new or very old),
+ *  false if the window was not moved/shifted.
  */
-int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, s32 seq_num_diff,
-                          int set_mark)
+bool batadv_bit_get_packet(void *priv, unsigned long *seq_bits,
+                           s32 seq_num_diff, int set_mark)
 {
         struct batadv_priv *bat_priv = priv;
 
@@ -52,7 +52,7 @@ int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, s32 seq_num_diff,
         if (seq_num_diff <= 0 && seq_num_diff > -BATADV_TQ_LOCAL_WINDOW_SIZE) {
                 if (set_mark)
                         batadv_set_bit(seq_bits, -seq_num_diff);
-                return 0;
+                return false;
         }
 
         /* sequence number is slightly newer, so we shift the window and
@@ -63,7 +63,7 @@ int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, s32 seq_num_diff,
 
                 if (set_mark)
                         batadv_set_bit(seq_bits, 0);
-                return 1;
+                return true;
         }
 
         /* sequence number is much newer, probably missed a lot of packets */
@@ -75,7 +75,7 @@ int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, s32 seq_num_diff,
                 bitmap_zero(seq_bits, BATADV_TQ_LOCAL_WINDOW_SIZE);
                 if (set_mark)
                         batadv_set_bit(seq_bits, 0);
-                return 1;
+                return true;
         }
 
         /* received a much older packet. The other host either restarted
@@ -94,5 +94,5 @@ int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, s32 seq_num_diff,
         if (set_mark)
                 batadv_set_bit(seq_bits, 0);
 
-        return 1;
+        return true;
 }
diff --git a/net/batman-adv/bitarray.h b/net/batman-adv/bitarray.h
index 3e41bb80eb81..0e6e9d09078c 100644
--- a/net/batman-adv/bitarray.h
+++ b/net/batman-adv/bitarray.h
@@ -22,6 +22,7 @@
 
 #include <linux/bitops.h>
 #include <linux/compiler.h>
+#include <linux/stddef.h>
 #include <linux/types.h>
 
 /**
@@ -31,17 +32,17 @@
  * @last_seqno: latest sequence number in seq_bits
  * @curr_seqno: sequence number to test for
  *
- * Return: 1 if the corresponding bit in the given seq_bits indicates true
- * and curr_seqno is within range of last_seqno. Otherwise returns 0.
+ * Return: true if the corresponding bit in the given seq_bits indicates true
+ * and curr_seqno is within range of last_seqno. Otherwise returns false.
  */
-static inline int batadv_test_bit(const unsigned long *seq_bits,
-                                  u32 last_seqno, u32 curr_seqno)
+static inline bool batadv_test_bit(const unsigned long *seq_bits,
+                                   u32 last_seqno, u32 curr_seqno)
 {
         s32 diff;
 
         diff = last_seqno - curr_seqno;
         if (diff < 0 || diff >= BATADV_TQ_LOCAL_WINDOW_SIZE)
-                return 0;
+                return false;
         return test_bit(diff, seq_bits) != 0;
 }
 
@@ -55,7 +56,7 @@ static inline void batadv_set_bit(unsigned long *seq_bits, s32 n)
         set_bit(n, seq_bits); /* turn the position on */
 }
 
-int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, s32 seq_num_diff,
-                          int set_mark);
+bool batadv_bit_get_packet(void *priv, unsigned long *seq_bits,
+                           s32 seq_num_diff, int set_mark);
 
 #endif /* _NET_BATMAN_ADV_BITARRAY_H_ */
diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c
index 5064ae5e9b34..748a9ead7ce5 100644
--- a/net/batman-adv/bridge_loop_avoidance.c
+++ b/net/batman-adv/bridge_loop_avoidance.c
@@ -101,10 +101,10 @@ static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
  * @node: list node of the first entry to compare
  * @data2: pointer to the second backbone gateway
  *
- * Return: 1 if the backbones have the same data, 0 otherwise
+ * Return: true if the backbones have the same data, false otherwise
  */
-static int batadv_compare_backbone_gw(const struct hlist_node *node,
-                                      const void *data2)
+static bool batadv_compare_backbone_gw(const struct hlist_node *node,
+                                       const void *data2)
 {
         const void *data1 = container_of(node, struct batadv_bla_backbone_gw,
                                          hash_entry);
@@ -112,12 +112,12 @@ static int batadv_compare_backbone_gw(const struct hlist_node *node,
         const struct batadv_bla_backbone_gw *gw2 = data2;
 
         if (!batadv_compare_eth(gw1->orig, gw2->orig))
-                return 0;
+                return false;
 
         if (gw1->vid != gw2->vid)
-                return 0;
+                return false;
 
-        return 1;
+        return true;
 }
 
 /**
@@ -125,10 +125,10 @@ static int batadv_compare_backbone_gw(const struct hlist_node *node,
  * @node: list node of the first entry to compare
  * @data2: pointer to the second claims
  *
- * Return: 1 if the claim have the same data, 0 otherwise
+ * Return: true if the claim have the same data, 0 otherwise
  */
-static int batadv_compare_claim(const struct hlist_node *node,
-                                const void *data2)
+static bool batadv_compare_claim(const struct hlist_node *node,
+                                 const void *data2)
 {
         const void *data1 = container_of(node, struct batadv_bla_claim,
                                          hash_entry);
@@ -136,12 +136,12 @@ static int batadv_compare_claim(const struct hlist_node *node,
         const struct batadv_bla_claim *cl2 = data2;
 
         if (!batadv_compare_eth(cl1->addr, cl2->addr))
-                return 0;
+                return false;
 
         if (cl1->vid != cl2->vid)
-                return 0;
+                return false;
 
-        return 1;
+        return true;
 }
 
 /**
@@ -775,22 +775,22 @@ static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
  * @backbone_addr: originator address of the sender (Ethernet source MAC)
  * @vid: the VLAN ID of the frame
  *
- * Return: 1 if handled
+ * Return: true if handled
  */
-static int batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
-                                  u8 *backbone_addr, unsigned short vid)
+static bool batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
+                                   u8 *backbone_addr, unsigned short vid)
 {
         struct batadv_bla_backbone_gw *backbone_gw;
         u16 backbone_crc, crc;
 
         if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
-                return 0;
+                return false;
 
         backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
                                                  false);
 
         if (unlikely(!backbone_gw))
-                return 1;
+                return true;
 
         /* handle as ANNOUNCE frame */
         backbone_gw->lasttime = jiffies;
@@ -823,7 +823,7 @@ static int batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
         }
 
         batadv_backbone_gw_put(backbone_gw);
-        return 1;
+        return true;
 }
 
 /**
@@ -834,29 +834,29 @@ static int batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
  * @ethhdr: ethernet header of a packet
  * @vid: the VLAN ID of the frame
  *
- * Return: 1 if handled
+ * Return: true if handled
  */
-static int batadv_handle_request(struct batadv_priv *bat_priv,
-                                 struct batadv_hard_iface *primary_if,
-                                 u8 *backbone_addr, struct ethhdr *ethhdr,
-                                 unsigned short vid)
+static bool batadv_handle_request(struct batadv_priv *bat_priv,
+                                  struct batadv_hard_iface *primary_if,
+                                  u8 *backbone_addr, struct ethhdr *ethhdr,
+                                  unsigned short vid)
 {
         /* check for REQUEST frame */
         if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
-                return 0;
+                return false;
 
         /* sanity check, this should not happen on a normal switch,
          * we ignore it in this case.
          */
         if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
-                return 1;
+                return true;
 
         batadv_dbg(BATADV_DBG_BLA, bat_priv,
                    "handle_request(): REQUEST vid %d (sent by %pM)...\n",
                    BATADV_PRINT_VID(vid), ethhdr->h_source);
 
         batadv_bla_answer_request(bat_priv, primary_if, vid);
-        return 1;
+        return true;
 }
 
 /**
@@ -867,12 +867,12 @@ static int batadv_handle_request(struct batadv_priv *bat_priv,
  * @claim_addr: Client to be unclaimed (ARP sender HW MAC)
  * @vid: the VLAN ID of the frame
  *
- * Return: 1 if handled
+ * Return: true if handled
  */
-static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
-                                 struct batadv_hard_iface *primary_if,
-                                 u8 *backbone_addr, u8 *claim_addr,
-                                 unsigned short vid)
+static bool batadv_handle_unclaim(struct batadv_priv *bat_priv,
+                                  struct batadv_hard_iface *primary_if,
+                                  u8 *backbone_addr, u8 *claim_addr,
+                                  unsigned short vid)
 {
         struct batadv_bla_backbone_gw *backbone_gw;
 
@@ -885,7 +885,7 @@ static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
         backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
 
         if (!backbone_gw)
-                return 1;
+                return true;
 
         /* this must be an UNCLAIM frame */
         batadv_dbg(BATADV_DBG_BLA, bat_priv,
@@ -894,7 +894,7 @@ static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
 
         batadv_bla_del_claim(bat_priv, claim_addr, vid);
         batadv_backbone_gw_put(backbone_gw);
-        return 1;
+        return true;
 }
 
 /**
@@ -905,12 +905,12 @@ static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
  * @claim_addr: client mac address to be claimed (ARP sender HW MAC)
  * @vid: the VLAN ID of the frame
  *
- * Return: 1 if handled
+ * Return: true if handled
  */
-static int batadv_handle_claim(struct batadv_priv *bat_priv,
-                               struct batadv_hard_iface *primary_if,
-                               u8 *backbone_addr, u8 *claim_addr,
-                               unsigned short vid)
+static bool batadv_handle_claim(struct batadv_priv *bat_priv,
+                                struct batadv_hard_iface *primary_if,
+                                u8 *backbone_addr, u8 *claim_addr,
+                                unsigned short vid)
 {
         struct batadv_bla_backbone_gw *backbone_gw;
 
@@ -920,7 +920,7 @@ static int batadv_handle_claim(struct batadv_priv *bat_priv,
                                                  false);
 
         if (unlikely(!backbone_gw))
-                return 1;
+                return true;
 
         /* this must be a CLAIM frame */
         batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
@@ -931,7 +931,7 @@ static int batadv_handle_claim(struct batadv_priv *bat_priv,
         /* TODO: we could call something like tt_local_del() here. */
 
         batadv_backbone_gw_put(backbone_gw);
-        return 1;
+        return true;
 }
 
 /**
@@ -1015,12 +1015,12 @@ static int batadv_check_claim_group(struct batadv_priv *bat_priv,
  * @primary_if: the primary hard interface of this batman soft interface
  * @skb: the frame to be checked
  *
- * Return: 1 if it was a claim frame, otherwise return 0 to
+ * Return: true if it was a claim frame, otherwise return false to
  * tell the callee that it can use the frame on its own.
  */
-static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
-                                    struct batadv_hard_iface *primary_if,
-                                    struct sk_buff *skb)
+static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,
+                                     struct batadv_hard_iface *primary_if,
+                                     struct sk_buff *skb)
 {
         struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
         u8 *hw_src, *hw_dst;
@@ -1051,7 +1051,7 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
                         vhdr = skb_header_pointer(skb, headlen, VLAN_HLEN,
                                                   &vhdr_buf);
                         if (!vhdr)
-                                return 0;
+                                return false;
 
                         proto = vhdr->h_vlan_encapsulated_proto;
                         headlen += VLAN_HLEN;
@@ -1060,12 +1060,12 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
         }
 
         if (proto != htons(ETH_P_ARP))
-                return 0; /* not a claim frame */
+                return false; /* not a claim frame */
 
         /* this must be a ARP frame. check if it is a claim. */
 
         if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
-                return 0;
+                return false;
 
         /* pskb_may_pull() may have modified the pointers, get ethhdr again */
         ethhdr = eth_hdr(skb);
@@ -1075,13 +1075,13 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
          * IP information
          */
         if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
-                return 0;
+                return false;
         if (arphdr->ar_pro != htons(ETH_P_IP))
-                return 0;
+                return false;
         if (arphdr->ar_hln != ETH_ALEN)
-                return 0;
+                return false;
         if (arphdr->ar_pln != 4)
-                return 0;
+                return false;
 
         hw_src = (u8 *)arphdr + sizeof(struct arphdr);
         hw_dst = hw_src + ETH_ALEN + 4;
@@ -1091,14 +1091,14 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
         /* check if it is a claim frame in general */
         if (memcmp(bla_dst->magic, bla_dst_own->magic,
                    sizeof(bla_dst->magic)) != 0)
-                return 0;
+                return false;
 
         /* check if there is a claim frame encapsulated deeper in (QinQ) and
          * drop that, as this is not supported by BLA but should also not be
          * sent via the mesh.
          */
         if (vlan_depth > 1)
-                return 1;
+                return true;
 
         /* Let the loopdetect frames on the mesh in any case. */
         if (bla_dst->type == BATADV_CLAIM_TYPE_LOOPDETECT)
@@ -1114,7 +1114,7 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
                            hw_dst);
 
         if (ret < 2)
-                return ret;
+                return !!ret;
 
         /* become a backbone gw ourselves on this vlan if not happened yet */
         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
@@ -1124,30 +1124,30 @@ static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
         case BATADV_CLAIM_TYPE_CLAIM:
                 if (batadv_handle_claim(bat_priv, primary_if, hw_src,
                                         ethhdr->h_source, vid))
-                        return 1;
+                        return true;
                 break;
         case BATADV_CLAIM_TYPE_UNCLAIM:
                 if (batadv_handle_unclaim(bat_priv, primary_if,
                                           ethhdr->h_source, hw_src, vid))
-                        return 1;
+                        return true;
                 break;
 
         case BATADV_CLAIM_TYPE_ANNOUNCE:
                 if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
                                            vid))
-                        return 1;
+                        return true;
                 break;
         case BATADV_CLAIM_TYPE_REQUEST:
                 if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
                                           vid))
-                        return 1;
+                        return true;
                 break;
         }
 
         batadv_dbg(BATADV_DBG_BLA, bat_priv,
                    "bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
                    ethhdr->h_source, BATADV_PRINT_VID(vid), hw_src, hw_dst);
-        return 1;
+        return true;
 }
 
 /**
@@ -1529,15 +1529,16 @@ int batadv_bla_init(struct batadv_priv *bat_priv)
  * sent by another host, drop it. We allow equal packets from
  * the same host however as this might be intended.
  *
- * Return: 1 if a packet is in the duplicate list, 0 otherwise.
+ * Return: true if a packet is in the duplicate list, false otherwise.
  */
-int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
-                                   struct sk_buff *skb)
+bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
+                                    struct sk_buff *skb)
 {
-        int i, curr, ret = 0;
+        int i, curr;
         __be32 crc;
         struct batadv_bcast_packet *bcast_packet;
         struct batadv_bcast_duplist_entry *entry;
+        bool ret = false;
 
         bcast_packet = (struct batadv_bcast_packet *)skb->data;
 
@@ -1565,9 +1566,9 @@ int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
                         continue;
 
                 /* this entry seems to match: same crc, not too old,
-                 * and from another gw. therefore return 1 to forbid it.
+                 * and from another gw. therefore return true to forbid it.
                  */
-                ret = 1;
+                ret = true;
                 goto out;
         }
         /* not found, add a new entry (overwrite the oldest entry)
@@ -1633,21 +1634,21 @@ bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
  * @orig_node: the orig_node of the frame
  * @hdr_size: maximum length of the frame
  *
- * Return: 1 if the orig_node is also a gateway on the soft interface, otherwise
- * it returns 0.
+ * Return: true if the orig_node is also a gateway on the soft interface,
+ * otherwise it returns false.
  */
-int batadv_bla_is_backbone_gw(struct sk_buff *skb,
-                              struct batadv_orig_node *orig_node, int hdr_size)
+bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
+                               struct batadv_orig_node *orig_node, int hdr_size)
 {
         struct batadv_bla_backbone_gw *backbone_gw;
         unsigned short vid;
 
         if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
-                return 0;
+                return false;
 
         /* first, find out the vid. */
         if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
-                return 0;
+                return false;
 
         vid = batadv_get_vid(skb, hdr_size);
 
@@ -1655,10 +1656,10 @@ int batadv_bla_is_backbone_gw(struct sk_buff *skb,
         backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
                                                 orig_node->orig, vid);
         if (!backbone_gw)
-                return 0;
+                return false;
 
         batadv_backbone_gw_put(backbone_gw);
-        return 1;
+        return true;
 }
 
 /**
@@ -1750,16 +1751,16 @@ batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
  *
  * in these cases, the skb is further handled by this function
  *
- * Return: 1 if handled, otherwise it returns 0 and the caller shall further
- * process the skb.
+ * Return: true if handled, otherwise it returns false and the caller shall
+ * further process the skb.
  */
-int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
-                  unsigned short vid, bool is_bcast)
+bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
+                   unsigned short vid, bool is_bcast)
 {
         struct ethhdr *ethhdr;
         struct batadv_bla_claim search_claim, *claim = NULL;
         struct batadv_hard_iface *primary_if;
-        int ret;
+        bool ret;
 
         ethhdr = eth_hdr(skb);
 
@@ -1821,12 +1822,12 @@ int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
         }
 allow:
         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
-        ret = 0;
+        ret = false;
         goto out;
 
 handled:
         kfree_skb(skb);
-        ret = 1;
+        ret = true;
 
 out:
         if (primary_if)
@@ -1850,16 +1851,16 @@ out:
  *
  * This call might reallocate skb data.
  *
- * Return: 1 if handled, otherwise it returns 0 and the caller shall further
- * process the skb.
+ * Return: true if handled, otherwise it returns false and the caller shall
+ * further process the skb.
  */
-int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
-                  unsigned short vid)
+bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
+                   unsigned short vid)
 {
         struct ethhdr *ethhdr;
         struct batadv_bla_claim search_claim, *claim = NULL;
         struct batadv_hard_iface *primary_if;
-        int ret = 0;
+        bool ret = false;
 
         primary_if = batadv_primary_if_get_selected(bat_priv);
         if (!primary_if)
@@ -1913,10 +1914,10 @@ int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
         }
 allow:
         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
-        ret = 0;
+        ret = false;
         goto out;
 handled:
-        ret = 1;
+        ret = true;
 out:
         if (primary_if)
                 batadv_hardif_put(primary_if);
diff --git a/net/batman-adv/bridge_loop_avoidance.h b/net/batman-adv/bridge_loop_avoidance.h
index 579f0fa6fe6a..0f01daeb359e 100644
--- a/net/batman-adv/bridge_loop_avoidance.h
+++ b/net/batman-adv/bridge_loop_avoidance.h
@@ -27,19 +27,20 @@ struct seq_file;
 struct sk_buff;
 
 #ifdef CONFIG_BATMAN_ADV_BLA
-int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
-                  unsigned short vid, bool is_bcast);
-int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
-                  unsigned short vid);
-int batadv_bla_is_backbone_gw(struct sk_buff *skb,
-                              struct batadv_orig_node *orig_node, int hdr_size);
+bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
+                   unsigned short vid, bool is_bcast);
+bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
+                   unsigned short vid);
+bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
+                               struct batadv_orig_node *orig_node,
+                               int hdr_size);
 int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset);
 int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq,
                                              void *offset);
 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
                                     unsigned short vid);
-int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
-                                   struct sk_buff *skb);
+bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
+                                    struct sk_buff *skb);
 void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
                                     struct batadv_hard_iface *primary_if,
                                     struct batadv_hard_iface *oldif);
@@ -50,24 +51,24 @@ void batadv_bla_free(struct batadv_priv *bat_priv);
 #define BATADV_BLA_CRC_INIT     0
 #else /* ifdef CONFIG_BATMAN_ADV_BLA */
 
-static inline int batadv_bla_rx(struct batadv_priv *bat_priv,
-                                struct sk_buff *skb, unsigned short vid,
-                                bool is_bcast)
+static inline bool batadv_bla_rx(struct batadv_priv *bat_priv,
+                                 struct sk_buff *skb, unsigned short vid,
+                                 bool is_bcast)
 {
-        return 0;
+        return false;
 }
 
-static inline int batadv_bla_tx(struct batadv_priv *bat_priv,
-                                struct sk_buff *skb, unsigned short vid)
+static inline bool batadv_bla_tx(struct batadv_priv *bat_priv,
+                                 struct sk_buff *skb, unsigned short vid)
 {
-        return 0;
+        return false;
 }
 
-static inline int batadv_bla_is_backbone_gw(struct sk_buff *skb,
-                                            struct batadv_orig_node *orig_node,
-                                            int hdr_size)
+static inline bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
+                                             struct batadv_orig_node *orig_node,
+                                             int hdr_size)
 {
-        return 0;
+        return false;
 }
 
 static inline int batadv_bla_claim_table_seq_print_text(struct seq_file *seq,
@@ -88,11 +89,11 @@ static inline bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv,
         return false;
 }
 
-static inline int
+static inline bool
 batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
                                struct sk_buff *skb)
 {
-        return 0;
+        return false;
 }
 
 static inline void
diff --git a/net/batman-adv/debugfs.c b/net/batman-adv/debugfs.c
index aa315da83429..952900466d88 100644
--- a/net/batman-adv/debugfs.c
+++ b/net/batman-adv/debugfs.c
@@ -134,7 +134,7 @@ static int batadv_log_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int batadv_log_empty(struct batadv_priv_debug_log *debug_log)
+static bool batadv_log_empty(struct batadv_priv_debug_log *debug_log)
 {
         return !(debug_log->log_start - debug_log->log_end);
 }
diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c
index 67f44f5d630b..278800a99c69 100644
--- a/net/batman-adv/distributed-arp-table.c
+++ b/net/batman-adv/distributed-arp-table.c
@@ -165,14 +165,14 @@ static void batadv_dat_purge(struct work_struct *work)
  * @node: node in the local table
  * @data2: second object to compare the node to
  *
- * Return: 1 if the two entries are the same, 0 otherwise.
+ * Return: true if the two entries are the same, false otherwise.
  */
-static int batadv_compare_dat(const struct hlist_node *node, const void *data2)
+static bool batadv_compare_dat(const struct hlist_node *node, const void *data2)
 {
         const void *data1 = container_of(node, struct batadv_dat_entry,
                                          hash_entry);
 
-        return memcmp(data1, data2, sizeof(__be32)) == 0 ? 1 : 0;
+        return memcmp(data1, data2, sizeof(__be32)) == 0;
 }
 
 /**
diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c
index 7c1d8d7ac548..8c2f39962fa5 100644
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@ -146,22 +146,22 @@ static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
         return ret;
 }
 
-static int batadv_is_valid_iface(const struct net_device *net_dev)
+static bool batadv_is_valid_iface(const struct net_device *net_dev)
 {
         if (net_dev->flags & IFF_LOOPBACK)
-                return 0;
+                return false;
 
         if (net_dev->type != ARPHRD_ETHER)
-                return 0;
+                return false;
 
         if (net_dev->addr_len != ETH_ALEN)
-                return 0;
+                return false;
 
         /* no batman over batman */
         if (batadv_is_on_batman_iface(net_dev))
-                return 0;
+                return false;
 
-        return 1;
+        return true;
 }
 
 /**
@@ -653,8 +653,7 @@ batadv_hardif_add_interface(struct net_device *net_dev)
 
         ASSERT_RTNL();
 
-        ret = batadv_is_valid_iface(net_dev);
-        if (ret != 1)
+        if (!batadv_is_valid_iface(net_dev))
                 goto out;
 
         dev_hold(net_dev);
diff --git a/net/batman-adv/hash.h b/net/batman-adv/hash.h
index 9bb57b87447c..cbbf87075f06 100644
--- a/net/batman-adv/hash.h
+++ b/net/batman-adv/hash.h
@@ -32,10 +32,10 @@ struct lock_class_key;
 /* callback to a compare function.  should compare 2 element datas for their
  * keys
  *
- * Return: 0 if same and not 0 if not same
+ * Return: true if same and false if not same
  */
-typedef int (*batadv_hashdata_compare_cb)(const struct hlist_node *,
-                                          const void *);
+typedef bool (*batadv_hashdata_compare_cb)(const struct hlist_node *,
+                                           const void *);
 
 /* the hashfunction
  *
diff --git a/net/batman-adv/main.h b/net/batman-adv/main.h
index 090c6f0f2398..76925266deed 100644
--- a/net/batman-adv/main.h
+++ b/net/batman-adv/main.h
@@ -292,7 +292,7 @@ static inline void _batadv_dbg(int type __always_unused,
  *
  * note: can't use ether_addr_equal() as it requires aligned memory
  *
- * Return: 1 if they are the same ethernet addr
+ * Return: true if they are the same ethernet addr
  */
 static inline bool batadv_compare_eth(const void *data1, const void *data2)
 {
diff --git a/net/batman-adv/network-coding.c b/net/batman-adv/network-coding.c
index 953dff1ad43b..df5ae9c7e507 100644
--- a/net/batman-adv/network-coding.c
+++ b/net/batman-adv/network-coding.c
@@ -510,10 +510,10 @@ static u32 batadv_nc_hash_choose(const void *data, u32 size)
  * @node: node in the local table
  * @data2: second object to compare the node to
  *
- * Return: 1 if the two entry are the same, 0 otherwise
+ * Return: true if the two entry are the same, false otherwise
  */
-static int batadv_nc_hash_compare(const struct hlist_node *node,
-                                  const void *data2)
+static bool batadv_nc_hash_compare(const struct hlist_node *node,
+                                   const void *data2)
 {
         const struct batadv_nc_path *nc_path1, *nc_path2;
 
@@ -523,13 +523,13 @@ static int batadv_nc_hash_compare(const struct hlist_node *node,
         /* Return 1 if the two keys are identical */
         if (memcmp(nc_path1->prev_hop, nc_path2->prev_hop,
                    sizeof(nc_path1->prev_hop)) != 0)
-                return 0;
+                return false;
 
         if (memcmp(nc_path1->next_hop, nc_path2->next_hop,
                    sizeof(nc_path1->next_hop)) != 0)
-                return 0;
+                return false;
 
-        return 1;
+        return true;
 }
 
 /**
diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 04fa139911c3..1ff4ee473966 100644
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -54,9 +54,9 @@ static void batadv_purge_orig(struct work_struct *work);
  * @node: node in the local table
  * @data2: second object to compare the node to
  *
- * Return: 1 if they are the same originator
+ * Return: true if they are the same originator
  */
-int batadv_compare_orig(const struct hlist_node *node, const void *data2)
+bool batadv_compare_orig(const struct hlist_node *node, const void *data2)
 {
         const void *data1 = container_of(node, struct batadv_orig_node,
                                          hash_entry);
diff --git a/net/batman-adv/originator.h b/net/batman-adv/originator.h
index 4e8b67f11051..64a8951e5844 100644
--- a/net/batman-adv/originator.h
+++ b/net/batman-adv/originator.h
@@ -33,7 +33,7 @@
 
 struct seq_file;
 
-int batadv_compare_orig(const struct hlist_node *node, const void *data2);
+bool batadv_compare_orig(const struct hlist_node *node, const void *data2);
 int batadv_originator_init(struct batadv_priv *bat_priv);
 void batadv_originator_free(struct batadv_priv *bat_priv);
 void batadv_purge_orig_ref(struct batadv_priv *bat_priv);
diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c
index b494e435686f..ae850f2d11cb 100644
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@ -163,18 +163,18 @@ out:
  *   doesn't change otherwise.
  *
  * Return:
- *  0 if the packet is to be accepted.
- *  1 if the packet is to be ignored.
+ *  false if the packet is to be accepted.
+ *  true if the packet is to be ignored.
  */
-int batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
-                            s32 seq_old_max_diff, unsigned long *last_reset,
-                            bool *protection_started)
+bool batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
+                             s32 seq_old_max_diff, unsigned long *last_reset,
+                             bool *protection_started)
 {
         if (seq_num_diff <= -seq_old_max_diff ||
             seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
                 if (!batadv_has_timed_out(*last_reset,
                                           BATADV_RESET_PROTECTION_MS))
-                        return 1;
+                        return true;
 
                 *last_reset = jiffies;
                 if (protection_started)
@@ -183,7 +183,7 @@ int batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
                            "old packet received, start protection\n");
         }
 
-        return 0;
+        return false;
 }
 
 bool batadv_check_management_packet(struct sk_buff *skb,
@@ -718,8 +718,9 @@ out:
         return ret;
 }
 
-static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
-                                     struct sk_buff *skb, int hdr_len) {
+static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
+                                      struct sk_buff *skb, int hdr_len)
+{
         struct batadv_unicast_packet *unicast_packet;
         struct batadv_hard_iface *primary_if;
         struct batadv_orig_node *orig_node;
@@ -730,11 +731,11 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
 
         /* check if there is enough data before accessing it */
         if (!pskb_may_pull(skb, hdr_len + ETH_HLEN))
-                return 0;
+                return false;
 
         /* create a copy of the skb (in case of for re-routing) to modify it. */
         if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
-                return 0;
+                return false;
 
         unicast_packet = (struct batadv_unicast_packet *)skb->data;
         vid = batadv_get_vid(skb, hdr_len);
@@ -758,7 +759,7 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
                  * table. If not, let the packet go untouched anyway because
                  * there is nothing the node can do
                  */
-                return 1;
+                return true;
         }
 
         /* retrieve the TTVN known by this node for the packet destination. This
@@ -774,7 +775,7 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
                  * not be possible to deliver it
                  */
                 if (!orig_node)
-                        return 0;
+                        return false;
 
                 curr_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
                 batadv_orig_node_put(orig_node);
@@ -785,7 +786,7 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
          */
         is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
         if (!is_old_ttvn)
-                return 1;
+                return true;
 
         old_ttvn = unicast_packet->ttvn;
         /* the packet was forged based on outdated network information. Its
@@ -798,7 +799,7 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
                                        "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
                                        unicast_packet->dest, ethhdr->h_dest,
                                        old_ttvn, curr_ttvn);
-                return 1;
+                return true;
         }
 
         /* the packet has not been re-routed: either the destination is
@@ -806,14 +807,14 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
          * it is possible to drop the packet
          */
         if (!batadv_is_my_client(bat_priv, ethhdr->h_dest, vid))
-                return 0;
+                return false;
 
         /* update the header in order to let the packet be delivered to this
          * node's soft interface
          */
         primary_if = batadv_primary_if_get_selected(bat_priv);
         if (!primary_if)
-                return 0;
+                return false;
 
         ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
 
@@ -821,7 +822,7 @@ static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
 
         unicast_packet->ttvn = curr_ttvn;
 
-        return 1;
+        return true;
 }
 
 /**
diff --git a/net/batman-adv/routing.h b/net/batman-adv/routing.h
index 02a5caa84127..05c3ff42e181 100644
--- a/net/batman-adv/routing.h
+++ b/net/batman-adv/routing.h
@@ -51,8 +51,8 @@ struct batadv_neigh_node *
 batadv_find_router(struct batadv_priv *bat_priv,
                    struct batadv_orig_node *orig_node,
                    struct batadv_hard_iface *recv_if);
-int batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
-                            s32 seq_old_max_diff, unsigned long *last_reset,
-                            bool *protection_started);
+bool batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
+                             s32 seq_old_max_diff, unsigned long *last_reset,
+                             bool *protection_started);
 
 #endif /* _NET_BATMAN_ADV_ROUTING_H_ */
diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c
index 04866c9b860a..3a0fc3c18444 100644
--- a/net/batman-adv/soft-interface.c
+++ b/net/batman-adv/soft-interface.c
@@ -1045,12 +1045,12 @@ static void batadv_softif_destroy_netlink(struct net_device *soft_iface,
         unregister_netdevice_queue(soft_iface, head);
 }
 
-int batadv_softif_is_valid(const struct net_device *net_dev)
+bool batadv_softif_is_valid(const struct net_device *net_dev)
 {
         if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
-                return 1;
+                return true;
 
-        return 0;
+        return false;
 }
 
 struct rtnl_link_ops batadv_link_ops __read_mostly = {
diff --git a/net/batman-adv/soft-interface.h b/net/batman-adv/soft-interface.h
index b0966342a986..ec303ddbf647 100644
--- a/net/batman-adv/soft-interface.h
+++ b/net/batman-adv/soft-interface.h
@@ -20,6 +20,7 @@
 
 #include "main.h"
 
+#include <linux/types.h>
 #include <net/rtnetlink.h>
 
 struct net_device;
@@ -32,7 +33,7 @@ void batadv_interface_rx(struct net_device *soft_iface,
                          struct batadv_orig_node *orig_node);
 struct net_device *batadv_softif_create(struct net *net, const char *name);
 void batadv_softif_destroy_sysfs(struct net_device *soft_iface);
-int batadv_softif_is_valid(const struct net_device *net_dev);
+bool batadv_softif_is_valid(const struct net_device *net_dev);
 extern struct rtnl_link_ops batadv_link_ops;
 int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid);
 void batadv_softif_vlan_put(struct batadv_softif_vlan *softif_vlan);
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index 6ea6e9bf9a8c..feaf492b01ca 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -75,9 +75,9 @@ static void batadv_tt_global_del(struct batadv_priv *bat_priv,
  *
  * Compare the MAC address and the VLAN ID of the two TT entries and check if
  * they are the same TT client.
- * Return: 1 if the two TT clients are the same, 0 otherwise
+ * Return: true if the two TT clients are the same, false otherwise
  */
-static int batadv_compare_tt(const struct hlist_node *node, const void *data2)
+static bool batadv_compare_tt(const struct hlist_node *node, const void *data2)
 {
         const void *data1 = container_of(node, struct batadv_tt_common_entry,
                                          hash_entry);
@@ -2361,19 +2361,19 @@ unlock:
  * @entry_ptr: to be checked local tt entry
  * @data_ptr: not used but definition required to satisfy the callback prototype
  *
- * Return: 1 if the entry is a valid, 0 otherwise.
+ * Return: true if the entry is a valid, false otherwise.
  */
-static int batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)
+static bool batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)
 {
         const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
 
         if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
-                return 0;
-        return 1;
+                return false;
+        return true;
 }
 
-static int batadv_tt_global_valid(const void *entry_ptr,
-                                  const void *data_ptr)
+static bool batadv_tt_global_valid(const void *entry_ptr,
+                                   const void *data_ptr)
 {
         const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
         const struct batadv_tt_global_entry *tt_global_entry;
@@ -2381,7 +2381,7 @@ static int batadv_tt_global_valid(const void *entry_ptr,
 
         if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
             tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
-                return 0;
+                return false;
 
         tt_global_entry = container_of(tt_common_entry,
                                        struct batadv_tt_global_entry,
@@ -2403,7 +2403,8 @@ static int batadv_tt_global_valid(const void *entry_ptr,
 static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
                                     struct batadv_hashtable *hash,
                                     void *tvlv_buff, u16 tt_len,
-                                    int (*valid_cb)(const void *, const void *),
+                                    bool (*valid_cb)(const void *,
+                                                     const void *),
                                     void *cb_data)
 {
         struct batadv_tt_common_entry *tt_common_entry;
@@ -2552,11 +2553,11 @@ static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
  *
  * Return: true if the TT Request was sent, false otherwise
  */
-static int batadv_send_tt_request(struct batadv_priv *bat_priv,
-                                  struct batadv_orig_node *dst_orig_node,
-                                  u8 ttvn,
-                                  struct batadv_tvlv_tt_vlan_data *tt_vlan,
-                                  u16 num_vlan, bool full_table)
+static bool batadv_send_tt_request(struct batadv_priv *bat_priv,
+                                   struct batadv_orig_node *dst_orig_node,
+                                   u8 ttvn,
+                                   struct batadv_tvlv_tt_vlan_data *tt_vlan,
+                                   u16 num_vlan, bool full_table)
 {
         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
         struct batadv_tt_req_node *tt_req_node = NULL;