mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
502 lines
12 KiB
C
502 lines
12 KiB
C
/* server.c: AFS server record management
|
|
*
|
|
* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <rxrpc/peer.h>
|
|
#include <rxrpc/connection.h>
|
|
#include "volume.h"
|
|
#include "cell.h"
|
|
#include "server.h"
|
|
#include "transport.h"
|
|
#include "vlclient.h"
|
|
#include "kafstimod.h"
|
|
#include "internal.h"
|
|
|
|
DEFINE_SPINLOCK(afs_server_peer_lock);
|
|
|
|
#define FS_SERVICE_ID 1 /* AFS Volume Location Service ID */
|
|
#define VL_SERVICE_ID 52 /* AFS Volume Location Service ID */
|
|
|
|
static void __afs_server_timeout(struct afs_timer *timer)
|
|
{
|
|
struct afs_server *server =
|
|
list_entry(timer, struct afs_server, timeout);
|
|
|
|
_debug("SERVER TIMEOUT [%p{u=%d}]",
|
|
server, atomic_read(&server->usage));
|
|
|
|
afs_server_do_timeout(server);
|
|
}
|
|
|
|
static const struct afs_timer_ops afs_server_timer_ops = {
|
|
.timed_out = __afs_server_timeout,
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* lookup a server record in a cell
|
|
* - TODO: search the cell's server list
|
|
*/
|
|
int afs_server_lookup(struct afs_cell *cell, const struct in_addr *addr,
|
|
struct afs_server **_server)
|
|
{
|
|
struct afs_server *server, *active, *zombie;
|
|
int loop;
|
|
|
|
_enter("%p,%08x,", cell, ntohl(addr->s_addr));
|
|
|
|
/* allocate and initialise a server record */
|
|
server = kmalloc(sizeof(struct afs_server), GFP_KERNEL);
|
|
if (!server) {
|
|
_leave(" = -ENOMEM");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memset(server, 0, sizeof(struct afs_server));
|
|
atomic_set(&server->usage, 1);
|
|
|
|
INIT_LIST_HEAD(&server->link);
|
|
init_rwsem(&server->sem);
|
|
INIT_LIST_HEAD(&server->fs_callq);
|
|
spin_lock_init(&server->fs_lock);
|
|
INIT_LIST_HEAD(&server->cb_promises);
|
|
spin_lock_init(&server->cb_lock);
|
|
|
|
for (loop = 0; loop < AFS_SERVER_CONN_LIST_SIZE; loop++)
|
|
server->fs_conn_cnt[loop] = 4;
|
|
|
|
memcpy(&server->addr, addr, sizeof(struct in_addr));
|
|
server->addr.s_addr = addr->s_addr;
|
|
|
|
afs_timer_init(&server->timeout, &afs_server_timer_ops);
|
|
|
|
/* add to the cell */
|
|
write_lock(&cell->sv_lock);
|
|
|
|
/* check the active list */
|
|
list_for_each_entry(active, &cell->sv_list, link) {
|
|
if (active->addr.s_addr == addr->s_addr)
|
|
goto use_active_server;
|
|
}
|
|
|
|
/* check the inactive list */
|
|
spin_lock(&cell->sv_gylock);
|
|
list_for_each_entry(zombie, &cell->sv_graveyard, link) {
|
|
if (zombie->addr.s_addr == addr->s_addr)
|
|
goto resurrect_server;
|
|
}
|
|
spin_unlock(&cell->sv_gylock);
|
|
|
|
afs_get_cell(cell);
|
|
server->cell = cell;
|
|
list_add_tail(&server->link, &cell->sv_list);
|
|
|
|
write_unlock(&cell->sv_lock);
|
|
|
|
*_server = server;
|
|
_leave(" = 0 (%p)", server);
|
|
return 0;
|
|
|
|
/* found a matching active server */
|
|
use_active_server:
|
|
_debug("active server");
|
|
afs_get_server(active);
|
|
write_unlock(&cell->sv_lock);
|
|
|
|
kfree(server);
|
|
|
|
*_server = active;
|
|
_leave(" = 0 (%p)", active);
|
|
return 0;
|
|
|
|
/* found a matching server in the graveyard, so resurrect it and
|
|
* dispose of the new record */
|
|
resurrect_server:
|
|
_debug("resurrecting server");
|
|
|
|
list_del(&zombie->link);
|
|
list_add_tail(&zombie->link, &cell->sv_list);
|
|
afs_get_server(zombie);
|
|
afs_kafstimod_del_timer(&zombie->timeout);
|
|
spin_unlock(&cell->sv_gylock);
|
|
write_unlock(&cell->sv_lock);
|
|
|
|
kfree(server);
|
|
|
|
*_server = zombie;
|
|
_leave(" = 0 (%p)", zombie);
|
|
return 0;
|
|
|
|
} /* end afs_server_lookup() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* destroy a server record
|
|
* - removes from the cell list
|
|
*/
|
|
void afs_put_server(struct afs_server *server)
|
|
{
|
|
struct afs_cell *cell;
|
|
|
|
if (!server)
|
|
return;
|
|
|
|
_enter("%p", server);
|
|
|
|
cell = server->cell;
|
|
|
|
/* sanity check */
|
|
BUG_ON(atomic_read(&server->usage) <= 0);
|
|
|
|
/* to prevent a race, the decrement and the dequeue must be effectively
|
|
* atomic */
|
|
write_lock(&cell->sv_lock);
|
|
|
|
if (likely(!atomic_dec_and_test(&server->usage))) {
|
|
write_unlock(&cell->sv_lock);
|
|
_leave("");
|
|
return;
|
|
}
|
|
|
|
spin_lock(&cell->sv_gylock);
|
|
list_del(&server->link);
|
|
list_add_tail(&server->link, &cell->sv_graveyard);
|
|
|
|
/* time out in 10 secs */
|
|
afs_kafstimod_add_timer(&server->timeout, 10 * HZ);
|
|
|
|
spin_unlock(&cell->sv_gylock);
|
|
write_unlock(&cell->sv_lock);
|
|
|
|
_leave(" [killed]");
|
|
} /* end afs_put_server() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* timeout server record
|
|
* - removes from the cell's graveyard if the usage count is zero
|
|
*/
|
|
void afs_server_do_timeout(struct afs_server *server)
|
|
{
|
|
struct rxrpc_peer *peer;
|
|
struct afs_cell *cell;
|
|
int loop;
|
|
|
|
_enter("%p", server);
|
|
|
|
cell = server->cell;
|
|
|
|
BUG_ON(atomic_read(&server->usage) < 0);
|
|
|
|
/* remove from graveyard if still dead */
|
|
spin_lock(&cell->vl_gylock);
|
|
if (atomic_read(&server->usage) == 0)
|
|
list_del_init(&server->link);
|
|
else
|
|
server = NULL;
|
|
spin_unlock(&cell->vl_gylock);
|
|
|
|
if (!server) {
|
|
_leave("");
|
|
return; /* resurrected */
|
|
}
|
|
|
|
/* we can now destroy it properly */
|
|
afs_put_cell(cell);
|
|
|
|
/* uncross-point the structs under a global lock */
|
|
spin_lock(&afs_server_peer_lock);
|
|
peer = server->peer;
|
|
if (peer) {
|
|
server->peer = NULL;
|
|
peer->user = NULL;
|
|
}
|
|
spin_unlock(&afs_server_peer_lock);
|
|
|
|
/* finish cleaning up the server */
|
|
for (loop = AFS_SERVER_CONN_LIST_SIZE - 1; loop >= 0; loop--)
|
|
if (server->fs_conn[loop])
|
|
rxrpc_put_connection(server->fs_conn[loop]);
|
|
|
|
if (server->vlserver)
|
|
rxrpc_put_connection(server->vlserver);
|
|
|
|
kfree(server);
|
|
|
|
_leave(" [destroyed]");
|
|
} /* end afs_server_do_timeout() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* get a callslot on a connection to the fileserver on the specified server
|
|
*/
|
|
int afs_server_request_callslot(struct afs_server *server,
|
|
struct afs_server_callslot *callslot)
|
|
{
|
|
struct afs_server_callslot *pcallslot;
|
|
struct rxrpc_connection *conn;
|
|
int nconn, ret;
|
|
|
|
_enter("%p,",server);
|
|
|
|
INIT_LIST_HEAD(&callslot->link);
|
|
callslot->task = current;
|
|
callslot->conn = NULL;
|
|
callslot->nconn = -1;
|
|
callslot->ready = 0;
|
|
|
|
ret = 0;
|
|
conn = NULL;
|
|
|
|
/* get hold of a callslot first */
|
|
spin_lock(&server->fs_lock);
|
|
|
|
/* resurrect the server if it's death timeout has expired */
|
|
if (server->fs_state) {
|
|
if (time_before(jiffies, server->fs_dead_jif)) {
|
|
ret = server->fs_state;
|
|
spin_unlock(&server->fs_lock);
|
|
_leave(" = %d [still dead]", ret);
|
|
return ret;
|
|
}
|
|
|
|
server->fs_state = 0;
|
|
}
|
|
|
|
/* try and find a connection that has spare callslots */
|
|
for (nconn = 0; nconn < AFS_SERVER_CONN_LIST_SIZE; nconn++) {
|
|
if (server->fs_conn_cnt[nconn] > 0) {
|
|
server->fs_conn_cnt[nconn]--;
|
|
spin_unlock(&server->fs_lock);
|
|
callslot->nconn = nconn;
|
|
goto obtained_slot;
|
|
}
|
|
}
|
|
|
|
/* none were available - wait interruptibly for one to become
|
|
* available */
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
list_add_tail(&callslot->link, &server->fs_callq);
|
|
spin_unlock(&server->fs_lock);
|
|
|
|
while (!callslot->ready && !signal_pending(current)) {
|
|
schedule();
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
}
|
|
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
/* even if we were interrupted we may still be queued */
|
|
if (!callslot->ready) {
|
|
spin_lock(&server->fs_lock);
|
|
list_del_init(&callslot->link);
|
|
spin_unlock(&server->fs_lock);
|
|
}
|
|
|
|
nconn = callslot->nconn;
|
|
|
|
/* if interrupted, we must release any slot we also got before
|
|
* returning an error */
|
|
if (signal_pending(current)) {
|
|
ret = -EINTR;
|
|
goto error_release;
|
|
}
|
|
|
|
/* if we were woken up with an error, then pass that error back to the
|
|
* called */
|
|
if (nconn < 0) {
|
|
_leave(" = %d", callslot->errno);
|
|
return callslot->errno;
|
|
}
|
|
|
|
/* were we given a connection directly? */
|
|
if (callslot->conn) {
|
|
/* yes - use it */
|
|
_leave(" = 0 (nc=%d)", nconn);
|
|
return 0;
|
|
}
|
|
|
|
/* got a callslot, but no connection */
|
|
obtained_slot:
|
|
|
|
/* need to get hold of the RxRPC connection */
|
|
down_write(&server->sem);
|
|
|
|
/* quick check to see if there's an outstanding error */
|
|
ret = server->fs_state;
|
|
if (ret)
|
|
goto error_release_upw;
|
|
|
|
if (server->fs_conn[nconn]) {
|
|
/* reuse an existing connection */
|
|
rxrpc_get_connection(server->fs_conn[nconn]);
|
|
callslot->conn = server->fs_conn[nconn];
|
|
}
|
|
else {
|
|
/* create a new connection */
|
|
ret = rxrpc_create_connection(afs_transport,
|
|
htons(7000),
|
|
server->addr.s_addr,
|
|
FS_SERVICE_ID,
|
|
NULL,
|
|
&server->fs_conn[nconn]);
|
|
|
|
if (ret < 0)
|
|
goto error_release_upw;
|
|
|
|
callslot->conn = server->fs_conn[0];
|
|
rxrpc_get_connection(callslot->conn);
|
|
}
|
|
|
|
up_write(&server->sem);
|
|
|
|
_leave(" = 0");
|
|
return 0;
|
|
|
|
/* handle an error occurring */
|
|
error_release_upw:
|
|
up_write(&server->sem);
|
|
|
|
error_release:
|
|
/* either release the callslot or pass it along to another deserving
|
|
* task */
|
|
spin_lock(&server->fs_lock);
|
|
|
|
if (nconn < 0) {
|
|
/* no callslot allocated */
|
|
}
|
|
else if (list_empty(&server->fs_callq)) {
|
|
/* no one waiting */
|
|
server->fs_conn_cnt[nconn]++;
|
|
spin_unlock(&server->fs_lock);
|
|
}
|
|
else {
|
|
/* someone's waiting - dequeue them and wake them up */
|
|
pcallslot = list_entry(server->fs_callq.next,
|
|
struct afs_server_callslot, link);
|
|
list_del_init(&pcallslot->link);
|
|
|
|
pcallslot->errno = server->fs_state;
|
|
if (!pcallslot->errno) {
|
|
/* pass them out callslot details */
|
|
callslot->conn = xchg(&pcallslot->conn,
|
|
callslot->conn);
|
|
pcallslot->nconn = nconn;
|
|
callslot->nconn = nconn = -1;
|
|
}
|
|
pcallslot->ready = 1;
|
|
wake_up_process(pcallslot->task);
|
|
spin_unlock(&server->fs_lock);
|
|
}
|
|
|
|
rxrpc_put_connection(callslot->conn);
|
|
callslot->conn = NULL;
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
|
|
} /* end afs_server_request_callslot() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* release a callslot back to the server
|
|
* - transfers the RxRPC connection to the next pending callslot if possible
|
|
*/
|
|
void afs_server_release_callslot(struct afs_server *server,
|
|
struct afs_server_callslot *callslot)
|
|
{
|
|
struct afs_server_callslot *pcallslot;
|
|
|
|
_enter("{ad=%08x,cnt=%u},{%d}",
|
|
ntohl(server->addr.s_addr),
|
|
server->fs_conn_cnt[callslot->nconn],
|
|
callslot->nconn);
|
|
|
|
BUG_ON(callslot->nconn < 0);
|
|
|
|
spin_lock(&server->fs_lock);
|
|
|
|
if (list_empty(&server->fs_callq)) {
|
|
/* no one waiting */
|
|
server->fs_conn_cnt[callslot->nconn]++;
|
|
spin_unlock(&server->fs_lock);
|
|
}
|
|
else {
|
|
/* someone's waiting - dequeue them and wake them up */
|
|
pcallslot = list_entry(server->fs_callq.next,
|
|
struct afs_server_callslot, link);
|
|
list_del_init(&pcallslot->link);
|
|
|
|
pcallslot->errno = server->fs_state;
|
|
if (!pcallslot->errno) {
|
|
/* pass them out callslot details */
|
|
callslot->conn = xchg(&pcallslot->conn, callslot->conn);
|
|
pcallslot->nconn = callslot->nconn;
|
|
callslot->nconn = -1;
|
|
}
|
|
|
|
pcallslot->ready = 1;
|
|
wake_up_process(pcallslot->task);
|
|
spin_unlock(&server->fs_lock);
|
|
}
|
|
|
|
rxrpc_put_connection(callslot->conn);
|
|
|
|
_leave("");
|
|
} /* end afs_server_release_callslot() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* get a handle to a connection to the vlserver (volume location) on the
|
|
* specified server
|
|
*/
|
|
int afs_server_get_vlconn(struct afs_server *server,
|
|
struct rxrpc_connection **_conn)
|
|
{
|
|
struct rxrpc_connection *conn;
|
|
int ret;
|
|
|
|
_enter("%p,", server);
|
|
|
|
ret = 0;
|
|
conn = NULL;
|
|
down_read(&server->sem);
|
|
|
|
if (server->vlserver) {
|
|
/* reuse an existing connection */
|
|
rxrpc_get_connection(server->vlserver);
|
|
conn = server->vlserver;
|
|
up_read(&server->sem);
|
|
}
|
|
else {
|
|
/* create a new connection */
|
|
up_read(&server->sem);
|
|
down_write(&server->sem);
|
|
if (!server->vlserver) {
|
|
ret = rxrpc_create_connection(afs_transport,
|
|
htons(7003),
|
|
server->addr.s_addr,
|
|
VL_SERVICE_ID,
|
|
NULL,
|
|
&server->vlserver);
|
|
}
|
|
if (ret == 0) {
|
|
rxrpc_get_connection(server->vlserver);
|
|
conn = server->vlserver;
|
|
}
|
|
up_write(&server->sem);
|
|
}
|
|
|
|
*_conn = conn;
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
} /* end afs_server_get_vlconn() */
|