home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Headers / mach / mach.defs < prev    next >
Text File  |  1995-02-28  |  33KB  |  1,104 lines

  1. /* 
  2.  * Mach Operating System
  3.  * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
  4.  * All Rights Reserved.
  5.  * 
  6.  * Permission to use, copy, modify and distribute this software and its
  7.  * documentation is hereby granted, provided that both the copyright
  8.  * notice and this permission notice appear in all copies of the
  9.  * software, derivative works or modified versions, and any portions
  10.  * thereof, and that both notices appear in supporting documentation.
  11.  * 
  12.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  13.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  14.  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  15.  * 
  16.  * Carnegie Mellon requests users of this software to return to
  17.  * 
  18.  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  19.  *  School of Computer Science
  20.  *  Carnegie Mellon University
  21.  *  Pittsburgh PA 15213-3890
  22.  * 
  23.  * any improvements or extensions that they make and grant Carnegie Mellon
  24.  * the rights to redistribute these changes.
  25.  */
  26. /*
  27.  * HISTORY
  28.  * $Log:    mach.defs,v $
  29.  * Revision 2.15  93/01/21  12:23:14  danner
  30.  *     New interface for task_ras_control.
  31.  *     [93/01/19  16:35:06  bershad]
  32.  * 
  33.  * Revision 2.14  92/07/20  13:33:09  cmaeda
  34.  *     Added definition for task_set_ras_pc.
  35.  *     Uses message number recycled from old task_get_io_port.
  36.  *     [92/05/11  14:37:53  cmaeda]
  37.  * 
  38.  * Revision 2.13  92/01/15  13:45:00  rpd
  39.  *     Changed MACH_IPC_COMPAT conditionals to default to not present.
  40.  * 
  41.  * Revision 2.12  92/01/14  16:45:18  rpd
  42.  *     Changed mach_port_array_t usages to remain compatible,
  43.  *     because the definition of the type changed incompatibly.
  44.  *     [92/01/13            rpd]
  45.  *     Updated vm_region for new memory_object_name_t definition.
  46.  *     [91/12/31            rpd]
  47.  * 
  48.  * Revision 2.11  92/01/03  20:20:53  dbg
  49.  *     Changed (new) task_get_emulation_vector,
  50.  *     task_set_emulation_vector to pass data out-of-line.  Old
  51.  *     routines still pass data in-line, for compatibility.
  52.  *     [92/01/03            dbg]
  53.  * 
  54.  *     Add 'CountInOut' tag to routines returning variable-length
  55.  *     inline arrays.  Remove 'IsLong' tag from routines passing or
  56.  *     returning variable-length arrays.  Old routines left under
  57.  *     'xxx_' names.  REMOVE THESE SOON!
  58.  * 
  59.  *     I used the message IDs from the Mach 1.5 thread calls (before
  60.  *     the real thread support went in) - they haven't been used since
  61.  *     1988.
  62.  *     [91/11/26            dbg]
  63.  * 
  64.  * Revision 2.10  91/08/28  11:15:04  jsb
  65.  *     Precious page support:  Add new version of memory_object_lock_request.
  66.  *     Add memory_object_{ready,change_attributes}.
  67.  *     [91/07/03  14:03:34  dlb]
  68.  *     Added KERNEL_USER definitions (for NORMA support).
  69.  *     [91/08/15  09:58:13  jsb]
  70.  * 
  71.  * Revision 2.9  91/07/31  17:53:17  dbg
  72.  *     Added user-settable 'dealloc' flag to data argument of
  73.  *     memory_object_data_supply.  Needs new MiG.
  74.  *     USERS OF THIS FUNCTION MUST RE-LINK!!
  75.  *     [91/07/29            dbg]
  76.  * 
  77.  *     MACH_IPC_COMPAT: set C type for backup argument to
  78.  *     port_set_backup to be 'mach_port_t'.  If mach_interface.h is
  79.  *     included with MACH_IPC_COMPAT == 0, the type 'port_t' is not
  80.  *     defined.
  81.  * 
  82.  *     Removed vm_pageable.
  83.  *     [91/06/24            dbg]
  84.  * 
  85.  * Revision 2.8  91/07/01  08:25:09  jsb
  86.  *     From David Black at OSF: added memory_object_data_supply.
  87.  *     [91/06/29  14:59:47  jsb]
  88.  * 
  89.  * Revision 2.7  91/06/06  17:07:51  jsb
  90.  *     Added task_get_emulation_vector, task_set_emulation_vector.
  91.  *     [91/05/24  18:26:01  jsb]
  92.  * 
  93.  * Revision 2.6  91/05/14  16:54:18  mrt
  94.  *     Correcting copyright
  95.  * 
  96.  * Revision 2.5  91/02/05  17:33:12  mrt
  97.  *     Changed to new Mach copyright
  98.  *     [91/02/01  17:17:41  mrt]
  99.  * 
  100.  * Revision 2.4  90/06/02  14:58:09  rpd
  101.  *     Changed reply_to argument of memory_object_lock_request
  102.  *     to default to a send-once right but still allow send rights.
  103.  *     [90/05/31            rpd]
  104.  * 
  105.  *     Changes for the emulator: remove vm_allocate, redefine vm_map.
  106.  * 
  107.  *     Obsoleted vm_allocate_with_pager.
  108.  *     [90/04/08            rpd]
  109.  *     Converted to new IPC.  Purged MACH_NP, MACH_NET.
  110.  *     Moved vm_set_default_memory_manager, memory_object_get_attributes.
  111.  *     [90/03/26  22:31:41  rpd]
  112.  * 
  113.  *
  114.  * Condensed history:
  115.  *    Added vm_machine_attribute (af).
  116.  *    Added memory_object_get_attributes (mwyoung).
  117.  *    Added vm_set_default_memory_manager (mwyoung).
  118.  *    Added thread_set_priority (dbg).
  119.  *    Added vm_pageable (dbg).
  120.  *     Added port_set_backup (rpd).
  121.  *    Added memory_object_destroy (mwyoung).
  122.  *    Converted to memory_object_* names (mwyoung).
  123.  *    New port and port set calls (rpd).
  124.  *    Added documentation (mwyoung).
  125.  *    Added vm_map, pager_attributes, pager_data_error (mwyoung).
  126.  *    Added task_set_emulation and task_get_io_port (dorr).
  127.  *    Added new thread and task interfaces (dbg).
  128.  *    Reset history (avie).
  129.  */
  130.  
  131. /*
  132.  *    Matchmaker definitions file for Mach kernel interface.
  133.  */
  134.  
  135. subsystem
  136. #if    KERNEL_USER && defined(NEW_MACH_IPC)
  137.       KernelUser
  138. #endif    KERNEL_USER
  139. #if    KERNEL_SERVER && defined(NEW_MACH_IPC)
  140.       KernelServer
  141. #endif    KERNEL_SERVER
  142.                mach 2000;
  143.  
  144. #include <mach/std_types.defs>
  145. #include <mach/mach_types.defs>
  146.  
  147. skip;    /* old port_allocate */
  148. skip;    /* old port_deallocate */
  149. skip;    /* old port_enable */
  150. skip;    /* old port_disable */
  151. skip;    /* old port_select */
  152. skip;    /* old port_set_backlog */
  153. skip;    /* old port_status */
  154.  
  155. /*
  156.  *    Create a new task with an empty set of IPC rights,
  157.  *    and having an address space constructed from the
  158.  *    target task (or empty, if inherit_memory is FALSE).
  159.  */
  160. routine task_create(
  161.         target_task    : task_t;
  162.         inherit_memory    : boolean_t;
  163.     out    child_task    : task_t);
  164.  
  165. /*
  166.  *    Destroy the target task, causing all of its threads
  167.  *    to be destroyed, all of its IPC rights to be deallocated,
  168.  *    and all of its address space to be deallocated.
  169.  */
  170. routine task_terminate(
  171.         target_task    : task_t);
  172.  
  173. skip;    /* task_get_emulation_vector */
  174. skip;    /* task_set_emulation_vector */
  175.  
  176. /*
  177.  *    Returns the set of threads belonging to the target task.
  178.  */
  179. routine task_threads(
  180.         target_task    : task_t;
  181.     out    thread_list    : thread_array_t);
  182.  
  183. skip;    /* task_info:        MACH 3.0 */
  184. skip;    /* old task_status */
  185. skip;    /* old task_set_notify */
  186. skip;    /* old thread_create */
  187.  
  188. /*
  189.  *    Destroy the target thread.
  190.  */
  191. routine thread_terminate(
  192.         target_thread    : thread_t);
  193.  
  194. skip;    /* thread_get_state:    MACH 3.0 */
  195. skip;    /* thread_set_state:    MACH 3.0 */
  196. skip;    /* thread_info:        MACH 3.0 */
  197. skip;    /* old thread_mutate */
  198.  
  199. /*
  200.  *    Allocate zero-filled memory in the address space
  201.  *    of the target task, either at the specified address,
  202.  *    or wherever space can be found (if anywhere is TRUE),
  203.  *    of the specified size.  The address at which the
  204.  *    allocation actually took place is returned.
  205.  */
  206. routine vm_allocate(
  207.         target_task    : vm_task_t;
  208.     inout    address        : vm_address_t;
  209.         size        : vm_size_t;
  210.         anywhere    : boolean_t);
  211.  
  212. skip;    /* old vm_allocate_with_pager */
  213.  
  214. /*
  215.  *    Deallocate the specified range from the virtual
  216.  *    address space of the target task.
  217.  */
  218. routine vm_deallocate(
  219.         target_task    : vm_task_t;
  220.         address        : vm_address_t;
  221.         size        : vm_size_t);
  222.  
  223. /*
  224.  *    Set the current or maximum protection attribute
  225.  *    for the specified range of the virtual address
  226.  *    space of the target task.  The current protection
  227.  *    limits the memory access rights of threads within
  228.  *    the task; the maximum protection limits the accesses
  229.  *    that may be given in the current protection.
  230.  *    Protections are specified as a set of {read, write, execute}
  231.  *    *permissions*.
  232.  */
  233. routine vm_protect(
  234.         target_task    : vm_task_t;
  235.         address        : vm_address_t;
  236.         size        : vm_size_t;
  237.         set_maximum    : boolean_t;
  238.         new_protection    : vm_prot_t);
  239.  
  240. /*
  241.  *    Set the inheritance attribute for the specified range
  242.  *    of the virtual address space of the target task.
  243.  *    The inheritance value is one of {none, copy, share}, and
  244.  *    specifies how the child address space should acquire
  245.  *    this memory at the time of a task_create call.
  246.  */
  247. routine vm_inherit(
  248.         target_task    : vm_task_t;
  249.         address        : vm_address_t;
  250.         size        : vm_size_t;
  251.         new_inheritance    : vm_inherit_t);
  252.  
  253. /*
  254.  *    Returns the contents of the specified range of the
  255.  *    virtual address space of the target task.  [The
  256.  *    range must be aligned on a virtual page boundary,
  257.  *    and must be a multiple of pages in extent.  The
  258.  *    protection on the specified range must permit reading.]
  259.  */
  260. routine vm_read(
  261.         target_task    : vm_task_t;
  262.         address        : vm_address_t;
  263.         size        : vm_size_t;
  264.     out    data        : pointer_t);
  265.  
  266. /*
  267.  *    Writes the contents of the specified range of the
  268.  *    virtual address space of the target task.  [The
  269.  *    range must be aligned on a virtual page boundary,
  270.  *    and must be a multiple of pages in extent.  The
  271.  *    protection on the specified range must permit writing.]
  272.  */
  273. routine vm_write(
  274.         target_task    : vm_task_t;
  275.         address        : vm_address_t;
  276.         data        : pointer_t);
  277.  
  278. /*
  279.  *    Copy the contents of the source range of the virtual
  280.  *    address space of the target task to the destination
  281.  *    range in that same address space.  [Both of the
  282.  *    ranges must be aligned on a virtual page boundary,
  283.  *    and must be multiples of pages in extent.  The
  284.  *    protection on the source range must permit reading,
  285.  *    and the protection on the destination range must
  286.  *    permit writing.]
  287.  */
  288. routine vm_copy(
  289.         target_task    : vm_task_t;
  290.         source_address    : vm_address_t;
  291.         size        : vm_size_t;
  292.         dest_address    : vm_address_t);
  293.  
  294. /*
  295.  *    Returns information about the contents of the virtual
  296.  *    address space of the target task at the specified
  297.  *    address.  The returned protection, inheritance, sharing
  298.  *    and memory object values apply to the entire range described
  299.  *    by the address range returned; the memory object offset
  300.  *    corresponds to the beginning of the address range.
  301.  *    [If the specified address is not allocated, the next
  302.  *    highest address range is described.  If no addresses beyond
  303.  *    the one specified are allocated, the call returns KERN_NO_SPACE.]
  304.  */
  305. routine vm_region(
  306.         target_task    : vm_task_t;
  307.     inout    address        : vm_address_t;
  308.     out    size        : vm_size_t;
  309.     out    protection    : vm_prot_t;
  310.     out    max_protection    : vm_prot_t;
  311.     out    inheritance    : vm_inherit_t;
  312.     out    is_shared    : boolean_t;
  313. #ifdef    NEW_MACH_IPC
  314.     /* avoid out-translation of the argument */
  315.     out    object_name    : memory_object_name_t =
  316.                     MACH_MSG_TYPE_MOVE_SEND
  317.                     ctype: mach_port_t;
  318. #else    /* NEW_MACH_IPC */
  319.     out    object_name    : memory_object_name_t;
  320. #endif    /* NEW_MACH_IPC */
  321.     out    offset        : vm_offset_t);
  322.  
  323. /*
  324.  *    Return virtual memory statistics for the host
  325.  *    on which the target task resides.  [Note that the
  326.  *    statistics are not specific to the target task.]
  327.  */
  328. routine vm_statistics(
  329.         target_task    : vm_task_t;
  330.     out    vm_stats    : vm_statistics_data_t);
  331.  
  332. routine task_by_unix_pid(
  333.         target_task    : task_t;
  334.         process_id    : int;
  335.     out    result_task    : task_t);
  336.  
  337. skip;    /* old vm_pageable */
  338. skip;    /* mach_ports_register */
  339. skip;    /* mach_ports_lookup */
  340.  
  341. routine unix_pid(
  342.         target_task    : task_t;
  343.     out    process_id    : int);
  344.  
  345. /*
  346.  *    Redirect network IP messages to the specified Mach port.
  347.  */
  348. routine netipc_listen(
  349.         request_port    : port_t;
  350.         src_addr    : int;
  351.         dst_addr    : int;
  352.         src_port    : int;
  353.         dst_port    : int;
  354.         protocol    : int;
  355.         ipc_port    : port_t);
  356.  
  357. /*
  358.  *    Stop IP message redirection as set up by netipc_listen.
  359.  */
  360. routine netipc_ignore(
  361.         request_port    : port_t;
  362.         ipc_port    : port_t);
  363.  
  364. #ifdef    NEW_MACH_IPC_and_XP
  365. /*
  366.  *    Provide the data contents of a range of the given memory
  367.  *    object, with the access restriction specified.  [Only
  368.  *    whole virtual pages of data can be accepted; partial pages
  369.  *    will be discarded.  Data should be provided on request, but
  370.  *    may be provided in advance as desired.  When data already
  371.  *    held by this kernel is provided again, the new data is ignored.
  372.  *    The access restriction is the subset of {read, write, execute}
  373.  *    which are prohibited.  The kernel may not provide any data (or
  374.  *    protection) consistency among pages with different virtual page
  375.  *    alignments within the same object.]
  376.  */
  377. simpleroutine memory_object_data_provided(
  378.         memory_control    : memory_object_control_t;
  379.         offset        : vm_offset_t;
  380.         data        : pointer_t;
  381.         lock_value    : vm_prot_t);
  382. #else    /* NEW_MACH_IPC */
  383. skip;    /* memory_object_data_provided */
  384. #endif    /* NEW_MACH_IPC */
  385.  
  386. #ifdef    NEW_MACH_IPC_and_XP
  387. /*
  388.  *    Indicate that a range of the given temporary memory object does
  389.  *    not exist, and that the backing memory object should be used
  390.  *    instead (or zero-fill memory be used, if no backing object exists).
  391.  *    [This call is intended for use only by the default memory manager.
  392.  *    It should not be used to indicate a real error --
  393.  *    memory_object_data_error should be used for that purpose.]
  394.  */
  395. simpleroutine memory_object_data_unavailable(
  396.         memory_control    : memory_object_control_t;
  397.         offset        : vm_offset_t;
  398.         size        : vm_size_t);
  399. #else    /* NEW_MACH_IPC */
  400. skip;    /* memory_object_data_unavailable */
  401. #endif    /* NEW_MACH_IPC */
  402.  
  403. #ifdef    NEW_MACH_IPC_and_XP
  404. /*
  405.  *    Retrieves the attributes currently associated with
  406.  *    a memory object.
  407.  */
  408. routine memory_object_get_attributes(
  409.         memory_control    : memory_object_control_t;
  410.     out    object_ready    : boolean_t;
  411.     out    may_cache    : boolean_t;
  412.     out    copy_strategy    : memory_object_copy_strategy_t);
  413. #else    /* NEW_MACH_IPC */
  414. skip;    /* memory_object_get_attributes */
  415. #endif    /* NEW_MACH_IPC */
  416.  
  417. #ifdef    NEW_MACH_IPC_and_XP
  418. /*
  419.  *    Sets the default memory manager, the port to which
  420.  *    newly-created temporary memory objects are delivered.
  421.  *    [See (memory_object_default)memory_object_create.]
  422.  *    The old memory manager port is returned.
  423.  */
  424. routine vm_set_default_memory_manager(
  425.         host_priv    : host_priv_t;
  426.     inout    default_manager    : mach_port_make_send_t);
  427. #else    /* NEW_MACH_IPC */
  428. skip;    /* vm_set_default_memory_manager */
  429. #endif    /* NEW_MACH_IPC */
  430.  
  431. skip;    /* old pager_flush_request */
  432.  
  433. #ifdef    NEW_MACH_IPC_and_XP
  434. /*
  435.  *    Control use of the data associated with the given
  436.  *    memory object.  For each page in the given range,
  437.  *    perform the following operations, in order:
  438.  *        1)  restrict access to the page (disallow
  439.  *            forms specified by "prot");
  440.  *        2)  write back modifications (if "should_return"
  441.  *            is RETURN_DIRTY and the page is dirty, or
  442.  *            "should_return" is RETURN_ALL and the page
  443.  *             is either dirty or precious); and,
  444.  *        3)  flush the cached copy (if "should_flush"
  445.  *            is asserted).
  446.  *    The set of pages is defined by a starting offset
  447.  *    ("offset") and size ("size").  Only pages with the
  448.  *    same page alignment as the starting offset are
  449.  *    considered.
  450.  *
  451.  *    A single acknowledgement is sent (to the "reply_to"
  452.  *    port) when these actions are complete.
  453.  *
  454.  *    There are two versions of this routine because IPC distinguishes
  455.  *    between booleans and integers (a 2-valued integer is NOT a
  456.  *    boolean).  The new routine is backwards compatible at the C
  457.  *    language interface.
  458.  */
  459. skip;    /* xxx_memory_object_lock_request */
  460.  
  461. simpleroutine memory_object_lock_request(
  462.         memory_control    : memory_object_control_t;
  463.         offset        : vm_offset_t;
  464.         size        : vm_size_t;
  465.         should_return    : memory_object_return_t;
  466.         should_flush    : boolean_t;
  467.         lock_value    : vm_prot_t;
  468.         reply_to    : mach_port_t =
  469.             MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
  470. #else    /* NEW_MACH_IPC */
  471. skip;    /* xxx_memory_object_lock_request */
  472. skip;    /* memory_object_lock_request */
  473. #endif    /* NEW_MACH_IPC */
  474.  
  475. skip;    /* xxx_task_get_emulation_vector */
  476. skip;    /* xxx_task_set_emulation_vector */
  477.  
  478. /*
  479.  *    Returns information about the host on which the
  480.  *    target object resides.  [This object may be
  481.  *    a task, thread, or memory_object_control port.]
  482.  */
  483. routine xxx_host_info(
  484. #ifdef    NEW_MACH_IPC
  485.         target_task    : mach_port_t;
  486. #else    /* NEW_MACH_IPC */
  487.         target_task    : port_t;
  488. #endif    /* NEW_MACH_IPC */
  489.     out    info        : machine_info_data_t);
  490.  
  491. /*
  492.  *    Returns information about a particular processor on
  493.  *    the host on which the target task resides.
  494.  */
  495. routine xxx_slot_info(
  496.         target_task    : task_t;
  497.         slot        : int;
  498.     out    info        : machine_slot_data_t);
  499.  
  500. /*
  501.  *    Performs control operations (currently only
  502.  *    turning off or on) on a particular processor on
  503.  *    the host on which the target task resides.
  504.  */
  505. routine xxx_cpu_control(
  506.         target_task    : task_t;
  507.         cpu        : int;
  508.         running        : boolean_t);
  509.  
  510. skip;    /* old thread_statistics */
  511. skip;    /* old task_statistics */
  512. skip;    /* old netport_init */
  513. skip;    /* old netport_enter */
  514. skip;    /* old netport_remove */
  515. skip;    /* old thread_set_priority */
  516.  
  517. /*
  518.  *    Increment the suspend count for the target task.
  519.  *    No threads within a task may run when the suspend
  520.  *    count for that task is non-zero.
  521.  */
  522. routine    task_suspend(
  523.         target_task    : task_t);
  524.  
  525. /*
  526.  *    Decrement the suspend count for the target task,
  527.  *    if the count is currently non-zero.  If the resulting
  528.  *    suspend    count is zero, then threads within the task
  529.  *    that also have non-zero suspend counts may execute.
  530.  */
  531. routine    task_resume(
  532.         target_task    : task_t);
  533.  
  534. /*
  535.  *    Returns the current value of the selected special port
  536.  *    associated with the target task.
  537.  */
  538. routine task_get_special_port(
  539.         task        : task_t;
  540.         which_port    : int;
  541. #ifdef    NEW_MACH_IPC
  542.     out    special_port    : mach_port_t);
  543. #else    /* NEW_MACH_IPC */
  544.     out    special_port    : port_t);
  545. #endif    /* NEW_MACH_IPC */
  546.  
  547. /*
  548.  *    Set one of the special ports associated with the
  549.  *    target task.
  550.  */
  551. routine task_set_special_port(
  552.         task        : task_t;
  553.         which_port    : int;
  554. #ifdef    NEW_MACH_IPC
  555.         special_port    : mach_port_t);
  556. #else    /* NEW_MACH_IPC */
  557.         special_port    : port_t);
  558. #endif    /* NEW_MACH_IPC */
  559.  
  560. /*
  561.  *    Returns information about the target task.
  562.  */
  563. routine    task_info(
  564.         target_task    : task_t;
  565.         flavor        : int;
  566.     out    task_info_out    : task_info_t, IsLong);
  567.  
  568.  
  569. /*
  570.  *    Create a new thread within the target task, returning
  571.  *    the port representing that new thread.  The
  572.  *    initial execution state of the thread is undefined.
  573.  */
  574. routine thread_create(
  575.         parent_task    : task_t;
  576.     out    child_thread    : thread_t);
  577.  
  578. /*
  579.  *    Increment the suspend count for the target thread.
  580.  *    Once this call has completed, the thread will not
  581.  *    execute any further user or meta- instructions.
  582.  *    Once suspended, a thread may not execute again until
  583.  *    its suspend count is zero, and the suspend count
  584.  *    for its task is also zero.
  585.  */
  586. routine    thread_suspend(
  587.         target_thread    : thread_t);
  588.  
  589. /*
  590.  *    Decrement the suspend count for the target thread,
  591.  *    if that count is not already zero.
  592.  */
  593. routine    thread_resume(
  594.         target_thread    : thread_t);
  595.  
  596. /*
  597.  *    Cause any user or meta- instructions currently being
  598.  *    executed by the target thread to be aborted.  [Meta-
  599.  *    instructions consist of the basic traps for IPC
  600.  *    (e.g., msg_send, msg_receive) and self-identification
  601.  *    (e.g., task_self, thread_self, thread_reply).  Calls
  602.  *    described by MiG interfaces are not meta-instructions
  603.  *    themselves.]
  604.  */
  605. routine thread_abort(
  606.         target_thread    : thread_t);
  607.  
  608. /*
  609.  *    Return the selected state information for the target
  610.  *    thread.  If the thread is currently executing, the results
  611.  *    may be stale.  [Flavor THREAD_STATE_FLAVOR_LIST provides a
  612.  *    list of valid flavors for the target thread.]
  613.  */
  614. routine thread_get_state(
  615.         target_thread    : thread_t;
  616.         flavor        : int;
  617.     out    old_state    : thread_state_t, IsLong);
  618.  
  619. /*
  620.  *    Set the selected state information for the target thread.
  621.  *    If the thread is currently executing, the state change
  622.  *    may be ill-defined.
  623.  */
  624. routine    thread_set_state(
  625.         target_thread    : thread_t;
  626.         flavor        : int;
  627.         new_state    : thread_state_t, IsLong);
  628.  
  629. /*
  630.  *    Returns the current value of the selected special port
  631.  *    associated with the target thread.
  632.  */
  633. routine thread_get_special_port(
  634.         thread        : thread_t;
  635.         which_port    : int;
  636. #ifdef    NEW_MACH_IPC
  637.     out    special_port    : mach_port_t);
  638. #else    /* NEW_MACH_IPC */
  639.     out    special_port    : port_t);
  640. #endif    /* NEW_MACH_IPC */
  641.  
  642. /*
  643.  *    Set one of the special ports associated with the
  644.  *    target thread.
  645.  */
  646. routine thread_set_special_port(
  647.         thread        : thread_t;
  648.         which_port    : int;
  649. #ifdef    NEW_MACH_IPC
  650.         special_port    : mach_port_t);
  651. #else    /* NEW_MACH_IPC */
  652.         special_port    : port_t);
  653. #endif    /* NEW_MACH_IPC */
  654.  
  655. /*
  656.  *    Returns information about the target thread.
  657.  */
  658. routine    thread_info(
  659.         target_thread    : thread_t;
  660.         flavor        : int;
  661.     out    thread_info_out    : thread_info_t, IsLong);
  662.  
  663. skip;    /* task_set_emulation */
  664. skip;    /* task_ras_control */
  665. skip;    /* old host_ipc_statistics */
  666.  
  667. /*
  668.  *    Returns the set of port and port set names
  669.  *    to which the target task has access, along with
  670.  *    the type (set or port) for each name.
  671.  */
  672. routine port_names(
  673. #ifdef    NEW_MACH_IPC
  674.         task        : ipc_space_t;
  675. #else    /* NEW_MACH_IPC */
  676.         task        : task_t;
  677. #endif    /* NEW_MACH_IPC */
  678.     out    port_names_p    : port_name_array_t;
  679.     out    port_types    : port_type_array_t);
  680.  
  681. /*
  682.  *    Returns the type (set or port) for the port name
  683.  *    within the target task.
  684.  */
  685. routine port_type(
  686. #ifdef    NEW_MACH_IPC
  687.         task        : ipc_space_t;
  688. #else    /* NEW_MACH_IPC */
  689.         task        : task_t;
  690. #endif    /* NEW_MACH_IPC */
  691.         port_name    : port_name_t;
  692.     out    port_type_p    : port_type_t);
  693.  
  694. /*
  695.  *    Changes the name by which a port (or port set) is known to
  696.  *    the target task.
  697.  */
  698. routine port_rename(
  699. #ifdef    NEW_MACH_IPC
  700.         task        : ipc_space_t;
  701. #else    /* NEW_MACH_IPC */
  702.         task        : task_t;
  703. #endif    /* NEW_MACH_IPC */
  704.         old_name    : port_name_t;
  705.         new_name    : port_name_t);
  706.  
  707. /*
  708.  *    Allocate a new port (with all rights) in the target task.
  709.  *    The port name in that task is returned.
  710.  */
  711. routine port_allocate(
  712. #ifdef    NEW_MACH_IPC
  713.         task        : ipc_space_t;
  714. #else    /* NEW_MACH_IPC */
  715.         task        : task_t;
  716. #endif    /* NEW_MACH_IPC */
  717.     out    port_name    : port_name_t);
  718.  
  719. /*
  720.  *    Deallocate the port with the given name from the target task.
  721.  */
  722. routine port_deallocate(
  723. #ifdef    NEW_MACH_IPC
  724.         task        : ipc_space_t;
  725. #else    /* NEW_MACH_IPC */
  726.         task        : task_t;
  727. #endif    /* NEW_MACH_IPC */
  728.         port_name    : port_name_t);
  729.  
  730. /*
  731.  *    Set the number of messages that may be queued to
  732.  *    the port in the target task with the given name
  733.  *    before further message queueing operations block.
  734.  *    The target task must hold receive rights for the
  735.  *    port named.
  736.  */
  737. routine port_set_backlog(
  738. #ifdef    NEW_MACH_IPC
  739.         task        : ipc_space_t;
  740. #else    /* NEW_MACH_IPC */
  741.         task        : task_t;
  742. #endif    /* NEW_MACH_IPC */
  743.         port_name    : port_name_t;
  744.         backlog        : int);
  745.  
  746. /*
  747.  *    Return information about the port with the given
  748.  *    name in the target task.  Only the ownership and
  749.  *    receive_rights results are meaningful unless the
  750.  *    target task holds receive rights for the port.
  751.  */
  752. routine port_status(
  753. #ifdef    NEW_MACH_IPC
  754.         task        : ipc_space_t;
  755. #else    /* NEW_MACH_IPC */
  756.         task        : task_t;
  757. #endif    /* NEW_MACH_IPC */
  758.         port_name    : port_name_t;
  759.     out    enabled        : port_set_name_t;
  760.     out    num_msgs    : int;
  761.     out    backlog        : int;
  762.     out    ownership    : boolean_t;
  763.     out    receive_rights    : boolean_t);
  764.  
  765. /*
  766.  *    Allocate a new port set in the target task, returning
  767.  *    the name of that new port set.  [The new set is
  768.  *    initially empty.]
  769.  */
  770. routine port_set_allocate(
  771. #ifdef    NEW_MACH_IPC
  772.         task        : ipc_space_t;
  773. #else    /* NEW_MACH_IPC */
  774.         task        : task_t;
  775. #endif    /* NEW_MACH_IPC */
  776.     out    set_name    : port_set_name_t);
  777.  
  778. /*
  779.  *    Deallocate the named port set from the target task.
  780.  *    Ports that are currently members of the named port
  781.  *    set are first removed from the set.
  782.  */
  783. routine port_set_deallocate(
  784. #ifdef    NEW_MACH_IPC
  785.         task        : ipc_space_t;
  786. #else    /* NEW_MACH_IPC */
  787.         task        : task_t;
  788. #endif    /* NEW_MACH_IPC */
  789.         set_name    : port_set_name_t);
  790.  
  791. /*
  792.  *    Add the named port to the port set named within
  793.  *    the target task.  [If the port currently is a member
  794.  *    of another port set, it is removed from that set.]
  795.  */
  796. routine port_set_add(
  797. #ifdef    NEW_MACH_IPC
  798.         task        : ipc_space_t;
  799. #else    /* NEW_MACH_IPC */
  800.         task        : task_t;
  801. #endif    /* NEW_MACH_IPC */
  802.         set_name    : port_set_name_t;
  803.         port_name    : port_name_t);
  804.  
  805. /*
  806.  *    Remove the named port from the port set named within
  807.  *    the target task.
  808.  */
  809. routine port_set_remove(
  810. #ifdef    NEW_MACH_IPC
  811.         task        : ipc_space_t;
  812. #else    /* NEW_MACH_IPC */
  813.         task        : task_t;
  814. #endif    /* NEW_MACH_IPC */
  815.         port_name    : port_name_t);
  816.  
  817. /*
  818.  *    Returns the current set of ports that are members
  819.  *    of the named port set in the target task.
  820.  */
  821. routine port_set_status(
  822. #ifdef    NEW_MACH_IPC
  823.         task        : ipc_space_t;
  824. #else    /* NEW_MACH_IPC */
  825.         task        : task_t;
  826. #endif    /* NEW_MACH_IPC */
  827.         set_name    : port_set_name_t;
  828.     out    members        : port_name_array_t);
  829.  
  830. /*
  831.  *    Insert send rights for the specified port into
  832.  *    the target task with the specified port name.
  833.  *    [If the name is in use, or the target task already
  834.  *    has another name for the specified port, then
  835.  *    the operation will fail.]
  836.  */
  837. routine port_insert_send(
  838. #ifdef    NEW_MACH_IPC
  839.         task        : ipc_space_t;
  840. #else    /* NEW_MACH_IPC */
  841.         task        : task_t;
  842. #endif    /* NEW_MACH_IPC */
  843.         my_port        : port_t;
  844.         his_name    : port_name_t);
  845.  
  846. /*
  847.  *    Returns send rights for the named port in the
  848.  *    target task, removing that port name and port
  849.  *    send rights from the target task.  [If the
  850.  *    target task holds receive rights for this port,
  851.  *    the operation will fail.]
  852.  */
  853. routine port_extract_send(
  854. #ifdef    NEW_MACH_IPC
  855.         task        : ipc_space_t;
  856. #else    /* NEW_MACH_IPC */
  857.         task        : task_t;
  858. #endif    /* NEW_MACH_IPC */
  859.         his_name    : port_name_t;
  860.     out    his_port    : port_t);
  861.  
  862. /*
  863.  *    Insert receive rights for the specified port into
  864.  *    the target task with the specified port name.
  865.  *    [If the name is in use, or the target task already
  866.  *    has another name for the specified port, then
  867.  *    the operation will fail.
  868.  */
  869. routine port_insert_receive(
  870. #ifdef    NEW_MACH_IPC
  871.         task        : ipc_space_t;
  872. #else    /* NEW_MACH_IPC */
  873.         task        : task_t;
  874. #endif    /* NEW_MACH_IPC */
  875.         my_port        : port_all_t;
  876.         his_name    : port_name_t);
  877.  
  878. /*
  879.  *    Returns receive rights for the named port in the
  880.  *    target task, removing that port name and all port
  881.  *    rights from the target task.
  882.  */
  883. routine port_extract_receive(
  884. #ifdef    NEW_MACH_IPC
  885.         task        : ipc_space_t;
  886. #else    /* NEW_MACH_IPC */
  887.         task        : task_t;
  888. #endif    /* NEW_MACH_IPC */
  889.         his_name    : port_name_t;
  890.     out    his_port    : port_all_t);
  891.  
  892. #ifdef    NEW_MACH_IPC_and_XP
  893. /*
  894.  *    Map a user-defined memory object into the virtual address
  895.  *    space of the target task.  If desired (anywhere is TRUE),
  896.  *    the kernel will find a suitable address range of the
  897.  *    specified size; else, the specific address will be allocated.
  898.  *
  899.  *    The beginning address of the range will be aligned on a virtual
  900.  *    page boundary, be at or beyond the address specified, and
  901.  *    meet the mask requirements (bits turned on in the mask must not
  902.  *    be turned on in the result); the size of the range, in bytes,
  903.  *    will be rounded    up to an integral number of virtual pages.
  904.  *
  905.  *    The memory in the resulting range will be associated with the
  906.  *    specified memory object, with the beginning of the memory range
  907.  *    referring to the specified offset into the memory object.
  908.  *
  909.  *    The mapping will take the current and maximum protections and
  910.  *    the inheritance attributes specified; see the vm_protect and
  911.  *    vm_inherit calls for a description of these attributes.
  912.  *
  913.  *    If desired (copy is TRUE), the memory range will be filled
  914.  *    with a copy of the data from the memory object; this copy will
  915.  *    be private to this mapping in this target task.  Otherwise,
  916.  *    the memory in this mapping will be shared with other mappings
  917.  *    of the same memory object at the same offset (in this task or
  918.  *    in other tasks).  [The Mach kernel only enforces shared memory
  919.  *    consistency among mappings on one host with similar page alignments.
  920.  *    The user-defined memory manager for this object is responsible
  921.  *    for further consistency.]
  922.  */
  923. routine vm_map(
  924.         target_task    : vm_task_t;
  925.     inout    address        : vm_address_t;
  926.         size        : vm_size_t;
  927.         mask        : vm_address_t;
  928.         anywhere    : boolean_t;
  929.         memory_object    : memory_object_t;
  930.         offset        : vm_offset_t;
  931.         copy        : boolean_t;
  932.         cur_protection    : vm_prot_t;
  933.         max_protection    : vm_prot_t;
  934.         inheritance    : vm_inherit_t);
  935. #else    /* NEW_MACH_IPC */
  936. skip;    /* vm_map */
  937. #endif    /* NEW_MACH_IPC */
  938.  
  939. #ifdef    NEW_MACH_IPC_and_XP
  940. /*
  941.  *    Indicate that a range of the specified memory object cannot
  942.  *    be provided at this time.  [Threads waiting for memory pages
  943.  *    specified by this call will experience a memory exception.
  944.  *    Only threads waiting at the time of the call are affected.]
  945.  */
  946. simpleroutine memory_object_data_error(
  947.         memory_control    : memory_object_control_t;
  948.         offset        : vm_offset_t;
  949.         size        : vm_size_t;
  950.         error_value    : kern_return_t);
  951. #else    /* NEW_MACH_IPC */
  952. skip;    /* memory_object_data_error */
  953. #endif    /* NEW_MACH_IPC */
  954.  
  955. #ifdef    NEW_MACH_IPC_and_XP
  956. /*
  957.  *    Make decisions regarding the use of the specified
  958.  *    memory object.
  959.  */
  960. simpleroutine memory_object_set_attributes(
  961.         memory_control    : memory_object_control_t;
  962.         object_ready    : boolean_t;
  963.         may_cache    : boolean_t;
  964.         copy_strategy    : memory_object_copy_strategy_t);
  965. #else    /* NEW_MACH_IPC */
  966. skip;    /* memory_object_set_attributes */
  967. #endif    /* NEW_MACH_IPC */
  968.  
  969. #ifdef    NEW_MACH_IPC_and_XP
  970. /*
  971.  */
  972. simpleroutine memory_object_destroy(
  973.         memory_control    : memory_object_control_t;
  974.         reason        : kern_return_t);
  975. #else    /* NEW_MACH_IPC */
  976. skip;    /* memory_object_destroy */
  977. #endif    /* NEW_MACH_IPC */
  978.  
  979. #ifdef    NEW_MACH_IPC_and_XP
  980. /*
  981.  *    Provide the data contents of a range of the given memory
  982.  *    object, with the access restriction specified, optional
  983.  *    precious attribute, and reply message.  [Only
  984.  *    whole virtual pages of data can be accepted; partial pages
  985.  *    will be discarded.  Data should be provided on request, but
  986.  *    may be provided in advance as desired.  When data already
  987.  *    held by this kernel is provided again, the new data is ignored.
  988.  *    The access restriction is the subset of {read, write, execute}
  989.  *    which are prohibited.  The kernel may not provide any data (or
  990.  *    protection) consistency among pages with different virtual page
  991.  *    alignments within the same object.  The precious value controls
  992.  *    how the kernel treats the data.  If it is FALSE, the kernel treats
  993.  *    its copy as a temporary and may throw it away if it hasn't been
  994.  *    changed.  If the precious value is TRUE, the kernel treats its
  995.  *    copy as a data repository and promises to return it to the manager;
  996.  *    the manager may tell the kernel to throw it away instead by flushing
  997.  *    and not cleaning the data -- see memory_object_lock_request.  The
  998.  *    reply_to port is for a compeletion message; it will be
  999.  *    memory_object_supply_completed.]
  1000.  */
  1001. simpleroutine memory_object_data_supply(
  1002.         memory_control    : memory_object_control_t;
  1003.         offset        : vm_offset_t;
  1004.         data        : pointer_t, Dealloc[];
  1005.         lock_value    : vm_prot_t;
  1006.         precious    : boolean_t;
  1007.         reply_to    : mach_port_t =
  1008.             MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
  1009. #else    /* NEW_MACH_IPC */
  1010. skip;    /* memory_object_data_supply */
  1011. #endif    /* NEW_MACH_IPC */
  1012.  
  1013. #ifdef    NEW_MACH_IPC_and_XP
  1014. /*
  1015.  */
  1016. simpleroutine memory_object_ready(
  1017.         memory_control    : memory_object_control_t;
  1018.         may_cache    : boolean_t;
  1019.         copy_strategy    : memory_object_copy_strategy_t);
  1020. #else    /* NEW_MACH_IPC */
  1021. skip;    /* memory_object_ready */
  1022. #endif    /* NEW_MACH_IPC */
  1023.  
  1024. #ifdef    NEW_MACH_IPC_and_XP
  1025. /*
  1026.  */
  1027. simpleroutine memory_object_change_attributes(
  1028.         memory_control    : memory_object_control_t;
  1029.         may_cache    : boolean_t;
  1030.         copy_strategy    : memory_object_copy_strategy_t;
  1031.         reply_to    : mach_port_t =
  1032.             MACH_MSG_TYPE_MAKE_SEND_ONCE|polymorphic);
  1033. #else    /* NEW_MACH_IPC */
  1034. skip;    /* memory_object_change_attributes */
  1035. #endif    /* NEW_MACH_IPC */
  1036.  
  1037. skip;    /* old host_callout_statistics_reset */
  1038. skip;    /* old port_set_select */
  1039.  
  1040. /*
  1041.  *    Sets a backup port for the named port.  The task
  1042.  *    must have receive rights for the named port.
  1043.  *    Returns the previous backup port, if any.
  1044.  */
  1045. routine port_set_backup(
  1046. #ifdef    NEW_MACH_IPC
  1047.         task        : ipc_space_t;
  1048. #else    /* NEW_MACH_IPC */
  1049.         task        : task_t;
  1050. #endif    /* NEW_MACH_IPC */
  1051.         port_name    : port_name_t;
  1052. #ifdef    NEW_IPC_IPC
  1053.         backup        : port_t = MACH_MSG_TYPE_MAKE_SEND
  1054.                   ctype: mach_port_t;
  1055. #else    /* NEW_MACH_IPC */
  1056.         backup        : port_t;
  1057. #endif    /* NEW_MACH_IPC */
  1058.     out    previous    : port_t);
  1059.  
  1060. /*
  1061.  *    Set/Get special properties of memory associated
  1062.  *    to some virtual address range, such as cachability, 
  1063.  *    migrability, replicability.  Machine-dependent.
  1064.  */
  1065. routine vm_machine_attribute(
  1066.         target_task    : vm_task_t;
  1067.         address        : vm_address_t;
  1068.         size        : vm_size_t;
  1069.         attribute    : vm_machine_attribute_t;
  1070.     inout    value        : vm_machine_attribute_val_t);
  1071.  
  1072. skip;    /* old host_fpa_counters_reset */
  1073.  
  1074. /*
  1075.  *    There is no more room in this interface for additional calls.
  1076.  */
  1077.  
  1078. /* HMM .... */
  1079.  
  1080. /*
  1081.  *  Synchronize the contents of an address space with backing store.
  1082.  *  Dirty pages in the address range are written to their appropriate
  1083.  *  backing store.  All pageouts are attempted.  If any pageout causes
  1084.  *  an error, vm_synchronize returns KERN_FAILURE.  If a page would be
  1085.  *  written to the default pager (swapfile), that page is skipped and
  1086.  *  KERN_FAILURE is returned.  This call is synchronous.
  1087.  */
  1088. routine vm_synchronize(
  1089.         target_task    : vm_task_t;
  1090.         address        : vm_address_t;
  1091.         size        : vm_size_t);
  1092.  
  1093. routine vm_set_policy(
  1094.         target_task    : vm_task_t;
  1095.         address        : vm_address_t;
  1096.         size        : vm_size_t;
  1097.         policy        : int);
  1098.  
  1099. routine vm_deactivate(
  1100.         target_task    : vm_task_t;
  1101.         address        : vm_address_t;
  1102.         size        : vm_size_t;
  1103.         when        : int);
  1104.