1 files changed, 70 insertions, 83 deletions

diff --git a/net/tipc/bearer.c b/net/tipc/bearer.c
index 3fef7eb776dc..264474394f9f 100644
--- a/net/tipc/bearer.c
+++ b/net/tipc/bearer.c
@@ -49,7 +49,7 @@ static struct tipc_media * const media_info_array[] = {
         NULL
 };
 
-struct tipc_bearer *bearer_list[MAX_BEARERS + 1];
+struct tipc_bearer __rcu *bearer_list[MAX_BEARERS + 1];
 
 static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down);
 
@@ -178,7 +178,7 @@ struct tipc_bearer *tipc_bearer_find(const char *name)
         u32 i;
 
         for (i = 0; i < MAX_BEARERS; i++) {
-                b_ptr = bearer_list[i];
+                b_ptr = rtnl_dereference(bearer_list[i]);
                 if (b_ptr && (!strcmp(b_ptr->name, name)))
                         return b_ptr;
         }
@@ -198,10 +198,9 @@ struct sk_buff *tipc_bearer_get_names(void)
         if (!buf)
                 return NULL;
 
-        read_lock_bh(&tipc_net_lock);
         for (i = 0; media_info_array[i] != NULL; i++) {
                 for (j = 0; j < MAX_BEARERS; j++) {
-                        b = bearer_list[j];
+                        b = rtnl_dereference(bearer_list[j]);
                         if (!b)
                                 continue;
                         if (b->media == media_info_array[i]) {
@@ -211,22 +210,33 @@ struct sk_buff *tipc_bearer_get_names(void)
                         }
                 }
         }
-        read_unlock_bh(&tipc_net_lock);
         return buf;
 }
 
-void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest)
+void tipc_bearer_add_dest(u32 bearer_id, u32 dest)
 {
-        tipc_nmap_add(&b_ptr->nodes, dest);
-        tipc_bcbearer_sort();
-        tipc_disc_add_dest(b_ptr->link_req);
+        struct tipc_bearer *b_ptr;
+
+        rcu_read_lock();
+        b_ptr = rcu_dereference_rtnl(bearer_list[bearer_id]);
+        if (b_ptr) {
+                tipc_bcbearer_sort(&b_ptr->nodes, dest, true);
+                tipc_disc_add_dest(b_ptr->link_req);
+        }
+        rcu_read_unlock();
 }
 
