From 879d9c6b6e1326c1432ad9f1196c3cde682f660d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Axel=20D=C3=B6rfler?= Date: Thu, 12 May 2005 15:43:02 +0000 Subject: [PATCH] Renamed the "blkman" module to "block_io". Also renamed some defines and structures, although the structure and some other names are still odd. This module should probably be moved into the kernel anyway, as it provides basic and crucial services. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@12646 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- headers/os/drivers/{blkman.h => block_io.h} | 66 ++++--- headers/os/drivers/bus/scsi/scsi_periph.h | 8 +- .../kernel/drivers/disk/scsi/scsi_cd/device.c | 12 +- .../drivers/disk/scsi/scsi_cd/scsi_cd.c | 26 +-- .../drivers/disk/scsi/scsi_cd/scsi_cd.h | 6 +- .../drivers/disk/scsi/scsi_cd/scsi_cd_int.h | 5 +- .../drivers/disk/scsi/scsi_dsk/device.c | 17 +- .../drivers/disk/scsi/scsi_dsk/scsi_dsk.c | 22 +-- .../drivers/disk/scsi/scsi_dsk/scsi_dsk_int.h | 6 +- src/add-ons/kernel/generic/block_io/Jamfile | 6 +- .../generic/block_io/KernelExport_ext.h | 40 ---- .../generic/block_io/{blkman.c => block_io.c} | 180 +++++++++--------- .../{blkman_int.h => block_io_private.h} | 60 +++--- src/add-ons/kernel/generic/block_io/io.c | 89 +++++---- .../kernel/generic/block_io/virtual_memory.c | 27 +-- .../kernel/generic/block_io/virtual_memory.h | 19 ++ .../kernel/generic/scsi_periph/device.c | 5 +- .../generic/scsi_periph/error_handling.c | 9 +- .../kernel/generic/scsi_periph/removable.c | 7 +- .../generic/scsi_periph/scsi_periph_int.h | 6 +- 20 files changed, 286 insertions(+), 330 deletions(-) rename headers/os/drivers/{blkman.h => block_io.h} (53%) delete mode 100644 src/add-ons/kernel/generic/block_io/KernelExport_ext.h rename src/add-ons/kernel/generic/block_io/{blkman.c => block_io.c} (72%) rename src/add-ons/kernel/generic/block_io/{blkman_int.h => block_io_private.h} (52%) create mode 100644 src/add-ons/kernel/generic/block_io/virtual_memory.h diff --git a/headers/os/drivers/blkman.h b/headers/os/drivers/block_io.h similarity index 53% rename from headers/os/drivers/blkman.h rename to headers/os/drivers/block_io.h index 5ca8050660..c9e5eaa4f7 100644 --- a/headers/os/drivers/blkman.h +++ b/headers/os/drivers/block_io.h @@ -1,7 +1,9 @@ /* -** Copyright 2002/03, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ + * Copyright 2002/03, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ +#ifndef __BLOCK_IO_H__ +#define __BLOCK_IO_H__ /* Part of Open block device manager @@ -13,19 +15,17 @@ by using a buffer (performance will suffer, though). */ -#ifndef __BLKMAN_H__ -#define __BLKMAN_H__ #include #include -// cookies issued by blkman -typedef struct blkman_device_info *blkman_device; -typedef struct blkman_handle_info *blkman_handle; +// cookies issued by block_io +typedef struct block_io_device_info *block_io_device; +typedef struct block_io_handle_info *block_io_handle; // cookies issued by device driver -typedef struct blkdev_device_cookie *blkdev_device_cookie; -typedef struct blkdev_handle_cookie *blkdev_handle_cookie; +typedef struct block_device_device_cookie *block_device_device_cookie; +typedef struct block_device_handle_cookie *block_device_handle_cookie; // two reason why to use array of size 1: @@ -46,57 +46,55 @@ typedef struct phys_vecs { // attributes: -// type code for block devices -#define BLKDEV_TYPE_NAME "blkdev" // if true, this device may be a BIOS drive (uint8, optional, default: false) -#define BLKDEV_IS_BIOS_DRIVE "blkdev/is_bios_drive" +#define B_BLOCK_DEVICE_IS_BIOS_DRIVE "block_device/is_bios_drive" // address bits that must be 0 - must be 2^i-1 for some i (uint32, optional, default: 0) -#define BLKDEV_DMA_ALIGNMENT "blkdev/dma_alignment" +#define B_BLOCK_DEVICE_DMA_ALIGNMENT "block_device/dma_alignment" // maximum number of blocks per transfer (uint32, optional, default: unlimited) -#define BLKDEV_MAX_BLOCKS_ITEM "blkdev/max_blocks" +#define B_BLOCK_DEVICE_MAX_BLOCKS_ITEM "block_device/max_blocks" // mask of bits that can change in one sg block (uint32, optional, default: ~0) -#define BLKDEV_DMA_BOUNDARY "blkdev/dma_boundary" +#define B_BLOCK_DEVICE_DMA_BOUNDARY "block_device/dma_boundary" // maximum size of one block in scatter/gather list (uint32, optional, default: ~0) -#define BLKDEV_MAX_SG_BLOCK_SIZE "blkdev/max_sg_block_size" +#define B_BLOCK_DEVICE_MAX_SG_BLOCK_SIZE "block_device/max_sg_block_size" // maximum number of scatter/gather blocks (uint32, optional, default: unlimited) -#define BLKDEV_MAX_SG_BLOCKS "blkdev/max_sg_blocks" +#define B_BLOCK_DEVICE_MAX_SG_BLOCKS "block_device/max_sg_blocks" // interface to be provided by device driver -typedef struct blkdev_interface { - driver_module_info dinfo; +typedef struct block_device_interface { + driver_module_info info; // iovecs are physical address here // pos and num_blocks are in blocks; bytes_transferred in bytes // vecs are guaranteed to describe enough data for given block count - status_t (*open)(blkdev_device_cookie device, blkdev_handle_cookie *handle); - status_t (*close)(blkdev_handle_cookie handle); - status_t (*free)(blkdev_handle_cookie handle); + status_t (*open)(block_device_device_cookie device, block_device_handle_cookie *handle); + status_t (*close)(block_device_handle_cookie handle); + status_t (*free)(block_device_handle_cookie handle); - status_t (*read)(blkdev_handle_cookie handle, const phys_vecs *vecs, off_t pos, + status_t (*read)(block_device_handle_cookie handle, const phys_vecs *vecs, off_t pos, size_t num_blocks, uint32 block_size, size_t *bytes_transferred); - status_t (*write)(blkdev_handle_cookie handle, const phys_vecs *vecs, off_t pos, + status_t (*write)(block_device_handle_cookie handle, const phys_vecs *vecs, off_t pos, size_t num_blocks, uint32 block_size, size_t *bytes_transferred); - status_t (*ioctl)(blkdev_handle_cookie handle, int op, void *buf, size_t len); -} blkdev_interface; + status_t (*ioctl)(block_device_handle_cookie handle, int op, void *buf, size_t len); +} block_device_interface; -#define BLKMAN_MODULE_NAME "generic/blkman/v1" +#define B_BLOCK_IO_MODULE_NAME "generic/block_io/v1" // Interface for Drivers // blkman interface used for callbacks done by driver -typedef struct blkman_for_driver_interface { - module_info minfo; +typedef struct block_io_for_driver_interface { + module_info info; // block_size - block size in bytes // ld_block_size - log2( block_size) (set to zero if block_size is not power of two) // capacity - capacity in blocks - void (*set_media_params)(blkman_device device, uint32 block_size, uint32 ld_block_size, + void (*set_media_params)(block_io_device device, uint32 block_size, uint32 ld_block_size, uint64 capacity); -} blkman_for_driver_interface; +} block_io_for_driver_interface; -#define BLKMAN_FOR_DRIVER_MODULE_NAME "generic/blkman/driver/v1" +#define B_BLOCK_IO_FOR_DRIVER_MODULE_NAME "generic/block_io/driver/v1" -#endif +#endif /* __BLOCK_IO_H__ */ diff --git a/headers/os/drivers/bus/scsi/scsi_periph.h b/headers/os/drivers/bus/scsi/scsi_periph.h index 43a0769931..a836a6c895 100644 --- a/headers/os/drivers/bus/scsi/scsi_periph.h +++ b/headers/os/drivers/bus/scsi/scsi_periph.h @@ -1,7 +1,7 @@ /* -** Copyright 2002/03, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ + * Copyright 2002/03, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ /* Part of Open SCSI Peripheral Driver @@ -19,7 +19,7 @@ #define __SCSI_PERIPH_H__ #include -#include +#include #include #include diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/device.c b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/device.c index 94a6d43edc..688d2b0cb2 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/device.c +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/device.c @@ -32,7 +32,7 @@ cd_init_device(device_node_handle node, void *user_cookie, void **cookie) memset(device, 0, sizeof(*device)); - device->blkman_device = user_cookie; + device->block_io_device = user_cookie; device->node = node; res = pnp->get_attr_uint8(node, "removable", @@ -119,7 +119,7 @@ cd_device_added(device_node_handle node) goto err; // get block limit of underlying hardware to lower it (if necessary) - if( pnp->get_attr_uint32( node, BLKDEV_MAX_BLOCKS_ITEM, + if( pnp->get_attr_uint32( node, B_BLOCK_DEVICE_MAX_BLOCKS_ITEM, &max_blocks, true ) != B_OK ) max_blocks = INT_MAX; @@ -140,14 +140,14 @@ cd_device_added(device_node_handle node) { device_attr attrs[] = { { B_DRIVER_MODULE, B_STRING_TYPE, { string: SCSI_CD_MODULE_NAME }}, - // we always want blkman on top of us - { B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { string: BLKMAN_MODULE_NAME }}, - // tell blkman whether the device is removable + { B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { string: B_BLOCK_IO_MODULE_NAME }}, + + // tell block_io whether the device is removable { "removable", B_UINT8_TYPE, { ui8: device_inquiry->RMB }}, // tell which name we want to have in devfs { PNP_DEVFS_FILENAME, B_STRING_TYPE, { string: name }}, // impose own max block restriction - { BLKDEV_MAX_BLOCKS_ITEM, B_UINT32_TYPE, { ui32: max_blocks }}, + { B_BLOCK_DEVICE_MAX_BLOCKS_ITEM, B_UINT32_TYPE, { ui32: max_blocks }}, { NULL } }; status_t res; diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.c b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.c index 83a78fd9ab..9ebc427f4c 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.c +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.c @@ -14,11 +14,11 @@ #include #include -extern blkdev_interface cd_interface; +extern block_device_interface cd_interface; scsi_periph_interface *scsi_periph; device_manager_info *pnp; -blkman_for_driver_interface *blkman; +block_io_for_driver_interface *sBlockIO; #define SCSI_CD_STD_TIMEOUT 10 @@ -663,7 +663,7 @@ cd_set_capacity(cd_device_info *device, uint64 capacity, device->capacity = capacity; device->block_size = block_size; - blkman->set_media_params(device->blkman_device, block_size, + sBlockIO->set_media_params(device->block_io_device, block_size, ld_block_size, capacity); } @@ -699,12 +699,12 @@ std_ops(int32 op, ...) module_dependency module_dependencies[] = { { SCSI_PERIPH_MODULE_NAME, (module_info **)&scsi_periph }, - { BLKMAN_FOR_DRIVER_MODULE_NAME, (module_info **)&blkman }, + { B_BLOCK_IO_FOR_DRIVER_MODULE_NAME, (module_info **)&sBlockIO }, { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&pnp }, {} }; -blkdev_interface scsi_cd_module = { +block_device_interface scsi_cd_module = { { { SCSI_CD_MODULE_NAME, @@ -719,16 +719,16 @@ blkdev_interface scsi_cd_module = { NULL }, - (status_t (*)( blkdev_device_cookie, blkdev_handle_cookie * )) &cd_open, - (status_t (*)( blkdev_handle_cookie )) &cd_close, - (status_t (*)( blkdev_handle_cookie )) &cd_free, + (status_t (*)(block_device_device_cookie, block_device_handle_cookie *))&cd_open, + (status_t (*)(block_device_handle_cookie)) &cd_close, + (status_t (*)(block_device_handle_cookie)) &cd_free, - (status_t (*)( blkdev_handle_cookie, const phys_vecs *, - off_t, size_t, uint32, size_t * )) &cd_read, - (status_t (*)( blkdev_handle_cookie, const phys_vecs *, - off_t, size_t, uint32, size_t * )) &cd_write, + (status_t (*)(block_device_handle_cookie, const phys_vecs *, + off_t, size_t, uint32, size_t *)) &cd_read, + (status_t (*)(block_device_handle_cookie, const phys_vecs *, + off_t, size_t, uint32, size_t *)) &cd_write, - (status_t (*)( blkdev_handle_cookie, int, void *, size_t )) &cd_ioctl, + (status_t (*)(block_device_handle_cookie, int, void *, size_t))&cd_ioctl, }; module_info *modules[] = { diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.h b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.h index b7edd4bc29..f01d0f6ba0 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.h +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.h @@ -1,7 +1,7 @@ /* -** Copyright 2003, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ + * Copyright 2003, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ /* Part of Open SCSI CD Driver diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd_int.h b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd_int.h index 0d8f6dfdf2..7c854db45b 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd_int.h +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd_int.h @@ -10,7 +10,7 @@ #include #include "scsi_cd.h" #include -#include +#include #define debug_level_flow 0 #define debug_level_error 3 @@ -26,7 +26,7 @@ typedef struct cd_device_info { scsi_periph_device scsi_periph_device; scsi_device scsi_device; scsi_device_interface *scsi; - blkman_device blkman_device; + block_io_device block_io_device; uint64 capacity; uint32 block_size; @@ -43,7 +43,6 @@ typedef struct cd_handle_info { extern scsi_periph_interface *scsi_periph; extern device_manager_info *pnp; extern scsi_periph_callbacks callbacks; -extern blkman_for_driver_interface *blkman; // device_mgr.c diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/device.c b/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/device.c index a259513706..5b8d93324d 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/device.c +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/device.c @@ -32,7 +32,7 @@ das_init_device(device_node_handle node, void *user_cookie, void **cookie) memset(device, 0, sizeof(*device)); - device->blkman_device = user_cookie; + device->block_io_device = user_cookie; device->node = node; res = pnp->get_attr_uint8(node, "removable", @@ -92,7 +92,7 @@ das_uninit_device(das_device_info *device) /** called whenever a new device was added to system; * if we really support it, we create a new node that gets - * server by blkdev + * server by the block_io module */ status_t @@ -116,12 +116,12 @@ das_device_added(device_node_handle node) goto err; // get block limit of underlying hardware to lower it (if necessary) - if (pnp->get_attr_uint32(node, BLKDEV_MAX_BLOCKS_ITEM, &max_blocks, true) != B_OK) + if (pnp->get_attr_uint32(node, B_BLOCK_DEVICE_MAX_BLOCKS_ITEM, &max_blocks, true) != B_OK) max_blocks = INT_MAX; // using 10 byte commands, at most 0xffff blocks can be transmitted at once // (sadly, we cannot update this value later on if only 6 byte commands - // are supported, but the blkdev can live with that) + // are supported, but the block_io module can live with that) max_blocks = min(max_blocks, 0xffff); name = scsi_periph->compose_device_name(node, "disk/scsi"); @@ -136,16 +136,15 @@ das_device_added(device_node_handle node) { device_attr attrs[] = { { B_DRIVER_MODULE, B_STRING_TYPE, { string: SCSI_DSK_MODULE_NAME }}, - // we always want blkman on top of us - { B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { string: BLKMAN_MODULE_NAME }}, - // tell blkman whether the device is removable + { B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { string: B_BLOCK_IO_MODULE_NAME }}, + // tell block_io whether the device is removable { "removable", B_UINT8_TYPE, { ui8: device_inquiry->RMB }}, // tell which name we want to have in devfs { PNP_DEVFS_FILENAME, B_STRING_TYPE, { string: name }}, // impose own max block restriction - { BLKDEV_MAX_BLOCKS_ITEM, B_UINT32_TYPE, { ui32: max_blocks }}, + { B_BLOCK_DEVICE_MAX_BLOCKS_ITEM, B_UINT32_TYPE, { ui32: max_blocks }}, // in general, any disk can be a BIOS drive (even ZIP-disks) - { BLKDEV_IS_BIOS_DRIVE, B_UINT8_TYPE, { ui8: 1 }}, + { B_BLOCK_DEVICE_IS_BIOS_DRIVE, B_UINT8_TYPE, { ui8: 1 }}, { NULL } }; diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk.c b/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk.c index 59831a41d2..ca0767e842 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk.c +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk.c @@ -21,11 +21,11 @@ #include -extern blkdev_interface das_interface; +extern block_device_interface das_interface; scsi_periph_interface *scsi_periph; device_manager_info *pnp; -blkman_for_driver_interface *blkman; +block_io_for_driver_interface *gBlockIO; static status_t @@ -161,7 +161,7 @@ das_set_capacity(das_device_info *device, uint64 capacity, device->capacity = capacity; device->block_size = block_size; - blkman->set_media_params(device->blkman_device, block_size, + gBlockIO->set_media_params(device->block_io_device, block_size, ld_block_size, capacity); } @@ -271,12 +271,12 @@ std_ops(int32 op, ...) module_dependency module_dependencies[] = { { SCSI_PERIPH_MODULE_NAME, (module_info **)&scsi_periph }, - { BLKMAN_FOR_DRIVER_MODULE_NAME, (module_info **)&blkman }, + { B_BLOCK_IO_FOR_DRIVER_MODULE_NAME, (module_info **)&gBlockIO }, { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&pnp }, {} }; -blkdev_interface scsi_dsk_module = { +block_device_interface scsi_dsk_module = { { { SCSI_DSK_MODULE_NAME, @@ -293,16 +293,16 @@ blkdev_interface scsi_dsk_module = { das_get_paths, }, - (status_t (*)(blkdev_device_cookie, blkdev_handle_cookie *)) &das_open, - (status_t (*)(blkdev_handle_cookie)) &das_close, - (status_t (*)(blkdev_handle_cookie)) &das_free, + (status_t (*)(block_device_device_cookie, block_device_handle_cookie *))&das_open, + (status_t (*)(block_device_handle_cookie)) &das_close, + (status_t (*)(block_device_handle_cookie)) &das_free, - (status_t (*)(blkdev_handle_cookie, const phys_vecs *, + (status_t (*)(block_device_handle_cookie, const phys_vecs *, off_t, size_t, uint32, size_t *)) &das_read, - (status_t (*)(blkdev_handle_cookie, const phys_vecs *, + (status_t (*)(block_device_handle_cookie, const phys_vecs *, off_t, size_t, uint32, size_t *)) &das_write, - (status_t (*)(blkdev_handle_cookie, int, void *, size_t)) &das_ioctl, + (status_t (*)(block_device_handle_cookie, int, void *, size_t))&das_ioctl, }; #if !_BUILDING_kernel && !BOOT diff --git a/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk_int.h b/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk_int.h index 2312c68fa2..0966e090d3 100644 --- a/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk_int.h +++ b/src/add-ons/kernel/drivers/disk/scsi/scsi_dsk/scsi_dsk_int.h @@ -12,7 +12,7 @@ #include #include "scsi_dsk.h" #include -#include +#include #define debug_level_flow 0 #define debug_level_info 1 @@ -28,7 +28,7 @@ typedef struct das_device_info { scsi_periph_device scsi_periph_device; scsi_device scsi_device; scsi_device_interface *scsi; - blkman_device blkman_device; + block_io_device block_io_device; uint64 capacity; uint32 block_size; @@ -44,7 +44,7 @@ typedef struct das_handle_info { extern scsi_periph_interface *scsi_periph; extern device_manager_info *pnp; extern scsi_periph_callbacks callbacks; -extern blkman_for_driver_interface *blkman; +extern block_io_for_driver_interface *gBlockIO; // device_mgr.c diff --git a/src/add-ons/kernel/generic/block_io/Jamfile b/src/add-ons/kernel/generic/block_io/Jamfile index 54f93d6d41..98ca025711 100644 --- a/src/add-ons/kernel/generic/block_io/Jamfile +++ b/src/add-ons/kernel/generic/block_io/Jamfile @@ -1,4 +1,4 @@ -SubDir OBOS_TOP src add-ons kernel generic blkman ; +SubDir OBOS_TOP src add-ons kernel generic block_io ; UsePrivateHeaders kernel ; UsePrivateHeaders [ FDirName kernel arch $(OBOS_ARCH) ] ; @@ -9,8 +9,8 @@ if $(DEBUG) = 0 { SubDirCcFlags [ FDefines DEBUG_MAX_LEVEL_FLOW=0 DEBUG_MAX_LEVEL_INFO=0 ] ; } -KernelAddon blkman : kernel generic : - blkman.c +KernelAddon block_io : kernel generic : + block_io.c io.c virtual_memory.c ; diff --git a/src/add-ons/kernel/generic/block_io/KernelExport_ext.h b/src/add-ons/kernel/generic/block_io/KernelExport_ext.h deleted file mode 100644 index c8365f90ef..0000000000 --- a/src/add-ons/kernel/generic/block_io/KernelExport_ext.h +++ /dev/null @@ -1,40 +0,0 @@ -/* -** Copyright 2002/03, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ - -/* - Functions that are missing in kernel. -*/ - -#ifndef _KERNEL_EXPORT_EXT_H -#define _KERNEL_EXPORT_EXT_H - -#include -#include - - -// get memory map of iovec -status_t get_iovec_memory_map( - iovec *vec, // iovec to analyze - size_t vec_count, // number of entries in vec - size_t vec_offset, // number of bytes to skip at beginning of vec - size_t len, // number of bytes to analyze - physical_entry *map, // resulting memory map - size_t max_entries, // max number of entries in map - size_t *num_entries, // actual number of map entries used - size_t *mapped_len // actual number of bytes described by map -); - -// map main memory into virtual address space -status_t map_mainmemory( - addr_t physical_addr, // physical address to map - void **virtual_addr // receives corresponding virtual address -); - -// unmap main memory from virtual address space -status_t unmap_mainmemory( - void *virtual_addr // virtual address to release -); - -#endif diff --git a/src/add-ons/kernel/generic/block_io/blkman.c b/src/add-ons/kernel/generic/block_io/block_io.c similarity index 72% rename from src/add-ons/kernel/generic/block_io/blkman.c rename to src/add-ons/kernel/generic/block_io/block_io.c index ae77fd4f0d..ec26005ef6 100644 --- a/src/add-ons/kernel/generic/block_io/blkman.c +++ b/src/add-ons/kernel/generic/block_io/block_io.c @@ -12,7 +12,7 @@ */ -#include "blkman_int.h" +#include "block_io_private.h" #include @@ -24,28 +24,28 @@ #endif -uint blkman_buffer_size; -sem_id blkman_buffer_lock; -struct iovec blkman_buffer_vec[1]; -void *blkman_buffer_phys; -char *blkman_buffer; -phys_vecs blkman_buffer_phys_vec; -area_id blkman_buffer_area; +uint block_io_buffer_size; +sem_id block_io_buffer_lock; +struct iovec block_io_buffer_vec[1]; +void *block_io_buffer_phys; +char *block_io_buffer; +phys_vecs block_io_buffer_phys_vec; +static area_id block_io_buffer_area; locked_pool_interface *locked_pool; device_manager_info *pnp; static status_t -blkman_open(blkman_device_info *device, uint32 flags, - blkman_handle_info **res_handle) +block_io_open(block_io_device_info *device, uint32 flags, + block_io_handle_info **res_handle) { - blkman_handle_info *handle; + block_io_handle_info *handle; status_t res; - TRACE(("blkman_open()\n")); + TRACE(("block_io_open()\n")); - handle = (blkman_handle_info *)malloc(sizeof(*handle)); + handle = (block_io_handle_info *)malloc(sizeof(*handle)); if (handle == NULL) return B_NO_MEMORY; @@ -69,11 +69,11 @@ err: static status_t -blkman_close(blkman_handle_info *handle) +block_io_close(block_io_handle_info *handle) { - blkman_device_info *device = handle->device; + block_io_device_info *device = handle->device; - TRACE(("blkman_close()\n")); + TRACE(("block_io_close()\n")); device->interface->close(handle->cookie); return B_OK; @@ -81,11 +81,11 @@ blkman_close(blkman_handle_info *handle) static status_t -blkman_freecookie(blkman_handle_info *handle) +block_io_freecookie(block_io_handle_info *handle) { - blkman_device_info *device = handle->device; + block_io_device_info *device = handle->device; - TRACE(("blkman_freecookie()\n")); + TRACE(("block_io_freecookie()\n")); device->interface->free(handle->cookie); free(handle); @@ -101,7 +101,7 @@ blkman_freecookie(blkman_handle_info *handle) */ static status_t -verify_checksum(blkman_handle_info *handle, uint64 offset, uint32 len, uint32 chksum) +verify_checksum(block_io_handle_info *handle, uint64 offset, uint32 len, uint32 chksum) { void *buffer; uint32 readlen; @@ -115,7 +115,7 @@ verify_checksum(blkman_handle_info *handle, uint64 offset, uint32 len, uint32 ch readlen = len; - res = blkman_read(handle, offset, buffer, &readlen); + res = block_io_read(handle, offset, buffer, &readlen); if (res < B_OK || readlen < len) goto err; @@ -138,10 +138,10 @@ err: /** store BIOS drive id in node's attribute */ static status_t -store_bios_drive_in_node(blkman_device_info *device) +store_bios_drive_in_node(block_io_device_info *device) { device_attr attribute = { - BLKDEV_BIOS_ID, B_UINT8_TYPE, { ui8: + B_BLOCK_DEVICE_BIOS_ID, B_UINT8_TYPE, { ui8: device->bios_drive != NULL ? device->bios_drive->bios_id : 0 } }; @@ -153,15 +153,15 @@ store_bios_drive_in_node(blkman_device_info *device) * this must be called whenever someone wants to access BIOS infos about the drive; * there are two reasons to not call this during probe(): * - perhaps nobody is interested in BIOS info - * - we need a working blkman device to handle lower level driver + * - we need a working block_io device to handle lower level driver * restrictions, so this method can only be safely called once the * node has been loaded */ static void -find_bios_drive_info(blkman_handle_info *handle) +find_bios_drive_info(block_io_handle_info *handle) { - blkman_device_info *device = handle->device; + block_io_device_info *device = handle->device; bios_drive *drive = NULL; //, *colliding_drive; char name[32]; uint8 bios_id; @@ -174,7 +174,7 @@ find_bios_drive_info(blkman_handle_info *handle) // check whether BIOS info was found during one of the previous // loads - if (pnp->get_attr_uint8(device->node, BLKDEV_BIOS_ID, &bios_id, false) == B_OK) { + if (pnp->get_attr_uint8(device->node, B_BLOCK_DEVICE_BIOS_ID, &bios_id, false) == B_OK) { TRACE(("use previous BIOS ID 0x%x\n", bios_id)); // ToDo: this assumes private R5 kernel functions to be present @@ -287,9 +287,9 @@ no_bios_drive: static status_t -blkman_ioctl(blkman_handle_info *handle, uint32 op, void *buf, size_t len) +block_io_ioctl(block_io_handle_info *handle, uint32 op, void *buf, size_t len) { - blkman_device_info *device = handle->device; + block_io_device_info *device = handle->device; status_t res; if (device->is_bios_drive) { @@ -340,17 +340,17 @@ blkman_ioctl(blkman_handle_info *handle, uint32 op, void *buf, size_t len) static status_t -blkman_register_device(device_node_handle parent) +block_io_register_device(device_node_handle parent) { - TRACE(("blkman_probe()\n")); + TRACE(("block_io_register_device()\n")); // ready to register at devfs { device_attr attrs[] = { - { B_DRIVER_MODULE, B_STRING_TYPE, { string: BLKMAN_MODULE_NAME }}, - // we always want devfs on top of us + { B_DRIVER_MODULE, B_STRING_TYPE, { string: B_BLOCK_IO_MODULE_NAME }}, + { PNP_DRIVER_CONNECTION, B_STRING_TYPE, { string: "block_io" }}, + { B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { string: PNP_DEVFS_MODULE_NAME }}, - { PNP_DRIVER_CONNECTION, B_STRING_TYPE, { string: "blkman" }}, { NULL } }; @@ -362,13 +362,13 @@ blkman_register_device(device_node_handle parent) static void -blkman_remove(device_node_handle node, void *cookie) +block_io_remove(device_node_handle node, void *cookie) { uint8 bios_id; //bios_drive *drive; // if this drive has a BIOS ID, remove it from BIOS drive list - if (pnp->get_attr_uint8(node, BLKDEV_BIOS_ID, &bios_id, false) != B_OK + if (pnp->get_attr_uint8(node, B_BLOCK_DEVICE_BIOS_ID, &bios_id, false) != B_OK || bios_id == 0 ) return; @@ -388,26 +388,26 @@ blkman_remove(device_node_handle node, void *cookie) static status_t -blkman_init_device(device_node_handle node, void *user_cookie, void **cookie) +block_io_init_device(device_node_handle node, void *user_cookie, void **cookie) { - blkman_device_info *device; - blkdev_params params; + block_io_device_info *device; + block_device_params params; char *name, *tmp_name; uint8 is_bios_drive; status_t res; - TRACE(("blkman_init_device()\n")); + TRACE(("block_io_init_device()\n")); // extract controller/protocoll restrictions from node - if (pnp->get_attr_uint32(node, BLKDEV_DMA_ALIGNMENT, ¶ms.alignment, true) != B_OK) + if (pnp->get_attr_uint32(node, B_BLOCK_DEVICE_DMA_ALIGNMENT, ¶ms.alignment, true) != B_OK) params.alignment = 0; - if (pnp->get_attr_uint32(node, BLKDEV_MAX_BLOCKS_ITEM, ¶ms.max_blocks, true) != B_OK) + if (pnp->get_attr_uint32(node, B_BLOCK_DEVICE_MAX_BLOCKS_ITEM, ¶ms.max_blocks, true) != B_OK) params.max_blocks = 0xffffffff; - if (pnp->get_attr_uint32(node, BLKDEV_DMA_BOUNDARY, ¶ms.dma_boundary, true) != B_OK) + if (pnp->get_attr_uint32(node, B_BLOCK_DEVICE_DMA_BOUNDARY, ¶ms.dma_boundary, true) != B_OK) params.dma_boundary = ~0; - if (pnp->get_attr_uint32(node, BLKDEV_MAX_SG_BLOCK_SIZE, ¶ms.max_sg_block_size, true) != B_OK) + if (pnp->get_attr_uint32(node, B_BLOCK_DEVICE_MAX_SG_BLOCK_SIZE, ¶ms.max_sg_block_size, true) != B_OK) params.max_sg_block_size = 0xffffffff; - if (pnp->get_attr_uint32(node, BLKDEV_MAX_SG_BLOCKS, ¶ms.max_sg_blocks, true) != B_OK) + if (pnp->get_attr_uint32(node, B_BLOCK_DEVICE_MAX_SG_BLOCKS, ¶ms.max_sg_blocks, true) != B_OK) params.max_sg_blocks = ~0; // do some sanity check: @@ -439,7 +439,7 @@ blkman_init_device(device_node_handle node, void *user_cookie, void **cookie) // (they consume 4KB and can describe up to 2MB virtual cont. memory!) params.max_sg_blocks = min(params.max_sg_blocks, 512); - if (pnp->get_attr_uint8(node, BLKDEV_IS_BIOS_DRIVE, &is_bios_drive, true) != B_OK) + if (pnp->get_attr_uint8(node, B_BLOCK_DEVICE_IS_BIOS_DRIVE, &is_bios_drive, true) != B_OK) is_bios_drive = false; // we don't really care about /dev name, but if it is @@ -449,7 +449,7 @@ blkman_init_device(device_node_handle node, void *user_cookie, void **cookie) return B_ERROR; } - device = (blkman_device_info *)malloc(sizeof(*device)); + device = (block_io_device_info *)malloc(sizeof(*device)); if (device == NULL) { res = B_NO_MEMORY; goto err1; @@ -459,7 +459,7 @@ blkman_init_device(device_node_handle node, void *user_cookie, void **cookie) device->node = node; - res = benaphore_init(&device->lock, "blkdev_mutex"); + res = benaphore_init(&device->lock, "block_device_mutex"); if (res < 0) goto err2; @@ -517,7 +517,7 @@ err1: static status_t -blkman_uninit_device(blkman_device_info *device) +block_io_uninit_device(block_io_device_info *device) { pnp->uninit_driver(pnp->get_parent(device->node)); @@ -530,54 +530,54 @@ blkman_uninit_device(blkman_device_info *device) static status_t -blkman_init_buffer(void) +block_io_init_buffer(void) { physical_entry physicalTable[2]; status_t res; - TRACE(("blkman_init_buffer()\n")); + TRACE(("block_io_init_buffer()\n")); - blkman_buffer_size = 32*1024; + block_io_buffer_size = 32*1024; - blkman_buffer_lock = create_sem(1, "blkman_buffer_mutex"); - if (blkman_buffer_lock < 0) { - res = blkman_buffer_lock; + block_io_buffer_lock = create_sem(1, "block_io_buffer_mutex"); + if (block_io_buffer_lock < 0) { + res = block_io_buffer_lock; goto err1; } - res = blkman_buffer_area = create_area("blkman_buffer", - (void **)&blkman_buffer, B_ANY_KERNEL_ADDRESS, - blkman_buffer_size, B_FULL_LOCK | B_CONTIGUOUS, B_READ_AREA | B_WRITE_AREA); + res = block_io_buffer_area = create_area("block_io_buffer", + (void **)&block_io_buffer, B_ANY_KERNEL_ADDRESS, + block_io_buffer_size, B_FULL_LOCK | B_CONTIGUOUS, B_READ_AREA | B_WRITE_AREA); if (res < 0) goto err2; - res = get_memory_map(blkman_buffer, blkman_buffer_size, physicalTable, 2); + res = get_memory_map(block_io_buffer, block_io_buffer_size, physicalTable, 2); if (res < 0) goto err3; - blkman_buffer_vec[0].iov_base = blkman_buffer; - blkman_buffer_vec[0].iov_len = blkman_buffer_size; + block_io_buffer_vec[0].iov_base = block_io_buffer; + block_io_buffer_vec[0].iov_len = block_io_buffer_size; - blkman_buffer_phys_vec.num = 1; - blkman_buffer_phys_vec.total_len = blkman_buffer_size; - blkman_buffer_phys_vec.vec[0] = physicalTable[0]; + block_io_buffer_phys_vec.num = 1; + block_io_buffer_phys_vec.total_len = block_io_buffer_size; + block_io_buffer_phys_vec.vec[0] = physicalTable[0]; return B_OK; err3: - delete_area(blkman_buffer_area); + delete_area(block_io_buffer_area); err2: - delete_sem(blkman_buffer_lock); + delete_sem(block_io_buffer_lock); err1: return res; } static status_t -blkman_uninit_buffer(void) +block_io_uninit_buffer(void) { - delete_area(blkman_buffer_area); - delete_sem(blkman_buffer_lock); + delete_area(block_io_buffer_area); + delete_sem(block_io_buffer_lock); return B_OK; } @@ -588,9 +588,9 @@ std_ops(int32 op, ...) { switch (op) { case B_MODULE_INIT: - return blkman_init_buffer(); + return block_io_init_buffer(); case B_MODULE_UNINIT: - blkman_uninit_buffer(); + block_io_uninit_buffer(); return B_OK; default: @@ -606,38 +606,38 @@ module_dependency module_dependencies[] = { }; -pnp_devfs_driver_info blkman_module = { +pnp_devfs_driver_info block_io_module = { { { - BLKMAN_MODULE_NAME, + B_BLOCK_IO_MODULE_NAME, 0, std_ops }, NULL, // supports device - blkman_register_device, - blkman_init_device, - (status_t (*)( void * )) blkman_uninit_device, - blkman_remove, + block_io_register_device, + block_io_init_device, + (status_t (*)( void * )) block_io_uninit_device, + block_io_remove, NULL, // cleanup NULL, // get paths }, - (status_t (*)(void *, uint32, void **))blkman_open, - (status_t (*)(void *))blkman_close, - (status_t (*)(void *))blkman_freecookie, + (status_t (*)(void *, uint32, void **))block_io_open, + (status_t (*)(void *))block_io_close, + (status_t (*)(void *))block_io_freecookie, - (status_t (*)(void *, uint32, void *, size_t))blkman_ioctl, + (status_t (*)(void *, uint32, void *, size_t))block_io_ioctl, - (status_t (*)(void *, off_t, void *, size_t *))blkman_read, - (status_t (*)(void *, off_t, const void *, size_t *))blkman_write, + (status_t (*)(void *, off_t, void *, size_t *))block_io_read, + (status_t (*)(void *, off_t, const void *, size_t *))block_io_write, NULL, NULL, - (status_t (*)(void *, off_t, const iovec *, size_t, size_t *))blkman_readv, - (status_t (*)(void *, off_t, const iovec *, size_t, size_t *))blkman_writev + (status_t (*)(void *, off_t, const iovec *, size_t, size_t *))block_io_readv, + (status_t (*)(void *, off_t, const iovec *, size_t, size_t *))block_io_writev }; @@ -657,19 +657,19 @@ std_ops_for_driver(int32 op, ...) } -blkman_for_driver_interface blkman_for_driver_module = { +block_io_for_driver_interface block_io_for_driver_module = { { - BLKMAN_FOR_DRIVER_MODULE_NAME, + B_BLOCK_IO_FOR_DRIVER_MODULE_NAME, 0, std_ops_for_driver }, - blkman_set_media_params, + block_io_set_media_params, }; module_info *modules[] = { - &blkman_module.info.info, - &blkman_for_driver_module.minfo, + &block_io_module.info.info, + &block_io_for_driver_module.info, NULL }; diff --git a/src/add-ons/kernel/generic/block_io/blkman_int.h b/src/add-ons/kernel/generic/block_io/block_io_private.h similarity index 52% rename from src/add-ons/kernel/generic/block_io/blkman_int.h rename to src/add-ons/kernel/generic/block_io/block_io_private.h index 60f4265c83..3eb1ee94dc 100644 --- a/src/add-ons/kernel/generic/block_io/blkman_int.h +++ b/src/add-ons/kernel/generic/block_io/block_io_private.h @@ -9,70 +9,72 @@ Internal header. */ -#include -#include +#include #include #include -#include #include #include -#include + +#include +#include + +#include "bios_drive.h" #include "wrapper.h" -// controller restrictions (see blkman.h) -typedef struct blkdev_params { +// controller restrictions (see block_io.h) +typedef struct block_device_params { uint32 alignment; uint32 max_blocks; uint32 dma_boundary; uint32 max_sg_block_size; uint32 max_sg_blocks; -} blkdev_params; +} block_device_params; // device info -typedef struct blkman_device_info { +typedef struct block_io_device_info { device_node_handle node; - blkdev_interface *interface; - blkdev_device_cookie cookie; + block_device_interface *interface; + block_device_device_cookie cookie; benaphore lock; // used for access to following variables uint32 block_size; uint32 ld_block_size; uint64 capacity; - blkdev_params params; + block_device_params params; bool is_bios_drive; // could be a BIOS drive locked_pool_cookie phys_vecs_pool; // pool of temporary phys_vecs bios_drive *bios_drive; // info about corresponding BIOS drive -} blkman_device_info; +} block_io_device_info; // file handle info -typedef struct blkman_handle_info { - blkman_device_info *device; - blkdev_handle_cookie cookie; -} blkman_handle_info; +typedef struct block_io_handle_info { + block_io_device_info *device; + block_device_handle_cookie cookie; +} block_io_handle_info; // attribute containing BIOS drive ID (or 0, if it's no BIOS drive) (uint8) -#define BLKDEV_BIOS_ID "blkdev/bios_id" +#define B_BLOCK_DEVICE_BIOS_ID "blkdev/bios_id" // transmission buffer data: // size in bytes -extern uint blkman_buffer_size; +extern uint block_io_buffer_size; // to use the buffer, you must own this semaphore -extern sem_id blkman_buffer_lock; +extern sem_id block_io_buffer_lock; // iovec -extern struct iovec blkman_buffer_vec[1]; +extern struct iovec block_io_buffer_vec[1]; // physical address -extern void *blkman_buffer_phys; +extern void *block_io_buffer_phys; // virtual address -extern char *blkman_buffer; +extern char *block_io_buffer; // phys_vec of it (always linear) -extern phys_vecs blkman_buffer_phys_vec; +extern phys_vecs block_io_buffer_phys_vec; // area containing buffer -extern area_id blkman_buffer_area; +extern area_id block_io_buffer_area; extern locked_pool_interface *locked_pool; extern device_manager_info *pnp; @@ -80,11 +82,11 @@ extern device_manager_info *pnp; // io.c -status_t blkman_readv(blkman_handle_info *handle, off_t pos, struct iovec *vec, +status_t block_io_readv(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, size_t *len); -status_t blkman_read(blkman_handle_info *handle, off_t pos, void *buf, size_t *len); -ssize_t blkman_writev(blkman_handle_info *handle, off_t pos, struct iovec *vec, +status_t block_io_read(block_io_handle_info *handle, off_t pos, void *buf, size_t *len); +ssize_t block_io_writev(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, ssize_t *len); -ssize_t blkman_write(blkman_handle_info *handle, off_t pos, void *buf, size_t *len); -void blkman_set_media_params(blkman_device_info *device, +ssize_t block_io_write(block_io_handle_info *handle, off_t pos, void *buf, size_t *len); +void block_io_set_media_params(block_io_device_info *device, uint32 block_size, uint32 ld_block_size, uint64 capacity); diff --git a/src/add-ons/kernel/generic/block_io/io.c b/src/add-ons/kernel/generic/block_io/io.c index 11a1108b0b..749a76b800 100644 --- a/src/add-ons/kernel/generic/block_io/io.c +++ b/src/add-ons/kernel/generic/block_io/io.c @@ -29,9 +29,8 @@ */ -#include "blkman_int.h" -#include "KernelExport_ext.h" -#include +#include "block_io_private.h" +#include "virtual_memory.h" /** get sg list of iovecs, taking dma boundaries and maximum size of @@ -40,7 +39,7 @@ */ static int -blkman_map_iovecs(iovec *vec, size_t vec_count, size_t vec_offset, size_t len, +block_io_map_iovecs(iovec *vec, size_t vec_count, size_t vec_offset, size_t len, phys_vecs *map, size_t max_phys_entries, size_t dma_boundary, size_t max_sg_block_size) { @@ -104,7 +103,7 @@ blkman_map_iovecs(iovec *vec, size_t vec_count, size_t vec_offset, size_t len, */ static bool -blkman_check_alignment(struct iovec *vecs, uint num_vecs, +block_io_check_alignment(struct iovec *vecs, uint num_vecs, size_t vec_offset, uint alignment) { if (alignment == 0) @@ -138,7 +137,7 @@ blkman_check_alignment(struct iovec *vecs, uint num_vecs, */ static size_t -blkman_lock_iovecs(struct iovec *vecs, uint num_vecs, +block_io_lock_iovecs(struct iovec *vecs, uint num_vecs, size_t vec_offset, size_t len, int flags) { size_t orig_len = len; @@ -172,7 +171,7 @@ blkman_lock_iovecs(struct iovec *vecs, uint num_vecs, /** unlock iovecs */ static void -blkman_unlock_iovecs(struct iovec *vecs, uint num_vecs, +block_io_unlock_iovecs(struct iovec *vecs, uint num_vecs, size_t vec_offset, size_t len, int flags) { SHOW_FLOW(3, "len = %lu", len); @@ -197,7 +196,7 @@ blkman_unlock_iovecs(struct iovec *vecs, uint num_vecs, */ static void -blkman_copy_buffer(char *buffer, struct iovec *vecs, uint num_vecs, +block_io_copy_buffer(char *buffer, struct iovec *vecs, uint num_vecs, size_t vec_offset, size_t len, bool to_buffer) { for (; len > 0 && num_vecs > 0; ++vecs, --num_vecs) { @@ -219,7 +218,7 @@ blkman_copy_buffer(char *buffer, struct iovec *vecs, uint num_vecs, /** determine number of bytes described by iovecs */ static size_t -blkman_iovec_len(struct iovec *vecs, uint num_vecs, size_t vec_offset) +block_io_iovec_len(struct iovec *vecs, uint num_vecs, size_t vec_offset) { size_t len = 0; @@ -240,10 +239,10 @@ blkman_iovec_len(struct iovec *vecs, uint num_vecs, size_t vec_offset) */ static inline status_t -blkman_readwrite(blkman_handle_info *handle, off_t pos, struct iovec *vec, +block_io_readwrite(block_io_handle_info *handle, off_t pos, struct iovec *vec, int vec_count, size_t *total_len, bool need_locking, bool write) { - blkman_device_info *device = handle->device; + block_io_device_info *device = handle->device; uint32 block_size, ld_block_size; uint64 capacity; bool need_buffer; @@ -355,7 +354,7 @@ blkman_readwrite(blkman_handle_info *handle, off_t pos, struct iovec *vec, // you deserve) need_buffer = block_ofs != 0 || len < block_size - || !blkman_check_alignment(vec, vec_count, vec_offset, device->params.alignment); + || !block_io_check_alignment(vec, vec_count, vec_offset, device->params.alignment); retry: if (need_buffer) { @@ -365,7 +364,7 @@ retry: SHOW_FLOW(1, "buffer required: len=%ld, block_ofs=%ld", len, block_ofs); - acquire_sem(blkman_buffer_lock); + acquire_sem(block_io_buffer_lock); // nobody helps us if there are too few iovecs, so test // for that explicitely @@ -373,7 +372,7 @@ retry: // we would get trouble when we try to round up to next // block size, which would lead to zero, making trouble // during lock) - tmp_len = blkman_iovec_len(vec, vec_count, vec_offset); + tmp_len = block_io_iovec_len(vec, vec_count, vec_offset); tmp_len = min(tmp_len, len); SHOW_FLOW(3, "tmp_len: %lu", tmp_len); @@ -385,7 +384,7 @@ retry: SHOW_FLOW0(3, "partial write at beginning: reading content of first block"); res = device->interface->read(handle->cookie, - &blkman_buffer_phys_vec, block_pos, + &block_io_buffer_phys_vec, block_pos, cur_blocks, block_size, &bytes_transferred); } else { // alignment problem or partial block read - find out how many @@ -395,8 +394,8 @@ retry: SHOW_FLOW(3, "cur_blocks: %ld", cur_blocks); // restrict block count to buffer size - if (cur_blocks * block_size > blkman_buffer_size) - cur_blocks = blkman_buffer_size / block_size; + if (cur_blocks * block_size > block_io_buffer_size) + cur_blocks = block_io_buffer_size / block_size; } // copy data into buffer before write @@ -404,12 +403,12 @@ retry: if (write) { SHOW_FLOW(3, "copy data to buffer (%ld bytes)", cur_blocks * block_size - block_ofs); - blkman_copy_buffer(blkman_buffer + block_ofs, + block_io_copy_buffer(block_io_buffer + block_ofs, vec, vec_count, vec_offset, cur_blocks * block_size - block_ofs, true); } - cur_vecs = blkman_buffer_vec; + cur_vecs = block_io_buffer_vec; cur_vec_count = 1; cur_vec_offset = 0; } else { @@ -449,7 +448,7 @@ retry: SHOW_FLOW(3, "trying to lock %lu bytes", cur_len); - locked_len = blkman_lock_iovecs(cur_vecs, cur_vec_count, + locked_len = block_io_lock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, cur_len, B_DMA_IO | (write ? 0 : B_READ_DEVICE)); if (locked_len == cur_len) @@ -469,7 +468,7 @@ retry: // got less then one block locked - unlock and retry SHOW_FLOW0(3, "too few bytes locked - trying again with fewer bytes"); - blkman_unlock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, locked_len, + block_io_unlock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, locked_len, B_DMA_IO | (write ? 0 : B_READ_DEVICE)); } @@ -495,7 +494,7 @@ retry: // time to setup sg list SHOW_FLOW0(3, "Creating SG list"); - res = blkman_map_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, cur_len, + res = block_io_map_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, cur_len, phys_vecs, device->params.max_sg_blocks, device->params.dma_boundary, device->params.max_sg_block_size); @@ -515,7 +514,7 @@ retry: SHOW_FLOW0(3, "SG too small to handle even one block"); if (need_locking) { - blkman_unlock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, + block_io_unlock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, cur_len, B_DMA_IO | (write ? 0 : B_READ_DEVICE)); } @@ -553,7 +552,7 @@ retry: cannot_map: // unlock data if (need_locking) { - blkman_unlock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, + block_io_unlock_iovecs(cur_vecs, cur_vec_count, cur_vec_offset, cur_len, B_DMA_IO | (write ? 0 : B_READ_DEVICE)); } @@ -572,11 +571,11 @@ cannot_map: if (!write) { SHOW_FLOW(3, "copying data back from buffer (%ld bytes)", bytes_transferred); - blkman_copy_buffer(blkman_buffer + block_ofs, + block_io_copy_buffer(block_io_buffer + block_ofs, vec, vec_count, vec_offset, bytes_transferred, false); } - release_sem(blkman_buffer_lock); + release_sem(block_io_buffer_lock); } len -= bytes_transferred; @@ -592,7 +591,7 @@ cannot_map: err3: if (need_buffer) - release_sem(blkman_buffer_lock); + release_sem(block_io_buffer_lock); err2: locked_pool->free(device->phys_vecs_pool, phys_vecs); err: @@ -605,18 +604,18 @@ err: static status_t -blkman_readv_int(blkman_handle_info *handle, off_t pos, struct iovec *vec, +block_io_readv_int(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, size_t *len, bool need_locking) { - return blkman_readwrite(handle, pos, vec, vec_count, len, need_locking, false); + return block_io_readwrite(handle, pos, vec, vec_count, len, need_locking, false); } static status_t -blkman_writev_int(blkman_handle_info *handle, off_t pos, struct iovec *vec, +block_io_writev_int(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, size_t *len, bool need_locking) { - return blkman_readwrite(handle, pos, vec, vec_count, len, need_locking, true); + return block_io_readwrite(handle, pos, vec, vec_count, len, need_locking, true); } @@ -626,7 +625,7 @@ blkman_writev_int(blkman_handle_info *handle, off_t pos, struct iovec *vec, */ static inline status_t -blkman_readwritev(blkman_handle_info *handle, off_t pos, struct iovec *vec, +block_io_readwritev(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, size_t *len, bool write) { @@ -649,9 +648,9 @@ blkman_readwritev(blkman_handle_info *handle, off_t pos, struct iovec *vec, *len = total_len; if (write) - res = blkman_writev_int(handle, pos, vec, vec_count, len, true); + res = block_io_writev_int(handle, pos, vec, vec_count, len, true); else - res = blkman_readv_int(handle, pos, vec, vec_count, len, true); + res = block_io_readv_int(handle, pos, vec, vec_count, len, true); unlock_memory(vec, vec_count * sizeof(vec[0]), 0); @@ -660,7 +659,7 @@ blkman_readwritev(blkman_handle_info *handle, off_t pos, struct iovec *vec, status_t -blkman_readv(blkman_handle_info *handle, off_t pos, struct iovec *vec, +block_io_readv(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, size_t *len) { /* SHOW_FLOW( 4, "len=%d", (int)*len ); @@ -670,12 +669,12 @@ blkman_readv(blkman_handle_info *handle, off_t pos, struct iovec *vec, (int)cur_vec->iov_base, (int)cur_vec->iov_len ); }*/ - return blkman_readwritev(handle, pos, vec, vec_count, len, false); + return block_io_readwritev(handle, pos, vec, vec_count, len, false); } status_t -blkman_read(blkman_handle_info *handle, off_t pos, void *buf, size_t *len) +block_io_read(block_io_handle_info *handle, off_t pos, void *buf, size_t *len) { iovec vec[1]; @@ -685,37 +684,37 @@ blkman_read(blkman_handle_info *handle, off_t pos, void *buf, size_t *len) SHOW_FLOW0( 3, "" ); // This assumes that the thread stack is not paged, - // else you want to use blkman_readv + // else you want to use block_io_readv // But this is not a problem, since kernel stacks // are always paged in (since they can be used by // an interrupt at any time) - return blkman_readv_int(handle, pos, vec, 1, len, true); + return block_io_readv_int(handle, pos, vec, 1, len, true); } ssize_t -blkman_writev(blkman_handle_info *handle, off_t pos, struct iovec *vec, +block_io_writev(block_io_handle_info *handle, off_t pos, struct iovec *vec, size_t vec_count, ssize_t *len) { - return blkman_readwritev(handle, pos, vec, vec_count, len, true); + return block_io_readwritev(handle, pos, vec, vec_count, len, true); } ssize_t -blkman_write(blkman_handle_info *handle, off_t pos, void *buf, size_t *len) +block_io_write(block_io_handle_info *handle, off_t pos, void *buf, size_t *len) { iovec vec[1]; vec[0].iov_base = buf; vec[0].iov_len = *len; - // see blkman_read - return blkman_writev_int(handle, pos, vec, 1, len, true); + // see block_io_read + return block_io_writev_int(handle, pos, vec, 1, len, true); } void -blkman_set_media_params(blkman_device_info *device, uint32 block_size, +block_io_set_media_params(block_io_device_info *device, uint32 block_size, uint32 ld_block_size, uint64 capacity) { SHOW_FLOW(3, "block_size = %lu, ld_block_size = %lu, capacity = %Lu\n", block_size, diff --git a/src/add-ons/kernel/generic/block_io/virtual_memory.c b/src/add-ons/kernel/generic/block_io/virtual_memory.c index 0a18b3d3df..35d5a6fd2c 100644 --- a/src/add-ons/kernel/generic/block_io/virtual_memory.c +++ b/src/add-ons/kernel/generic/block_io/virtual_memory.c @@ -1,7 +1,7 @@ /* -** Copyright 2002/03, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ + * Copyright 2002/03, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ /* VM helper functions. @@ -11,7 +11,7 @@ list of length one. */ -#include "KernelExport_ext.h" +#include "virtual_memory.h" #include "wrapper.h" #include @@ -118,22 +118,3 @@ get_iovec_memory_map(iovec *vec, size_t vec_count, size_t vec_offset, size_t len return B_OK; } - -/** map main memory into virtual address space */ - -status_t -map_mainmemory(addr_t physicalAddress, void **_virtualAddress) -{ - return vm_get_physical_page(physicalAddress, (addr_t *)_virtualAddress, PHYSICAL_PAGE_CAN_WAIT); - // ToDo: check if CAN_WAIT is correct -} - - -/** unmap main memory from virtual address space */ - -status_t -unmap_mainmemory(void *virtualAddress) -{ - return vm_put_physical_page((addr_t)virtualAddress); -} - diff --git a/src/add-ons/kernel/generic/block_io/virtual_memory.h b/src/add-ons/kernel/generic/block_io/virtual_memory.h new file mode 100644 index 0000000000..8115e12d4b --- /dev/null +++ b/src/add-ons/kernel/generic/block_io/virtual_memory.h @@ -0,0 +1,19 @@ +/* + * Copyright 2002/03, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ +#ifndef _VIRTUAL_MEMORY_H +#define _VIRTUAL_MEMORY_H + + +#include +#include + + +// get memory map of iovec +extern status_t get_iovec_memory_map(iovec *vec, size_t vecCount, + size_t vecOffset, size_t length, physical_entry *map, + size_t maxMapEntries, size_t *_numEntries, + size_t *_mappedLength); + +#endif /* _VIRTUAL_MEMORY_H */ diff --git a/src/add-ons/kernel/generic/scsi_periph/device.c b/src/add-ons/kernel/generic/scsi_periph/device.c index ab8bb1cb00..3db15cf67b 100644 --- a/src/add-ons/kernel/generic/scsi_periph/device.c +++ b/src/add-ons/kernel/generic/scsi_periph/device.c @@ -12,11 +12,10 @@ #include "scsi_periph_int.h" -#include - #include #include -#include +#include + #define SCSI_PERIPH_STD_TIMEOUT 10 diff --git a/src/add-ons/kernel/generic/scsi_periph/error_handling.c b/src/add-ons/kernel/generic/scsi_periph/error_handling.c index 116e6fcb36..93bba7234a 100644 --- a/src/add-ons/kernel/generic/scsi_periph/error_handling.c +++ b/src/add-ons/kernel/generic/scsi_periph/error_handling.c @@ -1,7 +1,7 @@ /* -** Copyright 2002/03, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ + * Copyright 2002/03, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ /* Part of Open SCSI Peripheral Driver @@ -9,9 +9,8 @@ Error handling */ -#include "scsi_periph_int.h" -#include +#include "scsi_periph_int.h" /** decode sense data and generate error code */ diff --git a/src/add-ons/kernel/generic/scsi_periph/removable.c b/src/add-ons/kernel/generic/scsi_periph/removable.c index 2d6209fb1f..dc1e2e07a3 100644 --- a/src/add-ons/kernel/generic/scsi_periph/removable.c +++ b/src/add-ons/kernel/generic/scsi_periph/removable.c @@ -1,7 +1,7 @@ /* -** Copyright 2002/03, Thomas Kurschel. All rights reserved. -** Distributed under the terms of the OpenBeOS License. -*/ + * Copyright 2002/03, Thomas Kurschel. All rights reserved. + * Distributed under the terms of the MIT License. + */ /* Part of Open SCSI Peripheral Driver @@ -12,7 +12,6 @@ #include "scsi_periph_int.h" -#include #include diff --git a/src/add-ons/kernel/generic/scsi_periph/scsi_periph_int.h b/src/add-ons/kernel/generic/scsi_periph/scsi_periph_int.h index bb633369f5..a295679054 100644 --- a/src/add-ons/kernel/generic/scsi_periph/scsi_periph_int.h +++ b/src/add-ons/kernel/generic/scsi_periph/scsi_periph_int.h @@ -6,10 +6,12 @@ #define __SCSI_PERIPH_INT_H__ -#include #include -#include +#include #include + +#include + #include "wrapper.h"