struct tipc_member {
        struct rb_node tree_node;
        struct list_head list;
-       struct list_head congested;
+       struct list_head small_win;
        struct sk_buff *event_msg;
        struct sk_buff_head deferredq;
        struct tipc_group *group;
 
 struct tipc_group {
        struct rb_root members;
-       struct list_head congested;
+       struct list_head small_win;
        struct list_head pending;
        struct list_head active;
        struct list_head reclaiming;
        return grp->bc_snd_nxt;
 }
 
-static bool tipc_group_is_enabled(struct tipc_member *m)
+static bool tipc_group_is_receiver(struct tipc_member *m)
 {
        return m->state != MBR_QUARANTINED && m->state != MBR_LEAVING;
 }
 
-static bool tipc_group_is_receiver(struct tipc_member *m)
+static bool tipc_group_is_sender(struct tipc_member *m)
 {
        return m && m->state >= MBR_JOINED;
 }
        if (!grp)
                return NULL;
        tipc_nlist_init(&grp->dests, tipc_own_addr(net));
-       INIT_LIST_HEAD(&grp->congested);
+       INIT_LIST_HEAD(&grp->small_win);
        INIT_LIST_HEAD(&grp->active);
        INIT_LIST_HEAD(&grp->pending);
        INIT_LIST_HEAD(&grp->reclaiming);
        struct tipc_member *m;
 
        m = tipc_group_find_member(grp, node, port);
-       if (m && tipc_group_is_enabled(m))
+       if (m && tipc_group_is_receiver(m))
                return m;
        return NULL;
 }
        if (!m)
                return NULL;
        INIT_LIST_HEAD(&m->list);
-       INIT_LIST_HEAD(&m->congested);
+       INIT_LIST_HEAD(&m->small_win);
        __skb_queue_head_init(&m->deferredq);
        m->group = grp;
        m->node = node;
                grp->bc_ackers--;
 
        list_del_init(&m->list);
-       list_del_init(&m->congested);
+       list_del_init(&m->small_win);
        tipc_group_decr_active(grp, m);
 
        /* If last member on a node, remove node from dest list */
        struct tipc_group *grp = m->group;
        struct tipc_member *_m, *tmp;
 
-       if (!tipc_group_is_enabled(m))
+       if (!tipc_group_is_receiver(m))
                return;
 
        m->window -= len;
        if (m->window >= ADV_IDLE)
                return;
 
-       list_del_init(&m->congested);
+       list_del_init(&m->small_win);
 
-       /* Sort member into congested members' list */
-       list_for_each_entry_safe(_m, tmp, &grp->congested, congested) {
+       /* Sort member into small_window members' list */
+       list_for_each_entry_safe(_m, tmp, &grp->small_win, small_win) {
                if (m->window > _m->window)
                        continue;
-               list_add_tail(&m->congested, &_m->congested);
+               list_add_tail(&m->small_win, &_m->small_win);
                return;
        }
-       list_add_tail(&m->congested, &grp->congested);
+       list_add_tail(&m->small_win, &grp->small_win);
 }
 
 void tipc_group_update_bc_members(struct tipc_group *grp, int len, bool ack)
 
        for (n = rb_first(&grp->members); n; n = rb_next(n)) {
                m = container_of(n, struct tipc_member, tree_node);
-               if (tipc_group_is_enabled(m)) {
+               if (tipc_group_is_receiver(m)) {
                        tipc_group_update_member(m, len);
                        m->bc_acked = prev;
                        ackers++;
        if (grp->bc_ackers)
                return true;
 
-       if (list_empty(&grp->congested))
+       if (list_empty(&grp->small_win))
                return false;
 
-       m = list_first_entry(&grp->congested, struct tipc_member, congested);
+       m = list_first_entry(&grp->small_win, struct tipc_member, small_win);
        if (m->window >= len)
                return false;
 
                goto drop;
 
        m = tipc_group_find_member(grp, node, port);
-       if (!tipc_group_is_receiver(m))
+       if (!tipc_group_is_sender(m))
                goto drop;
 
        if (less(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
                        msg_set_grp_bc_seqno(ehdr, m->bc_syncpt);
                        __skb_queue_tail(inputq, m->event_msg);
                }
-               list_del_init(&m->congested);
+               list_del_init(&m->small_win);
                tipc_group_update_member(m, 0);
                return;
        case GRP_LEAVE_MSG:
                        return;
                m->bc_syncpt = msg_grp_bc_syncpt(hdr);
                list_del_init(&m->list);
-               list_del_init(&m->congested);
+               list_del_init(&m->small_win);
                *usr_wakeup = true;
 
                /* Wait until WITHDRAW event is received */
                m->window += msg_adv_win(hdr);
                *usr_wakeup = m->usr_pending;
                m->usr_pending = false;
-               list_del_init(&m->congested);
+               list_del_init(&m->small_win);
                return;
        case GRP_ACK_MSG:
                if (!m)
                if (m->window < ADV_IDLE)
                        tipc_group_update_member(m, 0);
                else
-                       list_del_init(&m->congested);
+                       list_del_init(&m->small_win);
        } else if (event == TIPC_WITHDRAWN) {
                if (!m)
                        goto drop;
                        __skb_queue_tail(inputq, skb);
                }
                list_del_init(&m->list);
-               list_del_init(&m->congested);
+               list_del_init(&m->small_win);
        }
        *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
        return;