}
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        return res;
 }
 
        rcu_read_unlock();
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface)
 unlock:
        rcu_read_unlock();
 out:
-       if (neigh_node)
-               batadv_neigh_node_put(neigh_node);
-       if (router)
-               batadv_neigh_node_put(router);
-       if (neigh_ifinfo)
-               batadv_neigh_ifinfo_put(neigh_ifinfo);
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_neigh_node_put(neigh_node);
+       batadv_neigh_node_put(router);
+       batadv_neigh_ifinfo_put(neigh_ifinfo);
+       batadv_neigh_ifinfo_put(router_ifinfo);
 }
 
 /**
                ret = true;
 
 out:
-       if (neigh_node)
-               batadv_neigh_node_put(neigh_node);
+       batadv_neigh_node_put(neigh_node);
        return ret;
 }
 
        if (orig_neigh_node && !is_single_hop_neigh)
                batadv_orig_node_put(orig_neigh_node);
 out:
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
-       if (router)
-               batadv_neigh_node_put(router);
-       if (router_router)
-               batadv_neigh_node_put(router_router);
-       if (orig_neigh_router)
-               batadv_neigh_node_put(orig_neigh_router);
-       if (hardif_neigh)
-               batadv_hardif_neigh_put(hardif_neigh);
+       batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_neigh_node_put(router);
+       batadv_neigh_node_put(router_router);
+       batadv_neigh_node_put(orig_neigh_router);
+       batadv_hardif_neigh_put(hardif_neigh);
 
        consume_skb(skb_priv);
 }
        }
 
  out:
-       if (neigh_node_best)
-               batadv_neigh_node_put(neigh_node_best);
+       batadv_neigh_node_put(neigh_node_best);
 
        *sub_s = 0;
        return 0;
        *diff = (int)tq1 - (int)tq2;
 
 out:
-       if (neigh1_ifinfo)
-               batadv_neigh_ifinfo_put(neigh1_ifinfo);
-       if (neigh2_ifinfo)
-               batadv_neigh_ifinfo_put(neigh2_ifinfo);
+       batadv_neigh_ifinfo_put(neigh1_ifinfo);
+       batadv_neigh_ifinfo_put(neigh2_ifinfo);
 
        return ret;
 }
                        if (tmp_gw_factor > max_gw_factor ||
                            (tmp_gw_factor == max_gw_factor &&
                             tq_avg > max_tq)) {
-                               if (curr_gw)
-                                       batadv_gw_node_put(curr_gw);
+                               batadv_gw_node_put(curr_gw);
                                curr_gw = gw_node;
                                kref_get(&curr_gw->refcount);
                        }
                          *     $routing_class more tq points)
                          */
                        if (tq_avg > max_tq) {
-                               if (curr_gw)
-                                       batadv_gw_node_put(curr_gw);
+                               batadv_gw_node_put(curr_gw);
                                curr_gw = gw_node;
                                kref_get(&curr_gw->refcount);
                        }
 
 next:
                batadv_neigh_node_put(router);
-               if (router_ifinfo)
-                       batadv_neigh_ifinfo_put(router_ifinfo);
+               batadv_neigh_ifinfo_put(router_ifinfo);
        }
        rcu_read_unlock();
 
 
        ret = true;
 out:
-       if (router_gw_ifinfo)
-               batadv_neigh_ifinfo_put(router_gw_ifinfo);
-       if (router_orig_ifinfo)
-               batadv_neigh_ifinfo_put(router_orig_ifinfo);
-       if (router_gw)
-               batadv_neigh_node_put(router_gw);
-       if (router_orig)
-               batadv_neigh_node_put(router_orig);
+       batadv_neigh_ifinfo_put(router_gw_ifinfo);
+       batadv_neigh_ifinfo_put(router_orig_ifinfo);
+       batadv_neigh_node_put(router_gw);
+       batadv_neigh_node_put(router_orig);
 
        return ret;
 }
        ret = 0;
 
 out:
-       if (curr_gw)
-               batadv_gw_node_put(curr_gw);
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
-       if (router)
-               batadv_neigh_node_put(router);
+       batadv_gw_node_put(curr_gw);
+       batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_neigh_node_put(router);
        return ret;
 }
 
 
 
        batadv_v_primary_iface_set(hard_iface);
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 static void
        }
 
  out:
