Commit | Line | Data |
---|---|---|
35c55c98 JPM |
1 | /* |
2 | * net/tipc/monitor.c | |
3 | * | |
4 | * Copyright (c) 2016, Ericsson AB | |
5 | * All rights reserved. | |
6 | * | |
7 | * Redistribution and use in source and binary forms, with or without | |
8 | * modification, are permitted provided that the following conditions are met: | |
9 | * | |
10 | * 1. Redistributions of source code must retain the above copyright | |
11 | * notice, this list of conditions and the following disclaimer. | |
12 | * 2. Redistributions in binary form must reproduce the above copyright | |
13 | * notice, this list of conditions and the following disclaimer in the | |
14 | * documentation and/or other materials provided with the distribution. | |
15 | * 3. Neither the names of the copyright holders nor the names of its | |
16 | * contributors may be used to endorse or promote products derived from | |
17 | * this software without specific prior written permission. | |
18 | * | |
19 | * Alternatively, this software may be distributed under the terms of the | |
20 | * GNU General Public License ("GPL") version 2 as published by the Free | |
21 | * Software Foundation. | |
22 | * | |
23 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
24 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
25 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
26 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
27 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
28 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
29 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
30 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
31 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
32 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
33 | * POSSIBILITY OF SUCH DAMAGE. | |
34 | */ | |
35 | ||
36 | #include "core.h" | |
37 | #include "addr.h" | |
38 | #include "monitor.h" | |
39 | ||
40 | #define MAX_MON_DOMAIN 64 | |
41 | #define MON_TIMEOUT 120000 | |
42 | #define MAX_PEER_DOWN_EVENTS 4 | |
43 | ||
44 | /* struct tipc_mon_domain: domain record to be transferred between peers | |
45 | * @len: actual size of domain record | |
46 | * @gen: current generation of sender's domain | |
47 | * @ack_gen: most recent generation of self's domain acked by peer | |
48 | * @member_cnt: number of domain member nodes described in this record | |
49 | * @up_map: bit map indicating which of the members the sender considers up | |
50 | * @members: identity of the domain members | |
51 | */ | |
52 | struct tipc_mon_domain { | |
53 | u16 len; | |
54 | u16 gen; | |
55 | u16 ack_gen; | |
56 | u16 member_cnt; | |
57 | u64 up_map; | |
58 | u32 members[MAX_MON_DOMAIN]; | |
59 | }; | |
60 | ||
61 | /* struct tipc_peer: state of a peer node and its domain | |
62 | * @addr: tipc node identity of peer | |
63 | * @head_map: shows which other nodes currently consider peer 'up' | |
64 | * @domain: most recent domain record from peer | |
65 | * @hash: position in hashed lookup list | |
66 | * @list: position in linked list, in circular ascending order by 'addr' | |
67 | * @applied: number of reported domain members applied on this monitor list | |
68 | * @is_up: peer is up as seen from this node | |
69 | * @is_head: peer is assigned domain head as seen from this node | |
70 | * @is_local: peer is in local domain and should be continuously monitored | |
71 | * @down_cnt: - numbers of other peers which have reported this on lost | |
72 | */ | |
73 | struct tipc_peer { | |
74 | u32 addr; | |
75 | struct tipc_mon_domain *domain; | |
76 | struct hlist_node hash; | |
77 | struct list_head list; | |
78 | u8 applied; | |
79 | u8 down_cnt; | |
80 | bool is_up; | |
81 | bool is_head; | |
82 | bool is_local; | |
83 | }; | |
84 | ||
85 | struct tipc_monitor { | |
86 | struct hlist_head peers[NODE_HTABLE_SIZE]; | |
87 | int peer_cnt; | |
88 | struct tipc_peer *self; | |
89 | rwlock_t lock; | |
90 | struct tipc_mon_domain cache; | |
91 | u16 list_gen; | |
92 | u16 dom_gen; | |
93 | struct net *net; | |
94 | struct timer_list timer; | |
95 | unsigned long timer_intv; | |
96 | }; | |
97 | ||
98 | static struct tipc_monitor *tipc_monitor(struct net *net, int bearer_id) | |
99 | { | |
100 | return tipc_net(net)->monitors[bearer_id]; | |
101 | } | |
102 | ||
103 | const int tipc_max_domain_size = sizeof(struct tipc_mon_domain); | |
104 | ||
105 | /* dom_rec_len(): actual length of domain record for transport | |
106 | */ | |
107 | static int dom_rec_len(struct tipc_mon_domain *dom, u16 mcnt) | |
108 | { | |
109 | return ((void *)&dom->members - (void *)dom) + (mcnt * sizeof(u32)); | |
110 | } | |
111 | ||
112 | /* dom_size() : calculate size of own domain based on number of peers | |
113 | */ | |
114 | static int dom_size(int peers) | |
115 | { | |
116 | int i = 0; | |
117 | ||
118 | while ((i * i) < peers) | |
119 | i++; | |
120 | return i < MAX_MON_DOMAIN ? i : MAX_MON_DOMAIN; | |
121 | } | |
122 | ||
123 | static void map_set(u64 *up_map, int i, unsigned int v) | |
124 | { | |
125 | *up_map &= ~(1 << i); | |
126 | *up_map |= (v << i); | |
127 | } | |
128 | ||
129 | static int map_get(u64 up_map, int i) | |
130 | { | |
131 | return (up_map & (1 << i)) >> i; | |
132 | } | |
133 | ||
134 | static struct tipc_peer *peer_prev(struct tipc_peer *peer) | |
135 | { | |
136 | return list_last_entry(&peer->list, struct tipc_peer, list); | |
137 | } | |
138 | ||
139 | static struct tipc_peer *peer_nxt(struct tipc_peer *peer) | |
140 | { | |
141 | return list_first_entry(&peer->list, struct tipc_peer, list); | |
142 | } | |
143 | ||
144 | static struct tipc_peer *peer_head(struct tipc_peer *peer) | |
145 | { | |
146 | while (!peer->is_head) | |
147 | peer = peer_prev(peer); | |
148 | return peer; | |
149 | } | |
150 | ||
151 | static struct tipc_peer *get_peer(struct tipc_monitor *mon, u32 addr) | |
152 | { | |
153 | struct tipc_peer *peer; | |
154 | unsigned int thash = tipc_hashfn(addr); | |
155 | ||
156 | hlist_for_each_entry(peer, &mon->peers[thash], hash) { | |
157 | if (peer->addr == addr) | |
158 | return peer; | |
159 | } | |
160 | return NULL; | |
161 | } | |
162 | ||
163 | static struct tipc_peer *get_self(struct net *net, int bearer_id) | |
164 | { | |
165 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
166 | ||
167 | return mon->self; | |
168 | } | |
169 | ||
170 | static inline bool tipc_mon_is_active(struct net *net, struct tipc_monitor *mon) | |
171 | { | |
172 | struct tipc_net *tn = tipc_net(net); | |
173 | ||
174 | return mon->peer_cnt > tn->mon_threshold; | |
175 | } | |
176 | ||
177 | /* mon_identify_lost_members() : - identify amd mark potentially lost members | |
178 | */ | |
179 | static void mon_identify_lost_members(struct tipc_peer *peer, | |
180 | struct tipc_mon_domain *dom_bef, | |
181 | int applied_bef) | |
182 | { | |
183 | struct tipc_peer *member = peer; | |
184 | struct tipc_mon_domain *dom_aft = peer->domain; | |
185 | int applied_aft = peer->applied; | |
186 | int i; | |
187 | ||
188 | for (i = 0; i < applied_bef; i++) { | |
189 | member = peer_nxt(member); | |
190 | ||
191 | /* Do nothing if self or peer already see member as down */ | |
192 | if (!member->is_up || !map_get(dom_bef->up_map, i)) | |
193 | continue; | |
194 | ||
195 | /* Loss of local node must be detected by active probing */ | |
196 | if (member->is_local) | |
197 | continue; | |
198 | ||
199 | /* Start probing if member was removed from applied domain */ | |
200 | if (!applied_aft || (applied_aft < i)) { | |
201 | member->down_cnt = 1; | |
202 | continue; | |
203 | } | |
204 | ||
205 | /* Member loss is confirmed if it is still in applied domain */ | |
206 | if (!map_get(dom_aft->up_map, i)) | |
207 | member->down_cnt++; | |
208 | } | |
209 | } | |
210 | ||
211 | /* mon_apply_domain() : match a peer's domain record against monitor list | |
212 | */ | |
213 | static void mon_apply_domain(struct tipc_monitor *mon, | |
214 | struct tipc_peer *peer) | |
215 | { | |
216 | struct tipc_mon_domain *dom = peer->domain; | |
217 | struct tipc_peer *member; | |
218 | u32 addr; | |
219 | int i; | |
220 | ||
221 | if (!dom || !peer->is_up) | |
222 | return; | |
223 | ||
224 | /* Scan across domain members and match against monitor list */ | |
225 | peer->applied = 0; | |
226 | member = peer_nxt(peer); | |
227 | for (i = 0; i < dom->member_cnt; i++) { | |
228 | addr = dom->members[i]; | |
229 | if (addr != member->addr) | |
230 | return; | |
231 | peer->applied++; | |
232 | member = peer_nxt(member); | |
233 | } | |
234 | } | |
235 | ||
236 | /* mon_update_local_domain() : update after peer addition/removal/up/down | |
237 | */ | |
238 | static void mon_update_local_domain(struct tipc_monitor *mon) | |
239 | { | |
240 | struct tipc_peer *self = mon->self; | |
241 | struct tipc_mon_domain *cache = &mon->cache; | |
242 | struct tipc_mon_domain *dom = self->domain; | |
243 | struct tipc_peer *peer = self; | |
244 | u64 prev_up_map = dom->up_map; | |
245 | u16 member_cnt, i; | |
246 | bool diff; | |
247 | ||
248 | /* Update local domain size based on current size of cluster */ | |
249 | member_cnt = dom_size(mon->peer_cnt) - 1; | |
250 | self->applied = member_cnt; | |
251 | ||
252 | /* Update native and cached outgoing local domain records */ | |
253 | dom->len = dom_rec_len(dom, member_cnt); | |
254 | diff = dom->member_cnt != member_cnt; | |
255 | dom->member_cnt = member_cnt; | |
256 | for (i = 0; i < member_cnt; i++) { | |
257 | peer = peer_nxt(peer); | |
258 | diff |= dom->members[i] != peer->addr; | |
259 | dom->members[i] = peer->addr; | |
260 | map_set(&dom->up_map, i, peer->is_up); | |
261 | cache->members[i] = htonl(peer->addr); | |
262 | } | |
263 | diff |= dom->up_map != prev_up_map; | |
264 | if (!diff) | |
265 | return; | |
266 | dom->gen = ++mon->dom_gen; | |
267 | cache->len = htons(dom->len); | |
268 | cache->gen = htons(dom->gen); | |
269 | cache->member_cnt = htons(member_cnt); | |
270 | cache->up_map = cpu_to_be64(dom->up_map); | |
271 | mon_apply_domain(mon, self); | |
272 | } | |
273 | ||
274 | /* mon_update_neighbors() : update preceding neighbors of added/removed peer | |
275 | */ | |
276 | static void mon_update_neighbors(struct tipc_monitor *mon, | |
277 | struct tipc_peer *peer) | |
278 | { | |
279 | int dz, i; | |
280 | ||
281 | dz = dom_size(mon->peer_cnt); | |
282 | for (i = 0; i < dz; i++) { | |
283 | mon_apply_domain(mon, peer); | |
284 | peer = peer_prev(peer); | |
285 | } | |
286 | } | |
287 | ||
288 | /* mon_assign_roles() : reassign peer roles after a network change | |
289 | * The monitor list is consistent at this stage; i.e., each peer is monitoring | |
290 | * a set of domain members as matched between domain record and the monitor list | |
291 | */ | |
292 | static void mon_assign_roles(struct tipc_monitor *mon, struct tipc_peer *head) | |
293 | { | |
294 | struct tipc_peer *peer = peer_nxt(head); | |
295 | struct tipc_peer *self = mon->self; | |
296 | int i = 0; | |
297 | ||
298 | for (; peer != self; peer = peer_nxt(peer)) { | |
299 | peer->is_local = false; | |
300 | ||
301 | /* Update domain member */ | |
302 | if (i++ < head->applied) { | |
303 | peer->is_head = false; | |
304 | if (head == self) | |
305 | peer->is_local = true; | |
306 | continue; | |
307 | } | |
308 | /* Assign next domain head */ | |
309 | if (!peer->is_up) | |
310 | continue; | |
311 | if (peer->is_head) | |
312 | break; | |
313 | head = peer; | |
314 | head->is_head = true; | |
315 | i = 0; | |
316 | } | |
317 | mon->list_gen++; | |
318 | } | |
319 | ||
320 | void tipc_mon_remove_peer(struct net *net, u32 addr, int bearer_id) | |
321 | { | |
322 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
323 | struct tipc_peer *self = get_self(net, bearer_id); | |
324 | struct tipc_peer *peer, *prev, *head; | |
325 | ||
326 | write_lock_bh(&mon->lock); | |
327 | peer = get_peer(mon, addr); | |
328 | if (!peer) | |
329 | goto exit; | |
330 | prev = peer_prev(peer); | |
331 | list_del(&peer->list); | |
332 | hlist_del(&peer->hash); | |
333 | kfree(peer->domain); | |
334 | kfree(peer); | |
335 | mon->peer_cnt--; | |
336 | head = peer_head(prev); | |
337 | if (head == self) | |
338 | mon_update_local_domain(mon); | |
339 | mon_update_neighbors(mon, prev); | |
340 | ||
341 | /* Revert to full-mesh monitoring if we reach threshold */ | |
342 | if (!tipc_mon_is_active(net, mon)) { | |
343 | list_for_each_entry(peer, &self->list, list) { | |
344 | kfree(peer->domain); | |
345 | peer->domain = NULL; | |
346 | peer->applied = 0; | |
347 | } | |
348 | } | |
349 | mon_assign_roles(mon, head); | |
350 | exit: | |
351 | write_unlock_bh(&mon->lock); | |
352 | } | |
353 | ||
354 | static bool tipc_mon_add_peer(struct tipc_monitor *mon, u32 addr, | |
355 | struct tipc_peer **peer) | |
356 | { | |
357 | struct tipc_peer *self = mon->self; | |
358 | struct tipc_peer *cur, *prev, *p; | |
359 | ||
360 | p = kzalloc(sizeof(*p), GFP_ATOMIC); | |
361 | *peer = p; | |
362 | if (!p) | |
363 | return false; | |
364 | p->addr = addr; | |
365 | ||
366 | /* Add new peer to lookup list */ | |
367 | INIT_LIST_HEAD(&p->list); | |
368 | hlist_add_head(&p->hash, &mon->peers[tipc_hashfn(addr)]); | |
369 | ||
370 | /* Sort new peer into iterator list, in ascending circular order */ | |
371 | prev = self; | |
372 | list_for_each_entry(cur, &self->list, list) { | |
373 | if ((addr > prev->addr) && (addr < cur->addr)) | |
374 | break; | |
375 | if (((addr < cur->addr) || (addr > prev->addr)) && | |
376 | (prev->addr > cur->addr)) | |
377 | break; | |
378 | prev = cur; | |
379 | } | |
380 | list_add_tail(&p->list, &cur->list); | |
381 | mon->peer_cnt++; | |
382 | mon_update_neighbors(mon, p); | |
383 | return true; | |
384 | } | |
385 | ||
386 | void tipc_mon_peer_up(struct net *net, u32 addr, int bearer_id) | |
387 | { | |
388 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
389 | struct tipc_peer *self = get_self(net, bearer_id); | |
390 | struct tipc_peer *peer, *head; | |
391 | ||
392 | write_lock_bh(&mon->lock); | |
393 | peer = get_peer(mon, addr); | |
394 | if (!peer && !tipc_mon_add_peer(mon, addr, &peer)) | |
395 | goto exit; | |
396 | peer->is_up = true; | |
397 | head = peer_head(peer); | |
398 | if (head == self) | |
399 | mon_update_local_domain(mon); | |
400 | mon_assign_roles(mon, head); | |
401 | exit: | |
402 | write_unlock_bh(&mon->lock); | |
403 | } | |
404 | ||
405 | void tipc_mon_peer_down(struct net *net, u32 addr, int bearer_id) | |
406 | { | |
407 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
408 | struct tipc_peer *self = get_self(net, bearer_id); | |
409 | struct tipc_peer *peer, *head; | |
410 | struct tipc_mon_domain *dom; | |
411 | int applied; | |
412 | ||
413 | write_lock_bh(&mon->lock); | |
414 | peer = get_peer(mon, addr); | |
415 | if (!peer) { | |
416 | pr_warn("Mon: unknown link %x/%u DOWN\n", addr, bearer_id); | |
417 | goto exit; | |
418 | } | |
419 | applied = peer->applied; | |
420 | peer->applied = 0; | |
421 | dom = peer->domain; | |
422 | peer->domain = NULL; | |
423 | if (peer->is_head) | |
424 | mon_identify_lost_members(peer, dom, applied); | |
425 | kfree(dom); | |
426 | peer->is_up = false; | |
427 | peer->is_head = false; | |
428 | peer->is_local = false; | |
429 | peer->down_cnt = 0; | |
430 | head = peer_head(peer); | |
431 | if (head == self) | |
432 | mon_update_local_domain(mon); | |
433 | mon_assign_roles(mon, head); | |
434 | exit: | |
435 | write_unlock_bh(&mon->lock); | |
436 | } | |
437 | ||
438 | /* tipc_mon_rcv - process monitor domain event message | |
439 | */ | |
440 | void tipc_mon_rcv(struct net *net, void *data, u16 dlen, u32 addr, | |
441 | struct tipc_mon_state *state, int bearer_id) | |
442 | { | |
443 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
444 | struct tipc_mon_domain *arrv_dom = data; | |
445 | struct tipc_mon_domain dom_bef; | |
446 | struct tipc_mon_domain *dom; | |
447 | struct tipc_peer *peer; | |
448 | u16 new_member_cnt = ntohs(arrv_dom->member_cnt); | |
449 | int new_dlen = dom_rec_len(arrv_dom, new_member_cnt); | |
450 | u16 new_gen = ntohs(arrv_dom->gen); | |
451 | u16 acked_gen = ntohs(arrv_dom->ack_gen); | |
452 | bool probing = state->probing; | |
453 | int i, applied_bef; | |
454 | ||
455 | state->probing = false; | |
456 | if (!dlen) | |
457 | return; | |
458 | ||
459 | /* Sanity check received domain record */ | |
460 | if ((dlen < new_dlen) || ntohs(arrv_dom->len) != new_dlen) { | |
461 | pr_warn_ratelimited("Received illegal domain record\n"); | |
462 | return; | |
463 | } | |
464 | ||
465 | /* Synch generation numbers with peer if link just came up */ | |
466 | if (!state->synched) { | |
467 | state->peer_gen = new_gen - 1; | |
468 | state->acked_gen = acked_gen; | |
469 | state->synched = true; | |
470 | } | |
471 | ||
472 | if (more(acked_gen, state->acked_gen)) | |
473 | state->acked_gen = acked_gen; | |
474 | ||
475 | /* Drop duplicate unless we are waiting for a probe response */ | |
476 | if (!more(new_gen, state->peer_gen) && !probing) | |
477 | return; | |
478 | ||
479 | write_lock_bh(&mon->lock); | |
480 | peer = get_peer(mon, addr); | |
481 | if (!peer || !peer->is_up) | |
482 | goto exit; | |
483 | ||
484 | /* Peer is confirmed, stop any ongoing probing */ | |
485 | peer->down_cnt = 0; | |
486 | ||
487 | /* Task is done for duplicate record */ | |
488 | if (!more(new_gen, state->peer_gen)) | |
489 | goto exit; | |
490 | ||
491 | state->peer_gen = new_gen; | |
492 | ||
493 | /* Cache current domain record for later use */ | |
494 | dom_bef.member_cnt = 0; | |
495 | dom = peer->domain; | |
496 | if (dom) | |
497 | memcpy(&dom_bef, dom, dom->len); | |
498 | ||
499 | /* Transform and store received domain record */ | |
500 | if (!dom || (dom->len < new_dlen)) { | |
501 | kfree(dom); | |
502 | dom = kmalloc(new_dlen, GFP_ATOMIC); | |
503 | peer->domain = dom; | |
504 | if (!dom) | |
505 | goto exit; | |
506 | } | |
507 | dom->len = new_dlen; | |
508 | dom->gen = new_gen; | |
509 | dom->member_cnt = new_member_cnt; | |
510 | dom->up_map = be64_to_cpu(arrv_dom->up_map); | |
511 | for (i = 0; i < new_member_cnt; i++) | |
512 | dom->members[i] = ntohl(arrv_dom->members[i]); | |
513 | ||
514 | /* Update peers affected by this domain record */ | |
515 | applied_bef = peer->applied; | |
516 | mon_apply_domain(mon, peer); | |
517 | mon_identify_lost_members(peer, &dom_bef, applied_bef); | |
518 | mon_assign_roles(mon, peer_head(peer)); | |
519 | exit: | |
520 | write_unlock_bh(&mon->lock); | |
521 | } | |
522 | ||
523 | void tipc_mon_prep(struct net *net, void *data, int *dlen, | |
524 | struct tipc_mon_state *state, int bearer_id) | |
525 | { | |
526 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
527 | struct tipc_mon_domain *dom = data; | |
528 | u16 gen = mon->dom_gen; | |
529 | u16 len; | |
530 | ||
531 | if (!tipc_mon_is_active(net, mon)) | |
532 | return; | |
533 | ||
534 | /* Send only a dummy record with ack if peer has acked our last sent */ | |
535 | if (likely(state->acked_gen == gen)) { | |
536 | len = dom_rec_len(dom, 0); | |
537 | *dlen = len; | |
538 | dom->len = htons(len); | |
539 | dom->gen = htons(gen); | |
540 | dom->ack_gen = htons(state->peer_gen); | |
541 | dom->member_cnt = 0; | |
542 | return; | |
543 | } | |
544 | /* Send the full record */ | |
545 | read_lock_bh(&mon->lock); | |
546 | len = ntohs(mon->cache.len); | |
547 | *dlen = len; | |
548 | memcpy(data, &mon->cache, len); | |
549 | read_unlock_bh(&mon->lock); | |
550 | dom->ack_gen = htons(state->peer_gen); | |
551 | } | |
552 | ||
553 | void tipc_mon_get_state(struct net *net, u32 addr, | |
554 | struct tipc_mon_state *state, | |
555 | int bearer_id) | |
556 | { | |
557 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
558 | struct tipc_peer *peer; | |
559 | ||
560 | /* Used cached state if table has not changed */ | |
561 | if (!state->probing && | |
562 | (state->list_gen == mon->list_gen) && | |
563 | (state->acked_gen == mon->dom_gen)) | |
564 | return; | |
565 | ||
566 | read_lock_bh(&mon->lock); | |
567 | peer = get_peer(mon, addr); | |
568 | if (peer) { | |
569 | state->probing = state->acked_gen != mon->dom_gen; | |
570 | state->probing |= peer->down_cnt; | |
571 | state->reset |= peer->down_cnt >= MAX_PEER_DOWN_EVENTS; | |
572 | state->monitoring = peer->is_local; | |
573 | state->monitoring |= peer->is_head; | |
574 | state->list_gen = mon->list_gen; | |
575 | } | |
576 | read_unlock_bh(&mon->lock); | |
577 | } | |
578 | ||
579 | static void mon_timeout(unsigned long m) | |
580 | { | |
581 | struct tipc_monitor *mon = (void *)m; | |
582 | struct tipc_peer *self; | |
583 | int best_member_cnt = dom_size(mon->peer_cnt) - 1; | |
584 | ||
585 | write_lock_bh(&mon->lock); | |
586 | self = mon->self; | |
587 | if (self && (best_member_cnt != self->applied)) { | |
588 | mon_update_local_domain(mon); | |
589 | mon_assign_roles(mon, self); | |
590 | } | |
591 | write_unlock_bh(&mon->lock); | |
592 | mod_timer(&mon->timer, jiffies + mon->timer_intv); | |
593 | } | |
594 | ||
595 | int tipc_mon_create(struct net *net, int bearer_id) | |
596 | { | |
597 | struct tipc_net *tn = tipc_net(net); | |
598 | struct tipc_monitor *mon; | |
599 | struct tipc_peer *self; | |
600 | struct tipc_mon_domain *dom; | |
601 | ||
602 | if (tn->monitors[bearer_id]) | |
603 | return 0; | |
604 | ||
605 | mon = kzalloc(sizeof(*mon), GFP_ATOMIC); | |
606 | self = kzalloc(sizeof(*self), GFP_ATOMIC); | |
607 | dom = kzalloc(sizeof(*dom), GFP_ATOMIC); | |
608 | if (!mon || !self || !dom) { | |
609 | kfree(mon); | |
610 | kfree(self); | |
611 | kfree(dom); | |
612 | return -ENOMEM; | |
613 | } | |
614 | tn->monitors[bearer_id] = mon; | |
615 | rwlock_init(&mon->lock); | |
616 | mon->net = net; | |
617 | mon->peer_cnt = 1; | |
618 | mon->self = self; | |
619 | self->domain = dom; | |
620 | self->addr = tipc_own_addr(net); | |
621 | self->is_up = true; | |
622 | self->is_head = true; | |
623 | INIT_LIST_HEAD(&self->list); | |
624 | setup_timer(&mon->timer, mon_timeout, (unsigned long)mon); | |
625 | mon->timer_intv = msecs_to_jiffies(MON_TIMEOUT + (tn->random & 0xffff)); | |
626 | mod_timer(&mon->timer, jiffies + mon->timer_intv); | |
627 | return 0; | |
628 | } | |
629 | ||
630 | void tipc_mon_delete(struct net *net, int bearer_id) | |
631 | { | |
632 | struct tipc_net *tn = tipc_net(net); | |
633 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
634 | struct tipc_peer *self = get_self(net, bearer_id); | |
635 | struct tipc_peer *peer, *tmp; | |
636 | ||
637 | write_lock_bh(&mon->lock); | |
638 | tn->monitors[bearer_id] = NULL; | |
639 | list_for_each_entry_safe(peer, tmp, &self->list, list) { | |
640 | list_del(&peer->list); | |
641 | hlist_del(&peer->hash); | |
642 | kfree(peer->domain); | |
643 | kfree(peer); | |
644 | } | |
645 | mon->self = NULL; | |
646 | write_unlock_bh(&mon->lock); | |
647 | del_timer_sync(&mon->timer); | |
648 | kfree(self->domain); | |
649 | kfree(self); | |
650 | kfree(mon); | |
651 | } |