tipc: let group member stay in JOINED mode if unable to reclaim

We handle a corner case in the function tipc_group_update_rcv_win().
During extreme pessure it might happen that a message receiver has all
its active senders in RECLAIMING or REMITTED mode, meaning that there
is nobody to reclaim advertisements from if an additional sender tries
to go active.

Currently we just set the new sender to ACTIVE anyway, hence at least
theoretically opening up for a receiver queue overflow by exceeding the
MAX_ACTIVE limit. The correct solution to this is to instead add the
member to the pending queue, while letting the oldest member in that
queue revert to JOINED state.

In this commit we refactor the code for handling message arrival from
a JOINED member, both to make it more comprehensible and to cover the
case described above.

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

diff --git a/net/tipc/group.c b/net/tipc/group.c
index e5daeb0..652fa66 100644 (file)
--- a/net/tipc/group.c
+++ b/net/tipc/group.c
@@ -569,24 +569,34 @@ void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
 
        switch (m->state) {
        case MBR_JOINED:
-               /* Reclaim advertised space from least active member */
-               if (!list_empty(active) && active_cnt >= reclaim_limit) {
+               /* First, decide if member can go active */
+               if (active_cnt <= max_active) {
+                       m->state = MBR_ACTIVE;
+                       list_add_tail(&m->list, active);
+                       grp->active_cnt++;
+                       tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
+               } else {
+                       m->state = MBR_PENDING;
+                       list_add_tail(&m->list, &grp->pending);
+               }
+
+               if (active_cnt < reclaim_limit)
+                       break;
+
+               /* Reclaim from oldest active member, if possible */
+               if (!list_empty(active)) {
                        rm = list_first_entry(active, struct tipc_member, list);
                        rm->state = MBR_RECLAIMING;
                        list_del_init(&rm->list);
                        tipc_group_proto_xmit(grp, rm, GRP_RECLAIM_MSG, xmitq);
-               }
-               /* If max active, become pending and wait for reclaimed space */
-               if (active_cnt >= max_active) {
-                       m->state = MBR_PENDING;
-                       list_add_tail(&m->list, &grp->pending);
                        break;
                }
-               /* Otherwise become active */
-               m->state = MBR_ACTIVE;
-               list_add_tail(&m->list, &grp->active);
-               grp->active_cnt++;
-               /* Fall through */
+               /* Nobody to reclaim from; - revert oldest pending to JOINED */
+               pm = list_first_entry(&grp->pending, struct tipc_member, list);
+               list_del_init(&pm->list);
+               pm->state = MBR_JOINED;
+               tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
+               break;
        case MBR_ACTIVE:
                if (!list_is_last(&m->list, &grp->active))
                        list_move_tail(&m->list, &grp->active);