Loading...
1/*
2 * net/tipc/group.c: TIPC group messaging code
3 *
4 * Copyright (c) 2017, Ericsson AB
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
9 *
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.
18 *
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.
22 *
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.
34 */
35
36#include "core.h"
37#include "addr.h"
38#include "group.h"
39#include "bcast.h"
40#include "topsrv.h"
41#include "msg.h"
42#include "socket.h"
43#include "node.h"
44#include "name_table.h"
45#include "subscr.h"
46
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)
50
51enum mbr_state {
52 MBR_JOINING,
53 MBR_PUBLISHED,
54 MBR_JOINED,
55 MBR_PENDING,
56 MBR_ACTIVE,
57 MBR_RECLAIMING,
58 MBR_REMITTED,
59 MBR_LEAVING
60};
61
62struct tipc_member {
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;
68 u32 node;
69 u32 port;
70 u32 instance;
71 enum mbr_state state;
72 u16 advertised;
73 u16 window;
74 u16 bc_rcv_nxt;
75 u16 bc_syncpt;
76 u16 bc_acked;
77};
78
79struct tipc_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;
85 struct net *net;
86 int subid;
87 u32 type;
88 u32 instance;
89 u32 scope;
90 u32 portid;
91 u16 member_cnt;
92 u16 active_cnt;
93 u16 max_active;
94 u16 bc_snd_nxt;
95 u16 bc_ackers;
96 bool *open;
97 bool loopback;
98 bool events;
99};
100
101static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
102 int mtyp, struct sk_buff_head *xmitq);
103
104static void tipc_group_open(struct tipc_member *m, bool *wakeup)
105{
106 *wakeup = false;
107 if (list_empty(&m->small_win))
108 return;
109 list_del_init(&m->small_win);
110 *m->group->open = true;
111 *wakeup = true;
112}
113
114static void tipc_group_decr_active(struct tipc_group *grp,
115 struct tipc_member *m)
116{
117 if (m->state == MBR_ACTIVE || m->state == MBR_RECLAIMING ||
118 m->state == MBR_REMITTED)
119 grp->active_cnt--;
120}
121
122static int tipc_group_rcvbuf_limit(struct tipc_group *grp)
123{
124 int max_active, active_pool, idle_pool;
125 int mcnt = grp->member_cnt + 1;
126
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;
131
132 /* Reserve blocks for active and idle members */
133 active_pool = max_active * ADV_ACTIVE;
134 idle_pool = (mcnt - max_active) * ADV_IDLE;
135
136 /* Scale to bytes, considering worst-case truesize/msgsize ratio */
137 return (active_pool + idle_pool) * FLOWCTL_BLK_SZ * 4;
138}
139
140u16 tipc_group_bc_snd_nxt(struct tipc_group *grp)
141{
142 return grp->bc_snd_nxt;
143}
144
145static bool tipc_group_is_receiver(struct tipc_member *m)
146{
147 return m && m->state != MBR_JOINING && m->state != MBR_LEAVING;
148}
149
150static bool tipc_group_is_sender(struct tipc_member *m)
151{
152 return m && m->state != MBR_JOINING && m->state != MBR_PUBLISHED;
153}
154
155u32 tipc_group_exclude(struct tipc_group *grp)
156{
157 if (!grp->loopback)
158 return grp->portid;
159 return 0;
160}
161
162struct tipc_group *tipc_group_create(struct net *net, u32 portid,
163 struct tipc_group_req *mreq,
164 bool *group_is_open)
165{
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;
170
171 grp = kzalloc(sizeof(*grp), GFP_ATOMIC);
172 if (!grp)
173 return NULL;
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;
179 grp->net = net;
180 grp->portid = portid;
181 grp->type = type;
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;
187 *grp->open = false;
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))
191 return grp;
192 kfree(grp);
193 return NULL;
194}
195
196void tipc_group_join(struct net *net, struct tipc_group *grp, int *sk_rcvbuf)
197{
198 struct rb_root *tree = &grp->members;
199 struct tipc_member *m, *tmp;
200 struct sk_buff_head xmitq;
201
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);
206 }
207 tipc_node_distr_xmit(net, &xmitq);
208 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
209}
210
211void tipc_group_delete(struct net *net, struct tipc_group *grp)
212{
213 struct rb_root *tree = &grp->members;
214 struct tipc_member *m, *tmp;
215 struct sk_buff_head xmitq;
216
217 __skb_queue_head_init(&xmitq);
218
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);
222 list_del(&m->list);
223 kfree(m);
224 }
225 tipc_node_distr_xmit(net, &xmitq);
226 tipc_nlist_purge(&grp->dests);
227 tipc_topsrv_kern_unsubscr(net, grp->subid);
228 kfree(grp);
229}
230
231static struct tipc_member *tipc_group_find_member(struct tipc_group *grp,
232 u32 node, u32 port)
233{
234 struct rb_node *n = grp->members.rb_node;
235 u64 nkey, key = (u64)node << 32 | port;
236 struct tipc_member *m;
237
238 while (n) {
239 m = container_of(n, struct tipc_member, tree_node);
240 nkey = (u64)m->node << 32 | m->port;
241 if (key < nkey)
242 n = n->rb_left;
243 else if (key > nkey)
244 n = n->rb_right;
245 else
246 return m;
247 }
248 return NULL;
249}
250
251static struct tipc_member *tipc_group_find_dest(struct tipc_group *grp,
252 u32 node, u32 port)
253{
254 struct tipc_member *m;
255
256 m = tipc_group_find_member(grp, node, port);
257 if (m && tipc_group_is_receiver(m))
258 return m;
259 return NULL;
260}
261
262static struct tipc_member *tipc_group_find_node(struct tipc_group *grp,
263 u32 node)
264{
265 struct tipc_member *m;
266 struct rb_node *n;
267
268 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
269 m = container_of(n, struct tipc_member, tree_node);
270 if (m->node == node)
271 return m;
272 }
273 return NULL;
274}
275
276static int tipc_group_add_to_tree(struct tipc_group *grp,
277 struct tipc_member *m)
278{
279 u64 nkey, key = (u64)m->node << 32 | m->port;
280 struct rb_node **n, *parent = NULL;
281 struct tipc_member *tmp;
282
283 n = &grp->members.rb_node;
284 while (*n) {
285 tmp = container_of(*n, struct tipc_member, tree_node);
286 parent = *n;
287 tmp = container_of(parent, struct tipc_member, tree_node);
288 nkey = (u64)tmp->node << 32 | tmp->port;
289 if (key < nkey)
290 n = &(*n)->rb_left;
291 else if (key > nkey)
292 n = &(*n)->rb_right;
293 else
294 return -EEXIST;
295 }
296 rb_link_node(&m->tree_node, parent, n);
297 rb_insert_color(&m->tree_node, &grp->members);
298 return 0;
299}
300
301static struct tipc_member *tipc_group_create_member(struct tipc_group *grp,
302 u32 node, u32 port,
303 u32 instance, int state)
304{
305 struct tipc_member *m;
306 int ret;
307
308 m = kzalloc(sizeof(*m), GFP_ATOMIC);
309 if (!m)
310 return NULL;
311 INIT_LIST_HEAD(&m->list);
312 INIT_LIST_HEAD(&m->small_win);
313 __skb_queue_head_init(&m->deferredq);
314 m->group = grp;
315 m->node = node;
316 m->port = port;
317 m->instance = instance;
318 m->bc_acked = grp->bc_snd_nxt - 1;
319 ret = tipc_group_add_to_tree(grp, m);
320 if (ret < 0) {
321 kfree(m);
322 return NULL;
323 }
324 grp->member_cnt++;
325 tipc_nlist_add(&grp->dests, m->node);
326 m->state = state;
327 return m;
328}
329
330void tipc_group_add_member(struct tipc_group *grp, u32 node,
331 u32 port, u32 instance)
332{
333 tipc_group_create_member(grp, node, port, instance, MBR_PUBLISHED);
334}
335
336static void tipc_group_delete_member(struct tipc_group *grp,
337 struct tipc_member *m)
338{
339 rb_erase(&m->tree_node, &grp->members);
340 grp->member_cnt--;
341
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))
344 grp->bc_ackers--;
345
346 list_del_init(&m->list);
347 list_del_init(&m->small_win);
348 tipc_group_decr_active(grp, m);
349
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);
353
354 kfree(m);
355}
356
357struct tipc_nlist *tipc_group_dests(struct tipc_group *grp)
358{
359 return &grp->dests;
360}
361
362void tipc_group_self(struct tipc_group *grp, struct tipc_name_seq *seq,
363 int *scope)
364{
365 seq->type = grp->type;
366 seq->lower = grp->instance;
367 seq->upper = grp->instance;
368 *scope = grp->scope;
369}
370
371void tipc_group_update_member(struct tipc_member *m, int len)
372{
373 struct tipc_group *grp = m->group;
374 struct tipc_member *_m, *tmp;
375
376 if (!tipc_group_is_receiver(m))
377 return;
378
379 m->window -= len;
380
381 if (m->window >= ADV_IDLE)
382 return;
383
384 list_del_init(&m->small_win);
385
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)
389 break;
390 }
391 list_add_tail(&m->small_win, &_m->small_win);
392}
393
394void tipc_group_update_bc_members(struct tipc_group *grp, int len, bool ack)
395{
396 u16 prev = grp->bc_snd_nxt - 1;
397 struct tipc_member *m;
398 struct rb_node *n;
399 u16 ackers = 0;
400
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);
405 m->bc_acked = prev;
406 ackers++;
407 }
408 }
409
410 /* Mark number of acknowledges to expect, if any */
411 if (ack)
412 grp->bc_ackers = ackers;
413 grp->bc_snd_nxt++;
414}
415
416bool tipc_group_cong(struct tipc_group *grp, u32 dnode, u32 dport,
417 int len, struct tipc_member **mbr)
418{
419 struct sk_buff_head xmitq;
420 struct tipc_member *m;
421 int adv, state;
422
423 m = tipc_group_find_dest(grp, dnode, dport);
424 if (!tipc_group_is_receiver(m)) {
425 *mbr = NULL;
426 return false;
427 }
428 *mbr = m;
429
430 if (m->window >= len)
431 return false;
432
433 *grp->open = false;
434
435 /* If not fully advertised, do it now to prevent mutual blocking */
436 adv = m->advertised;
437 state = m->state;
438 if (state == MBR_JOINED && adv == ADV_IDLE)
439 return true;
440 if (state == MBR_ACTIVE && adv == ADV_ACTIVE)
441 return true;
442 if (state == MBR_PENDING && adv == ADV_IDLE)
443 return true;
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);
447 return true;
448}
449
450bool tipc_group_bc_cong(struct tipc_group *grp, int len)
451{
452 struct tipc_member *m = NULL;
453
454 /* If prev bcast was replicast, reject until all receivers have acked */
455 if (grp->bc_ackers) {
456 *grp->open = false;
457 return true;
458 }
459 if (list_empty(&grp->small_win))
460 return false;
461
462 m = list_first_entry(&grp->small_win, struct tipc_member, small_win);
463 if (m->window >= len)
464 return false;
465
466 return tipc_group_cong(grp, m->node, m->port, len, &m);
467}
468
469/* tipc_group_sort_msg() - sort msg into queue by bcast sequence number
470 */
471static void tipc_group_sort_msg(struct sk_buff *skb, struct sk_buff_head *defq)
472{
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);
477
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)))
483 continue;
484 __skb_queue_before(defq, _skb, skb);
485 return;
486 }
487 /* Bcast was not bypassed, - add to tail */
488 }
489 /* Unicasts are never bypassed, - always add to tail */
490 __skb_queue_tail(defq, skb);
491}
492
493/* tipc_group_filter_msg() - determine if we should accept arriving message
494 */
495void tipc_group_filter_msg(struct tipc_group *grp, struct sk_buff_head *inputq,
496 struct sk_buff_head *xmitq)
497{
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;
503 u32 node, port;
504 int mtyp, blks;
505
506 if (!skb)
507 return;
508
509 hdr = buf_msg(skb);
510 node = msg_orignode(hdr);
511 port = msg_origport(hdr);
512
513 if (!msg_in_group(hdr))
514 goto drop;
515
516 m = tipc_group_find_member(grp, node, port);
517 if (!tipc_group_is_sender(m))
518 goto drop;
519
520 if (less(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
521 goto drop;
522
523 TIPC_SKB_CB(skb)->orig_member = m->instance;
524 defq = &m->deferredq;
525 tipc_group_sort_msg(skb, defq);
526
527 while ((skb = skb_peek(defq))) {
528 hdr = buf_msg(skb);
529 mtyp = msg_type(hdr);
530 blks = msg_blocks(hdr);
531 deliver = true;
532 ack = false;
533 update = false;
534
535 if (more(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
536 break;
537
538 /* Decide what to do with message */
539 switch (mtyp) {
540 case TIPC_GRP_MCAST_MSG:
541 if (msg_nameinst(hdr) != grp->instance) {
542 update = true;
543 deliver = false;
544 }
545 fallthrough;
546 case TIPC_GRP_BCAST_MSG:
547 m->bc_rcv_nxt++;
548 ack = msg_grp_bc_ack_req(hdr);
549 break;
550 case TIPC_GRP_UCAST_MSG:
551 break;
552 case TIPC_GRP_MEMBER_EVT:
553 if (m->state == MBR_LEAVING)
554 leave = true;
555 if (!grp->events)
556 deliver = false;
557 break;
558 default:
559 break;
560 }
561
562 /* Execute decisions */
563 __skb_dequeue(defq);
564 if (deliver)
565 __skb_queue_tail(inputq, skb);
566 else
567 kfree_skb(skb);
568
569 if (ack)
570 tipc_group_proto_xmit(grp, m, GRP_ACK_MSG, xmitq);
571
572 if (leave) {
573 __skb_queue_purge(defq);
574 tipc_group_delete_member(grp, m);
575 break;
576 }
577 if (!update)
578 continue;
579
580 tipc_group_update_rcv_win(grp, blks, node, port, xmitq);
581 }
582 return;
583drop:
584 kfree_skb(skb);
585}
586
587void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
588 u32 port, struct sk_buff_head *xmitq)
589{
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;
595
596 m = tipc_group_find_member(grp, node, port);
597 if (!m)
598 return;
599
600 m->advertised -= blks;
601
602 switch (m->state) {
603 case MBR_JOINED:
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);
608 grp->active_cnt++;
609 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
610 } else {
611 m->state = MBR_PENDING;
612 list_add_tail(&m->list, &grp->pending);
613 }
614
615 if (active_cnt < reclaim_limit)
616 break;
617
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);
624 break;
625 }
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);
631 break;
632 case MBR_ACTIVE:
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))
636 break;
637 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
638 break;
639 case MBR_REMITTED:
640 if (m->advertised > ADV_IDLE)
641 break;
642 m->state = MBR_JOINED;
643 grp->active_cnt--;
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);
647 }
648
649 if (list_empty(&grp->pending))
650 return;
651
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);
656 grp->active_cnt++;
657 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
658 break;
659 case MBR_RECLAIMING:
660 case MBR_JOINING:
661 case MBR_LEAVING:
662 default:
663 break;
664 }
665}
666
667static 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;
673 struct sk_buff *skb;
674 struct tipc_msg *hdr;
675
676 memset(&evt, 0, sizeof(evt));
677 evt.event = event;
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;
685
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);
689 if (!skb)
690 return;
691
692 hdr = buf_msg(skb);
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);
700}
701
702static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
703 int mtyp, struct sk_buff_head *xmitq)
704{
705 struct tipc_msg *hdr;
706 struct sk_buff *skb;
707 int adv = 0;
708
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);
712 if (!skb)
713 return;
714
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;
719
720 hdr = buf_msg(skb);
721
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);
735 }
736 msg_set_dest_droppable(hdr, true);
737 __skb_queue_tail(xmitq, skb);
738}
739
740void 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)
743{
744 u32 node = msg_orignode(hdr);
745 u32 port = msg_origport(hdr);
746 struct tipc_member *m, *pm;
747 u16 remitted, in_flight;
748
749 if (!grp)
750 return;
751
752 if (grp->scope == TIPC_NODE_SCOPE && node != tipc_own_addr(grp->net))
753 return;
754
755 m = tipc_group_find_member(grp, node, port);
756
757 switch (msg_type(hdr)) {
758 case GRP_JOIN_MSG:
759 if (!m)
760 m = tipc_group_create_member(grp, node, port,
761 0, MBR_JOINING);
762 if (!m)
763 return;
764 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
765 m->bc_rcv_nxt = m->bc_syncpt;
766 m->window += msg_adv_win(hdr);
767
768 /* Wait until PUBLISH event is received if necessary */
769 if (m->state != MBR_PUBLISHED)
770 return;
771
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);
779 return;
780 case GRP_LEAVE_MSG:
781 if (!m)
782 return;
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);
790 return;
791 case GRP_ADV_MSG:
792 if (!m)
793 return;
794 m->window += msg_adv_win(hdr);
795 tipc_group_open(m, usr_wakeup);
796 return;
797 case GRP_ACK_MSG:
798 if (!m)
799 return;
800 m->bc_acked = msg_grp_bc_acked(hdr);
801 if (--grp->bc_ackers)
802 return;
803 list_del_init(&m->small_win);
804 *m->group->open = true;
805 *usr_wakeup = true;
806 tipc_group_update_member(m, 0);
807 return;
808 case GRP_RECLAIM_MSG:
809 if (!m)
810 return;
811 tipc_group_proto_xmit(grp, m, GRP_REMIT_MSG, xmitq);
812 m->window = ADV_IDLE;
813 tipc_group_open(m, usr_wakeup);
814 return;
815 case GRP_REMIT_MSG:
816 if (!m || m->state != MBR_RECLAIMING)
817 return;
818
819 remitted = msg_grp_remitted(hdr);
820
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;
826 return;
827 }
828 /* This should never happen */
829 if (m->advertised < remitted)
830 pr_warn_ratelimited("Unexpected REMIT msg\n");
831
832 /* All messages preceding the REMIT have been read */
833 m->state = MBR_JOINED;
834 grp->active_cnt--;
835 m->advertised = ADV_IDLE;
836
837 /* Set oldest pending member to active and advertise */
838 if (list_empty(&grp->pending))
839 return;
840 pm = list_first_entry(&grp->pending, struct tipc_member, list);
841 pm->state = MBR_ACTIVE;
842 list_move_tail(&pm->list, &grp->active);
843 grp->active_cnt++;
844 if (pm->advertised <= (ADV_ACTIVE * 3 / 4))
845 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
846 return;
847 default:
848 pr_warn("Received unknown GROUP_PROTO message\n");
849 }
850}
851
852/* tipc_group_member_evt() - receive and handle a member up/down event
853 */
854void tipc_group_member_evt(struct tipc_group *grp,
855 bool *usr_wakeup,
856 int *sk_rcvbuf,
857 struct tipc_msg *hdr,
858 struct sk_buff_head *inputq,
859 struct sk_buff_head *xmitq)
860{
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;
867 struct net *net;
868 u32 self;
869
870 if (!grp)
871 return;
872
873 net = grp->net;
874 self = tipc_own_addr(net);
875 if (!grp->loopback && node == self && port == grp->portid)
876 return;
877
878 m = tipc_group_find_member(grp, node, port);
879
880 switch (event) {
881 case TIPC_PUBLISHED:
882 /* Send and wait for arrival of JOIN message if necessary */
883 if (!m) {
884 m = tipc_group_create_member(grp, node, port, instance,
885 MBR_PUBLISHED);
886 if (!m)
887 break;
888 tipc_group_update_member(m, 0);
889 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
890 break;
891 }
892
893 if (m->state != MBR_JOINING)
894 break;
895
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);
904 break;
905 case TIPC_WITHDRAWN:
906 if (!m)
907 break;
908
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);
913
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);
918 break;
919 default:
920 break;
921 }
922 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
923}
924
925int tipc_group_fill_sock_diag(struct tipc_group *grp, struct sk_buff *skb)
926{
927 struct nlattr *group = nla_nest_start_noflag(skb, TIPC_NLA_SOCK_GROUP);
928
929 if (!group)
930 return -EMSGSIZE;
931
932 if (nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_ID,
933 grp->type) ||
934 nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_INSTANCE,
935 grp->instance) ||
936 nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_BC_SEND_NEXT,
937 grp->bc_snd_nxt))
938 goto group_msg_cancel;
939
940 if (grp->scope == TIPC_NODE_SCOPE)
941 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_NODE_SCOPE))
942 goto group_msg_cancel;
943
944 if (grp->scope == TIPC_CLUSTER_SCOPE)
945 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_CLUSTER_SCOPE))
946 goto group_msg_cancel;
947
948 if (*grp->open)
949 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_OPEN))
950 goto group_msg_cancel;
951
952 nla_nest_end(skb, group);
953 return 0;
954
955group_msg_cancel:
956 nla_nest_cancel(skb, group);
957 return -1;
958}
1/*
2 * net/tipc/group.c: TIPC group messaging code
3 *
4 * Copyright (c) 2017, Ericsson AB
5 * Copyright (c) 2020, Red Hat Inc
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include "core.h"
38#include "addr.h"
39#include "group.h"
40#include "bcast.h"
41#include "topsrv.h"
42#include "msg.h"
43#include "socket.h"
44#include "node.h"
45#include "name_table.h"
46#include "subscr.h"
47
48#define ADV_UNIT (((MAX_MSG_SIZE + MAX_H_SIZE) / FLOWCTL_BLK_SZ) + 1)
49#define ADV_IDLE ADV_UNIT
50#define ADV_ACTIVE (ADV_UNIT * 12)
51
52enum mbr_state {
53 MBR_JOINING,
54 MBR_PUBLISHED,
55 MBR_JOINED,
56 MBR_PENDING,
57 MBR_ACTIVE,
58 MBR_RECLAIMING,
59 MBR_REMITTED,
60 MBR_LEAVING
61};
62
63struct tipc_member {
64 struct rb_node tree_node;
65 struct list_head list;
66 struct list_head small_win;
67 struct sk_buff_head deferredq;
68 struct tipc_group *group;
69 u32 node;
70 u32 port;
71 u32 instance;
72 enum mbr_state state;
73 u16 advertised;
74 u16 window;
75 u16 bc_rcv_nxt;
76 u16 bc_syncpt;
77 u16 bc_acked;
78};
79
80struct tipc_group {
81 struct rb_root members;
82 struct list_head small_win;
83 struct list_head pending;
84 struct list_head active;
85 struct tipc_nlist dests;
86 struct net *net;
87 int subid;
88 u32 type;
89 u32 instance;
90 u32 scope;
91 u32 portid;
92 u16 member_cnt;
93 u16 active_cnt;
94 u16 max_active;
95 u16 bc_snd_nxt;
96 u16 bc_ackers;
97 bool *open;
98 bool loopback;
99 bool events;
100};
101
102static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
103 int mtyp, struct sk_buff_head *xmitq);
104
105static void tipc_group_open(struct tipc_member *m, bool *wakeup)
106{
107 *wakeup = false;
108 if (list_empty(&m->small_win))
109 return;
110 list_del_init(&m->small_win);
111 *m->group->open = true;
112 *wakeup = true;
113}
114
115static void tipc_group_decr_active(struct tipc_group *grp,
116 struct tipc_member *m)
117{
118 if (m->state == MBR_ACTIVE || m->state == MBR_RECLAIMING ||
119 m->state == MBR_REMITTED)
120 grp->active_cnt--;
121}
122
123static int tipc_group_rcvbuf_limit(struct tipc_group *grp)
124{
125 int max_active, active_pool, idle_pool;
126 int mcnt = grp->member_cnt + 1;
127
128 /* Limit simultaneous reception from other members */
129 max_active = min(mcnt / 8, 64);
130 max_active = max(max_active, 16);
131 grp->max_active = max_active;
132
133 /* Reserve blocks for active and idle members */
134 active_pool = max_active * ADV_ACTIVE;
135 idle_pool = (mcnt - max_active) * ADV_IDLE;
136
137 /* Scale to bytes, considering worst-case truesize/msgsize ratio */
138 return (active_pool + idle_pool) * FLOWCTL_BLK_SZ * 4;
139}
140
141u16 tipc_group_bc_snd_nxt(struct tipc_group *grp)
142{
143 return grp->bc_snd_nxt;
144}
145
146static bool tipc_group_is_receiver(struct tipc_member *m)
147{
148 return m && m->state != MBR_JOINING && m->state != MBR_LEAVING;
149}
150
151static bool tipc_group_is_sender(struct tipc_member *m)
152{
153 return m && m->state != MBR_JOINING && m->state != MBR_PUBLISHED;
154}
155
156u32 tipc_group_exclude(struct tipc_group *grp)
157{
158 if (!grp->loopback)
159 return grp->portid;
160 return 0;
161}
162
163struct tipc_group *tipc_group_create(struct net *net, u32 portid,
164 struct tipc_group_req *mreq,
165 bool *group_is_open)
166{
167 u32 filter = TIPC_SUB_PORTS | TIPC_SUB_NO_STATUS;
168 bool global = mreq->scope != TIPC_NODE_SCOPE;
169 struct tipc_group *grp;
170 u32 type = mreq->type;
171
172 grp = kzalloc(sizeof(*grp), GFP_ATOMIC);
173 if (!grp)
174 return NULL;
175 tipc_nlist_init(&grp->dests, tipc_own_addr(net));
176 INIT_LIST_HEAD(&grp->small_win);
177 INIT_LIST_HEAD(&grp->active);
178 INIT_LIST_HEAD(&grp->pending);
179 grp->members = RB_ROOT;
180 grp->net = net;
181 grp->portid = portid;
182 grp->type = type;
183 grp->instance = mreq->instance;
184 grp->scope = mreq->scope;
185 grp->loopback = mreq->flags & TIPC_GROUP_LOOPBACK;
186 grp->events = mreq->flags & TIPC_GROUP_MEMBER_EVTS;
187 grp->open = group_is_open;
188 *grp->open = false;
189 filter |= global ? TIPC_SUB_CLUSTER_SCOPE : TIPC_SUB_NODE_SCOPE;
190 if (tipc_topsrv_kern_subscr(net, portid, type, 0, ~0,
191 filter, &grp->subid))
192 return grp;
193 kfree(grp);
194 return NULL;
195}
196
197void tipc_group_join(struct net *net, struct tipc_group *grp, int *sk_rcvbuf)
198{
199 struct rb_root *tree = &grp->members;
200 struct tipc_member *m, *tmp;
201 struct sk_buff_head xmitq;
202
203 __skb_queue_head_init(&xmitq);
204 rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
205 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, &xmitq);
206 tipc_group_update_member(m, 0);
207 }
208 tipc_node_distr_xmit(net, &xmitq);
209 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
210}
211
212void tipc_group_delete(struct net *net, struct tipc_group *grp)
213{
214 struct rb_root *tree = &grp->members;
215 struct tipc_member *m, *tmp;
216 struct sk_buff_head xmitq;
217
218 __skb_queue_head_init(&xmitq);
219
220 rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
221 tipc_group_proto_xmit(grp, m, GRP_LEAVE_MSG, &xmitq);
222 __skb_queue_purge(&m->deferredq);
223 list_del(&m->list);
224 kfree(m);
225 }
226 tipc_node_distr_xmit(net, &xmitq);
227 tipc_nlist_purge(&grp->dests);
228 tipc_topsrv_kern_unsubscr(net, grp->subid);
229 kfree(grp);
230}
231
232static struct tipc_member *tipc_group_find_member(struct tipc_group *grp,
233 u32 node, u32 port)
234{
235 struct rb_node *n = grp->members.rb_node;
236 u64 nkey, key = (u64)node << 32 | port;
237 struct tipc_member *m;
238
239 while (n) {
240 m = container_of(n, struct tipc_member, tree_node);
241 nkey = (u64)m->node << 32 | m->port;
242 if (key < nkey)
243 n = n->rb_left;
244 else if (key > nkey)
245 n = n->rb_right;
246 else
247 return m;
248 }
249 return NULL;
250}
251
252static struct tipc_member *tipc_group_find_dest(struct tipc_group *grp,
253 u32 node, u32 port)
254{
255 struct tipc_member *m;
256
257 m = tipc_group_find_member(grp, node, port);
258 if (m && tipc_group_is_receiver(m))
259 return m;
260 return NULL;
261}
262
263static struct tipc_member *tipc_group_find_node(struct tipc_group *grp,
264 u32 node)
265{
266 struct tipc_member *m;
267 struct rb_node *n;
268
269 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
270 m = container_of(n, struct tipc_member, tree_node);
271 if (m->node == node)
272 return m;
273 }
274 return NULL;
275}
276
277static int tipc_group_add_to_tree(struct tipc_group *grp,
278 struct tipc_member *m)
279{
280 u64 nkey, key = (u64)m->node << 32 | m->port;
281 struct rb_node **n, *parent = NULL;
282 struct tipc_member *tmp;
283
284 n = &grp->members.rb_node;
285 while (*n) {
286 tmp = container_of(*n, struct tipc_member, tree_node);
287 parent = *n;
288 tmp = container_of(parent, struct tipc_member, tree_node);
289 nkey = (u64)tmp->node << 32 | tmp->port;
290 if (key < nkey)
291 n = &(*n)->rb_left;
292 else if (key > nkey)
293 n = &(*n)->rb_right;
294 else
295 return -EEXIST;
296 }
297 rb_link_node(&m->tree_node, parent, n);
298 rb_insert_color(&m->tree_node, &grp->members);
299 return 0;
300}
301
302static struct tipc_member *tipc_group_create_member(struct tipc_group *grp,
303 u32 node, u32 port,
304 u32 instance, int state)
305{
306 struct tipc_member *m;
307 int ret;
308
309 m = kzalloc(sizeof(*m), GFP_ATOMIC);
310 if (!m)
311 return NULL;
312 INIT_LIST_HEAD(&m->list);
313 INIT_LIST_HEAD(&m->small_win);
314 __skb_queue_head_init(&m->deferredq);
315 m->group = grp;
316 m->node = node;
317 m->port = port;
318 m->instance = instance;
319 m->bc_acked = grp->bc_snd_nxt - 1;
320 ret = tipc_group_add_to_tree(grp, m);
321 if (ret < 0) {
322 kfree(m);
323 return NULL;
324 }
325 grp->member_cnt++;
326 tipc_nlist_add(&grp->dests, m->node);
327 m->state = state;
328 return m;
329}
330
331void tipc_group_add_member(struct tipc_group *grp, u32 node,
332 u32 port, u32 instance)
333{
334 tipc_group_create_member(grp, node, port, instance, MBR_PUBLISHED);
335}
336
337static void tipc_group_delete_member(struct tipc_group *grp,
338 struct tipc_member *m)
339{
340 rb_erase(&m->tree_node, &grp->members);
341 grp->member_cnt--;
342
343 /* Check if we were waiting for replicast ack from this member */
344 if (grp->bc_ackers && less(m->bc_acked, grp->bc_snd_nxt - 1))
345 grp->bc_ackers--;
346
347 list_del_init(&m->list);
348 list_del_init(&m->small_win);
349 tipc_group_decr_active(grp, m);
350
351 /* If last member on a node, remove node from dest list */
352 if (!tipc_group_find_node(grp, m->node))
353 tipc_nlist_del(&grp->dests, m->node);
354
355 kfree(m);
356}
357
358struct tipc_nlist *tipc_group_dests(struct tipc_group *grp)
359{
360 return &grp->dests;
361}
362
363void tipc_group_self(struct tipc_group *grp, struct tipc_service_range *seq,
364 int *scope)
365{
366 seq->type = grp->type;
367 seq->lower = grp->instance;
368 seq->upper = grp->instance;
369 *scope = grp->scope;
370}
371
372void tipc_group_update_member(struct tipc_member *m, int len)
373{
374 struct tipc_group *grp = m->group;
375 struct tipc_member *_m, *tmp;
376
377 if (!tipc_group_is_receiver(m))
378 return;
379
380 m->window -= len;
381
382 if (m->window >= ADV_IDLE)
383 return;
384
385 list_del_init(&m->small_win);
386
387 /* Sort member into small_window members' list */
388 list_for_each_entry_safe(_m, tmp, &grp->small_win, small_win) {
389 if (_m->window > m->window)
390 break;
391 }
392 list_add_tail(&m->small_win, &_m->small_win);
393}
394
395void tipc_group_update_bc_members(struct tipc_group *grp, int len, bool ack)
396{
397 u16 prev = grp->bc_snd_nxt - 1;
398 struct tipc_member *m;
399 struct rb_node *n;
400 u16 ackers = 0;
401
402 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
403 m = container_of(n, struct tipc_member, tree_node);
404 if (tipc_group_is_receiver(m)) {
405 tipc_group_update_member(m, len);
406 m->bc_acked = prev;
407 ackers++;
408 }
409 }
410
411 /* Mark number of acknowledges to expect, if any */
412 if (ack)
413 grp->bc_ackers = ackers;
414 grp->bc_snd_nxt++;
415}
416
417bool tipc_group_cong(struct tipc_group *grp, u32 dnode, u32 dport,
418 int len, struct tipc_member **mbr)
419{
420 struct sk_buff_head xmitq;
421 struct tipc_member *m;
422 int adv, state;
423
424 m = tipc_group_find_dest(grp, dnode, dport);
425 if (!tipc_group_is_receiver(m)) {
426 *mbr = NULL;
427 return false;
428 }
429 *mbr = m;
430
431 if (m->window >= len)
432 return false;
433
434 *grp->open = false;
435
436 /* If not fully advertised, do it now to prevent mutual blocking */
437 adv = m->advertised;
438 state = m->state;
439 if (state == MBR_JOINED && adv == ADV_IDLE)
440 return true;
441 if (state == MBR_ACTIVE && adv == ADV_ACTIVE)
442 return true;
443 if (state == MBR_PENDING && adv == ADV_IDLE)
444 return true;
445 __skb_queue_head_init(&xmitq);
446 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, &xmitq);
447 tipc_node_distr_xmit(grp->net, &xmitq);
448 return true;
449}
450
451bool tipc_group_bc_cong(struct tipc_group *grp, int len)
452{
453 struct tipc_member *m = NULL;
454
455 /* If prev bcast was replicast, reject until all receivers have acked */
456 if (grp->bc_ackers) {
457 *grp->open = false;
458 return true;
459 }
460 if (list_empty(&grp->small_win))
461 return false;
462
463 m = list_first_entry(&grp->small_win, struct tipc_member, small_win);
464 if (m->window >= len)
465 return false;
466
467 return tipc_group_cong(grp, m->node, m->port, len, &m);
468}
469
470/* tipc_group_sort_msg() - sort msg into queue by bcast sequence number
471 */
472static void tipc_group_sort_msg(struct sk_buff *skb, struct sk_buff_head *defq)
473{
474 struct tipc_msg *_hdr, *hdr = buf_msg(skb);
475 u16 bc_seqno = msg_grp_bc_seqno(hdr);
476 struct sk_buff *_skb, *tmp;
477 int mtyp = msg_type(hdr);
478
479 /* Bcast/mcast may be bypassed by ucast or other bcast, - sort it in */
480 if (mtyp == TIPC_GRP_BCAST_MSG || mtyp == TIPC_GRP_MCAST_MSG) {
481 skb_queue_walk_safe(defq, _skb, tmp) {
482 _hdr = buf_msg(_skb);
483 if (!less(bc_seqno, msg_grp_bc_seqno(_hdr)))
484 continue;
485 __skb_queue_before(defq, _skb, skb);
486 return;
487 }
488 /* Bcast was not bypassed, - add to tail */
489 }
490 /* Unicasts are never bypassed, - always add to tail */
491 __skb_queue_tail(defq, skb);
492}
493
494/* tipc_group_filter_msg() - determine if we should accept arriving message
495 */
496void tipc_group_filter_msg(struct tipc_group *grp, struct sk_buff_head *inputq,
497 struct sk_buff_head *xmitq)
498{
499 struct sk_buff *skb = __skb_dequeue(inputq);
500 bool ack, deliver, update, leave = false;
501 struct sk_buff_head *defq;
502 struct tipc_member *m;
503 struct tipc_msg *hdr;
504 u32 node, port;
505 int mtyp, blks;
506
507 if (!skb)
508 return;
509
510 hdr = buf_msg(skb);
511 node = msg_orignode(hdr);
512 port = msg_origport(hdr);
513
514 if (!msg_in_group(hdr))
515 goto drop;
516
517 m = tipc_group_find_member(grp, node, port);
518 if (!tipc_group_is_sender(m))
519 goto drop;
520
521 if (less(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
522 goto drop;
523
524 TIPC_SKB_CB(skb)->orig_member = m->instance;
525 defq = &m->deferredq;
526 tipc_group_sort_msg(skb, defq);
527
528 while ((skb = skb_peek(defq))) {
529 hdr = buf_msg(skb);
530 mtyp = msg_type(hdr);
531 blks = msg_blocks(hdr);
532 deliver = true;
533 ack = false;
534 update = false;
535
536 if (more(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
537 break;
538
539 /* Decide what to do with message */
540 switch (mtyp) {
541 case TIPC_GRP_MCAST_MSG:
542 if (msg_nameinst(hdr) != grp->instance) {
543 update = true;
544 deliver = false;
545 }
546 fallthrough;
547 case TIPC_GRP_BCAST_MSG:
548 m->bc_rcv_nxt++;
549 ack = msg_grp_bc_ack_req(hdr);
550 break;
551 case TIPC_GRP_UCAST_MSG:
552 break;
553 case TIPC_GRP_MEMBER_EVT:
554 if (m->state == MBR_LEAVING)
555 leave = true;
556 if (!grp->events)
557 deliver = false;
558 break;
559 default:
560 break;
561 }
562
563 /* Execute decisions */
564 __skb_dequeue(defq);
565 if (deliver)
566 __skb_queue_tail(inputq, skb);
567 else
568 kfree_skb(skb);
569
570 if (ack)
571 tipc_group_proto_xmit(grp, m, GRP_ACK_MSG, xmitq);
572
573 if (leave) {
574 __skb_queue_purge(defq);
575 tipc_group_delete_member(grp, m);
576 break;
577 }
578 if (!update)
579 continue;
580
581 tipc_group_update_rcv_win(grp, blks, node, port, xmitq);
582 }
583 return;
584drop:
585 kfree_skb(skb);
586}
587
588void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
589 u32 port, struct sk_buff_head *xmitq)
590{
591 struct list_head *active = &grp->active;
592 int max_active = grp->max_active;
593 int reclaim_limit = max_active * 3 / 4;
594 int active_cnt = grp->active_cnt;
595 struct tipc_member *m, *rm, *pm;
596
597 m = tipc_group_find_member(grp, node, port);
598 if (!m)
599 return;
600
601 m->advertised -= blks;
602
603 switch (m->state) {
604 case MBR_JOINED:
605 /* First, decide if member can go active */
606 if (active_cnt <= max_active) {
607 m->state = MBR_ACTIVE;
608 list_add_tail(&m->list, active);
609 grp->active_cnt++;
610 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
611 } else {
612 m->state = MBR_PENDING;
613 list_add_tail(&m->list, &grp->pending);
614 }
615
616 if (active_cnt < reclaim_limit)
617 break;
618
619 /* Reclaim from oldest active member, if possible */
620 if (!list_empty(active)) {
621 rm = list_first_entry(active, struct tipc_member, list);
622 rm->state = MBR_RECLAIMING;
623 list_del_init(&rm->list);
624 tipc_group_proto_xmit(grp, rm, GRP_RECLAIM_MSG, xmitq);
625 break;
626 }
627 /* Nobody to reclaim from; - revert oldest pending to JOINED */
628 pm = list_first_entry(&grp->pending, struct tipc_member, list);
629 list_del_init(&pm->list);
630 pm->state = MBR_JOINED;
631 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
632 break;
633 case MBR_ACTIVE:
634 if (!list_is_last(&m->list, &grp->active))
635 list_move_tail(&m->list, &grp->active);
636 if (m->advertised > (ADV_ACTIVE * 3 / 4))
637 break;
638 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
639 break;
640 case MBR_REMITTED:
641 if (m->advertised > ADV_IDLE)
642 break;
643 m->state = MBR_JOINED;
644 grp->active_cnt--;
645 if (m->advertised < ADV_IDLE) {
646 pr_warn_ratelimited("Rcv unexpected msg after REMIT\n");
647 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
648 }
649
650 if (list_empty(&grp->pending))
651 return;
652
653 /* Set oldest pending member to active and advertise */
654 pm = list_first_entry(&grp->pending, struct tipc_member, list);
655 pm->state = MBR_ACTIVE;
656 list_move_tail(&pm->list, &grp->active);
657 grp->active_cnt++;
658 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
659 break;
660 case MBR_RECLAIMING:
661 case MBR_JOINING:
662 case MBR_LEAVING:
663 default:
664 break;
665 }
666}
667
668static void tipc_group_create_event(struct tipc_group *grp,
669 struct tipc_member *m,
670 u32 event, u16 seqno,
671 struct sk_buff_head *inputq)
672{ u32 dnode = tipc_own_addr(grp->net);
673 struct tipc_event evt;
674 struct sk_buff *skb;
675 struct tipc_msg *hdr;
676
677 memset(&evt, 0, sizeof(evt));
678 evt.event = event;
679 evt.found_lower = m->instance;
680 evt.found_upper = m->instance;
681 evt.port.ref = m->port;
682 evt.port.node = m->node;
683 evt.s.seq.type = grp->type;
684 evt.s.seq.lower = m->instance;
685 evt.s.seq.upper = m->instance;
686
687 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_GRP_MEMBER_EVT,
688 GROUP_H_SIZE, sizeof(evt), dnode, m->node,
689 grp->portid, m->port, 0);
690 if (!skb)
691 return;
692
693 hdr = buf_msg(skb);
694 msg_set_nametype(hdr, grp->type);
695 msg_set_grp_evt(hdr, event);
696 msg_set_dest_droppable(hdr, true);
697 msg_set_grp_bc_seqno(hdr, seqno);
698 memcpy(msg_data(hdr), &evt, sizeof(evt));
699 TIPC_SKB_CB(skb)->orig_member = m->instance;
700 __skb_queue_tail(inputq, skb);
701}
702
703static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
704 int mtyp, struct sk_buff_head *xmitq)
705{
706 struct tipc_msg *hdr;
707 struct sk_buff *skb;
708 int adv = 0;
709
710 skb = tipc_msg_create(GROUP_PROTOCOL, mtyp, INT_H_SIZE, 0,
711 m->node, tipc_own_addr(grp->net),
712 m->port, grp->portid, 0);
713 if (!skb)
714 return;
715
716 if (m->state == MBR_ACTIVE)
717 adv = ADV_ACTIVE - m->advertised;
718 else if (m->state == MBR_JOINED || m->state == MBR_PENDING)
719 adv = ADV_IDLE - m->advertised;
720
721 hdr = buf_msg(skb);
722
723 if (mtyp == GRP_JOIN_MSG) {
724 msg_set_grp_bc_syncpt(hdr, grp->bc_snd_nxt);
725 msg_set_adv_win(hdr, adv);
726 m->advertised += adv;
727 } else if (mtyp == GRP_LEAVE_MSG) {
728 msg_set_grp_bc_syncpt(hdr, grp->bc_snd_nxt);
729 } else if (mtyp == GRP_ADV_MSG) {
730 msg_set_adv_win(hdr, adv);
731 m->advertised += adv;
732 } else if (mtyp == GRP_ACK_MSG) {
733 msg_set_grp_bc_acked(hdr, m->bc_rcv_nxt);
734 } else if (mtyp == GRP_REMIT_MSG) {
735 msg_set_grp_remitted(hdr, m->window);
736 }
737 msg_set_dest_droppable(hdr, true);
738 __skb_queue_tail(xmitq, skb);
739}
740
741void tipc_group_proto_rcv(struct tipc_group *grp, bool *usr_wakeup,
742 struct tipc_msg *hdr, struct sk_buff_head *inputq,
743 struct sk_buff_head *xmitq)
744{
745 u32 node = msg_orignode(hdr);
746 u32 port = msg_origport(hdr);
747 struct tipc_member *m, *pm;
748 u16 remitted, in_flight;
749
750 if (!grp)
751 return;
752
753 if (grp->scope == TIPC_NODE_SCOPE && node != tipc_own_addr(grp->net))
754 return;
755
756 m = tipc_group_find_member(grp, node, port);
757
758 switch (msg_type(hdr)) {
759 case GRP_JOIN_MSG:
760 if (!m)
761 m = tipc_group_create_member(grp, node, port,
762 0, MBR_JOINING);
763 if (!m)
764 return;
765 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
766 m->bc_rcv_nxt = m->bc_syncpt;
767 m->window += msg_adv_win(hdr);
768
769 /* Wait until PUBLISH event is received if necessary */
770 if (m->state != MBR_PUBLISHED)
771 return;
772
773 /* Member can be taken into service */
774 m->state = MBR_JOINED;
775 tipc_group_open(m, usr_wakeup);
776 tipc_group_update_member(m, 0);
777 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
778 tipc_group_create_event(grp, m, TIPC_PUBLISHED,
779 m->bc_syncpt, inputq);
780 return;
781 case GRP_LEAVE_MSG:
782 if (!m)
783 return;
784 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
785 list_del_init(&m->list);
786 tipc_group_open(m, usr_wakeup);
787 tipc_group_decr_active(grp, m);
788 m->state = MBR_LEAVING;
789 tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
790 m->bc_syncpt, inputq);
791 return;
792 case GRP_ADV_MSG:
793 if (!m)
794 return;
795 m->window += msg_adv_win(hdr);
796 tipc_group_open(m, usr_wakeup);
797 return;
798 case GRP_ACK_MSG:
799 if (!m)
800 return;
801 m->bc_acked = msg_grp_bc_acked(hdr);
802 if (--grp->bc_ackers)
803 return;
804 list_del_init(&m->small_win);
805 *m->group->open = true;
806 *usr_wakeup = true;
807 tipc_group_update_member(m, 0);
808 return;
809 case GRP_RECLAIM_MSG:
810 if (!m)
811 return;
812 tipc_group_proto_xmit(grp, m, GRP_REMIT_MSG, xmitq);
813 m->window = ADV_IDLE;
814 tipc_group_open(m, usr_wakeup);
815 return;
816 case GRP_REMIT_MSG:
817 if (!m || m->state != MBR_RECLAIMING)
818 return;
819
820 remitted = msg_grp_remitted(hdr);
821
822 /* Messages preceding the REMIT still in receive queue */
823 if (m->advertised > remitted) {
824 m->state = MBR_REMITTED;
825 in_flight = m->advertised - remitted;
826 m->advertised = ADV_IDLE + in_flight;
827 return;
828 }
829 /* This should never happen */
830 if (m->advertised < remitted)
831 pr_warn_ratelimited("Unexpected REMIT msg\n");
832
833 /* All messages preceding the REMIT have been read */
834 m->state = MBR_JOINED;
835 grp->active_cnt--;
836 m->advertised = ADV_IDLE;
837
838 /* Set oldest pending member to active and advertise */
839 if (list_empty(&grp->pending))
840 return;
841 pm = list_first_entry(&grp->pending, struct tipc_member, list);
842 pm->state = MBR_ACTIVE;
843 list_move_tail(&pm->list, &grp->active);
844 grp->active_cnt++;
845 if (pm->advertised <= (ADV_ACTIVE * 3 / 4))
846 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
847 return;
848 default:
849 pr_warn("Received unknown GROUP_PROTO message\n");
850 }
851}
852
853/* tipc_group_member_evt() - receive and handle a member up/down event
854 */
855void tipc_group_member_evt(struct tipc_group *grp,
856 bool *usr_wakeup,
857 int *sk_rcvbuf,
858 struct tipc_msg *hdr,
859 struct sk_buff_head *inputq,
860 struct sk_buff_head *xmitq)
861{
862 struct tipc_event *evt = (void *)msg_data(hdr);
863 u32 instance = evt->found_lower;
864 u32 node = evt->port.node;
865 u32 port = evt->port.ref;
866 int event = evt->event;
867 struct tipc_member *m;
868 struct net *net;
869 u32 self;
870
871 if (!grp)
872 return;
873
874 net = grp->net;
875 self = tipc_own_addr(net);
876 if (!grp->loopback && node == self && port == grp->portid)
877 return;
878
879 m = tipc_group_find_member(grp, node, port);
880
881 switch (event) {
882 case TIPC_PUBLISHED:
883 /* Send and wait for arrival of JOIN message if necessary */
884 if (!m) {
885 m = tipc_group_create_member(grp, node, port, instance,
886 MBR_PUBLISHED);
887 if (!m)
888 break;
889 tipc_group_update_member(m, 0);
890 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
891 break;
892 }
893
894 if (m->state != MBR_JOINING)
895 break;
896
897 /* Member can be taken into service */
898 m->instance = instance;
899 m->state = MBR_JOINED;
900 tipc_group_open(m, usr_wakeup);
901 tipc_group_update_member(m, 0);
902 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
903 tipc_group_create_event(grp, m, TIPC_PUBLISHED,
904 m->bc_syncpt, inputq);
905 break;
906 case TIPC_WITHDRAWN:
907 if (!m)
908 break;
909
910 tipc_group_decr_active(grp, m);
911 m->state = MBR_LEAVING;
912 list_del_init(&m->list);
913 tipc_group_open(m, usr_wakeup);
914
915 /* Only send event if no LEAVE message can be expected */
916 if (!tipc_node_is_up(net, node))
917 tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
918 m->bc_rcv_nxt, inputq);
919 break;
920 default:
921 break;
922 }
923 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
924}
925
926int tipc_group_fill_sock_diag(struct tipc_group *grp, struct sk_buff *skb)
927{
928 struct nlattr *group = nla_nest_start_noflag(skb, TIPC_NLA_SOCK_GROUP);
929
930 if (!group)
931 return -EMSGSIZE;
932
933 if (nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_ID,
934 grp->type) ||
935 nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_INSTANCE,
936 grp->instance) ||
937 nla_put_u32(skb, TIPC_NLA_SOCK_GROUP_BC_SEND_NEXT,
938 grp->bc_snd_nxt))
939 goto group_msg_cancel;
940
941 if (grp->scope == TIPC_NODE_SCOPE)
942 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_NODE_SCOPE))
943 goto group_msg_cancel;
944
945 if (grp->scope == TIPC_CLUSTER_SCOPE)
946 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_CLUSTER_SCOPE))
947 goto group_msg_cancel;
948
949 if (*grp->open)
950 if (nla_put_flag(skb, TIPC_NLA_SOCK_GROUP_OPEN))
951 goto group_msg_cancel;
952
953 nla_nest_end(skb, group);
954 return 0;
955
956group_msg_cancel:
957 nla_nest_cancel(skb, group);
958 return -1;
959}