#include <mach/message.h>
#include <mach/mach_traps.h>
#include <mach/mach_host_server.h>
#include <mach/host_priv_server.h>
#include <kern/host.h>
#include <kern/processor.h>
#include <kern/lock.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/ipc_host.h>
#include <kern/ipc_kobject.h>
#include <kern/misc_protos.h>
#include <kern/spl.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_space.h>
void
ipc_processor_terminate(
processor_t processor);
void
ipc_processor_disable(
processor_t processor);
boolean_t
ref_pset_port_locked(
ipc_port_t port, boolean_t matchn, processor_set_t *ppset);
void ipc_host_init(void)
{
ipc_port_t port;
int i;
mutex_init(&realhost.lock, 0);
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));
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
realhost.exc_actions[i].port = IP_NULL;
}
ipc_pset_init(&default_pset);
ipc_pset_enable(&default_pset);
ipc_processor_init(master_processor);
ipc_processor_enable(master_processor);
}
mach_port_name_t
host_self_trap(
__unused struct host_self_trap_args *args)
{
ipc_port_t sright;
mach_port_name_t name;
sright = ipc_port_copy_send(current_task()->itk_host);
name = ipc_port_copyout_send(sright, current_space());
return name;
}
void
ipc_processor_init(
processor_t processor)
{
ipc_port_t port;
port = ipc_port_alloc_kernel();
if (port == IP_NULL)
panic("ipc_processor_init");
processor->processor_self = port;
}
void
ipc_processor_enable(
processor_t processor)
{
ipc_port_t myport;
myport = processor->processor_self;
ipc_kobject_set(myport, (ipc_kobject_t) processor, IKOT_PROCESSOR);
}
void
ipc_processor_disable(
processor_t processor)
{
ipc_port_t myport;
myport = processor->processor_self;
if (myport == IP_NULL)
return;
ipc_kobject_set(myport, IKO_NULL, IKOT_NONE);
}
void
ipc_processor_terminate(
processor_t processor)
{
ipc_port_t myport;
spl_t s;
s = splsched();
processor_lock(processor);
myport = processor->processor_self;
if (myport == IP_NULL) {
processor_unlock(processor);
splx(s);
return;
}
processor->processor_self = IP_NULL;
processor_unlock(processor);
splx(s);
ipc_port_dealloc_kernel(myport);
}
void
ipc_pset_init(
processor_set_t pset)
{
ipc_port_t port;
port = ipc_port_alloc_kernel();
if (port == IP_NULL)
panic("ipc_pset_init");
pset->pset_self = port;
port = ipc_port_alloc_kernel();
if (port == IP_NULL)
panic("ipc_pset_init");
pset->pset_name_self = port;
}
void
ipc_pset_enable(
processor_set_t pset)
{
pset_lock(pset);
if (pset->active) {
ipc_kobject_set(pset->pset_self,
(ipc_kobject_t) pset, IKOT_PSET);
ipc_kobject_set(pset->pset_name_self,
(ipc_kobject_t) pset, IKOT_PSET_NAME);
pset->ref_count += 2;
}
pset_unlock(pset);
}
void
ipc_pset_disable(
processor_set_t pset)
{
ipc_kobject_set(pset->pset_self, IKO_NULL, IKOT_NONE);
ipc_kobject_set(pset->pset_name_self, IKO_NULL, IKOT_NONE);
pset->ref_count -= 2;
}
void
ipc_pset_terminate(
processor_set_t pset)
{
ipc_port_dealloc_kernel(pset->pset_self);
ipc_port_dealloc_kernel(pset->pset_name_self);
}
kern_return_t
processor_set_default(
host_t host,
processor_set_t *pset)
{
if (host == HOST_NULL)
return(KERN_INVALID_ARGUMENT);
*pset = &default_pset;
pset_reference(*pset);
return(KERN_SUCCESS);
}
host_t
convert_port_to_host(
ipc_port_t port)
{
host_t host = HOST_NULL;
if (IP_VALID(port)) {
ip_lock(port);
if (ip_active(port) &&
((ip_kotype(port) == IKOT_HOST) ||
(ip_kotype(port) == IKOT_HOST_PRIV)
))
host = (host_t) port->ip_kobject;
ip_unlock(port);
}
return host;
}
host_t
convert_port_to_host_priv(
ipc_port_t port)
{
host_t host = HOST_NULL;
if (IP_VALID(port)) {
ip_lock(port);
if (ip_active(port) &&
(ip_kotype(port) == IKOT_HOST_PRIV))
host = (host_t) port->ip_kobject;
ip_unlock(port);
}
return host;
}
processor_t
convert_port_to_processor(
ipc_port_t port)
{
processor_t processor = PROCESSOR_NULL;
if (IP_VALID(port)) {
ip_lock(port);
if (ip_active(port) &&
(ip_kotype(port) == IKOT_PROCESSOR))
processor = (processor_t) port->ip_kobject;
ip_unlock(port);
}
return processor;
}
processor_set_t
convert_port_to_pset(
ipc_port_t port)
{
boolean_t r;
processor_set_t pset = PROCESSOR_SET_NULL;
r = FALSE;
while (!r && IP_VALID(port)) {
ip_lock(port);
r = ref_pset_port_locked(port, FALSE, &pset);
}
return pset;
}
processor_set_name_t
convert_port_to_pset_name(
ipc_port_t port)
{
boolean_t r;
processor_set_t pset = PROCESSOR_SET_NULL;
r = FALSE;
while (!r && IP_VALID(port)) {
ip_lock(port);
r = ref_pset_port_locked(port, TRUE, &pset);
}
return pset;
}
boolean_t
ref_pset_port_locked(ipc_port_t port, boolean_t matchn, processor_set_t *ppset)
{
processor_set_t pset;
pset = PROCESSOR_SET_NULL;
if (ip_active(port) &&
((ip_kotype(port) == IKOT_PSET) ||
(matchn && (ip_kotype(port) == IKOT_PSET_NAME)))) {
pset = (processor_set_t) port->ip_kobject;
if (!pset_lock_try(pset)) {
ip_unlock(port);
mutex_pause();
return (FALSE);
}
pset->ref_count++;
pset_unlock(pset);
}
*ppset = pset;
ip_unlock(port);
return (TRUE);
}
ipc_port_t
convert_host_to_port(
host_t host)
{
ipc_port_t port;
host_get_host_port(host, &port);
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;
}
ipc_port_t
convert_pset_to_port(
processor_set_t pset)
{
ipc_port_t port;
pset_lock(pset);
if (pset->active)
port = ipc_port_make_send(pset->pset_self);
else
port = IP_NULL;
pset_unlock(pset);
pset_deallocate(pset);
return port;
}
ipc_port_t
convert_pset_name_to_port(
processor_set_name_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;
}
host_t
convert_port_to_host_security(
ipc_port_t port)
{
host_t host = HOST_NULL;
if (IP_VALID(port)) {
ip_lock(port);
if (ip_active(port) &&
(ip_kotype(port) == IKOT_HOST_SECURITY))
host = (host_t) port->ip_kobject;
ip_unlock(port);
}
return host;
}
kern_return_t
host_set_exception_ports(
host_priv_t host_priv,
exception_mask_t exception_mask,
ipc_port_t new_port,
exception_behavior_t new_behavior,
thread_state_flavor_t new_flavor)
{
register int i;
ipc_port_t old_port[EXC_TYPES_COUNT];
if (host_priv == HOST_PRIV_NULL) {
return KERN_INVALID_ARGUMENT;
}
assert(host_priv == &realhost);
if (exception_mask & ~EXC_MASK_ALL) {
return KERN_INVALID_ARGUMENT;
}
if (IP_VALID(new_port)) {
switch (new_behavior) {
case EXCEPTION_DEFAULT:
case EXCEPTION_STATE:
case EXCEPTION_STATE_IDENTITY:
break;
default:
return KERN_INVALID_ARGUMENT;
}
}
host_lock(host_priv);
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
if (exception_mask & (1 << i)) {
old_port[i] = host_priv->exc_actions[i].port;
host_priv->exc_actions[i].port =
ipc_port_copy_send(new_port);
host_priv->exc_actions[i].behavior = new_behavior;
host_priv->exc_actions[i].flavor = new_flavor;
} else
old_port[i] = IP_NULL;
}
host_unlock(host_priv);
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
if (IP_VALID(old_port[i]))
ipc_port_release_send(old_port[i]);
if (IP_VALID(new_port))
ipc_port_release_send(new_port);
return KERN_SUCCESS;
}
kern_return_t
host_get_exception_ports(
host_priv_t host_priv,
exception_mask_t exception_mask,
exception_mask_array_t masks,
mach_msg_type_number_t * CountCnt,
exception_port_array_t ports,
exception_behavior_array_t behaviors,
thread_state_flavor_array_t flavors )
{
unsigned int i, j, count;
if (host_priv == HOST_PRIV_NULL)
return KERN_INVALID_ARGUMENT;
if (exception_mask & ~EXC_MASK_ALL) {
return KERN_INVALID_ARGUMENT;
}
assert (host_priv == &realhost);
host_lock(host_priv);
count = 0;
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
if (exception_mask & (1 << i)) {
for (j = 0; j < count; j++) {
if (host_priv->exc_actions[i].port == ports[j] &&
host_priv->exc_actions[i].behavior == behaviors[j]
&& host_priv->exc_actions[i].flavor == flavors[j])
{
masks[j] |= (1 << i);
break;
}
}
if (j == count) {
masks[j] = (1 << i);
ports[j] =
ipc_port_copy_send(host_priv->exc_actions[i].port);
behaviors[j] = host_priv->exc_actions[i].behavior;
flavors[j] = host_priv->exc_actions[i].flavor;
count++;
if (count > *CountCnt) {
break;
}
}
}
}
host_unlock(host_priv);
*CountCnt = count;
return KERN_SUCCESS;
}
kern_return_t
host_swap_exception_ports(
host_priv_t host_priv,
exception_mask_t exception_mask,
ipc_port_t new_port,
exception_behavior_t new_behavior,
thread_state_flavor_t new_flavor,
exception_mask_array_t masks,
mach_msg_type_number_t * CountCnt,
exception_port_array_t ports,
exception_behavior_array_t behaviors,
thread_state_flavor_array_t flavors )
{
unsigned int i,
j,
count;
ipc_port_t old_port[EXC_TYPES_COUNT];
if (host_priv == HOST_PRIV_NULL)
return KERN_INVALID_ARGUMENT;
if (exception_mask & ~EXC_MASK_ALL) {
return KERN_INVALID_ARGUMENT;
}
if (IP_VALID(new_port)) {
switch (new_behavior) {
case EXCEPTION_DEFAULT:
case EXCEPTION_STATE:
case EXCEPTION_STATE_IDENTITY:
break;
default:
return KERN_INVALID_ARGUMENT;
}
}
host_lock(host_priv);
count = 0;
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++) {
if (exception_mask & (1 << i)) {
for (j = 0; j < count; j++) {
if (host_priv->exc_actions[i].port == ports[j] &&
host_priv->exc_actions[i].behavior == behaviors[j]
&& host_priv->exc_actions[i].flavor == flavors[j])
{
masks[j] |= (1 << i);
break;
}
}
if (j == count) {
masks[j] = (1 << i);
ports[j] =
ipc_port_copy_send(host_priv->exc_actions[i].port);
behaviors[j] = host_priv->exc_actions[i].behavior;
flavors[j] = host_priv->exc_actions[i].flavor;
count++;
}
old_port[i] = host_priv->exc_actions[i].port;
host_priv->exc_actions[i].port =
ipc_port_copy_send(new_port);
host_priv->exc_actions[i].behavior = new_behavior;
host_priv->exc_actions[i].flavor = new_flavor;
if (count > *CountCnt) {
break;
}
} else
old_port[i] = IP_NULL;
}
host_unlock(host_priv);
for (i = FIRST_EXCEPTION; i < EXC_TYPES_COUNT; i++)
if (IP_VALID(old_port[i]))
ipc_port_release_send(old_port[i]);
if (IP_VALID(new_port))
ipc_port_release_send(new_port);
*CountCnt = count;
return KERN_SUCCESS;
}