-       if (neigh_node_best)
-               batadv_neigh_node_put(neigh_node_best);
+       batadv_neigh_node_put(neigh_node_best);
 
        *sub_s = 0;
        return 0;
 
        ret = 0;
 out:
-       if (router)
-               batadv_neigh_node_put(router);
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_neigh_node_put(router);
+       batadv_neigh_ifinfo_put(router_ifinfo);
 
        return ret;
 }
                if (curr_gw && bw <= max_bw)
                        goto next;
 
-               if (curr_gw)
-                       batadv_gw_node_put(curr_gw);
+               batadv_gw_node_put(curr_gw);
 
                curr_gw = gw_node;
                kref_get(&curr_gw->refcount);
 
        ret = true;
 out:
-       if (curr_gw)
-               batadv_gw_node_put(curr_gw);
-       if (orig_gw)
-               batadv_gw_node_put(orig_gw);
+       batadv_gw_node_put(curr_gw);
+       batadv_gw_node_put(orig_gw);
 
        return ret;
 }
        ret = 0;
 
 out:
-       if (curr_gw)
-               batadv_gw_node_put(curr_gw);
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
-       if (router)
-               batadv_neigh_node_put(router);
+       batadv_gw_node_put(curr_gw);
+       batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_neigh_node_put(router);
        return ret;
 }
 
 
        hardif_neigh->bat_v.elp_interval = ntohl(elp_packet->elp_interval);
 
 hardif_free:
-       if (hardif_neigh)
-               batadv_hardif_neigh_put(hardif_neigh);
+       batadv_hardif_neigh_put(hardif_neigh);
 neigh_free:
-       if (neigh)
-               batadv_neigh_node_put(neigh);
+       batadv_neigh_node_put(neigh);
 orig_free:
-       if (orig_neigh)
-               batadv_orig_node_put(orig_neigh);
+       batadv_orig_node_put(orig_neigh);
 }
 
 /**
 
        batadv_v_ogm_queue_on_if(skb, if_outgoing);
 
 out:
-       if (orig_ifinfo)
-               batadv_orig_ifinfo_put(orig_ifinfo);
-       if (router)
-               batadv_neigh_node_put(router);
-       if (neigh_ifinfo)
-               batadv_neigh_ifinfo_put(neigh_ifinfo);
+       batadv_orig_ifinfo_put(orig_ifinfo);
+       batadv_neigh_node_put(router);
+       batadv_neigh_ifinfo_put(neigh_ifinfo);
 }
 
 /**
        else
                ret = 0;
 out:
-       if (orig_ifinfo)
-               batadv_orig_ifinfo_put(orig_ifinfo);
-       if (neigh_ifinfo)
-               batadv_neigh_ifinfo_put(neigh_ifinfo);
+       batadv_orig_ifinfo_put(orig_ifinfo);
+       batadv_neigh_ifinfo_put(neigh_ifinfo);
 
        return ret;
 }
 
        batadv_update_route(bat_priv, orig_node, if_outgoing, neigh_node);
 out:
-       if (router)
-               batadv_neigh_node_put(router);
-       if (orig_neigh_router)
-               batadv_neigh_node_put(orig_neigh_router);
-       if (orig_neigh_node)
-               batadv_orig_node_put(orig_neigh_node);
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
-       if (neigh_ifinfo)
-               batadv_neigh_ifinfo_put(neigh_ifinfo);
+       batadv_neigh_node_put(router);
+       batadv_neigh_node_put(orig_neigh_router);
+       batadv_orig_node_put(orig_neigh_node);
+       batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_neigh_ifinfo_put(neigh_ifinfo);
 
        return forward;
 }
        }
        rcu_read_unlock();
 out:
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
-       if (neigh_node)
-               batadv_neigh_node_put(neigh_node);
-       if (hardif_neigh)
-               batadv_hardif_neigh_put(hardif_neigh);
+       batadv_orig_node_put(orig_node);
+       batadv_neigh_node_put(neigh_node);
+       batadv_hardif_neigh_put(hardif_neigh);
 }
 
 /**
 
 
        netif_rx_any_context(skb);
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 /**
                rcu_read_unlock();
        }
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
                           msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
                batadv_hash_destroy(bat_priv->bla.backbone_hash);
                bat_priv->bla.backbone_hash = NULL;
        }
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 /**
        ret = true;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
-       if (claim)
-               batadv_claim_put(claim);
+       batadv_hardif_put(primary_if);
+       batadv_claim_put(claim);
        return ret;
 }
 
 handled:
        ret = true;
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
-       if (claim)
-               batadv_claim_put(claim);
+       batadv_hardif_put(primary_if);
+       batadv_claim_put(claim);
        return ret;
 }
 
        ret = msg->len;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        dev_put(soft_iface);
 
        ret = msg->len;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        dev_put(soft_iface);
 
 
                   &dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid));
 
 out:
-       if (dat_entry)
-               batadv_dat_entry_put(dat_entry);
+       batadv_dat_entry_put(dat_entry);
 }
 
 #ifdef CONFIG_BATMAN_ADV_DEBUG
                                continue;
 
                        max = tmp_max;
-                       if (max_orig_node)
-                               batadv_orig_node_put(max_orig_node);
+                       batadv_orig_node_put(max_orig_node);
                        max_orig_node = orig_node;
                }
                rcu_read_unlock();
        ret = msg->len;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        dev_put(soft_iface);
 
                                              BATADV_P_DAT_DHT_GET);
        }
 out:
-       if (dat_entry)
-               batadv_dat_entry_put(dat_entry);
+       batadv_dat_entry_put(dat_entry);
        return ret;
 }
 
                ret = true;
        }
 out:
-       if (dat_entry)
-               batadv_dat_entry_put(dat_entry);
+       batadv_dat_entry_put(dat_entry);
        if (ret)
                kfree_skb(skb);
        return ret;
 out:
        if (dropped)
                kfree_skb(skb);
-       if (dat_entry)
-               batadv_dat_entry_put(dat_entry);
+       batadv_dat_entry_put(dat_entry);
        /* if dropped == false -> deliver to the interface */
        return dropped;
 }
        ret = true;
 
 out:
