mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-25 05:34:00 +08:00
1da177e4c3
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!
396 lines
9.8 KiB
C
396 lines
9.8 KiB
C
/* vnode.c: AFS vnode 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/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/pagemap.h>
|
|
#include "volume.h"
|
|
#include "cell.h"
|
|
#include "cmservice.h"
|
|
#include "fsclient.h"
|
|
#include "vlclient.h"
|
|
#include "vnode.h"
|
|
#include "internal.h"
|
|
|
|
static void afs_vnode_cb_timed_out(struct afs_timer *timer);
|
|
|
|
struct afs_timer_ops afs_vnode_cb_timed_out_ops = {
|
|
.timed_out = afs_vnode_cb_timed_out,
|
|
};
|
|
|
|
#ifdef AFS_CACHING_SUPPORT
|
|
static cachefs_match_val_t afs_vnode_cache_match(void *target,
|
|
const void *entry);
|
|
static void afs_vnode_cache_update(void *source, void *entry);
|
|
|
|
struct cachefs_index_def afs_vnode_cache_index_def = {
|
|
.name = "vnode",
|
|
.data_size = sizeof(struct afs_cache_vnode),
|
|
.keys[0] = { CACHEFS_INDEX_KEYS_BIN, 4 },
|
|
.match = afs_vnode_cache_match,
|
|
.update = afs_vnode_cache_update,
|
|
};
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* handle a callback timing out
|
|
* TODO: retain a ref to vnode struct for an outstanding callback timeout
|
|
*/
|
|
static void afs_vnode_cb_timed_out(struct afs_timer *timer)
|
|
{
|
|
struct afs_server *oldserver;
|
|
struct afs_vnode *vnode;
|
|
|
|
vnode = list_entry(timer, struct afs_vnode, cb_timeout);
|
|
|
|
_enter("%p", vnode);
|
|
|
|
/* set the changed flag in the vnode and release the server */
|
|
spin_lock(&vnode->lock);
|
|
|
|
oldserver = xchg(&vnode->cb_server, NULL);
|
|
if (oldserver) {
|
|
vnode->flags |= AFS_VNODE_CHANGED;
|
|
|
|
spin_lock(&afs_cb_hash_lock);
|
|
list_del_init(&vnode->cb_hash_link);
|
|
spin_unlock(&afs_cb_hash_lock);
|
|
|
|
spin_lock(&oldserver->cb_lock);
|
|
list_del_init(&vnode->cb_link);
|
|
spin_unlock(&oldserver->cb_lock);
|
|
}
|
|
|
|
spin_unlock(&vnode->lock);
|
|
|
|
afs_put_server(oldserver);
|
|
|
|
_leave("");
|
|
} /* end afs_vnode_cb_timed_out() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* finish off updating the recorded status of a file
|
|
* - starts callback expiry timer
|
|
* - adds to server's callback list
|
|
*/
|
|
static void afs_vnode_finalise_status_update(struct afs_vnode *vnode,
|
|
struct afs_server *server,
|
|
int ret)
|
|
{
|
|
struct afs_server *oldserver = NULL;
|
|
|
|
_enter("%p,%p,%d", vnode, server, ret);
|
|
|
|
spin_lock(&vnode->lock);
|
|
|
|
vnode->flags &= ~AFS_VNODE_CHANGED;
|
|
|
|
if (ret == 0) {
|
|
/* adjust the callback timeout appropriately */
|
|
afs_kafstimod_add_timer(&vnode->cb_timeout,
|
|
vnode->cb_expiry * HZ);
|
|
|
|
spin_lock(&afs_cb_hash_lock);
|
|
list_del(&vnode->cb_hash_link);
|
|
list_add_tail(&vnode->cb_hash_link,
|
|
&afs_cb_hash(server, &vnode->fid));
|
|
spin_unlock(&afs_cb_hash_lock);
|
|
|
|
/* swap ref to old callback server with that for new callback
|
|
* server */
|
|
oldserver = xchg(&vnode->cb_server, server);
|
|
if (oldserver != server) {
|
|
if (oldserver) {
|
|
spin_lock(&oldserver->cb_lock);
|
|
list_del_init(&vnode->cb_link);
|
|
spin_unlock(&oldserver->cb_lock);
|
|
}
|
|
|
|
afs_get_server(server);
|
|
spin_lock(&server->cb_lock);
|
|
list_add_tail(&vnode->cb_link, &server->cb_promises);
|
|
spin_unlock(&server->cb_lock);
|
|
}
|
|
else {
|
|
/* same server */
|
|
oldserver = NULL;
|
|
}
|
|
}
|
|
else if (ret == -ENOENT) {
|
|
/* the file was deleted - clear the callback timeout */
|
|
oldserver = xchg(&vnode->cb_server, NULL);
|
|
afs_kafstimod_del_timer(&vnode->cb_timeout);
|
|
|
|
_debug("got NOENT from server - marking file deleted");
|
|
vnode->flags |= AFS_VNODE_DELETED;
|
|
}
|
|
|
|
vnode->update_cnt--;
|
|
|
|
spin_unlock(&vnode->lock);
|
|
|
|
wake_up_all(&vnode->update_waitq);
|
|
|
|
afs_put_server(oldserver);
|
|
|
|
_leave("");
|
|
|
|
} /* end afs_vnode_finalise_status_update() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* fetch file status from the volume
|
|
* - don't issue a fetch if:
|
|
* - the changed bit is not set and there's a valid callback
|
|
* - there are any outstanding ops that will fetch the status
|
|
* - TODO implement local caching
|
|
*/
|
|
int afs_vnode_fetch_status(struct afs_vnode *vnode)
|
|
{
|
|
struct afs_server *server;
|
|
int ret;
|
|
|
|
DECLARE_WAITQUEUE(myself, current);
|
|
|
|
_enter("%s,{%u,%u,%u}",
|
|
vnode->volume->vlocation->vldb.name,
|
|
vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
|
|
|
|
if (!(vnode->flags & AFS_VNODE_CHANGED) && vnode->cb_server) {
|
|
_leave(" [unchanged]");
|
|
return 0;
|
|
}
|
|
|
|
if (vnode->flags & AFS_VNODE_DELETED) {
|
|
_leave(" [deleted]");
|
|
return -ENOENT;
|
|
}
|
|
|
|
spin_lock(&vnode->lock);
|
|
|
|
if (!(vnode->flags & AFS_VNODE_CHANGED)) {
|
|
spin_unlock(&vnode->lock);
|
|
_leave(" [unchanged]");
|
|
return 0;
|
|
}
|
|
|
|
if (vnode->update_cnt > 0) {
|
|
/* someone else started a fetch */
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
add_wait_queue(&vnode->update_waitq, &myself);
|
|
|
|
/* wait for the status to be updated */
|
|
for (;;) {
|
|
if (!(vnode->flags & AFS_VNODE_CHANGED))
|
|
break;
|
|
if (vnode->flags & AFS_VNODE_DELETED)
|
|
break;
|
|
|
|
/* it got updated and invalidated all before we saw
|
|
* it */
|
|
if (vnode->update_cnt == 0) {
|
|
remove_wait_queue(&vnode->update_waitq,
|
|
&myself);
|
|
set_current_state(TASK_RUNNING);
|
|
goto get_anyway;
|
|
}
|
|
|
|
spin_unlock(&vnode->lock);
|
|
|
|
schedule();
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
|
|
spin_lock(&vnode->lock);
|
|
}
|
|
|
|
remove_wait_queue(&vnode->update_waitq, &myself);
|
|
spin_unlock(&vnode->lock);
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
return vnode->flags & AFS_VNODE_DELETED ? -ENOENT : 0;
|
|
}
|
|
|
|
get_anyway:
|
|
/* okay... we're going to have to initiate the op */
|
|
vnode->update_cnt++;
|
|
|
|
spin_unlock(&vnode->lock);
|
|
|
|
/* merge AFS status fetches and clear outstanding callback on this
|
|
* vnode */
|
|
do {
|
|
/* pick a server to query */
|
|
ret = afs_volume_pick_fileserver(vnode->volume, &server);
|
|
if (ret<0)
|
|
return ret;
|
|
|
|
_debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
|
|
|
|
ret = afs_rxfs_fetch_file_status(server, vnode, NULL);
|
|
|
|
} while (!afs_volume_release_fileserver(vnode->volume, server, ret));
|
|
|
|
/* adjust the flags */
|
|
afs_vnode_finalise_status_update(vnode, server, ret);
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
} /* end afs_vnode_fetch_status() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* fetch file data from the volume
|
|
* - TODO implement caching and server failover
|
|
*/
|
|
int afs_vnode_fetch_data(struct afs_vnode *vnode,
|
|
struct afs_rxfs_fetch_descriptor *desc)
|
|
{
|
|
struct afs_server *server;
|
|
int ret;
|
|
|
|
_enter("%s,{%u,%u,%u}",
|
|
vnode->volume->vlocation->vldb.name,
|
|
vnode->fid.vid,
|
|
vnode->fid.vnode,
|
|
vnode->fid.unique);
|
|
|
|
/* this op will fetch the status */
|
|
spin_lock(&vnode->lock);
|
|
vnode->update_cnt++;
|
|
spin_unlock(&vnode->lock);
|
|
|
|
/* merge in AFS status fetches and clear outstanding callback on this
|
|
* vnode */
|
|
do {
|
|
/* pick a server to query */
|
|
ret = afs_volume_pick_fileserver(vnode->volume, &server);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
_debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
|
|
|
|
ret = afs_rxfs_fetch_file_data(server, vnode, desc, NULL);
|
|
|
|
} while (!afs_volume_release_fileserver(vnode->volume, server, ret));
|
|
|
|
/* adjust the flags */
|
|
afs_vnode_finalise_status_update(vnode, server, ret);
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
|
|
} /* end afs_vnode_fetch_data() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* break any outstanding callback on a vnode
|
|
* - only relevent to server that issued it
|
|
*/
|
|
int afs_vnode_give_up_callback(struct afs_vnode *vnode)
|
|
{
|
|
struct afs_server *server;
|
|
int ret;
|
|
|
|
_enter("%s,{%u,%u,%u}",
|
|
vnode->volume->vlocation->vldb.name,
|
|
vnode->fid.vid,
|
|
vnode->fid.vnode,
|
|
vnode->fid.unique);
|
|
|
|
spin_lock(&afs_cb_hash_lock);
|
|
list_del_init(&vnode->cb_hash_link);
|
|
spin_unlock(&afs_cb_hash_lock);
|
|
|
|
/* set the changed flag in the vnode and release the server */
|
|
spin_lock(&vnode->lock);
|
|
|
|
afs_kafstimod_del_timer(&vnode->cb_timeout);
|
|
|
|
server = xchg(&vnode->cb_server, NULL);
|
|
if (server) {
|
|
vnode->flags |= AFS_VNODE_CHANGED;
|
|
|
|
spin_lock(&server->cb_lock);
|
|
list_del_init(&vnode->cb_link);
|
|
spin_unlock(&server->cb_lock);
|
|
}
|
|
|
|
spin_unlock(&vnode->lock);
|
|
|
|
ret = 0;
|
|
if (server) {
|
|
ret = afs_rxfs_give_up_callback(server, vnode);
|
|
afs_put_server(server);
|
|
}
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
} /* end afs_vnode_give_up_callback() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* match a vnode record stored in the cache
|
|
*/
|
|
#ifdef AFS_CACHING_SUPPORT
|
|
static cachefs_match_val_t afs_vnode_cache_match(void *target,
|
|
const void *entry)
|
|
{
|
|
const struct afs_cache_vnode *cvnode = entry;
|
|
struct afs_vnode *vnode = target;
|
|
|
|
_enter("{%x,%x,%Lx},{%x,%x,%Lx}",
|
|
vnode->fid.vnode,
|
|
vnode->fid.unique,
|
|
vnode->status.version,
|
|
cvnode->vnode_id,
|
|
cvnode->vnode_unique,
|
|
cvnode->data_version);
|
|
|
|
if (vnode->fid.vnode != cvnode->vnode_id) {
|
|
_leave(" = FAILED");
|
|
return CACHEFS_MATCH_FAILED;
|
|
}
|
|
|
|
if (vnode->fid.unique != cvnode->vnode_unique ||
|
|
vnode->status.version != cvnode->data_version) {
|
|
_leave(" = DELETE");
|
|
return CACHEFS_MATCH_SUCCESS_DELETE;
|
|
}
|
|
|
|
_leave(" = SUCCESS");
|
|
return CACHEFS_MATCH_SUCCESS;
|
|
} /* end afs_vnode_cache_match() */
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* update a vnode record stored in the cache
|
|
*/
|
|
#ifdef AFS_CACHING_SUPPORT
|
|
static void afs_vnode_cache_update(void *source, void *entry)
|
|
{
|
|
struct afs_cache_vnode *cvnode = entry;
|
|
struct afs_vnode *vnode = source;
|
|
|
|
_enter("");
|
|
|
|
cvnode->vnode_id = vnode->fid.vnode;
|
|
cvnode->vnode_unique = vnode->fid.unique;
|
|
cvnode->data_version = vnode->status.version;
|
|
|
|
} /* end afs_vnode_cache_update() */
|
|
#endif
|