OpenStep 4.2J (Developer)

home *** CD-ROM | disk | FTP | other *** search

/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Headers / mach / mach.defs < prev next >

Wrap

Text File | 1995-02-28 | 31.9 KB | 1,104 lines

/* * Mach Operating System * Copyright (c) 1991,1990,1989,1988 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. */ /* * HISTORY * $Log: mach.defs,v $ * Revision 2.15 93/01/21 12:23:14 danner * New interface for task_ras_control. * [93/01/19 16:35:06 bershad] * * Revision 2.14 92/07/20 13:33:09 cmaeda * Added definition for task_set_ras_pc. * Uses message number recycled from old task_get_io_port. * [92/05/11 14:37:53 cmaeda] * * Revision 2.13 92/01/15 13:45:00 rpd * Changed MACH_IPC_COMPAT conditionals to default to not present. * * Revision 2.12 92/01/14 16:45:18 rpd * Changed mach_port_array_t usages to remain compatible, * because the definition of the type changed incompatibly. * [92/01/13 rpd] * Updated vm_region for new memory_object_name_t definition. * [91/12/31 rpd] * * Revision 2.11 92/01/03 20:20:53 dbg * Changed (new) task_get_emulation_vector, * task_set_emulation_vector to pass data out-of-line. Old * routines still pass data in-line, for compatibility. * [92/01/03 dbg] * * Add 'CountInOut' tag to routines returning variable-length * inline arrays. Remove 'IsLong' tag from routines passing or * returning variable-length arrays. Old routines left under * 'xxx_' names. REMOVE THESE SOON! * * I used the message IDs from the Mach 1.5 thread calls (before * the real thread support went in) - they haven't been used since * 1988. * [91/11/26 dbg] * * Revision 2.10 91/08/28 11:15:04 jsb * Precious page support: Add new version of memory_object_lock_request. * Add memory_object_{ready,change_attributes}. * [91/07/03 14:03:34 dlb] * Added KERNEL_USER definitions (for NORMA support). * [91/08/15 09:58:13 jsb] * * Revision 2.9 91/07/31 17:53:17 dbg * Added user-settable 'dealloc' flag to data argument of * memory_object_data_supply. Needs new MiG. * USERS OF THIS FUNCTION MUST RE-LINK!! * [91/07/29 dbg] * * MACH_IPC_COMPAT: set C type for backup argument to * port_set_backup to be 'mach_port_t'. If mach_interface.h is * included with MACH_IPC_COMPAT == 0, the type 'port_t' is not * defined. * * Removed vm_pageable. * [91/06/24 dbg] * * Revision 2.8 91/07/01 08:25:09 jsb * From David Black at OSF: added memory_object_data_supply. * [91/06/29 14:59:47 jsb] * * Revision 2.7 91/06/06 17:07:51 jsb * Added task_get_emulation_vector, task_set_emulation_vector. * [91/05/24 18:26:01 jsb] * * Revision 2.6 91/05/14 16:54:18 mrt * Correcting copyright * * Revision 2.5 91/02/05 17:33:12 mrt * Changed to new Mach copyright * [91/02/01 17:17:41 mrt] * * Revision 2.4 90/06/02 14:58:09 rpd * Changed reply_to argument of memory_object_lock_request * to default to a send-once right but still allow send rights. * [90/05/31 rpd] * * Changes for the emulator: remove vm_allocate, redefine vm_map. * * Obsoleted vm_allocate_with_pager. * [90/04/08 rpd] * Converted to new IPC. Purged MACH_NP, MACH_NET. * Moved vm_set_default_memory_manager, memory_object_get_attributes. * [90/03/26 22:31:41 rpd] * * * Condensed history: * Added vm_machine_attribute (af). * Added memory_object_get_attributes (mwyoung). * Added vm_set_default_memory_manager (mwyoung). * Added thread_set_priority (dbg). * Added vm_pageable (dbg). * Added port_set_backup (rpd). * Added memory_object_destroy (mwyoung). * Converted to memory_object_* names (mwyoung). * New port and port set calls (rpd). * Added documentation (mwyoung). * Added vm_map, pager_attributes, pager_data_error (mwyoung). * Added task_set_emulation and task_get_io_port (dorr). * Added new thread and task interfaces (dbg). * Reset history (avie). */ /* * Matchmaker definitions file for Mach kernel interface. */ subsystem #if KERNEL_USER && defined(NEW_MACH_IPC) KernelUser #endif KERNEL_USER #if KERNEL_SERVER && defined(NEW_MACH_IPC) KernelServer #endif KERNEL_SERVER mach 2000; #include <mach/std_types.defs> #include <mach/mach_types.defs> skip; /* old port_allocate */ skip; /* old port_deallocate */ skip; /* old port_enable */ skip; /* old port_disable */ skip; /* old port_select */ skip; /* old port_set_backlog */ skip; /* old port_status */ /* * Create a new task with an empty set of IPC rights, * and having an address space constructed from the * target task (or empty, if inherit_memory is FALSE). */ routine task_create( target_task : task_t; inherit_memory : boolean_t; out child_task : task_t); /* * Destroy the target task, causing all of its threads * to be destroyed, all of its IPC rights to be deallocated, * and all of its address space to be deallocated. */ routine task_terminate( target_task : task_t); skip; /* task_get_emulation_vector */ skip; /* task_set_emulation_vector */ /* * Returns the set of threads belonging to the target task. */ routine task_threads( target_task : task_t; out thread_list : thread_array_t); skip; /* task_info: MACH 3.0 */ skip; /* old task_status */ skip; /* old task_set_notify */ skip; /* old thread_create */ /* * Destroy the target thread. */ routine thread_terminate( target_thread : thread_t); skip; /* thread_get_state: MACH 3.0 */ skip; /* thread_set_state: MACH 3.0 */ skip; /* thread_info: MACH 3.0 */ skip; /* old thread_mutate */ /* * Allocate zero-filled memory in the address space * of the target task, either at the specified address, * or wherever space can be found (if anywhere is TRUE), * of the specified size. The address at which the * allocation actually took place is returned. */ routine vm_allocate( target_task : vm_task_t; inout address : vm_address_t; size : vm_size_t; anywhere : boolean_t); skip; /* old vm_allocate_with_pager */ /* * Deallocate the specified range from the virtual * address space of the target task. */ routine vm_deallocate( target_task : vm_task_t; address : vm_address_t; size : vm_size_t); /* * Set the current or maximum protection attribute * for the specified range of the virtual address * space of the target task. The current protection * limits the memory access rights of threads within * the task; the maximum protection limits the accesses * that may be given in the current protection. * Protections are specified as a set of {read, write, execute} * *permissions*. */ routine vm_protect( target_task : vm_task_t; address : vm_address_t; size : vm_size_t; set_maximum : boolean_t; new_protection : vm_prot_t); /* * Set the inheritance attribute for the specified range * of the virtual address space of the target task. * The inheritance value is one of {none, copy, share}, and * specifies how the child address space should acquire * this memory at the time of a task_create call. */ routine vm_inherit( target_task : vm_task_t; address : vm_address_t; size : vm_size_t; new_inheritance : vm_inherit_t); /* * Returns the contents of the specified range of the * virtual address space of the target task. [The * range must be aligned on a virtual page boundary, * and must be a multiple of pages in extent. The * protection on the specified range must permit reading.] */ routine vm_read( target_task : vm_task_t; address : vm_address_t; size : vm_size_t; out data : pointer_t); /* * Writes the contents of the specified range of the * virtual address space of the target task. [The * range must be aligned on a virtual page boundary, * and must be a multiple of pages in extent. The * protection on the specified range must permit writing.] */ routine vm_write( target_task : vm_task_t; address : vm_address_t; data : pointer_t); /* * Copy the contents of the source range of the virtual * address space of the target task to the destination * range in that same address space. [Both of the * ranges must be aligned on a virtual page boundary, * and must be multiples of pages in extent. The * protection on the source range must permit reading, * and the protection on the destination range must * permit writing.] */ routine vm_copy( target_task : vm_task_t; source_address : vm_address_t; size : vm_size_t; dest_address : vm_address_t); /* * Returns information about the contents of the virtual * address space of the target task at the specified * address. The returned protection, inheritance, sharing * and memory object values apply to the entire range described * by the address range returned; the memory object offset * corresponds to the beginning of the address range. * [If the specified address is not allocated, the next * highest address range is described. If no addresses beyond * the one specified are allocated, the call returns KERN_NO_SPACE.] */ routine vm_region( target_task : vm_task_t; inout address : vm_address_t; out size : vm_size_t; out protection : vm_prot_t; out max_protection : vm_prot_t; out inheritance : vm_inherit_t; out is_shared : boolean_t; #ifdef NEW_MACH_IPC /* avoid out-translation of the argument */ out object_name : memory_object_name_t = MACH_MSG_TYPE_MOVE_SEND ctype: mach_port_t; #else /* NEW_MACH_IPC */ out object_name : memory_object_name_t; #endif /* NEW_MACH_IPC */ out offset : vm_offset_t); /* * Return virtual memory statistics for the host * on which the target task resides. [Note that the * statistics are not specific to the target task.] */ routine vm_statistics( target_task : vm_task_t; out vm_stats : vm_statistics_data_t); routine task_by_unix_pid( target_task : task_t; process_id : int; out result_task : task_t); skip; /* old vm_pageable */ skip; /* mach_ports_register */ skip; /* mach_ports_lookup */ routine unix_pid( target_task : task_t; out process_id : int); /* * Redirect network IP messages to the specified Mach port. */ routine netipc_listen( request_port : port_t; src_addr : int; dst_addr : int; src_port : int; dst_port : int; protocol : int; ipc_port : port_t); /* * Stop IP message redirection as set up by netipc_listen. */ routine netipc_ignore( request_port : port_t; ipc_port : port_t); #ifdef NEW_MACH_IPC_and_XP /* * Provide the data contents of a range of the given memory * object, with the access restriction specified. [Only * whole virtual pages of data can be accepted; partial pages * will be discarded. Data should be provided on request, but * may be provided in advance as desired. When data already * held by this kernel is provided again, the new data is ignored. * The access restriction is the subset of {read, write, execute} * which are prohibited. The kernel may not provide any data (or * protection) consistency among pages with different virtual page * alignments within the same object.] */ simpleroutine memory_object_data_provided( memory_control : memory_object_control_t; offset : vm_offset_t; data : pointer_t; lock_value : vm_prot_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_data_provided */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* * Indicate that a range of the given temporary memory object does * not exist, and that the backing memory object should be used * instead (or zero-fill memory be used, if no backing object exists). * [This call is intended for use only by the default memory manager. * It should not be used to indicate a real error -- * memory_object_data_error should be used for that purpose.] */ simpleroutine memory_object_data_unavailable( memory_control : memory_object_control_t; offset : vm_offset_t; size : vm_size_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_data_unavailable */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* * Retrieves the attributes currently associated with * a memory object. */ routine memory_object_get_attributes( memory_control : memory_object_control_t; out object_ready : boolean_t; out may_cache : boolean_t; out copy_strategy : memory_object_copy_strategy_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_get_attributes */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* * Sets the default memory manager, the port to which * newly-created temporary memory objects are delivered. * [See (memory_object_default)memory_object_create.] * The old memory manager port is returned. */ routine vm_set_default_memory_manager( host_priv : host_priv_t; inout default_manager : mach_port_make_send_t); #else /* NEW_MACH_IPC */ skip; /* vm_set_default_memory_manager */ #endif /* NEW_MACH_IPC */ skip; /* old pager_flush_request */ #ifdef NEW_MACH_IPC_and_XP /* * Control use of the data associated with the given * memory object. For each page in the given range, * perform the following operations, in order: * 1) restrict access to the page (disallow * forms specified by "prot"); * 2) write back modifications (if "should_return" * is RETURN_DIRTY and the page is dirty, or * "should_return" is RETURN_ALL and the page * is either dirty or precious); and, * 3) flush the cached copy (if "should_flush" * is asserted). * The set of pages is defined by a starting offset * ("offset") and size ("size"). Only pages with the * same page alignment as the starting offset are * considered. * * A single acknowledgement is sent (to the "reply_to" * port) when these actions are complete. * * There are two versions of this routine because IPC distinguishes * between booleans and integers (a 2-valued integer is NOT a * boolean). The new routine is backwards compatible at the C * language interface. */ skip; /* xxx_memory_object_lock_request */ simpleroutine memory_object_lock_request( memory_control : memory_object_control_t; offset : vm_offset_t; size : vm_size_t; should_return : memory_object_return_t; should_flush : boolean_t; lock_value : vm_prot_t; reply_to : mach_port_t = MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic); #else /* NEW_MACH_IPC */ skip; /* xxx_memory_object_lock_request */ skip; /* memory_object_lock_request */ #endif /* NEW_MACH_IPC */ skip; /* xxx_task_get_emulation_vector */ skip; /* xxx_task_set_emulation_vector */ /* * Returns information about the host on which the * target object resides. [This object may be * a task, thread, or memory_object_control port.] */ routine xxx_host_info( #ifdef NEW_MACH_IPC target_task : mach_port_t; #else /* NEW_MACH_IPC */ target_task : port_t; #endif /* NEW_MACH_IPC */ out info : machine_info_data_t); /* * Returns information about a particular processor on * the host on which the target task resides. */ routine xxx_slot_info( target_task : task_t; slot : int; out info : machine_slot_data_t); /* * Performs control operations (currently only * turning off or on) on a particular processor on * the host on which the target task resides. */ routine xxx_cpu_control( target_task : task_t; cpu : int; running : boolean_t); skip; /* old thread_statistics */ skip; /* old task_statistics */ skip; /* old netport_init */ skip; /* old netport_enter */ skip; /* old netport_remove */ skip; /* old thread_set_priority */ /* * Increment the suspend count for the target task. * No threads within a task may run when the suspend * count for that task is non-zero. */ routine task_suspend( target_task : task_t); /* * Decrement the suspend count for the target task, * if the count is currently non-zero. If the resulting * suspend count is zero, then threads within the task * that also have non-zero suspend counts may execute. */ routine task_resume( target_task : task_t); /* * Returns the current value of the selected special port * associated with the target task. */ routine task_get_special_port( task : task_t; which_port : int; #ifdef NEW_MACH_IPC out special_port : mach_port_t); #else /* NEW_MACH_IPC */ out special_port : port_t); #endif /* NEW_MACH_IPC */ /* * Set one of the special ports associated with the * target task. */ routine task_set_special_port( task : task_t; which_port : int; #ifdef NEW_MACH_IPC special_port : mach_port_t); #else /* NEW_MACH_IPC */ special_port : port_t); #endif /* NEW_MACH_IPC */ /* * Returns information about the target task. */ routine task_info( target_task : task_t; flavor : int; out task_info_out : task_info_t, IsLong); /* * Create a new thread within the target task, returning * the port representing that new thread. The * initial execution state of the thread is undefined. */ routine thread_create( parent_task : task_t; out child_thread : thread_t); /* * Increment the suspend count for the target thread. * Once this call has completed, the thread will not * execute any further user or meta- instructions. * Once suspended, a thread may not execute again until * its suspend count is zero, and the suspend count * for its task is also zero. */ routine thread_suspend( target_thread : thread_t); /* * Decrement the suspend count for the target thread, * if that count is not already zero. */ routine thread_resume( target_thread : thread_t); /* * Cause any user or meta- instructions currently being * executed by the target thread to be aborted. [Meta- * instructions consist of the basic traps for IPC * (e.g., msg_send, msg_receive) and self-identification * (e.g., task_self, thread_self, thread_reply). Calls * described by MiG interfaces are not meta-instructions * themselves.] */ routine thread_abort( target_thread : thread_t); /* * Return the selected state information for the target * thread. If the thread is currently executing, the results * may be stale. [Flavor THREAD_STATE_FLAVOR_LIST provides a * list of valid flavors for the target thread.] */ routine thread_get_state( target_thread : thread_t; flavor : int; out old_state : thread_state_t, IsLong); /* * Set the selected state information for the target thread. * If the thread is currently executing, the state change * may be ill-defined. */ routine thread_set_state( target_thread : thread_t; flavor : int; new_state : thread_state_t, IsLong); /* * Returns the current value of the selected special port * associated with the target thread. */ routine thread_get_special_port( thread : thread_t; which_port : int; #ifdef NEW_MACH_IPC out special_port : mach_port_t); #else /* NEW_MACH_IPC */ out special_port : port_t); #endif /* NEW_MACH_IPC */ /* * Set one of the special ports associated with the * target thread. */ routine thread_set_special_port( thread : thread_t; which_port : int; #ifdef NEW_MACH_IPC special_port : mach_port_t); #else /* NEW_MACH_IPC */ special_port : port_t); #endif /* NEW_MACH_IPC */ /* * Returns information about the target thread. */ routine thread_info( target_thread : thread_t; flavor : int; out thread_info_out : thread_info_t, IsLong); skip; /* task_set_emulation */ skip; /* task_ras_control */ skip; /* old host_ipc_statistics */ /* * Returns the set of port and port set names * to which the target task has access, along with * the type (set or port) for each name. */ routine port_names( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ out port_names_p : port_name_array_t; out port_types : port_type_array_t); /* * Returns the type (set or port) for the port name * within the target task. */ routine port_type( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ port_name : port_name_t; out port_type_p : port_type_t); /* * Changes the name by which a port (or port set) is known to * the target task. */ routine port_rename( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ old_name : port_name_t; new_name : port_name_t); /* * Allocate a new port (with all rights) in the target task. * The port name in that task is returned. */ routine port_allocate( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ out port_name : port_name_t); /* * Deallocate the port with the given name from the target task. */ routine port_deallocate( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ port_name : port_name_t); /* * Set the number of messages that may be queued to * the port in the target task with the given name * before further message queueing operations block. * The target task must hold receive rights for the * port named. */ routine port_set_backlog( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ port_name : port_name_t; backlog : int); /* * Return information about the port with the given * name in the target task. Only the ownership and * receive_rights results are meaningful unless the * target task holds receive rights for the port. */ routine port_status( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ port_name : port_name_t; out enabled : port_set_name_t; out num_msgs : int; out backlog : int; out ownership : boolean_t; out receive_rights : boolean_t); /* * Allocate a new port set in the target task, returning * the name of that new port set. [The new set is * initially empty.] */ routine port_set_allocate( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ out set_name : port_set_name_t); /* * Deallocate the named port set from the target task. * Ports that are currently members of the named port * set are first removed from the set. */ routine port_set_deallocate( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ set_name : port_set_name_t); /* * Add the named port to the port set named within * the target task. [If the port currently is a member * of another port set, it is removed from that set.] */ routine port_set_add( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ set_name : port_set_name_t; port_name : port_name_t); /* * Remove the named port from the port set named within * the target task. */ routine port_set_remove( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ port_name : port_name_t); /* * Returns the current set of ports that are members * of the named port set in the target task. */ routine port_set_status( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ set_name : port_set_name_t; out members : port_name_array_t); /* * Insert send rights for the specified port into * the target task with the specified port name. * [If the name is in use, or the target task already * has another name for the specified port, then * the operation will fail.] */ routine port_insert_send( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ my_port : port_t; his_name : port_name_t); /* * Returns send rights for the named port in the * target task, removing that port name and port * send rights from the target task. [If the * target task holds receive rights for this port, * the operation will fail.] */ routine port_extract_send( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ his_name : port_name_t; out his_port : port_t); /* * Insert receive rights for the specified port into * the target task with the specified port name. * [If the name is in use, or the target task already * has another name for the specified port, then * the operation will fail. */ routine port_insert_receive( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ my_port : port_all_t; his_name : port_name_t); /* * Returns receive rights for the named port in the * target task, removing that port name and all port * rights from the target task. */ routine port_extract_receive( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ his_name : port_name_t; out his_port : port_all_t); #ifdef NEW_MACH_IPC_and_XP /* * Map a user-defined memory object into the virtual address * space of the target task. If desired (anywhere is TRUE), * the kernel will find a suitable address range of the * specified size; else, the specific address will be allocated. * * The beginning address of the range will be aligned on a virtual * page boundary, be at or beyond the address specified, and * meet the mask requirements (bits turned on in the mask must not * be turned on in the result); the size of the range, in bytes, * will be rounded up to an integral number of virtual pages. * * The memory in the resulting range will be associated with the * specified memory object, with the beginning of the memory range * referring to the specified offset into the memory object. * * The mapping will take the current and maximum protections and * the inheritance attributes specified; see the vm_protect and * vm_inherit calls for a description of these attributes. * * If desired (copy is TRUE), the memory range will be filled * with a copy of the data from the memory object; this copy will * be private to this mapping in this target task. Otherwise, * the memory in this mapping will be shared with other mappings * of the same memory object at the same offset (in this task or * in other tasks). [The Mach kernel only enforces shared memory * consistency among mappings on one host with similar page alignments. * The user-defined memory manager for this object is responsible * for further consistency.] */ routine vm_map( target_task : vm_task_t; inout address : vm_address_t; size : vm_size_t; mask : vm_address_t; anywhere : boolean_t; memory_object : memory_object_t; offset : vm_offset_t; copy : boolean_t; cur_protection : vm_prot_t; max_protection : vm_prot_t; inheritance : vm_inherit_t); #else /* NEW_MACH_IPC */ skip; /* vm_map */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* * Indicate that a range of the specified memory object cannot * be provided at this time. [Threads waiting for memory pages * specified by this call will experience a memory exception. * Only threads waiting at the time of the call are affected.] */ simpleroutine memory_object_data_error( memory_control : memory_object_control_t; offset : vm_offset_t; size : vm_size_t; error_value : kern_return_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_data_error */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* * Make decisions regarding the use of the specified * memory object. */ simpleroutine memory_object_set_attributes( memory_control : memory_object_control_t; object_ready : boolean_t; may_cache : boolean_t; copy_strategy : memory_object_copy_strategy_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_set_attributes */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* */ simpleroutine memory_object_destroy( memory_control : memory_object_control_t; reason : kern_return_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_destroy */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* * Provide the data contents of a range of the given memory * object, with the access restriction specified, optional * precious attribute, and reply message. [Only * whole virtual pages of data can be accepted; partial pages * will be discarded. Data should be provided on request, but * may be provided in advance as desired. When data already * held by this kernel is provided again, the new data is ignored. * The access restriction is the subset of {read, write, execute} * which are prohibited. The kernel may not provide any data (or * protection) consistency among pages with different virtual page * alignments within the same object. The precious value controls * how the kernel treats the data. If it is FALSE, the kernel treats * its copy as a temporary and may throw it away if it hasn't been * changed. If the precious value is TRUE, the kernel treats its * copy as a data repository and promises to return it to the manager; * the manager may tell the kernel to throw it away instead by flushing * and not cleaning the data -- see memory_object_lock_request. The * reply_to port is for a compeletion message; it will be * memory_object_supply_completed.] */ simpleroutine memory_object_data_supply( memory_control : memory_object_control_t; offset : vm_offset_t; data : pointer_t, Dealloc[]; lock_value : vm_prot_t; precious : boolean_t; reply_to : mach_port_t = MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic); #else /* NEW_MACH_IPC */ skip; /* memory_object_data_supply */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* */ simpleroutine memory_object_ready( memory_control : memory_object_control_t; may_cache : boolean_t; copy_strategy : memory_object_copy_strategy_t); #else /* NEW_MACH_IPC */ skip; /* memory_object_ready */ #endif /* NEW_MACH_IPC */ #ifdef NEW_MACH_IPC_and_XP /* */ simpleroutine memory_object_change_attributes( memory_control : memory_object_control_t; may_cache : boolean_t; copy_strategy : memory_object_copy_strategy_t; reply_to : mach_port_t = MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic); #else /* NEW_MACH_IPC */ skip; /* memory_object_change_attributes */ #endif /* NEW_MACH_IPC */ skip; /* old host_callout_statistics_reset */ skip; /* old port_set_select */ /* * Sets a backup port for the named port. The task * must have receive rights for the named port. * Returns the previous backup port, if any. */ routine port_set_backup( #ifdef NEW_MACH_IPC task : ipc_space_t; #else /* NEW_MACH_IPC */ task : task_t; #endif /* NEW_MACH_IPC */ port_name : port_name_t; #ifdef NEW_IPC_IPC backup : port_t = MACH_MSG_TYPE_MAKE_SEND ctype: mach_port_t; #else /* NEW_MACH_IPC */ backup : port_t; #endif /* NEW_MACH_IPC */ out previous : port_t); /* * Set/Get special properties of memory associated * to some virtual address range, such as cachability, * migrability, replicability. Machine-dependent. */ routine vm_machine_attribute( target_task : vm_task_t; address : vm_address_t; size : vm_size_t; attribute : vm_machine_attribute_t; inout value : vm_machine_attribute_val_t); skip; /* old host_fpa_counters_reset */ /* * There is no more room in this interface for additional calls. */ /* HMM .... */ /* * Synchronize the contents of an address space with backing store. * Dirty pages in the address range are written to their appropriate * backing store. All pageouts are attempted. If any pageout causes * an error, vm_synchronize returns KERN_FAILURE. If a page would be * written to the default pager (swapfile), that page is skipped and * KERN_FAILURE is returned. This call is synchronous. */ routine vm_synchronize( target_task : vm_task_t; address : vm_address_t; size : vm_size_t); routine vm_set_policy( target_task : vm_task_t; address : vm_address_t; size : vm_size_t; policy : int); routine vm_deactivate( target_task : vm_task_t; address : vm_address_t; size : vm_size_t; when : int);