4 files changed, 155 insertions, 166 deletions

diff --git a/net/tipc/bearer.c b/net/tipc/bearer.c
index e18cb271b005..76340b9e4851 100644
--- a/net/tipc/bearer.c
+++ b/net/tipc/bearer.c
@@ -210,7 +210,7 @@ void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
         rcu_read_lock();
         b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
         if (b)
-                tipc_disc_add_dest(b->link_req);
+                tipc_disc_add_dest(b->disc);
         rcu_read_unlock();
 }
 
@@ -222,7 +222,7 @@ void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
         rcu_read_lock();
         b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
         if (b)
-                tipc_disc_remove_dest(b->link_req);
+                tipc_disc_remove_dest(b->disc);
         rcu_read_unlock();
 }
 
@@ -389,8 +389,8 @@ static void bearer_disable(struct net *net, struct tipc_bearer *b)
         tipc_node_delete_links(net, bearer_id);
         b->media->disable_media(b);
         RCU_INIT_POINTER(b->media_ptr, NULL);
-        if (b->link_req)
-                tipc_disc_delete(b->link_req);
+        if (b->disc)
+                tipc_disc_delete(b->disc);
         RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
         kfree_rcu(b, rcu);
         tipc_mon_delete(net, bearer_id);
diff --git a/net/tipc/bearer.h b/net/tipc/bearer.h
index a53613d95bc9..6efcee63a381 100644
--- a/net/tipc/bearer.h
+++ b/net/tipc/bearer.h
@@ -159,7 +159,7 @@ struct tipc_bearer {
         u32 tolerance;
         u32 domain;
         u32 identity;
-        struct tipc_link_req *link_req;
+        struct tipc_discoverer *disc;
         char net_plane;
         unsigned long up;
 };
diff --git a/net/tipc/discover.c b/net/tipc/discover.c
index 92e4828c6b09..09f75558d353 100644
--- a/net/tipc/discover.c
+++ b/net/tipc/discover.c
@@ -39,34 +39,34 @@
 #include "discover.h"
 
 /* min delay during bearer start up */
-#define TIPC_LINK_REQ_INIT      msecs_to_jiffies(125)
+#define TIPC_DISC_INIT  msecs_to_jiffies(125)
 /* max delay if bearer has no links */
-#define TIPC_LINK_REQ_FAST      msecs_to_jiffies(1000)
+#define TIPC_DISC_FAST  msecs_to_jiffies(1000)
 /* max delay if bearer has links */
-#define TIPC_LINK_REQ_SLOW      msecs_to_jiffies(60000)
+#define TIPC_DISC_SLOW  msecs_to_jiffies(60000)
 /* indicates no timer in use */
-#define TIPC_LINK_REQ_INACTIVE  0xffffffff
+#define TIPC_DISC_INACTIVE      0xffffffff
 
 /**
- * struct tipc_link_req - information about an ongoing link setup request
+ * struct tipc_discoverer - information about an ongoing link setup request
  * @bearer_id: identity of bearer issuing requests
  * @net: network namespace instance
  * @dest: destination address for request messages
  * @domain: network domain to which links can be established
  * @num_nodes: number of nodes currently discovered (i.e. with an active link)
  * @lock: spinlock for controlling access to requests
- * @buf: request message to be (repeatedly) sent
+ * @skb: request message to be (repeatedly) sent
  * @timer: timer governing period between requests
  * @timer_intv: current interval between requests (in ms)
  */
