kernel/device_manager/IOCache.cpp

/*
 * Copyright 2010-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "IOCache.h"

#include <algorithm>

#include <condition_variable.h>
#include <heap.h>
#include <low_resource_manager.h>
#include <util/AutoLock.h>
#include <vm/vm.h>
#include <vm/VMAddressSpace.h>
#include <vm/VMCache.h>
#include <vm/VMTranslationMap.h>


//#define TRACE_IO_CACHE 1
#ifdef TRACE_IO_CACHE
#	define TRACE(format...)	dprintf(format)
#else
#	define TRACE(format...)	do {} while (false)
#endif


static inline bool
page_physical_number_less(const vm_page* a, const vm_page* b)
{
	return a->physical_page_number < b->physical_page_number;
}


struct IOCache::Operation : IOOperation {
	ConditionVariable	finishedCondition;
};


IOCache::IOCache(DMAResource* resource, size_t cacheLineSize)
	:
	IOScheduler(resource),
	fDeviceCapacity(0),
	fLineSize(cacheLineSize),
	fPagesPerLine(cacheLineSize / B_PAGE_SIZE),
	fArea(-1),
	fCache(NULL),
	fPages(NULL),
	fVecs(NULL)
{
	ASSERT(resource != NULL);
	TRACE("%p->IOCache::IOCache(%p, %" B_PRIuSIZE ")\n", this, resource,
		cacheLineSize);

	if (cacheLineSize < B_PAGE_SIZE
		|| (cacheLineSize & (cacheLineSize - 1)) != 0) {
		panic("Invalid cache line size (%" B_PRIuSIZE "). Must be a power of 2 "
			"multiple of the page size.", cacheLineSize);
	}

	mutex_init(&fSerializationLock, "I/O cache request serialization");

	fLineSizeShift = 0;
	while (cacheLineSize != 1) {
		fLineSizeShift++;
		cacheLineSize >>= 1;
	}
}


IOCache::~IOCache()
{
	if (fArea >= 0) {
		vm_page_unreserve_pages(&fMappingReservation);
		delete_area(fArea);
	}

	delete[] fPages;
	delete[] fVecs;

	mutex_destroy(&fSerializationLock);
}


status_t
IOCache::Init(const char* name)
{
	TRACE("%p->IOCache::Init(\"%s\")\n", this, name);

	status_t error = IOScheduler::Init(name);
	if (error != B_OK)
		return error;

	// create the area for mapping cache lines
	fArea = vm_create_null_area(B_SYSTEM_TEAM, "I/O cache line", &fAreaBase,
		B_ANY_KERNEL_ADDRESS, fLineSize, 0);
	if (fArea < 0)
		return fArea;

	// reserve pages for mapping a complete cache line
	VMAddressSpace* addressSpace = VMAddressSpace::Kernel();
	VMTranslationMap* translationMap = addressSpace->TranslationMap();
	size_t pagesNeeded = translationMap->MaxPagesNeededToMap((addr_t)fAreaBase,
		(addr_t)fAreaBase + fLineSize - 1);
	vm_page_reserve_pages(&fMappingReservation, pagesNeeded,
		VM_PRIORITY_SYSTEM);

	// get the area's cache
	VMArea* area = VMAreas::Lookup(fArea);
	if (area == NULL) {
		panic("IOCache::Init(): Where's our area (id: %" B_PRId32 ")?!", fArea);
		return B_ERROR;
	}
	fCache = area->cache;

	// allocate arrays for pages and io vecs
	fPages = new(std::nothrow) vm_page*[fPagesPerLine];
	fVecs = new(std::nothrow) generic_io_vec[fPagesPerLine];
	if (fPages == NULL || fVecs == NULL)
		return B_NO_MEMORY;

	return B_OK;
}


void
IOCache::SetDeviceCapacity(off_t deviceCapacity)
{
	TRACE("%p->IOCache::SetDeviceCapacity(%" B_PRIdOFF ")\n", this,
		deviceCapacity);

	MutexLocker serializationLocker(fSerializationLock);
	AutoLocker<VMCache> cacheLocker(fCache);

	fDeviceCapacity = deviceCapacity;
}


void
IOCache::MediaChanged()
{
	TRACE("%p->IOCache::MediaChanged()\n", this);

	MutexLocker serializationLocker(fSerializationLock);
	AutoLocker<VMCache> cacheLocker(fCache);

	// new media -- burn all cached data
	while (vm_page* page = fCache->pages.Root()) {
		DEBUG_PAGE_ACCESS_START(page);
		fCache->RemovePage(page);
		vm_page_free(NULL, page);
	}
}


status_t
IOCache::ScheduleRequest(IORequest* request)
{
	TRACE("%p->IOCache::ScheduleRequest(%p)\n", this, request);

	// lock the request's memory
	status_t error;
	IOBuffer* buffer = request->Buffer();
	if (buffer->IsVirtual()) {
		error = buffer->LockMemory(request->TeamID(), request->IsWrite());
		if (error != B_OK) {
			request->SetStatusAndNotify(error);
			return error;
		}
	}

	// we completely serialize all I/O in FIFO order
	MutexLocker serializationLocker(fSerializationLock);
	generic_size_t bytesTransferred = 0;
	error = _DoRequest(request, bytesTransferred);
	serializationLocker.Unlock();

	// unlock memory
	if (buffer->IsVirtual())
		buffer->UnlockMemory(request->TeamID(), request->IsWrite());

	// set status and notify
	if (error == B_OK) {
		request->SetTransferredBytes(bytesTransferred < request->Length(),
			bytesTransferred);
		request->SetStatusAndNotify(B_OK);
	} else
		request->SetStatusAndNotify(error);

	return error;
}


void
IOCache::AbortRequest(IORequest* request, status_t status)
{
	// TODO:...
}


void
IOCache::OperationCompleted(IOOperation* operation, status_t status,
	generic_size_t transferredBytes)
{
	operation->SetStatus(status, transferredBytes);

	if (status == B_OK) {
		// always fail in case of partial transfers
		((Operation*)operation)->finishedCondition.NotifyAll(
			transferredBytes == operation->Length() ? B_OK : B_ERROR);
	} else
		((Operation*)operation)->finishedCondition.NotifyAll(status);
}


void
IOCache::Dump() const
{
	kprintf("IOCache at %p\n", this);
	kprintf("  DMA resource:   %p\n", fDMAResource);
}


status_t
IOCache::_DoRequest(IORequest* request, generic_size_t& _bytesTransferred)
{
	off_t offset = request->Offset();
	generic_size_t length = request->Length();

	TRACE("%p->IOCache::ScheduleRequest(%p): offset: %" B_PRIdOFF
		", length: %" B_PRIuSIZE "\n", this, request, offset, length);

	if (offset < 0 || offset > fDeviceCapacity)
		return B_BAD_VALUE;

	// truncate the request to the device capacity
	if (fDeviceCapacity - offset < (off_t)length)
		length = fDeviceCapacity - offset;

	_bytesTransferred = 0;

	while (length > 0) {
		// the start of the current cache line
		off_t lineOffset = (offset >> fLineSizeShift) << fLineSizeShift;

		// intersection of request and cache line
		off_t cacheLineEnd = std::min(lineOffset + (off_t)fLineSize, fDeviceCapacity);
		size_t requestLineLength
			= std::min(cacheLineEnd - offset, (off_t)length);

		// transfer the data of the cache line
		status_t error = _TransferRequestLine(request, lineOffset,
			cacheLineEnd - lineOffset, offset, requestLineLength);
		if (error != B_OK)
			return error;

		offset = cacheLineEnd;
		length -= requestLineLength;
		_bytesTransferred += requestLineLength;
	}

	return B_OK;
}


status_t
IOCache::_TransferRequestLine(IORequest* request, off_t lineOffset,
	size_t lineSize, off_t requestOffset, size_t requestLength)
{
	TRACE("%p->IOCache::_TransferRequestLine(%p, %" B_PRIdOFF
		", %" B_PRIdOFF  ", %" B_PRIuSIZE ")\n", this, request, lineOffset,
		requestOffset, requestLength);

	// check whether there are pages of the cache line and the mark them used
	page_num_t firstPageOffset = lineOffset / B_PAGE_SIZE;
	page_num_t linePageCount = (lineSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

	AutoLocker<VMCache> cacheLocker(fCache);

	page_num_t firstMissing = 0;
	page_num_t lastMissing = 0;
	page_num_t missingPages = 0;
	page_num_t pageOffset = firstPageOffset;

	VMCachePagesTree::Iterator it = fCache->pages.GetIterator(pageOffset, true,
		true);
	while (pageOffset < firstPageOffset + linePageCount) {
		vm_page* page = it.Next();
		page_num_t currentPageOffset;
		if (page == NULL
			|| page->cache_offset >= firstPageOffset + linePageCount) {
			page = NULL;
			currentPageOffset = firstPageOffset + linePageCount;
		} else
			currentPageOffset = page->cache_offset;

		if (pageOffset < currentPageOffset) {
			// pages are missing
			if (missingPages == 0)
				firstMissing = pageOffset;
			lastMissing = currentPageOffset - 1;
			missingPages += currentPageOffset - pageOffset;

			for (; pageOffset < currentPageOffset; pageOffset++)
				fPages[pageOffset - firstPageOffset] = NULL;
		}

		if (page != NULL) {
			fPages[pageOffset++ - firstPageOffset] = page;
			DEBUG_PAGE_ACCESS_START(page);
			vm_page_set_state(page, PAGE_STATE_UNUSED);
			DEBUG_PAGE_ACCESS_END(page);
		}
	}

	cacheLocker.Unlock();

	bool isVIP = (request->Flags() & B_VIP_IO_REQUEST) != 0;

	if (missingPages > 0) {
// TODO: If this is a read request and the missing pages range doesn't intersect
// with the request, just satisfy the request and don't read anything at all.
		// There are pages of the cache line missing. We have to allocate fresh
		// ones.

		// reserve
		vm_page_reservation reservation;
		if (!vm_page_try_reserve_pages(&reservation, missingPages,
				VM_PRIORITY_SYSTEM)) {
			_DiscardPages(firstMissing - firstPageOffset, missingPages);

			// fall back to uncached transfer
			return _TransferRequestLineUncached(request, lineOffset,
				requestOffset, requestLength);
		}

		// Allocate the missing pages and remove the already existing pages in
		// the range from the cache. We're going to read/write the whole range
		// anyway and this way we can sort it, possibly improving the physical
		// vecs.
// TODO: When memory is low, we should consider cannibalizing ourselves or
// simply transferring past the cache!
		for (pageOffset = firstMissing; pageOffset <= lastMissing;
				pageOffset++) {
			page_num_t index = pageOffset - firstPageOffset;
			if (fPages[index] == NULL) {
				fPages[index] = vm_page_allocate_page(&reservation,
					PAGE_STATE_UNUSED);
				DEBUG_PAGE_ACCESS_END(fPages[index]);
			} else {
				cacheLocker.Lock();
				fCache->RemovePage(fPages[index]);
				cacheLocker.Unlock();
			}
		}

		missingPages = lastMissing - firstMissing + 1;

		// sort the page array by physical page number
		std::sort(fPages + firstMissing - firstPageOffset,
			fPages + lastMissing - firstPageOffset + 1,
			page_physical_number_less);

		// add the pages to the cache
		cacheLocker.Lock();

		for (pageOffset = firstMissing; pageOffset <= lastMissing;
				pageOffset++) {
			page_num_t index = pageOffset - firstPageOffset;
			fCache->InsertPage(fPages[index], (off_t)pageOffset * B_PAGE_SIZE);
		}

		cacheLocker.Unlock();

		// Read in the missing pages, if this is a read request or a write
		// request that doesn't cover the complete missing range.
		if (request->IsRead()
			|| requestOffset < (off_t)firstMissing * B_PAGE_SIZE
			|| requestOffset + (off_t)requestLength
				> (off_t)(lastMissing + 1) * B_PAGE_SIZE) {
			status_t error = _TransferPages(firstMissing - firstPageOffset,
				missingPages, false, isVIP);
			if (error != B_OK) {
				dprintf("IOCache::_TransferRequestLine(): Failed to read into "
					"cache (offset: %" B_PRIdOFF ", length: %" B_PRIuSIZE "), "
					"trying uncached read (offset: %" B_PRIdOFF ", length: %"
					B_PRIuSIZE ")\n", (off_t)firstMissing * B_PAGE_SIZE,
					(size_t)missingPages * B_PAGE_SIZE, requestOffset,
					requestLength);

				_DiscardPages(firstMissing - firstPageOffset, missingPages);

				// Try again using an uncached transfer
				return _TransferRequestLineUncached(request, lineOffset,
					requestOffset, requestLength);
			}
		}
	}

	if (request->IsRead()) {
		// copy data to request
		status_t error = _CopyPages(request, requestOffset - lineOffset,
			requestOffset, requestLength, true);
		_CachePages(0, linePageCount);
		return error;
	}

	// copy data from request
	status_t error = _CopyPages(request, requestOffset - lineOffset,
		requestOffset, requestLength, false);
	if (error != B_OK) {
		_DiscardPages(0, linePageCount);
		return error;
	}

	// write the pages to disk
	page_num_t firstPage = (requestOffset - lineOffset) / B_PAGE_SIZE;
	page_num_t endPage = (requestOffset + requestLength - lineOffset
		+ B_PAGE_SIZE - 1) / B_PAGE_SIZE;
	error = _TransferPages(firstPage, endPage - firstPage, true, isVIP);

	if (error != B_OK) {
		_DiscardPages(firstPage, endPage - firstPage);
		return error;
	}

	_CachePages(0, linePageCount);
	return error;
}


status_t
IOCache::_TransferRequestLineUncached(IORequest* request, off_t lineOffset,
	off_t requestOffset, size_t requestLength)
{
	TRACE("%p->IOCache::_TransferRequestLineUncached(%p, %" B_PRIdOFF
		", %" B_PRIdOFF  ", %" B_PRIuSIZE ")\n", this, request, lineOffset,
		requestOffset, requestLength);

	// Advance the request to the interesting offset, so the DMAResource can
	// provide us with fitting operations.
	off_t actualRequestOffset
		= request->Offset() + request->Length() - request->RemainingBytes();
	if (actualRequestOffset > requestOffset) {
		dprintf("IOCache::_TransferRequestLineUncached(): Request %p advanced "
			"beyond current cache line (%" B_PRIdOFF " vs. %" B_PRIdOFF ")\n",
			request, actualRequestOffset, requestOffset);
		return B_BAD_VALUE;
	}

	if (actualRequestOffset < requestOffset)
		request->Advance(requestOffset - actualRequestOffset);

	generic_size_t requestRemaining = request->RemainingBytes() - requestLength;

	// Process single operations until the specified part of the request is
	// finished or until an error occurs.
	Operation operation;
	operation.finishedCondition.Init(this, "I/O cache operation finished");

	while (request->RemainingBytes() > requestRemaining
		&& request->Status() > 0) {
		status_t error = fDMAResource->TranslateNext(request, &operation,
			request->RemainingBytes() - requestRemaining);
		if (error != B_OK)
			return error;

		error = _DoOperation(operation);

		request->OperationFinished(&operation);
		request->SetUnfinished();
			// Keep the request in unfinished state. ScheduleRequest() will set
			// the final status and notify.

		fDMAResource->RecycleBuffer(operation.Buffer());

		if (error != B_OK) {
			TRACE("%p->IOCache::_TransferRequestLineUncached(): operation at "
				"%" B_PRIdOFF " failed: %s\n", this, operation.Offset(),
				strerror(error));
			return error;
		}
	}

	return B_OK;
}


status_t
IOCache::_DoOperation(Operation& operation)
{
	TRACE("%p->IOCache::_DoOperation(%" B_PRIdOFF ", %" B_PRIuSIZE ")\n", this,
		operation.Offset(), operation.Length());

	while (true) {
		ConditionVariableEntry waitEntry;
		operation.finishedCondition.Add(&waitEntry);

		status_t error = fIOCallback(fIOCallbackData, &operation);
		if (error != B_OK) {
			operation.finishedCondition.NotifyAll(error);
				// removes the entry from the variable
			return error;
		}

		// wait for the operation to finish
		error = waitEntry.Wait();
		if (error != B_OK)
			return error;

		if (operation.Finish())
			return B_OK;
	}
}


status_t
IOCache::_TransferPages(size_t firstPage, size_t pageCount, bool isWrite,
	bool isVIP)
{
	TRACE("%p->IOCache::_TransferPages(%" B_PRIuSIZE ", %" B_PRIuSIZE
		", write: %d, vip: %d)\n", this, firstPage, pageCount, isWrite, isVIP);

	off_t firstPageOffset = (off_t)fPages[firstPage]->cache_offset
		* B_PAGE_SIZE;
	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;
	phys_addr_t vecsEndAddress = 0;
	for (size_t i = firstPage; i < endPage; i++) {
		phys_addr_t pageAddress
			= (phys_addr_t)fPages[i]->physical_page_number * B_PAGE_SIZE;
		if (vecCount == 0 || pageAddress != vecsEndAddress) {
			fVecs[vecCount].base = pageAddress;
			fVecs[vecCount++].length = B_PAGE_SIZE;
			vecsEndAddress = pageAddress + B_PAGE_SIZE;
		} else {
			// extend the previous vec
			fVecs[vecCount - 1].length += B_PAGE_SIZE;
			vecsEndAddress += B_PAGE_SIZE;
		}
	}

	// Don't try to read past the end of the device just to fill a page;
	// this makes sure that sum(fVecs[].length) == requestLength
	generic_size_t padLength = B_PAGE_SIZE - requestLength % B_PAGE_SIZE;
	if (vecCount > 0 && padLength != B_PAGE_SIZE)
		fVecs[vecCount - 1].length -= padLength;

	// create a request for the transfer
	IORequest request;
	status_t error = request.Init(firstPageOffset, fVecs, vecCount,
		requestLength, isWrite,
		B_PHYSICAL_IO_REQUEST | (isVIP ? B_VIP_IO_REQUEST : 0));
	if (error != B_OK)
		return error;

	// Process single operations until the complete request is finished or
	// until an error occurs.
	Operation operation;
	operation.finishedCondition.Init(this, "I/O cache operation finished");

	while (request.RemainingBytes() > 0 && request.Status() > 0) {
		error = fDMAResource->TranslateNext(&request, &operation,
			requestLength);
		if (error != B_OK)
			return error;

		error = _DoOperation(operation);

		request.RemoveOperation(&operation);

		fDMAResource->RecycleBuffer(operation.Buffer());

		if (error != B_OK) {
			TRACE("%p->IOCache::_TransferLine(): operation at %" B_PRIdOFF
				" failed: %s\n", this, operation.Offset(), strerror(error));
			return error;
		}
	}

	return B_OK;
}


/*!	Frees all pages in given range of the \c fPages array.
	\c NULL entries in the range are OK. All non \c NULL entries must refer
	to pages with \c PAGE_STATE_UNUSED. The pages may belong to \c fCache or
	may not have a cache.
	\c fCache must not be locked.
*/
void
IOCache::_DiscardPages(size_t firstPage, size_t pageCount)
{
	TRACE("%p->IOCache::_DiscardPages(%" B_PRIuSIZE ", %" B_PRIuSIZE ")\n",
		this, firstPage, pageCount);

	AutoLocker<VMCache> cacheLocker(fCache);

	for (size_t i = firstPage; i < firstPage + pageCount; i++) {
		vm_page* page = fPages[i];
		if (page == NULL)
			continue;

		DEBUG_PAGE_ACCESS_START(page);

		ASSERT_PRINT(page->State() == PAGE_STATE_UNUSED,
			"page: %p @! page -m %p", page, page);

		if (page->Cache() != NULL)
			fCache->RemovePage(page);

		vm_page_free(NULL, page);
	}
}


