Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision 08cba4b8a94988e64d6efb79b32a3f28694a26e9) +++ boot/Makefile.common (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -102,4 +102,5 @@ $(USPACE_PATH)/srv/fs/tmpfs/tmpfs \ $(USPACE_PATH)/srv/fs/fat/fat \ + $(USPACE_PATH)/srv/fs/cdfs/cdfs \ $(USPACE_PATH)/srv/fs/exfat/exfat \ $(USPACE_PATH)/srv/fs/ext2fs/ext2fs \ Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 08cba4b8a94988e64d6efb79b32a3f28694a26e9) +++ uspace/Makefile (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -81,4 +81,5 @@ srv/fs/exfat \ srv/fs/fat \ + srv/fs/cdfs \ srv/fs/tmpfs \ srv/fs/locfs \ Index: uspace/srv/fs/cdfs/Makefile =================================================================== --- uspace/srv/fs/cdfs/Makefile (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) +++ uspace/srv/fs/cdfs/Makefile (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -0,0 +1,38 @@ +# +# Copyright (c) 2010 Jiri Kavalik +# 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 = $(LIBBLOCK_PREFIX)/libblock.a $(LIBFS_PREFIX)/libfs.a +EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX) +BINARY = cdfs + +SOURCES = \ + cdfs.c \ + cdfs_ops.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/fs/cdfs/cdfs.c =================================================================== --- uspace/srv/fs/cdfs/cdfs.c (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) +++ uspace/srv/fs/cdfs/cdfs.c (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2006 Martin Decky + * Copyright (c) 2008 Jakub Jermar + * Copyright (c) 2010 Jiri Kavalik + * 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 cdfs.c + * @brief File system driver for ISO9660 file system. + */ + +#include +#include +#include +#include +#include +#include "cdfs.h" +#include "cdfs_ops.h" + +#define NAME "cdfs" + +static vfs_info_t cdfs_vfs_info = { + .name = NAME, + .concurrent_read_write = false, + .write_retains_size = false, +}; + +int main(int argc, char **argv) +{ + printf("%s: HelenOS cdfs file system server\n", NAME); + + if (!cdfs_init()) { + printf("%s: failed to initialize cdfs\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, &cdfs_vfs_info, &cdfs_ops, + &cdfs_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/cdfs/cdfs.h =================================================================== --- uspace/srv/fs/cdfs/cdfs.h (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) +++ uspace/srv/fs/cdfs/cdfs.h (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 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 CDFS_CDFS_H_ +#define CDFS_CDFS_H_ + +#include + +extern vfs_out_ops_t cdfs_ops; +extern libfs_ops_t cdfs_libfs_ops; + +#endif + +/** + * @} + */ Index: uspace/srv/fs/cdfs/cdfs_endian.h =================================================================== --- uspace/srv/fs/cdfs/cdfs_endian.h (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) +++ uspace/srv/fs/cdfs/cdfs_endian.h (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011 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 CDFS_CDFS_ENDIAN_H_ +#define CDFS_CDFS_ENDIAN_H_ + +#include + +#if !(defined(__BE__) ^ defined(__LE__)) + #error The architecture must be either big-endian or little-endian. +#endif + +typedef struct { + uint16_t le; + uint16_t be; +} __attribute__((packed)) uint16_t_lb; + +typedef struct { + uint32_t le; + uint32_t be; +} __attribute__((packed)) uint32_t_lb; + +static inline uint16_t uint16_lb(uint16_t_lb val) +{ +#ifdef __LE__ + return val.le; +#endif + +#ifdef __BE__ + return val.be; +#endif +} + +static inline uint32_t uint32_lb(uint32_t_lb val) +{ +#ifdef __LE__ + return val.le; +#endif + +#ifdef __BE__ + return val.be; +#endif +} + +#endif + +/** + * @} + */ Index: uspace/srv/fs/cdfs/cdfs_ops.c =================================================================== --- uspace/srv/fs/cdfs/cdfs_ops.c (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) +++ uspace/srv/fs/cdfs/cdfs_ops.c (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -0,0 +1,1017 @@ +/* + * Copyright (c) 2011 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 cdfs_ops.c + * @brief Implementation of VFS operations for the cdfs file system + * server. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "cdfs.h" +#include "cdfs_endian.h" +#include "cdfs_ops.h" + +/** Standard CD-ROM block size */ +#define BLOCK_SIZE 2048 + +/** Implicit node cache size + * + * More nodes can be actually cached if the files remain + * opended. + * + */ +#define NODE_CACHE_SIZE 200 + +#define NODES_BUCKETS 256 + +#define NODES_KEY_SRVC 0 +#define NODES_KEY_INDEX 1 + +/** All root nodes have index 0 */ +#define CDFS_SOME_ROOT 0 + +#define CDFS_NODE(node) ((node) ? (cdfs_node_t *)(node)->data : NULL) +#define FS_NODE(node) ((node) ? (node)->fs_node : NULL) + +#define CDFS_STANDARD_IDENT "CD001" + +typedef enum { + VOL_DESC_BOOT = 0, + VOL_DESC_PRIMARY = 1, + VOL_DESC_SUPPLEMENTARY = 2, + VOL_DESC_VOL_PARTITION = 3, + VOL_DESC_SET_TERMINATOR = 255 +} vol_desc_type_t; + +typedef struct { + uint8_t system_ident[32]; + uint8_t ident[32]; +} __attribute__((packed)) cdfs_vol_desc_boot_t; + +typedef struct { + uint8_t year[4]; + uint8_t mon[2]; + uint8_t day[2]; + + uint8_t hour[2]; + uint8_t min[2]; + uint8_t sec[2]; + uint8_t msec[2]; + + uint8_t offset; +} __attribute__((packed)) cdfs_datetime_t; + +typedef struct { + uint8_t year; /**< Since 1900 */ + uint8_t mon; + uint8_t day; + + uint8_t hour; + uint8_t min; + uint8_t sec; + + uint8_t offset; +} __attribute__((packed)) cdfs_timestamp_t; + +typedef enum { + DIR_FLAG_DIRECTORY = 2 +} cdfs_dir_flag_t; + +typedef struct { + uint8_t length; + uint8_t ea_length; + + uint32_t_lb lba; + uint32_t_lb size; + + cdfs_timestamp_t timestamp; + uint8_t flags; + uint8_t unit_size; + uint8_t gap_size; + uint16_t_lb sequence_nr; + + uint8_t name_length; + uint8_t name[]; +} __attribute__((packed)) cdfs_dir_t; + +typedef struct { + uint8_t res0; + + uint8_t system_ident[32]; + uint8_t ident[32]; + + uint64_t res1; + uint32_t_lb lba_size; + + uint8_t res2[32]; + uint16_t_lb set_size; + uint16_t_lb sequence_nr; + + uint16_t_lb block_size; + uint32_t_lb path_table_size; + + uint32_t path_table_lsb; + uint32_t opt_path_table_lsb; + uint32_t path_table_msb; + uint32_t opt_path_table_msb; + + cdfs_dir_t root_dir; + uint8_t pad0; + + uint8_t set_ident[128]; + uint8_t publisher_ident[128]; + uint8_t preparer_ident[128]; + uint8_t app_ident[128]; + + uint8_t copyright_file_ident[37]; + uint8_t abstract_file_ident[37]; + uint8_t biblio_file_ident[37]; + + cdfs_datetime_t creation; + cdfs_datetime_t modification; + cdfs_datetime_t expiration; + cdfs_datetime_t effective; + + uint8_t fs_version; +} __attribute__((packed)) cdfs_vol_desc_primary_t; + +typedef struct { + uint8_t type; + uint8_t standard_ident[5]; + uint8_t version; + union { + cdfs_vol_desc_boot_t boot; + cdfs_vol_desc_primary_t primary; + } data; +} __attribute__((packed)) cdfs_vol_desc_t; + +typedef enum { + CDFS_NONE, + CDFS_FILE, + CDFS_DIRECTORY +} cdfs_dentry_type_t; + +typedef struct { + link_t link; /**< Siblings list link */ + fs_index_t index; /**< Node index */ + char *name; /**< Dentry name */ +} cdfs_dentry_t; + +typedef uint32_t cdfs_lba_t; + +typedef struct { + fs_node_t *fs_node; /**< FS node */ + fs_index_t index; /**< Node index */ + service_id_t service_id; /**< Service ID of block device */ + + link_t nh_link; /**< Nodes hash table link */ + cdfs_dentry_type_t type; /**< Dentry type */ + + unsigned int lnkcnt; /**< Link count */ + uint32_t size; /**< File size if type is CDFS_FILE */ + + list_t cs_list; /**< Child's siblings list */ + cdfs_lba_t lba; /**< LBA of data on disk */ + bool processed; /**< If all children have been read */ + unsigned int opened; /**< Opened count */ +} cdfs_node_t; + +/** Shared index of nodes */ +static fs_index_t cdfs_index = 1; + +/** Number of currently cached nodes */ +static size_t nodes_cached = 0; + +/** Hash table of all cdfs nodes */ +static hash_table_t nodes; + +static hash_index_t nodes_hash(unsigned long key[]) +{ + return key[NODES_KEY_INDEX] % NODES_BUCKETS; +} + +static int nodes_compare(unsigned long key[], hash_count_t keys, link_t *item) +{ + cdfs_node_t *node = + hash_table_get_instance(item, cdfs_node_t, nh_link); + + switch (keys) { + case 1: + return (node->service_id == key[NODES_KEY_SRVC]); + case 2: + return ((node->service_id == key[NODES_KEY_SRVC]) && + (node->index == key[NODES_KEY_INDEX])); + default: + assert((keys == 1) || (keys == 2)); + } + + return 0; +} + +static void nodes_remove_callback(link_t *item) +{ + cdfs_node_t *node = + hash_table_get_instance(item, cdfs_node_t, nh_link); + + assert(node->type == CDFS_DIRECTORY); + + link_t *link; + while ((link = list_first(&node->cs_list)) != NULL) { + cdfs_dentry_t *dentry = list_get_instance(link, cdfs_dentry_t, link); + list_remove(&dentry->link); + free(dentry); + } + + free(node->fs_node); + free(node); +} + +/** Nodes hash table operations */ +static hash_table_operations_t nodes_ops = { + .hash = nodes_hash, + .compare = nodes_compare, + .remove_callback = nodes_remove_callback +}; + +static int cdfs_node_get(fs_node_t **rfn, service_id_t service_id, + fs_index_t index) +{ + unsigned long key[] = { + [NODES_KEY_SRVC] = service_id, + [NODES_KEY_INDEX] = index + }; + + link_t *link = hash_table_find(&nodes, key); + if (link) { + cdfs_node_t *node = + hash_table_get_instance(link, cdfs_node_t, nh_link); + + *rfn = FS_NODE(node); + } else + *rfn = NULL; + + return EOK; +} + +static int cdfs_root_get(fs_node_t **rfn, service_id_t service_id) +{ + return cdfs_node_get(rfn, service_id, CDFS_SOME_ROOT); +} + +static void cdfs_node_initialize(cdfs_node_t *node) +{ + node->fs_node = NULL; + node->index = 0; + node->service_id = 0; + node->type = CDFS_NONE; + node->lnkcnt = 0; + node->size = 0; + node->lba = 0; + node->processed = false; + node->opened = 0; + + link_initialize(&node->nh_link); + list_initialize(&node->cs_list); +} + +static int create_node(fs_node_t **rfn, service_id_t service_id, int lflag, + fs_index_t index) +{ + assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); + + cdfs_node_t *node = malloc(sizeof(cdfs_node_t)); + if (!node) + return ENOMEM; + + cdfs_node_initialize(node); + + node->fs_node = malloc(sizeof(fs_node_t)); + if (!node->fs_node) { + free(node); + return ENOMEM; + } + + fs_node_initialize(node->fs_node); + node->fs_node->data = node; + + fs_node_t *rootfn; + int rc = cdfs_root_get(&rootfn, service_id); + + assert(rc == EOK); + + if (!rootfn) + node->index = CDFS_SOME_ROOT; + else + node->index = index; + + node->service_id = service_id; + + if (lflag & L_DIRECTORY) + node->type = CDFS_DIRECTORY; + else + node->type = CDFS_FILE; + + /* Insert the new node into the nodes hash table. */ + unsigned long key[] = { + [NODES_KEY_SRVC] = node->service_id, + [NODES_KEY_INDEX] = node->index + }; + + hash_table_insert(&nodes, key, &node->nh_link); + + *rfn = FS_NODE(node); + nodes_cached++; + + return EOK; +} + +static int link_node(fs_node_t *pfn, fs_node_t *fn, const char *name) +{ + cdfs_node_t *parent = CDFS_NODE(pfn); + cdfs_node_t *node = CDFS_NODE(fn); + + assert(parent->type == CDFS_DIRECTORY); + + /* Check for duplicate entries */ + list_foreach(parent->cs_list, link) { + cdfs_dentry_t *dentry = + list_get_instance(link, cdfs_dentry_t, link); + + if (str_cmp(dentry->name, name) == 0) + return EEXIST; + } + + /* Allocate and initialize the dentry */ + cdfs_dentry_t *dentry = malloc(sizeof(cdfs_dentry_t)); + if (!dentry) + return ENOMEM; + + /* Populate and link the new dentry */ + dentry->name = str_dup(name); + if (dentry->name == NULL) { + free(dentry); + return ENOMEM; + } + + link_initialize(&dentry->link); + dentry->index = node->index; + + node->lnkcnt++; + list_append(&dentry->link, &parent->cs_list); + + return EOK; +} + +static bool cdfs_readdir(service_id_t service_id, fs_node_t *fs_node) +{ + cdfs_node_t *node = CDFS_NODE(fs_node); + assert(node); + + if (node->processed) + return true; + + uint32_t blocks = node->size / BLOCK_SIZE; + if ((node->size % BLOCK_SIZE) != 0) + blocks++; + + for (uint32_t i = 0; i < blocks; i++) { + block_t *block; + int rc = block_get(&block, service_id, node->lba + i, BLOCK_FLAGS_NONE); + if (rc != EOK) + return false; + + cdfs_dir_t *dir = (cdfs_dir_t *) block->data; + + // FIXME: skip '.' and '..' + + for (size_t offset = 0; + (dir->length != 0) && (offset < BLOCK_SIZE); + offset += dir->length) { + dir = (cdfs_dir_t *) (block->data + offset); + + cdfs_dentry_type_t dentry_type; + if (dir->flags & DIR_FLAG_DIRECTORY) + dentry_type = CDFS_DIRECTORY; + else + dentry_type = CDFS_FILE; + + // FIXME: hack - indexing by dentry byte offset on disc + + fs_node_t *fn; + int rc = create_node(&fn, service_id, dentry_type, + (node->lba + i) * BLOCK_SIZE + offset); + if ((rc != EOK) || (fn == NULL)) + return false; + + cdfs_node_t *cur = CDFS_NODE(fn); + cur->lba = uint32_lb(dir->lba); + cur->size = uint32_lb(dir->size); + + char *name = (char *) malloc(dir->name_length + 1); + if (name == NULL) + return false; + + memcpy(name, dir->name, dir->name_length); + name[dir->name_length] = 0; + + // FIXME: check return value + + link_node(fs_node, fn, name); + free(name); + + if (dentry_type == CDFS_FILE) + cur->processed = true; + } + + block_put(block); + } + + node->processed = true; + return true; +} + +static fs_node_t *get_uncached_node(service_id_t service_id, fs_index_t index) +{ + cdfs_lba_t lba = index / BLOCK_SIZE; + size_t offset = index % BLOCK_SIZE; + + block_t *block; + int rc = block_get(&block, service_id, lba, BLOCK_FLAGS_NONE); + if (rc != EOK) + return NULL; + + cdfs_dir_t *dir = (cdfs_dir_t *) (block->data + offset); + + cdfs_dentry_type_t dentry_type; + if (dir->flags & DIR_FLAG_DIRECTORY) + dentry_type = CDFS_DIRECTORY; + else + dentry_type = CDFS_FILE; + + fs_node_t *fn; + rc = create_node(&fn, service_id, dentry_type, index); + if ((rc != EOK) || (fn == NULL)) + return NULL; + + cdfs_node_t *node = CDFS_NODE(fn); + node->lba = uint32_lb(dir->lba); + node->size = uint32_lb(dir->size); + node->lnkcnt = 1; + + if (dentry_type == CDFS_FILE) + node->processed = true; + + block_put(block); + return fn; +} + +static fs_node_t *get_cached_node(service_id_t service_id, fs_index_t index) +{ + unsigned long key[] = { + [NODES_KEY_SRVC] = service_id, + [NODES_KEY_INDEX] = index + }; + + link_t *link = hash_table_find(&nodes, key); + if (link) { + cdfs_node_t *node = + hash_table_get_instance(link, cdfs_node_t, nh_link); + return FS_NODE(node); + } + + return get_uncached_node(service_id, index); +} + +static int cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component) +{ + cdfs_node_t *parent = CDFS_NODE(pfn); + + if (!parent->processed) { + int rc = cdfs_readdir(parent->service_id, pfn); + if (rc != EOK) + return rc; + } + + list_foreach(parent->cs_list, link) { + cdfs_dentry_t *dentry = + list_get_instance(link, cdfs_dentry_t, link); + + if (str_cmp(dentry->name, component) == 0) { + *fn = get_cached_node(parent->service_id, dentry->index); + return EOK; + } + } + + *fn = NULL; + return EOK; +} + +static int cdfs_node_open(fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + + if (!node->processed) + cdfs_readdir(node->service_id, fn); + + node->opened++; + return EOK; +} + +static int cdfs_node_put(fs_node_t *fn) +{ + /* Nothing to do */ + return EOK; +} + +static int cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag) +{ + /* Read-only */ + return ENOTSUP; +} + +static int cdfs_destroy_node(fs_node_t *fn) +{ + /* Read-only */ + return ENOTSUP; +} + +static int cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name) +{ + /* Read-only */ + return ENOTSUP; +} + +static int cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name) +{ + /* Read-only */ + return ENOTSUP; +} + +static int cdfs_has_children(bool *has_children, fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + + if ((node->type == CDFS_DIRECTORY) && (!node->processed)) + cdfs_readdir(node->service_id, fn); + + *has_children = !list_empty(&node->cs_list); + return EOK; +} + +static fs_index_t cdfs_index_get(fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + return node->index; +} + +static aoff64_t cdfs_size_get(fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + return node->size; +} + +static unsigned int cdfs_lnkcnt_get(fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + return node->lnkcnt; +} + +static bool cdfs_is_directory(fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + return (node->type == CDFS_DIRECTORY); +} + +static bool cdfs_is_file(fs_node_t *fn) +{ + cdfs_node_t *node = CDFS_NODE(fn); + return (node->type == CDFS_FILE); +} + +static service_id_t cdfs_device_get(fs_node_t *fn) +{ + return 0; +} + +libfs_ops_t cdfs_libfs_ops = { + .root_get = cdfs_root_get, + .match = cdfs_match, + .node_get = cdfs_node_get, + .node_open = cdfs_node_open, + .node_put = cdfs_node_put, + .create = cdfs_create_node, + .destroy = cdfs_destroy_node, + .link = cdfs_link_node, + .unlink = cdfs_unlink_node, + .has_children = cdfs_has_children, + .index_get = cdfs_index_get, + .size_get = cdfs_size_get, + .lnkcnt_get = cdfs_lnkcnt_get, + .is_directory = cdfs_is_directory, + .is_file = cdfs_is_file, + .device_get = cdfs_device_get +}; + +static bool iso_readfs(service_id_t service_id, fs_node_t *rfn, + cdfs_lba_t altroot) +{ + /* First 16 blocks of isofs are empty */ + block_t *block; + int rc = block_get(&block, service_id, altroot + 16, BLOCK_FLAGS_NONE); + if (rc != EOK) + return false; + + cdfs_vol_desc_t *vol_desc = (cdfs_vol_desc_t *) block->data; + + /* + * Test for primary volume descriptor + * and standard compliance. + */ + if ((vol_desc->type != VOL_DESC_PRIMARY) || + (bcmp(vol_desc->standard_ident, CDFS_STANDARD_IDENT, 5) != 0) || + (vol_desc->version != 1)) { + block_put(block); + return false; + } + + uint16_t set_size = uint16_lb(vol_desc->data.primary.set_size); + if (set_size > 1) { + /* + * Technically, we don't support multi-disc sets. + * But one can encounter erroneously mastered + * images in the wild and it might actually work + * for the first disc in the set. + */ + } + + uint16_t sequence_nr = uint16_lb(vol_desc->data.primary.sequence_nr); + if (sequence_nr != 1) { + /* + * We only support the first disc + * in multi-disc sets. + */ + block_put(block); + return false; + } + + uint16_t block_size = uint16_lb(vol_desc->data.primary.block_size); + if (block_size != BLOCK_SIZE) { + block_put(block); + return false; + } + + // TODO: implement path table support + + cdfs_node_t *node = CDFS_NODE(rfn); + node->lba = uint32_lb(vol_desc->data.primary.root_dir.lba); + node->size = uint32_lb(vol_desc->data.primary.root_dir.size); + + if (!cdfs_readdir(service_id, rfn)) { + block_put(block); + return false; + } + + block_put(block); + return true; +} + +/* Mount a session with session start offset + * + */ +static bool cdfs_instance_init(service_id_t service_id, cdfs_lba_t altroot) +{ + /* Create root node */ + fs_node_t *rfn; + int rc = create_node(&rfn, service_id, L_DIRECTORY, cdfs_index++); + + if ((rc != EOK) || (!rfn)) + return false; + + /* FS root is not linked */ + CDFS_NODE(rfn)->lnkcnt = 0; + CDFS_NODE(rfn)->lba = 0; + CDFS_NODE(rfn)->processed = false; + + /* Check if there is cdfs in given session */ + if (!iso_readfs(service_id, rfn, altroot)) { + // XXX destroy node + return false; + } + + return true; +} + +static int cdfs_mounted(service_id_t service_id, const char *opts, + fs_index_t *index, aoff64_t *size, unsigned int *lnkcnt) +{ + /* Initialize the block layer */ + int rc = block_init(EXCHANGE_SERIALIZE, service_id, BLOCK_SIZE); + if (rc != EOK) + return rc; + + cdfs_lba_t altroot = 0; + + if (str_lcmp(opts, "altroot=", 8) == 0) { + /* User-defined alternative root on a multi-session disk */ + if (str_uint32_t(opts + 8, NULL, 0, false, &altroot) != EOK) + altroot = 0; + } else { + /* Read TOC and find the last session */ + toc_block_t *toc = block_get_toc(service_id, 1); + if ((toc != NULL) && (uint16_t_be2host(toc->size) == 10)) { + altroot = uint32_t_be2host(toc->first_lba); + free(toc); + } + } + + /* Initialize the block cache */ + rc = block_cache_init(service_id, BLOCK_SIZE, 0, CACHE_MODE_WT); + if (rc != EOK) { + block_fini(service_id); + return rc; + } + + /* Check if this device is not already mounted */ + fs_node_t *rootfn; + rc = cdfs_root_get(&rootfn, service_id); + if ((rc == EOK) && (rootfn)) { + cdfs_node_put(rootfn); + block_cache_fini(service_id); + block_fini(service_id); + + return EEXIST; + } + + /* Initialize cdfs instance */ + if (!cdfs_instance_init(service_id, altroot)) { + block_cache_fini(service_id); + block_fini(service_id); + + return ENOMEM; + } + + rc = cdfs_root_get(&rootfn, service_id); + assert(rc == EOK); + + cdfs_node_t *root = CDFS_NODE(rootfn); + *index = root->index; + *size = root->size; + *lnkcnt = root->lnkcnt; + + return EOK; +} + +static void cdfs_instance_done(service_id_t service_id) +{ + unsigned long key[] = { + [NODES_KEY_SRVC] = service_id + }; + + hash_table_remove(&nodes, key, 1); + block_cache_fini(service_id); + block_fini(service_id); +} + +static int cdfs_unmounted(service_id_t service_id) +{ + cdfs_instance_done(service_id); + return EOK; +} + +static int cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos, + size_t *rbytes) +{ + unsigned long key[] = { + [NODES_KEY_SRVC] = service_id, + [NODES_KEY_INDEX] = index + }; + + link_t *link = hash_table_find(&nodes, key); + if (link == NULL) + return ENOENT; + + cdfs_node_t *node = + hash_table_get_instance(link, cdfs_node_t, nh_link); + + if (!node->processed) { + int rc = cdfs_readdir(service_id, FS_NODE(node)); + if (rc != EOK) + return rc; + } + + ipc_callid_t callid; + size_t len; + if (!async_data_read_receive(&callid, &len)) { + async_answer_0(callid, EINVAL); + return EINVAL; + } + + if (node->type == CDFS_FILE) { + if (pos >= node->size) { + *rbytes = 0; + async_data_read_finalize(callid, NULL, 0); + } else { + cdfs_lba_t lba = pos / BLOCK_SIZE; + size_t offset = pos % BLOCK_SIZE; + + *rbytes = min(len, BLOCK_SIZE - offset); + *rbytes = min(*rbytes, node->size - pos); + + block_t *block; + int rc = block_get(&block, service_id, node->lba + lba, + BLOCK_FLAGS_NONE); + if (rc != EOK) { + async_answer_0(callid, rc); + return rc; + } + + async_data_read_finalize(callid, block->data + offset, + *rbytes); + rc = block_put(block); + if (rc != EOK) + return rc; + } + } else { + link_t *link = list_nth(&node->cs_list, pos); + if (link == NULL) { + async_answer_0(callid, ENOENT); + return ENOENT; + } + + cdfs_dentry_t *dentry = + list_get_instance(link, cdfs_dentry_t, link); + + *rbytes = 1; + async_data_read_finalize(callid, dentry->name, + str_size(dentry->name) + 1); + } + + return EOK; +} + +static int cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos, + size_t *wbytes, aoff64_t *nsize) +{ + /* + * As cdfs is a read-only filesystem, + * the operation is not supported. + */ + + return ENOTSUP; +} + +static int cdfs_truncate(service_id_t service_id, fs_index_t index, + aoff64_t size) +{ + /* + * As cdfs is a read-only filesystem, + * the operation is not supported. + */ + + return ENOTSUP; +} + +static void cleanup_cache(service_id_t service_id) +{ + if (nodes_cached > NODE_CACHE_SIZE) { + size_t remove = nodes_cached - NODE_CACHE_SIZE; + + // FIXME: this accesses the internals of the hash table + // and should be rewritten in a clean way + + for (hash_index_t chain = 0; chain < nodes.entries; chain++) { + for (link_t *link = nodes.entry[chain].head.next; + link != &nodes.entry[chain].head; + link = link->next) { + if (remove == 0) + return; + + cdfs_node_t *node = + hash_table_get_instance(link, cdfs_node_t, nh_link); + if (node->opened == 0) { + link_t *tmp = link; + link = link->prev; + + list_remove(tmp); + nodes.op->remove_callback(tmp); + nodes_cached--; + remove--; + + continue; + } + } + } + } +} + +static int cdfs_close(service_id_t service_id, fs_index_t index) +{ + /* Root node is always in memory */ + if (index == 0) + return EOK; + + unsigned long key[] = { + [NODES_KEY_SRVC] = service_id, + [NODES_KEY_INDEX] = index + }; + + link_t *link = hash_table_find(&nodes, key); + if (link == 0) + return ENOENT; + + cdfs_node_t *node = + hash_table_get_instance(link, cdfs_node_t, nh_link); + + assert(node->opened > 0); + + node->opened--; + cleanup_cache(service_id); + + return EOK; +} + +static int cdfs_destroy(service_id_t service_id, fs_index_t index) +{ + /* + * As cdfs is a read-only filesystem, + * the operation is not supported. + */ + + return ENOTSUP; +} + +static int cdfs_sync(service_id_t service_id, fs_index_t index) +{ + /* + * As cdfs is a read-only filesystem, + * the sync operation is a no-op. + */ + + return EOK; +} + +vfs_out_ops_t cdfs_ops = { + .mounted = cdfs_mounted, + .unmounted = cdfs_unmounted, + .read = cdfs_read, + .write = cdfs_write, + .truncate = cdfs_truncate, + .close = cdfs_close, + .destroy = cdfs_destroy, + .sync = cdfs_sync +}; + +/** Initialize the cdfs server + * + */ +bool cdfs_init(void) +{ + if (!hash_table_create(&nodes, NODES_BUCKETS, 2, &nodes_ops)) + return false; + + return true; +} + +/** + * @} + */ Index: uspace/srv/fs/cdfs/cdfs_ops.h =================================================================== --- uspace/srv/fs/cdfs/cdfs_ops.h (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) +++ uspace/srv/fs/cdfs/cdfs_ops.h (revision a26895ddf444f99491f445f5813ad4b7cbf05a53) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2011 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 CDFS_CDFS_OPS_H_ +#define CDFS_CDFS_OPS_H_ + +#include + +extern bool cdfs_init(void); + +#endif + +/** + * @} + */