-void tipc_bearer_remove_dest(struct tipc_bearer *b_ptr, u32 dest)
+void tipc_bearer_remove_dest(u32 bearer_id, u32 dest)
 {
-        tipc_nmap_remove(&b_ptr->nodes, dest);
-        tipc_bcbearer_sort();
-        tipc_disc_remove_dest(b_ptr->link_req);
+        struct tipc_bearer *b_ptr;
+
+        rcu_read_lock();
+        b_ptr = rcu_dereference_rtnl(bearer_list[bearer_id]);
+        if (b_ptr) {
+                tipc_bcbearer_sort(&b_ptr->nodes, dest, false);
+                tipc_disc_remove_dest(b_ptr->link_req);
+        }
+        rcu_read_unlock();
 }
 
 /**
@@ -271,13 +281,11 @@ int tipc_enable_bearer(const char *name, u32 disc_domain, u32 priority)
                 return -EINVAL;
         }
 
-        write_lock_bh(&tipc_net_lock);
-
         m_ptr = tipc_media_find(b_names.media_name);
         if (!m_ptr) {
                 pr_warn("Bearer <%s> rejected, media <%s> not registered\n",
                         name, b_names.media_name);
-                goto exit;
+                return -EINVAL;
         }
 
         if (priority == TIPC_MEDIA_LINK_PRI)
@@ -287,7 +295,7 @@ restart:
         bearer_id = MAX_BEARERS;
         with_this_prio = 1;
         for (i = MAX_BEARERS; i-- != 0; ) {
-                b_ptr = bearer_list[i];
+                b_ptr = rtnl_dereference(bearer_list[i]);
                 if (!b_ptr) {
                         bearer_id = i;
                         continue;
@@ -295,14 +303,14 @@ restart:
                 if (!strcmp(name, b_ptr->name)) {
                         pr_warn("Bearer <%s> rejected, already enabled\n",
                                 name);
-                        goto exit;
+                        return -EINVAL;
                 }
                 if ((b_ptr->priority == priority) &&
                     (++with_this_prio > 2)) {
                         if (priority-- == 0) {
                                 pr_warn("Bearer <%s> rejected, duplicate priority\n",
                                         name);
-                                goto exit;
+                                return -EINVAL;
                         }
                         pr_warn("Bearer <%s> priority adjustment required %u->%u\n",
                                 name, priority + 1, priority);
@@ -312,21 +320,20 @@ restart:
         if (bearer_id >= MAX_BEARERS) {
                 pr_warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
                         name, MAX_BEARERS);
-                goto exit;
+                return -EINVAL;
         }
 
         b_ptr = kzalloc(sizeof(*b_ptr), GFP_ATOMIC);
-        if (!b_ptr) {
-                res = -ENOMEM;
-                goto exit;
-        }
+        if (!b_ptr)
+                return -ENOMEM;
+
         strcpy(b_ptr->name, name);
         b_ptr->media = m_ptr;
         res = m_ptr->enable_media(b_ptr);
         if (res) {
                 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
                         name, -res);
-                goto exit;
+                return -EINVAL;
         }
 
         b_ptr->identity = bearer_id;
@@ -341,16 +348,14 @@ restart:
                 bearer_disable(b_ptr, false);
                 pr_warn("Bearer <%s> rejected, discovery object creation failed\n",
                         name);
-                goto exit;
+                return -EINVAL;
         }
 
-        bearer_list[bearer_id] = b_ptr;
+        rcu_assign_pointer(bearer_list[bearer_id], b_ptr);
 
         pr_info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
                 name,
                 tipc_addr_string_fill(addr_string, disc_domain), priority);
-exit:
-        write_unlock_bh(&tipc_net_lock);
         return res;
 }
 
@@ -359,19 +364,16 @@ exit:
  */
 static int tipc_reset_bearer(struct tipc_bearer *b_ptr)
 {
-        read_lock_bh(&tipc_net_lock);
         pr_info("Resetting bearer <%s>\n", b_ptr->name);
-        tipc_disc_delete(b_ptr->link_req);
         tipc_link_reset_list(b_ptr->identity);
-        tipc_disc_create(b_ptr, &b_ptr->bcast_addr);
-        read_unlock_bh(&tipc_net_lock);
+        tipc_disc_reset(b_ptr);
         return 0;
 }
 
 /**
  * bearer_disable
  *
- * Note: This routine assumes caller holds tipc_net_lock.
+ * Note: This routine assumes caller holds RTNL lock.
  */
 static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down)
 {
@@ -385,12 +387,12 @@ static void bearer_disable(struct tipc_bearer *b_ptr, bool shutting_down)
                 tipc_disc_delete(b_ptr->link_req);
 
         for (i = 0; i < MAX_BEARERS; i++) {
-                if (b_ptr == bearer_list[i]) {
-                        bearer_list[i] = NULL;
+                if (b_ptr == rtnl_dereference(bearer_list[i])) {
+                        RCU_INIT_POINTER(bearer_list[i], NULL);
                         break;
                 }
         }
-        kfree(b_ptr);
+        kfree_rcu(b_ptr, rcu);
 }
 
 int tipc_disable_bearer(const char *name)
@@ -398,7 +400,6 @@ int tipc_disable_bearer(const char *name)
         struct tipc_bearer *b_ptr;
         int res;
 
-        write_lock_bh(&tipc_net_lock);
         b_ptr = tipc_bearer_find(name);
         if (b_ptr == NULL) {
                 pr_warn("Attempt to disable unknown bearer <%s>\n", name);
@@ -407,32 +408,9 @@ int tipc_disable_bearer(const char *name)
                 bearer_disable(b_ptr, false);
                 res = 0;
         }
-        write_unlock_bh(&tipc_net_lock);
         return res;
 }
 
-
-/* tipc_l2_media_addr_set - initialize Ethernet media address structure
- *
- * Media-dependent "value" field stores MAC address in first 6 bytes
- * and zeroes out the remaining bytes.
- */
-void tipc_l2_media_addr_set(const struct tipc_bearer *b,
-                            struct tipc_media_addr *a, char *mac)
-{
-        int len = b->media->hwaddr_len;
-
-        if (unlikely(sizeof(a->value) < len)) {
-                WARN_ONCE(1, "Media length invalid\n");
-                return;
-        }
-
-        memcpy(a->value, mac, len);
-        memset(a->value + len, 0, sizeof(a->value) - len);
-        a->media_id = b->media->type_id;
-        a->broadcast = !memcmp(mac, b->bcast_addr.value, len);
-}
-
 int tipc_enable_l2_media(struct tipc_bearer *b)
 {
         struct net_device *dev;
@@ -443,33 +421,37 @@ int tipc_enable_l2_media(struct tipc_bearer *b)
         if (!dev)
                 return -ENODEV;
 
-        /* Associate TIPC bearer with Ethernet bearer */
-        b->media_ptr = dev;
-        memset(b->bcast_addr.value, 0, sizeof(b->bcast_addr.value));
+        /* Associate TIPC bearer with L2 bearer */
+        rcu_assign_pointer(b->media_ptr, dev);
+        memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
         memcpy(b->bcast_addr.value, dev->broadcast, b->media->hwaddr_len);
         b->bcast_addr.media_id = b->media->type_id;
         b->bcast_addr.broadcast = 1;
         b->mtu = dev->mtu;
-        tipc_l2_media_addr_set(b, &b->addr, (char *)dev->dev_addr);
+        b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr);
         rcu_assign_pointer(dev->tipc_ptr, b);
         return 0;
 }
 