/*!	Marks all pages in the given range of the \c fPages array cached.
	There must not be any \c NULL entries in the given array range. All pages
	must belong to \c cache and have state \c PAGE_STATE_UNUSED.
	\c fCache must not be locked.
*/
void
IOCache::_CachePages(size_t firstPage, size_t pageCount)
{
	TRACE("%p->IOCache::_CachePages(%" B_PRIuSIZE ", %" B_PRIuSIZE ")\n",
		this, firstPage, pageCount);

	AutoLocker<VMCache> cacheLocker(fCache);

	for (size_t i = firstPage; i < firstPage + pageCount; i++) {
		vm_page* page = fPages[i];
		ASSERT(page != NULL);
		ASSERT_PRINT(page->State() == PAGE_STATE_UNUSED
				&& page->Cache() == fCache,
			"page: %p @! page -m %p", page, page);

		DEBUG_PAGE_ACCESS_START(page);
		vm_page_set_state(page, PAGE_STATE_CACHED);
		DEBUG_PAGE_ACCESS_END(page);
	}
}


/*!	Copies the contents of pages in \c fPages to \a request, or vice versa.
	\param request The request.
	\param pagesRelativeOffset The offset relative to \c fPages[0] where to
		start copying.
	\param requestOffset The request offset where to start copying.
	\param requestLength The number of bytes to copy.
	\param toRequest If \c true the copy directory is from \c fPages to
		\a request, otherwise the other way around.
	\return \c B_OK, if copying went fine, another error code otherwise.
*/
status_t
IOCache::_CopyPages(IORequest* request, size_t pagesRelativeOffset,
	off_t requestOffset, size_t requestLength, bool toRequest)
{
	TRACE("%p->IOCache::_CopyPages(%p, %" B_PRIuSIZE ", %" B_PRIdOFF
		", %" B_PRIuSIZE ", %d)\n", this, request, pagesRelativeOffset,
		requestOffset, requestLength, toRequest);

	size_t firstPage = pagesRelativeOffset / B_PAGE_SIZE;
	size_t endPage = (pagesRelativeOffset + requestLength + B_PAGE_SIZE - 1)
		/ B_PAGE_SIZE;

	// map the pages
	status_t error = _MapPages(firstPage, endPage);
// TODO: _MapPages() cannot fail, so the fallback is never needed. Test which
// method is faster (probably the active one)!
#if 0
	if (error != B_OK) {
		// fallback to copying individual pages
		size_t inPageOffset = pagesRelativeOffset % B_PAGE_SIZE;
		for (size_t i = firstPage; i < endPage; i++) {
			// map the page
			void* handle;
			addr_t address;
			error = vm_get_physical_page(
				fPages[i]->physical_page_number * B_PAGE_SIZE, &address,
				&handle);
			if (error != B_OK)
				return error;

			// copy the page's data
			size_t toCopy = std::min(B_PAGE_SIZE - inPageOffset, requestLength);

			if (toRequest) {
				error = request->CopyData((uint8*)(address + inPageOffset),
					requestOffset, toCopy);
			} else {
				error = request->CopyData(requestOffset,
					(uint8*)(address + inPageOffset), toCopy);
			}

			// unmap the page
			vm_put_physical_page(address, handle);

			if (error != B_OK)
				return error;

			inPageOffset = 0;
			requestOffset += toCopy;
			requestLength -= toCopy;
		}

		return B_OK;
	}
#endif	// 0

	// copy
	if (toRequest) {
		error = request->CopyData((uint8*)fAreaBase + pagesRelativeOffset,
			requestOffset, requestLength);
	} else {
		error = request->CopyData(requestOffset,
			(uint8*)fAreaBase + pagesRelativeOffset, requestLength);
	}

	// unmap the pages
	_UnmapPages(firstPage, endPage);

	return error;
}


