struct net_device *dev = idev->dev;
 
        WARN_ON(!list_empty(&idev->addr_list));
-       WARN_ON(idev->mc_list != NULL);
+       WARN_ON(idev->mc_list);
        WARN_ON(timer_pending(&idev->rs_timer));
 
 #ifdef NET_REFCNT_DEBUG
 
        /* Release rx options */
 
        skb = xchg(&np->pktoptions, NULL);
-       if (skb != NULL)
+       if (skb)
                kfree_skb(skb);
 
        skb = xchg(&np->rxpmtu, NULL);
-       if (skb != NULL)
+       if (skb)
                kfree_skb(skb);
 
        /* Free flowlabels */
        /* Free tx options */
 
        opt = xchg(&np->opt, NULL);
-       if (opt != NULL)
+       if (opt)
                sock_kfree_s(sk, opt, opt->tot_len);
 }
 EXPORT_SYMBOL_GPL(inet6_destroy_sock);
 
 
                WARN_ON(fn->fn_flags & RTN_RTINFO);
                WARN_ON(fn->fn_flags & RTN_TL_ROOT);
-               WARN_ON(fn->leaf != NULL);
+               WARN_ON(fn->leaf);
 
                children = 0;
                child = NULL;
 
 #if RT6_DEBUG >= 2
        if (rt->dst.obsolete > 0) {
-               WARN_ON(fn != NULL);
+               WARN_ON(fn);
                return -ENOENT;
        }
 #endif
 
                 * with the same label can only appear on another sock
                 */
                lfl = __fl_lookup(net, fl->label);
