Index: uspace/app/bdsh/cmds/modules/bdd/bdd.c =================================================================== --- uspace/app/bdsh/cmds/modules/bdd/bdd.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/app/bdsh/cmds/modules/bdd/bdd.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -68,5 +68,5 @@ unsigned int argc; unsigned int i, j; - dev_handle_t handle; + devmap_handle_t handle; uint8_t *blk; size_t size, bytes, rows; Index: uspace/app/init/init.c =================================================================== --- uspace/app/init/init.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/app/init/init.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -185,5 +185,5 @@ /* Wait for the input device to be ready */ - dev_handle_t handle; + devmap_handle_t handle; rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING); if (rc != EOK) { @@ -210,5 +210,5 @@ /* Wait for the terminal device to be ready */ - dev_handle_t handle; + devmap_handle_t handle; rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING); if (rc != EOK) { Index: uspace/app/mkfat/mkfat.c =================================================================== --- uspace/app/mkfat/mkfat.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/app/mkfat/mkfat.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -85,5 +85,5 @@ struct fat_params *par); static int fat_blocks_write(struct fat_params const *par, - dev_handle_t handle); + devmap_handle_t handle); static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs); @@ -95,5 +95,5 @@ int rc; char *dev_path; - dev_handle_t handle; + devmap_handle_t handle; size_t block_size; char *endptr; @@ -234,5 +234,5 @@ /** Create file system with the given parameters. */ -static int fat_blocks_write(struct fat_params const *par, dev_handle_t handle) +static int fat_blocks_write(struct fat_params const *par, devmap_handle_t handle) { aoff64_t addr; Index: uspace/lib/block/libblock.c =================================================================== --- uspace/lib/block/libblock.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/block/libblock.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -75,5 +75,5 @@ typedef struct { link_t link; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; int dev_phone; fibril_mutex_t comm_area_lock; @@ -91,5 +91,5 @@ static int get_num_blocks(int dev_phone, aoff64_t *nblocks); -static devcon_t *devcon_search(dev_handle_t dev_handle) +static devcon_t *devcon_search(devmap_handle_t devmap_handle) { link_t *cur; @@ -98,5 +98,5 @@ for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { devcon_t *devcon = list_get_instance(cur, devcon_t, link); - if (devcon->dev_handle == dev_handle) { + if (devcon->devmap_handle == devmap_handle) { fibril_mutex_unlock(&dcl_lock); return devcon; @@ -107,5 +107,5 @@ } -static int devcon_add(dev_handle_t dev_handle, int dev_phone, size_t bsize, +static int devcon_add(devmap_handle_t devmap_handle, int dev_phone, size_t bsize, void *comm_area, size_t comm_size) { @@ -121,5 +121,5 @@ link_initialize(&devcon->link); - devcon->dev_handle = dev_handle; + devcon->devmap_handle = devmap_handle; devcon->dev_phone = dev_phone; fibril_mutex_initialize(&devcon->comm_area_lock); @@ -134,5 +134,5 @@ for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { devcon_t *d = list_get_instance(cur, devcon_t, link); - if (d->dev_handle == dev_handle) { + if (d->devmap_handle == devmap_handle) { fibril_mutex_unlock(&dcl_lock); free(devcon); @@ -152,5 +152,5 @@ } -int block_init(dev_handle_t dev_handle, size_t comm_size) +int block_init(devmap_handle_t devmap_handle, size_t comm_size) { int rc; @@ -165,5 +165,5 @@ } - dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING); + dev_phone = devmap_device_connect(devmap_handle, IPC_FLAG_BLOCKING); if (dev_phone < 0) { munmap(comm_area, comm_size); @@ -185,5 +185,5 @@ } - rc = devcon_add(dev_handle, dev_phone, bsize, comm_area, comm_size); + rc = devcon_add(devmap_handle, dev_phone, bsize, comm_area, comm_size); if (rc != EOK) { munmap(comm_area, comm_size); @@ -195,11 +195,11 @@ } -void block_fini(dev_handle_t dev_handle) -{ - devcon_t *devcon = devcon_search(dev_handle); +void block_fini(devmap_handle_t devmap_handle) +{ + devcon_t *devcon = devcon_search(devmap_handle); assert(devcon); if (devcon->cache) - (void) block_cache_fini(dev_handle); + (void) block_cache_fini(devmap_handle); devcon_remove(devcon); @@ -214,10 +214,10 @@ } -int block_bb_read(dev_handle_t dev_handle, aoff64_t ba) +int block_bb_read(devmap_handle_t devmap_handle, aoff64_t ba) { void *bb_buf; int rc; - devcon_t *devcon = devcon_search(dev_handle); + devcon_t *devcon = devcon_search(devmap_handle); if (!devcon) return ENOENT; @@ -244,7 +244,7 @@ } -void *block_bb_get(dev_handle_t dev_handle) -{ - devcon_t *devcon = devcon_search(dev_handle); +void *block_bb_get(devmap_handle_t devmap_handle) +{ + devcon_t *devcon = devcon_search(devmap_handle); assert(devcon); return devcon->bb_buf; @@ -272,8 +272,8 @@ }; -int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks, +int block_cache_init(devmap_handle_t devmap_handle, size_t size, unsigned blocks, enum cache_mode mode) { - devcon_t *devcon = devcon_search(dev_handle); + devcon_t *devcon = devcon_search(devmap_handle); cache_t *cache; if (!devcon) @@ -305,7 +305,7 @@ } -int block_cache_fini(dev_handle_t dev_handle) -{ - devcon_t *devcon = devcon_search(dev_handle); +int block_cache_fini(devmap_handle_t devmap_handle) +{ + devcon_t *devcon = devcon_search(devmap_handle); cache_t *cache; int rc; @@ -374,5 +374,5 @@ * @param block Pointer to where the function will store the * block pointer on success. - * @param dev_handle Device handle of the block device. + * @param devmap_handle Device handle of the block device. * @param boff Block offset. * @param flags If BLOCK_FLAGS_NOREAD is specified, block_get() @@ -382,5 +382,5 @@ * @return EOK on success or a negative error code. */ -int block_get(block_t **block, dev_handle_t dev_handle, aoff64_t boff, int flags) +int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t boff, int flags) { devcon_t *devcon; @@ -391,5 +391,5 @@ int rc; - devcon = devcon_search(dev_handle); + devcon = devcon_search(devmap_handle); assert(devcon); @@ -500,5 +500,5 @@ block_initialize(b); - b->dev_handle = dev_handle; + b->devmap_handle = devmap_handle; b->size = cache->lblock_size; b->boff = boff; @@ -549,5 +549,5 @@ int block_put(block_t *block) { - devcon_t *devcon = devcon_search(block->dev_handle); + devcon_t *devcon = devcon_search(block->devmap_handle); cache_t *cache; unsigned blocks_cached; @@ -645,5 +645,5 @@ /** Read sequential data from a block device. * - * @param dev_handle Device handle of the block device. + * @param devmap_handle Device handle of the block device. * @param bufpos Pointer to the first unread valid offset within the * communication buffer. @@ -657,5 +657,5 @@ * @return EOK on success or a negative return code on failure. */ -int block_seqread(dev_handle_t dev_handle, size_t *bufpos, size_t *buflen, +int block_seqread(devmap_handle_t devmap_handle, size_t *bufpos, size_t *buflen, aoff64_t *pos, void *dst, size_t size) { @@ -665,5 +665,5 @@ devcon_t *devcon; - devcon = devcon_search(dev_handle); + devcon = devcon_search(devmap_handle); assert(devcon); block_size = devcon->pblock_size; @@ -711,5 +711,5 @@ /** Read blocks directly from device (bypass cache). * - * @param dev_handle Device handle of the block device. + * @param devmap_handle Device handle of the block device. * @param ba Address of first block. * @param cnt Number of blocks. @@ -718,10 +718,10 @@ * @return EOK on success or negative error code on failure. */ -int block_read_direct(dev_handle_t dev_handle, aoff64_t ba, size_t cnt, void *buf) +int block_read_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, void *buf) { devcon_t *devcon; int rc; - devcon = devcon_search(dev_handle); + devcon = devcon_search(devmap_handle); assert(devcon); @@ -739,5 +739,5 @@ /** Write blocks directly to device (bypass cache). * - * @param dev_handle Device handle of the block device. + * @param devmap_handle Device handle of the block device. * @param ba Address of first block. * @param cnt Number of blocks. @@ -746,5 +746,5 @@ * @return EOK on success or negative error code on failure. */ -int block_write_direct(dev_handle_t dev_handle, aoff64_t ba, size_t cnt, +int block_write_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, const void *data) { @@ -752,5 +752,5 @@ int rc; - devcon = devcon_search(dev_handle); + devcon = devcon_search(devmap_handle); assert(devcon); @@ -767,14 +767,14 @@ /** Get device block size. * - * @param dev_handle Device handle of the block device. + * @param devmap_handle Device handle of the block device. * @param bsize Output block size. * * @return EOK on success or negative error code on failure. */ -int block_get_bsize(dev_handle_t dev_handle, size_t *bsize) +int block_get_bsize(devmap_handle_t devmap_handle, size_t *bsize) { devcon_t *devcon; - devcon = devcon_search(dev_handle); + devcon = devcon_search(devmap_handle); assert(devcon); @@ -784,14 +784,14 @@ /** Get number of blocks on device. * - * @param dev_handle Device handle of the block device. + * @param devmap_handle Device handle of the block device. * @param nblocks Output number of blocks. * * @return EOK on success or negative error code on failure. */ -int block_get_nblocks(dev_handle_t dev_handle, aoff64_t *nblocks) +int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks) { devcon_t *devcon; - devcon = devcon_search(dev_handle); + devcon = devcon_search(devmap_handle); assert(devcon); @@ -818,5 +818,5 @@ printf("Error %d reading %d blocks starting at block %" PRIuOFF64 " from device handle %d\n", rc, cnt, ba, - devcon->dev_handle); + devcon->devmap_handle); #ifndef NDEBUG stacktrace_print(); @@ -844,5 +844,5 @@ if (rc != EOK) { printf("Error %d writing %d blocks starting at block %" PRIuOFF64 - " to device handle %d\n", rc, cnt, ba, devcon->dev_handle); + " to device handle %d\n", rc, cnt, ba, devcon->devmap_handle); #ifndef NDEBUG stacktrace_print(); Index: uspace/lib/block/libblock.h =================================================================== --- uspace/lib/block/libblock.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/block/libblock.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -72,5 +72,5 @@ fibril_rwlock_t contents_lock; /** Handle of the device where the block resides. */ - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; /** Block offset on the block device. Counted in 'size'-byte blocks. */ aoff64_t boff; @@ -93,23 +93,23 @@ }; -extern int block_init(dev_handle_t, size_t); -extern void block_fini(dev_handle_t); +extern int block_init(devmap_handle_t, size_t); +extern void block_fini(devmap_handle_t); -extern int block_bb_read(dev_handle_t, aoff64_t); -extern void *block_bb_get(dev_handle_t); +extern int block_bb_read(devmap_handle_t, aoff64_t); +extern void *block_bb_get(devmap_handle_t); -extern int block_cache_init(dev_handle_t, size_t, unsigned, enum cache_mode); -extern int block_cache_fini(dev_handle_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_get(block_t **, dev_handle_t, aoff64_t, int); +extern int block_get(block_t **, devmap_handle_t, aoff64_t, int); extern int block_put(block_t *); -extern int block_seqread(dev_handle_t, size_t *, size_t *, aoff64_t *, void *, +extern int block_seqread(devmap_handle_t, size_t *, size_t *, aoff64_t *, void *, size_t); -extern int block_get_bsize(dev_handle_t, size_t *); -extern int block_get_nblocks(dev_handle_t, aoff64_t *); -extern int block_read_direct(dev_handle_t, aoff64_t, size_t, void *); -extern int block_write_direct(dev_handle_t, aoff64_t, size_t, const void *); +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_write_direct(devmap_handle_t, aoff64_t, size_t, const void *); #endif Index: uspace/lib/c/generic/devmap.c =================================================================== --- uspace/lib/c/generic/devmap.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/c/generic/devmap.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -132,5 +132,5 @@ * */ -int devmap_device_register(const char *fqdn, dev_handle_t *handle) +int devmap_device_register(const char *fqdn, devmap_handle_t *handle) { int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); @@ -163,10 +163,10 @@ if (handle != NULL) - *handle = (dev_handle_t) IPC_GET_ARG1(answer); + *handle = (devmap_handle_t) IPC_GET_ARG1(answer); return retval; } -int devmap_device_get_handle(const char *fqdn, dev_handle_t *handle, unsigned int flags) +int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags) { int phone = devmap_get_phone(DEVMAP_CLIENT, flags); @@ -194,15 +194,15 @@ if (retval != EOK) { if (handle != NULL) - *handle = (dev_handle_t) -1; + *handle = (devmap_handle_t) -1; return retval; } if (handle != NULL) - *handle = (dev_handle_t) IPC_GET_ARG1(answer); + *handle = (devmap_handle_t) IPC_GET_ARG1(answer); return retval; } -int devmap_namespace_get_handle(const char *name, dev_handle_t *handle, unsigned int flags) +int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, unsigned int flags) { int phone = devmap_get_phone(DEVMAP_CLIENT, flags); @@ -230,15 +230,15 @@ if (retval != EOK) { if (handle != NULL) - *handle = (dev_handle_t) -1; + *handle = (devmap_handle_t) -1; return retval; } if (handle != NULL) - *handle = (dev_handle_t) IPC_GET_ARG1(answer); + *handle = (devmap_handle_t) IPC_GET_ARG1(answer); return retval; } -devmap_handle_type_t devmap_handle_probe(dev_handle_t handle) +devmap_handle_type_t devmap_handle_probe(devmap_handle_t handle) { int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); @@ -255,5 +255,5 @@ } -int devmap_device_connect(dev_handle_t handle, unsigned int flags) +int devmap_device_connect(devmap_handle_t handle, unsigned int flags) { int phone; @@ -305,5 +305,5 @@ } -static size_t devmap_count_devices_internal(int phone, dev_handle_t ns_handle) +static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle) { ipcarg_t count; @@ -325,5 +325,5 @@ } -size_t devmap_count_devices(dev_handle_t ns_handle) +size_t devmap_count_devices(devmap_handle_t ns_handle) { int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); @@ -387,5 +387,5 @@ } -size_t devmap_get_devices(dev_handle_t ns_handle, dev_desc_t **data) +size_t devmap_get_devices(devmap_handle_t ns_handle, dev_desc_t **data) { int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); Index: uspace/lib/c/generic/vfs/vfs.c =================================================================== --- uspace/lib/c/generic/vfs/vfs.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/c/generic/vfs/vfs.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -136,6 +136,6 @@ } - dev_handle_t dev_handle; - int res = devmap_device_get_handle(fqdn, &dev_handle, flags); + devmap_handle_t devmap_handle; + int res = devmap_device_get_handle(fqdn, &devmap_handle, flags); if (res != EOK) { if (null_id != -1) @@ -159,5 +159,5 @@ ipcarg_t rc_orig; - aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL); + aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL); ipcarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size); if (rc != EOK) { @@ -328,5 +328,5 @@ ipc_call_t answer; aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle, - node->dev_handle, node->index, oflag, &answer); + node->devmap_handle, node->index, oflag, &answer); ipcarg_t rc; @@ -797,5 +797,5 @@ if (rc == EOK) { node->fs_handle = stat.fs_handle; - node->dev_handle = stat.dev_handle; + node->devmap_handle = stat.devmap_handle; node->index = stat.index; } Index: uspace/lib/c/include/devmap.h =================================================================== --- uspace/lib/c/include/devmap.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/c/include/devmap.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -44,11 +44,11 @@ extern int devmap_driver_register(const char *, async_client_conn_t); -extern int devmap_device_register(const char *, dev_handle_t *); +extern int devmap_device_register(const char *, devmap_handle_t *); -extern int devmap_device_get_handle(const char *, dev_handle_t *, unsigned int); -extern int devmap_namespace_get_handle(const char *, dev_handle_t *, unsigned int); -extern devmap_handle_type_t devmap_handle_probe(dev_handle_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 int devmap_device_connect(dev_handle_t, unsigned int); +extern int devmap_device_connect(devmap_handle_t, unsigned int); extern int devmap_null_create(void); @@ -56,8 +56,8 @@ extern size_t devmap_count_namespaces(void); -extern size_t devmap_count_devices(dev_handle_t); +extern size_t devmap_count_devices(devmap_handle_t); extern size_t devmap_get_namespaces(dev_desc_t **); -extern size_t devmap_get_devices(dev_handle_t, dev_desc_t **); +extern size_t devmap_get_devices(devmap_handle_t, dev_desc_t **); #endif Index: uspace/lib/c/include/ipc/devmap.h =================================================================== --- uspace/lib/c/include/ipc/devmap.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/c/include/ipc/devmap.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -40,5 +40,5 @@ #define DEVMAP_NAME_MAXLEN 255 -typedef ipcarg_t dev_handle_t; +typedef ipcarg_t devmap_handle_t; typedef enum { @@ -81,5 +81,5 @@ typedef struct { - dev_handle_t handle; + devmap_handle_t handle; char name[DEVMAP_NAME_MAXLEN + 1]; } dev_desc_t; Index: uspace/lib/c/include/sys/stat.h =================================================================== --- uspace/lib/c/include/sys/stat.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/c/include/sys/stat.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -43,5 +43,5 @@ struct stat { fs_handle_t fs_handle; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; fs_index_t index; unsigned int lnkcnt; @@ -49,5 +49,5 @@ bool is_directory; aoff64_t size; - dev_handle_t device; + devmap_handle_t device; }; Index: uspace/lib/c/include/vfs/vfs.h =================================================================== --- uspace/lib/c/include/vfs/vfs.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/c/include/vfs/vfs.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -47,5 +47,5 @@ typedef struct { fs_handle_t fs_handle; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; fs_index_t index; } fdi_node_t; Index: uspace/lib/fs/libfs.c =================================================================== --- uspace/lib/fs/libfs.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/fs/libfs.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -150,8 +150,8 @@ ipc_call_t *request) { - dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request); - dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request); + devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*request); int res; ipcarg_t rc; @@ -174,5 +174,5 @@ fs_node_t *fn; - res = ops->node_get(&fn, mp_dev_handle, mp_fs_index); + res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); if ((res != EOK) || (!fn)) { ipc_hangup(mountee_phone); @@ -201,10 +201,10 @@ ipc_call_t answer; rc = async_data_write_forward_1_1(mountee_phone, VFS_OUT_MOUNTED, - mr_dev_handle, &answer); + mr_devmap_handle, &answer); if (rc == EOK) { fn->mp_data.mp_active = true; fn->mp_data.fs_handle = mr_fs_handle; - fn->mp_data.dev_handle = mr_dev_handle; + fn->mp_data.devmap_handle = mr_devmap_handle; fn->mp_data.phone = mountee_phone; } @@ -219,10 +219,10 @@ void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); fs_node_t *fn; int res; - res = ops->node_get(&fn, mp_dev_handle, mp_fs_index); + res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); if ((res != EOK) || (!fn)) { ipc_answer_0(rid, combine_rc(res, ENOENT)); @@ -243,5 +243,5 @@ */ res = async_req_1_0(fn->mp_data.phone, VFS_OUT_UNMOUNTED, - fn->mp_data.dev_handle); + fn->mp_data.devmap_handle); /* @@ -252,5 +252,5 @@ fn->mp_data.mp_active = false; fn->mp_data.fs_handle = 0; - fn->mp_data.dev_handle = 0; + fn->mp_data.devmap_handle = 0; fn->mp_data.phone = 0; /* Drop the reference created in libfs_mount(). */ @@ -281,5 +281,5 @@ unsigned int last = IPC_GET_ARG2(*request); unsigned int next = first; - dev_handle_t dev_handle = IPC_GET_ARG3(*request); + devmap_handle_t devmap_handle = IPC_GET_ARG3(*request); int lflag = IPC_GET_ARG4(*request); fs_index_t index = IPC_GET_ARG5(*request); @@ -295,10 +295,10 @@ fs_node_t *tmp = NULL; - rc = ops->root_get(&cur, dev_handle); + rc = ops->root_get(&cur, devmap_handle); on_error(rc, goto out_with_answer); if (cur->mp_data.mp_active) { ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, - next, last, cur->mp_data.dev_handle, lflag, index, + next, last, cur->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); (void) ops->node_put(cur); @@ -358,5 +358,5 @@ ipc_forward_slow(rid, tmp->mp_data.phone, - VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle, + VFS_OUT_LOOKUP, next, last, tmp->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); (void) ops->node_put(cur); @@ -385,8 +385,8 @@ fs_node_t *fn; if (lflag & L_CREATE) - rc = ops->create(&fn, dev_handle, + rc = ops->create(&fn, devmap_handle, lflag); else - rc = ops->node_get(&fn, dev_handle, + rc = ops->node_get(&fn, devmap_handle, index); on_error(rc, goto out_with_answer); @@ -401,5 +401,5 @@ aoff64_t size = ops->size_get(fn); ipc_answer_5(rid, fs_handle, - dev_handle, + devmap_handle, ops->index_get(fn), LOWER32(size), @@ -469,7 +469,7 @@ fs_node_t *fn; if (lflag & L_CREATE) - rc = ops->create(&fn, dev_handle, lflag); + rc = ops->create(&fn, devmap_handle, lflag); else - rc = ops->node_get(&fn, dev_handle, index); + rc = ops->node_get(&fn, devmap_handle, index); on_error(rc, goto out_with_answer); @@ -483,5 +483,5 @@ aoff64_t size = ops->size_get(fn); ipc_answer_5(rid, fs_handle, - dev_handle, + devmap_handle, ops->index_get(fn), LOWER32(size), @@ -509,5 +509,5 @@ if (rc == EOK) { aoff64_t size = ops->size_get(cur); - ipc_answer_5(rid, fs_handle, dev_handle, + ipc_answer_5(rid, fs_handle, devmap_handle, ops->index_get(cur), LOWER32(size), UPPER32(size), old_lnkcnt); @@ -547,5 +547,5 @@ if (rc == EOK) { aoff64_t size = ops->size_get(cur); - ipc_answer_5(rid, fs_handle, dev_handle, + ipc_answer_5(rid, fs_handle, devmap_handle, ops->index_get(cur), LOWER32(size), UPPER32(size), ops->lnkcnt_get(cur)); @@ -571,9 +571,9 @@ ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_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, dev_handle, index); + int rc = ops->node_get(&fn, devmap_handle, index); on_error(rc, answer_and_return(rid, rc)); @@ -592,5 +592,5 @@ stat.fs_handle = fs_handle; - stat.dev_handle = dev_handle; + stat.devmap_handle = devmap_handle; stat.index = index; stat.lnkcnt = ops->lnkcnt_get(fn); @@ -617,9 +617,9 @@ ipc_call_t *request) { - dev_handle_t dev_handle = IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = IPC_GET_ARG1(*request); fs_index_t index = IPC_GET_ARG2(*request); fs_node_t *fn; - int rc = ops->node_get(&fn, dev_handle, index); + int rc = ops->node_get(&fn, devmap_handle, index); on_error(rc, answer_and_return(rid, rc)); Index: uspace/lib/fs/libfs.h =================================================================== --- uspace/lib/fs/libfs.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/lib/fs/libfs.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -47,5 +47,5 @@ int phone; fs_handle_t fs_handle; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; } mp_data_t; @@ -61,10 +61,10 @@ * argument holds the output argument. */ - int (* root_get)(fs_node_t **, dev_handle_t); + int (* root_get)(fs_node_t **, devmap_handle_t); int (* match)(fs_node_t **, fs_node_t *, const char *); - int (* node_get)(fs_node_t **, dev_handle_t, fs_index_t); + int (* node_get)(fs_node_t **, devmap_handle_t, fs_index_t); int (* node_open)(fs_node_t *); int (* node_put)(fs_node_t *); - int (* create)(fs_node_t **, dev_handle_t, int); + int (* create)(fs_node_t **, devmap_handle_t, int); int (* destroy)(fs_node_t *); int (* link)(fs_node_t *, fs_node_t *, const char *); @@ -81,5 +81,5 @@ bool (* is_directory)(fs_node_t *); bool (* is_file)(fs_node_t *); - dev_handle_t (* device_get)(fs_node_t *); + devmap_handle_t (* device_get)(fs_node_t *); } libfs_ops_t; Index: uspace/srv/bd/ata_bd/ata_bd.c =================================================================== --- uspace/srv/bd/ata_bd/ata_bd.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/ata_bd/ata_bd.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -139,5 +139,5 @@ snprintf(name, 16, "%s/disk%d", NAMESPACE, i); - rc = devmap_device_register(name, &disk[i].dev_handle); + rc = devmap_device_register(name, &disk[i].devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); @@ -229,5 +229,5 @@ ipc_call_t call; ipcarg_t method; - dev_handle_t dh; + devmap_handle_t dh; int flags; int retval; @@ -242,5 +242,5 @@ disk_id = -1; for (i = 0; i < MAX_DISKS; i++) - if (disk[i].dev_handle == dh) + if (disk[i].devmap_handle == dh) disk_id = i; Index: uspace/srv/bd/ata_bd/ata_bd.h =================================================================== --- uspace/srv/bd/ata_bd/ata_bd.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/ata_bd/ata_bd.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -287,5 +287,5 @@ fibril_mutex_t lock; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; } disk_t; Index: uspace/srv/bd/file_bd/file_bd.c =================================================================== --- uspace/srv/bd/file_bd/file_bd.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/file_bd/file_bd.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -60,5 +60,5 @@ static FILE *img; -static dev_handle_t dev_handle; +static devmap_handle_t devmap_handle; static fibril_mutex_t dev_lock; @@ -82,5 +82,5 @@ return -1; - rc = devmap_device_register(argv[2], &dev_handle); + rc = devmap_device_register(argv[2], &devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); Index: uspace/srv/bd/gxe_bd/gxe_bd.c =================================================================== --- uspace/srv/bd/gxe_bd/gxe_bd.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/gxe_bd/gxe_bd.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -93,5 +93,5 @@ static gxe_bd_t *dev; -static dev_handle_t dev_handle[MAX_DISKS]; +static devmap_handle_t devmap_handle[MAX_DISKS]; static fibril_mutex_t dev_lock[MAX_DISKS]; @@ -143,5 +143,5 @@ for (i = 0; i < MAX_DISKS; i++) { snprintf(name, 16, "%s/disk%d", NAMESPACE, i); - rc = devmap_device_register(name, &dev_handle[i]); + rc = devmap_device_register(name, &devmap_handle[i]); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); @@ -161,5 +161,5 @@ ipc_call_t call; ipcarg_t method; - dev_handle_t dh; + devmap_handle_t dh; int flags; int retval; @@ -174,5 +174,5 @@ disk_id = -1; for (i = 0; i < MAX_DISKS; i++) - if (dev_handle[i] == dh) + if (devmap_handle[i] == dh) disk_id = i; Index: uspace/srv/bd/part/guid_part/guid_part.c =================================================================== --- uspace/srv/bd/part/guid_part/guid_part.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/part/guid_part/guid_part.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -83,5 +83,5 @@ aoff64_t length; /** Device representing the partition (outbound device) */ - dev_handle_t dev; + devmap_handle_t dev; /** Points to next partition structure. */ struct part *next; @@ -91,5 +91,5 @@ /** Partitioned device (inbound device) */ -static dev_handle_t indev_handle; +static devmap_handle_t indev_handle; /** List of partitions. This structure is an empty head. */ @@ -130,5 +130,5 @@ int i; char *name; - dev_handle_t dev; + devmap_handle_t dev; uint64_t size_mb; part_t *part; @@ -316,5 +316,5 @@ ipc_call_t call; ipcarg_t method; - dev_handle_t dh; + devmap_handle_t dh; int flags; int retval; Index: uspace/srv/bd/part/mbr_part/mbr_part.c =================================================================== --- uspace/srv/bd/part/mbr_part/mbr_part.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/part/mbr_part/mbr_part.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -101,5 +101,5 @@ aoff64_t length; /** Device representing the partition (outbound device) */ - dev_handle_t dev; + devmap_handle_t dev; /** Points to next partition structure. */ struct part *next; @@ -142,5 +142,5 @@ /** Partitioned device (inbound device) */ -static dev_handle_t indev_handle; +static devmap_handle_t indev_handle; /** List of partitions. This structure is an empty head. */ @@ -181,5 +181,5 @@ int i; char *name; - dev_handle_t dev; + devmap_handle_t dev; uint64_t size_mb; part_t *part; @@ -394,5 +394,5 @@ ipc_call_t call; ipcarg_t method; - dev_handle_t dh; + devmap_handle_t dh; int flags; int retval; Index: uspace/srv/bd/rd/rd.c =================================================================== --- uspace/srv/bd/rd/rd.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/bd/rd/rd.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -238,6 +238,6 @@ } - dev_handle_t dev_handle; - if (devmap_device_register("bd/initrd", &dev_handle) != EOK) { + devmap_handle_t devmap_handle; + if (devmap_device_register("bd/initrd", &devmap_handle) != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); printf("%s: Unable to register device\n", NAME); Index: uspace/srv/devman/devman.c =================================================================== --- uspace/srv/devman/devman.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/devman/devman.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -59,5 +59,5 @@ { node_t *dev = hash_table_get_instance(item, node_t, devmap_link); - return (dev->devmap_handle == (dev_handle_t) key[0]); + return (dev->devmap_handle == (devmap_handle_t) key[0]); } @@ -1106,5 +1106,5 @@ /* Devmap devices */ -node_t *find_devmap_tree_device(dev_tree_t *tree, dev_handle_t devmap_handle) +node_t *find_devmap_tree_device(dev_tree_t *tree, devmap_handle_t devmap_handle) { node_t *dev = NULL; @@ -1122,5 +1122,5 @@ node_t *find_devmap_class_device(class_list_t *classes, - dev_handle_t devmap_handle) + devmap_handle_t devmap_handle) { node_t *dev = NULL; Index: uspace/srv/devman/devman.h =================================================================== --- uspace/srv/devman/devman.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/devman/devman.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -157,5 +157,5 @@ link_t classes; /** Devmap handle if the device is registered by devmapper. */ - dev_handle_t devmap_handle; + devmap_handle_t devmap_handle; /** @@ -248,5 +248,5 @@ char *dev_name; /** The handle of the device by device mapper in the class namespace. */ - dev_handle_t devmap_handle; + devmap_handle_t devmap_handle; /** @@ -337,6 +337,6 @@ /* Devmap devices */ -extern node_t *find_devmap_tree_device(dev_tree_t *, dev_handle_t); -extern node_t *find_devmap_class_device(class_list_t *, dev_handle_t); +extern node_t *find_devmap_tree_device(dev_tree_t *, devmap_handle_t); +extern node_t *find_devmap_class_device(class_list_t *, devmap_handle_t); extern void class_add_devmap_device(class_list_t *, dev_class_info_t *); Index: uspace/srv/devman/main.c =================================================================== --- uspace/srv/devman/main.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/devman/main.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -464,5 +464,5 @@ static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall) { - dev_handle_t devmap_handle = IPC_GET_METHOD(*icall); + devmap_handle_t devmap_handle = IPC_GET_METHOD(*icall); node_t *dev; Index: uspace/srv/devmap/devmap.c =================================================================== --- uspace/srv/devmap/devmap.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/devmap/devmap.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -75,5 +75,5 @@ link_t namespaces; /** Unique namespace identifier */ - dev_handle_t handle; + devmap_handle_t handle; /** Namespace name */ char *name; @@ -92,5 +92,5 @@ link_t driver_devices; /** Unique device identifier */ - dev_handle_t handle; + devmap_handle_t handle; /** Device namespace */ devmap_namespace_t *namespace; @@ -118,8 +118,8 @@ static FIBRIL_MUTEX_INITIALIZE(null_devices_mutex); -static dev_handle_t last_handle = 0; +static devmap_handle_t last_handle = 0; static devmap_device_t *null_devices[NULL_DEVICES]; -static dev_handle_t devmap_create_handle(void) +static devmap_handle_t devmap_create_handle(void) { /* TODO: allow reusing old handles after their unregistration @@ -233,5 +233,5 @@ * */ -static devmap_namespace_t *devmap_namespace_find_handle(dev_handle_t handle) +static devmap_namespace_t *devmap_namespace_find_handle(devmap_handle_t handle) { link_t *item; @@ -275,5 +275,5 @@ * */ -static devmap_device_t *devmap_device_find_handle(dev_handle_t handle) +static devmap_device_t *devmap_device_find_handle(devmap_handle_t handle) { link_t *item; @@ -608,5 +608,5 @@ * Get handle from request */ - dev_handle_t handle = IPC_GET_ARG2(*call); + devmap_handle_t handle = IPC_GET_ARG2(*call); devmap_device_t *dev = devmap_device_find_handle(handle); Index: uspace/srv/fs/devfs/devfs_ops.c =================================================================== --- uspace/srv/fs/devfs/devfs_ops.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/devfs/devfs_ops.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -54,10 +54,10 @@ typedef struct { devmap_handle_type_t type; - dev_handle_t handle; + devmap_handle_t handle; } devfs_node_t; /** Opened devices structure */ typedef struct { - dev_handle_t handle; + devmap_handle_t handle; int phone; size_t refcount; @@ -84,5 +84,5 @@ { device_t *dev = hash_table_get_instance(item, device_t, link); - return (dev->handle == (dev_handle_t) key[DEVICES_KEY_HANDLE]); + return (dev->handle == (devmap_handle_t) key[DEVICES_KEY_HANDLE]); } @@ -99,5 +99,5 @@ static int devfs_node_get_internal(fs_node_t **rfn, devmap_handle_type_t type, - dev_handle_t handle) + devmap_handle_t handle) { devfs_node_t *node = (devfs_node_t *) malloc(sizeof(devfs_node_t)); @@ -122,5 +122,5 @@ } -static int devfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle) +static int devfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) { return devfs_node_get_internal(rfn, DEV_HANDLE_NONE, 0); @@ -154,5 +154,5 @@ /* Search root namespace */ - dev_handle_t namespace; + devmap_handle_t namespace; if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { count = devmap_get_devices(namespace, &devs); @@ -200,5 +200,5 @@ } -static int devfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index) +static int devfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) { return devfs_node_get_internal(rfn, devmap_handle_probe(index), index); @@ -269,5 +269,5 @@ } -static int devfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag) +static int devfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag) { assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); @@ -304,5 +304,5 @@ /* Root namespace */ - dev_handle_t namespace; + devmap_handle_t namespace; if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { count = devmap_count_devices(namespace); @@ -372,5 +372,5 @@ } -static dev_handle_t devfs_device_get(fs_node_t *fn) +static devmap_handle_t devfs_device_get(fs_node_t *fn) { devfs_node_t *node = (devfs_node_t *) fn->data; @@ -501,5 +501,5 @@ /* Search root namespace */ - dev_handle_t namespace; + devmap_handle_t namespace; if (devmap_namespace_get_handle("", &namespace, 0) == EOK) { count = devmap_get_devices(namespace, &desc); Index: uspace/srv/fs/fat/fat.h =================================================================== --- uspace/srv/fs/fat/fat.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/fat/fat.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -176,5 +176,5 @@ fibril_mutex_t lock; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; fs_index_t index; /** @@ -242,7 +242,7 @@ extern void fat_sync(ipc_callid_t, ipc_call_t *); -extern int fat_idx_get_new(fat_idx_t **, dev_handle_t); -extern fat_idx_t *fat_idx_get_by_pos(dev_handle_t, fat_cluster_t, unsigned); -extern fat_idx_t *fat_idx_get_by_index(dev_handle_t, fs_index_t); +extern int fat_idx_get_new(fat_idx_t **, devmap_handle_t); +extern fat_idx_t *fat_idx_get_by_pos(devmap_handle_t, fat_cluster_t, unsigned); +extern fat_idx_t *fat_idx_get_by_index(devmap_handle_t, fs_index_t); extern void fat_idx_destroy(fat_idx_t *); extern void fat_idx_hashin(fat_idx_t *); @@ -251,6 +251,6 @@ extern int fat_idx_init(void); extern void fat_idx_fini(void); -extern int fat_idx_init_by_dev_handle(dev_handle_t); -extern void fat_idx_fini_by_dev_handle(dev_handle_t); +extern int fat_idx_init_by_devmap_handle(devmap_handle_t); +extern void fat_idx_fini_by_devmap_handle(devmap_handle_t); #endif Index: uspace/srv/fs/fat/fat_fat.c =================================================================== --- uspace/srv/fs/fat/fat_fat.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/fat/fat_fat.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -70,5 +70,5 @@ * * @param bs Buffer holding the boot sector for the file. - * @param dev_handle Device handle of the device with the file. + * @param devmap_handle Device handle of the device with the file. * @param firstc First cluster to start the walk with. * @param lastc If non-NULL, output argument hodling the last cluster @@ -81,5 +81,5 @@ */ int -fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc, +fat_cluster_walk(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc, fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters) { @@ -108,5 +108,5 @@ fidx = clst % (BPS(bs) / sizeof(fat_cluster_t)); /* read FAT1 */ - rc = block_get(&b, dev_handle, RSCNT(bs) + fsec, + rc = block_get(&b, devmap_handle, RSCNT(bs) + fsec, BLOCK_FLAGS_NONE); if (rc != EOK) @@ -159,5 +159,5 @@ * when fortunately we have the last cluster number cached. */ - return block_get(block, nodep->idx->dev_handle, + return block_get(block, nodep->idx->devmap_handle, CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags); } @@ -173,5 +173,5 @@ fall_through: - rc = _fat_block_get(block, bs, nodep->idx->dev_handle, firstc, + rc = _fat_block_get(block, bs, nodep->idx->devmap_handle, firstc, &currc, relbn, flags); if (rc != EOK) @@ -192,5 +192,5 @@ * @param block Pointer to a block pointer for storing result. * @param bs Buffer holding the boot sector of the file system. - * @param dev_handle Device handle of the file system. + * @param devmap_handle Device handle of the file system. * @param fcl First cluster used by the file. Can be zero if the file * is empty. @@ -204,5 +204,5 @@ */ int -_fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle, +_fat_block_get(block_t **block, fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags) { @@ -221,5 +221,5 @@ /* root directory special case */ assert(bn < RDS(bs)); - rc = block_get(block, dev_handle, + rc = block_get(block, devmap_handle, RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags); return rc; @@ -227,10 +227,10 @@ max_clusters = bn / SPC(bs); - rc = fat_cluster_walk(bs, dev_handle, fcl, &c, &clusters, max_clusters); + rc = fat_cluster_walk(bs, devmap_handle, fcl, &c, &clusters, max_clusters); if (rc != EOK) return rc; assert(clusters == max_clusters); - rc = block_get(block, dev_handle, CLBN2PBN(bs, c, bn), flags); + rc = block_get(block, devmap_handle, CLBN2PBN(bs, c, bn), flags); if (clp) @@ -280,5 +280,5 @@ /* zero out the initial part of the new cluster chain */ for (o = boundary; o < pos; o += BPS(bs)) { - rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl, + rc = _fat_block_get(&b, bs, nodep->idx->devmap_handle, mcl, NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD); if (rc != EOK) @@ -297,5 +297,5 @@ * * @param bs Buffer holding the boot sector for the file system. - * @param dev_handle Device handle for the file system. + * @param devmap_handle Device handle for the file system. * @param clst Cluster which to get. * @param value Output argument holding the value of the cluster. @@ -304,5 +304,5 @@ */ int -fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno, +fat_get_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno, fat_cluster_t clst, fat_cluster_t *value) { @@ -311,5 +311,5 @@ int rc; - rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno + + rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno + (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); if (rc != EOK) @@ -326,5 +326,5 @@ * * @param bs Buffer holding the boot sector for the file system. - * @param dev_handle Device handle for the file system. + * @param devmap_handle Device handle for the file system. * @param fatno Number of the FAT instance where to make the change. * @param clst Cluster which is to be set. @@ -334,5 +334,5 @@ */ int -fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno, +fat_set_cluster(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned fatno, fat_cluster_t clst, fat_cluster_t value) { @@ -342,5 +342,5 @@ assert(fatno < FATCNT(bs)); - rc = block_get(&b, dev_handle, RSCNT(bs) + SF(bs) * fatno + + rc = block_get(&b, devmap_handle, RSCNT(bs) + SF(bs) * fatno + (clst * sizeof(fat_cluster_t)) / BPS(bs), BLOCK_FLAGS_NONE); if (rc != EOK) @@ -357,5 +357,5 @@ * * @param bs Buffer holding the boot sector of the file system. - * @param dev_handle Device handle of the file system. + * @param devmap_handle Device handle of the file system. * @param lifo Chain of allocated clusters. * @param nclsts Number of clusters in the lifo chain. @@ -363,5 +363,5 @@ * @return EOK on success or a negative error code. */ -int fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle, +int fat_alloc_shadow_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t *lifo, unsigned nclsts) { @@ -372,5 +372,5 @@ for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) { for (c = 0; c < nclsts; c++) { - rc = fat_set_cluster(bs, dev_handle, fatno, lifo[c], + rc = fat_set_cluster(bs, devmap_handle, fatno, lifo[c], c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]); if (rc != EOK) @@ -390,5 +390,5 @@ * * @param bs Buffer holding the boot sector of the file system. - * @param dev_handle Device handle of the file system. + * @param devmap_handle Device handle of the file system. * @param nclsts Number of clusters to allocate. * @param mcl Output parameter where the first cluster in the chain @@ -400,5 +400,5 @@ */ int -fat_alloc_clusters(fat_bs_t *bs, dev_handle_t dev_handle, unsigned nclsts, +fat_alloc_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, unsigned nclsts, fat_cluster_t *mcl, fat_cluster_t *lcl) { @@ -418,5 +418,5 @@ fibril_mutex_lock(&fat_alloc_lock); for (b = 0, cl = 0; b < SF(bs); b++) { - rc = block_get(&blk, dev_handle, RSCNT(bs) + b, + rc = block_get(&blk, devmap_handle, RSCNT(bs) + b, BLOCK_FLAGS_NONE); if (rc != EOK) @@ -457,5 +457,5 @@ /* update the shadow copies of FAT */ rc = fat_alloc_shadow_clusters(bs, - dev_handle, lifo, nclsts); + devmap_handle, lifo, nclsts); if (rc != EOK) goto error; @@ -484,5 +484,5 @@ */ while (found--) { - rc = fat_set_cluster(bs, dev_handle, FAT1, lifo[found], + rc = fat_set_cluster(bs, devmap_handle, FAT1, lifo[found], FAT_CLST_RES0); if (rc != EOK) { @@ -499,5 +499,5 @@ * * @param bs Buffer hodling the boot sector of the file system. - * @param dev_handle Device handle of the file system. + * @param devmap_handle Device handle of the file system. * @param firstc First cluster in the chain which is to be freed. * @@ -505,5 +505,5 @@ */ int -fat_free_clusters(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc) +fat_free_clusters(fat_bs_t *bs, devmap_handle_t devmap_handle, fat_cluster_t firstc) { unsigned fatno; @@ -514,9 +514,9 @@ while (firstc < FAT_CLST_LAST1) { assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD); - rc = fat_get_cluster(bs, dev_handle, FAT1, firstc, &nextc); + rc = fat_get_cluster(bs, devmap_handle, FAT1, firstc, &nextc); if (rc != EOK) return rc; for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { - rc = fat_set_cluster(bs, dev_handle, fatno, firstc, + rc = fat_set_cluster(bs, devmap_handle, fatno, firstc, FAT_CLST_RES0); if (rc != EOK) @@ -543,5 +543,5 @@ fat_cluster_t lcl) { - dev_handle_t dev_handle = nodep->idx->dev_handle; + devmap_handle_t devmap_handle = nodep->idx->devmap_handle; fat_cluster_t lastc; uint8_t fatno; @@ -557,5 +557,5 @@ nodep->lastc_cached_valid = false; } else { - rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, + rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc, &lastc, NULL, (uint16_t) -1); if (rc != EOK) @@ -564,5 +564,5 @@ for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { - rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, + rc = fat_set_cluster(bs, nodep->idx->devmap_handle, fatno, lastc, mcl); if (rc != EOK) @@ -590,5 +590,5 @@ { int rc; - dev_handle_t dev_handle = nodep->idx->dev_handle; + devmap_handle_t devmap_handle = nodep->idx->devmap_handle; /* @@ -601,5 +601,5 @@ if (lcl == FAT_CLST_RES0) { /* The node will have zero size and no clusters allocated. */ - rc = fat_free_clusters(bs, dev_handle, nodep->firstc); + rc = fat_free_clusters(bs, devmap_handle, nodep->firstc); if (rc != EOK) return rc; @@ -610,5 +610,5 @@ unsigned fatno; - rc = fat_get_cluster(bs, dev_handle, FAT1, lcl, &nextc); + rc = fat_get_cluster(bs, devmap_handle, FAT1, lcl, &nextc); if (rc != EOK) return rc; @@ -616,5 +616,5 @@ /* Terminate the cluster chain in all copies of FAT. */ for (fatno = FAT1; fatno < bs->fatcnt; fatno++) { - rc = fat_set_cluster(bs, dev_handle, fatno, lcl, + rc = fat_set_cluster(bs, devmap_handle, fatno, lcl, FAT_CLST_LAST1); if (rc != EOK) @@ -623,5 +623,5 @@ /* Free all following clusters. */ - rc = fat_free_clusters(bs, dev_handle, nextc); + rc = fat_free_clusters(bs, devmap_handle, nextc); if (rc != EOK) return rc; @@ -638,5 +638,5 @@ int -fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c) +fat_zero_cluster(struct fat_bs *bs, devmap_handle_t devmap_handle, fat_cluster_t c) { int i; @@ -645,5 +645,5 @@ for (i = 0; i < SPC(bs); i++) { - rc = _fat_block_get(&b, bs, dev_handle, c, NULL, i, + rc = _fat_block_get(&b, bs, devmap_handle, c, NULL, i, BLOCK_FLAGS_NOREAD); if (rc != EOK) @@ -665,5 +665,5 @@ * does not contain a fat file system. */ -int fat_sanity_check(fat_bs_t *bs, dev_handle_t dev_handle) +int fat_sanity_check(fat_bs_t *bs, devmap_handle_t devmap_handle) { fat_cluster_t e0, e1; @@ -706,9 +706,9 @@ for (fat_no = 0; fat_no < bs->fatcnt; fat_no++) { - rc = fat_get_cluster(bs, dev_handle, fat_no, 0, &e0); + rc = fat_get_cluster(bs, devmap_handle, fat_no, 0, &e0); if (rc != EOK) return EIO; - rc = fat_get_cluster(bs, dev_handle, fat_no, 1, &e1); + rc = fat_get_cluster(bs, devmap_handle, fat_no, 1, &e1); if (rc != EOK) return EIO; Index: uspace/srv/fs/fat/fat_fat.h =================================================================== --- uspace/srv/fs/fat/fat_fat.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/fat/fat_fat.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -61,10 +61,10 @@ #define fat_clusters_get(numc, bs, dh, fc) \ fat_cluster_walk((bs), (dh), (fc), NULL, (numc), (uint16_t) -1) -extern int fat_cluster_walk(struct fat_bs *, dev_handle_t, fat_cluster_t, +extern int fat_cluster_walk(struct fat_bs *, devmap_handle_t, fat_cluster_t, fat_cluster_t *, uint16_t *, uint16_t); extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *, aoff64_t, int); -extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t, +extern int _fat_block_get(block_t **, struct fat_bs *, devmap_handle_t, fat_cluster_t, fat_cluster_t *, aoff64_t, int); @@ -73,17 +73,17 @@ extern int fat_chop_clusters(struct fat_bs *, struct fat_node *, fat_cluster_t); -extern int fat_alloc_clusters(struct fat_bs *, dev_handle_t, unsigned, +extern int fat_alloc_clusters(struct fat_bs *, devmap_handle_t, unsigned, fat_cluster_t *, fat_cluster_t *); -extern int fat_free_clusters(struct fat_bs *, dev_handle_t, fat_cluster_t); -extern int fat_alloc_shadow_clusters(struct fat_bs *, dev_handle_t, +extern int fat_free_clusters(struct fat_bs *, devmap_handle_t, fat_cluster_t); +extern int fat_alloc_shadow_clusters(struct fat_bs *, devmap_handle_t, fat_cluster_t *, unsigned); -extern int fat_get_cluster(struct fat_bs *, dev_handle_t, unsigned, +extern int fat_get_cluster(struct fat_bs *, devmap_handle_t, unsigned, fat_cluster_t, fat_cluster_t *); -extern int fat_set_cluster(struct fat_bs *, dev_handle_t, unsigned, +extern int fat_set_cluster(struct fat_bs *, devmap_handle_t, unsigned, fat_cluster_t, fat_cluster_t); extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t, aoff64_t); -extern int fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t); -extern int fat_sanity_check(struct fat_bs *, dev_handle_t); +extern int fat_zero_cluster(struct fat_bs *, devmap_handle_t, fat_cluster_t); +extern int fat_sanity_check(struct fat_bs *, devmap_handle_t); #endif Index: uspace/srv/fs/fat/fat_idx.c =================================================================== --- uspace/srv/fs/fat/fat_idx.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/fat/fat_idx.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -58,5 +58,5 @@ typedef struct { link_t link; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; /** Next unassigned index. */ @@ -75,8 +75,8 @@ static LIST_INITIALIZE(unused_head); -static void unused_initialize(unused_t *u, dev_handle_t dev_handle) +static void unused_initialize(unused_t *u, devmap_handle_t devmap_handle) { link_initialize(&u->link); - u->dev_handle = dev_handle; + u->devmap_handle = devmap_handle; u->next = 0; u->remaining = ((uint64_t)((fs_index_t)-1)) + 1; @@ -84,5 +84,5 @@ } -static unused_t *unused_find(dev_handle_t dev_handle, bool lock) +static unused_t *unused_find(devmap_handle_t devmap_handle, bool lock) { unused_t *u; @@ -93,5 +93,5 @@ for (l = unused_head.next; l != &unused_head; l = l->next) { u = list_get_instance(l, unused_t, link); - if (u->dev_handle == dev_handle) + if (u->devmap_handle == devmap_handle) return u; } @@ -106,5 +106,5 @@ /** * Global hash table of all used fat_idx_t structures. - * The index structures are hashed by the dev_handle, parent node's first + * The index structures are hashed by the devmap_handle, parent node's first * cluster and index within the parent directory. */ @@ -120,5 +120,5 @@ static hash_index_t pos_hash(unsigned long key[]) { - dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY]; + devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY]; fat_cluster_t pfc = (fat_cluster_t)key[UPH_PFC_KEY]; unsigned pdi = (unsigned)key[UPH_PDI_KEY]; @@ -140,5 +140,5 @@ h |= (pdi & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) << (UPH_BUCKETS_LOG / 2); - h |= (dev_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) << + h |= (devmap_handle & ((1 << (UPH_BUCKETS_LOG / 4)) - 1)) << (3 * (UPH_BUCKETS_LOG / 4)); @@ -148,5 +148,5 @@ static int pos_compare(unsigned long key[], hash_count_t keys, link_t *item) { - dev_handle_t dev_handle = (dev_handle_t)key[UPH_DH_KEY]; + devmap_handle_t devmap_handle = (devmap_handle_t)key[UPH_DH_KEY]; fat_cluster_t pfc; unsigned pdi; @@ -155,9 +155,9 @@ switch (keys) { case 1: - return (dev_handle == fidx->dev_handle); + return (devmap_handle == fidx->devmap_handle); case 3: pfc = (fat_cluster_t) key[UPH_PFC_KEY]; pdi = (unsigned) key[UPH_PDI_KEY]; - return (dev_handle == fidx->dev_handle) && (pfc == fidx->pfc) && + return (devmap_handle == fidx->devmap_handle) && (pfc == fidx->pfc) && (pdi == fidx->pdi); default: @@ -181,5 +181,5 @@ /** * Global hash table of all used fat_idx_t structures. - * The index structures are hashed by the dev_handle and index. + * The index structures are hashed by the devmap_handle and index. */ static hash_table_t ui_hash; @@ -193,10 +193,10 @@ static hash_index_t idx_hash(unsigned long key[]) { - dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY]; + devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY]; fs_index_t index = (fs_index_t)key[UIH_INDEX_KEY]; hash_index_t h; - h = dev_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1); + h = devmap_handle & ((1 << (UIH_BUCKETS_LOG / 2)) - 1); h |= (index & ((1 << (UIH_BUCKETS_LOG / 2)) - 1)) << (UIH_BUCKETS_LOG / 2); @@ -207,5 +207,5 @@ static int idx_compare(unsigned long key[], hash_count_t keys, link_t *item) { - dev_handle_t dev_handle = (dev_handle_t)key[UIH_DH_KEY]; + devmap_handle_t devmap_handle = (devmap_handle_t)key[UIH_DH_KEY]; fs_index_t index; fat_idx_t *fidx = list_get_instance(item, fat_idx_t, uih_link); @@ -213,8 +213,8 @@ switch (keys) { case 1: - return (dev_handle == fidx->dev_handle); + return (devmap_handle == fidx->devmap_handle); case 2: index = (fs_index_t) key[UIH_INDEX_KEY]; - return (dev_handle == fidx->dev_handle) && + return (devmap_handle == fidx->devmap_handle) && (index == fidx->index); default: @@ -239,10 +239,10 @@ /** Allocate a VFS index which is not currently in use. */ -static bool fat_index_alloc(dev_handle_t dev_handle, fs_index_t *index) +static bool fat_index_alloc(devmap_handle_t devmap_handle, fs_index_t *index) { unused_t *u; assert(index); - u = unused_find(dev_handle, true); + u = unused_find(devmap_handle, true); if (!u) return false; @@ -301,9 +301,9 @@ /** Free a VFS index, which is no longer in use. */ -static void fat_index_free(dev_handle_t dev_handle, fs_index_t index) +static void fat_index_free(devmap_handle_t devmap_handle, fs_index_t index) { unused_t *u; - u = unused_find(dev_handle, true); + u = unused_find(devmap_handle, true); assert(u); @@ -363,5 +363,5 @@ } -static int fat_idx_create(fat_idx_t **fidxp, dev_handle_t dev_handle) +static int fat_idx_create(fat_idx_t **fidxp, devmap_handle_t devmap_handle) { fat_idx_t *fidx; @@ -370,5 +370,5 @@ if (!fidx) return ENOMEM; - if (!fat_index_alloc(dev_handle, &fidx->index)) { + if (!fat_index_alloc(devmap_handle, &fidx->index)) { free(fidx); return ENOSPC; @@ -378,5 +378,5 @@ link_initialize(&fidx->uih_link); fibril_mutex_initialize(&fidx->lock); - fidx->dev_handle = dev_handle; + fidx->devmap_handle = devmap_handle; fidx->pfc = FAT_CLST_RES0; /* no parent yet */ fidx->pdi = 0; @@ -387,5 +387,5 @@ } -int fat_idx_get_new(fat_idx_t **fidxp, dev_handle_t dev_handle) +int fat_idx_get_new(fat_idx_t **fidxp, devmap_handle_t devmap_handle) { fat_idx_t *fidx; @@ -393,5 +393,5 @@ fibril_mutex_lock(&used_lock); - rc = fat_idx_create(&fidx, dev_handle); + rc = fat_idx_create(&fidx, devmap_handle); if (rc != EOK) { fibril_mutex_unlock(&used_lock); @@ -400,5 +400,5 @@ unsigned long ikey[] = { - [UIH_DH_KEY] = dev_handle, + [UIH_DH_KEY] = devmap_handle, [UIH_INDEX_KEY] = fidx->index, }; @@ -413,10 +413,10 @@ fat_idx_t * -fat_idx_get_by_pos(dev_handle_t dev_handle, fat_cluster_t pfc, unsigned pdi) +fat_idx_get_by_pos(devmap_handle_t devmap_handle, fat_cluster_t pfc, unsigned pdi) { fat_idx_t *fidx; link_t *l; unsigned long pkey[] = { - [UPH_DH_KEY] = dev_handle, + [UPH_DH_KEY] = devmap_handle, [UPH_PFC_KEY] = pfc, [UPH_PDI_KEY] = pdi, @@ -430,5 +430,5 @@ int rc; - rc = fat_idx_create(&fidx, dev_handle); + rc = fat_idx_create(&fidx, devmap_handle); if (rc != EOK) { fibril_mutex_unlock(&used_lock); @@ -437,5 +437,5 @@ unsigned long ikey[] = { - [UIH_DH_KEY] = dev_handle, + [UIH_DH_KEY] = devmap_handle, [UIH_INDEX_KEY] = fidx->index, }; @@ -456,5 +456,5 @@ { unsigned long pkey[] = { - [UPH_DH_KEY] = idx->dev_handle, + [UPH_DH_KEY] = idx->devmap_handle, [UPH_PFC_KEY] = idx->pfc, [UPH_PDI_KEY] = idx->pdi, @@ -469,5 +469,5 @@ { unsigned long pkey[] = { - [UPH_DH_KEY] = idx->dev_handle, + [UPH_DH_KEY] = idx->devmap_handle, [UPH_PFC_KEY] = idx->pfc, [UPH_PDI_KEY] = idx->pdi, @@ -480,10 +480,10 @@ fat_idx_t * -fat_idx_get_by_index(dev_handle_t dev_handle, fs_index_t index) +fat_idx_get_by_index(devmap_handle_t devmap_handle, fs_index_t index) { fat_idx_t *fidx = NULL; link_t *l; unsigned long ikey[] = { - [UIH_DH_KEY] = dev_handle, + [UIH_DH_KEY] = devmap_handle, [UIH_INDEX_KEY] = index, }; @@ -507,8 +507,8 @@ { unsigned long ikey[] = { - [UIH_DH_KEY] = idx->dev_handle, + [UIH_DH_KEY] = idx->devmap_handle, [UIH_INDEX_KEY] = idx->index, }; - dev_handle_t dev_handle = idx->dev_handle; + devmap_handle_t devmap_handle = idx->devmap_handle; fs_index_t index = idx->index; @@ -524,5 +524,5 @@ fibril_mutex_unlock(&used_lock); /* Release the VFS index. */ - fat_index_free(dev_handle, index); + fat_index_free(devmap_handle, index); /* The index structure itself is freed in idx_remove_callback(). */ } @@ -546,5 +546,5 @@ } -int fat_idx_init_by_dev_handle(dev_handle_t dev_handle) +int fat_idx_init_by_devmap_handle(devmap_handle_t devmap_handle) { unused_t *u; @@ -554,7 +554,7 @@ if (!u) return ENOMEM; - unused_initialize(u, dev_handle); + unused_initialize(u, devmap_handle); fibril_mutex_lock(&unused_lock); - if (!unused_find(dev_handle, false)) { + if (!unused_find(devmap_handle, false)) { list_append(&u->link, &unused_head); } else { @@ -566,11 +566,11 @@ } -void fat_idx_fini_by_dev_handle(dev_handle_t dev_handle) +void fat_idx_fini_by_devmap_handle(devmap_handle_t devmap_handle) { unsigned long ikey[] = { - [UIH_DH_KEY] = dev_handle + [UIH_DH_KEY] = devmap_handle }; unsigned long pkey[] = { - [UPH_DH_KEY] = dev_handle + [UPH_DH_KEY] = devmap_handle }; @@ -588,5 +588,5 @@ * Free the unused and freed structures for this instance. */ - unused_t *u = unused_find(dev_handle, true); + unused_t *u = unused_find(devmap_handle, true); assert(u); list_remove(&u->link); Index: uspace/srv/fs/fat/fat_ops.c =================================================================== --- uspace/srv/fs/fat/fat_ops.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/fat/fat_ops.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -72,10 +72,10 @@ * Forward declarations of FAT libfs operations. */ -static int fat_root_get(fs_node_t **, dev_handle_t); +static int fat_root_get(fs_node_t **, devmap_handle_t); static int fat_match(fs_node_t **, fs_node_t *, const char *); -static int fat_node_get(fs_node_t **, dev_handle_t, fs_index_t); +static int fat_node_get(fs_node_t **, devmap_handle_t, fs_index_t); static int fat_node_open(fs_node_t *); static int fat_node_put(fs_node_t *); -static int fat_create_node(fs_node_t **, dev_handle_t, int); +static int fat_create_node(fs_node_t **, devmap_handle_t, int); static int fat_destroy_node(fs_node_t *); static int fat_link(fs_node_t *, fs_node_t *, const char *); @@ -88,5 +88,5 @@ static bool fat_is_directory(fs_node_t *); static bool fat_is_file(fs_node_t *node); -static dev_handle_t fat_device_get(fs_node_t *node); +static devmap_handle_t fat_device_get(fs_node_t *node); /* @@ -120,8 +120,8 @@ assert(node->dirty); - bs = block_bb_get(node->idx->dev_handle); + bs = block_bb_get(node->idx->devmap_handle); /* Read the block that contains the dentry of interest. */ - rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc, + rc = _fat_block_get(&b, bs, node->idx->devmap_handle, node->idx->pfc, NULL, (node->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE); @@ -145,5 +145,5 @@ } -static int fat_node_fini_by_dev_handle(dev_handle_t dev_handle) +static int fat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle) { link_t *lnk; @@ -170,5 +170,5 @@ goto restart; } - if (nodep->idx->dev_handle != dev_handle) { + if (nodep->idx->devmap_handle != devmap_handle) { fibril_mutex_unlock(&nodep->idx->lock); fibril_mutex_unlock(&nodep->lock); @@ -299,8 +299,8 @@ return rc; - bs = block_bb_get(idxp->dev_handle); + bs = block_bb_get(idxp->devmap_handle); /* Read the block that contains the dentry of interest. */ - rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc, NULL, + rc = _fat_block_get(&b, bs, idxp->devmap_handle, idxp->pfc, NULL, (idxp->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE); if (rc != EOK) { @@ -323,5 +323,5 @@ */ uint16_t clusters; - rc = fat_clusters_get(&clusters, bs, idxp->dev_handle, + rc = fat_clusters_get(&clusters, bs, idxp->devmap_handle, uint16_t_le2host(d->firstc)); if (rc != EOK) { @@ -356,7 +356,7 @@ */ -int fat_root_get(fs_node_t **rfn, dev_handle_t dev_handle) -{ - return fat_node_get(rfn, dev_handle, 0); +int fat_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) +{ + return fat_node_get(rfn, devmap_handle, 0); } @@ -369,13 +369,13 @@ unsigned blocks; fat_dentry_t *d; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; block_t *b; int rc; fibril_mutex_lock(&parentp->idx->lock); - dev_handle = parentp->idx->dev_handle; + devmap_handle = parentp->idx->devmap_handle; fibril_mutex_unlock(&parentp->idx->lock); - bs = block_bb_get(dev_handle); + bs = block_bb_get(devmap_handle); blocks = parentp->size / BPS(bs); for (i = 0; i < blocks; i++) { @@ -402,5 +402,5 @@ /* hit */ fat_node_t *nodep; - fat_idx_t *idx = fat_idx_get_by_pos(dev_handle, + fat_idx_t *idx = fat_idx_get_by_pos(devmap_handle, parentp->firstc, i * DPS(bs) + j); if (!idx) { @@ -435,5 +435,5 @@ /** Instantiate a FAT in-core node. */ -int fat_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index) +int fat_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) { fat_node_t *nodep; @@ -441,5 +441,5 @@ int rc; - idxp = fat_idx_get_by_index(dev_handle, index); + idxp = fat_idx_get_by_index(devmap_handle, index); if (!idxp) { *rfn = NULL; @@ -492,5 +492,5 @@ } -int fat_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int flags) +int fat_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags) { fat_idx_t *idxp; @@ -500,14 +500,14 @@ int rc; - bs = block_bb_get(dev_handle); + bs = block_bb_get(devmap_handle); if (flags & L_DIRECTORY) { /* allocate a cluster */ - rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl); + rc = fat_alloc_clusters(bs, devmap_handle, 1, &mcl, &lcl); if (rc != EOK) return rc; /* populate the new cluster with unused dentries */ - rc = fat_zero_cluster(bs, dev_handle, mcl); + rc = fat_zero_cluster(bs, devmap_handle, mcl); if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + (void) fat_free_clusters(bs, devmap_handle, mcl); return rc; } @@ -516,10 +516,10 @@ rc = fat_node_get_new(&nodep); if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + (void) fat_free_clusters(bs, devmap_handle, mcl); return rc; } - rc = fat_idx_get_new(&idxp, dev_handle); - if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + rc = fat_idx_get_new(&idxp, devmap_handle); + if (rc != EOK) { + (void) fat_free_clusters(bs, devmap_handle, mcl); (void) fat_node_put(FS_NODE(nodep)); return rc; @@ -570,9 +570,9 @@ assert(!has_children); - bs = block_bb_get(nodep->idx->dev_handle); + bs = block_bb_get(nodep->idx->devmap_handle); if (nodep->firstc != FAT_CLST_RES0) { assert(nodep->size); /* Free all clusters allocated to the node. */ - rc = fat_free_clusters(bs, nodep->idx->dev_handle, + rc = fat_free_clusters(bs, nodep->idx->devmap_handle, nodep->firstc); } @@ -620,5 +620,5 @@ fibril_mutex_lock(&parentp->idx->lock); - bs = block_bb_get(parentp->idx->dev_handle); + bs = block_bb_get(parentp->idx->devmap_handle); blocks = parentp->size / BPS(bs); @@ -659,12 +659,12 @@ return ENOSPC; } - rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl); + rc = fat_alloc_clusters(bs, parentp->idx->devmap_handle, 1, &mcl, &lcl); if (rc != EOK) { fibril_mutex_unlock(&parentp->idx->lock); return rc; } - rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl); - if (rc != EOK) { - (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl); + rc = fat_zero_cluster(bs, parentp->idx->devmap_handle, mcl); + if (rc != EOK) { + (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl); fibril_mutex_unlock(&parentp->idx->lock); return rc; @@ -672,5 +672,5 @@ rc = fat_append_clusters(bs, parentp, mcl, lcl); if (rc != EOK) { - (void) fat_free_clusters(bs, parentp->idx->dev_handle, mcl); + (void) fat_free_clusters(bs, parentp->idx->devmap_handle, mcl); fibril_mutex_unlock(&parentp->idx->lock); return rc; @@ -789,7 +789,7 @@ assert(childp->lnkcnt == 1); fibril_mutex_lock(&childp->idx->lock); - bs = block_bb_get(childp->idx->dev_handle); - - rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc, + bs = block_bb_get(childp->idx->devmap_handle); + + rc = _fat_block_get(&b, bs, childp->idx->devmap_handle, childp->idx->pfc, NULL, (childp->idx->pdi * sizeof(fat_dentry_t)) / BPS(bs), BLOCK_FLAGS_NONE); @@ -840,5 +840,5 @@ fibril_mutex_lock(&nodep->idx->lock); - bs = block_bb_get(nodep->idx->dev_handle); + bs = block_bb_get(nodep->idx->devmap_handle); blocks = nodep->size / BPS(bs); @@ -914,5 +914,5 @@ } -dev_handle_t fat_device_get(fs_node_t *node) +devmap_handle_t fat_device_get(fs_node_t *node) { return 0; @@ -946,5 +946,5 @@ void fat_mounted(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); enum cache_mode cmode; fat_bs_t *bs; @@ -968,5 +968,5 @@ /* initialize libblock */ - rc = block_init(dev_handle, BS_SIZE); + rc = block_init(devmap_handle, BS_SIZE); if (rc != EOK) { ipc_answer_0(rid, rc); @@ -975,7 +975,7 @@ /* prepare the boot block */ - rc = block_bb_read(dev_handle, BS_BLOCK); - if (rc != EOK) { - block_fini(dev_handle); + rc = block_bb_read(devmap_handle, BS_BLOCK); + if (rc != EOK) { + block_fini(devmap_handle); ipc_answer_0(rid, rc); return; @@ -983,8 +983,8 @@ /* get the buffer with the boot sector */ - bs = block_bb_get(dev_handle); + bs = block_bb_get(devmap_handle); if (BPS(bs) != BS_SIZE) { - block_fini(dev_handle); + block_fini(devmap_handle); ipc_answer_0(rid, ENOTSUP); return; @@ -992,7 +992,7 @@ /* Initialize the block cache */ - rc = block_cache_init(dev_handle, BPS(bs), 0 /* XXX */, cmode); - if (rc != EOK) { - block_fini(dev_handle); + rc = block_cache_init(devmap_handle, BPS(bs), 0 /* XXX */, cmode); + if (rc != EOK) { + block_fini(devmap_handle); ipc_answer_0(rid, rc); return; @@ -1000,16 +1000,16 @@ /* Do some simple sanity checks on the file system. */ - rc = fat_sanity_check(bs, dev_handle); - if (rc != EOK) { - (void) block_cache_fini(dev_handle); - block_fini(dev_handle); + rc = fat_sanity_check(bs, devmap_handle); + if (rc != EOK) { + (void) block_cache_fini(devmap_handle); + block_fini(devmap_handle); ipc_answer_0(rid, rc); return; } - rc = fat_idx_init_by_dev_handle(dev_handle); - if (rc != EOK) { - (void) block_cache_fini(dev_handle); - block_fini(dev_handle); + rc = fat_idx_init_by_devmap_handle(devmap_handle); + if (rc != EOK) { + (void) block_cache_fini(devmap_handle); + block_fini(devmap_handle); ipc_answer_0(rid, rc); return; @@ -1019,7 +1019,7 @@ fs_node_t *rfn = (fs_node_t *)malloc(sizeof(fs_node_t)); if (!rfn) { - (void) block_cache_fini(dev_handle); - block_fini(dev_handle); - fat_idx_fini_by_dev_handle(dev_handle); + (void) block_cache_fini(devmap_handle); + block_fini(devmap_handle); + fat_idx_fini_by_devmap_handle(devmap_handle); ipc_answer_0(rid, ENOMEM); return; @@ -1029,7 +1029,7 @@ if (!rootp) { free(rfn); - (void) block_cache_fini(dev_handle); - block_fini(dev_handle); - fat_idx_fini_by_dev_handle(dev_handle); + (void) block_cache_fini(devmap_handle); + block_fini(devmap_handle); + fat_idx_fini_by_devmap_handle(devmap_handle); ipc_answer_0(rid, ENOMEM); return; @@ -1037,11 +1037,11 @@ fat_node_initialize(rootp); - fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0); + fat_idx_t *ridxp = fat_idx_get_by_pos(devmap_handle, FAT_CLST_ROOTPAR, 0); if (!ridxp) { free(rfn); free(rootp); - (void) block_cache_fini(dev_handle); - block_fini(dev_handle); - fat_idx_fini_by_dev_handle(dev_handle); + (void) block_cache_fini(devmap_handle); + block_fini(devmap_handle); + fat_idx_fini_by_devmap_handle(devmap_handle); ipc_answer_0(rid, ENOMEM); return; @@ -1072,10 +1072,10 @@ void fat_unmounted(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_node_t *fn; fat_node_t *nodep; int rc; - rc = fat_root_get(&fn, dev_handle); + rc = fat_root_get(&fn, devmap_handle); if (rc != EOK) { ipc_answer_0(rid, rc); @@ -1105,8 +1105,8 @@ * stop using libblock for this instance. */ - (void) fat_node_fini_by_dev_handle(dev_handle); - fat_idx_fini_by_dev_handle(dev_handle); - (void) block_cache_fini(dev_handle); - block_fini(dev_handle); + (void) fat_node_fini_by_devmap_handle(devmap_handle); + fat_idx_fini_by_devmap_handle(devmap_handle); + (void) block_cache_fini(devmap_handle); + block_fini(devmap_handle); ipc_answer_0(rid, EOK); @@ -1125,5 +1125,5 @@ void fat_read(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); aoff64_t pos = @@ -1136,5 +1136,5 @@ int rc; - rc = fat_node_get(&fn, dev_handle, index); + rc = fat_node_get(&fn, devmap_handle, index); if (rc != EOK) { ipc_answer_0(rid, rc); @@ -1156,5 +1156,5 @@ } - bs = block_bb_get(dev_handle); + bs = block_bb_get(devmap_handle); if (nodep->type == FAT_FILE) { @@ -1262,5 +1262,5 @@ void fat_write(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); aoff64_t pos = @@ -1275,5 +1275,5 @@ int rc; - rc = fat_node_get(&fn, dev_handle, index); + rc = fat_node_get(&fn, devmap_handle, index); if (rc != EOK) { ipc_answer_0(rid, rc); @@ -1295,5 +1295,5 @@ } - bs = block_bb_get(dev_handle); + bs = block_bb_get(devmap_handle); /* @@ -1357,5 +1357,5 @@ nclsts = (ROUND_UP(pos + bytes, BPC(bs)) - boundary) / BPC(bs); /* create an independent chain of nclsts clusters in all FATs */ - rc = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl); + rc = fat_alloc_clusters(bs, devmap_handle, nclsts, &mcl, &lcl); if (rc != EOK) { /* could not allocate a chain of nclsts clusters */ @@ -1368,5 +1368,5 @@ rc = fat_fill_gap(bs, nodep, mcl, pos); if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + (void) fat_free_clusters(bs, devmap_handle, mcl); (void) fat_node_put(fn); ipc_answer_0(callid, rc); @@ -1374,8 +1374,8 @@ return; } - rc = _fat_block_get(&b, bs, dev_handle, lcl, NULL, + rc = _fat_block_get(&b, bs, devmap_handle, lcl, NULL, (pos / BPS(bs)) % SPC(bs), flags); if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + (void) fat_free_clusters(bs, devmap_handle, mcl); (void) fat_node_put(fn); ipc_answer_0(callid, rc); @@ -1388,5 +1388,5 @@ rc = block_put(b); if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + (void) fat_free_clusters(bs, devmap_handle, mcl); (void) fat_node_put(fn); ipc_answer_0(rid, rc); @@ -1399,5 +1399,5 @@ rc = fat_append_clusters(bs, nodep, mcl, lcl); if (rc != EOK) { - (void) fat_free_clusters(bs, dev_handle, mcl); + (void) fat_free_clusters(bs, devmap_handle, mcl); (void) fat_node_put(fn); ipc_answer_0(rid, rc); @@ -1414,5 +1414,5 @@ void fat_truncate(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); aoff64_t size = @@ -1423,5 +1423,5 @@ int rc; - rc = fat_node_get(&fn, dev_handle, index); + rc = fat_node_get(&fn, devmap_handle, index); if (rc != EOK) { ipc_answer_0(rid, rc); @@ -1434,5 +1434,5 @@ nodep = FAT_NODE(fn); - bs = block_bb_get(dev_handle); + bs = block_bb_get(devmap_handle); if (nodep->size == size) { @@ -1461,5 +1461,5 @@ } else { fat_cluster_t lastc; - rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, + rc = fat_cluster_walk(bs, devmap_handle, nodep->firstc, &lastc, NULL, (size - 1) / BPC(bs)); if (rc != EOK) @@ -1486,10 +1486,10 @@ void fat_destroy(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request); fs_node_t *fn; int rc; - rc = fat_node_get(&fn, dev_handle, index); + rc = fat_node_get(&fn, devmap_handle, index); if (rc != EOK) { ipc_answer_0(rid, rc); @@ -1517,9 +1517,9 @@ void fat_sync(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); fs_node_t *fn; - int rc = fat_node_get(&fn, dev_handle, index); + int rc = fat_node_get(&fn, devmap_handle, index); if (rc != EOK) { ipc_answer_0(rid, rc); Index: uspace/srv/fs/tmpfs/tmpfs.h =================================================================== --- uspace/srv/fs/tmpfs/tmpfs.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/tmpfs/tmpfs.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -62,5 +62,5 @@ fs_node_t *bp; /**< Back pointer to the FS node. */ fs_index_t index; /**< TMPFS node index. */ - dev_handle_t dev_handle;/**< Device handle. */ + devmap_handle_t devmap_handle;/**< Device handle. */ link_t nh_link; /**< Nodes hash table link. */ tmpfs_dentry_type_t type; @@ -91,5 +91,5 @@ extern void tmpfs_sync(ipc_callid_t, ipc_call_t *); -extern bool tmpfs_restore(dev_handle_t); +extern bool tmpfs_restore(devmap_handle_t); #endif Index: uspace/srv/fs/tmpfs/tmpfs_dump.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -55,5 +55,5 @@ static bool -tmpfs_restore_recursion(dev_handle_t dev, size_t *bufpos, size_t *buflen, +tmpfs_restore_recursion(devmap_handle_t dev, size_t *bufpos, size_t *buflen, aoff64_t *pos, fs_node_t *pfn) { @@ -161,5 +161,5 @@ } -bool tmpfs_restore(dev_handle_t dev) +bool tmpfs_restore(devmap_handle_t dev) { libfs_ops_t *ops = &tmpfs_libfs_ops; Index: uspace/srv/fs/tmpfs/tmpfs_ops.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs_ops.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/fs/tmpfs/tmpfs_ops.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -70,8 +70,8 @@ /* Forward declarations of static functions. */ static int tmpfs_match(fs_node_t **, fs_node_t *, const char *); -static int tmpfs_node_get(fs_node_t **, dev_handle_t, fs_index_t); +static int tmpfs_node_get(fs_node_t **, devmap_handle_t, fs_index_t); static int tmpfs_node_open(fs_node_t *); static int tmpfs_node_put(fs_node_t *); -static int tmpfs_create_node(fs_node_t **, dev_handle_t, int); +static int tmpfs_create_node(fs_node_t **, devmap_handle_t, int); static int tmpfs_destroy_node(fs_node_t *); static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *); @@ -79,7 +79,7 @@ /* Implementation of helper functions. */ -static int tmpfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle) -{ - return tmpfs_node_get(rfn, dev_handle, TMPFS_SOME_ROOT); +static int tmpfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle) +{ + return tmpfs_node_get(rfn, devmap_handle, TMPFS_SOME_ROOT); } @@ -120,5 +120,5 @@ } -static dev_handle_t tmpfs_device_get(fs_node_t *fn) +static devmap_handle_t tmpfs_device_get(fs_node_t *fn) { return 0; @@ -165,7 +165,7 @@ switch (keys) { case 1: - return (nodep->dev_handle == key[NODES_KEY_DEV]); + return (nodep->devmap_handle == key[NODES_KEY_DEV]); case 2: - return ((nodep->dev_handle == key[NODES_KEY_DEV]) && + return ((nodep->devmap_handle == key[NODES_KEY_DEV]) && (nodep->index == key[NODES_KEY_INDEX])); default: @@ -209,5 +209,5 @@ nodep->bp = NULL; nodep->index = 0; - nodep->dev_handle = 0; + nodep->devmap_handle = 0; nodep->type = TMPFS_NONE; nodep->lnkcnt = 0; @@ -233,10 +233,10 @@ } -static bool tmpfs_instance_init(dev_handle_t dev_handle) +static bool tmpfs_instance_init(devmap_handle_t devmap_handle) { fs_node_t *rfn; int rc; - rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY); + rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY); if (rc != EOK || !rfn) return false; @@ -245,8 +245,8 @@ } -static void tmpfs_instance_done(dev_handle_t dev_handle) +static void tmpfs_instance_done(devmap_handle_t devmap_handle) { unsigned long key[] = { - [NODES_KEY_DEV] = dev_handle + [NODES_KEY_DEV] = devmap_handle }; /* @@ -279,8 +279,8 @@ } -int tmpfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index) +int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index) { unsigned long key[] = { - [NODES_KEY_DEV] = dev_handle, + [NODES_KEY_DEV] = devmap_handle, [NODES_KEY_INDEX] = index }; @@ -308,5 +308,5 @@ } -int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag) +int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag) { fs_node_t *rootfn; @@ -327,5 +327,5 @@ nodep->bp->data = nodep; /* link the FS and TMPFS nodes */ - rc = tmpfs_root_get(&rootfn, dev_handle); + rc = tmpfs_root_get(&rootfn, devmap_handle); assert(rc == EOK); if (!rootfn) @@ -333,5 +333,5 @@ else nodep->index = tmpfs_next_index++; - nodep->dev_handle = dev_handle; + nodep->devmap_handle = devmap_handle; if (lflag & L_DIRECTORY) nodep->type = TMPFS_DIRECTORY; @@ -341,5 +341,5 @@ /* Insert the new node into the nodes hash table. */ unsigned long key[] = { - [NODES_KEY_DEV] = nodep->dev_handle, + [NODES_KEY_DEV] = nodep->devmap_handle, [NODES_KEY_INDEX] = nodep->index }; @@ -357,5 +357,5 @@ unsigned long key[] = { - [NODES_KEY_DEV] = nodep->dev_handle, + [NODES_KEY_DEV] = nodep->devmap_handle, [NODES_KEY_INDEX] = nodep->index }; @@ -442,5 +442,5 @@ void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_node_t *rootfn; int rc; @@ -455,5 +455,5 @@ /* Check if this device is not already mounted. */ - rc = tmpfs_root_get(&rootfn, dev_handle); + rc = tmpfs_root_get(&rootfn, devmap_handle); if ((rc == EOK) && (rootfn)) { (void) tmpfs_node_put(rootfn); @@ -464,5 +464,5 @@ /* Initialize TMPFS instance. */ - if (!tmpfs_instance_init(dev_handle)) { + if (!tmpfs_instance_init(devmap_handle)) { free(opts); ipc_answer_0(rid, ENOMEM); @@ -470,9 +470,9 @@ } - rc = tmpfs_root_get(&rootfn, dev_handle); + rc = tmpfs_root_get(&rootfn, devmap_handle); assert(rc == EOK); tmpfs_node_t *rootp = TMPFS_NODE(rootfn); if (str_cmp(opts, "restore") == 0) { - if (tmpfs_restore(dev_handle)) + if (tmpfs_restore(devmap_handle)) ipc_answer_3(rid, EOK, rootp->index, rootp->size, rootp->lnkcnt); @@ -493,7 +493,7 @@ void tmpfs_unmounted(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); - - tmpfs_instance_done(dev_handle); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); + + tmpfs_instance_done(devmap_handle); ipc_answer_0(rid, EOK); } @@ -511,5 +511,5 @@ void tmpfs_read(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); aoff64_t pos = @@ -521,5 +521,5 @@ link_t *hlp; unsigned long key[] = { - [NODES_KEY_DEV] = dev_handle, + [NODES_KEY_DEV] = devmap_handle, [NODES_KEY_INDEX] = index }; @@ -586,5 +586,5 @@ void tmpfs_write(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); aoff64_t pos = @@ -596,5 +596,5 @@ link_t *hlp; unsigned long key[] = { - [NODES_KEY_DEV] = dev_handle, + [NODES_KEY_DEV] = devmap_handle, [NODES_KEY_INDEX] = index }; @@ -651,5 +651,5 @@ void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); aoff64_t size = @@ -660,5 +660,5 @@ */ unsigned long key[] = { - [NODES_KEY_DEV] = dev_handle, + [NODES_KEY_DEV] = devmap_handle, [NODES_KEY_INDEX] = index }; @@ -704,5 +704,5 @@ void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request) { - dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request); fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request); int rc; @@ -710,5 +710,5 @@ link_t *hlp; unsigned long key[] = { - [NODES_KEY_DEV] = dev_handle, + [NODES_KEY_DEV] = devmap_handle, [NODES_KEY_INDEX] = index }; Index: uspace/srv/hid/adb_mouse/adb_mouse.c =================================================================== --- uspace/srv/hid/adb_mouse/adb_mouse.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hid/adb_mouse/adb_mouse.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -78,6 +78,6 @@ snprintf(dev_path, DEVMAP_NAME_MAXLEN, "%s/mouse", NAMESPACE); - dev_handle_t dev_handle; - if (devmap_device_register(dev_path, &dev_handle) != EOK) { + devmap_handle_t devmap_handle; + if (devmap_device_register(dev_path, &devmap_handle) != EOK) { printf(NAME ": Unable to register device %s\n", dev_path); return -1; Index: uspace/srv/hid/char_mouse/char_mouse.c =================================================================== --- uspace/srv/hid/char_mouse/char_mouse.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hid/char_mouse/char_mouse.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -134,6 +134,6 @@ snprintf(dev_path, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME); - dev_handle_t dev_handle; - if (devmap_device_register(dev_path, &dev_handle) != EOK) { + devmap_handle_t devmap_handle; + if (devmap_device_register(dev_path, &devmap_handle) != EOK) { printf(NAME ": Unable to register device %s\n", dev_path); return -1; Index: uspace/srv/hid/console/console.c =================================================================== --- uspace/srv/hid/console/console.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hid/console/console.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -82,5 +82,5 @@ size_t index; /**< Console index */ size_t refcount; /**< Connection reference count */ - dev_handle_t dev_handle; /**< Device handle */ + devmap_handle_t devmap_handle; /**< Device handle */ keybuffer_t keybuffer; /**< Buffer for incoming keys. */ screenbuffer_t scr; /**< Screenbuffer for saving screen @@ -571,5 +571,5 @@ continue; - if (consoles[i].dev_handle == (dev_handle_t) IPC_GET_ARG1(*icall)) { + if (consoles[i].devmap_handle == (devmap_handle_t) IPC_GET_ARG1(*icall)) { cons = &consoles[i]; break; @@ -815,5 +815,5 @@ snprintf(vc, DEVMAP_NAME_MAXLEN, "%s/vc%u", NAMESPACE, i); - if (devmap_device_register(vc, &consoles[i].dev_handle) != EOK) { + if (devmap_device_register(vc, &consoles[i].devmap_handle) != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); printf(NAME ": Unable to register device %s\n", vc); Index: uspace/srv/hid/kbd/generic/kbd.c =================================================================== --- uspace/srv/hid/kbd/generic/kbd.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hid/kbd/generic/kbd.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -250,6 +250,6 @@ snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME); - dev_handle_t dev_handle; - if (devmap_device_register(kbd, &dev_handle) != EOK) { + devmap_handle_t devmap_handle; + if (devmap_device_register(kbd, &devmap_handle) != EOK) { printf("%s: Unable to register device %s\n", NAME, kbd); return -1; Index: uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c =================================================================== --- uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -99,5 +99,5 @@ return -1; - rc = devmap_device_register(NAMESPACE "/mouse", &ts->dev_handle); + rc = devmap_device_register(NAMESPACE "/mouse", &ts->devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); Index: uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h =================================================================== --- uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -125,5 +125,5 @@ /** Device handle */ - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; /** Device/driver state */ Index: uspace/srv/hw/bus/cuda_adb/cuda_adb.c =================================================================== --- uspace/srv/hw/bus/cuda_adb/cuda_adb.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hw/bus/cuda_adb/cuda_adb.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -143,5 +143,5 @@ int main(int argc, char *argv[]) { - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; int rc; int i; @@ -151,5 +151,5 @@ for (i = 0; i < ADB_MAX_ADDR; ++i) { adb_dev[i].client_phone = -1; - adb_dev[i].dev_handle = 0; + adb_dev[i].devmap_handle = 0; } @@ -160,5 +160,5 @@ } - rc = devmap_device_register("adb/kbd", &dev_handle); + rc = devmap_device_register("adb/kbd", &devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); @@ -167,8 +167,8 @@ } - adb_dev[2].dev_handle = dev_handle; - adb_dev[8].dev_handle = dev_handle; - - rc = devmap_device_register("adb/mouse", &dev_handle); + adb_dev[2].devmap_handle = devmap_handle; + adb_dev[8].devmap_handle = devmap_handle; + + rc = devmap_device_register("adb/mouse", &devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); @@ -177,5 +177,5 @@ } - adb_dev[9].dev_handle = dev_handle; + adb_dev[9].devmap_handle = devmap_handle; if (cuda_init() < 0) { @@ -196,5 +196,5 @@ ipc_call_t call; ipcarg_t method; - dev_handle_t dh; + devmap_handle_t dh; int retval; int dev_addr, i; @@ -206,5 +206,5 @@ dev_addr = -1; for (i = 0; i < ADB_MAX_ADDR; i++) { - if (adb_dev[i].dev_handle == dh) + if (adb_dev[i].devmap_handle == dh) dev_addr = i; } @@ -237,5 +237,5 @@ */ for (i = 0; i < ADB_MAX_ADDR; ++i) { - if (adb_dev[i].dev_handle == dh) { + if (adb_dev[i].devmap_handle == dh) { adb_dev[i].client_phone = IPC_GET_ARG5(call); } Index: uspace/srv/hw/bus/cuda_adb/cuda_adb.h =================================================================== --- uspace/srv/hw/bus/cuda_adb/cuda_adb.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hw/bus/cuda_adb/cuda_adb.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -104,5 +104,5 @@ typedef struct { - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; int client_phone; } adb_dev_t; Index: uspace/srv/hw/char/i8042/i8042.c =================================================================== --- uspace/srv/hw/char/i8042/i8042.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hw/char/i8042/i8042.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -145,5 +145,5 @@ snprintf(name, 16, "%s/ps2%c", NAMESPACE, dchar[i]); - rc = devmap_device_register(name, &i8042_port[i].dev_handle); + rc = devmap_device_register(name, &i8042_port[i].devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); @@ -218,5 +218,5 @@ ipc_call_t call; ipcarg_t method; - dev_handle_t dh; + devmap_handle_t dh; int retval; int dev_id, i; @@ -230,5 +230,5 @@ dev_id = -1; for (i = 0; i < MAX_DEVS; i++) { - if (i8042_port[i].dev_handle == dh) + if (i8042_port[i].devmap_handle == dh) dev_id = i; } Index: uspace/srv/hw/char/i8042/i8042.h =================================================================== --- uspace/srv/hw/char/i8042/i8042.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hw/char/i8042/i8042.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -52,5 +52,5 @@ /** Softstate structure, one for each serial port (primary and aux). */ typedef struct { - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; int client_phone; } i8042_port_t; Index: uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c =================================================================== --- uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -92,5 +92,5 @@ return -1; - rc = devmap_device_register(NAMESPACE "/" NAME, &uart->dev_handle); + rc = devmap_device_register(NAMESPACE "/" NAME, &uart->devmap_handle); if (rc != EOK) { devmap_hangup_phone(DEVMAP_DRIVER); Index: uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h =================================================================== --- uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -88,5 +88,5 @@ /** Device handle */ - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; } s3c24xx_uart_t; Index: uspace/srv/vfs/vfs.h =================================================================== --- uspace/srv/vfs/vfs.h (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/vfs/vfs.h (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -62,5 +62,5 @@ #define VFS_PAIR \ fs_handle_t fs_handle; \ - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; /** @@ -68,5 +68,5 @@ * doesn't contain any state. For a stateful structure, see vfs_node_t. * - * @note fs_handle, dev_handle and index are meant to be returned in one + * @note fs_handle, devmap_handle and index are meant to be returned in one * IPC reply. */ @@ -182,5 +182,5 @@ extern void vfs_node_put(vfs_node_t *); extern void vfs_node_forget(vfs_node_t *); -extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, dev_handle_t); +extern unsigned vfs_nodes_refcount_sum_get(fs_handle_t, devmap_handle_t); Index: uspace/srv/vfs/vfs_lookup.c =================================================================== --- uspace/srv/vfs/vfs_lookup.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/vfs/vfs_lookup.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -163,5 +163,5 @@ aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (ipcarg_t) first, (ipcarg_t) (first + len - 1) % PLB_SIZE, - (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index, + (ipcarg_t) root->devmap_handle, (ipcarg_t) lflag, (ipcarg_t) index, &answer); @@ -183,5 +183,5 @@ result->triplet.fs_handle = (fs_handle_t) rc; - result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG1(answer); + result->triplet.devmap_handle = (devmap_handle_t) IPC_GET_ARG1(answer); result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer); result->size = @@ -210,5 +210,5 @@ ipc_call_t answer; aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE, - (ipcarg_t) result->triplet.dev_handle, + (ipcarg_t) result->triplet.devmap_handle, (ipcarg_t) result->triplet.index, &answer); Index: uspace/srv/vfs/vfs_node.c =================================================================== --- uspace/srv/vfs/vfs_node.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/vfs/vfs_node.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -113,5 +113,5 @@ unsigned long key[] = { [KEY_FS_HANDLE] = node->fs_handle, - [KEY_DEV_HANDLE] = node->dev_handle, + [KEY_DEV_HANDLE] = node->devmap_handle, [KEY_INDEX] = node->index }; @@ -131,5 +131,5 @@ ipcarg_t rc; rc = async_req_2_0(phone, VFS_OUT_DESTROY, - (ipcarg_t)node->dev_handle, (ipcarg_t)node->index); + (ipcarg_t)node->devmap_handle, (ipcarg_t)node->index); assert(rc == EOK); vfs_release_phone(node->fs_handle, phone); @@ -151,5 +151,5 @@ unsigned long key[] = { [KEY_FS_HANDLE] = node->fs_handle, - [KEY_DEV_HANDLE] = node->dev_handle, + [KEY_DEV_HANDLE] = node->devmap_handle, [KEY_INDEX] = node->index }; @@ -175,5 +175,5 @@ unsigned long key[] = { [KEY_FS_HANDLE] = result->triplet.fs_handle, - [KEY_DEV_HANDLE] = result->triplet.dev_handle, + [KEY_DEV_HANDLE] = result->triplet.devmap_handle, [KEY_INDEX] = result->triplet.index }; @@ -191,5 +191,5 @@ memset(node, 0, sizeof(vfs_node_t)); node->fs_handle = result->triplet.fs_handle; - node->dev_handle = result->triplet.dev_handle; + node->devmap_handle = result->triplet.devmap_handle; node->index = result->triplet.index; node->size = result->size; @@ -243,5 +243,5 @@ vfs_node_t *node = hash_table_get_instance(item, vfs_node_t, nh_link); return (node->fs_handle == (fs_handle_t) key[KEY_FS_HANDLE]) && - (node->dev_handle == key[KEY_DEV_HANDLE]) && + (node->devmap_handle == key[KEY_DEV_HANDLE]) && (node->index == key[KEY_INDEX]); } @@ -255,5 +255,5 @@ unsigned refcnt; fs_handle_t fs_handle; - dev_handle_t dev_handle; + devmap_handle_t devmap_handle; }; @@ -264,15 +264,15 @@ if ((node->fs_handle == rd->fs_handle) && - (node->dev_handle == rd->dev_handle)) + (node->devmap_handle == rd->devmap_handle)) rd->refcnt += node->refcnt; } unsigned -vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, dev_handle_t dev_handle) +vfs_nodes_refcount_sum_get(fs_handle_t fs_handle, devmap_handle_t devmap_handle) { struct refcnt_data rd = { .refcnt = 0, .fs_handle = fs_handle, - .dev_handle = dev_handle + .devmap_handle = devmap_handle }; Index: uspace/srv/vfs/vfs_ops.c =================================================================== --- uspace/srv/vfs/vfs_ops.c (revision 51a268fab894643a3bf8b035bc059e58759a3a53) +++ uspace/srv/vfs/vfs_ops.c (revision 991f645937e5e281d6996ad4623f9ab33c71916d) @@ -55,5 +55,5 @@ /* Forward declarations of static functions. */ -static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, aoff64_t); +static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t, aoff64_t); /** @@ -65,8 +65,8 @@ vfs_pair_t rootfs = { .fs_handle = 0, - .dev_handle = 0 + .devmap_handle = 0 }; -static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle, +static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle, fs_handle_t fs_handle, char *mp, char *opts) { @@ -125,5 +125,5 @@ phone = vfs_grab_phone(fs_handle); msg = async_send_1(phone, VFS_OUT_MOUNTED, - (ipcarg_t) dev_handle, &answer); + (ipcarg_t) devmap_handle, &answer); /* send the mount options */ rc = async_data_write_start(phone, (void *)opts, @@ -150,5 +150,5 @@ mr_res.triplet.fs_handle = fs_handle; - mr_res.triplet.dev_handle = dev_handle; + mr_res.triplet.devmap_handle = devmap_handle; mr_res.triplet.index = rindex; mr_res.size = rsize; @@ -157,5 +157,5 @@ rootfs.fs_handle = fs_handle; - rootfs.dev_handle = dev_handle; + rootfs.devmap_handle = devmap_handle; /* Add reference to the mounted root. */ @@ -187,8 +187,8 @@ phone = vfs_grab_phone(mp_res.triplet.fs_handle); msg = async_send_4(phone, VFS_OUT_MOUNT, - (ipcarg_t) mp_res.triplet.dev_handle, + (ipcarg_t) mp_res.triplet.devmap_handle, (ipcarg_t) mp_res.triplet.index, (ipcarg_t) fs_handle, - (ipcarg_t) dev_handle, &answer); + (ipcarg_t) devmap_handle, &answer); /* send connection */ @@ -229,5 +229,5 @@ mr_res.triplet.fs_handle = fs_handle; - mr_res.triplet.dev_handle = dev_handle; + mr_res.triplet.devmap_handle = devmap_handle; mr_res.triplet.index = rindex; mr_res.size = rsize; @@ -255,5 +255,5 @@ * in the request. */ - dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); + devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); /* @@ -343,5 +343,5 @@ /* Do the mount */ - vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts); + vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts); free(mp); free(fs_name); @@ -402,5 +402,5 @@ */ if (vfs_nodes_refcount_sum_get(mr_node->fs_handle, - mr_node->dev_handle) != 2) { + mr_node->devmap_handle) != 2) { fibril_rwlock_write_unlock(&namespace_rwlock); vfs_node_put(mr_node); @@ -422,5 +422,5 @@ phone = vfs_grab_phone(mr_node->fs_handle); rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED, - mr_node->dev_handle); + mr_node->devmap_handle); vfs_release_phone(mr_node->fs_handle, phone); if (rc != EOK) { @@ -431,5 +431,5 @@ } rootfs.fs_handle = 0; - rootfs.dev_handle = 0; + rootfs.devmap_handle = 0; } else { @@ -458,5 +458,5 @@ phone = vfs_grab_phone(mp_node->fs_handle); - rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->dev_handle, + rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->devmap_handle, mp_node->index); vfs_release_phone(mp_node->fs_handle, phone); @@ -569,5 +569,5 @@ if (node->size) { rc = vfs_truncate_internal(node->fs_handle, - node->dev_handle, node->index, 0); + node->devmap_handle, node->index, 0); if (rc) { fibril_rwlock_write_unlock(&node->contents_rwlock); @@ -626,5 +626,5 @@ lr.triplet.fs_handle = IPC_GET_ARG1(*request); - lr.triplet.dev_handle = IPC_GET_ARG2(*request); + lr.triplet.devmap_handle = IPC_GET_ARG2(*request); lr.triplet.index = IPC_GET_ARG3(*request); int oflag = IPC_GET_ARG4(*request); @@ -647,5 +647,5 @@ if (node->size) { rc = vfs_truncate_internal(node->fs_handle, - node->dev_handle, node->index, 0); + node->devmap_handle, node->index, 0); if (rc) { fibril_rwlock_write_unlock(&node->contents_rwlock); @@ -709,5 +709,5 @@ aid_t msg; ipc_call_t answer; - msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle, + msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle, file->node->index, &answer); @@ -740,5 +740,5 @@ aid_t msg; ipc_call_t answer; - msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle, + msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->devmap_handle, file->node->index, &answer); @@ -838,9 +838,9 @@ rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ, - file->node->dev_handle, file->node->index, file->pos, + file->node->devmap_handle, file->node->index, file->pos, &answer); } else { rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE, - file->node->dev_handle, file->node->index, file->pos, + file->node->devmap_handle, file->node->index, file->pos, &answer); } @@ -961,5 +961,5 @@ } -int vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle, +int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size) { @@ -968,5 +968,5 @@ fs_phone = vfs_grab_phone(fs_handle); - rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) dev_handle, + rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) devmap_handle, (ipcarg_t) index, LOWER32(size), UPPER32(size)); vfs_release_phone(fs_handle, fs_phone); @@ -990,5 +990,5 @@ fibril_rwlock_write_lock(&file->node->contents_rwlock); rc = vfs_truncate_internal(file->node->fs_handle, - file->node->dev_handle, file->node->index, size); + file->node->devmap_handle, file->node->index, size); if (rc == EOK) file->node->size = size; @@ -1022,5 +1022,5 @@ aid_t msg; - msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle, + msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle, file->node->index, true, NULL); ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); @@ -1071,5 +1071,5 @@ int fs_phone = vfs_grab_phone(node->fs_handle); aid_t msg; - msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle, + msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle, node->index, false, NULL); ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); @@ -1245,5 +1245,5 @@ /* Check whether linking to the same file system instance. */ if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) || - (old_node->dev_handle != new_par_lr.triplet.dev_handle)) { + (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) { fibril_rwlock_write_unlock(&namespace_rwlock); ipc_answer_0(rid, EXDEV); /* different file systems */