Index: uspace/srv/fs/devfs/Makefile =================================================================== --- uspace/srv/fs/devfs/Makefile (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ (revision ) @@ -1,40 +1,0 @@ -# -# Copyright (c) 2005 Martin Decky -# Copyright (c) 2007 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. -# - -USPACE_PREFIX = ../../.. -LIBS = $(LIBFS_PREFIX)/libfs.a -EXTRA_CFLAGS += -I$(LIBFS_PREFIX) -BINARY = devfs -STATIC_NEEDED = y - -SOURCES = \ - devfs.c \ - devfs_ops.c - -include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/fs/devfs/devfs.c =================================================================== --- uspace/srv/fs/devfs/devfs.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ (revision ) @@ -1,93 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * 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 devfs.c - * @brief Devices file system. - * - * Every device registered to device mapper is represented as a file in this - * file system. - */ - -#include -#include -#include -#include -#include -#include -#include -#include "devfs.h" -#include "devfs_ops.h" - -#define NAME "devfs" - -static vfs_info_t devfs_vfs_info = { - .name = NAME, - .concurrent_read_write = false, - .write_retains_size = false, -}; - -int main(int argc, char *argv[]) -{ - printf("%s: HelenOS Device Filesystem\n", NAME); - - if (!devfs_init()) { - printf("%s: failed to initialize devfs\n", NAME); - return -1; - } - - async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE, - SERVICE_VFS, 0, 0); - if (!vfs_sess) { - printf("%s: Unable to connect to VFS\n", NAME); - return -1; - } - - int rc = fs_register(vfs_sess, &devfs_vfs_info, &devfs_ops, - &devfs_libfs_ops); - if (rc != EOK) { - printf("%s: Failed to register file system (%d)\n", NAME, rc); - return rc; - } - - printf("%s: Accepting connections\n", NAME); - task_retval(0); - async_manager(); - - /* Not reached */ - return 0; -} - -/** - * @} - */ - Index: uspace/srv/fs/devfs/devfs.h =================================================================== --- uspace/srv/fs/devfs/devfs.h (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ (revision ) @@ -1,45 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * 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 - * @{ - */ - -#ifndef DEVFS_DEVFS_H_ -#define DEVFS_DEVFS_H_ - -#include - -extern vfs_out_ops_t devfs_ops; -extern libfs_ops_t devfs_libfs_ops; - -#endif - -/** - * @} - */ Index: uspace/srv/fs/devfs/devfs_ops.c =================================================================== --- uspace/srv/fs/devfs/devfs_ops.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ (revision ) @@ -1,778 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * 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 devfs_ops.c - * @brief Implementation of VFS operations for the devfs file system server. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "devfs.h" -#include "devfs_ops.h" - -typedef struct { - devmap_handle_type_t type; - devmap_handle_t handle; -} devfs_node_t; - -/** Opened devices structure */ -typedef struct { - devmap_handle_t handle; - async_sess_t *sess; /**< If NULL, the structure is incomplete. */ - size_t refcount; - link_t link; - fibril_condvar_t cv; /**< Broadcast when completed. */ -} device_t; - -/** Hash table of opened devices */ -static hash_table_t devices; - -/** Hash table mutex */ -static FIBRIL_MUTEX_INITIALIZE(devices_mutex); - -#define DEVICES_KEYS 1 -#define DEVICES_KEY_HANDLE 0 -#define DEVICES_BUCKETS 256 - -/* Implementation of hash table interface for the nodes hash table. */ -static hash_index_t devices_hash(unsigned long key[]) -{ - return key[DEVICES_KEY_HANDLE] % DEVICES_BUCKETS; -} - -static int devices_compare(unsigned long key[], hash_count_t keys, link_t *item) -{ - device_t *dev = hash_table_get_instance(item, device_t, link); - return (dev->handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]); -} - -static void devices_remove_callback(link_t *item) -{ - free(hash_table_get_instance(item, device_t, link)); -} - -static hash_table_operations_t devices_ops = { - .hash = devices_hash, - .compare = devices_compare, - .remove_callback = devices_remove_callback -}; - -static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type, - devmap_handle_t handle) -{ - devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t)); - if (node == NULL) { - *rfn = NULL; - return ENOMEM; - } - - *rfn = (fs_node_t *) malloc(sizeof(fs_node_t)); - if (*rfn == NULL) { - free(node); - *rfn = NULL; - return ENOMEM; - } - - fs_node_initialize(*rfn); - node->type = type; - node->handle = handle; - - (*rfn)->data = node; - return EOK; -} - -static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) -{ - return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0); -} - -static int devfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component) -{ - devfs_node_t *node = (devfs_node_t *) pfn->data; - int ret; - - if (node->handle == 0) { - /* Root directory */ - - dev_desc_t *devs; - size_t count = devmap_get_namespaces(&devs); - - if (count > 0) { - size_t pos; - for (pos = 0; pos < count; pos++) { - /* Ignore root namespace */ - if (str_cmp(devs[pos].name, "") == 0) - continue; - - if (str_cmp(devs[pos].name, component) == 0) { - ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle); - free(devs); - return ret; - } - } - - free(devs); - } - - /* Search root namespace */ - devmap_handle_t namespace; - if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { - count = devmap_get_devices(namespace, &devs); - - if (count > 0) { - size_t pos; - for (pos = 0; pos < count; pos++) { - if (str_cmp(devs[pos].name, component) == 0) { - ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle); - free(devs); - return ret; - } - } - - free(devs); - } - } - - *rfn = NULL; - return EOK; - } - - if (node->type == DEV_HANDLE_NAMESPACE) { - /* Namespace directory */ - - dev_desc_t *devs; - size_t count = devmap_get_devices(node->handle, &devs); - if (count > 0) { - size_t pos; - for (pos = 0; pos < count; pos++) { - if (str_cmp(devs[pos].name, component) == 0) { - ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle); - free(devs); - return ret; - } - } - - free(devs); - } - - *rfn = NULL; - return EOK; - } - - *rfn = NULL; - return EOK; -} - -static int devfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) -{ - return devfs_node_get_internal(rfn, devmap_handle_probe(index), index); -} - -static int devfs_node_open(fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - - if (node->handle == 0) { - /* Root directory */ - return EOK; - } - - devmap_handle_type_t type = devmap_handle_probe(node->handle); - - if (type == DEV_HANDLE_NAMESPACE) { - /* Namespace directory */ - return EOK; - } - - if (type == DEV_HANDLE_DEVICE) { - /* Device node */ - - unsigned long key[] = { - [DEVICES_KEY_HANDLE] = (unsigned long) node->handle - }; - link_t *lnk; - - fibril_mutex_lock(&devices_mutex); -restart: - lnk = hash_table_find(&devices, key); - if (lnk == NULL) { - device_t *dev = (device_t *) malloc(sizeof(device_t)); - if (dev == NULL) { - fibril_mutex_unlock(&devices_mutex); - return ENOMEM; - } - - dev->handle = node->handle; - - /* Mark as incomplete */ - dev->sess = NULL; - dev->refcount = 1; - fibril_condvar_initialize(&dev->cv); - - /* - * Insert the incomplete device structure so that other - * fibrils will not race with us when we drop the mutex - * below. - */ - hash_table_insert(&devices, key, &dev->link); - - /* - * Drop the mutex to allow recursive devfs requests. - */ - fibril_mutex_unlock(&devices_mutex); - - async_sess_t *sess = devmap_device_connect(EXCHANGE_SERIALIZE, - node->handle, 0); - - fibril_mutex_lock(&devices_mutex); - - /* - * Notify possible waiters about this device structure - * being completed (or destroyed). - */ - fibril_condvar_broadcast(&dev->cv); - - if (!sess) { - /* - * Connecting failed, need to remove the - * entry and free the device structure. - */ - hash_table_remove(&devices, key, DEVICES_KEYS); - fibril_mutex_unlock(&devices_mutex); - - return ENOENT; - } - - /* Set the correct session. */ - dev->sess = sess; - } else { - device_t *dev = hash_table_get_instance(lnk, device_t, link); - - if (!dev->sess) { - /* - * Wait until the device structure is completed - * and start from the beginning as the device - * structure might have entirely disappeared - * while we were not holding the mutex in - * fibril_condvar_wait(). - */ - fibril_condvar_wait(&dev->cv, &devices_mutex); - goto restart; - } - - dev->refcount++; - } - - fibril_mutex_unlock(&devices_mutex); - - return EOK; - } - - return ENOENT; -} - -static int devfs_node_put(fs_node_t *fn) -{ - free(fn->data); - free(fn); - return EOK; -} - -static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag) -{ - assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); - - *rfn = NULL; - return ENOTSUP; -} - -static int devfs_destroy_node(fs_node_t *fn) -{ - return ENOTSUP; -} - -static int devfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm) -{ - return ENOTSUP; -} - -static int devfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm) -{ - return ENOTSUP; -} - -static int devfs_has_children(bool *has_children, fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - - if (node->handle == 0) { - size_t count = devmap_count_namespaces(); - if (count > 0) { - *has_children = true; - return EOK; - } - - /* Root namespace */ - devmap_handle_t namespace; - if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { - count = devmap_count_devices(namespace); - if (count > 0) { - *has_children = true; - return EOK; - } - } - - *has_children = false; - return EOK; - } - - if (node->type == DEV_HANDLE_NAMESPACE) { - size_t count = devmap_count_devices(node->handle); - if (count > 0) { - *has_children = true; - return EOK; - } - - *has_children = false; - return EOK; - } - - *has_children = false; - return EOK; -} - -static fs_index_t devfs_index_get(fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - return node->handle; -} - -static aoff64_t devfs_size_get(fs_node_t *fn) -{ - return 0; -} - -static unsigned int devfs_lnkcnt_get(fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - - if (node->handle == 0) - return 0; - - return 1; -} - -static bool devfs_is_directory(fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - - return ((node->type == DEV_HANDLE_NONE) || (node->type == DEV_HANDLE_NAMESPACE)); -} - -static bool devfs_is_file(fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - - return (node->type == DEV_HANDLE_DEVICE); -} - -static devmap_handle_t devfs_device_get(fs_node_t *fn) -{ - devfs_node_t *node = (devfs_node_t *) fn->data; - - if (node->type == DEV_HANDLE_DEVICE) - return node->handle; - - return 0; -} - -/** libfs operations */ -libfs_ops_t devfs_libfs_ops = { - .root_get = devfs_root_get, - .match = devfs_match, - .node_get = devfs_node_get, - .node_open = devfs_node_open, - .node_put = devfs_node_put, - .create = devfs_create_node, - .destroy = devfs_destroy_node, - .link = devfs_link_node, - .unlink = devfs_unlink_node, - .has_children = devfs_has_children, - .index_get = devfs_index_get, - .size_get = devfs_size_get, - .lnkcnt_get = devfs_lnkcnt_get, - .is_directory = devfs_is_directory, - .is_file = devfs_is_file, - .device_get = devfs_device_get -}; - -bool devfs_init(void) -{ - if (!hash_table_create(&devices, DEVICES_BUCKETS, - DEVICES_KEYS, &devices_ops)) - return false; - - return true; -} - -static int devfs_mounted(devmap_handle_t devmap_handle, const char *opts, - fs_index_t *index, aoff64_t *size, unsigned *lnkcnt) -{ - *index = 0; - *size = 0; - *lnkcnt = 0; - return EOK; -} - -static int devfs_unmounted(devmap_handle_t devmap_handle) -{ - return ENOTSUP; -} - -static int -devfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, - size_t *rbytes) -{ - if (index == 0) { - ipc_callid_t callid; - size_t size; - if (!async_data_read_receive(&callid, &size)) { - async_answer_0(callid, EINVAL); - return EINVAL; - } - - dev_desc_t *desc; - size_t count = devmap_get_namespaces(&desc); - - /* Get rid of root namespace */ - size_t i; - for (i = 0; i < count; i++) { - if (str_cmp(desc[i].name, "") == 0) { - if (pos >= i) - pos++; - - break; - } - } - - if (pos < count) { - async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); - free(desc); - *rbytes = 1; - return EOK; - } - - free(desc); - pos -= count; - - /* Search root namespace */ - devmap_handle_t namespace; - if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { - count = devmap_get_devices(namespace, &desc); - - if (pos < count) { - async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); - free(desc); - *rbytes = 1; - return EOK; - } - - free(desc); - } - - async_answer_0(callid, ENOENT); - return ENOENT; - } - - devmap_handle_type_t type = devmap_handle_probe(index); - - if (type == DEV_HANDLE_NAMESPACE) { - /* Namespace directory */ - ipc_callid_t callid; - size_t size; - if (!async_data_read_receive(&callid, &size)) { - async_answer_0(callid, EINVAL); - return EINVAL; - } - - dev_desc_t *desc; - size_t count = devmap_get_devices(index, &desc); - - if (pos < count) { - async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); - free(desc); - *rbytes = 1; - return EOK; - } - - free(desc); - async_answer_0(callid, ENOENT); - return ENOENT; - } - - if (type == DEV_HANDLE_DEVICE) { - /* Device node */ - - unsigned long key[] = { - [DEVICES_KEY_HANDLE] = (unsigned long) index - }; - - fibril_mutex_lock(&devices_mutex); - link_t *lnk = hash_table_find(&devices, key); - if (lnk == NULL) { - fibril_mutex_unlock(&devices_mutex); - return ENOENT; - } - - device_t *dev = hash_table_get_instance(lnk, device_t, link); - assert(dev->sess); - - ipc_callid_t callid; - if (!async_data_read_receive(&callid, NULL)) { - fibril_mutex_unlock(&devices_mutex); - async_answer_0(callid, EINVAL); - return EINVAL; - } - - /* Make a request at the driver */ - async_exch_t *exch = async_exchange_begin(dev->sess); - - ipc_call_t answer; - aid_t msg = async_send_4(exch, VFS_OUT_READ, devmap_handle, - index, LOWER32(pos), UPPER32(pos), &answer); - - /* Forward the IPC_M_DATA_READ request to the driver */ - async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); - - async_exchange_end(exch); - - fibril_mutex_unlock(&devices_mutex); - - /* Wait for reply from the driver. */ - sysarg_t rc; - async_wait_for(msg, &rc); - - *rbytes = IPC_GET_ARG1(answer); - return rc; - } - - return ENOENT; -} - -static int -devfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, - size_t *wbytes, aoff64_t *nsize) -{ - if (index == 0) - return ENOTSUP; - - devmap_handle_type_t type = devmap_handle_probe(index); - - if (type == DEV_HANDLE_NAMESPACE) { - /* Namespace directory */ - return ENOTSUP; - } - - if (type == DEV_HANDLE_DEVICE) { - /* Device node */ - unsigned long key[] = { - [DEVICES_KEY_HANDLE] = (unsigned long) index - }; - - fibril_mutex_lock(&devices_mutex); - link_t *lnk = hash_table_find(&devices, key); - if (lnk == NULL) { - fibril_mutex_unlock(&devices_mutex); - return ENOENT; - } - - device_t *dev = hash_table_get_instance(lnk, device_t, link); - assert(dev->sess); - - ipc_callid_t callid; - if (!async_data_write_receive(&callid, NULL)) { - fibril_mutex_unlock(&devices_mutex); - async_answer_0(callid, EINVAL); - return EINVAL; - } - - /* Make a request at the driver */ - async_exch_t *exch = async_exchange_begin(dev->sess); - - ipc_call_t answer; - aid_t msg = async_send_4(exch, VFS_OUT_WRITE, devmap_handle, - index, LOWER32(pos), UPPER32(pos), &answer); - - /* Forward the IPC_M_DATA_WRITE request to the driver */ - async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); - - async_exchange_end(exch); - - fibril_mutex_unlock(&devices_mutex); - - /* Wait for reply from the driver. */ - sysarg_t rc; - async_wait_for(msg, &rc); - - *wbytes = IPC_GET_ARG1(answer); - *nsize = 0; - return rc; - } - - return ENOENT; -} - -static int -devfs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size) -{ - return ENOTSUP; -} - -static int devfs_close(devmap_handle_t devmap_handle, fs_index_t index) -{ - if (index == 0) - return EOK; - - devmap_handle_type_t type = devmap_handle_probe(index); - - if (type == DEV_HANDLE_NAMESPACE) { - /* Namespace directory */ - return EOK; - } - - if (type == DEV_HANDLE_DEVICE) { - unsigned long key[] = { - [DEVICES_KEY_HANDLE] = (unsigned long) index - }; - - fibril_mutex_lock(&devices_mutex); - link_t *lnk = hash_table_find(&devices, key); - if (lnk == NULL) { - fibril_mutex_unlock(&devices_mutex); - return ENOENT; - } - - device_t *dev = hash_table_get_instance(lnk, device_t, link); - assert(dev->sess); - dev->refcount--; - - if (dev->refcount == 0) { - async_hangup(dev->sess); - hash_table_remove(&devices, key, DEVICES_KEYS); - } - - fibril_mutex_unlock(&devices_mutex); - - return EOK; - } - - return ENOENT; -} - -static int devfs_sync(devmap_handle_t devmap_handle, fs_index_t index) -{ - if (index == 0) - return EOK; - - devmap_handle_type_t type = devmap_handle_probe(index); - - if (type == DEV_HANDLE_NAMESPACE) { - /* Namespace directory */ - return EOK; - } - - if (type == DEV_HANDLE_DEVICE) { - unsigned long key[] = { - [DEVICES_KEY_HANDLE] = (unsigned long) index - }; - - fibril_mutex_lock(&devices_mutex); - link_t *lnk = hash_table_find(&devices, key); - if (lnk == NULL) { - fibril_mutex_unlock(&devices_mutex); - return ENOENT; - } - - device_t *dev = hash_table_get_instance(lnk, device_t, link); - assert(dev->sess); - - /* Make a request at the driver */ - async_exch_t *exch = async_exchange_begin(dev->sess); - - ipc_call_t answer; - aid_t msg = async_send_2(exch, VFS_OUT_SYNC, devmap_handle, - index, &answer); - - async_exchange_end(exch); - - fibril_mutex_unlock(&devices_mutex); - - /* Wait for reply from the driver */ - sysarg_t rc; - async_wait_for(msg, &rc); - - return rc; - } - - return ENOENT; -} - -static int devfs_destroy(devmap_handle_t devmap_handle, fs_index_t index) -{ - return ENOTSUP; -} - -vfs_out_ops_t devfs_ops = { - .mounted = devfs_mounted, - .unmounted = devfs_unmounted, - .read = devfs_read, - .write = devfs_write, - .truncate = devfs_truncate, - .close = devfs_close, - .destroy = devfs_destroy, - .sync = devfs_sync, -}; - -/** - * @} - */ Index: uspace/srv/fs/devfs/devfs_ops.h =================================================================== --- uspace/srv/fs/devfs/devfs_ops.h (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ (revision ) @@ -1,44 +1,0 @@ -/* - * Copyright (c) 2009 Martin Decky - * 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 - * @{ - */ - -#ifndef DEVFS_DEVFS_OPS_H_ -#define DEVFS_DEVFS_OPS_H_ - -#include - -extern bool devfs_init(void); - -#endif - -/** - * @} - */ Index: uspace/srv/fs/ext2fs/ext2fs_ops.c =================================================================== --- uspace/srv/fs/ext2fs/ext2fs_ops.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/ext2fs/ext2fs_ops.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -42,5 +42,5 @@ #include #include -#include +#include #include #include @@ -69,5 +69,5 @@ typedef struct ext2fs_instance { link_t link; - devmap_handle_t devmap_handle; + service_id_t service_id; ext2_filesystem_t *filesystem; unsigned int open_nodes_count; @@ -85,5 +85,5 @@ * Forward declarations of auxiliary functions */ -static int ext2fs_instance_get(devmap_handle_t, ext2fs_instance_t **); +static int ext2fs_instance_get(service_id_t, ext2fs_instance_t **); static int ext2fs_read_directory(ipc_callid_t, aoff64_t, size_t, ext2fs_instance_t *, ext2_inode_ref_t *, size_t *); @@ -97,10 +97,10 @@ * Forward declarations of EXT2 libfs operations. */ -static int ext2fs_root_get(fs_node_t **, devmap_handle_t); +static int ext2fs_root_get(fs_node_t **, service_id_t); static int ext2fs_match(fs_node_t **, fs_node_t *, const char *); -static int ext2fs_node_get(fs_node_t **, devmap_handle_t, fs_index_t); +static int ext2fs_node_get(fs_node_t **, service_id_t, fs_index_t); static int ext2fs_node_open(fs_node_t *); static int ext2fs_node_put(fs_node_t *); -static int ext2fs_create_node(fs_node_t **, devmap_handle_t, int); +static int ext2fs_create_node(fs_node_t **, service_id_t, int); static int ext2fs_destroy_node(fs_node_t *); static int ext2fs_link(fs_node_t *, fs_node_t *, const char *); @@ -112,5 +112,5 @@ static bool ext2fs_is_directory(fs_node_t *); static bool ext2fs_is_file(fs_node_t *node); -static devmap_handle_t ext2fs_device_get(fs_node_t *node); +static service_id_t ext2fs_device_get(fs_node_t *node); /* @@ -134,6 +134,6 @@ ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link); assert(keys > 0); - if (enode->instance->devmap_handle != - ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) { + if (enode->instance->service_id != + ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY])) { return false; } @@ -180,9 +180,9 @@ /** - * Find an instance of filesystem for the given devmap_handle - */ -int ext2fs_instance_get(devmap_handle_t devmap_handle, ext2fs_instance_t **inst) -{ - EXT2FS_DBG("(%" PRIun ", -)", devmap_handle); + * Find an instance of filesystem for the given service_id + */ +int ext2fs_instance_get(service_id_t service_id, ext2fs_instance_t **inst) +{ + EXT2FS_DBG("(%" PRIun ", -)", service_id); ext2fs_instance_t *tmp; @@ -198,5 +198,5 @@ tmp = list_get_instance(link, ext2fs_instance_t, link); - if (tmp->devmap_handle == devmap_handle) { + if (tmp->service_id == service_id) { *inst = tmp; fibril_mutex_unlock(&instance_list_mutex); @@ -213,8 +213,8 @@ -int ext2fs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) -{ - EXT2FS_DBG("(-, %" PRIun ")", devmap_handle); - return ext2fs_node_get(rfn, devmap_handle, EXT2_INODE_ROOT_INDEX); +int ext2fs_root_get(fs_node_t **rfn, service_id_t service_id) +{ + EXT2FS_DBG("(-, %" PRIun ")", service_id); + return ext2fs_node_get(rfn, service_id, EXT2_INODE_ROOT_INDEX); } @@ -289,12 +289,12 @@ /** Instantiate a EXT2 in-core node. */ -int ext2fs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) -{ - EXT2FS_DBG("(-,%" PRIun ",%u)", devmap_handle, index); +int ext2fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index) +{ + EXT2FS_DBG("(-,%" PRIun ",%u)", service_id, index); ext2fs_instance_t *inst = NULL; int rc; - rc = ext2fs_instance_get(devmap_handle, &inst); + rc = ext2fs_instance_get(service_id, &inst); if (rc != EOK) { return rc; @@ -317,5 +317,5 @@ /* Check if the node is not already open */ unsigned long key[] = { - [OPEN_NODES_DEV_HANDLE_KEY] = inst->devmap_handle, + [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id, [OPEN_NODES_INODE_KEY] = index, }; @@ -411,5 +411,5 @@ unsigned long key[] = { - [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->devmap_handle, + [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id, [OPEN_NODES_INODE_KEY] = enode->inode_ref->index, }; @@ -429,5 +429,5 @@ } -int ext2fs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags) +int ext2fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags) { EXT2FS_DBG(""); @@ -557,9 +557,9 @@ } -devmap_handle_t ext2fs_device_get(fs_node_t *fn) +service_id_t ext2fs_device_get(fs_node_t *fn) { EXT2FS_DBG(""); ext2fs_node_t *enode = EXT2FS_NODE(fn); - return enode->instance->devmap_handle; + return enode->instance->service_id; } @@ -588,5 +588,5 @@ */ -static int ext2fs_mounted(devmap_handle_t devmap_handle, const char *opts, +static int ext2fs_mounted(service_id_t service_id, const char *opts, fs_index_t *index, aoff64_t *size, unsigned *lnkcnt) { @@ -610,5 +610,5 @@ /* Initialize the filesystem */ - rc = ext2_filesystem_init(fs, devmap_handle); + rc = ext2_filesystem_init(fs, service_id); if (rc != EOK) { free(fs); @@ -637,5 +637,5 @@ /* Initialize instance */ link_initialize(&inst->link); - inst->devmap_handle = devmap_handle; + inst->service_id = service_id; inst->filesystem = fs; inst->open_nodes_count = 0; @@ -666,5 +666,5 @@ } -static int ext2fs_unmounted(devmap_handle_t devmap_handle) +static int ext2fs_unmounted(service_id_t service_id) { EXT2FS_DBG(""); @@ -672,5 +672,5 @@ int rc; - rc = ext2fs_instance_get(devmap_handle, &inst); + rc = ext2fs_instance_get(service_id, &inst); if (rc != EOK) @@ -698,5 +698,5 @@ static int -ext2fs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, +ext2fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos, size_t *rbytes) { @@ -717,5 +717,5 @@ } - rc = ext2fs_instance_get(devmap_handle, &inst); + rc = ext2fs_instance_get(service_id, &inst); if (rc != EOK) { async_answer_0(callid, rc); @@ -907,5 +907,5 @@ /* Usual case - we need to read a block from device */ - rc = block_get(&block, inst->devmap_handle, fs_block, BLOCK_FLAGS_NONE); + rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE); if (rc != EOK) { async_answer_0(callid, rc); @@ -925,5 +925,5 @@ static int -ext2fs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, +ext2fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos, size_t *wbytes, aoff64_t *nsize) { @@ -933,5 +933,5 @@ static int -ext2fs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size) +ext2fs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size) { EXT2FS_DBG(""); @@ -939,11 +939,11 @@ } -static int ext2fs_close(devmap_handle_t devmap_handle, fs_index_t index) -{ - EXT2FS_DBG(""); - return EOK; -} - -static int ext2fs_destroy(devmap_handle_t devmap_handle, fs_index_t index) +static int ext2fs_close(service_id_t service_id, fs_index_t index) +{ + EXT2FS_DBG(""); + return EOK; +} + +static int ext2fs_destroy(service_id_t service_id, fs_index_t index) { EXT2FS_DBG(""); @@ -951,5 +951,5 @@ } -static int ext2fs_sync(devmap_handle_t devmap_handle, fs_index_t index) +static int ext2fs_sync(service_id_t service_id, fs_index_t index) { EXT2FS_DBG(""); Index: uspace/srv/fs/fat/fat.h =================================================================== --- uspace/srv/fs/fat/fat.h (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/fat/fat.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -175,5 +175,5 @@ fibril_mutex_t lock; - devmap_handle_t devmap_handle; + service_id_t service_id; fs_index_t index; /** @@ -227,7 +227,7 @@ extern libfs_ops_t fat_libfs_ops; -extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t); -extern fat_idx_t *fat_idx_get_by_pos(devmap_handle_t, fat_cluster_t, unsigned); -extern fat_idx_t *fat_idx_get_by_index(devmap_handle_t, fs_index_t); +extern int fat_idx_get_new(fat_idx_t **, service_id_t); +extern fat_idx_t *fat_idx_get_by_pos(service_id_t, fat_cluster_t, unsigned); +extern fat_idx_t *fat_idx_get_by_index(service_id_t, fs_index_t); extern void fat_idx_destroy(fat_idx_t *); extern void fat_idx_hashin(fat_idx_t *); @@ -236,6 +236,6 @@ extern int fat_idx_init(void); extern void fat_idx_fini(void); -extern int fat_idx_init_by_devmap_handle(devmap_handle_t); -extern void fat_idx_fini_by_devmap_handle(devmap_handle_t); +extern int fat_idx_init_by_service_id(service_id_t); +extern void fat_idx_fini_by_service_id(service_id_t); #endif Index: uspace/srv/fs/fat/fat_fat.c =================================================================== --- uspace/srv/fs/fat/fat_fat.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/fat/fat_fat.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -71,5 +71,5 @@ * * @param bs Buffer holding the boot sector for the file. - * @param devmap_handle Device handle of the device with the file. + * @param service_id Service ID of the device with the file. * @param firstc First cluster to start the walk with. * @param lastc If non-NULL, output argument hodling the last cluster @@ -82,5 +82,5 @@ */ int -fat_cluster_walk(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc, +fat_cluster_walk(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc, fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters) { @@ -109,5 +109,5 @@ fidx = clst % (BPS(bs) / sizeof(fat_cluster_t)); /* read FAT1 */ - rc = block_get(&b, devmap_handle, RSCNT(bs) + fsec, + rc = block_get(&b, service_id, RSCNT(bs) + fsec, BLOCK_FLAGS_NONE); if (rc != EOK) @@ -160,5 +160,5 @@ * when fortunately we have the last cluster number cached. */ - return block_get(block, nodep->idx->devmap_handle, + return block_get(block, nodep->idx->service_id, CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags); } @@ -174,5 +174,5 @@ fall_through: - rc = _fat_block_get(block, bs, nodep->idx->devmap_handle, firstc, + rc = _fat_block_get(block, bs, nodep->idx->service_id, firstc, &currc, relbn, flags); if (rc != EOK) @@ -193,5 +193,5 @@ * @param block Pointer to a block pointer for storing result. * @param bs Buffer holding the boot sector of the file system. - * @param devmap_handle Device handle of the file system. + * @param service_id Service ID handle of the file system. * @param fcl First cluster used by the file. Can be zero if the file * is empty. @@ -205,5 +205,5 @@ */ int -_fat_block_get(block_t **block, fat_bs_t *bs, devmap_handle_t devmap_handle, +_fat_block_get(block_t **block, fat_bs_t *bs, service_id_t service_id, fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags) { @@ -222,5 +222,5 @@ /* root directory special case */ assert(bn < RDS(bs)); - rc = block_get(block, devmap_handle, + rc = block_get(block, service_id, RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags); return rc; @@ -228,10 +228,10 @@ max_clusters = bn / SPC(bs); - rc = fat_cluster_walk(bs, devmap_handle, fcl, &c, &clusters, max_clusters); + rc = fat_cluster_walk(bs, service_id, fcl, &c, &clusters, max_clusters); if (rc != EOK) return rc; assert(clusters == max_clusters); - rc = block_get(block, devmap_handle, CLBN2PBN(bs, c, bn), flags); + rc = block_get(block, service_id, CLBN2PBN(bs, c, bn), flags); if (clp) @@ -281,5 +281,5 @@ /* zero out the initial part of the new cluster chain */ for (o = boundary; o < pos; o += BPS(bs)) { - rc = _fat_block_get(&b, bs, nodep->idx->devmap_handle, mcl, + rc = _fat_block_get(&b, bs, nodep->idx->service_id, mcl, NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD); if (rc != EOK) @@ -298,5 +298,5 @@ * * @param bs Buffer holding the boot sector for the file system. - * @param devmap_handle Device handle for the file system. + * @param service_id Service ID for the file system. * @param clst Cluster which to get. * @param value Output argument holding the value of the cluster. @@ -305,5 +305,5 @@ */ int -fat_get_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno, +fat_get_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno, fat_cluster_t clst, fat_cluster_t *value) { @@ -312,5 +312,5 @@ int rc; - rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno + + rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno + (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); if (rc != EOK) @@ -327,5 +327,5 @@ * * @param bs Buffer holding the boot sector for the file system. - * @param devmap_handle Device handle for the file system. + * @param service_id Device service ID for the file system. * @param fatno Number of the FAT instance where to make the change. * @param clst Cluster which is to be set. @@ -335,5 +335,5 @@ */ int -fat_set_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno, +fat_set_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno, fat_cluster_t clst, fat_cluster_t value) { @@ -343,5 +343,5 @@ assert(fatno < FATCNT(bs)); - rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno + + rc = block_get(&b, service_id, RSCNT(bs) + SF(bs) * fatno + (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); if (rc != EOK) @@ -358,5 +358,5 @@ * * @param bs Buffer holding the boot sector of the file system. - * @param devmap_handle Device handle of the file system. + * @param service_id Service ID of the file system. * @param lifo Chain of allocated clusters. * @param nclsts Number of clusters in the lifo chain. @@ -364,5 +364,5 @@ * @return EOK on success or a negative error code. */ -int fat_alloc_shadow_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, +int fat_alloc_shadow_clusters(fat_bs_t *bs, service_id_t service_id, fat_cluster_t *lifo, unsigned nclsts) { @@ -373,5 +373,5 @@ for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) { for (c = 0; c < nclsts; c++) { - rc = fat_set_cluster(bs, devmap_handle, fatno, lifo[c], + rc = fat_set_cluster(bs, service_id, fatno, lifo[c], c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]); if (rc != EOK) @@ -391,5 +391,5 @@ * * @param bs Buffer holding the boot sector of the file system. - * @param devmap_handle Device handle of the file system. + * @param service_id Device service ID of the file system. * @param nclsts Number of clusters to allocate. * @param mcl Output parameter where the first cluster in the chain @@ -401,5 +401,5 @@ */ int -fat_alloc_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned nclsts, +fat_alloc_clusters(fat_bs_t *bs, service_id_t service_id, unsigned nclsts, fat_cluster_t *mcl, fat_cluster_t *lcl) { @@ -419,5 +419,5 @@ fibril_mutex_lock(&fat_alloc_lock); for (b = 0, cl = 0; b < SF(bs); b++) { - rc = block_get(&blk, devmap_handle, RSCNT(bs) + b, + rc = block_get(&blk, service_id, RSCNT(bs) + b, BLOCK_FLAGS_NONE); if (rc != EOK) @@ -458,5 +458,5 @@ /* update the shadow copies of FAT */ rc = fat_alloc_shadow_clusters(bs, - devmap_handle, lifo, nclsts); + service_id, lifo, nclsts); if (rc != EOK) goto error; @@ -485,5 +485,5 @@ */ while (found--) { - rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found], + rc = fat_set_cluster(bs, service_id, FAT1, lifo[found], FAT_CLST_RES0); if (rc != EOK) { @@ -500,5 +500,5 @@ * * @param bs Buffer hodling the boot sector of the file system. - * @param devmap_handle Device handle of the file system. + * @param service_id Device service ID of the file system. * @param firstc First cluster in the chain which is to be freed. * @@ -506,5 +506,5 @@ */ int -fat_free_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc) +fat_free_clusters(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc) { unsigned fatno; @@ -515,9 +515,9 @@ while (firstc < FAT_CLST_LAST1) { assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD); - rc = fat_get_cluster(bs, devmap_handle, FAT1, firstc, &nextc); + rc = fat_get_cluster(bs, service_id, FAT1, firstc, &nextc); if (rc != EOK) return rc; for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { - rc = fat_set_cluster(bs, devmap_handle, fatno, firstc, + rc = fat_set_cluster(bs, service_id, fatno, firstc, FAT_CLST_RES0); if (rc != EOK) @@ -544,5 +544,5 @@ fat_cluster_t lcl) { - devmap_handle_t devmap_handle = nodep->idx->devmap_handle; + service_id_t service_id = nodep->idx->service_id; fat_cluster_t lastc; uint8_t fatno; @@ -558,5 +558,5 @@ nodep->lastc_cached_valid = false; } else { - rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc, + rc = fat_cluster_walk(bs, service_id, nodep->firstc, &lastc, NULL, (uint16_t) -1); if (rc != EOK) @@ -565,5 +565,5 @@ for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { - rc = fat_set_cluster(bs, nodep->idx->devmap_handle, fatno, + rc = fat_set_cluster(bs, nodep->idx->service_id, fatno, lastc, mcl); if (rc != EOK) @@ -591,5 +591,5 @@ { int rc; - devmap_handle_t devmap_handle = nodep->idx->devmap_handle; + service_id_t service_id = nodep->idx->service_id; /* @@ -602,5 +602,5 @@ if (lcl == FAT_CLST_RES0) { /* The node will have zero size and no clusters allocated. */ - rc = fat_free_clusters(bs, devmap_handle, nodep->firstc); + rc = fat_free_clusters(bs, service_id, nodep->firstc); if (rc != EOK) return rc; @@ -611,5 +611,5 @@ unsigned fatno; - rc = fat_get_cluster(bs, devmap_handle, FAT1, lcl, &nextc); + rc = fat_get_cluster(bs, service_id, FAT1, lcl, &nextc); if (rc != EOK) return rc; @@ -617,5 +617,5 @@ /* Terminate the cluster chain in all copies of FAT. */ for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { - rc = fat_set_cluster(bs, devmap_handle, fatno, lcl, + rc = fat_set_cluster(bs, service_id, fatno, lcl, FAT_CLST_LAST1); if (rc != EOK) @@ -624,5 +624,5 @@ /* Free all following clusters. */ - rc = fat_free_clusters(bs, devmap_handle, nextc); + rc = fat_free_clusters(bs, service_id, nextc); if (rc != EOK) return rc; @@ -639,5 +639,5 @@ int -fat_zero_cluster(struct fat_bs *bs, devmap_handle_t devmap_handle, fat_cluster_t c) +fat_zero_cluster(struct fat_bs *bs, service_id_t service_id, fat_cluster_t c) { int i; @@ -646,5 +646,5 @@ for (i = 0; i < SPC(bs); i++) { - rc = _fat_block_get(&b, bs, devmap_handle, c, NULL, i, + rc = _fat_block_get(&b, bs, service_id, c, NULL, i, BLOCK_FLAGS_NOREAD); if (rc != EOK) @@ -666,5 +666,5 @@ * does not contain a fat file system. */ -int fat_sanity_check(fat_bs_t *bs, devmap_handle_t devmap_handle) +int fat_sanity_check(fat_bs_t *bs, service_id_t service_id) { fat_cluster_t e0, e1; @@ -707,9 +707,9 @@ for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) { - rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0); + rc = fat_get_cluster(bs, service_id, fat_no, 0, &e0); if (rc != EOK) return EIO; - rc = fat_get_cluster(bs, devmap_handle, fat_no, 1, &e1); + rc = fat_get_cluster(bs, service_id, fat_no, 1, &e1); if (rc != EOK) return EIO; Index: uspace/srv/fs/fat/fat_fat.h =================================================================== --- uspace/srv/fs/fat/fat_fat.h (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/fat/fat_fat.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -61,10 +61,10 @@ #define fat_clusters_get(numc, bs, dh, fc) \ fat_cluster_walk((bs), (dh), (fc), NULL, (numc), (uint16_t) -1) -extern int fat_cluster_walk(struct fat_bs *, devmap_handle_t, fat_cluster_t, +extern int fat_cluster_walk(struct fat_bs *, service_id_t, fat_cluster_t, fat_cluster_t *, uint16_t *, uint16_t); extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *, aoff64_t, int); -extern int _fat_block_get(block_t **, struct fat_bs *, devmap_handle_t, +extern int _fat_block_get(block_t **, struct fat_bs *, service_id_t, fat_cluster_t, fat_cluster_t *, aoff64_t, int); @@ -73,17 +73,17 @@ extern int fat_chop_clusters(struct fat_bs *, struct fat_node *, fat_cluster_t); -extern int fat_alloc_clusters(struct fat_bs *, devmap_handle_t, unsigned, +extern int fat_alloc_clusters(struct fat_bs *, service_id_t, unsigned, fat_cluster_t *, fat_cluster_t *); -extern int fat_free_clusters(struct fat_bs *, devmap_handle_t, fat_cluster_t); -extern int fat_alloc_shadow_clusters(struct fat_bs *, devmap_handle_t, +extern int fat_free_clusters(struct fat_bs *, service_id_t, fat_cluster_t); +extern int fat_alloc_shadow_clusters(struct fat_bs *, service_id_t, fat_cluster_t *, unsigned); -extern int fat_get_cluster(struct fat_bs *, devmap_handle_t, unsigned, +extern int fat_get_cluster(struct fat_bs *, service_id_t, unsigned, fat_cluster_t, fat_cluster_t *); -extern int fat_set_cluster(struct fat_bs *, devmap_handle_t, unsigned, +extern int fat_set_cluster(struct fat_bs *, service_id_t, unsigned, fat_cluster_t, fat_cluster_t); extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t, aoff64_t); -extern int fat_zero_cluster(struct fat_bs *, devmap_handle_t, fat_cluster_t); -extern int fat_sanity_check(struct fat_bs *, devmap_handle_t); +extern int fat_zero_cluster(struct fat_bs *, service_id_t, fat_cluster_t); +extern int fat_sanity_check(struct fat_bs *, service_id_t); #endif Index: uspace/srv/fs/fat/fat_idx.c =================================================================== --- uspace/srv/fs/fat/fat_idx.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/fat/fat_idx.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -59,5 +59,5 @@ typedef struct { link_t link; - devmap_handle_t devmap_handle; + service_id_t service_id; /** Next unassigned index. */ @@ -76,8 +76,8 @@ static LIST_INITIALIZE(unused_list); -static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle) +static void unused_initialize(unused_t *u, service_id_t service_id) { link_initialize(&u->link); - u->devmap_handle = devmap_handle; + u->service_id = service_id; u->next = 0; u->remaining = ((uint64_t)((fs_index_t)-1)) + 1; @@ -85,5 +85,5 @@ } -static unused_t *unused_find(devmap_handle_t devmap_handle, bool lock) +static unused_t *unused_find(service_id_t service_id, bool lock) { unused_t *u; @@ -94,5 +94,5 @@ list_foreach(unused_list, l) { u = list_get_instance(l, unused_t, link); - if (u->devmap_handle == devmap_handle) + if (u->service_id == service_id) return u; } @@ -108,5 +108,5 @@ /** * Global hash table of all used fat_idx_t structures. - * The index structures are hashed by the devmap_handle, parent node's first + * The index structures are hashed by the service_id, parent node's first * cluster and index within the parent directory. */ @@ -122,5 +122,5 @@ static hash_index_t pos_hash(unsigned long key[]) { - devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY]; + service_id_t service_id = (service_id_t)key[UPH_DH_KEY]; fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY]; unsigned pdi = (unsigned)key[UPH_PDI_KEY]; @@ -142,5 +142,5 @@ h |= (pdi & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) << (UPH_BUCKETS_LOG / 2); - h |= (devmap_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) << + h |= (service_id & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) << (3 * (UPH_BUCKETS_LOG / 4)); @@ -150,5 +150,5 @@ static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item) { - devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY]; + service_id_t service_id = (service_id_t)key[UPH_DH_KEY]; fat_cluster_t pfc; unsigned pdi; @@ -157,9 +157,9 @@ switch (keys) { case 1: - return (devmap_handle == fidx->devmap_handle); + return (service_id == fidx->service_id); case 3: pfc = (fat_cluster_t) key[UPH_PFC_KEY]; pdi = (unsigned) key[UPH_PDI_KEY]; - return (devmap_handle == fidx->devmap_handle) && (pfc == fidx->pfc) && + return (service_id == fidx->service_id) && (pfc == fidx->pfc) && (pdi == fidx->pdi); default: @@ -183,5 +183,5 @@ /** * Global hash table of all used fat_idx_t structures. - * The index structures are hashed by the devmap_handle and index. + * The index structures are hashed by the service_id and index. */ static hash_table_t ui_hash; @@ -195,10 +195,10 @@ static hash_index_t idx_hash(unsigned long key[]) { - devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY]; + service_id_t service_id = (service_id_t)key[UIH_DH_KEY]; fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY]; hash_index_t h; - h = devmap_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1); + h = service_id & ((1 << (UIH_BUCKETS_LOG / 2)) - 1); h |= (index & ((1 << (UIH_BUCKETS_LOG / 2)) - 1)) << (UIH_BUCKETS_LOG / 2); @@ -209,5 +209,5 @@ static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item) { - devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY]; + service_id_t service_id = (service_id_t)key[UIH_DH_KEY]; fs_index_t index; fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link); @@ -215,8 +215,8 @@ switch (keys) { case 1: - return (devmap_handle == fidx->devmap_handle); + return (service_id == fidx->service_id); case 2: index = (fs_index_t) key[UIH_INDEX_KEY]; - return (devmap_handle == fidx->devmap_handle) && + return (service_id == fidx->service_id) && (index == fidx->index); default: @@ -241,10 +241,10 @@ /** Allocate a VFS index which is not currently in use. */ -static bool fat_index_alloc(devmap_handle_t devmap_handle, fs_index_t *index) +static bool fat_index_alloc(service_id_t service_id, fs_index_t *index) { unused_t *u; assert(index); - u = unused_find(devmap_handle, true); + u = unused_find(service_id, true); if (!u) return false; @@ -303,9 +303,9 @@ /** Free a VFS index, which is no longer in use. */ -static void fat_index_free(devmap_handle_t devmap_handle, fs_index_t index) +static void fat_index_free(service_id_t service_id, fs_index_t index) { unused_t *u; - u = unused_find(devmap_handle, true); + u = unused_find(service_id, true); assert(u); @@ -365,5 +365,5 @@ } -static int fat_idx_create(fat_idx_t **fidxp, devmap_handle_t devmap_handle) +static int fat_idx_create(fat_idx_t **fidxp, service_id_t service_id) { fat_idx_t *fidx; @@ -372,5 +372,5 @@ if (!fidx) return ENOMEM; - if (!fat_index_alloc(devmap_handle, &fidx->index)) { + if (!fat_index_alloc(service_id, &fidx->index)) { free(fidx); return ENOSPC; @@ -380,5 +380,5 @@ link_initialize(&fidx->uih_link); fibril_mutex_initialize(&fidx->lock); - fidx->devmap_handle = devmap_handle; + fidx->service_id = service_id; fidx->pfc = FAT_CLST_RES0; /* no parent yet */ fidx->pdi = 0; @@ -389,5 +389,5 @@ } -int fat_idx_get_new(fat_idx_t **fidxp, devmap_handle_t devmap_handle) +int fat_idx_get_new(fat_idx_t **fidxp, service_id_t service_id) { fat_idx_t *fidx; @@ -395,5 +395,5 @@ fibril_mutex_lock(&used_lock); - rc = fat_idx_create(&fidx, devmap_handle); + rc = fat_idx_create(&fidx, service_id); if (rc != EOK) { fibril_mutex_unlock(&used_lock); @@ -402,5 +402,5 @@ unsigned long ikey[] = { - [UIH_DH_KEY] = devmap_handle, + [UIH_DH_KEY] = service_id, [UIH_INDEX_KEY] = fidx->index, }; @@ -415,10 +415,10 @@ fat_idx_t * -fat_idx_get_by_pos(devmap_handle_t devmap_handle, fat_cluster_t pfc, unsigned pdi) +fat_idx_get_by_pos(service_id_t service_id, fat_cluster_t pfc, unsigned pdi) { fat_idx_t *fidx; link_t *l; unsigned long pkey[] = { - [UPH_DH_KEY] = devmap_handle, + [UPH_DH_KEY] = service_id, [UPH_PFC_KEY] = pfc, [UPH_PDI_KEY] = pdi, @@ -432,5 +432,5 @@ int rc; - rc = fat_idx_create(&fidx, devmap_handle); + rc = fat_idx_create(&fidx, service_id); if (rc != EOK) { fibril_mutex_unlock(&used_lock); @@ -439,5 +439,5 @@ unsigned long ikey[] = { - [UIH_DH_KEY] = devmap_handle, + [UIH_DH_KEY] = service_id, [UIH_INDEX_KEY] = fidx->index, }; @@ -458,5 +458,5 @@ { unsigned long pkey[] = { - [UPH_DH_KEY] = idx->devmap_handle, + [UPH_DH_KEY] = idx->service_id, [UPH_PFC_KEY] = idx->pfc, [UPH_PDI_KEY] = idx->pdi, @@ -471,5 +471,5 @@ { unsigned long pkey[] = { - [UPH_DH_KEY] = idx->devmap_handle, + [UPH_DH_KEY] = idx->service_id, [UPH_PFC_KEY] = idx->pfc, [UPH_PDI_KEY] = idx->pdi, @@ -482,10 +482,10 @@ fat_idx_t * -fat_idx_get_by_index(devmap_handle_t devmap_handle, fs_index_t index) +fat_idx_get_by_index(service_id_t service_id, fs_index_t index) { fat_idx_t *fidx = NULL; link_t *l; unsigned long ikey[] = { - [UIH_DH_KEY] = devmap_handle, + [UIH_DH_KEY] = service_id, [UIH_INDEX_KEY] = index, }; @@ -509,8 +509,8 @@ { unsigned long ikey[] = { - [UIH_DH_KEY] = idx->devmap_handle, + [UIH_DH_KEY] = idx->service_id, [UIH_INDEX_KEY] = idx->index, }; - devmap_handle_t devmap_handle = idx->devmap_handle; + service_id_t service_id = idx->service_id; fs_index_t index = idx->index; @@ -526,5 +526,5 @@ fibril_mutex_unlock(&used_lock); /* Release the VFS index. */ - fat_index_free(devmap_handle, index); + fat_index_free(service_id, index); /* The index structure itself is freed in idx_remove_callback(). */ } @@ -548,5 +548,5 @@ } -int fat_idx_init_by_devmap_handle(devmap_handle_t devmap_handle) +int fat_idx_init_by_service_id(service_id_t service_id) { unused_t *u; @@ -556,7 +556,7 @@ if (!u) return ENOMEM; - unused_initialize(u, devmap_handle); + unused_initialize(u, service_id); fibril_mutex_lock(&unused_lock); - if (!unused_find(devmap_handle, false)) { + if (!unused_find(service_id, false)) { list_append(&u->link, &unused_list); } else { @@ -568,11 +568,11 @@ } -void fat_idx_fini_by_devmap_handle(devmap_handle_t devmap_handle) +void fat_idx_fini_by_service_id(service_id_t service_id) { unsigned long ikey[] = { - [UIH_DH_KEY] = devmap_handle + [UIH_DH_KEY] = service_id }; unsigned long pkey[] = { - [UPH_DH_KEY] = devmap_handle + [UPH_DH_KEY] = service_id }; @@ -590,5 +590,5 @@ * Free the unused and freed structures for this instance. */ - unused_t *u = unused_find(devmap_handle, true); + unused_t *u = unused_find(service_id, true); assert(u); list_remove(&u->link); Index: uspace/srv/fs/fat/fat_ops.c =================================================================== --- uspace/srv/fs/fat/fat_ops.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/fat/fat_ops.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -43,5 +43,5 @@ #include #include -#include +#include #include #include @@ -72,10 +72,10 @@ * Forward declarations of FAT libfs operations. */ -static int fat_root_get(fs_node_t **, devmap_handle_t); +static int fat_root_get(fs_node_t **, service_id_t); static int fat_match(fs_node_t **, fs_node_t *, const char *); -static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t); +static int fat_node_get(fs_node_t **, service_id_t, fs_index_t); static int fat_node_open(fs_node_t *); static int fat_node_put(fs_node_t *); -static int fat_create_node(fs_node_t **, devmap_handle_t, int); +static int fat_create_node(fs_node_t **, service_id_t, int); static int fat_destroy_node(fs_node_t *); static int fat_link(fs_node_t *, fs_node_t *, const char *); @@ -87,5 +87,5 @@ static bool fat_is_directory(fs_node_t *); static bool fat_is_file(fs_node_t *node); -static devmap_handle_t fat_device_get(fs_node_t *node); +static service_id_t fat_device_get(fs_node_t *node); /* @@ -119,8 +119,8 @@ assert(node->dirty); - bs = block_bb_get(node->idx->devmap_handle); + bs = block_bb_get(node->idx->service_id); /* Read the block that contains the dentry of interest. */ - rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc, + rc = _fat_block_get(&b, bs, node->idx->service_id, node->idx->pfc, NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE); @@ -144,5 +144,5 @@ } -static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle) +static int fat_node_fini_by_service_id(service_id_t service_id) { fat_node_t *nodep; @@ -168,5 +168,5 @@ goto restart; } - if (nodep->idx->devmap_handle != devmap_handle) { + if (nodep->idx->service_id != service_id) { fibril_mutex_unlock(&nodep->idx->lock); fibril_mutex_unlock(&nodep->lock); @@ -298,8 +298,8 @@ return rc; - bs = block_bb_get(idxp->devmap_handle); + bs = block_bb_get(idxp->service_id); /* Read the block that contains the dentry of interest. */ - rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL, + rc = _fat_block_get(&b, bs, idxp->service_id, idxp->pfc, NULL, (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE); if (rc != EOK) { @@ -322,5 +322,5 @@ */ uint16_t clusters; - rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle, + rc = fat_clusters_get(&clusters, bs, idxp->service_id, uint16_t_le2host(d->firstc)); if (rc != EOK) { @@ -356,7 +356,7 @@ */ -int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) -{ - return fat_node_get(rfn, devmap_handle, 0); +int fat_root_get(fs_node_t **rfn, service_id_t service_id) +{ + return fat_node_get(rfn, service_id, 0); } @@ -369,13 +369,13 @@ unsigned blocks; fat_dentry_t *d; - devmap_handle_t devmap_handle; + service_id_t service_id; block_t *b; int rc; fibril_mutex_lock(&parentp->idx->lock); - devmap_handle = parentp->idx->devmap_handle; + service_id = parentp->idx->service_id; fibril_mutex_unlock(&parentp->idx->lock); - bs = block_bb_get(devmap_handle); + bs = block_bb_get(service_id); blocks = parentp->size / BPS(bs); for (i = 0; i < blocks; i++) { @@ -402,5 +402,5 @@ /* hit */ fat_node_t *nodep; - fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle, + fat_idx_t *idx = fat_idx_get_by_pos(service_id, parentp->firstc, i * DPS(bs) + j); if (!idx) { @@ -435,5 +435,5 @@ /** Instantiate a FAT in-core node. */ -int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) +int fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index) { fat_node_t *nodep; @@ -441,5 +441,5 @@ int rc; - idxp = fat_idx_get_by_index(devmap_handle, index); + idxp = fat_idx_get_by_index(service_id, index); if (!idxp) { *rfn = NULL; @@ -492,5 +492,5 @@ } -int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags) +int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags) { fat_idx_t *idxp; @@ -500,14 +500,14 @@ int rc; - bs = block_bb_get(devmap_handle); + bs = block_bb_get(service_id); if (flags & L_DIRECTORY) { /* allocate a cluster */ - rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl); + rc = fat_alloc_clusters(bs, service_id, 1, &mcl, &lcl); if (rc != EOK) return rc; /* populate the new cluster with unused dentries */ - rc = fat_zero_cluster(bs, devmap_handle, mcl); + rc = fat_zero_cluster(bs, service_id, mcl); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); + (void) fat_free_clusters(bs, service_id, mcl); return rc; } @@ -516,10 +516,10 @@ rc = fat_node_get_new(&nodep); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); - return rc; - } - rc = fat_idx_get_new(&idxp, devmap_handle); + (void) fat_free_clusters(bs, service_id, mcl); + return rc; + } + rc = fat_idx_get_new(&idxp, service_id); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); + (void) fat_free_clusters(bs, service_id, mcl); (void) fat_node_put(FS_NODE(nodep)); return rc; @@ -570,9 +570,9 @@ assert(!has_children); - bs = block_bb_get(nodep->idx->devmap_handle); + bs = block_bb_get(nodep->idx->service_id); if (nodep->firstc != FAT_CLST_RES0) { assert(nodep->size); /* Free all clusters allocated to the node. */ - rc = fat_free_clusters(bs, nodep->idx->devmap_handle, + rc = fat_free_clusters(bs, nodep->idx->service_id, nodep->firstc); } @@ -620,5 +620,5 @@ fibril_mutex_lock(&parentp->idx->lock); - bs = block_bb_get(parentp->idx->devmap_handle); + bs = block_bb_get(parentp->idx->service_id); blocks = parentp->size / BPS(bs); @@ -659,12 +659,12 @@ return ENOSPC; } - rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl); + rc = fat_alloc_clusters(bs, parentp->idx->service_id, 1, &mcl, &lcl); if (rc != EOK) { fibril_mutex_unlock(&parentp->idx->lock); return rc; } - rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl); + rc = fat_zero_cluster(bs, parentp->idx->service_id, mcl); if (rc != EOK) { - (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl); + (void) fat_free_clusters(bs, parentp->idx->service_id, mcl); fibril_mutex_unlock(&parentp->idx->lock); return rc; @@ -672,5 +672,5 @@ rc = fat_append_clusters(bs, parentp, mcl, lcl); if (rc != EOK) { - (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl); + (void) fat_free_clusters(bs, parentp->idx->service_id, mcl); fibril_mutex_unlock(&parentp->idx->lock); return rc; @@ -789,7 +789,7 @@ assert(childp->lnkcnt == 1); fibril_mutex_lock(&childp->idx->lock); - bs = block_bb_get(childp->idx->devmap_handle); - - rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc, + bs = block_bb_get(childp->idx->service_id); + + rc = _fat_block_get(&b, bs, childp->idx->service_id, childp->idx->pfc, NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE); @@ -841,5 +841,5 @@ fibril_mutex_lock(&nodep->idx->lock); - bs = block_bb_get(nodep->idx->devmap_handle); + bs = block_bb_get(nodep->idx->service_id); blocks = nodep->size / BPS(bs); @@ -910,5 +910,5 @@ } -devmap_handle_t fat_device_get(fs_node_t *node) +service_id_t fat_device_get(fs_node_t *node) { return 0; @@ -940,5 +940,5 @@ static int -fat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index, +fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index, aoff64_t *size, unsigned *linkcnt) { @@ -954,42 +954,42 @@ /* initialize libblock */ - rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE); + rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE); if (rc != EOK) return rc; /* prepare the boot block */ - rc = block_bb_read(devmap_handle, BS_BLOCK); + rc = block_bb_read(service_id, BS_BLOCK); if (rc != EOK) { - block_fini(devmap_handle); + block_fini(service_id); return rc; } /* get the buffer with the boot sector */ - bs = block_bb_get(devmap_handle); + bs = block_bb_get(service_id); if (BPS(bs) != BS_SIZE) { - block_fini(devmap_handle); + block_fini(service_id); return ENOTSUP; } /* Initialize the block cache */ - rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode); + rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode); if (rc != EOK) { - block_fini(devmap_handle); + block_fini(service_id); return rc; } /* Do some simple sanity checks on the file system. */ - rc = fat_sanity_check(bs, devmap_handle); + rc = fat_sanity_check(bs, service_id); if (rc != EOK) { - (void) block_cache_fini(devmap_handle); - block_fini(devmap_handle); - return rc; - } - - rc = fat_idx_init_by_devmap_handle(devmap_handle); + (void) block_cache_fini(service_id); + block_fini(service_id); + return rc; + } + + rc = fat_idx_init_by_service_id(service_id); if (rc != EOK) { - (void) block_cache_fini(devmap_handle); - block_fini(devmap_handle); + (void) block_cache_fini(service_id); + block_fini(service_id); return rc; } @@ -998,7 +998,7 @@ fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t)); if (!rfn) { - (void) block_cache_fini(devmap_handle); - block_fini(devmap_handle); - fat_idx_fini_by_devmap_handle(devmap_handle); + (void) block_cache_fini(service_id); + block_fini(service_id); + fat_idx_fini_by_service_id(service_id); return ENOMEM; } @@ -1007,18 +1007,18 @@ if (!rootp) { free(rfn); - (void) block_cache_fini(devmap_handle); - block_fini(devmap_handle); - fat_idx_fini_by_devmap_handle(devmap_handle); + (void) block_cache_fini(service_id); + block_fini(service_id); + fat_idx_fini_by_service_id(service_id); return ENOMEM; } fat_node_initialize(rootp); - fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0); + fat_idx_t *ridxp = fat_idx_get_by_pos(service_id, FAT_CLST_ROOTPAR, 0); if (!ridxp) { free(rfn); free(rootp); - (void) block_cache_fini(devmap_handle); - block_fini(devmap_handle); - fat_idx_fini_by_devmap_handle(devmap_handle); + (void) block_cache_fini(service_id); + block_fini(service_id); + fat_idx_fini_by_service_id(service_id); return ENOMEM; } @@ -1045,5 +1045,5 @@ } -static int fat_unmounted(devmap_handle_t devmap_handle) +static int fat_unmounted(service_id_t service_id) { fs_node_t *fn; @@ -1051,5 +1051,5 @@ int rc; - rc = fat_root_get(&fn, devmap_handle); + rc = fat_root_get(&fn, service_id); if (rc != EOK) return rc; @@ -1076,8 +1076,8 @@ * stop using libblock for this instance. */ - (void) fat_node_fini_by_devmap_handle(devmap_handle); - fat_idx_fini_by_devmap_handle(devmap_handle); - (void) block_cache_fini(devmap_handle); - block_fini(devmap_handle); + (void) fat_node_fini_by_service_id(service_id); + fat_idx_fini_by_service_id(service_id); + (void) block_cache_fini(service_id); + block_fini(service_id); return EOK; @@ -1085,5 +1085,5 @@ static int -fat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, +fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos, size_t *rbytes) { @@ -1095,5 +1095,5 @@ int rc; - rc = fat_node_get(&fn, devmap_handle, index); + rc = fat_node_get(&fn, service_id, index); if (rc != EOK) return rc; @@ -1110,5 +1110,5 @@ } - bs = block_bb_get(devmap_handle); + bs = block_bb_get(service_id); if (nodep->type == FAT_FILE) { @@ -1213,5 +1213,5 @@ static int -fat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, +fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos, size_t *wbytes, aoff64_t *nsize) { @@ -1225,5 +1225,5 @@ int rc; - rc = fat_node_get(&fn, devmap_handle, index); + rc = fat_node_get(&fn, service_id, index); if (rc != EOK) return rc; @@ -1240,5 +1240,5 @@ } - bs = block_bb_get(devmap_handle); + bs = block_bb_get(service_id); /* @@ -1299,5 +1299,5 @@ nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs); /* create an independent chain of nclsts clusters in all FATs */ - rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl); + rc = fat_alloc_clusters(bs, service_id, nclsts, &mcl, &lcl); if (rc != EOK) { /* could not allocate a chain of nclsts clusters */ @@ -1309,13 +1309,13 @@ rc = fat_fill_gap(bs, nodep, mcl, pos); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); + (void) fat_free_clusters(bs, service_id, mcl); (void) fat_node_put(fn); async_answer_0(callid, rc); return rc; } - rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL, + rc = _fat_block_get(&b, bs, service_id, lcl, NULL, (pos / BPS(bs)) % SPC(bs), flags); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); + (void) fat_free_clusters(bs, service_id, mcl); (void) fat_node_put(fn); async_answer_0(callid, rc); @@ -1327,5 +1327,5 @@ rc = block_put(b); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); + (void) fat_free_clusters(bs, service_id, mcl); (void) fat_node_put(fn); return rc; @@ -1337,5 +1337,5 @@ rc = fat_append_clusters(bs, nodep, mcl, lcl); if (rc != EOK) { - (void) fat_free_clusters(bs, devmap_handle, mcl); + (void) fat_free_clusters(bs, service_id, mcl); (void) fat_node_put(fn); return rc; @@ -1350,5 +1350,5 @@ static int -fat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size) +fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size) { fs_node_t *fn; @@ -1357,5 +1357,5 @@ int rc; - rc = fat_node_get(&fn, devmap_handle, index); + rc = fat_node_get(&fn, service_id, index); if (rc != EOK) return rc; @@ -1364,5 +1364,5 @@ nodep = FAT_NODE(fn); - bs = block_bb_get(devmap_handle); + bs = block_bb_get(service_id); if (nodep->size == size) { @@ -1391,5 +1391,5 @@ } else { fat_cluster_t lastc; - rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc, + rc = fat_cluster_walk(bs, service_id, nodep->firstc, &lastc, NULL, (size - 1) / BPC(bs)); if (rc != EOK) @@ -1408,10 +1408,10 @@ } -static int fat_close(devmap_handle_t devmap_handle, fs_index_t index) +static int fat_close(service_id_t service_id, fs_index_t index) { return EOK; } -static int fat_destroy(devmap_handle_t devmap_handle, fs_index_t index) +static int fat_destroy(service_id_t service_id, fs_index_t index) { fs_node_t *fn; @@ -1419,5 +1419,5 @@ int rc; - rc = fat_node_get(&fn, devmap_handle, index); + rc = fat_node_get(&fn, service_id, index); if (rc != EOK) return rc; @@ -1436,8 +1436,8 @@ } -static int fat_sync(devmap_handle_t devmap_handle, fs_index_t index) +static int fat_sync(service_id_t service_id, fs_index_t index) { fs_node_t *fn; - int rc = fat_node_get(&fn, devmap_handle, index); + int rc = fat_node_get(&fn, service_id, index); if (rc != EOK) return rc; Index: uspace/srv/fs/locfs/Makefile =================================================================== --- uspace/srv/fs/locfs/Makefile (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) +++ uspace/srv/fs/locfs/Makefile (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -0,0 +1,40 @@ +# +# Copyright (c) 2005 Martin Decky +# Copyright (c) 2007 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. +# + +USPACE_PREFIX = ../../.. +LIBS = $(LIBFS_PREFIX)/libfs.a +EXTRA_CFLAGS += -I$(LIBFS_PREFIX) +BINARY = locfs +STATIC_NEEDED = y + +SOURCES = \ + locfs.c \ + locfs_ops.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/fs/locfs/locfs.c =================================================================== --- uspace/srv/fs/locfs/locfs.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) +++ uspace/srv/fs/locfs/locfs.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2009 Martin Decky + * 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 locfs.c + * @brief Location-service file system. + * + * Every service registered with location service is represented as a file in this + * file system. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "locfs.h" +#include "locfs_ops.h" + +#define NAME "locfs" + +static vfs_info_t locfs_vfs_info = { + .name = NAME, + .concurrent_read_write = false, + .write_retains_size = false, +}; + +int main(int argc, char *argv[]) +{ + printf("%s: HelenOS Device Filesystem\n", NAME); + + if (!locfs_init()) { + printf("%s: failed to initialize locfs\n", NAME); + return -1; + } + + async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_VFS, 0, 0); + if (!vfs_sess) { + printf("%s: Unable to connect to VFS\n", NAME); + return -1; + } + + int rc = fs_register(vfs_sess, &locfs_vfs_info, &locfs_ops, + &locfs_libfs_ops); + if (rc != EOK) { + printf("%s: Failed to register file system (%d)\n", NAME, rc); + return rc; + } + + printf("%s: Accepting connections\n", NAME); + task_retval(0); + async_manager(); + + /* Not reached */ + return 0; +} + +/** + * @} + */ + Index: uspace/srv/fs/locfs/locfs.h =================================================================== --- uspace/srv/fs/locfs/locfs.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) +++ uspace/srv/fs/locfs/locfs.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2009 Martin Decky + * 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 + * @{ + */ + +#ifndef LOCFS_LOCFS_H_ +#define LOCFS_LOCFS_H_ + +#include + +extern vfs_out_ops_t locfs_ops; +extern libfs_ops_t locfs_libfs_ops; + +#endif + +/** + * @} + */ Index: uspace/srv/fs/locfs/locfs_ops.c =================================================================== --- uspace/srv/fs/locfs/locfs_ops.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) +++ uspace/srv/fs/locfs/locfs_ops.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -0,0 +1,779 @@ +/* + * Copyright (c) 2009 Martin Decky + * 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 locfs_ops.c + * @brief Implementation of VFS operations for the locfs file system server. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "locfs.h" +#include "locfs_ops.h" + +typedef struct { + loc_object_type_t type; + service_id_t service_id; +} locfs_node_t; + +/** Opened services structure */ +typedef struct { + service_id_t service_id; + async_sess_t *sess; /**< If NULL, the structure is incomplete. */ + size_t refcount; + link_t link; + fibril_condvar_t cv; /**< Broadcast when completed. */ +} service_t; + +/** Hash table of opened services */ +static hash_table_t services; + +/** Hash table mutex */ +static FIBRIL_MUTEX_INITIALIZE(services_mutex); + +#define SERVICES_KEYS 1 +#define SERVICES_KEY_HANDLE 0 +#define SERVICES_BUCKETS 256 + +/* Implementation of hash table interface for the nodes hash table. */ +static hash_index_t services_hash(unsigned long key[]) +{ + return key[SERVICES_KEY_HANDLE] % SERVICES_BUCKETS; +} + +static int services_compare(unsigned long key[], hash_count_t keys, link_t *item) +{ + service_t *dev = hash_table_get_instance(item, service_t, link); + return (dev->service_id == (service_id_t) key[SERVICES_KEY_HANDLE]); +} + +static void services_remove_callback(link_t *item) +{ + free(hash_table_get_instance(item, service_t, link)); +} + +static hash_table_operations_t services_ops = { + .hash = services_hash, + .compare = services_compare, + .remove_callback = services_remove_callback +}; + +static int locfs_node_get_internal(fs_node_t **rfn, loc_object_type_t type, + service_id_t service_id) +{ + locfs_node_t *node = (locfs_node_t *) malloc(sizeof(locfs_node_t)); + if (node == NULL) { + *rfn = NULL; + return ENOMEM; + } + + *rfn = (fs_node_t *) malloc(sizeof(fs_node_t)); + if (*rfn == NULL) { + free(node); + *rfn = NULL; + return ENOMEM; + } + + fs_node_initialize(*rfn); + node->type = type; + node->service_id = service_id; + + (*rfn)->data = node; + return EOK; +} + +static int locfs_root_get(fs_node_t **rfn, service_id_t service_id) +{ + return locfs_node_get_internal(rfn, LOC_OBJECT_NONE, 0); +} + +static int locfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component) +{ + locfs_node_t *node = (locfs_node_t *) pfn->data; + int ret; + + if (node->service_id == 0) { + /* Root directory */ + + loc_sdesc_t *nspaces; + size_t count = loc_get_namespaces(&nspaces); + + if (count > 0) { + size_t pos; + for (pos = 0; pos < count; pos++) { + /* Ignore root namespace */ + if (str_cmp(nspaces[pos].name, "") == 0) + continue; + + if (str_cmp(nspaces[pos].name, component) == 0) { + ret = locfs_node_get_internal(rfn, LOC_OBJECT_NAMESPACE, nspaces[pos].id); + free(nspaces); + return ret; + } + } + + free(nspaces); + } + + /* Search root namespace */ + service_id_t namespace; + loc_sdesc_t *svcs; + if (loc_namespace_get_id("", &namespace, 0) == EOK) { + count = loc_get_services(namespace, &svcs); + + if (count > 0) { + size_t pos; + for (pos = 0; pos < count; pos++) { + if (str_cmp(svcs[pos].name, component) == 0) { + ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id); + free(svcs); + return ret; + } + } + + free(svcs); + } + } + + *rfn = NULL; + return EOK; + } + + if (node->type == LOC_OBJECT_NAMESPACE) { + /* Namespace directory */ + + loc_sdesc_t *svcs; + size_t count = loc_get_services(node->service_id, &svcs); + if (count > 0) { + size_t pos; + for (pos = 0; pos < count; pos++) { + if (str_cmp(svcs[pos].name, component) == 0) { + ret = locfs_node_get_internal(rfn, LOC_OBJECT_SERVICE, svcs[pos].id); + free(svcs); + return ret; + } + } + + free(svcs); + } + + *rfn = NULL; + return EOK; + } + + *rfn = NULL; + return EOK; +} + +static int locfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index) +{ + return locfs_node_get_internal(rfn, loc_id_probe(index), index); +} + +static int locfs_node_open(fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + + if (node->service_id == 0) { + /* Root directory */ + return EOK; + } + + loc_object_type_t type = loc_id_probe(node->service_id); + + if (type == LOC_OBJECT_NAMESPACE) { + /* Namespace directory */ + return EOK; + } + + if (type == LOC_OBJECT_SERVICE) { + /* Device node */ + + unsigned long key[] = { + [SERVICES_KEY_HANDLE] = (unsigned long) node->service_id + }; + link_t *lnk; + + fibril_mutex_lock(&services_mutex); +restart: + lnk = hash_table_find(&services, key); + if (lnk == NULL) { + service_t *dev = (service_t *) malloc(sizeof(service_t)); + if (dev == NULL) { + fibril_mutex_unlock(&services_mutex); + return ENOMEM; + } + + dev->service_id = node->service_id; + + /* Mark as incomplete */ + dev->sess = NULL; + dev->refcount = 1; + fibril_condvar_initialize(&dev->cv); + + /* + * Insert the incomplete device structure so that other + * fibrils will not race with us when we drop the mutex + * below. + */ + hash_table_insert(&services, key, &dev->link); + + /* + * Drop the mutex to allow recursive locfs requests. + */ + fibril_mutex_unlock(&services_mutex); + + async_sess_t *sess = loc_service_connect( + EXCHANGE_SERIALIZE, node->service_id, 0); + + fibril_mutex_lock(&services_mutex); + + /* + * Notify possible waiters about this device structure + * being completed (or destroyed). + */ + fibril_condvar_broadcast(&dev->cv); + + if (!sess) { + /* + * Connecting failed, need to remove the + * entry and free the device structure. + */ + hash_table_remove(&services, key, SERVICES_KEYS); + fibril_mutex_unlock(&services_mutex); + + return ENOENT; + } + + /* Set the correct session. */ + dev->sess = sess; + } else { + service_t *dev = hash_table_get_instance(lnk, service_t, link); + + if (!dev->sess) { + /* + * Wait until the device structure is completed + * and start from the beginning as the device + * structure might have entirely disappeared + * while we were not holding the mutex in + * fibril_condvar_wait(). + */ + fibril_condvar_wait(&dev->cv, &services_mutex); + goto restart; + } + + dev->refcount++; + } + + fibril_mutex_unlock(&services_mutex); + + return EOK; + } + + return ENOENT; +} + +static int locfs_node_put(fs_node_t *fn) +{ + free(fn->data); + free(fn); + return EOK; +} + +static int locfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag) +{ + assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); + + *rfn = NULL; + return ENOTSUP; +} + +static int locfs_destroy_node(fs_node_t *fn) +{ + return ENOTSUP; +} + +static int locfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm) +{ + return ENOTSUP; +} + +static int locfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm) +{ + return ENOTSUP; +} + +static int locfs_has_children(bool *has_children, fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + + if (node->service_id == 0) { + size_t count = loc_count_namespaces(); + if (count > 0) { + *has_children = true; + return EOK; + } + + /* Root namespace */ + service_id_t namespace; + if (loc_namespace_get_id("", &namespace, 0) == EOK) { + count = loc_count_services(namespace); + if (count > 0) { + *has_children = true; + return EOK; + } + } + + *has_children = false; + return EOK; + } + + if (node->type == LOC_OBJECT_NAMESPACE) { + size_t count = loc_count_services(node->service_id); + if (count > 0) { + *has_children = true; + return EOK; + } + + *has_children = false; + return EOK; + } + + *has_children = false; + return EOK; +} + +static fs_index_t locfs_index_get(fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + return node->service_id; +} + +static aoff64_t locfs_size_get(fs_node_t *fn) +{ + return 0; +} + +static unsigned int locfs_lnkcnt_get(fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + + if (node->service_id == 0) + return 0; + + return 1; +} + +static bool locfs_is_directory(fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + + return ((node->type == LOC_OBJECT_NONE) || (node->type == LOC_OBJECT_NAMESPACE)); +} + +static bool locfs_is_file(fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + + return (node->type == LOC_OBJECT_SERVICE); +} + +static service_id_t locfs_device_get(fs_node_t *fn) +{ + locfs_node_t *node = (locfs_node_t *) fn->data; + + if (node->type == LOC_OBJECT_SERVICE) + return node->service_id; + + return 0; +} + +/** libfs operations */ +libfs_ops_t locfs_libfs_ops = { + .root_get = locfs_root_get, + .match = locfs_match, + .node_get = locfs_node_get, + .node_open = locfs_node_open, + .node_put = locfs_node_put, + .create = locfs_create_node, + .destroy = locfs_destroy_node, + .link = locfs_link_node, + .unlink = locfs_unlink_node, + .has_children = locfs_has_children, + .index_get = locfs_index_get, + .size_get = locfs_size_get, + .lnkcnt_get = locfs_lnkcnt_get, + .is_directory = locfs_is_directory, + .is_file = locfs_is_file, + .device_get = locfs_device_get +}; + +bool locfs_init(void) +{ + if (!hash_table_create(&services, SERVICES_BUCKETS, + SERVICES_KEYS, &services_ops)) + return false; + + return true; +} + +static int locfs_mounted(service_id_t service_id, const char *opts, + fs_index_t *index, aoff64_t *size, unsigned *lnkcnt) +{ + *index = 0; + *size = 0; + *lnkcnt = 0; + return EOK; +} + +static int locfs_unmounted(service_id_t service_id) +{ + return ENOTSUP; +} + +static int +locfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos, + size_t *rbytes) +{ + if (index == 0) { + ipc_callid_t callid; + size_t size; + if (!async_data_read_receive(&callid, &size)) { + async_answer_0(callid, EINVAL); + return EINVAL; + } + + loc_sdesc_t *desc; + size_t count = loc_get_namespaces(&desc); + + /* Get rid of root namespace */ + size_t i; + for (i = 0; i < count; i++) { + if (str_cmp(desc[i].name, "") == 0) { + if (pos >= i) + pos++; + + break; + } + } + + if (pos < count) { + async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); + free(desc); + *rbytes = 1; + return EOK; + } + + free(desc); + pos -= count; + + /* Search root namespace */ + service_id_t namespace; + if (loc_namespace_get_id("", &namespace, 0) == EOK) { + count = loc_get_services(namespace, &desc); + + if (pos < count) { + async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); + free(desc); + *rbytes = 1; + return EOK; + } + + free(desc); + } + + async_answer_0(callid, ENOENT); + return ENOENT; + } + + loc_object_type_t type = loc_id_probe(index); + + if (type == LOC_OBJECT_NAMESPACE) { + /* Namespace directory */ + ipc_callid_t callid; + size_t size; + if (!async_data_read_receive(&callid, &size)) { + async_answer_0(callid, EINVAL); + return EINVAL; + } + + loc_sdesc_t *desc; + size_t count = loc_get_services(index, &desc); + + if (pos < count) { + async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); + free(desc); + *rbytes = 1; + return EOK; + } + + free(desc); + async_answer_0(callid, ENOENT); + return ENOENT; + } + + if (type == LOC_OBJECT_SERVICE) { + /* Device node */ + + unsigned long key[] = { + [SERVICES_KEY_HANDLE] = (unsigned long) index + }; + + fibril_mutex_lock(&services_mutex); + link_t *lnk = hash_table_find(&services, key); + if (lnk == NULL) { + fibril_mutex_unlock(&services_mutex); + return ENOENT; + } + + service_t *dev = hash_table_get_instance(lnk, service_t, link); + assert(dev->sess); + + ipc_callid_t callid; + if (!async_data_read_receive(&callid, NULL)) { + fibril_mutex_unlock(&services_mutex); + async_answer_0(callid, EINVAL); + return EINVAL; + } + + /* Make a request at the driver */ + async_exch_t *exch = async_exchange_begin(dev->sess); + + ipc_call_t answer; + aid_t msg = async_send_4(exch, VFS_OUT_READ, service_id, + index, LOWER32(pos), UPPER32(pos), &answer); + + /* Forward the IPC_M_DATA_READ request to the driver */ + async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); + + async_exchange_end(exch); + + fibril_mutex_unlock(&services_mutex); + + /* Wait for reply from the driver. */ + sysarg_t rc; + async_wait_for(msg, &rc); + + *rbytes = IPC_GET_ARG1(answer); + return rc; + } + + return ENOENT; +} + +static int +locfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos, + size_t *wbytes, aoff64_t *nsize) +{ + if (index == 0) + return ENOTSUP; + + loc_object_type_t type = loc_id_probe(index); + + if (type == LOC_OBJECT_NAMESPACE) { + /* Namespace directory */ + return ENOTSUP; + } + + if (type == LOC_OBJECT_SERVICE) { + /* Device node */ + unsigned long key[] = { + [SERVICES_KEY_HANDLE] = (unsigned long) index + }; + + fibril_mutex_lock(&services_mutex); + link_t *lnk = hash_table_find(&services, key); + if (lnk == NULL) { + fibril_mutex_unlock(&services_mutex); + return ENOENT; + } + + service_t *dev = hash_table_get_instance(lnk, service_t, link); + assert(dev->sess); + + ipc_callid_t callid; + if (!async_data_write_receive(&callid, NULL)) { + fibril_mutex_unlock(&services_mutex); + async_answer_0(callid, EINVAL); + return EINVAL; + } + + /* Make a request at the driver */ + async_exch_t *exch = async_exchange_begin(dev->sess); + + ipc_call_t answer; + aid_t msg = async_send_4(exch, VFS_OUT_WRITE, service_id, + index, LOWER32(pos), UPPER32(pos), &answer); + + /* Forward the IPC_M_DATA_WRITE request to the driver */ + async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); + + async_exchange_end(exch); + + fibril_mutex_unlock(&services_mutex); + + /* Wait for reply from the driver. */ + sysarg_t rc; + async_wait_for(msg, &rc); + + *wbytes = IPC_GET_ARG1(answer); + *nsize = 0; + return rc; + } + + return ENOENT; +} + +static int +locfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size) +{ + return ENOTSUP; +} + +static int locfs_close(service_id_t service_id, fs_index_t index) +{ + if (index == 0) + return EOK; + + loc_object_type_t type = loc_id_probe(index); + + if (type == LOC_OBJECT_NAMESPACE) { + /* Namespace directory */ + return EOK; + } + + if (type == LOC_OBJECT_SERVICE) { + unsigned long key[] = { + [SERVICES_KEY_HANDLE] = (unsigned long) index + }; + + fibril_mutex_lock(&services_mutex); + link_t *lnk = hash_table_find(&services, key); + if (lnk == NULL) { + fibril_mutex_unlock(&services_mutex); + return ENOENT; + } + + service_t *dev = hash_table_get_instance(lnk, service_t, link); + assert(dev->sess); + dev->refcount--; + + if (dev->refcount == 0) { + async_hangup(dev->sess); + hash_table_remove(&services, key, SERVICES_KEYS); + } + + fibril_mutex_unlock(&services_mutex); + + return EOK; + } + + return ENOENT; +} + +static int locfs_sync(service_id_t service_id, fs_index_t index) +{ + if (index == 0) + return EOK; + + loc_object_type_t type = loc_id_probe(index); + + if (type == LOC_OBJECT_NAMESPACE) { + /* Namespace directory */ + return EOK; + } + + if (type == LOC_OBJECT_SERVICE) { + unsigned long key[] = { + [SERVICES_KEY_HANDLE] = (unsigned long) index + }; + + fibril_mutex_lock(&services_mutex); + link_t *lnk = hash_table_find(&services, key); + if (lnk == NULL) { + fibril_mutex_unlock(&services_mutex); + return ENOENT; + } + + service_t *dev = hash_table_get_instance(lnk, service_t, link); + assert(dev->sess); + + /* Make a request at the driver */ + async_exch_t *exch = async_exchange_begin(dev->sess); + + ipc_call_t answer; + aid_t msg = async_send_2(exch, VFS_OUT_SYNC, service_id, + index, &answer); + + async_exchange_end(exch); + + fibril_mutex_unlock(&services_mutex); + + /* Wait for reply from the driver */ + sysarg_t rc; + async_wait_for(msg, &rc); + + return rc; + } + + return ENOENT; +} + +static int locfs_destroy(service_id_t service_id, fs_index_t index) +{ + return ENOTSUP; +} + +vfs_out_ops_t locfs_ops = { + .mounted = locfs_mounted, + .unmounted = locfs_unmounted, + .read = locfs_read, + .write = locfs_write, + .truncate = locfs_truncate, + .close = locfs_close, + .destroy = locfs_destroy, + .sync = locfs_sync, +}; + +/** + * @} + */ Index: uspace/srv/fs/locfs/locfs_ops.h =================================================================== --- uspace/srv/fs/locfs/locfs_ops.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) +++ uspace/srv/fs/locfs/locfs_ops.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2009 Martin Decky + * 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 + * @{ + */ + +#ifndef LOCFS_LOCFS_OPS_H_ +#define LOCFS_LOCFS_OPS_H_ + +#include + +extern bool locfs_init(void); + +#endif + +/** + * @} + */ Index: uspace/srv/fs/tmpfs/tmpfs.h =================================================================== --- uspace/srv/fs/tmpfs/tmpfs.h (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/tmpfs/tmpfs.h (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -61,5 +61,5 @@ fs_node_t *bp; /**< Back pointer to the FS node. */ fs_index_t index; /**< TMPFS node index. */ - devmap_handle_t devmap_handle;/**< Device handle. */ + service_id_t service_id;/**< Service ID of block device. */ link_t nh_link; /**< Nodes hash table link. */ tmpfs_dentry_type_t type; @@ -74,5 +74,5 @@ extern bool tmpfs_init(void); -extern bool tmpfs_restore(devmap_handle_t); +extern bool tmpfs_restore(service_id_t); #endif Index: uspace/srv/fs/tmpfs/tmpfs_dump.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs_dump.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -55,5 +55,5 @@ static bool -tmpfs_restore_recursion(devmap_handle_t dev, size_t *bufpos, size_t *buflen, +tmpfs_restore_recursion(service_id_t dsid, size_t *bufpos, size_t *buflen, aoff64_t *pos, fs_node_t *pfn) { @@ -68,5 +68,5 @@ uint32_t size; - if (block_seqread(dev, bufpos, buflen, pos, &entry, + if (block_seqread(dsid, bufpos, buflen, pos, &entry, sizeof(entry)) != EOK) return false; @@ -82,5 +82,5 @@ return false; - rc = ops->create(&fn, dev, L_FILE); + rc = ops->create(&fn, dsid, L_FILE); if (rc != EOK || fn == NULL) { free(fname); @@ -88,5 +88,5 @@ } - if (block_seqread(dev, bufpos, buflen, pos, fname, + if (block_seqread(dsid, bufpos, buflen, pos, fname, entry.len) != EOK) { (void) ops->destroy(fn); @@ -104,5 +104,5 @@ free(fname); - if (block_seqread(dev, bufpos, buflen, pos, &size, + if (block_seqread(dsid, bufpos, buflen, pos, &size, sizeof(size)) != EOK) return false; @@ -116,5 +116,5 @@ nodep->size = size; - if (block_seqread(dev, bufpos, buflen, pos, nodep->data, + if (block_seqread(dsid, bufpos, buflen, pos, nodep->data, size) != EOK) return false; @@ -126,5 +126,5 @@ return false; - rc = ops->create(&fn, dev, L_DIRECTORY); + rc = ops->create(&fn, dsid, L_DIRECTORY); if (rc != EOK || fn == NULL) { free(fname); @@ -132,5 +132,5 @@ } - if (block_seqread(dev, bufpos, buflen, pos, fname, + if (block_seqread(dsid, bufpos, buflen, pos, fname, entry.len) != EOK) { (void) ops->destroy(fn); @@ -148,5 +148,5 @@ free(fname); - if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos, + if (!tmpfs_restore_recursion(dsid, bufpos, buflen, pos, fn)) return false; @@ -161,5 +161,5 @@ } -bool tmpfs_restore(devmap_handle_t dev) +bool tmpfs_restore(service_id_t dsid) { libfs_ops_t *ops = &tmpfs_libfs_ops; @@ -167,5 +167,5 @@ int rc; - rc = block_init(EXCHANGE_SERIALIZE, dev, TMPFS_COMM_SIZE); + rc = block_init(EXCHANGE_SERIALIZE, dsid, TMPFS_COMM_SIZE); if (rc != EOK) return false; @@ -176,5 +176,5 @@ char tag[6]; - if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5) != EOK) + if (block_seqread(dsid, &bufpos, &buflen, &pos, tag, 5) != EOK) goto error; @@ -183,16 +183,16 @@ goto error; - rc = ops->root_get(&fn, dev); + rc = ops->root_get(&fn, dsid); if (rc != EOK) goto error; - if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos, fn)) - goto error; - - block_fini(dev); + if (!tmpfs_restore_recursion(dsid, &bufpos, &buflen, &pos, fn)) + goto error; + + block_fini(dsid); return true; error: - block_fini(dev); + block_fini(dsid); return false; } Index: uspace/srv/fs/tmpfs/tmpfs_ops.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs_ops.c (revision efcebe1bce63b6779458eadc2fd6f252ab7cd703) +++ uspace/srv/fs/tmpfs/tmpfs_ops.c (revision 16dc8870242df10ae64ee7bcbf125aa8607cb7fb) @@ -69,8 +69,8 @@ /* Forward declarations of static functions. */ static int tmpfs_match(fs_node_t **, fs_node_t *, const char *); -static int tmpfs_node_get(fs_node_t **, devmap_handle_t, fs_index_t); +static int tmpfs_node_get(fs_node_t **, service_id_t, fs_index_t); static int tmpfs_node_open(fs_node_t *); static int tmpfs_node_put(fs_node_t *); -static int tmpfs_create_node(fs_node_t **, devmap_handle_t, int); +static int tmpfs_create_node(fs_node_t **, service_id_t, int); static int tmpfs_destroy_node(fs_node_t *); static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *); @@ -78,7 +78,7 @@ /* Implementation of helper functions. */ -static int tmpfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) -{ - return tmpfs_node_get(rfn, devmap_handle, TMPFS_SOME_ROOT); +static int tmpfs_root_get(fs_node_t **rfn, service_id_t service_id) +{ + return tmpfs_node_get(rfn, service_id, TMPFS_SOME_ROOT); } @@ -114,5 +114,5 @@ } -static devmap_handle_t tmpfs_device_get(fs_node_t *fn) +static service_id_t tmpfs_device_get(fs_node_t *fn) { return 0; @@ -158,7 +158,7 @@ switch (keys) { case 1: - return (nodep->devmap_handle == key[NODES_KEY_DEV]); + return (nodep->service_id == key[NODES_KEY_DEV]); case 2: - return ((nodep->devmap_handle == key[NODES_KEY_DEV]) && + return ((nodep->service_id == key[NODES_KEY_DEV]) && (nodep->index == key[NODES_KEY_INDEX])); default: @@ -202,5 +202,5 @@ nodep->bp = NULL; nodep->index = 0; - nodep->devmap_handle = 0; + nodep->service_id = 0; nodep->type = TMPFS_NONE; nodep->lnkcnt = 0; @@ -226,10 +226,10 @@ } -static bool tmpfs_instance_init(devmap_handle_t devmap_handle) +static bool tmpfs_instance_init(service_id_t service_id) { fs_node_t *rfn; int rc; - rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY); + rc = tmpfs_create_node(&rfn, service_id, L_DIRECTORY); if (rc != EOK || !rfn) return false; @@ -238,8 +238,8 @@ } -static void tmpfs_instance_done(devmap_handle_t devmap_handle) -{ - unsigned long key[] = { - [NODES_KEY_DEV] = devmap_handle +static void tmpfs_instance_done(service_id_t service_id) +{ + unsigned long key[] = { + [NODES_KEY_DEV] = service_id }; /* @@ -270,8 +270,8 @@ } -int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) -{ - unsigned long key[] = { - [NODES_KEY_DEV] = devmap_handle, +int tmpfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index) +{ + unsigned long key[] = { + [NODES_KEY_DEV] = service_id, [NODES_KEY_INDEX] = index }; @@ -299,5 +299,5 @@ } -int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag) +int tmpfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag) { fs_node_t *rootfn; @@ -318,5 +318,5 @@ nodep->bp->data = nodep; /* link the FS and TMPFS nodes */ - rc = tmpfs_root_get(&rootfn, devmap_handle); + rc = tmpfs_root_get(&rootfn, service_id); assert(rc == EOK); if (!rootfn) @@ -324,5 +324,5 @@ else nodep->index = tmpfs_next_index++; - nodep->devmap_handle = devmap_handle; + nodep->service_id = service_id; if (lflag & L_DIRECTORY) nodep->type = TMPFS_DIRECTORY; @@ -332,5 +332,5 @@ /* Insert the new node into the nodes hash table. */ unsigned long key[] = { - [NODES_KEY_DEV] = nodep->devmap_handle, + [NODES_KEY_DEV] = nodep->service_id, [NODES_KEY_INDEX] = nodep->index }; @@ -348,5 +348,5 @@ unsigned long key[] = { - [NODES_KEY_DEV] = nodep->devmap_handle, + [NODES_KEY_DEV] = nodep->service_id, [NODES_KEY_INDEX] = nodep->index }; @@ -432,5 +432,5 @@ static int -tmpfs_mounted(devmap_handle_t devmap_handle, const char *opts, +tmpfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index, aoff64_t *size, unsigned *lnkcnt) { @@ -439,5 +439,5 @@ /* Check if this device is not already mounted. */ - rc = tmpfs_root_get(&rootfn, devmap_handle); + rc = tmpfs_root_get(&rootfn, service_id); if ((rc == EOK) && (rootfn)) { (void) tmpfs_node_put(rootfn); @@ -446,12 +446,12 @@ /* Initialize TMPFS instance. */ - if (!tmpfs_instance_init(devmap_handle)) + if (!tmpfs_instance_init(service_id)) return ENOMEM; - rc = tmpfs_root_get(&rootfn, devmap_handle); + rc = tmpfs_root_get(&rootfn, service_id); assert(rc == EOK); tmpfs_node_t *rootp = TMPFS_NODE(rootfn); if (str_cmp(opts, "restore") == 0) { - if (!tmpfs_restore(devmap_handle)) + if (!tmpfs_restore(service_id)) return ELIMIT; } @@ -464,11 +464,11 @@ } -static int tmpfs_unmounted(devmap_handle_t devmap_handle) -{ - tmpfs_instance_done(devmap_handle); - return EOK; -} - -static int tmpfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, +static int tmpfs_unmounted(service_id_t service_id) +{ + tmpfs_instance_done(service_id); + return EOK; +} + +static int tmpfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos, size_t *rbytes) { @@ -478,5 +478,5 @@ link_t *hlp; unsigned long key[] = { - [NODES_KEY_DEV] = devmap_handle, + [NODES_KEY_DEV] = service_id, [NODES_KEY_INDEX] = index }; @@ -532,5 +532,5 @@ static int -tmpfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos, +tmpfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos, size_t *wbytes, aoff64_t *nsize) { @@ -540,5 +540,5 @@ link_t *hlp; unsigned long key[] = { - [NODES_KEY_DEV] = devmap_handle, + [NODES_KEY_DEV] = service_id, [NODES_KEY_INDEX] = index }; @@ -594,5 +594,5 @@ } -static int tmpfs_truncate(devmap_handle_t devmap_handle, fs_index_t index, +static int tmpfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size) { @@ -601,5 +601,5 @@ */ unsigned long key[] = { - [NODES_KEY_DEV] = devmap_handle, + [NODES_KEY_DEV] = service_id, [NODES_KEY_INDEX] = index }; @@ -629,14 +629,14 @@ } -static int tmpfs_close(devmap_handle_t devmap_handle, fs_index_t index) -{ - return EOK; -} - -static int tmpfs_destroy(devmap_handle_t devmap_handle, fs_index_t index) +static int tmpfs_close(service_id_t service_id, fs_index_t index) +{ + return EOK; +} + +static int tmpfs_destroy(service_id_t service_id, fs_index_t index) { link_t *hlp; unsigned long key[] = { - [NODES_KEY_DEV] = devmap_handle, + [NODES_KEY_DEV] = service_id, [NODES_KEY_INDEX] = index }; @@ -649,5 +649,5 @@ } -static int tmpfs_sync(devmap_handle_t devmap_handle, fs_index_t index) +static int tmpfs_sync(service_id_t service_id, fs_index_t index) { /*