1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* AFS server record management |
3 | * |
4 | * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. |
5 | * Written by David Howells (dhowells@redhat.com) |
6 | */ |
7 | |
8 | #include <linux/sched.h> |
9 | #include <linux/slab.h> |
10 | #include "afs_fs.h" |
11 | #include "internal.h" |
12 | #include "protocol_yfs.h" |
13 | |
14 | static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */ |
15 | static atomic_t afs_server_debug_id; |
16 | |
17 | static struct afs_server *afs_maybe_use_server(struct afs_server *, |
18 | enum afs_server_trace); |
19 | static void __afs_put_server(struct afs_net *, struct afs_server *); |
20 | |
21 | /* |
22 | * Find a server by one of its addresses. |
23 | */ |
24 | struct afs_server *afs_find_server(struct afs_net *net, |
25 | const struct sockaddr_rxrpc *srx) |
26 | { |
27 | const struct afs_addr_list *alist; |
28 | struct afs_server *server = NULL; |
29 | unsigned int i; |
30 | int seq = 0, diff; |
31 | |
32 | rcu_read_lock(); |
33 | |
34 | do { |
35 | if (server) |
36 | afs_unuse_server_notime(net, server, afs_server_trace_put_find_rsq); |
37 | server = NULL; |
38 | read_seqbegin_or_lock(lock: &net->fs_addr_lock, seq: &seq); |
39 | |
40 | if (srx->transport.family == AF_INET6) { |
41 | const struct sockaddr_in6 *a = &srx->transport.sin6, *b; |
42 | hlist_for_each_entry_rcu(server, &net->fs_addresses6, addr6_link) { |
43 | alist = rcu_dereference(server->addresses); |
44 | for (i = alist->nr_ipv4; i < alist->nr_addrs; i++) { |
45 | b = &alist->addrs[i].transport.sin6; |
46 | diff = ((u16 __force)a->sin6_port - |
47 | (u16 __force)b->sin6_port); |
48 | if (diff == 0) |
49 | diff = memcmp(p: &a->sin6_addr, |
50 | q: &b->sin6_addr, |
51 | size: sizeof(struct in6_addr)); |
52 | if (diff == 0) |
53 | goto found; |
54 | } |
55 | } |
56 | } else { |
57 | const struct sockaddr_in *a = &srx->transport.sin, *b; |
58 | hlist_for_each_entry_rcu(server, &net->fs_addresses4, addr4_link) { |
59 | alist = rcu_dereference(server->addresses); |
60 | for (i = 0; i < alist->nr_ipv4; i++) { |
61 | b = &alist->addrs[i].transport.sin; |
62 | diff = ((u16 __force)a->sin_port - |
63 | (u16 __force)b->sin_port); |
64 | if (diff == 0) |
65 | diff = ((u32 __force)a->sin_addr.s_addr - |
66 | (u32 __force)b->sin_addr.s_addr); |
67 | if (diff == 0) |
68 | goto found; |
69 | } |
70 | } |
71 | } |
72 | |
73 | server = NULL; |
74 | continue; |
75 | found: |
76 | server = afs_maybe_use_server(server, afs_server_trace_get_by_addr); |
77 | |
78 | } while (need_seqretry(lock: &net->fs_addr_lock, seq)); |
79 | |
80 | done_seqretry(lock: &net->fs_addr_lock, seq); |
81 | |
82 | rcu_read_unlock(); |
83 | return server; |
84 | } |
85 | |
86 | /* |
87 | * Look up a server by its UUID and mark it active. |
88 | */ |
89 | struct afs_server *afs_find_server_by_uuid(struct afs_net *net, const uuid_t *uuid) |
90 | { |
91 | struct afs_server *server = NULL; |
92 | struct rb_node *p; |
93 | int diff, seq = 0; |
94 | |
95 | _enter("%pU" , uuid); |
96 | |
97 | do { |
98 | /* Unfortunately, rbtree walking doesn't give reliable results |
99 | * under just the RCU read lock, so we have to check for |
100 | * changes. |
101 | */ |
102 | if (server) |
103 | afs_unuse_server(net, server, afs_server_trace_put_uuid_rsq); |
104 | server = NULL; |
105 | |
106 | read_seqbegin_or_lock(lock: &net->fs_lock, seq: &seq); |
107 | |
108 | p = net->fs_servers.rb_node; |
109 | while (p) { |
110 | server = rb_entry(p, struct afs_server, uuid_rb); |
111 | |
112 | diff = memcmp(p: uuid, q: &server->uuid, size: sizeof(*uuid)); |
113 | if (diff < 0) { |
114 | p = p->rb_left; |
115 | } else if (diff > 0) { |
116 | p = p->rb_right; |
117 | } else { |
118 | afs_use_server(server, afs_server_trace_get_by_uuid); |
119 | break; |
120 | } |
121 | |
122 | server = NULL; |
123 | } |
124 | } while (need_seqretry(lock: &net->fs_lock, seq)); |
125 | |
126 | done_seqretry(lock: &net->fs_lock, seq); |
127 | |
128 | _leave(" = %p" , server); |
129 | return server; |
130 | } |
131 | |
132 | /* |
133 | * Install a server record in the namespace tree. If there's a clash, we stick |
134 | * it into a list anchored on whichever afs_server struct is actually in the |
135 | * tree. |
136 | */ |
137 | static struct afs_server *afs_install_server(struct afs_cell *cell, |
138 | struct afs_server *candidate) |
139 | { |
140 | const struct afs_addr_list *alist; |
141 | struct afs_server *server, *next; |
142 | struct afs_net *net = cell->net; |
143 | struct rb_node **pp, *p; |
144 | int diff; |
145 | |
146 | _enter("%p" , candidate); |
147 | |
148 | write_seqlock(sl: &net->fs_lock); |
149 | |
150 | /* Firstly install the server in the UUID lookup tree */ |
151 | pp = &net->fs_servers.rb_node; |
152 | p = NULL; |
153 | while (*pp) { |
154 | p = *pp; |
155 | _debug("- consider %p" , p); |
156 | server = rb_entry(p, struct afs_server, uuid_rb); |
157 | diff = memcmp(p: &candidate->uuid, q: &server->uuid, size: sizeof(uuid_t)); |
158 | if (diff < 0) { |
159 | pp = &(*pp)->rb_left; |
160 | } else if (diff > 0) { |
161 | pp = &(*pp)->rb_right; |
162 | } else { |
163 | if (server->cell == cell) |
164 | goto exists; |
165 | |
166 | /* We have the same UUID representing servers in |
167 | * different cells. Append the new server to the list. |
168 | */ |
169 | for (;;) { |
170 | next = rcu_dereference_protected( |
171 | server->uuid_next, |
172 | lockdep_is_held(&net->fs_lock.lock)); |
173 | if (!next) |
174 | break; |
175 | server = next; |
176 | } |
177 | rcu_assign_pointer(server->uuid_next, candidate); |
178 | candidate->uuid_prev = server; |
179 | server = candidate; |
180 | goto added_dup; |
181 | } |
182 | } |
183 | |
184 | server = candidate; |
185 | rb_link_node(node: &server->uuid_rb, parent: p, rb_link: pp); |
186 | rb_insert_color(&server->uuid_rb, &net->fs_servers); |
187 | hlist_add_head_rcu(n: &server->proc_link, h: &net->fs_proc); |
188 | |
189 | added_dup: |
190 | write_seqlock(sl: &net->fs_addr_lock); |
191 | alist = rcu_dereference_protected(server->addresses, |
192 | lockdep_is_held(&net->fs_addr_lock.lock)); |
193 | |
194 | /* Secondly, if the server has any IPv4 and/or IPv6 addresses, install |
195 | * it in the IPv4 and/or IPv6 reverse-map lists. |
196 | * |
197 | * TODO: For speed we want to use something other than a flat list |
198 | * here; even sorting the list in terms of lowest address would help a |
199 | * bit, but anything we might want to do gets messy and memory |
200 | * intensive. |
201 | */ |
202 | if (alist->nr_ipv4 > 0) |
203 | hlist_add_head_rcu(n: &server->addr4_link, h: &net->fs_addresses4); |
204 | if (alist->nr_addrs > alist->nr_ipv4) |
205 | hlist_add_head_rcu(n: &server->addr6_link, h: &net->fs_addresses6); |
206 | |
207 | write_sequnlock(sl: &net->fs_addr_lock); |
208 | |
209 | exists: |
210 | afs_get_server(server, afs_server_trace_get_install); |
211 | write_sequnlock(sl: &net->fs_lock); |
212 | return server; |
213 | } |
214 | |
215 | /* |
216 | * Allocate a new server record and mark it active. |
217 | */ |
218 | static struct afs_server *afs_alloc_server(struct afs_cell *cell, |
219 | const uuid_t *uuid, |
220 | struct afs_addr_list *alist) |
221 | { |
222 | struct afs_server *server; |
223 | struct afs_net *net = cell->net; |
224 | |
225 | _enter("" ); |
226 | |
227 | server = kzalloc(size: sizeof(struct afs_server), GFP_KERNEL); |
228 | if (!server) |
229 | goto enomem; |
230 | |
231 | refcount_set(r: &server->ref, n: 1); |
232 | atomic_set(v: &server->active, i: 1); |
233 | server->debug_id = atomic_inc_return(v: &afs_server_debug_id); |
234 | RCU_INIT_POINTER(server->addresses, alist); |
235 | server->addr_version = alist->version; |
236 | server->uuid = *uuid; |
237 | rwlock_init(&server->fs_lock); |
238 | INIT_WORK(&server->initcb_work, afs_server_init_callback_work); |
239 | init_waitqueue_head(&server->probe_wq); |
240 | INIT_LIST_HEAD(list: &server->probe_link); |
241 | spin_lock_init(&server->probe_lock); |
242 | server->cell = cell; |
243 | server->rtt = UINT_MAX; |
244 | |
245 | afs_inc_servers_outstanding(net); |
246 | trace_afs_server(server_debug_id: server->debug_id, ref: 1, active: 1, reason: afs_server_trace_alloc); |
247 | _leave(" = %p" , server); |
248 | return server; |
249 | |
250 | enomem: |
251 | _leave(" = NULL [nomem]" ); |
252 | return NULL; |
253 | } |
254 | |
255 | /* |
256 | * Look up an address record for a server |
257 | */ |
258 | static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell, |
259 | struct key *key, const uuid_t *uuid) |
260 | { |
261 | struct afs_vl_cursor vc; |
262 | struct afs_addr_list *alist = NULL; |
263 | int ret; |
264 | |
265 | ret = -ERESTARTSYS; |
266 | if (afs_begin_vlserver_operation(&vc, cell, key)) { |
267 | while (afs_select_vlserver(&vc)) { |
268 | if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) |
269 | alist = afs_yfsvl_get_endpoints(&vc, uuid); |
270 | else |
271 | alist = afs_vl_get_addrs_u(&vc, uuid); |
272 | } |
273 | |
274 | ret = afs_end_vlserver_operation(&vc); |
275 | } |
276 | |
277 | return ret < 0 ? ERR_PTR(error: ret) : alist; |
278 | } |
279 | |
280 | /* |
281 | * Get or create a fileserver record. |
282 | */ |
283 | struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key, |
284 | const uuid_t *uuid, u32 addr_version) |
285 | { |
286 | struct afs_addr_list *alist; |
287 | struct afs_server *server, *candidate; |
288 | |
289 | _enter("%p,%pU" , cell->net, uuid); |
290 | |
291 | server = afs_find_server_by_uuid(net: cell->net, uuid); |
292 | if (server) { |
293 | if (server->addr_version != addr_version) |
294 | set_bit(AFS_SERVER_FL_NEEDS_UPDATE, addr: &server->flags); |
295 | return server; |
296 | } |
297 | |
298 | alist = afs_vl_lookup_addrs(cell, key, uuid); |
299 | if (IS_ERR(ptr: alist)) |
300 | return ERR_CAST(ptr: alist); |
301 | |
302 | candidate = afs_alloc_server(cell, uuid, alist); |
303 | if (!candidate) { |
304 | afs_put_addrlist(alist); |
305 | return ERR_PTR(error: -ENOMEM); |
306 | } |
307 | |
308 | server = afs_install_server(cell, candidate); |
309 | if (server != candidate) { |
310 | afs_put_addrlist(alist); |
311 | kfree(objp: candidate); |
312 | } else { |
313 | /* Immediately dispatch an asynchronous probe to each interface |
314 | * on the fileserver. This will make sure the repeat-probing |
315 | * service is started. |
316 | */ |
317 | afs_fs_probe_fileserver(cell->net, server, key, true); |
318 | } |
319 | |
320 | return server; |
321 | } |
322 | |
323 | /* |
324 | * Set the server timer to fire after a given delay, assuming it's not already |
325 | * set for an earlier time. |
326 | */ |
327 | static void afs_set_server_timer(struct afs_net *net, time64_t delay) |
328 | { |
329 | if (net->live) { |
330 | afs_inc_servers_outstanding(net); |
331 | if (timer_reduce(timer: &net->fs_timer, expires: jiffies + delay * HZ)) |
332 | afs_dec_servers_outstanding(net); |
333 | } |
334 | } |
335 | |
336 | /* |
337 | * Server management timer. We have an increment on fs_outstanding that we |
338 | * need to pass along to the work item. |
339 | */ |
340 | void afs_servers_timer(struct timer_list *timer) |
341 | { |
342 | struct afs_net *net = container_of(timer, struct afs_net, fs_timer); |
343 | |
344 | _enter("" ); |
345 | if (!queue_work(wq: afs_wq, work: &net->fs_manager)) |
346 | afs_dec_servers_outstanding(net); |
347 | } |
348 | |
349 | /* |
350 | * Get a reference on a server object. |
351 | */ |
352 | struct afs_server *afs_get_server(struct afs_server *server, |
353 | enum afs_server_trace reason) |
354 | { |
355 | unsigned int a; |
356 | int r; |
357 | |
358 | __refcount_inc(r: &server->ref, oldp: &r); |
359 | a = atomic_read(v: &server->active); |
360 | trace_afs_server(server_debug_id: server->debug_id, ref: r + 1, active: a, reason); |
361 | return server; |
362 | } |
363 | |
364 | /* |
365 | * Try to get a reference on a server object. |
366 | */ |
367 | static struct afs_server *afs_maybe_use_server(struct afs_server *server, |
368 | enum afs_server_trace reason) |
369 | { |
370 | unsigned int a; |
371 | int r; |
372 | |
373 | if (!__refcount_inc_not_zero(r: &server->ref, oldp: &r)) |
374 | return NULL; |
375 | |
376 | a = atomic_inc_return(v: &server->active); |
377 | trace_afs_server(server_debug_id: server->debug_id, ref: r + 1, active: a, reason); |
378 | return server; |
379 | } |
380 | |
381 | /* |
382 | * Get an active count on a server object. |
383 | */ |
384 | struct afs_server *afs_use_server(struct afs_server *server, enum afs_server_trace reason) |
385 | { |
386 | unsigned int a; |
387 | int r; |
388 | |
389 | __refcount_inc(r: &server->ref, oldp: &r); |
390 | a = atomic_inc_return(v: &server->active); |
391 | |
392 | trace_afs_server(server_debug_id: server->debug_id, ref: r + 1, active: a, reason); |
393 | return server; |
394 | } |
395 | |
396 | /* |
397 | * Release a reference on a server record. |
398 | */ |
399 | void afs_put_server(struct afs_net *net, struct afs_server *server, |
400 | enum afs_server_trace reason) |
401 | { |
402 | unsigned int a, debug_id = server->debug_id; |
403 | bool zero; |
404 | int r; |
405 | |
406 | if (!server) |
407 | return; |
408 | |
409 | a = atomic_read(v: &server->active); |
410 | zero = __refcount_dec_and_test(r: &server->ref, oldp: &r); |
411 | trace_afs_server(server_debug_id: debug_id, ref: r - 1, active: a, reason); |
412 | if (unlikely(zero)) |
413 | __afs_put_server(net, server); |
414 | } |
415 | |
416 | /* |
417 | * Drop an active count on a server object without updating the last-unused |
418 | * time. |
419 | */ |
420 | void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server, |
421 | enum afs_server_trace reason) |
422 | { |
423 | if (server) { |
424 | unsigned int active = atomic_dec_return(v: &server->active); |
425 | |
426 | if (active == 0) |
427 | afs_set_server_timer(net, delay: afs_server_gc_delay); |
428 | afs_put_server(net, server, reason); |
429 | } |
430 | } |
431 | |
432 | /* |
433 | * Drop an active count on a server object. |
434 | */ |
435 | void afs_unuse_server(struct afs_net *net, struct afs_server *server, |
436 | enum afs_server_trace reason) |
437 | { |
438 | if (server) { |
439 | server->unuse_time = ktime_get_real_seconds(); |
440 | afs_unuse_server_notime(net, server, reason); |
441 | } |
442 | } |
443 | |
444 | static void afs_server_rcu(struct rcu_head *rcu) |
445 | { |
446 | struct afs_server *server = container_of(rcu, struct afs_server, rcu); |
447 | |
448 | trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref), |
449 | active: atomic_read(v: &server->active), reason: afs_server_trace_free); |
450 | afs_put_addrlist(rcu_access_pointer(server->addresses)); |
451 | kfree(objp: server); |
452 | } |
453 | |
454 | static void __afs_put_server(struct afs_net *net, struct afs_server *server) |
455 | { |
456 | call_rcu(head: &server->rcu, func: afs_server_rcu); |
457 | afs_dec_servers_outstanding(net); |
458 | } |
459 | |
460 | static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server) |
461 | { |
462 | struct afs_addr_list *alist = rcu_access_pointer(server->addresses); |
463 | struct afs_addr_cursor ac = { |
464 | .alist = alist, |
465 | .index = alist->preferred, |
466 | .error = 0, |
467 | }; |
468 | |
469 | afs_fs_give_up_all_callbacks(net, server, &ac, NULL); |
470 | } |
471 | |
472 | /* |
473 | * destroy a dead server |
474 | */ |
475 | static void afs_destroy_server(struct afs_net *net, struct afs_server *server) |
476 | { |
477 | if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags)) |
478 | afs_give_up_callbacks(net, server); |
479 | |
480 | flush_work(work: &server->initcb_work); |
481 | afs_put_server(net, server, reason: afs_server_trace_destroy); |
482 | } |
483 | |
484 | /* |
485 | * Garbage collect any expired servers. |
486 | */ |
487 | static void afs_gc_servers(struct afs_net *net, struct afs_server *gc_list) |
488 | { |
489 | struct afs_server *server, *next, *prev; |
490 | int active; |
491 | |
492 | while ((server = gc_list)) { |
493 | gc_list = server->gc_next; |
494 | |
495 | write_seqlock(sl: &net->fs_lock); |
496 | |
497 | active = atomic_read(v: &server->active); |
498 | if (active == 0) { |
499 | trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref), |
500 | active, reason: afs_server_trace_gc); |
501 | next = rcu_dereference_protected( |
502 | server->uuid_next, lockdep_is_held(&net->fs_lock.lock)); |
503 | prev = server->uuid_prev; |
504 | if (!prev) { |
505 | /* The one at the front is in the tree */ |
506 | if (!next) { |
507 | rb_erase(&server->uuid_rb, &net->fs_servers); |
508 | } else { |
509 | rb_replace_node_rcu(victim: &server->uuid_rb, |
510 | new: &next->uuid_rb, |
511 | root: &net->fs_servers); |
512 | next->uuid_prev = NULL; |
513 | } |
514 | } else { |
515 | /* This server is not at the front */ |
516 | rcu_assign_pointer(prev->uuid_next, next); |
517 | if (next) |
518 | next->uuid_prev = prev; |
519 | } |
520 | |
521 | list_del(entry: &server->probe_link); |
522 | hlist_del_rcu(n: &server->proc_link); |
523 | if (!hlist_unhashed(h: &server->addr4_link)) |
524 | hlist_del_rcu(n: &server->addr4_link); |
525 | if (!hlist_unhashed(h: &server->addr6_link)) |
526 | hlist_del_rcu(n: &server->addr6_link); |
527 | } |
528 | write_sequnlock(sl: &net->fs_lock); |
529 | |
530 | if (active == 0) |
531 | afs_destroy_server(net, server); |
532 | } |
533 | } |
534 | |
535 | /* |
536 | * Manage the records of servers known to be within a network namespace. This |
537 | * includes garbage collecting unused servers. |
538 | * |
539 | * Note also that we were given an increment on net->servers_outstanding by |
540 | * whoever queued us that we need to deal with before returning. |
541 | */ |
542 | void afs_manage_servers(struct work_struct *work) |
543 | { |
544 | struct afs_net *net = container_of(work, struct afs_net, fs_manager); |
545 | struct afs_server *gc_list = NULL; |
546 | struct rb_node *cursor; |
547 | time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX; |
548 | bool purging = !net->live; |
549 | |
550 | _enter("" ); |
551 | |
552 | /* Trawl the server list looking for servers that have expired from |
553 | * lack of use. |
554 | */ |
555 | read_seqlock_excl(sl: &net->fs_lock); |
556 | |
557 | for (cursor = rb_first(&net->fs_servers); cursor; cursor = rb_next(cursor)) { |
558 | struct afs_server *server = |
559 | rb_entry(cursor, struct afs_server, uuid_rb); |
560 | int active = atomic_read(v: &server->active); |
561 | |
562 | _debug("manage %pU %u" , &server->uuid, active); |
563 | |
564 | if (purging) { |
565 | trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref), |
566 | active, reason: afs_server_trace_purging); |
567 | if (active != 0) |
568 | pr_notice("Can't purge s=%08x\n" , server->debug_id); |
569 | } |
570 | |
571 | if (active == 0) { |
572 | time64_t expire_at = server->unuse_time; |
573 | |
574 | if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) && |
575 | !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags)) |
576 | expire_at += afs_server_gc_delay; |
577 | if (purging || expire_at <= now) { |
578 | server->gc_next = gc_list; |
579 | gc_list = server; |
580 | } else if (expire_at < next_manage) { |
581 | next_manage = expire_at; |
582 | } |
583 | } |
584 | } |
585 | |
586 | read_sequnlock_excl(sl: &net->fs_lock); |
587 | |
588 | /* Update the timer on the way out. We have to pass an increment on |
589 | * servers_outstanding in the namespace that we are in to the timer or |
590 | * the work scheduler. |
591 | */ |
592 | if (!purging && next_manage < TIME64_MAX) { |
593 | now = ktime_get_real_seconds(); |
594 | |
595 | if (next_manage - now <= 0) { |
596 | if (queue_work(wq: afs_wq, work: &net->fs_manager)) |
597 | afs_inc_servers_outstanding(net); |
598 | } else { |
599 | afs_set_server_timer(net, delay: next_manage - now); |
600 | } |
601 | } |
602 | |
603 | afs_gc_servers(net, gc_list); |
604 | |
605 | afs_dec_servers_outstanding(net); |
606 | _leave(" [%d]" , atomic_read(&net->servers_outstanding)); |
607 | } |
608 | |
609 | static void afs_queue_server_manager(struct afs_net *net) |
610 | { |
611 | afs_inc_servers_outstanding(net); |
612 | if (!queue_work(wq: afs_wq, work: &net->fs_manager)) |
613 | afs_dec_servers_outstanding(net); |
614 | } |
615 | |
616 | /* |
617 | * Purge list of servers. |
618 | */ |
619 | void afs_purge_servers(struct afs_net *net) |
620 | { |
621 | _enter("" ); |
622 | |
623 | if (del_timer_sync(timer: &net->fs_timer)) |
624 | afs_dec_servers_outstanding(net); |
625 | |
626 | afs_queue_server_manager(net); |
627 | |
628 | _debug("wait" ); |
629 | atomic_dec(v: &net->servers_outstanding); |
630 | wait_var_event(&net->servers_outstanding, |
631 | !atomic_read(&net->servers_outstanding)); |
632 | _leave("" ); |
633 | } |
634 | |
635 | /* |
636 | * Get an update for a server's address list. |
637 | */ |
638 | static noinline bool afs_update_server_record(struct afs_operation *op, |
639 | struct afs_server *server) |
640 | { |
641 | struct afs_addr_list *alist, *discard; |
642 | |
643 | _enter("" ); |
644 | |
645 | trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref), |
646 | active: atomic_read(v: &server->active), |
647 | reason: afs_server_trace_update); |
648 | |
649 | alist = afs_vl_lookup_addrs(cell: op->volume->cell, key: op->key, uuid: &server->uuid); |
650 | if (IS_ERR(ptr: alist)) { |
651 | if ((PTR_ERR(ptr: alist) == -ERESTARTSYS || |
652 | PTR_ERR(ptr: alist) == -EINTR) && |
653 | (op->flags & AFS_OPERATION_UNINTR) && |
654 | server->addresses) { |
655 | _leave(" = t [intr]" ); |
656 | return true; |
657 | } |
658 | op->error = PTR_ERR(ptr: alist); |
659 | _leave(" = f [%d]" , op->error); |
660 | return false; |
661 | } |
662 | |
663 | discard = alist; |
664 | if (server->addr_version != alist->version) { |
665 | write_lock(&server->fs_lock); |
666 | discard = rcu_dereference_protected(server->addresses, |
667 | lockdep_is_held(&server->fs_lock)); |
668 | rcu_assign_pointer(server->addresses, alist); |
669 | server->addr_version = alist->version; |
670 | write_unlock(&server->fs_lock); |
671 | } |
672 | |
673 | afs_put_addrlist(discard); |
674 | _leave(" = t" ); |
675 | return true; |
676 | } |
677 | |
678 | /* |
679 | * See if a server's address list needs updating. |
680 | */ |
681 | bool afs_check_server_record(struct afs_operation *op, struct afs_server *server) |
682 | { |
683 | bool success; |
684 | int ret, retries = 0; |
685 | |
686 | _enter("" ); |
687 | |
688 | ASSERT(server); |
689 | |
690 | retry: |
691 | if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags)) |
692 | goto wait; |
693 | if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags)) |
694 | goto update; |
695 | _leave(" = t [good]" ); |
696 | return true; |
697 | |
698 | update: |
699 | if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, addr: &server->flags)) { |
700 | clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, addr: &server->flags); |
701 | success = afs_update_server_record(op, server); |
702 | clear_bit_unlock(AFS_SERVER_FL_UPDATING, addr: &server->flags); |
703 | wake_up_bit(word: &server->flags, AFS_SERVER_FL_UPDATING); |
704 | _leave(" = %d" , success); |
705 | return success; |
706 | } |
707 | |
708 | wait: |
709 | ret = wait_on_bit(word: &server->flags, AFS_SERVER_FL_UPDATING, |
710 | mode: (op->flags & AFS_OPERATION_UNINTR) ? |
711 | TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE); |
712 | if (ret == -ERESTARTSYS) { |
713 | op->error = ret; |
714 | _leave(" = f [intr]" ); |
715 | return false; |
716 | } |
717 | |
718 | retries++; |
719 | if (retries == 4) { |
720 | _leave(" = f [stale]" ); |
721 | ret = -ESTALE; |
722 | return false; |
723 | } |
724 | goto retry; |
725 | } |
726 | |