0,0 → 1,229 |
/* |
* Copyright (c) 2008 Jakub Jermar |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
|
/** @addtogroup fs |
* @{ |
*/ |
|
/** |
* @file vfs_node.c |
* @brief Various operations on VFS nodes have their home in this file. |
*/ |
|
#include "vfs.h" |
#include <stdlib.h> |
#include <string.h> |
#include <futex.h> |
#include <rwlock.h> |
#include <libadt/hash_table.h> |
#include <assert.h> |
#include <async.h> |
#include <errno.h> |
|
/** Futex protecting the VFS node hash table. */ |
futex_t nodes_futex = FUTEX_INITIALIZER; |
|
#define NODES_BUCKETS_LOG 8 |
#define NODES_BUCKETS (1 << NODES_BUCKETS_LOG) |
|
/** VFS node hash table containing all active, in-memory VFS nodes. */ |
hash_table_t nodes; |
|
#define KEY_FS_HANDLE 0 |
#define KEY_DEV_HANDLE 1 |
#define KEY_INDEX 2 |
|
static hash_index_t nodes_hash(unsigned long []); |
static int nodes_compare(unsigned long [], hash_count_t, link_t *); |
static void nodes_remove_callback(link_t *); |
|
/** VFS node hash table operations. */ |
hash_table_operations_t nodes_ops = { |
.hash = nodes_hash, |
.compare = nodes_compare, |
.remove_callback = nodes_remove_callback |
}; |
|
/** Initialize the VFS node hash table. |
* |
* @return Return true on success, false on failure. |
*/ |
bool vfs_nodes_init(void) |
{ |
return hash_table_create(&nodes, NODES_BUCKETS, 3, &nodes_ops); |
} |
|
static inline void _vfs_node_addref(vfs_node_t *node) |
{ |
node->refcnt++; |
} |
|
/** Increment reference count of a VFS node. |
* |
* @param node VFS node that will have its refcnt incremented. |
*/ |
void vfs_node_addref(vfs_node_t *node) |
{ |
futex_down(&nodes_futex); |
_vfs_node_addref(node); |
futex_up(&nodes_futex); |
} |
|
/** Decrement reference count of a VFS node. |
* |
* This function handles the case when the reference count drops to zero. |
* |
* @param node VFS node that will have its refcnt decremented. |
*/ |
void vfs_node_delref(vfs_node_t *node) |
{ |
bool free_vfs_node = false; |
bool free_fs_node = false; |
|
futex_down(&nodes_futex); |
if (node->refcnt-- == 1) { |
/* |
* We are dropping the last reference to this node. |
* Remove it from the VFS node hash table. |
*/ |
unsigned long key[] = { |
[KEY_FS_HANDLE] = node->fs_handle, |
[KEY_DEV_HANDLE] = node->dev_handle, |
[KEY_INDEX] = node->index |
}; |
hash_table_remove(&nodes, key, 3); |
free_vfs_node = true; |
if (!node->lnkcnt) |
free_fs_node = true; |
} |
futex_up(&nodes_futex); |
|
if (free_fs_node) { |
/* |
* The node is not visible in the file system namespace. |
* Free up its resources. |
*/ |
int phone = vfs_grab_phone(node->fs_handle); |
ipcarg_t rc; |
rc = async_req_2_0(phone, VFS_DESTROY, |
(ipcarg_t)node->dev_handle, (ipcarg_t)node->index); |
assert(rc == EOK); |
vfs_release_phone(phone); |
} |
if (free_vfs_node) |
free(node); |
} |
|
/** Find VFS node. |
* |
* This function will try to lookup the given triplet in the VFS node hash |
* table. In case the triplet is not found there, a new VFS node is created. |
* In any case, the VFS node will have its reference count incremented. Every |
* node returned by this call should be eventually put back by calling |
* vfs_node_put() on it. |
* |
* @param result Populated lookup result structure. |
* |
* @return VFS node corresponding to the given triplet. |
*/ |
vfs_node_t *vfs_node_get(vfs_lookup_res_t *result) |
{ |
unsigned long key[] = { |
[KEY_FS_HANDLE] = result->triplet.fs_handle, |
[KEY_DEV_HANDLE] = result->triplet.dev_handle, |
[KEY_INDEX] = result->triplet.index |
}; |
link_t *tmp; |
vfs_node_t *node; |
|
futex_down(&nodes_futex); |
tmp = hash_table_find(&nodes, key); |
if (!tmp) { |
node = (vfs_node_t *) malloc(sizeof(vfs_node_t)); |
if (!node) { |
futex_up(&nodes_futex); |
return NULL; |
} |
memset(node, 0, sizeof(vfs_node_t)); |
node->fs_handle = result->triplet.fs_handle; |
node->dev_handle = result->triplet.dev_handle; |
node->index = result->triplet.index; |
node->size = result->size; |
node->lnkcnt = result->lnkcnt; |
link_initialize(&node->nh_link); |
rwlock_initialize(&node->contents_rwlock); |
hash_table_insert(&nodes, key, &node->nh_link); |
} else { |
node = hash_table_get_instance(tmp, vfs_node_t, nh_link); |
} |
|
assert(node->size == result->size); |
assert(node->lnkcnt == result->lnkcnt); |
|
_vfs_node_addref(node); |
futex_up(&nodes_futex); |
|
return node; |
} |
|
/** Return VFS node when no longer needed by the caller. |
* |
* This function will remove the reference on the VFS node created by |
* vfs_node_get(). This function can only be called as a closing bracket to the |
* preceding vfs_node_get() call. |
* |
* @param node VFS node being released. |
*/ |
void vfs_node_put(vfs_node_t *node) |
{ |
vfs_node_delref(node); |
} |
|
hash_index_t nodes_hash(unsigned long key[]) |
{ |
hash_index_t a = key[KEY_FS_HANDLE] << (NODES_BUCKETS_LOG / 4); |
hash_index_t b = (a | key[KEY_DEV_HANDLE]) << (NODES_BUCKETS_LOG / 2); |
|
return (b | key[KEY_INDEX]) & (NODES_BUCKETS - 1); |
} |
|
int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item) |
{ |
vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link); |
return (node->fs_handle == key[KEY_FS_HANDLE]) && |
(node->dev_handle == key[KEY_DEV_HANDLE]) && |
(node->index == key[KEY_INDEX]); |
} |
|
void nodes_remove_callback(link_t *item) |
{ |
} |
|
/** |
* @} |
*/ |