/*
- * Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
*
- * 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.
- *
- * 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 OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
+ * 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
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
*/
#include <sys/errno.h>
-#include <kern/host.h>
+
#include <mach/mach_types.h>
-#include <vm/vm_map.h>
-#include <vm/vm_kern.h>
-#include <vm/vm_pageout.h>
#include <mach/kern_return.h>
+#include <mach/memory_object_control.h>
#include <mach/memory_object_types.h>
#include <mach/port.h>
#include <mach/policy.h>
+#include <mach/upl.h>
+#include <kern/kern_types.h>
+#include <kern/ipc_kobject.h>
+#include <kern/host.h>
+#include <kern/thread.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_space.h>
-#include <kern/thread.h>
#include <device/device_port.h>
+#include <vm/memory_object.h>
#include <vm/vm_pageout.h>
-
-#include <libkern/OSAtomic.h>
+#include <vm/vm_map.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_pageout.h>
+#include <vm/vm_protos.h>
/* Device VM COMPONENT INTERFACES */
/* until component support available */
-int device_pager_workaround;
+const struct memory_object_pager_ops device_pager_ops = {
+ device_pager_reference,
+ device_pager_deallocate,
+ device_pager_init,
+ device_pager_terminate,
+ device_pager_data_request,
+ device_pager_data_return,
+ device_pager_data_initialize,
+ device_pager_data_unlock,
+ device_pager_synchronize,
+ device_pager_unmap,
+ "device pager"
+};
typedef int device_port_t;
+/*
+ * The start of "struct device_pager" MUST match a "struct memory_object".
+ */
typedef struct device_pager {
- int *pager; /* pager workaround pointer */
+ memory_object_pager_ops_t pager_ops; /* == &device_pager_ops */
unsigned int pager_ikot; /* fake ip_kotype() */
unsigned int ref_count; /* reference count */
memory_object_control_t control_handle; /* mem object's cntrl handle */
-void
-device_pager_bootstrap(
- void);
-
-
-memory_object_t
-device_pager_setup(
- memory_object_t,
- int,
- vm_size_t,
- int);
device_pager_t
-device_pager_lookup(
- memory_object_t);
-
-kern_return_t
-device_pager_init(
- memory_object_t,
- memory_object_control_t,
- vm_size_t);
-
-
-kern_return_t
-device_pager_data_request(
- memory_object_t,
- memory_object_offset_t,
- vm_size_t,
- vm_prot_t);
-
-kern_return_t
-device_pager_data_return(
- memory_object_t,
- memory_object_offset_t,
- vm_size_t,
- boolean_t,
- boolean_t);
-
-void
-device_pager_reference(
- memory_object_t);
-
-void
-device_pager_deallocate(
- memory_object_t);
-
-kern_return_t
-device_pager_data_initialize(
- memory_object_t,
- memory_object_offset_t,
- vm_size_t);
-
-kern_return_t
-device_pager_data_unlock(
- memory_object_t,
- memory_object_offset_t,
- vm_size_t,
- vm_prot_t);
-
-kern_return_t
-device_pager_terminate(
- memory_object_t);
-
-kern_return_t
-device_pager_synchronize(
- memory_object_t,
- memory_object_offset_t,
- vm_offset_t,
- vm_sync_t);
-
-kern_return_t
-device_pager_unmap(
+device_pager_lookup( /* forward */
memory_object_t);
device_pager_t
-device_object_create(void);
+device_object_create(void); /* forward */
zone_t device_pager_zone;
*/
memory_object_t
device_pager_setup(
- memory_object_t device,
+ __unused memory_object_t device,
int device_handle,
vm_size_t size,
int flags)
device_object->device_handle = device_handle;
device_object->size = size;
- device_object->flags = 0;
- if(flags & DEVICE_PAGER_CONTIGUOUS) {
- device_object->flags |= DEVICE_PAGER_CONTIGUOUS;
- }
- if(flags & DEVICE_PAGER_NOPHYSCACHE) {
- device_object->flags |= DEVICE_PAGER_NOPHYSCACHE;
- }
+ device_object->flags = flags;
return((memory_object_t)device_object);
}
device_pager_populate_object(
memory_object_t device,
memory_object_offset_t offset,
- vm_offset_t phys_addr,
+ ppnum_t page_num,
vm_size_t size)
{
device_pager_t device_object;
vm_object_t vm_object;
kern_return_t kr;
upl_t upl;
- ipc_port_t previous;
device_object = device_pager_lookup(device);
if(device_object == DEVICE_PAGER_NULL)
return KERN_FAILURE;
kr = vm_object_populate_with_private(
- vm_object, offset, phys_addr, size);
+ vm_object, offset, page_num, size);
if(kr != KERN_SUCCESS)
return kr;
if(!vm_object->phys_contiguous) {
- int null_size = 0;
+ unsigned int null_size = 0;
kr = vm_object_upl_request(vm_object,
(vm_object_offset_t)offset, size, &upl, NULL,
&null_size, (UPL_NO_SYNC | UPL_CLEAN_IN_PLACE));
if(kr != KERN_SUCCESS)
panic("device_pager_populate_object: list_req failed");
- upl_commit(upl, NULL);
+ upl_commit(upl, NULL, 0);
upl_deallocate(upl);
}
device_pager_t device_object;
device_object = (device_pager_t)name;
- assert(device_object->pager == &device_pager_workaround);
+ assert(device_object->pager_ops == &device_pager_ops);
return (device_object);
}
*
*/
kern_return_t
-device_pager_init(memory_object_t mem_obj,
- memory_object_control_t control,
- vm_size_t pg_size)
+device_pager_init(
+ memory_object_t mem_obj,
+ memory_object_control_t control,
+ __unused vm_size_t pg_size)
{
device_pager_t device_object;
kern_return_t kr;
vm_object->phys_contiguous = TRUE;
if(device_object->flags & DEVICE_PAGER_NOPHYSCACHE)
vm_object->nophyscache = TRUE;
+
+ vm_object->wimg_bits = device_object->flags & VM_WIMG_MASK;
vm_object_unlock(vm_object);
/*
*
*/
+/*ARGSUSED6*/
kern_return_t
device_pager_data_return(
- memory_object_t mem_obj,
- memory_object_offset_t offset,
- vm_size_t data_cnt,
- boolean_t dirty,
- boolean_t kernel_copy)
+ memory_object_t mem_obj,
+ memory_object_offset_t offset,
+ vm_size_t data_cnt,
+ __unused memory_object_offset_t *resid_offset,
+ __unused int *io_error,
+ __unused boolean_t dirty,
+ __unused boolean_t kernel_copy,
+ __unused int upl_flags)
{
device_pager_t device_object;
if (device_object == DEVICE_PAGER_NULL)
panic("device_pager_data_return: lookup failed");
- return device_data_action(device_object->device_handle, device_object,
- VM_PROT_READ | VM_PROT_WRITE, offset, data_cnt);
+ return device_data_action(device_object->device_handle,
+ (ipc_port_t) device_object,
+ VM_PROT_READ | VM_PROT_WRITE,
+ offset, data_cnt);
}
/*
memory_object_t mem_obj,
memory_object_offset_t offset,
vm_size_t length,
- vm_prot_t protection_required)
+ __unused vm_prot_t protection_required)
{
device_pager_t device_object;
if (device_object == DEVICE_PAGER_NULL)
panic("device_pager_data_request: lookup failed");
- device_data_action(device_object->device_handle, device_object,
- VM_PROT_READ, offset, length);
+ device_data_action(device_object->device_handle,
+ (ipc_port_t) device_object,
+ VM_PROT_READ, offset, length);
return KERN_SUCCESS;
}
memory_object_t mem_obj)
{
device_pager_t device_object;
- unsigned int prev_ref_count;
+ unsigned int new_ref_count;
device_object = device_pager_lookup(mem_obj);
- prev_ref_count = OSIncrementAtomic((UInt32 *)&device_object->ref_count);
- assert(prev_ref_count > 0);
+ new_ref_count = hw_atomic_add(&device_object->ref_count, 1);
+ assert(new_ref_count > 1);
}
/*
device_pager_deallocate(
memory_object_t mem_obj)
{
- device_pager_t device_object;
+ device_pager_t device_object;
+ memory_object_control_t device_control;
device_object = device_pager_lookup(mem_obj);
- if (OSDecrementAtomic((UInt32 *)&device_object->ref_count) == 1) {
+ if (hw_atomic_sub(&device_object->ref_count, 1) == 0) {
if (device_object->device_handle != (device_port_t) NULL) {
device_close(device_object->device_handle);
+ device_object->device_handle = (device_port_t) NULL;
+ }
+ device_control = device_object->control_handle;
+ if (device_control != MEMORY_OBJECT_CONTROL_NULL) {
+ /*
+ * The VM object should already have been disconnected
+ * from the pager at this point.
+ * We still have to release the "memory object control"
+ * handle.
+ */
+ assert(device_control->moc_object == VM_OBJECT_NULL);
+ memory_object_control_deallocate(device_control);
+ device_object->control_handle =
+ MEMORY_OBJECT_CONTROL_NULL;
}
- zfree(device_pager_zone, (vm_offset_t) device_object);
+
+ zfree(device_pager_zone, device_object);
}
return;
}
kern_return_t
device_pager_data_initialize(
- memory_object_t mem_obj,
- memory_object_offset_t offset,
- vm_size_t data_cnt)
+ __unused memory_object_t mem_obj,
+ __unused memory_object_offset_t offset,
+ __unused vm_size_t data_cnt)
{
+ panic("device_pager_data_initialize");
return KERN_FAILURE;
}
kern_return_t
device_pager_data_unlock(
- memory_object_t mem_obj,
- memory_object_offset_t offset,
- vm_size_t size,
- vm_prot_t desired_access)
+ __unused memory_object_t mem_obj,
+ __unused memory_object_offset_t offset,
+ __unused vm_size_t size,
+ __unused vm_prot_t desired_access)
{
return KERN_FAILURE;
}
+kern_return_t
device_pager_terminate(
- memory_object_t mem_obj)
+ __unused memory_object_t mem_obj)
{
return KERN_SUCCESS;
}
memory_object_t mem_obj,
memory_object_offset_t offset,
vm_offset_t length,
- vm_sync_t sync_flags)
+ __unused vm_sync_t sync_flags)
{
device_pager_t device_object;
*/
kern_return_t
device_pager_unmap(
- memory_object_t mem_obj)
+ __unused memory_object_t mem_obj)
{
return KERN_SUCCESS;
}
device_object = (struct device_pager *) zalloc(device_pager_zone);
if (device_object == DEVICE_PAGER_NULL)
return(DEVICE_PAGER_NULL);
- device_object->pager = &device_pager_workaround;
+ device_object->pager_ops = &device_pager_ops;
device_object->pager_ikot = IKOT_MEMORY_OBJECT;
device_object->ref_count = 1;
device_object->control_handle = MEMORY_OBJECT_CONTROL_NULL;
projects / apple / xnu.git / blobdiff