in favor of their inner __ ones, which doesn't grab rtnl.
As these functions need to operate on a locked socket, we can't be
grabbing rtnl by then. It's too late and doing so causes reversed
locking.
So this patch:
- move rtnl handling to callers instead while already fixing some
  reversed locking situations, like on vxlan and ipvs code.
- renames __ ones to not have the __ mark:
  __ip_mc_{join,leave}_group -> ip_mc_{join,leave}_group
  __ipv6_sock_mc_{join,drop} -> ipv6_sock_mc_{join,drop}
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
 
 /* Callback to update multicast group membership when first VNI on
  * multicast asddress is brought up
- * Done as workqueue because ip_mc_join_group acquires RTNL.
  */
 static void vxlan_igmp_join(struct work_struct *work)
 {
        union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
        int ifindex = vxlan->default_dst.remote_ifindex;
 
+       rtnl_lock();
        lock_sock(sk);
        if (ip->sa.sa_family == AF_INET) {
                struct ip_mreqn mreq = {
 #endif
        }
        release_sock(sk);
+       rtnl_unlock();
 
        vxlan_sock_release(vs);
        dev_put(vxlan->dev);
        union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
        int ifindex = vxlan->default_dst.remote_ifindex;
 
+       rtnl_lock();
        lock_sock(sk);
        if (ip->sa.sa_family == AF_INET) {
                struct ip_mreqn mreq = {
        }
 
        release_sock(sk);
+       rtnl_unlock();
 
        vxlan_sock_release(vs);
        dev_put(vxlan->dev);
 
 
 extern int ip_check_mc_rcu(struct in_device *dev, __be32 mc_addr, __be32 src_addr, u16 proto);
 extern int igmp_rcv(struct sk_buff *);
-extern int __ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr);
 extern int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr);
-extern int __ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr);
 extern int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr);
 extern void ip_mc_drop_socket(struct sock *sk);
 extern int ip_mc_source(int add, int omode, struct sock *sk,
 
 
 int ipv6_sock_mc_join(struct sock *sk, int ifindex,
                      const struct in6_addr *addr);
-int __ipv6_sock_mc_join(struct sock *sk, int ifindex,
-                       const struct in6_addr *addr);
 int ipv6_sock_mc_drop(struct sock *sk, int ifindex,
                      const struct in6_addr *addr);
-int __ipv6_sock_mc_drop(struct sock *sk, int ifindex,
-                       const struct in6_addr *addr);
 #endif /* _NET_IPV6_H */
 
 
        lock_sock(sk);
        if (join)
-               ret = __ip_mc_join_group(sk, &mreq);
+               ret = ip_mc_join_group(sk, &mreq);
        else
-               ret = __ip_mc_leave_group(sk, &mreq);
+               ret = ip_mc_leave_group(sk, &mreq);
        release_sock(sk);
 
        return ret;
 
        pmc->sfcount[MCAST_EXCLUDE] = 1;
 }
 
-int __ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr)
+/* Join a multicast group
+ */
+
+int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr)
 {
        __be32 addr = imr->imr_multiaddr.s_addr;
        struct ip_mc_socklist *iml, *i;
 done:
        return err;
 }
-EXPORT_SYMBOL(__ip_mc_join_group);
-
-/* Join a multicast group
- */
-int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr)
-{
-       int ret;
-
-       rtnl_lock();
-       ret = __ip_mc_join_group(sk, imr);
-       rtnl_unlock();
-
-       return ret;
-}
 EXPORT_SYMBOL(ip_mc_join_group);
 
 static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
        return err;
 }
 
-int __ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
+int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
 {
        struct inet_sock *inet = inet_sk(sk);
        struct ip_mc_socklist *iml;
 out:
        return ret;
 }
-EXPORT_SYMBOL(__ip_mc_leave_group);
-
-int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
-{
-       int ret;
-
-       rtnl_lock();
-       ret = __ip_mc_leave_group(sk, imr);
-       rtnl_unlock();
-
-       return ret;
-}
 EXPORT_SYMBOL(ip_mc_leave_group);
 
 int ip_mc_source(int add, int omode, struct sock *sk, struct
        if (!ipv4_is_multicast(addr))
                return -EINVAL;
 
-       rtnl_lock();
+       ASSERT_RTNL();
 
        imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr;
        imr.imr_address.s_addr = mreqs->imr_interface;
        ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
                &mreqs->imr_sourceaddr, 1);
 done:
