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; }