Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632// SPDX-License-Identifier: GPL-2.0-or-later/* AFS server record management * * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) */
#include <linux/sched.h>#include <linux/slab.h>#include "afs_fs.h"#include "internal.h"#include "protocol_yfs.h"
static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */static atomic_t afs_server_debug_id;
static void __afs_put_server(struct afs_net *, struct afs_server *);static void afs_server_timer(struct timer_list *timer);static void afs_server_destroyer(struct work_struct *work);
/* * Find a server by one of its addresses. */struct afs_server *afs_find_server(const struct rxrpc_peer *peer){ struct afs_server *server = (struct afs_server *)rxrpc_kernel_get_peer_data(peer);
if (!server) return NULL; return afs_use_server(server, false, afs_server_trace_use_cm_call);}
/* * Look up a server by its UUID and mark it active. The caller must hold * cell->fs_lock. */static struct afs_server *afs_find_server_by_uuid(struct afs_cell *cell, const uuid_t *uuid){ struct afs_server *server; struct rb_node *p; int diff;
_enter("%pU", uuid);
p = cell->fs_servers.rb_node; while (p) { server = rb_entry(p, struct afs_server, uuid_rb);
diff = memcmp(uuid, &server->uuid, sizeof(*uuid)); if (diff < 0) { p = p->rb_left; } else if (diff > 0) { p = p->rb_right; } else { if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) return NULL; /* Need a write lock */ afs_use_server(server, true, afs_server_trace_use_by_uuid); return server; } }
return NULL;}
/* * Install a server record in the cell tree. The caller must hold an exclusive * lock on cell->fs_lock. */static struct afs_server *afs_install_server(struct afs_cell *cell, struct afs_server **candidate){ struct afs_server *server; struct afs_net *net = cell->net; struct rb_node **pp, *p; int diff;
_enter("%p", candidate);
/* Firstly install the server in the UUID lookup tree */ pp = &cell->fs_servers.rb_node; p = NULL; while (*pp) { p = *pp; _debug("- consider %p", p); server = rb_entry(p, struct afs_server, uuid_rb); diff = memcmp(&(*candidate)->uuid, &server->uuid, sizeof(uuid_t)); if (diff < 0) pp = &(*pp)->rb_left; else if (diff > 0) pp = &(*pp)->rb_right; else goto exists; }
server = *candidate; *candidate = NULL; rb_link_node(&server->uuid_rb, p, pp); rb_insert_color(&server->uuid_rb, &cell->fs_servers); write_seqlock(&net->fs_lock); hlist_add_head_rcu(&server->proc_link, &net->fs_proc); write_sequnlock(&net->fs_lock);
afs_get_cell(cell, afs_cell_trace_get_server);
exists: afs_use_server(server, true, afs_server_trace_use_install); return server;}
/* * Allocate a new server record and mark it as active but uncreated. */static struct afs_server *afs_alloc_server(struct afs_cell *cell, const uuid_t *uuid){ struct afs_server *server; struct afs_net *net = cell->net;
_enter("");
server = kzalloc_obj(struct afs_server); if (!server) return NULL;
refcount_set(&server->ref, 1); atomic_set(&server->active, 0); __set_bit(AFS_SERVER_FL_UNCREATED, &server->flags); server->debug_id = atomic_inc_return(&afs_server_debug_id); server->uuid = *uuid; rwlock_init(&server->fs_lock); INIT_WORK(&server->destroyer, &afs_server_destroyer); timer_setup(&server->timer, afs_server_timer, 0); INIT_LIST_HEAD(&server->volumes); init_waitqueue_head(&server->probe_wq); mutex_init(&server->cm_token_lock); INIT_LIST_HEAD(&server->probe_link); INIT_HLIST_NODE(&server->proc_link); spin_lock_init(&server->probe_lock); server->cell = cell; server->rtt = UINT_MAX; server->service_id = FS_SERVICE; server->probe_counter = 1; server->probed_at = jiffies - LONG_MAX / 2;
afs_inc_servers_outstanding(net); _leave(" = %p", server); return server;}
/* * Look up an address record for a server */static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_server *server, struct key *key){ struct afs_vl_cursor vc; struct afs_addr_list *alist = NULL; int ret;
ret = -ERESTARTSYS; if (afs_begin_vlserver_operation(&vc, server->cell, key)) { while (afs_select_vlserver(&vc)) { if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) alist = afs_yfsvl_get_endpoints(&vc, &server->uuid); else alist = afs_vl_get_addrs_u(&vc, &server->uuid); }
ret = afs_end_vlserver_operation(&vc); }
return ret < 0 ? ERR_PTR(ret) : alist;}
/* * Get or create a fileserver record and return it with an active-use count on * it. */struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key, const uuid_t *uuid, u32 addr_version){ struct afs_addr_list *alist = NULL; struct afs_server *server, *candidate = NULL; bool creating = false; int ret;
_enter("%p,%pU", cell->net, uuid);
down_read(&cell->fs_lock); server = afs_find_server_by_uuid(cell, uuid); /* Won't see servers marked uncreated. */ up_read(&cell->fs_lock);
if (server) { timer_delete_sync(&server->timer); if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) goto wait_for_creation; if (server->addr_version != addr_version) set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags); return server; }
candidate = afs_alloc_server(cell, uuid); if (!candidate) { afs_put_addrlist(alist, afs_alist_trace_put_server_oom); return ERR_PTR(-ENOMEM); }
down_write(&cell->fs_lock); server = afs_install_server(cell, &candidate); if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) { /* We need to wait for creation to complete. */ up_write(&cell->fs_lock); goto wait_for_creation; } if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) { set_bit(AFS_SERVER_FL_CREATING, &server->flags); clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags); creating = true; } up_write(&cell->fs_lock); timer_delete_sync(&server->timer);
/* If we get to create the server, we look up the addresses and then * immediately dispatch an asynchronous probe to each interface on the * fileserver. This will make sure the repeat-probing service is * started. */ if (creating) { alist = afs_vl_lookup_addrs(server, key); if (IS_ERR(alist)) { ret = PTR_ERR(alist); goto create_failed; }
ret = afs_fs_probe_fileserver(cell->net, server, alist, key); if (ret) goto create_failed;
clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags); }
out: afs_put_addrlist(alist, afs_alist_trace_put_server_create); if (candidate) { kfree(rcu_access_pointer(server->endpoint_state)); kfree(candidate); afs_dec_servers_outstanding(cell->net); } return server ?: ERR_PTR(ret);
wait_for_creation: afs_see_server(server, afs_server_trace_wait_create); wait_on_bit(&server->flags, AFS_SERVER_FL_CREATING, TASK_UNINTERRUPTIBLE); if (test_bit_acquire(AFS_SERVER_FL_UNCREATED, &server->flags)) { /* Barrier: read flag before error */ ret = READ_ONCE(server->create_error); afs_put_server(cell->net, server, afs_server_trace_unuse_create_fail); server = NULL; goto out; }
ret = 0; goto out;
create_failed: down_write(&cell->fs_lock);
WRITE_ONCE(server->create_error, ret); smp_wmb(); /* Barrier: set error before flag. */ set_bit(AFS_SERVER_FL_UNCREATED, &server->flags);
clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags);
if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) { clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags); creating = true; } afs_unuse_server(cell->net, server, afs_server_trace_unuse_create_fail); server = NULL;
up_write(&cell->fs_lock); goto out;}
/* * Set/reduce a server's timer. */static void afs_set_server_timer(struct afs_server *server, unsigned int delay_secs){ mod_timer(&server->timer, jiffies + delay_secs * HZ);}
/* * Get a reference on a server object. */struct afs_server *afs_get_server(struct afs_server *server, enum afs_server_trace reason){ unsigned int a; int r;
__refcount_inc(&server->ref, &r); a = atomic_read(&server->active); trace_afs_server(server->debug_id, r + 1, a, reason); return server;}
/* * Get an active count on a server object and maybe remove from the inactive * list. */struct afs_server *afs_use_server(struct afs_server *server, bool activate, enum afs_server_trace reason){ unsigned int a; int r;
__refcount_inc(&server->ref, &r); a = atomic_inc_return(&server->active); if (a == 1 && activate && !test_bit(AFS_SERVER_FL_EXPIRED, &server->flags)) timer_delete(&server->timer);
trace_afs_server(server->debug_id, r + 1, a, reason); return server;}
/* * Release a reference on a server record. */void afs_put_server(struct afs_net *net, struct afs_server *server, enum afs_server_trace reason){ unsigned int a, debug_id; bool zero; int r;
if (!server) return;
debug_id = server->debug_id; a = atomic_read(&server->active); zero = __refcount_dec_and_test(&server->ref, &r); trace_afs_server(debug_id, r - 1, a, reason); if (unlikely(zero)) __afs_put_server(net, server);}
/* * Drop an active count on a server object without updating the last-unused * time. */void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server, enum afs_server_trace reason){ if (!server) return;
if (atomic_dec_and_test(&server->active)) { if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) || READ_ONCE(server->cell->state) >= AFS_CELL_REMOVING) schedule_work(&server->destroyer); }
afs_put_server(net, server, reason);}
/* * Drop an active count on a server object. */void afs_unuse_server(struct afs_net *net, struct afs_server *server, enum afs_server_trace reason){ if (!server) return;
if (atomic_dec_and_test(&server->active)) { if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) && READ_ONCE(server->cell->state) < AFS_CELL_REMOVING) { time64_t unuse_time = ktime_get_real_seconds();
server->unuse_time = unuse_time; afs_set_server_timer(server, afs_server_gc_delay); } else { schedule_work(&server->destroyer); } }
afs_put_server(net, server, reason);}
static void afs_server_rcu(struct rcu_head *rcu){ struct afs_server *server = container_of(rcu, struct afs_server, rcu);
trace_afs_server(server->debug_id, refcount_read(&server->ref), atomic_read(&server->active), afs_server_trace_free); afs_put_endpoint_state(rcu_access_pointer(server->endpoint_state), afs_estate_trace_put_server); afs_put_cell(server->cell, afs_cell_trace_put_server); kfree(server->cm_rxgk_appdata.data); kfree(server);}
static void __afs_put_server(struct afs_net *net, struct afs_server *server){ call_rcu(&server->rcu, afs_server_rcu); afs_dec_servers_outstanding(net);}
static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server){ struct afs_endpoint_state *estate = rcu_access_pointer(server->endpoint_state); struct afs_addr_list *alist = estate->addresses;
afs_fs_give_up_all_callbacks(net, server, &alist->addrs[alist->preferred], NULL);}
/* * Check to see if the server record has expired. */static bool afs_has_server_expired(const struct afs_server *server){ time64_t expires_at;
if (atomic_read(&server->active)) return false;
if (server->cell->net->live || server->cell->state >= AFS_CELL_REMOVING) { trace_afs_server(server->debug_id, refcount_read(&server->ref), 0, afs_server_trace_purging); return true; }
expires_at = server->unuse_time; if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) && !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags)) expires_at += afs_server_gc_delay;
return ktime_get_real_seconds() > expires_at;}
/* * Remove a server record from it's parent cell's database. */static bool afs_remove_server_from_cell(struct afs_server *server){ struct afs_cell *cell = server->cell;
down_write(&cell->fs_lock);
if (!afs_has_server_expired(server)) { up_write(&cell->fs_lock); return false; }
set_bit(AFS_SERVER_FL_EXPIRED, &server->flags); _debug("expire %pU %u", &server->uuid, atomic_read(&server->active)); afs_see_server(server, afs_server_trace_see_expired); rb_erase(&server->uuid_rb, &cell->fs_servers); up_write(&cell->fs_lock); return true;}
static void afs_server_destroyer(struct work_struct *work){ struct afs_endpoint_state *estate; struct afs_server *server = container_of(work, struct afs_server, destroyer); struct afs_net *net = server->cell->net;
afs_see_server(server, afs_server_trace_see_destroyer);
if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags)) return;
if (!afs_remove_server_from_cell(server)) return;
timer_shutdown_sync(&server->timer); cancel_work(&server->destroyer);
if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags)) afs_give_up_callbacks(net, server);
/* Unbind the rxrpc_peer records from the server. */ estate = rcu_access_pointer(server->endpoint_state); if (estate) afs_set_peer_appdata(server, estate->addresses, NULL);
write_seqlock(&net->fs_lock); list_del_init(&server->probe_link); if (!hlist_unhashed(&server->proc_link)) hlist_del_rcu(&server->proc_link); write_sequnlock(&net->fs_lock);
afs_put_server(net, server, afs_server_trace_destroy);}
static void afs_server_timer(struct timer_list *timer){ struct afs_server *server = container_of(timer, struct afs_server, timer);
afs_see_server(server, afs_server_trace_see_timer); if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags)) schedule_work(&server->destroyer);}
/* * Wake up all the servers in a cell so that they can purge themselves. */void afs_purge_servers(struct afs_cell *cell){ struct afs_server *server; struct rb_node *rb;
down_read(&cell->fs_lock); for (rb = rb_first(&cell->fs_servers); rb; rb = rb_next(rb)) { server = rb_entry(rb, struct afs_server, uuid_rb); afs_see_server(server, afs_server_trace_see_purge); schedule_work(&server->destroyer); } up_read(&cell->fs_lock);}
/* * Wait for outstanding servers. */void afs_wait_for_servers(struct afs_net *net){ _enter("");
atomic_dec(&net->servers_outstanding); wait_var_event(&net->servers_outstanding, !atomic_read(&net->servers_outstanding)); _leave("");}
/* * Get an update for a server's address list. */static noinline bool afs_update_server_record(struct afs_operation *op, struct afs_server *server, struct key *key){ struct afs_endpoint_state *estate; struct afs_addr_list *alist; bool has_addrs;
_enter("");
trace_afs_server(server->debug_id, refcount_read(&server->ref), atomic_read(&server->active), afs_server_trace_update);
alist = afs_vl_lookup_addrs(server, op->key); if (IS_ERR(alist)) { rcu_read_lock(); estate = rcu_dereference(server->endpoint_state); has_addrs = estate->addresses; rcu_read_unlock();
if ((PTR_ERR(alist) == -ERESTARTSYS || PTR_ERR(alist) == -EINTR) && (op->flags & AFS_OPERATION_UNINTR) && has_addrs) { _leave(" = t [intr]"); return true; } afs_op_set_error(op, PTR_ERR(alist)); _leave(" = f [%d]", afs_op_error(op)); return false; }
if (server->addr_version != alist->version) afs_fs_probe_fileserver(op->net, server, alist, key);
afs_put_addrlist(alist, afs_alist_trace_put_server_update); _leave(" = t"); return true;}
/* * See if a server's address list needs updating. */bool afs_check_server_record(struct afs_operation *op, struct afs_server *server, struct key *key){ bool success; int ret, retries = 0;
_enter("");
ASSERT(server);
retry: if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags)) goto wait; if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags)) goto update; _leave(" = t [good]"); return true;
update: if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) { clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags); success = afs_update_server_record(op, server, key); clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags); wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING); _leave(" = %d", success); return success; }
wait: ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING, (op->flags & AFS_OPERATION_UNINTR) ? TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE); if (ret == -ERESTARTSYS) { afs_op_set_error(op, ret); _leave(" = f [intr]"); return false; }
retries++; if (retries == 4) { _leave(" = f [stale]"); ret = -ESTALE; return false; } goto retry;}