]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/afs/server.c
1 /* AFS server record management
3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/sched.h>
13 #include <linux/slab.h>
17 static unsigned afs_server_gc_delay
= 10; /* Server record timeout in seconds */
18 static unsigned afs_server_update_delay
= 30; /* Time till VLDB recheck in secs */
20 static void afs_inc_servers_outstanding(struct afs_net
*net
)
22 atomic_inc(&net
->servers_outstanding
);
25 static void afs_dec_servers_outstanding(struct afs_net
*net
)
27 if (atomic_dec_and_test(&net
->servers_outstanding
))
28 wake_up_atomic_t(&net
->servers_outstanding
);
32 * Find a server by one of its addresses.
34 struct afs_server
*afs_find_server(struct afs_net
*net
,
35 const struct sockaddr_rxrpc
*srx
)
37 const struct sockaddr_in6
*a
= &srx
->transport
.sin6
, *b
;
38 const struct afs_addr_list
*alist
;
39 struct afs_server
*server
= NULL
;
44 if (srx
->transport
.sin6
.sin6_addr
.s6_addr32
[0] == 0 ||
45 srx
->transport
.sin6
.sin6_addr
.s6_addr32
[1] == 0 ||
46 srx
->transport
.sin6
.sin6_addr
.s6_addr32
[2] == htonl(0xffff))
53 afs_put_server(net
, server
);
55 read_seqbegin_or_lock(&net
->fs_addr_lock
, &seq
);
58 hlist_for_each_entry_rcu(server
, &net
->fs_addresses6
, addr6_link
) {
59 alist
= rcu_dereference(server
->addresses
);
60 for (i
= alist
->nr_ipv4
; i
< alist
->nr_addrs
; i
++) {
61 b
= &alist
->addrs
[i
].transport
.sin6
;
62 diff
= (u16
)a
->sin6_port
- (u16
)b
->sin6_port
;
64 diff
= memcmp(&a
->sin6_addr
,
66 sizeof(struct in6_addr
));
72 hlist_for_each_entry_rcu(server
, &net
->fs_addresses4
, addr4_link
) {
73 alist
= rcu_dereference(server
->addresses
);
74 for (i
= 0; i
< alist
->nr_ipv4
; i
++) {
75 b
= &alist
->addrs
[i
].transport
.sin6
;
76 diff
= (u16
)a
->sin6_port
- (u16
)b
->sin6_port
;
78 diff
= ((u32
)a
->sin6_addr
.s6_addr32
[3] -
79 (u32
)b
->sin6_addr
.s6_addr32
[3]);
88 if (server
&& !atomic_inc_not_zero(&server
->usage
))
91 } while (need_seqretry(&net
->fs_addr_lock
, seq
));
93 done_seqretry(&net
->fs_addr_lock
, seq
);
100 * Look up a server by its UUID
102 struct afs_server
*afs_find_server_by_uuid(struct afs_net
*net
, const uuid_t
*uuid
)
104 struct afs_server
*server
= NULL
;
111 /* Unfortunately, rbtree walking doesn't give reliable results
112 * under just the RCU read lock, so we have to check for
116 afs_put_server(net
, server
);
119 read_seqbegin_or_lock(&net
->fs_lock
, &seq
);
121 p
= net
->fs_servers
.rb_node
;
123 server
= rb_entry(p
, struct afs_server
, uuid_rb
);
125 diff
= memcmp(uuid
, &server
->uuid
, sizeof(*uuid
));
128 } else if (diff
> 0) {
131 afs_get_server(server
);
137 } while (need_seqretry(&net
->fs_lock
, seq
));
139 done_seqretry(&net
->fs_lock
, seq
);
141 _leave(" = %p", server
);
146 * Install a server record in the namespace tree
148 static struct afs_server
*afs_install_server(struct afs_net
*net
,
149 struct afs_server
*candidate
)
151 const struct afs_addr_list
*alist
;
152 struct afs_server
*server
;
153 struct rb_node
**pp
, *p
;
154 int ret
= -EEXIST
, diff
;
156 _enter("%p", candidate
);
158 write_seqlock(&net
->fs_lock
);
160 /* Firstly install the server in the UUID lookup tree */
161 pp
= &net
->fs_servers
.rb_node
;
165 _debug("- consider %p", p
);
166 server
= rb_entry(p
, struct afs_server
, uuid_rb
);
167 diff
= memcmp(&candidate
->uuid
, &server
->uuid
, sizeof(uuid_t
));
169 pp
= &(*pp
)->rb_left
;
171 pp
= &(*pp
)->rb_right
;
177 rb_link_node(&server
->uuid_rb
, p
, pp
);
178 rb_insert_color(&server
->uuid_rb
, &net
->fs_servers
);
179 hlist_add_head_rcu(&server
->proc_link
, &net
->fs_proc
);
181 write_seqlock(&net
->fs_addr_lock
);
182 alist
= rcu_dereference_protected(server
->addresses
,
183 lockdep_is_held(&net
->fs_addr_lock
.lock
));
185 /* Secondly, if the server has any IPv4 and/or IPv6 addresses, install
186 * it in the IPv4 and/or IPv6 reverse-map lists.
188 * TODO: For speed we want to use something other than a flat list
189 * here; even sorting the list in terms of lowest address would help a
190 * bit, but anything we might want to do gets messy and memory
193 if (alist
->nr_ipv4
> 0)
194 hlist_add_head_rcu(&server
->addr4_link
, &net
->fs_addresses4
);
195 if (alist
->nr_addrs
> alist
->nr_ipv4
)
196 hlist_add_head_rcu(&server
->addr6_link
, &net
->fs_addresses6
);
198 write_sequnlock(&net
->fs_addr_lock
);
202 afs_get_server(server
);
203 write_sequnlock(&net
->fs_lock
);
208 * allocate a new server record
210 static struct afs_server
*afs_alloc_server(struct afs_net
*net
,
212 struct afs_addr_list
*alist
)
214 struct afs_server
*server
;
218 server
= kzalloc(sizeof(struct afs_server
), GFP_KERNEL
);
222 atomic_set(&server
->usage
, 1);
223 RCU_INIT_POINTER(server
->addresses
, alist
);
224 server
->addr_version
= alist
->version
;
225 server
->uuid
= *uuid
;
226 server
->flags
= (1UL << AFS_SERVER_FL_NEW
);
227 server
->update_at
= ktime_get_real_seconds() + afs_server_update_delay
;
228 rwlock_init(&server
->fs_lock
);
229 INIT_LIST_HEAD(&server
->cb_interests
);
230 rwlock_init(&server
->cb_break_lock
);
232 afs_inc_servers_outstanding(net
);
233 _leave(" = %p", server
);
237 _leave(" = NULL [nomem]");
242 * Look up an address record for a server
244 static struct afs_addr_list
*afs_vl_lookup_addrs(struct afs_cell
*cell
,
245 struct key
*key
, const uuid_t
*uuid
)
247 struct afs_addr_cursor ac
;
248 struct afs_addr_list
*alist
;
251 ret
= afs_set_vl_cursor(&ac
, cell
);
255 while (afs_iterate_addresses(&ac
)) {
256 if (test_bit(ac
.index
, &ac
.alist
->yfs
))
257 alist
= afs_yfsvl_get_endpoints(cell
->net
, &ac
, key
, uuid
);
259 alist
= afs_vl_get_addrs_u(cell
->net
, &ac
, key
, uuid
);
265 ac
.error
= afs_abort_to_error(ac
.abort_code
);
281 return ERR_PTR(afs_end_cursor(&ac
));
285 * Get or create a fileserver record.
287 struct afs_server
*afs_lookup_server(struct afs_cell
*cell
, struct key
*key
,
290 struct afs_addr_list
*alist
;
291 struct afs_server
*server
, *candidate
;
293 _enter("%p,%pU", cell
->net
, uuid
);
295 server
= afs_find_server_by_uuid(cell
->net
, uuid
);
299 alist
= afs_vl_lookup_addrs(cell
, key
, uuid
);
301 return ERR_CAST(alist
);
303 candidate
= afs_alloc_server(cell
->net
, uuid
, alist
);
305 afs_put_addrlist(alist
);
306 return ERR_PTR(-ENOMEM
);
309 server
= afs_install_server(cell
->net
, candidate
);
310 if (server
!= candidate
) {
311 afs_put_addrlist(alist
);
315 _leave(" = %p{%d}", server
, atomic_read(&server
->usage
));
320 * Set the server timer to fire after a given delay, assuming it's not already
321 * set for an earlier time.
323 static void afs_set_server_timer(struct afs_net
*net
, time64_t delay
)
326 afs_inc_servers_outstanding(net
);
327 if (timer_reduce(&net
->fs_timer
, jiffies
+ delay
* HZ
))
328 afs_dec_servers_outstanding(net
);
333 * Server management timer. We have an increment on fs_outstanding that we
334 * need to pass along to the work item.
336 void afs_servers_timer(struct timer_list
*timer
)
338 struct afs_net
*net
= container_of(timer
, struct afs_net
, fs_timer
);
341 if (!queue_work(afs_wq
, &net
->fs_manager
))
342 afs_dec_servers_outstanding(net
);
346 * Release a reference on a server record.
348 void afs_put_server(struct afs_net
*net
, struct afs_server
*server
)
355 server
->put_time
= ktime_get_real_seconds();
357 usage
= atomic_dec_return(&server
->usage
);
359 _enter("{%u}", usage
);
361 if (likely(usage
> 0))
364 afs_set_server_timer(net
, afs_server_gc_delay
);
367 static void afs_server_rcu(struct rcu_head
*rcu
)
369 struct afs_server
*server
= container_of(rcu
, struct afs_server
, rcu
);
371 afs_put_addrlist(server
->addresses
);
376 * destroy a dead server
378 static void afs_destroy_server(struct afs_net
*net
, struct afs_server
*server
)
380 struct afs_addr_list
*alist
= server
->addresses
;
381 struct afs_addr_cursor ac
= {
383 .addr
= &alist
->addrs
[0],
384 .start
= alist
->index
,
385 .index
= alist
->index
,
388 _enter("%p", server
);
390 afs_fs_give_up_all_callbacks(net
, server
, &ac
, NULL
);
391 call_rcu(&server
->rcu
, afs_server_rcu
);
392 afs_dec_servers_outstanding(net
);
396 * Garbage collect any expired servers.
398 static void afs_gc_servers(struct afs_net
*net
, struct afs_server
*gc_list
)
400 struct afs_server
*server
;
404 while ((server
= gc_list
)) {
405 gc_list
= server
->gc_next
;
407 write_seqlock(&net
->fs_lock
);
409 deleted
= atomic_try_cmpxchg(&server
->usage
, &usage
, 0);
411 rb_erase(&server
->uuid_rb
, &net
->fs_servers
);
412 hlist_del_rcu(&server
->proc_link
);
414 write_sequnlock(&net
->fs_lock
);
417 write_seqlock(&net
->fs_addr_lock
);
418 if (!hlist_unhashed(&server
->addr4_link
))
419 hlist_del_rcu(&server
->addr4_link
);
420 if (!hlist_unhashed(&server
->addr6_link
))
421 hlist_del_rcu(&server
->addr6_link
);
422 write_sequnlock(&net
->fs_addr_lock
);
423 afs_destroy_server(net
, server
);
429 * Manage the records of servers known to be within a network namespace. This
430 * includes garbage collecting unused servers.
432 * Note also that we were given an increment on net->servers_outstanding by
433 * whoever queued us that we need to deal with before returning.
435 void afs_manage_servers(struct work_struct
*work
)
437 struct afs_net
*net
= container_of(work
, struct afs_net
, fs_manager
);
438 struct afs_server
*gc_list
= NULL
;
439 struct rb_node
*cursor
;
440 time64_t now
= ktime_get_real_seconds(), next_manage
= TIME64_MAX
;
441 bool purging
= !net
->live
;
445 /* Trawl the server list looking for servers that have expired from
448 read_seqlock_excl(&net
->fs_lock
);
450 for (cursor
= rb_first(&net
->fs_servers
); cursor
; cursor
= rb_next(cursor
)) {
451 struct afs_server
*server
=
452 rb_entry(cursor
, struct afs_server
, uuid_rb
);
453 int usage
= atomic_read(&server
->usage
);
455 _debug("manage %pU %u", &server
->uuid
, usage
);
457 ASSERTCMP(usage
, >=, 1);
458 ASSERTIFCMP(purging
, usage
, ==, 1);
461 time64_t expire_at
= server
->put_time
;
463 if (!test_bit(AFS_SERVER_FL_VL_FAIL
, &server
->flags
) &&
464 !test_bit(AFS_SERVER_FL_NOT_FOUND
, &server
->flags
))
465 expire_at
+= afs_server_gc_delay
;
466 if (purging
|| expire_at
<= now
) {
467 server
->gc_next
= gc_list
;
469 } else if (expire_at
< next_manage
) {
470 next_manage
= expire_at
;
475 read_sequnlock_excl(&net
->fs_lock
);
477 /* Update the timer on the way out. We have to pass an increment on
478 * servers_outstanding in the namespace that we are in to the timer or
479 * the work scheduler.
481 if (!purging
&& next_manage
< TIME64_MAX
) {
482 now
= ktime_get_real_seconds();
484 if (next_manage
- now
<= 0) {
485 if (queue_work(afs_wq
, &net
->fs_manager
))
486 afs_inc_servers_outstanding(net
);
488 afs_set_server_timer(net
, next_manage
- now
);
492 afs_gc_servers(net
, gc_list
);
494 afs_dec_servers_outstanding(net
);
495 _leave(" [%d]", atomic_read(&net
->servers_outstanding
));
498 static void afs_queue_server_manager(struct afs_net
*net
)
500 afs_inc_servers_outstanding(net
);
501 if (!queue_work(afs_wq
, &net
->fs_manager
))
502 afs_dec_servers_outstanding(net
);
506 * Purge list of servers.
508 void afs_purge_servers(struct afs_net
*net
)
512 if (del_timer_sync(&net
->fs_timer
))
513 atomic_dec(&net
->servers_outstanding
);
515 afs_queue_server_manager(net
);
518 wait_on_atomic_t(&net
->servers_outstanding
, atomic_t_wait
,
519 TASK_UNINTERRUPTIBLE
);
524 * Probe a fileserver to find its capabilities.
526 * TODO: Try service upgrade.
528 static bool afs_do_probe_fileserver(struct afs_fs_cursor
*fc
)
533 fc
->ac
.start
= READ_ONCE(fc
->ac
.alist
->index
);
534 fc
->ac
.index
= fc
->ac
.start
;
536 fc
->ac
.begun
= false;
538 while (afs_iterate_addresses(&fc
->ac
)) {
539 afs_fs_get_capabilities(afs_v2net(fc
->vnode
), fc
->cbi
->server
,
541 switch (fc
->ac
.error
) {
543 afs_end_cursor(&fc
->ac
);
544 set_bit(AFS_SERVER_FL_PROBED
, &fc
->cbi
->server
->flags
);
547 fc
->ac
.error
= afs_abort_to_error(fc
->ac
.abort_code
);
565 afs_end_cursor(&fc
->ac
);
570 * If we haven't already, try probing the fileserver to get its capabilities.
571 * We try not to instigate parallel probes, but it's possible that the parallel
572 * probes will fail due to authentication failure when ours would succeed.
574 * TODO: Try sending an anonymous probe if an authenticated probe fails.
576 bool afs_probe_fileserver(struct afs_fs_cursor
*fc
)
579 int ret
, retries
= 0;
584 if (test_bit(AFS_SERVER_FL_PROBED
, &fc
->cbi
->server
->flags
)) {
589 if (!test_and_set_bit_lock(AFS_SERVER_FL_PROBING
, &fc
->cbi
->server
->flags
)) {
590 success
= afs_do_probe_fileserver(fc
);
591 clear_bit_unlock(AFS_SERVER_FL_PROBING
, &fc
->cbi
->server
->flags
);
592 wake_up_bit(&fc
->cbi
->server
->flags
, AFS_SERVER_FL_PROBING
);
598 ret
= wait_on_bit(&fc
->cbi
->server
->flags
, AFS_SERVER_FL_PROBING
,
600 if (ret
== -ERESTARTSYS
) {
602 _leave(" = f [%d]", ret
);
608 fc
->ac
.error
= -ESTALE
;
609 _leave(" = f [stale]");
617 * Get an update for a server's address list.
619 static noinline
bool afs_update_server_record(struct afs_fs_cursor
*fc
, struct afs_server
*server
)
621 struct afs_addr_list
*alist
, *discard
;
625 alist
= afs_vl_lookup_addrs(fc
->vnode
->volume
->cell
, fc
->key
,
628 fc
->ac
.error
= PTR_ERR(alist
);
629 _leave(" = f [%d]", fc
->ac
.error
);
634 if (server
->addr_version
!= alist
->version
) {
635 write_lock(&server
->fs_lock
);
636 discard
= rcu_dereference_protected(server
->addresses
,
637 lockdep_is_held(&server
->fs_lock
));
638 rcu_assign_pointer(server
->addresses
, alist
);
639 server
->addr_version
= alist
->version
;
640 write_unlock(&server
->fs_lock
);
643 server
->update_at
= ktime_get_real_seconds() + afs_server_update_delay
;
644 afs_put_addrlist(discard
);
650 * See if a server's address list needs updating.
652 bool afs_check_server_record(struct afs_fs_cursor
*fc
, struct afs_server
*server
)
654 time64_t now
= ktime_get_real_seconds();
657 int ret
, retries
= 0;
664 diff
= READ_ONCE(server
->update_at
) - now
;
666 _leave(" = t [not now %ld]", diff
);
670 if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING
, &server
->flags
)) {
671 success
= afs_update_server_record(fc
, server
);
672 clear_bit_unlock(AFS_SERVER_FL_UPDATING
, &server
->flags
);
673 wake_up_bit(&server
->flags
, AFS_SERVER_FL_UPDATING
);
674 _leave(" = %d", success
);
678 ret
= wait_on_bit(&server
->flags
, AFS_SERVER_FL_UPDATING
,
680 if (ret
== -ERESTARTSYS
) {
682 _leave(" = f [intr]");
688 _leave(" = f [stale]");