Commit | Line | Data |
---|---|---|
b97bf3fd PL |
1 | /* |
2 | * net/tipc/discover.c | |
c4307285 | 3 | * |
25b0b9c4 | 4 | * Copyright (c) 2003-2006, 2014-2018, Ericsson AB |
2d627b92 | 5 | * Copyright (c) 2005-2006, 2010-2011, Wind River Systems |
b97bf3fd PL |
6 | * All rights reserved. |
7 | * | |
9ea1fd3c | 8 | * Redistribution and use in source and binary forms, with or without |
b97bf3fd PL |
9 | * modification, are permitted provided that the following conditions are met: |
10 | * | |
9ea1fd3c PL |
11 | * 1. Redistributions of source code must retain the above copyright |
12 | * notice, this list of conditions and the following disclaimer. | |
13 | * 2. Redistributions in binary form must reproduce the above copyright | |
14 | * notice, this list of conditions and the following disclaimer in the | |
15 | * documentation and/or other materials provided with the distribution. | |
16 | * 3. Neither the names of the copyright holders nor the names of its | |
17 | * contributors may be used to endorse or promote products derived from | |
18 | * this software without specific prior written permission. | |
b97bf3fd | 19 | * |
9ea1fd3c PL |
20 | * Alternatively, this software may be distributed under the terms of the |
21 | * GNU General Public License ("GPL") version 2 as published by the Free | |
22 | * Software Foundation. | |
23 | * | |
24 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
25 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
28 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
29 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
30 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
31 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
32 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
33 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
b97bf3fd PL |
34 | * POSSIBILITY OF SUCH DAMAGE. |
35 | */ | |
36 | ||
37 | #include "core.h" | |
d3a43b90 | 38 | #include "node.h" |
b97bf3fd | 39 | #include "discover.h" |
b97bf3fd | 40 | |
2f55c437 | 41 | /* min delay during bearer start up */ |
b39e465e | 42 | #define TIPC_DISC_INIT msecs_to_jiffies(125) |
2f55c437 | 43 | /* max delay if bearer has no links */ |
b39e465e | 44 | #define TIPC_DISC_FAST msecs_to_jiffies(1000) |
2f55c437 | 45 | /* max delay if bearer has links */ |
b39e465e | 46 | #define TIPC_DISC_SLOW msecs_to_jiffies(60000) |
2f55c437 | 47 | /* indicates no timer in use */ |
b39e465e | 48 | #define TIPC_DISC_INACTIVE 0xffffffff |
b97bf3fd | 49 | |
b97bf3fd | 50 | /** |
b39e465e | 51 | * struct tipc_discoverer - information about an ongoing link setup request |
7a2f7d18 | 52 | * @bearer_id: identity of bearer issuing requests |
7f9f95d9 | 53 | * @net: network namespace instance |
b97bf3fd | 54 | * @dest: destination address for request messages |
7a2f7d18 | 55 | * @domain: network domain to which links can be established |
1209966c | 56 | * @num_nodes: number of nodes currently discovered (i.e. with an active link) |
f9a2c80b | 57 | * @lock: spinlock for controlling access to requests |
b39e465e | 58 | * @skb: request message to be (repeatedly) sent |
b97bf3fd PL |
59 | * @timer: timer governing period between requests |
60 | * @timer_intv: current interval between requests (in ms) | |
61 | */ | |
b39e465e | 62 | struct tipc_discoverer { |
7a2f7d18 | 63 | u32 bearer_id; |
b97bf3fd | 64 | struct tipc_media_addr dest; |
7f9f95d9 | 65 | struct net *net; |
7a2f7d18 | 66 | u32 domain; |
1209966c | 67 | int num_nodes; |
f9a2c80b | 68 | spinlock_t lock; |
b39e465e | 69 | struct sk_buff *skb; |
b97bf3fd | 70 | struct timer_list timer; |
2f55c437 | 71 | unsigned long timer_intv; |
b97bf3fd PL |
72 | }; |
73 | ||
c4307285 | 74 | /** |
4323add6 | 75 | * tipc_disc_init_msg - initialize a link setup message |
c93d3baa | 76 | * @net: the applicable net namespace |
b97bf3fd | 77 | * @type: message type (request or response) |
1a90632d | 78 | * @b: ptr to bearer issuing message |
b97bf3fd | 79 | */ |
b39e465e | 80 | static void tipc_disc_init_msg(struct net *net, struct sk_buff *skb, |
25b0b9c4 | 81 | u32 mtyp, struct tipc_bearer *b) |
b97bf3fd | 82 | { |
b39e465e | 83 | struct tipc_net *tn = tipc_net(net); |
1a90632d | 84 | u32 dest_domain = b->domain; |
b39e465e | 85 | struct tipc_msg *hdr; |
b97bf3fd | 86 | |
b39e465e | 87 | hdr = buf_msg(skb); |
25b0b9c4 | 88 | tipc_msg_init(tn->trial_addr, hdr, LINK_CONFIG, mtyp, |
948fa2d1 | 89 | MAX_H_SIZE, dest_domain); |
25b0b9c4 | 90 | msg_set_size(hdr, MAX_H_SIZE + NODE_ID_LEN); |
b39e465e JM |
91 | msg_set_non_seq(hdr, 1); |
92 | msg_set_node_sig(hdr, tn->random); | |
93 | msg_set_node_capabilities(hdr, TIPC_NODE_CAPABILITIES); | |
94 | msg_set_dest_domain(hdr, dest_domain); | |
95 | msg_set_bc_netid(hdr, tn->net_id); | |
96 | b->media->addr2msg(msg_media_addr(hdr), &b->addr); | |
25b0b9c4 | 97 | msg_set_node_id(hdr, tipc_own_id(net)); |
b39e465e JM |
98 | } |
99 | ||
25b0b9c4 JM |
100 | static void tipc_disc_msg_xmit(struct net *net, u32 mtyp, u32 dst, |
101 | u32 src, u32 sugg_addr, | |
b39e465e JM |
102 | struct tipc_media_addr *maddr, |
103 | struct tipc_bearer *b) | |
104 | { | |
25b0b9c4 | 105 | struct tipc_msg *hdr; |
b39e465e JM |
106 | struct sk_buff *skb; |
107 | ||
25b0b9c4 | 108 | skb = tipc_buf_acquire(MAX_H_SIZE + NODE_ID_LEN, GFP_ATOMIC); |
b39e465e JM |
109 | if (!skb) |
110 | return; | |
25b0b9c4 | 111 | hdr = buf_msg(skb); |
b39e465e | 112 | tipc_disc_init_msg(net, skb, mtyp, b); |
25b0b9c4 JM |
113 | msg_set_sugg_node_addr(hdr, sugg_addr); |
114 | msg_set_dest_domain(hdr, dst); | |
b39e465e | 115 | tipc_bearer_xmit_skb(net, b->identity, skb, maddr); |
b97bf3fd PL |
116 | } |
117 | ||
e91ed0bc AS |
118 | /** |
119 | * disc_dupl_alert - issue node address duplication alert | |
1a90632d | 120 | * @b: pointer to bearer detecting duplication |
e91ed0bc AS |
121 | * @node_addr: duplicated node address |
122 | * @media_addr: media address advertised by duplicated node | |
123 | */ | |
1a90632d | 124 | static void disc_dupl_alert(struct tipc_bearer *b, u32 node_addr, |
e91ed0bc AS |
125 | struct tipc_media_addr *media_addr) |
126 | { | |
e91ed0bc | 127 | char media_addr_str[64]; |
e91ed0bc | 128 | |
dc1aed37 EH |
129 | tipc_media_addr_printf(media_addr_str, sizeof(media_addr_str), |
130 | media_addr); | |
d50ccc2d | 131 | pr_warn("Duplicate %x using %s seen on <%s>\n", node_addr, |
1a90632d | 132 | media_addr_str, b->name); |
e91ed0bc AS |
133 | } |
134 | ||
25b0b9c4 | 135 | /* tipc_disc_addr_trial(): - handle an address uniqueness trial from peer |
e415577f JM |
136 | * Returns true if message should be dropped by caller, i.e., if it is a |
137 | * trial message or we are inside trial period. Otherwise false. | |
25b0b9c4 | 138 | */ |
da18ab32 | 139 | static bool tipc_disc_addr_trial_msg(struct tipc_discoverer *d, |
140 | struct tipc_media_addr *maddr, | |
141 | struct tipc_bearer *b, | |
142 | u32 dst, u32 src, | |
143 | u32 sugg_addr, | |
144 | u8 *peer_id, | |
145 | int mtyp) | |
25b0b9c4 JM |
146 | { |
147 | struct net *net = d->net; | |
148 | struct tipc_net *tn = tipc_net(net); | |
149 | bool trial = time_before(jiffies, tn->addr_trial_end); | |
150 | u32 self = tipc_own_addr(net); | |
151 | ||
152 | if (mtyp == DSC_TRIAL_FAIL_MSG) { | |
153 | if (!trial) | |
154 | return true; | |
155 | ||
156 | /* Ignore if somebody else already gave new suggestion */ | |
157 | if (dst != tn->trial_addr) | |
158 | return true; | |
159 | ||
160 | /* Otherwise update trial address and restart trial period */ | |
161 | tn->trial_addr = sugg_addr; | |
162 | msg_set_prevnode(buf_msg(d->skb), sugg_addr); | |
163 | tn->addr_trial_end = jiffies + msecs_to_jiffies(1000); | |
164 | return true; | |
165 | } | |
166 | ||
167 | /* Apply trial address if we just left trial period */ | |
168 | if (!trial && !self) { | |
169 | tipc_net_finalize(net, tn->trial_addr); | |
170 | msg_set_type(buf_msg(d->skb), DSC_REQ_MSG); | |
171 | } | |
172 | ||
e415577f | 173 | /* Accept regular link requests/responses only after trial period */ |
25b0b9c4 | 174 | if (mtyp != DSC_TRIAL_MSG) |
e415577f | 175 | return trial; |
25b0b9c4 JM |
176 | |
177 | sugg_addr = tipc_node_try_addr(net, peer_id, src); | |
178 | if (sugg_addr) | |
179 | tipc_disc_msg_xmit(net, DSC_TRIAL_FAIL_MSG, src, | |
180 | self, sugg_addr, maddr, b); | |
181 | return true; | |
182 | } | |
183 | ||
b97bf3fd | 184 | /** |
c82910e2 | 185 | * tipc_disc_rcv - handle incoming discovery message (request or response) |
b39e465e JM |
186 | * @net: applicable net namespace |
187 | * @skb: buffer containing message | |
188 | * @b: bearer that message arrived on | |
b97bf3fd | 189 | */ |
cf148816 | 190 | void tipc_disc_rcv(struct net *net, struct sk_buff *skb, |
b39e465e | 191 | struct tipc_bearer *b) |
b97bf3fd | 192 | { |
b39e465e | 193 | struct tipc_net *tn = tipc_net(net); |
cf148816 | 194 | struct tipc_msg *hdr = buf_msg(skb); |
b39e465e | 195 | u16 caps = msg_node_capabilities(hdr); |
b89afb11 | 196 | bool legacy = tn->legacy_addr_format; |
25b0b9c4 | 197 | u32 sugg = msg_sugg_node_addr(hdr); |
b39e465e | 198 | u32 signature = msg_node_sig(hdr); |
25b0b9c4 | 199 | u8 peer_id[NODE_ID_LEN] = {0,}; |
b39e465e | 200 | u32 dst = msg_dest_domain(hdr); |
cf148816 | 201 | u32 net_id = msg_bc_netid(hdr); |
b39e465e JM |
202 | struct tipc_media_addr maddr; |
203 | u32 src = msg_prevnode(hdr); | |
cf148816 | 204 | u32 mtyp = msg_type(hdr); |
cf148816 | 205 | bool dupl_addr = false; |
b39e465e | 206 | bool respond = false; |
25b0b9c4 | 207 | u32 self; |
e9942923 | 208 | int err; |
b97bf3fd | 209 | |
25b0b9c4 JM |
210 | skb_linearize(skb); |
211 | hdr = buf_msg(skb); | |
212 | ||
213 | if (caps & TIPC_NODE_ID128) | |
214 | memcpy(peer_id, msg_node_id(hdr), NODE_ID_LEN); | |
215 | else | |
216 | sprintf(peer_id, "%x", src); | |
217 | ||
b39e465e | 218 | err = b->media->msg2addr(b, &maddr, msg_media_addr(hdr)); |
cf148816 | 219 | kfree_skb(skb); |
b39e465e JM |
220 | if (err || maddr.broadcast) { |
221 | pr_warn_ratelimited("Rcv corrupt discovery message\n"); | |
e9942923 | 222 | return; |
b39e465e JM |
223 | } |
224 | /* Ignore discovery messages from own node */ | |
225 | if (!memcmp(&maddr, &b->addr, sizeof(maddr))) | |
b97bf3fd | 226 | return; |
b39e465e | 227 | if (net_id != tn->net_id) |
d6d4577a | 228 | return; |
25b0b9c4 JM |
229 | if (tipc_disc_addr_trial_msg(b->disc, &maddr, b, dst, |
230 | src, sugg, peer_id, mtyp)) | |
231 | return; | |
232 | self = tipc_own_addr(net); | |
233 | ||
234 | /* Message from somebody using this node's address */ | |
b39e465e JM |
235 | if (in_own_node(net, src)) { |
236 | disc_dupl_alert(b, self, &maddr); | |
b97bf3fd | 237 | return; |
e91ed0bc | 238 | } |
b89afb11 JM |
239 | if (!tipc_in_scope(legacy, dst, self)) |
240 | return; | |
241 | if (!tipc_in_scope(legacy, b->domain, src)) | |
242 | return; | |
25b0b9c4 | 243 | tipc_node_check_dest(net, src, peer_id, b, caps, signature, |
cf148816 JPM |
244 | &maddr, &respond, &dupl_addr); |
245 | if (dupl_addr) | |
b39e465e JM |
246 | disc_dupl_alert(b, src, &maddr); |
247 | if (!respond) | |
248 | return; | |
249 | if (mtyp != DSC_REQ_MSG) | |
250 | return; | |
25b0b9c4 | 251 | tipc_disc_msg_xmit(net, DSC_RESP_MSG, src, self, 0, &maddr, b); |
b97bf3fd PL |
252 | } |
253 | ||
b39e465e | 254 | /* tipc_disc_add_dest - increment set of discovered nodes |
b97bf3fd | 255 | */ |
b39e465e | 256 | void tipc_disc_add_dest(struct tipc_discoverer *d) |
b97bf3fd | 257 | { |
b39e465e JM |
258 | spin_lock_bh(&d->lock); |
259 | d->num_nodes++; | |
260 | spin_unlock_bh(&d->lock); | |
c4307285 | 261 | } |
b97bf3fd | 262 | |
b39e465e | 263 | /* tipc_disc_remove_dest - decrement set of discovered nodes |
1209966c | 264 | */ |
b39e465e | 265 | void tipc_disc_remove_dest(struct tipc_discoverer *d) |
1209966c | 266 | { |
b39e465e | 267 | int intv, num; |
1209966c | 268 | |
b39e465e JM |
269 | spin_lock_bh(&d->lock); |
270 | d->num_nodes--; | |
271 | num = d->num_nodes; | |
272 | intv = d->timer_intv; | |
273 | if (!num && (intv == TIPC_DISC_INACTIVE || intv > TIPC_DISC_FAST)) { | |
274 | d->timer_intv = TIPC_DISC_INIT; | |
275 | mod_timer(&d->timer, jiffies + d->timer_intv); | |
276 | } | |
277 | spin_unlock_bh(&d->lock); | |
1209966c AS |
278 | } |
279 | ||
b39e465e | 280 | /* tipc_disc_timeout - send a periodic link setup request |
b97bf3fd | 281 | * Called whenever a link setup request timer associated with a bearer expires. |
b39e465e JM |
282 | * - Keep doubling time between sent request until limit is reached; |
283 | * - Hold at fast polling rate if we don't have any associated nodes | |
284 | * - Otherwise hold at slow polling rate | |
b97bf3fd | 285 | */ |
b39e465e | 286 | static void tipc_disc_timeout(struct timer_list *t) |
b97bf3fd | 287 | { |
b39e465e | 288 | struct tipc_discoverer *d = from_timer(d, t, timer); |
25b0b9c4 | 289 | struct tipc_net *tn = tipc_net(d->net); |
b39e465e JM |
290 | struct tipc_media_addr maddr; |
291 | struct sk_buff *skb = NULL; | |
25b0b9c4 | 292 | struct net *net = d->net; |
b39e465e | 293 | u32 bearer_id; |
972a77fb | 294 | |
b39e465e | 295 | spin_lock_bh(&d->lock); |
b97bf3fd | 296 | |
972a77fb | 297 | /* Stop searching if only desired node has been found */ |
b39e465e JM |
298 | if (tipc_node(d->domain) && d->num_nodes) { |
299 | d->timer_intv = TIPC_DISC_INACTIVE; | |
972a77fb | 300 | goto exit; |
b97bf3fd | 301 | } |
25b0b9c4 | 302 | |
92018c7c JM |
303 | /* Trial period over ? */ |
304 | if (!time_before(jiffies, tn->addr_trial_end)) { | |
305 | /* Did we just leave it ? */ | |
306 | if (!tipc_own_addr(net)) | |
307 | tipc_net_finalize(net, tn->trial_addr); | |
308 | ||
25b0b9c4 | 309 | msg_set_type(buf_msg(d->skb), DSC_REQ_MSG); |
92018c7c | 310 | msg_set_prevnode(buf_msg(d->skb), tipc_own_addr(net)); |
25b0b9c4 JM |
311 | } |
312 | ||
b39e465e | 313 | /* Adjust timeout interval according to discovery phase */ |
25b0b9c4 JM |
314 | if (time_before(jiffies, tn->addr_trial_end)) { |
315 | d->timer_intv = TIPC_DISC_INIT; | |
316 | } else { | |
317 | d->timer_intv *= 2; | |
318 | if (d->num_nodes && d->timer_intv > TIPC_DISC_SLOW) | |
319 | d->timer_intv = TIPC_DISC_SLOW; | |
320 | else if (!d->num_nodes && d->timer_intv > TIPC_DISC_FAST) | |
321 | d->timer_intv = TIPC_DISC_FAST; | |
322 | } | |
323 | ||
b39e465e JM |
324 | mod_timer(&d->timer, jiffies + d->timer_intv); |
325 | memcpy(&maddr, &d->dest, sizeof(maddr)); | |
326 | skb = skb_clone(d->skb, GFP_ATOMIC); | |
b39e465e | 327 | bearer_id = d->bearer_id; |
972a77fb | 328 | exit: |
b39e465e JM |
329 | spin_unlock_bh(&d->lock); |
330 | if (skb) | |
331 | tipc_bearer_xmit_skb(net, bearer_id, skb, &maddr); | |
b97bf3fd PL |
332 | } |
333 | ||
334 | /** | |
3a777ff8 | 335 | * tipc_disc_create - create object to send periodic link setup requests |
c93d3baa | 336 | * @net: the applicable net namespace |
1a90632d | 337 | * @b: ptr to bearer issuing requests |
b97bf3fd | 338 | * @dest: destination address for request messages |
66e019a6 | 339 | * @dest_domain: network domain to which links can be established |
c4307285 | 340 | * |
3a777ff8 | 341 | * Returns 0 if successful, otherwise -errno. |
b97bf3fd | 342 | */ |
1a90632d | 343 | int tipc_disc_create(struct net *net, struct tipc_bearer *b, |
4e801fa1 | 344 | struct tipc_media_addr *dest, struct sk_buff **skb) |
b97bf3fd | 345 | { |
25b0b9c4 | 346 | struct tipc_net *tn = tipc_net(net); |
b39e465e | 347 | struct tipc_discoverer *d; |
b97bf3fd | 348 | |
b39e465e JM |
349 | d = kmalloc(sizeof(*d), GFP_ATOMIC); |
350 | if (!d) | |
3a777ff8 | 351 | return -ENOMEM; |
25b0b9c4 | 352 | d->skb = tipc_buf_acquire(MAX_H_SIZE + NODE_ID_LEN, GFP_ATOMIC); |
b39e465e JM |
353 | if (!d->skb) { |
354 | kfree(d); | |
a8b9b96e | 355 | return -ENOMEM; |
22e7987a | 356 | } |
b39e465e | 357 | tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b); |
25b0b9c4 JM |
358 | |
359 | /* Do we need an address trial period first ? */ | |
360 | if (!tipc_own_addr(net)) { | |
361 | tn->addr_trial_end = jiffies + msecs_to_jiffies(1000); | |
362 | msg_set_type(buf_msg(d->skb), DSC_TRIAL_MSG); | |
363 | } | |
b39e465e JM |
364 | memcpy(&d->dest, dest, sizeof(*dest)); |
365 | d->net = net; | |
366 | d->bearer_id = b->identity; | |
367 | d->domain = b->domain; | |
368 | d->num_nodes = 0; | |
369 | d->timer_intv = TIPC_DISC_INIT; | |
370 | spin_lock_init(&d->lock); | |
371 | timer_setup(&d->timer, tipc_disc_timeout, 0); | |
372 | mod_timer(&d->timer, jiffies + d->timer_intv); | |
373 | b->disc = d; | |
374 | *skb = skb_clone(d->skb, GFP_ATOMIC); | |
3a777ff8 AS |
375 | return 0; |
376 | } | |
377 | ||
378 | /** | |
379 | * tipc_disc_delete - destroy object sending periodic link setup requests | |
b39e465e | 380 | * @d: ptr to link duest structure |
3a777ff8 | 381 | */ |
b39e465e | 382 | void tipc_disc_delete(struct tipc_discoverer *d) |
3a777ff8 | 383 | { |
b39e465e JM |
384 | del_timer_sync(&d->timer); |
385 | kfree_skb(d->skb); | |
386 | kfree(d); | |
c4307285 | 387 | } |
a8b9b96e YX |
388 | |
389 | /** | |
390 | * tipc_disc_reset - reset object to send periodic link setup requests | |
c93d3baa | 391 | * @net: the applicable net namespace |
1a90632d | 392 | * @b: ptr to bearer issuing requests |
a8b9b96e YX |
393 | * @dest_domain: network domain to which links can be established |
394 | */ | |
1a90632d | 395 | void tipc_disc_reset(struct net *net, struct tipc_bearer *b) |
a8b9b96e | 396 | { |
b39e465e JM |
397 | struct tipc_discoverer *d = b->disc; |
398 | struct tipc_media_addr maddr; | |
60852d67 | 399 | struct sk_buff *skb; |
a8b9b96e | 400 | |
b39e465e JM |
401 | spin_lock_bh(&d->lock); |
402 | tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b); | |
403 | d->net = net; | |
404 | d->bearer_id = b->identity; | |
405 | d->domain = b->domain; | |
406 | d->num_nodes = 0; | |
407 | d->timer_intv = TIPC_DISC_INIT; | |
408 | memcpy(&maddr, &d->dest, sizeof(maddr)); | |
409 | mod_timer(&d->timer, jiffies + d->timer_intv); | |
410 | skb = skb_clone(d->skb, GFP_ATOMIC); | |
411 | spin_unlock_bh(&d->lock); | |
60852d67 | 412 | if (skb) |
b39e465e | 413 | tipc_bearer_xmit_skb(net, b->identity, skb, &maddr); |
a8b9b96e | 414 | } |