void
mach_init_doit(void)
{
// Initialize cached mach ports defined in mach_init.h
mach_task_self_ = task_self_trap();
_task_reply_port = mach_reply_port();
if (vm_kernel_page_shift == 0) {
#ifdef _COMM_PAGE_KERNEL_PAGE_SHIFT
vm_kernel_page_shift = *(uint8_t*) _COMM_PAGE_KERNEL_PAGE_SHIFT;
vm_kernel_page_size = 1 << vm_kernel_page_shift;
vm_kernel_page_mask = vm_kernel_page_size - 1;
#else
vm_kernel_page_size = PAGE_SIZE;
vm_kernel_page_mask = PAGE_MASK;
vm_kernel_page_shift = PAGE_SHIFT;
#endif /* _COMM_PAGE_KERNEL_PAGE_SHIFT */
}
if (vm_page_shift == 0) {
vm_page_shift = vm_kernel_page_shift;
vm_page_size = 1 << vm_page_shift;
vm_page_mask = vm_page_size - 1;
}
_init_cpu_capabilities();
_pthread_set_self(0);
}
/* Initialize Mach global data.
Should be called early in main(). */
void VG_(mach_init)(void)
{
reply = 0;
mach_task_self_ = task_self_trap();
// GrP fixme host_page_size(host_self_trap(), &vm_page_size);
vm_page_size = 4096;
}
void VG_(mach_init)(void)
{
reply = 0;
mach_task_self_ = task_self_trap();
vm_page_size = 4096;
}
int
mach_init_doit(bool forkchild)
{
/*
* Get the important ports into the cached values,
* as required by "mach_init.h".
*/
mach_task_self_ = task_self_trap();
/*
* Initialize the single mig reply port
*/
_pthread_set_self(0);
_mig_init(0);
#if WE_REALLY_NEED_THIS_GDB_HACK
/*
* Check to see if GDB wants us to stop
*/
{
task_user_data_data_t user_data;
mach_msg_type_number_t user_data_count = TASK_USER_DATA_COUNT;
user_data.user_data = 0;
(void)task_info(mach_task_self_, TASK_USER_DATA,
(task_info_t)&user_data, &user_data_count);
#define MACH_GDB_RUN_MAGIC_NUMBER 1
#ifdef MACH_GDB_RUN_MAGIC_NUMBER
/* This magic number is set in mach-aware gdb
* for RUN command to allow us to suspend user's
* executable (linked with this libmach!)
* with the code below.
* This hack should disappear when gdb improves.
*/
if ((int)user_data.user_data == MACH_GDB_RUN_MAGIC_NUMBER) {
kern_return_t ret;
user_data.user_data = 0;
ret = task_suspend(mach_task_self_);
if (ret != KERN_SUCCESS) {
while (1) {
(void)task_terminate(mach_task_self_);
}
}
}
#undef MACH_GDB_RUN_MAGIC_NUMBER
#endif /* MACH_GDB_RUN_MAGIC_NUMBER */
}
#endif /* WE_REALLY_NEED_THIS_GDB_HACK */
return 0;
}
int main(){
mach_port_t boot_port;
mach_port_t server_port;
mach_port_t task_self_port = task_self_trap();
kern_return_t result;
receive_message_t received_msg;
send_message_t sent_msg;
mach_msg_header_t* mach_hdr;
char print_buffer[1024];
str_mach_port_name(task_self_port, print_buffer, 1024);
printf("Task self port: %s\n", print_buffer);
/* Get the bootstrap port for the current login context. */
result = task_get_bootstrap_port(task_self_port, &boot_port);
ERR_EXIT(result, "task_get_bootstrap_port failed.");
str_mach_port_name(boot_port, print_buffer, 1024);
printf("Bootstrap port: %s\n", print_buffer);
/* check in our service directly. No need for resgister etc. */
result = bootstrap_check_in(boot_port,
SERVER_NAME,
&server_port);
ERR_EXIT(result, "Bootstrap Checkin Failed.\n");
str_mach_port_name(server_port, print_buffer, 1024);
printf("Server port: %s\n", print_buffer);
/* prepare for doing the real work. */
do {
mach_hdr = &(received_msg.msg_header);
mach_hdr->msgh_id = MULTIPLEX_ID;
mach_hdr->msgh_local_port = MACH_PORT_NULL;
mach_hdr->msgh_remote_port = MACH_PORT_NULL;
mach_hdr->msgh_size = sizeof(received_msg);
mach_hdr->msgh_bits = 0;
result = mach_msg(mach_hdr,
MACH_RCV_MSG,
0,
mach_hdr->msgh_size,
server_port,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if(result != KERN_SUCCESS){
fprintf(stderr, "mach_msg(receive) failed. Error: %s\n",
mach_error_string(result));
print_mach_msg_header(stderr, mach_hdr);
continue;
}
fprintf(stdout, "**** Received message with header:\n");
print_mach_msg_header(stdout, mach_hdr);
enumerate_ports_with_status(stdout);
// Use LLDB to insert the above statement to find out
// all the available ports in the process.
reverse(received_msg.response, sent_msg.request);
mach_hdr=&(sent_msg.msg_header);
mach_hdr->msgh_id = MULTIPLEX_ID;
mach_hdr->msgh_remote_port = received_msg.msg_header.msgh_remote_port;
mach_hdr->msgh_local_port = MACH_PORT_NULL;
mach_hdr->msgh_bits = received_msg.msg_header.msgh_bits;
mach_hdr->msgh_size = sizeof(sent_msg);
fprintf(stdout, "**** Sending response with header:\n");
print_mach_msg_header(stdout, mach_hdr);
fprintf(stdout, "\n\nList of ports and their status:\n");
result = mach_msg(mach_hdr,
MACH_SEND_MSG,
mach_hdr->msgh_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if(result != KERN_SUCCESS){
fprintf(stderr, "mach_msg(send) failed. Error: %s\n",
mach_error_string(result));
continue;
}
fprintf(stdout, "Successfully sent the message.\n");
} while (1);
return 0;
}
