2 * net/tipc/group.c: TIPC group messaging code
4 * Copyright (c) 2017, Ericsson AB
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the names of the copyright holders nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
19 * Alternatively, this software may be distributed under the terms of the
20 * GNU General Public License ("GPL") version 2 as published by the Free
21 * Software Foundation.
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
44 #include "name_table.h"
47 #define ADV_UNIT (((MAX_MSG_SIZE + MAX_H_SIZE) / FLOWCTL_BLK_SZ) + 1)
48 #define ADV_IDLE ADV_UNIT
49 #define ADV_ACTIVE (ADV_UNIT * 12)
63 struct rb_node tree_node;
64 struct list_head list;
65 struct list_head small_win;
66 struct sk_buff_head deferredq;
67 struct tipc_group *group;
80 struct rb_root members;
81 struct list_head small_win;
82 struct list_head pending;
83 struct list_head active;
84 struct tipc_nlist dests;
101 static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
102 int mtyp, struct sk_buff_head *xmitq);
104 static void tipc_group_open(struct tipc_member *m, bool *wakeup)
107 if (list_empty(&m->small_win))
109 list_del_init(&m->small_win);
110 *m->group->open = true;
114 static void tipc_group_decr_active(struct tipc_group *grp,
115 struct tipc_member *m)
117 if (m->state == MBR_ACTIVE || m->state == MBR_RECLAIMING ||
118 m->state == MBR_REMITTED)
122 static int tipc_group_rcvbuf_limit(struct tipc_group *grp)
124 int max_active, active_pool, idle_pool;
125 int mcnt = grp->member_cnt + 1;
127 /* Limit simultaneous reception from other members */
128 max_active = min(mcnt / 8, 64);
129 max_active = max(max_active, 16);
130 grp->max_active = max_active;
132 /* Reserve blocks for active and idle members */
133 active_pool = max_active * ADV_ACTIVE;
134 idle_pool = (mcnt - max_active) * ADV_IDLE;
136 /* Scale to bytes, considering worst-case truesize/msgsize ratio */
137 return (active_pool + idle_pool) * FLOWCTL_BLK_SZ * 4;
140 u16 tipc_group_bc_snd_nxt(struct tipc_group *grp)
142 return grp->bc_snd_nxt;
145 static bool tipc_group_is_receiver(struct tipc_member *m)
147 return m && m->state != MBR_JOINING && m->state != MBR_LEAVING;
150 static bool tipc_group_is_sender(struct tipc_member *m)
152 return m && m->state != MBR_JOINING && m->state != MBR_PUBLISHED;
155 u32 tipc_group_exclude(struct tipc_group *grp)
162 struct tipc_group *tipc_group_create(struct net *net, u32 portid,
163 struct tipc_group_req *mreq,
166 u32 filter = TIPC_SUB_PORTS | TIPC_SUB_NO_STATUS;
167 bool global = mreq->scope != TIPC_NODE_SCOPE;
168 struct tipc_group *grp;
169 u32 type = mreq->type;
171 grp = kzalloc(sizeof(*grp), GFP_ATOMIC);
174 tipc_nlist_init(&grp->dests, tipc_own_addr(net));
175 INIT_LIST_HEAD(&grp->small_win);
176 INIT_LIST_HEAD(&grp->active);
177 INIT_LIST_HEAD(&grp->pending);
178 grp->members = RB_ROOT;
180 grp->portid = portid;
182 grp->instance = mreq->instance;
183 grp->scope = mreq->scope;
184 grp->loopback = mreq->flags & TIPC_GROUP_LOOPBACK;
185 grp->events = mreq->flags & TIPC_GROUP_MEMBER_EVTS;
186 grp->open = group_is_open;
188 filter |= global ? TIPC_SUB_CLUSTER_SCOPE : TIPC_SUB_NODE_SCOPE;
189 if (tipc_topsrv_kern_subscr(net, portid, type, 0, ~0,
190 filter, &grp->subid))
196 void tipc_group_join(struct net *net, struct tipc_group *grp, int *sk_rcvbuf)
198 struct rb_root *tree = &grp->members;
199 struct tipc_member *m, *tmp;
200 struct sk_buff_head xmitq;
202 __skb_queue_head_init(&xmitq);
203 rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
204 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, &xmitq);
205 tipc_group_update_member(m, 0);
207 tipc_node_distr_xmit(net, &xmitq);
208 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
211 void tipc_group_delete(struct net *net, struct tipc_group *grp)
213 struct rb_root *tree = &grp->members;
214 struct tipc_member *m, *tmp;
215 struct sk_buff_head xmitq;
217 __skb_queue_head_init(&xmitq);
219 rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
220 tipc_group_proto_xmit(grp, m, GRP_LEAVE_MSG, &xmitq);
221 __skb_queue_purge(&m->deferredq);
225 tipc_node_distr_xmit(net, &xmitq);
226 tipc_nlist_purge(&grp->dests);
227 tipc_topsrv_kern_unsubscr(net, grp->subid);
231 static struct tipc_member *tipc_group_find_member(struct tipc_group *grp,
234 struct rb_node *n = grp->members.rb_node;
235 u64 nkey, key = (u64)node << 32 | port;
236 struct tipc_member *m;
239 m = container_of(n, struct tipc_member, tree_node);
240 nkey = (u64)m->node << 32 | m->port;
251 static struct tipc_member *tipc_group_find_dest(struct tipc_group *grp,
254 struct tipc_member *m;
256 m = tipc_group_find_member(grp, node, port);
257 if (m && tipc_group_is_receiver(m))
262 static struct tipc_member *tipc_group_find_node(struct tipc_group *grp,
265 struct tipc_member *m;
268 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
269 m = container_of(n, struct tipc_member, tree_node);
276 static int tipc_group_add_to_tree(struct tipc_group *grp,
277 struct tipc_member *m)
279 u64 nkey, key = (u64)m->node << 32 | m->port;
280 struct rb_node **n, *parent = NULL;
281 struct tipc_member *tmp;
283 n = &grp->members.rb_node;
285 tmp = container_of(*n, struct tipc_member, tree_node);
287 tmp = container_of(parent, struct tipc_member, tree_node);
288 nkey = (u64)tmp->node << 32 | tmp->port;
296 rb_link_node(&m->tree_node, parent, n);
297 rb_insert_color(&m->tree_node, &grp->members);
301 static struct tipc_member *tipc_group_create_member(struct tipc_group *grp,
303 u32 instance, int state)
305 struct tipc_member *m;
308 m = kzalloc(sizeof(*m), GFP_ATOMIC);
311 INIT_LIST_HEAD(&m->list);
312 INIT_LIST_HEAD(&m->small_win);
313 __skb_queue_head_init(&m->deferredq);
317 m->instance = instance;
318 m->bc_acked = grp->bc_snd_nxt - 1;
319 ret = tipc_group_add_to_tree(grp, m);
325 tipc_nlist_add(&grp->dests, m->node);
330 void tipc_group_add_member(struct tipc_group *grp, u32 node,
331 u32 port, u32 instance)
333 tipc_group_create_member(grp, node, port, instance, MBR_PUBLISHED);
336 static void tipc_group_delete_member(struct tipc_group *grp,
337 struct tipc_member *m)
339 rb_erase(&m->tree_node, &grp->members);
342 /* Check if we were waiting for replicast ack from this member */
343 if (grp->bc_ackers && less(m->bc_acked, grp->bc_snd_nxt - 1))
346 list_del_init(&m->list);
347 list_del_init(&m->small_win);
348 tipc_group_decr_active(grp, m);
350 /* If last member on a node, remove node from dest list */
351 if (!tipc_group_find_node(grp, m->node))
352 tipc_nlist_del(&grp->dests, m->node);
357 struct tipc_nlist *tipc_group_dests(struct tipc_group *grp)
362 void tipc_group_self(struct tipc_group *grp, struct tipc_name_seq *seq,
365 seq->type = grp->type;
366 seq->lower = grp->instance;
367 seq->upper = grp->instance;
371 void tipc_group_update_member(struct tipc_member *m, int len)
373 struct tipc_group *grp = m->group;
374 struct tipc_member *_m, *tmp;
376 if (!tipc_group_is_receiver(m))
381 if (m->window >= ADV_IDLE)
384 list_del_init(&m->small_win);
386 /* Sort member into small_window members' list */
387 list_for_each_entry_safe(_m, tmp, &grp->small_win, small_win) {
388 if (_m->window > m->window)
391 list_add_tail(&m->small_win, &_m->small_win);
394 void tipc_group_update_bc_members(struct tipc_group *grp, int len, bool ack)
396 u16 prev = grp->bc_snd_nxt - 1;
397 struct tipc_member *m;
401 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
402 m = container_of(n, struct tipc_member, tree_node);
403 if (tipc_group_is_receiver(m)) {
404 tipc_group_update_member(m, len);
410 /* Mark number of acknowledges to expect, if any */
412 grp->bc_ackers = ackers;
416 bool tipc_group_cong(struct tipc_group *grp, u32 dnode, u32 dport,
417 int len, struct tipc_member **mbr)
419 struct sk_buff_head xmitq;
420 struct tipc_member *m;
423 m = tipc_group_find_dest(grp, dnode, dport);
424 if (!tipc_group_is_receiver(m)) {
430 if (m->window >= len)
435 /* If not fully advertised, do it now to prevent mutual blocking */
438 if (state == MBR_JOINED && adv == ADV_IDLE)
440 if (state == MBR_ACTIVE && adv == ADV_ACTIVE)
442 if (state == MBR_PENDING && adv == ADV_IDLE)
444 __skb_queue_head_init(&xmitq);
445 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, &xmitq);
446 tipc_node_distr_xmit(grp->net, &xmitq);
450 bool tipc_group_bc_cong(struct tipc_group *grp, int len)
452 struct tipc_member *m = NULL;
454 /* If prev bcast was replicast, reject until all receivers have acked */
455 if (grp->bc_ackers) {
459 if (list_empty(&grp->small_win))
462 m = list_first_entry(&grp->small_win, struct tipc_member, small_win);
463 if (m->window >= len)
466 return tipc_group_cong(grp, m->node, m->port, len, &m);
469 /* tipc_group_sort_msg() - sort msg into queue by bcast sequence number
471 static void tipc_group_sort_msg(struct sk_buff *skb, struct sk_buff_head *defq)
473 struct tipc_msg *_hdr, *hdr = buf_msg(skb);
474 u16 bc_seqno = msg_grp_bc_seqno(hdr);
475 struct sk_buff *_skb, *tmp;
476 int mtyp = msg_type(hdr);
478 /* Bcast/mcast may be bypassed by ucast or other bcast, - sort it in */
479 if (mtyp == TIPC_GRP_BCAST_MSG || mtyp == TIPC_GRP_MCAST_MSG) {
480 skb_queue_walk_safe(defq, _skb, tmp) {
481 _hdr = buf_msg(_skb);
482 if (!less(bc_seqno, msg_grp_bc_seqno(_hdr)))
484 __skb_queue_before(defq, _skb, skb);
487 /* Bcast was not bypassed, - add to tail */
489 /* Unicasts are never bypassed, - always add to tail */
490 __skb_queue_tail(defq, skb);
493 /* tipc_group_filter_msg() - determine if we should accept arriving message
495 void tipc_group_filter_msg(struct tipc_group *grp, struct sk_buff_head *inputq,
496 struct sk_buff_head *xmitq)
498 struct sk_buff *skb = __skb_dequeue(inputq);
499 bool ack, deliver, update, leave = false;
500 struct sk_buff_head *defq;
501 struct tipc_member *m;
502 struct tipc_msg *hdr;
510 node = msg_orignode(hdr);
511 port = msg_origport(hdr);
513 if (!msg_in_group(hdr))
516 m = tipc_group_find_member(grp, node, port);
517 if (!tipc_group_is_sender(m))
520 if (less(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
523 TIPC_SKB_CB(skb)->orig_member = m->instance;
524 defq = &m->deferredq;
525 tipc_group_sort_msg(skb, defq);
527 while ((skb = skb_peek(defq))) {
529 mtyp = msg_type(hdr);
530 blks = msg_blocks(hdr);
535 if (more(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
538 /* Decide what to do with message */
540 case TIPC_GRP_MCAST_MSG:
541 if (msg_nameinst(hdr) != grp->instance) {
546 case TIPC_GRP_BCAST_MSG:
548 ack = msg_grp_bc_ack_req(hdr);
550 case TIPC_GRP_UCAST_MSG:
552 case TIPC_GRP_MEMBER_EVT:
553 if (m->state == MBR_LEAVING)
562 /* Execute decisions */
565 __skb_queue_tail(inputq, skb);
570 tipc_group_proto_xmit(grp, m, GRP_ACK_MSG, xmitq);
573 __skb_queue_purge(defq);
574 tipc_group_delete_member(grp, m);
580 tipc_group_update_rcv_win(grp, blks, node, port, xmitq);
587 void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
588 u32 port, struct sk_buff_head *xmitq)
590 struct list_head *active = &grp->active;
591 int max_active = grp->max_active;
592 int reclaim_limit = max_active * 3 / 4;
593 int active_cnt = grp->active_cnt;
594 struct tipc_member *m, *rm, *pm;
596 m = tipc_group_find_member(grp, node, port);
600 m->advertised -= blks;
604 /* First, decide if member can go active */
605 if (active_cnt <= max_active) {
606 m->state = MBR_ACTIVE;
607 list_add_tail(&m->list, active);
609 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
611 m->state = MBR_PENDING;
612 list_add_tail(&m->list, &grp->pending);
615 if (active_cnt < reclaim_limit)
618 /* Reclaim from oldest active member, if possible */
619 if (!list_empty(active)) {
620 rm = list_first_entry(active, struct tipc_member, list);
621 rm->state = MBR_RECLAIMING;
622 list_del_init(&rm->list);
623 tipc_group_proto_xmit(grp, rm, GRP_RECLAIM_MSG, xmitq);
626 /* Nobody to reclaim from; - revert oldest pending to JOINED */
627 pm = list_first_entry(&grp->pending, struct tipc_member, list);
628 list_del_init(&pm->list);
629 pm->state = MBR_JOINED;
630 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
633 if (!list_is_last(&m->list, &grp->active))
634 list_move_tail(&m->list, &grp->active);
635 if (m->advertised > (ADV_ACTIVE * 3 / 4))
637 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
640 if (m->advertised > ADV_IDLE)
642 m->state = MBR_JOINED;
644 if (m->advertised < ADV_IDLE) {
645 pr_warn_ratelimited("Rcv unexpected msg after REMIT\n");
646 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
649 if (list_empty(&grp->pending))
652 /* Set oldest pending member to active and advertise */
653 pm = list_first_entry(&grp->pending, struct tipc_member, list);
654 pm->state = MBR_ACTIVE;
655 list_move_tail(&pm->list, &grp->active);
657 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
667 static void tipc_group_create_event(struct tipc_group *grp,
668 struct tipc_member *m,
669 u32 event, u16 seqno,
670 struct sk_buff_head *inputq)
671 { u32 dnode = tipc_own_addr(grp->net);
672 struct tipc_event evt;
674 struct tipc_msg *hdr;
676 memset(&evt, 0, sizeof(evt));
678 evt.found_lower = m->instance;
679 evt.found_upper = m->instance;
680 evt.port.ref = m->port;
681 evt.port.node = m->node;
682 evt.s.seq.type = grp->type;
683 evt.s.seq.lower = m->instance;
684 evt.s.seq.upper = m->instance;
686 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_GRP_MEMBER_EVT,
687 GROUP_H_SIZE, sizeof(evt), dnode, m->node,
688 grp->portid, m->port, 0);
693 msg_set_nametype(hdr, grp->type);
694 msg_set_grp_evt(hdr, event);
695 msg_set_dest_droppable(hdr, true);
696 msg_set_grp_bc_seqno(hdr, seqno);
697 memcpy(msg_data(hdr), &evt, sizeof(evt));
698 TIPC_SKB_CB(skb)->orig_member = m->instance;
699 __skb_queue_tail(inputq, skb);
702 static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
703 int mtyp, struct sk_buff_head *xmitq)
705 struct tipc_msg *hdr;
709 skb = tipc_msg_create(GROUP_PROTOCOL, mtyp, INT_H_SIZE, 0,
710 m->node, tipc_own_addr(grp->net),
711 m->port, grp->portid, 0);
715 if (m->state == MBR_ACTIVE)
716 adv = ADV_ACTIVE - m->advertised;
717 else if (m->state == MBR_JOINED || m->state == MBR_PENDING)
718 adv = ADV_IDLE - m->advertised;
722 if (mtyp == GRP_JOIN_MSG) {
723 msg_set_grp_bc_syncpt(hdr, grp->bc_snd_nxt);
724 msg_set_adv_win(hdr, adv);
725 m->advertised += adv;
726 } else if (mtyp == GRP_LEAVE_MSG) {
727 msg_set_grp_bc_syncpt(hdr, grp->bc_snd_nxt);
728 } else if (mtyp == GRP_ADV_MSG) {
729 msg_set_adv_win(hdr, adv);
730 m->advertised += adv;
731 } else if (mtyp == GRP_ACK_MSG) {
732 msg_set_grp_bc_acked(hdr, m->bc_rcv_nxt);
733 } else if (mtyp == GRP_REMIT_MSG) {
734 msg_set_grp_remitted(hdr, m->window);
736 msg_set_dest_droppable(hdr, true);
737 __skb_queue_tail(xmitq, skb);
740 void tipc_group_proto_rcv(struct tipc_group *grp, bool *usr_wakeup,
741 struct tipc_msg *hdr, struct sk_buff_head *inputq,
742 struct sk_buff_head *xmitq)
744 u32 node = msg_orignode(hdr);
745 u32 port = msg_origport(hdr);
746 struct tipc_member *m, *pm;
747 u16 remitted, in_flight;
752 if (grp->scope == TIPC_NODE_SCOPE && node != tipc_own_addr(grp->net))
755 m = tipc_group_find_member(grp, node, port);
757 switch (msg_type(hdr)) {
760 m = tipc_group_create_member(grp, node, port,
764 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
765 m->bc_rcv_nxt = m->bc_syncpt;
766 m->window += msg_adv_win(hdr);
768 /* Wait until PUBLISH event is received if necessary */
769 if (m->state != MBR_PUBLISHED)
772 /* Member can be taken into service */
773 m->state = MBR_JOINED;
774 tipc_group_open(m, usr_wakeup);
775 tipc_group_update_member(m, 0);
776 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
777 tipc_group_create_event(grp, m, TIPC_PUBLISHED,
778 m->bc_syncpt, inputq);
783 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
784 list_del_init(&m->list);
785 tipc_group_open(m, usr_wakeup);
786 tipc_group_decr_active(grp, m);
787 m->state = MBR_LEAVING;
788 tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
789 m->bc_syncpt, inputq);
794 m->window += msg_adv_win(hdr);
795 tipc_group_open(m, usr_wakeup);
800 m->bc_acked = msg_grp_bc_acked(hdr);
801 if (--grp->bc_ackers)
803 list_del_init(&m->small_win);
804 *m->group->open = true;
806 tipc_group_update_member(m, 0);
808 case GRP_RECLAIM_MSG:
811 tipc_group_proto_xmit(grp, m, GRP_REMIT_MSG, xmitq);
812 m->window = ADV_IDLE;
813 tipc_group_open(m, usr_wakeup);
816 if (!m || m->state != MBR_RECLAIMING)
819 remitted = msg_grp_remitted(hdr);
821 /* Messages preceding the REMIT still in receive queue */
822 if (m->advertised > remitted) {
823 m->state = MBR_REMITTED;
824 in_flight = m->advertised - remitted;
825 m->advertised = ADV_IDLE + in_flight;
828 /* This should never happen */
829 if (m->advertised < remitted)
830 pr_warn_ratelimited("Unexpected REMIT msg\n");
832 /* All messages preceding the REMIT have been read */
833 m->state = MBR_JOINED;
835 m->advertised = ADV_IDLE;
837 /* Set oldest pending member to active and advertise */
838 if (list_empty(&grp->pending))
840 pm = list_first_entry(&grp->pending, struct tipc_member, list);
841 pm->state = MBR_ACTIVE;
842 list_move_tail(&pm->list, &grp->active);
844 if (pm->advertised <= (ADV_ACTIVE * 3 / 4))
845 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
848 pr_warn("Received unknown GROUP_PROTO message\n");
852 /* tipc_group_member_evt() - receive and handle a member up/down event
854 void tipc_group_member_evt(struct tipc_group *grp,
857 struct tipc_msg *hdr,
858 struct sk_buff_head *inputq,
859 struct sk_buff_head *xmitq)
861 struct tipc_event *evt = (void *)msg_data(hdr);
862 u32 instance = evt->found_lower;
863 u32 node = evt->port.node;
864 u32 port = evt->port.ref;
865 int event = evt->event;
866 struct tipc_member *m;
874 self = tipc_own_addr(net);
875 if (!grp->loopback && node == self && port == grp->portid)
878 m = tipc_group_find_member(grp, node, port);
882 /* Send and wait for arrival of JOIN message if necessary */
884 m = tipc_group_create_member(grp, node, port, instance,
888 tipc_group_update_member(m, 0);
889 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
893 if (m->state != MBR_JOINING)
896 /* Member can be taken into service */
897 m->instance = instance;
898 m->state = MBR_JOINED;
899 tipc_group_open(m, usr_wakeup);
900 tipc_group_update_member(m, 0);
901 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
902 tipc_group_create_event(grp, m, TIPC_PUBLISHED,
903 m->bc_syncpt, inputq);
909 tipc_group_decr_active(grp, m);
910 m->state = MBR_LEAVING;
911 list_del_init(&m->list);
912 tipc_group_open(m, usr_wakeup);
914 /* Only send event if no LEAVE message can be expected */
915 if (!tipc_node_is_up(net, node))
916 tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
917 m->bc_rcv_nxt, inputq);
922 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
925 int tipc_group_fill_sock_diag(struct tipc_group *grp, struct sk_buff *skb)
927 struct nlattr *group = nla_nest_start_noflag(skb, TIPC_NLA_SOCK_GROUP);
932 if (nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_ID,
934 nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_INSTANCE,
936 nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_BC_SEND_NEXT,
938 goto group_msg_cancel;
940 if (grp->scope == TIPC_NODE_SCOPE)
941 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_NODE_SCOPE))
942 goto group_msg_cancel;
944 if (grp->scope == TIPC_CLUSTER_SCOPE)
945 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_CLUSTER_SCOPE))
946 goto group_msg_cancel;
949 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_OPEN))
950 goto group_msg_cancel;
952 nla_nest_end(skb, group);
956 nla_nest_cancel(skb, group);