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