Index: uspace/lib/block/libblock.c =================================================================== --- uspace/lib/block/libblock.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/block/libblock.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -39,5 +39,5 @@ #include "libblock.h" #include "../../srv/vfs/vfs.h" -#include +#include #include #include @@ -78,5 +78,5 @@ typedef struct { link_t link; - devmap_handle_t devmap_handle; + service_id_t service_id; async_sess_t *sess; fibril_mutex_t comm_area_lock; @@ -95,5 +95,5 @@ static aoff64_t ba_ltop(devcon_t *, aoff64_t); -static devcon_t *devcon_search(devmap_handle_t devmap_handle) +static devcon_t *devcon_search(service_id_t service_id) { fibril_mutex_lock(&dcl_lock); @@ -101,5 +101,5 @@ list_foreach(dcl, cur) { devcon_t *devcon = list_get_instance(cur, devcon_t, link); - if (devcon->devmap_handle == devmap_handle) { + if (devcon->service_id == service_id) { fibril_mutex_unlock(&dcl_lock); return devcon; @@ -111,5 +111,5 @@ } -static int devcon_add(devmap_handle_t devmap_handle, async_sess_t *sess, +static int devcon_add(service_id_t service_id, async_sess_t *sess, size_t bsize, void *comm_area, size_t comm_size) { @@ -124,5 +124,5 @@ link_initialize(&devcon->link); - devcon->devmap_handle = devmap_handle; + devcon->service_id = service_id; devcon->sess = sess; fibril_mutex_initialize(&devcon->comm_area_lock); @@ -137,5 +137,5 @@ list_foreach(dcl, cur) { devcon_t *d = list_get_instance(cur, devcon_t, link); - if (d->devmap_handle == devmap_handle) { + if (d->service_id == service_id) { fibril_mutex_unlock(&dcl_lock); free(devcon); @@ -155,5 +155,5 @@ } -int block_init(exch_mgmt_t mgmt, devmap_handle_t devmap_handle, +int block_init(exch_mgmt_t mgmt, service_id_t service_id, size_t comm_size) { @@ -163,5 +163,5 @@ return ENOMEM; - async_sess_t *sess = devmap_device_connect(mgmt, devmap_handle, + async_sess_t *sess = loc_service_connect(mgmt, service_id, IPC_FLAG_BLOCKING); if (!sess) { @@ -190,5 +190,5 @@ } - rc = devcon_add(devmap_handle, sess, bsize, comm_area, comm_size); + rc = devcon_add(service_id, sess, bsize, comm_area, comm_size); if (rc != EOK) { munmap(comm_area, comm_size); @@ -200,11 +200,11 @@ } -void block_fini(devmap_handle_t devmap_handle) -{ - devcon_t *devcon = devcon_search(devmap_handle); +void block_fini(service_id_t service_id) +{ + devcon_t *devcon = devcon_search(service_id); assert(devcon); if (devcon->cache) - (void) block_cache_fini(devmap_handle); + (void) block_cache_fini(service_id); devcon_remove(devcon); @@ -219,10 +219,10 @@ } -int block_bb_read(devmap_handle_t devmap_handle, aoff64_t ba) +int block_bb_read(service_id_t service_id, aoff64_t ba) { void *bb_buf; int rc; - devcon_t *devcon = devcon_search(devmap_handle); + devcon_t *devcon = devcon_search(service_id); if (!devcon) return ENOENT; @@ -249,7 +249,7 @@ } -void *block_bb_get(devmap_handle_t devmap_handle) -{ - devcon_t *devcon = devcon_search(devmap_handle); +void *block_bb_get(service_id_t service_id) +{ + devcon_t *devcon = devcon_search(service_id); assert(devcon); return devcon->bb_buf; @@ -277,8 +277,8 @@ }; -int block_cache_init(devmap_handle_t devmap_handle, size_t size, unsigned blocks, +int block_cache_init(service_id_t service_id, size_t size, unsigned blocks, enum cache_mode mode) { - devcon_t *devcon = devcon_search(devmap_handle); + devcon_t *devcon = devcon_search(service_id); cache_t *cache; if (!devcon) @@ -315,7 +315,7 @@ } -int block_cache_fini(devmap_handle_t devmap_handle) -{ - devcon_t *devcon = devcon_search(devmap_handle); +int block_cache_fini(service_id_t service_id) +{ + devcon_t *devcon = devcon_search(service_id); cache_t *cache; int rc; @@ -387,5 +387,5 @@ * @param block Pointer to where the function will store the * block pointer on success. - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param ba Block address (logical). * @param flags If BLOCK_FLAGS_NOREAD is specified, block_get() @@ -395,5 +395,5 @@ * @return EOK on success or a negative error code. */ -int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t ba, int flags) +int block_get(block_t **block, service_id_t service_id, aoff64_t ba, int flags) { devcon_t *devcon; @@ -408,5 +408,5 @@ int rc; - devcon = devcon_search(devmap_handle); + devcon = devcon_search(service_id); assert(devcon); @@ -536,5 +536,5 @@ block_initialize(b); - b->devmap_handle = devmap_handle; + b->service_id = service_id; b->size = cache->lblock_size; b->lba = ba; @@ -586,5 +586,5 @@ int block_put(block_t *block) { - devcon_t *devcon = devcon_search(block->devmap_handle); + devcon_t *devcon = devcon_search(block->service_id); cache_t *cache; unsigned blocks_cached; @@ -687,5 +687,5 @@ /** Read sequential data from a block device. * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param bufpos Pointer to the first unread valid offset within the * communication buffer. @@ -699,5 +699,5 @@ * @return EOK on success or a negative return code on failure. */ -int block_seqread(devmap_handle_t devmap_handle, size_t *bufpos, size_t *buflen, +int block_seqread(service_id_t service_id, size_t *bufpos, size_t *buflen, aoff64_t *pos, void *dst, size_t size) { @@ -707,5 +707,5 @@ devcon_t *devcon; - devcon = devcon_search(devmap_handle); + devcon = devcon_search(service_id); assert(devcon); block_size = devcon->pblock_size; @@ -753,5 +753,5 @@ /** Read blocks directly from device (bypass cache). * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param ba Address of first block (physical). * @param cnt Number of blocks. @@ -760,10 +760,10 @@ * @return EOK on success or negative error code on failure. */ -int block_read_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, void *buf) +int block_read_direct(service_id_t service_id, aoff64_t ba, size_t cnt, void *buf) { devcon_t *devcon; int rc; - devcon = devcon_search(devmap_handle); + devcon = devcon_search(service_id); assert(devcon); @@ -781,5 +781,5 @@ /** Write blocks directly to device (bypass cache). * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param ba Address of first block (physical). * @param cnt Number of blocks. @@ -788,5 +788,5 @@ * @return EOK on success or negative error code on failure. */ -int block_write_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, +int block_write_direct(service_id_t service_id, aoff64_t ba, size_t cnt, const void *data) { @@ -794,5 +794,5 @@ int rc; - devcon = devcon_search(devmap_handle); + devcon = devcon_search(service_id); assert(devcon); @@ -809,14 +809,14 @@ /** Get device block size. * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param bsize Output block size. * * @return EOK on success or negative error code on failure. */ -int block_get_bsize(devmap_handle_t devmap_handle, size_t *bsize) +int block_get_bsize(service_id_t service_id, size_t *bsize) { devcon_t *devcon; - devcon = devcon_search(devmap_handle); + devcon = devcon_search(service_id); assert(devcon); @@ -826,12 +826,12 @@ /** Get number of blocks on device. * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param nblocks Output number of blocks. * * @return EOK on success or negative error code on failure. */ -int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks) -{ - devcon_t *devcon = devcon_search(devmap_handle); +int block_get_nblocks(service_id_t service_id, aoff64_t *nblocks) +{ + devcon_t *devcon = devcon_search(service_id); assert(devcon); @@ -841,5 +841,5 @@ /** Read bytes directly from the device (bypass cache) * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param abs_offset Absolute offset in bytes where to start reading * @param bytes Number of bytes to read @@ -848,5 +848,5 @@ * @return EOK on success or negative error code on failure. */ -int block_read_bytes_direct(devmap_handle_t devmap_handle, aoff64_t abs_offset, +int block_read_bytes_direct(service_id_t service_id, aoff64_t abs_offset, size_t bytes, void *data) { @@ -860,5 +860,5 @@ size_t offset; - rc = block_get_bsize(devmap_handle, &phys_block_size); + rc = block_get_bsize(service_id, &phys_block_size); if (rc != EOK) { return rc; @@ -878,5 +878,5 @@ } - rc = block_read_direct(devmap_handle, first_block, blocks, buffer); + rc = block_read_direct(service_id, first_block, blocks, buffer); if (rc != EOK) { free(buffer); @@ -912,5 +912,5 @@ printf("Error %d reading %zu blocks starting at block %" PRIuOFF64 " from device handle %" PRIun "\n", rc, cnt, ba, - devcon->devmap_handle); + devcon->service_id); #ifndef NDEBUG stacktrace_print(); @@ -941,5 +941,5 @@ if (rc != EOK) { printf("Error %d writing %zu blocks starting at block %" PRIuOFF64 - " to device handle %" PRIun "\n", rc, cnt, ba, devcon->devmap_handle); + " to device handle %" PRIun "\n", rc, cnt, ba, devcon->service_id); #ifndef NDEBUG stacktrace_print(); Index: uspace/lib/block/libblock.h =================================================================== --- uspace/lib/block/libblock.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/block/libblock.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -1,6 +1,6 @@ /* * Copyright (c) 2008 Jakub Jermar - * Copyright (c) 2008 Martin Decky - * Copyright (c) 2011 Martin Sucha + * Copyright (c) 2008 Martin Decky + * Copyright (c) 2011 Martin Sucha * All rights reserved. * @@ -73,6 +73,6 @@ /** Readers / Writer lock protecting the contents of the block. */ fibril_rwlock_t contents_lock; - /** Handle of the device where the block resides. */ - devmap_handle_t devmap_handle; + /** Service ID of service providing the block device. */ + service_id_t service_id; /** Logical block address */ aoff64_t lba; @@ -97,24 +97,24 @@ }; -extern int block_init(exch_mgmt_t, devmap_handle_t, size_t); -extern void block_fini(devmap_handle_t); +extern int block_init(exch_mgmt_t, service_id_t, size_t); +extern void block_fini(service_id_t); -extern int block_bb_read(devmap_handle_t, aoff64_t); -extern void *block_bb_get(devmap_handle_t); +extern int block_bb_read(service_id_t, aoff64_t); +extern void *block_bb_get(service_id_t); -extern int block_cache_init(devmap_handle_t, size_t, unsigned, enum cache_mode); -extern int block_cache_fini(devmap_handle_t); +extern int block_cache_init(service_id_t, size_t, unsigned, enum cache_mode); +extern int block_cache_fini(service_id_t); -extern int block_get(block_t **, devmap_handle_t, aoff64_t, int); +extern int block_get(block_t **, service_id_t, aoff64_t, int); extern int block_put(block_t *); -extern int block_seqread(devmap_handle_t, size_t *, size_t *, aoff64_t *, void *, +extern int block_seqread(service_id_t, size_t *, size_t *, aoff64_t *, void *, size_t); -extern int block_get_bsize(devmap_handle_t, size_t *); -extern int block_get_nblocks(devmap_handle_t, aoff64_t *); -extern int block_read_direct(devmap_handle_t, aoff64_t, size_t, void *); -extern int block_read_bytes_direct(devmap_handle_t, aoff64_t, size_t, void *); -extern int block_write_direct(devmap_handle_t, aoff64_t, size_t, const void *); +extern int block_get_bsize(service_id_t, size_t *); +extern int block_get_nblocks(service_id_t, aoff64_t *); +extern int block_read_direct(service_id_t, aoff64_t, size_t, void *); +extern int block_read_bytes_direct(service_id_t, aoff64_t, size_t, void *); +extern int block_write_direct(service_id_t, aoff64_t, size_t, const void *); #endif Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/Makefile (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -64,5 +64,4 @@ generic/cap.c \ generic/clipboard.c \ - generic/devmap.c \ generic/devman.c \ generic/device/hw_res.c \ @@ -71,4 +70,5 @@ generic/event.c \ generic/errno.c \ + generic/loc.c \ generic/mem.c \ generic/str.c \ Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/generic/devman.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -271,14 +271,14 @@ } -int devman_add_device_to_class(devman_handle_t devman_handle, - const char *class_name) +int devman_add_device_to_category(devman_handle_t devman_handle, + const char *cat_name) { async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER); ipc_call_t answer; - aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CLASS, + aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY, devman_handle, &answer); - sysarg_t retval = async_data_write_start(exch, class_name, - str_size(class_name)); + sysarg_t retval = async_data_write_start(exch, cat_name, + str_size(cat_name)); devman_exchange_end(exch); @@ -308,4 +308,23 @@ } +/** Remove function from device. + * + * Request devman to remove function owned by this driver task. + * @param funh Devman handle of the function + * + * @return EOK on success or negative error code. + */ +int devman_remove_function(devman_handle_t funh) +{ + async_exch_t *exch; + sysarg_t retval; + + exch = devman_exchange_begin_blocking(DEVMAN_DRIVER); + retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh); + devman_exchange_end(exch); + + return (int) retval; +} + async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt, devman_handle_t handle, unsigned int flags) @@ -333,5 +352,5 @@ exch = devman_exchange_begin(DEVMAN_CLIENT); if (exch == NULL) - return errno; + return ENOMEM; } @@ -364,59 +383,9 @@ } -int devman_device_get_handle_by_class(const char *classname, - const char *devname, devman_handle_t *handle, unsigned int flags) -{ - async_exch_t *exch; - - if (flags & IPC_FLAG_BLOCKING) - exch = devman_exchange_begin_blocking(DEVMAN_CLIENT); - else { - exch = devman_exchange_begin(DEVMAN_CLIENT); - if (exch == NULL) - return errno; - } - - ipc_call_t answer; - aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, - flags, &answer); - sysarg_t retval = async_data_write_start(exch, classname, - str_size(classname)); - - if (retval != EOK) { - devman_exchange_end(exch); - async_wait_for(req, NULL); - return retval; - } - - retval = async_data_write_start(exch, devname, - str_size(devname)); - - devman_exchange_end(exch); - - if (retval != EOK) { - async_wait_for(req, NULL); - return retval; - } - - async_wait_for(req, &retval); - - if (retval != EOK) { - if (handle != NULL) - *handle = (devman_handle_t) -1; - - return retval; - } - - if (handle != NULL) - *handle = (devman_handle_t) IPC_GET_ARG1(answer); - - return retval; -} - int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size) { async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT); if (exch == NULL) - return errno; + return ENOMEM; ipc_call_t answer; @@ -463,4 +432,17 @@ } +int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle) +{ + async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT); + if (exch == NULL) + return ENOMEM; + + sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE, + sid, handle); + + devman_exchange_end(exch); + return (int) retval; +} + /** @} */ Index: uspace/lib/c/generic/devmap.c =================================================================== --- uspace/lib/c/generic/devmap.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ (revision ) @@ -1,521 +1,0 @@ -/* - * Copyright (c) 2007 Josef Cejka - * Copyright (c) 2009 Jiri Svoboda - * 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. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -static FIBRIL_MUTEX_INITIALIZE(devmap_driver_block_mutex); -static FIBRIL_MUTEX_INITIALIZE(devmap_client_block_mutex); - -static FIBRIL_MUTEX_INITIALIZE(devmap_driver_mutex); -static FIBRIL_MUTEX_INITIALIZE(devmap_client_mutex); - -static async_sess_t *devmap_driver_block_sess = NULL; -static async_sess_t *devmap_client_block_sess = NULL; - -static async_sess_t *devmap_driver_sess = NULL; -static async_sess_t *devmap_client_sess = NULL; - -static void clone_session(fibril_mutex_t *mtx, async_sess_t *src, - async_sess_t **dst) -{ - fibril_mutex_lock(mtx); - - if ((*dst == NULL) && (src != NULL)) - *dst = src; - - fibril_mutex_unlock(mtx); -} - -/** Start an async exchange on the devmap session (blocking). - * - * @param iface Device mapper interface to choose - * - * @return New exchange. - * - */ -async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t iface) -{ - switch (iface) { - case DEVMAP_DRIVER: - fibril_mutex_lock(&devmap_driver_block_mutex); - - while (devmap_driver_block_sess == NULL) { - clone_session(&devmap_driver_mutex, devmap_driver_sess, - &devmap_driver_block_sess); - - if (devmap_driver_block_sess == NULL) - devmap_driver_block_sess = - service_connect_blocking(EXCHANGE_SERIALIZE, - SERVICE_DEVMAP, DEVMAP_DRIVER, 0); - } - - fibril_mutex_unlock(&devmap_driver_block_mutex); - - clone_session(&devmap_driver_mutex, devmap_driver_block_sess, - &devmap_driver_sess); - - return async_exchange_begin(devmap_driver_block_sess); - case DEVMAP_CLIENT: - fibril_mutex_lock(&devmap_client_block_mutex); - - while (devmap_client_block_sess == NULL) { - clone_session(&devmap_client_mutex, devmap_client_sess, - &devmap_client_block_sess); - - if (devmap_client_block_sess == NULL) - devmap_client_block_sess = - service_connect_blocking(EXCHANGE_SERIALIZE, - SERVICE_DEVMAP, DEVMAP_CLIENT, 0); - } - - fibril_mutex_unlock(&devmap_client_block_mutex); - - clone_session(&devmap_client_mutex, devmap_client_block_sess, - &devmap_client_sess); - - return async_exchange_begin(devmap_client_block_sess); - default: - return NULL; - } -} - -/** Start an async exchange on the devmap session. - * - * @param iface Device mapper interface to choose - * - * @return New exchange. - * - */ -async_exch_t *devmap_exchange_begin(devmap_interface_t iface) -{ - switch (iface) { - case DEVMAP_DRIVER: - fibril_mutex_lock(&devmap_driver_mutex); - - if (devmap_driver_sess == NULL) - devmap_driver_sess = - service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAP, - DEVMAP_DRIVER, 0); - - fibril_mutex_unlock(&devmap_driver_mutex); - - if (devmap_driver_sess == NULL) - return NULL; - - return async_exchange_begin(devmap_driver_sess); - case DEVMAP_CLIENT: - fibril_mutex_lock(&devmap_client_mutex); - - if (devmap_client_sess == NULL) - devmap_client_sess = - service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAP, - DEVMAP_CLIENT, 0); - - fibril_mutex_unlock(&devmap_client_mutex); - - if (devmap_client_sess == NULL) - return NULL; - - return async_exchange_begin(devmap_client_sess); - default: - return NULL; - } -} - -/** Finish an async exchange on the devmap session. - * - * @param exch Exchange to be finished. - * - */ -void devmap_exchange_end(async_exch_t *exch) -{ - async_exchange_end(exch); -} - -/** Register new driver with devmap. */ -int devmap_driver_register(const char *name, async_client_conn_t conn) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_DRIVER); - - ipc_call_t answer; - aid_t req = async_send_2(exch, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); - sysarg_t retval = async_data_write_start(exch, name, str_size(name)); - - devmap_exchange_end(exch); - - if (retval != EOK) { - async_wait_for(req, NULL); - return retval; - } - - async_set_client_connection(conn); - - exch = devmap_exchange_begin(DEVMAP_DRIVER); - async_connect_to_me(exch, 0, 0, 0, NULL, NULL); - devmap_exchange_end(exch); - - async_wait_for(req, &retval); - return retval; -} - -/** Register new device. - * - * The @p interface is used when forwarding connection to the driver. - * If not 0, the first argument is the interface and the second argument - * is the devmap handle of the device. - * - * When the interface is zero (default), the first argument is directly - * the handle (to ensure backward compatibility). - * - * @param fqdn Fully qualified device name. - * @param[out] handle Handle to the created instance of device. - * @param interface Interface when forwarding. - * - */ -int devmap_device_register_with_iface(const char *fqdn, - devmap_handle_t *handle, sysarg_t interface) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_DRIVER); - - ipc_call_t answer; - aid_t req = async_send_2(exch, DEVMAP_DEVICE_REGISTER, interface, 0, - &answer); - sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn)); - - devmap_exchange_end(exch); - - if (retval != EOK) { - async_wait_for(req, NULL); - return retval; - } - - async_wait_for(req, &retval); - - if (retval != EOK) { - if (handle != NULL) - *handle = -1; - - return retval; - } - - if (handle != NULL) - *handle = (devmap_handle_t) IPC_GET_ARG1(answer); - - return retval; -} - -/** Register new device. - * - * @param fqdn Fully qualified device name. - * @param handle Output: Handle to the created instance of device. - * - */ -int devmap_device_register(const char *fqdn, devmap_handle_t *handle) -{ - return devmap_device_register_with_iface(fqdn, handle, 0); -} - -int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, - unsigned int flags) -{ - async_exch_t *exch; - - if (flags & IPC_FLAG_BLOCKING) - exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - else { - exch = devmap_exchange_begin(DEVMAP_CLIENT); - if (exch == NULL) - return errno; - } - - ipc_call_t answer; - aid_t req = async_send_2(exch, DEVMAP_DEVICE_GET_HANDLE, flags, 0, - &answer); - sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn)); - - devmap_exchange_end(exch); - - if (retval != EOK) { - async_wait_for(req, NULL); - return retval; - } - - async_wait_for(req, &retval); - - if (retval != EOK) { - if (handle != NULL) - *handle = (devmap_handle_t) -1; - - return retval; - } - - if (handle != NULL) - *handle = (devmap_handle_t) IPC_GET_ARG1(answer); - - return retval; -} - -int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, - unsigned int flags) -{ - async_exch_t *exch; - - if (flags & IPC_FLAG_BLOCKING) - exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - else { - exch = devmap_exchange_begin(DEVMAP_CLIENT); - if (exch == NULL) - return errno; - } - - ipc_call_t answer; - aid_t req = async_send_2(exch, DEVMAP_NAMESPACE_GET_HANDLE, flags, 0, - &answer); - sysarg_t retval = async_data_write_start(exch, name, str_size(name)); - - devmap_exchange_end(exch); - - if (retval != EOK) { - async_wait_for(req, NULL); - return retval; - } - - async_wait_for(req, &retval); - - if (retval != EOK) { - if (handle != NULL) - *handle = (devmap_handle_t) -1; - - return retval; - } - - if (handle != NULL) - *handle = (devmap_handle_t) IPC_GET_ARG1(answer); - - return retval; -} - -devmap_handle_type_t devmap_handle_probe(devmap_handle_t handle) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - - sysarg_t type; - int retval = async_req_1_1(exch, DEVMAP_HANDLE_PROBE, handle, &type); - - devmap_exchange_end(exch); - - if (retval != EOK) - return DEV_HANDLE_NONE; - - return (devmap_handle_type_t) type; -} - -async_sess_t *devmap_device_connect(exch_mgmt_t mgmt, devmap_handle_t handle, - unsigned int flags) -{ - async_sess_t *sess; - - if (flags & IPC_FLAG_BLOCKING) - sess = service_connect_blocking(mgmt, SERVICE_DEVMAP, - DEVMAP_CONNECT_TO_DEVICE, handle); - else - sess = service_connect(mgmt, SERVICE_DEVMAP, - DEVMAP_CONNECT_TO_DEVICE, handle); - - return sess; -} - -int devmap_null_create(void) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - - sysarg_t null_id; - int retval = async_req_0_1(exch, DEVMAP_NULL_CREATE, &null_id); - - devmap_exchange_end(exch); - - if (retval != EOK) - return -1; - - return (int) null_id; -} - -void devmap_null_destroy(int null_id) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - async_req_1_0(exch, DEVMAP_NULL_DESTROY, (sysarg_t) null_id); - devmap_exchange_end(exch); -} - -static size_t devmap_count_namespaces_internal(async_exch_t *exch) -{ - sysarg_t count; - int retval = async_req_0_1(exch, DEVMAP_GET_NAMESPACE_COUNT, &count); - if (retval != EOK) - return 0; - - return count; -} - -static size_t devmap_count_devices_internal(async_exch_t *exch, - devmap_handle_t ns_handle) -{ - sysarg_t count; - int retval = async_req_1_1(exch, DEVMAP_GET_DEVICE_COUNT, ns_handle, - &count); - if (retval != EOK) - return 0; - - return count; -} - -size_t devmap_count_namespaces(void) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - size_t size = devmap_count_namespaces_internal(exch); - devmap_exchange_end(exch); - - return size; -} - -size_t devmap_count_devices(devmap_handle_t ns_handle) -{ - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - size_t size = devmap_count_devices_internal(exch, ns_handle); - devmap_exchange_end(exch); - - return size; -} - -size_t devmap_get_namespaces(dev_desc_t **data) -{ - /* Loop until namespaces read succesful */ - while (true) { - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - size_t count = devmap_count_namespaces_internal(exch); - devmap_exchange_end(exch); - - if (count == 0) - return 0; - - dev_desc_t *devs = (dev_desc_t *) calloc(count, sizeof(dev_desc_t)); - if (devs == NULL) - return 0; - - exch = devmap_exchange_begin(DEVMAP_CLIENT); - - ipc_call_t answer; - aid_t req = async_send_0(exch, DEVMAP_GET_NAMESPACES, &answer); - int rc = async_data_read_start(exch, devs, count * sizeof(dev_desc_t)); - - devmap_exchange_end(exch); - - if (rc == EOVERFLOW) { - /* - * Number of namespaces has changed since - * the last call of DEVMAP_DEVICE_GET_NAMESPACE_COUNT - */ - free(devs); - continue; - } - - if (rc != EOK) { - async_wait_for(req, NULL); - free(devs); - return 0; - } - - sysarg_t retval; - async_wait_for(req, &retval); - - if (retval != EOK) - return 0; - - *data = devs; - return count; - } -} - -size_t devmap_get_devices(devmap_handle_t ns_handle, dev_desc_t **data) -{ - /* Loop until devices read succesful */ - while (true) { - async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); - size_t count = devmap_count_devices_internal(exch, ns_handle); - devmap_exchange_end(exch); - - if (count == 0) - return 0; - - dev_desc_t *devs = (dev_desc_t *) calloc(count, sizeof(dev_desc_t)); - if (devs == NULL) - return 0; - - exch = devmap_exchange_begin(DEVMAP_CLIENT); - - ipc_call_t answer; - aid_t req = async_send_1(exch, DEVMAP_GET_DEVICES, ns_handle, &answer); - int rc = async_data_read_start(exch, devs, count * sizeof(dev_desc_t)); - - devmap_exchange_end(exch); - - if (rc == EOVERFLOW) { - /* - * Number of devices has changed since - * the last call of DEVMAP_DEVICE_GET_DEVICE_COUNT - */ - free(devs); - continue; - } - - if (rc != EOK) { - async_wait_for(req, NULL); - free(devs); - return 0; - } - - sysarg_t retval; - async_wait_for(req, &retval); - - if (retval != EOK) - return 0; - - *data = devs; - return count; - } -} Index: uspace/lib/c/generic/io/io.c =================================================================== --- uspace/lib/c/generic/io/io.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/generic/io/io.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -45,5 +45,5 @@ #include #include -#include +#include #include #include "../private/io.h" Index: uspace/lib/c/generic/loc.c =================================================================== --- uspace/lib/c/generic/loc.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) +++ uspace/lib/c/generic/loc.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -0,0 +1,876 @@ +/* + * Copyright (c) 2007 Josef Cejka + * Copyright (c) 2011 Jiri Svoboda + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static FIBRIL_MUTEX_INITIALIZE(loc_supp_block_mutex); +static FIBRIL_MUTEX_INITIALIZE(loc_cons_block_mutex); + +static FIBRIL_MUTEX_INITIALIZE(loc_supplier_mutex); +static FIBRIL_MUTEX_INITIALIZE(loc_consumer_mutex); + +static FIBRIL_MUTEX_INITIALIZE(loc_callback_mutex); +static bool loc_callback_created = false; + +static async_sess_t *loc_supp_block_sess = NULL; +static async_sess_t *loc_cons_block_sess = NULL; + +static async_sess_t *loc_supplier_sess = NULL; +static async_sess_t *loc_consumer_sess = NULL; + +static loc_cat_change_cb_t cat_change_cb = NULL; + +static void loc_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + loc_cat_change_cb_t cb_fun; + + while (true) { + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) { + /* TODO: Handle hangup */ + return; + } + + int retval; + + switch (IPC_GET_IMETHOD(call)) { + case LOC_EVENT_CAT_CHANGE: + fibril_mutex_lock(&loc_callback_mutex); + cb_fun = cat_change_cb; + if (cb_fun != NULL) { + (*cb_fun)(); + } + fibril_mutex_unlock(&loc_callback_mutex); + retval = 0; + break; + default: + retval = ENOTSUP; + } + + async_answer_0(callid, retval); + } +} + + +static void clone_session(fibril_mutex_t *mtx, async_sess_t *src, + async_sess_t **dst) +{ + fibril_mutex_lock(mtx); + + if ((*dst == NULL) && (src != NULL)) + *dst = src; + + fibril_mutex_unlock(mtx); +} + +static int loc_callback_create(void) +{ + async_exch_t *exch; + sysarg_t retval; + int rc = EOK; + + fibril_mutex_lock(&loc_callback_mutex); + + if (!loc_callback_created) { + exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer); + async_connect_to_me(exch, 0, 0, 0, loc_cb_conn, NULL); + loc_exchange_end(exch); + + async_wait_for(req, &retval); + if (rc != EOK) + goto done; + + if (retval != EOK) { + rc = retval; + goto done; + } + + loc_callback_created = true; + } + + rc = EOK; +done: + fibril_mutex_unlock(&loc_callback_mutex); + return rc; +} + +/** Start an async exchange on the loc session (blocking). + * + * @param iface Location service interface to choose + * + * @return New exchange. + * + */ +async_exch_t *loc_exchange_begin_blocking(loc_interface_t iface) +{ + switch (iface) { + case LOC_PORT_SUPPLIER: + fibril_mutex_lock(&loc_supp_block_mutex); + + while (loc_supp_block_sess == NULL) { + clone_session(&loc_supplier_mutex, loc_supplier_sess, + &loc_supp_block_sess); + + if (loc_supp_block_sess == NULL) + loc_supp_block_sess = + service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_LOC, LOC_PORT_SUPPLIER, 0); + } + + fibril_mutex_unlock(&loc_supp_block_mutex); + + clone_session(&loc_supplier_mutex, loc_supp_block_sess, + &loc_supplier_sess); + + return async_exchange_begin(loc_supp_block_sess); + case LOC_PORT_CONSUMER: + fibril_mutex_lock(&loc_cons_block_mutex); + + while (loc_cons_block_sess == NULL) { + clone_session(&loc_consumer_mutex, loc_consumer_sess, + &loc_cons_block_sess); + + if (loc_cons_block_sess == NULL) + loc_cons_block_sess = + service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_LOC, LOC_PORT_CONSUMER, 0); + } + + fibril_mutex_unlock(&loc_cons_block_mutex); + + clone_session(&loc_consumer_mutex, loc_cons_block_sess, + &loc_consumer_sess); + + return async_exchange_begin(loc_cons_block_sess); + default: + return NULL; + } +} + +/** Start an async exchange on the loc session. + * + * @param iface Location service interface to choose + * + * @return New exchange. + * + */ +async_exch_t *loc_exchange_begin(loc_interface_t iface) +{ + switch (iface) { + case LOC_PORT_SUPPLIER: + fibril_mutex_lock(&loc_supplier_mutex); + + if (loc_supplier_sess == NULL) + loc_supplier_sess = + service_connect(EXCHANGE_SERIALIZE, SERVICE_LOC, + LOC_PORT_SUPPLIER, 0); + + fibril_mutex_unlock(&loc_supplier_mutex); + + if (loc_supplier_sess == NULL) + return NULL; + + return async_exchange_begin(loc_supplier_sess); + case LOC_PORT_CONSUMER: + fibril_mutex_lock(&loc_consumer_mutex); + + if (loc_consumer_sess == NULL) + loc_consumer_sess = + service_connect(EXCHANGE_SERIALIZE, SERVICE_LOC, + LOC_PORT_CONSUMER, 0); + + fibril_mutex_unlock(&loc_consumer_mutex); + + if (loc_consumer_sess == NULL) + return NULL; + + return async_exchange_begin(loc_consumer_sess); + default: + return NULL; + } +} + +/** Finish an async exchange on the loc session. + * + * @param exch Exchange to be finished. + * + */ +void loc_exchange_end(async_exch_t *exch) +{ + async_exchange_end(exch); +} + +/** Register new driver with loc. */ +int loc_server_register(const char *name, async_client_conn_t conn) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER); + + ipc_call_t answer; + aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + loc_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_set_client_connection(conn); + + exch = loc_exchange_begin(LOC_PORT_SUPPLIER); + async_connect_to_me(exch, 0, 0, 0, NULL, NULL); + loc_exchange_end(exch); + + async_wait_for(req, &retval); + return retval; +} + +/** Register new service. + * + * The @p interface is used when forwarding connection to the server. + * If not 0, the first argument is the interface and the second argument + * is the service ID. + * + * When the interface is zero (default), the first argument is directly + * the handle (to ensure backward compatibility). + * + * @param fqsn Fully qualified service name + * @param[out] sid Service ID of new service + * @param interface Interface when forwarding + * + */ +int loc_service_register_with_iface(const char *fqsn, + service_id_t *sid, sysarg_t interface) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER); + + ipc_call_t answer; + aid_t req = async_send_2(exch, LOC_SERVICE_REGISTER, interface, 0, + &answer); + sysarg_t retval = async_data_write_start(exch, fqsn, str_size(fqsn)); + + loc_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + + if (retval != EOK) { + if (sid != NULL) + *sid = -1; + + return retval; + } + + if (sid != NULL) + *sid = (service_id_t) IPC_GET_ARG1(answer); + + return retval; +} + +/** Register new service. + * + * @param fqsn Fully qualified service name + * @param sid Output: ID of new service + * + */ +int loc_service_register(const char *fqdn, service_id_t *sid) +{ + return loc_service_register_with_iface(fqdn, sid, 0); +} + +/** Unregister service. + * + * @param sid Service ID + */ +int loc_service_unregister(service_id_t sid) +{ + async_exch_t *exch; + sysarg_t retval; + + exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER); + retval = async_req_1_0(exch, LOC_SERVICE_UNREGISTER, sid); + loc_exchange_end(exch); + + return (int)retval; +} + +int loc_service_get_id(const char *fqdn, service_id_t *handle, + unsigned int flags) +{ + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + else { + exch = loc_exchange_begin(LOC_PORT_CONSUMER); + if (exch == NULL) + return errno; + } + + ipc_call_t answer; + aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0, + &answer); + sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn)); + + loc_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + + if (retval != EOK) { + if (handle != NULL) + *handle = (service_id_t) -1; + + return retval; + } + + if (handle != NULL) + *handle = (service_id_t) IPC_GET_ARG1(answer); + + return retval; +} + +/** Get object name. + * + * Provided ID of an object, return its name. + * + * @param method IPC method + * @param id Object ID + * @param name Place to store pointer to new string. Caller should + * free it using free(). + * @return EOK on success or negative error code + */ +static int loc_get_name_internal(sysarg_t method, sysarg_t id, char **name) +{ + async_exch_t *exch; + char name_buf[LOC_NAME_MAXLEN + 1]; + ipc_call_t dreply; + size_t act_size; + sysarg_t dretval; + + *name = NULL; + exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + + ipc_call_t answer; + aid_t req = async_send_1(exch, method, id, &answer); + aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, + &dreply); + async_wait_for(dreq, &dretval); + + loc_exchange_end(exch); + + if (dretval != EOK) { + async_wait_for(req, NULL); + return dretval; + } + + sysarg_t retval; + async_wait_for(req, &retval); + + if (retval != EOK) + return retval; + + act_size = IPC_GET_ARG2(dreply); + assert(act_size <= LOC_NAME_MAXLEN); + name_buf[act_size] = '\0'; + + *name = str_dup(name_buf); + if (*name == NULL) + return ENOMEM; + + return EOK; +} + +/** Get category name. + * + * Provided ID of a service, return its name. + * + * @param cat_id Category ID + * @param name Place to store pointer to new string. Caller should + * free it using free(). + * @return EOK on success or negative error code + */ +int loc_category_get_name(category_id_t cat_id, char **name) +{ + return loc_get_name_internal(LOC_CATEGORY_GET_NAME, cat_id, name); +} + +/** Get service name. + * + * Provided ID of a service, return its name. + * + * @param svc_id Service ID + * @param name Place to store pointer to new string. Caller should + * free it using free(). + * @return EOK on success or negative error code + */ +int loc_service_get_name(service_id_t svc_id, char **name) +{ + return loc_get_name_internal(LOC_SERVICE_GET_NAME, svc_id, name); +} + +int loc_namespace_get_id(const char *name, service_id_t *handle, + unsigned int flags) +{ + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + else { + exch = loc_exchange_begin(LOC_PORT_CONSUMER); + if (exch == NULL) + return errno; + } + + ipc_call_t answer; + aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0, + &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + loc_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + + if (retval != EOK) { + if (handle != NULL) + *handle = (service_id_t) -1; + + return retval; + } + + if (handle != NULL) + *handle = (service_id_t) IPC_GET_ARG1(answer); + + return retval; +} + +/** Get category ID. + * + * Provided name of a category, return its ID. + * + * @param name Category name + * @param cat_id Place to store ID + * @param flags IPC_FLAG_BLOCKING to wait for location service to start + * @return EOK on success or negative error code + */ +int loc_category_get_id(const char *name, category_id_t *cat_id, + unsigned int flags) +{ + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + else { + exch = loc_exchange_begin(LOC_PORT_CONSUMER); + if (exch == NULL) + return errno; + } + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID, + &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + loc_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + + if (retval != EOK) { + if (cat_id != NULL) + *cat_id = (category_id_t) -1; + + return retval; + } + + if (cat_id != NULL) + *cat_id = (category_id_t) IPC_GET_ARG1(answer); + + return retval; +} + + +loc_object_type_t loc_id_probe(service_id_t handle) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + + sysarg_t type; + int retval = async_req_1_1(exch, LOC_ID_PROBE, handle, &type); + + loc_exchange_end(exch); + + if (retval != EOK) + return LOC_OBJECT_NONE; + + return (loc_object_type_t) type; +} + +async_sess_t *loc_service_connect(exch_mgmt_t mgmt, service_id_t handle, + unsigned int flags) +{ + async_sess_t *sess; + + if (flags & IPC_FLAG_BLOCKING) + sess = service_connect_blocking(mgmt, SERVICE_LOC, + LOC_CONNECT_TO_SERVICE, handle); + else + sess = service_connect(mgmt, SERVICE_LOC, + LOC_CONNECT_TO_SERVICE, handle); + + return sess; +} + +int loc_null_create(void) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + + sysarg_t null_id; + int retval = async_req_0_1(exch, LOC_NULL_CREATE, &null_id); + + loc_exchange_end(exch); + + if (retval != EOK) + return -1; + + return (int) null_id; +} + +void loc_null_destroy(int null_id) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + async_req_1_0(exch, LOC_NULL_DESTROY, (sysarg_t) null_id); + loc_exchange_end(exch); +} + +static size_t loc_count_namespaces_internal(async_exch_t *exch) +{ + sysarg_t count; + int retval = async_req_0_1(exch, LOC_GET_NAMESPACE_COUNT, &count); + if (retval != EOK) + return 0; + + return count; +} + +/** Add service to category. + * + * @param svc_id Service ID + * @param cat_id Category ID + * @return EOK on success or negative error code + */ +int loc_service_add_to_cat(service_id_t svc_id, service_id_t cat_id) +{ + async_exch_t *exch; + sysarg_t retval; + + exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER); + retval = async_req_2_0(exch, LOC_SERVICE_ADD_TO_CAT, svc_id, cat_id); + loc_exchange_end(exch); + + return retval; +} + +static size_t loc_count_services_internal(async_exch_t *exch, + service_id_t ns_handle) +{ + sysarg_t count; + int retval = async_req_1_1(exch, LOC_GET_SERVICE_COUNT, ns_handle, + &count); + if (retval != EOK) + return 0; + + return count; +} + +size_t loc_count_namespaces(void) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + size_t size = loc_count_namespaces_internal(exch); + loc_exchange_end(exch); + + return size; +} + +size_t loc_count_services(service_id_t ns_handle) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + size_t size = loc_count_services_internal(exch, ns_handle); + loc_exchange_end(exch); + + return size; +} + +size_t loc_get_namespaces(loc_sdesc_t **data) +{ + /* Loop until read is succesful */ + while (true) { + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + size_t count = loc_count_namespaces_internal(exch); + loc_exchange_end(exch); + + if (count == 0) + return 0; + + loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t)); + if (devs == NULL) + return 0; + + exch = loc_exchange_begin(LOC_PORT_CONSUMER); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOC_GET_NAMESPACES, &answer); + int rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t)); + + loc_exchange_end(exch); + + if (rc == EOVERFLOW) { + /* + * Number of namespaces has changed since + * the last call of LOC_GET_NAMESPACE_COUNT + */ + free(devs); + continue; + } + + if (rc != EOK) { + async_wait_for(req, NULL); + free(devs); + return 0; + } + + sysarg_t retval; + async_wait_for(req, &retval); + + if (retval != EOK) + return 0; + + *data = devs; + return count; + } +} + +size_t loc_get_services(service_id_t ns_handle, loc_sdesc_t **data) +{ + /* Loop until read is succesful */ + while (true) { + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + size_t count = loc_count_services_internal(exch, ns_handle); + loc_exchange_end(exch); + + if (count == 0) + return 0; + + loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t)); + if (devs == NULL) + return 0; + + exch = loc_exchange_begin(LOC_PORT_CONSUMER); + + ipc_call_t answer; + aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer); + int rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t)); + + loc_exchange_end(exch); + + if (rc == EOVERFLOW) { + /* + * Number of services has changed since + * the last call of LOC_GET_SERVICE_COUNT + */ + free(devs); + continue; + } + + if (rc != EOK) { + async_wait_for(req, NULL); + free(devs); + return 0; + } + + sysarg_t retval; + async_wait_for(req, &retval); + + if (retval != EOK) + return 0; + + *data = devs; + return count; + } +} + +static int loc_category_get_ids_once(sysarg_t method, sysarg_t arg1, + sysarg_t *id_buf, size_t buf_size, size_t *act_size) +{ + async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER); + + ipc_call_t answer; + aid_t req = async_send_1(exch, method, arg1, &answer); + int rc = async_data_read_start(exch, id_buf, buf_size); + + loc_exchange_end(exch); + + if (rc != EOK) { + async_wait_for(req, NULL); + return rc; + } + + sysarg_t retval; + async_wait_for(req, &retval); + + if (retval != EOK) { + return retval; + } + + *act_size = IPC_GET_ARG1(answer); + return EOK; +} + +/** Get list of IDs. + * + * Returns an allocated array of service IDs. + * + * @param method IPC method + * @param arg1 IPC argument 1 + * @param data Place to store pointer to array of IDs + * @param count Place to store number of IDs + * @return EOK on success or negative error code + */ +static int loc_get_ids_internal(sysarg_t method, sysarg_t arg1, + sysarg_t **data, size_t *count) +{ + service_id_t *ids; + size_t act_size; + size_t alloc_size; + int rc; + + *data = NULL; + act_size = 0; /* silence warning */ + + rc = loc_category_get_ids_once(method, arg1, NULL, 0, + &act_size); + if (rc != EOK) + return rc; + + alloc_size = act_size; + ids = malloc(alloc_size); + if (ids == NULL) + return ENOMEM; + + while (true) { + rc = loc_category_get_ids_once(method, arg1, ids, alloc_size, + &act_size); + if (rc != EOK) + return rc; + + if (act_size <= alloc_size) + break; + + alloc_size *= 2; + free(ids); + + ids = malloc(alloc_size); + if (ids == NULL) + return ENOMEM; + } + + *count = act_size / sizeof(category_id_t); + *data = ids; + return EOK; +} + +/** Get list of services in category. + * + * Returns an allocated array of service IDs. + * + * @param cat_id Category ID + * @param data Place to store pointer to array of IDs + * @param count Place to store number of IDs + * @return EOK on success or negative error code + */ +int loc_category_get_svcs(category_id_t cat_id, service_id_t **data, + size_t *count) +{ + return loc_get_ids_internal(LOC_CATEGORY_GET_SVCS, cat_id, + data, count); +} + +/** Get list of categories. + * + * Returns an allocated array of category IDs. + * + * @param data Place to store pointer to array of IDs + * @param count Place to store number of IDs + * @return EOK on success or negative error code + */ +int loc_get_categories(category_id_t **data, size_t *count) +{ + return loc_get_ids_internal(LOC_GET_CATEGORIES, 0, + data, count); +} + +int loc_register_cat_change_cb(loc_cat_change_cb_t cb_fun) +{ + if (loc_callback_create() != EOK) + return EIO; + + cat_change_cb = cb_fun; + return EOK; +} Index: uspace/lib/c/generic/vfs/vfs.c =================================================================== --- uspace/lib/c/generic/vfs/vfs.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/generic/vfs/vfs.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -51,7 +51,7 @@ #include #include -#include +#include #include -#include +#include static FIBRIL_MUTEX_INITIALIZE(vfs_mutex); @@ -142,27 +142,27 @@ } -int mount(const char *fs_name, const char *mp, const char *fqdn, +int mount(const char *fs_name, const char *mp, const char *fqsn, const char *opts, unsigned int flags) { int null_id = -1; - char null[DEVMAP_NAME_MAXLEN]; - - if (str_cmp(fqdn, "") == 0) { + char null[LOC_NAME_MAXLEN]; + + if (str_cmp(fqsn, "") == 0) { /* No device specified, create a fresh null/%d device instead */ - null_id = devmap_null_create(); + null_id = loc_null_create(); if (null_id == -1) return ENOMEM; - snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id); - fqdn = null; - } - - devmap_handle_t devmap_handle; - int res = devmap_device_get_handle(fqdn, &devmap_handle, flags); + snprintf(null, LOC_NAME_MAXLEN, "null/%d", null_id); + fqsn = null; + } + + service_id_t service_id; + int res = loc_service_get_id(fqsn, &service_id, flags); if (res != EOK) { if (null_id != -1) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); return res; @@ -173,5 +173,5 @@ if (!mpa) { if (null_id != -1) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); return ENOMEM; @@ -181,5 +181,5 @@ sysarg_t rc_orig; - aid_t req = async_send_2(exch, VFS_IN_MOUNT, devmap_handle, flags, NULL); + aid_t req = async_send_2(exch, VFS_IN_MOUNT, service_id, flags, NULL); sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size); if (rc != EOK) { @@ -189,5 +189,5 @@ if (null_id != -1) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); if (rc_orig == EOK) @@ -204,5 +204,5 @@ if (null_id != -1) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); if (rc_orig == EOK) @@ -219,5 +219,5 @@ if (null_id != -1) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); if (rc_orig == EOK) @@ -235,5 +235,5 @@ if (null_id != -1) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); if (rc_orig == EOK) @@ -248,5 +248,5 @@ if ((rc != EOK) && (null_id != -1)) - devmap_null_destroy(null_id); + loc_null_destroy(null_id); return (int) rc; @@ -792,10 +792,10 @@ } - if (!stat.device) { + if (!stat.service) { errno = ENOENT; return NULL; } - return devmap_device_connect(mgmt, stat.device, 0); + return loc_service_connect(mgmt, stat.service, 0); } Index: uspace/lib/c/include/devman.h =================================================================== --- uspace/lib/c/include/devman.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/include/devman.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -38,4 +38,5 @@ #include +#include #include #include @@ -48,4 +49,5 @@ extern int devman_add_function(const char *, fun_type_t, match_id_list_t *, devman_handle_t, devman_handle_t *); +extern int devman_remove_function(devman_handle_t); extern async_sess_t *devman_device_connect(exch_mgmt_t, devman_handle_t, @@ -56,9 +58,8 @@ extern int devman_device_get_handle(const char *, devman_handle_t *, unsigned int); -extern int devman_device_get_handle_by_class(const char *, const char *, - devman_handle_t *, unsigned int); extern int devman_get_device_path(devman_handle_t, char *, size_t); -extern int devman_add_device_to_class(devman_handle_t, const char *); +extern int devman_add_device_to_category(devman_handle_t, const char *); +extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *); #endif Index: uspace/lib/c/include/devmap.h =================================================================== --- uspace/lib/c/include/devmap.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ (revision ) @@ -1,72 +1,0 @@ -/* - * Copyright (c) 2009 Jiri Svoboda - * 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 libc - * @{ - */ -/** @file - */ - -#ifndef LIBC_DEVMAP_H_ -#define LIBC_DEVMAP_H_ - -#include -#include -#include - -extern async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t); -extern async_exch_t *devmap_exchange_begin(devmap_interface_t); -extern void devmap_exchange_end(async_exch_t *); - -extern int devmap_driver_register(const char *, async_client_conn_t); -extern int devmap_device_register(const char *, devmap_handle_t *); -extern int devmap_device_register_with_iface(const char *, devmap_handle_t *, - sysarg_t); - -extern int devmap_device_get_handle(const char *, devmap_handle_t *, - unsigned int); -extern int devmap_namespace_get_handle(const char *, devmap_handle_t *, - unsigned int); -extern devmap_handle_type_t devmap_handle_probe(devmap_handle_t); - -extern async_sess_t *devmap_device_connect(exch_mgmt_t, devmap_handle_t, - unsigned int); - -extern int devmap_null_create(void); -extern void devmap_null_destroy(int); - -extern size_t devmap_count_namespaces(void); -extern size_t devmap_count_devices(devmap_handle_t); - -extern size_t devmap_get_namespaces(dev_desc_t **); -extern size_t devmap_get_devices(devmap_handle_t, dev_desc_t **); - -#endif - -/** @} - */ Index: uspace/lib/c/include/ipc/devman.h =================================================================== --- uspace/lib/c/include/ipc/devman.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/include/ipc/devman.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -130,5 +130,5 @@ DEVMAN_CLIENT, DEVMAN_CONNECT_TO_DEVICE, - DEVMAN_CONNECT_FROM_DEVMAP, + DEVMAN_CONNECT_FROM_LOC, DEVMAN_CONNECT_TO_PARENTS_DEVICE } devman_interface_t; @@ -138,6 +138,6 @@ DEVMAN_ADD_FUNCTION, DEVMAN_ADD_MATCH_ID, - DEVMAN_ADD_DEVICE_TO_CLASS - + DEVMAN_ADD_DEVICE_TO_CATEGORY, + DEVMAN_REMOVE_FUNCTION } driver_to_devman_t; @@ -149,6 +149,6 @@ typedef enum { DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD, - DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, - DEVMAN_DEVICE_GET_DEVICE_PATH + DEVMAN_DEVICE_GET_DEVICE_PATH, + DEVMAN_FUN_SID_TO_HANDLE } client_to_devman_t; Index: uspace/lib/c/include/ipc/devmap.h =================================================================== --- uspace/lib/c/include/ipc/devmap.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ (revision ) @@ -1,85 +1,0 @@ -/* - * Copyright (c) 2007 Josef Cejka - * 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 devmap - * @{ - */ - -#ifndef LIBC_IPC_DEVMAP_H_ -#define LIBC_IPC_DEVMAP_H_ - -#include - -#define DEVMAP_NAME_MAXLEN 255 - -typedef sysarg_t devmap_handle_t; - -typedef enum { - DEV_HANDLE_NONE, - DEV_HANDLE_NAMESPACE, - DEV_HANDLE_DEVICE -} devmap_handle_type_t; - -typedef enum { - DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD, - DEVMAP_DRIVER_UNREGISTER, - DEVMAP_DEVICE_REGISTER, - DEVMAP_DEVICE_UNREGISTER, - DEVMAP_DEVICE_GET_HANDLE, - DEVMAP_NAMESPACE_GET_HANDLE, - DEVMAP_HANDLE_PROBE, - DEVMAP_NULL_CREATE, - DEVMAP_NULL_DESTROY, - DEVMAP_GET_NAMESPACE_COUNT, - DEVMAP_GET_DEVICE_COUNT, - DEVMAP_GET_NAMESPACES, - DEVMAP_GET_DEVICES -} devmap_request_t; - -/** Interface provided by devmap. - * - * Every process that connects to devmap must ask one of following - * interfaces otherwise connection will be refused. - * - */ -typedef enum { - /** Connect as device driver */ - DEVMAP_DRIVER = 1, - /** Connect as client */ - DEVMAP_CLIENT, - /** Create new connection to instance of device that - is specified by second argument of call. */ - DEVMAP_CONNECT_TO_DEVICE -} devmap_interface_t; - -typedef struct { - devmap_handle_t handle; - char name[DEVMAP_NAME_MAXLEN + 1]; -} dev_desc_t; - -#endif Index: uspace/lib/c/include/ipc/loc.h =================================================================== --- uspace/lib/c/include/ipc/loc.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) +++ uspace/lib/c/include/ipc/loc.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2007 Josef Cejka + * Copyright (c) 2011 Jiri Svoboda + * 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 loc + * @{ + */ + +#ifndef LIBC_IPC_LOC_H_ +#define LIBC_IPC_LOC_H_ + +#include + +#define LOC_NAME_MAXLEN 255 + +typedef sysarg_t service_id_t; +typedef sysarg_t category_id_t; + +typedef enum { + LOC_OBJECT_NONE, + LOC_OBJECT_NAMESPACE, + LOC_OBJECT_SERVICE +} loc_object_type_t; + +typedef enum { + LOC_SERVER_REGISTER = IPC_FIRST_USER_METHOD, + LOC_SERVER_UNREGISTER, + LOC_SERVICE_ADD_TO_CAT, + LOC_SERVICE_REGISTER, + LOC_SERVICE_UNREGISTER, + LOC_SERVICE_GET_ID, + LOC_SERVICE_GET_NAME, + LOC_NAMESPACE_GET_ID, + LOC_CALLBACK_CREATE, + LOC_CATEGORY_GET_ID, + LOC_CATEGORY_GET_NAME, + LOC_CATEGORY_GET_SVCS, + LOC_ID_PROBE, + LOC_NULL_CREATE, + LOC_NULL_DESTROY, + LOC_GET_NAMESPACE_COUNT, + LOC_GET_SERVICE_COUNT, + LOC_GET_CATEGORIES, + LOC_GET_NAMESPACES, + LOC_GET_SERVICES +} loc_request_t; + +typedef enum { + LOC_EVENT_CAT_CHANGE = IPC_FIRST_USER_METHOD +} loc_event_t; + +/** Ports provided by location service. + * + * Every process that connects to loc must ask one of following + * ports, otherwise connection will be refused. + * + */ +typedef enum { + /** Service supplier (server) port */ + LOC_PORT_SUPPLIER = 1, + /** Service consumer (client) port */ + LOC_PORT_CONSUMER, + /** Create new connection to instance of device that + is specified by second argument of call. */ + LOC_CONNECT_TO_SERVICE +} loc_interface_t; + +typedef struct { + service_id_t id; + char name[LOC_NAME_MAXLEN + 1]; +} loc_sdesc_t; + +#endif Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/include/ipc/services.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -45,5 +45,5 @@ SERVICE_VIDEO = FOURCC('v', 'i', 'd', ' '), SERVICE_VFS = FOURCC('v', 'f', 's', ' '), - SERVICE_DEVMAP = FOURCC('d', 'e', 'v', 'p'), + SERVICE_LOC = FOURCC('l', 'o', 'c', ' '), SERVICE_DEVMAN = FOURCC('d', 'e', 'v', 'n'), SERVICE_IRC = FOURCC('i', 'r', 'c', ' '), Index: uspace/lib/c/include/loc.h =================================================================== --- uspace/lib/c/include/loc.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) +++ uspace/lib/c/include/loc.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * 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 libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_LOC_H_ +#define LIBC_LOC_H_ + +#include +#include +#include + +typedef void (*loc_cat_change_cb_t)(void); + +extern async_exch_t *loc_exchange_begin_blocking(loc_interface_t); +extern async_exch_t *loc_exchange_begin(loc_interface_t); +extern void loc_exchange_end(async_exch_t *); + +extern int loc_server_register(const char *, async_client_conn_t); +extern int loc_service_register(const char *, service_id_t *); +extern int loc_service_register_with_iface(const char *, service_id_t *, + sysarg_t); +extern int loc_service_unregister(service_id_t); +extern int loc_service_add_to_cat(service_id_t, category_id_t); + +extern int loc_service_get_id(const char *, service_id_t *, + unsigned int); +extern int loc_service_get_name(service_id_t, char **); +extern int loc_namespace_get_id(const char *, service_id_t *, + unsigned int); +extern int loc_category_get_id(const char *, category_id_t *, + unsigned int); +extern int loc_category_get_name(category_id_t, char **); +extern int loc_category_get_svcs(category_id_t, category_id_t **, size_t *); +extern loc_object_type_t loc_id_probe(service_id_t); + +extern async_sess_t *loc_service_connect(exch_mgmt_t, service_id_t, + unsigned int); + +extern int loc_null_create(void); +extern void loc_null_destroy(int); + +extern size_t loc_count_namespaces(void); +extern size_t loc_count_services(service_id_t); + +extern size_t loc_get_namespaces(loc_sdesc_t **); +extern size_t loc_get_services(service_id_t, loc_sdesc_t **); +extern int loc_get_categories(category_id_t **, size_t *); +extern int loc_register_cat_change_cb(loc_cat_change_cb_t); + + +#endif + +/** @} + */ Index: uspace/lib/c/include/sys/stat.h =================================================================== --- uspace/lib/c/include/sys/stat.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/include/sys/stat.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -39,9 +39,9 @@ #include #include -#include +#include struct stat { fs_handle_t fs_handle; - devmap_handle_t devmap_handle; + service_id_t service_id; fs_index_t index; unsigned int lnkcnt; @@ -49,5 +49,5 @@ bool is_directory; aoff64_t size; - devmap_handle_t device; + service_id_t service; }; Index: uspace/lib/c/include/vfs/vfs.h =================================================================== --- uspace/lib/c/include/vfs/vfs.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/c/include/vfs/vfs.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -38,5 +38,5 @@ #include #include -#include +#include #include #include Index: uspace/lib/drv/generic/driver.c =================================================================== --- uspace/lib/drv/generic/driver.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/drv/generic/driver.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -582,4 +582,5 @@ int ddf_fun_bind(ddf_fun_t *fun) { + assert(fun->bound == false); assert(fun->name != NULL); @@ -598,4 +599,29 @@ } +/** Unbind a function node. + * + * Unbind the specified function from the system. This effectively makes + * the function invisible to the system. + * + * @param fun Function to bind + * @return EOK on success or negative error code + */ +int ddf_fun_unbind(ddf_fun_t *fun) +{ + int res; + + assert(fun->bound == true); + + add_to_functions_list(fun); + res = devman_remove_function(fun->handle); + if (res != EOK) + return res; + + remove_from_functions_list(fun); + + fun->bound = false; + return EOK; +} + /** Add single match ID to inner function. * @@ -635,14 +661,14 @@ } -/** Add exposed function to class. +/** Add exposed function to category. * * Must only be called when the function is bound. */ -int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name) +int ddf_fun_add_to_category(ddf_fun_t *fun, const char *cat_name) { assert(fun->bound == true); assert(fun->ftype == fun_exposed); - return devman_add_device_to_class(fun->handle, class_name); + return devman_add_device_to_category(fun->handle, cat_name); } Index: uspace/lib/drv/include/ddf/driver.h =================================================================== --- uspace/lib/drv/include/ddf/driver.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/drv/include/ddf/driver.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -149,7 +149,8 @@ extern void ddf_fun_destroy(ddf_fun_t *); extern int ddf_fun_bind(ddf_fun_t *); +extern int ddf_fun_unbind(ddf_fun_t *); extern int ddf_fun_add_match_id(ddf_fun_t *, const char *, int); -extern int ddf_fun_add_to_class(ddf_fun_t *, const char *); +extern int ddf_fun_add_to_category(ddf_fun_t *, const char *); #endif Index: uspace/lib/ext2/libext2_filesystem.c =================================================================== --- uspace/lib/ext2/libext2_filesystem.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/ext2/libext2_filesystem.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -50,9 +50,9 @@ * * @param fs Pointer to ext2_filesystem_t to initialize - * @param devmap_handle Device handle of the block device - * - * @return EOK on success or negative error code on failure - */ -int ext2_filesystem_init(ext2_filesystem_t *fs, devmap_handle_t devmap_handle) + * @param service_id Service ID of the block device + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_init(ext2_filesystem_t *fs, service_id_t service_id) { int rc; @@ -60,5 +60,5 @@ size_t block_size; - fs->device = devmap_handle; + fs->device = service_id; rc = block_init(EXCHANGE_SERIALIZE, fs->device, 2048); @@ -80,5 +80,5 @@ } - rc = block_cache_init(devmap_handle, block_size, 0, CACHE_MODE_WT); + rc = block_cache_init(service_id, block_size, 0, CACHE_MODE_WT); if (rc != EOK) { block_fini(fs->device); Index: uspace/lib/ext2/libext2_filesystem.h =================================================================== --- uspace/lib/ext2/libext2_filesystem.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/ext2/libext2_filesystem.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -43,5 +43,5 @@ typedef struct ext2_filesystem { - devmap_handle_t device; + service_id_t device; ext2_superblock_t * superblock; } ext2_filesystem_t; @@ -59,5 +59,5 @@ #define EXT2_SUPPORTED_READ_ONLY_FEATURES 0 -extern int ext2_filesystem_init(ext2_filesystem_t *, devmap_handle_t); +extern int ext2_filesystem_init(ext2_filesystem_t *, service_id_t); extern int ext2_filesystem_check_sanity(ext2_filesystem_t *); extern int ext2_filesystem_check_flags(ext2_filesystem_t *, bool *); Index: uspace/lib/ext2/libext2_superblock.c =================================================================== --- uspace/lib/ext2/libext2_superblock.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/ext2/libext2_superblock.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -321,10 +321,10 @@ /** Read a superblock directly from device (i.e. no libblock cache) * - * @param devmap_handle Device handle of the block device. + * @param service_id Service ID of the block device. * @param superblock Pointer where to store pointer to new superblock * * @return EOK on success or negative error code on failure. */ -int ext2_superblock_read_direct(devmap_handle_t devmap_handle, +int ext2_superblock_read_direct(service_id_t service_id, ext2_superblock_t **superblock) { @@ -337,5 +337,5 @@ } - rc = block_read_bytes_direct(devmap_handle, EXT2_SUPERBLOCK_OFFSET, + rc = block_read_bytes_direct(service_id, EXT2_SUPERBLOCK_OFFSET, EXT2_SUPERBLOCK_SIZE, data); if (rc != EOK) { Index: uspace/lib/ext2/libext2_superblock.h =================================================================== --- uspace/lib/ext2/libext2_superblock.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/ext2/libext2_superblock.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -110,5 +110,5 @@ extern uint32_t ext2_superblock_get_features_read_only(ext2_superblock_t *); -extern int ext2_superblock_read_direct(devmap_handle_t, ext2_superblock_t **); +extern int ext2_superblock_read_direct(service_id_t, ext2_superblock_t **); extern int ext2_superblock_check_sanity(ext2_superblock_t *); Index: uspace/lib/fs/libfs.c =================================================================== --- uspace/lib/fs/libfs.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/fs/libfs.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -77,5 +77,5 @@ static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); char *opts; int rc; @@ -91,5 +91,5 @@ aoff64_t size; unsigned lnkcnt; - rc = vfs_out_ops->mounted(devmap_handle, opts, &index, &size, &lnkcnt); + rc = vfs_out_ops->mounted(service_id, opts, &index, &size, &lnkcnt); if (rc == EOK) @@ -109,8 +109,8 @@ static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); int rc; - rc = vfs_out_ops->unmounted(devmap_handle); + rc = vfs_out_ops->unmounted(service_id); async_answer_0(rid, rc); @@ -130,5 +130,5 @@ static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req), @@ -137,5 +137,5 @@ int rc; - rc = vfs_out_ops->read(devmap_handle, index, pos, &rbytes); + rc = vfs_out_ops->read(service_id, index, pos, &rbytes); if (rc == EOK) @@ -147,5 +147,5 @@ static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req), @@ -155,5 +155,5 @@ int rc; - rc = vfs_out_ops->write(devmap_handle, index, pos, &wbytes, &nsize); + rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize); if (rc == EOK) @@ -165,5 +165,5 @@ static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req), @@ -171,5 +171,5 @@ int rc; - rc = vfs_out_ops->truncate(devmap_handle, index, size); + rc = vfs_out_ops->truncate(service_id, index, size); async_answer_0(rid, rc); @@ -178,9 +178,9 @@ static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); int rc; - rc = vfs_out_ops->close(devmap_handle, index); + rc = vfs_out_ops->close(service_id, index); async_answer_0(rid, rc); @@ -189,9 +189,9 @@ static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); int rc; - rc = vfs_out_ops->destroy(devmap_handle, index); + rc = vfs_out_ops->destroy(service_id, index); async_answer_0(rid, rc); @@ -210,9 +210,9 @@ static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); int rc; - rc = vfs_out_ops->sync(devmap_handle, index); + rc = vfs_out_ops->sync(service_id, index); async_answer_0(rid, rc); @@ -380,8 +380,8 @@ ipc_call_t *req) { - devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req); - devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*req); + service_id_t mr_service_id = (service_id_t) IPC_GET_ARG4(*req); async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL); @@ -392,5 +392,5 @@ fs_node_t *fn; - int res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); + int res = ops->node_get(&fn, mp_service_id, mp_fs_index); if ((res != EOK) || (!fn)) { async_hangup(mountee_sess); @@ -422,5 +422,5 @@ ipc_call_t answer; int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED, - mr_devmap_handle, &answer); + mr_service_id, &answer); async_exchange_end(exch); @@ -428,5 +428,5 @@ fn->mp_data.mp_active = true; fn->mp_data.fs_handle = mr_fs_handle; - fn->mp_data.devmap_handle = mr_devmap_handle; + fn->mp_data.service_id = mr_service_id; fn->mp_data.sess = mountee_sess; } @@ -441,10 +441,10 @@ void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req) { - devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*req); + service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req); fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); fs_node_t *fn; int res; - res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); + res = ops->node_get(&fn, mp_service_id, mp_fs_index); if ((res != EOK) || (!fn)) { async_answer_0(rid, combine_rc(res, ENOENT)); @@ -465,5 +465,5 @@ */ async_exch_t *exch = async_exchange_begin(fn->mp_data.sess); - res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.devmap_handle); + res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.service_id); async_exchange_end(exch); @@ -475,5 +475,5 @@ fn->mp_data.mp_active = false; fn->mp_data.fs_handle = 0; - fn->mp_data.devmap_handle = 0; + fn->mp_data.service_id = 0; fn->mp_data.sess = NULL; @@ -510,5 +510,5 @@ unsigned int last = IPC_GET_ARG2(*req); unsigned int next = first; - devmap_handle_t devmap_handle = IPC_GET_ARG3(*req); + service_id_t service_id = IPC_GET_ARG3(*req); int lflag = IPC_GET_ARG4(*req); fs_index_t index = IPC_GET_ARG5(*req); @@ -524,5 +524,5 @@ fs_node_t *tmp = NULL; - rc = ops->root_get(&cur, devmap_handle); + rc = ops->root_get(&cur, service_id); on_error(rc, goto out_with_answer); @@ -530,5 +530,5 @@ async_exch_t *exch = async_exchange_begin(cur->mp_data.sess); async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, - cur->mp_data.devmap_handle, lflag, index, + cur->mp_data.service_id, lflag, index, IPC_FF_ROUTE_FROM_ME); async_exchange_end(exch); @@ -591,5 +591,5 @@ async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess); async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, - last, tmp->mp_data.devmap_handle, lflag, index, + last, tmp->mp_data.service_id, lflag, index, IPC_FF_ROUTE_FROM_ME); async_exchange_end(exch); @@ -620,8 +620,8 @@ fs_node_t *fn; if (lflag & L_CREATE) - rc = ops->create(&fn, devmap_handle, + rc = ops->create(&fn, service_id, lflag); else - rc = ops->node_get(&fn, devmap_handle, + rc = ops->node_get(&fn, service_id, index); on_error(rc, goto out_with_answer); @@ -638,5 +638,5 @@ aoff64_t size = ops->size_get(fn); async_answer_5(rid, fs_handle, - devmap_handle, + service_id, ops->index_get(fn), LOWER32(size), @@ -706,7 +706,7 @@ fs_node_t *fn; if (lflag & L_CREATE) - rc = ops->create(&fn, devmap_handle, lflag); + rc = ops->create(&fn, service_id, lflag); else - rc = ops->node_get(&fn, devmap_handle, index); + rc = ops->node_get(&fn, service_id, index); on_error(rc, goto out_with_answer); @@ -722,5 +722,5 @@ aoff64_t size = ops->size_get(fn); async_answer_5(rid, fs_handle, - devmap_handle, + service_id, ops->index_get(fn), LOWER32(size), @@ -748,5 +748,5 @@ if (rc == EOK) { aoff64_t size = ops->size_get(cur); - async_answer_5(rid, fs_handle, devmap_handle, + async_answer_5(rid, fs_handle, service_id, ops->index_get(cur), LOWER32(size), UPPER32(size), old_lnkcnt); @@ -786,5 +786,5 @@ if (rc == EOK) { aoff64_t size = ops->size_get(cur); - async_answer_5(rid, fs_handle, devmap_handle, + async_answer_5(rid, fs_handle, service_id, ops->index_get(cur), LOWER32(size), UPPER32(size), ops->lnkcnt_get(cur)); @@ -810,9 +810,9 @@ ipc_call_t *request) { - devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); + service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); fs_node_t *fn; - int rc = ops->node_get(&fn, devmap_handle, index); + int rc = ops->node_get(&fn, service_id, index); on_error(rc, answer_and_return(rid, rc)); @@ -831,5 +831,5 @@ stat.fs_handle = fs_handle; - stat.devmap_handle = devmap_handle; + stat.service_id = service_id; stat.index = index; stat.lnkcnt = ops->lnkcnt_get(fn); @@ -837,5 +837,5 @@ stat.is_directory = ops->is_directory(fn); stat.size = ops->size_get(fn); - stat.device = ops->device_get(fn); + stat.service = ops->device_get(fn); ops->node_put(fn); @@ -856,9 +856,9 @@ ipc_call_t *request) { - devmap_handle_t devmap_handle = IPC_GET_ARG1(*request); + service_id_t service_id = IPC_GET_ARG1(*request); fs_index_t index = IPC_GET_ARG2(*request); fs_node_t *fn; - int rc = ops->node_get(&fn, devmap_handle, index); + int rc = ops->node_get(&fn, service_id, index); on_error(rc, answer_and_return(rid, rc)); Index: uspace/lib/fs/libfs.h =================================================================== --- uspace/lib/fs/libfs.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/fs/libfs.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -40,17 +40,17 @@ #include #include -#include +#include typedef struct { - int (* mounted)(devmap_handle_t, const char *, fs_index_t *, aoff64_t *, + int (* mounted)(service_id_t, const char *, fs_index_t *, aoff64_t *, unsigned *); - int (* unmounted)(devmap_handle_t); - int (* read)(devmap_handle_t, fs_index_t, aoff64_t, size_t *); - int (* write)(devmap_handle_t, fs_index_t, aoff64_t, size_t *, + int (* unmounted)(service_id_t); + int (* read)(service_id_t, fs_index_t, aoff64_t, size_t *); + int (* write)(service_id_t, fs_index_t, aoff64_t, size_t *, aoff64_t *); - int (* truncate)(devmap_handle_t, fs_index_t, aoff64_t); - int (* close)(devmap_handle_t, fs_index_t); - int (* destroy)(devmap_handle_t, fs_index_t); - int (* sync)(devmap_handle_t, fs_index_t); + int (* truncate)(service_id_t, fs_index_t, aoff64_t); + int (* close)(service_id_t, fs_index_t); + int (* destroy)(service_id_t, fs_index_t); + int (* sync)(service_id_t, fs_index_t); } vfs_out_ops_t; @@ -59,5 +59,5 @@ async_sess_t *sess; fs_handle_t fs_handle; - devmap_handle_t devmap_handle; + service_id_t service_id; } mp_data_t; @@ -73,10 +73,10 @@ * argument holds the output argument. */ - int (* root_get)(fs_node_t **, devmap_handle_t); + int (* root_get)(fs_node_t **, service_id_t); int (* match)(fs_node_t **, fs_node_t *, const char *); - int (* node_get)(fs_node_t **, devmap_handle_t, fs_index_t); + int (* node_get)(fs_node_t **, service_id_t, fs_index_t); int (* node_open)(fs_node_t *); int (* node_put)(fs_node_t *); - int (* create)(fs_node_t **, devmap_handle_t, int); + int (* create)(fs_node_t **, service_id_t, int); int (* destroy)(fs_node_t *); int (* link)(fs_node_t *, fs_node_t *, const char *); @@ -92,5 +92,5 @@ bool (* is_directory)(fs_node_t *); bool (* is_file)(fs_node_t *); - devmap_handle_t (* device_get)(fs_node_t *); + service_id_t (* device_get)(fs_node_t *); } libfs_ops_t; Index: uspace/lib/usb/include/usb/hc.h =================================================================== --- uspace/lib/usb/include/usb/hc.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/usb/include/usb/hc.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -38,4 +38,5 @@ #include #include +#include #include #include @@ -68,5 +69,5 @@ devman_handle_t *); -int usb_ddf_get_hc_handle_by_class(size_t, devman_handle_t *); +int usb_ddf_get_hc_handle_by_sid(service_id_t, devman_handle_t *); Index: uspace/lib/usb/include/usb/usb.h =================================================================== --- uspace/lib/usb/include/usb/usb.h (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/usb/include/usb/usb.h (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -174,6 +174,6 @@ } usb_packet_id; -/** Class name for USB host controllers. */ -#define USB_HC_DDF_CLASS_NAME "usbhc" +/** Category for USB host controllers. */ +#define USB_HC_CATEGORY "usbhc" #endif Index: uspace/lib/usb/src/hc.c =================================================================== --- uspace/lib/usb/src/hc.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/usb/src/hc.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -201,32 +201,19 @@ /** Get host controller handle by its class index. * - * @param class_index Class index for the host controller. + * @param sid Service ID of the HC function. * @param hc_handle Where to store the HC handle * (can be NULL for existence test only). * @return Error code. */ -int usb_ddf_get_hc_handle_by_class(size_t class_index, - devman_handle_t *hc_handle) -{ - char *class_index_str; - devman_handle_t hc_handle_tmp; +int usb_ddf_get_hc_handle_by_sid(service_id_t sid, devman_handle_t *hc_handle) +{ + devman_handle_t handle; int rc; - - rc = asprintf(&class_index_str, "%zu", class_index); - if (rc < 0) { - return ENOMEM; - } - rc = devman_device_get_handle_by_class("usbhc", class_index_str, - &hc_handle_tmp, 0); - free(class_index_str); - if (rc != EOK) { - return rc; - } - - if (hc_handle != NULL) { - *hc_handle = hc_handle_tmp; - } - - return EOK; + + rc = devman_fun_sid_to_handle(sid, &handle); + if (hc_handle != NULL) + *hc_handle = handle; + + return rc; } Index: uspace/lib/usb/src/resolve.c =================================================================== --- uspace/lib/usb/src/resolve.c (revision d894fbdb1cbc656ff7db4a33f03a2d331d2b4837) +++ uspace/lib/usb/src/resolve.c (revision 42a619b240617c4f0e4dd04ddf2366f3c5a0709a) @@ -46,10 +46,10 @@ devman_handle_t *out_hc_handle, usb_address_t *out_device_address) { - size_t class_index; + uint64_t sid; size_t address; int rc; char *ptr; - rc = str_size_t(path, &ptr, 10, false, &class_index); + rc = str_uint64(path, &ptr, 10, false, &sid); if (rc != EOK) { return false; @@ -64,5 +64,5 @@ return false; } - rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle); + rc = usb_ddf_get_hc_handle_by_sid(sid, out_hc_handle); if (rc != EOK) { return false;