]>
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 JM |
135 | /* tipc_disc_addr_trial(): - handle an address uniqueness trial from peer |
136 | */ | |
da18ab32 | 137 | static bool tipc_disc_addr_trial_msg(struct tipc_discoverer *d, |
138 | struct tipc_media_addr *maddr, | |
139 | struct tipc_bearer *b, | |
140 | u32 dst, u32 src, | |
141 | u32 sugg_addr, | |
142 | u8 *peer_id, | |
143 | int mtyp) | |
25b0b9c4 JM |
144 | { |
145 | struct net *net = d->net; | |
146 | struct tipc_net *tn = tipc_net(net); | |
147 | bool trial = time_before(jiffies, tn->addr_trial_end); | |
148 | u32 self = tipc_own_addr(net); | |
149 | ||
150 | if (mtyp == DSC_TRIAL_FAIL_MSG) { | |
151 | if (!trial) | |
152 | return true; | |
153 | ||
154 | /* Ignore if somebody else already gave new suggestion */ | |
155 | if (dst != tn->trial_addr) | |
156 | return true; | |
157 | ||
158 | /* Otherwise update trial address and restart trial period */ | |
159 | tn->trial_addr = sugg_addr; | |
160 | msg_set_prevnode(buf_msg(d->skb), sugg_addr); | |
161 | tn->addr_trial_end = jiffies + msecs_to_jiffies(1000); | |
162 | return true; | |
163 | } | |
164 | ||
165 | /* Apply trial address if we just left trial period */ | |
166 | if (!trial && !self) { | |
167 | tipc_net_finalize(net, tn->trial_addr); | |
168 | msg_set_type(buf_msg(d->skb), DSC_REQ_MSG); | |
169 | } | |
170 | ||
171 | if (mtyp != DSC_TRIAL_MSG) | |
172 | return false; | |
173 | ||
174 | sugg_addr = tipc_node_try_addr(net, peer_id, src); | |
175 | if (sugg_addr) | |
176 | tipc_disc_msg_xmit(net, DSC_TRIAL_FAIL_MSG, src, | |
177 | self, sugg_addr, maddr, b); | |
178 | return true; | |
179 | } | |
180 | ||
b97bf3fd | 181 | /** |
c82910e2 | 182 | * tipc_disc_rcv - handle incoming discovery message (request or response) |
b39e465e JM |
183 | * @net: applicable net namespace |
184 | * @skb: buffer containing message | |
185 | * @b: bearer that message arrived on | |
b97bf3fd | 186 | */ |
cf148816 | 187 | void tipc_disc_rcv(struct net *net, struct sk_buff *skb, |
b39e465e | 188 | struct tipc_bearer *b) |
b97bf3fd | 189 | { |
b39e465e | 190 | struct tipc_net *tn = tipc_net(net); |
cf148816 | 191 | struct tipc_msg *hdr = buf_msg(skb); |
b39e465e | 192 | u16 caps = msg_node_capabilities(hdr); |
b89afb11 | 193 | bool legacy = tn->legacy_addr_format; |
25b0b9c4 | 194 | u32 sugg = msg_sugg_node_addr(hdr); |
b39e465e | 195 | u32 signature = msg_node_sig(hdr); |
25b0b9c4 | 196 | u8 peer_id[NODE_ID_LEN] = {0,}; |
b39e465e | 197 | u32 dst = msg_dest_domain(hdr); |
cf148816 | 198 | u32 net_id = msg_bc_netid(hdr); |
b39e465e JM |
199 | struct tipc_media_addr maddr; |
200 | u32 src = msg_prevnode(hdr); | |
cf148816 | 201 | u32 mtyp = msg_type(hdr); |
cf148816 | 202 | bool dupl_addr = false; |
b39e465e | 203 | bool respond = false; |
25b0b9c4 | 204 | u32 self; |
e9942923 | 205 | int err; |
b97bf3fd | 206 | |
25b0b9c4 JM |
207 | skb_linearize(skb); |
208 | hdr = buf_msg(skb); | |
209 | ||
210 | if (caps & TIPC_NODE_ID128) | |
211 | memcpy(peer_id, msg_node_id(hdr), NODE_ID_LEN); | |
212 | else | |
213 | sprintf(peer_id, "%x", src); | |
214 | ||
b39e465e | 215 | err = b->media->msg2addr(b, &maddr, msg_media_addr(hdr)); |
cf148816 | 216 | kfree_skb(skb); |
b39e465e JM |
217 | if (err || maddr.broadcast) { |
218 | pr_warn_ratelimited("Rcv corrupt discovery message\n"); | |
e9942923 | 219 | return; |
b39e465e JM |
220 | } |
221 | /* Ignore discovery messages from own node */ | |
222 | if (!memcmp(&maddr, &b->addr, sizeof(maddr))) | |
b97bf3fd | 223 | return; |
b39e465e | 224 | if (net_id != tn->net_id) |
d6d4577a | 225 | return; |
25b0b9c4 JM |
226 | if (tipc_disc_addr_trial_msg(b->disc, &maddr, b, dst, |
227 | src, sugg, peer_id, mtyp)) | |
228 | return; | |
229 | self = tipc_own_addr(net); | |
230 | ||
231 | /* Message from somebody using this node's address */ | |
b39e465e JM |
232 | if (in_own_node(net, src)) { |
233 | disc_dupl_alert(b, self, &maddr); | |
b97bf3fd | 234 | return; |
e91ed0bc | 235 | } |
b89afb11 JM |
236 | if (!tipc_in_scope(legacy, dst, self)) |
237 | return; | |
238 | if (!tipc_in_scope(legacy, b->domain, src)) | |
239 | return; | |
25b0b9c4 | 240 | tipc_node_check_dest(net, src, peer_id, b, caps, signature, |
cf148816 JPM |
241 | &maddr, &respond, &dupl_addr); |
242 | if (dupl_addr) | |
b39e465e JM |
243 | disc_dupl_alert(b, src, &maddr); |
244 | if (!respond) | |
245 | return; | |
246 | if (mtyp != DSC_REQ_MSG) | |
247 | return; | |
25b0b9c4 | 248 | tipc_disc_msg_xmit(net, DSC_RESP_MSG, src, self, 0, &maddr, b); |
b97bf3fd PL |
249 | } |
250 | ||
b39e465e | 251 | /* tipc_disc_add_dest - increment set of discovered nodes |
b97bf3fd | 252 | */ |
b39e465e | 253 | void tipc_disc_add_dest(struct tipc_discoverer *d) |
b97bf3fd | 254 | { |
b39e465e JM |
255 | spin_lock_bh(&d->lock); |
256 | d->num_nodes++; | |
257 | spin_unlock_bh(&d->lock); | |
c4307285 | 258 | } |
b97bf3fd | 259 | |
b39e465e | 260 | /* tipc_disc_remove_dest - decrement set of discovered nodes |
1209966c | 261 | */ |
b39e465e | 262 | void tipc_disc_remove_dest(struct tipc_discoverer *d) |
1209966c | 263 | { |
b39e465e | 264 | int intv, num; |
1209966c | 265 | |
b39e465e JM |
266 | spin_lock_bh(&d->lock); |
267 | d->num_nodes--; | |
268 | num = d->num_nodes; | |
269 | intv = d->timer_intv; | |
270 | if (!num && (intv == TIPC_DISC_INACTIVE || intv > TIPC_DISC_FAST)) { | |
271 | d->timer_intv = TIPC_DISC_INIT; | |
272 | mod_timer(&d->timer, jiffies + d->timer_intv); | |
273 | } | |
274 | spin_unlock_bh(&d->lock); | |
1209966c AS |
275 | } |
276 | ||
b39e465e | 277 | /* tipc_disc_timeout - send a periodic link setup request |
b97bf3fd | 278 | * Called whenever a link setup request timer associated with a bearer expires. |
b39e465e JM |
279 | * - Keep doubling time between sent request until limit is reached; |
280 | * - Hold at fast polling rate if we don't have any associated nodes | |
281 | * - Otherwise hold at slow polling rate | |
b97bf3fd | 282 | */ |
b39e465e | 283 | static void tipc_disc_timeout(struct timer_list *t) |
b97bf3fd | 284 | { |
b39e465e | 285 | struct tipc_discoverer *d = from_timer(d, t, timer); |
25b0b9c4 JM |
286 | struct tipc_net *tn = tipc_net(d->net); |
287 | u32 self = tipc_own_addr(d->net); | |
b39e465e JM |
288 | struct tipc_media_addr maddr; |
289 | struct sk_buff *skb = NULL; | |
25b0b9c4 | 290 | struct net *net = d->net; |
b39e465e | 291 | u32 bearer_id; |
972a77fb | 292 | |
b39e465e | 293 | spin_lock_bh(&d->lock); |
b97bf3fd | 294 | |
972a77fb | 295 | /* Stop searching if only desired node has been found */ |
b39e465e JM |
296 | if (tipc_node(d->domain) && d->num_nodes) { |
297 | d->timer_intv = TIPC_DISC_INACTIVE; | |
972a77fb | 298 | goto exit; |
b97bf3fd | 299 | } |
25b0b9c4 JM |
300 | |
301 | /* Did we just leave the address trial period ? */ | |
302 | if (!self && !time_before(jiffies, tn->addr_trial_end)) { | |
303 | self = tn->trial_addr; | |
304 | tipc_net_finalize(net, self); | |
305 | msg_set_prevnode(buf_msg(d->skb), self); | |
306 | msg_set_type(buf_msg(d->skb), DSC_REQ_MSG); | |
307 | } | |
308 | ||
b39e465e | 309 | /* Adjust timeout interval according to discovery phase */ |
25b0b9c4 JM |
310 | if (time_before(jiffies, tn->addr_trial_end)) { |
311 | d->timer_intv = TIPC_DISC_INIT; | |
312 | } else { | |
313 | d->timer_intv *= 2; | |
314 | if (d->num_nodes && d->timer_intv > TIPC_DISC_SLOW) | |
315 | d->timer_intv = TIPC_DISC_SLOW; | |
316 | else if (!d->num_nodes && d->timer_intv > TIPC_DISC_FAST) | |
317 | d->timer_intv = TIPC_DISC_FAST; | |
318 | } | |
319 | ||
b39e465e JM |
320 | mod_timer(&d->timer, jiffies + d->timer_intv); |
321 | memcpy(&maddr, &d->dest, sizeof(maddr)); | |
322 | skb = skb_clone(d->skb, GFP_ATOMIC); | |
b39e465e | 323 | bearer_id = d->bearer_id; |
972a77fb | 324 | exit: |
b39e465e JM |
325 | spin_unlock_bh(&d->lock); |
326 | if (skb) | |
327 | tipc_bearer_xmit_skb(net, bearer_id, skb, &maddr); | |
b97bf3fd PL |
328 | } |
329 | ||
330 | /** | |
3a777ff8 | 331 | * tipc_disc_create - create object to send periodic link setup requests |
c93d3baa | 332 | * @net: the applicable net namespace |
1a90632d | 333 | * @b: ptr to bearer issuing requests |
b97bf3fd | 334 | * @dest: destination address for request messages |
66e019a6 | 335 | * @dest_domain: network domain to which links can be established |
c4307285 | 336 | * |
3a777ff8 | 337 | * Returns 0 if successful, otherwise -errno. |
b97bf3fd | 338 | */ |
1a90632d | 339 | int tipc_disc_create(struct net *net, struct tipc_bearer *b, |
4e801fa1 | 340 | struct tipc_media_addr *dest, struct sk_buff **skb) |
b97bf3fd | 341 | { |
25b0b9c4 | 342 | struct tipc_net *tn = tipc_net(net); |
b39e465e | 343 | struct tipc_discoverer *d; |
b97bf3fd | 344 | |
b39e465e JM |
345 | d = kmalloc(sizeof(*d), GFP_ATOMIC); |
346 | if (!d) | |
3a777ff8 | 347 | return -ENOMEM; |
25b0b9c4 | 348 | d->skb = tipc_buf_acquire(MAX_H_SIZE + NODE_ID_LEN, GFP_ATOMIC); |
b39e465e JM |
349 | if (!d->skb) { |
350 | kfree(d); | |
a8b9b96e | 351 | return -ENOMEM; |
22e7987a | 352 | } |
b39e465e | 353 | tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b); |
25b0b9c4 JM |
354 | |
355 | /* Do we need an address trial period first ? */ | |
356 | if (!tipc_own_addr(net)) { | |
357 | tn->addr_trial_end = jiffies + msecs_to_jiffies(1000); | |
358 | msg_set_type(buf_msg(d->skb), DSC_TRIAL_MSG); | |
359 | } | |
b39e465e JM |
360 | memcpy(&d->dest, dest, sizeof(*dest)); |
361 | d->net = net; | |
362 | d->bearer_id = b->identity; | |
363 | d->domain = b->domain; | |
364 | d->num_nodes = 0; | |
365 | d->timer_intv = TIPC_DISC_INIT; | |
366 | spin_lock_init(&d->lock); | |
367 | timer_setup(&d->timer, tipc_disc_timeout, 0); | |
368 | mod_timer(&d->timer, jiffies + d->timer_intv); | |
369 | b->disc = d; | |
370 | *skb = skb_clone(d->skb, GFP_ATOMIC); | |
3a777ff8 AS |
371 | return 0; |
372 | } | |
373 | ||
374 | /** | |
375 | * tipc_disc_delete - destroy object sending periodic link setup requests | |
b39e465e | 376 | * @d: ptr to link duest structure |
3a777ff8 | 377 | */ |
b39e465e | 378 | void tipc_disc_delete(struct tipc_discoverer *d) |
3a777ff8 | 379 | { |
b39e465e JM |
380 | del_timer_sync(&d->timer); |
381 | kfree_skb(d->skb); | |
382 | kfree(d); | |
c4307285 | 383 | } |
a8b9b96e YX |
384 | |
385 | /** | |
386 | * tipc_disc_reset - reset object to send periodic link setup requests | |
c93d3baa | 387 | * @net: the applicable net namespace |
1a90632d | 388 | * @b: ptr to bearer issuing requests |
a8b9b96e YX |
389 | * @dest_domain: network domain to which links can be established |
390 | */ | |
1a90632d | 391 | void tipc_disc_reset(struct net *net, struct tipc_bearer *b) |
a8b9b96e | 392 | { |
b39e465e JM |
393 | struct tipc_discoverer *d = b->disc; |
394 | struct tipc_media_addr maddr; | |
60852d67 | 395 | struct sk_buff *skb; |
a8b9b96e | 396 | |
b39e465e JM |
397 | spin_lock_bh(&d->lock); |
398 | tipc_disc_init_msg(net, d->skb, DSC_REQ_MSG, b); | |
399 | d->net = net; | |
400 | d->bearer_id = b->identity; | |
401 | d->domain = b->domain; | |
402 | d->num_nodes = 0; | |
403 | d->timer_intv = TIPC_DISC_INIT; | |
404 | memcpy(&maddr, &d->dest, sizeof(maddr)); | |
405 | mod_timer(&d->timer, jiffies + d->timer_intv); | |
406 | skb = skb_clone(d->skb, GFP_ATOMIC); | |
407 | spin_unlock_bh(&d->lock); | |
60852d67 | 408 | if (skb) |
b39e465e | 409 | tipc_bearer_xmit_skb(net, b->identity, skb, &maddr); |
a8b9b96e | 410 | } |