diff options
Diffstat (limited to 'boot-proxy-exc/mach_impl.c~')
| -rw-r--r-- | boot-proxy-exc/mach_impl.c~ | 906 |
1 files changed, 906 insertions, 0 deletions
diff --git a/boot-proxy-exc/mach_impl.c~ b/boot-proxy-exc/mach_impl.c~ new file mode 100644 index 00000000..a5c53197 --- /dev/null +++ b/boot-proxy-exc/mach_impl.c~ @@ -0,0 +1,906 @@ +/* + Copyright (C) 2009 Free Software Foundation, Inc. + Written by Zheng Da. + + This file is part of the GNU Hurd. + + The GNU Hurd is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + The GNU Hurd is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with the GNU Hurd; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This file implements the server-side RPC functions of mach_host. */ + +#include <string.h> +#include <mach.h> +#include <hurd.h> +#include <assert.h> + +#include "util.h" +#include "mach_proxy.h" +#include "list.h" + +/* Routine task_create */ +kern_return_t +S_task_create (mach_port_t target_task, boolean_t inherit_memory, + mach_port_t *child_task, mach_msg_type_name_t *child_taskPoly) +{ + struct task_info *target_task_pi; + task_t real_child_task; + task_t pseudo_child_task; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = task_create (target_task_pi->task_port, + inherit_memory, &real_child_task); + debug ("get a request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + if (err) + return err; + + err = create_pseudo_task (real_child_task, &pseudo_child_task); + if (err) + { + task_terminate (real_child_task); + return err; + } + + *child_task = pseudo_child_task; + *child_taskPoly = MACH_MSG_TYPE_COPY_SEND; + + debug ("new task: %d", real_child_task); + return err; +} + +/* Routine task_terminate */ +kern_return_t +S_task_terminate (mach_port_t target_task) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = task_terminate (target_task_pi->task_port); + debug ("get request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_destroy_right (target_task_pi); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine task_info */ +kern_return_t +S_task_info (mach_port_t target_task, int flavor, + task_info_t task_info_out, + mach_msg_type_number_t *task_info_outCnt) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = task_info (target_task_pi->task_port, flavor, + task_info_out, task_info_outCnt); + debug ("%s", strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_allocate */ +kern_return_t +S_vm_allocate (mach_port_t target_task, vm_address_t *address, + vm_size_t size, boolean_t anywhere) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + /* This should be enough. */ + err = vm_allocate (target_task_pi->task_port, address, size, anywhere); + debug ("request is from task %d, address: %d, size: %d, anywhere: %d, %s", + target_task_pi->task_port, *address, size, anywhere, strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_deallocate */ +kern_return_t +S_vm_deallocate (mach_port_t target_task, + vm_address_t address, vm_size_t size) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = vm_deallocate (target_task_pi->task_port, address, size); + debug ("get a request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_protect */ +kern_return_t +S_vm_protect (mach_port_t target_task, vm_address_t address, + vm_size_t size, boolean_t set_maximum, + vm_prot_t new_protection) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = vm_protect (target_task_pi->task_port, address, + size, set_maximum, new_protection); + debug ("request is from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_inherit */ +kern_return_t +S_vm_inherit (mach_port_t target_task, vm_address_t address, + vm_size_t size, vm_inherit_t new_inheritance) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = vm_inherit (target_task_pi->task_port, address, + size, new_inheritance); + debug ("%s", strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_read */ +kern_return_t +S_vm_read (mach_port_t target_task, vm_address_t address, + vm_size_t size, vm_offset_t *data, + mach_msg_type_number_t *dataCnt) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = vm_read (target_task_pi->task_port, address, size, data, dataCnt); + debug ("get a request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + /* The deallocation bit is set.*/ + return err; +} + +/* Routine vm_write */ +kern_return_t +S_vm_write (mach_port_t target_task, vm_address_t address, + vm_offset_t data, mach_msg_type_number_t dataCnt) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = vm_write (target_task_pi->task_port, address, data, dataCnt); + debug ("get a request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + /* the proxy get the mapped pages from the client, + * deallocate it here. */ + vm_deallocate (mach_task_self (), data, dataCnt); + return err; +} + +/* Routine vm_copy */ +kern_return_t +S_vm_copy (mach_port_t target_task, vm_address_t source_address, + vm_size_t size, vm_address_t dest_address) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = vm_copy (target_task_pi->task_port, source_address, + size, dest_address); + debug ("%s", strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_region */ +kern_return_t +S_vm_region (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) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = vm_region (target_task_pi->task_port, address, size, protection, + max_protection, inheritance, is_shared, object_name, offset); + debug ("get a request from task %d: %s, object: %d", + target_task_pi->task_port, strerror (err), *object_name); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_statistics */ +kern_return_t +S_vm_statistics (mach_port_t target_task, vm_statistics_data_t *vm_stats) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = vm_statistics (target_task_pi->task_port, vm_stats); + debug ("request is from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine mach_ports_register */ +kern_return_t +S_mach_ports_register (mach_port_t target_task, + mach_port_array_t init_port_set, + mach_msg_type_number_t init_port_setCnt) +{ + debug (""); + assert (0); + // not used by Hurd + return EOPNOTSUPP; +} + +/* Routine mach_ports_lookup */ +kern_return_t +S_mach_ports_lookup (mach_port_t target_task, + mach_port_array_t *init_port_set, + mach_msg_type_number_t *init_port_setCnt) +{ + debug (""); + assert (0); + // not used by Hurd + return EOPNOTSUPP; +} + +/* Routine vm_set_default_memory_manager */ +kern_return_t +S_vm_set_default_memory_manager (mach_port_t host_priv, + mach_port_t *default_manager) +{ + extern mach_port_t defpager; + debug (""); + *default_manager = defpager; + return 0; +} + + +/* Routine xxx_task_info */ +kern_return_t +S_xxx_task_info (mach_port_t target_task, int flavor, + task_info_t task_info_out, + mach_msg_type_number_t *task_info_outCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_host_info */ +kern_return_t +S_xxx_host_info (mach_port_t target_task, machine_info_data_t *info) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_slot_info */ +kern_return_t +S_xxx_slot_info (mach_port_t target_task, int slot, machine_slot_data_t *info) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_cpu_control */ +kern_return_t +S_xxx_cpu_control (mach_port_t target_task, int cpu, boolean_t running) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine task_suspend */ +kern_return_t +S_task_suspend (mach_port_t target_task) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = task_suspend (target_task_pi->task_port); + debug ("get request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine task_resume */ +kern_return_t +S_task_resume (mach_port_t target_task) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = task_resume (target_task_pi->task_port); + debug ("get request from task %d: %s", + target_task_pi->task_port, strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine task_get_special_port */ +kern_return_t +S_task_get_special_port (mach_port_t target_task, int which_port, + mach_port_t *special_port, + mach_msg_type_name_t *special_portPoly) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + err = task_get_special_port (target_task_pi->task_port, + which_port, special_port); + debug ("request is from task %d (%d, %d): %s\n", + target_task_pi->task_port, which_port, *special_port, strerror (err)); + ports_port_deref (target_task_pi); + if (err) + return err; + *special_portPoly = MACH_MSG_TYPE_MOVE_SEND; + return err; +} + +/* Routine task_set_special_port */ +kern_return_t +S_task_set_special_port (mach_port_t target_task, int which_port, + mach_port_t special_port) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + if (which_port == TASK_EXCEPTION_PORT) + { + struct port_info *new_exc_pi; + struct port_info *old_exc_pi; + mach_port_t old_user_exc_port; + mach_port_t new_exc_port; + + err = ports_create_port (exc_portclass, port_bucket, + sizeof (new_exc_pi), &new_exc_pi); + if (err) + { + ports_port_deref (target_task_pi); + return err; + } + new_exc_port = ports_get_send_right (new_exc_pi); + + mutex_lock (&target_task_pi->lock); + old_exc_pi = target_task_pi->exc_pi; + old_user_exc_port = target_task_pi->user_exc_port; + err = task_set_special_port (target_task_pi->task_port, + which_port, new_exc_port); + target_task_pi->user_exc_port = special_port; + target_task_pi->exc_pi = new_exc_pi; + mutex_unlock (&target_task_pi->lock); + + ports_port_deref (new_exc_pi); + if (old_user_exc_port) + mach_port_deallocate (mach_task_self (), old_user_exc_port); + if (old_exc_pi) + ports_destroy_right (old_exc_pi); + } + else + { + err = task_set_special_port (target_task_pi->task_port, + which_port, special_port); + debug ("get request from task %d (%d, %d): %s", + target_task_pi->task_port, which_port, + special_port, strerror (err)); + mach_port_deallocate (mach_task_self (), special_port); + } + ports_port_deref (target_task_pi); + return err; +} + +/* Routine task_ras_control */ +kern_return_t +S_task_ras_control (mach_port_t target_task, vm_address_t basepc, + vm_address_t boundspc, int flavor) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = task_ras_control (target_task_pi->task_port, basepc, boundspc, flavor); + debug ("%s", strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine vm_map */ +kern_return_t +S_vm_map (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) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = vm_map (target_task_pi->task_port, address, size, mask, + anywhere, memory_object, offset, copy, + cur_protection, max_protection, inheritance); + debug ("request is from task %d, anywhere: %d: %s", + target_task_pi->task_port, anywhere, strerror (err)); + ports_port_deref (target_task_pi); + mach_port_deallocate (mach_task_self (), memory_object); + return err; +} + +/* Routine vm_machine_attribute */ +kern_return_t +S_vm_machine_attribute (mach_port_t target_task, vm_address_t address, + vm_size_t size, vm_machine_attribute_t attribute, + vm_machine_attribute_val_t *value) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = vm_machine_attribute (target_task_pi->task_port, address, + size, attribute, value); + debug ("%s", strerror (err)); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine task_threads */ +kern_return_t +S_task_threads (mach_port_t target_task, thread_array_t *thread_list, + mach_msg_type_number_t *thread_listCnt) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + target_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + + // TODO: use move send + err = task_threads (target_task_pi->task_port, + thread_list, thread_listCnt); + debug ("get a request from task %d: %s", + target_task_pi->task_port, strerror (err)); +// info ("task_threads: %s, number of threads: %d", +// strerror (err), *thread_listCnt); + ports_port_deref (target_task_pi); + return err; +} + +/* Routine thread_create */ +kern_return_t +S_thread_create (mach_port_t parent_task, mach_port_t *child_thread, + mach_msg_type_name_t *child_threadPoly) +{ + struct task_info *target_task_pi; + error_t err; + + target_task_pi = ports_lookup_port (port_bucket, + parent_task, task_portclass); + if (target_task_pi == NULL) + return EOPNOTSUPP; + err = thread_create (target_task_pi->task_port, child_thread); + debug ("get a request from task %d: thread port: %d: %s", + target_task_pi->task_port, *child_thread, strerror (err)); + ports_port_deref (target_task_pi); + *child_threadPoly = MACH_MSG_TYPE_MOVE_SEND; + return err; +} + +////////////////////it doesn't forward thread request//////////////// + +/* Routine thread_suspend */ +kern_return_t +S_thread_suspend (mach_port_t target_thread) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_resume */ +kern_return_t +S_thread_resume (mach_port_t target_thread) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_abort */ +kern_return_t +S_thread_abort (mach_port_t target_thread) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_thread_get_state */ +kern_return_t +S_xxx_thread_get_state (mach_port_t target_thread, int flavor, + thread_state_t old_state, + mach_msg_type_number_t *old_stateCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_thread_set_state */ +kern_return_t +S_xxx_thread_set_state (mach_port_t target_thread, int flavor, + thread_state_t new_state, + mach_msg_type_number_t new_stateCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_thread_info */ +kern_return_t +S_xxx_thread_info (mach_port_t target_thread, int flavor, + thread_info_t thread_info_out, + mach_msg_type_number_t *thread_info_outCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_get_special_port */ +kern_return_t +S_thread_get_special_port (mach_port_t thread, int which_port, + mach_port_t *special_port) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_set_special_port */ +kern_return_t +S_thread_set_special_port (mach_port_t thread, int which_port, + mach_port_t special_port) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_terminate */ +kern_return_t +S_thread_terminate (mach_port_t target_thread) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_get_state */ +kern_return_t +S_thread_get_state (mach_port_t target_thread, int flavor, + thread_state_t old_state, + mach_msg_type_number_t *old_stateCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_set_state */ +kern_return_t +S_thread_set_state (mach_port_t target_thread, int flavor, + thread_state_t new_state, + mach_msg_type_number_t new_stateCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine thread_info */ +kern_return_t +S_thread_info (mach_port_t target_thread, int flavor, + thread_info_t thread_info_out, + mach_msg_type_number_t *thread_info_outCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/////////////////////RPC related to memory object//////////////////// +//////////////////they are not needed to be forwarded//////////////// + +/* SimpleRoutine memory_object_data_provided */ +kern_return_t +S_memory_object_data_provided (mach_port_t memory_control, + vm_offset_t offset, vm_offset_t data, + mach_msg_type_number_t dataCnt, + vm_prot_t lock_value) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_data_unavailable */ +kern_return_t +S_memory_object_data_unavailable (mach_port_t memory_control, + vm_offset_t offset, vm_size_t size) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine memory_object_get_attributes */ +kern_return_t +S_memory_object_get_attributes (mach_port_t memory_control, + boolean_t *object_ready, boolean_t *may_cache, + memory_object_copy_strategy_t *copy_strategy) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine xxx_memory_object_lock_request */ +kern_return_t +S_xxx_memory_object_lock_request (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, + mach_msg_type_name_t reply_toPoly) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_lock_request */ +kern_return_t +S_memory_object_lock_request ( 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, + mach_msg_type_name_t reply_toPoly) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_data_error */ +kern_return_t +S_memory_object_data_error (mach_port_t memory_control, + vm_offset_t offset, vm_size_t size, + kern_return_t error_value) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_set_attributes */ +kern_return_t +S_memory_object_set_attributes (mach_port_t memory_control, + boolean_t object_ready, boolean_t may_cache, + memory_object_copy_strategy_t copy_strategy) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_destroy */ +kern_return_t +S_memory_object_destroy (mach_port_t memory_control, kern_return_t reason) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_data_supply */ +kern_return_t +S_memory_object_data_supply (mach_port_t memory_control, + vm_offset_t offset, vm_offset_t data, + mach_msg_type_number_t dataCnt, + vm_prot_t lock_value, boolean_t precious, + mach_port_t reply_to, + mach_msg_type_name_t reply_toPoly) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_ready */ +kern_return_t +S_memory_object_ready (mach_port_t memory_control, boolean_t may_cache, + memory_object_copy_strategy_t copy_strategy) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* SimpleRoutine memory_object_change_attributes */ +kern_return_t +S_memory_object_change_attributes (mach_port_t memory_control, + boolean_t may_cache, + memory_object_copy_strategy_t copy_strategy, + mach_port_t reply_to, + mach_msg_type_name_t reply_toPoly) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +///////////////////////RPCs related to emulation///////////////////// +//////////////////////subhurd doesn't support it.//////////////////// + +/* Routine task_get_emulation_vector */ +kern_return_t +S_task_get_emulation_vector (mach_port_t task, int *vector_start, + emulation_vector_t *emulation_vector, + mach_msg_type_number_t *emulation_vectorCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine task_set_emulation_vector */ +kern_return_t +S_task_set_emulation_vector (mach_port_t task, int vector_start, + emulation_vector_t emulation_vector, + mach_msg_type_number_t emulation_vectorCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_task_get_emulation_vector */ +kern_return_t +S_xxx_task_get_emulation_vector (mach_port_t task, int *vector_start, + emulation_vector_t emulation_vector, + mach_msg_type_number_t *emulation_vectorCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine xxx_task_set_emulation_vector */ +kern_return_t +S_xxx_task_set_emulation_vector (mach_port_t task, int vector_start, + emulation_vector_t emulation_vector, + mach_msg_type_number_t emulation_vectorCnt) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} + +/* Routine task_set_emulation */ +kern_return_t +S_task_set_emulation (mach_port_t target_port, + vm_address_t routine_entry_pt, int routine_number) +{ + debug (""); + assert (0); + return EOPNOTSUPP; +} |