-       if (dat_entry)
-               batadv_dat_entry_put(dat_entry);
+       batadv_dat_entry_put(dat_entry);
        return ret;
 }
 
        }
 
 out:
-       if (orig_node_dst)
-               batadv_orig_node_put(orig_node_dst);
-       if (neigh_node)
-               batadv_neigh_node_put(neigh_node);
+       batadv_orig_node_put(orig_node_dst);
+       batadv_neigh_node_put(neigh_node);
        return ret;
 }
 
 
 unlock:
        rcu_read_unlock();
 out:
-       if (gw_node)
-               batadv_gw_node_put(gw_node);
+       batadv_gw_node_put(gw_node);
        return orig_node;
 }
 
        curr_gw_node = rcu_replace_pointer(bat_priv->gw.curr_gw, new_gw_node,
                                           true);
 
-       if (curr_gw_node)
-               batadv_gw_node_put(curr_gw_node);
+       batadv_gw_node_put(curr_gw_node);
 
        spin_unlock_bh(&bat_priv->gw.list_lock);
 }
        batadv_gw_select(bat_priv, next_gw);
 
 out:
-       if (curr_gw)
-               batadv_gw_node_put(curr_gw);
-       if (next_gw)
-               batadv_gw_node_put(next_gw);
-       if (router)
-               batadv_neigh_node_put(router);
-       if (router_ifinfo)
-               batadv_neigh_ifinfo_put(router_ifinfo);
+       batadv_gw_node_put(curr_gw);
+       batadv_gw_node_put(next_gw);
+       batadv_neigh_node_put(router);
+       batadv_neigh_ifinfo_put(router_ifinfo);
 }
 
 /**
 reselect:
        batadv_gw_reselect(bat_priv);
 out:
-       if (curr_gw_orig)
-               batadv_orig_node_put(curr_gw_orig);
+       batadv_orig_node_put(curr_gw_orig);
 }
 
 /**
                if (gw_node == curr_gw)
                        batadv_gw_reselect(bat_priv);
 
-               if (curr_gw)
-                       batadv_gw_node_put(curr_gw);
+               batadv_gw_node_put(curr_gw);
        }
 
 out:
-       if (gw_node)
-               batadv_gw_node_put(gw_node);
+       batadv_gw_node_put(gw_node);
 }
 
 /**
        ret = msg->len;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        dev_put(soft_iface);
 
        return ret;
        batadv_neigh_ifinfo_put(old_ifinfo);
 
 out:
-       if (orig_dst_node)
-               batadv_orig_node_put(orig_dst_node);
-       if (curr_gw)
-               batadv_gw_node_put(curr_gw);
-       if (gw_node)
-               batadv_gw_node_put(gw_node);
-       if (neigh_old)
-               batadv_neigh_node_put(neigh_old);
-       if (neigh_curr)
-               batadv_neigh_node_put(neigh_curr);
+       batadv_orig_node_put(orig_dst_node);
+       batadv_gw_node_put(curr_gw);
+       batadv_gw_node_put(gw_node);
+       batadv_neigh_node_put(neigh_old);
+       batadv_neigh_node_put(neigh_curr);
        return out_of_range;
 }
 
        real_netdev = dev_get_by_index(real_net, ifindex);
 
 out:
-       if (hard_iface)
-               batadv_hardif_put(hard_iface);
+       batadv_hardif_put(hard_iface);
        return real_netdev;
 }
 
        batadv_dat_init_own_addr(bat_priv, primary_if);
        batadv_bla_update_orig_address(bat_priv, primary_if, oldif);
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 static void batadv_primary_if_select(struct batadv_priv *bat_priv,
        batadv_primary_if_update_addr(bat_priv, curr_hard_iface);
 
 out:
-       if (curr_hard_iface)
-               batadv_hardif_put(curr_hard_iface);
+       batadv_hardif_put(curr_hard_iface);
 }
 
 static bool
                bat_priv->algo_ops->iface.activate(hard_iface);
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 static void
                new_if = batadv_hardif_get_active(hard_iface->soft_iface);
                batadv_primary_if_select(bat_priv, new_if);
 
-               if (new_if)
-                       batadv_hardif_put(new_if);
+               batadv_hardif_put(new_if);
        }
 
        bat_priv->algo_ops->iface.disable(hard_iface);
        batadv_hardif_put(hard_iface);
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 static struct batadv_hard_iface *
 hardif_put:
        batadv_hardif_put(hard_iface);
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        return NOTIFY_DONE;
 }
 
 
 
        if (!ret && primary_if)
                *primary_if = hard_iface;
-       else if (hard_iface)
+       else
                batadv_hardif_put(hard_iface);
 
        return ret;
 
                        atomic_read(&bat_priv->orig_interval)))
                goto nla_put_failure;
 
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        genlmsg_end(msg, hdr);
        return 0;
 
 nla_put_failure:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        genlmsg_cancel(msg, hdr);
        return -EMSGSIZE;
 
        out_nc_node->last_seen = jiffies;
 
 out:
-       if (in_nc_node)
-               batadv_nc_node_put(in_nc_node);
-       if (out_nc_node)
-               batadv_nc_node_put(out_nc_node);
+       batadv_nc_node_put(in_nc_node);
+       batadv_nc_node_put(out_nc_node);
 }
 
 /**
        batadv_send_unicast_skb(skb_dest, first_dest);
        res = true;
 out:
-       if (router_neigh)
-               batadv_neigh_node_put(router_neigh);
-       if (router_coding)
-               batadv_neigh_node_put(router_coding);
-       if (router_neigh_ifinfo)
-               batadv_neigh_ifinfo_put(router_neigh_ifinfo);
-       if (router_coding_ifinfo)
-               batadv_neigh_ifinfo_put(router_coding_ifinfo);
+       batadv_neigh_node_put(router_neigh);
+       batadv_neigh_node_put(router_coding);
+       batadv_neigh_ifinfo_put(router_neigh_ifinfo);
+       batadv_neigh_ifinfo_put(router_coding_ifinfo);
        return res;
 }
 
 
 out:
        spin_unlock_bh(&orig_node->neigh_list_lock);
 
-       if (hardif_neigh)
-               batadv_hardif_neigh_put(hardif_neigh);
+       batadv_hardif_neigh_put(hardif_neigh);
        return neigh_node;
 }
 
        ret = msg->len;
 
  out:
-       if (hardif)
-               batadv_hardif_put(hardif);
+       batadv_hardif_put(hardif);
        dev_put(hard_iface);
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        dev_put(soft_iface);
 
        return ret;
 
        /* this is the last reference to this object */
        router = rcu_dereference_protected(orig_ifinfo->router, true);
