blob: 09ae8448f394f738f434cf521503a43450615c95 [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"
Tuong Lienb4b97712018-12-19 09:17:56 +070046#include "trace.h"
Tuong Lienfc1b6d62019-11-08 12:05:11 +070047#include "crypto.h"
Per Lidenb97bf3f2006-01-02 19:04:38 +010048
Ying Xue796c75d2013-06-17 10:54:48 -040049#include <linux/pkt_sched.h>
50
Jon Paul Maloy38206d52015-11-19 14:30:46 -050051struct tipc_stats {
Jon Paul Maloy95901122016-11-25 10:35:02 -050052 u32 sent_pkts;
53 u32 recv_pkts;
Jon Paul Maloy38206d52015-11-19 14:30:46 -050054 u32 sent_states;
55 u32 recv_states;
56 u32 sent_probes;
57 u32 recv_probes;
58 u32 sent_nacks;
59 u32 recv_nacks;
60 u32 sent_acks;
61 u32 sent_bundled;
62 u32 sent_bundles;
63 u32 recv_bundled;
64 u32 recv_bundles;
65 u32 retransmitted;
66 u32 sent_fragmented;
67 u32 sent_fragments;
68 u32 recv_fragmented;
69 u32 recv_fragments;
70 u32 link_congs; /* # port sends blocked by congestion */
71 u32 deferred_recv;
72 u32 duplicates;
73 u32 max_queue_sz; /* send queue size high water mark */
74 u32 accu_queue_sz; /* used for send queue size profiling */
75 u32 queue_sz_counts; /* used for send queue size profiling */
76 u32 msg_length_counts; /* used for message length profiling */
77 u32 msg_lengths_total; /* used for message length profiling */
78 u32 msg_length_profile[7]; /* used for msg. length profiling */
79};
80
81/**
82 * struct tipc_link - TIPC link data structure
83 * @addr: network address of link's peer node
84 * @name: link name character string
85 * @media_addr: media address to use when sending messages over link
86 * @timer: link timer
87 * @net: pointer to namespace struct
88 * @refcnt: reference counter for permanent references (owner node & timer)
89 * @peer_session: link session # being used by peer end of link
90 * @peer_bearer_id: bearer id used by link's peer endpoint
91 * @bearer_id: local bearer id used by link
92 * @tolerance: minimum link continuity loss needed to reset link [in ms]
Jon Paul Maloy38206d52015-11-19 14:30:46 -050093 * @abort_limit: # of unacknowledged continuity probes needed to reset link
94 * @state: current state of link FSM
95 * @peer_caps: bitmap describing capabilities of peer node
96 * @silent_intv_cnt: # of timer intervals without any reception from peer
97 * @proto_msg: template for control messages generated by link
98 * @pmsg: convenience pointer to "proto_msg" field
99 * @priority: current link priority
100 * @net_plane: current link network plane ('A' through 'H')
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400101 * @mon_state: cookie with information needed by link monitor
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500102 * @backlog_limit: backlog queue congestion thresholds (indexed by importance)
103 * @exp_msg_count: # of tunnelled messages expected during link changeover
104 * @reset_rcv_checkpt: seq # of last acknowledged message at time of link reset
105 * @mtu: current maximum packet size for this link
106 * @advertised_mtu: advertised own mtu when link is being established
107 * @transmitq: queue for sent, non-acked messages
108 * @backlogq: queue for messages waiting to be sent
109 * @snt_nxt: next sequence number to use for outbound messages
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500110 * @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
Randy Dunlapa99df442020-11-29 10:32:44 -0800123 * @session: session to be used by link
124 * @snd_nxt_state: next send seq number
125 * @rcv_nxt_state: next rcv seq number
126 * @in_session: have received ACTIVATE_MSG from peer
127 * @active: link is active
128 * @if_name: associated interface name
129 * @rst_cnt: link reset counter
130 * @drop_point: seq number for failover handling (FIXME)
131 * @failover_reasm_skb: saved failover msg ptr (FIXME)
132 * @failover_deferdq: deferred message queue for failover processing (FIXME)
133 * @transmq: the link's transmit queue
134 * @backlog: link's backlog by priority (importance)
135 * @snd_nxt: next sequence number to be used
136 * @rcv_unacked: # messages read by user, but not yet acked back to peer
137 * @deferdq: deferred receive queue
138 * @window: sliding window size for congestion handling
139 * @min_win: minimal send window to be used by link
140 * @ssthresh: slow start threshold for congestion handling
141 * @max_win: maximal send window to be used by link
142 * @cong_acks: congestion acks for congestion avoidance (FIXME)
143 * @checkpoint: seq number for congestion window size handling
144 * @reasm_tnlmsg: fragmentation/reassembly area for tunnel protocol message
145 * @last_gap: last gap ack blocks for bcast (FIXME)
146 * @last_ga: ptr to gap ack blocks
147 * @bc_rcvlink: the peer specific link used for broadcast reception
148 * @bc_sndlink: the namespace global link used for broadcast sending
149 * @nack_state: bcast nack state
150 * @bc_peer_is_up: peer has acked the bcast init msg
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500151 */
152struct tipc_link {
153 u32 addr;
154 char name[TIPC_MAX_LINK_NAME];
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500155 struct net *net;
156
157 /* Management and link supervision data */
Jon Maloy7ea817f2018-07-10 01:07:36 +0200158 u16 peer_session;
159 u16 session;
Jon Maloy9012de52018-07-10 01:07:35 +0200160 u16 snd_nxt_state;
161 u16 rcv_nxt_state;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500162 u32 peer_bearer_id;
163 u32 bearer_id;
164 u32 tolerance;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500165 u32 abort_limit;
166 u32 state;
167 u16 peer_caps;
Jon Maloy7ea817f2018-07-10 01:07:36 +0200168 bool in_session;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500169 bool active;
170 u32 silent_intv_cnt;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500171 char if_name[TIPC_MAX_IF_NAME];
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500172 u32 priority;
173 char net_plane;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400174 struct tipc_mon_state mon_state;
Jon Paul Maloy88e8ac72016-04-15 13:33:04 -0400175 u16 rst_cnt;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500176
177 /* Failover/synch */
178 u16 drop_point;
179 struct sk_buff *failover_reasm_skb;
Tuong Lien58ee86b2019-04-04 11:09:53 +0700180 struct sk_buff_head failover_deferdq;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500181
182 /* Max packet negotiation */
183 u16 mtu;
184 u16 advertised_mtu;
185
186 /* Sending */
187 struct sk_buff_head transmq;
188 struct sk_buff_head backlogq;
189 struct {
190 u16 len;
191 u16 limit;
Tuong Liene95584a2019-10-02 18:49:43 +0700192 struct sk_buff *target_bskb;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500193 } backlog[5];
194 u16 snd_nxt;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500195
196 /* Reception */
197 u16 rcv_nxt;
198 u32 rcv_unacked;
199 struct sk_buff_head deferdq;
200 struct sk_buff_head *inputq;
201 struct sk_buff_head *namedq;
202
203 /* Congestion handling */
204 struct sk_buff_head wakeupq;
Jon Maloy16ad3f42019-12-10 00:52:46 +0100205 u16 window;
206 u16 min_win;
207 u16 ssthresh;
208 u16 max_win;
209 u16 cong_acks;
210 u16 checkpoint;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500211
212 /* Fragmentation/reassembly */
213 struct sk_buff *reasm_buf;
Tuong Lien2320bcd2019-07-24 08:56:12 +0700214 struct sk_buff *reasm_tnlmsg;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500215
216 /* Broadcast */
217 u16 ackers;
218 u16 acked;
Tuong Liend7626b52020-05-26 16:38:34 +0700219 u16 last_gap;
220 struct tipc_gap_ack_blks *last_ga;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500221 struct tipc_link *bc_rcvlink;
222 struct tipc_link *bc_sndlink;
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -0400223 u8 nack_state;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500224 bool bc_peer_is_up;
225
226 /* Statistics */
227 struct tipc_stats stats;
228};
229
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400230/*
231 * Error message prefixes
232 */
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400233static const char *link_co_err = "Link tunneling error, ";
Erik Hugne2cf8aa12012-06-29 00:16:37 -0400234static const char *link_rst_msg = "Resetting link ";
Richard Alpe7be57fc2014-11-20 10:29:12 +0100235
Jon Paul Maloy52666982015-10-22 08:51:41 -0400236/* Send states for broadcast NACKs
237 */
238enum {
239 BC_NACK_SND_CONDITIONAL,
240 BC_NACK_SND_UNCONDITIONAL,
241 BC_NACK_SND_SUPPRESS,
242};
243
Jon Maloy53962bc2019-06-28 17:06:20 +0200244#define TIPC_BC_RETR_LIM (jiffies + msecs_to_jiffies(10))
Tuong Lien382f5982019-04-04 11:09:52 +0700245#define TIPC_UC_RETR_TIME (jiffies + msecs_to_jiffies(1))
Jon Paul Maloy7c4a54b2016-09-01 13:52:50 -0400246
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400247/* Link FSM states:
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400248 */
249enum {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400250 LINK_ESTABLISHED = 0xe,
251 LINK_ESTABLISHING = 0xe << 4,
252 LINK_RESET = 0x1 << 8,
253 LINK_RESETTING = 0x2 << 12,
254 LINK_PEER_RESET = 0xd << 16,
255 LINK_FAILINGOVER = 0xf << 20,
256 LINK_SYNCHING = 0xc << 24
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400257};
258
259/* Link FSM state checking routines
260 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400261static int link_is_up(struct tipc_link *l)
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400262{
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400263 return l->state & (LINK_ESTABLISHED | LINK_SYNCHING);
Jon Paul Maloyd3504c32015-07-16 16:54:25 -0400264}
265
Jon Paul Maloyd9992972015-07-16 16:54:31 -0400266static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
267 struct sk_buff_head *xmitq);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -0400268static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
Jon Maloy8d6e79d2017-11-08 09:59:26 +0100269 bool probe_reply, u16 rcvgap,
270 int tolerance, int priority,
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -0400271 struct sk_buff_head *xmitq);
Jon Paul Maloy1a906322015-11-19 14:30:47 -0500272static void link_print(struct tipc_link *l, const char *str);
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -0400273static int tipc_link_build_nack_msg(struct tipc_link *l,
274 struct sk_buff_head *xmitq);
Jon Paul Maloy52666982015-10-22 08:51:41 -0400275static void tipc_link_build_bc_init_msg(struct tipc_link *l,
276 struct sk_buff_head *xmitq);
Tuong Liend7626b52020-05-26 16:38:34 +0700277static u8 __tipc_build_gap_ack_blks(struct tipc_gap_ack_blks *ga,
278 struct tipc_link *l, u8 start_index);
279static u16 tipc_build_gap_ack_blks(struct tipc_link *l, struct tipc_msg *hdr);
280static int tipc_link_advance_transmq(struct tipc_link *l, struct tipc_link *r,
281 u16 acked, u16 gap,
Tuong Lien6a6b5c82019-06-17 12:15:42 +0700282 struct tipc_gap_ack_blks *ga,
Tuong Liend7626b52020-05-26 16:38:34 +0700283 struct sk_buff_head *xmitq,
284 bool *retransmitted, int *rc);
Jon Maloy16ad3f42019-12-10 00:52:46 +0100285static void tipc_link_update_cwin(struct tipc_link *l, int released,
286 bool retransmitted);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100287/*
Sam Ravnborg05790c62006-03-20 22:37:04 -0800288 * Simple non-static link routines (i.e. referenced outside this file)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100289 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400290bool tipc_link_is_up(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100291{
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400292 return link_is_up(l);
293}
294
Jon Paul Maloyc8199302015-10-15 14:52:46 -0400295bool tipc_link_peer_is_down(struct tipc_link *l)
296{
297 return l->state == LINK_PEER_RESET;
298}
299
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400300bool tipc_link_is_reset(struct tipc_link *l)
301{
302 return l->state & (LINK_RESET | LINK_FAILINGOVER | LINK_ESTABLISHING);
303}
304
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400305bool tipc_link_is_establishing(struct tipc_link *l)
306{
307 return l->state == LINK_ESTABLISHING;
308}
309
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400310bool tipc_link_is_synching(struct tipc_link *l)
311{
312 return l->state == LINK_SYNCHING;
313}
314
315bool tipc_link_is_failingover(struct tipc_link *l)
316{
317 return l->state == LINK_FAILINGOVER;
318}
319
320bool tipc_link_is_blocked(struct tipc_link *l)
321{
322 return l->state & (LINK_RESETTING | LINK_PEER_RESET | LINK_FAILINGOVER);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100323}
324
Wu Fengguang742e0382015-10-24 22:56:01 +0800325static bool link_is_bc_sndlink(struct tipc_link *l)
Jon Paul Maloy52666982015-10-22 08:51:41 -0400326{
327 return !l->bc_sndlink;
328}
329
Wu Fengguang742e0382015-10-24 22:56:01 +0800330static bool link_is_bc_rcvlink(struct tipc_link *l)
Jon Paul Maloy52666982015-10-22 08:51:41 -0400331{
332 return ((l->bc_rcvlink == l) && !link_is_bc_sndlink(l));
333}
334
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400335void tipc_link_set_active(struct tipc_link *l, bool active)
336{
337 l->active = active;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100338}
339
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500340u32 tipc_link_id(struct tipc_link *l)
341{
342 return l->peer_bearer_id << 16 | l->bearer_id;
343}
344
Jon Maloy16ad3f42019-12-10 00:52:46 +0100345int tipc_link_min_win(struct tipc_link *l)
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500346{
Jon Maloy16ad3f42019-12-10 00:52:46 +0100347 return l->min_win;
348}
349
350int tipc_link_max_win(struct tipc_link *l)
351{
352 return l->max_win;
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500353}
354
355int tipc_link_prio(struct tipc_link *l)
356{
357 return l->priority;
358}
359
360unsigned long tipc_link_tolerance(struct tipc_link *l)
361{
362 return l->tolerance;
363}
364
365struct sk_buff_head *tipc_link_inputq(struct tipc_link *l)
366{
367 return l->inputq;
368}
369
370char tipc_link_plane(struct tipc_link *l)
371{
372 return l->net_plane;
373}
374
Xin Longbe07f052021-05-18 10:09:08 +0800375struct net *tipc_link_net(struct tipc_link *l)
376{
377 return l->net;
378}
379
Jon Maloy9012de52018-07-10 01:07:35 +0200380void tipc_link_update_caps(struct tipc_link *l, u16 capabilities)
381{
382 l->peer_caps = capabilities;
383}
384
Jon Paul Maloy52666982015-10-22 08:51:41 -0400385void tipc_link_add_bc_peer(struct tipc_link *snd_l,
386 struct tipc_link *uc_l,
387 struct sk_buff_head *xmitq)
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400388{
Jon Paul Maloy52666982015-10-22 08:51:41 -0400389 struct tipc_link *rcv_l = uc_l->bc_rcvlink;
390
391 snd_l->ackers++;
392 rcv_l->acked = snd_l->snd_nxt - 1;
Jon Paul Maloy9a650832015-11-19 14:12:50 -0500393 snd_l->state = LINK_ESTABLISHED;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400394 tipc_link_build_bc_init_msg(uc_l, xmitq);
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400395}
396
Jon Paul Maloy52666982015-10-22 08:51:41 -0400397void tipc_link_remove_bc_peer(struct tipc_link *snd_l,
398 struct tipc_link *rcv_l,
399 struct sk_buff_head *xmitq)
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400400{
Jon Paul Maloy52666982015-10-22 08:51:41 -0400401 u16 ack = snd_l->snd_nxt - 1;
402
403 snd_l->ackers--;
Jon Paul Maloya71eb722016-07-11 16:08:36 -0400404 rcv_l->bc_peer_is_up = true;
405 rcv_l->state = LINK_ESTABLISHED;
Tuong Liena91d55d2020-05-26 16:38:36 +0700406 tipc_link_bc_ack_rcv(rcv_l, ack, 0, NULL, xmitq, NULL);
Tuong Lien26574db2018-12-19 09:17:57 +0700407 trace_tipc_link_reset(rcv_l, TIPC_DUMP_ALL, "bclink removed!");
Jon Paul Maloy52666982015-10-22 08:51:41 -0400408 tipc_link_reset(rcv_l);
409 rcv_l->state = LINK_RESET;
410 if (!snd_l->ackers) {
Tuong Lien26574db2018-12-19 09:17:57 +0700411 trace_tipc_link_reset(snd_l, TIPC_DUMP_ALL, "zero ackers!");
Jon Paul Maloy52666982015-10-22 08:51:41 -0400412 tipc_link_reset(snd_l);
Jon Paul Maloy9a650832015-11-19 14:12:50 -0500413 snd_l->state = LINK_RESET;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400414 __skb_queue_purge(xmitq);
415 }
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400416}
417
418int tipc_link_bc_peers(struct tipc_link *l)
419{
420 return l->ackers;
421}
422
YueHaibinge064cce2018-07-19 17:16:59 +0800423static u16 link_bc_rcv_gap(struct tipc_link *l)
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -0400424{
425 struct sk_buff *skb = skb_peek(&l->deferdq);
426 u16 gap = 0;
427
428 if (more(l->snd_nxt, l->rcv_nxt))
429 gap = l->snd_nxt - l->rcv_nxt;
430 if (skb)
431 gap = buf_seqno(skb) - l->rcv_nxt;
432 return gap;
433}
434
Jon Paul Maloy959e1782015-10-22 08:51:43 -0400435void tipc_link_set_mtu(struct tipc_link *l, int mtu)
436{
437 l->mtu = mtu;
438}
439
440int tipc_link_mtu(struct tipc_link *l)
441{
442 return l->mtu;
443}
444
Tuong Lienfc1b6d62019-11-08 12:05:11 +0700445int tipc_link_mss(struct tipc_link *l)
446{
447#ifdef CONFIG_TIPC_CRYPTO
448 return l->mtu - INT_H_SIZE - EMSG_OVERHEAD;
449#else
450 return l->mtu - INT_H_SIZE;
451#endif
452}
453
Jon Paul Maloy38206d52015-11-19 14:30:46 -0500454u16 tipc_link_rcv_nxt(struct tipc_link *l)
455{
456 return l->rcv_nxt;
457}
458
459u16 tipc_link_acked(struct tipc_link *l)
460{
461 return l->acked;
462}
463
464char *tipc_link_name(struct tipc_link *l)
465{
466 return l->name;
467}
468
LUU Duc Canhc140eb12018-09-26 21:00:54 +0200469u32 tipc_link_state(struct tipc_link *l)
470{
471 return l->state;
472}
473
Per Lidenb97bf3f2006-01-02 19:04:38 +0100474/**
Per Liden4323add2006-01-18 00:38:21 +0100475 * tipc_link_create - create a new link
Andrew Lunnd8141202020-07-13 01:15:14 +0200476 * @net: pointer to associated network namespace
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400477 * @if_name: associated interface name
478 * @bearer_id: id (index) of associated bearer
479 * @tolerance: link tolerance to be used by link
480 * @net_plane: network plane (A,B,c..) this link belongs to
481 * @mtu: mtu to be advertised by link
482 * @priority: priority to be used by link
Jon Maloy16ad3f42019-12-10 00:52:46 +0100483 * @min_win: minimal send window to be used by link
484 * @max_win: maximal send window to be used by link
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400485 * @session: session to be used by link
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400486 * @peer: node id of peer node
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400487 * @peer_caps: bitmap describing peer node capabilities
Jon Paul Maloy52666982015-10-22 08:51:41 -0400488 * @bc_sndlink: the namespace global link used for broadcast sending
489 * @bc_rcvlink: the peer specific link used for broadcast reception
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400490 * @inputq: queue to put messages ready for delivery
491 * @namedq: queue to put binding table update messages ready for delivery
492 * @link: return value, pointer to put the created link
Randy Dunlapa99df442020-11-29 10:32:44 -0800493 * @self: local unicast link id
494 * @peer_id: 128-bit ID of peer
YOSHIFUJI Hideakic4307282007-02-09 23:25:21 +0900495 *
Randy Dunlap637b77f2020-11-29 10:32:48 -0800496 * Return: true if link was created, otherwise false
Per Lidenb97bf3f2006-01-02 19:04:38 +0100497 */
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400498bool tipc_link_create(struct net *net, char *if_name, int bearer_id,
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400499 int tolerance, char net_plane, u32 mtu, int priority,
Jon Maloy16ad3f42019-12-10 00:52:46 +0100500 u32 min_win, u32 max_win, u32 session, u32 self,
Jon Maloy25b0b9c2018-03-22 20:42:51 +0100501 u32 peer, u8 *peer_id, u16 peer_caps,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400502 struct tipc_link *bc_sndlink,
503 struct tipc_link *bc_rcvlink,
504 struct sk_buff_head *inputq,
505 struct sk_buff_head *namedq,
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400506 struct tipc_link **link)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100507{
Jon Maloy25b0b9c2018-03-22 20:42:51 +0100508 char peer_str[NODE_ID_STR_LEN] = {0,};
509 char self_str[NODE_ID_STR_LEN] = {0,};
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400510 struct tipc_link *l;
Allan Stephens37b9c082011-02-28 11:32:27 -0500511
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400512 l = kzalloc(sizeof(*l), GFP_ATOMIC);
513 if (!l)
514 return false;
515 *link = l;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500516 l->session = session;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400517
Jon Maloy25b0b9c2018-03-22 20:42:51 +0100518 /* Set link name for unicast links only */
519 if (peer_id) {
520 tipc_nodeid2string(self_str, tipc_own_id(net));
521 if (strlen(self_str) > 16)
522 sprintf(self_str, "%x", self);
523 tipc_nodeid2string(peer_str, peer_id);
524 if (strlen(peer_str) > 16)
525 sprintf(peer_str, "%x", peer);
526 }
527 /* Peer i/f name will be completed by reset/activate message */
Jon Maloy7494cfa2018-03-29 23:20:45 +0200528 snprintf(l->name, sizeof(l->name), "%s:%s-%s:unknown",
529 self_str, if_name, peer_str);
Jon Maloy25b0b9c2018-03-22 20:42:51 +0100530
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500531 strcpy(l->if_name, if_name);
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400532 l->addr = peer;
Jon Paul Maloyfd556f22015-10-22 08:51:40 -0400533 l->peer_caps = peer_caps;
Jon Paul Maloyc72fa872015-10-22 08:51:46 -0400534 l->net = net;
Jon Maloy7ea817f2018-07-10 01:07:36 +0200535 l->in_session = false;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400536 l->bearer_id = bearer_id;
537 l->tolerance = tolerance;
Jon Maloy047491e2018-10-10 17:34:01 +0200538 if (bc_rcvlink)
539 bc_rcvlink->tolerance = tolerance;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400540 l->net_plane = net_plane;
541 l->advertised_mtu = mtu;
542 l->mtu = mtu;
543 l->priority = priority;
Jon Maloy16ad3f42019-12-10 00:52:46 +0100544 tipc_link_set_queue_limits(l, min_win, max_win);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -0400545 l->ackers = 1;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400546 l->bc_sndlink = bc_sndlink;
547 l->bc_rcvlink = bc_rcvlink;
Jon Paul Maloy0e054982015-10-22 08:51:36 -0400548 l->inputq = inputq;
549 l->namedq = namedq;
550 l->state = LINK_RESETTING;
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400551 __skb_queue_head_init(&l->transmq);
552 __skb_queue_head_init(&l->backlogq);
553 __skb_queue_head_init(&l->deferdq);
Tuong Lien58ee86b2019-04-04 11:09:53 +0700554 __skb_queue_head_init(&l->failover_deferdq);
Jon Paul Maloy440d8962015-07-30 18:24:26 -0400555 skb_queue_head_init(&l->wakeupq);
556 skb_queue_head_init(l->inputq);
557 return true;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100558}
559
Jon Paul Maloy32301902015-10-22 08:51:37 -0400560/**
561 * tipc_link_bc_create - create new link to be used for broadcast
Andrew Lunnd8141202020-07-13 01:15:14 +0200562 * @net: pointer to associated network namespace
Jon Maloy4c94cc22017-11-30 16:47:25 +0100563 * @mtu: mtu to be used initially if no peers
Lu Wei2e5117b2020-09-15 10:39:55 +0800564 * @min_win: minimal send window to be used by link
565 * @max_win: maximal send window to be used by link
Jon Paul Maloy32301902015-10-22 08:51:37 -0400566 * @inputq: queue to put messages ready for delivery
567 * @namedq: queue to put binding table update messages ready for delivery
568 * @link: return value, pointer to put the created link
Randy Dunlapa99df442020-11-29 10:32:44 -0800569 * @ownnode: identity of own node
570 * @peer: node id of peer node
571 * @peer_id: 128-bit ID of peer
572 * @peer_caps: bitmap describing peer node capabilities
573 * @bc_sndlink: the namespace global link used for broadcast sending
Jon Paul Maloy32301902015-10-22 08:51:37 -0400574 *
Randy Dunlap637b77f2020-11-29 10:32:48 -0800575 * Return: true if link was created, otherwise false
Jon Paul Maloy32301902015-10-22 08:51:37 -0400576 */
Tuong Lien03b6fef2020-05-26 16:38:37 +0700577bool tipc_link_bc_create(struct net *net, u32 ownnode, u32 peer, u8 *peer_id,
Jon Maloy16ad3f42019-12-10 00:52:46 +0100578 int mtu, u32 min_win, u32 max_win, u16 peer_caps,
Jon Paul Maloy32301902015-10-22 08:51:37 -0400579 struct sk_buff_head *inputq,
580 struct sk_buff_head *namedq,
Jon Paul Maloy52666982015-10-22 08:51:41 -0400581 struct tipc_link *bc_sndlink,
Jon Paul Maloy32301902015-10-22 08:51:37 -0400582 struct tipc_link **link)
583{
584 struct tipc_link *l;
585
Jon Maloy16ad3f42019-12-10 00:52:46 +0100586 if (!tipc_link_create(net, "", MAX_BEARERS, 0, 'Z', mtu, 0, min_win,
587 max_win, 0, ownnode, peer, NULL, peer_caps,
588 bc_sndlink, NULL, inputq, namedq, link))
Jon Paul Maloy32301902015-10-22 08:51:37 -0400589 return false;
590
591 l = *link;
Tuong Lien03b6fef2020-05-26 16:38:37 +0700592 if (peer_id) {
593 char peer_str[NODE_ID_STR_LEN] = {0,};
594
595 tipc_nodeid2string(peer_str, peer_id);
596 if (strlen(peer_str) > 16)
597 sprintf(peer_str, "%x", peer);
598 /* Broadcast receiver link name: "broadcast-link:<peer>" */
599 snprintf(l->name, sizeof(l->name), "%s:%s", tipc_bclink_name,
600 peer_str);
601 } else {
602 strcpy(l->name, tipc_bclink_name);
603 }
Tuong Lien26574db2018-12-19 09:17:57 +0700604 trace_tipc_link_reset(l, TIPC_DUMP_ALL, "bclink created!");
Jon Paul Maloy32301902015-10-22 08:51:37 -0400605 tipc_link_reset(l);
Jon Paul Maloy52666982015-10-22 08:51:41 -0400606 l->state = LINK_RESET;
Jon Paul Maloy2f566122015-10-22 08:51:39 -0400607 l->ackers = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400608 l->bc_rcvlink = l;
609
610 /* Broadcast send link is always up */
611 if (link_is_bc_sndlink(l))
612 l->state = LINK_ESTABLISHED;
613
Jon Paul Maloy01fd12b2017-01-18 13:50:53 -0500614 /* Disable replicast if even a single peer doesn't support it */
615 if (link_is_bc_rcvlink(l) && !(peer_caps & TIPC_BCAST_RCAST))
Hoang Leba5f6a82019-11-21 10:01:09 +0700616 tipc_bcast_toggle_rcast(net, false);
Jon Paul Maloy01fd12b2017-01-18 13:50:53 -0500617
Jon Paul Maloy32301902015-10-22 08:51:37 -0400618 return true;
619}
620
Per Lidenb97bf3f2006-01-02 19:04:38 +0100621/**
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400622 * tipc_link_fsm_evt - link finite state machine
623 * @l: pointer to link
624 * @evt: state machine event to be processed
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400625 */
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400626int tipc_link_fsm_evt(struct tipc_link *l, int evt)
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400627{
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400628 int rc = 0;
Tuong Lien26574db2018-12-19 09:17:57 +0700629 int old_state = l->state;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400630
631 switch (l->state) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400632 case LINK_RESETTING:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400633 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400634 case LINK_PEER_RESET_EVT:
635 l->state = LINK_PEER_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400636 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400637 case LINK_RESET_EVT:
638 l->state = LINK_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400639 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400640 case LINK_FAILURE_EVT:
641 case LINK_FAILOVER_BEGIN_EVT:
642 case LINK_ESTABLISH_EVT:
643 case LINK_FAILOVER_END_EVT:
644 case LINK_SYNCH_BEGIN_EVT:
645 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400646 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400647 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400648 }
649 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400650 case LINK_RESET:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400651 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400652 case LINK_PEER_RESET_EVT:
653 l->state = LINK_ESTABLISHING;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400654 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400655 case LINK_FAILOVER_BEGIN_EVT:
656 l->state = LINK_FAILINGOVER;
Gustavo A. R. Silva1c78ba4922020-11-20 12:40:08 -0600657 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400658 case LINK_FAILURE_EVT:
659 case LINK_RESET_EVT:
660 case LINK_ESTABLISH_EVT:
661 case LINK_FAILOVER_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400662 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400663 case LINK_SYNCH_BEGIN_EVT:
664 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400665 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400666 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400667 }
668 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400669 case LINK_PEER_RESET:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400670 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400671 case LINK_RESET_EVT:
672 l->state = LINK_ESTABLISHING;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400673 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400674 case LINK_PEER_RESET_EVT:
675 case LINK_ESTABLISH_EVT:
676 case LINK_FAILURE_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400677 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400678 case LINK_SYNCH_BEGIN_EVT:
679 case LINK_SYNCH_END_EVT:
680 case LINK_FAILOVER_BEGIN_EVT:
681 case LINK_FAILOVER_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400682 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400683 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400684 }
685 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400686 case LINK_FAILINGOVER:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400687 switch (evt) {
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400688 case LINK_FAILOVER_END_EVT:
689 l->state = LINK_RESET;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400690 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400691 case LINK_PEER_RESET_EVT:
692 case LINK_RESET_EVT:
693 case LINK_ESTABLISH_EVT:
694 case LINK_FAILURE_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400695 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400696 case LINK_FAILOVER_BEGIN_EVT:
697 case LINK_SYNCH_BEGIN_EVT:
698 case LINK_SYNCH_END_EVT:
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400699 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400700 goto illegal_evt;
701 }
702 break;
703 case LINK_ESTABLISHING:
704 switch (evt) {
705 case LINK_ESTABLISH_EVT:
706 l->state = LINK_ESTABLISHED;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400707 break;
708 case LINK_FAILOVER_BEGIN_EVT:
709 l->state = LINK_FAILINGOVER;
710 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400711 case LINK_RESET_EVT:
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400712 l->state = LINK_RESET;
713 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400714 case LINK_FAILURE_EVT:
Jon Paul Maloy73f646c2015-10-15 14:52:44 -0400715 case LINK_PEER_RESET_EVT:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400716 case LINK_SYNCH_BEGIN_EVT:
717 case LINK_FAILOVER_END_EVT:
718 break;
719 case LINK_SYNCH_END_EVT:
720 default:
721 goto illegal_evt;
722 }
723 break;
724 case LINK_ESTABLISHED:
725 switch (evt) {
726 case LINK_PEER_RESET_EVT:
727 l->state = LINK_PEER_RESET;
728 rc |= TIPC_LINK_DOWN_EVT;
729 break;
730 case LINK_FAILURE_EVT:
731 l->state = LINK_RESETTING;
732 rc |= TIPC_LINK_DOWN_EVT;
733 break;
734 case LINK_RESET_EVT:
735 l->state = LINK_RESET;
736 break;
737 case LINK_ESTABLISH_EVT:
Jon Paul Maloy5ae2f8e2015-08-20 02:12:55 -0400738 case LINK_SYNCH_END_EVT:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400739 break;
740 case LINK_SYNCH_BEGIN_EVT:
741 l->state = LINK_SYNCHING;
742 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400743 case LINK_FAILOVER_BEGIN_EVT:
744 case LINK_FAILOVER_END_EVT:
745 default:
746 goto illegal_evt;
747 }
748 break;
749 case LINK_SYNCHING:
750 switch (evt) {
751 case LINK_PEER_RESET_EVT:
752 l->state = LINK_PEER_RESET;
753 rc |= TIPC_LINK_DOWN_EVT;
754 break;
755 case LINK_FAILURE_EVT:
756 l->state = LINK_RESETTING;
757 rc |= TIPC_LINK_DOWN_EVT;
758 break;
759 case LINK_RESET_EVT:
760 l->state = LINK_RESET;
761 break;
762 case LINK_ESTABLISH_EVT:
763 case LINK_SYNCH_BEGIN_EVT:
764 break;
765 case LINK_SYNCH_END_EVT:
766 l->state = LINK_ESTABLISHED;
767 break;
768 case LINK_FAILOVER_BEGIN_EVT:
769 case LINK_FAILOVER_END_EVT:
770 default:
771 goto illegal_evt;
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400772 }
773 break;
774 default:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400775 pr_err("Unknown FSM state %x in %s\n", l->state, l->name);
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400776 }
Tuong Lien26574db2018-12-19 09:17:57 +0700777 trace_tipc_link_fsm(l->name, old_state, l->state, evt);
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400778 return rc;
779illegal_evt:
780 pr_err("Illegal FSM event %x in state %x on link %s\n",
781 evt, l->state, l->name);
Tuong Lien26574db2018-12-19 09:17:57 +0700782 trace_tipc_link_fsm(l->name, old_state, l->state, evt);
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400783 return rc;
784}
785
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400786/* link_profile_stats - update statistical profiling of traffic
787 */
788static void link_profile_stats(struct tipc_link *l)
789{
790 struct sk_buff *skb;
791 struct tipc_msg *msg;
792 int length;
793
794 /* Update counters used in statistical profiling of send traffic */
795 l->stats.accu_queue_sz += skb_queue_len(&l->transmq);
796 l->stats.queue_sz_counts++;
797
798 skb = skb_peek(&l->transmq);
799 if (!skb)
800 return;
801 msg = buf_msg(skb);
802 length = msg_size(msg);
803
804 if (msg_user(msg) == MSG_FRAGMENTER) {
805 if (msg_type(msg) != FIRST_FRAGMENT)
806 return;
Jon Maloya7dc51a2019-06-25 19:37:00 +0200807 length = msg_size(msg_inner_hdr(msg));
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400808 }
809 l->stats.msg_lengths_total += length;
810 l->stats.msg_length_counts++;
811 if (length <= 64)
812 l->stats.msg_length_profile[0]++;
813 else if (length <= 256)
814 l->stats.msg_length_profile[1]++;
815 else if (length <= 1024)
816 l->stats.msg_length_profile[2]++;
817 else if (length <= 4096)
818 l->stats.msg_length_profile[3]++;
819 else if (length <= 16384)
820 l->stats.msg_length_profile[4]++;
821 else if (length <= 32768)
822 l->stats.msg_length_profile[5]++;
823 else
824 l->stats.msg_length_profile[6]++;
825}
826
Tuong Lien26574db2018-12-19 09:17:57 +0700827/**
828 * tipc_link_too_silent - check if link is "too silent"
829 * @l: tipc link to be checked
830 *
Randy Dunlap637b77f2020-11-29 10:32:48 -0800831 * Return: true if the link 'silent_intv_cnt' is about to reach the
Tuong Lien26574db2018-12-19 09:17:57 +0700832 * 'abort_limit' value, otherwise false
833 */
834bool tipc_link_too_silent(struct tipc_link *l)
835{
836 return (l->silent_intv_cnt + 2 > l->abort_limit);
837}
838
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400839/* tipc_link_timeout - perform periodic task as instructed from node timeout
840 */
841int tipc_link_timeout(struct tipc_link *l, struct sk_buff_head *xmitq)
842{
Ying Xuec91522f2016-06-15 14:11:31 +0800843 int mtyp = 0;
844 int rc = 0;
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400845 bool state = false;
846 bool probe = false;
847 bool setup = false;
Jon Paul Maloy52666982015-10-22 08:51:41 -0400848 u16 bc_snt = l->bc_sndlink->snd_nxt - 1;
849 u16 bc_acked = l->bc_rcvlink->acked;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400850 struct tipc_mon_state *mstate = &l->mon_state;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400851
Tuong Lien26574db2018-12-19 09:17:57 +0700852 trace_tipc_link_timeout(l, TIPC_DUMP_NONE, " ");
853 trace_tipc_link_too_silent(l, TIPC_DUMP_ALL, " ");
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400854 switch (l->state) {
855 case LINK_ESTABLISHED:
856 case LINK_SYNCHING:
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400857 mtyp = STATE_MSG;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400858 link_profile_stats(l);
859 tipc_mon_get_state(l->net, l->addr, mstate, l->bearer_id);
860 if (mstate->reset || (l->silent_intv_cnt > l->abort_limit))
861 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400862 state = bc_acked != bc_snt;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400863 state |= l->bc_rcvlink->rcv_unacked;
864 state |= l->rcv_unacked;
865 state |= !skb_queue_empty(&l->transmq);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -0400866 probe = mstate->probing;
867 probe |= l->silent_intv_cnt;
868 if (probe || mstate->monitoring)
869 l->silent_intv_cnt++;
Tung Nguyen6ef9dcb2020-07-21 08:57:05 +0700870 probe |= !skb_queue_empty(&l->deferdq);
Jon Maloy16ad3f42019-12-10 00:52:46 +0100871 if (l->snd_nxt == l->checkpoint) {
872 tipc_link_update_cwin(l, 0, 0);
873 probe = true;
874 }
875 l->checkpoint = l->snd_nxt;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400876 break;
877 case LINK_RESET:
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400878 setup = l->rst_cnt++ <= 4;
879 setup |= !(l->rst_cnt % 16);
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400880 mtyp = RESET_MSG;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400881 break;
882 case LINK_ESTABLISHING:
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400883 setup = true;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400884 mtyp = ACTIVATE_MSG;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400885 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400886 case LINK_PEER_RESET:
Jon Paul Maloy598411d2015-07-30 18:24:23 -0400887 case LINK_RESETTING:
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400888 case LINK_FAILINGOVER:
889 break;
890 default:
891 break;
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400892 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -0400893
Jon Paul Maloy42b18f62016-04-15 13:33:05 -0400894 if (state || probe || setup)
Jon Maloy8d6e79d2017-11-08 09:59:26 +0100895 tipc_link_build_proto_msg(l, mtyp, probe, 0, 0, 0, 0, xmitq);
Jon Paul Maloy5045f7b2015-07-30 18:24:20 -0400896
Jon Paul Maloy333ef692015-07-16 16:54:28 -0400897 return rc;
898}
899
Jon Paul Maloy6ab30f92015-07-16 16:54:27 -0400900/**
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400901 * link_schedule_user - schedule a message sender for wakeup after congestion
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500902 * @l: congested link
903 * @hdr: header of message that is being sent
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400904 * Create pseudo msg to send back to user when congestion abates
Per Lidenb97bf3f2006-01-02 19:04:38 +0100905 */
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500906static int link_schedule_user(struct tipc_link *l, struct tipc_msg *hdr)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100907{
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500908 u32 dnode = tipc_own_addr(l->net);
909 u32 dport = msg_origport(hdr);
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400910 struct sk_buff *skb;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100911
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400912 /* Create and schedule wakeup pseudo message */
913 skb = tipc_msg_create(SOCK_WAKEUP, 0, INT_H_SIZE, 0,
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500914 dnode, l->addr, dport, 0, 0);
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400915 if (!skb)
Hoang Le86704992021-08-11 08:22:09 +0700916 return -ENOBUFS;
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500917 msg_set_dest_droppable(buf_msg(skb), true);
918 TIPC_SKB_CB(skb)->chain_imp = msg_importance(hdr);
919 skb_queue_tail(&l->wakeupq, skb);
920 l->stats.link_congs++;
Tuong Lien26574db2018-12-19 09:17:57 +0700921 trace_tipc_link_conges(l, TIPC_DUMP_ALL, "wakeup scheduled!");
Jon Paul Maloy3127a022015-03-25 12:07:25 -0400922 return -ELINKCONG;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100923}
924
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400925/**
926 * link_prepare_wakeup - prepare users for wakeup after congestion
Jon Paul Maloy365ad352017-01-03 10:55:11 -0500927 * @l: congested link
928 * Wake up a number of waiting users, as permitted by available space
929 * in the send queue
Jon Paul Maloy50100a52014-08-22 18:09:07 -0400930 */
YueHaibinge064cce2018-07-19 17:16:59 +0800931static void link_prepare_wakeup(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100932{
Jon Maloy7c5b4202019-07-30 16:23:18 +0200933 struct sk_buff_head *wakeupq = &l->wakeupq;
934 struct sk_buff_head *inputq = l->inputq;
Ying Xue58d78b32014-11-26 11:41:51 +0800935 struct sk_buff *skb, *tmp;
Jon Maloy7c5b4202019-07-30 16:23:18 +0200936 struct sk_buff_head tmpq;
937 int avail[5] = {0,};
938 int imp = 0;
Per Lidenb97bf3f2006-01-02 19:04:38 +0100939
Jon Maloy7c5b4202019-07-30 16:23:18 +0200940 __skb_queue_head_init(&tmpq);
941
942 for (; imp <= TIPC_SYSTEM_IMPORTANCE; imp++)
943 avail[imp] = l->backlog[imp].limit - l->backlog[imp].len;
944
945 skb_queue_walk_safe(wakeupq, skb, tmp) {
Jon Paul Maloy1f66d162015-03-25 12:07:24 -0400946 imp = TIPC_SKB_CB(skb)->chain_imp;
Jon Maloy7c5b4202019-07-30 16:23:18 +0200947 if (avail[imp] <= 0)
948 continue;
949 avail[imp]--;
950 __skb_unlink(skb, wakeupq);
951 __skb_queue_tail(&tmpq, skb);
Per Lidenb97bf3f2006-01-02 19:04:38 +0100952 }
Jon Maloy7c5b4202019-07-30 16:23:18 +0200953
954 spin_lock_bh(&inputq->lock);
955 skb_queue_splice_tail(&tmpq, inputq);
956 spin_unlock_bh(&inputq->lock);
957
Per Lidenb97bf3f2006-01-02 19:04:38 +0100958}
959
Hamish Martina34f8292020-07-09 09:06:44 +1200960/**
961 * tipc_link_set_skb_retransmit_time - set the time at which retransmission of
962 * the given skb should be next attempted
963 * @skb: skb to set a future retransmission time for
964 * @l: link the skb will be transmitted on
965 */
966static void tipc_link_set_skb_retransmit_time(struct sk_buff *skb,
967 struct tipc_link *l)
968{
969 if (link_is_bc_sndlink(l))
970 TIPC_SKB_CB(skb)->nxt_retr = TIPC_BC_RETR_LIM;
971 else
972 TIPC_SKB_CB(skb)->nxt_retr = TIPC_UC_RETR_TIME;
973}
974
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400975void tipc_link_reset(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +0100976{
Ying Xuea1f8dd32018-10-11 19:57:56 +0800977 struct sk_buff_head list;
Tuong Liene95584a2019-10-02 18:49:43 +0700978 u32 imp;
Ying Xuea1f8dd32018-10-11 19:57:56 +0800979
980 __skb_queue_head_init(&list);
981
Jon Maloy7ea817f2018-07-10 01:07:36 +0200982 l->in_session = false;
Tuong Lienf7a93782019-04-16 10:48:07 +0700983 /* Force re-synch of peer session number before establishing */
984 l->peer_session--;
Jon Paul Maloye74a3862016-03-03 14:23:21 -0500985 l->session++;
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400986 l->mtu = l->advertised_mtu;
Ying Xuea1f8dd32018-10-11 19:57:56 +0800987
Parthasarathy Bhuvaragan3f32d0b2018-09-25 22:09:10 +0200988 spin_lock_bh(&l->wakeupq.lock);
Ying Xuea1f8dd32018-10-11 19:57:56 +0800989 skb_queue_splice_init(&l->wakeupq, &list);
Parthasarathy Bhuvaragan3f32d0b2018-09-25 22:09:10 +0200990 spin_unlock_bh(&l->wakeupq.lock);
991
Ying Xuea1f8dd32018-10-11 19:57:56 +0800992 spin_lock_bh(&l->inputq->lock);
993 skb_queue_splice_init(&list, l->inputq);
994 spin_unlock_bh(&l->inputq->lock);
995
Jon Paul Maloy6e498152015-07-30 18:24:19 -0400996 __skb_queue_purge(&l->transmq);
997 __skb_queue_purge(&l->deferdq);
Jon Paul Maloy2af5ae32015-10-22 08:51:48 -0400998 __skb_queue_purge(&l->backlogq);
Tuong Lien58ee86b2019-04-04 11:09:53 +0700999 __skb_queue_purge(&l->failover_deferdq);
Tuong Liene95584a2019-10-02 18:49:43 +07001000 for (imp = 0; imp <= TIPC_SYSTEM_IMPORTANCE; imp++) {
1001 l->backlog[imp].len = 0;
1002 l->backlog[imp].target_bskb = NULL;
1003 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001004 kfree_skb(l->reasm_buf);
Tuong Lien2320bcd2019-07-24 08:56:12 +07001005 kfree_skb(l->reasm_tnlmsg);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001006 kfree_skb(l->failover_reasm_skb);
1007 l->reasm_buf = NULL;
Tuong Lien2320bcd2019-07-24 08:56:12 +07001008 l->reasm_tnlmsg = NULL;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001009 l->failover_reasm_skb = NULL;
1010 l->rcv_unacked = 0;
1011 l->snd_nxt = 1;
1012 l->rcv_nxt = 1;
Jon Maloy9012de52018-07-10 01:07:35 +02001013 l->snd_nxt_state = 1;
1014 l->rcv_nxt_state = 1;
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001015 l->acked = 0;
Tuong Liend7626b52020-05-26 16:38:34 +07001016 l->last_gap = 0;
1017 kfree(l->last_ga);
1018 l->last_ga = NULL;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001019 l->silent_intv_cnt = 0;
Jon Paul Maloy88e8ac72016-04-15 13:33:04 -04001020 l->rst_cnt = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001021 l->bc_peer_is_up = false;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001022 memset(&l->mon_state, 0, sizeof(l->mon_state));
Jon Paul Maloy38206d52015-11-19 14:30:46 -05001023 tipc_link_reset_stats(l);
Per Lidenb97bf3f2006-01-02 19:04:38 +01001024}
1025
Per Lidenb97bf3f2006-01-02 19:04:38 +01001026/**
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001027 * tipc_link_xmit(): enqueue buffer list according to queue situation
Andrew Lunnd8141202020-07-13 01:15:14 +02001028 * @l: link to use
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001029 * @list: chain of buffers containing message
1030 * @xmitq: returned list of packets to be sent by caller
1031 *
Jon Paul Maloy365ad352017-01-03 10:55:11 -05001032 * Consumes the buffer chain.
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001033 * Messages at TIPC_SYSTEM_IMPORTANCE are always accepted
Hoang Le86704992021-08-11 08:22:09 +07001034 * Return: 0 if success, or errno: -ELINKCONG, -EMSGSIZE or -ENOBUFS
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001035 */
1036int tipc_link_xmit(struct tipc_link *l, struct sk_buff_head *list,
1037 struct sk_buff_head *xmitq)
1038{
Tuong Lien06e7c702019-11-01 09:58:57 +07001039 struct sk_buff_head *backlogq = &l->backlogq;
1040 struct sk_buff_head *transmq = &l->transmq;
1041 struct sk_buff *skb, *_skb;
1042 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001043 u16 ack = l->rcv_nxt - 1;
1044 u16 seqno = l->snd_nxt;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001045 int pkt_cnt = skb_queue_len(list);
Tuong Lienfc1b6d62019-11-08 12:05:11 +07001046 unsigned int mss = tipc_link_mss(l);
Jon Maloy16ad3f42019-12-10 00:52:46 +01001047 unsigned int cwin = l->window;
Tuong Lien06e7c702019-11-01 09:58:57 +07001048 unsigned int mtu = l->mtu;
Hoang Leb7741342021-01-08 14:13:37 +07001049 struct tipc_msg *hdr;
Tuong Lien06e7c702019-11-01 09:58:57 +07001050 bool new_bundle;
Jon Paul Maloy365ad352017-01-03 10:55:11 -05001051 int rc = 0;
Hoang Leb7741342021-01-08 14:13:37 +07001052 int imp;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001053
Hoang Leb7741342021-01-08 14:13:37 +07001054 if (pkt_cnt <= 0)
1055 return 0;
1056
1057 hdr = buf_msg(skb_peek(list));
Richard Alpe4952cd32016-02-11 10:43:15 +01001058 if (unlikely(msg_size(hdr) > mtu)) {
Tuong Lien2320bcd2019-07-24 08:56:12 +07001059 pr_warn("Too large msg, purging xmit list %d %d %d %d %d!\n",
1060 skb_queue_len(list), msg_user(hdr),
1061 msg_type(hdr), msg_size(hdr), mtu);
Jon Maloye654f9f2019-08-15 16:42:50 +02001062 __skb_queue_purge(list);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001063 return -EMSGSIZE;
Richard Alpe4952cd32016-02-11 10:43:15 +01001064 }
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001065
Hoang Leb7741342021-01-08 14:13:37 +07001066 imp = msg_importance(hdr);
Jon Paul Maloy365ad352017-01-03 10:55:11 -05001067 /* Allow oversubscription of one data msg per source at congestion */
1068 if (unlikely(l->backlog[imp].len >= l->backlog[imp].limit)) {
1069 if (imp == TIPC_SYSTEM_IMPORTANCE) {
1070 pr_warn("%s<%s>, link overflow", link_rst_msg, l->name);
1071 return -ENOBUFS;
1072 }
1073 rc = link_schedule_user(l, hdr);
1074 }
1075
Jon Paul Maloy95901122016-11-25 10:35:02 -05001076 if (pkt_cnt > 1) {
1077 l->stats.sent_fragmented++;
1078 l->stats.sent_fragments += pkt_cnt;
1079 }
1080
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001081 /* Prepare each packet for sending, and add to relevant queue: */
Tuong Lien06e7c702019-11-01 09:58:57 +07001082 while ((skb = __skb_dequeue(list))) {
Jon Maloy16ad3f42019-12-10 00:52:46 +01001083 if (likely(skb_queue_len(transmq) < cwin)) {
Tuong Lien06e7c702019-11-01 09:58:57 +07001084 hdr = buf_msg(skb);
1085 msg_set_seqno(hdr, seqno);
1086 msg_set_ack(hdr, ack);
1087 msg_set_bcast_ack(hdr, bc_ack);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001088 _skb = skb_clone(skb, GFP_ATOMIC);
Richard Alpe4952cd32016-02-11 10:43:15 +01001089 if (!_skb) {
Tuong Lien06e7c702019-11-01 09:58:57 +07001090 kfree_skb(skb);
Jon Maloye654f9f2019-08-15 16:42:50 +02001091 __skb_queue_purge(list);
Hoang Le86704992021-08-11 08:22:09 +07001092 return -ENOBUFS;
Richard Alpe4952cd32016-02-11 10:43:15 +01001093 }
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001094 __skb_queue_tail(transmq, skb);
Hamish Martina34f8292020-07-09 09:06:44 +12001095 tipc_link_set_skb_retransmit_time(skb, l);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001096 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001097 TIPC_SKB_CB(skb)->ackers = l->ackers;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001098 l->rcv_unacked = 0;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001099 l->stats.sent_pkts++;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001100 seqno++;
1101 continue;
1102 }
Tuong Lien06e7c702019-11-01 09:58:57 +07001103 if (tipc_msg_try_bundle(l->backlog[imp].target_bskb, &skb,
Tuong Lienfc1b6d62019-11-08 12:05:11 +07001104 mss, l->addr, &new_bundle)) {
Tuong Lien06e7c702019-11-01 09:58:57 +07001105 if (skb) {
1106 /* Keep a ref. to the skb for next try */
1107 l->backlog[imp].target_bskb = skb;
1108 l->backlog[imp].len++;
1109 __skb_queue_tail(backlogq, skb);
1110 } else {
1111 if (new_bundle) {
1112 l->stats.sent_bundles++;
1113 l->stats.sent_bundled++;
1114 }
1115 l->stats.sent_bundled++;
1116 }
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001117 continue;
1118 }
Tuong Liene95584a2019-10-02 18:49:43 +07001119 l->backlog[imp].target_bskb = NULL;
Tuong Lien06e7c702019-11-01 09:58:57 +07001120 l->backlog[imp].len += (1 + skb_queue_len(list));
1121 __skb_queue_tail(backlogq, skb);
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001122 skb_queue_splice_tail_init(list, backlogq);
1123 }
1124 l->snd_nxt = seqno;
Jon Paul Maloy365ad352017-01-03 10:55:11 -05001125 return rc;
Jon Paul Maloyaf9b0282015-07-16 16:54:24 -04001126}
1127
Jon Maloy16ad3f42019-12-10 00:52:46 +01001128static void tipc_link_update_cwin(struct tipc_link *l, int released,
1129 bool retransmitted)
1130{
1131 int bklog_len = skb_queue_len(&l->backlogq);
1132 struct sk_buff_head *txq = &l->transmq;
1133 int txq_len = skb_queue_len(txq);
1134 u16 cwin = l->window;
1135
1136 /* Enter fast recovery */
1137 if (unlikely(retransmitted)) {
1138 l->ssthresh = max_t(u16, l->window / 2, 300);
Tuong Lienedadedf2020-04-15 18:34:49 +07001139 l->window = min_t(u16, l->ssthresh, l->window);
Jon Maloy16ad3f42019-12-10 00:52:46 +01001140 return;
1141 }
1142 /* Enter slow start */
1143 if (unlikely(!released)) {
1144 l->ssthresh = max_t(u16, l->window / 2, 300);
1145 l->window = l->min_win;
1146 return;
1147 }
1148 /* Don't increase window if no pressure on the transmit queue */
1149 if (txq_len + bklog_len < cwin)
1150 return;
1151
1152 /* Don't increase window if there are holes the transmit queue */
1153 if (txq_len && l->snd_nxt - buf_seqno(skb_peek(txq)) != txq_len)
1154 return;
1155
1156 l->cong_acks += released;
1157
1158 /* Slow start */
1159 if (cwin <= l->ssthresh) {
1160 l->window = min_t(u16, cwin + released, l->max_win);
1161 return;
1162 }
1163 /* Congestion avoidance */
1164 if (l->cong_acks < cwin)
1165 return;
1166 l->window = min_t(u16, ++cwin, l->max_win);
1167 l->cong_acks = 0;
1168}
1169
YueHaibinge064cce2018-07-19 17:16:59 +08001170static void tipc_link_advance_backlog(struct tipc_link *l,
1171 struct sk_buff_head *xmitq)
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001172{
Jon Paul Maloy52666982015-10-22 08:51:41 -04001173 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
Jon Maloy16ad3f42019-12-10 00:52:46 +01001174 struct sk_buff_head *txq = &l->transmq;
1175 struct sk_buff *skb, *_skb;
1176 u16 ack = l->rcv_nxt - 1;
1177 u16 seqno = l->snd_nxt;
1178 struct tipc_msg *hdr;
1179 u16 cwin = l->window;
Tuong Liene95584a2019-10-02 18:49:43 +07001180 u32 imp;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001181
Jon Maloy16ad3f42019-12-10 00:52:46 +01001182 while (skb_queue_len(txq) < cwin) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001183 skb = skb_peek(&l->backlogq);
1184 if (!skb)
1185 break;
1186 _skb = skb_clone(skb, GFP_ATOMIC);
1187 if (!_skb)
1188 break;
1189 __skb_dequeue(&l->backlogq);
1190 hdr = buf_msg(skb);
Tuong Liene95584a2019-10-02 18:49:43 +07001191 imp = msg_importance(hdr);
1192 l->backlog[imp].len--;
1193 if (unlikely(skb == l->backlog[imp].target_bskb))
1194 l->backlog[imp].target_bskb = NULL;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001195 __skb_queue_tail(&l->transmq, skb);
Hamish Martina34f8292020-07-09 09:06:44 +12001196 tipc_link_set_skb_retransmit_time(skb, l);
Hoang Le05572272018-12-19 11:42:19 +07001197
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001198 __skb_queue_tail(xmitq, _skb);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04001199 TIPC_SKB_CB(skb)->ackers = l->ackers;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001200 msg_set_seqno(hdr, seqno);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001201 msg_set_ack(hdr, ack);
1202 msg_set_bcast_ack(hdr, bc_ack);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001203 l->rcv_unacked = 0;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001204 l->stats.sent_pkts++;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001205 seqno++;
1206 }
1207 l->snd_nxt = seqno;
1208}
1209
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001210/**
1211 * link_retransmit_failure() - Detect repeated retransmit failures
1212 * @l: tipc link sender
1213 * @r: tipc link receiver (= l in case of unicast)
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001214 * @rc: returned code
1215 *
1216 * Return: true if the repeated retransmit failures happens, otherwise
1217 * false
1218 */
1219static bool link_retransmit_failure(struct tipc_link *l, struct tipc_link *r,
Tuong Lien71204232019-08-15 10:24:08 +07001220 int *rc)
Allan Stephensd356eeb2006-06-25 23:40:01 -07001221{
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001222 struct sk_buff *skb = skb_peek(&l->transmq);
1223 struct tipc_msg *hdr;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001224
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001225 if (!skb)
1226 return false;
Tuong Lien71204232019-08-15 10:24:08 +07001227
1228 if (!TIPC_SKB_CB(skb)->retr_cnt)
1229 return false;
1230
1231 if (!time_after(jiffies, TIPC_SKB_CB(skb)->retr_stamp +
Hoang Le426071f2019-11-06 13:26:10 +07001232 msecs_to_jiffies(r->tolerance * 10)))
Tuong Lien71204232019-08-15 10:24:08 +07001233 return false;
1234
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001235 hdr = buf_msg(skb);
Tuong Lien71204232019-08-15 10:24:08 +07001236 if (link_is_bc_sndlink(l) && !less(r->acked, msg_seqno(hdr)))
1237 return false;
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001238
Tuong Lien71204232019-08-15 10:24:08 +07001239 pr_warn("Retransmission failure on link <%s>\n", l->name);
1240 link_print(l, "State of link ");
1241 pr_info("Failed msg: usr %u, typ %u, len %u, err %u\n",
1242 msg_user(hdr), msg_type(hdr), msg_size(hdr), msg_errcode(hdr));
1243 pr_info("sqno %u, prev: %x, dest: %x\n",
1244 msg_seqno(hdr), msg_prevnode(hdr), msg_destnode(hdr));
1245 pr_info("retr_stamp %d, retr_cnt %d\n",
1246 jiffies_to_msecs(TIPC_SKB_CB(skb)->retr_stamp),
1247 TIPC_SKB_CB(skb)->retr_cnt);
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001248
Tuong Lien71204232019-08-15 10:24:08 +07001249 trace_tipc_list_dump(&l->transmq, true, "retrans failure!");
1250 trace_tipc_link_dump(l, TIPC_DUMP_NONE, "retrans failure!");
1251 trace_tipc_link_dump(r, TIPC_DUMP_NONE, "retrans failure!");
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001252
Tuong Lien71204232019-08-15 10:24:08 +07001253 if (link_is_bc_sndlink(l)) {
1254 r->state = LINK_RESET;
Tuong Liend7626b52020-05-26 16:38:34 +07001255 *rc |= TIPC_LINK_DOWN_EVT;
Tuong Lien71204232019-08-15 10:24:08 +07001256 } else {
Tuong Liend7626b52020-05-26 16:38:34 +07001257 *rc |= tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001258 }
1259
Tuong Lien71204232019-08-15 10:24:08 +07001260 return true;
Allan Stephensd356eeb2006-06-25 23:40:01 -07001261}
1262
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001263/* tipc_data_input - deliver data and name distr msgs to upper layer
Erik Hugne7ae934b2014-07-01 10:22:40 +02001264 *
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001265 * Consumes buffer if message is of right type
Erik Hugne7ae934b2014-07-01 10:22:40 +02001266 * Node lock must be held
1267 */
Jon Paul Maloy52666982015-10-22 08:51:41 -04001268static bool tipc_data_input(struct tipc_link *l, struct sk_buff *skb,
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001269 struct sk_buff_head *inputq)
Erik Hugne7ae934b2014-07-01 10:22:40 +02001270{
Jon Maloy399574d2017-10-13 11:04:32 +02001271 struct sk_buff_head *mc_inputq = l->bc_rcvlink->inputq;
Jon Paul Maloya853e4c2017-01-18 13:50:52 -05001272 struct tipc_msg *hdr = buf_msg(skb);
1273
1274 switch (msg_user(hdr)) {
Erik Hugne7ae934b2014-07-01 10:22:40 +02001275 case TIPC_LOW_IMPORTANCE:
1276 case TIPC_MEDIUM_IMPORTANCE:
1277 case TIPC_HIGH_IMPORTANCE:
1278 case TIPC_CRITICAL_IMPORTANCE:
Jon Maloy2f487712017-10-13 11:04:31 +02001279 if (unlikely(msg_in_group(hdr) || msg_mcast(hdr))) {
Jon Maloy399574d2017-10-13 11:04:32 +02001280 skb_queue_tail(mc_inputq, skb);
Jon Paul Maloya853e4c2017-01-18 13:50:52 -05001281 return true;
1282 }
Miaohe Lin7f8901b2020-08-18 08:07:13 -04001283 fallthrough;
Jon Maloy2f487712017-10-13 11:04:31 +02001284 case CONN_MANAGER:
Jon Maloy36c0a9d2017-10-16 16:04:51 +02001285 skb_queue_tail(inputq, skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001286 return true;
Jon Maloy399574d2017-10-13 11:04:32 +02001287 case GROUP_PROTOCOL:
1288 skb_queue_tail(mc_inputq, skb);
1289 return true;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001290 case NAME_DISTRIBUTOR:
Jon Paul Maloy52666982015-10-22 08:51:41 -04001291 l->bc_rcvlink->state = LINK_ESTABLISHED;
1292 skb_queue_tail(l->namedq, skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001293 return true;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001294 case MSG_BUNDLER:
Jon Paul Maloydff29b12015-04-02 09:33:01 -04001295 case TUNNEL_PROTOCOL:
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001296 case MSG_FRAGMENTER:
1297 case BCAST_PROTOCOL:
1298 return false;
Tuong Lien1ef6f7c2020-09-18 08:17:28 +07001299#ifdef CONFIG_TIPC_CRYPTO
1300 case MSG_CRYPTO:
Xin Long271351d2021-11-15 07:45:24 -05001301 if (TIPC_SKB_CB(skb)->decrypted) {
1302 tipc_crypto_msg_rcv(l->net, skb);
1303 return true;
1304 }
1305 fallthrough;
Tuong Lien1ef6f7c2020-09-18 08:17:28 +07001306#endif
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001307 default:
1308 pr_warn("Dropping received illegal msg type\n");
1309 kfree_skb(skb);
Hoang Le7384b532019-02-11 09:18:28 +07001310 return true;
Tom Rixf2219c32020-11-01 07:58:22 -08001311 }
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001312}
1313
1314/* tipc_link_input - process packet that has passed link protocol check
1315 *
1316 * Consumes buffer
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001317 */
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001318static int tipc_link_input(struct tipc_link *l, struct sk_buff *skb,
Tuong Lien58ee86b2019-04-04 11:09:53 +07001319 struct sk_buff_head *inputq,
1320 struct sk_buff **reasm_skb)
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001321{
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001322 struct tipc_msg *hdr = buf_msg(skb);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001323 struct sk_buff *iskb;
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001324 struct sk_buff_head tmpq;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001325 int usr = msg_user(hdr);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001326 int pos = 0;
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001327
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001328 if (usr == MSG_BUNDLER) {
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001329 skb_queue_head_init(&tmpq);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001330 l->stats.recv_bundles++;
1331 l->stats.recv_bundled += msg_msgcnt(hdr);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001332 while (tipc_msg_extract(skb, &iskb, &pos))
Jon Paul Maloy9945e802015-10-15 14:52:40 -04001333 tipc_data_input(l, iskb, &tmpq);
1334 tipc_skb_queue_splice_tail(&tmpq, inputq);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001335 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001336 } else if (usr == MSG_FRAGMENTER) {
1337 l->stats.recv_fragments++;
1338 if (tipc_buf_append(reasm_skb, &skb)) {
1339 l->stats.recv_fragmented++;
Jon Paul Maloy9073fb82015-07-30 18:24:25 -04001340 tipc_data_input(l, skb, inputq);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001341 } else if (!*reasm_skb && !link_is_bc_rcvlink(l)) {
1342 pr_warn_ratelimited("Unable to build fragment list\n");
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001343 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Paul Maloyc637c102015-02-05 08:36:41 -05001344 }
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001345 return 0;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001346 } else if (usr == BCAST_PROTOCOL) {
Jon Paul Maloyc72fa872015-10-22 08:51:46 -04001347 tipc_bcast_lock(l->net);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001348 tipc_link_bc_init_rcv(l->bc_rcvlink, hdr);
Jon Paul Maloyc72fa872015-10-22 08:51:46 -04001349 tipc_bcast_unlock(l->net);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001350 }
Tuong Lien58ee86b2019-04-04 11:09:53 +07001351
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001352 kfree_skb(skb);
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001353 return 0;
Erik Hugne7ae934b2014-07-01 10:22:40 +02001354}
1355
Tuong Lien58ee86b2019-04-04 11:09:53 +07001356/* tipc_link_tnl_rcv() - receive TUNNEL_PROTOCOL message, drop or process the
1357 * inner message along with the ones in the old link's
1358 * deferdq
1359 * @l: tunnel link
1360 * @skb: TUNNEL_PROTOCOL message
1361 * @inputq: queue to put messages ready for delivery
1362 */
1363static int tipc_link_tnl_rcv(struct tipc_link *l, struct sk_buff *skb,
1364 struct sk_buff_head *inputq)
1365{
1366 struct sk_buff **reasm_skb = &l->failover_reasm_skb;
Tuong Lien2320bcd2019-07-24 08:56:12 +07001367 struct sk_buff **reasm_tnlmsg = &l->reasm_tnlmsg;
Tuong Lien58ee86b2019-04-04 11:09:53 +07001368 struct sk_buff_head *fdefq = &l->failover_deferdq;
1369 struct tipc_msg *hdr = buf_msg(skb);
1370 struct sk_buff *iskb;
1371 int ipos = 0;
1372 int rc = 0;
1373 u16 seqno;
1374
Tuong Lien2320bcd2019-07-24 08:56:12 +07001375 if (msg_type(hdr) == SYNCH_MSG) {
1376 kfree_skb(skb);
1377 return 0;
1378 }
Tuong Lien58ee86b2019-04-04 11:09:53 +07001379
Tuong Lien2320bcd2019-07-24 08:56:12 +07001380 /* Not a fragment? */
1381 if (likely(!msg_nof_fragms(hdr))) {
1382 if (unlikely(!tipc_msg_extract(skb, &iskb, &ipos))) {
1383 pr_warn_ratelimited("Unable to extract msg, defq: %d\n",
1384 skb_queue_len(fdefq));
1385 return 0;
1386 }
1387 kfree_skb(skb);
1388 } else {
1389 /* Set fragment type for buf_append */
1390 if (msg_fragm_no(hdr) == 1)
1391 msg_set_type(hdr, FIRST_FRAGMENT);
1392 else if (msg_fragm_no(hdr) < msg_nof_fragms(hdr))
1393 msg_set_type(hdr, FRAGMENT);
1394 else
1395 msg_set_type(hdr, LAST_FRAGMENT);
1396
1397 if (!tipc_buf_append(reasm_tnlmsg, &skb)) {
1398 /* Successful but non-complete reassembly? */
1399 if (*reasm_tnlmsg || link_is_bc_rcvlink(l))
1400 return 0;
1401 pr_warn_ratelimited("Unable to reassemble tunnel msg\n");
1402 return tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
1403 }
1404 iskb = skb;
Tuong Lien58ee86b2019-04-04 11:09:53 +07001405 }
1406
1407 do {
1408 seqno = buf_seqno(iskb);
Tuong Lien58ee86b2019-04-04 11:09:53 +07001409 if (unlikely(less(seqno, l->drop_point))) {
1410 kfree_skb(iskb);
1411 continue;
1412 }
Tuong Lien58ee86b2019-04-04 11:09:53 +07001413 if (unlikely(seqno != l->drop_point)) {
1414 __tipc_skb_queue_sorted(fdefq, seqno, iskb);
1415 continue;
1416 }
1417
1418 l->drop_point++;
Tuong Lien58ee86b2019-04-04 11:09:53 +07001419 if (!tipc_data_input(l, iskb, inputq))
1420 rc |= tipc_link_input(l, iskb, inputq, reasm_skb);
1421 if (unlikely(rc))
1422 break;
1423 } while ((iskb = __tipc_skb_dequeue(fdefq, l->drop_point)));
1424
Tuong Lien58ee86b2019-04-04 11:09:53 +07001425 return rc;
1426}
1427
Tuong Liend7626b52020-05-26 16:38:34 +07001428/**
1429 * tipc_get_gap_ack_blks - get Gap ACK blocks from PROTOCOL/STATE_MSG
1430 * @ga: returned pointer to the Gap ACK blocks if any
1431 * @l: the tipc link
1432 * @hdr: the PROTOCOL/STATE_MSG header
1433 * @uc: desired Gap ACK blocks type, i.e. unicast (= 1) or broadcast (= 0)
1434 *
1435 * Return: the total Gap ACK blocks size
1436 */
1437u16 tipc_get_gap_ack_blks(struct tipc_gap_ack_blks **ga, struct tipc_link *l,
1438 struct tipc_msg *hdr, bool uc)
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001439{
Tuong Liend7626b52020-05-26 16:38:34 +07001440 struct tipc_gap_ack_blks *p;
1441 u16 sz = 0;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001442
Tuong Liend7626b52020-05-26 16:38:34 +07001443 /* Does peer support the Gap ACK blocks feature? */
1444 if (l->peer_caps & TIPC_GAP_ACK_BLOCK) {
1445 p = (struct tipc_gap_ack_blks *)msg_data(hdr);
1446 sz = ntohs(p->len);
1447 /* Sanity check */
Gustavo A. R. Silvae034c6d2020-06-18 08:35:00 -05001448 if (sz == struct_size(p, gacks, p->ugack_cnt + p->bgack_cnt)) {
Tuong Liend7626b52020-05-26 16:38:34 +07001449 /* Good, check if the desired type exists */
1450 if ((uc && p->ugack_cnt) || (!uc && p->bgack_cnt))
1451 goto ok;
1452 /* Backward compatible: peer might not support bc, but uc? */
Gustavo A. R. Silvae034c6d2020-06-18 08:35:00 -05001453 } else if (uc && sz == struct_size(p, gacks, p->ugack_cnt)) {
Tuong Liend7626b52020-05-26 16:38:34 +07001454 if (p->ugack_cnt) {
1455 p->bgack_cnt = 0;
1456 goto ok;
1457 }
1458 }
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001459 }
Tuong Liend7626b52020-05-26 16:38:34 +07001460 /* Other cases: ignore! */
1461 p = NULL;
1462
1463ok:
1464 *ga = p;
1465 return sz;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001466}
1467
Tuong Liend7626b52020-05-26 16:38:34 +07001468static u8 __tipc_build_gap_ack_blks(struct tipc_gap_ack_blks *ga,
1469 struct tipc_link *l, u8 start_index)
Tuong Lien91959482019-04-04 11:09:51 +07001470{
Tuong Liend7626b52020-05-26 16:38:34 +07001471 struct tipc_gap_ack *gacks = &ga->gacks[start_index];
Tuong Lien91959482019-04-04 11:09:51 +07001472 struct sk_buff *skb = skb_peek(&l->deferdq);
Tuong Liend7626b52020-05-26 16:38:34 +07001473 u16 expect, seqno = 0;
Tuong Lien91959482019-04-04 11:09:51 +07001474 u8 n = 0;
1475
Tuong Liend7626b52020-05-26 16:38:34 +07001476 if (!skb)
1477 return 0;
Tuong Lien91959482019-04-04 11:09:51 +07001478
1479 expect = buf_seqno(skb);
1480 skb_queue_walk(&l->deferdq, skb) {
1481 seqno = buf_seqno(skb);
1482 if (unlikely(more(seqno, expect))) {
Tuong Liend7626b52020-05-26 16:38:34 +07001483 gacks[n].ack = htons(expect - 1);
1484 gacks[n].gap = htons(seqno - expect);
1485 if (++n >= MAX_GAP_ACK_BLKS / 2) {
Tuong Liend7626b52020-05-26 16:38:34 +07001486 pr_info_ratelimited("Gacks on %s: %d, ql: %d!\n",
Tuong Lien03b6fef2020-05-26 16:38:37 +07001487 l->name, n,
Tuong Liend7626b52020-05-26 16:38:34 +07001488 skb_queue_len(&l->deferdq));
1489 return n;
Tuong Lien91959482019-04-04 11:09:51 +07001490 }
1491 } else if (unlikely(less(seqno, expect))) {
1492 pr_warn("Unexpected skb in deferdq!\n");
1493 continue;
1494 }
1495 expect = seqno + 1;
1496 }
1497
1498 /* last block */
Tuong Liend7626b52020-05-26 16:38:34 +07001499 gacks[n].ack = htons(seqno);
1500 gacks[n].gap = 0;
Tuong Lien91959482019-04-04 11:09:51 +07001501 n++;
Tuong Liend7626b52020-05-26 16:38:34 +07001502 return n;
1503}
Tuong Lien91959482019-04-04 11:09:51 +07001504
Tuong Liend7626b52020-05-26 16:38:34 +07001505/* tipc_build_gap_ack_blks - build Gap ACK blocks
1506 * @l: tipc unicast link
1507 * @hdr: the tipc message buffer to store the Gap ACK blocks after built
1508 *
1509 * The function builds Gap ACK blocks for both the unicast & broadcast receiver
1510 * links of a certain peer, the buffer after built has the network data format
1511 * as found at the struct tipc_gap_ack_blks definition.
1512 *
1513 * returns the actual allocated memory size
1514 */
1515static u16 tipc_build_gap_ack_blks(struct tipc_link *l, struct tipc_msg *hdr)
1516{
1517 struct tipc_link *bcl = l->bc_rcvlink;
1518 struct tipc_gap_ack_blks *ga;
1519 u16 len;
1520
1521 ga = (struct tipc_gap_ack_blks *)msg_data(hdr);
1522
1523 /* Start with broadcast link first */
1524 tipc_bcast_lock(bcl->net);
1525 msg_set_bcast_ack(hdr, bcl->rcv_nxt - 1);
1526 msg_set_bc_gap(hdr, link_bc_rcv_gap(bcl));
1527 ga->bgack_cnt = __tipc_build_gap_ack_blks(ga, bcl, 0);
1528 tipc_bcast_unlock(bcl->net);
1529
1530 /* Now for unicast link, but an explicit NACK only (???) */
1531 ga->ugack_cnt = (msg_seq_gap(hdr)) ?
1532 __tipc_build_gap_ack_blks(ga, l, ga->bgack_cnt) : 0;
1533
1534 /* Total len */
Gustavo A. R. Silvae034c6d2020-06-18 08:35:00 -05001535 len = struct_size(ga, gacks, ga->bgack_cnt + ga->ugack_cnt);
Tuong Lien91959482019-04-04 11:09:51 +07001536 ga->len = htons(len);
Tuong Lien91959482019-04-04 11:09:51 +07001537 return len;
1538}
1539
1540/* tipc_link_advance_transmq - advance TIPC link transmq queue by releasing
1541 * acked packets, also doing retransmissions if
1542 * gaps found
1543 * @l: tipc link with transmq queue to be advanced
Tuong Liend7626b52020-05-26 16:38:34 +07001544 * @r: tipc link "receiver" i.e. in case of broadcast (= "l" if unicast)
Tuong Lien91959482019-04-04 11:09:51 +07001545 * @acked: seqno of last packet acked by peer without any gaps before
1546 * @gap: # of gap packets
1547 * @ga: buffer pointer to Gap ACK blocks from peer
1548 * @xmitq: queue for accumulating the retransmitted packets if any
Tuong Liend7626b52020-05-26 16:38:34 +07001549 * @retransmitted: returned boolean value if a retransmission is really issued
1550 * @rc: returned code e.g. TIPC_LINK_DOWN_EVT if a repeated retransmit failures
1551 * happens (- unlikely case)
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001552 *
Tuong Liend7626b52020-05-26 16:38:34 +07001553 * Return: the number of packets released from the link transmq
Tuong Lien91959482019-04-04 11:09:51 +07001554 */
Tuong Liend7626b52020-05-26 16:38:34 +07001555static int tipc_link_advance_transmq(struct tipc_link *l, struct tipc_link *r,
1556 u16 acked, u16 gap,
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001557 struct tipc_gap_ack_blks *ga,
Tuong Liend7626b52020-05-26 16:38:34 +07001558 struct sk_buff_head *xmitq,
1559 bool *retransmitted, int *rc)
Tuong Lien91959482019-04-04 11:09:51 +07001560{
Tuong Liend7626b52020-05-26 16:38:34 +07001561 struct tipc_gap_ack_blks *last_ga = r->last_ga, *this_ga = NULL;
1562 struct tipc_gap_ack *gacks = NULL;
Tuong Lien91959482019-04-04 11:09:51 +07001563 struct sk_buff *skb, *_skb, *tmp;
1564 struct tipc_msg *hdr;
Tuong Liend7626b52020-05-26 16:38:34 +07001565 u32 qlen = skb_queue_len(&l->transmq);
1566 u16 nacked = acked, ngap = gap, gack_cnt = 0;
Tuong Lien91959482019-04-04 11:09:51 +07001567 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1;
1568 u16 ack = l->rcv_nxt - 1;
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001569 u16 seqno, n = 0;
Tuong Liend7626b52020-05-26 16:38:34 +07001570 u16 end = r->acked, start = end, offset = r->last_gap;
1571 u16 si = (last_ga) ? last_ga->start_index : 0;
1572 bool is_uc = !link_is_bc_sndlink(l);
1573 bool bc_has_acked = false;
Tuong Lien6a6b5c82019-06-17 12:15:42 +07001574
Tuong Lienc6ed7a52020-05-26 16:38:35 +07001575 trace_tipc_link_retrans(r, acked + 1, acked + gap, &l->transmq);
1576
Tuong Liend7626b52020-05-26 16:38:34 +07001577 /* Determine Gap ACK blocks if any for the particular link */
1578 if (ga && is_uc) {
1579 /* Get the Gap ACKs, uc part */
1580 gack_cnt = ga->ugack_cnt;
1581 gacks = &ga->gacks[ga->bgack_cnt];
1582 } else if (ga) {
1583 /* Copy the Gap ACKs, bc part, for later renewal if needed */
Gustavo A. R. Silvae034c6d2020-06-18 08:35:00 -05001584 this_ga = kmemdup(ga, struct_size(ga, gacks, ga->bgack_cnt),
Tuong Liend7626b52020-05-26 16:38:34 +07001585 GFP_ATOMIC);
1586 if (likely(this_ga)) {
1587 this_ga->start_index = 0;
1588 /* Start with the bc Gap ACKs */
1589 gack_cnt = this_ga->bgack_cnt;
1590 gacks = &this_ga->gacks[0];
1591 } else {
1592 /* Hmm, we can get in trouble..., simply ignore it */
1593 pr_warn_ratelimited("Ignoring bc Gap ACKs, no memory\n");
1594 }
1595 }
1596
1597 /* Advance the link transmq */
Tuong Lien91959482019-04-04 11:09:51 +07001598 skb_queue_walk_safe(&l->transmq, skb, tmp) {
1599 seqno = buf_seqno(skb);
1600
1601next_gap_ack:
Tuong Liend7626b52020-05-26 16:38:34 +07001602 if (less_eq(seqno, nacked)) {
1603 if (is_uc)
1604 goto release;
1605 /* Skip packets peer has already acked */
1606 if (!more(seqno, r->acked))
1607 continue;
1608 /* Get the next of last Gap ACK blocks */
1609 while (more(seqno, end)) {
1610 if (!last_ga || si >= last_ga->bgack_cnt)
1611 break;
1612 start = end + offset + 1;
1613 end = ntohs(last_ga->gacks[si].ack);
1614 offset = ntohs(last_ga->gacks[si].gap);
1615 si++;
1616 WARN_ONCE(more(start, end) ||
1617 (!offset &&
1618 si < last_ga->bgack_cnt) ||
1619 si > MAX_GAP_ACK_BLKS,
1620 "Corrupted Gap ACK: %d %d %d %d %d\n",
1621 start, end, offset, si,
1622 last_ga->bgack_cnt);
1623 }
1624 /* Check against the last Gap ACK block */
1625 if (in_range(seqno, start, end))
1626 continue;
1627 /* Update/release the packet peer is acking */
1628 bc_has_acked = true;
1629 if (--TIPC_SKB_CB(skb)->ackers)
1630 continue;
1631release:
Tuong Lien91959482019-04-04 11:09:51 +07001632 /* release skb */
1633 __skb_unlink(skb, &l->transmq);
1634 kfree_skb(skb);
Tuong Liend7626b52020-05-26 16:38:34 +07001635 } else if (less_eq(seqno, nacked + ngap)) {
1636 /* First gap: check if repeated retrans failures? */
1637 if (unlikely(seqno == acked + 1 &&
1638 link_retransmit_failure(l, r, rc))) {
1639 /* Ignore this bc Gap ACKs if any */
1640 kfree(this_ga);
1641 this_ga = NULL;
1642 break;
1643 }
Tuong Lien71204232019-08-15 10:24:08 +07001644 /* retransmit skb if unrestricted*/
Tuong Lien382f5982019-04-04 11:09:52 +07001645 if (time_before(jiffies, TIPC_SKB_CB(skb)->nxt_retr))
1646 continue;
Hamish Martina34f8292020-07-09 09:06:44 +12001647 tipc_link_set_skb_retransmit_time(skb, l);
Tuong Lienfc1b6d62019-11-08 12:05:11 +07001648 _skb = pskb_copy(skb, GFP_ATOMIC);
Tuong Lien91959482019-04-04 11:09:51 +07001649 if (!_skb)
1650 continue;
1651 hdr = buf_msg(_skb);
1652 msg_set_ack(hdr, ack);
1653 msg_set_bcast_ack(hdr, bc_ack);
1654 _skb->priority = TC_PRIO_CONTROL;
1655 __skb_queue_tail(xmitq, _skb);
1656 l->stats.retransmitted++;
Tuong Lien03b6fef2020-05-26 16:38:37 +07001657 if (!is_uc)
1658 r->stats.retransmitted++;
Tuong Liend7626b52020-05-26 16:38:34 +07001659 *retransmitted = true;
Tuong Lien71204232019-08-15 10:24:08 +07001660 /* Increase actual retrans counter & mark first time */
1661 if (!TIPC_SKB_CB(skb)->retr_cnt++)
1662 TIPC_SKB_CB(skb)->retr_stamp = jiffies;
Tuong Lien91959482019-04-04 11:09:51 +07001663 } else {
1664 /* retry with Gap ACK blocks if any */
Tuong Liend7626b52020-05-26 16:38:34 +07001665 if (n >= gack_cnt)
Tuong Lien91959482019-04-04 11:09:51 +07001666 break;
Tuong Liend7626b52020-05-26 16:38:34 +07001667 nacked = ntohs(gacks[n].ack);
1668 ngap = ntohs(gacks[n].gap);
Tuong Lien91959482019-04-04 11:09:51 +07001669 n++;
1670 goto next_gap_ack;
1671 }
1672 }
Tuong Liend7626b52020-05-26 16:38:34 +07001673
1674 /* Renew last Gap ACK blocks for bc if needed */
1675 if (bc_has_acked) {
1676 if (this_ga) {
1677 kfree(last_ga);
1678 r->last_ga = this_ga;
1679 r->last_gap = gap;
1680 } else if (last_ga) {
1681 if (less(acked, start)) {
1682 si--;
1683 offset = start - acked - 1;
1684 } else if (less(acked, end)) {
1685 acked = end;
1686 }
1687 if (si < last_ga->bgack_cnt) {
1688 last_ga->start_index = si;
1689 r->last_gap = offset;
1690 } else {
1691 kfree(last_ga);
1692 r->last_ga = NULL;
1693 r->last_gap = 0;
1694 }
1695 } else {
1696 r->last_gap = 0;
1697 }
1698 r->acked = acked;
1699 } else {
1700 kfree(this_ga);
1701 }
1702
1703 return qlen - skb_queue_len(&l->transmq);
Tuong Lien91959482019-04-04 11:09:51 +07001704}
1705
Jon Paul Maloy34b9cd62016-04-15 13:33:07 -04001706/* tipc_link_build_state_msg: prepare link state message for transmission
Jon Paul Maloy52666982015-10-22 08:51:41 -04001707 *
1708 * Note that sending of broadcast ack is coordinated among nodes, to reduce
1709 * risk of ack storms towards the sender
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001710 */
Jon Paul Maloy34b9cd62016-04-15 13:33:07 -04001711int tipc_link_build_state_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001712{
Jon Paul Maloy52666982015-10-22 08:51:41 -04001713 if (!l)
1714 return 0;
1715
1716 /* Broadcast ACK must be sent via a unicast link => defer to caller */
1717 if (link_is_bc_rcvlink(l)) {
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001718 if (((l->rcv_nxt ^ tipc_own_addr(l->net)) & 0xf) != 0xf)
Jon Paul Maloy52666982015-10-22 08:51:41 -04001719 return 0;
1720 l->rcv_unacked = 0;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001721
1722 /* Use snd_nxt to store peer's snd_nxt in broadcast rcv link */
1723 l->snd_nxt = l->rcv_nxt;
1724 return TIPC_LINK_SND_STATE;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001725 }
Jon Paul Maloy52666982015-10-22 08:51:41 -04001726 /* Unicast ACK */
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001727 l->rcv_unacked = 0;
1728 l->stats.sent_acks++;
Jon Maloy8d6e79d2017-11-08 09:59:26 +01001729 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, 0, xmitq);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001730 return 0;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001731}
1732
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001733/* tipc_link_build_reset_msg: prepare link RESET or ACTIVATE message
1734 */
1735void tipc_link_build_reset_msg(struct tipc_link *l, struct sk_buff_head *xmitq)
1736{
1737 int mtyp = RESET_MSG;
Jon Paul Maloy634696b2016-04-15 13:33:03 -04001738 struct sk_buff *skb;
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001739
1740 if (l->state == LINK_ESTABLISHING)
1741 mtyp = ACTIVATE_MSG;
1742
Jon Maloy8d6e79d2017-11-08 09:59:26 +01001743 tipc_link_build_proto_msg(l, mtyp, 0, 0, 0, 0, 0, xmitq);
Jon Paul Maloy634696b2016-04-15 13:33:03 -04001744
1745 /* Inform peer that this endpoint is going down if applicable */
1746 skb = skb_peek_tail(xmitq);
1747 if (skb && (l->state == LINK_RESET))
1748 msg_set_peer_stopping(buf_msg(skb), 1);
Jon Paul Maloy282b3a02015-10-15 14:52:45 -04001749}
1750
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001751/* tipc_link_build_nack_msg: prepare link nack message for transmission
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001752 * Note that sending of broadcast NACK is coordinated among nodes, to
1753 * reduce the risk of NACK storms towards the sender
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001754 */
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001755static int tipc_link_build_nack_msg(struct tipc_link *l,
1756 struct sk_buff_head *xmitq)
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001757{
1758 u32 def_cnt = ++l->stats.deferred_recv;
Jon Maloy02288242019-12-10 00:52:44 +01001759 struct sk_buff_head *dfq = &l->deferdq;
1760 u32 defq_len = skb_queue_len(dfq);
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001761 int match1, match2;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001762
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001763 if (link_is_bc_rcvlink(l)) {
1764 match1 = def_cnt & 0xf;
1765 match2 = tipc_own_addr(l->net) & 0xf;
1766 if (match1 == match2)
1767 return TIPC_LINK_SND_STATE;
1768 return 0;
1769 }
Jon Paul Maloy52666982015-10-22 08:51:41 -04001770
Jon Maloy02288242019-12-10 00:52:44 +01001771 if (defq_len >= 3 && !((defq_len - 3) % 16)) {
1772 u16 rcvgap = buf_seqno(skb_peek(dfq)) - l->rcv_nxt;
1773
1774 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0,
1775 rcvgap, 0, 0, xmitq);
1776 }
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001777 return 0;
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001778}
1779
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001780/* tipc_link_rcv - process TIPC packets/messages arriving from off-node
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001781 * @l: the link that should handle the message
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001782 * @skb: TIPC packet
1783 * @xmitq: queue to place packets to be sent after this call
1784 */
1785int tipc_link_rcv(struct tipc_link *l, struct sk_buff *skb,
1786 struct sk_buff_head *xmitq)
1787{
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001788 struct sk_buff_head *defq = &l->deferdq;
Tuong Lien382f5982019-04-04 11:09:52 +07001789 struct tipc_msg *hdr = buf_msg(skb);
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001790 u16 seqno, rcv_nxt, win_lim;
Jon Maloy16ad3f42019-12-10 00:52:46 +01001791 int released = 0;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001792 int rc = 0;
1793
Tuong Lien382f5982019-04-04 11:09:52 +07001794 /* Verify and update link state */
1795 if (unlikely(msg_user(hdr) == LINK_PROTOCOL))
1796 return tipc_link_proto_rcv(l, skb, xmitq);
1797
1798 /* Don't send probe at next timeout expiration */
1799 l->silent_intv_cnt = 0;
1800
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001801 do {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001802 hdr = buf_msg(skb);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001803 seqno = msg_seqno(hdr);
1804 rcv_nxt = l->rcv_nxt;
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001805 win_lim = rcv_nxt + TIPC_MAX_LINK_WIN;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001806
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001807 if (unlikely(!link_is_up(l))) {
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04001808 if (l->state == LINK_ESTABLISHING)
1809 rc = TIPC_LINK_UP_EVT;
Jon Maloy16ad3f42019-12-10 00:52:46 +01001810 kfree_skb(skb);
1811 break;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001812 }
1813
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001814 /* Drop if outside receive window */
1815 if (unlikely(less(seqno, rcv_nxt) || more(seqno, win_lim))) {
1816 l->stats.duplicates++;
Jon Maloy16ad3f42019-12-10 00:52:46 +01001817 kfree_skb(skb);
1818 break;
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001819 }
Tuong Liend7626b52020-05-26 16:38:34 +07001820 released += tipc_link_advance_transmq(l, l, msg_ack(hdr), 0,
1821 NULL, NULL, NULL, NULL);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001822
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001823 /* Defer delivery if sequence gap */
1824 if (unlikely(seqno != rcv_nxt)) {
Tuong Lien03b6fef2020-05-26 16:38:37 +07001825 if (!__tipc_skb_queue_sorted(defq, seqno, skb))
1826 l->stats.duplicates++;
Jon Paul Maloye0a05eb2016-09-01 13:52:51 -04001827 rc |= tipc_link_build_nack_msg(l, xmitq);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001828 break;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001829 }
1830
Jon Paul Maloy81204c42015-10-15 14:52:42 -04001831 /* Deliver packet */
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001832 l->rcv_nxt++;
Jon Paul Maloy95901122016-11-25 10:35:02 -05001833 l->stats.recv_pkts++;
Tuong Lien58ee86b2019-04-04 11:09:53 +07001834
1835 if (unlikely(msg_user(hdr) == TUNNEL_PROTOCOL))
1836 rc |= tipc_link_tnl_rcv(l, skb, l->inputq);
1837 else if (!tipc_data_input(l, skb, l->inputq))
1838 rc |= tipc_link_input(l, skb, l->inputq, &l->reasm_buf);
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001839 if (unlikely(++l->rcv_unacked >= TIPC_MIN_LINK_WIN))
Jon Paul Maloy34b9cd62016-04-15 13:33:07 -04001840 rc |= tipc_link_build_state_msg(l, xmitq);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001841 if (unlikely(rc & ~TIPC_LINK_SND_STATE))
Jon Paul Maloy52666982015-10-22 08:51:41 -04001842 break;
Tuong Lien382f5982019-04-04 11:09:52 +07001843 } while ((skb = __tipc_skb_dequeue(defq, l->rcv_nxt)));
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001844
Jon Maloy16ad3f42019-12-10 00:52:46 +01001845 /* Forward queues and wake up waiting users */
1846 if (released) {
1847 tipc_link_update_cwin(l, released, 0);
1848 tipc_link_advance_backlog(l, xmitq);
1849 if (unlikely(!skb_queue_empty(&l->wakeupq)))
1850 link_prepare_wakeup(l);
1851 }
Jon Paul Maloyd9992972015-07-16 16:54:31 -04001852 return rc;
1853}
1854
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001855static void tipc_link_build_proto_msg(struct tipc_link *l, int mtyp, bool probe,
Jon Maloy8d6e79d2017-11-08 09:59:26 +01001856 bool probe_reply, u16 rcvgap,
1857 int tolerance, int priority,
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001858 struct sk_buff_head *xmitq)
1859{
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001860 struct tipc_mon_state *mstate = &l->mon_state;
Tuong Lien03b6fef2020-05-26 16:38:37 +07001861 struct sk_buff_head *dfq = &l->deferdq;
1862 struct tipc_link *bcl = l->bc_rcvlink;
1863 struct tipc_msg *hdr;
1864 struct sk_buff *skb;
1865 bool node_up = link_is_up(bcl);
1866 u16 glen = 0, bc_rcvgap = 0;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001867 int dlen = 0;
1868 void *data;
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001869
1870 /* Don't send protocol message during reset or link failover */
Jon Paul Maloy662921c2015-07-30 18:24:21 -04001871 if (tipc_link_is_blocked(l))
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001872 return;
1873
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001874 if (!tipc_link_is_up(l) && (mtyp == STATE_MSG))
1875 return;
1876
Jon Maloy02288242019-12-10 00:52:44 +01001877 if ((probe || probe_reply) && !skb_queue_empty(dfq))
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001878 rcvgap = buf_seqno(skb_peek(dfq)) - l->rcv_nxt;
1879
1880 skb = tipc_msg_create(LINK_PROTOCOL, mtyp, INT_H_SIZE,
Tuong Lien91959482019-04-04 11:09:51 +07001881 tipc_max_domain_size + MAX_GAP_ACK_BLKS_SZ,
1882 l->addr, tipc_own_addr(l->net), 0, 0, 0);
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001883 if (!skb)
1884 return;
1885
1886 hdr = buf_msg(skb);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001887 data = msg_data(hdr);
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001888 msg_set_session(hdr, l->session);
1889 msg_set_bearer_id(hdr, l->bearer_id);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001890 msg_set_net_plane(hdr, l->net_plane);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001891 msg_set_next_sent(hdr, l->snd_nxt);
1892 msg_set_ack(hdr, l->rcv_nxt - 1);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04001893 msg_set_bcast_ack(hdr, bcl->rcv_nxt - 1);
Jon Paul Maloy06bd2b12016-10-27 18:51:55 -04001894 msg_set_bc_ack_invalid(hdr, !node_up);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001895 msg_set_last_bcast(hdr, l->bc_sndlink->snd_nxt - 1);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001896 msg_set_link_tolerance(hdr, tolerance);
1897 msg_set_linkprio(hdr, priority);
1898 msg_set_redundant_link(hdr, node_up);
1899 msg_set_seq_gap(hdr, 0);
Jon Paul Maloy52666982015-10-22 08:51:41 -04001900 msg_set_seqno(hdr, l->snd_nxt + U16_MAX / 2);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001901
1902 if (mtyp == STATE_MSG) {
Jon Maloy9012de52018-07-10 01:07:35 +02001903 if (l->peer_caps & TIPC_LINK_PROTO_SEQNO)
1904 msg_set_seqno(hdr, l->snd_nxt_state++);
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001905 msg_set_seq_gap(hdr, rcvgap);
Tuong Lien03b6fef2020-05-26 16:38:37 +07001906 bc_rcvgap = link_bc_rcv_gap(bcl);
1907 msg_set_bc_gap(hdr, bc_rcvgap);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001908 msg_set_probe(hdr, probe);
Jon Maloy8d6e79d2017-11-08 09:59:26 +01001909 msg_set_is_keepalive(hdr, probe || probe_reply);
Tuong Lien91959482019-04-04 11:09:51 +07001910 if (l->peer_caps & TIPC_GAP_ACK_BLOCK)
Tuong Liend7626b52020-05-26 16:38:34 +07001911 glen = tipc_build_gap_ack_blks(l, hdr);
Tuong Lien91959482019-04-04 11:09:51 +07001912 tipc_mon_prep(l->net, data + glen, &dlen, mstate, l->bearer_id);
1913 msg_set_size(hdr, INT_H_SIZE + glen + dlen);
1914 skb_trim(skb, INT_H_SIZE + glen + dlen);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001915 l->stats.sent_states++;
Jon Paul Maloy52666982015-10-22 08:51:41 -04001916 l->rcv_unacked = 0;
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001917 } else {
1918 /* RESET_MSG or ACTIVATE_MSG */
Tuong Lien91986ee2019-02-11 13:29:43 +07001919 if (mtyp == ACTIVATE_MSG) {
1920 msg_set_dest_session_valid(hdr, 1);
1921 msg_set_dest_session(hdr, l->peer_session);
1922 }
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001923 msg_set_max_pkt(hdr, l->advertised_mtu);
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04001924 strcpy(data, l->if_name);
1925 msg_set_size(hdr, INT_H_SIZE + TIPC_MAX_IF_NAME);
1926 skb_trim(skb, INT_H_SIZE + TIPC_MAX_IF_NAME);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001927 }
Jon Paul Maloye74a3862016-03-03 14:23:21 -05001928 if (probe)
1929 l->stats.sent_probes++;
1930 if (rcvgap)
1931 l->stats.sent_nacks++;
Tuong Lien03b6fef2020-05-26 16:38:37 +07001932 if (bc_rcvgap)
1933 bcl->stats.sent_nacks++;
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001934 skb->priority = TC_PRIO_CONTROL;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001935 __skb_queue_tail(xmitq, skb);
Tuong Lien26574db2018-12-19 09:17:57 +07001936 trace_tipc_proto_build(skb, false, l->name);
Jon Paul Maloy426cc2b2015-07-16 16:54:26 -04001937}
Per Lidenb97bf3f2006-01-02 19:04:38 +01001938
LUU Duc Canhc140eb12018-09-26 21:00:54 +02001939void tipc_link_create_dummy_tnl_msg(struct tipc_link *l,
1940 struct sk_buff_head *xmitq)
1941{
1942 u32 onode = tipc_own_addr(l->net);
1943 struct tipc_msg *hdr, *ihdr;
1944 struct sk_buff_head tnlq;
1945 struct sk_buff *skb;
1946 u32 dnode = l->addr;
1947
Jon Maloye654f9f2019-08-15 16:42:50 +02001948 __skb_queue_head_init(&tnlq);
LUU Duc Canhc140eb12018-09-26 21:00:54 +02001949 skb = tipc_msg_create(TUNNEL_PROTOCOL, FAILOVER_MSG,
1950 INT_H_SIZE, BASIC_H_SIZE,
1951 dnode, onode, 0, 0, 0);
1952 if (!skb) {
1953 pr_warn("%sunable to create tunnel packet\n", link_co_err);
1954 return;
1955 }
1956
1957 hdr = buf_msg(skb);
1958 msg_set_msgcnt(hdr, 1);
1959 msg_set_bearer_id(hdr, l->peer_bearer_id);
1960
1961 ihdr = (struct tipc_msg *)msg_data(hdr);
1962 tipc_msg_init(onode, ihdr, TIPC_LOW_IMPORTANCE, TIPC_DIRECT_MSG,
1963 BASIC_H_SIZE, dnode);
1964 msg_set_errcode(ihdr, TIPC_ERR_NO_PORT);
1965 __skb_queue_tail(&tnlq, skb);
1966 tipc_link_xmit(l, &tnlq, xmitq);
1967}
1968
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001969/* tipc_link_tnl_prepare(): prepare and return a list of tunnel packets
Jon Paul Maloyf9aa3582015-10-15 14:52:41 -04001970 * with contents of the link's transmit and backlog queues.
Per Lidenb97bf3f2006-01-02 19:04:38 +01001971 */
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001972void tipc_link_tnl_prepare(struct tipc_link *l, struct tipc_link *tnl,
1973 int mtyp, struct sk_buff_head *xmitq)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001974{
Tuong Lien58ee86b2019-04-04 11:09:53 +07001975 struct sk_buff_head *fdefq = &tnl->failover_deferdq;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001976 struct sk_buff *skb, *tnlskb;
1977 struct tipc_msg *hdr, tnlhdr;
1978 struct sk_buff_head *queue = &l->transmq;
Tuong Lien2320bcd2019-07-24 08:56:12 +07001979 struct sk_buff_head tmpxq, tnlq, frags;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001980 u16 pktlen, pktcnt, seqno = l->snd_nxt;
Tuong Lien2320bcd2019-07-24 08:56:12 +07001981 bool pktcnt_need_update = false;
Tuong Lien4929a932019-07-24 08:56:11 +07001982 u16 syncpt;
Tuong Lien2320bcd2019-07-24 08:56:12 +07001983 int rc;
Per Lidenb97bf3f2006-01-02 19:04:38 +01001984
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001985 if (!tnl)
Per Lidenb97bf3f2006-01-02 19:04:38 +01001986 return;
Jon Paul Maloy6e498152015-07-30 18:24:19 -04001987
Jon Maloye654f9f2019-08-15 16:42:50 +02001988 __skb_queue_head_init(&tnlq);
Tuong Lien4929a932019-07-24 08:56:11 +07001989 /* Link Synching:
1990 * From now on, send only one single ("dummy") SYNCH message
1991 * to peer. The SYNCH message does not contain any data, just
1992 * a header conveying the synch point to the peer.
1993 */
1994 if (mtyp == SYNCH_MSG && (tnl->peer_caps & TIPC_TUNNEL_ENHANCED)) {
1995 tnlskb = tipc_msg_create(TUNNEL_PROTOCOL, SYNCH_MSG,
1996 INT_H_SIZE, 0, l->addr,
1997 tipc_own_addr(l->net),
1998 0, 0, 0);
1999 if (!tnlskb) {
2000 pr_warn("%sunable to create dummy SYNCH_MSG\n",
2001 link_co_err);
2002 return;
2003 }
2004
2005 hdr = buf_msg(tnlskb);
2006 syncpt = l->snd_nxt + skb_queue_len(&l->backlogq) - 1;
2007 msg_set_syncpt(hdr, syncpt);
2008 msg_set_bearer_id(hdr, l->peer_bearer_id);
2009 __skb_queue_tail(&tnlq, tnlskb);
2010 tipc_link_xmit(tnl, &tnlq, xmitq);
2011 return;
2012 }
2013
Tuong Liend0d605c2019-11-06 18:12:17 +07002014 __skb_queue_head_init(&tmpxq);
2015 __skb_queue_head_init(&frags);
2016 /* At least one packet required for safe algorithm => add dummy */
2017 skb = tipc_msg_create(TIPC_LOW_IMPORTANCE, TIPC_DIRECT_MSG,
2018 BASIC_H_SIZE, 0, l->addr, tipc_own_addr(l->net),
2019 0, 0, TIPC_ERR_NO_PORT);
2020 if (!skb) {
2021 pr_warn("%sunable to create tunnel packet\n", link_co_err);
2022 return;
2023 }
2024 __skb_queue_tail(&tnlq, skb);
2025 tipc_link_xmit(l, &tnlq, &tmpxq);
2026 __skb_queue_purge(&tmpxq);
2027
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002028 /* Initialize reusable tunnel packet header */
Jon Paul Maloye74a3862016-03-03 14:23:21 -05002029 tipc_msg_init(tipc_own_addr(l->net), &tnlhdr, TUNNEL_PROTOCOL,
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002030 mtyp, INT_H_SIZE, l->addr);
Tuong Lien58ee86b2019-04-04 11:09:53 +07002031 if (mtyp == SYNCH_MSG)
2032 pktcnt = l->snd_nxt - buf_seqno(skb_peek(&l->transmq));
2033 else
2034 pktcnt = skb_queue_len(&l->transmq);
2035 pktcnt += skb_queue_len(&l->backlogq);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002036 msg_set_msgcnt(&tnlhdr, pktcnt);
2037 msg_set_bearer_id(&tnlhdr, l->peer_bearer_id);
2038tnl:
2039 /* Wrap each packet into a tunnel packet */
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -04002040 skb_queue_walk(queue, skb) {
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002041 hdr = buf_msg(skb);
2042 if (queue == &l->backlogq)
2043 msg_set_seqno(hdr, seqno++);
2044 pktlen = msg_size(hdr);
Tuong Lien2320bcd2019-07-24 08:56:12 +07002045
2046 /* Tunnel link MTU is not large enough? This could be
2047 * due to:
2048 * 1) Link MTU has just changed or set differently;
2049 * 2) Or FAILOVER on the top of a SYNCH message
2050 *
2051 * The 2nd case should not happen if peer supports
2052 * TIPC_TUNNEL_ENHANCED
2053 */
2054 if (pktlen > tnl->mtu - INT_H_SIZE) {
2055 if (mtyp == FAILOVER_MSG &&
2056 (tnl->peer_caps & TIPC_TUNNEL_ENHANCED)) {
2057 rc = tipc_msg_fragment(skb, &tnlhdr, tnl->mtu,
2058 &frags);
2059 if (rc) {
2060 pr_warn("%sunable to frag msg: rc %d\n",
2061 link_co_err, rc);
2062 return;
2063 }
2064 pktcnt += skb_queue_len(&frags) - 1;
2065 pktcnt_need_update = true;
2066 skb_queue_splice_tail_init(&frags, &tnlq);
2067 continue;
2068 }
2069 /* Unluckily, peer doesn't have TIPC_TUNNEL_ENHANCED
2070 * => Just warn it and return!
2071 */
2072 pr_warn_ratelimited("%stoo large msg <%d, %d>: %d!\n",
2073 link_co_err, msg_user(hdr),
2074 msg_type(hdr), msg_size(hdr));
2075 return;
2076 }
2077
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002078 msg_set_size(&tnlhdr, pktlen + INT_H_SIZE);
Parthasarathy Bhuvaragan57d5f642017-01-13 15:46:25 +01002079 tnlskb = tipc_buf_acquire(pktlen + INT_H_SIZE, GFP_ATOMIC);
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002080 if (!tnlskb) {
2081 pr_warn("%sunable to send packet\n", link_co_err);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002082 return;
2083 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002084 skb_copy_to_linear_data(tnlskb, &tnlhdr, INT_H_SIZE);
2085 skb_copy_to_linear_data_offset(tnlskb, INT_H_SIZE, hdr, pktlen);
2086 __skb_queue_tail(&tnlq, tnlskb);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002087 }
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002088 if (queue != &l->backlogq) {
2089 queue = &l->backlogq;
2090 goto tnl;
Jon Paul Maloydd3f9e72015-05-14 10:46:18 -04002091 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002092
Tuong Lien2320bcd2019-07-24 08:56:12 +07002093 if (pktcnt_need_update)
2094 skb_queue_walk(&tnlq, skb) {
2095 hdr = buf_msg(skb);
2096 msg_set_msgcnt(hdr, pktcnt);
2097 }
2098
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002099 tipc_link_xmit(tnl, &tnlq, xmitq);
Jon Paul Maloyf006c9c2014-02-13 17:29:11 -05002100
Jon Paul Maloy6e498152015-07-30 18:24:19 -04002101 if (mtyp == FAILOVER_MSG) {
2102 tnl->drop_point = l->rcv_nxt;
2103 tnl->failover_reasm_skb = l->reasm_buf;
2104 l->reasm_buf = NULL;
Tuong Lien58ee86b2019-04-04 11:09:53 +07002105
2106 /* Failover the link's deferdq */
2107 if (unlikely(!skb_queue_empty(fdefq))) {
2108 pr_warn("Link failover deferdq not empty: %d!\n",
2109 skb_queue_len(fdefq));
2110 __skb_queue_purge(fdefq);
2111 }
2112 skb_queue_splice_init(&l->deferdq, fdefq);
Jon Paul Maloyf006c9c2014-02-13 17:29:11 -05002113 }
Per Lidenb97bf3f2006-01-02 19:04:38 +01002114}
2115
Tuong Lienc0b14a02019-05-02 17:23:23 +07002116/**
2117 * tipc_link_failover_prepare() - prepare tnl for link failover
2118 *
2119 * This is a special version of the precursor - tipc_link_tnl_prepare(),
2120 * see the tipc_node_link_failover() for details
2121 *
2122 * @l: failover link
2123 * @tnl: tunnel link
2124 * @xmitq: queue for messages to be xmited
2125 */
2126void tipc_link_failover_prepare(struct tipc_link *l, struct tipc_link *tnl,
2127 struct sk_buff_head *xmitq)
2128{
2129 struct sk_buff_head *fdefq = &tnl->failover_deferdq;
2130
2131 tipc_link_create_dummy_tnl_msg(tnl, xmitq);
2132
Geert Uytterhoeven8ebed8a2019-10-24 17:30:43 +02002133 /* This failover link endpoint was never established before,
Tuong Lienc0b14a02019-05-02 17:23:23 +07002134 * so it has not received anything from peer.
2135 * Otherwise, it must be a normal failover situation or the
2136 * node has entered SELF_DOWN_PEER_LEAVING and both peer nodes
2137 * would have to start over from scratch instead.
2138 */
Tuong Lienc0b14a02019-05-02 17:23:23 +07002139 tnl->drop_point = 1;
2140 tnl->failover_reasm_skb = NULL;
2141
2142 /* Initiate the link's failover deferdq */
2143 if (unlikely(!skb_queue_empty(fdefq))) {
2144 pr_warn("Link failover deferdq not empty: %d!\n",
2145 skb_queue_len(fdefq));
2146 __skb_queue_purge(fdefq);
2147 }
2148}
2149
Jon Maloy7ea817f2018-07-10 01:07:36 +02002150/* tipc_link_validate_msg(): validate message against current link state
2151 * Returns true if message should be accepted, otherwise false
2152 */
2153bool tipc_link_validate_msg(struct tipc_link *l, struct tipc_msg *hdr)
2154{
2155 u16 curr_session = l->peer_session;
2156 u16 session = msg_session(hdr);
2157 int mtyp = msg_type(hdr);
2158
2159 if (msg_user(hdr) != LINK_PROTOCOL)
2160 return true;
2161
2162 switch (mtyp) {
2163 case RESET_MSG:
2164 if (!l->in_session)
2165 return true;
2166 /* Accept only RESET with new session number */
2167 return more(session, curr_session);
2168 case ACTIVATE_MSG:
2169 if (!l->in_session)
2170 return true;
2171 /* Accept only ACTIVATE with new or current session number */
2172 return !less(session, curr_session);
2173 case STATE_MSG:
2174 /* Accept only STATE with current session number */
2175 if (!l->in_session)
2176 return false;
2177 if (session != curr_session)
2178 return false;
LUU Duc Canhd949cfe2018-09-26 22:28:52 +02002179 /* Extra sanity check */
2180 if (!link_is_up(l) && msg_ack(hdr))
2181 return false;
Jon Maloy7ea817f2018-07-10 01:07:36 +02002182 if (!(l->peer_caps & TIPC_LINK_PROTO_SEQNO))
2183 return true;
2184 /* Accept only STATE with new sequence number */
2185 return !less(msg_seqno(hdr), l->rcv_nxt_state);
2186 default:
2187 return false;
2188 }
2189}
2190
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002191/* tipc_link_proto_rcv(): receive link level protocol message :
2192 * Note that network plane id propagates through the network, and may
2193 * change at any time. The node with lowest numerical id determines
2194 * network plane
2195 */
2196static int tipc_link_proto_rcv(struct tipc_link *l, struct sk_buff *skb,
2197 struct sk_buff_head *xmitq)
2198{
2199 struct tipc_msg *hdr = buf_msg(skb);
Tuong Lien91959482019-04-04 11:09:51 +07002200 struct tipc_gap_ack_blks *ga = NULL;
Tuong Liend7626b52020-05-26 16:38:34 +07002201 bool reply = msg_probe(hdr), retransmitted = false;
2202 u16 dlen = msg_data_sz(hdr), glen = 0;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002203 u16 peers_snd_nxt = msg_next_sent(hdr);
2204 u16 peers_tol = msg_link_tolerance(hdr);
2205 u16 peers_prio = msg_linkprio(hdr);
Tuong Liend7626b52020-05-26 16:38:34 +07002206 u16 gap = msg_seq_gap(hdr);
2207 u16 ack = msg_ack(hdr);
Jon Paul Maloy2be80c22015-08-20 02:12:56 -04002208 u16 rcv_nxt = l->rcv_nxt;
Tuong Liend7626b52020-05-26 16:38:34 +07002209 u16 rcvgap = 0;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04002210 int mtyp = msg_type(hdr);
Tuong Liend7626b52020-05-26 16:38:34 +07002211 int rc = 0, released;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002212 char *if_name;
Tuong Liend7626b52020-05-26 16:38:34 +07002213 void *data;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002214
Tuong Lien26574db2018-12-19 09:17:57 +07002215 trace_tipc_proto_rcv(skb, false, l->name);
Jon Paul Maloy52666982015-10-22 08:51:41 -04002216 if (tipc_link_is_blocked(l) || !xmitq)
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002217 goto exit;
2218
Jon Paul Maloye74a3862016-03-03 14:23:21 -05002219 if (tipc_own_addr(l->net) > msg_prevnode(hdr))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002220 l->net_plane = msg_net_plane(hdr);
2221
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04002222 skb_linearize(skb);
2223 hdr = buf_msg(skb);
2224 data = msg_data(hdr);
2225
Tuong Lien26574db2018-12-19 09:17:57 +07002226 if (!tipc_link_validate_msg(l, hdr)) {
2227 trace_tipc_skb_dump(skb, false, "PROTO invalid (1)!");
2228 trace_tipc_link_dump(l, TIPC_DUMP_NONE, "PROTO invalid (1)!");
Jon Maloy7ea817f2018-07-10 01:07:36 +02002229 goto exit;
Tuong Lien26574db2018-12-19 09:17:57 +07002230 }
Jon Maloy7ea817f2018-07-10 01:07:36 +02002231
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04002232 switch (mtyp) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002233 case RESET_MSG:
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002234 case ACTIVATE_MSG:
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002235 /* Complete own link name with peer's interface name */
2236 if_name = strrchr(l->name, ':') + 1;
2237 if (sizeof(l->name) - (if_name - l->name) <= TIPC_MAX_IF_NAME)
2238 break;
2239 if (msg_data_sz(hdr) < TIPC_MAX_IF_NAME)
2240 break;
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04002241 strncpy(if_name, data, TIPC_MAX_IF_NAME);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002242
2243 /* Update own tolerance if peer indicates a non-zero value */
Jon Maloy047491e2018-10-10 17:34:01 +02002244 if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL)) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002245 l->tolerance = peers_tol;
Jon Maloy047491e2018-10-10 17:34:01 +02002246 l->bc_rcvlink->tolerance = peers_tol;
2247 }
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002248 /* Update own priority if peer's priority is higher */
2249 if (in_range(peers_prio, l->priority + 1, TIPC_MAX_LINK_PRI))
2250 l->priority = peers_prio;
2251
Jon Maloy7ab412d2018-11-10 17:30:24 -05002252 /* If peer is going down we want full re-establish cycle */
2253 if (msg_peer_stopping(hdr)) {
Jon Paul Maloy634696b2016-04-15 13:33:03 -04002254 rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
Jon Maloy7ab412d2018-11-10 17:30:24 -05002255 break;
2256 }
Tuong Lien91986ee2019-02-11 13:29:43 +07002257
2258 /* If this endpoint was re-created while peer was ESTABLISHING
2259 * it doesn't know current session number. Force re-synch.
2260 */
2261 if (mtyp == ACTIVATE_MSG && msg_dest_session_valid(hdr) &&
2262 l->session != msg_dest_session(hdr)) {
2263 if (less(l->session, msg_dest_session(hdr)))
2264 l->session = msg_dest_session(hdr) + 1;
2265 break;
2266 }
2267
Jon Maloy7ab412d2018-11-10 17:30:24 -05002268 /* ACTIVATE_MSG serves as PEER_RESET if link is already down */
2269 if (mtyp == RESET_MSG || !link_is_up(l))
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04002270 rc = tipc_link_fsm_evt(l, LINK_PEER_RESET_EVT);
2271
2272 /* ACTIVATE_MSG takes up link if it was already locally reset */
Jon Maloy7ab412d2018-11-10 17:30:24 -05002273 if (mtyp == ACTIVATE_MSG && l->state == LINK_ESTABLISHING)
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04002274 rc = TIPC_LINK_UP_EVT;
2275
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002276 l->peer_session = msg_session(hdr);
Jon Maloy7ea817f2018-07-10 01:07:36 +02002277 l->in_session = true;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002278 l->peer_bearer_id = msg_bearer_id(hdr);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002279 if (l->mtu > msg_max_pkt(hdr))
2280 l->mtu = msg_max_pkt(hdr);
2281 break;
Jon Paul Maloy662921c2015-07-30 18:24:21 -04002282
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002283 case STATE_MSG:
Jon Maloy9012de52018-07-10 01:07:35 +02002284 l->rcv_nxt_state = msg_seqno(hdr) + 1;
2285
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002286 /* Update own tolerance if peer indicates a non-zero value */
Jon Maloy047491e2018-10-10 17:34:01 +02002287 if (in_range(peers_tol, TIPC_MIN_LINK_TOL, TIPC_MAX_LINK_TOL)) {
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002288 l->tolerance = peers_tol;
Jon Maloy047491e2018-10-10 17:34:01 +02002289 l->bc_rcvlink->tolerance = peers_tol;
2290 }
Jon Paul Maloyf7967552016-11-23 21:05:26 -05002291 /* Update own prio if peer indicates a different value */
2292 if ((peers_prio != l->priority) &&
2293 in_range(peers_prio, 1, TIPC_MAX_LINK_PRI)) {
Richard Alpe81729812016-02-01 08:19:57 +01002294 l->priority = peers_prio;
2295 rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
2296 }
2297
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002298 l->silent_intv_cnt = 0;
2299 l->stats.recv_states++;
2300 if (msg_probe(hdr))
2301 l->stats.recv_probes++;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04002302
2303 if (!link_is_up(l)) {
2304 if (l->state == LINK_ESTABLISHING)
2305 rc = TIPC_LINK_UP_EVT;
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002306 break;
Jon Paul Maloy73f646c2015-10-15 14:52:44 -04002307 }
Tuong Lien91959482019-04-04 11:09:51 +07002308
2309 /* Receive Gap ACK blocks from peer if any */
Tuong Liend7626b52020-05-26 16:38:34 +07002310 glen = tipc_get_gap_ack_blks(&ga, l, hdr, true);
Tuong Lien91959482019-04-04 11:09:51 +07002311
2312 tipc_mon_rcv(l->net, data + glen, dlen - glen, l->addr,
Jon Paul Maloy35c55c92016-06-13 20:46:22 -04002313 &l->mon_state, l->bearer_id);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002314
Jon Paul Maloy662921c2015-07-30 18:24:21 -04002315 /* Send NACK if peer has sent pkts we haven't received yet */
Jon Maloyd3b09992019-12-10 00:52:45 +01002316 if ((reply || msg_is_keepalive(hdr)) &&
2317 more(peers_snd_nxt, rcv_nxt) &&
2318 !tipc_link_is_synching(l) &&
2319 skb_queue_empty(&l->deferdq))
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002320 rcvgap = peers_snd_nxt - l->rcv_nxt;
Jon Maloy8d6e79d2017-11-08 09:59:26 +01002321 if (rcvgap || reply)
2322 tipc_link_build_proto_msg(l, STATE_MSG, 0, reply,
2323 rcvgap, 0, 0, xmitq);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002324
Tuong Liend7626b52020-05-26 16:38:34 +07002325 released = tipc_link_advance_transmq(l, l, ack, gap, ga, xmitq,
2326 &retransmitted, &rc);
Tuong Lien91959482019-04-04 11:09:51 +07002327 if (gap)
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002328 l->stats.recv_nacks++;
Tuong Liend7626b52020-05-26 16:38:34 +07002329 if (released || retransmitted)
2330 tipc_link_update_cwin(l, released, retransmitted);
2331 if (released)
2332 tipc_link_advance_backlog(l, xmitq);
Jon Paul Maloyd9992972015-07-16 16:54:31 -04002333 if (unlikely(!skb_queue_empty(&l->wakeupq)))
2334 link_prepare_wakeup(l);
2335 }
2336exit:
2337 kfree_skb(skb);
2338 return rc;
2339}
2340
Jon Paul Maloy52666982015-10-22 08:51:41 -04002341/* tipc_link_build_bc_proto_msg() - create broadcast protocol message
2342 */
2343static bool tipc_link_build_bc_proto_msg(struct tipc_link *l, bool bcast,
2344 u16 peers_snd_nxt,
2345 struct sk_buff_head *xmitq)
2346{
2347 struct sk_buff *skb;
2348 struct tipc_msg *hdr;
2349 struct sk_buff *dfrd_skb = skb_peek(&l->deferdq);
2350 u16 ack = l->rcv_nxt - 1;
2351 u16 gap_to = peers_snd_nxt - 1;
2352
2353 skb = tipc_msg_create(BCAST_PROTOCOL, STATE_MSG, INT_H_SIZE,
Jon Paul Maloye74a3862016-03-03 14:23:21 -05002354 0, l->addr, tipc_own_addr(l->net), 0, 0, 0);
Jon Paul Maloy52666982015-10-22 08:51:41 -04002355 if (!skb)
2356 return false;
2357 hdr = buf_msg(skb);
2358 msg_set_last_bcast(hdr, l->bc_sndlink->snd_nxt - 1);
2359 msg_set_bcast_ack(hdr, ack);
2360 msg_set_bcgap_after(hdr, ack);
2361 if (dfrd_skb)
2362 gap_to = buf_seqno(dfrd_skb) - 1;
2363 msg_set_bcgap_to(hdr, gap_to);
2364 msg_set_non_seq(hdr, bcast);
2365 __skb_queue_tail(xmitq, skb);
2366 return true;
2367}
2368
2369/* tipc_link_build_bc_init_msg() - synchronize broadcast link endpoints.
2370 *
2371 * Give a newly added peer node the sequence number where it should
2372 * start receiving and acking broadcast packets.
2373 */
Wu Fengguang742e0382015-10-24 22:56:01 +08002374static void tipc_link_build_bc_init_msg(struct tipc_link *l,
2375 struct sk_buff_head *xmitq)
Jon Paul Maloy52666982015-10-22 08:51:41 -04002376{
2377 struct sk_buff_head list;
2378
2379 __skb_queue_head_init(&list);
2380 if (!tipc_link_build_bc_proto_msg(l->bc_rcvlink, false, 0, &list))
2381 return;
Jon Paul Maloy06bd2b12016-10-27 18:51:55 -04002382 msg_set_bc_ack_invalid(buf_msg(skb_peek(&list)), true);
Jon Paul Maloy52666982015-10-22 08:51:41 -04002383 tipc_link_xmit(l, &list, xmitq);
2384}
2385
2386/* tipc_link_bc_init_rcv - receive initial broadcast synch data from peer
2387 */
2388void tipc_link_bc_init_rcv(struct tipc_link *l, struct tipc_msg *hdr)
2389{
2390 int mtyp = msg_type(hdr);
2391 u16 peers_snd_nxt = msg_bc_snd_nxt(hdr);
2392
2393 if (link_is_up(l))
2394 return;
2395
2396 if (msg_user(hdr) == BCAST_PROTOCOL) {
2397 l->rcv_nxt = peers_snd_nxt;
2398 l->state = LINK_ESTABLISHED;
2399 return;
2400 }
2401
2402 if (l->peer_caps & TIPC_BCAST_SYNCH)
2403 return;
2404
2405 if (msg_peer_node_is_up(hdr))
2406 return;
2407
2408 /* Compatibility: accept older, less safe initial synch data */
2409 if ((mtyp == RESET_MSG) || (mtyp == ACTIVATE_MSG))
2410 l->rcv_nxt = peers_snd_nxt;
2411}
2412
2413/* tipc_link_bc_sync_rcv - update rcv link according to peer's send state
2414 */
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002415int tipc_link_bc_sync_rcv(struct tipc_link *l, struct tipc_msg *hdr,
2416 struct sk_buff_head *xmitq)
Jon Paul Maloy52666982015-10-22 08:51:41 -04002417{
2418 u16 peers_snd_nxt = msg_bc_snd_nxt(hdr);
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002419 int rc = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002420
2421 if (!link_is_up(l))
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002422 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002423
2424 if (!msg_peer_node_is_up(hdr))
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002425 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002426
Randy Dunlapa99df442020-11-29 10:32:44 -08002427 /* Open when peer acknowledges our bcast init msg (pkt #1) */
Jon Paul Maloy2d18ac42016-07-11 16:08:35 -04002428 if (msg_ack(hdr))
2429 l->bc_peer_is_up = true;
2430
2431 if (!l->bc_peer_is_up)
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002432 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002433
2434 /* Ignore if peers_snd_nxt goes beyond receive window */
2435 if (more(peers_snd_nxt, l->rcv_nxt + l->window))
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002436 return rc;
2437
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002438 l->snd_nxt = peers_snd_nxt;
2439 if (link_bc_rcv_gap(l))
2440 rc |= TIPC_LINK_SND_STATE;
2441
2442 /* Return now if sender supports nack via STATE messages */
2443 if (l->peer_caps & TIPC_BCAST_STATE_NACK)
2444 return rc;
2445
2446 /* Otherwise, be backwards compatible */
Jon Paul Maloy52666982015-10-22 08:51:41 -04002447
2448 if (!more(peers_snd_nxt, l->rcv_nxt)) {
2449 l->nack_state = BC_NACK_SND_CONDITIONAL;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002450 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002451 }
2452
2453 /* Don't NACK if one was recently sent or peeked */
2454 if (l->nack_state == BC_NACK_SND_SUPPRESS) {
2455 l->nack_state = BC_NACK_SND_UNCONDITIONAL;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002456 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002457 }
2458
2459 /* Conditionally delay NACK sending until next synch rcv */
2460 if (l->nack_state == BC_NACK_SND_CONDITIONAL) {
2461 l->nack_state = BC_NACK_SND_UNCONDITIONAL;
2462 if ((peers_snd_nxt - l->rcv_nxt) < TIPC_MIN_LINK_WIN)
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002463 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002464 }
2465
2466 /* Send NACK now but suppress next one */
2467 tipc_link_build_bc_proto_msg(l, true, peers_snd_nxt, xmitq);
2468 l->nack_state = BC_NACK_SND_SUPPRESS;
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002469 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002470}
2471
Tuong Liend7626b52020-05-26 16:38:34 +07002472int tipc_link_bc_ack_rcv(struct tipc_link *r, u16 acked, u16 gap,
2473 struct tipc_gap_ack_blks *ga,
Tuong Liena91d55d2020-05-26 16:38:36 +07002474 struct sk_buff_head *xmitq,
2475 struct sk_buff_head *retrq)
Jon Paul Maloy52666982015-10-22 08:51:41 -04002476{
Tuong Liend7626b52020-05-26 16:38:34 +07002477 struct tipc_link *l = r->bc_sndlink;
2478 bool unused = false;
2479 int rc = 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002480
Tuong Liend7626b52020-05-26 16:38:34 +07002481 if (!link_is_up(r) || !r->bc_peer_is_up)
2482 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002483
Tuong Lien03b6fef2020-05-26 16:38:37 +07002484 if (gap) {
2485 l->stats.recv_nacks++;
2486 r->stats.recv_nacks++;
2487 }
2488
Tuong Liend7626b52020-05-26 16:38:34 +07002489 if (less(acked, r->acked) || (acked == r->acked && !gap && !ga))
2490 return 0;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002491
Tuong Lienc6ed7a52020-05-26 16:38:35 +07002492 trace_tipc_link_bc_ack(r, acked, gap, &l->transmq);
Tuong Liena91d55d2020-05-26 16:38:36 +07002493 tipc_link_advance_transmq(l, r, acked, gap, ga, retrq, &unused, &rc);
Jon Paul Maloy52666982015-10-22 08:51:41 -04002494
Tuong Liend7626b52020-05-26 16:38:34 +07002495 tipc_link_advance_backlog(l, xmitq);
2496 if (unlikely(!skb_queue_empty(&l->wakeupq)))
2497 link_prepare_wakeup(l);
2498
2499 return rc;
Jon Paul Maloy52666982015-10-22 08:51:41 -04002500}
2501
2502/* tipc_link_bc_nack_rcv(): receive broadcast nack message
Jon Paul Maloy02d11ca2016-09-01 13:52:49 -04002503 * This function is here for backwards compatibility, since
2504 * no BCAST_PROTOCOL/STATE messages occur from TIPC v2.5.
Jon Paul Maloy52666982015-10-22 08:51:41 -04002505 */
2506int tipc_link_bc_nack_rcv(struct tipc_link *l, struct sk_buff *skb,
2507 struct sk_buff_head *xmitq)
2508{
2509 struct tipc_msg *hdr = buf_msg(skb);
2510 u32 dnode = msg_destnode(hdr);
2511 int mtyp = msg_type(hdr);
2512 u16 acked = msg_bcast_ack(hdr);
2513 u16 from = acked + 1;
2514 u16 to = msg_bcgap_to(hdr);
2515 u16 peers_snd_nxt = to + 1;
2516 int rc = 0;
2517
2518 kfree_skb(skb);
2519
2520 if (!tipc_link_is_up(l) || !l->bc_peer_is_up)
2521 return 0;
2522
2523 if (mtyp != STATE_MSG)
2524 return 0;
2525
Jon Paul Maloye74a3862016-03-03 14:23:21 -05002526 if (dnode == tipc_own_addr(l->net)) {
Tuong Liena91d55d2020-05-26 16:38:36 +07002527 rc = tipc_link_bc_ack_rcv(l, acked, to - acked, NULL, xmitq,
2528 xmitq);
Jon Paul Maloy52666982015-10-22 08:51:41 -04002529 l->stats.recv_nacks++;
2530 return rc;
2531 }
2532
2533 /* Msg for other node => suppress own NACK at next sync if applicable */
2534 if (more(peers_snd_nxt, l->rcv_nxt) && !less(l->rcv_nxt, from))
2535 l->nack_state = BC_NACK_SND_SUPPRESS;
2536
2537 return 0;
2538}
2539
Jon Maloy16ad3f42019-12-10 00:52:46 +01002540void tipc_link_set_queue_limits(struct tipc_link *l, u32 min_win, u32 max_win)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002541{
Jon Maloy218527f2018-03-29 23:20:41 +02002542 int max_bulk = TIPC_MAX_PUBL / (l->mtu / ITEM_SIZE);
Jon Paul Maloy05dcc5a2015-03-13 16:08:10 -04002543
Jon Maloy16ad3f42019-12-10 00:52:46 +01002544 l->min_win = min_win;
2545 l->ssthresh = max_win;
2546 l->max_win = max_win;
2547 l->window = min_win;
2548 l->backlog[TIPC_LOW_IMPORTANCE].limit = min_win * 2;
2549 l->backlog[TIPC_MEDIUM_IMPORTANCE].limit = min_win * 4;
2550 l->backlog[TIPC_HIGH_IMPORTANCE].limit = min_win * 6;
2551 l->backlog[TIPC_CRITICAL_IMPORTANCE].limit = min_win * 8;
Jon Paul Maloy1f66d162015-03-25 12:07:24 -04002552 l->backlog[TIPC_SYSTEM_IMPORTANCE].limit = max_bulk;
Per Lidenb97bf3f2006-01-02 19:04:38 +01002553}
2554
Allan Stephens5c216e12011-10-18 11:34:29 -04002555/**
Mauro Carvalho Chehab25764772021-01-14 09:04:48 +01002556 * tipc_link_reset_stats - reset link statistics
Jon Paul Maloy1a906322015-11-19 14:30:47 -05002557 * @l: pointer to link
Per Lidenb97bf3f2006-01-02 19:04:38 +01002558 */
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002559void tipc_link_reset_stats(struct tipc_link *l)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002560{
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002561 memset(&l->stats, 0, sizeof(l->stats));
Per Lidenb97bf3f2006-01-02 19:04:38 +01002562}
2563
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04002564static void link_print(struct tipc_link *l, const char *str)
Per Lidenb97bf3f2006-01-02 19:04:38 +01002565{
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04002566 struct sk_buff *hskb = skb_peek(&l->transmq);
Jon Paul Maloyc1ab3f1d2015-10-22 08:51:38 -04002567 u16 head = hskb ? msg_seqno(buf_msg(hskb)) : l->snd_nxt - 1;
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04002568 u16 tail = l->snd_nxt - 1;
Ying Xue7a2f7d12014-04-21 10:55:46 +08002569
Jon Paul Maloy662921c2015-07-30 18:24:21 -04002570 pr_info("%s Link <%s> state %x\n", str, l->name, l->state);
Jon Paul Maloy1a20cc22015-07-16 16:54:30 -04002571 pr_info("XMTQ: %u [%u-%u], BKLGQ: %u, SNDNX: %u, RCVNX: %u\n",
2572 skb_queue_len(&l->transmq), head, tail,
2573 skb_queue_len(&l->backlogq), l->snd_nxt, l->rcv_nxt);
Per Lidenb97bf3f2006-01-02 19:04:38 +01002574}
Richard Alpe0655f6a2014-11-20 10:29:07 +01002575
2576/* Parse and validate nested (link) properties valid for media, bearer and link
2577 */
2578int tipc_nl_parse_link_prop(struct nlattr *prop, struct nlattr *props[])
2579{
2580 int err;
2581
Johannes Berg8cb08172019-04-26 14:07:28 +02002582 err = nla_parse_nested_deprecated(props, TIPC_NLA_PROP_MAX, prop,
2583 tipc_nl_prop_policy, NULL);
Richard Alpe0655f6a2014-11-20 10:29:07 +01002584 if (err)
2585 return err;
2586
2587 if (props[TIPC_NLA_PROP_PRIO]) {
2588 u32 prio;
2589
2590 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
2591 if (prio > TIPC_MAX_LINK_PRI)
2592 return -EINVAL;
2593 }
2594
2595 if (props[TIPC_NLA_PROP_TOL]) {
2596 u32 tol;
2597
2598 tol = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
2599 if ((tol < TIPC_MIN_LINK_TOL) || (tol > TIPC_MAX_LINK_TOL))
2600 return -EINVAL;
2601 }
2602
2603 if (props[TIPC_NLA_PROP_WIN]) {
Jon Maloy16ad3f42019-12-10 00:52:46 +01002604 u32 max_win;
Richard Alpe0655f6a2014-11-20 10:29:07 +01002605
Jon Maloy16ad3f42019-12-10 00:52:46 +01002606 max_win = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
2607 if (max_win < TIPC_DEF_LINK_WIN || max_win > TIPC_MAX_LINK_WIN)
Richard Alpe0655f6a2014-11-20 10:29:07 +01002608 return -EINVAL;
2609 }
2610
2611 return 0;
2612}
Richard Alpe7be57fc2014-11-20 10:29:12 +01002613
Richard Alped8182802014-11-24 11:10:29 +01002614static int __tipc_nl_add_stats(struct sk_buff *skb, struct tipc_stats *s)
Richard Alpe7be57fc2014-11-20 10:29:12 +01002615{
2616 int i;
2617 struct nlattr *stats;
2618
2619 struct nla_map {
2620 u32 key;
2621 u32 val;
2622 };
2623
2624 struct nla_map map[] = {
Jon Paul Maloy95901122016-11-25 10:35:02 -05002625 {TIPC_NLA_STATS_RX_INFO, 0},
Richard Alpe7be57fc2014-11-20 10:29:12 +01002626 {TIPC_NLA_STATS_RX_FRAGMENTS, s->recv_fragments},
2627 {TIPC_NLA_STATS_RX_FRAGMENTED, s->recv_fragmented},
2628 {TIPC_NLA_STATS_RX_BUNDLES, s->recv_bundles},
2629 {TIPC_NLA_STATS_RX_BUNDLED, s->recv_bundled},
Jon Paul Maloy95901122016-11-25 10:35:02 -05002630 {TIPC_NLA_STATS_TX_INFO, 0},
Richard Alpe7be57fc2014-11-20 10:29:12 +01002631 {TIPC_NLA_STATS_TX_FRAGMENTS, s->sent_fragments},
2632 {TIPC_NLA_STATS_TX_FRAGMENTED, s->sent_fragmented},
2633 {TIPC_NLA_STATS_TX_BUNDLES, s->sent_bundles},
2634 {TIPC_NLA_STATS_TX_BUNDLED, s->sent_bundled},
2635 {TIPC_NLA_STATS_MSG_PROF_TOT, (s->msg_length_counts) ?
2636 s->msg_length_counts : 1},
2637 {TIPC_NLA_STATS_MSG_LEN_CNT, s->msg_length_counts},
2638 {TIPC_NLA_STATS_MSG_LEN_TOT, s->msg_lengths_total},
2639 {TIPC_NLA_STATS_MSG_LEN_P0, s->msg_length_profile[0]},
2640 {TIPC_NLA_STATS_MSG_LEN_P1, s->msg_length_profile[1]},
2641 {TIPC_NLA_STATS_MSG_LEN_P2, s->msg_length_profile[2]},
2642 {TIPC_NLA_STATS_MSG_LEN_P3, s->msg_length_profile[3]},
2643 {TIPC_NLA_STATS_MSG_LEN_P4, s->msg_length_profile[4]},
2644 {TIPC_NLA_STATS_MSG_LEN_P5, s->msg_length_profile[5]},
2645 {TIPC_NLA_STATS_MSG_LEN_P6, s->msg_length_profile[6]},
2646 {TIPC_NLA_STATS_RX_STATES, s->recv_states},
2647 {TIPC_NLA_STATS_RX_PROBES, s->recv_probes},
2648 {TIPC_NLA_STATS_RX_NACKS, s->recv_nacks},
2649 {TIPC_NLA_STATS_RX_DEFERRED, s->deferred_recv},
2650 {TIPC_NLA_STATS_TX_STATES, s->sent_states},
2651 {TIPC_NLA_STATS_TX_PROBES, s->sent_probes},
2652 {TIPC_NLA_STATS_TX_NACKS, s->sent_nacks},
2653 {TIPC_NLA_STATS_TX_ACKS, s->sent_acks},
2654 {TIPC_NLA_STATS_RETRANSMITTED, s->retransmitted},
2655 {TIPC_NLA_STATS_DUPLICATES, s->duplicates},
2656 {TIPC_NLA_STATS_LINK_CONGS, s->link_congs},
2657 {TIPC_NLA_STATS_MAX_QUEUE, s->max_queue_sz},
2658 {TIPC_NLA_STATS_AVG_QUEUE, s->queue_sz_counts ?
2659 (s->accu_queue_sz / s->queue_sz_counts) : 0}
2660 };
2661
Michal Kubecekae0be8d2019-04-26 11:13:06 +02002662 stats = nla_nest_start_noflag(skb, TIPC_NLA_LINK_STATS);
Richard Alpe7be57fc2014-11-20 10:29:12 +01002663 if (!stats)
2664 return -EMSGSIZE;
2665
2666 for (i = 0; i < ARRAY_SIZE(map); i++)
2667 if (nla_put_u32(skb, map[i].key, map[i].val))
2668 goto msg_full;
2669
2670 nla_nest_end(skb, stats);
2671
2672 return 0;
2673msg_full:
2674 nla_nest_cancel(skb, stats);
2675
2676 return -EMSGSIZE;
2677}
2678
2679/* Caller should hold appropriate locks to protect the link */
Jon Paul Maloy5be9c082015-11-19 14:30:45 -05002680int __tipc_nl_add_link(struct net *net, struct tipc_nl_msg *msg,
2681 struct tipc_link *link, int nlflags)
Richard Alpe7be57fc2014-11-20 10:29:12 +01002682{
Jon Maloy23fd3ea2018-03-22 20:42:49 +01002683 u32 self = tipc_own_addr(net);
Richard Alpe7be57fc2014-11-20 10:29:12 +01002684 struct nlattr *attrs;
2685 struct nlattr *prop;
Jon Maloy23fd3ea2018-03-22 20:42:49 +01002686 void *hdr;
2687 int err;
Richard Alpe7be57fc2014-11-20 10:29:12 +01002688
Richard Alpebfb3e5d2015-02-09 09:50:03 +01002689 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
Nicolas Dichtelf2f67392015-04-28 18:33:50 +02002690 nlflags, TIPC_NL_LINK_GET);
Richard Alpe7be57fc2014-11-20 10:29:12 +01002691 if (!hdr)
2692 return -EMSGSIZE;
2693
Michal Kubecekae0be8d2019-04-26 11:13:06 +02002694 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_LINK);
Richard Alpe7be57fc2014-11-20 10:29:12 +01002695 if (!attrs)
2696 goto msg_full;
2697
2698 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, link->name))
2699 goto attr_msg_full;
Jon Maloy23fd3ea2018-03-22 20:42:49 +01002700 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_DEST, tipc_cluster_mask(self)))
Richard Alpe7be57fc2014-11-20 10:29:12 +01002701 goto attr_msg_full;
Jon Paul Maloyed193ec2015-04-02 09:33:02 -04002702 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_MTU, link->mtu))
Richard Alpe7be57fc2014-11-20 10:29:12 +01002703 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05002704 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, link->stats.recv_pkts))
Richard Alpe7be57fc2014-11-20 10:29:12 +01002705 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05002706 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, link->stats.sent_pkts))
Richard Alpe7be57fc2014-11-20 10:29:12 +01002707 goto attr_msg_full;
2708
2709 if (tipc_link_is_up(link))
2710 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
2711 goto attr_msg_full;
Jon Paul Maloyc72fa872015-10-22 08:51:46 -04002712 if (link->active)
Richard Alpe7be57fc2014-11-20 10:29:12 +01002713 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_ACTIVE))
2714 goto attr_msg_full;
2715
Michal Kubecekae0be8d2019-04-26 11:13:06 +02002716 prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_LINK_PROP);
Richard Alpe7be57fc2014-11-20 10:29:12 +01002717 if (!prop)
2718 goto attr_msg_full;
2719 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
2720 goto prop_msg_full;
2721 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, link->tolerance))
2722 goto prop_msg_full;
2723 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN,
Jon Paul Maloy1f66d162015-03-25 12:07:24 -04002724 link->window))
Richard Alpe7be57fc2014-11-20 10:29:12 +01002725 goto prop_msg_full;
2726 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, link->priority))
2727 goto prop_msg_full;
2728 nla_nest_end(msg->skb, prop);
2729
2730 err = __tipc_nl_add_stats(msg->skb, &link->stats);
2731 if (err)
2732 goto attr_msg_full;
2733
2734 nla_nest_end(msg->skb, attrs);
2735 genlmsg_end(msg->skb, hdr);
2736
2737 return 0;
2738
2739prop_msg_full:
2740 nla_nest_cancel(msg->skb, prop);
2741attr_msg_full:
2742 nla_nest_cancel(msg->skb, attrs);
2743msg_full:
2744 genlmsg_cancel(msg->skb, hdr);
2745
2746 return -EMSGSIZE;
2747}
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002748
2749static int __tipc_nl_add_bc_link_stat(struct sk_buff *skb,
2750 struct tipc_stats *stats)
2751{
2752 int i;
2753 struct nlattr *nest;
2754
2755 struct nla_map {
2756 __u32 key;
2757 __u32 val;
2758 };
2759
2760 struct nla_map map[] = {
Jon Paul Maloy95901122016-11-25 10:35:02 -05002761 {TIPC_NLA_STATS_RX_INFO, stats->recv_pkts},
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002762 {TIPC_NLA_STATS_RX_FRAGMENTS, stats->recv_fragments},
2763 {TIPC_NLA_STATS_RX_FRAGMENTED, stats->recv_fragmented},
2764 {TIPC_NLA_STATS_RX_BUNDLES, stats->recv_bundles},
2765 {TIPC_NLA_STATS_RX_BUNDLED, stats->recv_bundled},
Jon Paul Maloy95901122016-11-25 10:35:02 -05002766 {TIPC_NLA_STATS_TX_INFO, stats->sent_pkts},
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002767 {TIPC_NLA_STATS_TX_FRAGMENTS, stats->sent_fragments},
2768 {TIPC_NLA_STATS_TX_FRAGMENTED, stats->sent_fragmented},
2769 {TIPC_NLA_STATS_TX_BUNDLES, stats->sent_bundles},
2770 {TIPC_NLA_STATS_TX_BUNDLED, stats->sent_bundled},
2771 {TIPC_NLA_STATS_RX_NACKS, stats->recv_nacks},
2772 {TIPC_NLA_STATS_RX_DEFERRED, stats->deferred_recv},
2773 {TIPC_NLA_STATS_TX_NACKS, stats->sent_nacks},
2774 {TIPC_NLA_STATS_TX_ACKS, stats->sent_acks},
2775 {TIPC_NLA_STATS_RETRANSMITTED, stats->retransmitted},
2776 {TIPC_NLA_STATS_DUPLICATES, stats->duplicates},
2777 {TIPC_NLA_STATS_LINK_CONGS, stats->link_congs},
2778 {TIPC_NLA_STATS_MAX_QUEUE, stats->max_queue_sz},
2779 {TIPC_NLA_STATS_AVG_QUEUE, stats->queue_sz_counts ?
2780 (stats->accu_queue_sz / stats->queue_sz_counts) : 0}
2781 };
2782
Michal Kubecekae0be8d2019-04-26 11:13:06 +02002783 nest = nla_nest_start_noflag(skb, TIPC_NLA_LINK_STATS);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002784 if (!nest)
2785 return -EMSGSIZE;
2786
2787 for (i = 0; i < ARRAY_SIZE(map); i++)
2788 if (nla_put_u32(skb, map[i].key, map[i].val))
2789 goto msg_full;
2790
2791 nla_nest_end(skb, nest);
2792
2793 return 0;
2794msg_full:
2795 nla_nest_cancel(skb, nest);
2796
2797 return -EMSGSIZE;
2798}
2799
Tuong Lien03b6fef2020-05-26 16:38:37 +07002800int tipc_nl_add_bc_link(struct net *net, struct tipc_nl_msg *msg,
2801 struct tipc_link *bcl)
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002802{
2803 int err;
2804 void *hdr;
2805 struct nlattr *attrs;
2806 struct nlattr *prop;
Hoang Huu Lecad29292020-06-17 13:56:05 +07002807 u32 bc_mode = tipc_bcast_get_mode(net);
Hoang Le02ec6ca2019-03-19 18:49:48 +07002808 u32 bc_ratio = tipc_bcast_get_broadcast_ratio(net);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002809
2810 if (!bcl)
2811 return 0;
2812
2813 tipc_bcast_lock(net);
2814
2815 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
2816 NLM_F_MULTI, TIPC_NL_LINK_GET);
Insu Yunb53ce3e2016-02-17 11:47:35 -05002817 if (!hdr) {
2818 tipc_bcast_unlock(net);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002819 return -EMSGSIZE;
Insu Yunb53ce3e2016-02-17 11:47:35 -05002820 }
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002821
Michal Kubecekae0be8d2019-04-26 11:13:06 +02002822 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_LINK);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002823 if (!attrs)
2824 goto msg_full;
2825
2826 /* The broadcast link is always up */
2827 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_UP))
2828 goto attr_msg_full;
2829
2830 if (nla_put_flag(msg->skb, TIPC_NLA_LINK_BROADCAST))
2831 goto attr_msg_full;
2832 if (nla_put_string(msg->skb, TIPC_NLA_LINK_NAME, bcl->name))
2833 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05002834 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_RX, 0))
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002835 goto attr_msg_full;
Jon Paul Maloy95901122016-11-25 10:35:02 -05002836 if (nla_put_u32(msg->skb, TIPC_NLA_LINK_TX, 0))
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002837 goto attr_msg_full;
2838
Michal Kubecekae0be8d2019-04-26 11:13:06 +02002839 prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_LINK_PROP);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002840 if (!prop)
2841 goto attr_msg_full;
Jon Maloy16ad3f42019-12-10 00:52:46 +01002842 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bcl->max_win))
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002843 goto prop_msg_full;
Hoang Le02ec6ca2019-03-19 18:49:48 +07002844 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_BROADCAST, bc_mode))
2845 goto prop_msg_full;
2846 if (bc_mode & BCLINK_MODE_SEL)
2847 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_BROADCAST_RATIO,
2848 bc_ratio))
2849 goto prop_msg_full;
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002850 nla_nest_end(msg->skb, prop);
2851
2852 err = __tipc_nl_add_bc_link_stat(msg->skb, &bcl->stats);
2853 if (err)
2854 goto attr_msg_full;
2855
2856 tipc_bcast_unlock(net);
2857 nla_nest_end(msg->skb, attrs);
2858 genlmsg_end(msg->skb, hdr);
2859
2860 return 0;
2861
2862prop_msg_full:
2863 nla_nest_cancel(msg->skb, prop);
2864attr_msg_full:
2865 nla_nest_cancel(msg->skb, attrs);
2866msg_full:
2867 tipc_bcast_unlock(net);
2868 genlmsg_cancel(msg->skb, hdr);
2869
2870 return -EMSGSIZE;
2871}
2872
Richard Alped01332f2016-02-01 08:19:56 +01002873void tipc_link_set_tolerance(struct tipc_link *l, u32 tol,
2874 struct sk_buff_head *xmitq)
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002875{
2876 l->tolerance = tol;
Jon Maloy047491e2018-10-10 17:34:01 +02002877 if (l->bc_rcvlink)
2878 l->bc_rcvlink->tolerance = tol;
Jon Maloy37c64cf2018-02-14 13:34:39 +01002879 if (link_is_up(l))
2880 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, tol, 0, xmitq);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002881}
2882
Richard Alped01332f2016-02-01 08:19:56 +01002883void tipc_link_set_prio(struct tipc_link *l, u32 prio,
2884 struct sk_buff_head *xmitq)
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002885{
2886 l->priority = prio;
Jon Maloy8d6e79d2017-11-08 09:59:26 +01002887 tipc_link_build_proto_msg(l, STATE_MSG, 0, 0, 0, 0, prio, xmitq);
Jon Paul Maloy38206d52015-11-19 14:30:46 -05002888}
2889
2890void tipc_link_set_abort_limit(struct tipc_link *l, u32 limit)
2891{
2892 l->abort_limit = limit;
2893}
Tuong Lienb4b97712018-12-19 09:17:56 +07002894
Tuong Lienb4b97712018-12-19 09:17:56 +07002895/**
2896 * tipc_link_dump - dump TIPC link data
2897 * @l: tipc link to be dumped
2898 * @dqueues: bitmask to decide if any link queue to be dumped?
2899 * - TIPC_DUMP_NONE: don't dump link queues
2900 * - TIPC_DUMP_TRANSMQ: dump link transmq queue
2901 * - TIPC_DUMP_BACKLOGQ: dump link backlog queue
2902 * - TIPC_DUMP_DEFERDQ: dump link deferd queue
2903 * - TIPC_DUMP_INPUTQ: dump link input queue
2904 * - TIPC_DUMP_WAKEUP: dump link wakeup queue
2905 * - TIPC_DUMP_ALL: dump all the link queues above
2906 * @buf: returned buffer of dump data in format
2907 */
2908int tipc_link_dump(struct tipc_link *l, u16 dqueues, char *buf)
2909{
2910 int i = 0;
2911 size_t sz = (dqueues) ? LINK_LMAX : LINK_LMIN;
2912 struct sk_buff_head *list;
2913 struct sk_buff *hskb, *tskb;
2914 u32 len;
2915
2916 if (!l) {
2917 i += scnprintf(buf, sz, "link data: (null)\n");
2918 return i;
2919 }
2920
2921 i += scnprintf(buf, sz, "link data: %x", l->addr);
2922 i += scnprintf(buf + i, sz - i, " %x", l->state);
2923 i += scnprintf(buf + i, sz - i, " %u", l->in_session);
2924 i += scnprintf(buf + i, sz - i, " %u", l->session);
2925 i += scnprintf(buf + i, sz - i, " %u", l->peer_session);
2926 i += scnprintf(buf + i, sz - i, " %u", l->snd_nxt);
2927 i += scnprintf(buf + i, sz - i, " %u", l->rcv_nxt);
2928 i += scnprintf(buf + i, sz - i, " %u", l->snd_nxt_state);
2929 i += scnprintf(buf + i, sz - i, " %u", l->rcv_nxt_state);
2930 i += scnprintf(buf + i, sz - i, " %x", l->peer_caps);
2931 i += scnprintf(buf + i, sz - i, " %u", l->silent_intv_cnt);
2932 i += scnprintf(buf + i, sz - i, " %u", l->rst_cnt);
Tuong Lien71204232019-08-15 10:24:08 +07002933 i += scnprintf(buf + i, sz - i, " %u", 0);
Jon Maloy77cf8ed2019-06-25 17:36:43 +02002934 i += scnprintf(buf + i, sz - i, " %u", 0);
Tuong Lienb4b97712018-12-19 09:17:56 +07002935 i += scnprintf(buf + i, sz - i, " %u", l->acked);
2936
2937 list = &l->transmq;
2938 len = skb_queue_len(list);
2939 hskb = skb_peek(list);
2940 tskb = skb_peek_tail(list);
2941 i += scnprintf(buf + i, sz - i, " | %u %u %u", len,
2942 (hskb) ? msg_seqno(buf_msg(hskb)) : 0,
2943 (tskb) ? msg_seqno(buf_msg(tskb)) : 0);
2944
2945 list = &l->deferdq;
2946 len = skb_queue_len(list);
2947 hskb = skb_peek(list);
2948 tskb = skb_peek_tail(list);
2949 i += scnprintf(buf + i, sz - i, " | %u %u %u", len,
2950 (hskb) ? msg_seqno(buf_msg(hskb)) : 0,
2951 (tskb) ? msg_seqno(buf_msg(tskb)) : 0);
2952
2953 list = &l->backlogq;
2954 len = skb_queue_len(list);
2955 hskb = skb_peek(list);
2956 tskb = skb_peek_tail(list);
2957 i += scnprintf(buf + i, sz - i, " | %u %u %u", len,
2958 (hskb) ? msg_seqno(buf_msg(hskb)) : 0,
2959 (tskb) ? msg_seqno(buf_msg(tskb)) : 0);
2960
2961 list = l->inputq;
2962 len = skb_queue_len(list);
2963 hskb = skb_peek(list);
2964 tskb = skb_peek_tail(list);
2965 i += scnprintf(buf + i, sz - i, " | %u %u %u\n", len,
2966 (hskb) ? msg_seqno(buf_msg(hskb)) : 0,
2967 (tskb) ? msg_seqno(buf_msg(tskb)) : 0);
2968
2969 if (dqueues & TIPC_DUMP_TRANSMQ) {
2970 i += scnprintf(buf + i, sz - i, "transmq: ");
2971 i += tipc_list_dump(&l->transmq, false, buf + i);
2972 }
2973 if (dqueues & TIPC_DUMP_BACKLOGQ) {
2974 i += scnprintf(buf + i, sz - i,
2975 "backlogq: <%u %u %u %u %u>, ",
2976 l->backlog[TIPC_LOW_IMPORTANCE].len,
2977 l->backlog[TIPC_MEDIUM_IMPORTANCE].len,
2978 l->backlog[TIPC_HIGH_IMPORTANCE].len,
2979 l->backlog[TIPC_CRITICAL_IMPORTANCE].len,
2980 l->backlog[TIPC_SYSTEM_IMPORTANCE].len);
2981 i += tipc_list_dump(&l->backlogq, false, buf + i);
2982 }
2983 if (dqueues & TIPC_DUMP_DEFERDQ) {
2984 i += scnprintf(buf + i, sz - i, "deferdq: ");
2985 i += tipc_list_dump(&l->deferdq, false, buf + i);
2986 }
2987 if (dqueues & TIPC_DUMP_INPUTQ) {
2988 i += scnprintf(buf + i, sz - i, "inputq: ");
2989 i += tipc_list_dump(l->inputq, false, buf + i);
2990 }
2991 if (dqueues & TIPC_DUMP_WAKEUP) {
2992 i += scnprintf(buf + i, sz - i, "wakeup: ");
2993 i += tipc_list_dump(&l->wakeupq, false, buf + i);
2994 }
2995
2996 return i;
2997}