struct ethhdr *eth;
        struct bpqdev *bpq;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto drop;
 
        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
 {
        struct net_device *dev = (struct net_device *)ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (!dev_is_ethdev(dev))
 
 out_free_netdev:
        free_netdev(dev);
 out:
-       if (net == &init_net)
+       if (net_eq(net, &init_net))
                panic("loopback: Failed to register netdevice: %d\n", err);
        return err;
 }
 
 {
        struct hdlc_device *hdlc = dev_to_hdlc(dev);
 
-       if (dev_net(dev) != &init_net) {
+       if (!net_eq(dev_net(dev), &init_net)) {
                kfree_skb(skb);
                return 0;
        }
        unsigned long flags;
        int on;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (!(dev->priv_flags & IFF_WAN_HDLC))
 
        struct sock *sk;
        int rc = -ESOCKTNOSUPPORT;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        /*
 
 {
        int error;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        sock->ops = &svc_proto_ops;
 
        struct sock *sk;
        ax25_cb *ax25;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        switch (sock->type) {
 
        if (protocol < 0 || protocol >= CAN_NPROTO)
                return -EINVAL;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
 #ifdef CONFIG_MODULES
 
        /* For now only devices in the initial network namespace
         * are in sysfs.
         */
-       if (net == &init_net) {
+       if (net_eq(net, &init_net)) {
                ret = device_rename(&dev->dev, dev->name);
                if (ret) {
                        memcpy(dev->name, oldname, IFNAMSIZ);
        list_for_each_entry_safe(dev, aux, head, unreg_list) {
                int new_net = 1;
                list_for_each_entry(fdev, &pernet_list, unreg_list) {
-                       if (dev_net(dev) == dev_net(fdev)) {
+                       if (net_eq(dev_net(dev), dev_net(fdev))) {
                                new_net = 0;
                                dev_put(dev);
                                break;
 
                if (h > s_h)
                        s_idx = 0;
                for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next) {
-                       if (dev_net(n->dev) != net)
+                       if (!net_eq(dev_net(n->dev), net))
                                continue;
                        if (idx < s_idx)
                                goto next;
 
 
        kobject_get(&dev->kobj);
 
-       if (dev_net(net) != &init_net)
+       if (!net_eq(dev_net(net), &init_net))
                return;
 
        device_del(dev);
 #endif
 #endif /* CONFIG_SYSFS */
 
-       if (dev_net(net) != &init_net)
+       if (!net_eq(dev_net(net), &init_net))
                return 0;
 
        return device_add(dev);
 
        list_del(&ops->list);
        if (ops->exit) {
                for_each_net(undo_net) {
-                       if (undo_net == net)
+                       if (net_eq(undo_net, net))
                                goto undone;
                        ops->exit(undo_net);
                }
 
        net->core.sysctl_somaxconn = SOMAXCONN;
 
        tbl = netns_core_table;
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                tbl = kmemdup(tbl, sizeof(netns_core_table), GFP_KERNEL);
                if (tbl == NULL)
                        goto err_dup;
 
        u32 pid = skb ? NETLINK_CB(skb).pid : 0;
        int ret = -EINVAL;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        ret = nlmsg_parse(nlh, sizeof(*dcb), tb, DCB_ATTR_MAX,
 
 {
        struct sock *sk;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        switch(sock->type) {
 
        struct dn_ifaddr *ifa, **ifap;
        int err = -EINVAL;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                goto errout;
 
        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
        struct dn_ifaddr *ifa;
        int err;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy);
        struct dn_dev *dn_db;
        struct dn_ifaddr *ifa;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        skip_ndevs = cb->args[0];
 
        struct rtattr **rta = arg;
        struct rtmsg *r = NLMSG_DATA(nlh);
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        if (dn_fib_check_attr(r, rta))
        struct rtattr **rta = arg;
        struct rtmsg *r = NLMSG_DATA(nlh);
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        if (dn_fib_check_attr(r, rta))
 
        struct sk_buff *skb;
        struct flowi fl;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        memset(&fl, 0, sizeof(fl));
        int h, s_h;
        int idx, s_idx;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        if (NLMSG_PAYLOAD(cb->nlh, 0) < sizeof(struct rtmsg))
 
        struct hlist_node *node;
        int dumped = 0;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        if (NLMSG_PAYLOAD(cb->nlh, 0) >= sizeof(struct rtmsg) &&
 
        struct econet_sock *eo;
        int err;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        /* Econet only provides datagram services. */
 
        struct proto *proto;
        const struct proto_ops *ops;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        switch (sock->type) {
 
        all = &ipv4_devconf;
        dflt = &ipv4_devconf_dflt;
 
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
                if (all == NULL)
                        goto err_alloc_all;
 
        head = &fib_info_hash[hash];
 
        hlist_for_each_entry(fi, node, head, fib_hash) {
-               if (fi->fib_net != nfi->fib_net)
+               if (!net_eq(fi->fib_net, nfi->fib_net))
                        continue;
                if (fi->fib_nhs != nfi->fib_nhs)
                        continue;
                return 0;
 
        hlist_for_each_entry(fi, node, head, fib_lhash) {
-               if (fi->fib_net != net)
+               if (!net_eq(fi->fib_net, net))
                        continue;
                if (fi->fib_prefsrc == local) {
                        fi->fib_flags |= RTNH_F_DEAD;
 
                                        hashinfo->bhash_size)];
                        spin_lock(&head->lock);
                        inet_bind_bucket_for_each(tb, node, &head->chain)
-                               if (ib_net(tb) == net && tb->port == rover) {
+                               if (net_eq(ib_net(tb), net) && tb->port == rover) {
                                        if (tb->fastreuse > 0 &&
                                            sk->sk_reuse &&
                                            sk->sk_state != TCP_LISTEN &&
                                hashinfo->bhash_size)];
                spin_lock(&head->lock);
                inet_bind_bucket_for_each(tb, node, &head->chain)
-                       if (ib_net(tb) == net && tb->port == snum)
+                       if (net_eq(ib_net(tb), net) && tb->port == snum)
                                goto tb_found;
        }
        tb = NULL;
 
                         * unique enough.
                         */
                        inet_bind_bucket_for_each(tb, node, &head->chain) {
-                               if (ib_net(tb) == net && tb->port == port) {
+                               if (net_eq(ib_net(tb), net) &&
+                                   tb->port == port) {
                                        if (tb->fastreuse >= 0)
                                                goto next_port;
                                        WARN_ON(hlist_empty(&tb->owners));
 
        struct ctl_table_header *hdr;
 
        table = ip4_frags_ns_ctl_table;
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL);
                if (table == NULL)
                        goto err_alloc;
        return 0;
 
 err_reg:
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                kfree(table);
 err_alloc:
        return -ENOMEM;
 
                if (sk && inet_sk(sk)->inet_num == protocol &&
                    (!sk->sk_bound_dev_if ||
                     sk->sk_bound_dev_if == dev->ifindex) &&
-                   sock_net(sk) == dev_net(dev)) {
+                   net_eq(sock_net(sk), dev_net(dev))) {
                        if (ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)) {
                                if (ip_defrag(skb, IP_DEFRAG_CALL_RA_CHAIN)) {
                                        read_unlock(&ip_ra_lock);
 
        if (event == NETLINK_URELEASE &&
            n->protocol == NETLINK_FIREWALL && n->pid) {
                write_lock_bh(&queue_lock);
-               if ((n->net == &init_net) && (n->pid == peer_pid))
+               if ((net_eq(n->net, &init_net)) && (n->pid == peer_pid))
                        __ipq_reset();
                write_unlock_bh(&queue_lock);
        }
 
 
 static inline int compare_netns(struct rtable *rt1, struct rtable *rt2)
 {
-       return dev_net(rt1->u.dst.dev) == dev_net(rt2->u.dst.dev);
+       return net_eq(dev_net(rt1->u.dst.dev), dev_net(rt2->u.dst.dev));
 }
 
 static inline int rt_is_expired(struct rtable *rth)
        struct ctl_table *tbl;
 
        tbl = ipv4_route_flush_table;
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
                if (tbl == NULL)
                        goto err_dup;
 
        struct ctl_table *table;
 
        table = ipv4_net_table;
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                table = kmemdup(table, sizeof(ipv4_net_table), GFP_KERNEL);
                if (table == NULL)
                        goto err_alloc;
        return 0;
 
 err_reg:
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                kfree(table);
 err_alloc:
        return -ENOMEM;
 
        all = &ipv6_devconf;
        dflt = &ipv6_devconf_dflt;
 
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                all = kmemdup(all, sizeof(ipv6_devconf), GFP_KERNEL);
                if (all == NULL)
                        goto err_alloc_all;
        __addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
        __addrconf_sysctl_unregister(net->ipv6.devconf_all);
 #endif
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                kfree(net->ipv6.devconf_dflt);
                kfree(net->ipv6.devconf_all);
        }
 
        struct ip6_flowlabel *fl;
 
        for (fl=fl_ht[FL_HASH(label)]; fl; fl = fl->next) {
-               if (fl->label == label && fl->fl_net == net)
+               if (fl->label == label && net_eq(fl->fl_net, net))
                        return fl;
        }
        return NULL;
                struct ip6_flowlabel *fl, **flp;
                flp = &fl_ht[i];
                while ((fl = *flp) != NULL) {
-                       if (fl->fl_net == net && atomic_read(&fl->users) == 0) {
+                       if (net_eq(fl->fl_net, net) &&
+                           atomic_read(&fl->users) == 0) {
                                *flp = fl->next;
                                fl_free(fl);
                                atomic_dec(&fl_size);
        for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) {
                fl = fl_ht[state->bucket];
 
-               while (fl && fl->fl_net != net)
+               while (fl && !net_eq(fl->fl_net, net))
                        fl = fl->next;
                if (fl)
                        break;
 
        fl = fl->next;
 try_again:
-       while (fl && fl->fl_net != net)
+       while (fl && !net_eq(fl->fl_net, net))
                fl = fl->next;
 
        while (!fl) {
 
        if (event == NETLINK_URELEASE &&
            n->protocol == NETLINK_IP6_FW && n->pid) {
                write_lock_bh(&queue_lock);
-               if ((n->net == &init_net) && (n->pid == peer_pid))
+               if ((net_eq(n->net, &init_net)) && (n->pid == peer_pid))
                        __ipq_reset();
                write_unlock_bh(&queue_lock);
        }
 
        struct ctl_table_header *hdr;
 
        table = ip6_frags_ns_ctl_table;
-       if (net != &init_net) {
+       if (!net_eq(net, &init_net)) {
                table = kmemdup(table, sizeof(ip6_frags_ns_ctl_table), GFP_KERNEL);
                if (table == NULL)
                        goto err_alloc;
        return 0;
 
 err_reg:
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                kfree(table);
 err_alloc:
        return -ENOMEM;
 
        int rc = -ESOCKTNOSUPPORT;
        struct sock *sk;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        /*
 
        if (!capable(CAP_NET_RAW))
                return -EPERM;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        if (likely(sock->type == SOCK_DGRAM || sock->type == SOCK_STREAM)) {
 
                        struct hlist_head *head = &instance_table[i];
 
                        hlist_for_each_entry_safe(inst, tmp, t2, head, hlist) {
-                               if ((n->net == &init_net) &&
+                               if ((net_eq(n->net, &init_net)) &&
                                    (n->pid == inst->peer_pid))
                                        __instance_destroy(inst);
                        }
 
        if (sk == p->exclude_sk)
                goto out;
 
-       if (sock_net(sk) != sock_net(p->exclude_sk))
+       if (!net_eq(sock_net(sk), sock_net(p->exclude_sk)))
                goto out;
 
        if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
 
        struct sock *sk;
        struct nr_sock *nr;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        if (sock->type != SOCK_SEQPACKET || protocol != 0)
 
        if (skb->pkt_type == PACKET_LOOPBACK)
                goto out;
 
-       if (dev_net(dev) != sock_net(sk))
+       if (!net_eq(dev_net(dev), sock_net(sk)))
                goto out;
 
        skb = skb_share_check(skb, GFP_ATOMIC);
        sk = pt->af_packet_priv;
        po = pkt_sk(sk);
 
-       if (dev_net(dev) != sock_net(sk))
+       if (!net_eq(dev_net(dev), sock_net(sk)))
                goto drop;
 
        skb->dev = dev;
        sk = pt->af_packet_priv;
        po = pkt_sk(sk);
 
-       if (dev_net(dev) != sock_net(sk))
+       if (!net_eq(dev_net(dev), sock_net(sk)))
                goto drop;
 
        if (dev->header_ops) {
 
        struct sock *sk;
        struct rose_sock *rose;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        if (sock->type != SOCK_SEQPACKET || protocol != 0)
 
 
        _enter("%p,%d", sock, protocol);
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        /* we support transport protocol UDP only */
 
        u32 pid = skb ? NETLINK_CB(skb).pid : 0;
        int ret = 0, ovr = 0;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        ret = nlmsg_parse(n, sizeof(struct tcamsg), tca, TCA_ACT_MAX, NULL);
        struct tcamsg *t = (struct tcamsg *) NLMSG_DATA(cb->nlh);
        struct nlattr *kind = find_dump_kind(cb->nlh);
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        if (kind == NULL) {
 
        int err;
        int tp_created = 0;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
 replay:
        const struct Qdisc_class_ops *cops;
        struct tcf_dump_args arg;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
 
        struct Qdisc *p = NULL;
        int err;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
        struct Qdisc *q, *p;
        int err;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
 replay:
        int s_idx, s_q_idx;
        struct net_device *dev;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        s_idx = cb->args[0];
        u32 qid = TC_H_MAJ(clid);
        int err;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EINVAL;
 
        if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
        struct net_device *dev;
        int t, s_t;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return 0;
 
        if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
 
 
        /* Validate arguments */
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        if (unlikely(protocol != 0))
 
        struct x25_sock *x25;
        int rc = -ESOCKTNOSUPPORT;
 
-       if (net != &init_net)
+       if (!net_eq(net, &init_net))
                return -EAFNOSUPPORT;
 
        if (sock->type != SOCK_SEQPACKET || protocol)