-       if (router)
-               batadv_neigh_node_put(router);
+       batadv_neigh_node_put(router);
 
        kfree_rcu(orig_ifinfo, rcu);
 }
        orig_node->last_bonding_candidate = NULL;
        spin_unlock_bh(&orig_node->neigh_list_lock);
 
-       if (last_candidate)
-               batadv_orig_ifinfo_put(last_candidate);
+       batadv_orig_ifinfo_put(last_candidate);
 
        spin_lock_bh(&orig_node->vlan_list_lock);
        hlist_for_each_entry_safe(vlan, node_tmp, &orig_node->vlan_list, list) {
                if (!kref_get_unless_zero(&neigh->refcount))
                        continue;
 
-               if (best)
-                       batadv_neigh_node_put(best);
+               batadv_neigh_node_put(best);
 
                best = neigh;
        }
                                                    BATADV_IF_DEFAULT);
        batadv_update_route(bat_priv, orig_node, BATADV_IF_DEFAULT,
                            best_neigh_node);
-       if (best_neigh_node)
-               batadv_neigh_node_put(best_neigh_node);
+       batadv_neigh_node_put(best_neigh_node);
 
        /* ... then for all other interfaces. */
        rcu_read_lock();
                                                            hard_iface);
                batadv_update_route(bat_priv, orig_node, hard_iface,
                                    best_neigh_node);
