Without CONFIG_NET_NS, namespace is always &init_net.
Compiler will be able to omit namespace comparisons with this patch.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
        struct net_device *dev = ptr;
        int ct;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event == NETDEV_DOWN) {
        struct atalk_addr sa, *ma, da;
        struct atalk_iface *ifa;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto out0;
 
        /* We only do Ethernet SNAP AARP. */
 
 {
        struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event == NETDEV_DOWN)
        int origlen;
        __u16 len_hops;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto freeit;
 
        /* Don't mangle buffer if shared */
 static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev,
                     struct packet_type *pt, struct net_device *orig_dev)
 {
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto freeit;
 
        /* Expand any short form frames */
 
 {
        struct net_device *dev = arg;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event == NETDEV_UNREGISTER) {
 
 
        dev = (struct net_device *)dev_ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (dev->name == NULL || strncmp(dev->name, "lec", 3))
 
 {
        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;
 
        /* Reject non AX.25 devices */
 
        skb->sk = NULL;         /* Initially we don't know who it's for */
        skb->destructor = NULL; /* Who initializes this, dammit?! */
 
-       if (dev_net(dev) != &init_net) {
+       if (!net_eq(dev_net(dev), &init_net)) {
                kfree_skb(skb);
                return 0;
        }
 
        struct net_bridge_port *p = dev->br_port;
        struct net_bridge *br;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        /* not a port of a bridge */
 
        struct net_bridge *br;
        const unsigned char *buf;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto err;
 
        if (!p)
 
        struct can_frame *cf = (struct can_frame *)skb->data;
        int matches;
 
-       if (dev->type != ARPHRD_CAN || dev_net(dev) != &init_net) {
+       if (dev->type != ARPHRD_CAN || !net_eq(dev_net(dev), &init_net)) {
                kfree_skb(skb);
                return 0;
        }
        struct net_device *dev = (struct net_device *)data;
        struct dev_rcv_lists *d;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (dev->type != ARPHRD_CAN)
 
        struct bcm_op *op;
        int notify_enodev = 0;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (dev->type != ARPHRD_CAN)
 
        struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
        struct sock *sk = &ro->sk;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (dev->type != ARPHRD_CAN)
 
 {
        struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        /* It is OK that we do not hold the group lock right now,
 
 {
        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;
 
        switch(event) {
 
        struct dn_dev *dn = (struct dn_dev *)dev->dn_ptr;
        unsigned char padlen = 0;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto dump_it;
 
        if (dn == NULL)
 
        struct sock *sk;
        struct ec_device *edev = dev->ec_ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto drop;
 
        if (skb->pkt_type == PACKET_OTHERHOST)
        struct net_device *dev = (struct net_device *)data;
        struct ec_device *edev;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        switch (msg) {
 
 
        ASSERT_RTNL();
 
-       if (dev_net(in_dev->dev) != &init_net)
+       if (!net_eq(dev_net(in_dev->dev), &init_net))
                return;
 
        for (im=in_dev->mc_list; im; im=im->next) {
 
        ASSERT_RTNL();
 
-       if (dev_net(in_dev->dev) != &init_net)
+       if (!net_eq(dev_net(in_dev->dev), &init_net))
                return;
 
        for (ip=&in_dev->mc_list; (i=*ip)!=NULL; ip=&i->next) {
 
        ASSERT_RTNL();
 
-       if (dev_net(in_dev->dev) != &init_net)
+       if (!net_eq(dev_net(in_dev->dev), &init_net))
                return;
 
        for (i=in_dev->mc_list; i; i=i->next)
 {
        ASSERT_RTNL();
 
-       if (dev_net(in_dev->dev) != &init_net)
+       if (!net_eq(dev_net(in_dev->dev), &init_net))
                return;
 
        in_dev->mc_tomb = NULL;
 
        ASSERT_RTNL();
 
-       if (dev_net(in_dev->dev) != &init_net)
+       if (!net_eq(dev_net(in_dev->dev), &init_net))
                return;
 
        ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS);
 
        ASSERT_RTNL();
 
-       if (dev_net(in_dev->dev) != &init_net)
+       if (!net_eq(dev_net(in_dev->dev), &init_net))
                return;
 
        /* Deactivate timers */
        if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return -EPROTONOSUPPORT;
 
        rtnl_lock();
        u32 ifindex;
        int ret = -EADDRNOTAVAIL;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return -EPROTONOSUPPORT;
 
        rtnl_lock();
        if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return -EPROTONOSUPPORT;
 
        rtnl_lock();
            msf->imsf_fmode != MCAST_EXCLUDE)
                return -EINVAL;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return -EPROTONOSUPPORT;
 
        rtnl_lock();
        if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return -EPROTONOSUPPORT;
 
        rtnl_lock();
        if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return -EPROTONOSUPPORT;
 
        rtnl_lock();
        if (inet->mc_list == NULL)
                return;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return;
 
        rtnl_lock();
 
        unsigned char *sha, *tha;               /* s for "source", t for "target" */
        struct ic_device *d;
 
-       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 ic_device *d;
        int len, ext_len;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto drop;
 
        /* Perform verifications before taking the lock.  */
 
        struct vif_device *v;
        int ct;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event != NETDEV_UNREGISTER)
 
 {
        struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        /* Drop any packets associated with the downed device */
 
 {
        const struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event == NETDEV_DOWN) {
 
        struct mif_device *v;
        int ct;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event != NETDEV_UNREGISTER)
 
 {
        struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        /* Drop any packets associated with the downed device */
 
        if (!idev || !idev->dev)
                return -EINVAL;
 
-       if (dev_net(idev->dev) != &init_net)
+       if (!net_eq(dev_net(idev->dev), &init_net))
                return 0;
 
        if (!proc_net_devsnmp6)
 
        struct net_device *dev = ptr;
        struct ipx_interface *i, *tmp;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (event != NETDEV_DOWN && event != NETDEV_UP)
        u16 ipx_pktsize;
        int rc = 0;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto drop;
 
        /* Not ours */
 
        int command;
        __u8 control;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto out;
 
        /* FIXME: should we get our own field? */
 
        int (*rcv)(struct sk_buff *, struct net_device *,
                   struct packet_type *, struct net_device *);
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto drop;
 
        /*
 
 {
        struct nf_sockopt_ops *ops;
 
-       if (sock_net(sk) != &init_net)
+       if (!net_eq(sock_net(sk), &init_net))
                return ERR_PTR(-ENOPROTOOPT);
 
        if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
 
 {
        struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        /* Drop any packets associated with the downed device */
 
        struct net_device *dev = ptr;
        struct netlbl_unlhsh_iface *iface = NULL;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        /* XXX - should this be a check for NETDEV_DOWN or _UNREGISTER? */
 
 {
        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 (event != NETDEV_DOWN)
 
                case SIOCGIFDSTADDR:
                case SIOCSIFDSTADDR:
                case SIOCSIFFLAGS:
-                       if (sock_net(sk) != &init_net)
+                       if (!net_eq(sock_net(sk), &init_net))
                                return -ENOIOCTLCMD;
                        return inet_dgram_ops.ioctl(sock, cmd, arg);
 #endif
 
 {
        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 (event != NETDEV_DOWN)
 
        struct sctp_sockaddr_entry *temp;
        int found = 0;
 
-       if (dev_net(ifa->ifa_dev->dev) != &init_net)
+       if (!net_eq(dev_net(ifa->ifa_dev->dev), &init_net))
                return NOTIFY_DONE;
 
        switch (ev) {
 
        struct eth_bearer *eb_ptr = (struct eth_bearer *)pt->af_packet_priv;
        u32 size;
 
-       if (dev_net(dev) != &init_net) {
+       if (!net_eq(dev_net(dev), &init_net)) {
                kfree_skb(buf);
                return 0;
        }
        struct eth_bearer *eb_ptr = ð_bearers[0];
        struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS];
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        while ((eb_ptr->dev != dev)) {
 
        struct sk_buff *skb;
        int err;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return;
 
        skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 
        struct net_device *dev = ptr;
        struct x25_neigh *nb;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        if (dev->type == ARPHRD_X25
 
        struct sk_buff *nskb;
        struct x25_neigh *nb;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                goto drop;
 
        nskb = skb_copy(skb, GFP_ATOMIC);
 
 {
        struct net_device *dev = ptr;
 
-       if (dev_net(dev) != &init_net)
+       if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
        switch (event) {