return ERR_PTR(-EINVAL);
 
        ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
-       if (ndev == NULL)
+       if (!ndev)
                return ERR_PTR(err);
 
        rwlock_init(&ndev->lock);
        ndev->cnf.mtu6 = dev->mtu;
        ndev->cnf.sysctl = NULL;
        ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
-       if (ndev->nd_parms == NULL) {
+       if (!ndev->nd_parms) {
                kfree(ndev);
                return ERR_PTR(err);
        }
 
        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
                        flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        ncm = nlmsg_data(nlh);
        int err = -ENOBUFS;
 
        skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC);
-       if (skb == NULL)
+       if (!skb)
                goto errout;
 
        err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
                break;
        default:
                dev = __dev_get_by_index(net, ifindex);
-               if (dev == NULL)
+               if (!dev)
                        goto errout;
                in6_dev = __in6_dev_get(dev);
-               if (in6_dev == NULL)
+               if (!in6_dev)
                        goto errout;
                devconf = &in6_dev->cnf;
                break;
 
        err = -ENOBUFS;
        skb = nlmsg_new(inet6_netconf_msgsize_devconf(-1), GFP_ATOMIC);
-       if (skb == NULL)
+       if (!skb)
                goto errout;
 
        err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
 
        ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
 
-       if (ifa == NULL) {
+       if (!ifa) {
                ADBG("ipv6_add_addr: malloc failed\n");
                err = -ENOBUFS;
                goto out;
                            : ifp->flags;
                if (ipv6_addr_equal(&ifp->addr, addr) &&
                    !(ifp_flags&banned_flags) &&
-                   (dev == NULL || ifp->idev->dev == dev ||
+                   (!dev || ifp->idev->dev == dev ||
                     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
                        rcu_read_unlock_bh();
                        return 1;
                if (!net_eq(dev_net(ifp->idev->dev), net))
                        continue;
                if (ipv6_addr_equal(&ifp->addr, addr)) {
-                       if (dev == NULL || ifp->idev->dev == dev)
+                       if (!dev || ifp->idev->dev == dev)
                                return true;
                }
        }
                if (!net_eq(dev_net(ifp->idev->dev), net))
                        continue;
                if (ipv6_addr_equal(&ifp->addr, addr)) {
-                       if (dev == NULL || ifp->idev->dev == dev ||
+                       if (!dev || ifp->idev->dev == dev ||
                            !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
                                result = ifp;
                                in6_ifa_hold(ifp);
        struct fib6_table *table;
 
        table = fib6_get_table(dev_net(dev), RT6_TABLE_PREFIX);
-       if (table == NULL)
+       if (!table)
                return NULL;
 
        read_lock_bh(&table->tb6_lock);
 
        in6_dev = in6_dev_get(dev);
 
-       if (in6_dev == NULL) {
+       if (!in6_dev) {
                net_dbg_ratelimited("addrconf: device %s not configured\n",
                                    dev->name);
                return;
 
                ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
 
-               if (ifp == NULL && valid_lft) {
+               if (!ifp && valid_lft) {
                        int max_addresses = in6_dev->cnf.max_addresses;
 
 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
        dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
 
        err = -ENODEV;
-       if (dev == NULL)
+       if (!dev)
                goto err_exit;
 
 #if IS_ENABLED(CONFIG_IPV6_SIT)
                return -ENODEV;
 
        idev = __in6_dev_get(dev);
-       if (idev == NULL)
+       if (!idev)
                return -ENXIO;
 
        read_lock_bh(&idev->lock);
        ASSERT_RTNL();
 
        idev = ipv6_find_idev(dev);
-       if (idev == NULL) {
+       if (!idev) {
                pr_debug("%s: add_dev failed\n", __func__);
                return;
        }
         */
 
        idev = ipv6_find_idev(dev);
-       if (idev == NULL) {
+       if (!idev) {
                pr_debug("%s: add_dev failed\n", __func__);
                return;
        }
        ASSERT_RTNL();
 
        idev = ipv6_find_idev(dev);
-       if (idev == NULL) {
+       if (!idev) {
                pr_debug("%s: add_dev failed\n", __func__);
                return;
        }
        neigh_ifdown(&nd_tbl, dev);
 
        idev = __in6_dev_get(dev);
-       if (idev == NULL)
+       if (!idev)
                return -ENODEV;
 
        /*
 
        ifm = nlmsg_data(nlh);
        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
-       if (pfx == NULL)
+       if (!pfx)
                return -EINVAL;
 
        ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
 
        ifm = nlmsg_data(nlh);
        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
-       if (pfx == NULL)
+       if (!pfx)
                return -EINVAL;
 
        if (tb[IFA_CACHEINFO]) {
        }
 
        dev =  __dev_get_by_index(net, ifm->ifa_index);
-       if (dev == NULL)
+       if (!dev)
                return -ENODEV;
 
        ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
                     IFA_F_NOPREFIXROUTE | IFA_F_MCAUTOJOIN;
 
        ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
-       if (ifa == NULL) {
+       if (!ifa) {
                /*
                 * It would be best to check for !NLM_F_CREATE here but
                 * userspace already relies on not having to provide this.
        u32 preferred, valid;
 
        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
                scope = RT_SCOPE_SITE;
 
        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
                scope = RT_SCOPE_SITE;
 
        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
                goto errout;
 
        addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
-       if (addr == NULL) {
+       if (!addr) {
                err = -EINVAL;
                goto errout;
        }
        int err = -ENOBUFS;
 
        skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
-       if (skb == NULL)
+       if (!skb)
                goto errout;
 
        err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
        if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
                goto nla_put_failure;
        nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
-       if (nla == NULL)
+       if (!nla)
                goto nla_put_failure;
        ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
 
        /* XXX - MC not implemented */
 
        nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
-       if (nla == NULL)
+       if (!nla)
                goto nla_put_failure;
        snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
 
        nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
-       if (nla == NULL)
+       if (!nla)
                goto nla_put_failure;
        snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
 
        nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
-       if (nla == NULL)
+       if (!nla)
                goto nla_put_failure;
 
        if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->addr_gen_mode))
 
        ASSERT_RTNL();
 
-       if (token == NULL)
+       if (!token)
                return -EINVAL;
        if (ipv6_addr_any(token))
                return -EINVAL;
        void *protoinfo;
 
        nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        hdr = nlmsg_data(nlh);
             nla_put_u32(skb, IFLA_LINK, dev->iflink)))
                goto nla_put_failure;
        protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
-       if (protoinfo == NULL)
+       if (!protoinfo)
                goto nla_put_failure;
 
        if (inet6_fill_ifla6_attrs(skb, idev) < 0)
        int err = -ENOBUFS;
 
        skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
-       if (skb == NULL)
+       if (!skb)
                goto errout;
 
        err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
        struct prefix_cacheinfo ci;
 
        nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        pmsg = nlmsg_data(nlh);
        int err = -ENOBUFS;
 
        skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
-       if (skb == NULL)
+       if (!skb)
                goto errout;
 
        err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
        char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
 
        t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
-       if (t == NULL)
+       if (!t)
                goto out;
 
        for (i = 0; t->addrconf_vars[i].data; i++) {
        snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
 
        t->sysctl_header = register_net_sysctl(net, path, t->addrconf_vars);
-       if (t->sysctl_header == NULL)
+       if (!t->sysctl_header)
                goto free;
 
        p->sysctl = t;
 {
        struct addrconf_sysctl_table *t;
 
-       if (p->sysctl == NULL)
+       if (!p->sysctl)
                return;
 
        t = p->sysctl;
        struct ipv6_devconf *all, *dflt;
 
        all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
-       if (all == NULL)
+       if (!all)
                goto err_alloc_all;
 
        dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
-       if (dflt == NULL)
+       if (!dflt)
                goto err_alloc_dflt;
 
        /* these will be inherited by all namespaces */
 
        answer_flags = answer->flags;
        rcu_read_unlock();
 
-       WARN_ON(answer_prot->slab == NULL);
+       WARN_ON(!answer_prot->slab);
 
        err = -ENOBUFS;
        sk = sk_alloc(net, PF_INET6, GFP_KERNEL, answer_prot);
-       if (sk == NULL)
+       if (!sk)
                goto out;
 
        sock_init_data(sock, sk);
 {
        struct sock *sk = sock->sk;
 
-       if (sk == NULL)
+       if (!sk)
                return -EINVAL;
 
        /* Free mc lists */
 
        dst = __sk_dst_check(sk, np->dst_cookie);
 
-       if (dst == NULL) {
+       if (!dst) {
                struct inet_sock *inet = inet_sk(sk);
                struct in6_addr *final_p, final;
                struct flowi6 fl6;
 
                goto error;
 
        ahp = kzalloc(sizeof(*ahp), GFP_KERNEL);
-       if (ahp == NULL)
+       if (!ahp)
                return -ENOMEM;
 
        ahash = crypto_alloc_ahash(x->aalg->alg_name, 0, 0);
 
                return -EINVAL;
 
        pac = sock_kmalloc(sk, sizeof(struct ipv6_ac_socklist), GFP_KERNEL);
-       if (pac == NULL)
+       if (!pac)
                return -ENOMEM;
        pac->acl_next = NULL;
        pac->acl_addr = *addr;
        } else
                dev = __dev_get_by_index(net, ifindex);
 
-       if (dev == NULL) {
+       if (!dev) {
                err = -ENODEV;
                goto error;
        }
        struct ifacaddr6 *aca;
 
        aca = kzalloc(sizeof(*aca), GFP_ATOMIC);
-       if (aca == NULL)
+       if (!aca)
                return NULL;
 
        aca->aca_addr = *addr;
                goto out;
        }
        aca = aca_alloc(rt, addr);
-       if (aca == NULL) {
+       if (!aca) {
                ip6_rt_put(rt);
                err = -ENOMEM;
                goto out;
 {
        struct inet6_dev *idev = __in6_dev_get(dev);
 
-       if (idev == NULL)
+       if (!idev)
                return -ENODEV;
        return __ipv6_dev_ac_dec(idev, addr);
 }
 
                fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
                if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
                        flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
-                       if (flowlabel == NULL)
+                       if (!flowlabel)
                                return -EINVAL;
                }
        }
 
        err = -EAGAIN;
        skb = sock_dequeue_err_skb(sk);
-       if (skb == NULL)
+       if (!skb)
                goto out;
 
        copied = skb->len;
 
        err = -EAGAIN;
        skb = xchg(&np->rxpmtu, NULL);
-       if (skb == NULL)
+       if (!skb)
                goto out;
 
        copied = skb->len;
 
        int err;
 
        err = -EINVAL;
-       if (x->ealg == NULL)
+       if (!x->ealg)
                goto error;
 
        err = -ENAMETOOLONG;
 
                if (nexthdr == NEXTHDR_NONE)
                        return -1;
                hp = skb_header_pointer(skb, start, sizeof(_hdr), &_hdr);
-               if (hp == NULL)
+               if (!hp)
                        return -1;
                if (nexthdr == NEXTHDR_FRAGMENT) {
                        __be16 _frag_off, *fp;
                                                               frag_off),
                                                sizeof(_frag_off),
                                                &_frag_off);
-                       if (fp == NULL)
+                       if (!fp)
                                return -1;
 
                        *frag_offp = *fp;
                }
 
                hp = skb_header_pointer(skb, start, sizeof(_hdr), &_hdr);
-               if (hp == NULL)
+               if (!hp)
                        return -EBADMSG;
 
                if (nexthdr == NEXTHDR_ROUTING) {
 
                        rh = skb_header_pointer(skb, start, sizeof(_rh),
                                                &_rh);
-                       if (rh == NULL)
+                       if (!rh)
                                return -EBADMSG;
 
                        if (flags && (*flags & IP6_FH_F_SKIP_RH) &&
                                                               frag_off),
                                                sizeof(_frag_off),
                                                &_frag_off);
-                       if (fp == NULL)
+                       if (!fp)
                                return -EBADMSG;
 
                        _frag_off = ntohs(*fp) & ~0x7;
 
                tp = skb_header_pointer(skb,
                        ptr+offsetof(struct icmp6hdr, icmp6_type),
                        sizeof(_type), &_type);
-               if (tp == NULL ||
-                   !(*tp & ICMPV6_INFOMSG_MASK))
+               if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
                        return true;
        }
        return false;
 
        offset += skb_network_offset(skb);
        op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
-       if (op == NULL)
+       if (!op)
                return true;
        return (*op & 0xC0) == 0x80;
 }
        int err = 0;
 
        skb = skb_peek(&sk->sk_write_queue);
-       if (skb == NULL)
+       if (!skb)
                goto out;
 
        icmp6h = icmp6_hdr(skb);
        security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
 
        sk = icmpv6_xmit_lock(net);
-       if (sk == NULL)
+       if (!sk)
                return;
        sk->sk_mark = mark;
        np = inet6_sk(sk);
        security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
 
        sk = icmpv6_xmit_lock(net);
-       if (sk == NULL)
+       if (!sk)
                return;
        sk->sk_mark = mark;
        np = inet6_sk(sk);
 
        net->ipv6.icmp_sk =
                kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
-       if (net->ipv6.icmp_sk == NULL)
+       if (!net->ipv6.icmp_sk)
                return -ENOMEM;
 
        for_each_possible_cpu(i) {
 
                        fl->label = htonl(prandom_u32())&IPV6_FLOWLABEL_MASK;
                        if (fl->label) {
                                lfl = __fl_lookup(net, fl->label);
-                               if (lfl == NULL)
+                               if (!lfl)
                                        break;
                        }
                }
 {
        struct ipv6_txoptions *fl_opt = fl->opt;
 
-       if (fopt == NULL || fopt->opt_flen == 0)
+       if (!fopt || fopt->opt_flen == 0)
                return fl_opt;
 
        if (fl_opt != NULL) {
 
        err = -ENOMEM;
        fl = kzalloc(sizeof(*fl), GFP_KERNEL);
-       if (fl == NULL)
+       if (!fl)
                goto done;
 
        if (olen > 0) {
 
                err = -ENOMEM;
                fl->opt = kmalloc(sizeof(*fl->opt) + olen, GFP_KERNEL);
-               if (fl->opt == NULL)
+               if (!fl->opt)
                        goto done;
 
                memset(fl->opt, 0, sizeof(*fl->opt));
                        return -EINVAL;
 
                fl = fl_create(net, sk, &freq, optval, optlen, &err);
-               if (fl == NULL)
+               if (!fl)
                        return err;
                sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL);
 
                        }
                        rcu_read_unlock_bh();
 
-                       if (fl1 == NULL)
+                       if (!fl1)
                                fl1 = fl_lookup(net, freq.flr_label);
                        if (fl1) {
 recheck:
                                        goto release;
 
                                err = -ENOMEM;
-                               if (sfl1 == NULL)
+                               if (!sfl1)
                                        goto release;
                                if (fl->linger > fl1->linger)
                                        fl1->linger = fl->linger;
                        goto done;
 
                err = -ENOMEM;
-               if (sfl1 == NULL)
+               if (!sfl1)
                        goto done;
 
                err = mem_check(sk);
 
                                flags & GRE_KEY ?
                                *(((__be32 *)p) + (grehlen / 4) - 1) : 0,
                                p[1]);
-       if (t == NULL)
+       if (!t)
                return;
 
        switch (type) {
                                                 &p->raddr, &p->laddr,
                                                 p->link, strict);
 
-               if (rt == NULL)
+               if (!rt)
                        return;
 
                if (rt->dst.dev) {
                        }
                        ip6gre_tnl_parm_from_user(&p1, &p);
                        t = ip6gre_tunnel_locate(net, &p1, 0);
-                       if (t == NULL)
+                       if (!t)
                                t = netdev_priv(dev);
                }
                memset(&p, 0, sizeof(p));
                        err = -ENOENT;
                        ip6gre_tnl_parm_from_user(&p1, &p);
                        t = ip6gre_tunnel_locate(net, &p1, 0);
-                       if (t == NULL)
+                       if (!t)
                                goto done;
                        err = -EPERM;
                        if (t == netdev_priv(ign->fb_tunnel_dev))
 
 
                if (skb_headroom(skb) < head_room) {
                        struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
-                       if (skb2 == NULL) {
+                       if (!skb2) {
                                IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
                                              IPSTATS_MIB_OUTDISCARDS);
                                kfree_skb(skb);
                               const struct in6_addr *addr_cache)
 {
        return (rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) &&
-               (addr_cache == NULL || !ipv6_addr_equal(fl_addr, addr_cache));
+               (!addr_cache || !ipv6_addr_equal(fl_addr, addr_cache));
 }
 
 static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
 #endif
        int err;
 
-       if (*dst == NULL)
+       if (!*dst)
                *dst = ip6_route_output(net, sk, fl6);
 
        err = (*dst)->error;
         * udp datagram
         */
        skb = skb_peek_tail(queue);
-       if (skb == NULL) {
+       if (!skb) {
                skb = sock_alloc_send_skb(sk,
                        hh_len + fragheaderlen + transhdrlen + 20,
                        (flags & MSG_DONTWAIT), &err);
-               if (skb == NULL)
+               if (!skb)
                        return err;
 
                /* reserve space for Hardware header */
                                unsigned int orig_mtu)
 {
        if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {
-               if (skb == NULL) {
+               if (!skb) {
                        /* first fragment, reserve header_len */
                        *mtu = orig_mtu - rt->dst.header_len;
 
                        return -EINVAL;
 
                v6_cork->opt = kzalloc(opt->tot_len, sk->sk_allocation);
-               if (unlikely(v6_cork->opt == NULL))
+               if (unlikely(!v6_cork->opt))
                        return -ENOBUFS;
 
                v6_cork->opt->tot_len = opt->tot_len;
                        else
                                fraggap = 0;
                        /* update mtu and maxfraglen if necessary */
-                       if (skb == NULL || skb_prev == NULL)
+                       if (!skb || !skb_prev)
                                ip6_append_data_mtu(&mtu, &maxfraglen,
                                                    fragheaderlen, skb, rt,
                                                    orig_mtu);
                                        skb = sock_wmalloc(sk,
                                                           alloclen + hh_len, 1,
                                                           sk->sk_allocation);
-                               if (unlikely(skb == NULL))
+                               if (unlikely(!skb))
                                        err = -ENOBUFS;
                        }
-                       if (skb == NULL)
+                       if (!skb)
                                goto error;
                        /*
                         *      Fill in the control structures
        unsigned char proto = fl6->flowi6_proto;
 
        skb = __skb_dequeue(queue);
-       if (skb == NULL)
+       if (!skb)
                goto out;
        tail_skb = &(skb_shinfo(skb)->frag_list);
 
 
        struct dst_entry *dst = t->dst_cache;
 
        if (dst && dst->obsolete &&
-           dst->ops->check(dst, t->dst_cookie) == NULL) {
+           !dst->ops->check(dst, t->dst_cookie)) {
                t->dst_cache = NULL;
                dst_release(dst);
                return NULL;
 
        dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
                           ip6_tnl_dev_setup);
-       if (dev == NULL)
+       if (!dev)
                goto failed;
 
        dev_net_set(dev, net);
 
        rcu_read_lock();
        t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->daddr, &ipv6h->saddr);
-       if (t == NULL)
+       if (!t)
                goto out;
 
        tproto = ACCESS_ONCE(t->parms.proto);
                                                 &p->raddr, &p->laddr,
                                                 p->link, strict);
 
-               if (rt == NULL)
+               if (!rt)
                        return;
 
                if (rt->dst.dev) {
 
                sprintf(name, "ip6_vti%%d");
 
        dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN, vti6_dev_setup);
-       if (dev == NULL)
+       if (!dev)
                goto failed;
 
        dev_net_set(dev, net);
                } else {
                        memset(&p, 0, sizeof(p));
                }
-               if (t == NULL)
+               if (!t)
                        t = netdev_priv(dev);
                vti6_parm_to_user(&p, &t->parms);
                if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
                        err = -ENOENT;
                        vti6_parm_from_user(&p1, &p);
                        t = vti6_locate(net, &p1, 0);
-                       if (t == NULL)
+                       if (!t)
                                break;
                        err = -EPERM;
                        if (t->dev == ip6n->fb_tnl_dev)
 
        }
 
        mrt = ip6mr_get_table(rule->fr_net, rule->table);
-       if (mrt == NULL)
+       if (!mrt)
                return -EAGAIN;
        res->mrt = mrt;
        return 0;
        INIT_LIST_HEAD(&net->ipv6.mr6_tables);
 
        mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
-       if (mrt == NULL) {
+       if (!mrt) {
                err = -ENOMEM;
                goto err1;
        }
                return mrt;
 
        mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
-       if (mrt == NULL)
+       if (!mrt)
                return NULL;
        mrt->id = id;
        write_pnet(&mrt->net, net);
        struct mr6_table *mrt;
 
        mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return ERR_PTR(-ENOENT);
 
        iter->mrt = mrt;
        struct mr6_table *mrt;
 
        mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return ERR_PTR(-ENOENT);
 
        it->mrt = mrt;
                dev_hold(reg_dev);
        read_unlock(&mrt_lock);
 
-       if (reg_dev == NULL)
+       if (!reg_dev)
                goto drop;
 
        skb->mac_header = skb->network_header;
                sprintf(name, "pim6reg%u", mrt->id);
 
        dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
-       if (dev == NULL)
+       if (!dev)
                return NULL;
 
        dev_net_set(dev, net);
 static struct mfc6_cache *ip6mr_cache_alloc(void)
 {
        struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
-       if (c == NULL)
+       if (!c)
                return NULL;
        c->mfc_un.res.minvif = MAXMIFS;
        return c;
 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
 {
        struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
-       if (c == NULL)
+       if (!c)
                return NULL;
        skb_queue_head_init(&c->mfc_un.unres.unresolved);
        c->mfc_un.unres.expires = jiffies + 10 * HZ;
        skb->ip_summed = CHECKSUM_UNNECESSARY;
        }
 
-       if (mrt->mroute6_sk == NULL) {
+       if (!mrt->mroute6_sk) {
                kfree_skb(skb);
                return -EINVAL;
        }
                return -EINVAL;
 
        c = ip6mr_cache_alloc();
-       if (c == NULL)
+       if (!c)
                return -ENOMEM;
 
        c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
        struct mr6_table *mrt;
 
        mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return -ENOENT;
 
        if (optname != MRT6_INIT) {
        struct mr6_table *mrt;
 
        mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return -ENOENT;
 
        switch (optname) {
        struct mr6_table *mrt;
 
        mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return -ENOENT;
 
        switch (cmd) {
        struct mr6_table *mrt;
 
        mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return -ENOENT;
 
        switch (cmd) {
        struct dst_entry *dst;
        struct flowi6 fl6;
 
-       if (vif->dev == NULL)
+       if (!vif->dev)
                goto out_free;
 
 #ifdef CONFIG_IPV6_PIMSM_V2
        read_lock(&mrt_lock);
        cache = ip6mr_cache_find(mrt,
                                 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
-       if (cache == NULL) {
+       if (!cache) {
                int vif = ip6mr_find_vif(mrt, skb->dev);
 
                if (vif >= 0)
        /*
         *      No usable cache entry
         */
-       if (cache == NULL) {
+       if (!cache) {
                int vif;
 
                vif = ip6mr_find_vif(mrt, skb->dev);
            nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
                return -EMSGSIZE;
        mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
-       if (mp_attr == NULL)
+       if (!mp_attr)
                return -EMSGSIZE;
 
        for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
                if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
                        nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
-                       if (nhp == NULL) {
+                       if (!nhp) {
                                nla_nest_cancel(skb, mp_attr);
                                return -EMSGSIZE;
                        }
        struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
 
        mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
-       if (mrt == NULL)
+       if (!mrt)
                return -ENOENT;
 
        read_lock(&mrt_lock);
                }
 
                dev = skb->dev;
-               if (dev == NULL || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
+               if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
                        read_unlock(&mrt_lock);
                        return -ENODEV;
                }
        int err;
 
        nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
-       if (nlh == NULL)
+       if (!nlh)
                return -EMSGSIZE;
 
        rtm = nlmsg_data(nlh);
 
        skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
                        GFP_ATOMIC);
-       if (skb == NULL)
+       if (!skb)
                goto errout;
 
        err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
 
                        return 0;
                }
        }
-       if (new_ra == NULL) {
+       if (!new_ra) {
                write_unlock_bh(&ip6_ra_lock);
                return -ENOBUFS;
        }
        int retv = -ENOPROTOOPT;
        bool needs_rtnl = setsockopt_needs_rtnl(optname);
 
-       if (optval == NULL)
+       if (!optval)
                val = 0;
        else {
                if (optlen >= sizeof(int)) {
                 */
                if (optlen == 0)
                        optval = NULL;
-               else if (optval == NULL)
+               else if (!optval)
                        goto e_inval;
                else if (optlen < sizeof(struct ipv6_opt_hdr) ||
                         optlen & 0x7 || optlen > 8 * 255)
 
                if (optlen == 0)
                        goto e_inval;
-               else if (optlen < sizeof(struct in6_pktinfo) || optval == NULL)
+               else if (optlen < sizeof(struct in6_pktinfo) || !optval)
                        goto e_inval;
 
                if (copy_from_user(&pkt, optval, sizeof(struct in6_pktinfo))) {
 
                opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
                retv = -ENOBUFS;
-               if (opt == NULL)
+               if (!opt)
                        break;
 
                memset(opt, 0, sizeof(*opt));
 
 
        mc_lst = sock_kmalloc(sk, sizeof(struct ipv6_mc_socklist), GFP_KERNEL);
 
-       if (mc_lst == NULL)
+       if (!mc_lst)
                return -ENOMEM;
 
        mc_lst->next = NULL;
        } else
                dev = __dev_get_by_index(net, ifindex);
 
-       if (dev == NULL) {
+       if (!dev) {
                sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
                return -ENODEV;
        }
        struct ifmcaddr6 *mc;
 
        mc = kzalloc(sizeof(*mc), GFP_ATOMIC);
-       if (mc == NULL)
+       if (!mc)
                return NULL;
 
        setup_timer(&mc->mca_timer, igmp6_timer_handler, (unsigned long)mc);
        /* we need to take a reference on idev */
        idev = in6_dev_get(dev);
 
-       if (idev == NULL)
+       if (!idev)
                return -EINVAL;
 
        write_lock_bh(&idev->lock);
                return -EINVAL;
 
        idev = __in6_dev_get(skb->dev);
-       if (idev == NULL)
+       if (!idev)
                return 0;
 
        mld = (struct mld_msg *)icmp6_hdr(skb);
                return -EINVAL;
 
        idev = __in6_dev_get(skb->dev);
-       if (idev == NULL)
+       if (!idev)
                return -ENODEV;
 
        /*
 
        skb = sock_alloc_send_skb(sk, hlen + tlen + full_len, 1, &err);
 
-       if (skb == NULL) {
+       if (!skb) {
                rcu_read_lock();
                IP6_INC_STATS(net, __in6_dev_get(dev),
                              IPSTATS_MIB_OUTDISCARDS);
 
        bool is_multicast = ipv6_addr_is_multicast(addr);
 
        in6_dev = in6_dev_get(dev);
-       if (in6_dev == NULL) {
+       if (!in6_dev) {
                return -EINVAL;
        }
 
        struct in6_addr maddr;
        struct net_device *dev = n->dev;
 
-       if (dev == NULL || __in6_dev_get(dev) == NULL)
+       if (!dev || !__in6_dev_get(dev))
                return -EINVAL;
        addrconf_addr_solict_mult(addr, &maddr);
        ipv6_dev_mc_inc(dev, &maddr);
        struct in6_addr maddr;
        struct net_device *dev = n->dev;
 
-       if (dev == NULL || __in6_dev_get(dev) == NULL)
+       if (!dev || !__in6_dev_get(dev))
                return;
        addrconf_addr_solict_mult(addr, &maddr);
        ipv6_dev_mc_dec(dev, &maddr);
        int optlen = 0;
        struct nd_msg *msg;
 
-       if (saddr == NULL) {
+       if (!saddr) {
                if (ipv6_get_lladdr(dev, &addr_buf,
                                   (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
                        return;
        size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
 
        skb = nlmsg_new(msg_size, GFP_ATOMIC);
-       if (skb == NULL) {
+       if (!skb) {
                err = -ENOBUFS;
                goto errout;
        }
 
        nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
-       if (nlh == NULL) {
+       if (!nlh) {
                goto nla_put_failure;
        }
 
         */
 
        in6_dev = __in6_dev_get(skb->dev);
-       if (in6_dev == NULL) {
+       if (!in6_dev) {
                ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
                          skb->dev->name);
                return;
 
        ND_PRINTK(3, info, "RA: rt: %p  lifetime: %d, for dev: %s\n",
                  rt, lifetime, skb->dev->name);
-       if (rt == NULL && lifetime) {
+       if (!rt && lifetime) {
                ND_PRINTK(3, info, "RA: adding default router\n");
 
                rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
-               if (rt == NULL) {
+               if (!rt) {
                        ND_PRINTK(0, err,
                                  "RA: %s failed to add default route\n",
                                  __func__);
                }
 
                neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
-               if (neigh == NULL) {
+               if (!neigh) {
                        ND_PRINTK(0, err,
                                  "RA: %s got default router without neighbour\n",
                                  __func__);
 
        read_lock(&raw_v6_hashinfo.lock);
        sk = sk_head(&raw_v6_hashinfo.ht[hash]);
 
-       if (sk == NULL)
+       if (!sk)
                goto out;
 
        net = dev_net(skb->dev);
        skb = sock_alloc_send_skb(sk,
                                  length + hlen + tlen + 15,
                                  flags & MSG_DONTWAIT, &err);
-       if (skb == NULL)
+       if (!skb)
                goto error;
        skb_reserve(skb, hlen);
 
                        fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
                        if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
                                flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
-                               if (flowlabel == NULL)
+                               if (!flowlabel)
                                        return -EINVAL;
                        }
                }
                }
                if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
                        flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
-                       if (flowlabel == NULL)
+                       if (!flowlabel)
                                return -EINVAL;
                }
                if (!(opt->opt_nflen|opt->opt_flen))
                        opt = NULL;
        }
-       if (opt == NULL)
+       if (!opt)
                opt = np->opt;
        if (flowlabel)
                opt = fl6_merge_options(&opt_space, flowlabel, opt);
 
                int i, plen = 0;
 
                clone = alloc_skb(0, GFP_ATOMIC);
-               if (clone == NULL)
+               if (!clone)
                        goto out_oom;
                clone->next = head->next;
                head->next = clone;
        table = ip6_frags_ns_ctl_table;
        if (!net_eq(net, &init_net)) {
                table = kmemdup(table, sizeof(ip6_frags_ns_ctl_table), GFP_KERNEL);
-               if (table == NULL)
+               if (!table)
                        goto err_alloc;
 
                table[0].data = &net->ipv6.frags.high_thresh;
        }
 
        hdr = register_net_sysctl(net, "net/ipv6", table);
-       if (hdr == NULL)
+       if (!hdr)
                goto err_reg;
 
        net->ipv6.sysctl.frags_hdr = hdr;
 
        int remaining;
        u32 *mp;
 
-       if (cfg->fc_mx == NULL)
+       if (!cfg->fc_mx)
                return 0;
 
        mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
 
 
        dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
                           ipip6_tunnel_setup);
-       if (dev == NULL)
+       if (!dev)
                return NULL;
 
        dev_net_set(dev, net);
                                skb->dev,
                                iph->daddr,
                                iph->saddr);
-       if (t == NULL)
+       if (!t)
                goto out;
 
        if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
                if (skb_dst(skb))
                        neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
 
-               if (neigh == NULL) {
+               if (!neigh) {
                        net_dbg_ratelimited("nexthop == NULL\n");
                        goto tx_error;
                }
                if (skb_dst(skb))
                        neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
 
-               if (neigh == NULL) {
+               if (!neigh) {
                        net_dbg_ratelimited("nexthop == NULL\n");
                        goto tx_error;
                }
                                break;
                        }
                        t = ipip6_tunnel_locate(net, &p, 0);
-                       if (t == NULL)
+                       if (!t)
                                t = netdev_priv(dev);
                }
 
                                goto done;
                        err = -ENOENT;
                        t = ipip6_tunnel_locate(net, &p, 0);
-                       if (t == NULL)
+                       if (!t)
                                goto done;
                        err = -EPERM;
                        if (t == netdev_priv(sitn->fb_tunnel_dev))
 
        int err = -ENOMEM;
 
        ip6_header = register_net_sysctl(&init_net, "net/ipv6", ipv6_rotable);
-       if (ip6_header == NULL)
+       if (!ip6_header)
                goto out;
 
        err = register_pernet_subsys(&ipv6_sysctl_net_ops);
 
                if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
                        struct ip6_flowlabel *flowlabel;
                        flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
-                       if (flowlabel == NULL)
+                       if (!flowlabel)
                                return -EINVAL;
                        fl6_sock_release(flowlabel);
                }
                goto failure;
        }
 
-       if (saddr == NULL) {
+       if (!saddr) {
                saddr = &fl6.saddr;
                sk->sk_v6_rcv_saddr = *saddr;
        }
                /* Only in fast or simultaneous open. If a fast open socket is
                 * is already accepted it is treated as a connected one below.
                 */
-               if (fastopen && fastopen->sk == NULL)
+               if (fastopen && !fastopen->sk)
                        break;
 
                if (!sock_owned_by_user(sk)) {
 
        buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
                         GFP_ATOMIC);
-       if (buff == NULL)
+       if (!buff)
                return;
 
        skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
 
                newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
 
-               if (newsk == NULL)
+               if (!newsk)
                        return NULL;
 
                newtcp6sk = (struct tcp6_sock *)newsk;
        }
 
        newsk = tcp_create_openreq_child(sk, req, skb);
-       if (newsk == NULL)
+       if (!newsk)
                goto out_nonewsk;
 
        /*
 
 
        sk = __udp6_lib_lookup(net, daddr, uh->dest,
                               saddr, uh->source, inet6_iif(skb), udptable);
-       if (sk == NULL) {
+       if (!sk) {
                ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
                                   ICMP6_MIB_INERRORS);
                return;
 
        for (i = 0; i < count; i++) {
                sk = stack[i];
-               if (likely(skb1 == NULL))
+               if (likely(!skb1))
                        skb1 = (i == final) ? skb : skb_clone(skb, GFP_ATOMIC);
                if (!skb1) {
                        atomic_inc(&sk->sk_drops);
                        fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
                        if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
                                flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
-                               if (flowlabel == NULL)
+                               if (!flowlabel)
                                        return -EINVAL;
                        }
                }
                }
                if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
                        flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
-                       if (flowlabel == NULL)
+                       if (!flowlabel)
                                return -EINVAL;
                }
                if (!(opt->opt_nflen|opt->opt_flen))
                        opt = NULL;
                connected = 0;
        }
-       if (opt == NULL)
+       if (!opt)
                opt = np->opt;
        if (flowlabel)
                opt = fl6_merge_options(&opt_space, flowlabel, opt);
 
 {
        struct ctl_table *table;
 
-       if (net->ipv6.sysctl.xfrm6_hdr == NULL)
+       if (!net->ipv6.sysctl.xfrm6_hdr)
                return;
 
        table = net->ipv6.sysctl.xfrm6_hdr->ctl_table_arg;