/*!	Maps a range of pages in \c fPages into fArea.

	If successful, it must be balanced by a call to _UnmapPages().

	\param firstPage The \c fPages relative index of the first page to map.
	\param endPage The \c fPages relative index of the page after the last page
		to map.
	\return \c B_OK, if mapping went fine, another error code otherwise.
*/
status_t
IOCache::_MapPages(size_t firstPage, size_t endPage)
{
	VMTranslationMap* translationMap
		= VMAddressSpace::Kernel()->TranslationMap();

	translationMap->Lock();

	for (size_t i = firstPage; i < endPage; i++) {
		vm_page* page = fPages[i];

		ASSERT_PRINT(page->State() == PAGE_STATE_UNUSED,
			"page: %p @! page -m %p", page, page);

		translationMap->Map((addr_t)fAreaBase + i * B_PAGE_SIZE,
			page->physical_page_number * B_PAGE_SIZE,
			B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA, 0, &fMappingReservation);
		// NOTE: We don't increment gMappedPagesCount. Our pages have state
		// PAGE_STATE_UNUSED anyway and we map them only for a short time.
	}

	translationMap->Unlock();

	return B_OK;
}


/*!	Unmaps a range of pages in \c fPages into fArea.

	Must balance a call to _MapPages().

	\param firstPage The \c fPages relative index of the first page to unmap.
	\param endPage The \c fPages relative index of the page after the last page
		to unmap.
*/
void
IOCache::_UnmapPages(size_t firstPage, size_t endPage)
{
	VMTranslationMap* translationMap
		= VMAddressSpace::Kernel()->TranslationMap();

	translationMap->Lock();

	translationMap->Unmap((addr_t)fAreaBase + firstPage * B_PAGE_SIZE,
		(addr_t)fAreaBase + endPage * B_PAGE_SIZE - 1);

	translationMap->Unlock();
}