-/* tipc_disable_l2_media - detach TIPC bearer from an Ethernet interface
+/* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
  *
- * Mark Ethernet bearer as inactive so that incoming buffers are thrown away,
+ * Mark L2 bearer as inactive so that incoming buffers are thrown away,
  * then get worker thread to complete bearer cleanup.  (Can't do cleanup
  * here because cleanup code needs to sleep and caller holds spinlocks.)
  */
 void tipc_disable_l2_media(struct tipc_bearer *b)
 {
-        struct net_device *dev = (struct net_device *)b->media_ptr;
+        struct net_device *dev;
+
+        dev = (struct net_device *)rtnl_dereference(b->media_ptr);
+        RCU_INIT_POINTER(b->media_ptr, NULL);
         RCU_INIT_POINTER(dev->tipc_ptr, NULL);
+        synchronize_net();
         dev_put(dev);
 }
 
 /**
- * tipc_l2_send_msg - send a TIPC packet out over an Ethernet interface
+ * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
  * @buf: the packet to be sent
  * @b_ptr: the bearer through which the packet is to be sent
  * @dest: peer destination address
@@ -478,8 +460,12 @@ int tipc_l2_send_msg(struct sk_buff *buf, struct tipc_bearer *b,
                      struct tipc_media_addr *dest)
 {
         struct sk_buff *clone;
+        struct net_device *dev;
         int delta;
-        struct net_device *dev = (struct net_device *)b->media_ptr;
+
+        dev = (struct net_device *)rcu_dereference_rtnl(b->media_ptr);
+        if (!dev)
+                return 0;
 
         clone = skb_clone(buf, GFP_ATOMIC);
         if (!clone)
@@ -507,10 +493,16 @@ int tipc_l2_send_msg(struct sk_buff *buf, struct tipc_bearer *b,
  * The media send routine must not alter the buffer being passed in
  * as it may be needed for later retransmission!
  */
-void tipc_bearer_send(struct tipc_bearer *b, struct sk_buff *buf,
+void tipc_bearer_send(u32 bearer_id, struct sk_buff *buf,
                       struct tipc_media_addr *dest)
 {
-        b->media->send_msg(buf, b, dest);
+        struct tipc_bearer *b_ptr;
+
+        rcu_read_lock();
+        b_ptr = rcu_dereference_rtnl(bearer_list[bearer_id]);
+        if (likely(b_ptr))
+                b_ptr->media->send_msg(buf, b_ptr, dest);
+        rcu_read_unlock();
 }
 
 /**
@@ -535,7 +527,7 @@ static int tipc_l2_rcv_msg(struct sk_buff *buf, struct net_device *dev,
         }
 
         rcu_read_lock();
-        b_ptr = rcu_dereference(dev->tipc_ptr);
+        b_ptr = rcu_dereference_rtnl(dev->tipc_ptr);
         if (likely(b_ptr)) {
                 if (likely(buf->pkt_type <= PACKET_BROADCAST)) {
                         buf->next = NULL;
@@ -568,12 +560,9 @@ static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
         if (!net_eq(dev_net(dev), &init_net))
                 return NOTIFY_DONE;
 
-        rcu_read_lock();
-        b_ptr = rcu_dereference(dev->tipc_ptr);
-        if (!b_ptr) {
-                rcu_read_unlock();
+        b_ptr = rtnl_dereference(dev->tipc_ptr);
+        if (!b_ptr)
                 return NOTIFY_DONE;
-        }
 
         b_ptr->mtu = dev->mtu;
 
@@ -586,17 +575,15 @@ static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
                 tipc_reset_bearer(b_ptr);
                 break;
         case NETDEV_CHANGEADDR:
-                tipc_l2_media_addr_set(b_ptr, &b_ptr->addr,
+                b_ptr->media->raw2addr(b_ptr, &b_ptr->addr,
                                        (char *)dev->dev_addr);
                 tipc_reset_bearer(b_ptr);
                 break;
         case NETDEV_UNREGISTER:
         case NETDEV_CHANGENAME:
-                tipc_disable_bearer(b_ptr->name);
+                bearer_disable(b_ptr, false);
                 break;
         }
-        rcu_read_unlock();
-
         return NOTIFY_OK;
 }
 
@@ -633,7 +620,7 @@ void tipc_bearer_stop(void)
         u32 i;
 
         for (i = 0; i < MAX_BEARERS; i++) {
-                b_ptr = bearer_list[i];
+                b_ptr = rtnl_dereference(bearer_list[i]);
                 if (b_ptr) {
                         bearer_disable(b_ptr, true);
                         bearer_list[i] = NULL;