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 ...]