[haiku-commits] r36997 - in haiku/trunk: headers/private/kernel headers/private/kernel/vm src/add-ons/kernel/drivers/disk/scsi/scsi_cd src/add-ons/kernel/drivers/disk/scsi/scsi_disk src/system/kernel/cache ...
- From: ingo_weinhold@xxxxxx
- To: haiku-commits@xxxxxxxxxxxxx
- Date: Wed, 2 Jun 2010 20:42:21 +0200 (CEST)
Author: bonefish
Date: 2010-06-02 20:42:20 +0200 (Wed, 02 Jun 2010)
New Revision: 36997
Changeset: http://dev.haiku-os.org/changeset/36997/haiku
Modified:
haiku/trunk/headers/private/kernel/vfs.h
haiku/trunk/headers/private/kernel/vm/VMCache.h
haiku/trunk/headers/private/kernel/vm/vm.h
haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp
haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_disk/scsi_disk.cpp
haiku/trunk/src/system/kernel/cache/file_cache.cpp
haiku/trunk/src/system/kernel/cache/vnode_store.cpp
haiku/trunk/src/system/kernel/cache/vnode_store.h
haiku/trunk/src/system/kernel/device_manager/IOCache.cpp
haiku/trunk/src/system/kernel/device_manager/IOCache.h
haiku/trunk/src/system/kernel/device_manager/IORequest.cpp
haiku/trunk/src/system/kernel/device_manager/IORequest.h
haiku/trunk/src/system/kernel/device_manager/IOScheduler.h
haiku/trunk/src/system/kernel/device_manager/IOSchedulerSimple.cpp
haiku/trunk/src/system/kernel/device_manager/IOSchedulerSimple.h
haiku/trunk/src/system/kernel/device_manager/dma_resources.cpp
haiku/trunk/src/system/kernel/device_manager/dma_resources.h
haiku/trunk/src/system/kernel/fs/vfs.cpp
haiku/trunk/src/system/kernel/fs/vfs_request_io.cpp
haiku/trunk/src/system/kernel/vm/VMAnonymousCache.cpp
haiku/trunk/src/system/kernel/vm/VMAnonymousCache.h
haiku/trunk/src/system/kernel/vm/VMCache.cpp
haiku/trunk/src/system/kernel/vm/vm.cpp
haiku/trunk/src/system/kernel/vm/vm_page.cpp
Log:
* Introduced type generic_io_vec, which is similar to iovec, but uses types
that are wide enough for both virtual and physical addresses.
* DMABuffer, IORequest, IOScheduler,... and code using them: Use
generic_io_vec and generic_{addr,size}_t where necessary.
Modified: haiku/trunk/headers/private/kernel/vfs.h
===================================================================
--- haiku/trunk/headers/private/kernel/vfs.h 2010-06-02 18:22:38 UTC (rev
36996)
+++ haiku/trunk/headers/private/kernel/vfs.h 2010-06-02 18:42:20 UTC (rev
36997)
@@ -33,6 +33,7 @@
struct attr_info;
struct file_descriptor;
+struct generic_io_vec;
struct kernel_args;
struct net_stat;
struct pollfd;
@@ -59,12 +60,7 @@
uint32 max_monitors;
} io_context;
-/* macro to allocate a iovec array on the stack */
-#define IOVECS(name, size) \
- uint8 _##name[sizeof(iovecs) + (size)*sizeof(iovec)]; \
- iovecs *name = (iovecs *)_##name
-
#ifdef __cplusplus
extern "C" {
#endif
@@ -100,11 +96,11 @@
status_t vfs_get_cookie_from_fd(int fd, void **_cookie);
bool vfs_can_page(struct vnode *vnode, void *cookie);
status_t vfs_read_pages(struct vnode *vnode, void *cookie, off_t pos,
- const iovec *vecs, size_t count, uint32 flags,
- size_t *_numBytes);
+ const struct generic_io_vec *vecs, size_t
count, uint32 flags,
+ generic_size_t *_numBytes);
status_t vfs_write_pages(struct vnode *vnode, void *cookie, off_t pos,
- const iovec *vecs, size_t count, uint32 flags,
- size_t *_numBytes);
+ const struct generic_io_vec *vecs, size_t
count, uint32 flags,
+ generic_size_t *_numBytes);
status_t vfs_vnode_io(struct vnode* vnode, void* cookie,
io_request* request);
status_t vfs_synchronous_io(io_request* request,
@@ -287,12 +283,12 @@
virtual void IOFinished(status_t status,
bool
partialTransfer,
- size_t
bytesTransferred) = 0;
+
generic_size_t bytesTransferred) = 0;
static status_t IORequestCallback(void* data,
io_request* request, status_t status,
bool
partialTransfer,
- size_t
transferEndOffset);
+
generic_size_t transferEndOffset);
};
@@ -306,12 +302,14 @@
status_t vfs_asynchronous_read_pages(struct vnode* vnode, void* cookie,
- off_t pos, const iovec* vecs, size_t count,
size_t numBytes,
- uint32 flags, AsyncIOCallback* callback);
+ off_t pos, const struct generic_io_vec* vecs,
size_t count,
+ generic_size_t numBytes, uint32 flags,
+ AsyncIOCallback* callback);
status_t vfs_asynchronous_write_pages(struct vnode* vnode, void* cookie,
- off_t pos, const iovec* vecs, size_t count,
size_t numBytes,
- uint32 flags, AsyncIOCallback* callback);
+ off_t pos, const struct generic_io_vec* vecs,
size_t count,
+ generic_size_t numBytes, uint32 flags,
+ AsyncIOCallback* callback);
#endif // __cplusplus
Modified: haiku/trunk/headers/private/kernel/vm/VMCache.h
===================================================================
--- haiku/trunk/headers/private/kernel/vm/VMCache.h 2010-06-02 18:22:38 UTC
(rev 36996)
+++ haiku/trunk/headers/private/kernel/vm/VMCache.h 2010-06-02 18:42:20 UTC
(rev 36997)
@@ -129,13 +129,15 @@
virtual status_t Commit(off_t size, int
priority);
virtual bool HasPage(off_t offset);
- virtual status_t Read(off_t offset, const iovec
*vecs,
+ virtual status_t Read(off_t offset, const
generic_io_vec *vecs,
size_t
count,uint32 flags,
- size_t
*_numBytes);
- virtual status_t Write(off_t offset, const iovec
*vecs, size_t count,
- uint32
flags, size_t *_numBytes);
- virtual status_t WriteAsync(off_t offset, const
iovec* vecs,
- size_t
count, size_t numBytes, uint32 flags,
+
generic_size_t *_numBytes);
+ virtual status_t Write(off_t offset, const
generic_io_vec *vecs,
+ size_t
count, uint32 flags,
+
generic_size_t *_numBytes);
+ virtual status_t WriteAsync(off_t offset,
+ const
generic_io_vec* vecs, size_t count,
+
generic_size_t numBytes, uint32 flags,
AsyncIOCallback* callback);
virtual bool CanWritePage(off_t offset);
Modified: haiku/trunk/headers/private/kernel/vm/vm.h
===================================================================
--- haiku/trunk/headers/private/kernel/vm/vm.h 2010-06-02 18:22:38 UTC (rev
36996)
+++ haiku/trunk/headers/private/kernel/vm/vm.h 2010-06-02 18:42:20 UTC (rev
36997)
@@ -14,7 +14,7 @@
#include <vm_defs.h>
-struct iovec;
+struct generic_io_vec;
struct kernel_args;
struct ObjectCache;
struct system_memory_info;
@@ -93,7 +93,7 @@
phys_addr_t physicalAddress, bool alreadyWired);
area_id vm_map_physical_memory_vecs(team_id team, const char* name,
void** _address, uint32 addressSpec, addr_t* _size, uint32 protection,
- struct iovec* vecs, uint32 vecCount);
+ struct generic_io_vec* vecs, uint32 vecCount);
area_id vm_map_file(team_id aid, const char *name, void **address,
uint32 addressSpec, addr_t size, uint32 protection,
uint32 mapping,
bool unmapAddressRange, int fd, off_t offset);
Modified: haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp
===================================================================
--- haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp
2010-06-02 18:22:38 UTC (rev 36996)
+++ haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp
2010-06-02 18:42:20 UTC (rev 36997)
@@ -770,7 +770,7 @@
return B_DEV_NO_MEDIA;
IORequest request;
- status_t status = request.Init(pos, buffer, length, false, 0);
+ status_t status = request.Init(pos, (addr_t)buffer, length, false, 0);
if (status != B_OK)
return status;
@@ -798,7 +798,7 @@
return B_DEV_NO_MEDIA;
IORequest request;
- status_t status = request.Init(pos, (void*)buffer, length, true, 0);
+ status_t status = request.Init(pos, (addr_t)buffer, length, true, 0);
if (status != B_OK)
return status;
Modified:
haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_disk/scsi_disk.cpp
===================================================================
--- haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_disk/scsi_disk.cpp
2010-06-02 18:22:38 UTC (rev 36996)
+++ haiku/trunk/src/add-ons/kernel/drivers/disk/scsi/scsi_disk/scsi_disk.cpp
2010-06-02 18:42:20 UTC (rev 36997)
@@ -265,7 +265,7 @@
size_t length = *_length;
IORequest request;
- status_t status = request.Init(pos, buffer, length, false, 0);
+ status_t status = request.Init(pos, (addr_t)buffer, length, false, 0);
if (status != B_OK)
return status;
@@ -290,7 +290,7 @@
size_t length = *_length;
IORequest request;
- status_t status = request.Init(pos, (void*)buffer, length, true, 0);
+ status_t status = request.Init(pos, (addr_t)buffer, length, true, 0);
if (status != B_OK)
return status;
Modified: haiku/trunk/src/system/kernel/cache/file_cache.cpp
===================================================================
--- haiku/trunk/src/system/kernel/cache/file_cache.cpp 2010-06-02 18:22:38 UTC
(rev 36996)
+++ haiku/trunk/src/system/kernel/cache/file_cache.cpp 2010-06-02 18:42:20 UTC
(rev 36997)
@@ -72,7 +72,7 @@
class PrecacheIO : public AsyncIOCallback {
public:
PrecacheIO(file_cache_ref* ref, off_t offset,
- size_t
size);
+
generic_size_t size);
~PrecacheIO();
status_t
Prepare(vm_page_reservation* reservation);
@@ -80,7 +80,7 @@
virtual void IOFinished(status_t status,
bool
partialTransfer,
- size_t
bytesTransferred);
+
generic_size_t bytesTransferred);
private:
file_cache_ref* fRef;
@@ -88,10 +88,10 @@
vm_page** fPages;
size_t fPageCount;
ConditionVariable* fBusyConditions;
- iovec* fVecs;
+ generic_io_vec* fVecs;
off_t fOffset;
uint32 fVecCount;
- size_t fSize;
+ generic_size_t fSize;
#if DEBUG_PAGE_ACCESS
thread_id fAllocatingThread;
#endif
@@ -101,8 +101,8 @@
int32 pageOffset, addr_t buffer, size_t bufferSize, bool useBuffer,
vm_page_reservation* reservation, size_t reservePages);
-static void add_to_iovec(iovec* vecs, uint32 &index, uint32 max, addr_t
address,
- size_t size);
+static void add_to_iovec(generic_io_vec* vecs, uint32 &index, uint32 max,
+ generic_addr_t address, generic_size_t size);
static struct cache_module_info* sCacheModule;
@@ -110,14 +110,14 @@
static const uint32 kZeroVecCount = 32;
static const size_t kZeroVecSize = kZeroVecCount * B_PAGE_SIZE;
-static addr_t sZeroPage; // physical address
-static iovec sZeroVecs[kZeroVecCount];
+static phys_addr_t sZeroPage; // physical address
+static generic_io_vec sZeroVecs[kZeroVecCount];
// #pragma mark -
-PrecacheIO::PrecacheIO(file_cache_ref* ref, off_t offset, size_t size)
+PrecacheIO::PrecacheIO(file_cache_ref* ref, off_t offset, generic_size_t size)
:
fRef(ref),
fCache(ref->cache),
@@ -150,13 +150,13 @@
if (fPages == NULL)
return B_NO_MEMORY;
- fVecs = new(std::nothrow) iovec[fPageCount];
+ fVecs = new(std::nothrow) generic_io_vec[fPageCount];
if (fVecs == NULL)
return B_NO_MEMORY;
// allocate pages for the cache and mark them busy
uint32 i = 0;
- for (size_t pos = 0; pos < fSize; pos += B_PAGE_SIZE) {
+ for (generic_size_t pos = 0; pos < fSize; pos += B_PAGE_SIZE) {
vm_page* page = vm_page_allocate_page(reservation,
PAGE_STATE_CACHED | VM_PAGE_ALLOC_BUSY);
@@ -187,13 +187,13 @@
void
PrecacheIO::IOFinished(status_t status, bool partialTransfer,
- size_t bytesTransferred)
+ generic_size_t bytesTransferred)
{
AutoLocker<VMCache> locker(fCache);
// Make successfully loaded pages accessible again (partially
// transferred pages are considered failed)
- size_t pagesTransferred
+ phys_size_t pagesTransferred
= (bytesTransferred + B_PAGE_SIZE - 1) / B_PAGE_SIZE;
if (fOffset + bytesTransferred > fCache->virtual_end)
@@ -204,8 +204,10 @@
&& (bytesTransferred % B_PAGE_SIZE) != 0) {
// clear partial page
size_t bytesTouched = bytesTransferred % B_PAGE_SIZE;
- vm_memset_physical((fPages[i]->physical_page_number <<
PAGE_SHIFT)
- + bytesTouched, 0, B_PAGE_SIZE - bytesTouched);
+ vm_memset_physical(
+ ((phys_addr_t)fPages[i]->physical_page_number
<< PAGE_SHIFT)
+ + bytesTouched,
+ 0, B_PAGE_SIZE - bytesTouched);
}
DEBUG_PAGE_ACCESS_TRANSFER(fPages[i], fAllocatingThread);
@@ -231,13 +233,12 @@
static void
-add_to_iovec(iovec* vecs, uint32 &index, uint32 max, addr_t address,
- size_t size)
+add_to_iovec(generic_io_vec* vecs, uint32 &index, uint32 max,
+ generic_addr_t address, generic_size_t size)
{
- if (index > 0 && (addr_t)vecs[index - 1].iov_base
- + vecs[index - 1].iov_len == address) {
+ if (index > 0 && vecs[index - 1].base + vecs[index - 1].length ==
address) {
// the iovec can be combined with the previous one
- vecs[index - 1].iov_len += size;
+ vecs[index - 1].length += size;
return;
}
@@ -245,8 +246,8 @@
panic("no more space for iovecs!");
// we need to start a new iovec
- vecs[index].iov_base = (void*)address;
- vecs[index].iov_len = size;
+ vecs[index].base = address;
+ vecs[index].length = size;
index++;
}
@@ -259,7 +260,8 @@
static inline void
-push_access(file_cache_ref* ref, off_t offset, size_t bytes, bool isWrite)
+push_access(file_cache_ref* ref, off_t offset, generic_size_t bytes,
+ bool isWrite)
{
TRACE(("%p: push %Ld, %ld, %s\n", ref, offset, bytes,
isWrite ? "write" : "read"));
@@ -331,14 +333,15 @@
static inline status_t
read_pages_and_clear_partial(file_cache_ref* ref, void* cookie, off_t offset,
- const iovec* vecs, size_t count, uint32 flags, size_t* _numBytes)
+ const generic_io_vec* vecs, size_t count, uint32 flags,
+ generic_size_t* _numBytes)
{
- size_t bytesUntouched = *_numBytes;
+ generic_size_t bytesUntouched = *_numBytes;
status_t status = vfs_read_pages(ref->vnode, cookie, offset, vecs,
count,
flags, _numBytes);
- size_t bytesEnd = *_numBytes;
+ generic_size_t bytesEnd = *_numBytes;
if (offset + bytesEnd > ref->cache->virtual_end)
bytesEnd = ref->cache->virtual_end - offset;
@@ -350,9 +353,9 @@
bytesUntouched -= bytesEnd;
for (int32 i = count; i-- > 0 && bytesUntouched != 0; ) {
- size_t length = min_c(bytesUntouched, vecs[i].iov_len);
- vm_memset_physical((addr_t)vecs[i].iov_base +
vecs[i].iov_len
- - length, 0, length);
+ generic_size_t length = min_c(bytesUntouched,
vecs[i].length);
+ vm_memset_physical(vecs[i].base + vecs[i].length -
length, 0,
+ length);
bytesUntouched -= length;
}
@@ -381,7 +384,7 @@
// TODO: We're using way too much stack! Rather allocate a sufficiently
// large chunk on the heap.
- iovec vecs[MAX_IO_VECS];
+ generic_io_vec vecs[MAX_IO_VECS];
uint32 vecCount = 0;
size_t numBytes = PAGE_ALIGN(pageOffset + bufferSize);
@@ -464,9 +467,9 @@
if (!useBuffer)
return B_OK;
- iovec vec;
- vec.iov_base = (void*)buffer;
- vec.iov_len = bufferSize;
+ generic_io_vec vec;
+ vec.base = buffer;
+ vec.length = bufferSize;
push_access(ref, offset, bufferSize, false);
ref->cache->Unlock();
@@ -496,7 +499,7 @@
{
// TODO: We're using way too much stack! Rather allocate a sufficiently
// large chunk on the heap.
- iovec vecs[MAX_IO_VECS];
+ generic_io_vec vecs[MAX_IO_VECS];
uint32 vecCount = 0;
size_t numBytes = PAGE_ALIGN(pageOffset + bufferSize);
vm_page* pages[MAX_IO_VECS];
@@ -535,8 +538,8 @@
if (pageOffset != 0) {
// This is only a partial write, so we have to read the rest of
the page
// from the file to have consistent data in the cache
- iovec readVec = { vecs[0].iov_base, B_PAGE_SIZE };
- size_t bytesRead = B_PAGE_SIZE;
+ generic_io_vec readVec = { vecs[0].base, B_PAGE_SIZE };
+ generic_size_t bytesRead = B_PAGE_SIZE;
status = vfs_read_pages(ref->vnode, cookie, offset, &readVec, 1,
B_PHYSICAL_IO_REQUEST, &bytesRead);
@@ -545,11 +548,11 @@
panic("1. vfs_read_pages() failed: %s!\n",
strerror(status));
}
- addr_t lastPageOffset = (pageOffset + bufferSize) & (B_PAGE_SIZE - 1);
+ size_t lastPageOffset = (pageOffset + bufferSize) % B_PAGE_SIZE;
if (lastPageOffset != 0) {
// get the last page in the I/O vectors
- addr_t last = (addr_t)vecs[vecCount - 1].iov_base
- + vecs[vecCount - 1].iov_len - B_PAGE_SIZE;
+ generic_addr_t last = vecs[vecCount - 1].base
+ + vecs[vecCount - 1].length - B_PAGE_SIZE;
if (offset + pageOffset + bufferSize ==
ref->cache->virtual_end) {
// the space in the page after this write action needs
to be cleaned
@@ -558,8 +561,8 @@
} else {
// the end of this write does not happen on a page
boundary, so we
// need to fetch the last page before we can update it
- iovec readVec = { (void*)last, B_PAGE_SIZE };
- size_t bytesRead = B_PAGE_SIZE;
+ generic_io_vec readVec = { last, B_PAGE_SIZE };
+ generic_size_t bytesRead = B_PAGE_SIZE;
status = vfs_read_pages(ref->vnode, cookie,
PAGE_ALIGN(offset + pageOffset + bufferSize) -
B_PAGE_SIZE,
@@ -577,9 +580,9 @@
}
for (uint32 i = 0; i < vecCount; i++) {
- addr_t base = (addr_t)vecs[i].iov_base;
- size_t bytes = min_c(bufferSize,
- size_t(vecs[i].iov_len - pageOffset));
+ generic_addr_t base = vecs[i].base;
+ generic_size_t bytes = min_c((generic_size_t)bufferSize,
+ generic_size_t(vecs[i].length - pageOffset));
if (useBuffer) {
// copy data from user buffer
@@ -638,7 +641,7 @@
if (!useBuffer) {
while (bufferSize > 0) {
- size_t written = min_c(bufferSize, kZeroVecSize);
+ generic_size_t written = min_c(bufferSize,
kZeroVecSize);
status = vfs_write_pages(ref->vnode, cookie, offset +
pageOffset,
sZeroVecs, kZeroVecCount,
B_PHYSICAL_IO_REQUEST, &written);
if (status != B_OK)
@@ -650,9 +653,9 @@
pageOffset += written;
}
} else {
- iovec vec;
- vec.iov_base = (void*)buffer;
- vec.iov_len = bufferSize;
+ generic_io_vec vec;
+ vec.base = buffer;
+ vec.length = bufferSize;
status = vfs_write_pages(ref->vnode, cookie, offset +
pageOffset,
&vec, 1, 0, &bufferSize);
}
@@ -669,8 +672,8 @@
static inline status_t
satisfy_cache_io(file_cache_ref* ref, void* cookie, cache_func function,
off_t offset, addr_t buffer, bool useBuffer, int32 &pageOffset,
- size_t bytesLeft, size_t &reservePages, off_t &lastOffset,
- addr_t &lastBuffer, int32 &lastPageOffset, size_t &lastLeft,
+ generic_size_t bytesLeft, size_t &reservePages, off_t &lastOffset,
+ addr_t &lastBuffer, int32 &lastPageOffset, generic_size_t &lastLeft,
size_t &lastReservedPages, vm_page_reservation* reservation)
{
if (lastBuffer == buffer)
@@ -797,8 +800,9 @@
locker.Unlock();
// copy the contents of the page already in
memory
- addr_t pageAddress = page->physical_page_number
* B_PAGE_SIZE
- + pageOffset;
+ phys_addr_t pageAddress
+ =
(phys_addr_t)page->physical_page_number * B_PAGE_SIZE
+ + pageOffset;
if (doWrite) {
if (useBuffer) {
vm_memcpy_to_physical(pageAddress, (void*)buffer,
@@ -1095,11 +1099,11 @@
PAGE_STATE_WIRED | VM_PAGE_ALLOC_CLEAR);
vm_page_unreserve_pages(&reservation);
- sZeroPage = (addr_t)page->physical_page_number * B_PAGE_SIZE;
+ sZeroPage = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;
for (uint32 i = 0; i < kZeroVecCount; i++) {
- sZeroVecs[i].iov_base = (void*)sZeroPage;
- sZeroVecs[i].iov_len = B_PAGE_SIZE;
+ sZeroVecs[i].base = sZeroPage;
+ sZeroVecs[i].length = B_PAGE_SIZE;
}
register_generic_syscall(CACHE_SYSCALLS, file_cache_control, 1, 0);
@@ -1280,9 +1284,9 @@
if (ref->disabled_count > 0) {
// Caching is disabled -- read directly from the file.
- iovec vec;
- vec.iov_base = buffer;
- vec.iov_len = *_size;
+ generic_io_vec vec;
+ vec.base = (addr_t)buffer;
+ vec.length = *_size;
return vfs_read_pages(ref->vnode, cookie, offset, &vec, 1, 0,
_size);
}
@@ -1300,9 +1304,9 @@
// Caching is disabled -- write directly to the file.
if (buffer != NULL) {
- iovec vec;
- vec.iov_base = (void*)buffer;
- vec.iov_len = *_size;
+ generic_io_vec vec;
+ vec.base = (addr_t)buffer;
+ vec.length = *_size;
return vfs_write_pages(ref->vnode, cookie, offset,
&vec, 1, 0,
_size);
}
@@ -1311,7 +1315,7 @@
size_t size = *_size;
while (size > 0) {
size_t toWrite = min_c(size, kZeroVecSize);
- size_t written = toWrite;
+ generic_size_t written = toWrite;
status_t error = vfs_write_pages(ref->vnode, cookie,
offset,
sZeroVecs, kZeroVecCount,
B_PHYSICAL_IO_REQUEST, &written);
if (error != B_OK)
Modified: haiku/trunk/src/system/kernel/cache/vnode_store.cpp
===================================================================
--- haiku/trunk/src/system/kernel/cache/vnode_store.cpp 2010-06-02 18:22:38 UTC
(rev 36996)
+++ haiku/trunk/src/system/kernel/cache/vnode_store.cpp 2010-06-02 18:42:20 UTC
(rev 36997)
@@ -1,5 +1,5 @@
/*
- * Copyright 2008, Ingo Weinhold, ingo_weinhold@xxxxxxx
+ * Copyright 2008-2010, Ingo Weinhold, ingo_weinhold@xxxxxxx
* Copyright 2004-2007, Axel Dörfler, axeld@xxxxxxxxxxxxxxxxx
* Distributed under the terms of the MIT License.
*/
@@ -42,15 +42,15 @@
status_t
-VMVnodeCache::Read(off_t offset, const iovec *vecs, size_t count,
- uint32 flags, size_t *_numBytes)
+VMVnodeCache::Read(off_t offset, const generic_io_vec *vecs, size_t count,
+ uint32 flags, generic_size_t *_numBytes)
{
- size_t bytesUntouched = *_numBytes;
+ generic_size_t bytesUntouched = *_numBytes;
status_t status = vfs_read_pages(fVnode, NULL, offset, vecs, count,
flags, _numBytes);
- size_t bytesEnd = *_numBytes;
+ generic_size_t bytesEnd = *_numBytes;
if (offset + bytesEnd > virtual_end)
bytesEnd = virtual_end - offset;
@@ -66,13 +66,13 @@
// doing this here so that not every file system/device has to implement
// this
for (int32 i = count; i-- > 0 && bytesUntouched != 0;) {
- size_t length = min_c(bytesUntouched, vecs[i].iov_len);
+ generic_size_t length = min_c(bytesUntouched, vecs[i].length);
- addr_t address = (addr_t)vecs[i].iov_base + vecs[i].iov_len -
length;
+ generic_addr_t address = vecs[i].base + vecs[i].length - length;
if ((flags & B_PHYSICAL_IO_REQUEST) != 0)
vm_memset_physical(address, 0, length);
else
- memset((void*)address, 0, length);
+ memset((void*)(addr_t)address, 0, length);
bytesUntouched -= length;
}
@@ -82,16 +82,16 @@
status_t
-VMVnodeCache::Write(off_t offset, const iovec *vecs, size_t count,
- uint32 flags, size_t *_numBytes)
+VMVnodeCache::Write(off_t offset, const generic_io_vec *vecs, size_t count,
+ uint32 flags, generic_size_t *_numBytes)
{
return vfs_write_pages(fVnode, NULL, offset, vecs, count, flags,
_numBytes);
}
status_t
-VMVnodeCache::WriteAsync(off_t offset, const iovec* vecs, size_t count,
- size_t numBytes, uint32 flags, AsyncIOCallback* callback)
+VMVnodeCache::WriteAsync(off_t offset, const generic_io_vec* vecs, size_t
count,
+ generic_size_t numBytes, uint32 flags, AsyncIOCallback* callback)
{
return vfs_asynchronous_write_pages(fVnode, NULL, offset, vecs, count,
numBytes, flags, callback);
Modified: haiku/trunk/src/system/kernel/cache/vnode_store.h
===================================================================
--- haiku/trunk/src/system/kernel/cache/vnode_store.h 2010-06-02 18:22:38 UTC
(rev 36996)
+++ haiku/trunk/src/system/kernel/cache/vnode_store.h 2010-06-02 18:42:20 UTC
(rev 36997)
@@ -20,14 +20,15 @@
virtual bool HasPage(off_t offset);
- virtual status_t Read(off_t offset, const iovec
*vecs,
+ virtual status_t Read(off_t offset, const
generic_io_vec *vecs,
size_t
count, uint32 flags,
- size_t
*_numBytes);
- virtual status_t Write(off_t offset, const iovec
*vecs,
+
generic_size_t *_numBytes);
+ virtual status_t Write(off_t offset, const
generic_io_vec *vecs,
size_t
count, uint32 flags,
- size_t
*_numBytes);
- virtual status_t WriteAsync(off_t offset, const
iovec* vecs,
- size_t
count, size_t numBytes, uint32 flags,
+
generic_size_t *_numBytes);
+ virtual status_t WriteAsync(off_t offset,
+ const
generic_io_vec* vecs, size_t count,
+
generic_size_t numBytes, uint32 flags,
AsyncIOCallback* callback);
virtual bool CanWritePage(off_t offset);
Modified: haiku/trunk/src/system/kernel/device_manager/IOCache.cpp
===================================================================
--- haiku/trunk/src/system/kernel/device_manager/IOCache.cpp 2010-06-02
18:22:38 UTC (rev 36996)
+++ haiku/trunk/src/system/kernel/device_manager/IOCache.cpp 2010-06-02
18:42:20 UTC (rev 36997)
@@ -113,9 +113,9 @@
}
fCache = area->cache;
- // allocate arrays for pages and iovecs
+ // allocate arrays for pages and io vecs
fPages = new(std::nothrow) vm_page*[fPagesPerLine];
- fVecs = new(std::nothrow) iovec[fPagesPerLine];
+ fVecs = new(std::nothrow) generic_io_vec[fPagesPerLine];
if (fPages == NULL || fVecs == NULL)
return B_NO_MEMORY;
@@ -171,7 +171,7 @@
// we completely serialize all I/O in FIFO order
MutexLocker serializationLocker(fSerializationLock);
- size_t bytesTransferred = 0;
+ generic_size_t bytesTransferred = 0;
error = _DoRequest(request, bytesTransferred);
serializationLocker.Unlock();
@@ -200,7 +200,7 @@
void
IOCache::OperationCompleted(IOOperation* operation, status_t status,
- size_t transferredBytes)
+ generic_size_t transferredBytes)
{
if (status == B_OK) {
// always fail in case of partial transfers
@@ -220,10 +220,10 @@
status_t
-IOCache::_DoRequest(IORequest* request, size_t& _bytesTransferred)
+IOCache::_DoRequest(IORequest* request, generic_size_t& _bytesTransferred)
{
off_t offset = request->Offset();
- size_t length = request->Length();
+ generic_size_t length = request->Length();
TRACE("%p->IOCache::ScheduleRequest(%p): offset: %" B_PRIdOFF
", length: %" B_PRIuSIZE "\n", this, request, offset, length);
@@ -439,7 +439,7 @@
if (actualRequestOffset < requestOffset)
request->Advance(requestOffset - actualRequestOffset);
- size_t requestRemaining = request->RemainingBytes() - requestLength;
+ generic_size_t requestRemaining = request->RemainingBytes() -
requestLength;
// Process single operations until the specified part of the request is
// finished or until an error occurs.
@@ -513,23 +513,24 @@
off_t firstPageOffset = (off_t)fPages[firstPage]->cache_offset
* B_PAGE_SIZE;
- size_t requestLength = std::min(
+ generic_size_t requestLength = std::min(
firstPageOffset + (off_t)pageCount * B_PAGE_SIZE,
fDeviceCapacity)
- firstPageOffset;
// prepare the I/O vecs
size_t vecCount = 0;
size_t endPage = firstPage + pageCount;
- addr_t vecsEndAddress = 0;
+ phys_addr_t vecsEndAddress = 0;
for (size_t i = firstPage; i < endPage; i++) {
- addr_t pageAddress = fPages[i]->physical_page_number *
B_PAGE_SIZE;
+ phys_addr_t pageAddress
+ = (phys_addr_t)fPages[i]->physical_page_number *
B_PAGE_SIZE;
if (vecCount == 0 || pageAddress != vecsEndAddress) {
- fVecs[vecCount].iov_base = (void*)pageAddress;
- fVecs[vecCount++].iov_len = B_PAGE_SIZE;
+ fVecs[vecCount].base = pageAddress;
+ fVecs[vecCount++].length = B_PAGE_SIZE;
vecsEndAddress = pageAddress + B_PAGE_SIZE;
} else {
// extend the previous vec
- fVecs[vecCount - 1].iov_len += B_PAGE_SIZE;
+ fVecs[vecCount - 1].length += B_PAGE_SIZE;
vecsEndAddress += B_PAGE_SIZE;
}
}
Modified: haiku/trunk/src/system/kernel/device_manager/IOCache.h
===================================================================
--- haiku/trunk/src/system/kernel/device_manager/IOCache.h 2010-06-02
18:22:38 UTC (rev 36996)
+++ haiku/trunk/src/system/kernel/device_manager/IOCache.h 2010-06-02
18:42:20 UTC (rev 36997)
@@ -33,7 +33,8 @@
virtual void AbortRequest(IORequest* request,
status_t status = B_CANCELED);
virtual void OperationCompleted(IOOperation*
operation,
-
status_t status, size_t transferredBytes);
+
status_t status,
+
generic_size_t transferredBytes);
virtual void Dump() const;
@@ -42,7 +43,7 @@
private:
status_t _DoRequest(IORequest*
request,
- size_t&
_bytesTransferred);
+
generic_size_t& _bytesTransferred);
status_t
_TransferRequestLine(IORequest* request,
off_t
lineOffset, size_t lineSize,
off_t
requestOffset, size_t requestLength);
@@ -76,7 +77,7 @@
vm_page_reservation fMappingReservation;
VMCache* fCache;
vm_page** fPages;
- iovec* fVecs;
+ generic_io_vec* fVecs;
};
Modified: haiku/trunk/src/system/kernel/device_manager/IORequest.cpp
===================================================================
--- haiku/trunk/src/system/kernel/device_manager/IORequest.cpp 2010-06-02
18:22:38 UTC (rev 36996)
+++ haiku/trunk/src/system/kernel/device_manager/IORequest.cpp 2010-06-02
18:42:20 UTC (rev 36997)
@@ -4,6 +4,7 @@
* Distributed under the terms of the MIT License.
*/
+
#include "IORequest.h"
#include <string.h>
@@ -56,18 +57,18 @@
struct virtual_vec_cookie {
- uint32 vec_index;
- size_t vec_offset;
- area_id mapped_area;
- void* physical_page_handle;
- addr_t virtual_address;
+ uint32 vec_index;
+ generic_size_t vec_offset;
+ area_id mapped_area;
+ void* physical_page_handle;
+ addr_t virtual_address;
};
IOBuffer*
IOBuffer::Create(uint32 count, bool vip)
{
- size_t size = sizeof(IOBuffer) + sizeof(iovec) * (count - 1);
+ size_t size = sizeof(IOBuffer) + sizeof(generic_io_vec) * (count - 1);
IOBuffer* buffer
= (IOBuffer*)(malloc_etc(size, vip ? HEAP_PRIORITY_VIP : 0));
if (buffer == NULL)
@@ -95,19 +96,20 @@
void
-IOBuffer::SetVecs(size_t firstVecOffset, const iovec* vecs, uint32 count,
- size_t length, uint32 flags)
+IOBuffer::SetVecs(generic_size_t firstVecOffset, const generic_io_vec* vecs,
+ uint32 count, generic_size_t length, uint32 flags)
{
- memcpy(fVecs, vecs, sizeof(iovec) * count);
+ memcpy(fVecs, vecs, sizeof(generic_io_vec) * count);
+
if (count > 0 && firstVecOffset > 0) {
- fVecs[0].iov_base = (uint8*)fVecs[0].iov_base + firstVecOffset;
- fVecs[0].iov_len -= firstVecOffset;
+ fVecs[0].base += firstVecOffset;
+ fVecs[0].length -= firstVecOffset;
}
fVecCount = count;
fLength = length;
fPhysical = (flags & B_PHYSICAL_IO_REQUEST) != 0;
- fUser = !fPhysical && IS_USER_ADDRESS(vecs[0].iov_base);
+ fUser = !fPhysical && IS_USER_ADDRESS(vecs[0].base);
}
@@ -141,12 +143,13 @@
return B_BAD_INDEX;
if (!fPhysical) {
- vector = fVecs[cookie->vec_index++];
+ vector.iov_base = (void*)(addr_t)fVecs[cookie->vec_index].base;
+ vector.iov_len = fVecs[cookie->vec_index++].length;
return B_OK;
}
if (cookie->vec_index == 0
- && (fVecCount > 1 || fVecs[0].iov_len > B_PAGE_SIZE)) {
+ && (fVecCount > 1 || fVecs[0].length > B_PAGE_SIZE)) {
void* mappedAddress;
addr_t mappedSize;
@@ -158,7 +161,7 @@
B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA, fVecs,
fVecCount);
if (cookie->mapped_area >= 0) {
- vector.iov_base = (void*)mappedAddress;
+ vector.iov_base = mappedAddress;
vector.iov_len = mappedSize;
return B_OK;
} else
@@ -166,9 +169,9 @@
}
// fallback to page wise mapping
- iovec& currentVec = fVecs[cookie->vec_index];
- addr_t address = (addr_t)currentVec.iov_base + cookie->vec_offset;
- addr_t pageOffset = address % B_PAGE_SIZE;
+ generic_io_vec& currentVec = fVecs[cookie->vec_index];
+ generic_addr_t address = currentVec.base + cookie->vec_offset;
+ size_t pageOffset = address % B_PAGE_SIZE;
// TODO: This is a potential violation of the VIP requirement, since
// vm_get_physical_page() may allocate memory without special flags!
@@ -177,14 +180,14 @@
if (result != B_OK)
return result;
- size_t length = min_c(currentVec.iov_len - cookie->vec_offset,
+ generic_size_t length = min_c(currentVec.length - cookie->vec_offset,
B_PAGE_SIZE - pageOffset);
vector.iov_base = (void*)(cookie->virtual_address + pageOffset);
vector.iov_len = length;
cookie->vec_offset += length;
- if (cookie->vec_offset >= currentVec.iov_len) {
+ if (cookie->vec_offset >= currentVec.length) {
cookie->vec_index++;
cookie->vec_offset = 0;
}
@@ -214,8 +217,8 @@
}
for (uint32 i = 0; i < fVecCount; i++) {
- status_t status = lock_memory_etc(team, fVecs[i].iov_base,
- fVecs[i].iov_len, isWrite ? 0 : B_READ_DEVICE);
+ status_t status = lock_memory_etc(team,
(void*)(addr_t)fVecs[i].base,
+ fVecs[i].length, isWrite ? 0 : B_READ_DEVICE);
if (status != B_OK) {
_UnlockMemory(team, i, isWrite);
return status;
@@ -231,7 +234,7 @@
IOBuffer::_UnlockMemory(team_id team, size_t count, bool isWrite)
{
for (uint32 i = 0; i < count; i++) {
- unlock_memory_etc(team, fVecs[i].iov_base, fVecs[i].iov_len,
+ unlock_memory_etc(team, (void*)(addr_t)fVecs[i].base,
fVecs[i].length,
isWrite ? 0 : B_READ_DEVICE);
}
}
@@ -262,7 +265,8 @@
kprintf(" vecs: %lu\n", fVecCount);
for (uint32 i = 0; i < fVecCount; i++) {
- kprintf(" [%lu] %p, %lu\n", i, fVecs[i].iov_base,
fVecs[i].iov_len);
+ kprintf(" [%" B_PRIu32 "] %#" B_PRIxGENADDR ", %"
B_PRIuGENADDR "\n",
+ i, fVecs[i].base, fVecs[i].length);
}
}
@@ -280,7 +284,7 @@
if (fPhase == PHASE_READ_BEGIN) {
TRACE(" phase read begin\n");
// repair phase adjusted vec
- fDMABuffer->VecAt(fSavedVecIndex).iov_len =
fSavedVecLength;
+ fDMABuffer->VecAt(fSavedVecIndex).length =
fSavedVecLength;
// partial write: copy partial begin to bounce
buffer
bool skipReadEndPhase;
@@ -301,10 +305,9 @@
} else if (fPhase == PHASE_READ_END) {
TRACE(" phase read end\n");
// repair phase adjusted vec
- iovec& vec = fDMABuffer->VecAt(fSavedVecIndex);
- vec.iov_base = (uint8*)vec.iov_base
- + vec.iov_len - fSavedVecLength;
- vec.iov_len = fSavedVecLength;
+ generic_io_vec& vec =
fDMABuffer->VecAt(fSavedVecIndex);
+ vec.base += vec.length - fSavedVecLength;
+ vec.length = fSavedVecLength;
// partial write: copy partial end to bounce
buffer
status_t error = _CopyPartialEnd(true);
@@ -327,26 +330,27 @@
TRACE(" read with bounce buffer\n");
// copy the bounce buffer segments to the final location
uint8* bounceBuffer = (uint8*)fDMABuffer->BounceBufferAddress();
- addr_t bounceBufferStart =
fDMABuffer->PhysicalBounceBufferAddress();
- addr_t bounceBufferEnd = bounceBufferStart
+ phys_addr_t bounceBufferStart
+ = fDMABuffer->PhysicalBounceBufferAddress();
+ phys_addr_t bounceBufferEnd = bounceBufferStart
+ fDMABuffer->BounceBufferSize();
- const iovec* vecs = fDMABuffer->Vecs();
+ const generic_io_vec* vecs = fDMABuffer->Vecs();
uint32 vecCount = fDMABuffer->VecCount();
status_t error = B_OK;
// We iterate through the vecs we have read, moving offset (the
device
- // offset) as we go. If [offset, offset + vec.iov_len)
intersects with
+ // offset) as we go. If [offset, offset + vec.length)
intersects with
// [startOffset, endOffset) we copy to the final location.
off_t offset = fOffset;
const off_t startOffset = fOriginalOffset;
const off_t endOffset = fOriginalOffset + fOriginalLength;
for (uint32 i = 0; error == B_OK && i < vecCount; i++) {
- const iovec& vec = vecs[i];
- addr_t base = (addr_t)vec.iov_base;
- size_t length = vec.iov_len;
+ const generic_io_vec& vec = vecs[i];
+ generic_addr_t base = vec.base;
+ generic_size_t length = vec.length;
if (offset < startOffset) {
// If the complete vector is before the start
offset, skip it.
@@ -357,7 +361,7 @@
// The vector starts before the start offset,
but intersects
// with it. Skip the part we aren't interested
in.
- size_t diff = startOffset - offset;
+ generic_size_t diff = startOffset - offset;
offset += diff;
base += diff;
length -= diff;
@@ -408,14 +412,14 @@
if (UsesBounceBuffer()) {
TRACE(" write with bounce buffer\n");
uint8* bounceBuffer =
(uint8*)fDMABuffer->BounceBufferAddress();
- addr_t bounceBufferStart
+ phys_addr_t bounceBufferStart
= fDMABuffer->PhysicalBounceBufferAddress();
- addr_t bounceBufferEnd = bounceBufferStart
+ phys_addr_t bounceBufferEnd = bounceBufferStart
+ fDMABuffer->BounceBufferSize();
- const iovec* vecs = fDMABuffer->Vecs();
+ const generic_io_vec* vecs = fDMABuffer->Vecs();
uint32 vecCount = fDMABuffer->VecCount();
- size_t vecOffset = 0;
+ generic_size_t vecOffset = 0;
uint32 i = 0;
off_t offset = fOffset;
@@ -423,10 +427,10 @@
if (HasPartialBegin()) {
// skip first block
- size_t toSkip = fBlockSize;
+ generic_size_t toSkip = fBlockSize;
while (toSkip > 0) {
- if (vecs[i].iov_len <= toSkip) {
- toSkip -= vecs[i].iov_len;
+ if (vecs[i].length <= toSkip) {
+ toSkip -= vecs[i].length;
i++;
} else {
vecOffset = toSkip;
@@ -439,10 +443,10 @@
if (HasPartialEnd()) {
// skip last block
[... truncated: 1709 lines follow ...]
Other related posts:
- » [haiku-commits] r36997 - in haiku/trunk: headers/private/kernel headers/private/kernel/vm src/add-ons/kernel/drivers/disk/scsi/scsi_cd src/add-ons/kernel/drivers/disk/scsi/scsi_disk src/system/kernel/cache ... - ingo_weinhold
