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
14static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */
15static atomic_t afs_server_debug_id;
16
17static void __afs_put_server(struct afs_net *, struct afs_server *);
18static void afs_server_timer(struct timer_list *timer);
19static void afs_server_destroyer(struct work_struct *work);
20
21/*
22 * Find a server by one of its addresses.
23 */
24struct afs_server *afs_find_server(const struct rxrpc_peer *peer)
25{
26 struct afs_server *server = (struct afs_server *)rxrpc_kernel_get_peer_data(peer);
27
28 if (!server)
29 return NULL;
30 return afs_use_server(server, activate: false, reason: afs_server_trace_use_cm_call);
31}
32
33/*
34 * Look up a server by its UUID and mark it active. The caller must hold
35 * cell->fs_lock.
36 */
37static struct afs_server *afs_find_server_by_uuid(struct afs_cell *cell, const uuid_t *uuid)
38{
39 struct afs_server *server;
40 struct rb_node *p;
41 int diff;
42
43 _enter("%pU", uuid);
44
45 p = cell->fs_servers.rb_node;
46 while (p) {
47 server = rb_entry(p, struct afs_server, uuid_rb);
48
49 diff = memcmp(p: uuid, q: &server->uuid, size: sizeof(*uuid));
50 if (diff < 0) {
51 p = p->rb_left;
52 } else if (diff > 0) {
53 p = p->rb_right;
54 } else {
55 if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags))
56 return NULL; /* Need a write lock */
57 afs_use_server(server, activate: true, reason: afs_server_trace_use_by_uuid);
58 return server;
59 }
60 }
61
62 return NULL;
63}
64
65/*
66 * Install a server record in the cell tree. The caller must hold an exclusive
67 * lock on cell->fs_lock.
68 */
69static struct afs_server *afs_install_server(struct afs_cell *cell,
70 struct afs_server **candidate)
71{
72 struct afs_server *server;
73 struct afs_net *net = cell->net;
74 struct rb_node **pp, *p;
75 int diff;
76
77 _enter("%p", candidate);
78
79 /* Firstly install the server in the UUID lookup tree */
80 pp = &cell->fs_servers.rb_node;
81 p = NULL;
82 while (*pp) {
83 p = *pp;
84 _debug("- consider %p", p);
85 server = rb_entry(p, struct afs_server, uuid_rb);
86 diff = memcmp(p: &(*candidate)->uuid, q: &server->uuid, size: sizeof(uuid_t));
87 if (diff < 0)
88 pp = &(*pp)->rb_left;
89 else if (diff > 0)
90 pp = &(*pp)->rb_right;
91 else
92 goto exists;
93 }
94
95 server = *candidate;
96 *candidate = NULL;
97 rb_link_node(node: &server->uuid_rb, parent: p, rb_link: pp);
98 rb_insert_color(&server->uuid_rb, &cell->fs_servers);
99 write_seqlock(sl: &net->fs_lock);
100 hlist_add_head_rcu(n: &server->proc_link, h: &net->fs_proc);
101 write_sequnlock(sl: &net->fs_lock);
102
103 afs_get_cell(cell, afs_cell_trace_get_server);
104
105exists:
106 afs_use_server(server, activate: true, reason: afs_server_trace_use_install);
107 return server;
108}
109
110/*
111 * Allocate a new server record and mark it as active but uncreated.
112 */
113static struct afs_server *afs_alloc_server(struct afs_cell *cell, const uuid_t *uuid)
114{
115 struct afs_server *server;
116 struct afs_net *net = cell->net;
117
118 _enter("");
119
120 server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
121 if (!server)
122 return NULL;
123
124 refcount_set(r: &server->ref, n: 1);
125 atomic_set(v: &server->active, i: 0);
126 __set_bit(AFS_SERVER_FL_UNCREATED, &server->flags);
127 server->debug_id = atomic_inc_return(v: &afs_server_debug_id);
128 server->uuid = *uuid;
129 rwlock_init(&server->fs_lock);
130 INIT_WORK(&server->destroyer, &afs_server_destroyer);
131 timer_setup(&server->timer, afs_server_timer, 0);
132 INIT_LIST_HEAD(list: &server->volumes);
133 init_waitqueue_head(&server->probe_wq);
134 mutex_init(&server->cm_token_lock);
135 INIT_LIST_HEAD(list: &server->probe_link);
136 INIT_HLIST_NODE(h: &server->proc_link);
137 spin_lock_init(&server->probe_lock);
138 server->cell = cell;
139 server->rtt = UINT_MAX;
140 server->service_id = FS_SERVICE;
141 server->probe_counter = 1;
142 server->probed_at = jiffies - LONG_MAX / 2;
143
144 afs_inc_servers_outstanding(net);
145 _leave(" = %p", server);
146 return server;
147}
148
149/*
150 * Look up an address record for a server
151 */
152static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_server *server,
153 struct key *key)
154{
155 struct afs_vl_cursor vc;
156 struct afs_addr_list *alist = NULL;
157 int ret;
158
159 ret = -ERESTARTSYS;
160 if (afs_begin_vlserver_operation(&vc, server->cell, key)) {
161 while (afs_select_vlserver(&vc)) {
162 if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags))
163 alist = afs_yfsvl_get_endpoints(&vc, &server->uuid);
164 else
165 alist = afs_vl_get_addrs_u(&vc, &server->uuid);
166 }
167
168 ret = afs_end_vlserver_operation(&vc);
169 }
170
171 return ret < 0 ? ERR_PTR(error: ret) : alist;
172}
173
174/*
175 * Get or create a fileserver record and return it with an active-use count on
176 * it.
177 */
178struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key,
179 const uuid_t *uuid, u32 addr_version)
180{
181 struct afs_addr_list *alist = NULL;
182 struct afs_server *server, *candidate = NULL;
183 bool creating = false;
184 int ret;
185
186 _enter("%p,%pU", cell->net, uuid);
187
188 down_read(sem: &cell->fs_lock);
189 server = afs_find_server_by_uuid(cell, uuid);
190 /* Won't see servers marked uncreated. */
191 up_read(sem: &cell->fs_lock);
192
193 if (server) {
194 timer_delete_sync(timer: &server->timer);
195 if (test_bit(AFS_SERVER_FL_CREATING, &server->flags))
196 goto wait_for_creation;
197 if (server->addr_version != addr_version)
198 set_bit(AFS_SERVER_FL_NEEDS_UPDATE, addr: &server->flags);
199 return server;
200 }
201
202 candidate = afs_alloc_server(cell, uuid);
203 if (!candidate) {
204 afs_put_addrlist(alist, reason: afs_alist_trace_put_server_oom);
205 return ERR_PTR(error: -ENOMEM);
206 }
207
208 down_write(sem: &cell->fs_lock);
209 server = afs_install_server(cell, candidate: &candidate);
210 if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) {
211 /* We need to wait for creation to complete. */
212 up_write(sem: &cell->fs_lock);
213 goto wait_for_creation;
214 }
215 if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) {
216 set_bit(AFS_SERVER_FL_CREATING, addr: &server->flags);
217 clear_bit(AFS_SERVER_FL_UNCREATED, addr: &server->flags);
218 creating = true;
219 }
220 up_write(sem: &cell->fs_lock);
221 timer_delete_sync(timer: &server->timer);
222
223 /* If we get to create the server, we look up the addresses and then
224 * immediately dispatch an asynchronous probe to each interface on the
225 * fileserver. This will make sure the repeat-probing service is
226 * started.
227 */
228 if (creating) {
229 alist = afs_vl_lookup_addrs(server, key);
230 if (IS_ERR(ptr: alist)) {
231 ret = PTR_ERR(ptr: alist);
232 goto create_failed;
233 }
234
235 ret = afs_fs_probe_fileserver(net: cell->net, server, new_alist: alist, key);
236 if (ret)
237 goto create_failed;
238
239 clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, word: &server->flags);
240 }
241
242out:
243 afs_put_addrlist(alist, reason: afs_alist_trace_put_server_create);
244 if (candidate) {
245 kfree(rcu_access_pointer(server->endpoint_state));
246 kfree(objp: candidate);
247 afs_dec_servers_outstanding(net: cell->net);
248 }
249 return server ?: ERR_PTR(error: ret);
250
251wait_for_creation:
252 afs_see_server(server, trace: afs_server_trace_wait_create);
253 wait_on_bit(word: &server->flags, AFS_SERVER_FL_CREATING, TASK_UNINTERRUPTIBLE);
254 if (test_bit_acquire(AFS_SERVER_FL_UNCREATED, &server->flags)) {
255 /* Barrier: read flag before error */
256 ret = READ_ONCE(server->create_error);
257 afs_put_server(cell->net, server, afs_server_trace_unuse_create_fail);
258 server = NULL;
259 goto out;
260 }
261
262 ret = 0;
263 goto out;
264
265create_failed:
266 down_write(sem: &cell->fs_lock);
267
268 WRITE_ONCE(server->create_error, ret);
269 smp_wmb(); /* Barrier: set error before flag. */
270 set_bit(AFS_SERVER_FL_UNCREATED, addr: &server->flags);
271
272 clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, word: &server->flags);
273
274 if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) {
275 clear_bit(AFS_SERVER_FL_UNCREATED, addr: &server->flags);
276 creating = true;
277 }
278 afs_unuse_server(net: cell->net, server, reason: afs_server_trace_unuse_create_fail);
279 server = NULL;
280
281 up_write(sem: &cell->fs_lock);
282 goto out;
283}
284
285/*
286 * Set/reduce a server's timer.
287 */
288static void afs_set_server_timer(struct afs_server *server, unsigned int delay_secs)
289{
290 mod_timer(timer: &server->timer, expires: jiffies + delay_secs * HZ);
291}
292
293/*
294 * Get a reference on a server object.
295 */
296struct afs_server *afs_get_server(struct afs_server *server,
297 enum afs_server_trace reason)
298{
299 unsigned int a;
300 int r;
301
302 __refcount_inc(r: &server->ref, oldp: &r);
303 a = atomic_read(v: &server->active);
304 trace_afs_server(server_debug_id: server->debug_id, ref: r + 1, active: a, reason);
305 return server;
306}
307
308/*
309 * Get an active count on a server object and maybe remove from the inactive
310 * list.
311 */
312struct afs_server *afs_use_server(struct afs_server *server, bool activate,
313 enum afs_server_trace reason)
314{
315 unsigned int a;
316 int r;
317
318 __refcount_inc(r: &server->ref, oldp: &r);
319 a = atomic_inc_return(v: &server->active);
320 if (a == 1 && activate &&
321 !test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))
322 timer_delete(timer: &server->timer);
323
324 trace_afs_server(server_debug_id: server->debug_id, ref: r + 1, active: a, reason);
325 return server;
326}
327
328/*
329 * Release a reference on a server record.
330 */
331void afs_put_server(struct afs_net *net, struct afs_server *server,
332 enum afs_server_trace reason)
333{
334 unsigned int a, debug_id;
335 bool zero;
336 int r;
337
338 if (!server)
339 return;
340
341 debug_id = server->debug_id;
342 a = atomic_read(v: &server->active);
343 zero = __refcount_dec_and_test(r: &server->ref, oldp: &r);
344 trace_afs_server(server_debug_id: debug_id, ref: r - 1, active: a, reason);
345 if (unlikely(zero))
346 __afs_put_server(net, server);
347}
348
349/*
350 * Drop an active count on a server object without updating the last-unused
351 * time.
352 */
353void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server,
354 enum afs_server_trace reason)
355{
356 if (!server)
357 return;
358
359 if (atomic_dec_and_test(v: &server->active)) {
360 if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) ||
361 READ_ONCE(server->cell->state) >= AFS_CELL_REMOVING)
362 schedule_work(work: &server->destroyer);
363 }
364
365 afs_put_server(net, server, reason);
366}
367
368/*
369 * Drop an active count on a server object.
370 */
371void afs_unuse_server(struct afs_net *net, struct afs_server *server,
372 enum afs_server_trace reason)
373{
374 if (!server)
375 return;
376
377 if (atomic_dec_and_test(v: &server->active)) {
378 if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) &&
379 READ_ONCE(server->cell->state) < AFS_CELL_REMOVING) {
380 time64_t unuse_time = ktime_get_real_seconds();
381
382 server->unuse_time = unuse_time;
383 afs_set_server_timer(server, delay_secs: afs_server_gc_delay);
384 } else {
385 schedule_work(work: &server->destroyer);
386 }
387 }
388
389 afs_put_server(net, server, reason);
390}
391
392static void afs_server_rcu(struct rcu_head *rcu)
393{
394 struct afs_server *server = container_of(rcu, struct afs_server, rcu);
395
396 trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref),
397 active: atomic_read(v: &server->active), reason: afs_server_trace_free);
398 afs_put_endpoint_state(rcu_access_pointer(server->endpoint_state),
399 where: afs_estate_trace_put_server);
400 afs_put_cell(server->cell, afs_cell_trace_put_server);
401 kfree(objp: server->cm_rxgk_appdata.data);
402 kfree(objp: server);
403}
404
405static void __afs_put_server(struct afs_net *net, struct afs_server *server)
406{
407 call_rcu(head: &server->rcu, func: afs_server_rcu);
408 afs_dec_servers_outstanding(net);
409}
410
411static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server)
412{
413 struct afs_endpoint_state *estate = rcu_access_pointer(server->endpoint_state);
414 struct afs_addr_list *alist = estate->addresses;
415
416 afs_fs_give_up_all_callbacks(net, server, addr: &alist->addrs[alist->preferred], NULL);
417}
418
419/*
420 * Check to see if the server record has expired.
421 */
422static bool afs_has_server_expired(const struct afs_server *server)
423{
424 time64_t expires_at;
425
426 if (atomic_read(v: &server->active))
427 return false;
428
429 if (server->cell->net->live ||
430 server->cell->state >= AFS_CELL_REMOVING) {
431 trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref),
432 active: 0, reason: afs_server_trace_purging);
433 return true;
434 }
435
436 expires_at = server->unuse_time;
437 if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) &&
438 !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags))
439 expires_at += afs_server_gc_delay;
440
441 return ktime_get_real_seconds() > expires_at;
442}
443
444/*
445 * Remove a server record from it's parent cell's database.
446 */
447static bool afs_remove_server_from_cell(struct afs_server *server)
448{
449 struct afs_cell *cell = server->cell;
450
451 down_write(sem: &cell->fs_lock);
452
453 if (!afs_has_server_expired(server)) {
454 up_write(sem: &cell->fs_lock);
455 return false;
456 }
457
458 set_bit(AFS_SERVER_FL_EXPIRED, addr: &server->flags);
459 _debug("expire %pU %u", &server->uuid, atomic_read(&server->active));
460 afs_see_server(server, trace: afs_server_trace_see_expired);
461 rb_erase(&server->uuid_rb, &cell->fs_servers);
462 up_write(sem: &cell->fs_lock);
463 return true;
464}
465
466static void afs_server_destroyer(struct work_struct *work)
467{
468 struct afs_endpoint_state *estate;
469 struct afs_server *server = container_of(work, struct afs_server, destroyer);
470 struct afs_net *net = server->cell->net;
471
472 afs_see_server(server, trace: afs_server_trace_see_destroyer);
473
474 if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))
475 return;
476
477 if (!afs_remove_server_from_cell(server))
478 return;
479
480 timer_shutdown_sync(timer: &server->timer);
481 cancel_work(work: &server->destroyer);
482
483 if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))
484 afs_give_up_callbacks(net, server);
485
486 /* Unbind the rxrpc_peer records from the server. */
487 estate = rcu_access_pointer(server->endpoint_state);
488 if (estate)
489 afs_set_peer_appdata(server, old_alist: estate->addresses, NULL);
490
491 write_seqlock(sl: &net->fs_lock);
492 list_del_init(entry: &server->probe_link);
493 if (!hlist_unhashed(h: &server->proc_link))
494 hlist_del_rcu(n: &server->proc_link);
495 write_sequnlock(sl: &net->fs_lock);
496
497 afs_put_server(net, server, reason: afs_server_trace_destroy);
498}
499
500static void afs_server_timer(struct timer_list *timer)
501{
502 struct afs_server *server = container_of(timer, struct afs_server, timer);
503
504 afs_see_server(server, trace: afs_server_trace_see_timer);
505 if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))
506 schedule_work(work: &server->destroyer);
507}
508
509/*
510 * Wake up all the servers in a cell so that they can purge themselves.
511 */
512void afs_purge_servers(struct afs_cell *cell)
513{
514 struct afs_server *server;
515 struct rb_node *rb;
516
517 down_read(sem: &cell->fs_lock);
518 for (rb = rb_first(root: &cell->fs_servers); rb; rb = rb_next(rb)) {
519 server = rb_entry(rb, struct afs_server, uuid_rb);
520 afs_see_server(server, trace: afs_server_trace_see_purge);
521 schedule_work(work: &server->destroyer);
522 }
523 up_read(sem: &cell->fs_lock);
524}
525
526/*
527 * Wait for outstanding servers.
528 */
529void afs_wait_for_servers(struct afs_net *net)
530{
531 _enter("");
532
533 atomic_dec(v: &net->servers_outstanding);
534 wait_var_event(&net->servers_outstanding,
535 !atomic_read(&net->servers_outstanding));
536 _leave("");
537}
538
539/*
540 * Get an update for a server's address list.
541 */
542static noinline bool afs_update_server_record(struct afs_operation *op,
543 struct afs_server *server,
544 struct key *key)
545{
546 struct afs_endpoint_state *estate;
547 struct afs_addr_list *alist;
548 bool has_addrs;
549
550 _enter("");
551
552 trace_afs_server(server_debug_id: server->debug_id, ref: refcount_read(r: &server->ref),
553 active: atomic_read(v: &server->active),
554 reason: afs_server_trace_update);
555
556 alist = afs_vl_lookup_addrs(server, key: op->key);
557 if (IS_ERR(ptr: alist)) {
558 rcu_read_lock();
559 estate = rcu_dereference(server->endpoint_state);
560 has_addrs = estate->addresses;
561 rcu_read_unlock();
562
563 if ((PTR_ERR(ptr: alist) == -ERESTARTSYS ||
564 PTR_ERR(ptr: alist) == -EINTR) &&
565 (op->flags & AFS_OPERATION_UNINTR) &&
566 has_addrs) {
567 _leave(" = t [intr]");
568 return true;
569 }
570 afs_op_set_error(op, error: PTR_ERR(ptr: alist));
571 _leave(" = f [%d]", afs_op_error(op));
572 return false;
573 }
574
575 if (server->addr_version != alist->version)
576 afs_fs_probe_fileserver(net: op->net, server, new_alist: alist, key);
577
578 afs_put_addrlist(alist, reason: afs_alist_trace_put_server_update);
579 _leave(" = t");
580 return true;
581}
582
583/*
584 * See if a server's address list needs updating.
585 */
586bool afs_check_server_record(struct afs_operation *op, struct afs_server *server,
587 struct key *key)
588{
589 bool success;
590 int ret, retries = 0;
591
592 _enter("");
593
594 ASSERT(server);
595
596retry:
597 if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags))
598 goto wait;
599 if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags))
600 goto update;
601 _leave(" = t [good]");
602 return true;
603
604update:
605 if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, addr: &server->flags)) {
606 clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, addr: &server->flags);
607 success = afs_update_server_record(op, server, key);
608 clear_bit_unlock(AFS_SERVER_FL_UPDATING, addr: &server->flags);
609 wake_up_bit(word: &server->flags, AFS_SERVER_FL_UPDATING);
610 _leave(" = %d", success);
611 return success;
612 }
613
614wait:
615 ret = wait_on_bit(word: &server->flags, AFS_SERVER_FL_UPDATING,
616 mode: (op->flags & AFS_OPERATION_UNINTR) ?
617 TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
618 if (ret == -ERESTARTSYS) {
619 afs_op_set_error(op, error: ret);
620 _leave(" = f [intr]");
621 return false;
622 }
623
624 retries++;
625 if (retries == 4) {
626 _leave(" = f [stale]");
627 ret = -ESTALE;
628 return false;
629 }
630 goto retry;
631}
632

source code of linux/fs/afs/server.c