-       rtnl_unlock();
        if (leavegroup)
-               return ip_mc_leave_group(sk, &imr);
+               err = ip_mc_leave_group(sk, &imr);
        return err;
 }
 
            msf->imsf_fmode != MCAST_EXCLUDE)
                return -EINVAL;
 
-       rtnl_lock();
+       ASSERT_RTNL();
 
        imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
        imr.imr_address.s_addr = msf->imsf_interface;
        pmc->sfmode = msf->imsf_fmode;
        err = 0;
 done:
-       rtnl_unlock();
        if (leavegroup)
                err = ip_mc_leave_group(sk, &imr);
        return err;
 
        switch (optname) {
        case IP_ADD_MEMBERSHIP:
        case IP_ADD_SOURCE_MEMBERSHIP:
+       case IP_BLOCK_SOURCE:
        case IP_DROP_MEMBERSHIP:
+       case IP_DROP_SOURCE_MEMBERSHIP:
+       case IP_MSFILTER:
+       case IP_UNBLOCK_SOURCE:
+       case MCAST_BLOCK_SOURCE:
+       case MCAST_MSFILTER:
        case MCAST_JOIN_GROUP:
+       case MCAST_JOIN_SOURCE_GROUP:
        case MCAST_LEAVE_GROUP:
+       case MCAST_LEAVE_SOURCE_GROUP:
+       case MCAST_UNBLOCK_SOURCE:
                return true;
        }
        return false;
                }
 
                if (optname == IP_ADD_MEMBERSHIP)
-                       err = __ip_mc_join_group(sk, &mreq);
+                       err = ip_mc_join_group(sk, &mreq);
                else
-                       err = __ip_mc_leave_group(sk, &mreq);
+                       err = ip_mc_leave_group(sk, &mreq);
                break;
        }
        case IP_MSFILTER:
                        mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
                        mreq.imr_address.s_addr = mreqs.imr_interface;
                        mreq.imr_ifindex = 0;
-                       err = __ip_mc_join_group(sk, &mreq);
+                       err = ip_mc_join_group(sk, &mreq);
                        if (err && err != -EADDRINUSE)
                                break;
                        omode = MCAST_INCLUDE;
                mreq.imr_ifindex = greq.gr_interface;
 
                if (optname == MCAST_JOIN_GROUP)
-                       err = __ip_mc_join_group(sk, &mreq);
+                       err = ip_mc_join_group(sk, &mreq);
                else
-                       err = __ip_mc_leave_group(sk, &mreq);
+                       err = ip_mc_leave_group(sk, &mreq);
                break;
        }
        case MCAST_JOIN_SOURCE_GROUP:
                        mreq.imr_multiaddr = psin->sin_addr;
                        mreq.imr_address.s_addr = 0;
                        mreq.imr_ifindex = greqs.gsr_interface;
-                       err = __ip_mc_join_group(sk, &mreq);
+                       err = ip_mc_join_group(sk, &mreq);
                        if (err && err != -EADDRINUSE)
                                break;
                        greqs.gsr_interface = mreq.imr_ifindex;
 
 
        lock_sock(sk);
        if (join)
-               ret = __ipv6_sock_mc_join(sk, ifindex, addr);
+               ret = ipv6_sock_mc_join(sk, ifindex, addr);
        else
-               ret = __ipv6_sock_mc_drop(sk, ifindex, addr);
+               ret = ipv6_sock_mc_drop(sk, ifindex, addr);
        release_sock(sk);
 
        return ret;
 
        case IPV6_DROP_MEMBERSHIP:
        case MCAST_JOIN_GROUP:
        case MCAST_LEAVE_GROUP:
+       case MCAST_JOIN_SOURCE_GROUP:
+       case MCAST_LEAVE_SOURCE_GROUP:
+       case MCAST_BLOCK_SOURCE:
+       case MCAST_UNBLOCK_SOURCE:
+       case MCAST_MSFILTER:
                return true;
        }
        return false;
                        break;
 
                if (optname == IPV6_ADD_MEMBERSHIP)
