/* 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