-struct tipc_link_req {
+struct tipc_discoverer {
         u32 bearer_id;
         struct tipc_media_addr dest;
         struct net *net;
         u32 domain;
         int num_nodes;
         spinlock_t lock;
-        struct sk_buff *buf;
+        struct sk_buff *skb;
         struct timer_list timer;
         unsigned long timer_intv;
 };
@@ -77,22 +77,35 @@ struct tipc_link_req {
  * @type: message type (request or response)
  * @b: ptr to bearer issuing message
  */
-static void tipc_disc_init_msg(struct net *net, struct sk_buff *buf, u32 type,
-                               struct tipc_bearer *b)
+static void tipc_disc_init_msg(struct net *net, struct sk_buff *skb,
+                               u32 mtyp, struct tipc_bearer *b)
 {
-        struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_msg *msg;
+        struct tipc_net *tn = tipc_net(net);
         u32 dest_domain = b->domain;
+        struct tipc_msg *hdr;
 
-        msg = buf_msg(buf);
-        tipc_msg_init(tn->own_addr, msg, LINK_CONFIG, type,
+        hdr = buf_msg(skb);
+        tipc_msg_init(tn->own_addr, hdr, LINK_CONFIG, mtyp,
                       MAX_H_SIZE, dest_domain);
-        msg_set_non_seq(msg, 1);
-        msg_set_node_sig(msg, tn->random);
-        msg_set_node_capabilities(msg, TIPC_NODE_CAPABILITIES);
-        msg_set_dest_domain(msg, dest_domain);
-        msg_set_bc_netid(msg, tn->net_id);
-        b->media->addr2msg(msg_media_addr(msg), &b->addr);
+        msg_set_non_seq(hdr, 1);
+        msg_set_node_sig(hdr, tn->random);
+        msg_set_node_capabilities(hdr, TIPC_NODE_CAPABILITIES);
+        msg_set_dest_domain(hdr, dest_domain);
+        msg_set_bc_netid(hdr, tn->net_id);
+        b->media->addr2msg(msg_media_addr(hdr), &b->addr);
+}
+
+static void tipc_disc_msg_xmit(struct net *net, u32 mtyp, u32 dst, u32 src,
+                               struct tipc_media_addr *maddr,
+                               struct tipc_bearer *b)
+{
+        struct sk_buff *skb;
+
+        skb = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
+        if (!skb)
+                return;
+        tipc_disc_init_msg(net, skb, mtyp, b);
+        tipc_bearer_xmit_skb(net, b->identity, skb, maddr);
 }
 
 /**
@@ -116,149 +129,123 @@ static void disc_dupl_alert(struct tipc_bearer *b, u32 node_addr,
 
 /**
  * tipc_disc_rcv - handle incoming discovery message (request or response)
- * @net: the applicable net namespace
- * @buf: buffer containing message
- * @bearer: bearer that message arrived on
+ * @net: applicable net namespace
+ * @skb: buffer containing message
+ * @b: bearer that message arrived on
  */
 void tipc_disc_rcv(struct net *net, struct sk_buff *skb,
-                   struct tipc_bearer *bearer)
+                   struct tipc_bearer *b)
 {
-        struct tipc_net *tn = net_generic(net, tipc_net_id);
-        struct tipc_media_addr maddr;
-        struct sk_buff *rskb;
+        struct tipc_net *tn = tipc_net(net);
         struct tipc_msg *hdr = buf_msg(skb);
-        u32 ddom = msg_dest_domain(hdr);
-        u32 onode = msg_prevnode(hdr);
+        u16 caps = msg_node_capabilities(hdr);
+        u32 signature = msg_node_sig(hdr);
+        u32 dst = msg_dest_domain(hdr);
         u32 net_id = msg_bc_netid(hdr);
+        u32 self = tipc_own_addr(net);
+        struct tipc_media_addr maddr;
+        u32 src = msg_prevnode(hdr);
         u32 mtyp = msg_type(hdr);
-        u32 signature = msg_node_sig(hdr);
-        u16 caps = msg_node_capabilities(hdr);
-        bool respond = false;
         bool dupl_addr = false;
+        bool respond = false;
         int err;
 
-        err = bearer->media->msg2addr(bearer, &maddr, msg_media_addr(hdr));
+        err = b->media->msg2addr(b, &maddr, msg_media_addr(hdr));
         kfree_skb(skb);
-        if (err)
+        if (err || maddr.broadcast) {
+                pr_warn_ratelimited("Rcv corrupt discovery message\n");
                 return;
-
-        /* Ensure message from node is valid and communication is permitted */
-        if (net_id != tn->net_id)
+        }
+        /* Ignore discovery messages from own node */
+        if (!memcmp(&maddr, &b->addr, sizeof(maddr)))
                 return;
-        if (maddr.broadcast)
+        if (net_id != tn->net_id)
                 return;
-        if (!tipc_addr_domain_valid(ddom))
+        if (!tipc_addr_domain_valid(dst))
                 return;
-        if (!tipc_addr_node_valid(onode))
+        if (!tipc_addr_node_valid(src))
                 return;
-
-        if (in_own_node(net, onode)) {
-                if (memcmp(&maddr, &bearer->addr, sizeof(maddr)))
-                        disc_dupl_alert(bearer, tn->own_addr, &maddr);
+        if (in_own_node(net, src)) {
+                disc_dupl_alert(b, self, &maddr);
                 return;
         }
-        if (!tipc_in_scope(ddom, tn->own_addr))
+        if (!tipc_in_scope(dst, self))
                 return;
-        if (!tipc_in_scope(bearer->domain, onode))
+        if (!tipc_in_scope(b->domain, src))
                 return;
-
-        tipc_node_check_dest(net, onode, bearer, caps, signature,
+        tipc_node_check_dest(net, src, b, caps, signature,
                              &maddr, &respond, &dupl_addr);
         if (dupl_addr)
-                disc_dupl_alert(bearer, onode, &maddr);
-
-        /* Send response, if necessary */
-        if (respond && (mtyp == DSC_REQ_MSG)) {
-                rskb = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
-                if (!rskb)
-                        return;
-                tipc_disc_init_msg(net, rskb, DSC_RESP_MSG, bearer);
-                tipc_bearer_xmit_skb(net, bearer->identity, rskb, &maddr);
-        }
+                disc_dupl_alert(b, src, &maddr);
+        if (!respond)
+                return;
+        if (mtyp != DSC_REQ_MSG)
+                return;
+        tipc_disc_msg_xmit(net, DSC_RESP_MSG, src, self, &maddr, b);
 }
 
-/**
- * disc_update - update frequency of periodic link setup requests
- * @req: ptr to link request structure
- *
- * Reinitiates discovery process if discovery object has no associated nodes
- * and is either not currently searching or is searching at a slow rate
+/* tipc_disc_add_dest - increment set of discovered nodes
  */
-static void disc_update(struct tipc_link_req *req)
+void tipc_disc_add_dest(struct tipc_discoverer *d)
 {
-        if (!req->num_nodes) {
-                if ((req->timer_intv == TIPC_LINK_REQ_INACTIVE) ||
-                    (req->timer_intv > TIPC_LINK_REQ_FAST)) {
-                        req->timer_intv = TIPC_LINK_REQ_INIT;
-                        mod_timer(&req->timer, jiffies + req->timer_intv);
-                }
-        }
+        spin_lock_bh(&d->lock);
+        d->num_nodes++;
+        spin_unlock_bh(&d->lock);
 }
 
-/**
- * tipc_disc_add_dest - increment set of discovered nodes
- * @req: ptr to link request structure
+/* tipc_disc_remove_dest - decrement set of discovered nodes
  */
-void tipc_disc_add_dest(struct tipc_link_req *req)
+void tipc_disc_remove_dest(struct tipc_discoverer *d)
 {
-        spin_lock_bh(&req->lock);
-        req->num_nodes++;
-        spin_unlock_bh(&req->lock);
-}
+        int intv, num;
 
-/**
- * tipc_disc_remove_dest - decrement set of discovered nodes
- * @req: ptr to link request structure
- */
-void tipc_disc_remove_dest(struct tipc_link_req *req)
-{
-        spin_lock_bh(&req->lock);
-        req->num_nodes--;
-        disc_update(req);
-        spin_unlock_bh(&req->lock);
+        spin_lock_bh(&d->lock);
+        d->num_nodes--;
+        num = d->num_nodes;
+        intv = d->timer_intv;
+        if (!num && (intv == TIPC_DISC_INACTIVE || intv > TIPC_DISC_FAST))  {
+                d->timer_intv = TIPC_DISC_INIT;
+                mod_timer(&d->timer, jiffies + d->timer_intv);
+        }
+        spin_unlock_bh(&d->lock);
 }
 
-/**
- * disc_timeout - send a periodic link setup request
- * @data: ptr to link request structure
- *
+/* tipc_disc_timeout - send a periodic link setup request
  * Called whenever a link setup request timer associated with a bearer expires.
+ * - Keep doubling time between sent request until limit is reached;
+ * - Hold at fast polling rate if we don't have any associated nodes
+ * - Otherwise hold at slow polling rate
  */
-static void disc_timeout(struct timer_list *t)
+static void tipc_disc_timeout(struct timer_list *t)
 {
-        struct tipc_link_req *req = from_timer(req, t, timer);
-        struct sk_buff *skb;
-        int max_delay;
+        struct tipc_discoverer *d = from_timer(d, t, timer);
+        struct tipc_media_addr maddr;
+        struct sk_buff *skb = NULL;
+        struct net *net;
+        u32 bearer_id;
 
-        spin_lock_bh(&req->lock);
+        spin_lock_bh(&d->lock);
 
         /* Stop searching if only desired node has been found */
-        if (tipc_node(req->domain) && req->num_nodes) {
-                req->timer_intv = TIPC_LINK_REQ_INACTIVE;
+        if (tipc_node(d->domain) && d->num_nodes) {
+                d->timer_intv = TIPC_DISC_INACTIVE;
                 goto exit;
         }
-
-        /*
-         * Send discovery message, then update discovery timer
-         *
-         * Keep doubling time between requests until limit is reached;
-         * hold at fast polling rate if don't have any associated nodes,
-         * otherwise hold at slow polling rate
-         */
-        skb = skb_clone(req->buf, GFP_ATOMIC);
-        if (skb)
-                tipc_bearer_xmit_skb(req->net, req->bearer_id, skb, &req->dest);
-        req->timer_intv *= 2;
-        if (req->num_nodes)
-                max_delay = TIPC_LINK_REQ_SLOW;
-        else
-                max_delay = TIPC_LINK_REQ_FAST;
-        if (req->timer_intv > max_delay)
-                req->timer_intv = max_delay;
-
-        mod_timer(&req->timer, jiffies + req->timer_intv);
+        /* Adjust timeout interval according to discovery phase */
+        d->timer_intv *= 2;
+        if (d->num_nodes && d->timer_intv > TIPC_DISC_SLOW)
+                d->timer_intv = TIPC_DISC_SLOW;
+        else if (!d->num_nodes && d->timer_intv > TIPC_DISC_FAST)
+                d->timer_intv = TIPC_DISC_FAST;
+        mod_timer(&d->timer, jiffies + d->timer_intv);
+        memcpy(&maddr, &d->dest, sizeof(maddr));
+        skb = skb_clone(d->skb, GFP_ATOMIC);
+        net = d->net;
+        bearer_id = d->bearer_id;
 exit:
-        spin_unlock_bh(&req->lock);
+        spin_unlock_bh(&d->lock);
+        if (skb)
+                tipc_bearer_xmit_skb(net, bearer_id, skb, &maddr);
 }
 
 /**
@@ -273,41 +260,41 @@ exit:
 int tipc_disc_create(struct net *net, struct tipc_bearer *b,
                      struct tipc_media_addr *dest, struct sk_buff **skb)
 {
-        struct tipc_link_req *req;
+        struct tipc_discoverer *d;
 
-        req = kmalloc(sizeof(*req), GFP_ATOMIC);
-        if (!req)
+        d = kmalloc(sizeof(*d), GFP_ATOMIC);
+        if (!d)
                 return -ENOMEM;
-        req->buf = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
-        if (!req->buf) {
-                kfree(req);
+        d->skb = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
+        if (!d->skb) {
+                kfree(d);
                 return -ENOMEM;
         }
 
-        tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
-        memcpy(&req->dest, dest, sizeof(*dest));
-        req->net = net;
-        req->bearer_id = b->identity;
-        req->domain = b->domain;
-        req->num_nodes = 0;
-        req->timer_intv = TIPC_LINK_REQ_INIT;
-        spin_lock_init(&req->lock);
-        timer_setup(&req->timer, disc_timeout, 0);
-        mod_timer(&req->timer, jiffies + req->timer_intv);
-        b->link_req = req;
-        *skb = skb_clone(req->buf, GFP_ATOMIC);
+        tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b);
+        memcpy(&d->dest, dest, sizeof(*dest));
+        d->net = net;
+        d->bearer_id = b->identity;
+        d->domain = b->domain;
+        d->num_nodes = 0;
+        d->timer_intv = TIPC_DISC_INIT;
+        spin_lock_init(&d->lock);
+        timer_setup(&d->timer, tipc_disc_timeout, 0);
+        mod_timer(&d->timer, jiffies + d->timer_intv);
+        b->disc = d;
+        *skb = skb_clone(d->skb, GFP_ATOMIC);
         return 0;
 }
 
 /**
  * tipc_disc_delete - destroy object sending periodic link setup requests
- * @req: ptr to link request structure
+ * @d: ptr to link duest structure
  */
-void tipc_disc_delete(struct tipc_link_req *req)
+void tipc_disc_delete(struct tipc_discoverer *d)
 {
-        del_timer_sync(&req->timer);
-        kfree_skb(req->buf);
-        kfree(req);
+        del_timer_sync(&d->timer);
+        kfree_skb(d->skb);
+        kfree(d);
 }
 
 /**
@@ -318,19 +305,21 @@ void tipc_disc_delete(struct tipc_link_req *req)
  */
 void tipc_disc_reset(struct net *net, struct tipc_bearer *b)
 {
-        struct tipc_link_req *req = b->link_req;
+        struct tipc_discoverer *d = b->disc;
+        struct tipc_media_addr maddr;
         struct sk_buff *skb;
 
-        spin_lock_bh(&req->lock);
-        tipc_disc_init_msg(net, req->buf, DSC_REQ_MSG, b);
-        req->net = net;
-        req->bearer_id = b->identity;
-        req->domain = b->domain;
-        req->num_nodes = 0;
-        req->timer_intv = TIPC_LINK_REQ_INIT;
-        mod_timer(&req->timer, jiffies + req->timer_intv);
-        skb = skb_clone(req->buf, GFP_ATOMIC);
+        spin_lock_bh(&d->lock);
+        tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b);
+        d->net = net;
+        d->bearer_id = b->identity;
+        d->domain = b->domain;
+        d->num_nodes = 0;
+        d->timer_intv = TIPC_DISC_INIT;
+        memcpy(&maddr, &d->dest, sizeof(maddr));
+        mod_timer(&d->timer, jiffies + d->timer_intv);
+        skb = skb_clone(d->skb, GFP_ATOMIC);
+        spin_unlock_bh(&d->lock);
         if (skb)
-                tipc_bearer_xmit_skb(net, req->bearer_id, skb, &req->dest);
-        spin_unlock_bh(&req->lock);
+                tipc_bearer_xmit_skb(net, b->identity, skb, &maddr);
 }
diff --git a/net/tipc/discover.h b/net/tipc/discover.h
index b80a335389c0..521d96c41dfd 100644
--- a/net/tipc/discover.h
+++ b/net/tipc/discover.h
@@ -37,14 +37,14 @@
 #ifndef _TIPC_DISCOVER_H
 #define _TIPC_DISCOVER_H
 
-struct tipc_link_req;
+struct tipc_discoverer;
 
 int tipc_disc_create(struct net *net, struct tipc_bearer *b_ptr,
                      struct tipc_media_addr *dest, struct sk_buff **skb);
-void tipc_disc_delete(struct tipc_link_req *req);
+void tipc_disc_delete(struct tipc_discoverer *req);
 void tipc_disc_reset(struct net *net, struct tipc_bearer *b_ptr);
-void tipc_disc_add_dest(struct tipc_link_req *req);
-void tipc_disc_remove_dest(struct tipc_link_req *req);
+void tipc_disc_add_dest(struct tipc_discoverer *req);
+void tipc_disc_remove_dest(struct tipc_discoverer *req);
 void tipc_disc_rcv(struct net *net, struct sk_buff *buf,
                    struct tipc_bearer *b_ptr);