-               if (lfl != NULL) {
+               if (lfl) {
                        atomic_inc(&lfl->users);
                        spin_unlock_bh(&ip6_fl_lock);
                        return lfl;
        if (!fopt || fopt->opt_flen == 0)
                return fl_opt;
 
-       if (fl_opt != NULL) {
+       if (fl_opt) {
                opt_space->hopopt = fl_opt->hopopt;
                opt_space->dst0opt = fl_opt->dst0opt;
                opt_space->srcrt = fl_opt->srcrt;
                        goto done;
 
                fl1 = fl_intern(net, fl, freq.flr_label);
-               if (fl1 != NULL)
+               if (fl1)
                        goto recheck;
 
                if (!freq.flr_label) {
 
                }
        }
 
-       if (cand != NULL)
+       if (cand)
                return cand;
 
        dev = ign->fb_tunnel_dev;
                t = ip6gre_tunnel_locate(net, &p1, cmd == SIOCADDTUNNEL);
 
                if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
-                       if (t != NULL) {
+                       if (t) {
                                if (t->dev != dev) {
                                        err = -EEXIST;
                                        break;
 
                        t = rtnl_dereference(ign->tunnels[prio][h]);
 
-                       while (t != NULL) {
+                       while (t) {
                                /* If dev is in the same netns, it has already
                                 * been added to the list by the previous loop.
                                 */
 
 
        raw = raw6_local_deliver(skb, nexthdr);
        ipprot = rcu_dereference(inet6_protos[nexthdr]);
-       if (ipprot != NULL) {
+       if (ipprot) {
                int ret;
 
                if (ipprot->flags & INET6_PROTO_FINAL) {
 
                        unfrag_ip6hlen = ip6_find_1stfragopt(skb, &prevhdr);
                        fptr = (struct frag_hdr *)((u8 *)ipv6h + unfrag_ip6hlen);
                        fptr->frag_off = htons(offset);
-                       if (skb->next != NULL)
+                       if (skb->next)
                                fptr->frag_off |= htons(IP6_MF);
                        offset += (ntohs(ipv6h->payload_len) -
                                   sizeof(struct frag_hdr));
 
                                fh->nexthdr = nexthdr;
                                fh->reserved = 0;
                                fh->frag_off = htons(offset);
-                               if (frag->next != NULL)
+                               if (frag->next)
                                        fh->frag_off |= htons(IP6_MF);
                                fh->identification = frag_id;
                                ipv6_hdr(frag)->payload_len =
 
 
        rcu_read_lock();
        t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr, &ipv6h->daddr);
-       if (t != NULL) {
+       if (t) {
                struct pcpu_sw_netstats *tstats;
 
                tproto = ACCESS_ONCE(t->parms.proto);
 
        for (h = 0; h < HASH_SIZE; h++) {
                t = rtnl_dereference(ip6n->tnls_r_l[h]);
-               while (t != NULL) {
+               while (t) {
                        /* If dev is in the same netns, it has already
                         * been added to the list by the previous loop.
                         */
 
 
        rcu_read_lock();
        t = vti6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr, &ipv6h->daddr);
-       if (t != NULL) {
+       if (t) {
                if (t->parms.proto != IPPROTO_IPV6 && t->parms.proto != 0) {
                        rcu_read_unlock();
                        goto discard;
                vti6_parm_from_user(&p1, &p);
                t = vti6_locate(net, &p1, cmd == SIOCADDTUNNEL);
                if (dev != ip6n->fb_tnl_dev && cmd == SIOCCHGTUNNEL) {
-                       if (t != NULL) {
+                       if (t) {
                                if (t->dev != dev) {
                                        err = -EEXIST;
                                        break;
 
        for (h = 0; h < HASH_SIZE; h++) {
                t = rtnl_dereference(ip6n->tnls_r_l[h]);
-               while (t != NULL) {
+               while (t) {
                        unregister_netdevice_queue(t->dev, &list);
                        t = rtnl_dereference(t->next);
                }
 
        unsigned int i;
 
        mrt = ip6mr_get_table(net, id);
-       if (mrt != NULL)
+       if (mrt)
                return mrt;
 
        mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
 
                        *lnk = mc_lst->next;
 
                        dev = __dev_get_by_index(net, mc_lst->ifindex);
-                       if (dev != NULL) {
+                       if (dev) {
                                struct inet6_dev *idev = __in6_dev_get(dev);
 
                                (void) ip6_mc_leave_src(sk, mc_lst, idev);
 
        im = im->next;
        while (!im) {
-               if (likely(state->idev != NULL))
+               if (likely(state->idev))
                        read_unlock_bh(&state->idev->lock);
 
                state->dev = next_net_device_rcu(state->dev);
 {
        struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
 
-       if (likely(state->idev != NULL)) {
+       if (likely(state->idev)) {
                read_unlock_bh(&state->idev->lock);
                state->idev = NULL;
        }
                        continue;
                read_lock_bh(&idev->lock);
                im = idev->mc_list;
-               if (likely(im != NULL)) {
+               if (likely(im)) {
                        spin_lock_bh(&im->mca_lock);
                        psf = im->mca_sources;
-                       if (likely(psf != NULL)) {
+                       if (likely(psf)) {
                                state->im = im;
                                state->idev = idev;
                                break;
                spin_unlock_bh(&state->im->mca_lock);
                state->im = state->im->next;
                while (!state->im) {
-                       if (likely(state->idev != NULL))
+                       if (likely(state->idev))
                                read_unlock_bh(&state->idev->lock);
 
                        state->dev = next_net_device_rcu(state->dev);
        __releases(RCU)
 {
        struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
-       if (likely(state->im != NULL)) {
+       if (likely(state->im)) {
                spin_unlock_bh(&state->im->mca_lock);
                state->im = NULL;
        }
-       if (likely(state->idev != NULL)) {
+       if (likely(state->idev)) {
                read_unlock_bh(&state->idev->lock);
                state->idev = NULL;
        }
 
 
        read_lock(&raw_v6_hashinfo.lock);
        sk = sk_head(&raw_v6_hashinfo.ht[hash]);
-       if (sk != NULL) {
+       if (sk) {
                /* Note: ipv6_hdr(skb) != skb->data */
                const struct ipv6hdr *ip6h = (const struct ipv6hdr *)skb->data;
                saddr = &ip6h->saddr;
 
                spin_lock_bh(&sk->sk_receive_queue.lock);
                skb = skb_peek(&sk->sk_receive_queue);
-               if (skb != NULL)
+               if (skb)
                        amount = skb_tail_pointer(skb) -
                                skb_transport_header(skb);
                spin_unlock_bh(&sk->sk_receive_queue.lock);
 
 
        fq = fq_find(net, fhdr->identification, &hdr->saddr, &hdr->daddr,
                     ip6_frag_ecn(hdr));
-       if (fq != NULL) {
+       if (fq) {
                int ret;
 
                spin_lock(&fq->q.lock);
 
                        return t;
        }
        t = rcu_dereference(sitn->tunnels_wc[0]);
-       if ((t != NULL) && (t->dev->flags & IFF_UP))
+       if (t && (t->dev->flags & IFF_UP))
                return t;
        return NULL;
 }
 
        tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
                                     iph->saddr, iph->daddr);
-       if (tunnel != NULL) {
+       if (tunnel) {
                struct pcpu_sw_netstats *tstats;
 
                if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
        iph = ip_hdr(skb);
        tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
                                     iph->saddr, iph->daddr);
-       if (tunnel != NULL) {
+       if (tunnel) {
                if (tunnel->parms.iph.protocol != IPPROTO_IPIP &&
                    tunnel->parms.iph.protocol != 0)
                        goto drop;
                t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
 
                if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
-                       if (t != NULL) {
+                       if (t) {
                                if (t->dev != dev) {
                                        err = -EEXIST;
                                        break;
                        struct ip_tunnel *t;
 
                        t = rtnl_dereference(sitn->tunnels[prio][h]);
-                       while (t != NULL) {
+                       while (t) {
                                /* If dev is in the same netns, it has already
                                 * been added to the list by the previous loop.
                                 */
 
                                    &ireq->ir_v6_rmt_addr);
 
                fl6->daddr = ireq->ir_v6_rmt_addr;
-               if (np->repflow && (ireq->pktopts != NULL))
+               if (np->repflow && ireq->pktopts)
                        fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
 
                skb_set_queue_mapping(skb, queue_mapping);
 
        /* Clone pktoptions received with SYN */
        newnp->pktoptions = NULL;
-       if (ireq->pktopts != NULL) {
+       if (ireq->pktopts) {
                newnp->pktoptions = skb_clone(ireq->pktopts,
                                              sk_gfp_atomic(sk, GFP_ATOMIC));
                consume_skb(ireq->pktopts);
 #ifdef CONFIG_TCP_MD5SIG
        /* Copy over the MD5 key from the original socket */
        key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
-       if (key != NULL) {
+       if (key) {
                /* We're using one, so create a matching key
                 * on the newsk structure. If we fail to get
                 * memory, then we end up not copying the key
                                            &ipv6_hdr(skb)->saddr, th->source,
                                            &ipv6_hdr(skb)->daddr,
                                            ntohs(th->dest), tcp_v6_iif(skb));
-               if (sk2 != NULL) {
+               if (sk2) {
                        struct inet_timewait_sock *tw = inet_twsk(sk);
                        inet_twsk_deschedule(tw, &tcp_death_row);
                        inet_twsk_put(tw);
 
 
                /* if we're overly short, let UDP handle it */
                encap_rcv = ACCESS_ONCE(up->encap_rcv);
-               if (skb->len > sizeof(struct udphdr) && encap_rcv != NULL) {
+               if (skb->len > sizeof(struct udphdr) && encap_rcv) {
                        int ret;
 
                        /* Verify checksum before giving to encap */
         * for sock caches... i'll skip this for now.
         */
        sk = __udp6_lib_lookup_skb(skb, uh->source, uh->dest, udptable);
-       if (sk != NULL) {
+       if (sk) {
                int ret;
 
                if (!uh->check && !udp_sk(sk)->no_check6_rx) {