static void
bootstrap_exec_compat(void *e)
{
task_t bootstrap_task;
thread_t bootstrap_thread;
/*
* Create the bootstrap task.
*/
(void) task_create(TASK_NULL, FALSE, &bootstrap_task);
(void) thread_create(bootstrap_task, &bootstrap_thread);
/*
* Insert send rights to the master host and device ports.
*/
boot_host_port =
task_insert_send_right(bootstrap_task,
ipc_port_make_send(realhost.host_priv_self));
boot_device_port =
task_insert_send_right(bootstrap_task,
ipc_port_make_send(master_device_port));
/*
* Start the bootstrap thread.
*/
bootstrap_thread->saved.other = e;
thread_start(bootstrap_thread, user_bootstrap_compat);
(void) thread_resume(bootstrap_thread);
}
void ipc_host_init(void)
{
ipc_port_t port;
int i;
lck_mtx_init(&realhost.lock, &host_notify_lock_grp, &host_notify_lock_attr);
/*
* Allocate and set up the two host ports.
*/
port = ipc_port_alloc_kernel();
if (port == IP_NULL)
panic("ipc_host_init");
ipc_kobject_set(port, (ipc_kobject_t) &realhost, IKOT_HOST_SECURITY);
kernel_set_special_port(&realhost, HOST_SECURITY_PORT,
ipc_port_make_send(port));
port = ipc_port_alloc_kernel();
if (port == IP_NULL)
panic("ipc_host_init");
ipc_kobject_set(port, (ipc_kobject_t) &realhost, IKOT_HOST);
kernel_set_special_port(&realhost, HOST_PORT,
ipc_port_make_send(port));
port = ipc_port_alloc_kernel();
if (port == IP_NULL)
panic("ipc_host_init");
ipc_kobject_set(port, (ipc_kobject_t) &realhost, IKOT_HOST_PRIV);
kernel_set_special_port(&realhost, HOST_PRIV_PORT,
ipc_port_make_send(port));
/* the rest of the special ports will be set up later */
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
realhost.exc_actions[i].port = IP_NULL;
}/* for */
/*
* Set up ipc for default processor set.
*/
ipc_pset_init(&pset0);
ipc_pset_enable(&pset0);
/*
* And for master processor
*/
ipc_processor_init(master_processor);
ipc_processor_enable(master_processor);
}
/*
* fileport_alloc
*
* Description: Obtain a send right for the given fileglob, which must be
* referenced.
*
* Parameters: fg A fileglob.
*
* Returns: Port of type IKOT_FILEPORT with fileglob set as its kobject.
* Port is returned with a send right.
*/
ipc_port_t
fileport_alloc(struct fileglob *fg)
{
ipc_port_t fileport;
ipc_port_t sendport;
ipc_port_t notifyport;
fileport = ipc_port_alloc_kernel();
if (fileport == IP_NULL) {
goto out;
}
ipc_kobject_set(fileport, (ipc_kobject_t)fg, IKOT_FILEPORT);
notifyport = ipc_port_make_sonce(fileport);
ip_lock(fileport); /* unlocked by ipc_port_nsrequest */
ipc_port_nsrequest(fileport, 1, notifyport, ¬ifyport);
sendport = ipc_port_make_send(fileport);
if (!IP_VALID(sendport)) {
panic("Couldn't allocate send right for fileport!\n");
}
out:
return fileport;
}
/* Return a send right associated with network device ND. */
static ipc_port_t
dev_to_port (void *nd)
{
return (nd
? ipc_port_make_send (((struct net_data *) nd)->port)
: IP_NULL);
}
void
ipc_task_reset(
task_t task)
{
ipc_port_t old_kport, new_kport;
ipc_port_t old_sself;
ipc_port_t old_exc_actions[EXC_TYPES_COUNT];
int i;
new_kport = ipc_port_alloc_kernel();
if (new_kport == IP_NULL)
panic("ipc_task_reset");
itk_lock(task);
old_kport = task->itk_self;
if (old_kport == IP_NULL) {
/* the task is already terminated (can this happen?) */
itk_unlock(task);
ipc_port_dealloc_kernel(new_kport);
return;
}
task->itk_self = new_kport;
old_sself = task->itk_sself;
task->itk_sself = ipc_port_make_send(new_kport);
ipc_kobject_set(old_kport, IKO_NULL, IKOT_NONE);
ipc_kobject_set(new_kport, (ipc_kobject_t) task, IKOT_TASK);
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
if (!task->exc_actions[i].privileged) {
old_exc_actions[i] = task->exc_actions[i].port;
task->exc_actions[i].port = IP_NULL;
} else {
old_exc_actions[i] = IP_NULL;
}
}/* for */
if (IP_VALID(task->itk_debug_control)) {
ipc_port_release_send(task->itk_debug_control);
}
task->itk_debug_control = IP_NULL;
itk_unlock(task);
/* release the naked send rights */
if (IP_VALID(old_sself))
ipc_port_release_send(old_sself);
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
if (IP_VALID(old_exc_actions[i])) {
ipc_port_release_send(old_exc_actions[i]);
}
}/* for */
/* destroy the kernel port */
ipc_port_dealloc_kernel(old_kport);
}
int
boot_script_insert_right (struct cmd *cmd, mach_port_t port, mach_port_t *name)
{
*name = task_insert_send_right (cmd->task,
ipc_port_make_send((ipc_port_t) port));
return 0;
}
EXTERN mach_port_name_t
iokit_make_send_right( task_t task, io_object_t obj, ipc_kobject_type_t type )
{
ipc_port_t port;
ipc_port_t sendPort;
mach_port_name_t name = 0;
if( obj == NULL)
return MACH_PORT_NULL;
port = iokit_port_for_object( obj, type );
if( port) {
sendPort = ipc_port_make_send( port);
iokit_release_port( port );
} else
sendPort = IP_NULL;
if (IP_VALID( sendPort )) {
kern_return_t kr;
kr = ipc_object_copyout( task->itk_space, (ipc_object_t) sendPort,
MACH_MSG_TYPE_PORT_SEND, TRUE, &name);
if ( kr != KERN_SUCCESS) {
ipc_port_release_send( sendPort );
name = MACH_PORT_NULL;
}
} else if ( sendPort == IP_NULL)
name = MACH_PORT_NULL;
else if ( sendPort == IP_DEAD)
name = MACH_PORT_DEAD;
iokit_remove_reference( obj );
return( name );
}
mach_port_t
mach_host_self(void)
{
ipc_port_t sright;
sright = ipc_port_make_send(realhost.host_self);
return ipc_port_copyout_send(sright, current_space());
}
/*
* Inititalize the ledger facility
*/
void ledger_init(void)
{
/*
* Allocate the root ledgers; wired and paged.
*/
root_wired_ledger = ledger_allocate(LEDGER_ITEM_INFINITY,
LEDGER_NULL, LEDGER_NULL);
if (root_wired_ledger == LEDGER_NULL)
panic("can't allocate root (wired) ledger");
ipc_port_make_send(root_wired_ledger->ledger_self);
root_paged_ledger = ledger_allocate(LEDGER_ITEM_INFINITY,
LEDGER_NULL, LEDGER_NULL);
if (root_paged_ledger == LEDGER_NULL)
panic("can't allocate root (paged) ledger");
ipc_port_make_send(root_paged_ledger->ledger_self);
}
ipc_port_t
convert_processor_to_port(processor_t processor)
{
ipc_port_t port;
port = ipc_port_make_send(processor->processor_self);
return port;
}
/*
* Routine: convert_clock_ctrl_to_port
* Purpose:
* Convert from a clock to a port.
* Produces a naked send right which may be invalid.
* Conditions:
* Nothing locked.
*/
ipc_port_t
convert_clock_ctrl_to_port(
clock_t clock)
{
ipc_port_t port;
port = ipc_port_make_send(clock->cl_control);
return (port);
}
/*
* Routine: convert_clock_to_port
* Purpose:
* Convert from a clock to a port.
* Produces a naked send right which may be invalid.
* Conditions:
* Nothing locked.
*/
ipc_port_t
convert_clock_to_port(
clock_t clock)
{
ipc_port_t port;
port = ipc_port_make_send(clock->cl_service);
return (port);
}
ipc_port_t
convert_host_to_port(
host_t host)
{
ipc_port_t port;
port = ipc_port_make_send(host->host_self);
return port;
}
ipc_port_t
convert_ledger_to_port(
ledger_t ledger)
{
ipc_port_t port;
port = ipc_port_make_send(ledger->ledger_self);
return port;
}
ipc_port_t
convert_processor_to_port(
processor_t processor)
{
ipc_port_t port = processor->processor_self;
if (port != IP_NULL)
port = ipc_port_make_send(port);
return port;
}
kern_return_t
task_get_special_port(
task_t task,
int which,
ipc_port_t *portp)
{
ipc_port_t port;
if (task == TASK_NULL)
return KERN_INVALID_ARGUMENT;
itk_lock(task);
if (task->itk_self == IP_NULL) {
itk_unlock(task);
return KERN_FAILURE;
}
switch (which) {
case TASK_KERNEL_PORT:
port = ipc_port_copy_send(task->itk_sself);
break;
case TASK_NAME_PORT:
port = ipc_port_make_send(task->itk_nself);
break;
case TASK_HOST_PORT:
port = ipc_port_copy_send(task->itk_host);
break;
case TASK_BOOTSTRAP_PORT:
port = ipc_port_copy_send(task->itk_bootstrap);
break;
case TASK_SEATBELT_PORT:
port = ipc_port_copy_send(task->itk_seatbelt);
break;
case TASK_ACCESS_PORT:
port = ipc_port_copy_send(task->itk_task_access);
break;
case TASK_DEBUG_CONTROL_PORT:
port = ipc_port_copy_send(task->itk_debug_control);
break;
default:
itk_unlock(task);
return KERN_INVALID_ARGUMENT;
}
itk_unlock(task);
*portp = port;
return KERN_SUCCESS;
}
ipc_port_t
convert_pset_name_to_port(
processor_set_name_t pset)
{
ipc_port_t port = pset->pset_name_self;
if (port != IP_NULL)
port = ipc_port_make_send(port);
return port;
}
/*
* Routine: convert_mig_object_to_port [interface]
* Purpose:
* Base implementation of MIG outtrans routine to convert from
* a mig object reference to a new send right on the object's
* port. The object reference is consumed.
* Returns:
* IP_NULL - Null MIG object supplied
* Otherwise, a newly made send right for the port
* Conditions:
* Nothing locked.
*/
ipc_port_t
convert_mig_object_to_port(
mig_object_t mig_object)
{
ipc_port_t port;
boolean_t deallocate = TRUE;
if (mig_object == MIG_OBJECT_NULL)
return IP_NULL;
port = mig_object->port;
while ((port == IP_NULL) ||
((port = ipc_port_make_send(port)) == IP_NULL)) {
ipc_port_t previous;
/*
* Either the port was never set up, or it was just
* deallocated out from under us by the no-senders
* processing. In either case, we must:
* Attempt to make one
* Arrange for no senders
* Try to atomically register it with the object
* Destroy it if we are raced.
*/
port = ipc_port_alloc_kernel();
ip_lock(port);
ipc_kobject_set_atomically(port,
(ipc_kobject_t) mig_object,
IKOT_MIG);
/* make a sonce right for the notification */
port->ip_sorights++;
ip_reference(port);
ipc_port_nsrequest(port, 1, port, &previous);
/* port unlocked */
assert(previous == IP_NULL);
if (OSCompareAndSwapPtr((void *)IP_NULL, (void *)port,
(void * volatile *)&mig_object->port)) {
deallocate = FALSE;
} else {
ipc_port_dealloc_kernel(port);
port = mig_object->port;
}
}
if (deallocate)
mig_object->pVtbl->Release((IMIGObject *)mig_object);
return (port);
}
ipc_port_t
convert_ledger_to_port(
ledger_t ledger)
{
ipc_port_t port;
if (ledger == LEDGER_NULL)
return IP_NULL;
port = ipc_port_make_send(ledger->ledger_self);
return port;
}
void
ipc_task_init(
task_t task,
task_t parent)
{
ipc_space_t space;
ipc_port_t kport;
kern_return_t kr;
int i;
kr = ipc_space_create(&space);
if (kr != KERN_SUCCESS)
panic("ipc_task_init");
kport = ipc_port_alloc_kernel();
if (kport == IP_NULL)
panic("ipc_task_init");
itk_lock_init(task);
task->itk_self = kport;
task->itk_sself = ipc_port_make_send(kport);
task->itk_space = space;
if (parent == TASK_NULL) {
task->itk_exception = IP_NULL;
task->itk_bootstrap = IP_NULL;
for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
task->itk_registered[i] = IP_NULL;
} else {
itk_lock(parent);
assert(parent->itk_self != IP_NULL);
/* inherit registered ports */
for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
task->itk_registered[i] =
ipc_port_copy_send(parent->itk_registered[i]);
/* inherit exception and bootstrap ports */
task->itk_exception =
ipc_port_copy_send(parent->itk_exception);
task->itk_bootstrap =
ipc_port_copy_send(parent->itk_bootstrap);
itk_unlock(parent);
}
}
ipc_port_t
convert_pset_name_to_port(
processor_set_t pset)
{
ipc_port_t port;
pset_lock(pset);
if (pset->active)
port = ipc_port_make_send(pset->pset_name_self);
else
port = IP_NULL;
pset_unlock(pset);
pset_deallocate(pset);
return port;
}
ipc_port_t
convert_task_name_to_port(
task_name_t task_name)
{
ipc_port_t port;
itk_lock(task_name);
if (task_name->itk_nself != IP_NULL)
port = ipc_port_make_send(task_name->itk_nself);
else
port = IP_NULL;
itk_unlock(task_name);
task_name_deallocate(task_name);
return port;
}
void
xmm_object_set(
ipc_port_t memory_object,
ipc_port_t xmm_object,
boolean_t make_copy)
{
assert(! IP_IS_REMOTE(xmm_object));
assert(ip_kotype(xmm_object) == IKOT_XMM_OBJECT);
assert(memory_object->ip_norma_xmm_object == IP_NULL);
memory_object->ip_norma_xmm_object = ipc_port_make_send(xmm_object);
if (make_copy) {
memory_object->ip_norma_xmm_object_refs = 1;
ipc_port_copy_send(xmm_object);
} else {
memory_object->ip_norma_xmm_object_refs = 0;
}
}
ipc_port_t
convert_thread_to_port(
thread_t thread)
{
ipc_port_t port;
thread_mtx_lock(thread);
if (thread->ith_self != IP_NULL)
port = ipc_port_make_send(thread->ith_self);
else
port = IP_NULL;
thread_mtx_unlock(thread);
thread_deallocate(thread);
return (port);
}
ipc_port_t
convert_processor_to_port(
processor_t processor)
{
ipc_port_t port;
spl_t s;
s = splsched();
processor_lock(processor);
if (processor->processor_self != IP_NULL)
port = ipc_port_make_send(processor->processor_self);
else
port = IP_NULL;
processor_unlock(processor);
splx(s);
return port;
}
IOReturn com_enkript_driver_Service::hello(task_t target)
{
EKDebugLog("hello task 0x%x", target);
kern_return_t ret = KERN_SUCCESS;
/* allocate receive port
*/
ret = ipc_port_alloc(get_task_ipcspace(current_task()), &exception_port_name, &exception_port);
EKDebugLog("ipc_port_alloc() ret=%d", ret);
if (ret) return kIOReturnError;
/* set task exception port
*/
ret = task_set_exception_ports(target, EXC_MASK_ALL, ipc_port_make_send(exception_port), EXCEPTION_DEFAULT, THREAD_STATE_NONE);
EKDebugLog("task_set_exception_ports() ret=%d", ret);
if (ret) return kIOReturnError;
/* create exception handler thread
*/
(void) kernel_thread(kernel_task, exception_handler);
return kIOReturnSuccess;
}
void
ipc_thread_init(thread_t thread)
{
ipc_port_t kport;
kport = ipc_port_alloc_kernel();
if (kport == IP_NULL)
panic("ipc_thread_init");
ipc_thread_links_init(thread);
ipc_kmsg_queue_init(&thread->ith_messages);
ith_lock_init(thread);
thread->ith_self = kport;
thread->ith_sself = ipc_port_make_send(kport);
thread->ith_exception = IP_NULL;
thread->ith_mig_reply = MACH_PORT_NULL;
thread->ith_rpc_reply = IP_NULL;
}
MIGEXTERN ipc_port_t
iokit_make_connect_port(
io_object_t obj )
{
ipc_port_t port;
ipc_port_t sendPort;
if( obj == NULL)
return IP_NULL;
port = iokit_port_for_object( obj, IKOT_IOKIT_CONNECT );
if( port) {
sendPort = ipc_port_make_send( port);
iokit_release_port( port );
} else
sendPort = IP_NULL;
iokit_remove_reference( obj );
return( sendPort);
}
void
ipc_thread_init(
thread_t thread)
{
ipc_port_t kport;
int i;
kport = ipc_port_alloc_kernel();
if (kport == IP_NULL)
panic("ipc_thread_init");
thread->ith_self = kport;
thread->ith_sself = ipc_port_make_send(kport);
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; ++i)
thread->exc_actions[i].port = IP_NULL;
ipc_kobject_set(kport, (ipc_kobject_t)thread, IKOT_THREAD);
ipc_kmsg_queue_init(&thread->ith_messages);
thread->ith_rpc_reply = IP_NULL;
}
void
ipc_thread_init(
thread_t thread)
{
ipc_port_t kport;
kport = ipc_port_alloc_kernel();
if (kport == IP_NULL)
panic("ipc_thread_init");
thread->ith_self = kport;
thread->ith_sself = ipc_port_make_send(kport);
thread->exc_actions = NULL;
ipc_kobject_set(kport, (ipc_kobject_t)thread, IKOT_THREAD);
#if IMPORTANCE_INHERITANCE
thread->ith_assertions = 0;
#endif
ipc_kmsg_queue_init(&thread->ith_messages);
thread->ith_rpc_reply = IP_NULL;
}
