From f07a4c844da9f0ecae5bbee1ab94be56505f26f7 Mon Sep 17 00:00:00 2001 From: Thomas Bushnell Date: Tue, 25 Feb 1997 21:28:37 +0000 Subject: Initial source --- include/mach/memory_object.defs | 313 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 313 insertions(+) create mode 100644 include/mach/memory_object.defs (limited to 'include/mach/memory_object.defs') diff --git a/include/mach/memory_object.defs b/include/mach/memory_object.defs new file mode 100644 index 0000000..e64be87 --- /dev/null +++ b/include/mach/memory_object.defs @@ -0,0 +1,313 @@ +/* + * Mach Operating System + * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University + * All Rights Reserved. + * + * Permission to use, copy, modify and distribute this software and its + * documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR + * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie Mellon + * the rights to redistribute these changes. + */ +/* + * File: mach/memory_object.defs + * + * Abstract: + * Basic Mach external memory management interface declaration. + */ + +subsystem +#if KERNEL_USER + KernelUser +#endif KERNEL_USER +#if KERNEL_SERVER + KernelServer +#endif KERNEL_SERVER + memory_object 2200; + +#ifdef KERNEL +#include +#if NORMA_VM +userprefix k_; +#endif NORMA_VM +#endif KERNEL + +#include +#include + +#if SEQNOS +serverprefix seqnos_; +serverdemux seqnos_memory_object_server; +#endif SEQNOS + +/* + * Initialize the specified memory object, providing + * a reqeust port on which control calls can be made, and + * a name port that identifies this object to callers of + * vm_regions. + * [To allow the mapping of this object to be used, the + * memory manager must call memory_object_set_attributes, + * specifying the "ready" parameter as TRUE. To reject + * all mappings of this object, the memory manager may + * use memory_object_destroy.] + */ +simpleroutine memory_object_init( + memory_object : memory_object_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + memory_object_name : memory_object_name_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + memory_object_page_size : vm_size_t); + +/* + * Indicates that the specified memory object is no longer + * mapped (or cached -- see memory_object_set_attributes), + * and that further mappings will cause another memory_object_init + * call to be made. No further calls will be made on + * the memory object by this kernel. + * + * [All rights to the control and name ports are included + * in this call. The memory manager should use port_deallocate + * to release them once they are no longer needed.] + */ +simpleroutine memory_object_terminate( + memory_object : memory_object_t = + MACH_MSG_TYPE_MOVE_SEND + ctype: mach_port_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MOVE_RECEIVE + ctype: mach_port_t +#if KERNEL_USER + /* for compatibility with Mach 2.5 kernels */ + , dealloc +#endif KERNEL_USER + ; + memory_object_name : memory_object_name_t = + MACH_MSG_TYPE_MOVE_RECEIVE + ctype: mach_port_t +#if KERNEL_USER + /* for compatibility with Mach 2.5 kernels */ + , dealloc +#endif KERNEL_USER + ); + +/* + * Indicates that a copy has been made of the specified range of + * the given original memory object. The kernel will use the new + * memory object, control and name ports to refer to the new copy + * (once the memory manager has asserted its "ready" attribute). + * + * Cached pages from the original memory object at the time of + * the copy operation are handled as follows: + * Readable pages may be silently copied to the new + * memory object (with all access permissions). + * Pages not copied are locked to prevent write access. + * + * This call includes only the new memory object itself; a + * memory_object_init call will be made on the new memory + * object after the actions above are completed. + * + * The new memory object is *temporary*, meaning that the + * memory manager should not change its contents or allow + * the memory object to be mapped in another client. The + * memory manager may use the memory_object_data_unavailable + * call to indicate that the appropriate page of the original + * memory object may be used to fulfill a data request. + * + * [Reply should be memory_object_set_attributes on the + * new memory object control port to indicate readiness.] + */ +simpleroutine memory_object_copy( + old_memory_object : memory_object_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + old_memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + length : vm_size_t; + new_memory_object : memory_object_t = + MACH_MSG_TYPE_MOVE_RECEIVE + ctype: mach_port_t +#if KERNEL_USER + /* for compatibility with Mach 2.5 kernels */ + , dealloc +#endif KERNEL_USER + ); + +/* + * Request data from this memory object. At least + * the specified data should be returned with at + * least the specified access permitted. + * + * [Reply should be memory_object_data_provided.] + */ +simpleroutine memory_object_data_request( + memory_object : memory_object_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + length : vm_size_t; + desired_access : vm_prot_t); + +/* + * Request that the specified portion of this + * memory object be unlocked to allow the specified + * forms of access; the kernel already has the data. + * + * [Reply should be memory_object_lock_request.] + */ +simpleroutine memory_object_data_unlock( + memory_object : memory_object_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + length : vm_size_t; + desired_access : vm_prot_t); + +/* + * Write back modifications made to this portion of + * the memory object while in memory. + * + * Unless explicitly requested by a memory_object_lock_request + * (clean, but not flush), the kernel will not retain + * the data. + * + * [Reply should be vm_deallocate to release the data.] + */ +simpleroutine memory_object_data_write( + memory_object : memory_object_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + data : pointer_t); + +/* + * Indicate that a previous memory_object_lock_reqeust has been + * completed. Note that this call is made on whatever + * port is specified in the memory_object_lock_request; that port + * need not be the memory object port itself. + * + * [No reply expected.] + */ +simpleroutine memory_object_lock_completed( + memory_object : memory_object_t = + polymorphic|MACH_MSG_TYPE_PORT_SEND_ONCE + ctype: mach_port_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + length : vm_size_t); + +/* + * Indicate that a previous memory_object_data_supply has been + * completed. Note that this call is made on whatever + * port is specified in the memory_object_data_supply; that port + * need not be the memory object port itself. + * + * The result parameter indicates what happened during the supply. + * If it is not KERN_SUCCESS, then error_offset identifies the + * first offset at which a problem occurred. The pagein operation + * stopped at this point. Note that the only failures reported + * by this mechanism are KERN_MEMORY_PRESENT. All other failures + * (invalid argument, error on pagein of supplied data in manager's + * address space) cause the entire operation to fail. + * + * XXX Check what actually happens in latter case! + * + * [No reply expected.] + */ +simpleroutine memory_object_supply_completed( + memory_object : memory_object_t = + polymorphic|MACH_MSG_TYPE_PORT_SEND_ONCE + ctype: mach_port_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + length : vm_size_t; + result : kern_return_t; + error_offset : vm_offset_t); + +/* + * Return data to manager. This call is used in place of data_write + * for objects initialized by object_ready instead of set_attributes. + * This call indicates whether the returned data is dirty and whether + * the kernel kept a copy. Precious data remains precious if the + * kernel keeps a copy. The indication that the kernel kept a copy + * is only a hint if the data is not precious; the cleaned copy may + * be discarded without further notifying the manager. + * + * [Reply should be vm_deallocate to release the data.] + */ +simpleroutine memory_object_data_return( + memory_object : memory_object_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + memory_control : memory_object_control_t = + MACH_MSG_TYPE_MAKE_SEND + ctype: mach_port_t; + offset : vm_offset_t; + data : pointer_t; + dirty : boolean_t; + kernel_copy : boolean_t); + +/* + * XXX Warning: This routine does NOT contain a memory_object_control_t + * XXX because the memory_object_change_attributes call may cause + * XXX memory object termination (by uncaching the object). This would + * XXX yield an invalid port. + */ + +simpleroutine memory_object_change_completed( + memory_object : memory_object_t = + polymorphic|MACH_MSG_TYPE_PORT_SEND_ONCE + ctype: mach_port_t; +#if SEQNOS + msgseqno seqno : mach_port_seqno_t; +#endif SEQNOS + may_cache : boolean_t; + copy_strategy : memory_object_copy_strategy_t); -- cgit v1.2.3