Four years ago, Patrick made a change to hold rtnl mutex during netlink
dump callbacks.
I believe it was a wrong move. This slows down concurrent dumps, making
good old /proc/net/ files faster than rtnetlink in some situations.
This occurred to me because one "ip link show dev ..." was _very_ slow
on a workload adding/removing network devices in background.
All dump callbacks are able to use RCU locking now, so this patch does
roughly a revert of commits :
1c2d670f366 : [RTNETLINK]: Hold rtnl_mutex during netlink dump callbacks
6313c1e0992 : [RTNETLINK]: Remove unnecessary locking in dump callbacks
This let writers fight for rtnl mutex and readers going full speed.
It also takes care of phonet : phonet_route_get() is now called from rcu
read section. I renamed it to phonet_route_get_rcu()
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Patrick McHardy <kaber@trash.net>
Cc: Remi Denis-Courmont <remi.denis-courmont@nokia.com>
Acked-by: Stephen Hemminger <shemminger@vyatta.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
 int phonet_route_add(struct net_device *dev, u8 daddr);
 int phonet_route_del(struct net_device *dev, u8 daddr);
 void rtm_phonet_notify(int event, struct net_device *dev, u8 dst);
-struct net_device *phonet_route_get(struct net *net, u8 daddr);
+struct net_device *phonet_route_get_rcu(struct net *net, u8 daddr);
 struct net_device *phonet_route_output(struct net *net, u8 daddr);
 
 #define PN_NO_ADDR     0xff
 
        int idx;
 
        idx = 0;
-       for_each_netdev(net, dev) {
-               struct net_bridge_port *port = br_port_get_rtnl(dev);
+       rcu_read_lock();
+       for_each_netdev_rcu(net, dev) {
+               struct net_bridge_port *port = br_port_get_rcu(dev);
 
                /* not a bridge port */
                if (!port || idx < cb->args[0])
 skip:
                ++idx;
        }
-
+       rcu_read_unlock();
        cb->args[0] = idx;
 
        return skb->len;
 
        int idx = 0;
        struct fib_rule *rule;
 
-       list_for_each_entry(rule, &ops->rules_list, list) {
+       rcu_read_lock();
+       list_for_each_entry_rcu(rule, &ops->rules_list, list) {
                if (idx < cb->args[1])
                        goto skip;
 
 
        s_h = cb->args[0];
        s_idx = cb->args[1];
 
+       rcu_read_lock();
        for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
                idx = 0;
                head = &net->dev_index_head[h];
-               hlist_for_each_entry(dev, node, head, index_hlist) {
+               hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
                        if (idx < s_idx)
                                goto cont;
                        if (rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
                }
        }
 out:
+       rcu_read_unlock();
        cb->args[1] = idx;
        cb->args[0] = h;
 
        int min_len;
        int family;
        int type;
-       int err;
 
        type = nlh->nlmsg_type;
        if (type > RTM_MAX)
                if (dumpit == NULL)
                        return -EOPNOTSUPP;
 
-               __rtnl_unlock();
                rtnl = net->rtnl;
-               err = netlink_dump_start(rtnl, skb, nlh, dumpit, NULL);
-               rtnl_lock();
-               return err;
+               return netlink_dump_start(rtnl, skb, nlh, dumpit, NULL);
        }
 
        memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *)));
 {
        struct sock *sk;
        sk = netlink_kernel_create(net, NETLINK_ROUTE, RTNLGRP_MAX,
-                                  rtnetlink_rcv, &rtnl_mutex, THIS_MODULE);
+                                  rtnetlink_rcv, NULL, THIS_MODULE);
        if (!sk)
                return -ENOMEM;
        net->rtnl = sk;
 
        skip_naddr = cb->args[1];
 
        idx = 0;
-       for_each_netdev(&init_net, dev) {
+       rcu_read_lock();
+       for_each_netdev_rcu(&init_net, dev) {
                if (idx < skip_ndevs)
                        goto cont;
                else if (idx > skip_ndevs) {
                        skip_naddr = 0;
                }
 
-               if ((dn_db = rtnl_dereference(dev->dn_ptr)) == NULL)
+               if ((dn_db = rcu_dereference(dev->dn_ptr)) == NULL)
                        goto cont;
 
-               for (ifa = rtnl_dereference(dn_db->ifa_list), dn_idx = 0; ifa;
-                    ifa = rtnl_dereference(ifa->ifa_next), dn_idx++) {
+               for (ifa = rcu_dereference(dn_db->ifa_list), dn_idx = 0; ifa;
+                    ifa = rcu_dereference(ifa->ifa_next), dn_idx++) {
                        if (dn_idx < skip_naddr)
                                continue;
 
                idx++;
        }
 done:
+       rcu_read_unlock();
        cb->args[0] = idx;
        cb->args[1] = dn_idx;
 
 
        arg.net = net;
        w->args = &arg;
 
+       rcu_read_lock();
        for (h = s_h; h < FIB6_TABLE_HASHSZ; h++, s_e = 0) {
                e = 0;
                head = &net->ipv6.fib_table_hash[h];
-               hlist_for_each_entry(tb, node, head, tb6_hlist) {
+               hlist_for_each_entry_rcu(tb, node, head, tb6_hlist) {
                        if (e < s_e)
                                goto next;
                        res = fib6_dump_table(tb, skb, cb);
                }
        }
 out:
+       rcu_read_unlock();
        cb->args[1] = e;
        cb->args[0] = h;
 
 
        return 0;
 }
 
-struct net_device *phonet_route_get(struct net *net, u8 daddr)
+struct net_device *phonet_route_get_rcu(struct net *net, u8 daddr)
 {
        struct phonet_net *pnn = phonet_pernet(net);
        struct phonet_routes *routes = &pnn->routes;
        struct net_device *dev;
 
-       ASSERT_RTNL(); /* no need to hold the device */
-
        daddr >>= 2;
-       rcu_read_lock();
        dev = rcu_dereference(routes->table[daddr]);
-       rcu_read_unlock();
        return dev;
 }
 
 
        struct net *net = sock_net(skb->sk);
        u8 addr, addr_idx = 0, addr_start_idx = cb->args[0];
 
+       rcu_read_lock();
        for (addr = 0; addr < 64; addr++) {
                struct net_device *dev;
 
-               dev = phonet_route_get(net, addr << 2);
+               dev = phonet_route_get_rcu(net, addr << 2);
                if (!dev)
                        continue;
 
        }
 
 out:
+       rcu_read_unlock();
        cb->args[0] = addr_idx;
        cb->args[1] = 0;