kern_return_t
mach_port_extract_member(
ipc_space_t space,
mach_port_name_t name,
mach_port_name_t psname)
{
mach_port_name_t oldname;
ipc_object_t psobj;
ipc_object_t obj;
kern_return_t kr;
if (space == IS_NULL)
return KERN_INVALID_TASK;
if (!MACH_PORT_VALID(name) || !MACH_PORT_VALID(psname))
return KERN_INVALID_RIGHT;
kr = ipc_object_translate_two(space,
name, MACH_PORT_RIGHT_RECEIVE, &obj,
psname, MACH_PORT_RIGHT_PORT_SET, &psobj);
if (kr != KERN_SUCCESS)
return kr;
/* obj and psobj are both locked (and were locked in that order) */
assert(psobj != IO_NULL);
assert(obj != IO_NULL);
kr = ipc_pset_remove((ipc_pset_t)psobj, (ipc_port_t)obj);
io_unlock(psobj);
io_unlock(obj);
return kr;
}
void
ipc_port_clear_receiver(
ipc_port_t port)
{
ipc_pset_t pset;
assert(ip_active(port));
pset = port->ip_pset;
if (pset != IPS_NULL) {
ips_lock(pset);
ipc_pset_remove(pset, port);
ips_unlock(pset);
ips_release(pset);
}
ipc_port_changed(port, MACH_RCV_PORT_DIED);
ipc_port_set_mscount(port, 0);
port->ip_seqno = 0;
}
void
ipc_port_set_seqno(
ipc_port_t port,
mach_port_seqno_t seqno)
{
if (port->ip_pset != IPS_NULL) {
ipc_pset_t pset = port->ip_pset;
ips_lock(pset);
if (!ips_active(pset)) {
ipc_pset_remove(pset, port);
ips_unlock(pset);
ips_release(pset);
goto no_port_set;
} else {
port->ip_seqno = seqno;
}
} else {
no_port_set:
port->ip_seqno = seqno;
}
}
kern_return_t
ipc_pset_move(
ipc_space_t space,
ipc_port_t port,
ipc_pset_t nset)
{
ipc_pset_t oset;
/*
* While we've got the space locked, it holds refs for
* the port and nset (because of the entries). Also,
* they must be alive. While we've got port locked, it
* holds a ref for oset, which might not be alive.
*/
ip_lock(port);
assert(ip_active(port));
oset = port->ip_pset;
if (oset == nset) {
/* the port is already in the new set: a noop */
is_read_unlock(space);
} else if (oset == IPS_NULL) {
/* just add port to the new set */
ips_lock(nset);
assert(ips_active(nset));
is_read_unlock(space);
ipc_pset_add(nset, port);
ips_unlock(nset);
} else if (nset == IPS_NULL) {
/* just remove port from the old set */
is_read_unlock(space);
ips_lock(oset);
ipc_pset_remove(oset, port);
if (ips_active(oset))
ips_unlock(oset);
else {
ips_check_unlock(oset);
oset = IPS_NULL; /* trigger KERN_NOT_IN_SET */
}
} else {
/* atomically move port from oset to nset */
if (oset < nset) {
ips_lock(oset);
ips_lock(nset);
} else {
ips_lock(nset);
ips_lock(oset);
}
is_read_unlock(space);
assert(ips_active(nset));
ipc_pset_remove(oset, port);
ipc_pset_add(nset, port);
ips_unlock(nset);
ips_check_unlock(oset); /* KERN_NOT_IN_SET not a possibility */
}
ip_unlock(port);
return (((nset == IPS_NULL) && (oset == IPS_NULL)) ?
KERN_NOT_IN_SET : KERN_SUCCESS);
}
mach_msg_return_t
ipc_mqueue_copyin(
ipc_space_t space,
mach_port_t name,
ipc_mqueue_t *mqueuep,
ipc_object_t *objectp)
{
ipc_entry_t entry;
ipc_entry_bits_t bits;
ipc_object_t object;
ipc_mqueue_t mqueue;
is_read_lock(space);
if (!space->is_active) {
is_read_unlock(space);
return MACH_RCV_INVALID_NAME;
}
entry = ipc_entry_lookup(space, name);
if (entry == IE_NULL) {
is_read_unlock(space);
return MACH_RCV_INVALID_NAME;
}
bits = entry->ie_bits;
object = entry->ie_object;
if (bits & MACH_PORT_TYPE_RECEIVE) {
ipc_port_t port;
ipc_pset_t pset;
port = (ipc_port_t) object;
assert(port != IP_NULL);
ip_lock(port);
assert(ip_active(port));
assert(port->ip_receiver_name == name);
assert(port->ip_receiver == space);
is_read_unlock(space);
pset = port->ip_pset;
if (pset != IPS_NULL) {
ips_lock(pset);
if (ips_active(pset)) {
ips_unlock(pset);
ip_unlock(port);
return MACH_RCV_IN_SET;
}
ipc_pset_remove(pset, port);
ips_check_unlock(pset);
assert(port->ip_pset == IPS_NULL);
}
mqueue = &port->ip_messages;
} else if (bits & MACH_PORT_TYPE_PORT_SET) {
ipc_pset_t pset;
pset = (ipc_pset_t) object;
assert(pset != IPS_NULL);
ips_lock(pset);
assert(ips_active(pset));
assert(pset->ips_local_name == name);
is_read_unlock(space);
mqueue = &pset->ips_messages;
} else {
is_read_unlock(space);
return MACH_RCV_INVALID_NAME;
}
/*
* At this point, the object is locked and active,
* the space is unlocked, and mqueue is initialized.
*/
io_reference(object);
imq_lock(mqueue);
io_unlock(object);
*objectp = object;
*mqueuep = mqueue;
return MACH_MSG_SUCCESS;
}
