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