mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-29 23:53:32 +00:00
94d30ae90a
Provide the ability to enable and disable fscache cookies. A disabled cookie will reject or ignore further requests to: Acquire a child cookie Invalidate and update backing objects Check the consistency of a backing object Allocate storage for backing page Read backing pages Write to backing pages but still allows: Checks/waits on the completion of already in-progress objects Uncaching of pages Relinquishment of cookies Two new operations are provided: (1) Disable a cookie: void fscache_disable_cookie(struct fscache_cookie *cookie, bool invalidate); If the cookie is not already disabled, this locks the cookie against other dis/enablement ops, marks the cookie as being disabled, discards or invalidates any backing objects and waits for cessation of activity on any associated object. This is a wrapper around a chunk split out of fscache_relinquish_cookie(), but it reinitialises the cookie such that it can be reenabled. All possible failures are handled internally. The caller should consider calling fscache_uncache_all_inode_pages() afterwards to make sure all page markings are cleared up. (2) Enable a cookie: void fscache_enable_cookie(struct fscache_cookie *cookie, bool (*can_enable)(void *data), void *data) If the cookie is not already enabled, this locks the cookie against other dis/enablement ops, invokes can_enable() and, if the cookie is not an index cookie, will begin the procedure of acquiring backing objects. The optional can_enable() function is passed the data argument and returns a ruling as to whether or not enablement should actually be permitted to begin. All possible failures are handled internally. The cookie will only be marked as enabled if provisional backing objects are allocated. A later patch will introduce these to NFS. Cookie enablement during nfs_open() is then contingent on i_writecount <= 0. can_enable() checks for a race between open(O_RDONLY) and open(O_WRONLY/O_RDWR). This simplifies NFS's cookie handling and allows us to get rid of open(O_RDONLY) accidentally introducing caching to an inode that's open for writing already. One operation has its API modified: (3) Acquire a cookie. struct fscache_cookie *fscache_acquire_cookie( struct fscache_cookie *parent, const struct fscache_cookie_def *def, void *netfs_data, bool enable); This now has an additional argument that indicates whether the requested cookie should be enabled by default. It doesn't need the can_enable() function because the caller must prevent multiple calls for the same netfs object and it doesn't need to take the enablement lock because no one else can get at the cookie before this returns. Signed-off-by: David Howells <dhowells@redhat.com
719 lines
18 KiB
C
719 lines
18 KiB
C
/* AFS volume location management
|
|
*
|
|
* Copyright (C) 2002, 2007 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/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/init.h>
|
|
#include <linux/sched.h>
|
|
#include "internal.h"
|
|
|
|
static unsigned afs_vlocation_timeout = 10; /* volume location timeout in seconds */
|
|
static unsigned afs_vlocation_update_timeout = 10 * 60;
|
|
|
|
static void afs_vlocation_reaper(struct work_struct *);
|
|
static void afs_vlocation_updater(struct work_struct *);
|
|
|
|
static LIST_HEAD(afs_vlocation_updates);
|
|
static LIST_HEAD(afs_vlocation_graveyard);
|
|
static DEFINE_SPINLOCK(afs_vlocation_updates_lock);
|
|
static DEFINE_SPINLOCK(afs_vlocation_graveyard_lock);
|
|
static DECLARE_DELAYED_WORK(afs_vlocation_reap, afs_vlocation_reaper);
|
|
static DECLARE_DELAYED_WORK(afs_vlocation_update, afs_vlocation_updater);
|
|
static struct workqueue_struct *afs_vlocation_update_worker;
|
|
|
|
/*
|
|
* iterate through the VL servers in a cell until one of them admits knowing
|
|
* about the volume in question
|
|
*/
|
|
static int afs_vlocation_access_vl_by_name(struct afs_vlocation *vl,
|
|
struct key *key,
|
|
struct afs_cache_vlocation *vldb)
|
|
{
|
|
struct afs_cell *cell = vl->cell;
|
|
struct in_addr addr;
|
|
int count, ret;
|
|
|
|
_enter("%s,%s", cell->name, vl->vldb.name);
|
|
|
|
down_write(&vl->cell->vl_sem);
|
|
ret = -ENOMEDIUM;
|
|
for (count = cell->vl_naddrs; count > 0; count--) {
|
|
addr = cell->vl_addrs[cell->vl_curr_svix];
|
|
|
|
_debug("CellServ[%hu]: %08x", cell->vl_curr_svix, addr.s_addr);
|
|
|
|
/* attempt to access the VL server */
|
|
ret = afs_vl_get_entry_by_name(&addr, key, vl->vldb.name, vldb,
|
|
&afs_sync_call);
|
|
switch (ret) {
|
|
case 0:
|
|
goto out;
|
|
case -ENOMEM:
|
|
case -ENONET:
|
|
case -ENETUNREACH:
|
|
case -EHOSTUNREACH:
|
|
case -ECONNREFUSED:
|
|
if (ret == -ENOMEM || ret == -ENONET)
|
|
goto out;
|
|
goto rotate;
|
|
case -ENOMEDIUM:
|
|
case -EKEYREJECTED:
|
|
case -EKEYEXPIRED:
|
|
goto out;
|
|
default:
|
|
ret = -EIO;
|
|
goto rotate;
|
|
}
|
|
|
|
/* rotate the server records upon lookup failure */
|
|
rotate:
|
|
cell->vl_curr_svix++;
|
|
cell->vl_curr_svix %= cell->vl_naddrs;
|
|
}
|
|
|
|
out:
|
|
up_write(&vl->cell->vl_sem);
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* iterate through the VL servers in a cell until one of them admits knowing
|
|
* about the volume in question
|
|
*/
|
|
static int afs_vlocation_access_vl_by_id(struct afs_vlocation *vl,
|
|
struct key *key,
|
|
afs_volid_t volid,
|
|
afs_voltype_t voltype,
|
|
struct afs_cache_vlocation *vldb)
|
|
{
|
|
struct afs_cell *cell = vl->cell;
|
|
struct in_addr addr;
|
|
int count, ret;
|
|
|
|
_enter("%s,%x,%d,", cell->name, volid, voltype);
|
|
|
|
down_write(&vl->cell->vl_sem);
|
|
ret = -ENOMEDIUM;
|
|
for (count = cell->vl_naddrs; count > 0; count--) {
|
|
addr = cell->vl_addrs[cell->vl_curr_svix];
|
|
|
|
_debug("CellServ[%hu]: %08x", cell->vl_curr_svix, addr.s_addr);
|
|
|
|
/* attempt to access the VL server */
|
|
ret = afs_vl_get_entry_by_id(&addr, key, volid, voltype, vldb,
|
|
&afs_sync_call);
|
|
switch (ret) {
|
|
case 0:
|
|
goto out;
|
|
case -ENOMEM:
|
|
case -ENONET:
|
|
case -ENETUNREACH:
|
|
case -EHOSTUNREACH:
|
|
case -ECONNREFUSED:
|
|
if (ret == -ENOMEM || ret == -ENONET)
|
|
goto out;
|
|
goto rotate;
|
|
case -EBUSY:
|
|
vl->upd_busy_cnt++;
|
|
if (vl->upd_busy_cnt <= 3) {
|
|
if (vl->upd_busy_cnt > 1) {
|
|
/* second+ BUSY - sleep a little bit */
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
schedule_timeout(1);
|
|
__set_current_state(TASK_RUNNING);
|
|
}
|
|
continue;
|
|
}
|
|
break;
|
|
case -ENOMEDIUM:
|
|
vl->upd_rej_cnt++;
|
|
goto rotate;
|
|
default:
|
|
ret = -EIO;
|
|
goto rotate;
|
|
}
|
|
|
|
/* rotate the server records upon lookup failure */
|
|
rotate:
|
|
cell->vl_curr_svix++;
|
|
cell->vl_curr_svix %= cell->vl_naddrs;
|
|
vl->upd_busy_cnt = 0;
|
|
}
|
|
|
|
out:
|
|
if (ret < 0 && vl->upd_rej_cnt > 0) {
|
|
printk(KERN_NOTICE "kAFS:"
|
|
" Active volume no longer valid '%s'\n",
|
|
vl->vldb.name);
|
|
vl->valid = 0;
|
|
ret = -ENOMEDIUM;
|
|
}
|
|
|
|
up_write(&vl->cell->vl_sem);
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* allocate a volume location record
|
|
*/
|
|
static struct afs_vlocation *afs_vlocation_alloc(struct afs_cell *cell,
|
|
const char *name,
|
|
size_t namesz)
|
|
{
|
|
struct afs_vlocation *vl;
|
|
|
|
vl = kzalloc(sizeof(struct afs_vlocation), GFP_KERNEL);
|
|
if (vl) {
|
|
vl->cell = cell;
|
|
vl->state = AFS_VL_NEW;
|
|
atomic_set(&vl->usage, 1);
|
|
INIT_LIST_HEAD(&vl->link);
|
|
INIT_LIST_HEAD(&vl->grave);
|
|
INIT_LIST_HEAD(&vl->update);
|
|
init_waitqueue_head(&vl->waitq);
|
|
spin_lock_init(&vl->lock);
|
|
memcpy(vl->vldb.name, name, namesz);
|
|
}
|
|
|
|
_leave(" = %p", vl);
|
|
return vl;
|
|
}
|
|
|
|
/*
|
|
* update record if we found it in the cache
|
|
*/
|
|
static int afs_vlocation_update_record(struct afs_vlocation *vl,
|
|
struct key *key,
|
|
struct afs_cache_vlocation *vldb)
|
|
{
|
|
afs_voltype_t voltype;
|
|
afs_volid_t vid;
|
|
int ret;
|
|
|
|
/* try to look up a cached volume in the cell VL databases by ID */
|
|
_debug("Locally Cached: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
|
|
vl->vldb.name,
|
|
vl->vldb.vidmask,
|
|
ntohl(vl->vldb.servers[0].s_addr),
|
|
vl->vldb.srvtmask[0],
|
|
ntohl(vl->vldb.servers[1].s_addr),
|
|
vl->vldb.srvtmask[1],
|
|
ntohl(vl->vldb.servers[2].s_addr),
|
|
vl->vldb.srvtmask[2]);
|
|
|
|
_debug("Vids: %08x %08x %08x",
|
|
vl->vldb.vid[0],
|
|
vl->vldb.vid[1],
|
|
vl->vldb.vid[2]);
|
|
|
|
if (vl->vldb.vidmask & AFS_VOL_VTM_RW) {
|
|
vid = vl->vldb.vid[0];
|
|
voltype = AFSVL_RWVOL;
|
|
} else if (vl->vldb.vidmask & AFS_VOL_VTM_RO) {
|
|
vid = vl->vldb.vid[1];
|
|
voltype = AFSVL_ROVOL;
|
|
} else if (vl->vldb.vidmask & AFS_VOL_VTM_BAK) {
|
|
vid = vl->vldb.vid[2];
|
|
voltype = AFSVL_BACKVOL;
|
|
} else {
|
|
BUG();
|
|
vid = 0;
|
|
voltype = 0;
|
|
}
|
|
|
|
/* contact the server to make sure the volume is still available
|
|
* - TODO: need to handle disconnected operation here
|
|
*/
|
|
ret = afs_vlocation_access_vl_by_id(vl, key, vid, voltype, vldb);
|
|
switch (ret) {
|
|
/* net error */
|
|
default:
|
|
printk(KERN_WARNING "kAFS:"
|
|
" failed to update volume '%s' (%x) up in '%s': %d\n",
|
|
vl->vldb.name, vid, vl->cell->name, ret);
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
|
|
/* pulled from local cache into memory */
|
|
case 0:
|
|
_leave(" = 0");
|
|
return 0;
|
|
|
|
/* uh oh... looks like the volume got deleted */
|
|
case -ENOMEDIUM:
|
|
printk(KERN_ERR "kAFS:"
|
|
" volume '%s' (%x) does not exist '%s'\n",
|
|
vl->vldb.name, vid, vl->cell->name);
|
|
|
|
/* TODO: make existing record unavailable */
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* apply the update to a VL record
|
|
*/
|
|
static void afs_vlocation_apply_update(struct afs_vlocation *vl,
|
|
struct afs_cache_vlocation *vldb)
|
|
{
|
|
_debug("Done VL Lookup: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
|
|
vldb->name, vldb->vidmask,
|
|
ntohl(vldb->servers[0].s_addr), vldb->srvtmask[0],
|
|
ntohl(vldb->servers[1].s_addr), vldb->srvtmask[1],
|
|
ntohl(vldb->servers[2].s_addr), vldb->srvtmask[2]);
|
|
|
|
_debug("Vids: %08x %08x %08x",
|
|
vldb->vid[0], vldb->vid[1], vldb->vid[2]);
|
|
|
|
if (strcmp(vldb->name, vl->vldb.name) != 0)
|
|
printk(KERN_NOTICE "kAFS:"
|
|
" name of volume '%s' changed to '%s' on server\n",
|
|
vl->vldb.name, vldb->name);
|
|
|
|
vl->vldb = *vldb;
|
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
fscache_update_cookie(vl->cache);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* fill in a volume location record, consulting the cache and the VL server
|
|
* both
|
|
*/
|
|
static int afs_vlocation_fill_in_record(struct afs_vlocation *vl,
|
|
struct key *key)
|
|
{
|
|
struct afs_cache_vlocation vldb;
|
|
int ret;
|
|
|
|
_enter("");
|
|
|
|
ASSERTCMP(vl->valid, ==, 0);
|
|
|
|
memset(&vldb, 0, sizeof(vldb));
|
|
|
|
/* see if we have an in-cache copy (will set vl->valid if there is) */
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
vl->cache = fscache_acquire_cookie(vl->cell->cache,
|
|
&afs_vlocation_cache_index_def, vl,
|
|
true);
|
|
#endif
|
|
|
|
if (vl->valid) {
|
|
/* try to update a known volume in the cell VL databases by
|
|
* ID as the name may have changed */
|
|
_debug("found in cache");
|
|
ret = afs_vlocation_update_record(vl, key, &vldb);
|
|
} else {
|
|
/* try to look up an unknown volume in the cell VL databases by
|
|
* name */
|
|
ret = afs_vlocation_access_vl_by_name(vl, key, &vldb);
|
|
if (ret < 0) {
|
|
printk("kAFS: failed to locate '%s' in cell '%s'\n",
|
|
vl->vldb.name, vl->cell->name);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
afs_vlocation_apply_update(vl, &vldb);
|
|
_leave(" = 0");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* queue a vlocation record for updates
|
|
*/
|
|
static void afs_vlocation_queue_for_updates(struct afs_vlocation *vl)
|
|
{
|
|
struct afs_vlocation *xvl;
|
|
|
|
/* wait at least 10 minutes before updating... */
|
|
vl->update_at = get_seconds() + afs_vlocation_update_timeout;
|
|
|
|
spin_lock(&afs_vlocation_updates_lock);
|
|
|
|
if (!list_empty(&afs_vlocation_updates)) {
|
|
/* ... but wait at least 1 second more than the newest record
|
|
* already queued so that we don't spam the VL server suddenly
|
|
* with lots of requests
|
|
*/
|
|
xvl = list_entry(afs_vlocation_updates.prev,
|
|
struct afs_vlocation, update);
|
|
if (vl->update_at <= xvl->update_at)
|
|
vl->update_at = xvl->update_at + 1;
|
|
} else {
|
|
queue_delayed_work(afs_vlocation_update_worker,
|
|
&afs_vlocation_update,
|
|
afs_vlocation_update_timeout * HZ);
|
|
}
|
|
|
|
list_add_tail(&vl->update, &afs_vlocation_updates);
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
}
|
|
|
|
/*
|
|
* lookup volume location
|
|
* - iterate through the VL servers in a cell until one of them admits knowing
|
|
* about the volume in question
|
|
* - lookup in the local cache if not able to find on the VL server
|
|
* - insert/update in the local cache if did get a VL response
|
|
*/
|
|
struct afs_vlocation *afs_vlocation_lookup(struct afs_cell *cell,
|
|
struct key *key,
|
|
const char *name,
|
|
size_t namesz)
|
|
{
|
|
struct afs_vlocation *vl;
|
|
int ret;
|
|
|
|
_enter("{%s},{%x},%*.*s,%zu",
|
|
cell->name, key_serial(key),
|
|
(int) namesz, (int) namesz, name, namesz);
|
|
|
|
if (namesz >= sizeof(vl->vldb.name)) {
|
|
_leave(" = -ENAMETOOLONG");
|
|
return ERR_PTR(-ENAMETOOLONG);
|
|
}
|
|
|
|
/* see if we have an in-memory copy first */
|
|
down_write(&cell->vl_sem);
|
|
spin_lock(&cell->vl_lock);
|
|
list_for_each_entry(vl, &cell->vl_list, link) {
|
|
if (vl->vldb.name[namesz] != '\0')
|
|
continue;
|
|
if (memcmp(vl->vldb.name, name, namesz) == 0)
|
|
goto found_in_memory;
|
|
}
|
|
spin_unlock(&cell->vl_lock);
|
|
|
|
/* not in the cell's in-memory lists - create a new record */
|
|
vl = afs_vlocation_alloc(cell, name, namesz);
|
|
if (!vl) {
|
|
up_write(&cell->vl_sem);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
afs_get_cell(cell);
|
|
|
|
list_add_tail(&vl->link, &cell->vl_list);
|
|
vl->state = AFS_VL_CREATING;
|
|
up_write(&cell->vl_sem);
|
|
|
|
fill_in_record:
|
|
ret = afs_vlocation_fill_in_record(vl, key);
|
|
if (ret < 0)
|
|
goto error_abandon;
|
|
spin_lock(&vl->lock);
|
|
vl->state = AFS_VL_VALID;
|
|
spin_unlock(&vl->lock);
|
|
wake_up(&vl->waitq);
|
|
|
|
/* update volume entry in local cache */
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
fscache_update_cookie(vl->cache);
|
|
#endif
|
|
|
|
/* schedule for regular updates */
|
|
afs_vlocation_queue_for_updates(vl);
|
|
goto success;
|
|
|
|
found_in_memory:
|
|
/* found in memory */
|
|
_debug("found in memory");
|
|
atomic_inc(&vl->usage);
|
|
spin_unlock(&cell->vl_lock);
|
|
if (!list_empty(&vl->grave)) {
|
|
spin_lock(&afs_vlocation_graveyard_lock);
|
|
list_del_init(&vl->grave);
|
|
spin_unlock(&afs_vlocation_graveyard_lock);
|
|
}
|
|
up_write(&cell->vl_sem);
|
|
|
|
/* see if it was an abandoned record that we might try filling in */
|
|
spin_lock(&vl->lock);
|
|
while (vl->state != AFS_VL_VALID) {
|
|
afs_vlocation_state_t state = vl->state;
|
|
|
|
_debug("invalid [state %d]", state);
|
|
|
|
if (state == AFS_VL_NEW || state == AFS_VL_NO_VOLUME) {
|
|
vl->state = AFS_VL_CREATING;
|
|
spin_unlock(&vl->lock);
|
|
goto fill_in_record;
|
|
}
|
|
|
|
/* must now wait for creation or update by someone else to
|
|
* complete */
|
|
_debug("wait");
|
|
|
|
spin_unlock(&vl->lock);
|
|
ret = wait_event_interruptible(vl->waitq,
|
|
vl->state == AFS_VL_NEW ||
|
|
vl->state == AFS_VL_VALID ||
|
|
vl->state == AFS_VL_NO_VOLUME);
|
|
if (ret < 0)
|
|
goto error;
|
|
spin_lock(&vl->lock);
|
|
}
|
|
spin_unlock(&vl->lock);
|
|
|
|
success:
|
|
_leave(" = %p", vl);
|
|
return vl;
|
|
|
|
error_abandon:
|
|
spin_lock(&vl->lock);
|
|
vl->state = AFS_VL_NEW;
|
|
spin_unlock(&vl->lock);
|
|
wake_up(&vl->waitq);
|
|
error:
|
|
ASSERT(vl != NULL);
|
|
afs_put_vlocation(vl);
|
|
_leave(" = %d", ret);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
/*
|
|
* finish using a volume location record
|
|
*/
|
|
void afs_put_vlocation(struct afs_vlocation *vl)
|
|
{
|
|
if (!vl)
|
|
return;
|
|
|
|
_enter("%s", vl->vldb.name);
|
|
|
|
ASSERTCMP(atomic_read(&vl->usage), >, 0);
|
|
|
|
if (likely(!atomic_dec_and_test(&vl->usage))) {
|
|
_leave("");
|
|
return;
|
|
}
|
|
|
|
spin_lock(&afs_vlocation_graveyard_lock);
|
|
if (atomic_read(&vl->usage) == 0) {
|
|
_debug("buried");
|
|
list_move_tail(&vl->grave, &afs_vlocation_graveyard);
|
|
vl->time_of_death = get_seconds();
|
|
queue_delayed_work(afs_wq, &afs_vlocation_reap,
|
|
afs_vlocation_timeout * HZ);
|
|
|
|
/* suspend updates on this record */
|
|
if (!list_empty(&vl->update)) {
|
|
spin_lock(&afs_vlocation_updates_lock);
|
|
list_del_init(&vl->update);
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
}
|
|
}
|
|
spin_unlock(&afs_vlocation_graveyard_lock);
|
|
_leave(" [killed?]");
|
|
}
|
|
|
|
/*
|
|
* destroy a dead volume location record
|
|
*/
|
|
static void afs_vlocation_destroy(struct afs_vlocation *vl)
|
|
{
|
|
_enter("%p", vl);
|
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
fscache_relinquish_cookie(vl->cache, 0);
|
|
#endif
|
|
afs_put_cell(vl->cell);
|
|
kfree(vl);
|
|
}
|
|
|
|
/*
|
|
* reap dead volume location records
|
|
*/
|
|
static void afs_vlocation_reaper(struct work_struct *work)
|
|
{
|
|
LIST_HEAD(corpses);
|
|
struct afs_vlocation *vl;
|
|
unsigned long delay, expiry;
|
|
time_t now;
|
|
|
|
_enter("");
|
|
|
|
now = get_seconds();
|
|
spin_lock(&afs_vlocation_graveyard_lock);
|
|
|
|
while (!list_empty(&afs_vlocation_graveyard)) {
|
|
vl = list_entry(afs_vlocation_graveyard.next,
|
|
struct afs_vlocation, grave);
|
|
|
|
_debug("check %p", vl);
|
|
|
|
/* the queue is ordered most dead first */
|
|
expiry = vl->time_of_death + afs_vlocation_timeout;
|
|
if (expiry > now) {
|
|
delay = (expiry - now) * HZ;
|
|
_debug("delay %lu", delay);
|
|
mod_delayed_work(afs_wq, &afs_vlocation_reap, delay);
|
|
break;
|
|
}
|
|
|
|
spin_lock(&vl->cell->vl_lock);
|
|
if (atomic_read(&vl->usage) > 0) {
|
|
_debug("no reap");
|
|
list_del_init(&vl->grave);
|
|
} else {
|
|
_debug("reap");
|
|
list_move_tail(&vl->grave, &corpses);
|
|
list_del_init(&vl->link);
|
|
}
|
|
spin_unlock(&vl->cell->vl_lock);
|
|
}
|
|
|
|
spin_unlock(&afs_vlocation_graveyard_lock);
|
|
|
|
/* now reap the corpses we've extracted */
|
|
while (!list_empty(&corpses)) {
|
|
vl = list_entry(corpses.next, struct afs_vlocation, grave);
|
|
list_del(&vl->grave);
|
|
afs_vlocation_destroy(vl);
|
|
}
|
|
|
|
_leave("");
|
|
}
|
|
|
|
/*
|
|
* initialise the VL update process
|
|
*/
|
|
int __init afs_vlocation_update_init(void)
|
|
{
|
|
afs_vlocation_update_worker =
|
|
create_singlethread_workqueue("kafs_vlupdated");
|
|
return afs_vlocation_update_worker ? 0 : -ENOMEM;
|
|
}
|
|
|
|
/*
|
|
* discard all the volume location records for rmmod
|
|
*/
|
|
void afs_vlocation_purge(void)
|
|
{
|
|
afs_vlocation_timeout = 0;
|
|
|
|
spin_lock(&afs_vlocation_updates_lock);
|
|
list_del_init(&afs_vlocation_updates);
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
mod_delayed_work(afs_vlocation_update_worker, &afs_vlocation_update, 0);
|
|
destroy_workqueue(afs_vlocation_update_worker);
|
|
|
|
mod_delayed_work(afs_wq, &afs_vlocation_reap, 0);
|
|
}
|
|
|
|
/*
|
|
* update a volume location
|
|
*/
|
|
static void afs_vlocation_updater(struct work_struct *work)
|
|
{
|
|
struct afs_cache_vlocation vldb;
|
|
struct afs_vlocation *vl, *xvl;
|
|
time_t now;
|
|
long timeout;
|
|
int ret;
|
|
|
|
_enter("");
|
|
|
|
now = get_seconds();
|
|
|
|
/* find a record to update */
|
|
spin_lock(&afs_vlocation_updates_lock);
|
|
for (;;) {
|
|
if (list_empty(&afs_vlocation_updates)) {
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
_leave(" [nothing]");
|
|
return;
|
|
}
|
|
|
|
vl = list_entry(afs_vlocation_updates.next,
|
|
struct afs_vlocation, update);
|
|
if (atomic_read(&vl->usage) > 0)
|
|
break;
|
|
list_del_init(&vl->update);
|
|
}
|
|
|
|
timeout = vl->update_at - now;
|
|
if (timeout > 0) {
|
|
queue_delayed_work(afs_vlocation_update_worker,
|
|
&afs_vlocation_update, timeout * HZ);
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
_leave(" [nothing]");
|
|
return;
|
|
}
|
|
|
|
list_del_init(&vl->update);
|
|
atomic_inc(&vl->usage);
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
|
|
/* we can now perform the update */
|
|
_debug("update %s", vl->vldb.name);
|
|
vl->state = AFS_VL_UPDATING;
|
|
vl->upd_rej_cnt = 0;
|
|
vl->upd_busy_cnt = 0;
|
|
|
|
ret = afs_vlocation_update_record(vl, NULL, &vldb);
|
|
spin_lock(&vl->lock);
|
|
switch (ret) {
|
|
case 0:
|
|
afs_vlocation_apply_update(vl, &vldb);
|
|
vl->state = AFS_VL_VALID;
|
|
break;
|
|
case -ENOMEDIUM:
|
|
vl->state = AFS_VL_VOLUME_DELETED;
|
|
break;
|
|
default:
|
|
vl->state = AFS_VL_UNCERTAIN;
|
|
break;
|
|
}
|
|
spin_unlock(&vl->lock);
|
|
wake_up(&vl->waitq);
|
|
|
|
/* and then reschedule */
|
|
_debug("reschedule");
|
|
vl->update_at = get_seconds() + afs_vlocation_update_timeout;
|
|
|
|
spin_lock(&afs_vlocation_updates_lock);
|
|
|
|
if (!list_empty(&afs_vlocation_updates)) {
|
|
/* next update in 10 minutes, but wait at least 1 second more
|
|
* than the newest record already queued so that we don't spam
|
|
* the VL server suddenly with lots of requests
|
|
*/
|
|
xvl = list_entry(afs_vlocation_updates.prev,
|
|
struct afs_vlocation, update);
|
|
if (vl->update_at <= xvl->update_at)
|
|
vl->update_at = xvl->update_at + 1;
|
|
xvl = list_entry(afs_vlocation_updates.next,
|
|
struct afs_vlocation, update);
|
|
timeout = xvl->update_at - now;
|
|
if (timeout < 0)
|
|
timeout = 0;
|
|
} else {
|
|
timeout = afs_vlocation_update_timeout;
|
|
}
|
|
|
|
ASSERT(list_empty(&vl->update));
|
|
|
|
list_add_tail(&vl->update, &afs_vlocation_updates);
|
|
|
|
_debug("timeout %ld", timeout);
|
|
queue_delayed_work(afs_vlocation_update_worker,
|
|
&afs_vlocation_update, timeout * HZ);
|
|
spin_unlock(&afs_vlocation_updates_lock);
|
|
afs_put_vlocation(vl);
|
|
}
|