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 | ||
cf6f7e1d | 36 | #include <net/genetlink.h> |
35c55c98 JPM |
37 | #include "core.h" |
38 | #include "addr.h" | |
39 | #include "monitor.h" | |
cf6f7e1d | 40 | #include "bearer.h" |
35c55c98 JPM |
41 | |
42 | #define MAX_MON_DOMAIN 64 | |
43 | #define MON_TIMEOUT 120000 | |
44 | #define MAX_PEER_DOWN_EVENTS 4 | |
45 | ||
46 | /* struct tipc_mon_domain: domain record to be transferred between peers | |
47 | * @len: actual size of domain record | |
48 | * @gen: current generation of sender's domain | |
49 | * @ack_gen: most recent generation of self's domain acked by peer | |
50 | * @member_cnt: number of domain member nodes described in this record | |
51 | * @up_map: bit map indicating which of the members the sender considers up | |
52 | * @members: identity of the domain members | |
53 | */ | |
54 | struct tipc_mon_domain { | |
55 | u16 len; | |
56 | u16 gen; | |
57 | u16 ack_gen; | |
58 | u16 member_cnt; | |
59 | u64 up_map; | |
60 | u32 members[MAX_MON_DOMAIN]; | |
61 | }; | |
62 | ||
63 | /* struct tipc_peer: state of a peer node and its domain | |
64 | * @addr: tipc node identity of peer | |
65 | * @head_map: shows which other nodes currently consider peer 'up' | |
66 | * @domain: most recent domain record from peer | |
67 | * @hash: position in hashed lookup list | |
68 | * @list: position in linked list, in circular ascending order by 'addr' | |
69 | * @applied: number of reported domain members applied on this monitor list | |
70 | * @is_up: peer is up as seen from this node | |
71 | * @is_head: peer is assigned domain head as seen from this node | |
72 | * @is_local: peer is in local domain and should be continuously monitored | |
73 | * @down_cnt: - numbers of other peers which have reported this on lost | |
74 | */ | |
75 | struct tipc_peer { | |
76 | u32 addr; | |
77 | struct tipc_mon_domain *domain; | |
78 | struct hlist_node hash; | |
79 | struct list_head list; | |
80 | u8 applied; | |
81 | u8 down_cnt; | |
82 | bool is_up; | |
83 | bool is_head; | |
84 | bool is_local; | |
85 | }; | |
86 | ||
87 | struct tipc_monitor { | |
88 | struct hlist_head peers[NODE_HTABLE_SIZE]; | |
89 | int peer_cnt; | |
90 | struct tipc_peer *self; | |
91 | rwlock_t lock; | |
92 | struct tipc_mon_domain cache; | |
93 | u16 list_gen; | |
94 | u16 dom_gen; | |
95 | struct net *net; | |
96 | struct timer_list timer; | |
97 | unsigned long timer_intv; | |
98 | }; | |
99 | ||
100 | static struct tipc_monitor *tipc_monitor(struct net *net, int bearer_id) | |
101 | { | |
102 | return tipc_net(net)->monitors[bearer_id]; | |
103 | } | |
104 | ||
105 | const int tipc_max_domain_size = sizeof(struct tipc_mon_domain); | |
106 | ||
107 | /* dom_rec_len(): actual length of domain record for transport | |
108 | */ | |
109 | static int dom_rec_len(struct tipc_mon_domain *dom, u16 mcnt) | |
110 | { | |
520ec343 | 111 | return (offsetof(struct tipc_mon_domain, members)) + (mcnt * sizeof(u32)); |
35c55c98 JPM |
112 | } |
113 | ||
114 | /* dom_size() : calculate size of own domain based on number of peers | |
115 | */ | |
116 | static int dom_size(int peers) | |
117 | { | |
118 | int i = 0; | |
119 | ||
120 | while ((i * i) < peers) | |
121 | i++; | |
122 | return i < MAX_MON_DOMAIN ? i : MAX_MON_DOMAIN; | |
123 | } | |
124 | ||
125 | static void map_set(u64 *up_map, int i, unsigned int v) | |
126 | { | |
0350cb48 DC |
127 | *up_map &= ~(1ULL << i); |
128 | *up_map |= ((u64)v << i); | |
35c55c98 JPM |
129 | } |
130 | ||
131 | static int map_get(u64 up_map, int i) | |
132 | { | |
133 | return (up_map & (1 << i)) >> i; | |
134 | } | |
135 | ||
136 | static struct tipc_peer *peer_prev(struct tipc_peer *peer) | |
137 | { | |
138 | return list_last_entry(&peer->list, struct tipc_peer, list); | |
139 | } | |
140 | ||
141 | static struct tipc_peer *peer_nxt(struct tipc_peer *peer) | |
142 | { | |
143 | return list_first_entry(&peer->list, struct tipc_peer, list); | |
144 | } | |
145 | ||
146 | static struct tipc_peer *peer_head(struct tipc_peer *peer) | |
147 | { | |
148 | while (!peer->is_head) | |
149 | peer = peer_prev(peer); | |
150 | return peer; | |
151 | } | |
152 | ||
153 | static struct tipc_peer *get_peer(struct tipc_monitor *mon, u32 addr) | |
154 | { | |
155 | struct tipc_peer *peer; | |
156 | unsigned int thash = tipc_hashfn(addr); | |
157 | ||
158 | hlist_for_each_entry(peer, &mon->peers[thash], hash) { | |
159 | if (peer->addr == addr) | |
160 | return peer; | |
161 | } | |
162 | return NULL; | |
163 | } | |
164 | ||
165 | static struct tipc_peer *get_self(struct net *net, int bearer_id) | |
166 | { | |
167 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
168 | ||
169 | return mon->self; | |
170 | } | |
171 | ||
172 | static inline bool tipc_mon_is_active(struct net *net, struct tipc_monitor *mon) | |
173 | { | |
174 | struct tipc_net *tn = tipc_net(net); | |
175 | ||
176 | return mon->peer_cnt > tn->mon_threshold; | |
177 | } | |
178 | ||
179 | /* mon_identify_lost_members() : - identify amd mark potentially lost members | |
180 | */ | |
181 | static void mon_identify_lost_members(struct tipc_peer *peer, | |
182 | struct tipc_mon_domain *dom_bef, | |
183 | int applied_bef) | |
184 | { | |
185 | struct tipc_peer *member = peer; | |
186 | struct tipc_mon_domain *dom_aft = peer->domain; | |
187 | int applied_aft = peer->applied; | |
188 | int i; | |
189 | ||
190 | for (i = 0; i < applied_bef; i++) { | |
191 | member = peer_nxt(member); | |
192 | ||
193 | /* Do nothing if self or peer already see member as down */ | |
194 | if (!member->is_up || !map_get(dom_bef->up_map, i)) | |
195 | continue; | |
196 | ||
197 | /* Loss of local node must be detected by active probing */ | |
198 | if (member->is_local) | |
199 | continue; | |
200 | ||
201 | /* Start probing if member was removed from applied domain */ | |
202 | if (!applied_aft || (applied_aft < i)) { | |
203 | member->down_cnt = 1; | |
204 | continue; | |
205 | } | |
206 | ||
207 | /* Member loss is confirmed if it is still in applied domain */ | |
208 | if (!map_get(dom_aft->up_map, i)) | |
209 | member->down_cnt++; | |
210 | } | |
211 | } | |
212 | ||
213 | /* mon_apply_domain() : match a peer's domain record against monitor list | |
214 | */ | |
215 | static void mon_apply_domain(struct tipc_monitor *mon, | |
216 | struct tipc_peer *peer) | |
217 | { | |
218 | struct tipc_mon_domain *dom = peer->domain; | |
219 | struct tipc_peer *member; | |
220 | u32 addr; | |
221 | int i; | |
222 | ||
223 | if (!dom || !peer->is_up) | |
224 | return; | |
225 | ||
226 | /* Scan across domain members and match against monitor list */ | |
227 | peer->applied = 0; | |
228 | member = peer_nxt(peer); | |
229 | for (i = 0; i < dom->member_cnt; i++) { | |
230 | addr = dom->members[i]; | |
231 | if (addr != member->addr) | |
232 | return; | |
233 | peer->applied++; | |
234 | member = peer_nxt(member); | |
235 | } | |
236 | } | |
237 | ||
238 | /* mon_update_local_domain() : update after peer addition/removal/up/down | |
239 | */ | |
240 | static void mon_update_local_domain(struct tipc_monitor *mon) | |
241 | { | |
242 | struct tipc_peer *self = mon->self; | |
243 | struct tipc_mon_domain *cache = &mon->cache; | |
244 | struct tipc_mon_domain *dom = self->domain; | |
245 | struct tipc_peer *peer = self; | |
246 | u64 prev_up_map = dom->up_map; | |
247 | u16 member_cnt, i; | |
248 | bool diff; | |
249 | ||
250 | /* Update local domain size based on current size of cluster */ | |
251 | member_cnt = dom_size(mon->peer_cnt) - 1; | |
252 | self->applied = member_cnt; | |
253 | ||
254 | /* Update native and cached outgoing local domain records */ | |
255 | dom->len = dom_rec_len(dom, member_cnt); | |
256 | diff = dom->member_cnt != member_cnt; | |
257 | dom->member_cnt = member_cnt; | |
258 | for (i = 0; i < member_cnt; i++) { | |
259 | peer = peer_nxt(peer); | |
260 | diff |= dom->members[i] != peer->addr; | |
261 | dom->members[i] = peer->addr; | |
262 | map_set(&dom->up_map, i, peer->is_up); | |
263 | cache->members[i] = htonl(peer->addr); | |
264 | } | |
265 | diff |= dom->up_map != prev_up_map; | |
266 | if (!diff) | |
267 | return; | |
268 | dom->gen = ++mon->dom_gen; | |
269 | cache->len = htons(dom->len); | |
270 | cache->gen = htons(dom->gen); | |
271 | cache->member_cnt = htons(member_cnt); | |
272 | cache->up_map = cpu_to_be64(dom->up_map); | |
273 | mon_apply_domain(mon, self); | |
274 | } | |
275 | ||
276 | /* mon_update_neighbors() : update preceding neighbors of added/removed peer | |
277 | */ | |
278 | static void mon_update_neighbors(struct tipc_monitor *mon, | |
279 | struct tipc_peer *peer) | |
280 | { | |
281 | int dz, i; | |
282 | ||
283 | dz = dom_size(mon->peer_cnt); | |
284 | for (i = 0; i < dz; i++) { | |
285 | mon_apply_domain(mon, peer); | |
286 | peer = peer_prev(peer); | |
287 | } | |
288 | } | |
289 | ||
290 | /* mon_assign_roles() : reassign peer roles after a network change | |
291 | * The monitor list is consistent at this stage; i.e., each peer is monitoring | |
292 | * a set of domain members as matched between domain record and the monitor list | |
293 | */ | |
294 | static void mon_assign_roles(struct tipc_monitor *mon, struct tipc_peer *head) | |
295 | { | |
296 | struct tipc_peer *peer = peer_nxt(head); | |
297 | struct tipc_peer *self = mon->self; | |
298 | int i = 0; | |
299 | ||
300 | for (; peer != self; peer = peer_nxt(peer)) { | |
301 | peer->is_local = false; | |
302 | ||
303 | /* Update domain member */ | |
304 | if (i++ < head->applied) { | |
305 | peer->is_head = false; | |
306 | if (head == self) | |
307 | peer->is_local = true; | |
308 | continue; | |
309 | } | |
310 | /* Assign next domain head */ | |
311 | if (!peer->is_up) | |
312 | continue; | |
313 | if (peer->is_head) | |
314 | break; | |
315 | head = peer; | |
316 | head->is_head = true; | |
317 | i = 0; | |
318 | } | |
319 | mon->list_gen++; | |
320 | } | |
321 | ||
322 | void tipc_mon_remove_peer(struct net *net, u32 addr, int bearer_id) | |
323 | { | |
324 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
746a1eda | 325 | struct tipc_peer *self; |
35c55c98 JPM |
326 | struct tipc_peer *peer, *prev, *head; |
327 | ||
746a1eda HL |
328 | if (!mon) |
329 | return; | |
330 | ||
331 | self = get_self(net, bearer_id); | |
35c55c98 JPM |
332 | write_lock_bh(&mon->lock); |
333 | peer = get_peer(mon, addr); | |
334 | if (!peer) | |
335 | goto exit; | |
336 | prev = peer_prev(peer); | |
337 | list_del(&peer->list); | |
338 | hlist_del(&peer->hash); | |
339 | kfree(peer->domain); | |
340 | kfree(peer); | |
341 | mon->peer_cnt--; | |
342 | head = peer_head(prev); | |
343 | if (head == self) | |
344 | mon_update_local_domain(mon); | |
345 | mon_update_neighbors(mon, prev); | |
346 | ||
347 | /* Revert to full-mesh monitoring if we reach threshold */ | |
348 | if (!tipc_mon_is_active(net, mon)) { | |
349 | list_for_each_entry(peer, &self->list, list) { | |
350 | kfree(peer->domain); | |
351 | peer->domain = NULL; | |
352 | peer->applied = 0; | |
353 | } | |
354 | } | |
355 | mon_assign_roles(mon, head); | |
356 | exit: | |
357 | write_unlock_bh(&mon->lock); | |
358 | } | |
359 | ||
360 | static bool tipc_mon_add_peer(struct tipc_monitor *mon, u32 addr, | |
361 | struct tipc_peer **peer) | |
362 | { | |
363 | struct tipc_peer *self = mon->self; | |
364 | struct tipc_peer *cur, *prev, *p; | |
365 | ||
366 | p = kzalloc(sizeof(*p), GFP_ATOMIC); | |
367 | *peer = p; | |
368 | if (!p) | |
369 | return false; | |
370 | p->addr = addr; | |
371 | ||
372 | /* Add new peer to lookup list */ | |
373 | INIT_LIST_HEAD(&p->list); | |
374 | hlist_add_head(&p->hash, &mon->peers[tipc_hashfn(addr)]); | |
375 | ||
376 | /* Sort new peer into iterator list, in ascending circular order */ | |
377 | prev = self; | |
378 | list_for_each_entry(cur, &self->list, list) { | |
379 | if ((addr > prev->addr) && (addr < cur->addr)) | |
380 | break; | |
381 | if (((addr < cur->addr) || (addr > prev->addr)) && | |
382 | (prev->addr > cur->addr)) | |
383 | break; | |
384 | prev = cur; | |
385 | } | |
386 | list_add_tail(&p->list, &cur->list); | |
387 | mon->peer_cnt++; | |
388 | mon_update_neighbors(mon, p); | |
389 | return true; | |
390 | } | |
391 | ||
392 | void tipc_mon_peer_up(struct net *net, u32 addr, int bearer_id) | |
393 | { | |
394 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
395 | struct tipc_peer *self = get_self(net, bearer_id); | |
396 | struct tipc_peer *peer, *head; | |
397 | ||
398 | write_lock_bh(&mon->lock); | |
399 | peer = get_peer(mon, addr); | |
400 | if (!peer && !tipc_mon_add_peer(mon, addr, &peer)) | |
401 | goto exit; | |
402 | peer->is_up = true; | |
403 | head = peer_head(peer); | |
404 | if (head == self) | |
405 | mon_update_local_domain(mon); | |
406 | mon_assign_roles(mon, head); | |
407 | exit: | |
408 | write_unlock_bh(&mon->lock); | |
409 | } | |
410 | ||
411 | void tipc_mon_peer_down(struct net *net, u32 addr, int bearer_id) | |
412 | { | |
413 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
746a1eda | 414 | struct tipc_peer *self; |
35c55c98 JPM |
415 | struct tipc_peer *peer, *head; |
416 | struct tipc_mon_domain *dom; | |
417 | int applied; | |
418 | ||
746a1eda HL |
419 | if (!mon) |
420 | return; | |
421 | ||
422 | self = get_self(net, bearer_id); | |
35c55c98 JPM |
423 | write_lock_bh(&mon->lock); |
424 | peer = get_peer(mon, addr); | |
425 | if (!peer) { | |
426 | pr_warn("Mon: unknown link %x/%u DOWN\n", addr, bearer_id); | |
427 | goto exit; | |
428 | } | |
429 | applied = peer->applied; | |
430 | peer->applied = 0; | |
431 | dom = peer->domain; | |
432 | peer->domain = NULL; | |
433 | if (peer->is_head) | |
434 | mon_identify_lost_members(peer, dom, applied); | |
435 | kfree(dom); | |
436 | peer->is_up = false; | |
437 | peer->is_head = false; | |
438 | peer->is_local = false; | |
439 | peer->down_cnt = 0; | |
440 | head = peer_head(peer); | |
441 | if (head == self) | |
442 | mon_update_local_domain(mon); | |
443 | mon_assign_roles(mon, head); | |
444 | exit: | |
445 | write_unlock_bh(&mon->lock); | |
446 | } | |
447 | ||
448 | /* tipc_mon_rcv - process monitor domain event message | |
449 | */ | |
450 | void tipc_mon_rcv(struct net *net, void *data, u16 dlen, u32 addr, | |
451 | struct tipc_mon_state *state, int bearer_id) | |
452 | { | |
453 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
454 | struct tipc_mon_domain *arrv_dom = data; | |
455 | struct tipc_mon_domain dom_bef; | |
456 | struct tipc_mon_domain *dom; | |
457 | struct tipc_peer *peer; | |
458 | u16 new_member_cnt = ntohs(arrv_dom->member_cnt); | |
459 | int new_dlen = dom_rec_len(arrv_dom, new_member_cnt); | |
460 | u16 new_gen = ntohs(arrv_dom->gen); | |
461 | u16 acked_gen = ntohs(arrv_dom->ack_gen); | |
462 | bool probing = state->probing; | |
463 | int i, applied_bef; | |
464 | ||
465 | state->probing = false; | |
35c55c98 JPM |
466 | |
467 | /* Sanity check received domain record */ | |
d876a4d2 JPM |
468 | if (dlen < dom_rec_len(arrv_dom, 0)) |
469 | return; | |
470 | if (dlen != dom_rec_len(arrv_dom, new_member_cnt)) | |
471 | return; | |
472 | if ((dlen < new_dlen) || ntohs(arrv_dom->len) != new_dlen) | |
35c55c98 | 473 | return; |
35c55c98 JPM |
474 | |
475 | /* Synch generation numbers with peer if link just came up */ | |
476 | if (!state->synched) { | |
477 | state->peer_gen = new_gen - 1; | |
478 | state->acked_gen = acked_gen; | |
479 | state->synched = true; | |
480 | } | |
481 | ||
482 | if (more(acked_gen, state->acked_gen)) | |
483 | state->acked_gen = acked_gen; | |
484 | ||
485 | /* Drop duplicate unless we are waiting for a probe response */ | |
486 | if (!more(new_gen, state->peer_gen) && !probing) | |
487 | return; | |
488 | ||
489 | write_lock_bh(&mon->lock); | |
490 | peer = get_peer(mon, addr); | |
491 | if (!peer || !peer->is_up) | |
492 | goto exit; | |
493 | ||
494 | /* Peer is confirmed, stop any ongoing probing */ | |
495 | peer->down_cnt = 0; | |
496 | ||
497 | /* Task is done for duplicate record */ | |
498 | if (!more(new_gen, state->peer_gen)) | |
499 | goto exit; | |
500 | ||
501 | state->peer_gen = new_gen; | |
502 | ||
503 | /* Cache current domain record for later use */ | |
504 | dom_bef.member_cnt = 0; | |
505 | dom = peer->domain; | |
506 | if (dom) | |
507 | memcpy(&dom_bef, dom, dom->len); | |
508 | ||
509 | /* Transform and store received domain record */ | |
510 | if (!dom || (dom->len < new_dlen)) { | |
511 | kfree(dom); | |
512 | dom = kmalloc(new_dlen, GFP_ATOMIC); | |
513 | peer->domain = dom; | |
514 | if (!dom) | |
515 | goto exit; | |
516 | } | |
517 | dom->len = new_dlen; | |
518 | dom->gen = new_gen; | |
519 | dom->member_cnt = new_member_cnt; | |
520 | dom->up_map = be64_to_cpu(arrv_dom->up_map); | |
521 | for (i = 0; i < new_member_cnt; i++) | |
522 | dom->members[i] = ntohl(arrv_dom->members[i]); | |
523 | ||
524 | /* Update peers affected by this domain record */ | |
525 | applied_bef = peer->applied; | |
526 | mon_apply_domain(mon, peer); | |
527 | mon_identify_lost_members(peer, &dom_bef, applied_bef); | |
528 | mon_assign_roles(mon, peer_head(peer)); | |
529 | exit: | |
530 | write_unlock_bh(&mon->lock); | |
531 | } | |
532 | ||
533 | void tipc_mon_prep(struct net *net, void *data, int *dlen, | |
534 | struct tipc_mon_state *state, int bearer_id) | |
535 | { | |
536 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
537 | struct tipc_mon_domain *dom = data; | |
538 | u16 gen = mon->dom_gen; | |
539 | u16 len; | |
540 | ||
fa368826 JM |
541 | /* Send invalid record if not active */ |
542 | if (!tipc_mon_is_active(net, mon)) { | |
543 | dom->len = 0; | |
35c55c98 | 544 | return; |
fa368826 | 545 | } |
35c55c98 JPM |
546 | |
547 | /* Send only a dummy record with ack if peer has acked our last sent */ | |
548 | if (likely(state->acked_gen == gen)) { | |
549 | len = dom_rec_len(dom, 0); | |
550 | *dlen = len; | |
551 | dom->len = htons(len); | |
552 | dom->gen = htons(gen); | |
553 | dom->ack_gen = htons(state->peer_gen); | |
554 | dom->member_cnt = 0; | |
555 | return; | |
556 | } | |
557 | /* Send the full record */ | |
558 | read_lock_bh(&mon->lock); | |
559 | len = ntohs(mon->cache.len); | |
560 | *dlen = len; | |
561 | memcpy(data, &mon->cache, len); | |
562 | read_unlock_bh(&mon->lock); | |
563 | dom->ack_gen = htons(state->peer_gen); | |
564 | } | |
565 | ||
566 | void tipc_mon_get_state(struct net *net, u32 addr, | |
567 | struct tipc_mon_state *state, | |
568 | int bearer_id) | |
569 | { | |
570 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
571 | struct tipc_peer *peer; | |
572 | ||
fa368826 JM |
573 | if (!tipc_mon_is_active(net, mon)) { |
574 | state->probing = false; | |
575 | state->monitoring = true; | |
576 | return; | |
577 | } | |
578 | ||
35c55c98 JPM |
579 | /* Used cached state if table has not changed */ |
580 | if (!state->probing && | |
581 | (state->list_gen == mon->list_gen) && | |
582 | (state->acked_gen == mon->dom_gen)) | |
583 | return; | |
584 | ||
585 | read_lock_bh(&mon->lock); | |
586 | peer = get_peer(mon, addr); | |
587 | if (peer) { | |
588 | state->probing = state->acked_gen != mon->dom_gen; | |
589 | state->probing |= peer->down_cnt; | |
590 | state->reset |= peer->down_cnt >= MAX_PEER_DOWN_EVENTS; | |
591 | state->monitoring = peer->is_local; | |
592 | state->monitoring |= peer->is_head; | |
593 | state->list_gen = mon->list_gen; | |
594 | } | |
595 | read_unlock_bh(&mon->lock); | |
596 | } | |
597 | ||
31b102bb | 598 | static void mon_timeout(struct timer_list *t) |
35c55c98 | 599 | { |
31b102bb | 600 | struct tipc_monitor *mon = from_timer(mon, t, timer); |
35c55c98 JPM |
601 | struct tipc_peer *self; |
602 | int best_member_cnt = dom_size(mon->peer_cnt) - 1; | |
603 | ||
604 | write_lock_bh(&mon->lock); | |
605 | self = mon->self; | |
606 | if (self && (best_member_cnt != self->applied)) { | |
607 | mon_update_local_domain(mon); | |
608 | mon_assign_roles(mon, self); | |
609 | } | |
610 | write_unlock_bh(&mon->lock); | |
611 | mod_timer(&mon->timer, jiffies + mon->timer_intv); | |
612 | } | |
613 | ||
614 | int tipc_mon_create(struct net *net, int bearer_id) | |
615 | { | |
616 | struct tipc_net *tn = tipc_net(net); | |
617 | struct tipc_monitor *mon; | |
618 | struct tipc_peer *self; | |
619 | struct tipc_mon_domain *dom; | |
620 | ||
621 | if (tn->monitors[bearer_id]) | |
622 | return 0; | |
623 | ||
624 | mon = kzalloc(sizeof(*mon), GFP_ATOMIC); | |
625 | self = kzalloc(sizeof(*self), GFP_ATOMIC); | |
626 | dom = kzalloc(sizeof(*dom), GFP_ATOMIC); | |
627 | if (!mon || !self || !dom) { | |
628 | kfree(mon); | |
629 | kfree(self); | |
630 | kfree(dom); | |
631 | return -ENOMEM; | |
632 | } | |
633 | tn->monitors[bearer_id] = mon; | |
634 | rwlock_init(&mon->lock); | |
635 | mon->net = net; | |
636 | mon->peer_cnt = 1; | |
637 | mon->self = self; | |
638 | self->domain = dom; | |
639 | self->addr = tipc_own_addr(net); | |
640 | self->is_up = true; | |
641 | self->is_head = true; | |
642 | INIT_LIST_HEAD(&self->list); | |
31b102bb | 643 | timer_setup(&mon->timer, mon_timeout, 0); |
35c55c98 JPM |
644 | mon->timer_intv = msecs_to_jiffies(MON_TIMEOUT + (tn->random & 0xffff)); |
645 | mod_timer(&mon->timer, jiffies + mon->timer_intv); | |
646 | return 0; | |
647 | } | |
648 | ||
649 | void tipc_mon_delete(struct net *net, int bearer_id) | |
650 | { | |
651 | struct tipc_net *tn = tipc_net(net); | |
652 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
642a8439 | 653 | struct tipc_peer *self; |
35c55c98 JPM |
654 | struct tipc_peer *peer, *tmp; |
655 | ||
642a8439 TR |
656 | if (!mon) |
657 | return; | |
658 | ||
659 | self = get_self(net, bearer_id); | |
35c55c98 JPM |
660 | write_lock_bh(&mon->lock); |
661 | tn->monitors[bearer_id] = NULL; | |
662 | list_for_each_entry_safe(peer, tmp, &self->list, list) { | |
663 | list_del(&peer->list); | |
664 | hlist_del(&peer->hash); | |
665 | kfree(peer->domain); | |
666 | kfree(peer); | |
667 | } | |
668 | mon->self = NULL; | |
669 | write_unlock_bh(&mon->lock); | |
670 | del_timer_sync(&mon->timer); | |
671 | kfree(self->domain); | |
672 | kfree(self); | |
673 | kfree(mon); | |
674 | } | |
7b3f5229 | 675 | |
46cb01ee HL |
676 | void tipc_mon_reinit_self(struct net *net) |
677 | { | |
678 | struct tipc_monitor *mon; | |
679 | int bearer_id; | |
680 | ||
681 | for (bearer_id = 0; bearer_id < MAX_BEARERS; bearer_id++) { | |
682 | mon = tipc_monitor(net, bearer_id); | |
683 | if (!mon) | |
684 | continue; | |
685 | write_lock_bh(&mon->lock); | |
686 | mon->self->addr = tipc_own_addr(net); | |
687 | write_unlock_bh(&mon->lock); | |
688 | } | |
689 | } | |
690 | ||
7b3f5229 PB |
691 | int tipc_nl_monitor_set_threshold(struct net *net, u32 cluster_size) |
692 | { | |
693 | struct tipc_net *tn = tipc_net(net); | |
694 | ||
695 | if (cluster_size > TIPC_CLUSTER_SIZE) | |
696 | return -EINVAL; | |
697 | ||
698 | tn->mon_threshold = cluster_size; | |
699 | ||
700 | return 0; | |
701 | } | |
bf1035b2 PB |
702 | |
703 | int tipc_nl_monitor_get_threshold(struct net *net) | |
704 | { | |
705 | struct tipc_net *tn = tipc_net(net); | |
706 | ||
707 | return tn->mon_threshold; | |
708 | } | |
cf6f7e1d | 709 | |
e064cce1 Y |
710 | static int __tipc_nl_add_monitor_peer(struct tipc_peer *peer, |
711 | struct tipc_nl_msg *msg) | |
cf6f7e1d PB |
712 | { |
713 | struct tipc_mon_domain *dom = peer->domain; | |
714 | struct nlattr *attrs; | |
715 | void *hdr; | |
716 | ||
717 | hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, | |
718 | NLM_F_MULTI, TIPC_NL_MON_PEER_GET); | |
719 | if (!hdr) | |
720 | return -EMSGSIZE; | |
721 | ||
ae0be8de | 722 | attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON_PEER); |
cf6f7e1d PB |
723 | if (!attrs) |
724 | goto msg_full; | |
725 | ||
726 | if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_ADDR, peer->addr)) | |
727 | goto attr_msg_full; | |
728 | if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_APPLIED, peer->applied)) | |
729 | goto attr_msg_full; | |
730 | ||
731 | if (peer->is_up) | |
732 | if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_UP)) | |
733 | goto attr_msg_full; | |
734 | if (peer->is_local) | |
735 | if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_LOCAL)) | |
736 | goto attr_msg_full; | |
737 | if (peer->is_head) | |
738 | if (nla_put_flag(msg->skb, TIPC_NLA_MON_PEER_HEAD)) | |
739 | goto attr_msg_full; | |
740 | ||
741 | if (dom) { | |
742 | if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEER_DOMGEN, dom->gen)) | |
743 | goto attr_msg_full; | |
744 | if (nla_put_u64_64bit(msg->skb, TIPC_NLA_MON_PEER_UPMAP, | |
745 | dom->up_map, TIPC_NLA_MON_PEER_PAD)) | |
746 | goto attr_msg_full; | |
747 | if (nla_put(msg->skb, TIPC_NLA_MON_PEER_MEMBERS, | |
748 | dom->member_cnt * sizeof(u32), &dom->members)) | |
749 | goto attr_msg_full; | |
750 | } | |
751 | ||
752 | nla_nest_end(msg->skb, attrs); | |
753 | genlmsg_end(msg->skb, hdr); | |
754 | return 0; | |
755 | ||
756 | attr_msg_full: | |
757 | nla_nest_cancel(msg->skb, attrs); | |
758 | msg_full: | |
759 | genlmsg_cancel(msg->skb, hdr); | |
760 | ||
761 | return -EMSGSIZE; | |
762 | } | |
763 | ||
764 | int tipc_nl_add_monitor_peer(struct net *net, struct tipc_nl_msg *msg, | |
765 | u32 bearer_id, u32 *prev_node) | |
766 | { | |
767 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
672ca65d | 768 | struct tipc_peer *peer; |
cf6f7e1d PB |
769 | |
770 | if (!mon) | |
771 | return -EINVAL; | |
772 | ||
773 | read_lock_bh(&mon->lock); | |
672ca65d | 774 | peer = mon->self; |
cf6f7e1d PB |
775 | do { |
776 | if (*prev_node) { | |
777 | if (peer->addr == *prev_node) | |
778 | *prev_node = 0; | |
779 | else | |
780 | continue; | |
781 | } | |
782 | if (__tipc_nl_add_monitor_peer(peer, msg)) { | |
783 | *prev_node = peer->addr; | |
784 | read_unlock_bh(&mon->lock); | |
785 | return -EMSGSIZE; | |
786 | } | |
787 | } while ((peer = peer_nxt(peer)) != mon->self); | |
788 | read_unlock_bh(&mon->lock); | |
789 | ||
790 | return 0; | |
791 | } | |
792 | ||
793 | int __tipc_nl_add_monitor(struct net *net, struct tipc_nl_msg *msg, | |
794 | u32 bearer_id) | |
795 | { | |
796 | struct tipc_monitor *mon = tipc_monitor(net, bearer_id); | |
797 | char bearer_name[TIPC_MAX_BEARER_NAME]; | |
798 | struct nlattr *attrs; | |
799 | void *hdr; | |
800 | int ret; | |
801 | ||
802 | ret = tipc_bearer_get_name(net, bearer_name, bearer_id); | |
803 | if (ret || !mon) | |
36a50a98 | 804 | return 0; |
cf6f7e1d PB |
805 | |
806 | hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family, | |
807 | NLM_F_MULTI, TIPC_NL_MON_GET); | |
808 | if (!hdr) | |
809 | return -EMSGSIZE; | |
810 | ||
ae0be8de | 811 | attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MON); |
cf6f7e1d PB |
812 | if (!attrs) |
813 | goto msg_full; | |
814 | ||
815 | read_lock_bh(&mon->lock); | |
816 | if (nla_put_u32(msg->skb, TIPC_NLA_MON_REF, bearer_id)) | |
817 | goto attr_msg_full; | |
818 | if (tipc_mon_is_active(net, mon)) | |
819 | if (nla_put_flag(msg->skb, TIPC_NLA_MON_ACTIVE)) | |
820 | goto attr_msg_full; | |
821 | if (nla_put_string(msg->skb, TIPC_NLA_MON_BEARER_NAME, bearer_name)) | |
822 | goto attr_msg_full; | |
823 | if (nla_put_u32(msg->skb, TIPC_NLA_MON_PEERCNT, mon->peer_cnt)) | |
824 | goto attr_msg_full; | |
825 | if (nla_put_u32(msg->skb, TIPC_NLA_MON_LISTGEN, mon->list_gen)) | |
826 | goto attr_msg_full; | |
827 | ||
828 | read_unlock_bh(&mon->lock); | |
829 | nla_nest_end(msg->skb, attrs); | |
830 | genlmsg_end(msg->skb, hdr); | |
831 | ||
832 | return 0; | |
833 | ||
834 | attr_msg_full: | |
6b65bc29 | 835 | read_unlock_bh(&mon->lock); |
cf6f7e1d PB |
836 | nla_nest_cancel(msg->skb, attrs); |
837 | msg_full: | |
838 | genlmsg_cancel(msg->skb, hdr); | |
cf6f7e1d PB |
839 | |
840 | return -EMSGSIZE; | |
841 | } |