mirror of
https://github.com/torvalds/linux.git
synced 2024-11-25 05:32:00 +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
461 lines
10 KiB
C
461 lines
10 KiB
C
/* AFS cell and 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/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/key.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/dns_resolver.h>
|
|
#include <linux/sched.h>
|
|
#include <keys/rxrpc-type.h>
|
|
#include "internal.h"
|
|
|
|
DECLARE_RWSEM(afs_proc_cells_sem);
|
|
LIST_HEAD(afs_proc_cells);
|
|
|
|
static LIST_HEAD(afs_cells);
|
|
static DEFINE_RWLOCK(afs_cells_lock);
|
|
static DECLARE_RWSEM(afs_cells_sem); /* add/remove serialisation */
|
|
static DECLARE_WAIT_QUEUE_HEAD(afs_cells_freeable_wq);
|
|
static struct afs_cell *afs_cell_root;
|
|
|
|
/*
|
|
* allocate a cell record and fill in its name, VL server address list and
|
|
* allocate an anonymous key
|
|
*/
|
|
static struct afs_cell *afs_cell_alloc(const char *name, unsigned namelen,
|
|
char *vllist)
|
|
{
|
|
struct afs_cell *cell;
|
|
struct key *key;
|
|
char keyname[4 + AFS_MAXCELLNAME + 1], *cp, *dp, *next;
|
|
char *dvllist = NULL, *_vllist = NULL;
|
|
char delimiter = ':';
|
|
int ret;
|
|
|
|
_enter("%*.*s,%s", namelen, namelen, name ?: "", vllist);
|
|
|
|
BUG_ON(!name); /* TODO: want to look up "this cell" in the cache */
|
|
|
|
if (namelen > AFS_MAXCELLNAME) {
|
|
_leave(" = -ENAMETOOLONG");
|
|
return ERR_PTR(-ENAMETOOLONG);
|
|
}
|
|
|
|
/* allocate and initialise a cell record */
|
|
cell = kzalloc(sizeof(struct afs_cell) + namelen + 1, GFP_KERNEL);
|
|
if (!cell) {
|
|
_leave(" = -ENOMEM");
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
memcpy(cell->name, name, namelen);
|
|
cell->name[namelen] = 0;
|
|
|
|
atomic_set(&cell->usage, 1);
|
|
INIT_LIST_HEAD(&cell->link);
|
|
rwlock_init(&cell->servers_lock);
|
|
INIT_LIST_HEAD(&cell->servers);
|
|
init_rwsem(&cell->vl_sem);
|
|
INIT_LIST_HEAD(&cell->vl_list);
|
|
spin_lock_init(&cell->vl_lock);
|
|
|
|
/* if the ip address is invalid, try dns query */
|
|
if (!vllist || strlen(vllist) < 7) {
|
|
ret = dns_query("afsdb", name, namelen, "ipv4", &dvllist, NULL);
|
|
if (ret < 0) {
|
|
if (ret == -ENODATA || ret == -EAGAIN || ret == -ENOKEY)
|
|
/* translate these errors into something
|
|
* userspace might understand */
|
|
ret = -EDESTADDRREQ;
|
|
_leave(" = %d", ret);
|
|
return ERR_PTR(ret);
|
|
}
|
|
_vllist = dvllist;
|
|
|
|
/* change the delimiter for user-space reply */
|
|
delimiter = ',';
|
|
|
|
} else {
|
|
_vllist = vllist;
|
|
}
|
|
|
|
/* fill in the VL server list from the rest of the string */
|
|
do {
|
|
unsigned a, b, c, d;
|
|
|
|
next = strchr(_vllist, delimiter);
|
|
if (next)
|
|
*next++ = 0;
|
|
|
|
if (sscanf(_vllist, "%u.%u.%u.%u", &a, &b, &c, &d) != 4)
|
|
goto bad_address;
|
|
|
|
if (a > 255 || b > 255 || c > 255 || d > 255)
|
|
goto bad_address;
|
|
|
|
cell->vl_addrs[cell->vl_naddrs++].s_addr =
|
|
htonl((a << 24) | (b << 16) | (c << 8) | d);
|
|
|
|
} while (cell->vl_naddrs < AFS_CELL_MAX_ADDRS && (_vllist = next));
|
|
|
|
/* create a key to represent an anonymous user */
|
|
memcpy(keyname, "afs@", 4);
|
|
dp = keyname + 4;
|
|
cp = cell->name;
|
|
do {
|
|
*dp++ = toupper(*cp);
|
|
} while (*cp++);
|
|
|
|
key = rxrpc_get_null_key(keyname);
|
|
if (IS_ERR(key)) {
|
|
_debug("no key");
|
|
ret = PTR_ERR(key);
|
|
goto error;
|
|
}
|
|
cell->anonymous_key = key;
|
|
|
|
_debug("anon key %p{%x}",
|
|
cell->anonymous_key, key_serial(cell->anonymous_key));
|
|
|
|
_leave(" = %p", cell);
|
|
return cell;
|
|
|
|
bad_address:
|
|
printk(KERN_ERR "kAFS: bad VL server IP address\n");
|
|
ret = -EINVAL;
|
|
error:
|
|
key_put(cell->anonymous_key);
|
|
kfree(dvllist);
|
|
kfree(cell);
|
|
_leave(" = %d", ret);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
/*
|
|
* afs_cell_crate() - create a cell record
|
|
* @name: is the name of the cell.
|
|
* @namsesz: is the strlen of the cell name.
|
|
* @vllist: is a colon separated list of IP addresses in "a.b.c.d" format.
|
|
* @retref: is T to return the cell reference when the cell exists.
|
|
*/
|
|
struct afs_cell *afs_cell_create(const char *name, unsigned namesz,
|
|
char *vllist, bool retref)
|
|
{
|
|
struct afs_cell *cell;
|
|
int ret;
|
|
|
|
_enter("%*.*s,%s", namesz, namesz, name ?: "", vllist);
|
|
|
|
down_write(&afs_cells_sem);
|
|
read_lock(&afs_cells_lock);
|
|
list_for_each_entry(cell, &afs_cells, link) {
|
|
if (strncasecmp(cell->name, name, namesz) == 0)
|
|
goto duplicate_name;
|
|
}
|
|
read_unlock(&afs_cells_lock);
|
|
|
|
cell = afs_cell_alloc(name, namesz, vllist);
|
|
if (IS_ERR(cell)) {
|
|
_leave(" = %ld", PTR_ERR(cell));
|
|
up_write(&afs_cells_sem);
|
|
return cell;
|
|
}
|
|
|
|
/* add a proc directory for this cell */
|
|
ret = afs_proc_cell_setup(cell);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
/* put it up for caching (this never returns an error) */
|
|
cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index,
|
|
&afs_cell_cache_index_def,
|
|
cell, true);
|
|
#endif
|
|
|
|
/* add to the cell lists */
|
|
write_lock(&afs_cells_lock);
|
|
list_add_tail(&cell->link, &afs_cells);
|
|
write_unlock(&afs_cells_lock);
|
|
|
|
down_write(&afs_proc_cells_sem);
|
|
list_add_tail(&cell->proc_link, &afs_proc_cells);
|
|
up_write(&afs_proc_cells_sem);
|
|
up_write(&afs_cells_sem);
|
|
|
|
_leave(" = %p", cell);
|
|
return cell;
|
|
|
|
error:
|
|
up_write(&afs_cells_sem);
|
|
key_put(cell->anonymous_key);
|
|
kfree(cell);
|
|
_leave(" = %d", ret);
|
|
return ERR_PTR(ret);
|
|
|
|
duplicate_name:
|
|
if (retref && !IS_ERR(cell))
|
|
afs_get_cell(cell);
|
|
|
|
read_unlock(&afs_cells_lock);
|
|
up_write(&afs_cells_sem);
|
|
|
|
if (retref) {
|
|
_leave(" = %p", cell);
|
|
return cell;
|
|
}
|
|
|
|
_leave(" = -EEXIST");
|
|
return ERR_PTR(-EEXIST);
|
|
}
|
|
|
|
/*
|
|
* set the root cell information
|
|
* - can be called with a module parameter string
|
|
* - can be called from a write to /proc/fs/afs/rootcell
|
|
*/
|
|
int afs_cell_init(char *rootcell)
|
|
{
|
|
struct afs_cell *old_root, *new_root;
|
|
char *cp;
|
|
|
|
_enter("");
|
|
|
|
if (!rootcell) {
|
|
/* module is loaded with no parameters, or built statically.
|
|
* - in the future we might initialize cell DB here.
|
|
*/
|
|
_leave(" = 0 [no root]");
|
|
return 0;
|
|
}
|
|
|
|
cp = strchr(rootcell, ':');
|
|
if (!cp)
|
|
_debug("kAFS: no VL server IP addresses specified");
|
|
else
|
|
*cp++ = 0;
|
|
|
|
/* allocate a cell record for the root cell */
|
|
new_root = afs_cell_create(rootcell, strlen(rootcell), cp, false);
|
|
if (IS_ERR(new_root)) {
|
|
_leave(" = %ld", PTR_ERR(new_root));
|
|
return PTR_ERR(new_root);
|
|
}
|
|
|
|
/* install the new cell */
|
|
write_lock(&afs_cells_lock);
|
|
old_root = afs_cell_root;
|
|
afs_cell_root = new_root;
|
|
write_unlock(&afs_cells_lock);
|
|
afs_put_cell(old_root);
|
|
|
|
_leave(" = 0");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* lookup a cell record
|
|
*/
|
|
struct afs_cell *afs_cell_lookup(const char *name, unsigned namesz,
|
|
bool dns_cell)
|
|
{
|
|
struct afs_cell *cell;
|
|
|
|
_enter("\"%*.*s\",", namesz, namesz, name ?: "");
|
|
|
|
down_read(&afs_cells_sem);
|
|
read_lock(&afs_cells_lock);
|
|
|
|
if (name) {
|
|
/* if the cell was named, look for it in the cell record list */
|
|
list_for_each_entry(cell, &afs_cells, link) {
|
|
if (strncmp(cell->name, name, namesz) == 0) {
|
|
afs_get_cell(cell);
|
|
goto found;
|
|
}
|
|
}
|
|
cell = ERR_PTR(-ENOENT);
|
|
if (dns_cell)
|
|
goto create_cell;
|
|
found:
|
|
;
|
|
} else {
|
|
cell = afs_cell_root;
|
|
if (!cell) {
|
|
/* this should not happen unless user tries to mount
|
|
* when root cell is not set. Return an impossibly
|
|
* bizarre errno to alert the user. Things like
|
|
* ENOENT might be "more appropriate" but they happen
|
|
* for other reasons.
|
|
*/
|
|
cell = ERR_PTR(-EDESTADDRREQ);
|
|
} else {
|
|
afs_get_cell(cell);
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock(&afs_cells_lock);
|
|
up_read(&afs_cells_sem);
|
|
_leave(" = %p", cell);
|
|
return cell;
|
|
|
|
create_cell:
|
|
read_unlock(&afs_cells_lock);
|
|
up_read(&afs_cells_sem);
|
|
|
|
cell = afs_cell_create(name, namesz, NULL, true);
|
|
|
|
_leave(" = %p", cell);
|
|
return cell;
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* try and get a cell record
|
|
*/
|
|
struct afs_cell *afs_get_cell_maybe(struct afs_cell *cell)
|
|
{
|
|
write_lock(&afs_cells_lock);
|
|
|
|
if (cell && !list_empty(&cell->link))
|
|
afs_get_cell(cell);
|
|
else
|
|
cell = NULL;
|
|
|
|
write_unlock(&afs_cells_lock);
|
|
return cell;
|
|
}
|
|
#endif /* 0 */
|
|
|
|
/*
|
|
* destroy a cell record
|
|
*/
|
|
void afs_put_cell(struct afs_cell *cell)
|
|
{
|
|
if (!cell)
|
|
return;
|
|
|
|
_enter("%p{%d,%s}", cell, atomic_read(&cell->usage), cell->name);
|
|
|
|
ASSERTCMP(atomic_read(&cell->usage), >, 0);
|
|
|
|
/* to prevent a race, the decrement and the dequeue must be effectively
|
|
* atomic */
|
|
write_lock(&afs_cells_lock);
|
|
|
|
if (likely(!atomic_dec_and_test(&cell->usage))) {
|
|
write_unlock(&afs_cells_lock);
|
|
_leave("");
|
|
return;
|
|
}
|
|
|
|
ASSERT(list_empty(&cell->servers));
|
|
ASSERT(list_empty(&cell->vl_list));
|
|
|
|
write_unlock(&afs_cells_lock);
|
|
|
|
wake_up(&afs_cells_freeable_wq);
|
|
|
|
_leave(" [unused]");
|
|
}
|
|
|
|
/*
|
|
* destroy a cell record
|
|
* - must be called with the afs_cells_sem write-locked
|
|
* - cell->link should have been broken by the caller
|
|
*/
|
|
static void afs_cell_destroy(struct afs_cell *cell)
|
|
{
|
|
_enter("%p{%d,%s}", cell, atomic_read(&cell->usage), cell->name);
|
|
|
|
ASSERTCMP(atomic_read(&cell->usage), >=, 0);
|
|
ASSERT(list_empty(&cell->link));
|
|
|
|
/* wait for everyone to stop using the cell */
|
|
if (atomic_read(&cell->usage) > 0) {
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
_debug("wait for cell %s", cell->name);
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
add_wait_queue(&afs_cells_freeable_wq, &myself);
|
|
|
|
while (atomic_read(&cell->usage) > 0) {
|
|
schedule();
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
}
|
|
|
|
remove_wait_queue(&afs_cells_freeable_wq, &myself);
|
|
set_current_state(TASK_RUNNING);
|
|
}
|
|
|
|
_debug("cell dead");
|
|
ASSERTCMP(atomic_read(&cell->usage), ==, 0);
|
|
ASSERT(list_empty(&cell->servers));
|
|
ASSERT(list_empty(&cell->vl_list));
|
|
|
|
afs_proc_cell_remove(cell);
|
|
|
|
down_write(&afs_proc_cells_sem);
|
|
list_del_init(&cell->proc_link);
|
|
up_write(&afs_proc_cells_sem);
|
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
fscache_relinquish_cookie(cell->cache, 0);
|
|
#endif
|
|
key_put(cell->anonymous_key);
|
|
kfree(cell);
|
|
|
|
_leave(" [destroyed]");
|
|
}
|
|
|
|
/*
|
|
* purge in-memory cell database on module unload or afs_init() failure
|
|
* - the timeout daemon is stopped before calling this
|
|
*/
|
|
void afs_cell_purge(void)
|
|
{
|
|
struct afs_cell *cell;
|
|
|
|
_enter("");
|
|
|
|
afs_put_cell(afs_cell_root);
|
|
|
|
down_write(&afs_cells_sem);
|
|
|
|
while (!list_empty(&afs_cells)) {
|
|
cell = NULL;
|
|
|
|
/* remove the next cell from the front of the list */
|
|
write_lock(&afs_cells_lock);
|
|
|
|
if (!list_empty(&afs_cells)) {
|
|
cell = list_entry(afs_cells.next,
|
|
struct afs_cell, link);
|
|
list_del_init(&cell->link);
|
|
}
|
|
|
|
write_unlock(&afs_cells_lock);
|
|
|
|
if (cell) {
|
|
_debug("PURGING CELL %s (%d)",
|
|
cell->name, atomic_read(&cell->usage));
|
|
|
|
/* now the cell should be left with no references */
|
|
afs_cell_destroy(cell);
|
|
}
|
|
}
|
|
|
|
up_write(&afs_cells_sem);
|
|
_leave("");
|
|
}
|