blob: bd25bff63925d82b8dec024358f0763b0796f0b4 [file] [log] [blame]
Per Lidenb97bf3f2006-01-02 19:04:38 +01001/*
2 * net/tipc/link.c: TIPC link code
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +09003 *
Jon Paul Maloye74a3862016-03-03 14:23:21 -05004 * Copyright (c) 1996-2007, 2012-2016, Ericsson AB
Ying Xue198d73b2013-06-17 10:54:42 -04005 * Copyright (c) 2004-2007, 2010-2013, Wind River Systems
Per Lidenb97bf3f2006-01-02 19:04:38 +01006 * All rights reserved.
7 *
Per Liden9ea1fd32006-01-11 13:30:43 +01008 * Redistribution and use in source and binary forms, with or without
Per Lidenb97bf3f2006-01-02 19:04:38 +01009 * modification, are permitted provided that the following conditions are met:
10 *
Per Liden9ea1fd32006-01-11 13:30:43 +010011 * 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.
Per Lidenb97bf3f2006-01-02 19:04:38 +010019 *
Per Liden9ea1fd32006-01-11 13:30:43 +010020 * 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
Per Lidenb97bf3f2006-01-02 19:04:38 +010034 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include "core.h"
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -040038#include "subscr.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010039#include "link.h"
Richard Alpe7be57fc2014-11-20 10:29:12 +010040#include "bcast.h"
Jon Paul Maloy9816f062014-05-14 05:39:15 -040041#include "socket.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010042#include "name_distr.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010043#include "discover.h"
Richard Alpe0655f6a2014-11-20 10:29:07 +010044#include "netlink.h"
Jon Paul Maloy35c55c92016-06-13 20:46:22 -040045#include "monitor.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010046
Ying Xue796c75d2013-06-17 10:54:48 -040047#include <linux/pkt_sched.h>
48
Jon Paul Maloy38206d52015-11-19 14:30:46 -050049struct tipc_stats {
Jon Paul Maloy95901122016-11-25 10:35:02 -050050 u32 sent_pkts;
51 u32 recv_pkts;
Jon Paul Maloy38206d52015-11-19 14:30:46 -050052 u32 sent_states;
53 u32 recv_states;
54 u32 sent_probes;
55 u32 recv_probes;
56 u32 sent_nacks;
57 u32 recv_nacks;
58 u32 sent_acks;
59 u32 sent_bundled;
60 u32 sent_bundles;
61 u32 recv_bundled;
62 u32 recv_bundles;
63 u32 retransmitted;
64 u32 sent_fragmented;
65 u32 sent_fragments;
66 u32 recv_fragmented;
67 u32 recv_fragments;
68 u32 link_congs; /* # port sends blocked by congestion */
69 u32 deferred_recv;
70 u32 duplicates;
71 u32 max_queue_sz; /* send queue size high water mark */
72 u32 accu_queue_sz; /* used for send queue size profiling */
73 u32 queue_sz_counts; /* used for send queue size profiling */
74 u32 msg_length_counts; /* used for message length profiling */
75 u32 msg_lengths_total; /* used for message length profiling */
76 u32 msg_length_profile[7]; /* used for msg. length profiling */
77};
78
79/**
80 * struct tipc_link - TIPC link data structure
81 * @addr: network address of link's peer node
82 * @name: link name character string
83 * @media_addr: media address to use when sending messages over link
84 * @timer: link timer
85 * @net: pointer to namespace struct
86 * @refcnt: reference counter for permanent references (owner node & timer)
87 * @peer_session: link session # being used by peer end of link
88 * @peer_bearer_id: bearer id used by link's peer endpoint
89 * @bearer_id: local bearer id used by link
90 * @tolerance: minimum link continuity loss needed to reset link [in ms]
Jon Paul Maloy38206d52015-11-19 14:30:46 -050091 * @abort_limit: # of unacknowledged continuity probes needed to reset link
92 * @state: current state of link FSM
93 * @peer_caps: bitmap describing capabilities of peer node
94 * @silent_intv_cnt: # of timer intervals without any reception from peer
95 * @proto_msg: template for control messages generated by link
96 * @pmsg: convenience pointer to "proto_msg" field
97 * @priority: current link priority
98 * @net_plane: current link network plane ('A' through 'H')
Jon Paul Maloy35c55c92016-06-13 20:46:22 -040099 * @mon_state: cookie with information needed by link monitor
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500100 * @backlog_limit: backlog queue congestion thresholds (indexed by importance)
101 * @exp_msg_count: # of tunnelled messages expected during link changeover
102 * @reset_rcv_checkpt: seq # of last acknowledged message at time of link reset
103 * @mtu: current maximum packet size for this link
104 * @advertised_mtu: advertised own mtu when link is being established
105 * @transmitq: queue for sent, non-acked messages
106 * @backlogq: queue for messages waiting to be sent
107 * @snt_nxt: next sequence number to use for outbound messages
108 * @last_retransmitted: sequence number of most recently retransmitted message
109 * @stale_count: # of identical retransmit requests made by peer
110 * @ackers: # of peers that needs to ack each packet before it can be released
111 * @acked: # last packet acked by a certain peer. Used for broadcast.
112 * @rcv_nxt: next sequence number to expect for inbound messages
113 * @deferred_queue: deferred queue saved OOS b'cast message received from node
114 * @unacked_window: # of inbound messages rx'd without ack'ing back to peer
115 * @inputq: buffer queue for messages to be delivered upwards
116 * @namedq: buffer queue for name table messages to be delivered upwards
117 * @next_out: ptr to first unsent outbound message in queue
118 * @wakeupq: linked list of wakeup msgs waiting for link congestion to abate
119 * @long_msg_seq_no: next identifier to use for outbound fragmented messages
120 * @reasm_buf: head of partially reassembled inbound message fragments
121 * @bc_rcvr: marks that this is a broadcast receiver link
122 * @stats: collects statistics regarding link activity
123 */
124struct tipc_link {
125 u32 addr;
126 char name[TIPC_MAX_LINK_NAME];
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500127 struct net *net;
128
129 /* Management and link supervision data */
130 u32 peer_session;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500131 u32 session;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500132 u32 peer_bearer_id;
133 u32 bearer_id;
134 u32 tolerance;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500135 u32 abort_limit;
136 u32 state;
137 u16 peer_caps;
138 bool active;
139 u32 silent_intv_cnt;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500140 char if_name[TIPC_MAX_IF_NAME];
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500141 u32 priority;
142 char net_plane;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400143 struct tipc_mon_state mon_state;
Jon Paul Maloy88e8ac72016-04-15 13:33:04 -0400144 u16 rst_cnt;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500145
146 /* Failover/synch */
147 u16 drop_point;
148 struct sk_buff *failover_reasm_skb;
149
150 /* Max packet negotiation */
151 u16 mtu;
152 u16 advertised_mtu;
153
154 /* Sending */
155 struct sk_buff_head transmq;
156 struct sk_buff_head backlogq;
157 struct {
158 u16 len;
159 u16 limit;
160 } backlog[5];
161 u16 snd_nxt;
162 u16 last_retransm;
163 u16 window;
164 u32 stale_count;
165
166 /* Reception */
167 u16 rcv_nxt;
168 u32 rcv_unacked;
169 struct sk_buff_head deferdq;
170 struct sk_buff_head *inputq;
171 struct sk_buff_head *namedq;
172
173 /* Congestion handling */
174 struct sk_buff_head wakeupq;
175
176 /* Fragmentation/reassembly */
177 struct sk_buff *reasm_buf;
178
179 /* Broadcast */
180 u16 ackers;
181 u16 acked;
182 struct tipc_link *bc_rcvlink;
183 struct tipc_link *bc_sndlink;
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -0400184 unsigned long prev_retr;
185 u16 prev_from;
186 u16 prev_to;
187 u8 nack_state;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500188 bool bc_peer_is_up;
189
190 /* Statistics */
191 struct tipc_stats stats;
192};
193
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400194/*
195 * Error message prefixes
196 */
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400197static const char *link_co_err = "Link tunneling error, ";
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400198static const char *link_rst_msg = "Resetting link ";
Richard Alpe7be57fc2014-11-20 10:29:12 +0100199
Jon Paul Maloy52666982015-10-22 08:51:41 -0400200/* Send states for broadcast NACKs
201 */
202enum {
203 BC_NACK_SND_CONDITIONAL,
204 BC_NACK_SND_UNCONDITIONAL,
205 BC_NACK_SND_SUPPRESS,
206};
207
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -0400208#define TIPC_BC_RETR_LIMIT 10 /* [ms] */
209
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900210/*
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400211 * Interval between NACKs when packets arrive out of order
212 */
213#define TIPC_NACK_INTV (TIPC_MIN_LINK_WIN * 2)
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500214
215/* Wildcard value for link session numbers. When it is known that
216 * peer endpoint is down, any session number must be accepted.
Allan Stephensa686e682008-06-04 17:29:39 -0700217 */
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500218#define ANY_SESSION 0x10000
Allan Stephensa686e682008-06-04 17:29:39 -0700219
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400220/* Link FSM states:
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400221 */
222enum {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400223 LINK_ESTABLISHED = 0xe,
224 LINK_ESTABLISHING = 0xe << 4,
225 LINK_RESET = 0x1 << 8,
226 LINK_RESETTING = 0x2 << 12,
227 LINK_PEER_RESET = 0xd << 16,
228 LINK_FAILINGOVER = 0xf << 20,
229 LINK_SYNCHING = 0xc << 24
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400230};
231
232/* Link FSM state checking routines
233 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400234static int link_is_up(struct tipc_link *l)
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400235{
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400236 return l->state & (LINK_ESTABLISHED | LINK_SYNCHING);
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400237}
238
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400239static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
240 struct sk_buff_head *xmitq);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -0400241static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
242 u16 rcvgap, int tolerance, int priority,
243 struct sk_buff_head *xmitq);
Jon Paul Maloy1a906322015-11-19 14:30:47 -0500244static void link_print(struct tipc_link *l, const char *str);
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -0400245static int tipc_link_build_nack_msg(struct tipc_link *l,
246 struct sk_buff_head *xmitq);
Jon Paul Maloy52666982015-10-22 08:51:41 -0400247static void tipc_link_build_bc_init_msg(struct tipc_link *l,
248 struct sk_buff_head *xmitq);
249static bool tipc_link_release_pkts(struct tipc_link *l, u16 to);
Jon Paul Maloy8b4ed862015-03-25 12:07:26 -0400250
Per Lidenb97bf3f2006-01-02 19:04:38 +0100251/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800252 * Simple non-static link routines (i.e. referenced outside this file)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100253 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400254bool tipc_link_is_up(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100255{
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400256 return link_is_up(l);
257}
258
Jon Paul Maloyc8199302015-10-15 14:52:46 -0400259bool tipc_link_peer_is_down(struct tipc_link *l)
260{
261 return l->state == LINK_PEER_RESET;
262}
263
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400264bool tipc_link_is_reset(struct tipc_link *l)
265{
266 return l->state & (LINK_RESET | LINK_FAILINGOVER | LINK_ESTABLISHING);
267}
268
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400269bool tipc_link_is_establishing(struct tipc_link *l)
270{
271 return l->state == LINK_ESTABLISHING;
272}
273
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400274bool tipc_link_is_synching(struct tipc_link *l)
275{
276 return l->state == LINK_SYNCHING;
277}
278
279bool tipc_link_is_failingover(struct tipc_link *l)
280{
281 return l->state == LINK_FAILINGOVER;
282}
283
284bool tipc_link_is_blocked(struct tipc_link *l)
285{
286 return l->state & (LINK_RESETTING | LINK_PEER_RESET | LINK_FAILINGOVER);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100287}
288
Wu Fengguang742e0382015-10-24 22:56:01 +0800289static bool link_is_bc_sndlink(struct tipc_link *l)
Jon Paul Maloy52666982015-10-22 08:51:41 -0400290{
291 return !l->bc_sndlink;
292}
293
Wu Fengguang742e0382015-10-24 22:56:01 +0800294static bool link_is_bc_rcvlink(struct tipc_link *l)
Jon Paul Maloy52666982015-10-22 08:51:41 -0400295{
296 return ((l->bc_rcvlink == l) && !link_is_bc_sndlink(l));
297}
298
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -0400299int tipc_link_is_active(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100300{
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400301 return l->active;
302}
Jon Paul Maloy9d13ec62015-07-16 16:54:19 -0400303
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400304void tipc_link_set_active(struct tipc_link *l, bool active)
305{
306 l->active = active;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100307}
308
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500309u32 tipc_link_id(struct tipc_link *l)
310{
311 return l->peer_bearer_id << 16 | l->bearer_id;
312}
313
314int tipc_link_window(struct tipc_link *l)
315{
316 return l->window;
317}
318
319int tipc_link_prio(struct tipc_link *l)
320{
321 return l->priority;
322}
323
324unsigned long tipc_link_tolerance(struct tipc_link *l)
325{
326 return l->tolerance;
327}
328
329struct sk_buff_head *tipc_link_inputq(struct tipc_link *l)
330{
331 return l->inputq;
332}
333
334char tipc_link_plane(struct tipc_link *l)
335{
336 return l->net_plane;
337}
338
Jon Paul Maloy52666982015-10-22 08:51:41 -0400339void tipc_link_add_bc_peer(struct tipc_link *snd_l,
340 struct tipc_link *uc_l,
341 struct sk_buff_head *xmitq)
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400342{
Jon Paul Maloy52666982015-10-22 08:51:41 -0400343 struct tipc_link *rcv_l = uc_l->bc_rcvlink;
344
345 snd_l->ackers++;
346 rcv_l->acked = snd_l->snd_nxt - 1;
Jon Paul Maloy9a650832015-11-19 14:12:50 -0500347 snd_l->state = LINK_ESTABLISHED;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400348 tipc_link_build_bc_init_msg(uc_l, xmitq);
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400349}
350
Jon Paul Maloy52666982015-10-22 08:51:41 -0400351void tipc_link_remove_bc_peer(struct tipc_link *snd_l,
352 struct tipc_link *rcv_l,
353 struct sk_buff_head *xmitq)
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400354{
Jon Paul Maloy52666982015-10-22 08:51:41 -0400355 u16 ack = snd_l->snd_nxt - 1;
356
357 snd_l->ackers--;
Jon Paul Maloya71eb722016-07-11 16:08:36 -0400358 rcv_l->bc_peer_is_up = true;
359 rcv_l->state = LINK_ESTABLISHED;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400360 tipc_link_bc_ack_rcv(rcv_l, ack, xmitq);
361 tipc_link_reset(rcv_l);
362 rcv_l->state = LINK_RESET;
363 if (!snd_l->ackers) {
364 tipc_link_reset(snd_l);
Jon Paul Maloy9a650832015-11-19 14:12:50 -0500365 snd_l->state = LINK_RESET;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400366 __skb_queue_purge(xmitq);
367 }
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400368}
369
370int tipc_link_bc_peers(struct tipc_link *l)
371{
372 return l->ackers;
373}
374
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -0400375u16 link_bc_rcv_gap(struct tipc_link *l)
376{
377 struct sk_buff *skb = skb_peek(&l->deferdq);
378 u16 gap = 0;
379
380 if (more(l->snd_nxt, l->rcv_nxt))
381 gap = l->snd_nxt - l->rcv_nxt;
382 if (skb)
383 gap = buf_seqno(skb) - l->rcv_nxt;
384 return gap;
385}
386
Jon Paul Maloy959e1782015-10-22 08:51:43 -0400387void tipc_link_set_mtu(struct tipc_link *l, int mtu)
388{
389 l->mtu = mtu;
390}
391
392int tipc_link_mtu(struct tipc_link *l)
393{
394 return l->mtu;
395}
396
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500397u16 tipc_link_rcv_nxt(struct tipc_link *l)
398{
399 return l->rcv_nxt;
400}
401
402u16 tipc_link_acked(struct tipc_link *l)
403{
404 return l->acked;
405}
406
407char *tipc_link_name(struct tipc_link *l)
408{
409 return l->name;
410}
411
Per Lidenb97bf3f2006-01-02 19:04:38 +0100412/**
Per Liden4323add2006-01-18 00:38:21 +0100413 * tipc_link_create - create a new link
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400414 * @n: pointer to associated node
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400415 * @if_name: associated interface name
416 * @bearer_id: id (index) of associated bearer
417 * @tolerance: link tolerance to be used by link
418 * @net_plane: network plane (A,B,c..) this link belongs to
419 * @mtu: mtu to be advertised by link
420 * @priority: priority to be used by link
421 * @window: send window to be used by link
422 * @session: session to be used by link
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400423 * @ownnode: identity of own node
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400424 * @peer: node id of peer node
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400425 * @peer_caps: bitmap describing peer node capabilities
Jon Paul Maloy52666982015-10-22 08:51:41 -0400426 * @bc_sndlink: the namespace global link used for broadcast sending
427 * @bc_rcvlink: the peer specific link used for broadcast reception
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400428 * @inputq: queue to put messages ready for delivery
429 * @namedq: queue to put binding table update messages ready for delivery
430 * @link: return value, pointer to put the created link
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900431 *
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400432 * Returns true if link was created, otherwise false
Per Lidenb97bf3f2006-01-02 19:04:38 +0100433 */
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400434bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400435 int tolerance, char net_plane, u32 mtu, int priority,
436 int window, u32 session, u32 ownnode, u32 peer,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400437 u16 peer_caps,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400438 struct tipc_link *bc_sndlink,
439 struct tipc_link *bc_rcvlink,
440 struct sk_buff_head *inputq,
441 struct sk_buff_head *namedq,
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400442 struct tipc_link **link)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100443{
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400444 struct tipc_link *l;
Allan Stephens37b9c082011-02-28 11:32:27 -0500445
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400446 l = kzalloc(sizeof(*l), GFP_ATOMIC);
447 if (!l)
448 return false;
449 *link = l;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500450 l->session = session;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400451
452 /* Note: peer i/f name is completed by reset/activate message */
453 sprintf(l->name, "%u.%u.%u:%s-%u.%u.%u:unknown",
454 tipc_zone(ownnode), tipc_cluster(ownnode), tipc_node(ownnode),
455 if_name, tipc_zone(peer), tipc_cluster(peer), tipc_node(peer));
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500456 strcpy(l->if_name, if_name);
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400457 l->addr = peer;
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400458 l->peer_caps = peer_caps;
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400459 l->net = net;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500460 l->peer_session = ANY_SESSION;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400461 l->bearer_id = bearer_id;
462 l->tolerance = tolerance;
463 l->net_plane = net_plane;
464 l->advertised_mtu = mtu;
465 l->mtu = mtu;
466 l->priority = priority;
467 tipc_link_set_queue_limits(l, window);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400468 l->ackers = 1;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400469 l->bc_sndlink = bc_sndlink;
470 l->bc_rcvlink = bc_rcvlink;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400471 l->inputq = inputq;
472 l->namedq = namedq;
473 l->state = LINK_RESETTING;
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400474 __skb_queue_head_init(&l->transmq);
475 __skb_queue_head_init(&l->backlogq);
476 __skb_queue_head_init(&l->deferdq);
477 skb_queue_head_init(&l->wakeupq);
478 skb_queue_head_init(l->inputq);
479 return true;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100480}
481
Jon Paul Maloy32301902015-10-22 08:51:37 -0400482/**
483 * tipc_link_bc_create - create new link to be used for broadcast
484 * @n: pointer to associated node
485 * @mtu: mtu to be used
486 * @window: send window to be used
487 * @inputq: queue to put messages ready for delivery
488 * @namedq: queue to put binding table update messages ready for delivery
489 * @link: return value, pointer to put the created link
490 *
491 * Returns true if link was created, otherwise false
492 */
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400493bool tipc_link_bc_create(struct net *net, u32 ownnode, u32 peer,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400494 int mtu, int window, u16 peer_caps,
Jon Paul Maloy32301902015-10-22 08:51:37 -0400495 struct sk_buff_head *inputq,
496 struct sk_buff_head *namedq,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400497 struct tipc_link *bc_sndlink,
Jon Paul Maloy32301902015-10-22 08:51:37 -0400498 struct tipc_link **link)
499{
500 struct tipc_link *l;
501
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400502 if (!tipc_link_create(net, "", MAX_BEARERS, 0, 'Z', mtu, 0, window,
Jon Paul Maloy2af5ae32015-10-22 08:51:48 -0400503 0, ownnode, peer, peer_caps, bc_sndlink,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400504 NULL, inputq, namedq, link))
Jon Paul Maloy32301902015-10-22 08:51:37 -0400505 return false;
506
507 l = *link;
508 strcpy(l->name, tipc_bclink_name);
509 tipc_link_reset(l);
Jon Paul Maloy52666982015-10-22 08:51:41 -0400510 l->state = LINK_RESET;
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400511 l->ackers = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400512 l->bc_rcvlink = l;
513
514 /* Broadcast send link is always up */
515 if (link_is_bc_sndlink(l))
516 l->state = LINK_ESTABLISHED;
517
Jon Paul Maloy01fd12b2017-01-18 13:50:53 -0500518 /* Disable replicast if even a single peer doesn't support it */
519 if (link_is_bc_rcvlink(l) && !(peer_caps & TIPC_BCAST_RCAST))
520 tipc_bcast_disable_rcast(net);
521
Jon Paul Maloy32301902015-10-22 08:51:37 -0400522 return true;
523}
524
Per Lidenb97bf3f2006-01-02 19:04:38 +0100525/**
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400526 * tipc_link_fsm_evt - link finite state machine
527 * @l: pointer to link
528 * @evt: state machine event to be processed
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400529 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400530int tipc_link_fsm_evt(struct tipc_link *l, int evt)
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400531{
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400532 int rc = 0;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400533
534 switch (l->state) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400535 case LINK_RESETTING:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400536 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400537 case LINK_PEER_RESET_EVT:
538 l->state = LINK_PEER_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400539 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400540 case LINK_RESET_EVT:
541 l->state = LINK_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400542 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400543 case LINK_FAILURE_EVT:
544 case LINK_FAILOVER_BEGIN_EVT:
545 case LINK_ESTABLISH_EVT:
546 case LINK_FAILOVER_END_EVT:
547 case LINK_SYNCH_BEGIN_EVT:
548 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400549 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400550 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400551 }
552 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400553 case LINK_RESET:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400554 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400555 case LINK_PEER_RESET_EVT:
556 l->state = LINK_ESTABLISHING;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400557 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400558 case LINK_FAILOVER_BEGIN_EVT:
559 l->state = LINK_FAILINGOVER;
560 case LINK_FAILURE_EVT:
561 case LINK_RESET_EVT:
562 case LINK_ESTABLISH_EVT:
563 case LINK_FAILOVER_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400564 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400565 case LINK_SYNCH_BEGIN_EVT:
566 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400567 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400568 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400569 }
570 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400571 case LINK_PEER_RESET:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400572 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400573 case LINK_RESET_EVT:
574 l->state = LINK_ESTABLISHING;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400575 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400576 case LINK_PEER_RESET_EVT:
577 case LINK_ESTABLISH_EVT:
578 case LINK_FAILURE_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400579 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400580 case LINK_SYNCH_BEGIN_EVT:
581 case LINK_SYNCH_END_EVT:
582 case LINK_FAILOVER_BEGIN_EVT:
583 case LINK_FAILOVER_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400584 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400585 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400586 }
587 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400588 case LINK_FAILINGOVER:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400589 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400590 case LINK_FAILOVER_END_EVT:
591 l->state = LINK_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400592 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400593 case LINK_PEER_RESET_EVT:
594 case LINK_RESET_EVT:
595 case LINK_ESTABLISH_EVT:
596 case LINK_FAILURE_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400597 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400598 case LINK_FAILOVER_BEGIN_EVT:
599 case LINK_SYNCH_BEGIN_EVT:
600 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400601 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400602 goto illegal_evt;
603 }
604 break;
605 case LINK_ESTABLISHING:
606 switch (evt) {
607 case LINK_ESTABLISH_EVT:
608 l->state = LINK_ESTABLISHED;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400609 break;
610 case LINK_FAILOVER_BEGIN_EVT:
611 l->state = LINK_FAILINGOVER;
612 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400613 case LINK_RESET_EVT:
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400614 l->state = LINK_RESET;
615 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400616 case LINK_FAILURE_EVT:
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400617 case LINK_PEER_RESET_EVT:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400618 case LINK_SYNCH_BEGIN_EVT:
619 case LINK_FAILOVER_END_EVT:
620 break;
621 case LINK_SYNCH_END_EVT:
622 default:
623 goto illegal_evt;
624 }
625 break;
626 case LINK_ESTABLISHED:
627 switch (evt) {
628 case LINK_PEER_RESET_EVT:
629 l->state = LINK_PEER_RESET;
630 rc |= TIPC_LINK_DOWN_EVT;
631 break;
632 case LINK_FAILURE_EVT:
633 l->state = LINK_RESETTING;
634 rc |= TIPC_LINK_DOWN_EVT;
635 break;
636 case LINK_RESET_EVT:
637 l->state = LINK_RESET;
638 break;
639 case LINK_ESTABLISH_EVT:
Jon Paul Maloy5ae2f8e2015-08-20 02:12:55 -0400640 case LINK_SYNCH_END_EVT:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400641 break;
642 case LINK_SYNCH_BEGIN_EVT:
643 l->state = LINK_SYNCHING;
644 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400645 case LINK_FAILOVER_BEGIN_EVT:
646 case LINK_FAILOVER_END_EVT:
647 default:
648 goto illegal_evt;
649 }
650 break;
651 case LINK_SYNCHING:
652 switch (evt) {
653 case LINK_PEER_RESET_EVT:
654 l->state = LINK_PEER_RESET;
655 rc |= TIPC_LINK_DOWN_EVT;
656 break;
657 case LINK_FAILURE_EVT:
658 l->state = LINK_RESETTING;
659 rc |= TIPC_LINK_DOWN_EVT;
660 break;
661 case LINK_RESET_EVT:
662 l->state = LINK_RESET;
663 break;
664 case LINK_ESTABLISH_EVT:
665 case LINK_SYNCH_BEGIN_EVT:
666 break;
667 case LINK_SYNCH_END_EVT:
668 l->state = LINK_ESTABLISHED;
669 break;
670 case LINK_FAILOVER_BEGIN_EVT:
671 case LINK_FAILOVER_END_EVT:
672 default:
673 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400674 }
675 break;
676 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400677 pr_err("Unknown FSM state %x in %s\n", l->state, l->name);
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400678 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400679 return rc;
680illegal_evt:
681 pr_err("Illegal FSM event %x in state %x on link %s\n",
682 evt, l->state, l->name);
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400683 return rc;
684}
685
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400686/* link_profile_stats - update statistical profiling of traffic
687 */
688static void link_profile_stats(struct tipc_link *l)
689{
690 struct sk_buff *skb;
691 struct tipc_msg *msg;
692 int length;
693
694 /* Update counters used in statistical profiling of send traffic */
695 l->stats.accu_queue_sz += skb_queue_len(&l->transmq);
696 l->stats.queue_sz_counts++;
697
698 skb = skb_peek(&l->transmq);
699 if (!skb)
700 return;
701 msg = buf_msg(skb);
702 length = msg_size(msg);
703
704 if (msg_user(msg) == MSG_FRAGMENTER) {
705 if (msg_type(msg) != FIRST_FRAGMENT)
706 return;
707 length = msg_size(msg_get_wrapped(msg));
708 }
709 l->stats.msg_lengths_total += length;
710 l->stats.msg_length_counts++;
711 if (length <= 64)
712 l->stats.msg_length_profile[0]++;
713 else if (length <= 256)
714 l->stats.msg_length_profile[1]++;
715 else if (length <= 1024)
716 l->stats.msg_length_profile[2]++;
717 else if (length <= 4096)
718 l->stats.msg_length_profile[3]++;
719 else if (length <= 16384)
720 l->stats.msg_length_profile[4]++;
721 else if (length <= 32768)
722 l->stats.msg_length_profile[5]++;
723 else
724 l->stats.msg_length_profile[6]++;
725}
726
727/* tipc_link_timeout - perform periodic task as instructed from node timeout
728 */
729int tipc_link_timeout(struct tipc_link *l, struct sk_buff_head *xmitq)
730{
Ying Xuec91522f2016-06-15 14:11:31 +0800731 int mtyp = 0;
732 int rc = 0;
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400733 bool state = false;
734 bool probe = false;
735 bool setup = false;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400736 u16 bc_snt = l->bc_sndlink->snd_nxt - 1;
737 u16 bc_acked = l->bc_rcvlink->acked;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400738 struct tipc_mon_state *mstate = &l->mon_state;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400739
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400740 switch (l->state) {
741 case LINK_ESTABLISHED:
742 case LINK_SYNCHING:
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400743 mtyp = STATE_MSG;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400744 link_profile_stats(l);
745 tipc_mon_get_state(l->net, l->addr, mstate, l->bearer_id);
746 if (mstate->reset || (l->silent_intv_cnt > l->abort_limit))
747 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400748 state = bc_acked != bc_snt;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400749 state |= l->bc_rcvlink->rcv_unacked;
750 state |= l->rcv_unacked;
751 state |= !skb_queue_empty(&l->transmq);
752 state |= !skb_queue_empty(&l->deferdq);
753 probe = mstate->probing;
754 probe |= l->silent_intv_cnt;
755 if (probe || mstate->monitoring)
756 l->silent_intv_cnt++;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400757 break;
758 case LINK_RESET:
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400759 setup = l->rst_cnt++ <= 4;
760 setup |= !(l->rst_cnt % 16);
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400761 mtyp = RESET_MSG;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400762 break;
763 case LINK_ESTABLISHING:
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400764 setup = true;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400765 mtyp = ACTIVATE_MSG;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400766 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400767 case LINK_PEER_RESET:
Jon Paul Maloy598411d2015-07-30 18:24:23 -0400768 case LINK_RESETTING:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400769 case LINK_FAILINGOVER:
770 break;
771 default:
772 break;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400773 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400774
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400775 if (state || probe || setup)
776 tipc_link_build_proto_msg(l, mtyp, probe, 0, 0, 0, xmitq);
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400777
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400778 return rc;
779}
780
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400781/**
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400782 * link_schedule_user - schedule a message sender for wakeup after congestion
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500783 * @l: congested link
784 * @hdr: header of message that is being sent
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400785 * Create pseudo msg to send back to user when congestion abates
Per Lidenb97bf3f2006-01-02 19:04:38 +0100786 */
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500787static int link_schedule_user(struct tipc_link *l, struct tipc_msg *hdr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100788{
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500789 u32 dnode = tipc_own_addr(l->net);
790 u32 dport = msg_origport(hdr);
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400791 struct sk_buff *skb;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100792
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400793 /* Create and schedule wakeup pseudo message */
794 skb = tipc_msg_create(SOCK_WAKEUP, 0, INT_H_SIZE, 0,
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500795 dnode, l->addr, dport, 0, 0);
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400796 if (!skb)
Jon Paul Maloy22d85c72015-07-16 16:54:23 -0400797 return -ENOBUFS;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500798 msg_set_dest_droppable(buf_msg(skb), true);
799 TIPC_SKB_CB(skb)->chain_imp = msg_importance(hdr);
800 skb_queue_tail(&l->wakeupq, skb);
801 l->stats.link_congs++;
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400802 return -ELINKCONG;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100803}
804
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400805/**
806 * link_prepare_wakeup - prepare users for wakeup after congestion
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500807 * @l: congested link
808 * Wake up a number of waiting users, as permitted by available space
809 * in the send queue
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400810 */
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400811void link_prepare_wakeup(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100812{
Ying Xue58d78b32014-11-26 11:41:51 +0800813 struct sk_buff *skb, *tmp;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500814 int imp, i = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100815
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400816 skb_queue_walk_safe(&l->wakeupq, skb, tmp) {
817 imp = TIPC_SKB_CB(skb)->chain_imp;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500818 if (l->backlog[imp].len < l->backlog[imp].limit) {
819 skb_unlink(skb, &l->wakeupq);
820 skb_queue_tail(l->inputq, skb);
821 } else if (i++ > 10) {
Per Lidenb97bf3f2006-01-02 19:04:38 +0100822 break;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500823 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100824 }
Per Lidenb97bf3f2006-01-02 19:04:38 +0100825}
826
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400827void tipc_link_reset(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100828{
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500829 l->peer_session = ANY_SESSION;
830 l->session++;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400831 l->mtu = l->advertised_mtu;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400832 __skb_queue_purge(&l->transmq);
833 __skb_queue_purge(&l->deferdq);
Jon Paul Maloy23d83352015-07-30 18:24:24 -0400834 skb_queue_splice_init(&l->wakeupq, l->inputq);
Jon Paul Maloy2af5ae32015-10-22 08:51:48 -0400835 __skb_queue_purge(&l->backlogq);
836 l->backlog[TIPC_LOW_IMPORTANCE].len = 0;
837 l->backlog[TIPC_MEDIUM_IMPORTANCE].len = 0;
838 l->backlog[TIPC_HIGH_IMPORTANCE].len = 0;
839 l->backlog[TIPC_CRITICAL_IMPORTANCE].len = 0;
840 l->backlog[TIPC_SYSTEM_IMPORTANCE].len = 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400841 kfree_skb(l->reasm_buf);
842 kfree_skb(l->failover_reasm_skb);
843 l->reasm_buf = NULL;
844 l->failover_reasm_skb = NULL;
845 l->rcv_unacked = 0;
846 l->snd_nxt = 1;
847 l->rcv_nxt = 1;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400848 l->acked = 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400849 l->silent_intv_cnt = 0;
Jon Paul Maloy88e8ac72016-04-15 13:33:04 -0400850 l->rst_cnt = 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400851 l->stale_count = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400852 l->bc_peer_is_up = false;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400853 memset(&l->mon_state, 0, sizeof(l->mon_state));
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500854 tipc_link_reset_stats(l);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100855}
856
Per Lidenb97bf3f2006-01-02 19:04:38 +0100857/**
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400858 * tipc_link_xmit(): enqueue buffer list according to queue situation
859 * @link: link to use
860 * @list: chain of buffers containing message
861 * @xmitq: returned list of packets to be sent by caller
862 *
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500863 * Consumes the buffer chain.
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400864 * Returns 0 if success, or errno: -ELINKCONG, -EMSGSIZE or -ENOBUFS
865 * Messages at TIPC_SYSTEM_IMPORTANCE are always accepted
866 */
867int tipc_link_xmit(struct tipc_link *l, struct sk_buff_head *list,
868 struct sk_buff_head *xmitq)
869{
870 struct tipc_msg *hdr = buf_msg(skb_peek(list));
871 unsigned int maxwin = l->window;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500872 int imp = msg_importance(hdr);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400873 unsigned int mtu = l->mtu;
874 u16 ack = l->rcv_nxt - 1;
875 u16 seqno = l->snd_nxt;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400876 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400877 struct sk_buff_head *transmq = &l->transmq;
878 struct sk_buff_head *backlogq = &l->backlogq;
879 struct sk_buff *skb, *_skb, *bskb;
Jon Paul Maloy95901122016-11-25 10:35:02 -0500880 int pkt_cnt = skb_queue_len(list);
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500881 int rc = 0;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400882
Richard Alpe4952cd32016-02-11 10:43:15 +0100883 if (unlikely(msg_size(hdr) > mtu)) {
884 skb_queue_purge(list);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400885 return -EMSGSIZE;
Richard Alpe4952cd32016-02-11 10:43:15 +0100886 }
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400887
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500888 /* Allow oversubscription of one data msg per source at congestion */
889 if (unlikely(l->backlog[imp].len >= l->backlog[imp].limit)) {
890 if (imp == TIPC_SYSTEM_IMPORTANCE) {
891 pr_warn("%s<%s>, link overflow", link_rst_msg, l->name);
892 return -ENOBUFS;
893 }
894 rc = link_schedule_user(l, hdr);
895 }
896
Jon Paul Maloy95901122016-11-25 10:35:02 -0500897 if (pkt_cnt > 1) {
898 l->stats.sent_fragmented++;
899 l->stats.sent_fragments += pkt_cnt;
900 }
901
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400902 /* Prepare each packet for sending, and add to relevant queue: */
903 while (skb_queue_len(list)) {
904 skb = skb_peek(list);
905 hdr = buf_msg(skb);
906 msg_set_seqno(hdr, seqno);
907 msg_set_ack(hdr, ack);
Jon Paul Maloy52666982015-10-22 08:51:41 -0400908 msg_set_bcast_ack(hdr, bc_ack);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400909
910 if (likely(skb_queue_len(transmq) < maxwin)) {
911 _skb = skb_clone(skb, GFP_ATOMIC);
Richard Alpe4952cd32016-02-11 10:43:15 +0100912 if (!_skb) {
913 skb_queue_purge(list);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400914 return -ENOBUFS;
Richard Alpe4952cd32016-02-11 10:43:15 +0100915 }
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400916 __skb_dequeue(list);
917 __skb_queue_tail(transmq, skb);
918 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400919 TIPC_SKB_CB(skb)->ackers = l->ackers;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400920 l->rcv_unacked = 0;
Jon Paul Maloy95901122016-11-25 10:35:02 -0500921 l->stats.sent_pkts++;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400922 seqno++;
923 continue;
924 }
925 if (tipc_msg_bundle(skb_peek_tail(backlogq), hdr, mtu)) {
926 kfree_skb(__skb_dequeue(list));
927 l->stats.sent_bundled++;
928 continue;
929 }
930 if (tipc_msg_make_bundle(&bskb, hdr, mtu, l->addr)) {
931 kfree_skb(__skb_dequeue(list));
932 __skb_queue_tail(backlogq, bskb);
933 l->backlog[msg_importance(buf_msg(bskb))].len++;
934 l->stats.sent_bundled++;
935 l->stats.sent_bundles++;
936 continue;
937 }
938 l->backlog[imp].len += skb_queue_len(list);
939 skb_queue_splice_tail_init(list, backlogq);
940 }
941 l->snd_nxt = seqno;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500942 return rc;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -0400943}
944
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400945void tipc_link_advance_backlog(struct tipc_link *l, struct sk_buff_head *xmitq)
946{
947 struct sk_buff *skb, *_skb;
948 struct tipc_msg *hdr;
949 u16 seqno = l->snd_nxt;
950 u16 ack = l->rcv_nxt - 1;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400951 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400952
953 while (skb_queue_len(&l->transmq) < l->window) {
954 skb = skb_peek(&l->backlogq);
955 if (!skb)
956 break;
957 _skb = skb_clone(skb, GFP_ATOMIC);
958 if (!_skb)
959 break;
960 __skb_dequeue(&l->backlogq);
961 hdr = buf_msg(skb);
962 l->backlog[msg_importance(hdr)].len--;
963 __skb_queue_tail(&l->transmq, skb);
964 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400965 TIPC_SKB_CB(skb)->ackers = l->ackers;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400966 msg_set_seqno(hdr, seqno);
Jon Paul Maloy52666982015-10-22 08:51:41 -0400967 msg_set_ack(hdr, ack);
968 msg_set_bcast_ack(hdr, bc_ack);
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400969 l->rcv_unacked = 0;
Jon Paul Maloy95901122016-11-25 10:35:02 -0500970 l->stats.sent_pkts++;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400971 seqno++;
972 }
973 l->snd_nxt = seqno;
974}
975
Jon Paul Maloy52666982015-10-22 08:51:41 -0400976static void link_retransmit_failure(struct tipc_link *l, struct sk_buff *skb)
Allan Stephensd356eeb2006-06-25 23:40:01 -0700977{
Jon Paul Maloy52666982015-10-22 08:51:41 -0400978 struct tipc_msg *hdr = buf_msg(skb);
Allan Stephensd356eeb2006-06-25 23:40:01 -0700979
Jon Paul Maloy52666982015-10-22 08:51:41 -0400980 pr_warn("Retransmission failure on link <%s>\n", l->name);
Jon Paul Maloy40501f92017-08-21 17:59:30 +0200981 link_print(l, "State of link ");
Jon Paul Maloy52666982015-10-22 08:51:41 -0400982 pr_info("Failed msg: usr %u, typ %u, len %u, err %u\n",
983 msg_user(hdr), msg_type(hdr), msg_size(hdr), msg_errcode(hdr));
984 pr_info("sqno %u, prev: %x, src: %x\n",
985 msg_seqno(hdr), msg_prevnode(hdr), msg_orignode(hdr));
Allan Stephensd356eeb2006-06-25 23:40:01 -0700986}
987
Jon Paul Maloy40501f92017-08-21 17:59:30 +0200988int tipc_link_retrans(struct tipc_link *l, struct tipc_link *nacker,
989 u16 from, u16 to, struct sk_buff_head *xmitq)
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400990{
991 struct sk_buff *_skb, *skb = skb_peek(&l->transmq);
992 struct tipc_msg *hdr;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400993 u16 ack = l->rcv_nxt - 1;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400994 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400995
996 if (!skb)
997 return 0;
998
999 /* Detect repeated retransmit failures on same packet */
Jon Paul Maloy40501f92017-08-21 17:59:30 +02001000 if (nacker->last_retransm != buf_seqno(skb)) {
1001 nacker->last_retransm = buf_seqno(skb);
1002 nacker->stale_count = 1;
1003 } else if (++nacker->stale_count > 100) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001004 link_retransmit_failure(l, skb);
Jon Paul Maloy40501f92017-08-21 17:59:30 +02001005 nacker->stale_count = 0;
1006 if (link_is_bc_sndlink(l))
1007 return TIPC_LINK_DOWN_EVT;
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001008 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001009 }
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001010
1011 /* Move forward to where retransmission should start */
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001012 skb_queue_walk(&l->transmq, skb) {
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001013 if (!less(buf_seqno(skb), from))
1014 break;
1015 }
1016
1017 skb_queue_walk_from(&l->transmq, skb) {
1018 if (more(buf_seqno(skb), to))
1019 break;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001020 hdr = buf_msg(skb);
1021 _skb = __pskb_copy(skb, MIN_H_SIZE, GFP_ATOMIC);
1022 if (!_skb)
1023 return 0;
1024 hdr = buf_msg(_skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001025 msg_set_ack(hdr, ack);
1026 msg_set_bcast_ack(hdr, bc_ack);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001027 _skb->priority = TC_PRIO_CONTROL;
1028 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001029 l->stats.retransmitted++;
1030 }
1031 return 0;
1032}
1033
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001034/* tipc_data_input - deliver data and name distr msgs to upper layer
Erik Hugne7ae934b2014-07-01 10:22:40 +02001035 *
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001036 * Consumes buffer if message is of right type
Erik Hugne7ae934b2014-07-01 10:22:40 +02001037 * Node lock must be held
1038 */
Jon Paul Maloy52666982015-10-22 08:51:41 -04001039static bool tipc_data_input(struct tipc_link *l, struct sk_buff *skb,
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001040 struct sk_buff_head *inputq)
Erik Hugne7ae934b2014-07-01 10:22:40 +02001041{
Jon Paul Maloya853e4c2017-01-18 13:50:52 -05001042 struct tipc_msg *hdr = buf_msg(skb);
1043
1044 switch (msg_user(hdr)) {
Erik Hugne7ae934b2014-07-01 10:22:40 +02001045 case TIPC_LOW_IMPORTANCE:
1046 case TIPC_MEDIUM_IMPORTANCE:
1047 case TIPC_HIGH_IMPORTANCE:
1048 case TIPC_CRITICAL_IMPORTANCE:
Jon Maloy75da2162017-10-13 11:04:23 +02001049 if (unlikely(msg_mcast(hdr))) {
Jon Paul Maloya853e4c2017-01-18 13:50:52 -05001050 skb_queue_tail(l->bc_rcvlink->inputq, skb);
1051 return true;
1052 }
Erik Hugne7ae934b2014-07-01 10:22:40 +02001053 case CONN_MANAGER:
Jon Maloy75da2162017-10-13 11:04:23 +02001054 case GROUP_PROTOCOL:
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001055 skb_queue_tail(inputq, skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001056 return true;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001057 case NAME_DISTRIBUTOR:
Jon Paul Maloy52666982015-10-22 08:51:41 -04001058 l->bc_rcvlink->state = LINK_ESTABLISHED;
1059 skb_queue_tail(l->namedq, skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001060 return true;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001061 case MSG_BUNDLER:
Jon Paul Maloydff29b12015-04-02 09:33:01 -04001062 case TUNNEL_PROTOCOL:
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001063 case MSG_FRAGMENTER:
1064 case BCAST_PROTOCOL:
1065 return false;
1066 default:
1067 pr_warn("Dropping received illegal msg type\n");
1068 kfree_skb(skb);
1069 return false;
1070 };
1071}
1072
1073/* tipc_link_input - process packet that has passed link protocol check
1074 *
1075 * Consumes buffer
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001076 */
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001077static int tipc_link_input(struct tipc_link *l, struct sk_buff *skb,
1078 struct sk_buff_head *inputq)
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001079{
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001080 struct tipc_msg *hdr = buf_msg(skb);
1081 struct sk_buff **reasm_skb = &l->reasm_buf;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001082 struct sk_buff *iskb;
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001083 struct sk_buff_head tmpq;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001084 int usr = msg_user(hdr);
Jon Paul Maloy6144a992015-07-30 18:24:16 -04001085 int rc = 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001086 int pos = 0;
1087 int ipos = 0;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001088
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001089 if (unlikely(usr == TUNNEL_PROTOCOL)) {
1090 if (msg_type(hdr) == SYNCH_MSG) {
1091 __skb_queue_purge(&l->deferdq);
1092 goto drop;
Jon Paul Maloy8b4ed862015-03-25 12:07:26 -04001093 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001094 if (!tipc_msg_extract(skb, &iskb, &ipos))
1095 return rc;
1096 kfree_skb(skb);
1097 skb = iskb;
1098 hdr = buf_msg(skb);
1099 if (less(msg_seqno(hdr), l->drop_point))
1100 goto drop;
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001101 if (tipc_data_input(l, skb, inputq))
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001102 return rc;
1103 usr = msg_user(hdr);
1104 reasm_skb = &l->failover_reasm_skb;
1105 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001106
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001107 if (usr == MSG_BUNDLER) {
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001108 skb_queue_head_init(&tmpq);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001109 l->stats.recv_bundles++;
1110 l->stats.recv_bundled += msg_msgcnt(hdr);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001111 while (tipc_msg_extract(skb, &iskb, &pos))
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001112 tipc_data_input(l, iskb, &tmpq);
1113 tipc_skb_queue_splice_tail(&tmpq, inputq);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001114 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001115 } else if (usr == MSG_FRAGMENTER) {
1116 l->stats.recv_fragments++;
1117 if (tipc_buf_append(reasm_skb, &skb)) {
1118 l->stats.recv_fragmented++;
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001119 tipc_data_input(l, skb, inputq);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001120 } else if (!*reasm_skb && !link_is_bc_rcvlink(l)) {
1121 pr_warn_ratelimited("Unable to build fragment list\n");
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001122 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001123 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001124 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001125 } else if (usr == BCAST_PROTOCOL) {
Jon Paul Maloyc72fa872015-10-22 08:51:46 -04001126 tipc_bcast_lock(l->net);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001127 tipc_link_bc_init_rcv(l->bc_rcvlink, hdr);
Jon Paul Maloyc72fa872015-10-22 08:51:46 -04001128 tipc_bcast_unlock(l->net);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001129 }
1130drop:
1131 kfree_skb(skb);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001132 return 0;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001133}
1134
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001135static bool tipc_link_release_pkts(struct tipc_link *l, u16 acked)
1136{
1137 bool released = false;
1138 struct sk_buff *skb, *tmp;
1139
1140 skb_queue_walk_safe(&l->transmq, skb, tmp) {
1141 if (more(buf_seqno(skb), acked))
1142 break;
1143 __skb_unlink(skb, &l->transmq);
1144 kfree_skb(skb);
1145 released = true;
1146 }
1147 return released;
1148}
1149
Jon Paul Maloy34b9cd62016-04-15 13:33:07 -04001150/* tipc_link_build_state_msg: prepare link state message for transmission
Jon Paul Maloy52666982015-10-22 08:51:41 -04001151 *
1152 * Note that sending of broadcast ack is coordinated among nodes, to reduce
1153 * risk of ack storms towards the sender
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001154 */
Jon Paul Maloy34b9cd62016-04-15 13:33:07 -04001155int tipc_link_build_state_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001156{
Jon Paul Maloy52666982015-10-22 08:51:41 -04001157 if (!l)
1158 return 0;
1159
1160 /* Broadcast ACK must be sent via a unicast link => defer to caller */
1161 if (link_is_bc_rcvlink(l)) {
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001162 if (((l->rcv_nxt ^ tipc_own_addr(l->net)) & 0xf) != 0xf)
Jon Paul Maloy52666982015-10-22 08:51:41 -04001163 return 0;
1164 l->rcv_unacked = 0;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001165
1166 /* Use snd_nxt to store peer's snd_nxt in broadcast rcv link */
1167 l->snd_nxt = l->rcv_nxt;
1168 return TIPC_LINK_SND_STATE;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001169 }
1170
1171 /* Unicast ACK */
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001172 l->rcv_unacked = 0;
1173 l->stats.sent_acks++;
1174 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, xmitq);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001175 return 0;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001176}
1177
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001178/* tipc_link_build_reset_msg: prepare link RESET or ACTIVATE message
1179 */
1180void tipc_link_build_reset_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
1181{
1182 int mtyp = RESET_MSG;
Jon Paul Maloy634696b2016-04-15 13:33:03 -04001183 struct sk_buff *skb;
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001184
1185 if (l->state == LINK_ESTABLISHING)
1186 mtyp = ACTIVATE_MSG;
1187
1188 tipc_link_build_proto_msg(l, mtyp, 0, 0, 0, 0, xmitq);
Jon Paul Maloy634696b2016-04-15 13:33:03 -04001189
1190 /* Inform peer that this endpoint is going down if applicable */
1191 skb = skb_peek_tail(xmitq);
1192 if (skb && (l->state == LINK_RESET))
1193 msg_set_peer_stopping(buf_msg(skb), 1);
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001194}
1195
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001196/* tipc_link_build_nack_msg: prepare link nack message for transmission
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001197 * Note that sending of broadcast NACK is coordinated among nodes, to
1198 * reduce the risk of NACK storms towards the sender
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001199 */
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001200static int tipc_link_build_nack_msg(struct tipc_link *l,
1201 struct sk_buff_head *xmitq)
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001202{
1203 u32 def_cnt = ++l->stats.deferred_recv;
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001204 int match1, match2;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001205
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001206 if (link_is_bc_rcvlink(l)) {
1207 match1 = def_cnt & 0xf;
1208 match2 = tipc_own_addr(l->net) & 0xf;
1209 if (match1 == match2)
1210 return TIPC_LINK_SND_STATE;
1211 return 0;
1212 }
Jon Paul Maloy52666982015-10-22 08:51:41 -04001213
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001214 if ((skb_queue_len(&l->deferdq) == 1) || !(def_cnt % TIPC_NACK_INTV))
1215 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, xmitq);
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001216 return 0;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001217}
1218
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001219/* tipc_link_rcv - process TIPC packets/messages arriving from off-node
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001220 * @l: the link that should handle the message
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001221 * @skb: TIPC packet
1222 * @xmitq: queue to place packets to be sent after this call
1223 */
1224int tipc_link_rcv(struct tipc_link *l, struct sk_buff *skb,
1225 struct sk_buff_head *xmitq)
1226{
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001227 struct sk_buff_head *defq = &l->deferdq;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001228 struct tipc_msg *hdr;
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001229 u16 seqno, rcv_nxt, win_lim;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001230 int rc = 0;
1231
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001232 do {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001233 hdr = buf_msg(skb);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001234 seqno = msg_seqno(hdr);
1235 rcv_nxt = l->rcv_nxt;
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001236 win_lim = rcv_nxt + TIPC_MAX_LINK_WIN;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001237
1238 /* Verify and update link state */
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001239 if (unlikely(msg_user(hdr) == LINK_PROTOCOL))
1240 return tipc_link_proto_rcv(l, skb, xmitq);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001241
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001242 if (unlikely(!link_is_up(l))) {
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001243 if (l->state == LINK_ESTABLISHING)
1244 rc = TIPC_LINK_UP_EVT;
1245 goto drop;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001246 }
1247
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001248 /* Don't send probe at next timeout expiration */
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001249 l->silent_intv_cnt = 0;
1250
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001251 /* Drop if outside receive window */
1252 if (unlikely(less(seqno, rcv_nxt) || more(seqno, win_lim))) {
1253 l->stats.duplicates++;
1254 goto drop;
1255 }
1256
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001257 /* Forward queues and wake up waiting users */
1258 if (likely(tipc_link_release_pkts(l, msg_ack(hdr)))) {
1259 tipc_link_advance_backlog(l, xmitq);
1260 if (unlikely(!skb_queue_empty(&l->wakeupq)))
1261 link_prepare_wakeup(l);
1262 }
1263
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001264 /* Defer delivery if sequence gap */
1265 if (unlikely(seqno != rcv_nxt)) {
Jon Paul Maloy8306f992015-10-15 14:52:43 -04001266 __tipc_skb_queue_sorted(defq, seqno, skb);
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001267 rc |= tipc_link_build_nack_msg(l, xmitq);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001268 break;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001269 }
1270
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001271 /* Deliver packet */
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001272 l->rcv_nxt++;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001273 l->stats.recv_pkts++;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001274 if (!tipc_data_input(l, skb, l->inputq))
Jon Paul Maloy52666982015-10-22 08:51:41 -04001275 rc |= tipc_link_input(l, skb, l->inputq);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001276 if (unlikely(++l->rcv_unacked >= TIPC_MIN_LINK_WIN))
Jon Paul Maloy34b9cd62016-04-15 13:33:07 -04001277 rc |= tipc_link_build_state_msg(l, xmitq);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001278 if (unlikely(rc & ~TIPC_LINK_SND_STATE))
Jon Paul Maloy52666982015-10-22 08:51:41 -04001279 break;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001280 } while ((skb = __skb_dequeue(defq)));
1281
1282 return rc;
1283drop:
1284 kfree_skb(skb);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001285 return rc;
1286}
1287
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001288static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
1289 u16 rcvgap, int tolerance, int priority,
1290 struct sk_buff_head *xmitq)
1291{
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001292 struct tipc_link *bcl = l->bc_rcvlink;
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001293 struct sk_buff *skb;
1294 struct tipc_msg *hdr;
1295 struct sk_buff_head *dfq = &l->deferdq;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001296 bool node_up = link_is_up(bcl);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001297 struct tipc_mon_state *mstate = &l->mon_state;
1298 int dlen = 0;
1299 void *data;
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001300
1301 /* Don't send protocol message during reset or link failover */
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001302 if (tipc_link_is_blocked(l))
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001303 return;
1304
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001305 if (!tipc_link_is_up(l) && (mtyp == STATE_MSG))
1306 return;
1307
1308 if (!skb_queue_empty(dfq))
1309 rcvgap = buf_seqno(skb_peek(dfq)) - l->rcv_nxt;
1310
1311 skb = tipc_msg_create(LINK_PROTOCOL, mtyp, INT_H_SIZE,
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001312 tipc_max_domain_size, l->addr,
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001313 tipc_own_addr(l->net), 0, 0, 0);
1314 if (!skb)
1315 return;
1316
1317 hdr = buf_msg(skb);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001318 data = msg_data(hdr);
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001319 msg_set_session(hdr, l->session);
1320 msg_set_bearer_id(hdr, l->bearer_id);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001321 msg_set_net_plane(hdr, l->net_plane);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001322 msg_set_next_sent(hdr, l->snd_nxt);
1323 msg_set_ack(hdr, l->rcv_nxt - 1);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001324 msg_set_bcast_ack(hdr, bcl->rcv_nxt - 1);
Jon Paul Maloy06bd2b12016-10-27 18:51:55 -04001325 msg_set_bc_ack_invalid(hdr, !node_up);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001326 msg_set_last_bcast(hdr, l->bc_sndlink->snd_nxt - 1);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001327 msg_set_link_tolerance(hdr, tolerance);
1328 msg_set_linkprio(hdr, priority);
1329 msg_set_redundant_link(hdr, node_up);
1330 msg_set_seq_gap(hdr, 0);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001331 msg_set_seqno(hdr, l->snd_nxt + U16_MAX / 2);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001332
1333 if (mtyp == STATE_MSG) {
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001334 msg_set_seq_gap(hdr, rcvgap);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001335 msg_set_bc_gap(hdr, link_bc_rcv_gap(bcl));
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001336 msg_set_probe(hdr, probe);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001337 tipc_mon_prep(l->net, data, &dlen, mstate, l->bearer_id);
1338 msg_set_size(hdr, INT_H_SIZE + dlen);
1339 skb_trim(skb, INT_H_SIZE + dlen);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001340 l->stats.sent_states++;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001341 l->rcv_unacked = 0;
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001342 } else {
1343 /* RESET_MSG or ACTIVATE_MSG */
1344 msg_set_max_pkt(hdr, l->advertised_mtu);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001345 strcpy(data, l->if_name);
1346 msg_set_size(hdr, INT_H_SIZE + TIPC_MAX_IF_NAME);
1347 skb_trim(skb, INT_H_SIZE + TIPC_MAX_IF_NAME);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001348 }
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001349 if (probe)
1350 l->stats.sent_probes++;
1351 if (rcvgap)
1352 l->stats.sent_nacks++;
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001353 skb->priority = TC_PRIO_CONTROL;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001354 __skb_queue_tail(xmitq, skb);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001355}
Per Lidenb97bf3f2006-01-02 19:04:38 +01001356
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001357/* tipc_link_tnl_prepare(): prepare and return a list of tunnel packets
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001358 * with contents of the link's transmit and backlog queues.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001359 */
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001360void tipc_link_tnl_prepare(struct tipc_link *l, struct tipc_link *tnl,
1361 int mtyp, struct sk_buff_head *xmitq)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001362{
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001363 struct sk_buff *skb, *tnlskb;
1364 struct tipc_msg *hdr, tnlhdr;
1365 struct sk_buff_head *queue = &l->transmq;
1366 struct sk_buff_head tmpxq, tnlq;
1367 u16 pktlen, pktcnt, seqno = l->snd_nxt;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001368
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001369 if (!tnl)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001370 return;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001371
1372 skb_queue_head_init(&tnlq);
1373 skb_queue_head_init(&tmpxq);
1374
1375 /* At least one packet required for safe algorithm => add dummy */
1376 skb = tipc_msg_create(TIPC_LOW_IMPORTANCE, TIPC_DIRECT_MSG,
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001377 BASIC_H_SIZE, 0, l->addr, tipc_own_addr(l->net),
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001378 0, 0, TIPC_ERR_NO_PORT);
Ying Xuea6ca1092014-11-26 11:41:55 +08001379 if (!skb) {
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001380 pr_warn("%sunable to create tunnel packet\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001381 return;
Allan Stephens5392d642006-06-25 23:52:50 -07001382 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001383 skb_queue_tail(&tnlq, skb);
1384 tipc_link_xmit(l, &tnlq, &tmpxq);
1385 __skb_queue_purge(&tmpxq);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001386
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001387 /* Initialize reusable tunnel packet header */
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001388 tipc_msg_init(tipc_own_addr(l->net), &tnlhdr, TUNNEL_PROTOCOL,
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001389 mtyp, INT_H_SIZE, l->addr);
1390 pktcnt = skb_queue_len(&l->transmq) + skb_queue_len(&l->backlogq);
1391 msg_set_msgcnt(&tnlhdr, pktcnt);
1392 msg_set_bearer_id(&tnlhdr, l->peer_bearer_id);
1393tnl:
1394 /* Wrap each packet into a tunnel packet */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -04001395 skb_queue_walk(queue, skb) {
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001396 hdr = buf_msg(skb);
1397 if (queue == &l->backlogq)
1398 msg_set_seqno(hdr, seqno++);
1399 pktlen = msg_size(hdr);
1400 msg_set_size(&tnlhdr, pktlen + INT_H_SIZE);
Parthasarathy Bhuvaragan57d5f642017-01-13 15:46:25 +01001401 tnlskb = tipc_buf_acquire(pktlen + INT_H_SIZE, GFP_ATOMIC);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001402 if (!tnlskb) {
1403 pr_warn("%sunable to send packet\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001404 return;
1405 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001406 skb_copy_to_linear_data(tnlskb, &tnlhdr, INT_H_SIZE);
1407 skb_copy_to_linear_data_offset(tnlskb, INT_H_SIZE, hdr, pktlen);
1408 __skb_queue_tail(&tnlq, tnlskb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001409 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001410 if (queue != &l->backlogq) {
1411 queue = &l->backlogq;
1412 goto tnl;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -04001413 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001414
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001415 tipc_link_xmit(tnl, &tnlq, xmitq);
Jon Paul Maloyf006c9c2014-02-13 17:29:11 -05001416
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001417 if (mtyp == FAILOVER_MSG) {
1418 tnl->drop_point = l->rcv_nxt;
1419 tnl->failover_reasm_skb = l->reasm_buf;
1420 l->reasm_buf = NULL;
Jon Paul Maloyf006c9c2014-02-13 17:29:11 -05001421 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01001422}
1423
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001424/* tipc_link_proto_rcv(): receive link level protocol message :
1425 * Note that network plane id propagates through the network, and may
1426 * change at any time. The node with lowest numerical id determines
1427 * network plane
1428 */
1429static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
1430 struct sk_buff_head *xmitq)
1431{
1432 struct tipc_msg *hdr = buf_msg(skb);
1433 u16 rcvgap = 0;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001434 u16 ack = msg_ack(hdr);
1435 u16 gap = msg_seq_gap(hdr);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001436 u16 peers_snd_nxt = msg_next_sent(hdr);
1437 u16 peers_tol = msg_link_tolerance(hdr);
1438 u16 peers_prio = msg_linkprio(hdr);
Jon Paul Maloy2be80c22015-08-20 02:12:56 -04001439 u16 rcv_nxt = l->rcv_nxt;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001440 u16 dlen = msg_data_sz(hdr);
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001441 int mtyp = msg_type(hdr);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001442 void *data;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001443 char *if_name;
1444 int rc = 0;
1445
Jon Paul Maloy52666982015-10-22 08:51:41 -04001446 if (tipc_link_is_blocked(l) || !xmitq)
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001447 goto exit;
1448
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001449 if (tipc_own_addr(l->net) > msg_prevnode(hdr))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001450 l->net_plane = msg_net_plane(hdr);
1451
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001452 skb_linearize(skb);
1453 hdr = buf_msg(skb);
1454 data = msg_data(hdr);
1455
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001456 switch (mtyp) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001457 case RESET_MSG:
1458
1459 /* Ignore duplicate RESET with old session number */
1460 if ((less_eq(msg_session(hdr), l->peer_session)) &&
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001461 (l->peer_session != ANY_SESSION))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001462 break;
1463 /* fall thru' */
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001464
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001465 case ACTIVATE_MSG:
1466
1467 /* Complete own link name with peer's interface name */
1468 if_name = strrchr(l->name, ':') + 1;
1469 if (sizeof(l->name) - (if_name - l->name) <= TIPC_MAX_IF_NAME)
1470 break;
1471 if (msg_data_sz(hdr) < TIPC_MAX_IF_NAME)
1472 break;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001473 strncpy(if_name, data, TIPC_MAX_IF_NAME);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001474
1475 /* Update own tolerance if peer indicates a non-zero value */
1476 if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL))
1477 l->tolerance = peers_tol;
1478
1479 /* Update own priority if peer's priority is higher */
1480 if (in_range(peers_prio, l->priority + 1, TIPC_MAX_LINK_PRI))
1481 l->priority = peers_prio;
1482
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001483 /* ACTIVATE_MSG serves as PEER_RESET if link is already down */
Jon Paul Maloy634696b2016-04-15 13:33:03 -04001484 if (msg_peer_stopping(hdr))
1485 rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
1486 else if ((mtyp == RESET_MSG) || !link_is_up(l))
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001487 rc = tipc_link_fsm_evt(l, LINK_PEER_RESET_EVT);
1488
1489 /* ACTIVATE_MSG takes up link if it was already locally reset */
1490 if ((mtyp == ACTIVATE_MSG) && (l->state == LINK_ESTABLISHING))
1491 rc = TIPC_LINK_UP_EVT;
1492
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001493 l->peer_session = msg_session(hdr);
1494 l->peer_bearer_id = msg_bearer_id(hdr);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001495 if (l->mtu > msg_max_pkt(hdr))
1496 l->mtu = msg_max_pkt(hdr);
1497 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001498
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001499 case STATE_MSG:
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001500
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001501 /* Update own tolerance if peer indicates a non-zero value */
1502 if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL))
1503 l->tolerance = peers_tol;
1504
Jon Paul Maloyf7967552016-11-23 21:05:26 -05001505 /* Update own prio if peer indicates a different value */
1506 if ((peers_prio != l->priority) &&
1507 in_range(peers_prio, 1, TIPC_MAX_LINK_PRI)) {
Richard Alpe81729812016-02-01 08:19:57 +01001508 l->priority = peers_prio;
1509 rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
1510 }
1511
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001512 l->silent_intv_cnt = 0;
1513 l->stats.recv_states++;
1514 if (msg_probe(hdr))
1515 l->stats.recv_probes++;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001516
1517 if (!link_is_up(l)) {
1518 if (l->state == LINK_ESTABLISHING)
1519 rc = TIPC_LINK_UP_EVT;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001520 break;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001521 }
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001522 tipc_mon_rcv(l->net, data, dlen, l->addr,
1523 &l->mon_state, l->bearer_id);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001524
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001525 /* Send NACK if peer has sent pkts we haven't received yet */
Jon Paul Maloy2be80c22015-08-20 02:12:56 -04001526 if (more(peers_snd_nxt, rcv_nxt) && !tipc_link_is_synching(l))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001527 rcvgap = peers_snd_nxt - l->rcv_nxt;
1528 if (rcvgap || (msg_probe(hdr)))
1529 tipc_link_build_proto_msg(l, STATE_MSG, 0, rcvgap,
Jon Paul Maloy16040892015-07-21 06:42:28 -04001530 0, 0, xmitq);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001531 tipc_link_release_pkts(l, ack);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001532
1533 /* If NACK, retransmit will now start at right position */
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001534 if (gap) {
Jon Paul Maloy40501f92017-08-21 17:59:30 +02001535 rc = tipc_link_retrans(l, l, ack + 1, ack + gap, xmitq);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001536 l->stats.recv_nacks++;
1537 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001538
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001539 tipc_link_advance_backlog(l, xmitq);
1540 if (unlikely(!skb_queue_empty(&l->wakeupq)))
1541 link_prepare_wakeup(l);
1542 }
1543exit:
1544 kfree_skb(skb);
1545 return rc;
1546}
1547
Jon Paul Maloy52666982015-10-22 08:51:41 -04001548/* tipc_link_build_bc_proto_msg() - create broadcast protocol message
1549 */
1550static bool tipc_link_build_bc_proto_msg(struct tipc_link *l, bool bcast,
1551 u16 peers_snd_nxt,
1552 struct sk_buff_head *xmitq)
1553{
1554 struct sk_buff *skb;
1555 struct tipc_msg *hdr;
1556 struct sk_buff *dfrd_skb = skb_peek(&l->deferdq);
1557 u16 ack = l->rcv_nxt - 1;
1558 u16 gap_to = peers_snd_nxt - 1;
1559
1560 skb = tipc_msg_create(BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE,
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001561 0, l->addr, tipc_own_addr(l->net), 0, 0, 0);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001562 if (!skb)
1563 return false;
1564 hdr = buf_msg(skb);
1565 msg_set_last_bcast(hdr, l->bc_sndlink->snd_nxt - 1);
1566 msg_set_bcast_ack(hdr, ack);
1567 msg_set_bcgap_after(hdr, ack);
1568 if (dfrd_skb)
1569 gap_to = buf_seqno(dfrd_skb) - 1;
1570 msg_set_bcgap_to(hdr, gap_to);
1571 msg_set_non_seq(hdr, bcast);
1572 __skb_queue_tail(xmitq, skb);
1573 return true;
1574}
1575
1576/* tipc_link_build_bc_init_msg() - synchronize broadcast link endpoints.
1577 *
1578 * Give a newly added peer node the sequence number where it should
1579 * start receiving and acking broadcast packets.
1580 */
Wu Fengguang742e0382015-10-24 22:56:01 +08001581static void tipc_link_build_bc_init_msg(struct tipc_link *l,
1582 struct sk_buff_head *xmitq)
Jon Paul Maloy52666982015-10-22 08:51:41 -04001583{
1584 struct sk_buff_head list;
1585
1586 __skb_queue_head_init(&list);
1587 if (!tipc_link_build_bc_proto_msg(l->bc_rcvlink, false, 0, &list))
1588 return;
Jon Paul Maloy06bd2b12016-10-27 18:51:55 -04001589 msg_set_bc_ack_invalid(buf_msg(skb_peek(&list)), true);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001590 tipc_link_xmit(l, &list, xmitq);
1591}
1592
1593/* tipc_link_bc_init_rcv - receive initial broadcast synch data from peer
1594 */
1595void tipc_link_bc_init_rcv(struct tipc_link *l, struct tipc_msg *hdr)
1596{
1597 int mtyp = msg_type(hdr);
1598 u16 peers_snd_nxt = msg_bc_snd_nxt(hdr);
1599
1600 if (link_is_up(l))
1601 return;
1602
1603 if (msg_user(hdr) == BCAST_PROTOCOL) {
1604 l->rcv_nxt = peers_snd_nxt;
1605 l->state = LINK_ESTABLISHED;
1606 return;
1607 }
1608
1609 if (l->peer_caps & TIPC_BCAST_SYNCH)
1610 return;
1611
1612 if (msg_peer_node_is_up(hdr))
1613 return;
1614
1615 /* Compatibility: accept older, less safe initial synch data */
1616 if ((mtyp == RESET_MSG) || (mtyp == ACTIVATE_MSG))
1617 l->rcv_nxt = peers_snd_nxt;
1618}
1619
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -04001620/* link_bc_retr eval()- check if the indicated range can be retransmitted now
1621 * - Adjust permitted range if there is overlap with previous retransmission
1622 */
1623static bool link_bc_retr_eval(struct tipc_link *l, u16 *from, u16 *to)
1624{
1625 unsigned long elapsed = jiffies_to_msecs(jiffies - l->prev_retr);
1626
1627 if (less(*to, *from))
1628 return false;
1629
1630 /* New retransmission request */
1631 if ((elapsed > TIPC_BC_RETR_LIMIT) ||
1632 less(*to, l->prev_from) || more(*from, l->prev_to)) {
1633 l->prev_from = *from;
1634 l->prev_to = *to;
1635 l->prev_retr = jiffies;
1636 return true;
1637 }
1638
1639 /* Inside range of previous retransmit */
1640 if (!less(*from, l->prev_from) && !more(*to, l->prev_to))
1641 return false;
1642
1643 /* Fully or partially outside previous range => exclude overlap */
1644 if (less(*from, l->prev_from)) {
1645 *to = l->prev_from - 1;
1646 l->prev_from = *from;
1647 }
1648 if (more(*to, l->prev_to)) {
1649 *from = l->prev_to + 1;
1650 l->prev_to = *to;
1651 }
1652 l->prev_retr = jiffies;
1653 return true;
1654}
1655
Jon Paul Maloy52666982015-10-22 08:51:41 -04001656/* tipc_link_bc_sync_rcv - update rcv link according to peer's send state
1657 */
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001658int tipc_link_bc_sync_rcv(struct tipc_link *l, struct tipc_msg *hdr,
1659 struct sk_buff_head *xmitq)
Jon Paul Maloy52666982015-10-22 08:51:41 -04001660{
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -04001661 struct tipc_link *snd_l = l->bc_sndlink;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001662 u16 peers_snd_nxt = msg_bc_snd_nxt(hdr);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001663 u16 from = msg_bcast_ack(hdr) + 1;
1664 u16 to = from + msg_bc_gap(hdr) - 1;
1665 int rc = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001666
1667 if (!link_is_up(l))
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001668 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001669
1670 if (!msg_peer_node_is_up(hdr))
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001671 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001672
Jon Paul Maloy2d18ac42016-07-11 16:08:35 -04001673 /* Open when peer ackowledges our bcast init msg (pkt #1) */
1674 if (msg_ack(hdr))
1675 l->bc_peer_is_up = true;
1676
1677 if (!l->bc_peer_is_up)
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001678 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001679
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -04001680 l->stats.recv_nacks++;
1681
Jon Paul Maloy52666982015-10-22 08:51:41 -04001682 /* Ignore if peers_snd_nxt goes beyond receive window */
1683 if (more(peers_snd_nxt, l->rcv_nxt + l->window))
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001684 return rc;
1685
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -04001686 if (link_bc_retr_eval(snd_l, &from, &to))
Jon Paul Maloy40501f92017-08-21 17:59:30 +02001687 rc = tipc_link_retrans(snd_l, l, from, to, xmitq);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001688
1689 l->snd_nxt = peers_snd_nxt;
1690 if (link_bc_rcv_gap(l))
1691 rc |= TIPC_LINK_SND_STATE;
1692
1693 /* Return now if sender supports nack via STATE messages */
1694 if (l->peer_caps & TIPC_BCAST_STATE_NACK)
1695 return rc;
1696
1697 /* Otherwise, be backwards compatible */
Jon Paul Maloy52666982015-10-22 08:51:41 -04001698
1699 if (!more(peers_snd_nxt, l->rcv_nxt)) {
1700 l->nack_state = BC_NACK_SND_CONDITIONAL;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001701 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001702 }
1703
1704 /* Don't NACK if one was recently sent or peeked */
1705 if (l->nack_state == BC_NACK_SND_SUPPRESS) {
1706 l->nack_state = BC_NACK_SND_UNCONDITIONAL;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001707 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001708 }
1709
1710 /* Conditionally delay NACK sending until next synch rcv */
1711 if (l->nack_state == BC_NACK_SND_CONDITIONAL) {
1712 l->nack_state = BC_NACK_SND_UNCONDITIONAL;
1713 if ((peers_snd_nxt - l->rcv_nxt) < TIPC_MIN_LINK_WIN)
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001714 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001715 }
1716
1717 /* Send NACK now but suppress next one */
1718 tipc_link_build_bc_proto_msg(l, true, peers_snd_nxt, xmitq);
1719 l->nack_state = BC_NACK_SND_SUPPRESS;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001720 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001721}
1722
1723void tipc_link_bc_ack_rcv(struct tipc_link *l, u16 acked,
1724 struct sk_buff_head *xmitq)
1725{
1726 struct sk_buff *skb, *tmp;
1727 struct tipc_link *snd_l = l->bc_sndlink;
1728
1729 if (!link_is_up(l) || !l->bc_peer_is_up)
1730 return;
1731
1732 if (!more(acked, l->acked))
1733 return;
1734
1735 /* Skip over packets peer has already acked */
1736 skb_queue_walk(&snd_l->transmq, skb) {
1737 if (more(buf_seqno(skb), l->acked))
1738 break;
1739 }
1740
1741 /* Update/release the packets peer is acking now */
1742 skb_queue_walk_from_safe(&snd_l->transmq, skb, tmp) {
1743 if (more(buf_seqno(skb), acked))
1744 break;
1745 if (!--TIPC_SKB_CB(skb)->ackers) {
1746 __skb_unlink(skb, &snd_l->transmq);
1747 kfree_skb(skb);
1748 }
1749 }
1750 l->acked = acked;
1751 tipc_link_advance_backlog(snd_l, xmitq);
1752 if (unlikely(!skb_queue_empty(&snd_l->wakeupq)))
1753 link_prepare_wakeup(snd_l);
1754}
1755
1756/* tipc_link_bc_nack_rcv(): receive broadcast nack message
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001757 * This function is here for backwards compatibility, since
1758 * no BCAST_PROTOCOL/STATE messages occur from TIPC v2.5.
Jon Paul Maloy52666982015-10-22 08:51:41 -04001759 */
1760int tipc_link_bc_nack_rcv(struct tipc_link *l, struct sk_buff *skb,
1761 struct sk_buff_head *xmitq)
1762{
1763 struct tipc_msg *hdr = buf_msg(skb);
1764 u32 dnode = msg_destnode(hdr);
1765 int mtyp = msg_type(hdr);
1766 u16 acked = msg_bcast_ack(hdr);
1767 u16 from = acked + 1;
1768 u16 to = msg_bcgap_to(hdr);
1769 u16 peers_snd_nxt = to + 1;
1770 int rc = 0;
1771
1772 kfree_skb(skb);
1773
1774 if (!tipc_link_is_up(l) || !l->bc_peer_is_up)
1775 return 0;
1776
1777 if (mtyp != STATE_MSG)
1778 return 0;
1779
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001780 if (dnode == tipc_own_addr(l->net)) {
Jon Paul Maloy52666982015-10-22 08:51:41 -04001781 tipc_link_bc_ack_rcv(l, acked, xmitq);
Jon Paul Maloy40501f92017-08-21 17:59:30 +02001782 rc = tipc_link_retrans(l->bc_sndlink, l, from, to, xmitq);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001783 l->stats.recv_nacks++;
1784 return rc;
1785 }
1786
1787 /* Msg for other node => suppress own NACK at next sync if applicable */
1788 if (more(peers_snd_nxt, l->rcv_nxt) && !less(l->rcv_nxt, from))
1789 l->nack_state = BC_NACK_SND_SUPPRESS;
1790
1791 return 0;
1792}
1793
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -04001794void tipc_link_set_queue_limits(struct tipc_link *l, u32 win)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001795{
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001796 int max_bulk = TIPC_MAX_PUBLICATIONS / (l->mtu / ITEM_SIZE);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -04001797
Jon Paul Maloye3eea1e2015-03-13 16:08:11 -04001798 l->window = win;
Jon Paul Maloy5a0950c2016-08-16 11:53:51 -04001799 l->backlog[TIPC_LOW_IMPORTANCE].limit = max_t(u16, 50, win);
1800 l->backlog[TIPC_MEDIUM_IMPORTANCE].limit = max_t(u16, 100, win * 2);
1801 l->backlog[TIPC_HIGH_IMPORTANCE].limit = max_t(u16, 150, win * 3);
1802 l->backlog[TIPC_CRITICAL_IMPORTANCE].limit = max_t(u16, 200, win * 4);
Jon Paul Maloy1f66d162015-03-25 12:07:24 -04001803 l->backlog[TIPC_SYSTEM_IMPORTANCE].limit = max_bulk;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001804}
1805
Allan Stephens5c216e12011-10-18 11:34:29 -04001806/**
Jon Paul Maloy38206d52015-11-19 14:30:46 -05001807 * link_reset_stats - reset link statistics
Jon Paul Maloy1a906322015-11-19 14:30:47 -05001808 * @l: pointer to link
Per Lidenb97bf3f2006-01-02 19:04:38 +01001809 */
Jon Paul Maloy38206d52015-11-19 14:30:46 -05001810void tipc_link_reset_stats(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001811{
Jon Paul Maloy38206d52015-11-19 14:30:46 -05001812 memset(&l->stats, 0, sizeof(l->stats));
Per Lidenb97bf3f2006-01-02 19:04:38 +01001813}
1814
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001815static void link_print(struct tipc_link *l, const char *str)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001816{
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001817 struct sk_buff *hskb = skb_peek(&l->transmq);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001818 u16 head = hskb ? msg_seqno(buf_msg(hskb)) : l->snd_nxt - 1;
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001819 u16 tail = l->snd_nxt - 1;
Ying Xue7a2f7d12014-04-21 10:55:46 +08001820
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001821 pr_info("%s Link <%s> state %x\n", str, l->name, l->state);
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04001822 pr_info("XMTQ: %u [%u-%u], BKLGQ: %u, SNDNX: %u, RCVNX: %u\n",
1823 skb_queue_len(&l->transmq), head, tail,
1824 skb_queue_len(&l->backlogq), l->snd_nxt, l->rcv_nxt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001825}
Richard Alpe0655f6a2014-11-20 10:29:07 +01001826
1827/* Parse and validate nested (link) properties valid for media, bearer and link
1828 */
1829int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[])
1830{
1831 int err;
1832
1833 err = nla_parse_nested(props, TIPC_NLA_PROP_MAX, prop,
Johannes Bergfceb6432017-04-12 14:34:07 +02001834 tipc_nl_prop_policy, NULL);
Richard Alpe0655f6a2014-11-20 10:29:07 +01001835 if (err)
1836 return err;
1837
1838 if (props[TIPC_NLA_PROP_PRIO]) {
1839 u32 prio;
1840
1841 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1842 if (prio > TIPC_MAX_LINK_PRI)
1843 return -EINVAL;
1844 }
1845
1846 if (props[TIPC_NLA_PROP_TOL]) {
1847 u32 tol;
1848
1849 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1850 if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
1851 return -EINVAL;
1852 }
1853
1854 if (props[TIPC_NLA_PROP_WIN]) {
1855 u32 win;
1856
1857 win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1858 if ((win < TIPC_MIN_LINK_WIN) || (win > TIPC_MAX_LINK_WIN))
1859 return -EINVAL;
1860 }
1861
1862 return 0;
1863}
Richard Alpe7be57fc2014-11-20 10:29:12 +01001864
Richard Alped8182802014-11-24 11:10:29 +01001865static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001866{
1867 int i;
1868 struct nlattr *stats;
1869
1870 struct nla_map {
1871 u32 key;
1872 u32 val;
1873 };
1874
1875 struct nla_map map[] = {
Jon Paul Maloy95901122016-11-25 10:35:02 -05001876 {TIPC_NLA_STATS_RX_INFO, 0},
Richard Alpe7be57fc2014-11-20 10:29:12 +01001877 {TIPC_NLA_STATS_RX_FRAGMENTS, s->recv_fragments},
1878 {TIPC_NLA_STATS_RX_FRAGMENTED, s->recv_fragmented},
1879 {TIPC_NLA_STATS_RX_BUNDLES, s->recv_bundles},
1880 {TIPC_NLA_STATS_RX_BUNDLED, s->recv_bundled},
Jon Paul Maloy95901122016-11-25 10:35:02 -05001881 {TIPC_NLA_STATS_TX_INFO, 0},
Richard Alpe7be57fc2014-11-20 10:29:12 +01001882 {TIPC_NLA_STATS_TX_FRAGMENTS, s->sent_fragments},
1883 {TIPC_NLA_STATS_TX_FRAGMENTED, s->sent_fragmented},
1884 {TIPC_NLA_STATS_TX_BUNDLES, s->sent_bundles},
1885 {TIPC_NLA_STATS_TX_BUNDLED, s->sent_bundled},
1886 {TIPC_NLA_STATS_MSG_PROF_TOT, (s->msg_length_counts) ?
1887 s->msg_length_counts : 1},
1888 {TIPC_NLA_STATS_MSG_LEN_CNT, s->msg_length_counts},
1889 {TIPC_NLA_STATS_MSG_LEN_TOT, s->msg_lengths_total},
1890 {TIPC_NLA_STATS_MSG_LEN_P0, s->msg_length_profile[0]},
1891 {TIPC_NLA_STATS_MSG_LEN_P1, s->msg_length_profile[1]},
1892 {TIPC_NLA_STATS_MSG_LEN_P2, s->msg_length_profile[2]},
1893 {TIPC_NLA_STATS_MSG_LEN_P3, s->msg_length_profile[3]},
1894 {TIPC_NLA_STATS_MSG_LEN_P4, s->msg_length_profile[4]},
1895 {TIPC_NLA_STATS_MSG_LEN_P5, s->msg_length_profile[5]},
1896 {TIPC_NLA_STATS_MSG_LEN_P6, s->msg_length_profile[6]},
1897 {TIPC_NLA_STATS_RX_STATES, s->recv_states},
1898 {TIPC_NLA_STATS_RX_PROBES, s->recv_probes},
1899 {TIPC_NLA_STATS_RX_NACKS, s->recv_nacks},
1900 {TIPC_NLA_STATS_RX_DEFERRED, s->deferred_recv},
1901 {TIPC_NLA_STATS_TX_STATES, s->sent_states},
1902 {TIPC_NLA_STATS_TX_PROBES, s->sent_probes},
1903 {TIPC_NLA_STATS_TX_NACKS, s->sent_nacks},
1904 {TIPC_NLA_STATS_TX_ACKS, s->sent_acks},
1905 {TIPC_NLA_STATS_RETRANSMITTED, s->retransmitted},
1906 {TIPC_NLA_STATS_DUPLICATES, s->duplicates},
1907 {TIPC_NLA_STATS_LINK_CONGS, s->link_congs},
1908 {TIPC_NLA_STATS_MAX_QUEUE, s->max_queue_sz},
1909 {TIPC_NLA_STATS_AVG_QUEUE, s->queue_sz_counts ?
1910 (s->accu_queue_sz / s->queue_sz_counts) : 0}
1911 };
1912
1913 stats = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
1914 if (!stats)
1915 return -EMSGSIZE;
1916
1917 for (i = 0; i < ARRAY_SIZE(map); i++)
1918 if (nla_put_u32(skb, map[i].key, map[i].val))
1919 goto msg_full;
1920
1921 nla_nest_end(skb, stats);
1922
1923 return 0;
1924msg_full:
1925 nla_nest_cancel(skb, stats);
1926
1927 return -EMSGSIZE;
1928}
1929
1930/* Caller should hold appropriate locks to protect the link */
Jon Paul Maloy5be9c082015-11-19 14:30:45 -05001931int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
1932 struct tipc_link *link, int nlflags)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001933{
1934 int err;
1935 void *hdr;
1936 struct nlattr *attrs;
1937 struct nlattr *prop;
Ying Xue34747532015-01-09 15:27:10 +08001938 struct tipc_net *tn = net_generic(net, tipc_net_id);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001939
Richard Alpebfb3e5d2015-02-09 09:50:03 +01001940 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
Nicolas Dichtelf2f67392015-04-28 18:33:50 +02001941 nlflags, TIPC_NL_LINK_GET);
Richard Alpe7be57fc2014-11-20 10:29:12 +01001942 if (!hdr)
1943 return -EMSGSIZE;
1944
1945 attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
1946 if (!attrs)
1947 goto msg_full;
1948
1949 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, link->name))
1950 goto attr_msg_full;
1951 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST,
Ying Xue34747532015-01-09 15:27:10 +08001952 tipc_cluster_mask(tn->own_addr)))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001953 goto attr_msg_full;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04001954 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->mtu))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001955 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001956 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, link->stats.recv_pkts))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001957 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001958 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, link->stats.sent_pkts))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001959 goto attr_msg_full;
1960
1961 if (tipc_link_is_up(link))
1962 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
1963 goto attr_msg_full;
Jon Paul Maloyc72fa872015-10-22 08:51:46 -04001964 if (link->active)
Richard Alpe7be57fc2014-11-20 10:29:12 +01001965 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_ACTIVE))
1966 goto attr_msg_full;
1967
1968 prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
1969 if (!prop)
1970 goto attr_msg_full;
1971 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
1972 goto prop_msg_full;
1973 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, link->tolerance))
1974 goto prop_msg_full;
1975 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN,
Jon Paul Maloy1f66d162015-03-25 12:07:24 -04001976 link->window))
Richard Alpe7be57fc2014-11-20 10:29:12 +01001977 goto prop_msg_full;
1978 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
1979 goto prop_msg_full;
1980 nla_nest_end(msg->skb, prop);
1981
1982 err = __tipc_nl_add_stats(msg->skb, &link->stats);
1983 if (err)
1984 goto attr_msg_full;
1985
1986 nla_nest_end(msg->skb, attrs);
1987 genlmsg_end(msg->skb, hdr);
1988
1989 return 0;
1990
1991prop_msg_full:
1992 nla_nest_cancel(msg->skb, prop);
1993attr_msg_full:
1994 nla_nest_cancel(msg->skb, attrs);
1995msg_full:
1996 genlmsg_cancel(msg->skb, hdr);
1997
1998 return -EMSGSIZE;
1999}
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002000
2001static int __tipc_nl_add_bc_link_stat(struct sk_buff *skb,
2002 struct tipc_stats *stats)
2003{
2004 int i;
2005 struct nlattr *nest;
2006
2007 struct nla_map {
2008 __u32 key;
2009 __u32 val;
2010 };
2011
2012 struct nla_map map[] = {
Jon Paul Maloy95901122016-11-25 10:35:02 -05002013 {TIPC_NLA_STATS_RX_INFO, stats->recv_pkts},
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002014 {TIPC_NLA_STATS_RX_FRAGMENTS, stats->recv_fragments},
2015 {TIPC_NLA_STATS_RX_FRAGMENTED, stats->recv_fragmented},
2016 {TIPC_NLA_STATS_RX_BUNDLES, stats->recv_bundles},
2017 {TIPC_NLA_STATS_RX_BUNDLED, stats->recv_bundled},
Jon Paul Maloy95901122016-11-25 10:35:02 -05002018 {TIPC_NLA_STATS_TX_INFO, stats->sent_pkts},
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002019 {TIPC_NLA_STATS_TX_FRAGMENTS, stats->sent_fragments},
2020 {TIPC_NLA_STATS_TX_FRAGMENTED, stats->sent_fragmented},
2021 {TIPC_NLA_STATS_TX_BUNDLES, stats->sent_bundles},
2022 {TIPC_NLA_STATS_TX_BUNDLED, stats->sent_bundled},
2023 {TIPC_NLA_STATS_RX_NACKS, stats->recv_nacks},
2024 {TIPC_NLA_STATS_RX_DEFERRED, stats->deferred_recv},
2025 {TIPC_NLA_STATS_TX_NACKS, stats->sent_nacks},
2026 {TIPC_NLA_STATS_TX_ACKS, stats->sent_acks},
2027 {TIPC_NLA_STATS_RETRANSMITTED, stats->retransmitted},
2028 {TIPC_NLA_STATS_DUPLICATES, stats->duplicates},
2029 {TIPC_NLA_STATS_LINK_CONGS, stats->link_congs},
2030 {TIPC_NLA_STATS_MAX_QUEUE, stats->max_queue_sz},
2031 {TIPC_NLA_STATS_AVG_QUEUE, stats->queue_sz_counts ?
2032 (stats->accu_queue_sz / stats->queue_sz_counts) : 0}
2033 };
2034
2035 nest = nla_nest_start(skb, TIPC_NLA_LINK_STATS);
2036 if (!nest)
2037 return -EMSGSIZE;
2038
2039 for (i = 0; i < ARRAY_SIZE(map); i++)
2040 if (nla_put_u32(skb, map[i].key, map[i].val))
2041 goto msg_full;
2042
2043 nla_nest_end(skb, nest);
2044
2045 return 0;
2046msg_full:
2047 nla_nest_cancel(skb, nest);
2048
2049 return -EMSGSIZE;
2050}
2051
2052int tipc_nl_add_bc_link(struct net *net, struct tipc_nl_msg *msg)
2053{
2054 int err;
2055 void *hdr;
2056 struct nlattr *attrs;
2057 struct nlattr *prop;
2058 struct tipc_net *tn = net_generic(net, tipc_net_id);
2059 struct tipc_link *bcl = tn->bcl;
2060
2061 if (!bcl)
2062 return 0;
2063
2064 tipc_bcast_lock(net);
2065
2066 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
2067 NLM_F_MULTI, TIPC_NL_LINK_GET);
Insu Yunb53ce3e2016-02-17 11:47:35 -05002068 if (!hdr) {
2069 tipc_bcast_unlock(net);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002070 return -EMSGSIZE;
Insu Yunb53ce3e2016-02-17 11:47:35 -05002071 }
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002072
2073 attrs = nla_nest_start(msg->skb, TIPC_NLA_LINK);
2074 if (!attrs)
2075 goto msg_full;
2076
2077 /* The broadcast link is always up */
2078 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
2079 goto attr_msg_full;
2080
2081 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_BROADCAST))
2082 goto attr_msg_full;
2083 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, bcl->name))
2084 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05002085 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, 0))
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002086 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05002087 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, 0))
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002088 goto attr_msg_full;
2089
2090 prop = nla_nest_start(msg->skb, TIPC_NLA_LINK_PROP);
2091 if (!prop)
2092 goto attr_msg_full;
2093 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bcl->window))
2094 goto prop_msg_full;
2095 nla_nest_end(msg->skb, prop);
2096
2097 err = __tipc_nl_add_bc_link_stat(msg->skb, &bcl->stats);
2098 if (err)
2099 goto attr_msg_full;
2100
2101 tipc_bcast_unlock(net);
2102 nla_nest_end(msg->skb, attrs);
2103 genlmsg_end(msg->skb, hdr);
2104
2105 return 0;
2106
2107prop_msg_full:
2108 nla_nest_cancel(msg->skb, prop);
2109attr_msg_full:
2110 nla_nest_cancel(msg->skb, attrs);
2111msg_full:
2112 tipc_bcast_unlock(net);
2113 genlmsg_cancel(msg->skb, hdr);
2114
2115 return -EMSGSIZE;
2116}
2117
Richard Alped01332f2016-02-01 08:19:56 +01002118void tipc_link_set_tolerance(struct tipc_link *l, u32 tol,
2119 struct sk_buff_head *xmitq)
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002120{
2121 l->tolerance = tol;
Richard Alped01332f2016-02-01 08:19:56 +01002122 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, tol, 0, xmitq);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002123}
2124
Richard Alped01332f2016-02-01 08:19:56 +01002125void tipc_link_set_prio(struct tipc_link *l, u32 prio,
2126 struct sk_buff_head *xmitq)
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002127{
2128 l->priority = prio;
Richard Alped01332f2016-02-01 08:19:56 +01002129 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, prio, xmitq);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002130}
2131
2132void tipc_link_set_abort_limit(struct tipc_link *l, u32 limit)
2133{
2134 l->abort_limit = limit;
2135}