From e0faf22f31c48fb27b43c1825897d26e58feafc4 Mon Sep 17 00:00:00 2001 From: root Date: Sun, 3 May 2009 17:20:00 +0200 Subject: This is my initial working version. There is a bug in boot in this version: subhurd sometimes cannot boot. --- tmp/mach.h | 1263 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1263 insertions(+) create mode 100644 tmp/mach.h (limited to 'tmp/mach.h') diff --git a/tmp/mach.h b/tmp/mach.h new file mode 100644 index 00000000..f970a64c --- /dev/null +++ b/tmp/mach.h @@ -0,0 +1,1263 @@ +#ifndef _mach_user_ +#define _mach_user_ + +/* Module mach */ + +#include +#include +#include + +#include +#include + +/* Routine task_create */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_create +#if defined(LINTLIBRARY) + (target_task, inherit_memory, child_task) + mach_port_t target_task; + boolean_t inherit_memory; + mach_port_t *child_task; +{ return task_create(target_task, inherit_memory, child_task); } +#else +( + mach_port_t target_task, + boolean_t inherit_memory, + mach_port_t *child_task +); +#endif + +/* Routine task_terminate */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_terminate +#if defined(LINTLIBRARY) + (target_task) + mach_port_t target_task; +{ return task_terminate(target_task); } +#else +( + mach_port_t target_task +); +#endif + +/* Routine task_get_emulation_vector */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_get_emulation_vector +#if defined(LINTLIBRARY) + (task, vector_start, emulation_vector, emulation_vectorCnt) + mach_port_t task; + int *vector_start; + emulation_vector_t *emulation_vector; + mach_msg_type_number_t *emulation_vectorCnt; +{ return task_get_emulation_vector(task, vector_start, emulation_vector, emulation_vectorCnt); } +#else +( + mach_port_t task, + int *vector_start, + emulation_vector_t *emulation_vector, + mach_msg_type_number_t *emulation_vectorCnt +); +#endif + +/* Routine task_set_emulation_vector */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_set_emulation_vector +#if defined(LINTLIBRARY) + (task, vector_start, emulation_vector, emulation_vectorCnt) + mach_port_t task; + int vector_start; + emulation_vector_t emulation_vector; + mach_msg_type_number_t emulation_vectorCnt; +{ return task_set_emulation_vector(task, vector_start, emulation_vector, emulation_vectorCnt); } +#else +( + mach_port_t task, + int vector_start, + emulation_vector_t emulation_vector, + mach_msg_type_number_t emulation_vectorCnt +); +#endif + +/* Routine task_threads */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_threads +#if defined(LINTLIBRARY) + (target_task, thread_list, thread_listCnt) + mach_port_t target_task; + thread_array_t *thread_list; + mach_msg_type_number_t *thread_listCnt; +{ return task_threads(target_task, thread_list, thread_listCnt); } +#else +( + mach_port_t target_task, + thread_array_t *thread_list, + mach_msg_type_number_t *thread_listCnt +); +#endif + +/* Routine task_info */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_info +#if defined(LINTLIBRARY) + (target_task, flavor, task_info_out, task_info_outCnt) + mach_port_t target_task; + int flavor; + task_info_t task_info_out; + mach_msg_type_number_t *task_info_outCnt; +{ return task_info(target_task, flavor, task_info_out, task_info_outCnt); } +#else +( + mach_port_t target_task, + int flavor, + task_info_t task_info_out, + mach_msg_type_number_t *task_info_outCnt +); +#endif + +/* Routine thread_terminate */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_terminate +#if defined(LINTLIBRARY) + (target_thread) + mach_port_t target_thread; +{ return thread_terminate(target_thread); } +#else +( + mach_port_t target_thread +); +#endif + +/* Routine thread_get_state */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_get_state +#if defined(LINTLIBRARY) + (target_thread, flavor, old_state, old_stateCnt) + mach_port_t target_thread; + int flavor; + thread_state_t old_state; + mach_msg_type_number_t *old_stateCnt; +{ return thread_get_state(target_thread, flavor, old_state, old_stateCnt); } +#else +( + mach_port_t target_thread, + int flavor, + thread_state_t old_state, + mach_msg_type_number_t *old_stateCnt +); +#endif + +/* Routine thread_set_state */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_set_state +#if defined(LINTLIBRARY) + (target_thread, flavor, new_state, new_stateCnt) + mach_port_t target_thread; + int flavor; + thread_state_t new_state; + mach_msg_type_number_t new_stateCnt; +{ return thread_set_state(target_thread, flavor, new_state, new_stateCnt); } +#else +( + mach_port_t target_thread, + int flavor, + thread_state_t new_state, + mach_msg_type_number_t new_stateCnt +); +#endif + +/* Routine thread_info */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_info +#if defined(LINTLIBRARY) + (target_thread, flavor, thread_info_out, thread_info_outCnt) + mach_port_t target_thread; + int flavor; + thread_info_t thread_info_out; + mach_msg_type_number_t *thread_info_outCnt; +{ return thread_info(target_thread, flavor, thread_info_out, thread_info_outCnt); } +#else +( + mach_port_t target_thread, + int flavor, + thread_info_t thread_info_out, + mach_msg_type_number_t *thread_info_outCnt +); +#endif + +/* Routine vm_allocate */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_allocate +#if defined(LINTLIBRARY) + (target_task, address, size, anywhere) + mach_port_t target_task; + vm_address_t *address; + vm_size_t size; + boolean_t anywhere; +{ return vm_allocate(target_task, address, size, anywhere); } +#else +( + mach_port_t target_task, + vm_address_t *address, + vm_size_t size, + boolean_t anywhere +); +#endif + +/* Routine vm_deallocate */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_deallocate +#if defined(LINTLIBRARY) + (target_task, address, size) + mach_port_t target_task; + vm_address_t address; + vm_size_t size; +{ return vm_deallocate(target_task, address, size); } +#else +( + mach_port_t target_task, + vm_address_t address, + vm_size_t size +); +#endif + +/* Routine vm_protect */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_protect +#if defined(LINTLIBRARY) + (target_task, address, size, set_maximum, new_protection) + mach_port_t target_task; + vm_address_t address; + vm_size_t size; + boolean_t set_maximum; + vm_prot_t new_protection; +{ return vm_protect(target_task, address, size, set_maximum, new_protection); } +#else +( + mach_port_t target_task, + vm_address_t address, + vm_size_t size, + boolean_t set_maximum, + vm_prot_t new_protection +); +#endif + +/* Routine vm_inherit */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_inherit +#if defined(LINTLIBRARY) + (target_task, address, size, new_inheritance) + mach_port_t target_task; + vm_address_t address; + vm_size_t size; + vm_inherit_t new_inheritance; +{ return vm_inherit(target_task, address, size, new_inheritance); } +#else +( + mach_port_t target_task, + vm_address_t address, + vm_size_t size, + vm_inherit_t new_inheritance +); +#endif + +/* Routine vm_read */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_read +#if defined(LINTLIBRARY) + (target_task, address, size, data, dataCnt) + mach_port_t target_task; + vm_address_t address; + vm_size_t size; + vm_offset_t *data; + mach_msg_type_number_t *dataCnt; +{ return vm_read(target_task, address, size, data, dataCnt); } +#else +( + mach_port_t target_task, + vm_address_t address, + vm_size_t size, + vm_offset_t *data, + mach_msg_type_number_t *dataCnt +); +#endif + +/* Routine vm_write */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_write +#if defined(LINTLIBRARY) + (target_task, address, data, dataCnt) + mach_port_t target_task; + vm_address_t address; + vm_offset_t data; + mach_msg_type_number_t dataCnt; +{ return vm_write(target_task, address, data, dataCnt); } +#else +( + mach_port_t target_task, + vm_address_t address, + vm_offset_t data, + mach_msg_type_number_t dataCnt +); +#endif + +/* Routine vm_copy */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_copy +#if defined(LINTLIBRARY) + (target_task, source_address, size, dest_address) + mach_port_t target_task; + vm_address_t source_address; + vm_size_t size; + vm_address_t dest_address; +{ return vm_copy(target_task, source_address, size, dest_address); } +#else +( + mach_port_t target_task, + vm_address_t source_address, + vm_size_t size, + vm_address_t dest_address +); +#endif + +/* Routine vm_region */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_region +#if defined(LINTLIBRARY) + (target_task, address, size, protection, max_protection, inheritance, is_shared, object_name, offset) + mach_port_t target_task; + vm_address_t *address; + vm_size_t *size; + vm_prot_t *protection; + vm_prot_t *max_protection; + vm_inherit_t *inheritance; + boolean_t *is_shared; + mach_port_t *object_name; + vm_offset_t *offset; +{ return vm_region(target_task, address, size, protection, max_protection, inheritance, is_shared, object_name, offset); } +#else +( + mach_port_t target_task, + vm_address_t *address, + vm_size_t *size, + vm_prot_t *protection, + vm_prot_t *max_protection, + vm_inherit_t *inheritance, + boolean_t *is_shared, + mach_port_t *object_name, + vm_offset_t *offset +); +#endif + +/* Routine vm_statistics */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_statistics +#if defined(LINTLIBRARY) + (target_task, vm_stats) + mach_port_t target_task; + vm_statistics_data_t *vm_stats; +{ return vm_statistics(target_task, vm_stats); } +#else +( + mach_port_t target_task, + vm_statistics_data_t *vm_stats +); +#endif + +/* Routine mach_ports_register */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t mach_ports_register +#if defined(LINTLIBRARY) + (target_task, init_port_set, init_port_setCnt) + mach_port_t target_task; + mach_port_array_t init_port_set; + mach_msg_type_number_t init_port_setCnt; +{ return mach_ports_register(target_task, init_port_set, init_port_setCnt); } +#else +( + mach_port_t target_task, + mach_port_array_t init_port_set, + mach_msg_type_number_t init_port_setCnt +); +#endif + +/* Routine mach_ports_lookup */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t mach_ports_lookup +#if defined(LINTLIBRARY) + (target_task, init_port_set, init_port_setCnt) + mach_port_t target_task; + mach_port_array_t *init_port_set; + mach_msg_type_number_t *init_port_setCnt; +{ return mach_ports_lookup(target_task, init_port_set, init_port_setCnt); } +#else +( + mach_port_t target_task, + mach_port_array_t *init_port_set, + mach_msg_type_number_t *init_port_setCnt +); +#endif + +/* SimpleRoutine memory_object_data_provided */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_data_provided +#if defined(LINTLIBRARY) + (memory_control, offset, data, dataCnt, lock_value) + mach_port_t memory_control; + vm_offset_t offset; + vm_offset_t data; + mach_msg_type_number_t dataCnt; + vm_prot_t lock_value; +{ return memory_object_data_provided(memory_control, offset, data, dataCnt, lock_value); } +#else +( + mach_port_t memory_control, + vm_offset_t offset, + vm_offset_t data, + mach_msg_type_number_t dataCnt, + vm_prot_t lock_value +); +#endif + +/* SimpleRoutine memory_object_data_unavailable */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_data_unavailable +#if defined(LINTLIBRARY) + (memory_control, offset, size) + mach_port_t memory_control; + vm_offset_t offset; + vm_size_t size; +{ return memory_object_data_unavailable(memory_control, offset, size); } +#else +( + mach_port_t memory_control, + vm_offset_t offset, + vm_size_t size +); +#endif + +/* Routine memory_object_get_attributes */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_get_attributes +#if defined(LINTLIBRARY) + (memory_control, object_ready, may_cache, copy_strategy) + mach_port_t memory_control; + boolean_t *object_ready; + boolean_t *may_cache; + memory_object_copy_strategy_t *copy_strategy; +{ return memory_object_get_attributes(memory_control, object_ready, may_cache, copy_strategy); } +#else +( + mach_port_t memory_control, + boolean_t *object_ready, + boolean_t *may_cache, + memory_object_copy_strategy_t *copy_strategy +); +#endif + +/* Routine vm_set_default_memory_manager */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_set_default_memory_manager +#if defined(LINTLIBRARY) + (host_priv, default_manager) + mach_port_t host_priv; + mach_port_t *default_manager; +{ return vm_set_default_memory_manager(host_priv, default_manager); } +#else +( + mach_port_t host_priv, + mach_port_t *default_manager +); +#endif + +/* SimpleRoutine xxx_memory_object_lock_request */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_memory_object_lock_request +#if defined(LINTLIBRARY) + (memory_control, offset, size, should_clean, should_flush, lock_value, reply_to) + mach_port_t memory_control; + vm_offset_t offset; + vm_size_t size; + boolean_t should_clean; + boolean_t should_flush; + vm_prot_t lock_value; + mach_port_t reply_to; +{ return xxx_memory_object_lock_request(memory_control, offset, size, should_clean, should_flush, lock_value, reply_to); } +#else +( + mach_port_t memory_control, + vm_offset_t offset, + vm_size_t size, + boolean_t should_clean, + boolean_t should_flush, + vm_prot_t lock_value, + mach_port_t reply_to +); +#endif + +/* SimpleRoutine memory_object_lock_request */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_lock_request +#if defined(LINTLIBRARY) + (memory_control, offset, size, should_return, should_flush, lock_value, reply_to) + mach_port_t memory_control; + vm_offset_t offset; + vm_size_t size; + memory_object_return_t should_return; + boolean_t should_flush; + vm_prot_t lock_value; + mach_port_t reply_to; +{ return memory_object_lock_request(memory_control, offset, size, should_return, should_flush, lock_value, reply_to); } +#else +( + mach_port_t memory_control, + vm_offset_t offset, + vm_size_t size, + memory_object_return_t should_return, + boolean_t should_flush, + vm_prot_t lock_value, + mach_port_t reply_to +); +#endif + +/* Routine xxx_task_get_emulation_vector */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_task_get_emulation_vector +#if defined(LINTLIBRARY) + (task, vector_start, emulation_vector, emulation_vectorCnt) + mach_port_t task; + int *vector_start; + emulation_vector_t emulation_vector; + mach_msg_type_number_t *emulation_vectorCnt; +{ return xxx_task_get_emulation_vector(task, vector_start, emulation_vector, emulation_vectorCnt); } +#else +( + mach_port_t task, + int *vector_start, + emulation_vector_t emulation_vector, + mach_msg_type_number_t *emulation_vectorCnt +); +#endif + +/* Routine xxx_task_set_emulation_vector */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_task_set_emulation_vector +#if defined(LINTLIBRARY) + (task, vector_start, emulation_vector, emulation_vectorCnt) + mach_port_t task; + int vector_start; + emulation_vector_t emulation_vector; + mach_msg_type_number_t emulation_vectorCnt; +{ return xxx_task_set_emulation_vector(task, vector_start, emulation_vector, emulation_vectorCnt); } +#else +( + mach_port_t task, + int vector_start, + emulation_vector_t emulation_vector, + mach_msg_type_number_t emulation_vectorCnt +); +#endif + +/* Routine xxx_host_info */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_host_info +#if defined(LINTLIBRARY) + (target_task, info) + mach_port_t target_task; + machine_info_data_t *info; +{ return xxx_host_info(target_task, info); } +#else +( + mach_port_t target_task, + machine_info_data_t *info +); +#endif + +/* Routine xxx_slot_info */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_slot_info +#if defined(LINTLIBRARY) + (target_task, slot, info) + mach_port_t target_task; + int slot; + machine_slot_data_t *info; +{ return xxx_slot_info(target_task, slot, info); } +#else +( + mach_port_t target_task, + int slot, + machine_slot_data_t *info +); +#endif + +/* Routine xxx_cpu_control */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_cpu_control +#if defined(LINTLIBRARY) + (target_task, cpu, running) + mach_port_t target_task; + int cpu; + boolean_t running; +{ return xxx_cpu_control(target_task, cpu, running); } +#else +( + mach_port_t target_task, + int cpu, + boolean_t running +); +#endif + +/* Routine task_suspend */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_suspend +#if defined(LINTLIBRARY) + (target_task) + mach_port_t target_task; +{ return task_suspend(target_task); } +#else +( + mach_port_t target_task +); +#endif + +/* Routine task_resume */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_resume +#if defined(LINTLIBRARY) + (target_task) + mach_port_t target_task; +{ return task_resume(target_task); } +#else +( + mach_port_t target_task +); +#endif + +/* Routine task_get_special_port */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_get_special_port +#if defined(LINTLIBRARY) + (task, which_port, special_port) + mach_port_t task; + int which_port; + mach_port_t *special_port; +{ return task_get_special_port(task, which_port, special_port); } +#else +( + mach_port_t task, + int which_port, + mach_port_t *special_port +); +#endif + +/* Routine task_set_special_port */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_set_special_port +#if defined(LINTLIBRARY) + (task, which_port, special_port) + mach_port_t task; + int which_port; + mach_port_t special_port; +{ return task_set_special_port(task, which_port, special_port); } +#else +( + mach_port_t task, + int which_port, + mach_port_t special_port +); +#endif + +/* Routine xxx_task_info */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_task_info +#if defined(LINTLIBRARY) + (target_task, flavor, task_info_out, task_info_outCnt) + mach_port_t target_task; + int flavor; + task_info_t task_info_out; + mach_msg_type_number_t *task_info_outCnt; +{ return xxx_task_info(target_task, flavor, task_info_out, task_info_outCnt); } +#else +( + mach_port_t target_task, + int flavor, + task_info_t task_info_out, + mach_msg_type_number_t *task_info_outCnt +); +#endif + +/* Routine thread_create */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_create +#if defined(LINTLIBRARY) + (parent_task, child_thread) + mach_port_t parent_task; + mach_port_t *child_thread; +{ return thread_create(parent_task, child_thread); } +#else +( + mach_port_t parent_task, + mach_port_t *child_thread +); +#endif + +/* Routine thread_suspend */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_suspend +#if defined(LINTLIBRARY) + (target_thread) + mach_port_t target_thread; +{ return thread_suspend(target_thread); } +#else +( + mach_port_t target_thread +); +#endif + +/* Routine thread_resume */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_resume +#if defined(LINTLIBRARY) + (target_thread) + mach_port_t target_thread; +{ return thread_resume(target_thread); } +#else +( + mach_port_t target_thread +); +#endif + +/* Routine thread_abort */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_abort +#if defined(LINTLIBRARY) + (target_thread) + mach_port_t target_thread; +{ return thread_abort(target_thread); } +#else +( + mach_port_t target_thread +); +#endif + +/* Routine xxx_thread_get_state */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_thread_get_state +#if defined(LINTLIBRARY) + (target_thread, flavor, old_state, old_stateCnt) + mach_port_t target_thread; + int flavor; + thread_state_t old_state; + mach_msg_type_number_t *old_stateCnt; +{ return xxx_thread_get_state(target_thread, flavor, old_state, old_stateCnt); } +#else +( + mach_port_t target_thread, + int flavor, + thread_state_t old_state, + mach_msg_type_number_t *old_stateCnt +); +#endif + +/* Routine xxx_thread_set_state */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_thread_set_state +#if defined(LINTLIBRARY) + (target_thread, flavor, new_state, new_stateCnt) + mach_port_t target_thread; + int flavor; + thread_state_t new_state; + mach_msg_type_number_t new_stateCnt; +{ return xxx_thread_set_state(target_thread, flavor, new_state, new_stateCnt); } +#else +( + mach_port_t target_thread, + int flavor, + thread_state_t new_state, + mach_msg_type_number_t new_stateCnt +); +#endif + +/* Routine thread_get_special_port */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_get_special_port +#if defined(LINTLIBRARY) + (thread, which_port, special_port) + mach_port_t thread; + int which_port; + mach_port_t *special_port; +{ return thread_get_special_port(thread, which_port, special_port); } +#else +( + mach_port_t thread, + int which_port, + mach_port_t *special_port +); +#endif + +/* Routine thread_set_special_port */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t thread_set_special_port +#if defined(LINTLIBRARY) + (thread, which_port, special_port) + mach_port_t thread; + int which_port; + mach_port_t special_port; +{ return thread_set_special_port(thread, which_port, special_port); } +#else +( + mach_port_t thread, + int which_port, + mach_port_t special_port +); +#endif + +/* Routine xxx_thread_info */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t xxx_thread_info +#if defined(LINTLIBRARY) + (target_thread, flavor, thread_info_out, thread_info_outCnt) + mach_port_t target_thread; + int flavor; + thread_info_t thread_info_out; + mach_msg_type_number_t *thread_info_outCnt; +{ return xxx_thread_info(target_thread, flavor, thread_info_out, thread_info_outCnt); } +#else +( + mach_port_t target_thread, + int flavor, + thread_info_t thread_info_out, + mach_msg_type_number_t *thread_info_outCnt +); +#endif + +/* Routine task_set_emulation */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_set_emulation +#if defined(LINTLIBRARY) + (target_port, routine_entry_pt, routine_number) + mach_port_t target_port; + vm_address_t routine_entry_pt; + int routine_number; +{ return task_set_emulation(target_port, routine_entry_pt, routine_number); } +#else +( + mach_port_t target_port, + vm_address_t routine_entry_pt, + int routine_number +); +#endif + +/* Routine task_ras_control */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t task_ras_control +#if defined(LINTLIBRARY) + (target_task, basepc, boundspc, flavor) + mach_port_t target_task; + vm_address_t basepc; + vm_address_t boundspc; + int flavor; +{ return task_ras_control(target_task, basepc, boundspc, flavor); } +#else +( + mach_port_t target_task, + vm_address_t basepc, + vm_address_t boundspc, + int flavor +); +#endif + +/* Routine vm_map */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_map +#if defined(LINTLIBRARY) + (target_task, address, size, mask, anywhere, memory_object, offset, copy, cur_protection, max_protection, inheritance) + mach_port_t target_task; + vm_address_t *address; + vm_size_t size; + vm_address_t mask; + boolean_t anywhere; + mach_port_t memory_object; + vm_offset_t offset; + boolean_t copy; + vm_prot_t cur_protection; + vm_prot_t max_protection; + vm_inherit_t inheritance; +{ return vm_map(target_task, address, size, mask, anywhere, memory_object, offset, copy, cur_protection, max_protection, inheritance); } +#else +( + mach_port_t target_task, + vm_address_t *address, + vm_size_t size, + vm_address_t mask, + boolean_t anywhere, + mach_port_t memory_object, + vm_offset_t offset, + boolean_t copy, + vm_prot_t cur_protection, + vm_prot_t max_protection, + vm_inherit_t inheritance +); +#endif + +/* SimpleRoutine memory_object_data_error */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_data_error +#if defined(LINTLIBRARY) + (memory_control, offset, size, error_value) + mach_port_t memory_control; + vm_offset_t offset; + vm_size_t size; + kern_return_t error_value; +{ return memory_object_data_error(memory_control, offset, size, error_value); } +#else +( + mach_port_t memory_control, + vm_offset_t offset, + vm_size_t size, + kern_return_t error_value +); +#endif + +/* SimpleRoutine memory_object_set_attributes */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_set_attributes +#if defined(LINTLIBRARY) + (memory_control, object_ready, may_cache, copy_strategy) + mach_port_t memory_control; + boolean_t object_ready; + boolean_t may_cache; + memory_object_copy_strategy_t copy_strategy; +{ return memory_object_set_attributes(memory_control, object_ready, may_cache, copy_strategy); } +#else +( + mach_port_t memory_control, + boolean_t object_ready, + boolean_t may_cache, + memory_object_copy_strategy_t copy_strategy +); +#endif + +/* SimpleRoutine memory_object_destroy */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_destroy +#if defined(LINTLIBRARY) + (memory_control, reason) + mach_port_t memory_control; + kern_return_t reason; +{ return memory_object_destroy(memory_control, reason); } +#else +( + mach_port_t memory_control, + kern_return_t reason +); +#endif + +/* SimpleRoutine memory_object_data_supply */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_data_supply +#if defined(LINTLIBRARY) + (memory_control, offset, data, dataCnt, dataDealloc, lock_value, precious, reply_to) + mach_port_t memory_control; + vm_offset_t offset; + vm_offset_t data; + mach_msg_type_number_t dataCnt; + boolean_t dataDealloc; + vm_prot_t lock_value; + boolean_t precious; + mach_port_t reply_to; +{ return memory_object_data_supply(memory_control, offset, data, dataCnt, dataDealloc, lock_value, precious, reply_to); } +#else +( + mach_port_t memory_control, + vm_offset_t offset, + vm_offset_t data, + mach_msg_type_number_t dataCnt, + boolean_t dataDealloc, + vm_prot_t lock_value, + boolean_t precious, + mach_port_t reply_to +); +#endif + +/* SimpleRoutine memory_object_ready */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_ready +#if defined(LINTLIBRARY) + (memory_control, may_cache, copy_strategy) + mach_port_t memory_control; + boolean_t may_cache; + memory_object_copy_strategy_t copy_strategy; +{ return memory_object_ready(memory_control, may_cache, copy_strategy); } +#else +( + mach_port_t memory_control, + boolean_t may_cache, + memory_object_copy_strategy_t copy_strategy +); +#endif + +/* SimpleRoutine memory_object_change_attributes */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t memory_object_change_attributes +#if defined(LINTLIBRARY) + (memory_control, may_cache, copy_strategy, reply_to) + mach_port_t memory_control; + boolean_t may_cache; + memory_object_copy_strategy_t copy_strategy; + mach_port_t reply_to; +{ return memory_object_change_attributes(memory_control, may_cache, copy_strategy, reply_to); } +#else +( + mach_port_t memory_control, + boolean_t may_cache, + memory_object_copy_strategy_t copy_strategy, + mach_port_t reply_to +); +#endif + +/* Routine vm_machine_attribute */ +#ifdef mig_external +mig_external +#else +extern +#endif +kern_return_t vm_machine_attribute +#if defined(LINTLIBRARY) + (target_task, address, size, attribute, value) + mach_port_t target_task; + vm_address_t address; + vm_size_t size; + vm_machine_attribute_t attribute; + vm_machine_attribute_val_t *value; +{ return vm_machine_attribute(target_task, address, size, attribute, value); } +#else +( + mach_port_t target_task, + vm_address_t address, + vm_size_t size, + vm_machine_attribute_t attribute, + vm_machine_attribute_val_t *value +); +#endif + +#endif /* not defined(_mach_user_) */ -- cgit v1.2.3