-               if (best_neigh_node)
-                       batadv_neigh_node_put(best_neigh_node);
+               batadv_neigh_node_put(best_neigh_node);
 
                batadv_hardif_put(hard_iface);
        }
        ret = msg->len;
 
  out:
-       if (hardif)
-               batadv_hardif_put(hardif);
+       batadv_hardif_put(hardif);
        dev_put(hard_iface);
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        dev_put(soft_iface);
 
        return ret;
 
        }
 
        /* decrease refcount of previous best neighbor */
-       if (curr_router)
-               batadv_neigh_node_put(curr_router);
+       batadv_neigh_node_put(curr_router);
 }
 
 /**
                _batadv_update_route(bat_priv, orig_node, recv_if, neigh_node);
 
 out:
-       if (router)
-               batadv_neigh_node_put(router);
+       batadv_neigh_node_put(router);
 }
 
 /**
                goto out;
        }
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
 
        kfree_skb(skb);
 
        skb = NULL;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
 
        kfree_skb(skb);
 
        skb = NULL;
 
 put_orig_node:
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
 free_skb:
        kfree_skb(skb);
 
        orig_node->last_bonding_candidate = new_candidate;
        spin_unlock_bh(&orig_node->neigh_list_lock);
 
-       if (old_candidate)
-               batadv_orig_ifinfo_put(old_candidate);
+       batadv_orig_ifinfo_put(old_candidate);
 }
 
 /**
                batadv_orig_ifinfo_put(next_candidate);
        }
 
-       if (last_candidate)
-               batadv_orig_ifinfo_put(last_candidate);
+       batadv_orig_ifinfo_put(last_candidate);
 
        return router;
 }
 
        ret = true;
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
 
        return ret;
 }
                                    orig_node);
 
 rx_success:
-               if (orig_node)
-                       batadv_orig_node_put(orig_node);
+               batadv_orig_node_put(orig_node);
 
                return NET_RX_SUCCESS;
        }
        kfree_skb(skb);
        ret = NET_RX_DROP;
 out:
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
        return ret;
 }
 
        if (hardif_neigh && ret != NET_XMIT_DROP)
                hardif_neigh->bat_v.last_unicast_tx = jiffies;
 
-       if (hardif_neigh)
-               batadv_hardif_neigh_put(hardif_neigh);
+       batadv_hardif_neigh_put(hardif_neigh);
 #endif
 
        return ret;
 
        ret = true;
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        return ret;
 }
 
        ret = batadv_send_skb_unicast(bat_priv, skb, packet_type,
                                      packet_subtype, orig_node, vid);
 
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
 
        return ret;
 }
        ret = batadv_send_skb_unicast(bat_priv, skb, BATADV_UNICAST_4ADDR,
                                      BATADV_P_DATA, orig_node, vid);
 
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
 
        return ret;
 }
        else
                consume_skb(forw_packet->skb);
 
-       if (forw_packet->if_incoming)
-               batadv_hardif_put(forw_packet->if_incoming);
-       if (forw_packet->if_outgoing)
-               batadv_hardif_put(forw_packet->if_outgoing);
+       batadv_hardif_put(forw_packet->if_incoming);
+       batadv_hardif_put(forw_packet->if_outgoing);
        if (forw_packet->queue_left)
                atomic_inc(forw_packet->queue_left);
        kfree(forw_packet);
        ret = batadv_hardif_no_broadcast(if_out, bcast_packet->orig,
                                         orig_neigh);
 
-       if (neigh_node)
-               batadv_hardif_neigh_put(neigh_node);
+       batadv_hardif_neigh_put(neigh_node);
 
        /* ok, may broadcast */
        if (!ret)
 
 dropped_freed:
        batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 end:
