Loading...
--- xnu/xnu-1228/iokit/Kernel/IOMemoryDescriptor.cpp
+++ xnu/xnu-792/iokit/Kernel/IOMemoryDescriptor.cpp
@@ -1,29 +1,23 @@
/*
- * Copyright (c) 1998-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 1998-2004 Apple Computer, Inc. All rights reserved.
*
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ * @APPLE_LICENSE_HEADER_START@
*
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
+ * The contents of this file constitute Original Code as defined in and
+ * are subject to the Apple Public Source License Version 1.1 (the
+ * "License"). You may not use this file except in compliance with the
+ * License. Please obtain a copy of the License at
+ * http://www.apple.com/publicsource and read it before using this file.
*
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * This Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
*
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ * @APPLE_LICENSE_HEADER_END@
*/
/*
* Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
@@ -42,10 +36,8 @@
#include <IOKit/IOKitKeysPrivate.h>
#include <IOKit/IOKitDebug.h>
-#include <libkern/OSDebug.h>
#include "IOKitKernelInternal.h"
-#include "IOCopyMapper.h"
#include <libkern/c++/OSContainers.h>
#include <libkern/c++/OSDictionary.h>
@@ -58,13 +50,15 @@
__BEGIN_DECLS
#include <vm/pmap.h>
#include <vm/vm_pageout.h>
+#include <vm/vm_shared_memory_server.h>
#include <mach/memory_object_types.h>
#include <device/device_port.h>
+#ifndef i386
#include <mach/vm_prot.h>
-#include <mach/mach_vm.h>
#include <vm/vm_fault.h>
-#include <vm/vm_protos.h>
+struct phys_entry *pmap_find_physentry(ppnum_t pa);
+#endif
extern ppnum_t pmap_find_phys(pmap_t pmap, addr64_t va);
void ipc_port_release_send(ipc_port_t port);
@@ -103,13 +97,8 @@
#define kIOMaximumMappedIOByteCount (512*1024*1024)
-static IOMapper * gIOSystemMapper = NULL;
-
-IOCopyMapper * gIOCopyMapper = NULL;
-
+static IOMapper * gIOSystemMapper;
static ppnum_t gIOMaximumMappedIOPageCount = atop_32(kIOMaximumMappedIOByteCount);
-
-ppnum_t gIOLastPage;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -129,29 +118,23 @@
#define WAKEUP \
IORecursiveLockWakeup( gIOMemoryLock, (void *)this, /* one-thread */ false)
-#if 0
-#define DEBG(fmt, args...) { kprintf(fmt, ## args); }
-#else
-#define DEBG(fmt, args...) {}
-#endif
-
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
class _IOMemoryMap : public IOMemoryMap
{
OSDeclareDefaultStructors(_IOMemoryMap)
public:
- IOMemoryDescriptor * fMemory;
- IOMemoryMap * fSuperMap;
- mach_vm_size_t fOffset;
- mach_vm_address_t fAddress;
- mach_vm_size_t fLength;
- task_t fAddressTask;
- vm_map_t fAddressMap;
- IOOptionBits fOptions;
- upl_t fRedirUPL;
- ipc_port_t fRedirEntry;
- IOMemoryDescriptor * fOwner;
+ IOMemoryDescriptor * memory;
+ IOMemoryMap * superMap;
+ IOByteCount offset;
+ IOByteCount length;
+ IOVirtualAddress logical;
+ task_t addressTask;
+ vm_map_t addressMap;
+ IOOptionBits options;
+ upl_t redirUPL;
+ ipc_port_t redirEntry;
+ IOMemoryDescriptor * owner;
protected:
virtual void taggedRelease(const void *tag = 0) const;
@@ -163,8 +146,6 @@
virtual IOVirtualAddress getVirtualAddress();
virtual IOByteCount getLength();
virtual task_t getAddressTask();
- virtual mach_vm_address_t getAddress();
- virtual mach_vm_size_t getSize();
virtual IOMemoryDescriptor * getMemoryDescriptor();
virtual IOOptionBits getMapOptions();
@@ -175,24 +156,31 @@
IOOptionBits options,
IOByteCount offset = 0);
- virtual IOReturn redirect(IOMemoryDescriptor * newBackingMemory,
- IOOptionBits options,
- mach_vm_size_t offset = 0);
-
virtual IOPhysicalAddress getPhysicalSegment(IOByteCount offset,
IOByteCount * length);
// for IOMemoryDescriptor use
- _IOMemoryMap * copyCompatible( _IOMemoryMap * newMapping );
-
- bool init(
+ _IOMemoryMap * copyCompatible(
+ IOMemoryDescriptor * owner,
+ task_t intoTask,
+ IOVirtualAddress toAddress,
+ IOOptionBits options,
+ IOByteCount offset,
+ IOByteCount length );
+
+ bool initCompatible(
+ IOMemoryDescriptor * memory,
+ IOMemoryMap * superMap,
+ IOByteCount offset,
+ IOByteCount length );
+
+ bool initWithDescriptor(
+ IOMemoryDescriptor * memory,
task_t intoTask,
- mach_vm_address_t toAddress,
+ IOVirtualAddress toAddress,
IOOptionBits options,
- mach_vm_size_t offset,
- mach_vm_size_t length );
-
- bool setMemoryDescriptor(IOMemoryDescriptor * _memory, mach_vm_size_t _offset);
+ IOByteCount offset,
+ IOByteCount length );
IOReturn redirect(
task_t intoTask, bool redirect );
@@ -303,17 +291,11 @@
getAddrLenForInd(user_addr_t &addr, IOPhysicalLength &len, // Output variables
UInt32 type, IOGeneralMemoryDescriptor::Ranges r, UInt32 ind)
{
- assert(kIOMemoryTypeUIO == type
- || kIOMemoryTypeVirtual == type || kIOMemoryTypeVirtual64 == type
- || kIOMemoryTypePhysical == type || kIOMemoryTypePhysical64 == type);
+ assert(kIOMemoryTypePhysical == type || kIOMemoryTypeUIO == type
+ || kIOMemoryTypeVirtual == type);
if (kIOMemoryTypeUIO == type) {
user_size_t us;
uio_getiov((uio_t) r.uio, ind, &addr, &us); len = us;
- }
- else if ((kIOMemoryTypeVirtual64 == type) || (kIOMemoryTypePhysical64 == type)) {
- IOAddressRange cur = r.v64[ind];
- addr = cur.address;
- len = cur.length;
}
else {
IOVirtualRange cur = r.v[ind];
@@ -346,15 +328,6 @@
IODirection direction,
task_t task)
{
-#if TEST_V64
- if (task)
- {
- IOOptionBits options = (IOOptionBits) direction;
- if (task == kernel_task)
- options |= kIOMemoryAutoPrepare;
- return (IOMemoryDescriptor::withAddressRange(address, length, options, task));
- }
-#endif
IOGeneralMemoryDescriptor * that = new IOGeneralMemoryDescriptor;
if (that)
{
@@ -372,9 +345,6 @@
IOByteCount length,
IODirection direction )
{
-#if TEST_P64
- return (IOMemoryDescriptor::withAddressRange(address, length, (IOOptionBits) direction, NULL));
-#endif
IOGeneralMemoryDescriptor *self = new IOGeneralMemoryDescriptor;
if (self
&& !self->initWithPhysicalAddress(address, length, direction)) {
@@ -400,39 +370,6 @@
that->release();
}
- return 0;
-}
-
-IOMemoryDescriptor *
-IOMemoryDescriptor::withAddressRange(mach_vm_address_t address,
- mach_vm_size_t length,
- IOOptionBits options,
- task_t task)
-{
- IOAddressRange range = { address, length };
- return (IOMemoryDescriptor::withAddressRanges(&range, 1, options, task));
-}
-
-IOMemoryDescriptor *
-IOMemoryDescriptor::withAddressRanges(IOAddressRange * ranges,
- UInt32 rangeCount,
- IOOptionBits options,
- task_t task)
-{
- IOGeneralMemoryDescriptor * that = new IOGeneralMemoryDescriptor;
- if (that)
- {
- if (task)
- options |= kIOMemoryTypeVirtual64;
- else
- options |= kIOMemoryTypePhysical64;
-
- if (that->initWithOptions(ranges, rangeCount, 0, task, options, /* mapper */ 0))
- return that;
-
- that->release();
- }
-
return 0;
}
@@ -510,8 +447,8 @@
return self;
}
-IOMemoryDescriptor *
-IOMemoryDescriptor::withPersistentMemoryDescriptor(IOMemoryDescriptor *originalMD)
+IOMemoryDescriptor * IOMemoryDescriptor::
+ withPersistentMemoryDescriptor(IOMemoryDescriptor *originalMD)
{
IOGeneralMemoryDescriptor *origGenMD =
OSDynamicCast(IOGeneralMemoryDescriptor, originalMD);
@@ -523,8 +460,8 @@
return 0;
}
-IOMemoryDescriptor *
-IOGeneralMemoryDescriptor::withPersistentMemoryDescriptor(IOGeneralMemoryDescriptor *originalMD)
+IOMemoryDescriptor * IOGeneralMemoryDescriptor::
+ withPersistentMemoryDescriptor(IOGeneralMemoryDescriptor *originalMD)
{
ipc_port_t sharedMem = (ipc_port_t) originalMD->createNamedEntry();
@@ -569,12 +506,7 @@
: get_task_map(_task);
memory_object_size_t actualSize = size;
- vm_prot_t prot = VM_PROT_READ;
-#if CONFIG_EMBEDDED
- if (kIODirectionOut != (kIODirectionOutIn & _flags))
-#endif
- prot |= VM_PROT_WRITE;
-
+ vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
if (_memEntry)
prot |= MAP_MEM_NAMED_REUSE;
@@ -676,7 +608,7 @@
// Auto-prepare if this is a kernel memory descriptor as very few
// clients bother to prepare() kernel memory.
- // But it was not enforced so what are you going to do?
+ // But it was not enforced so what are you going to do?
if (task == kernel_task)
mdOpts |= kIOMemoryAutoPrepare;
}
@@ -739,22 +671,13 @@
switch (type) {
case kIOMemoryTypeUIO:
case kIOMemoryTypeVirtual:
- case kIOMemoryTypeVirtual64:
assert(task);
if (!task)
return false;
-
- if (vm_map_is_64bit(get_task_map(task))
- && (kIOMemoryTypeVirtual == type)
- && ((IOVirtualRange *) buffers)->address)
- {
- OSReportWithBacktrace("IOMemoryDescriptor: attempt to create 32b virtual in 64b task, use ::withAddressRange()");
- return false;
- }
- break;
+ else
+ break;
case kIOMemoryTypePhysical: // Neither Physical nor UPL should have a task
- case kIOMemoryTypePhysical64:
mapper = kIOMapperNone;
case kIOMemoryTypeUPL:
@@ -778,26 +701,15 @@
* An existing memory descriptor is being retargeted to point to
* somewhere else. Clean up our present state.
*/
- IOOptionBits type = _flags & kIOMemoryTypeMask;
- if ((kIOMemoryTypePhysical != type) && (kIOMemoryTypePhysical64 != type))
- {
- while (_wireCount)
- complete();
- }
+
+ while (_wireCount)
+ complete();
+ if (_kernPtrAligned)
+ unmapFromKernel();
if (_ranges.v && _rangesIsAllocated)
- {
- if (kIOMemoryTypeUIO == type)
- uio_free((uio_t) _ranges.v);
- else if ((kIOMemoryTypeVirtual64 == type) || (kIOMemoryTypePhysical64 == type))
- IODelete(_ranges.v64, IOAddressRange, _rangesCount);
- else
- IODelete(_ranges.v, IOVirtualRange, _rangesCount);
- }
-
+ IODelete(_ranges.v, IOVirtualRange, _rangesCount);
if (_memEntry)
{ ipc_port_release_send((ipc_port_t) _memEntry); _memEntry = 0; }
- if (_mappings)
- _mappings->flushCollection();
}
else {
if (!super::init())
@@ -808,7 +720,7 @@
// Grab the appropriate mapper
if (mapper == kIOMapperNone)
mapper = 0; // No Mapper
- else if (mapper == kIOMapperSystem) {
+ else if (!mapper) {
IOMapper::checkForSystemMapper();
gIOSystemMapper = mapper = IOMapper::gSystem;
}
@@ -820,22 +732,11 @@
// DEPRECATED variable initialisation
_direction = (IODirection) (_flags & kIOMemoryDirectionMask);
-
- __iomd_reservedA = 0;
- __iomd_reservedB = 0;
- _highestPage = 0;
-
- if (kIOMemoryThreadSafe & options)
- {
- if (!_prepareLock)
- _prepareLock = IOLockAlloc();
- }
- else if (_prepareLock)
- {
- IOLockFree(_prepareLock);
- _prepareLock = NULL;
- }
-
+ _position = 0;
+ _kernPtrAligned = 0;
+ _cachedPhysicalAddress = 0;
+ _cachedVirtualAddress = 0;
+
if (kIOMemoryTypeUPL == type) {
ioGMDData *dataP;
@@ -854,7 +755,7 @@
dataP->fMapper = mapper;
dataP->fPageCnt = 0;
- // _wireCount++; // UPLs start out life wired
+ _wireCount++; // UPLs start out life wired
_length = count;
_pages += atop_32(offset + count + PAGE_MASK) - atop_32(offset);
@@ -866,9 +767,6 @@
// Set the flag kIOPLOnDevice convieniently equal to 1
iopl.fFlags = pageList->device | kIOPLExternUPL;
iopl.fIOMDOffset = 0;
-
- _highestPage = upl_get_highest_page(iopl.fIOPL);
-
if (!pageList->device) {
// Pre-compute the offset into the UPL's page list
pageList = &pageList[atop_32(offset)];
@@ -888,8 +786,7 @@
_memoryEntries->appendBytes(&iopl, sizeof(iopl));
}
else {
- // kIOMemoryTypeVirtual | kIOMemoryTypeVirtual64 | kIOMemoryTypeUIO
- // kIOMemoryTypePhysical | kIOMemoryTypePhysical64
+ // kIOMemoryTypeVirtual | kIOMemoryTypeUIO | kIOMemoryTypePhysical
// Initialize the memory descriptor
if (options & kIOMemoryAsReference) {
@@ -902,28 +799,13 @@
_ranges.v = (IOVirtualRange *) buffers;
}
else {
+ assert(kIOMemoryTypeUIO != type);
+
_rangesIsAllocated = true;
- switch (_flags & kIOMemoryTypeMask)
- {
- case kIOMemoryTypeUIO:
- _ranges.v = (IOVirtualRange *) uio_duplicate((uio_t) buffers);
- break;
-
- case kIOMemoryTypeVirtual64:
- case kIOMemoryTypePhysical64:
- _ranges.v64 = IONew(IOAddressRange, count);
- if (!_ranges.v64)
- return false;
- bcopy(buffers, _ranges.v, count * sizeof(IOAddressRange));
- break;
- case kIOMemoryTypeVirtual:
- case kIOMemoryTypePhysical:
- _ranges.v = IONew(IOVirtualRange, count);
- if (!_ranges.v)
- return false;
- bcopy(buffers, _ranges.v, count * sizeof(IOVirtualRange));
- break;
- }
+ _ranges.v = IONew(IOVirtualRange, count);
+ if (!_ranges.v)
+ return false;
+ bcopy(buffers, _ranges.v, count * sizeof(IOVirtualRange));
}
// Find starting address within the vector of ranges
@@ -938,15 +820,8 @@
getAddrLenForInd(addr, len, type, vec, ind);
pages += (atop_64(addr + len + PAGE_MASK) - atop_64(addr));
len += length;
- assert(len >= length); // Check for 32 bit wrap around
+ assert(len > length); // Check for 32 bit wrap around
length = len;
-
- if ((kIOMemoryTypePhysical == type) || (kIOMemoryTypePhysical64 == type))
- {
- ppnum_t highPage = atop_64(addr + len - 1);
- if (highPage > _highestPage)
- _highestPage = highPage;
- }
}
_length = length;
_pages = pages;
@@ -954,9 +829,9 @@
// Auto-prepare memory at creation time.
// Implied completion when descriptor is free-ed
- if ((kIOMemoryTypePhysical == type) || (kIOMemoryTypePhysical64 == type))
+ if (kIOMemoryTypePhysical == type)
_wireCount++; // Physical MDs are, by definition, wired
- else { /* kIOMemoryTypeVirtual | kIOMemoryTypeVirtual64 | kIOMemoryTypeUIO */
+ else { /* kIOMemoryTypeVirtual | kIOMemoryTypeUIO */
ioGMDData *dataP;
unsigned dataSize = computeDataSize(_pages, /* upls */ count * 2);
@@ -992,32 +867,20 @@
*/
void IOGeneralMemoryDescriptor::free()
{
- IOOptionBits type = _flags & kIOMemoryTypeMask;
-
+ LOCK;
if( reserved)
- {
- LOCK;
reserved->memory = 0;
- UNLOCK;
- }
-
- if ((kIOMemoryTypePhysical != type) && (kIOMemoryTypePhysical64 != type))
- {
- while (_wireCount)
- complete();
- }
+ UNLOCK;
+
+ while (_wireCount)
+ complete();
if (_memoryEntries)
_memoryEntries->release();
+ if (_kernPtrAligned)
+ unmapFromKernel();
if (_ranges.v && _rangesIsAllocated)
- {
- if (kIOMemoryTypeUIO == type)
- uio_free((uio_t) _ranges.v);
- else if ((kIOMemoryTypeVirtual64 == type) || (kIOMemoryTypePhysical64 == type))
- IODelete(_ranges.v64, IOAddressRange, _rangesCount);
- else
- IODelete(_ranges.v, IOVirtualRange, _rangesCount);
- }
+ IODelete(_ranges.v, IOVirtualRange, _rangesCount);
if (reserved && reserved->devicePager)
device_pager_deallocate( (memory_object_t) reserved->devicePager );
@@ -1026,9 +889,6 @@
// (ExpansionData) so no reserved access after this point
if (_memEntry)
ipc_port_release_send( (ipc_port_t) _memEntry );
-
- if (_prepareLock)
- IOLockFree(_prepareLock);
super::free();
}
@@ -1074,17 +934,17 @@
}
// @@@ gvdl: who is using this API? Seems like a wierd thing to implement.
-IOPhysicalAddress
-IOMemoryDescriptor::getSourceSegment( IOByteCount offset, IOByteCount * length )
-{
- addr64_t physAddr = 0;
+IOPhysicalAddress IOMemoryDescriptor::getSourceSegment( IOByteCount offset,
+ IOByteCount * length )
+{
+ IOPhysicalAddress physAddr = 0;
if( prepare() == kIOReturnSuccess) {
- physAddr = getPhysicalSegment64( offset, length );
+ physAddr = getPhysicalSegment( offset, length );
complete();
}
- return( (IOPhysicalAddress) physAddr ); // truncated but only page offset is used
+ return( physAddr );
}
IOByteCount IOMemoryDescriptor::readBytes
@@ -1097,6 +957,7 @@
assert(offset < _length);
assert(offset + length <= _length);
if (offset >= _length) {
+IOLog("IOGMD(%p): rB = o%lx, l%lx\n", this, offset, length); // @@@ gvdl
return 0;
}
@@ -1139,6 +1000,7 @@
assert( !(kIOMemoryPreparedReadOnly & _flags) );
if ( (kIOMemoryPreparedReadOnly & _flags) || offset >= _length) {
+IOLog("IOGMD(%p): wB = o%lx, l%lx\n", this, offset, length); // @@@ gvdl
return 0;
}
@@ -1176,250 +1038,137 @@
panic("IOGMD::setPosition deprecated");
/* DEPRECATED */ }
-IOReturn IOGeneralMemoryDescriptor::dmaCommandOperation(DMACommandOps op, void *vData, UInt dataSize) const
-{
- if (kIOMDGetCharacteristics == op) {
-
- if (dataSize < sizeof(IOMDDMACharacteristics))
- return kIOReturnUnderrun;
-
- IOMDDMACharacteristics *data = (IOMDDMACharacteristics *) vData;
- data->fLength = _length;
- data->fSGCount = _rangesCount;
- data->fPages = _pages;
- data->fDirection = _direction;
- if (!_wireCount)
- data->fIsPrepared = false;
- else {
- data->fIsPrepared = true;
- data->fHighestPage = _highestPage;
- if (_memoryEntries) {
- ioGMDData *gmdData = getDataP(_memoryEntries);
- ioPLBlock *ioplList = getIOPLList(gmdData);
- UInt count = getNumIOPL(_memoryEntries, gmdData);
-
- data->fIsMapped = (gmdData->fMapper && _pages && (count > 0)
- && ioplList[0].fMappedBase);
- if (count == 1)
- data->fPageAlign = (ioplList[0].fPageOffset & PAGE_MASK) | ~PAGE_MASK;
- }
- else
- data->fIsMapped = false;
- }
-
- return kIOReturnSuccess;
- }
- else if (!(kIOMDWalkSegments & op))
- return kIOReturnBadArgument;
-
- // Get the next segment
- struct InternalState {
- IOMDDMAWalkSegmentArgs fIO;
- UInt fOffset2Index;
- UInt fIndex;
- UInt fNextOffset;
- } *isP;
-
- // Find the next segment
- if (dataSize < sizeof(*isP))
- return kIOReturnUnderrun;
-
- isP = (InternalState *) vData;
- UInt offset = isP->fIO.fOffset;
- bool mapped = isP->fIO.fMapped;
-
- if (offset >= _length)
- return (offset == _length)? kIOReturnOverrun : kIOReturnInternalError;
-
- // Validate the previous offset
- UInt ind, off2Ind = isP->fOffset2Index;
- if ((kIOMDFirstSegment != op)
- && offset
- && (offset == isP->fNextOffset || off2Ind <= offset))
- ind = isP->fIndex;
- else
- ind = off2Ind = 0; // Start from beginning
-
- UInt length;
- UInt64 address;
- if ( (_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical) {
-
- // Physical address based memory descriptor
- const IOPhysicalRange *physP = (IOPhysicalRange *) &_ranges.p[0];
-
- // Find the range after the one that contains the offset
- UInt len;
- for (len = 0; off2Ind <= offset; ind++) {
- len = physP[ind].length;
- off2Ind += len;
- }
-
- // Calculate length within range and starting address
- length = off2Ind - offset;
- address = physP[ind - 1].address + len - length;
-
- // see how far we can coalesce ranges
- while (ind < _rangesCount && address + length == physP[ind].address) {
- len = physP[ind].length;
- length += len;
- off2Ind += len;
- ind++;
- }
-
- // correct contiguous check overshoot
- ind--;
- off2Ind -= len;
- }
- else if ( (_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical64) {
-
- // Physical address based memory descriptor
- const IOAddressRange *physP = (IOAddressRange *) &_ranges.v64[0];
-
- // Find the range after the one that contains the offset
- mach_vm_size_t len;
- for (len = 0; off2Ind <= offset; ind++) {
- len = physP[ind].length;
- off2Ind += len;
- }
-
- // Calculate length within range and starting address
- length = off2Ind - offset;
- address = physP[ind - 1].address + len - length;
-
- // see how far we can coalesce ranges
- while (ind < _rangesCount && address + length == physP[ind].address) {
- len = physP[ind].length;
- length += len;
- off2Ind += len;
- ind++;
- }
-
- // correct contiguous check overshoot
- ind--;
- off2Ind -= len;
- }
- else do {
- if (!_wireCount)
- panic("IOGMD: not wired for the IODMACommand");
-
- assert(_memoryEntries);
-
- ioGMDData * dataP = getDataP(_memoryEntries);
- const ioPLBlock *ioplList = getIOPLList(dataP);
- UInt numIOPLs = getNumIOPL(_memoryEntries, dataP);
- upl_page_info_t *pageList = getPageList(dataP);
-
- assert(numIOPLs > 0);
-
- // Scan through iopl info blocks looking for block containing offset
- while (ind < numIOPLs && offset >= ioplList[ind].fIOMDOffset)
- ind++;
-
- // Go back to actual range as search goes past it
- ioPLBlock ioplInfo = ioplList[ind - 1];
- off2Ind = ioplInfo.fIOMDOffset;
-
- if (ind < numIOPLs)
- length = ioplList[ind].fIOMDOffset;
- else
- length = _length;
- length -= offset; // Remainder within iopl
-
- // Subtract offset till this iopl in total list
- offset -= off2Ind;
-
- // If a mapped address is requested and this is a pre-mapped IOPL
- // then just need to compute an offset relative to the mapped base.
- if (mapped && ioplInfo.fMappedBase) {
- offset += (ioplInfo.fPageOffset & PAGE_MASK);
- address = ptoa_64(ioplInfo.fMappedBase) + offset;
- continue; // Done leave do/while(false) now
- }
-
- // The offset is rebased into the current iopl.
- // Now add the iopl 1st page offset.
- offset += ioplInfo.fPageOffset;
-
- // For external UPLs the fPageInfo field points directly to
- // the upl's upl_page_info_t array.
- if (ioplInfo.fFlags & kIOPLExternUPL)
- pageList = (upl_page_info_t *) ioplInfo.fPageInfo;
- else
- pageList = &pageList[ioplInfo.fPageInfo];
-
- // Check for direct device non-paged memory
- if ( ioplInfo.fFlags & kIOPLOnDevice ) {
- address = ptoa_64(pageList->phys_addr) + offset;
- continue; // Done leave do/while(false) now
- }
-
- // Now we need compute the index into the pageList
- UInt pageInd = atop_32(offset);
- offset &= PAGE_MASK;
-
- // Compute the starting address of this segment
- IOPhysicalAddress pageAddr = pageList[pageInd].phys_addr;
- address = ptoa_64(pageAddr) + offset;
-
- // length is currently set to the length of the remainider of the iopl.
- // We need to check that the remainder of the iopl is contiguous.
- // This is indicated by pageList[ind].phys_addr being sequential.
- IOByteCount contigLength = PAGE_SIZE - offset;
- while (contigLength < length
- && ++pageAddr == pageList[++pageInd].phys_addr)
- {
- contigLength += PAGE_SIZE;
- }
-
- if (contigLength < length)
- length = contigLength;
-
-
- assert(address);
- assert(length);
-
- } while (false);
-
- // Update return values and state
- isP->fIO.fIOVMAddr = address;
- isP->fIO.fLength = length;
- isP->fIndex = ind;
- isP->fOffset2Index = off2Ind;
- isP->fNextOffset = isP->fIO.fOffset + length;
-
- return kIOReturnSuccess;
-}
-
-addr64_t
-IOGeneralMemoryDescriptor::getPhysicalSegment64(IOByteCount offset, IOByteCount *lengthOfSegment)
-{
- IOReturn ret;
- IOByteCount length = 0;
- addr64_t address = 0;
-
- if (gIOSystemMapper && (kIOMemoryTypePhysical == (_flags & kIOMemoryTypeMask)))
- return (super::getPhysicalSegment64(offset, lengthOfSegment));
-
+IOPhysicalAddress IOGeneralMemoryDescriptor::getPhysicalSegment
+ (IOByteCount offset, IOByteCount *lengthOfSegment)
+{
+ IOPhysicalAddress address = 0;
+ IOPhysicalLength length = 0;
+
+// assert(offset <= _length);
if (offset < _length) // (within bounds?)
{
- IOMDDMAWalkSegmentState _state;
- IOMDDMAWalkSegmentArgs * state = (IOMDDMAWalkSegmentArgs *) &_state;
-
- state->fOffset = offset;
- state->fLength = _length - offset;
- state->fMapped = false;
-
- ret = dmaCommandOperation(kIOMDFirstSegment, _state, sizeof(_state));
-
- if ((kIOReturnSuccess != ret) && (kIOReturnOverrun != ret))
- DEBG("getPhysicalSegment64 dmaCommandOperation(%lx), %p, offset %qx, addr %qx, len %qx\n",
- ret, this, state->fOffset,
- state->fIOVMAddr, state->fLength);
- if (kIOReturnSuccess == ret)
- {
- address = state->fIOVMAddr;
- length = state->fLength;
- }
+ if ( (_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical) {
+ unsigned int ind;
+
+ // Physical address based memory descriptor
+
+ // Find offset within descriptor and make it relative
+ // to the current _range.
+ for (ind = 0 ; offset >= _ranges.p[ind].length; ind++ )
+ offset -= _ranges.p[ind].length;
+
+ IOPhysicalRange cur = _ranges.p[ind];
+ address = cur.address + offset;
+ length = cur.length - offset;
+
+ // see how far we can coalesce ranges
+ for (++ind; ind < _rangesCount; ind++) {
+ cur = _ranges.p[ind];
+
+ if (address + length != cur.address)
+ break;
+
+ length += cur.length;
+ }
+
+ // @@@ gvdl: should be assert(address);
+ // but can't as NVidia GeForce creates a bogus physical mem
+ assert(address
+ || /* nvidia */ (!_ranges.p[0].address && 1 == _rangesCount));
+ assert(length);
+ }
+ else do {
+ // We need wiring & we are wired.
+ assert(_wireCount);
+
+ if (!_wireCount)
+ {
+ panic("IOGMD: not wired for getPhysicalSegment()");
+ continue;
+ }
+
+ assert(_memoryEntries);
+
+ ioGMDData * dataP = getDataP(_memoryEntries);
+ const ioPLBlock *ioplList = getIOPLList(dataP);
+ UInt ind, numIOPLs = getNumIOPL(_memoryEntries, dataP);
+ upl_page_info_t *pageList = getPageList(dataP);
+
+ assert(numIOPLs > 0);
+
+ // Scan through iopl info blocks looking for block containing offset
+ for (ind = 1; ind < numIOPLs; ind++) {
+ if (offset < ioplList[ind].fIOMDOffset)
+ break;
+ }
+
+ // Go back to actual range as search goes past it
+ ioPLBlock ioplInfo = ioplList[ind - 1];
+
+ if (ind < numIOPLs)
+ length = ioplList[ind].fIOMDOffset;
+ else
+ length = _length;
+ length -= offset; // Remainder within iopl
+
+ // Subtract offset till this iopl in total list
+ offset -= ioplInfo.fIOMDOffset;
+
+ // This is a mapped IOPL so we just need to compute an offset
+ // relative to the mapped base.
+ if (ioplInfo.fMappedBase) {
+ offset += (ioplInfo.fPageOffset & PAGE_MASK);
+ address = ptoa_32(ioplInfo.fMappedBase) + offset;
+ continue;
+ }
+
+ // Currently the offset is rebased into the current iopl.
+ // Now add the iopl 1st page offset.
+ offset += ioplInfo.fPageOffset;
+
+ // For external UPLs the fPageInfo field points directly to
+ // the upl's upl_page_info_t array.
+ if (ioplInfo.fFlags & kIOPLExternUPL)
+ pageList = (upl_page_info_t *) ioplInfo.fPageInfo;
+ else
+ pageList = &pageList[ioplInfo.fPageInfo];
+
+ // Check for direct device non-paged memory
+ if ( ioplInfo.fFlags & kIOPLOnDevice ) {
+ address = ptoa_32(pageList->phys_addr) + offset;
+ continue;
+ }
+
+ // Now we need compute the index into the pageList
+ ind = atop_32(offset);
+ offset &= PAGE_MASK;
+
+ IOPhysicalAddress pageAddr = pageList[ind].phys_addr;
+ address = ptoa_32(pageAddr) + offset;
+
+ // Check for the remaining data in this upl being longer than the
+ // remainder on the current page. This should be checked for
+ // contiguous pages
+ if (length > PAGE_SIZE - offset) {
+ // See if the next page is contiguous. Stop looking when we hit
+ // the end of this upl, which is indicated by the
+ // contigLength >= length.
+ IOByteCount contigLength = PAGE_SIZE - offset;
+
+ // Look for contiguous segment
+ while (contigLength < length
+ && ++pageAddr == pageList[++ind].phys_addr) {
+ contigLength += PAGE_SIZE;
+ }
+ if (length > contigLength)
+ length = contigLength;
+ }
+
+ assert(address);
+ assert(length);
+
+ } while (0);
+
if (!address)
length = 0;
}
@@ -1427,80 +1176,29 @@
if (lengthOfSegment)
*lengthOfSegment = length;
- return (address);
-}
-
-IOPhysicalAddress
-IOGeneralMemoryDescriptor::getPhysicalSegment(IOByteCount offset, IOByteCount *lengthOfSegment)
-{
- IOReturn ret;
- IOByteCount length = 0;
- addr64_t address = 0;
-
-// assert(offset <= _length);
-
- if (offset < _length) // (within bounds?)
- {
- IOMDDMAWalkSegmentState _state;
- IOMDDMAWalkSegmentArgs * state = (IOMDDMAWalkSegmentArgs *) &_state;
-
- state->fOffset = offset;
- state->fLength = _length - offset;
- state->fMapped = true;
-
- ret = dmaCommandOperation(
- kIOMDFirstSegment, _state, sizeof(_state));
-
- if ((kIOReturnSuccess != ret) && (kIOReturnOverrun != ret))
- DEBG("getPhysicalSegment dmaCommandOperation(%lx), %p, offset %qx, addr %qx, len %qx\n",
- ret, this, state->fOffset,
- state->fIOVMAddr, state->fLength);
- if (kIOReturnSuccess == ret)
- {
- address = state->fIOVMAddr;
- length = state->fLength;
- }
-
- if (!address)
- length = 0;
- }
-
- if ((address + length) > 0x100000000ULL)
- {
- panic("getPhysicalSegment() out of 32b range 0x%qx, len 0x%lx, class %s",
- address, length, (getMetaClass())->getClassName());
- }
-
- if (lengthOfSegment)
- *lengthOfSegment = length;
-
- return ((IOPhysicalAddress) address);
-}
-
-addr64_t
-IOMemoryDescriptor::getPhysicalSegment64(IOByteCount offset, IOByteCount *lengthOfSegment)
+ return address;
+}
+
+addr64_t IOMemoryDescriptor::getPhysicalSegment64
+ (IOByteCount offset, IOByteCount *lengthOfSegment)
{
IOPhysicalAddress phys32;
IOByteCount length;
addr64_t phys64;
- IOMapper * mapper = 0;
phys32 = getPhysicalSegment(offset, lengthOfSegment);
if (!phys32)
return 0;
if (gIOSystemMapper)
- mapper = gIOSystemMapper;
-
- if (mapper)
{
IOByteCount origLen;
- phys64 = mapper->mapAddr(phys32);
+ phys64 = gIOSystemMapper->mapAddr(phys32);
origLen = *lengthOfSegment;
length = page_size - (phys64 & (page_size - 1));
while ((length < origLen)
- && ((phys64 + length) == mapper->mapAddr(phys32 + length)))
+ && ((phys64 + length) == gIOSystemMapper->mapAddr(phys32 + length)))
length += page_size;
if (length > origLen)
length = origLen;
@@ -1513,8 +1211,8 @@
return phys64;
}
-IOPhysicalAddress
-IOGeneralMemoryDescriptor::getSourceSegment(IOByteCount offset, IOByteCount *lengthOfSegment)
+IOPhysicalAddress IOGeneralMemoryDescriptor::
+getSourceSegment(IOByteCount offset, IOByteCount *lengthOfSegment)
{
IOPhysicalAddress address = 0;
IOPhysicalLength length = 0;
@@ -1578,42 +1276,6 @@
/* DEPRECATED */ /* USE INSTEAD: map(), readBytes(), writeBytes() */
-
-IOReturn
-IOMemoryDescriptor::dmaCommandOperation(DMACommandOps op, void *vData, UInt dataSize) const
-{
- if (kIOMDGetCharacteristics == op) {
- if (dataSize < sizeof(IOMDDMACharacteristics))
- return kIOReturnUnderrun;
-
- IOMDDMACharacteristics *data = (IOMDDMACharacteristics *) vData;
- data->fLength = getLength();
- data->fSGCount = 0;
- data->fDirection = _direction;
- if (IOMapper::gSystem)
- data->fIsMapped = true;
- data->fIsPrepared = true; // Assume prepared - fails safe
- }
- else if (kIOMDWalkSegments & op) {
- if (dataSize < sizeof(IOMDDMAWalkSegmentArgs))
- return kIOReturnUnderrun;
-
- IOMDDMAWalkSegmentArgs *data = (IOMDDMAWalkSegmentArgs *) vData;
- IOByteCount offset = (IOByteCount) data->fOffset;
-
- IOPhysicalLength length;
- IOMemoryDescriptor *ncmd = const_cast<IOMemoryDescriptor *>(this);
- if (data->fMapped && IOMapper::gSystem)
- data->fIOVMAddr = ncmd->getPhysicalSegment(offset, &length);
- else
- data->fIOVMAddr = ncmd->getPhysicalSegment64(offset, &length);
- data->fLength = length;
- }
- else
- return kIOReturnBadArgument;
-
- return kIOReturnSuccess;
-}
IOReturn IOMemoryDescriptor::setPurgeable( IOOptionBits newState,
IOOptionBits * oldState )
@@ -1731,7 +1393,7 @@
return (remaining ? kIOReturnUnderrun : kIOReturnSuccess);
}
-#if defined(__ppc__) || defined(__arm__)
+#ifdef __ppc__
extern vm_offset_t static_memory_end;
#define io_kernel_static_end static_memory_end
#else
@@ -1746,12 +1408,10 @@
vm_size_t *upl_size,
upl_t *upl,
upl_page_info_array_t page_list,
- unsigned int *count,
- ppnum_t *highest_page)
+ unsigned int *count)
{
unsigned int pageCount, page;
ppnum_t phys;
- ppnum_t highestPage = 0;
pageCount = atop_32(*upl_size);
if (pageCount > *count)
@@ -1770,11 +1430,7 @@
page_list[page].dirty = 0;
page_list[page].precious = 0;
page_list[page].device = 0;
- if (phys > highestPage)
- highestPage = page;
- }
-
- *highest_page = highestPage;
+ }
return ((page >= pageCount) ? kIOReturnSuccess : kIOReturnVMError);
}
@@ -1782,14 +1438,14 @@
IOReturn IOGeneralMemoryDescriptor::wireVirtual(IODirection forDirection)
{
IOOptionBits type = _flags & kIOMemoryTypeMask;
- IOReturn error = kIOReturnCannotWire;
+ IOReturn error = kIOReturnNoMemory;
ioGMDData *dataP;
ppnum_t mapBase = 0;
IOMapper *mapper;
ipc_port_t sharedMem = (ipc_port_t) _memEntry;
assert(!_wireCount);
- assert(kIOMemoryTypeVirtual == type || kIOMemoryTypeVirtual64 == type || kIOMemoryTypeUIO == type);
+ assert(kIOMemoryTypeVirtual == type || kIOMemoryTypeUIO == type);
if (_pages >= gIOMaximumMappedIOPageCount)
return kIOReturnNoResources;
@@ -1808,7 +1464,7 @@
forDirection = _direction;
int uplFlags; // This Mem Desc's default flags for upl creation
- switch (kIODirectionOutIn & forDirection)
+ switch (forDirection)
{
case kIODirectionOut:
// Pages do not need to be marked as dirty on commit
@@ -1823,11 +1479,6 @@
}
uplFlags |= UPL_SET_IO_WIRE | UPL_SET_LITE;
-#ifdef UPL_NEED_32BIT_ADDR
- if (kIODirectionPrepareToPhys32 & forDirection)
- uplFlags |= UPL_NEED_32BIT_ADDR;
-#endif
-
// Find the appropriate vm_map for the given task
vm_map_t curMap;
if (_task == kernel_task && (kIOMemoryBufferPageable & _flags))
@@ -1839,12 +1490,10 @@
Ranges vec = _ranges;
unsigned int pageIndex = 0;
IOByteCount mdOffset = 0;
- ppnum_t highestPage = 0;
for (UInt range = 0; range < _rangesCount; range++) {
ioPLBlock iopl;
user_addr_t startPage;
IOByteCount numBytes;
- ppnum_t highPage = 0;
// Get the startPage address and length of vec[range]
getAddrLenForInd(startPage, numBytes, type, vec, range);
@@ -1884,8 +1533,7 @@
&ioplSize,
&iopl.fIOPL,
baseInfo,
- &numPageInfo,
- &highPage);
+ &numPageInfo);
}
else if (sharedMem) {
error = memory_object_iopl_request(sharedMem,
@@ -1911,12 +1559,7 @@
if (error != KERN_SUCCESS)
goto abortExit;
- if (iopl.fIOPL)
- highPage = upl_get_highest_page(iopl.fIOPL);
- if (highPage > highestPage)
- highestPage = highPage;
-
- error = kIOReturnCannotWire;
+ error = kIOReturnNoMemory;
if (baseInfo->device) {
numPageInfo = 1;
@@ -1930,7 +1573,7 @@
}
else {
iopl.fFlags = 0;
- if (mapper)
+ if (mapper)
mapper->iovmInsert(mapBase, pageIndex,
baseInfo, numPageInfo);
}
@@ -1972,8 +1615,6 @@
}
}
- _highestPage = highestPage;
-
return kIOReturnSuccess;
abortExit:
@@ -1995,9 +1636,6 @@
mapper->iovmFree(mapBase, _pages);
}
- if (error == KERN_FAILURE)
- error = kIOReturnCannotWire;
-
return error;
}
@@ -2015,24 +1653,16 @@
IOReturn error = kIOReturnSuccess;
IOOptionBits type = _flags & kIOMemoryTypeMask;
- if ((kIOMemoryTypePhysical == type) || (kIOMemoryTypePhysical64 == type))
- return kIOReturnSuccess;
-
- if (_prepareLock)
- IOLockLock(_prepareLock);
-
if (!_wireCount
- && (kIOMemoryTypeVirtual == type || kIOMemoryTypeVirtual64 == type || kIOMemoryTypeUIO == type) ) {
+ && (kIOMemoryTypeVirtual == type || kIOMemoryTypeUIO == type) ) {
error = wireVirtual(forDirection);
- }
-
- if (kIOReturnSuccess == error)
- _wireCount++;
-
- if (_prepareLock)
- IOLockUnlock(_prepareLock);
-
- return error;
+ if (error)
+ return error;
+ }
+
+ _wireCount++;
+
+ return kIOReturnSuccess;
}
/*
@@ -2046,61 +1676,49 @@
IOReturn IOGeneralMemoryDescriptor::complete(IODirection /* forDirection */)
{
- IOOptionBits type = _flags & kIOMemoryTypeMask;
-
- if ((kIOMemoryTypePhysical == type) || (kIOMemoryTypePhysical64 == type))
- return kIOReturnSuccess;
-
- if (_prepareLock)
- IOLockLock(_prepareLock);
-
assert(_wireCount);
- if (_wireCount)
- {
- _wireCount--;
- if (!_wireCount)
- {
- IOOptionBits type = _flags & kIOMemoryTypeMask;
- ioGMDData * dataP = getDataP(_memoryEntries);
- ioPLBlock *ioplList = getIOPLList(dataP);
+ if (!_wireCount)
+ return kIOReturnSuccess;
+
+ _wireCount--;
+ if (!_wireCount) {
+ IOOptionBits type = _flags & kIOMemoryTypeMask;
+
+ if (kIOMemoryTypePhysical == type) {
+ /* kIOMemoryTypePhysical */
+ // DO NOTHING
+ }
+ else {
+ ioGMDData * dataP = getDataP(_memoryEntries);
+ ioPLBlock *ioplList = getIOPLList(dataP);
UInt count = getNumIOPL(_memoryEntries, dataP);
- if (dataP->fMapper && _pages && ioplList[0].fMappedBase)
- dataP->fMapper->iovmFree(ioplList[0].fMappedBase, _pages);
-
- // Only complete iopls that we created which are for TypeVirtual
- if (kIOMemoryTypeVirtual == type || kIOMemoryTypeVirtual64 == type || kIOMemoryTypeUIO == type) {
- for (UInt ind = 0; ind < count; ind++)
+ if (dataP->fMapper && _pages && ioplList[0].fMappedBase)
+ dataP->fMapper->iovmFree(ioplList[0].fMappedBase, _pages);
+
+ // Only complete iopls that we created which are for TypeVirtual
+ if (kIOMemoryTypeVirtual == type || kIOMemoryTypeUIO == type) {
+ for (UInt ind = 0; ind < count; ind++)
if (ioplList[ind].fIOPL) {
upl_commit(ioplList[ind].fIOPL, 0, 0);
upl_deallocate(ioplList[ind].fIOPL);
}
- }
- (void) _memoryEntries->initWithBytes(dataP, sizeof(ioGMDData)); // == setLength()
- }
- }
-
- if (_prepareLock)
- IOLockUnlock(_prepareLock);
-
+ }
+
+ (void) _memoryEntries->initWithBytes(dataP, sizeof(ioGMDData)); // == setLength()
+ }
+ }
return kIOReturnSuccess;
}
IOReturn IOGeneralMemoryDescriptor::doMap(
- vm_map_t __addressMap,
- IOVirtualAddress * __address,
+ vm_map_t addressMap,
+ IOVirtualAddress * atAddress,
IOOptionBits options,
- IOByteCount __offset,
- IOByteCount __length )
-
-{
- if (!(kIOMap64Bit & options)) panic("IOGeneralMemoryDescriptor::doMap !64bit");
-
- _IOMemoryMap * mapping = (_IOMemoryMap *) *__address;
- mach_vm_size_t offset = mapping->fOffset + __offset;
- mach_vm_size_t length = mapping->fLength;
-
+ IOByteCount sourceOffset,
+ IOByteCount length )
+{
kern_return_t kr;
ipc_port_t sharedMem = (ipc_port_t) _memEntry;
@@ -2115,14 +1733,15 @@
// mapping source == dest? (could be much better)
if( _task
- && (mapping->fAddressMap == get_task_map(_task)) && (options & kIOMapAnywhere)
- && (1 == _rangesCount) && (0 == offset)
- && range0Addr && (length <= range0Len) )
- {
- mapping->fAddress = range0Addr;
- mapping->fOptions |= kIOMapStatic;
-
- return( kIOReturnSuccess );
+ && (addressMap == get_task_map(_task)) && (options & kIOMapAnywhere)
+ && (1 == _rangesCount) && (0 == sourceOffset)
+ && range0Addr && (length <= range0Len) ) {
+ if (sizeof(user_addr_t) > 4 && ((UInt64) range0Addr) >> 32)
+ return kIOReturnOverrun; // Doesn't fit in 32bit return field
+ else {
+ *atAddress = range0Addr;
+ return( kIOReturnSuccess );
+ }
}
if( 0 == sharedMem) {
@@ -2130,17 +1749,11 @@
vm_size_t size = ptoa_32(_pages);
if( _task) {
-
+#ifndef i386
memory_object_size_t actualSize = size;
- vm_prot_t prot = VM_PROT_READ;
- if (!(kIOMapReadOnly & options))
- prot |= VM_PROT_WRITE;
- else if (kIOMapDefaultCache != (options & kIOMapCacheMask))
- prot |= VM_PROT_WRITE;
-
kr = mach_make_memory_entry_64(get_task_map(_task),
&actualSize, range0Addr,
- prot, &sharedMem,
+ VM_PROT_READ | VM_PROT_WRITE, &sharedMem,
NULL );
if( (KERN_SUCCESS == kr) && (actualSize != round_page_32(size))) {
@@ -2153,16 +1766,17 @@
}
if( KERN_SUCCESS != kr)
+#endif /* !i386 */
sharedMem = MACH_PORT_NULL;
- } else do { // _task == 0, must be physical
+ } else do {
memory_object_t pager;
unsigned int flags = 0;
addr64_t pa;
IOPhysicalLength segLen;
- pa = getPhysicalSegment64( offset, &segLen );
+ pa = getPhysicalSegment64( sourceOffset, &segLen );
if( !reserved) {
reserved = IONew( ExpansionData, 1 );
@@ -2178,17 +1792,6 @@
case kIOMapDefaultCache:
default:
flags = IODefaultCacheBits(pa);
- if (DEVICE_PAGER_CACHE_INHIB & flags)
- {
- if (DEVICE_PAGER_GUARDED & flags)
- mapping->fOptions |= kIOMapInhibitCache;
- else
- mapping->fOptions |= kIOMapWriteCombineCache;
- }
- else if (DEVICE_PAGER_WRITE_THROUGH & flags)
- mapping->fOptions |= kIOMapWriteThruCache;
- else
- mapping->fOptions |= kIOMapCopybackCache;
break;
case kIOMapInhibitCache:
@@ -2222,8 +1825,7 @@
size, VM_PROT_READ | VM_PROT_WRITE, pager, &sharedMem );
assert( KERN_SUCCESS == kr );
- if( KERN_SUCCESS != kr)
- {
+ if( KERN_SUCCESS != kr) {
device_pager_deallocate( pager );
pager = MACH_PORT_NULL;
sharedMem = MACH_PORT_NULL;
@@ -2241,22 +1843,36 @@
_memEntry = (void *) sharedMem;
}
- IOReturn result;
- if (0 == sharedMem)
- result = kIOReturnVMError;
+
+#ifndef i386
+ if( 0 == sharedMem)
+ kr = kIOReturnVMError;
else
- result = super::doMap( __addressMap, __address,
- options, __offset, __length );
-
- return( result );
+#endif
+ kr = super::doMap( addressMap, atAddress,
+ options, sourceOffset, length );
+
+ return( kr );
}
IOReturn IOGeneralMemoryDescriptor::doUnmap(
vm_map_t addressMap,
- IOVirtualAddress __address,
- IOByteCount __length )
-{
- return (super::doUnmap(addressMap, __address, __length));
+ IOVirtualAddress logical,
+ IOByteCount length )
+{
+ // could be much better
+ if( _task && (addressMap == get_task_map(_task)) && (1 == _rangesCount)) {
+
+ IOOptionBits type = _flags & kIOMemoryTypeMask;
+ user_addr_t range0Addr;
+ IOByteCount range0Len;
+
+ getAddrLenForInd(range0Addr, range0Len, type, _ranges, 0);
+ if (logical == range0Addr && length <= range0Len)
+ return( kIOReturnSuccess );
+ }
+
+ return( super::doUnmap( addressMap, logical, length ));
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -2275,63 +1891,108 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-bool _IOMemoryMap::init(
+bool _IOMemoryMap::initCompatible(
+ IOMemoryDescriptor * _memory,
+ IOMemoryMap * _superMap,
+ IOByteCount _offset,
+ IOByteCount _length )
+{
+
+ if( !super::init())
+ return( false);
+
+ if( (_offset + _length) > _superMap->getLength())
+ return( false);
+
+ _memory->retain();
+ memory = _memory;
+ _superMap->retain();
+ superMap = _superMap;
+
+ offset = _offset;
+ if( _length)
+ length = _length;
+ else
+ length = _memory->getLength();
+
+ options = superMap->getMapOptions();
+ logical = superMap->getVirtualAddress() + offset;
+
+ return( true );
+}
+
+bool _IOMemoryMap::initWithDescriptor(
+ IOMemoryDescriptor * _memory,
task_t intoTask,
- mach_vm_address_t toAddress,
+ IOVirtualAddress toAddress,
IOOptionBits _options,
- mach_vm_size_t _offset,
- mach_vm_size_t _length )
-{
- if (!intoTask)
+ IOByteCount _offset,
+ IOByteCount _length )
+{
+ bool ok;
+ bool redir = ((kIOMapUnique|kIOMapReference) == ((kIOMapUnique|kIOMapReference) & _options));
+
+ if ((!_memory) || (!intoTask))
return( false);
- if (!super::init())
- return(false);
-
- fAddressMap = get_task_map(intoTask);
- if (!fAddressMap)
- return(false);
- vm_map_reference(fAddressMap);
-
- fAddressTask = intoTask;
- fOptions = _options;
- fLength = _length;
- fOffset = _offset;
- fAddress = toAddress;
-
- return (true);
-}
-
-bool _IOMemoryMap::setMemoryDescriptor(IOMemoryDescriptor * _memory, mach_vm_size_t _offset)
-{
- if (!_memory)
- return(false);
-
- if (!fSuperMap)
+ if( (_offset + _length) > _memory->getLength())
+ return( false);
+
+ if (!redir)
{
- if( (_offset + fLength) > _memory->getLength())
+ if (!super::init())
+ return(false);
+ addressMap = get_task_map(intoTask);
+ if( !addressMap)
return( false);
- fOffset = _offset;
+ vm_map_reference(addressMap);
+ addressTask = intoTask;
+ logical = toAddress;
+ options = _options;
}
_memory->retain();
- if (fMemory)
+
+ offset = _offset;
+ if( _length)
+ length = _length;
+ else
+ length = _memory->getLength();
+
+ if( options & kIOMapStatic)
+ ok = true;
+ else
+ ok = (kIOReturnSuccess == _memory->doMap( addressMap, &toAddress,
+ _options, offset, length ));
+ if (ok || redir)
{
- if (fMemory != _memory)
- fMemory->removeMapping(this);
- fMemory->release();
- }
- fMemory = _memory;
-
- return( true );
-}
-
+ if (memory)
+ memory->release();
+ memory = _memory;
+ logical = toAddress;
+ }
+ else
+ {
+ _memory->release();
+ if (!redir)
+ {
+ logical = 0;
+ memory = 0;
+ vm_map_deallocate(addressMap);
+ addressMap = 0;
+ }
+ }
+
+ return( ok );
+}
+
+/* LP64todo - these need to expand */
struct IOMemoryDescriptorMapAllocRef
{
ipc_port_t sharedMem;
- mach_vm_address_t mapped;
- mach_vm_size_t size;
- mach_vm_size_t sourceOffset;
+ vm_size_t size;
+ vm_offset_t mapped;
+ IOByteCount sourceOffset;
IOOptionBits options;
};
@@ -2341,14 +2002,9 @@
IOReturn err;
do {
- if( ref->sharedMem)
- {
+ if( ref->sharedMem) {
vm_prot_t prot = VM_PROT_READ
| ((ref->options & kIOMapReadOnly) ? 0 : VM_PROT_WRITE);
-
- // VM system requires write access to change cache mode
- if (kIOMapDefaultCache != (ref->options & kIOMapCacheMask))
- prot |= VM_PROT_WRITE;
// set memory entry cache
vm_prot_t memEntryCacheMode = prot | MAP_MEM_ONLY;
@@ -2383,7 +2039,7 @@
if (KERN_SUCCESS != err)
IOLog("MAP_MEM_ONLY failed %d\n", err);
- err = mach_vm_map( map,
+ err = vm_map( map,
&ref->mapped,
ref->size, 0 /* mask */,
(( ref->options & kIOMapAnywhere ) ? VM_FLAGS_ANYWHERE : VM_FLAGS_FIXED)
@@ -2399,97 +2055,72 @@
continue;
}
- }
- else
- {
- err = mach_vm_allocate( map, &ref->mapped, ref->size,
+ } else {
+
+ err = vm_allocate( map, &ref->mapped, ref->size,
((ref->options & kIOMapAnywhere) ? VM_FLAGS_ANYWHERE : VM_FLAGS_FIXED)
| VM_MAKE_TAG(VM_MEMORY_IOKIT) );
+
if( KERN_SUCCESS != err) {
ref->mapped = 0;
continue;
}
+
// we have to make sure that these guys don't get copied if we fork.
err = vm_inherit( map, ref->mapped, ref->size, VM_INHERIT_NONE);
assert( KERN_SUCCESS == err );
}
- }
- while( false );
+
+ } while( false );
return( err );
}
-kern_return_t
-IOMemoryDescriptorMapMemEntry(vm_map_t map, ipc_port_t entry, IOOptionBits options, bool pageable,
- mach_vm_size_t offset,
- mach_vm_address_t * address, mach_vm_size_t length)
-{
- IOReturn err;
- IOMemoryDescriptorMapAllocRef ref;
-
- ref.sharedMem = entry;
- ref.sourceOffset = offset;
+
+IOReturn IOMemoryDescriptor::doMap(
+ vm_map_t addressMap,
+ IOVirtualAddress * atAddress,
+ IOOptionBits options,
+ IOByteCount sourceOffset,
+ IOByteCount length )
+{
+ IOReturn err = kIOReturnSuccess;
+ memory_object_t pager;
+ vm_address_t logical;
+ IOByteCount pageOffset;
+ IOPhysicalAddress sourceAddr;
+ IOMemoryDescriptorMapAllocRef ref;
+
+ ref.sharedMem = (ipc_port_t) _memEntry;
+ ref.sourceOffset = sourceOffset;
ref.options = options;
- ref.size = length;
-
- if (options & kIOMapAnywhere)
- // vm_map looks for addresses above here, even when VM_FLAGS_ANYWHERE
- ref.mapped = 0;
- else
- ref.mapped = *address;
-
- if( ref.sharedMem && (map == kernel_map) && pageable)
- err = IOIteratePageableMaps( ref.size, &IOMemoryDescriptorMapAlloc, &ref );
- else
- err = IOMemoryDescriptorMapAlloc( map, &ref );
-
- *address = ref.mapped;
- return (err);
-}
-
-
-IOReturn IOMemoryDescriptor::doMap(
- vm_map_t __addressMap,
- IOVirtualAddress * __address,
- IOOptionBits options,
- IOByteCount __offset,
- IOByteCount __length )
-{
- if (!(kIOMap64Bit & options)) panic("IOMemoryDescriptor::doMap !64bit");
-
- _IOMemoryMap * mapping = (_IOMemoryMap *) *__address;
- mach_vm_size_t offset = mapping->fOffset + __offset;
- mach_vm_size_t length = mapping->fLength;
-
- IOReturn err = kIOReturnSuccess;
- memory_object_t pager;
- mach_vm_size_t pageOffset;
- IOPhysicalAddress sourceAddr;
-
- do
- {
- sourceAddr = getSourceSegment( offset, NULL );
+ do {
+
+ if( 0 == length)
+ length = getLength();
+
+ sourceAddr = getSourceSegment( sourceOffset, NULL );
pageOffset = sourceAddr - trunc_page_32( sourceAddr );
- if( reserved)
- pager = (memory_object_t) reserved->devicePager;
- else
- pager = MACH_PORT_NULL;
+ ref.size = round_page_32( length + pageOffset );
if ((kIOMapReference|kIOMapUnique) == ((kIOMapReference|kIOMapUnique) & options))
{
- upl_t redirUPL2;
- vm_size_t size;
- int flags;
-
+ upl_t redirUPL2;
+ vm_size_t size;
+ int flags;
+
+ _IOMemoryMap * mapping = (_IOMemoryMap *) *atAddress;
+ ref.mapped = mapping->getVirtualAddress();
+
if (!_memEntry)
{
err = kIOReturnNotReadable;
continue;
}
- size = mapping->fLength + pageOffset;
+ size = length;
flags = UPL_COPYOUT_FROM | UPL_SET_INTERNAL
| UPL_SET_LITE | UPL_SET_IO_WIRE | UPL_BLOCK_ACCESS;
@@ -2498,7 +2129,7 @@
&flags))
redirUPL2 = NULL;
- err = upl_transpose(redirUPL2, mapping->fRedirUPL);
+ err = upl_transpose(redirUPL2, mapping->redirUPL);
if (kIOReturnSuccess != err)
{
IOLog("upl_transpose(%x)\n", err);
@@ -2514,54 +2145,52 @@
{
// swap the memEntries since they now refer to different vm_objects
void * me = _memEntry;
- _memEntry = mapping->fMemory->_memEntry;
- mapping->fMemory->_memEntry = me;
+ _memEntry = mapping->memory->_memEntry;
+ mapping->memory->_memEntry = me;
}
- if (pager)
- err = handleFault( reserved->devicePager, mapping->fAddressMap, mapping->fAddress, offset, length, options );
}
else
{
- mach_vm_address_t address;
-
- if (!(options & kIOMapAnywhere))
- {
- address = trunc_page_64(mapping->fAddress);
- if( (mapping->fAddress - address) != pageOffset)
- {
+
+ logical = *atAddress;
+ if( options & kIOMapAnywhere)
+ // vm_map looks for addresses above here, even when VM_FLAGS_ANYWHERE
+ ref.mapped = 0;
+ else {
+ ref.mapped = trunc_page_32( logical );
+ if( (logical - ref.mapped) != pageOffset) {
err = kIOReturnVMError;
continue;
}
}
-
- err = IOMemoryDescriptorMapMemEntry(mapping->fAddressMap, (ipc_port_t) _memEntry,
- options, (kIOMemoryBufferPageable & _flags),
- offset, &address, round_page_64(length + pageOffset));
- if( err != KERN_SUCCESS)
- continue;
-
- if (!_memEntry || pager)
- {
- err = handleFault( pager, mapping->fAddressMap, address, offset, length, options );
- if (err != KERN_SUCCESS)
- doUnmap( mapping->fAddressMap, (IOVirtualAddress) mapping, 0 );
- }
-
-#ifdef DEBUG
- if (kIOLogMapping & gIOKitDebug)
- IOLog("mapping(%x) desc %p @ %lx, map %p, address %qx, offset %qx, length %qx\n",
- err, this, sourceAddr, mapping, address, offset, length);
-#endif
-
- if (err == KERN_SUCCESS)
- mapping->fAddress = address + pageOffset;
+
+ if( ref.sharedMem && (addressMap == kernel_map) && (kIOMemoryBufferPageable & _flags))
+ err = IOIteratePageableMaps( ref.size, &IOMemoryDescriptorMapAlloc, &ref );
else
- mapping->fAddress = NULL;
+ err = IOMemoryDescriptorMapAlloc( addressMap, &ref );
}
- }
- while( false );
-
- return (err);
+
+ if( err != KERN_SUCCESS)
+ continue;
+
+ if( reserved)
+ pager = (memory_object_t) reserved->devicePager;
+ else
+ pager = MACH_PORT_NULL;
+
+ if( !ref.sharedMem || pager )
+ err = handleFault( pager, addressMap, ref.mapped, sourceOffset, length, options );
+
+ } while( false );
+
+ if( err != KERN_SUCCESS) {
+ if( ref.mapped)
+ doUnmap( addressMap, ref.mapped, ref.size );
+ *atAddress = NULL;
+ } else
+ *atAddress = ref.mapped + pageOffset;
+
+ return( err );
}
enum {
@@ -2571,27 +2200,26 @@
IOReturn IOMemoryDescriptor::handleFault(
void * _pager,
vm_map_t addressMap,
- mach_vm_address_t address,
- mach_vm_size_t sourceOffset,
- mach_vm_size_t length,
+ IOVirtualAddress address,
+ IOByteCount sourceOffset,
+ IOByteCount length,
IOOptionBits options )
{
IOReturn err = kIOReturnSuccess;
memory_object_t pager = (memory_object_t) _pager;
- mach_vm_size_t size;
- mach_vm_size_t bytes;
- mach_vm_size_t page;
- mach_vm_size_t pageOffset;
- mach_vm_size_t pagerOffset;
+ vm_size_t size;
+ vm_size_t bytes;
+ vm_size_t page;
+ IOByteCount pageOffset;
+ IOByteCount pagerOffset;
IOPhysicalLength segLen;
addr64_t physAddr;
- if( !addressMap)
- {
- if( kIOMemoryRedirected & _flags)
- {
+ if( !addressMap) {
+
+ if( kIOMemoryRedirected & _flags) {
#ifdef DEBUG
- IOLog("sleep mem redirect %p, %qx\n", this, sourceOffset);
+ IOLog("sleep mem redirect %p, %lx\n", this, sourceOffset);
#endif
do {
SLEEP;
@@ -2611,8 +2239,7 @@
segLen += pageOffset;
bytes = size;
- do
- {
+ do {
// in the middle of the loop only map whole pages
if( segLen >= bytes)
segLen = bytes;
@@ -2620,16 +2247,26 @@
err = kIOReturnVMError;
if( physAddr != trunc_page_64( physAddr))
err = kIOReturnBadArgument;
- if (kIOReturnSuccess != err)
- break;
#ifdef DEBUG
if( kIOLogMapping & gIOKitDebug)
- IOLog("_IOMemoryMap::map(%p) 0x%qx->0x%qx:0x%qx\n",
+ IOLog("_IOMemoryMap::map(%p) %08lx->%08qx:%08lx\n",
addressMap, address + pageOffset, physAddr + pageOffset,
segLen - pageOffset);
#endif
+
+
+
+
+#ifdef i386
+ /* i386 doesn't support faulting on device memory yet */
+ if( addressMap && (kIOReturnSuccess == err))
+ err = IOMapPages( addressMap, address, (IOPhysicalAddress) physAddr, segLen, options );
+ assert( KERN_SUCCESS == err );
+ if( err)
+ break;
+#endif
if( pager) {
if( reserved && reserved->pagerContig) {
@@ -2638,33 +2275,41 @@
allPhys = getPhysicalSegment64( 0, &allLen );
assert( allPhys );
- err = device_pager_populate_object( pager, 0, atop_64(allPhys), round_page_32(allLen) );
- }
- else
- {
-
- for( page = 0;
+ err = device_pager_populate_object( pager, 0, allPhys >> PAGE_SHIFT, round_page_32(allLen) );
+
+ } else {
+
+ for( page = 0;
(page < segLen) && (KERN_SUCCESS == err);
- page += page_size)
- {
- err = device_pager_populate_object(pager, pagerOffset,
- (ppnum_t)(atop_64(physAddr + page)), page_size);
- pagerOffset += page_size;
+ page += page_size) {
+ err = device_pager_populate_object(pager, pagerOffset,
+ (ppnum_t)((physAddr + page) >> PAGE_SHIFT), page_size);
+ pagerOffset += page_size;
}
}
assert( KERN_SUCCESS == err );
if( err)
break;
}
-
- // This call to vm_fault causes an early pmap level resolution
- // of the mappings created above for kernel mappings, since
- // faulting in later can't take place from interrupt level.
+#ifndef i386
/* *** ALERT *** */
/* *** Temporary Workaround *** */
- if ((addressMap == kernel_map) && !(kIOMemoryRedirected & _flags))
- {
+ /* This call to vm_fault causes an early pmap level resolution */
+ /* of the mappings created above. Need for this is in absolute */
+ /* violation of the basic tenet that the pmap layer is a cache. */
+ /* Further, it implies a serious I/O architectural violation on */
+ /* the part of some user of the mapping. As of this writing, */
+ /* the call to vm_fault is needed because the NVIDIA driver */
+ /* makes a call to pmap_extract. The NVIDIA driver needs to be */
+ /* fixed as soon as possible. The NVIDIA driver should not */
+ /* need to query for this info as it should know from the doMap */
+ /* call where the physical memory is mapped. When a query is */
+ /* necessary to find a physical mapping, it should be done */
+ /* through an iokit call which includes the mapped memory */
+ /* handle. This is required for machine architecture independence.*/
+
+ if(!(kIOMemoryRedirected & _flags)) {
vm_fault(addressMap,
(vm_map_offset_t)address,
VM_PROT_READ|VM_PROT_WRITE,
@@ -2674,54 +2319,45 @@
/* *** Temporary Workaround *** */
/* *** ALERT *** */
-
+#endif
sourceOffset += segLen - pageOffset;
address += segLen;
bytes -= segLen;
pageOffset = 0;
- }
- while (bytes && (physAddr = getPhysicalSegment64( sourceOffset, &segLen )));
-
- if (bytes)
+ } while( bytes
+ && (physAddr = getPhysicalSegment64( sourceOffset, &segLen )));
+
+ if( bytes)
err = kIOReturnBadArgument;
- return (err);
+ return( err );
}
IOReturn IOMemoryDescriptor::doUnmap(
vm_map_t addressMap,
- IOVirtualAddress __address,
- IOByteCount __length )
-{
- IOReturn err;
- mach_vm_address_t address;
- mach_vm_size_t length;
-
- if (__length)
- {
- address = __address;
- length = __length;
- }
- else
- {
- addressMap = ((_IOMemoryMap *) __address)->fAddressMap;
- address = ((_IOMemoryMap *) __address)->fAddress;
- length = ((_IOMemoryMap *) __address)->fLength;
- }
-
- if( _memEntry && (addressMap == kernel_map) && (kIOMemoryBufferPageable & _flags))
- addressMap = IOPageableMapForAddress( address );
+ IOVirtualAddress logical,
+ IOByteCount length )
+{
+ IOReturn err;
#ifdef DEBUG
if( kIOLogMapping & gIOKitDebug)
- IOLog("IOMemoryDescriptor::doUnmap map %p, 0x%qx:0x%qx\n",
- addressMap, address, length );
+ kprintf("IOMemoryDescriptor::doUnmap(%x) %08x:%08x\n",
+ addressMap, logical, length );
#endif
- err = mach_vm_deallocate( addressMap, address, length );
-
- return (err);
+ if( true /* && (addressMap == kernel_map) || (addressMap == get_task_map(current_task()))*/) {
+
+ if( _memEntry && (addressMap == kernel_map) && (kIOMemoryBufferPageable & _flags))
+ addressMap = IOPageableMapForAddress( logical );
+
+ err = vm_deallocate( addressMap, logical, length );
+
+ } else
+ err = kIOReturnSuccess;
+
+ return( err );
}
IOReturn IOMemoryDescriptor::redirect( task_t safeTask, bool doRedirect )
@@ -2772,54 +2408,36 @@
{
IOReturn err = kIOReturnSuccess;
- if( fSuperMap) {
+ if( superMap) {
// err = ((_IOMemoryMap *)superMap)->redirect( safeTask, doRedirect );
} else {
LOCK;
-
- do
+ if( logical && addressMap
+ && (!safeTask || (get_task_map(safeTask) != addressMap))
+ && (0 == (options & kIOMapStatic)))
{
- if (!fAddress)
- break;
- if (!fAddressMap)
- break;
-
- if ((!safeTask || (get_task_map(safeTask) != fAddressMap))
- && (0 == (fOptions & kIOMapStatic)))
- {
- IOUnmapPages( fAddressMap, fAddress, fLength );
- if(!doRedirect && safeTask
- && (((fMemory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
- || ((fMemory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical64)))
- {
- IOVirtualAddress iova = (IOVirtualAddress) this;
- err = mach_vm_deallocate( fAddressMap, fAddress, fLength );
- err = fMemory->doMap( fAddressMap, &iova,
- (fOptions & ~kIOMapAnywhere) | kIOMap64Bit/*| kIOMapReserve*/,
- 0, 0 );
- } else
- err = kIOReturnSuccess;
+ IOUnmapPages( addressMap, logical, length );
+ if(!doRedirect && safeTask
+ && ((memory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical))
+ {
+ err = vm_deallocate( addressMap, logical, length );
+ err = memory->doMap( addressMap, &logical,
+ (options & ~kIOMapAnywhere) /*| kIOMapReserve*/,
+ offset, length );
+ } else
+ err = kIOReturnSuccess;
#ifdef DEBUG
- IOLog("IOMemoryMap::redirect(%d, %p) 0x%qx:0x%qx from %p\n", doRedirect, this, fAddress, fLength, fAddressMap);
+ IOLog("IOMemoryMap::redirect(%d, %p) %x:%lx from %p\n", doRedirect, this, logical, length, addressMap);
#endif
- }
- else if (kIOMapWriteCombineCache == (fOptions & kIOMapCacheMask))
- {
- IOOptionBits newMode;
- newMode = (fOptions & ~kIOMapCacheMask) | (doRedirect ? kIOMapInhibitCache : kIOMapWriteCombineCache);
- IOProtectCacheMode(fAddressMap, fAddress, fLength, newMode);
- }
- }
- while (false);
- UNLOCK;
- }
-
- if ((((fMemory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
- || ((fMemory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical64))
+ }
+ UNLOCK;
+ }
+
+ if (((memory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
&& safeTask
- && (doRedirect != (0 != (fMemory->_flags & kIOMemoryRedirected))))
- fMemory->redirect(safeTask, doRedirect);
+ && (doRedirect != (0 != (memory->_flags & kIOMemoryRedirected))))
+ memory->redirect(safeTask, doRedirect);
return( err );
}
@@ -2830,21 +2448,17 @@
LOCK;
- if( fAddress && fAddressMap && (0 == fSuperMap) && fMemory
- && (0 == (fOptions & kIOMapStatic))) {
-
- err = fMemory->doUnmap(fAddressMap, (IOVirtualAddress) this, 0);
+ if( logical && addressMap && (0 == superMap)
+ && (0 == (options & kIOMapStatic))) {
+
+ err = memory->doUnmap( addressMap, logical, length );
+ vm_map_deallocate(addressMap);
+ addressMap = 0;
} else
err = kIOReturnSuccess;
- if (fAddressMap)
- {
- vm_map_deallocate(fAddressMap);
- fAddressMap = 0;
- }
-
- fAddress = 0;
+ logical = 0;
UNLOCK;
@@ -2854,12 +2468,12 @@
void _IOMemoryMap::taskDied( void )
{
LOCK;
- if( fAddressMap) {
- vm_map_deallocate(fAddressMap);
- fAddressMap = 0;
- }
- fAddressTask = 0;
- fAddress = 0;
+ if( addressMap) {
+ vm_map_deallocate(addressMap);
+ addressMap = 0;
+ }
+ addressTask = 0;
+ logical = 0;
UNLOCK;
}
@@ -2878,27 +2492,26 @@
{
unmap();
- if (fMemory)
+ if( memory) {
+ LOCK;
+ memory->removeMapping( this);
+ UNLOCK;
+ memory->release();
+ }
+
+ if (owner && (owner != memory))
{
LOCK;
- fMemory->removeMapping(this);
+ owner->removeMapping(this);
UNLOCK;
- fMemory->release();
- }
-
- if (fOwner && (fOwner != fMemory))
- {
- LOCK;
- fOwner->removeMapping(this);
- UNLOCK;
- }
-
- if (fSuperMap)
- fSuperMap->release();
-
- if (fRedirUPL) {
- upl_commit(fRedirUPL, NULL, 0);
- upl_deallocate(fRedirUPL);
+ }
+
+ if( superMap)
+ superMap->release();
+
+ if (redirUPL) {
+ upl_commit(redirUPL, NULL, 0);
+ upl_deallocate(redirUPL);
}
super::free();
@@ -2906,101 +2519,86 @@
IOByteCount _IOMemoryMap::getLength()
{
- return( fLength );
+ return( length );
}
IOVirtualAddress _IOMemoryMap::getVirtualAddress()
{
- if (fSuperMap)
- fSuperMap->getVirtualAddress();
- else if (fAddressMap && vm_map_is_64bit(fAddressMap))
- {
- OSReportWithBacktrace("IOMemoryMap::getVirtualAddress(0x%qx) called on 64b map; use ::getAddress()", fAddress);
- }
-
- return (fAddress);
-}
-
-mach_vm_address_t _IOMemoryMap::getAddress()
-{
- return( fAddress);
-}
-
-mach_vm_size_t _IOMemoryMap::getSize()
-{
- return( fLength );
-}
-
+ return( logical);
+}
task_t _IOMemoryMap::getAddressTask()
{
- if( fSuperMap)
- return( fSuperMap->getAddressTask());
+ if( superMap)
+ return( superMap->getAddressTask());
else
- return( fAddressTask);
+ return( addressTask);
}
IOOptionBits _IOMemoryMap::getMapOptions()
{
- return( fOptions);
+ return( options);
}
IOMemoryDescriptor * _IOMemoryMap::getMemoryDescriptor()
{
- return( fMemory );
+ return( memory );
}
_IOMemoryMap * _IOMemoryMap::copyCompatible(
- _IOMemoryMap * newMapping )
-{
- task_t task = newMapping->getAddressTask();
- mach_vm_address_t toAddress = newMapping->fAddress;
- IOOptionBits _options = newMapping->fOptions;
- mach_vm_size_t _offset = newMapping->fOffset;
- mach_vm_size_t _length = newMapping->fLength;
-
- if( (!task) || (!fAddressMap) || (fAddressMap != get_task_map(task)))
+ IOMemoryDescriptor * owner,
+ task_t task,
+ IOVirtualAddress toAddress,
+ IOOptionBits _options,
+ IOByteCount _offset,
+ IOByteCount _length )
+{
+ _IOMemoryMap * mapping;
+
+ if( (!task) || (!addressMap) || (addressMap != get_task_map(task)))
return( 0 );
- if( (fOptions ^ _options) & kIOMapReadOnly)
+ if( options & kIOMapUnique)
+ return( 0 );
+ if( (options ^ _options) & kIOMapReadOnly)
return( 0 );
if( (kIOMapDefaultCache != (_options & kIOMapCacheMask))
- && ((fOptions ^ _options) & kIOMapCacheMask))
+ && ((options ^ _options) & kIOMapCacheMask))
return( 0 );
- if( (0 == (_options & kIOMapAnywhere)) && (fAddress != toAddress))
+ if( (0 == (_options & kIOMapAnywhere)) && (logical != toAddress))
return( 0 );
- if( _offset < fOffset)
+ if( _offset < offset)
return( 0 );
- _offset -= fOffset;
-
- if( (_offset + _length) > fLength)
+ _offset -= offset;
+
+ if( (_offset + _length) > length)
return( 0 );
- retain();
- if( (fLength == _length) && (!_offset))
- {
- newMapping->release();
- newMapping = this;
- }
- else
- {
- newMapping->fSuperMap = this;
- newMapping->fOffset = _offset;
- newMapping->fAddress = fAddress + _offset;
- }
-
- return( newMapping );
-}
-
-IOPhysicalAddress
-_IOMemoryMap::getPhysicalSegment( IOByteCount _offset, IOPhysicalLength * _length)
+ if( (length == _length) && (!_offset)) {
+ retain();
+ mapping = this;
+
+ } else {
+ mapping = new _IOMemoryMap;
+ if( mapping
+ && !mapping->initCompatible( owner, this, _offset, _length )) {
+ mapping->release();
+ mapping = 0;
+ }
+ }
+
+ return( mapping );
+}
+
+IOPhysicalAddress _IOMemoryMap::getPhysicalSegment( IOByteCount _offset,
+ IOPhysicalLength * _length)
{
IOPhysicalAddress address;
LOCK;
- address = fMemory->getPhysicalSegment( fOffset + _offset, _length );
+ address = memory->getPhysicalSegment( offset + _offset, _length );
UNLOCK;
return( address );
@@ -3020,20 +2618,6 @@
IORegistryEntry::getRegistryRoot()->setProperty(kIOMaximumMappedIOByteCountKey,
ptoa_64(gIOMaximumMappedIOPageCount), 64);
- if (!gIOCopyMapper)
- {
- IOMapper *
- mapper = new IOCopyMapper;
- if (mapper)
- {
- if (mapper->init() && mapper->start(NULL))
- gIOCopyMapper = (IOCopyMapper *) mapper;
- else
- mapper->release();
- }
- }
-
- gIOLastPage = IOGetLastPageNumber();
}
void IOMemoryDescriptor::free( void )
@@ -3049,129 +2633,96 @@
IOVirtualAddress mapAddress,
IOOptionBits options )
{
- return (createMappingInTask( intoTask, mapAddress,
- options | kIOMapStatic,
- 0, getLength() ));
+ _IOMemoryMap * newMap;
+
+ newMap = new _IOMemoryMap;
+
+ LOCK;
+
+ if( newMap
+ && !newMap->initWithDescriptor( this, intoTask, mapAddress,
+ options | kIOMapStatic, 0, getLength() )) {
+ newMap->release();
+ newMap = 0;
+ }
+
+ addMapping( newMap);
+
+ UNLOCK;
+
+ return( newMap);
}
IOMemoryMap * IOMemoryDescriptor::map(
IOOptionBits options )
{
- return (createMappingInTask( kernel_task, 0,
- options | kIOMapAnywhere,
- 0, getLength() ));
-}
-
-IOMemoryMap * IOMemoryDescriptor::map(
- task_t intoTask,
- IOVirtualAddress atAddress,
+
+ return( makeMapping( this, kernel_task, 0,
+ options | kIOMapAnywhere,
+ 0, getLength() ));
+}
+
+IOMemoryMap * IOMemoryDescriptor::map(
+ task_t intoTask,
+ IOVirtualAddress toAddress,
IOOptionBits options,
IOByteCount offset,
IOByteCount length )
{
- if ((!(kIOMapAnywhere & options)) && vm_map_is_64bit(get_task_map(intoTask)))
- {
- OSReportWithBacktrace("IOMemoryDescriptor::map() in 64b task, use ::createMappingInTask()");
- return (0);
- }
-
- return (createMappingInTask(intoTask, atAddress,
- options, offset, length));
-}
-
-IOMemoryMap * IOMemoryDescriptor::createMappingInTask(
- task_t intoTask,
- mach_vm_address_t atAddress,
- IOOptionBits options,
- mach_vm_size_t offset,
- mach_vm_size_t length)
-{
- IOMemoryMap * result;
- _IOMemoryMap * mapping;
-
- if (0 == length)
+ if( 0 == length)
length = getLength();
- mapping = new _IOMemoryMap;
-
- if( mapping
- && !mapping->init( intoTask, atAddress,
- options, offset, length )) {
- mapping->release();
- mapping = 0;
- }
-
- if (mapping)
- result = makeMapping(this, intoTask, (IOVirtualAddress) mapping, options | kIOMap64Bit, 0, 0);
- else
- result = 0;
-
-#ifdef DEBUG
- if (!result)
- IOLog("createMappingInTask failed desc %p, addr %qx, options %lx, offset %qx, length %qx\n",
- this, atAddress, options, offset, length);
-#endif
-
- return (result);
+ return( makeMapping( this, intoTask, toAddress, options, offset, length ));
}
IOReturn _IOMemoryMap::redirect(IOMemoryDescriptor * newBackingMemory,
IOOptionBits options,
IOByteCount offset)
{
- return (redirect(newBackingMemory, options, (mach_vm_size_t)offset));
-}
-
-IOReturn _IOMemoryMap::redirect(IOMemoryDescriptor * newBackingMemory,
- IOOptionBits options,
- mach_vm_size_t offset)
-{
IOReturn err = kIOReturnSuccess;
IOMemoryDescriptor * physMem = 0;
LOCK;
- if (fAddress && fAddressMap) do
+ if (logical && addressMap) do
{
- if (((fMemory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
- || ((fMemory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical64))
+ if ((memory->_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
{
- physMem = fMemory;
+ physMem = memory;
physMem->retain();
}
- if (!fRedirUPL)
+ if (!redirUPL)
{
- vm_size_t size = fLength;
+ vm_size_t size = length;
int flags = UPL_COPYOUT_FROM | UPL_SET_INTERNAL
| UPL_SET_LITE | UPL_SET_IO_WIRE | UPL_BLOCK_ACCESS;
- if (KERN_SUCCESS != memory_object_iopl_request((ipc_port_t) fMemory->_memEntry, 0, &size, &fRedirUPL,
+ if (KERN_SUCCESS != memory_object_iopl_request((ipc_port_t) memory->_memEntry, 0, &size, &redirUPL,
NULL, NULL,
&flags))
- fRedirUPL = 0;
+ redirUPL = 0;
if (physMem)
{
- IOUnmapPages( fAddressMap, fAddress, fLength );
+ IOUnmapPages( addressMap, logical, length );
physMem->redirect(0, true);
}
}
if (newBackingMemory)
{
- if (newBackingMemory != fMemory)
+ if (newBackingMemory != memory)
{
- fOffset = 0;
- if (this != newBackingMemory->makeMapping(newBackingMemory, fAddressTask, (IOVirtualAddress) this,
- options | kIOMapUnique | kIOMapReference | kIOMap64Bit,
- offset, fLength))
+ if (this != newBackingMemory->makeMapping(newBackingMemory, addressTask, (IOVirtualAddress) this,
+ options | kIOMapUnique | kIOMapReference,
+ offset, length))
err = kIOReturnError;
}
- if (fRedirUPL)
+ if (redirUPL)
{
- upl_commit(fRedirUPL, NULL, 0);
- upl_deallocate(fRedirUPL);
- fRedirUPL = 0;
+ upl_commit(redirUPL, NULL, 0);
+ upl_deallocate(redirUPL);
+ redirUPL = 0;
}
if (physMem)
physMem->redirect(0, false);
@@ -3189,45 +2740,29 @@
IOMemoryMap * IOMemoryDescriptor::makeMapping(
IOMemoryDescriptor * owner,
- task_t __intoTask,
- IOVirtualAddress __address,
+ task_t intoTask,
+ IOVirtualAddress toAddress,
IOOptionBits options,
- IOByteCount __offset,
- IOByteCount __length )
-{
- if (!(kIOMap64Bit & options)) panic("IOMemoryDescriptor::makeMapping !64bit");
-
+ IOByteCount offset,
+ IOByteCount length )
+{
IOMemoryDescriptor * mapDesc = 0;
- _IOMemoryMap * result = 0;
- OSIterator * iter;
-
- _IOMemoryMap * mapping = (_IOMemoryMap *) __address;
- mach_vm_size_t offset = mapping->fOffset + __offset;
- mach_vm_size_t length = mapping->fLength;
-
- mapping->fOffset = offset;
+ _IOMemoryMap * mapping = 0;
+ OSIterator * iter;
LOCK;
do
{
- if (kIOMapStatic & options)
- {
- result = mapping;
- addMapping(mapping);
- mapping->setMemoryDescriptor(this, 0);
- continue;
- }
-
if (kIOMapUnique & options)
{
IOPhysicalAddress phys;
IOByteCount physLen;
-// if (owner != this) continue;
-
- if (((_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
- || ((_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical64))
+ if (owner != this)
+ continue;
+
+ if ((_flags & kIOMemoryTypeMask) == kIOMemoryTypePhysical)
{
phys = getPhysicalSegment(offset, &physLen);
if (!phys || (physLen < length))
@@ -3238,64 +2773,107 @@
if (!mapDesc)
continue;
offset = 0;
- mapping->fOffset = offset;
+ }
+ else
+ {
+ mapDesc = this;
+ mapDesc->retain();
+ }
+
+ if (kIOMapReference & options)
+ {
+ mapping = (_IOMemoryMap *) toAddress;
+ mapping->retain();
+
+#if 1
+ uint32_t pageOffset1 = mapDesc->getSourceSegment( offset, NULL );
+ pageOffset1 -= trunc_page_32( pageOffset1 );
+
+ uint32_t pageOffset2 = mapping->getVirtualAddress();
+ pageOffset2 -= trunc_page_32( pageOffset2 );
+
+ if (pageOffset1 != pageOffset2)
+ IOLog("::redirect can't map offset %x to addr %x\n",
+ pageOffset1, mapping->getVirtualAddress());
+#endif
+
+
+ if (!mapping->initWithDescriptor( mapDesc, intoTask, toAddress, options,
+ offset, length ))
+ {
+#ifdef DEBUG
+ IOLog("Didn't redirect map %08lx : %08lx\n", offset, length );
+#endif
+ }
+
+ if (mapping->owner)
+ mapping->owner->removeMapping(mapping);
+ continue;
}
}
else
{
- // look for a compatible existing mapping
- if( (iter = OSCollectionIterator::withCollection(_mappings)))
- {
- _IOMemoryMap * lookMapping;
- while ((lookMapping = (_IOMemoryMap *) iter->getNextObject()))
- {
- if ((result = lookMapping->copyCompatible(mapping)))
- {
- addMapping(result);
- result->setMemoryDescriptor(this, offset);
+ // look for an existing mapping
+ if( (iter = OSCollectionIterator::withCollection( _mappings))) {
+
+ while( (mapping = (_IOMemoryMap *) iter->getNextObject())) {
+
+ if( (mapping = mapping->copyCompatible(
+ owner, intoTask, toAddress,
+ options | kIOMapReference,
+ offset, length )))
break;
- }
}
iter->release();
}
- if (result || (options & kIOMapReference))
+
+
+ if (mapping)
+ mapping->retain();
+
+ if( mapping || (options & kIOMapReference))
continue;
- }
-
- if (!mapDesc)
- {
- mapDesc = this;
+
+ mapDesc = owner;
mapDesc->retain();
}
- IOReturn
- kr = mapDesc->doMap( 0, (IOVirtualAddress *) &mapping, options, 0, 0 );
- if (kIOReturnSuccess == kr)
- {
- result = mapping;
- mapDesc->addMapping(result);
- result->setMemoryDescriptor(mapDesc, offset);
+ owner = this;
+
+ mapping = new _IOMemoryMap;
+ if( mapping
+ && !mapping->initWithDescriptor( mapDesc, intoTask, toAddress, options,
+ offset, length )) {
+#ifdef DEBUG
+ IOLog("Didn't make map %08lx : %08lx\n", offset, length );
+#endif
+ mapping->release();
+ mapping = 0;
}
- else
- {
- mapping->release();
- mapping = NULL;
- }
- }
- while( false );
+
+ if (mapping)
+ mapping->retain();
+
+ } while( false );
+
+ if (mapping)
+ {
+ mapping->owner = owner;
+ owner->addMapping( mapping);
+ mapping->release();
+ }
UNLOCK;
if (mapDesc)
mapDesc->release();
- return (result);
+ return( mapping);
}
void IOMemoryDescriptor::addMapping(
IOMemoryMap * mapping )
{
- if( mapping)
- {
+ if( mapping) {
if( 0 == _mappings)
_mappings = OSSet::withCapacity(1);
if( _mappings )
@@ -3367,52 +2945,11 @@
}
-IOReturn
-IOSubMemoryDescriptor::dmaCommandOperation(DMACommandOps op, void *vData, UInt dataSize) const
-{
- IOReturn rtn;
-
- if (kIOMDGetCharacteristics == op) {
-
- rtn = _parent->dmaCommandOperation(op, vData, dataSize);
- if (kIOReturnSuccess == rtn) {
- IOMDDMACharacteristics *data = (IOMDDMACharacteristics *) vData;
- data->fLength = _length;
- data->fSGCount = 0; // XXX gvdl: need to compute and pages
- data->fPages = 0;
- data->fPageAlign = 0;
- }
-
- return rtn;
- }
- else if (kIOMDWalkSegments & op) {
- if (dataSize < sizeof(IOMDDMAWalkSegmentArgs))
- return kIOReturnUnderrun;
-
- IOMDDMAWalkSegmentArgs *data =
- reinterpret_cast<IOMDDMAWalkSegmentArgs *>(vData);
- UInt offset = data->fOffset;
- UInt remain = _length - offset;
- if ((int) remain <= 0)
- return (!remain)? kIOReturnOverrun : kIOReturnInternalError;
-
- data->fOffset = offset + _start;
- rtn = _parent->dmaCommandOperation(op, vData, dataSize);
- if (data->fLength > remain)
- data->fLength = remain;
- data->fOffset = offset;
-
- return rtn;
- }
- else
- return kIOReturnBadArgument;
-}
-
-addr64_t
-IOSubMemoryDescriptor::getPhysicalSegment64(IOByteCount offset, IOByteCount * length)
-{
- addr64_t address;
- IOByteCount actualLength;
+IOPhysicalAddress IOSubMemoryDescriptor::getPhysicalSegment( IOByteCount offset,
+ IOByteCount * length )
+{
+ IOPhysicalAddress address;
+ IOByteCount actualLength;
assert(offset <= _length);
@@ -3422,7 +2959,7 @@
if( offset >= _length)
return( 0 );
- address = _parent->getPhysicalSegment64( offset + _start, &actualLength );
+ address = _parent->getPhysicalSegment( offset + _start, &actualLength );
if( address && length)
*length = min( _length - offset, actualLength );
@@ -3430,55 +2967,6 @@
return( address );
}
-IOPhysicalAddress
-IOSubMemoryDescriptor::getPhysicalSegment( IOByteCount offset, IOByteCount * length )
-{
- IOPhysicalAddress address;
- IOByteCount actualLength;
-
- assert(offset <= _length);
-
- if( length)
- *length = 0;
-
- if( offset >= _length)
- return( 0 );
-
- address = _parent->getPhysicalSegment( offset + _start, &actualLength );
-
- if( address && length)
- *length = min( _length - offset, actualLength );
-
- return( address );
-}
-
-IOPhysicalAddress
-IOSubMemoryDescriptor::getSourceSegment( IOByteCount offset, IOByteCount * length )
-{
- IOPhysicalAddress address;
- IOByteCount actualLength;
-
- assert(offset <= _length);
-
- if( length)
- *length = 0;
-
- if( offset >= _length)
- return( 0 );
-
- address = _parent->getSourceSegment( offset + _start, &actualLength );
-
- if( address && length)
- *length = min( _length - offset, actualLength );
-
- return( address );
-}
-
-void * IOSubMemoryDescriptor::getVirtualSegment(IOByteCount offset,
- IOByteCount * lengthOfSegment)
-{
- return( 0 );
-}
IOReturn IOSubMemoryDescriptor::doMap(
vm_map_t addressMap,
@@ -3487,8 +2975,37 @@
IOByteCount sourceOffset,
IOByteCount length )
{
- panic("IOSubMemoryDescriptor::doMap");
- return (IOMemoryDescriptor::doMap(addressMap, atAddress, options, sourceOffset, length));
+ if( sourceOffset >= _length)
+ return( kIOReturnOverrun );
+ return (_parent->doMap(addressMap, atAddress, options, sourceOffset + _start, length));
+}
+
+IOPhysicalAddress IOSubMemoryDescriptor::getSourceSegment( IOByteCount offset,
+ IOByteCount * length )
+{
+ IOPhysicalAddress address;
+ IOByteCount actualLength;
+
+ assert(offset <= _length);
+
+ if( length)
+ *length = 0;
+
+ if( offset >= _length)
+ return( 0 );
+
+ address = _parent->getSourceSegment( offset + _start, &actualLength );
+
+ if( address && length)
+ *length = min( _length - offset, actualLength );
+
+ return( address );
+}
+
+void * IOSubMemoryDescriptor::getVirtualSegment(IOByteCount offset,
+ IOByteCount * lengthOfSegment)
+{
+ return( 0 );
}
IOByteCount IOSubMemoryDescriptor::readBytes(IOByteCount offset,
@@ -3584,23 +3101,29 @@
IOMemoryMap * IOSubMemoryDescriptor::makeMapping(
IOMemoryDescriptor * owner,
task_t intoTask,
- IOVirtualAddress address,
+ IOVirtualAddress toAddress,
IOOptionBits options,
IOByteCount offset,
IOByteCount length )
{
IOMemoryMap * mapping = 0;
- if (!(kIOMap64Bit & options))
- {
- panic("IOSubMemoryDescriptor::makeMapping !64bit");
- }
-
- mapping = (IOMemoryMap *) _parent->makeMapping(
- owner,
- intoTask,
- address,
+ if (!(kIOMapUnique & options))
+ mapping = (IOMemoryMap *) _parent->makeMapping(
+ _parent, intoTask,
+ toAddress - (_start + offset),
+ options | kIOMapReference,
+ _start + offset, length );
+
+ if( !mapping)
+ mapping = (IOMemoryMap *) _parent->makeMapping(
+ _parent, intoTask,
+ toAddress,
options, _start + offset, length );
+
+ if( !mapping)
+ mapping = super::makeMapping( owner, intoTask, toAddress, options,
+ offset, length );
return( mapping );
}
@@ -3747,7 +3270,7 @@
if (keys[1])
keys[1]->release();
if (vcopy)
- IOFree(vcopy, sizeof(SerData) * nRanges);
+ IOFree(vcopy, sizeof(IOVirtualRange) * nRanges);
return result;
}
@@ -3805,7 +3328,7 @@
OSMetaClassDefineReservedUsed(IOMemoryDescriptor, 2);
OSMetaClassDefineReservedUsed(IOMemoryDescriptor, 3);
OSMetaClassDefineReservedUsed(IOMemoryDescriptor, 4);
-OSMetaClassDefineReservedUsed(IOMemoryDescriptor, 5);
+OSMetaClassDefineReservedUnused(IOMemoryDescriptor, 5);
OSMetaClassDefineReservedUnused(IOMemoryDescriptor, 6);
OSMetaClassDefineReservedUnused(IOMemoryDescriptor, 7);
OSMetaClassDefineReservedUnused(IOMemoryDescriptor, 8);
@@ -3818,9 +3341,5 @@
OSMetaClassDefineReservedUnused(IOMemoryDescriptor, 15);
/* ex-inline function implementation */
-IOPhysicalAddress
-IOMemoryDescriptor::getPhysicalAddress()
+IOPhysicalAddress IOMemoryDescriptor::getPhysicalAddress()
{ return( getPhysicalSegment( 0, 0 )); }
-
-
-