/*
- * Copyright (c) 1998-2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2004 Apple Computer, Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
*
- * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
- *
- * 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. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
+ * 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.
+ *
+ * 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
- * 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
+ *
+ * The 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.
- *
- * @APPLE_LICENSE_HEADER_END@
+ *
+ * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
*/
/*
* HISTORY
#include <IOKit/IOReturn.h>
#include <IOKit/IOLib.h>
+#include <IOKit/IOLocks.h>
#include <IOKit/IOMapper.h>
#include <IOKit/IOKitDebug.h>
+#include "IOKitKernelInternal.h"
+
mach_timespec_t IOZeroTvalspec = { 0, 0 };
extern ppnum_t pmap_find_phys(pmap_t pmap, addr64_t va);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+lck_grp_t *IOLockGroup;
+
/*
* Global variables for use by iLogger
* These symbols are for use only by Apple diagnostic code.
* Static variables for this module.
*/
-static IOThreadFunc threadArgFcn;
-static void * threadArgArg;
-static lock_t * threadArgLock;
-
static queue_head_t gIOMallocContiguousEntries;
-static mutex_t * gIOMallocContiguousEntriesLock;
+static lck_mtx_t * gIOMallocContiguousEntriesLock;
enum { kIOMaxPageableMaps = 16 };
-enum { kIOPageableMapSize = 16 * 1024 * 1024 };
-enum { kIOPageableMaxMapSize = 64 * 1024 * 1024 };
+enum { kIOPageableMapSize = 96 * 1024 * 1024 };
+enum { kIOPageableMaxMapSize = 96 * 1024 * 1024 };
+/* LP64todo - these need to expand */
typedef struct {
vm_map_t map;
vm_offset_t address;
UInt32 count;
UInt32 hint;
IOMapData maps[ kIOMaxPageableMaps ];
- mutex_t * lock;
+ lck_mtx_t * lock;
} gIOKitPageableSpace;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
if(libInitialized)
return;
- threadArgLock = lock_alloc( true, NULL, NULL );
-
gIOKitPageableSpace.maps[0].address = 0;
ret = kmem_suballoc(kernel_map,
&gIOKitPageableSpace.maps[0].address,
kIOPageableMapSize,
TRUE,
- TRUE,
+ VM_FLAGS_ANYWHERE,
&gIOKitPageableSpace.maps[0].map);
if (ret != KERN_SUCCESS)
panic("failed to allocate iokit pageable map\n");
- gIOKitPageableSpace.lock = mutex_alloc( 0 );
+ IOLockGroup = lck_grp_alloc_init("IOKit", LCK_GRP_ATTR_NULL);
+
+ gIOKitPageableSpace.lock = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL);
gIOKitPageableSpace.maps[0].end = gIOKitPageableSpace.maps[0].address + kIOPageableMapSize;
gIOKitPageableSpace.hint = 0;
gIOKitPageableSpace.count = 1;
- gIOMallocContiguousEntriesLock = mutex_alloc( 0 );
+ gIOMallocContiguousEntriesLock = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL);
queue_init( &gIOMallocContiguousEntries );
libInitialized = true;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*
- * We pass an argument to a new thread by saving fcn and arg in some
- * locked variables and starting the thread at ioThreadStart(). This
- * function retrives fcn and arg and makes the appropriate call.
- *
- */
-
-static void ioThreadStart( void )
-{
- IOThreadFunc fcn;
- void * arg;
-
- fcn = threadArgFcn;
- arg = threadArgArg;
- lock_done( threadArgLock);
-
- (*fcn)(arg);
-
- IOExitThread();
-}
-
IOThread IOCreateThread(IOThreadFunc fcn, void *arg)
{
- IOThread thread;
+ kern_return_t result;
+ thread_t thread;
- lock_write( threadArgLock);
- threadArgFcn = fcn;
- threadArgArg = arg;
+ result = kernel_thread_start((thread_continue_t)fcn, arg, &thread);
+ if (result != KERN_SUCCESS)
+ return (NULL);
- thread = kernel_thread( kernel_task, ioThreadStart);
+ thread_deallocate(thread);
- return(thread);
+ return (thread);
}
-volatile void IOExitThread()
+volatile void IOExitThread(void)
{
- (void) thread_terminate(current_act());
+ (void) thread_terminate(current_thread());
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void IOFree(void * address, vm_size_t size)
{
if (address) {
- kfree((vm_offset_t)address, size);
+ kfree(address, size);
#if IOALLOCDEBUG
debug_iomalloc_size -= size;
#endif
- sizeof(vm_address_t) ));
if (adjustedSize >= page_size)
- kmem_free( kernel_map, (vm_address_t) allocationAddress, adjustedSize);
+ kmem_free( kernel_map, allocationAddress, adjustedSize);
else
- kfree((vm_offset_t) allocationAddress, adjustedSize);
+ kfree((void *)allocationAddress, adjustedSize);
}
#if IOALLOCDEBUG
}
entry->virtual = (void *) address;
entry->ioBase = base;
- mutex_lock(gIOMallocContiguousEntriesLock);
+ lck_mtx_lock(gIOMallocContiguousEntriesLock);
queue_enter( &gIOMallocContiguousEntries, entry,
_IOMallocContiguousEntry *, link );
- mutex_unlock(gIOMallocContiguousEntriesLock);
+ lck_mtx_unlock(gIOMallocContiguousEntriesLock);
*physicalAddress = (IOPhysicalAddress)((base << PAGE_SHIFT) | (address & PAGE_MASK));
for (offset = 0; offset < ((size + PAGE_MASK) >> PAGE_SHIFT); offset++, pagenum++)
assert(size);
- mutex_lock(gIOMallocContiguousEntriesLock);
+ lck_mtx_lock(gIOMallocContiguousEntriesLock);
queue_iterate( &gIOMallocContiguousEntries, entry,
_IOMallocContiguousEntry *, link )
{
break;
}
}
- mutex_unlock(gIOMallocContiguousEntriesLock);
+ lck_mtx_unlock(gIOMallocContiguousEntriesLock);
if (base)
{
allocationAddress = *((vm_address_t *)( (vm_address_t) address
- sizeof(vm_address_t) ));
- kfree((vm_offset_t) allocationAddress, adjustedSize);
+ kfree((void *)allocationAddress, adjustedSize);
}
#if IOALLOCDEBUG
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-typedef kern_return_t (*IOIteratePageableMapsCallback)(vm_map_t map, void * ref);
-
kern_return_t IOIteratePageableMaps(vm_size_t size,
IOIteratePageableMapsCallback callback, void * ref)
{
if( KERN_SUCCESS == kr)
break;
- mutex_lock( gIOKitPageableSpace.lock );
+ lck_mtx_lock( gIOKitPageableSpace.lock );
index = gIOKitPageableSpace.count;
if( index >= (kIOMaxPageableMaps - 1)) {
- mutex_unlock( gIOKitPageableSpace.lock );
+ lck_mtx_unlock( gIOKitPageableSpace.lock );
break;
}
&min,
segSize,
TRUE,
- TRUE,
+ VM_FLAGS_ANYWHERE,
&map);
if( KERN_SUCCESS != kr) {
- mutex_unlock( gIOKitPageableSpace.lock );
+ lck_mtx_unlock( gIOKitPageableSpace.lock );
break;
}
gIOKitPageableSpace.hint = index;
gIOKitPageableSpace.count = index + 1;
- mutex_unlock( gIOKitPageableSpace.lock );
+ lck_mtx_unlock( gIOKitPageableSpace.lock );
} while( true );
#if IOALLOCDEBUG
if( ref.address)
- debug_iomalloc_size += round_page_32(size);
+ debug_iomallocpageable_size += round_page_32(size);
#endif
return( (void *) ref.address );
kmem_free( map, (vm_offset_t) address, size);
#if IOALLOCDEBUG
- debug_iomalloc_size -= round_page_32(size);
+ debug_iomallocpageable_size -= round_page_32(size);
#endif
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-extern kern_return_t IOMapPages(vm_map_t map, vm_offset_t va, vm_offset_t pa,
- vm_size_t length, unsigned int options);
-extern kern_return_t IOUnmapPages(vm_map_t map, vm_offset_t va, vm_size_t length);
-
IOReturn IOSetProcessorCacheMode( task_t task, IOVirtualAddress address,
IOByteCount length, IOOptionBits cacheMode )
{
void IOSleep(unsigned milliseconds)
{
- wait_result_t wait_result;
-
- wait_result = assert_wait_timeout(milliseconds, THREAD_UNINT);
- assert(wait_result == THREAD_WAITING);
-
- wait_result = thread_block(THREAD_CONTINUE_NULL);
- assert(wait_result == THREAD_TIMED_OUT);
+ delay_for_interval(milliseconds, kMillisecondScale);
}
/*
*/
void IODelay(unsigned microseconds)
{
- extern void delay(int usec);
-
- delay(microseconds);
+ delay_for_interval(microseconds, kMicrosecondScale);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
va_list ap;
extern void conslog_putc(char);
- extern void logwakeup();
+ extern void logwakeup(void);
va_start(ap, format);
_doprnt(format, &ap, conslog_putc, 16);
}
return size;
}
-
-IOReturn IONDRVLibrariesInitialize( void )
-{
- return( kIOReturnUnsupported );
-}
projects / apple / xnu.git / blobdiff