dt-bindings: clock: rk3328: fixup HCLK_I2S1 id
[firefly-linux-kernel-4.4.55.git] / net / tipc / node.c
1 /*
2  * net/tipc/node.c: TIPC node management routines
3  *
4  * Copyright (c) 2000-2006, 2012-2015, Ericsson AB
5  * Copyright (c) 2005-2006, 2010-2014, Wind River Systems
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 "link.h"
39 #include "node.h"
40 #include "name_distr.h"
41 #include "socket.h"
42 #include "bcast.h"
43 #include "discover.h"
44
45 /* Node FSM states and events:
46  */
47 enum {
48         SELF_DOWN_PEER_DOWN    = 0xdd,
49         SELF_UP_PEER_UP        = 0xaa,
50         SELF_DOWN_PEER_LEAVING = 0xd1,
51         SELF_UP_PEER_COMING    = 0xac,
52         SELF_COMING_PEER_UP    = 0xca,
53         SELF_LEAVING_PEER_DOWN = 0x1d,
54         NODE_FAILINGOVER       = 0xf0,
55         NODE_SYNCHING          = 0xcc
56 };
57
58 enum {
59         SELF_ESTABL_CONTACT_EVT = 0xece,
60         SELF_LOST_CONTACT_EVT   = 0x1ce,
61         PEER_ESTABL_CONTACT_EVT = 0x9ece,
62         PEER_LOST_CONTACT_EVT   = 0x91ce,
63         NODE_FAILOVER_BEGIN_EVT = 0xfbe,
64         NODE_FAILOVER_END_EVT   = 0xfee,
65         NODE_SYNCH_BEGIN_EVT    = 0xcbe,
66         NODE_SYNCH_END_EVT      = 0xcee
67 };
68
69 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
70                                   struct sk_buff_head *xmitq,
71                                   struct tipc_media_addr **maddr);
72 static void tipc_node_link_down(struct tipc_node *n, int bearer_id,
73                                 bool delete);
74 static void node_lost_contact(struct tipc_node *n, struct sk_buff_head *inputq);
75 static void tipc_node_delete(struct tipc_node *node);
76 static void tipc_node_timeout(unsigned long data);
77 static void tipc_node_fsm_evt(struct tipc_node *n, int evt);
78
79 struct tipc_sock_conn {
80         u32 port;
81         u32 peer_port;
82         u32 peer_node;
83         struct list_head list;
84 };
85
86 static const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = {
87         [TIPC_NLA_NODE_UNSPEC]          = { .type = NLA_UNSPEC },
88         [TIPC_NLA_NODE_ADDR]            = { .type = NLA_U32 },
89         [TIPC_NLA_NODE_UP]              = { .type = NLA_FLAG }
90 };
91
92 /*
93  * A trivial power-of-two bitmask technique is used for speed, since this
94  * operation is done for every incoming TIPC packet. The number of hash table
95  * entries has been chosen so that no hash chain exceeds 8 nodes and will
96  * usually be much smaller (typically only a single node).
97  */
98 static unsigned int tipc_hashfn(u32 addr)
99 {
100         return addr & (NODE_HTABLE_SIZE - 1);
101 }
102
103 static void tipc_node_kref_release(struct kref *kref)
104 {
105         struct tipc_node *node = container_of(kref, struct tipc_node, kref);
106
107         tipc_node_delete(node);
108 }
109
110 void tipc_node_put(struct tipc_node *node)
111 {
112         kref_put(&node->kref, tipc_node_kref_release);
113 }
114
115 static void tipc_node_get(struct tipc_node *node)
116 {
117         kref_get(&node->kref);
118 }
119
120 /*
121  * tipc_node_find - locate specified node object, if it exists
122  */
123 struct tipc_node *tipc_node_find(struct net *net, u32 addr)
124 {
125         struct tipc_net *tn = net_generic(net, tipc_net_id);
126         struct tipc_node *node;
127
128         if (unlikely(!in_own_cluster_exact(net, addr)))
129                 return NULL;
130
131         rcu_read_lock();
132         hlist_for_each_entry_rcu(node, &tn->node_htable[tipc_hashfn(addr)],
133                                  hash) {
134                 if (node->addr == addr) {
135                         tipc_node_get(node);
136                         rcu_read_unlock();
137                         return node;
138                 }
139         }
140         rcu_read_unlock();
141         return NULL;
142 }
143
144 struct tipc_node *tipc_node_create(struct net *net, u32 addr, u16 capabilities)
145 {
146         struct tipc_net *tn = net_generic(net, tipc_net_id);
147         struct tipc_node *n_ptr, *temp_node;
148
149         spin_lock_bh(&tn->node_list_lock);
150         n_ptr = tipc_node_find(net, addr);
151         if (n_ptr)
152                 goto exit;
153         n_ptr = kzalloc(sizeof(*n_ptr), GFP_ATOMIC);
154         if (!n_ptr) {
155                 pr_warn("Node creation failed, no memory\n");
156                 goto exit;
157         }
158         n_ptr->addr = addr;
159         n_ptr->net = net;
160         n_ptr->capabilities = capabilities;
161         kref_init(&n_ptr->kref);
162         spin_lock_init(&n_ptr->lock);
163         INIT_HLIST_NODE(&n_ptr->hash);
164         INIT_LIST_HEAD(&n_ptr->list);
165         INIT_LIST_HEAD(&n_ptr->publ_list);
166         INIT_LIST_HEAD(&n_ptr->conn_sks);
167         skb_queue_head_init(&n_ptr->bc_entry.namedq);
168         skb_queue_head_init(&n_ptr->bc_entry.inputq1);
169         __skb_queue_head_init(&n_ptr->bc_entry.arrvq);
170         skb_queue_head_init(&n_ptr->bc_entry.inputq2);
171         n_ptr->state = SELF_DOWN_PEER_LEAVING;
172         n_ptr->signature = INVALID_NODE_SIG;
173         n_ptr->active_links[0] = INVALID_BEARER_ID;
174         n_ptr->active_links[1] = INVALID_BEARER_ID;
175         if (!tipc_link_bc_create(net, tipc_own_addr(net), n_ptr->addr,
176                                  U16_MAX, tipc_bc_sndlink(net)->window,
177                                  n_ptr->capabilities,
178                                  &n_ptr->bc_entry.inputq1,
179                                  &n_ptr->bc_entry.namedq,
180                                  tipc_bc_sndlink(net),
181                                  &n_ptr->bc_entry.link)) {
182                 pr_warn("Broadcast rcv link creation failed, no memory\n");
183                 kfree(n_ptr);
184                 n_ptr = NULL;
185                 goto exit;
186         }
187         tipc_node_get(n_ptr);
188         setup_timer(&n_ptr->timer, tipc_node_timeout, (unsigned long)n_ptr);
189         n_ptr->keepalive_intv = U32_MAX;
190         hlist_add_head_rcu(&n_ptr->hash, &tn->node_htable[tipc_hashfn(addr)]);
191         list_for_each_entry_rcu(temp_node, &tn->node_list, list) {
192                 if (n_ptr->addr < temp_node->addr)
193                         break;
194         }
195         list_add_tail_rcu(&n_ptr->list, &temp_node->list);
196 exit:
197         spin_unlock_bh(&tn->node_list_lock);
198         return n_ptr;
199 }
200
201 static void tipc_node_calculate_timer(struct tipc_node *n, struct tipc_link *l)
202 {
203         unsigned long tol = l->tolerance;
204         unsigned long intv = ((tol / 4) > 500) ? 500 : tol / 4;
205         unsigned long keepalive_intv = msecs_to_jiffies(intv);
206
207         /* Link with lowest tolerance determines timer interval */
208         if (keepalive_intv < n->keepalive_intv)
209                 n->keepalive_intv = keepalive_intv;
210
211         /* Ensure link's abort limit corresponds to current interval */
212         l->abort_limit = l->tolerance / jiffies_to_msecs(n->keepalive_intv);
213 }
214
215 static void tipc_node_delete(struct tipc_node *node)
216 {
217         list_del_rcu(&node->list);
218         hlist_del_rcu(&node->hash);
219         kfree(node->bc_entry.link);
220         kfree_rcu(node, rcu);
221 }
222
223 void tipc_node_stop(struct net *net)
224 {
225         struct tipc_net *tn = net_generic(net, tipc_net_id);
226         struct tipc_node *node, *t_node;
227
228         spin_lock_bh(&tn->node_list_lock);
229         list_for_each_entry_safe(node, t_node, &tn->node_list, list) {
230                 if (del_timer(&node->timer))
231                         tipc_node_put(node);
232                 tipc_node_put(node);
233         }
234         spin_unlock_bh(&tn->node_list_lock);
235 }
236
237 int tipc_node_add_conn(struct net *net, u32 dnode, u32 port, u32 peer_port)
238 {
239         struct tipc_node *node;
240         struct tipc_sock_conn *conn;
241         int err = 0;
242
243         if (in_own_node(net, dnode))
244                 return 0;
245
246         node = tipc_node_find(net, dnode);
247         if (!node) {
248                 pr_warn("Connecting sock to node 0x%x failed\n", dnode);
249                 return -EHOSTUNREACH;
250         }
251         conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
252         if (!conn) {
253                 err = -EHOSTUNREACH;
254                 goto exit;
255         }
256         conn->peer_node = dnode;
257         conn->port = port;
258         conn->peer_port = peer_port;
259
260         tipc_node_lock(node);
261         list_add_tail(&conn->list, &node->conn_sks);
262         tipc_node_unlock(node);
263 exit:
264         tipc_node_put(node);
265         return err;
266 }
267
268 void tipc_node_remove_conn(struct net *net, u32 dnode, u32 port)
269 {
270         struct tipc_node *node;
271         struct tipc_sock_conn *conn, *safe;
272
273         if (in_own_node(net, dnode))
274                 return;
275
276         node = tipc_node_find(net, dnode);
277         if (!node)
278                 return;
279
280         tipc_node_lock(node);
281         list_for_each_entry_safe(conn, safe, &node->conn_sks, list) {
282                 if (port != conn->port)
283                         continue;
284                 list_del(&conn->list);
285                 kfree(conn);
286         }
287         tipc_node_unlock(node);
288         tipc_node_put(node);
289 }
290
291 /* tipc_node_timeout - handle expiration of node timer
292  */
293 static void tipc_node_timeout(unsigned long data)
294 {
295         struct tipc_node *n = (struct tipc_node *)data;
296         struct tipc_link_entry *le;
297         struct sk_buff_head xmitq;
298         int bearer_id;
299         int rc = 0;
300
301         __skb_queue_head_init(&xmitq);
302
303         for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) {
304                 tipc_node_lock(n);
305                 le = &n->links[bearer_id];
306                 if (le->link) {
307                         /* Link tolerance may change asynchronously: */
308                         tipc_node_calculate_timer(n, le->link);
309                         rc = tipc_link_timeout(le->link, &xmitq);
310                 }
311                 tipc_node_unlock(n);
312                 tipc_bearer_xmit(n->net, bearer_id, &xmitq, &le->maddr);
313                 if (rc & TIPC_LINK_DOWN_EVT)
314                         tipc_node_link_down(n, bearer_id, false);
315         }
316         if (!mod_timer(&n->timer, jiffies + n->keepalive_intv))
317                 tipc_node_get(n);
318         tipc_node_put(n);
319 }
320
321 /**
322  * __tipc_node_link_up - handle addition of link
323  * Node lock must be held by caller
324  * Link becomes active (alone or shared) or standby, depending on its priority.
325  */
326 static void __tipc_node_link_up(struct tipc_node *n, int bearer_id,
327                                 struct sk_buff_head *xmitq)
328 {
329         int *slot0 = &n->active_links[0];
330         int *slot1 = &n->active_links[1];
331         struct tipc_link *ol = node_active_link(n, 0);
332         struct tipc_link *nl = n->links[bearer_id].link;
333
334         if (!nl)
335                 return;
336
337         tipc_link_fsm_evt(nl, LINK_ESTABLISH_EVT);
338         if (!tipc_link_is_up(nl))
339                 return;
340
341         n->working_links++;
342         n->action_flags |= TIPC_NOTIFY_LINK_UP;
343         n->link_id = nl->peer_bearer_id << 16 | bearer_id;
344
345         /* Leave room for tunnel header when returning 'mtu' to users: */
346         n->links[bearer_id].mtu = nl->mtu - INT_H_SIZE;
347
348         tipc_bearer_add_dest(n->net, bearer_id, n->addr);
349         tipc_bcast_inc_bearer_dst_cnt(n->net, bearer_id);
350
351         pr_debug("Established link <%s> on network plane %c\n",
352                  nl->name, nl->net_plane);
353
354         /* First link? => give it both slots */
355         if (!ol) {
356                 *slot0 = bearer_id;
357                 *slot1 = bearer_id;
358                 tipc_node_fsm_evt(n, SELF_ESTABL_CONTACT_EVT);
359                 n->action_flags |= TIPC_NOTIFY_NODE_UP;
360                 tipc_bcast_add_peer(n->net, nl, xmitq);
361                 return;
362         }
363
364         /* Second link => redistribute slots */
365         if (nl->priority > ol->priority) {
366                 pr_debug("Old link <%s> becomes standby\n", ol->name);
367                 *slot0 = bearer_id;
368                 *slot1 = bearer_id;
369                 tipc_link_set_active(nl, true);
370                 tipc_link_set_active(ol, false);
371         } else if (nl->priority == ol->priority) {
372                 tipc_link_set_active(nl, true);
373                 *slot1 = bearer_id;
374         } else {
375                 pr_debug("New link <%s> is standby\n", nl->name);
376         }
377
378         /* Prepare synchronization with first link */
379         tipc_link_tnl_prepare(ol, nl, SYNCH_MSG, xmitq);
380 }
381
382 /**
383  * tipc_node_link_up - handle addition of link
384  *
385  * Link becomes active (alone or shared) or standby, depending on its priority.
386  */
387 static void tipc_node_link_up(struct tipc_node *n, int bearer_id,
388                               struct sk_buff_head *xmitq)
389 {
390         tipc_node_lock(n);
391         __tipc_node_link_up(n, bearer_id, xmitq);
392         tipc_node_unlock(n);
393 }
394
395 /**
396  * __tipc_node_link_down - handle loss of link
397  */
398 static void __tipc_node_link_down(struct tipc_node *n, int *bearer_id,
399                                   struct sk_buff_head *xmitq,
400                                   struct tipc_media_addr **maddr)
401 {
402         struct tipc_link_entry *le = &n->links[*bearer_id];
403         int *slot0 = &n->active_links[0];
404         int *slot1 = &n->active_links[1];
405         int i, highest = 0;
406         struct tipc_link *l, *_l, *tnl;
407
408         l = n->links[*bearer_id].link;
409         if (!l || tipc_link_is_reset(l))
410                 return;
411
412         n->working_links--;
413         n->action_flags |= TIPC_NOTIFY_LINK_DOWN;
414         n->link_id = l->peer_bearer_id << 16 | *bearer_id;
415
416         tipc_bearer_remove_dest(n->net, *bearer_id, n->addr);
417
418         pr_debug("Lost link <%s> on network plane %c\n",
419                  l->name, l->net_plane);
420
421         /* Select new active link if any available */
422         *slot0 = INVALID_BEARER_ID;
423         *slot1 = INVALID_BEARER_ID;
424         for (i = 0; i < MAX_BEARERS; i++) {
425                 _l = n->links[i].link;
426                 if (!_l || !tipc_link_is_up(_l))
427                         continue;
428                 if (_l == l)
429                         continue;
430                 if (_l->priority < highest)
431                         continue;
432                 if (_l->priority > highest) {
433                         highest = _l->priority;
434                         *slot0 = i;
435                         *slot1 = i;
436                         continue;
437                 }
438                 *slot1 = i;
439         }
440
441         if (!tipc_node_is_up(n)) {
442                 if (tipc_link_peer_is_down(l))
443                         tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
444                 tipc_node_fsm_evt(n, SELF_LOST_CONTACT_EVT);
445                 tipc_link_fsm_evt(l, LINK_RESET_EVT);
446                 tipc_link_reset(l);
447                 tipc_link_build_reset_msg(l, xmitq);
448                 *maddr = &n->links[*bearer_id].maddr;
449                 node_lost_contact(n, &le->inputq);
450                 tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
451                 return;
452         }
453         tipc_bcast_dec_bearer_dst_cnt(n->net, *bearer_id);
454
455         /* There is still a working link => initiate failover */
456         tnl = node_active_link(n, 0);
457         tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
458         tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
459         n->sync_point = tnl->rcv_nxt + (U16_MAX / 2 - 1);
460         tipc_link_tnl_prepare(l, tnl, FAILOVER_MSG, xmitq);
461         tipc_link_reset(l);
462         tipc_link_fsm_evt(l, LINK_RESET_EVT);
463         tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
464         tipc_node_fsm_evt(n, NODE_FAILOVER_BEGIN_EVT);
465         *maddr = &n->links[tnl->bearer_id].maddr;
466         *bearer_id = tnl->bearer_id;
467 }
468
469 static void tipc_node_link_down(struct tipc_node *n, int bearer_id, bool delete)
470 {
471         struct tipc_link_entry *le = &n->links[bearer_id];
472         struct tipc_link *l = le->link;
473         struct tipc_media_addr *maddr;
474         struct sk_buff_head xmitq;
475
476         if (!l)
477                 return;
478
479         __skb_queue_head_init(&xmitq);
480
481         tipc_node_lock(n);
482         if (!tipc_link_is_establishing(l)) {
483                 __tipc_node_link_down(n, &bearer_id, &xmitq, &maddr);
484                 if (delete) {
485                         kfree(l);
486                         le->link = NULL;
487                         n->link_cnt--;
488                 }
489         } else {
490                 /* Defuse pending tipc_node_link_up() */
491                 tipc_link_fsm_evt(l, LINK_RESET_EVT);
492         }
493         tipc_node_unlock(n);
494         tipc_bearer_xmit(n->net, bearer_id, &xmitq, maddr);
495         tipc_sk_rcv(n->net, &le->inputq);
496 }
497
498 bool tipc_node_is_up(struct tipc_node *n)
499 {
500         return n->active_links[0] != INVALID_BEARER_ID;
501 }
502
503 void tipc_node_check_dest(struct net *net, u32 onode,
504                           struct tipc_bearer *b,
505                           u16 capabilities, u32 signature,
506                           struct tipc_media_addr *maddr,
507                           bool *respond, bool *dupl_addr)
508 {
509         struct tipc_node *n;
510         struct tipc_link *l;
511         struct tipc_link_entry *le;
512         bool addr_match = false;
513         bool sign_match = false;
514         bool link_up = false;
515         bool accept_addr = false;
516         bool reset = true;
517         char *if_name;
518
519         *dupl_addr = false;
520         *respond = false;
521
522         n = tipc_node_create(net, onode, capabilities);
523         if (!n)
524                 return;
525
526         tipc_node_lock(n);
527
528         le = &n->links[b->identity];
529
530         /* Prepare to validate requesting node's signature and media address */
531         l = le->link;
532         link_up = l && tipc_link_is_up(l);
533         addr_match = l && !memcmp(&le->maddr, maddr, sizeof(*maddr));
534         sign_match = (signature == n->signature);
535
536         /* These three flags give us eight permutations: */
537
538         if (sign_match && addr_match && link_up) {
539                 /* All is fine. Do nothing. */
540                 reset = false;
541         } else if (sign_match && addr_match && !link_up) {
542                 /* Respond. The link will come up in due time */
543                 *respond = true;
544         } else if (sign_match && !addr_match && link_up) {
545                 /* Peer has changed i/f address without rebooting.
546                  * If so, the link will reset soon, and the next
547                  * discovery will be accepted. So we can ignore it.
548                  * It may also be an cloned or malicious peer having
549                  * chosen the same node address and signature as an
550                  * existing one.
551                  * Ignore requests until the link goes down, if ever.
552                  */
553                 *dupl_addr = true;
554         } else if (sign_match && !addr_match && !link_up) {
555                 /* Peer link has changed i/f address without rebooting.
556                  * It may also be a cloned or malicious peer; we can't
557                  * distinguish between the two.
558                  * The signature is correct, so we must accept.
559                  */
560                 accept_addr = true;
561                 *respond = true;
562         } else if (!sign_match && addr_match && link_up) {
563                 /* Peer node rebooted. Two possibilities:
564                  *  - Delayed re-discovery; this link endpoint has already
565                  *    reset and re-established contact with the peer, before
566                  *    receiving a discovery message from that node.
567                  *    (The peer happened to receive one from this node first).
568                  *  - The peer came back so fast that our side has not
569                  *    discovered it yet. Probing from this side will soon
570                  *    reset the link, since there can be no working link
571                  *    endpoint at the peer end, and the link will re-establish.
572                  *  Accept the signature, since it comes from a known peer.
573                  */
574                 n->signature = signature;
575         } else if (!sign_match && addr_match && !link_up) {
576                 /*  The peer node has rebooted.
577                  *  Accept signature, since it is a known peer.
578                  */
579                 n->signature = signature;
580                 *respond = true;
581         } else if (!sign_match && !addr_match && link_up) {
582                 /* Peer rebooted with new address, or a new/duplicate peer.
583                  * Ignore until the link goes down, if ever.
584                  */
585                 *dupl_addr = true;
586         } else if (!sign_match && !addr_match && !link_up) {
587                 /* Peer rebooted with new address, or it is a new peer.
588                  * Accept signature and address.
589                  */
590                 n->signature = signature;
591                 accept_addr = true;
592                 *respond = true;
593         }
594
595         if (!accept_addr)
596                 goto exit;
597
598         /* Now create new link if not already existing */
599         if (!l) {
600                 if (n->link_cnt == 2) {
601                         pr_warn("Cannot establish 3rd link to %x\n", n->addr);
602                         goto exit;
603                 }
604                 if_name = strchr(b->name, ':') + 1;
605                 if (!tipc_link_create(net, if_name, b->identity, b->tolerance,
606                                       b->net_plane, b->mtu, b->priority,
607                                       b->window, mod(tipc_net(net)->random),
608                                       tipc_own_addr(net), onode,
609                                       n->capabilities,
610                                       tipc_bc_sndlink(n->net), n->bc_entry.link,
611                                       &le->inputq,
612                                       &n->bc_entry.namedq, &l)) {
613                         *respond = false;
614                         goto exit;
615                 }
616                 tipc_link_reset(l);
617                 tipc_link_fsm_evt(l, LINK_RESET_EVT);
618                 if (n->state == NODE_FAILINGOVER)
619                         tipc_link_fsm_evt(l, LINK_FAILOVER_BEGIN_EVT);
620                 le->link = l;
621                 n->link_cnt++;
622                 tipc_node_calculate_timer(n, l);
623                 if (n->link_cnt == 1)
624                         if (!mod_timer(&n->timer, jiffies + n->keepalive_intv))
625                                 tipc_node_get(n);
626         }
627         memcpy(&le->maddr, maddr, sizeof(*maddr));
628 exit:
629         tipc_node_unlock(n);
630         if (reset && !tipc_link_is_reset(l))
631                 tipc_node_link_down(n, b->identity, false);
632         tipc_node_put(n);
633 }
634
635 void tipc_node_delete_links(struct net *net, int bearer_id)
636 {
637         struct tipc_net *tn = net_generic(net, tipc_net_id);
638         struct tipc_node *n;
639
640         rcu_read_lock();
641         list_for_each_entry_rcu(n, &tn->node_list, list) {
642                 tipc_node_link_down(n, bearer_id, true);
643         }
644         rcu_read_unlock();
645 }
646
647 static void tipc_node_reset_links(struct tipc_node *n)
648 {
649         char addr_string[16];
650         int i;
651
652         pr_warn("Resetting all links to %s\n",
653                 tipc_addr_string_fill(addr_string, n->addr));
654
655         for (i = 0; i < MAX_BEARERS; i++) {
656                 tipc_node_link_down(n, i, false);
657         }
658 }
659
660 /* tipc_node_fsm_evt - node finite state machine
661  * Determines when contact is allowed with peer node
662  */
663 static void tipc_node_fsm_evt(struct tipc_node *n, int evt)
664 {
665         int state = n->state;
666
667         switch (state) {
668         case SELF_DOWN_PEER_DOWN:
669                 switch (evt) {
670                 case SELF_ESTABL_CONTACT_EVT:
671                         state = SELF_UP_PEER_COMING;
672                         break;
673                 case PEER_ESTABL_CONTACT_EVT:
674                         state = SELF_COMING_PEER_UP;
675                         break;
676                 case SELF_LOST_CONTACT_EVT:
677                 case PEER_LOST_CONTACT_EVT:
678                         break;
679                 case NODE_SYNCH_END_EVT:
680                 case NODE_SYNCH_BEGIN_EVT:
681                 case NODE_FAILOVER_BEGIN_EVT:
682                 case NODE_FAILOVER_END_EVT:
683                 default:
684                         goto illegal_evt;
685                 }
686                 break;
687         case SELF_UP_PEER_UP:
688                 switch (evt) {
689                 case SELF_LOST_CONTACT_EVT:
690                         state = SELF_DOWN_PEER_LEAVING;
691                         break;
692                 case PEER_LOST_CONTACT_EVT:
693                         state = SELF_LEAVING_PEER_DOWN;
694                         break;
695                 case NODE_SYNCH_BEGIN_EVT:
696                         state = NODE_SYNCHING;
697                         break;
698                 case NODE_FAILOVER_BEGIN_EVT:
699                         state = NODE_FAILINGOVER;
700                         break;
701                 case SELF_ESTABL_CONTACT_EVT:
702                 case PEER_ESTABL_CONTACT_EVT:
703                 case NODE_SYNCH_END_EVT:
704                 case NODE_FAILOVER_END_EVT:
705                         break;
706                 default:
707                         goto illegal_evt;
708                 }
709                 break;
710         case SELF_DOWN_PEER_LEAVING:
711                 switch (evt) {
712                 case PEER_LOST_CONTACT_EVT:
713                         state = SELF_DOWN_PEER_DOWN;
714                         break;
715                 case SELF_ESTABL_CONTACT_EVT:
716                 case PEER_ESTABL_CONTACT_EVT:
717                 case SELF_LOST_CONTACT_EVT:
718                         break;
719                 case NODE_SYNCH_END_EVT:
720                 case NODE_SYNCH_BEGIN_EVT:
721                 case NODE_FAILOVER_BEGIN_EVT:
722                 case NODE_FAILOVER_END_EVT:
723                 default:
724                         goto illegal_evt;
725                 }
726                 break;
727         case SELF_UP_PEER_COMING:
728                 switch (evt) {
729                 case PEER_ESTABL_CONTACT_EVT:
730                         state = SELF_UP_PEER_UP;
731                         break;
732                 case SELF_LOST_CONTACT_EVT:
733                         state = SELF_DOWN_PEER_LEAVING;
734                         break;
735                 case SELF_ESTABL_CONTACT_EVT:
736                 case PEER_LOST_CONTACT_EVT:
737                 case NODE_SYNCH_END_EVT:
738                 case NODE_FAILOVER_BEGIN_EVT:
739                         break;
740                 case NODE_SYNCH_BEGIN_EVT:
741                 case NODE_FAILOVER_END_EVT:
742                 default:
743                         goto illegal_evt;
744                 }
745                 break;
746         case SELF_COMING_PEER_UP:
747                 switch (evt) {
748                 case SELF_ESTABL_CONTACT_EVT:
749                         state = SELF_UP_PEER_UP;
750                         break;
751                 case PEER_LOST_CONTACT_EVT:
752                         state = SELF_LEAVING_PEER_DOWN;
753                         break;
754                 case SELF_LOST_CONTACT_EVT:
755                 case PEER_ESTABL_CONTACT_EVT:
756                         break;
757                 case NODE_SYNCH_END_EVT:
758                 case NODE_SYNCH_BEGIN_EVT:
759                 case NODE_FAILOVER_BEGIN_EVT:
760                 case NODE_FAILOVER_END_EVT:
761                 default:
762                         goto illegal_evt;
763                 }
764                 break;
765         case SELF_LEAVING_PEER_DOWN:
766                 switch (evt) {
767                 case SELF_LOST_CONTACT_EVT:
768                         state = SELF_DOWN_PEER_DOWN;
769                         break;
770                 case SELF_ESTABL_CONTACT_EVT:
771                 case PEER_ESTABL_CONTACT_EVT:
772                 case PEER_LOST_CONTACT_EVT:
773                         break;
774                 case NODE_SYNCH_END_EVT:
775                 case NODE_SYNCH_BEGIN_EVT:
776                 case NODE_FAILOVER_BEGIN_EVT:
777                 case NODE_FAILOVER_END_EVT:
778                 default:
779                         goto illegal_evt;
780                 }
781                 break;
782         case NODE_FAILINGOVER:
783                 switch (evt) {
784                 case SELF_LOST_CONTACT_EVT:
785                         state = SELF_DOWN_PEER_LEAVING;
786                         break;
787                 case PEER_LOST_CONTACT_EVT:
788                         state = SELF_LEAVING_PEER_DOWN;
789                         break;
790                 case NODE_FAILOVER_END_EVT:
791                         state = SELF_UP_PEER_UP;
792                         break;
793                 case NODE_FAILOVER_BEGIN_EVT:
794                 case SELF_ESTABL_CONTACT_EVT:
795                 case PEER_ESTABL_CONTACT_EVT:
796                         break;
797                 case NODE_SYNCH_BEGIN_EVT:
798                 case NODE_SYNCH_END_EVT:
799                 default:
800                         goto illegal_evt;
801                 }
802                 break;
803         case NODE_SYNCHING:
804                 switch (evt) {
805                 case SELF_LOST_CONTACT_EVT:
806                         state = SELF_DOWN_PEER_LEAVING;
807                         break;
808                 case PEER_LOST_CONTACT_EVT:
809                         state = SELF_LEAVING_PEER_DOWN;
810                         break;
811                 case NODE_SYNCH_END_EVT:
812                         state = SELF_UP_PEER_UP;
813                         break;
814                 case NODE_FAILOVER_BEGIN_EVT:
815                         state = NODE_FAILINGOVER;
816                         break;
817                 case NODE_SYNCH_BEGIN_EVT:
818                 case SELF_ESTABL_CONTACT_EVT:
819                 case PEER_ESTABL_CONTACT_EVT:
820                         break;
821                 case NODE_FAILOVER_END_EVT:
822                 default:
823                         goto illegal_evt;
824                 }
825                 break;
826         default:
827                 pr_err("Unknown node fsm state %x\n", state);
828                 break;
829         }
830         n->state = state;
831         return;
832
833 illegal_evt:
834         pr_err("Illegal node fsm evt %x in state %x\n", evt, state);
835 }
836
837 bool tipc_node_filter_pkt(struct tipc_node *n, struct tipc_msg *hdr)
838 {
839         int state = n->state;
840
841         if (likely(state == SELF_UP_PEER_UP))
842                 return true;
843
844         if (state == SELF_LEAVING_PEER_DOWN)
845                 return false;
846
847         if (state == SELF_DOWN_PEER_LEAVING) {
848                 if (msg_peer_node_is_up(hdr))
849                         return false;
850         }
851
852         return true;
853 }
854
855 static void node_lost_contact(struct tipc_node *n,
856                               struct sk_buff_head *inputq)
857 {
858         char addr_string[16];
859         struct tipc_sock_conn *conn, *safe;
860         struct tipc_link *l;
861         struct list_head *conns = &n->conn_sks;
862         struct sk_buff *skb;
863         uint i;
864
865         pr_debug("Lost contact with %s\n",
866                  tipc_addr_string_fill(addr_string, n->addr));
867
868         /* Clean up broadcast state */
869         tipc_bcast_remove_peer(n->net, n->bc_entry.link);
870
871         /* Abort any ongoing link failover */
872         for (i = 0; i < MAX_BEARERS; i++) {
873                 l = n->links[i].link;
874                 if (l)
875                         tipc_link_fsm_evt(l, LINK_FAILOVER_END_EVT);
876         }
877
878         /* Notify publications from this node */
879         n->action_flags |= TIPC_NOTIFY_NODE_DOWN;
880
881         /* Notify sockets connected to node */
882         list_for_each_entry_safe(conn, safe, conns, list) {
883                 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_CONN_MSG,
884                                       SHORT_H_SIZE, 0, tipc_own_addr(n->net),
885                                       conn->peer_node, conn->port,
886                                       conn->peer_port, TIPC_ERR_NO_NODE);
887                 if (likely(skb))
888                         skb_queue_tail(inputq, skb);
889                 list_del(&conn->list);
890                 kfree(conn);
891         }
892 }
893
894 /**
895  * tipc_node_get_linkname - get the name of a link
896  *
897  * @bearer_id: id of the bearer
898  * @node: peer node address
899  * @linkname: link name output buffer
900  *
901  * Returns 0 on success
902  */
903 int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr,
904                            char *linkname, size_t len)
905 {
906         struct tipc_link *link;
907         int err = -EINVAL;
908         struct tipc_node *node = tipc_node_find(net, addr);
909
910         if (!node)
911                 return err;
912
913         if (bearer_id >= MAX_BEARERS)
914                 goto exit;
915
916         tipc_node_lock(node);
917         link = node->links[bearer_id].link;
918         if (link) {
919                 strncpy(linkname, link->name, len);
920                 err = 0;
921         }
922 exit:
923         tipc_node_unlock(node);
924         tipc_node_put(node);
925         return err;
926 }
927
928 void tipc_node_unlock(struct tipc_node *node)
929 {
930         struct net *net = node->net;
931         u32 addr = 0;
932         u32 flags = node->action_flags;
933         u32 link_id = 0;
934         struct list_head *publ_list;
935
936         if (likely(!flags)) {
937                 spin_unlock_bh(&node->lock);
938                 return;
939         }
940
941         addr = node->addr;
942         link_id = node->link_id;
943         publ_list = &node->publ_list;
944
945         node->action_flags &= ~(TIPC_NOTIFY_NODE_DOWN | TIPC_NOTIFY_NODE_UP |
946                                 TIPC_NOTIFY_LINK_DOWN | TIPC_NOTIFY_LINK_UP);
947
948         spin_unlock_bh(&node->lock);
949
950         if (flags & TIPC_NOTIFY_NODE_DOWN)
951                 tipc_publ_notify(net, publ_list, addr);
952
953         if (flags & TIPC_NOTIFY_NODE_UP)
954                 tipc_named_node_up(net, addr);
955
956         if (flags & TIPC_NOTIFY_LINK_UP)
957                 tipc_nametbl_publish(net, TIPC_LINK_STATE, addr, addr,
958                                      TIPC_NODE_SCOPE, link_id, addr);
959
960         if (flags & TIPC_NOTIFY_LINK_DOWN)
961                 tipc_nametbl_withdraw(net, TIPC_LINK_STATE, addr,
962                                       link_id, addr);
963
964 }
965
966 /* Caller should hold node lock for the passed node */
967 static int __tipc_nl_add_node(struct tipc_nl_msg *msg, struct tipc_node *node)
968 {
969         void *hdr;
970         struct nlattr *attrs;
971
972         hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
973                           NLM_F_MULTI, TIPC_NL_NODE_GET);
974         if (!hdr)
975                 return -EMSGSIZE;
976
977         attrs = nla_nest_start(msg->skb, TIPC_NLA_NODE);
978         if (!attrs)
979                 goto msg_full;
980
981         if (nla_put_u32(msg->skb, TIPC_NLA_NODE_ADDR, node->addr))
982                 goto attr_msg_full;
983         if (tipc_node_is_up(node))
984                 if (nla_put_flag(msg->skb, TIPC_NLA_NODE_UP))
985                         goto attr_msg_full;
986
987         nla_nest_end(msg->skb, attrs);
988         genlmsg_end(msg->skb, hdr);
989
990         return 0;
991
992 attr_msg_full:
993         nla_nest_cancel(msg->skb, attrs);
994 msg_full:
995         genlmsg_cancel(msg->skb, hdr);
996
997         return -EMSGSIZE;
998 }
999
1000 static struct tipc_link *tipc_node_select_link(struct tipc_node *n, int sel,
1001                                                int *bearer_id,
1002                                                struct tipc_media_addr **maddr)
1003 {
1004         int id = n->active_links[sel & 1];
1005
1006         if (unlikely(id < 0))
1007                 return NULL;
1008
1009         *bearer_id = id;
1010         *maddr = &n->links[id].maddr;
1011         return n->links[id].link;
1012 }
1013
1014 /**
1015  * tipc_node_xmit() is the general link level function for message sending
1016  * @net: the applicable net namespace
1017  * @list: chain of buffers containing message
1018  * @dnode: address of destination node
1019  * @selector: a number used for deterministic link selection
1020  * Consumes the buffer chain, except when returning -ELINKCONG
1021  * Returns 0 if success, otherwise errno: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE
1022  */
1023 int tipc_node_xmit(struct net *net, struct sk_buff_head *list,
1024                    u32 dnode, int selector)
1025 {
1026         struct tipc_link *l = NULL;
1027         struct tipc_node *n;
1028         struct sk_buff_head xmitq;
1029         struct tipc_media_addr *maddr;
1030         int bearer_id;
1031         int rc = -EHOSTUNREACH;
1032
1033         __skb_queue_head_init(&xmitq);
1034         n = tipc_node_find(net, dnode);
1035         if (likely(n)) {
1036                 tipc_node_lock(n);
1037                 l = tipc_node_select_link(n, selector, &bearer_id, &maddr);
1038                 if (likely(l))
1039                         rc = tipc_link_xmit(l, list, &xmitq);
1040                 tipc_node_unlock(n);
1041                 if (unlikely(rc == -ENOBUFS))
1042                         tipc_node_link_down(n, bearer_id, false);
1043                 tipc_node_put(n);
1044         }
1045         if (likely(!rc)) {
1046                 tipc_bearer_xmit(net, bearer_id, &xmitq, maddr);
1047                 return 0;
1048         }
1049         if (likely(in_own_node(net, dnode))) {
1050                 tipc_sk_rcv(net, list);
1051                 return 0;
1052         }
1053         return rc;
1054 }
1055
1056 /* tipc_node_xmit_skb(): send single buffer to destination
1057  * Buffers sent via this functon are generally TIPC_SYSTEM_IMPORTANCE
1058  * messages, which will not be rejected
1059  * The only exception is datagram messages rerouted after secondary
1060  * lookup, which are rare and safe to dispose of anyway.
1061  * TODO: Return real return value, and let callers use
1062  * tipc_wait_for_sendpkt() where applicable
1063  */
1064 int tipc_node_xmit_skb(struct net *net, struct sk_buff *skb, u32 dnode,
1065                        u32 selector)
1066 {
1067         struct sk_buff_head head;
1068         int rc;
1069
1070         skb_queue_head_init(&head);
1071         __skb_queue_tail(&head, skb);
1072         rc = tipc_node_xmit(net, &head, dnode, selector);
1073         if (rc == -ELINKCONG)
1074                 kfree_skb(skb);
1075         return 0;
1076 }
1077
1078 /**
1079  * tipc_node_bc_rcv - process TIPC broadcast packet arriving from off-node
1080  * @net: the applicable net namespace
1081  * @skb: TIPC packet
1082  * @bearer_id: id of bearer message arrived on
1083  *
1084  * Invoked with no locks held.
1085  */
1086 static void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id)
1087 {
1088         int rc;
1089         struct sk_buff_head xmitq;
1090         struct tipc_bclink_entry *be;
1091         struct tipc_link_entry *le;
1092         struct tipc_msg *hdr = buf_msg(skb);
1093         int usr = msg_user(hdr);
1094         u32 dnode = msg_destnode(hdr);
1095         struct tipc_node *n;
1096
1097         __skb_queue_head_init(&xmitq);
1098
1099         /* If NACK for other node, let rcv link for that node peek into it */
1100         if ((usr == BCAST_PROTOCOL) && (dnode != tipc_own_addr(net)))
1101                 n = tipc_node_find(net, dnode);
1102         else
1103                 n = tipc_node_find(net, msg_prevnode(hdr));
1104         if (!n) {
1105                 kfree_skb(skb);
1106                 return;
1107         }
1108         be = &n->bc_entry;
1109         le = &n->links[bearer_id];
1110
1111         rc = tipc_bcast_rcv(net, be->link, skb);
1112
1113         /* Broadcast link reset may happen at reassembly failure */
1114         if (rc & TIPC_LINK_DOWN_EVT)
1115                 tipc_node_reset_links(n);
1116
1117         /* Broadcast ACKs are sent on a unicast link */
1118         if (rc & TIPC_LINK_SND_BC_ACK) {
1119                 tipc_node_lock(n);
1120                 tipc_link_build_ack_msg(le->link, &xmitq);
1121                 tipc_node_unlock(n);
1122         }
1123
1124         if (!skb_queue_empty(&xmitq))
1125                 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
1126
1127         /* Deliver. 'arrvq' is under inputq2's lock protection */
1128         if (!skb_queue_empty(&be->inputq1)) {
1129                 spin_lock_bh(&be->inputq2.lock);
1130                 spin_lock_bh(&be->inputq1.lock);
1131                 skb_queue_splice_tail_init(&be->inputq1, &be->arrvq);
1132                 spin_unlock_bh(&be->inputq1.lock);
1133                 spin_unlock_bh(&be->inputq2.lock);
1134                 tipc_sk_mcast_rcv(net, &be->arrvq, &be->inputq2);
1135         }
1136         tipc_node_put(n);
1137 }
1138
1139 /**
1140  * tipc_node_check_state - check and if necessary update node state
1141  * @skb: TIPC packet
1142  * @bearer_id: identity of bearer delivering the packet
1143  * Returns true if state is ok, otherwise consumes buffer and returns false
1144  */
1145 static bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb,
1146                                   int bearer_id, struct sk_buff_head *xmitq)
1147 {
1148         struct tipc_msg *hdr = buf_msg(skb);
1149         int usr = msg_user(hdr);
1150         int mtyp = msg_type(hdr);
1151         u16 oseqno = msg_seqno(hdr);
1152         u16 iseqno = msg_seqno(msg_get_wrapped(hdr));
1153         u16 exp_pkts = msg_msgcnt(hdr);
1154         u16 rcv_nxt, syncpt, dlv_nxt;
1155         int state = n->state;
1156         struct tipc_link *l, *tnl, *pl = NULL;
1157         struct tipc_media_addr *maddr;
1158         int i, pb_id;
1159
1160         l = n->links[bearer_id].link;
1161         if (!l)
1162                 return false;
1163         rcv_nxt = l->rcv_nxt;
1164
1165
1166         if (likely((state == SELF_UP_PEER_UP) && (usr != TUNNEL_PROTOCOL)))
1167                 return true;
1168
1169         /* Find parallel link, if any */
1170         for (i = 0; i < MAX_BEARERS; i++) {
1171                 if ((i != bearer_id) && n->links[i].link) {
1172                         pl = n->links[i].link;
1173                         break;
1174                 }
1175         }
1176
1177         /* Update node accesibility if applicable */
1178         if (state == SELF_UP_PEER_COMING) {
1179                 if (!tipc_link_is_up(l))
1180                         return true;
1181                 if (!msg_peer_link_is_up(hdr))
1182                         return true;
1183                 tipc_node_fsm_evt(n, PEER_ESTABL_CONTACT_EVT);
1184         }
1185
1186         if (state == SELF_DOWN_PEER_LEAVING) {
1187                 if (msg_peer_node_is_up(hdr))
1188                         return false;
1189                 tipc_node_fsm_evt(n, PEER_LOST_CONTACT_EVT);
1190         }
1191
1192         /* Ignore duplicate packets */
1193         if ((usr != LINK_PROTOCOL) && less(oseqno, rcv_nxt))
1194                 return true;
1195
1196         /* Initiate or update failover mode if applicable */
1197         if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) {
1198                 syncpt = oseqno + exp_pkts - 1;
1199                 if (pl && tipc_link_is_up(pl)) {
1200                         pb_id = pl->bearer_id;
1201                         __tipc_node_link_down(n, &pb_id, xmitq, &maddr);
1202                         tipc_skb_queue_splice_tail_init(pl->inputq, l->inputq);
1203                 }
1204                 /* If pkts arrive out of order, use lowest calculated syncpt */
1205                 if (less(syncpt, n->sync_point))
1206                         n->sync_point = syncpt;
1207         }
1208
1209         /* Open parallel link when tunnel link reaches synch point */
1210         if ((n->state == NODE_FAILINGOVER) && tipc_link_is_up(l)) {
1211                 if (!more(rcv_nxt, n->sync_point))
1212                         return true;
1213                 tipc_node_fsm_evt(n, NODE_FAILOVER_END_EVT);
1214                 if (pl)
1215                         tipc_link_fsm_evt(pl, LINK_FAILOVER_END_EVT);
1216                 return true;
1217         }
1218
1219         /* No synching needed if only one link */
1220         if (!pl || !tipc_link_is_up(pl))
1221                 return true;
1222
1223         /* Initiate synch mode if applicable */
1224         if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG) && (oseqno == 1)) {
1225                 syncpt = iseqno + exp_pkts - 1;
1226                 if (!tipc_link_is_up(l)) {
1227                         tipc_link_fsm_evt(l, LINK_ESTABLISH_EVT);
1228                         __tipc_node_link_up(n, bearer_id, xmitq);
1229                 }
1230                 if (n->state == SELF_UP_PEER_UP) {
1231                         n->sync_point = syncpt;
1232                         tipc_link_fsm_evt(l, LINK_SYNCH_BEGIN_EVT);
1233                         tipc_node_fsm_evt(n, NODE_SYNCH_BEGIN_EVT);
1234                 }
1235                 if (less(syncpt, n->sync_point))
1236                         n->sync_point = syncpt;
1237         }
1238
1239         /* Open tunnel link when parallel link reaches synch point */
1240         if ((n->state == NODE_SYNCHING) && tipc_link_is_synching(l)) {
1241                 if (tipc_link_is_synching(l)) {
1242                         tnl = l;
1243                 } else {
1244                         tnl = pl;
1245                         pl = l;
1246                 }
1247                 dlv_nxt = pl->rcv_nxt - mod(skb_queue_len(pl->inputq));
1248                 if (more(dlv_nxt, n->sync_point)) {
1249                         tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT);
1250                         tipc_node_fsm_evt(n, NODE_SYNCH_END_EVT);
1251                         return true;
1252                 }
1253                 if (l == pl)
1254                         return true;
1255                 if ((usr == TUNNEL_PROTOCOL) && (mtyp == SYNCH_MSG))
1256                         return true;
1257                 if (usr == LINK_PROTOCOL)
1258                         return true;
1259                 return false;
1260         }
1261         return true;
1262 }
1263
1264 /**
1265  * tipc_rcv - process TIPC packets/messages arriving from off-node
1266  * @net: the applicable net namespace
1267  * @skb: TIPC packet
1268  * @bearer: pointer to bearer message arrived on
1269  *
1270  * Invoked with no locks held. Bearer pointer must point to a valid bearer
1271  * structure (i.e. cannot be NULL), but bearer can be inactive.
1272  */
1273 void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b)
1274 {
1275         struct sk_buff_head xmitq;
1276         struct tipc_node *n;
1277         struct tipc_msg *hdr = buf_msg(skb);
1278         int usr = msg_user(hdr);
1279         int bearer_id = b->identity;
1280         struct tipc_link_entry *le;
1281         u16 bc_ack = msg_bcast_ack(hdr);
1282         int rc = 0;
1283
1284         __skb_queue_head_init(&xmitq);
1285
1286         /* Ensure message is well-formed */
1287         if (unlikely(!tipc_msg_validate(skb)))
1288                 goto discard;
1289
1290         /* Handle arrival of discovery or broadcast packet */
1291         if (unlikely(msg_non_seq(hdr))) {
1292                 if (unlikely(usr == LINK_CONFIG))
1293                         return tipc_disc_rcv(net, skb, b);
1294                 else
1295                         return tipc_node_bc_rcv(net, skb, bearer_id);
1296         }
1297
1298         /* Locate neighboring node that sent packet */
1299         n = tipc_node_find(net, msg_prevnode(hdr));
1300         if (unlikely(!n))
1301                 goto discard;
1302         le = &n->links[bearer_id];
1303
1304         /* Ensure broadcast reception is in synch with peer's send state */
1305         if (unlikely(usr == LINK_PROTOCOL))
1306                 tipc_bcast_sync_rcv(net, n->bc_entry.link, hdr);
1307         else if (unlikely(n->bc_entry.link->acked != bc_ack))
1308                 tipc_bcast_ack_rcv(net, n->bc_entry.link, bc_ack);
1309
1310         tipc_node_lock(n);
1311
1312         /* Is reception permitted at the moment ? */
1313         if (!tipc_node_filter_pkt(n, hdr))
1314                 goto unlock;
1315
1316         /* Check and if necessary update node state */
1317         if (likely(tipc_node_check_state(n, skb, bearer_id, &xmitq))) {
1318                 rc = tipc_link_rcv(le->link, skb, &xmitq);
1319                 skb = NULL;
1320         }
1321 unlock:
1322         tipc_node_unlock(n);
1323
1324         if (unlikely(rc & TIPC_LINK_UP_EVT))
1325                 tipc_node_link_up(n, bearer_id, &xmitq);
1326
1327         if (unlikely(rc & TIPC_LINK_DOWN_EVT))
1328                 tipc_node_link_down(n, bearer_id, false);
1329
1330         if (unlikely(!skb_queue_empty(&n->bc_entry.namedq)))
1331                 tipc_named_rcv(net, &n->bc_entry.namedq);
1332
1333         if (!skb_queue_empty(&le->inputq))
1334                 tipc_sk_rcv(net, &le->inputq);
1335
1336         if (!skb_queue_empty(&xmitq))
1337                 tipc_bearer_xmit(net, bearer_id, &xmitq, &le->maddr);
1338
1339         tipc_node_put(n);
1340 discard:
1341         kfree_skb(skb);
1342 }
1343
1344 int tipc_nl_node_dump(struct sk_buff *skb, struct netlink_callback *cb)
1345 {
1346         int err;
1347         struct net *net = sock_net(skb->sk);
1348         struct tipc_net *tn = net_generic(net, tipc_net_id);
1349         int done = cb->args[0];
1350         int last_addr = cb->args[1];
1351         struct tipc_node *node;
1352         struct tipc_nl_msg msg;
1353
1354         if (done)
1355                 return 0;
1356
1357         msg.skb = skb;
1358         msg.portid = NETLINK_CB(cb->skb).portid;
1359         msg.seq = cb->nlh->nlmsg_seq;
1360
1361         rcu_read_lock();
1362         if (last_addr) {
1363                 node = tipc_node_find(net, last_addr);
1364                 if (!node) {
1365                         rcu_read_unlock();
1366                         /* We never set seq or call nl_dump_check_consistent()
1367                          * this means that setting prev_seq here will cause the
1368                          * consistence check to fail in the netlink callback
1369                          * handler. Resulting in the NLMSG_DONE message having
1370                          * the NLM_F_DUMP_INTR flag set if the node state
1371                          * changed while we released the lock.
1372                          */
1373                         cb->prev_seq = 1;
1374                         return -EPIPE;
1375                 }
1376                 tipc_node_put(node);
1377         }
1378
1379         list_for_each_entry_rcu(node, &tn->node_list, list) {
1380                 if (last_addr) {
1381                         if (node->addr == last_addr)
1382                                 last_addr = 0;
1383                         else
1384                                 continue;
1385                 }
1386
1387                 tipc_node_lock(node);
1388                 err = __tipc_nl_add_node(&msg, node);
1389                 if (err) {
1390                         last_addr = node->addr;
1391                         tipc_node_unlock(node);
1392                         goto out;
1393                 }
1394
1395                 tipc_node_unlock(node);
1396         }
1397         done = 1;
1398 out:
1399         cb->args[0] = done;
1400         cb->args[1] = last_addr;
1401         rcu_read_unlock();
1402
1403         return skb->len;
1404 }