-       if (mcast_single_orig)
-               batadv_orig_node_put(mcast_single_orig);
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_orig_node_put(mcast_single_orig);
+       batadv_hardif_put(primary_if);
        return NETDEV_TX_OK;
 }
 
        ret = batadv_hardif_enable_interface(hard_iface, dev);
 
 out:
-       if (hard_iface)
-               batadv_hardif_put(hard_iface);
+       batadv_hardif_put(hard_iface);
        return ret;
 }
 
        ret = 0;
 
 out:
-       if (hard_iface)
-               batadv_hardif_put(hard_iface);
+       batadv_hardif_put(hard_iface);
        return ret;
 }
 
 
 
        wake_up(&tp_vars->more_bytes);
 out:
-       if (likely(primary_if))
-               batadv_hardif_put(primary_if);
-       if (likely(orig_node))
-               batadv_orig_node_put(orig_node);
-       if (likely(tp_vars))
-               batadv_tp_vars_put(tp_vars);
+       batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
+       batadv_tp_vars_put(tp_vars);
 }
 
 /**
        }
 
 out:
-       if (likely(primary_if))
-               batadv_hardif_put(primary_if);
-       if (likely(orig_node))
-               batadv_orig_node_put(orig_node);
+       batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
 
        batadv_tp_sender_end(bat_priv, tp_vars);
        batadv_tp_sender_cleanup(bat_priv, tp_vars);
        ret = 0;
 
 out:
-       if (likely(orig_node))
-               batadv_orig_node_put(orig_node);
-       if (likely(primary_if))
-               batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
+       batadv_hardif_put(primary_if);
 
        return ret;
 }
        batadv_tp_send_ack(bat_priv, icmp->orig, tp_vars->last_recv,
                           icmp->timestamp, icmp->session, icmp->uid);
 out:
-       if (likely(tp_vars))
-               batadv_tp_vars_put(tp_vars);
+       batadv_tp_vars_put(tp_vars);
 }
 
 /**
 
 
        ret = true;
 out:
-       if (in_hardif)
-               batadv_hardif_put(in_hardif);
+       batadv_hardif_put(in_hardif);
        dev_put(in_dev);
-       if (tt_local)
-               batadv_tt_local_entry_put(tt_local);
-       if (tt_global)
-               batadv_tt_global_entry_put(tt_global);
+       batadv_tt_local_entry_put(tt_local);
+       batadv_tt_global_entry_put(tt_global);
        return ret;
 }
 
        ret = msg->len;
 
  out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        dev_put(soft_iface);
 
        cb->args[0] = bucket;
        batadv_tt_local_entry_put(tt_removed_entry);
 
 out:
-       if (tt_local_entry)
-               batadv_tt_local_entry_put(tt_local_entry);
+       batadv_tt_local_entry_put(tt_local_entry);
 
        return curr_flags;
 }
 sync_flags:
        batadv_tt_global_sync_flags(tt_global);
 out:
-       if (orig_entry)
-               batadv_tt_orig_list_entry_put(orig_entry);
+       batadv_tt_orig_list_entry_put(orig_entry);
 
        spin_unlock_bh(&tt_global->list_lock);
 }
                tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
 
 out:
-       if (tt_global_entry)
-               batadv_tt_global_entry_put(tt_global_entry);
-       if (tt_local_entry)
-               batadv_tt_local_entry_put(tt_local_entry);
+       batadv_tt_global_entry_put(tt_global_entry);
+       batadv_tt_local_entry_put(tt_local_entry);
        return ret;
 }
 
                }
 
                /* release the refcount for the "old" best */
