void dev_add_offload(struct packet_offload *po);
 void dev_remove_offload(struct packet_offload *po);
 
-struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
-                                       unsigned short mask);
+struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
+                                     unsigned short mask);
 struct net_device *dev_get_by_name(struct net *net, const char *name);
 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
 struct net_device *__dev_get_by_name(struct net *net, const char *name);
 
 EXPORT_SYMBOL(dev_getfirstbyhwtype);
 
 /**
- *     dev_get_by_flags_rcu - find any device with given flags
+ *     __dev_get_by_flags - find any device with given flags
  *     @net: the applicable net namespace
  *     @if_flags: IFF_* values
  *     @mask: bitmask of bits in if_flags to check
  *
  *     Search for any interface with the given flags. Returns NULL if a device
  *     is not found or a pointer to the device. Must be called inside
- *     rcu_read_lock(), and result refcount is unchanged.
+ *     rtnl_lock(), and result refcount is unchanged.
  */
 
-struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short if_flags,
-                                   unsigned short mask)
+struct net_device *__dev_get_by_flags(struct net *net, unsigned short if_flags,
+                                     unsigned short mask)
 {
        struct net_device *dev, *ret;
 
+       ASSERT_RTNL();
+
        ret = NULL;
-       for_each_netdev_rcu(net, dev) {
+       for_each_netdev(net, dev) {
                if (((dev->flags ^ if_flags) & mask) == 0) {
                        ret = dev;
                        break;
        }
        return ret;
 }
-EXPORT_SYMBOL(dev_get_by_flags_rcu);
+EXPORT_SYMBOL(__dev_get_by_flags);
 
 /**
  *     dev_valid_name - check if name is okay for network device
 
        pac->acl_addr = *addr;
 
        rtnl_lock();
-       rcu_read_lock();
        if (ifindex == 0) {
                struct rt6_info *rt;
 
                        goto error;
                } else {
                        /* router, no matching interface: just pick one */
-                       dev = dev_get_by_flags_rcu(net, IFF_UP,
-                                                  IFF_UP | IFF_LOOPBACK);
+                       dev = __dev_get_by_flags(net, IFF_UP,
+                                                IFF_UP | IFF_LOOPBACK);
                }
        } else
-               dev = dev_get_by_index_rcu(net, ifindex);
+               dev = __dev_get_by_index(net, ifindex);
 
        if (dev == NULL) {
                err = -ENODEV;
        }
 
 error:
-       rcu_read_unlock();
        rtnl_unlock();
        if (pac)
                sock_kfree_s(sk, pac, sizeof(*pac));
        spin_unlock_bh(&ipv6_sk_ac_lock);
 
        rtnl_lock();
-       rcu_read_lock();
-       dev = dev_get_by_index_rcu(net, pac->acl_ifindex);
+       dev = __dev_get_by_index(net, pac->acl_ifindex);
        if (dev)
                ipv6_dev_ac_dec(dev, &pac->acl_addr);
-       rcu_read_unlock();
        rtnl_unlock();
 
        sock_kfree_s(sk, pac, sizeof(*pac));
 
        prev_index = 0;
        rtnl_lock();
-       rcu_read_lock();
        while (pac) {
                struct ipv6_ac_socklist *next = pac->acl_next;
 
                if (pac->acl_ifindex != prev_index) {
-                       dev = dev_get_by_index_rcu(net, pac->acl_ifindex);
+                       dev = __dev_get_by_index(net, pac->acl_ifindex);
                        prev_index = pac->acl_ifindex;
                }
                if (dev)
                sock_kfree_s(sk, pac, sizeof(*pac));
                pac = next;
        }
-       rcu_read_unlock();
        rtnl_unlock();
 }
 
        return 0;
 }
 
-/* called with rcu_read_lock() */
+/* called with rtnl_lock() */
 static int ipv6_dev_ac_dec(struct net_device *dev, const struct in6_addr *addr)
 {
        struct inet6_dev *idev = __in6_dev_get(dev);