-                       retv = __ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
+                       retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
                else
-                       retv = __ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
+                       retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
                break;
        }
        case IPV6_JOIN_ANYCAST:
                }
                psin6 = (struct sockaddr_in6 *)&greq.gr_group;
                if (optname == MCAST_JOIN_GROUP)
-                       retv = __ipv6_sock_mc_join(sk, greq.gr_interface,
-                                                  &psin6->sin6_addr);
+                       retv = ipv6_sock_mc_join(sk, greq.gr_interface,
+                                                &psin6->sin6_addr);
                else
-                       retv = __ipv6_sock_mc_drop(sk, greq.gr_interface,
-                                                  &psin6->sin6_addr);
+                       retv = ipv6_sock_mc_drop(sk, greq.gr_interface,
+                                                &psin6->sin6_addr);
                break;
        }
        case MCAST_JOIN_SOURCE_GROUP:
                        struct sockaddr_in6 *psin6;
 
                        psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;
-                       retv = __ipv6_sock_mc_join(sk, greqs.gsr_interface,
-                                                  &psin6->sin6_addr);
+                       retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,
+                                                &psin6->sin6_addr);
                        /* prior join w/ different source is ok */
                        if (retv && retv != -EADDRINUSE)
                                break;
 
        return iv > 0 ? iv : 1;
 }
 
-int __ipv6_sock_mc_join(struct sock *sk, int ifindex, const struct in6_addr *addr)
+int ipv6_sock_mc_join(struct sock *sk, int ifindex, const struct in6_addr *addr)
 {
        struct net_device *dev = NULL;
        struct ipv6_mc_socklist *mc_lst;
 
        return 0;
 }
-EXPORT_SYMBOL(__ipv6_sock_mc_join);
-
-int ipv6_sock_mc_join(struct sock *sk, int ifindex, const struct in6_addr *addr)
-{
-       int ret;
-
-       rtnl_lock();
-       ret = __ipv6_sock_mc_join(sk, ifindex, addr);
-       rtnl_unlock();
-
-       return ret;
-}
 EXPORT_SYMBOL(ipv6_sock_mc_join);
 
 /*
  *     socket leave on multicast group
  */
-int __ipv6_sock_mc_drop(struct sock *sk, int ifindex, const struct in6_addr *addr)
+int ipv6_sock_mc_drop(struct sock *sk, int ifindex, const struct in6_addr *addr)
 {
        struct ipv6_pinfo *np = inet6_sk(sk);
        struct ipv6_mc_socklist *mc_lst;
 
        return -EADDRNOTAVAIL;
 }
-EXPORT_SYMBOL(__ipv6_sock_mc_drop);
-
-int ipv6_sock_mc_drop(struct sock *sk, int ifindex, const struct in6_addr *addr)
-{
-       int ret;
-
-       rtnl_lock();
-       ret = __ipv6_sock_mc_drop(sk, ifindex, addr);
-       rtnl_unlock();
-
-       return ret;
-}
 EXPORT_SYMBOL(ipv6_sock_mc_drop);
 
 /* called with rcu_read_lock() */
        read_unlock_bh(&idev->lock);
        rcu_read_unlock();
        if (leavegroup)
-               return ipv6_sock_mc_drop(sk, pgsr->gsr_interface, group);
+               err = ipv6_sock_mc_drop(sk, pgsr->gsr_interface, group);
        return err;
 }
 
 
 
        mreq.imr_ifindex = dev->ifindex;
 
+       rtnl_lock();
        lock_sock(sk);
        ret = ip_mc_join_group(sk, &mreq);
        release_sock(sk);
+       rtnl_unlock();
 
        return ret;
 }
 
                        return 0;
                mreqn.imr_multiaddr = remote->ipv4;
                mreqn.imr_ifindex = ub->ifindex;
-               err = __ip_mc_join_group(sk, &mreqn);
+               err = ip_mc_join_group(sk, &mreqn);
        } else {
                if (!ipv6_addr_is_multicast(&remote->ipv6))
                        return 0;
-               err = __ipv6_sock_mc_join(sk, ub->ifindex, &remote->ipv6);
+               err = ipv6_sock_mc_join(sk, ub->ifindex, &remote->ipv6);
        }
        return err;
 }