tipc: introduce group anycast messaging

In this commit, we make it possible to send connectionless unicast
messages to any member corresponding to the given member identity,
when there is more than one such member. The sender must use a
TIPC_ADDR_NAME address to achieve this effect.

We also perform load balancing between the destinations, i.e., we
primarily select one which has advertised sufficient send window
to not cause a block/EAGAIN delay, if any. This mechanism is
overlayed on the always present round-robin selection.

Anycast messages are subject to the same start synchronization
and flow control mechanism as group broadcast messages.

Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Acked-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 84 insertions, 0 deletions

diff --git a/net/tipc/socket.c b/net/tipc/socket.c
index e71c8d23acb9..66165e12d2f4 100644
--- a/net/tipc/socket.c
+++ b/net/tipc/socket.c
@@ -905,6 +905,88 @@ static int tipc_send_group_unicast(struct socket *sock, struct msghdr *m,
 }
 
 /**
+ * tipc_send_group_anycast - send message to any member with given identity
+ * @sock: socket structure
+ * @m: message to send
+ * @dlen: total length of message data
+ * @timeout: timeout to wait for wakeup
+ *
+ * Called from function tipc_sendmsg(), which has done all sanity checks
+ * Returns the number of bytes sent on success, or errno
+ */
+static int tipc_send_group_anycast(struct socket *sock, struct msghdr *m,
+                                   int dlen, long timeout)
+{
+        DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name);
+        struct sock *sk = sock->sk;
+        struct tipc_sock *tsk = tipc_sk(sk);
+        struct list_head *cong_links = &tsk->cong_links;
+        int blks = tsk_blocks(GROUP_H_SIZE + dlen);
+        struct tipc_group *grp = tsk->group;
+        struct tipc_member *first = NULL;
+        struct tipc_member *mbr = NULL;
+        struct net *net = sock_net(sk);
+        u32 node, port, exclude;
+        u32 type, inst, domain;
+        struct list_head dsts;
+        int lookups = 0;
+        int dstcnt, rc;
+        bool cong;
+
+        INIT_LIST_HEAD(&dsts);
+
+        type = dest->addr.name.name.type;
+        inst = dest->addr.name.name.instance;
+        domain = addr_domain(net, dest->scope);
+        exclude = tipc_group_exclude(grp);
+
+        while (++lookups < 4) {
+                first = NULL;
+
+                /* Look for a non-congested destination member, if any */
+                while (1) {
+                        if (!tipc_nametbl_lookup(net, type, inst, domain, &dsts,
+                                                 &dstcnt, exclude, false))
+                                return -EHOSTUNREACH;
+                        tipc_dest_pop(&dsts, &node, &port);
+                        cong = tipc_group_cong(grp, node, port, blks, &mbr);
+                        if (!cong)
+                                break;
+                        if (mbr == first)
+                                break;
+                        if (!first)
+                                first = mbr;
+                }
+
+                /* Start over if destination was not in member list */
+                if (unlikely(!mbr))
+                        continue;
+
+                if (likely(!cong && !tipc_dest_find(cong_links, node, 0)))
+                        break;
+
+                /* Block or return if destination link or member is congested */
+                rc = tipc_wait_for_cond(sock, &timeout,
+                                        !tipc_dest_find(cong_links, node, 0) &&
+                                        !tipc_group_cong(grp, node, port,
+                                                         blks, &mbr));
+                if (unlikely(rc))
+                        return rc;
+
+                /* Send, unless destination disappeared while waiting */
+                if (likely(mbr))
+                        break;
+        }
+
+        if (unlikely(lookups >= 4))
+                return -EHOSTUNREACH;
+
+        rc = tipc_send_group_msg(net, tsk, m, mbr, node, port, dlen);
+
+        return rc ? rc : dlen;
+}
+
+/**
  * tipc_send_group_bcast - send message to all members in communication group
  * @sk: socket structure
  * @m: message to send
@@ -1127,6 +1209,8 @@ static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dlen)
         if (grp) {
                 if (!dest)
                         return tipc_send_group_bcast(sock, m, dlen, timeout);
+                if (dest->addrtype == TIPC_ADDR_NAME)
+                        return tipc_send_group_anycast(sock, m, dlen, timeout);
                 if (dest->addrtype == TIPC_ADDR_ID)
                         return tipc_send_group_unicast(sock, m, dlen, timeout);
                 return -EINVAL;