]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame_incremental - net/tipc/group.c
projects / thirdparty / kernel / stable.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
tipc: improve groupcast scope handling
[thirdparty/kernel/stable.git] / net / tipc / group.c
... / ...
CommitLineData
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 "server.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 bool usr_pending;
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 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_decr_active(struct tipc_group *grp,
105 struct tipc_member *m)
106{
107 if (m->state == MBR_ACTIVE || m->state == MBR_RECLAIMING ||
108 m->state == MBR_REMITTED)
109 grp->active_cnt--;
110}
111
112static int tipc_group_rcvbuf_limit(struct tipc_group *grp)
113{
114 int max_active, active_pool, idle_pool;
115 int mcnt = grp->member_cnt + 1;
116
117 /* Limit simultaneous reception from other members */
118 max_active = min(mcnt / 8, 64);
119 max_active = max(max_active, 16);
120 grp->max_active = max_active;
121
122 /* Reserve blocks for active and idle members */
123 active_pool = max_active * ADV_ACTIVE;
124 idle_pool = (mcnt - max_active) * ADV_IDLE;
125
126 /* Scale to bytes, considering worst-case truesize/msgsize ratio */
127 return (active_pool + idle_pool) * FLOWCTL_BLK_SZ * 4;
128}
129
130u16 tipc_group_bc_snd_nxt(struct tipc_group *grp)
131{
132 return grp->bc_snd_nxt;
133}
134
135static bool tipc_group_is_receiver(struct tipc_member *m)
136{
137 return m && m->state != MBR_JOINING && m->state != MBR_LEAVING;
138}
139
140static bool tipc_group_is_sender(struct tipc_member *m)
141{
142 return m && m->state != MBR_JOINING && m->state != MBR_PUBLISHED;
143}
144
145u32 tipc_group_exclude(struct tipc_group *grp)
146{
147 if (!grp->loopback)
148 return grp->portid;
149 return 0;
150}
151
152int tipc_group_size(struct tipc_group *grp)
153{
154 return grp->member_cnt;
155}
156
157struct tipc_group *tipc_group_create(struct net *net, u32 portid,
158 struct tipc_group_req *mreq)
159{
160 u32 filter = TIPC_SUB_PORTS | TIPC_SUB_NO_STATUS;
161 bool global = mreq->scope != TIPC_NODE_SCOPE;
162 struct tipc_group *grp;
163 u32 type = mreq->type;
164
165 grp = kzalloc(sizeof(*grp), GFP_ATOMIC);
166 if (!grp)
167 return NULL;
168 tipc_nlist_init(&grp->dests, tipc_own_addr(net));
169 INIT_LIST_HEAD(&grp->small_win);
170 INIT_LIST_HEAD(&grp->active);
171 INIT_LIST_HEAD(&grp->pending);
172 grp->members = RB_ROOT;
173 grp->net = net;
174 grp->portid = portid;
175 grp->type = type;
176 grp->instance = mreq->instance;
177 grp->scope = mreq->scope;
178 grp->loopback = mreq->flags & TIPC_GROUP_LOOPBACK;
179 grp->events = mreq->flags & TIPC_GROUP_MEMBER_EVTS;
180 filter |= global ? TIPC_SUB_CLUSTER_SCOPE : TIPC_SUB_NODE_SCOPE;
181 if (tipc_topsrv_kern_subscr(net, portid, type, 0, ~0,
182 filter, &grp->subid))
183 return grp;
184 kfree(grp);
185 return NULL;
186}
187
188void tipc_group_join(struct net *net, struct tipc_group *grp, int *sk_rcvbuf)
189{
190 struct rb_root *tree = &grp->members;
191 struct tipc_member *m, *tmp;
192 struct sk_buff_head xmitq;
193
194 skb_queue_head_init(&xmitq);
195 rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
196 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, &xmitq);
197 tipc_group_update_member(m, 0);
198 }
199 tipc_node_distr_xmit(net, &xmitq);
200 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
201}
202
203void tipc_group_delete(struct net *net, struct tipc_group *grp)
204{
205 struct rb_root *tree = &grp->members;
206 struct tipc_member *m, *tmp;
207 struct sk_buff_head xmitq;
208
209 __skb_queue_head_init(&xmitq);
210
211 rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
212 tipc_group_proto_xmit(grp, m, GRP_LEAVE_MSG, &xmitq);
213 list_del(&m->list);
214 kfree(m);
215 }
216 tipc_node_distr_xmit(net, &xmitq);
217 tipc_nlist_purge(&grp->dests);
218 tipc_topsrv_kern_unsubscr(net, grp->subid);
219 kfree(grp);
220}
221
222struct tipc_member *tipc_group_find_member(struct tipc_group *grp,
223 u32 node, u32 port)
224{
225 struct rb_node *n = grp->members.rb_node;
226 u64 nkey, key = (u64)node << 32 | port;
227 struct tipc_member *m;
228
229 while (n) {
230 m = container_of(n, struct tipc_member, tree_node);
231 nkey = (u64)m->node << 32 | m->port;
232 if (key < nkey)
233 n = n->rb_left;
234 else if (key > nkey)
235 n = n->rb_right;
236 else
237 return m;
238 }
239 return NULL;
240}
241
242static struct tipc_member *tipc_group_find_dest(struct tipc_group *grp,
243 u32 node, u32 port)
244{
245 struct tipc_member *m;
246
247 m = tipc_group_find_member(grp, node, port);
248 if (m && tipc_group_is_receiver(m))
249 return m;
250 return NULL;
251}
252
253static struct tipc_member *tipc_group_find_node(struct tipc_group *grp,
254 u32 node)
255{
256 struct tipc_member *m;
257 struct rb_node *n;
258
259 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
260 m = container_of(n, struct tipc_member, tree_node);
261 if (m->node == node)
262 return m;
263 }
264 return NULL;
265}
266
267static void tipc_group_add_to_tree(struct tipc_group *grp,
268 struct tipc_member *m)
269{
270 u64 nkey, key = (u64)m->node << 32 | m->port;
271 struct rb_node **n, *parent = NULL;
272 struct tipc_member *tmp;
273
274 n = &grp->members.rb_node;
275 while (*n) {
276 tmp = container_of(*n, struct tipc_member, tree_node);
277 parent = *n;
278 tmp = container_of(parent, struct tipc_member, tree_node);
279 nkey = (u64)tmp->node << 32 | tmp->port;
280 if (key < nkey)
281 n = &(*n)->rb_left;
282 else if (key > nkey)
283 n = &(*n)->rb_right;
284 else
285 return;
286 }
287 rb_link_node(&m->tree_node, parent, n);
288 rb_insert_color(&m->tree_node, &grp->members);
289}
290
291static struct tipc_member *tipc_group_create_member(struct tipc_group *grp,
292 u32 node, u32 port,
293 u32 instance, int state)
294{
295 struct tipc_member *m;
296
297 m = kzalloc(sizeof(*m), GFP_ATOMIC);
298 if (!m)
299 return NULL;
300 INIT_LIST_HEAD(&m->list);
301 INIT_LIST_HEAD(&m->small_win);
302 __skb_queue_head_init(&m->deferredq);
303 m->group = grp;
304 m->node = node;
305 m->port = port;
306 m->instance = instance;
307 m->bc_acked = grp->bc_snd_nxt - 1;
308 grp->member_cnt++;
309 tipc_group_add_to_tree(grp, m);
310 tipc_nlist_add(&grp->dests, m->node);
311 m->state = state;
312 return m;
313}
314
315void tipc_group_add_member(struct tipc_group *grp, u32 node,
316 u32 port, u32 instance)
317{
318 tipc_group_create_member(grp, node, port, instance, MBR_PUBLISHED);
319}
320
321static void tipc_group_delete_member(struct tipc_group *grp,
322 struct tipc_member *m)
323{
324 rb_erase(&m->tree_node, &grp->members);
325 grp->member_cnt--;
326
327 /* Check if we were waiting for replicast ack from this member */
328 if (grp->bc_ackers && less(m->bc_acked, grp->bc_snd_nxt - 1))
329 grp->bc_ackers--;
330
331 list_del_init(&m->list);
332 list_del_init(&m->small_win);
333 tipc_group_decr_active(grp, m);
334
335 /* If last member on a node, remove node from dest list */
336 if (!tipc_group_find_node(grp, m->node))
337 tipc_nlist_del(&grp->dests, m->node);
338
339 kfree(m);
340}
341
342struct tipc_nlist *tipc_group_dests(struct tipc_group *grp)
343{
344 return &grp->dests;
345}
346
347void tipc_group_self(struct tipc_group *grp, struct tipc_name_seq *seq,
348 int *scope)
349{
350 seq->type = grp->type;
351 seq->lower = grp->instance;
352 seq->upper = grp->instance;
353 *scope = grp->scope;
354}
355
356void tipc_group_update_member(struct tipc_member *m, int len)
357{
358 struct tipc_group *grp = m->group;
359 struct tipc_member *_m, *tmp;
360
361 if (!tipc_group_is_receiver(m))
362 return;
363
364 m->window -= len;
365
366 if (m->window >= ADV_IDLE)
367 return;
368
369 list_del_init(&m->small_win);
370
371 /* Sort member into small_window members' list */
372 list_for_each_entry_safe(_m, tmp, &grp->small_win, small_win) {
373 if (_m->window > m->window)
374 break;
375 }
376 list_add_tail(&m->small_win, &_m->small_win);
377}
378
379void tipc_group_update_bc_members(struct tipc_group *grp, int len, bool ack)
380{
381 u16 prev = grp->bc_snd_nxt - 1;
382 struct tipc_member *m;
383 struct rb_node *n;
384 u16 ackers = 0;
385
386 for (n = rb_first(&grp->members); n; n = rb_next(n)) {
387 m = container_of(n, struct tipc_member, tree_node);
388 if (tipc_group_is_receiver(m)) {
389 tipc_group_update_member(m, len);
390 m->bc_acked = prev;
391 ackers++;
392 }
393 }
394
395 /* Mark number of acknowledges to expect, if any */
396 if (ack)
397 grp->bc_ackers = ackers;
398 grp->bc_snd_nxt++;
399}
400
401bool tipc_group_cong(struct tipc_group *grp, u32 dnode, u32 dport,
402 int len, struct tipc_member **mbr)
403{
404 struct sk_buff_head xmitq;
405 struct tipc_member *m;
406 int adv, state;
407
408 m = tipc_group_find_dest(grp, dnode, dport);
409 *mbr = m;
410 if (!m)
411 return false;
412 if (m->usr_pending)
413 return true;
414 if (m->window >= len)
415 return false;
416 m->usr_pending = true;
417
418 /* If not fully advertised, do it now to prevent mutual blocking */
419 adv = m->advertised;
420 state = m->state;
421 if (state < MBR_JOINED)
422 return true;
423 if (state == MBR_JOINED && adv == ADV_IDLE)
424 return true;
425 if (state == MBR_ACTIVE && adv == ADV_ACTIVE)
426 return true;
427 if (state == MBR_PENDING && adv == ADV_IDLE)
428 return true;
429 skb_queue_head_init(&xmitq);
430 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, &xmitq);
431 tipc_node_distr_xmit(grp->net, &xmitq);
432 return true;
433}
434
435bool tipc_group_bc_cong(struct tipc_group *grp, int len)
436{
437 struct tipc_member *m = NULL;
438
439 /* If prev bcast was replicast, reject until all receivers have acked */
440 if (grp->bc_ackers)
441 return true;
442
443 if (list_empty(&grp->small_win))
444 return false;
445
446 m = list_first_entry(&grp->small_win, struct tipc_member, small_win);
447 if (m->window >= len)
448 return false;
449
450 return tipc_group_cong(grp, m->node, m->port, len, &m);
451}
452
453/* tipc_group_sort_msg() - sort msg into queue by bcast sequence number
454 */
455static void tipc_group_sort_msg(struct sk_buff *skb, struct sk_buff_head *defq)
456{
457 struct tipc_msg *_hdr, *hdr = buf_msg(skb);
458 u16 bc_seqno = msg_grp_bc_seqno(hdr);
459 struct sk_buff *_skb, *tmp;
460 int mtyp = msg_type(hdr);
461
462 /* Bcast/mcast may be bypassed by ucast or other bcast, - sort it in */
463 if (mtyp == TIPC_GRP_BCAST_MSG || mtyp == TIPC_GRP_MCAST_MSG) {
464 skb_queue_walk_safe(defq, _skb, tmp) {
465 _hdr = buf_msg(_skb);
466 if (!less(bc_seqno, msg_grp_bc_seqno(_hdr)))
467 continue;
468 __skb_queue_before(defq, _skb, skb);
469 return;
470 }
471 /* Bcast was not bypassed, - add to tail */
472 }
473 /* Unicasts are never bypassed, - always add to tail */
474 __skb_queue_tail(defq, skb);
475}
476
477/* tipc_group_filter_msg() - determine if we should accept arriving message
478 */
479void tipc_group_filter_msg(struct tipc_group *grp, struct sk_buff_head *inputq,
480 struct sk_buff_head *xmitq)
481{
482 struct sk_buff *skb = __skb_dequeue(inputq);
483 bool ack, deliver, update, leave = false;
484 struct sk_buff_head *defq;
485 struct tipc_member *m;
486 struct tipc_msg *hdr;
487 u32 node, port;
488 int mtyp, blks;
489
490 if (!skb)
491 return;
492
493 hdr = buf_msg(skb);
494 node = msg_orignode(hdr);
495 port = msg_origport(hdr);
496
497 if (!msg_in_group(hdr))
498 goto drop;
499
500 m = tipc_group_find_member(grp, node, port);
501 if (!tipc_group_is_sender(m))
502 goto drop;
503
504 if (less(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
505 goto drop;
506
507 TIPC_SKB_CB(skb)->orig_member = m->instance;
508 defq = &m->deferredq;
509 tipc_group_sort_msg(skb, defq);
510
511 while ((skb = skb_peek(defq))) {
512 hdr = buf_msg(skb);
513 mtyp = msg_type(hdr);
514 blks = msg_blocks(hdr);
515 deliver = true;
516 ack = false;
517 update = false;
518
519 if (more(msg_grp_bc_seqno(hdr), m->bc_rcv_nxt))
520 break;
521
522 /* Decide what to do with message */
523 switch (mtyp) {
524 case TIPC_GRP_MCAST_MSG:
525 if (msg_nameinst(hdr) != grp->instance) {
526 update = true;
527 deliver = false;
528 }
529 /* Fall thru */
530 case TIPC_GRP_BCAST_MSG:
531 m->bc_rcv_nxt++;
532 ack = msg_grp_bc_ack_req(hdr);
533 break;
534 case TIPC_GRP_UCAST_MSG:
535 break;
536 case TIPC_GRP_MEMBER_EVT:
537 if (m->state == MBR_LEAVING)
538 leave = true;
539 if (!grp->events)
540 deliver = false;
541 break;
542 default:
543 break;
544 }
545
546 /* Execute decisions */
547 __skb_dequeue(defq);
548 if (deliver)
549 __skb_queue_tail(inputq, skb);
550 else
551 kfree_skb(skb);
552
553 if (ack)
554 tipc_group_proto_xmit(grp, m, GRP_ACK_MSG, xmitq);
555
556 if (leave) {
557 __skb_queue_purge(defq);
558 tipc_group_delete_member(grp, m);
559 break;
560 }
561 if (!update)
562 continue;
563
564 tipc_group_update_rcv_win(grp, blks, node, port, xmitq);
565 }
566 return;
567drop:
568 kfree_skb(skb);
569}
570
571void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
572 u32 port, struct sk_buff_head *xmitq)
573{
574 struct list_head *active = &grp->active;
575 int max_active = grp->max_active;
576 int reclaim_limit = max_active * 3 / 4;
577 int active_cnt = grp->active_cnt;
578 struct tipc_member *m, *rm, *pm;
579
580 m = tipc_group_find_member(grp, node, port);
581 if (!m)
582 return;
583
584 m->advertised -= blks;
585
586 switch (m->state) {
587 case MBR_JOINED:
588 /* First, decide if member can go active */
589 if (active_cnt <= max_active) {
590 m->state = MBR_ACTIVE;
591 list_add_tail(&m->list, active);
592 grp->active_cnt++;
593 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
594 } else {
595 m->state = MBR_PENDING;
596 list_add_tail(&m->list, &grp->pending);
597 }
598
599 if (active_cnt < reclaim_limit)
600 break;
601
602 /* Reclaim from oldest active member, if possible */
603 if (!list_empty(active)) {
604 rm = list_first_entry(active, struct tipc_member, list);
605 rm->state = MBR_RECLAIMING;
606 list_del_init(&rm->list);
607 tipc_group_proto_xmit(grp, rm, GRP_RECLAIM_MSG, xmitq);
608 break;
609 }
610 /* Nobody to reclaim from; - revert oldest pending to JOINED */
611 pm = list_first_entry(&grp->pending, struct tipc_member, list);
612 list_del_init(&pm->list);
613 pm->state = MBR_JOINED;
614 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
615 break;
616 case MBR_ACTIVE:
617 if (!list_is_last(&m->list, &grp->active))
618 list_move_tail(&m->list, &grp->active);
619 if (m->advertised > (ADV_ACTIVE * 3 / 4))
620 break;
621 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
622 break;
623 case MBR_REMITTED:
624 if (m->advertised > ADV_IDLE)
625 break;
626 m->state = MBR_JOINED;
627 grp->active_cnt--;
628 if (m->advertised < ADV_IDLE) {
629 pr_warn_ratelimited("Rcv unexpected msg after REMIT\n");
630 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
631 }
632
633 if (list_empty(&grp->pending))
634 return;
635
636 /* Set oldest pending member to active and advertise */
637 pm = list_first_entry(&grp->pending, struct tipc_member, list);
638 pm->state = MBR_ACTIVE;
639 list_move_tail(&pm->list, &grp->active);
640 grp->active_cnt++;
641 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
642 break;
643 case MBR_RECLAIMING:
644 case MBR_JOINING:
645 case MBR_LEAVING:
646 default:
647 break;
648 }
649}
650
651static void tipc_group_create_event(struct tipc_group *grp,
652 struct tipc_member *m,
653 u32 event, u16 seqno,
654 struct sk_buff_head *inputq)
655{ u32 dnode = tipc_own_addr(grp->net);
656 struct tipc_event evt;
657 struct sk_buff *skb;
658 struct tipc_msg *hdr;
659
660 evt.event = event;
661 evt.found_lower = m->instance;
662 evt.found_upper = m->instance;
663 evt.port.ref = m->port;
664 evt.port.node = m->node;
665 evt.s.seq.type = grp->type;
666 evt.s.seq.lower = m->instance;
667 evt.s.seq.upper = m->instance;
668
669 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_GRP_MEMBER_EVT,
670 GROUP_H_SIZE, sizeof(evt), dnode, m->node,
671 grp->portid, m->port, 0);
672 if (!skb)
673 return;
674
675 hdr = buf_msg(skb);
676 msg_set_nametype(hdr, grp->type);
677 msg_set_grp_evt(hdr, event);
678 msg_set_dest_droppable(hdr, true);
679 msg_set_grp_bc_seqno(hdr, seqno);
680 memcpy(msg_data(hdr), &evt, sizeof(evt));
681 TIPC_SKB_CB(skb)->orig_member = m->instance;
682 __skb_queue_tail(inputq, skb);
683}
684
685static void tipc_group_proto_xmit(struct tipc_group *grp, struct tipc_member *m,
686 int mtyp, struct sk_buff_head *xmitq)
687{
688 struct tipc_msg *hdr;
689 struct sk_buff *skb;
690 int adv = 0;
691
692 skb = tipc_msg_create(GROUP_PROTOCOL, mtyp, INT_H_SIZE, 0,
693 m->node, tipc_own_addr(grp->net),
694 m->port, grp->portid, 0);
695 if (!skb)
696 return;
697
698 if (m->state == MBR_ACTIVE)
699 adv = ADV_ACTIVE - m->advertised;
700 else if (m->state == MBR_JOINED || m->state == MBR_PENDING)
701 adv = ADV_IDLE - m->advertised;
702
703 hdr = buf_msg(skb);
704
705 if (mtyp == GRP_JOIN_MSG) {
706 msg_set_grp_bc_syncpt(hdr, grp->bc_snd_nxt);
707 msg_set_adv_win(hdr, adv);
708 m->advertised += adv;
709 } else if (mtyp == GRP_LEAVE_MSG) {
710 msg_set_grp_bc_syncpt(hdr, grp->bc_snd_nxt);
711 } else if (mtyp == GRP_ADV_MSG) {
712 msg_set_adv_win(hdr, adv);
713 m->advertised += adv;
714 } else if (mtyp == GRP_ACK_MSG) {
715 msg_set_grp_bc_acked(hdr, m->bc_rcv_nxt);
716 } else if (mtyp == GRP_REMIT_MSG) {
717 msg_set_grp_remitted(hdr, m->window);
718 }
719 msg_set_dest_droppable(hdr, true);
720 __skb_queue_tail(xmitq, skb);
721}
722
723void tipc_group_proto_rcv(struct tipc_group *grp, bool *usr_wakeup,
724 struct tipc_msg *hdr, struct sk_buff_head *inputq,
725 struct sk_buff_head *xmitq)
726{
727 u32 node = msg_orignode(hdr);
728 u32 port = msg_origport(hdr);
729 struct tipc_member *m, *pm;
730 u16 remitted, in_flight;
731
732 if (!grp)
733 return;
734
735 if (grp->scope == TIPC_NODE_SCOPE && node != tipc_own_addr(grp->net))
736 return;
737
738 m = tipc_group_find_member(grp, node, port);
739
740 switch (msg_type(hdr)) {
741 case GRP_JOIN_MSG:
742 if (!m)
743 m = tipc_group_create_member(grp, node, port,
744 0, MBR_JOINING);
745 if (!m)
746 return;
747 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
748 m->bc_rcv_nxt = m->bc_syncpt;
749 m->window += msg_adv_win(hdr);
750
751 /* Wait until PUBLISH event is received if necessary */
752 if (m->state != MBR_PUBLISHED)
753 return;
754
755 /* Member can be taken into service */
756 m->state = MBR_JOINED;
757 *usr_wakeup = true;
758 m->usr_pending = false;
759 list_del_init(&m->small_win);
760 tipc_group_update_member(m, 0);
761 tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
762 tipc_group_create_event(grp, m, TIPC_PUBLISHED,
763 m->bc_syncpt, inputq);
764 return;
765 case GRP_LEAVE_MSG:
766 if (!m)
767 return;
768 m->bc_syncpt = msg_grp_bc_syncpt(hdr);
769 list_del_init(&m->list);
770 list_del_init(&m->small_win);
771 *usr_wakeup = true;
772 tipc_group_decr_active(grp, m);
773 m->state = MBR_LEAVING;
774 tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
775 m->bc_syncpt, inputq);
776 return;
777 case GRP_ADV_MSG:
778 if (!m)
779 return;
780 m->window += msg_adv_win(hdr);
781 *usr_wakeup = m->usr_pending;
782 m->usr_pending = false;
783 list_del_init(&m->small_win);
784 return;
785 case GRP_ACK_MSG:
786 if (!m)
787 return;
788 m->bc_acked = msg_grp_bc_acked(hdr);
789 if (--grp->bc_ackers)
790 break;
791 *usr_wakeup = true;
792 m->usr_pending = false;
793 return;
794 case GRP_RECLAIM_MSG:
795 if (!m)
796 return;
797 *usr_wakeup = m->usr_pending;
798 m->usr_pending = false;
799 tipc_group_proto_xmit(grp, m, GRP_REMIT_MSG, xmitq);
800 m->window = ADV_IDLE;
801 return;
802 case GRP_REMIT_MSG:
803 if (!m || m->state != MBR_RECLAIMING)
804 return;
805
806 remitted = msg_grp_remitted(hdr);
807
808 /* Messages preceding the REMIT still in receive queue */
809 if (m->advertised > remitted) {
810 m->state = MBR_REMITTED;
811 in_flight = m->advertised - remitted;
812 m->advertised = ADV_IDLE + in_flight;
813 return;
814 }
815 /* This should never happen */
816 if (m->advertised < remitted)
817 pr_warn_ratelimited("Unexpected REMIT msg\n");
818
819 /* All messages preceding the REMIT have been read */
820 m->state = MBR_JOINED;
821 grp->active_cnt--;
822 m->advertised = ADV_IDLE;
823
824 /* Set oldest pending member to active and advertise */
825 if (list_empty(&grp->pending))
826 return;
827 pm = list_first_entry(&grp->pending, struct tipc_member, list);
828 pm->state = MBR_ACTIVE;
829 list_move_tail(&pm->list, &grp->active);
830 grp->active_cnt++;
831 if (pm->advertised <= (ADV_ACTIVE * 3 / 4))
832 tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
833 return;
834 default:
835 pr_warn("Received unknown GROUP_PROTO message\n");
836 }
837}
838
839/* tipc_group_member_evt() - receive and handle a member up/down event
840 */
841void tipc_group_member_evt(struct tipc_group *grp,
842 bool *usr_wakeup,
843 int *sk_rcvbuf,
844 struct tipc_msg *hdr,
845 struct sk_buff_head *inputq,
846 struct sk_buff_head *xmitq)
847{
848 struct tipc_event *evt = (void *)msg_data(hdr);
849 u32 instance = evt->found_lower;
850 u32 node = evt->port.node;
851 u32 port = evt->port.ref;
852 int event = evt->event;
853 struct tipc_member *m;
854 struct net *net;
855 u32 self;
856
857 if (!grp)
858 return;
859
860 net = grp->net;
861 self = tipc_own_addr(net);
862 if (!grp->loopback && node == self && port == grp->portid)
863 return;
864
865 m = tipc_group_find_member(grp, node, port);
866
867 switch (event) {
868 case TIPC_PUBLISHED:
869 /* Send and wait for arrival of JOIN message if necessary */
870 if (!m) {
871 m = tipc_group_create_member(grp, node, port, instance,
872 MBR_PUBLISHED);
873 if (!m)
874 break;
875 tipc_group_update_member(m, 0);
876 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
877 break;
878 }
879
880 if (m->state != MBR_JOINING)
881 break;
882
883 /* Member can be taken into service */
884 m->instance = instance;
885 m->state = MBR_JOINED;
886 *usr_wakeup = true;
887 m->usr_pending = false;
888 list_del_init(&m->small_win);
889 tipc_group_update_member(m, 0);
890 tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
891 tipc_group_create_event(grp, m, TIPC_PUBLISHED,
892 m->bc_syncpt, inputq);
893 break;
894 case TIPC_WITHDRAWN:
895 if (!m)
896 break;
897
898 *usr_wakeup = true;
899 m->usr_pending = false;
900 tipc_group_decr_active(grp, m);
901 m->state = MBR_LEAVING;
902 list_del_init(&m->list);
903 list_del_init(&m->small_win);
904
905 /* Only send event if no LEAVE message can be expected */
906 if (!tipc_node_is_up(net, node))
907 tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
908 m->bc_rcv_nxt, inputq);
909 break;
910 default:
911 break;
912 }
913 *sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
914}
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git