kern_return_t
mach_port_space_info(
ipc_space_t space,
ipc_info_space_t *infop,
ipc_info_name_array_t *tablep,
mach_msg_type_number_t *tableCntp,
ipc_info_tree_name_array_t *treep,
mach_msg_type_number_t *treeCntp)
{
ipc_info_name_t *table_info;
unsigned int table_potential, table_actual;
vm_offset_t table_addr;
vm_size_t table_size = 0; /* Suppress gcc warning */
ipc_info_tree_name_t *tree_info;
unsigned int tree_potential, tree_actual;
vm_offset_t tree_addr;
vm_size_t tree_size = 0; /* Suppress gcc warning */
ipc_tree_entry_t tentry;
ipc_entry_t table;
ipc_entry_num_t tsize;
mach_port_index_t index;
kern_return_t kr;
if (space == IS_NULL)
return KERN_INVALID_TASK;
/* start with in-line memory */
table_info = *tablep;
table_potential = *tableCntp;
tree_info = *treep;
tree_potential = *treeCntp;
for (;;) {
is_read_lock(space);
if (!space->is_active) {
is_read_unlock(space);
if (table_info != *tablep)
kmem_free(ipc_kernel_map,
table_addr, table_size);
if (tree_info != *treep)
kmem_free(ipc_kernel_map,
tree_addr, tree_size);
return KERN_INVALID_TASK;
}
table_actual = space->is_table_size;
tree_actual = space->is_tree_total;
if ((table_actual <= table_potential) &&
(tree_actual <= tree_potential))
break;
is_read_unlock(space);
if (table_actual > table_potential) {
if (table_info != *tablep)
kmem_free(ipc_kernel_map,
table_addr, table_size);
table_size = round_page(table_actual *
sizeof *table_info);
kr = kmem_alloc(ipc_kernel_map,
&table_addr, table_size);
if (kr != KERN_SUCCESS) {
if (tree_info != *treep)
kmem_free(ipc_kernel_map,
tree_addr, tree_size);
return KERN_RESOURCE_SHORTAGE;
}
table_info = (ipc_info_name_t *) table_addr;
table_potential = table_size/sizeof *table_info;
}
if (tree_actual > tree_potential) {
if (tree_info != *treep)
kmem_free(ipc_kernel_map,
tree_addr, tree_size);
tree_size = round_page(tree_actual *
sizeof *tree_info);
kr = kmem_alloc(ipc_kernel_map,
&tree_addr, tree_size);
if (kr != KERN_SUCCESS) {
if (table_info != *tablep)
kmem_free(ipc_kernel_map,
table_addr, table_size);
return KERN_RESOURCE_SHORTAGE;
}
tree_info = (ipc_info_tree_name_t *) tree_addr;
tree_potential = tree_size/sizeof *tree_info;
}
}
/* space is read-locked and active; we have enough wired memory */
infop->iis_genno_mask = MACH_PORT_NGEN(MACH_PORT_DEAD);
infop->iis_table_size = space->is_table_size;
infop->iis_table_next = space->is_table_next->its_size;
infop->iis_tree_size = space->is_tree_total;
infop->iis_tree_small = space->is_tree_small;
infop->iis_tree_hash = space->is_tree_hash;
table = space->is_table;
tsize = space->is_table_size;
for (index = 0; index < tsize; index++) {
ipc_info_name_t *iin = &table_info[index];
ipc_entry_t entry = &table[index];
ipc_entry_bits_t bits = entry->ie_bits;
iin->iin_name = MACH_PORT_MAKEB(index, bits);
iin->iin_collision = (bits & IE_BITS_COLLISION) ? TRUE : FALSE;
iin->iin_compat = FALSE;
iin->iin_marequest = (bits & IE_BITS_MAREQUEST) ? TRUE : FALSE;
iin->iin_type = IE_BITS_TYPE(bits);
iin->iin_urefs = IE_BITS_UREFS(bits);
iin->iin_object = (vm_offset_t) entry->ie_object;
iin->iin_next = entry->ie_next;
iin->iin_hash = entry->ie_index;
}
for (tentry = ipc_splay_traverse_start(&space->is_tree), index = 0;
tentry != ITE_NULL;
tentry = ipc_splay_traverse_next(&space->is_tree, FALSE)) {
ipc_info_tree_name_t *iitn = &tree_info[index++];
ipc_info_name_t *iin = &iitn->iitn_name;
ipc_entry_t entry = &tentry->ite_entry;
ipc_entry_bits_t bits = entry->ie_bits;
assert(IE_BITS_TYPE(bits) != MACH_PORT_TYPE_NONE);
iin->iin_name = tentry->ite_name;
iin->iin_collision = (bits & IE_BITS_COLLISION) ? TRUE : FALSE;
iin->iin_compat = FALSE;
iin->iin_marequest = (bits & IE_BITS_MAREQUEST) ? TRUE : FALSE;
iin->iin_type = IE_BITS_TYPE(bits);
iin->iin_urefs = IE_BITS_UREFS(bits);
iin->iin_object = (vm_offset_t) entry->ie_object;
iin->iin_next = entry->ie_next;
iin->iin_hash = entry->ie_index;
if (tentry->ite_lchild == ITE_NULL)
iitn->iitn_lchild = MACH_PORT_NULL;
else
iitn->iitn_lchild = tentry->ite_lchild->ite_name;
if (tentry->ite_rchild == ITE_NULL)
iitn->iitn_rchild = MACH_PORT_NULL;
else
iitn->iitn_rchild = tentry->ite_rchild->ite_name;
}
ipc_splay_traverse_finish(&space->is_tree);
is_read_unlock(space);
if (table_info == *tablep) {
/* data fit in-line; nothing to deallocate */
*tableCntp = table_actual;
} else if (table_actual == 0) {
kmem_free(ipc_kernel_map, table_addr, table_size);
*tableCntp = 0;
} else {
vm_size_t size_used, rsize_used;
vm_map_copy_t copy;
/* kmem_alloc doesn't zero memory */
size_used = table_actual * sizeof *table_info;
rsize_used = round_page(size_used);
if (rsize_used != table_size)
kmem_free(ipc_kernel_map,
table_addr + rsize_used,
table_size - rsize_used);
if (size_used != rsize_used)
memset((void *) (table_addr + size_used), 0,
rsize_used - size_used);
kr = vm_map_copyin(ipc_kernel_map, table_addr, rsize_used,
TRUE, ©);
assert(kr == KERN_SUCCESS);
*tablep = (ipc_info_name_t *) copy;
*tableCntp = table_actual;
}
if (tree_info == *treep) {
/* data fit in-line; nothing to deallocate */
*treeCntp = tree_actual;
} else if (tree_actual == 0) {
kmem_free(ipc_kernel_map, tree_addr, tree_size);
*treeCntp = 0;
} else {
vm_size_t size_used, rsize_used;
vm_map_copy_t copy;
/* kmem_alloc doesn't zero memory */
size_used = tree_actual * sizeof *tree_info;
rsize_used = round_page(size_used);
if (rsize_used != tree_size)
kmem_free(ipc_kernel_map,
tree_addr + rsize_used,
tree_size - rsize_used);
if (size_used != rsize_used)
memset((void *) (tree_addr + size_used), 0,
rsize_used - size_used);
kr = vm_map_copyin(ipc_kernel_map, tree_addr, rsize_used,
TRUE, ©);
assert(kr == KERN_SUCCESS);
*treep = (ipc_info_tree_name_t *) copy;
*treeCntp = tree_actual;
}
return KERN_SUCCESS;
}
void
ipc_space_destroy(
ipc_space_t space)
{
ipc_tree_entry_t tentry;
ipc_entry_t table;
ipc_entry_num_t size;
mach_port_index_t index;
boolean_t active;
assert(space != IS_NULL);
is_write_lock(space);
active = space->is_active;
space->is_active = FALSE;
is_write_unlock(space);
if (!active)
return;
/*
* If somebody is trying to grow the table,
* we must wait until they finish and figure
* out the space died.
*/
is_read_lock(space);
while (space->is_growing) {
assert_wait((event_t) space, FALSE);
is_read_unlock(space);
thread_block((void (*)(void)) 0);
is_read_lock(space);
}
is_read_unlock(space);
/*
* Now we can futz with it without having it locked.
*/
table = space->is_table;
size = space->is_table_size;
for (index = 0; index < size; index++) {
ipc_entry_t entry = &table[index];
mach_port_type_t type = IE_BITS_TYPE(entry->ie_bits);
if (type != MACH_PORT_TYPE_NONE) {
mach_port_t name =
MACH_PORT_MAKEB(index, entry->ie_bits);
ipc_right_clean(space, name, entry);
}
}
it_entries_free(space->is_table_next-1, table);
for (tentry = ipc_splay_traverse_start(&space->is_tree);
tentry != ITE_NULL;
tentry = ipc_splay_traverse_next(&space->is_tree, TRUE)) {
mach_port_type_t type = IE_BITS_TYPE(tentry->ite_bits);
mach_port_t name = tentry->ite_name;
assert(type != MACH_PORT_TYPE_NONE);
/* use object before ipc_right_clean releases ref */
if (type == MACH_PORT_TYPE_SEND)
ipc_hash_global_delete(space, tentry->ite_object,
name, tentry);
ipc_right_clean(space, name, &tentry->ite_entry);
}
ipc_splay_traverse_finish(&space->is_tree);
/*
* Because the space is now dead,
* we must release the "active" reference for it.
* Our caller still has his reference.
*/
is_release(space);
}