-               if (best_router)
-                       batadv_neigh_node_put(best_router);
+               batadv_neigh_node_put(best_router);
 
                best_entry = orig_entry;
                best_router = router;
        }
 
-       if (best_router)
-               batadv_neigh_node_put(best_router);
+       batadv_neigh_node_put(best_router);
 
        return best_entry;
 }
        ret = msg->len;
 
  out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
        dev_put(soft_iface);
 
        cb->args[0] = bucket;
        }
 
 out:
-       if (tt_global_entry)
-               batadv_tt_global_entry_put(tt_global_entry);
-       if (local_entry)
-               batadv_tt_local_entry_put(local_entry);
+       batadv_tt_global_entry_put(tt_global_entry);
+       batadv_tt_local_entry_put(local_entry);
 }
 
 /**
        rcu_read_unlock();
 
 out:
-       if (tt_global_entry)
-               batadv_tt_global_entry_put(tt_global_entry);
-       if (tt_local_entry)
-               batadv_tt_local_entry_put(tt_local_entry);
+       batadv_tt_global_entry_put(tt_global_entry);
+       batadv_tt_local_entry_put(tt_local_entry);
 
        return orig_node;
 }
        ret = true;
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 
        if (ret && tt_req_node) {
                spin_lock_bh(&bat_priv->tt.req_list_lock);
                spin_unlock_bh(&bat_priv->tt.req_list_lock);
        }
 
-       if (tt_req_node)
-               batadv_tt_req_node_put(tt_req_node);
+       batadv_tt_req_node_put(tt_req_node);
 
        kfree(tvlv_tt_data);
        return ret;
        spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
 
 out:
-       if (res_dst_orig_node)
-               batadv_orig_node_put(res_dst_orig_node);
-       if (req_dst_orig_node)
-               batadv_orig_node_put(req_dst_orig_node);
+       batadv_orig_node_put(res_dst_orig_node);
+       batadv_orig_node_put(req_dst_orig_node);
        kfree(tvlv_tt_data);
        return ret;
 }
        spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
 out:
        spin_unlock_bh(&bat_priv->tt.commit_lock);
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_orig_node_put(orig_node);
+       batadv_hardif_put(primary_if);
        kfree(tvlv_tt_data);
        /* The packet was for this host, so it doesn't need to be re-routed */
        return true;
        atomic_set(&orig_node->last_ttvn, ttvn);
 
 out:
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
 }
 
 static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
                goto out;
        ret = true;
 out:
-       if (tt_local_entry)
-               batadv_tt_local_entry_put(tt_local_entry);
+       batadv_tt_local_entry_put(tt_local_entry);
        return ret;
 }
 
 
        spin_unlock_bh(&bat_priv->tt.req_list_lock);
 out:
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
 }
 
 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
                                 &tvlv_roam, sizeof(tvlv_roam));
 
 out:
-       if (primary_if)
-               batadv_hardif_put(primary_if);
+       batadv_hardif_put(primary_if);
 }
 
 static void batadv_tt_purge(struct work_struct *work)
                             atomic_read(&orig_node->last_ttvn) + 1);
 
 out:
-       if (orig_node)
-               batadv_orig_node_put(orig_node);
+       batadv_orig_node_put(orig_node);
        return NET_RX_SUCCESS;
 }
 
 
                                                ogm_source, orig_node,
                                                src, dst, tvlv_value,
                                                tvlv_value_cont_len);
-               if (tvlv_handler)
-                       batadv_tvlv_handler_put(tvlv_handler);
+               batadv_tvlv_handler_put(tvlv_handler);
                tvlv_value = (u8 *)tvlv_value + tvlv_value_cont_len;
                tvlv_value_len -= tvlv_value_cont_len;
        }