/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
*
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
#include <mach/vm_map.h>
#include <kern/task.h>
#include <kern/counters.h>
-#include <kern/thread_act.h>
-#include <kern/thread_pool.h>
+#include <kern/thread.h>
+#include <kern/kalloc.h>
#include <mach/mach_port_server.h>
#include <vm/vm_map.h>
#include <vm/vm_kern.h>
mach_port_name_t name,
mach_port_name_t *names,
mach_port_type_t *types,
- ipc_entry_num_t *actualp,
- ipc_space_t space);
+ ipc_entry_num_t *actualp);
void mach_port_gst_helper(
ipc_pset_t pset,
mach_port_name_t name,
mach_port_name_t *names,
mach_port_type_t *types,
- ipc_entry_num_t *actualp,
- ipc_space_t space)
+ ipc_entry_num_t *actualp)
{
ipc_entry_bits_t bits;
ipc_port_request_index_t request;
mach_port_type_t **typesp,
mach_msg_type_number_t *typesCnt)
{
- ipc_entry_bits_t *capability;
ipc_tree_entry_t tentry;
ipc_entry_t table;
ipc_entry_num_t tsize;
}
size = size_needed;
- kr = vm_allocate(ipc_kernel_map, &addr1, size, TRUE);
+ kr = vm_allocate(ipc_kernel_map, &addr1, size, VM_FLAGS_ANYWHERE);
if (kr != KERN_SUCCESS)
return KERN_RESOURCE_SHORTAGE;
- kr = vm_allocate(ipc_kernel_map, &addr2, size, TRUE);
+ kr = vm_allocate(ipc_kernel_map, &addr2, size, VM_FLAGS_ANYWHERE);
if (kr != KERN_SUCCESS) {
kmem_free(ipc_kernel_map, addr1, size);
return KERN_RESOURCE_SHORTAGE;
/* can't fault while we hold locks */
- kr = vm_map_wire(ipc_kernel_map, addr1, addr1 + size,
- VM_PROT_READ|VM_PROT_WRITE, FALSE);
- assert(kr == KERN_SUCCESS);
+ kr = vm_map_wire(ipc_kernel_map, vm_map_trunc_page(addr1),
+ vm_map_round_page(addr1 + size),
+ VM_PROT_READ|VM_PROT_WRITE, FALSE);
+ if (kr != KERN_SUCCESS) {
+ kmem_free(ipc_kernel_map, addr1, size);
+ kmem_free(ipc_kernel_map, addr2, size);
+ return KERN_RESOURCE_SHORTAGE;
+ }
+
+ kr = vm_map_wire(ipc_kernel_map, vm_map_trunc_page(addr2),
+ vm_map_round_page(addr2 + size),
+ VM_PROT_READ|VM_PROT_WRITE, FALSE);
+ if (kr != KERN_SUCCESS) {
+ kmem_free(ipc_kernel_map, addr1, size);
+ kmem_free(ipc_kernel_map, addr2, size);
+ return KERN_RESOURCE_SHORTAGE;
+ }
- kr = vm_map_wire(ipc_kernel_map, addr2, addr2 + size,
- VM_PROT_READ|VM_PROT_WRITE, FALSE);
- assert(kr == KERN_SUCCESS);
}
/* space is read-locked and active */
name = MACH_PORT_MAKE(index, IE_BITS_GEN(bits));
mach_port_names_helper(timestamp, entry, name, names,
- types, &actual, space);
+ types, &actual);
}
}
assert(IE_BITS_TYPE(tentry->ite_bits) != MACH_PORT_TYPE_NONE);
mach_port_names_helper(timestamp, entry, name, names,
- types, &actual, space);
+ types, &actual);
}
ipc_splay_traverse_finish(&space->is_tree);
is_read_unlock(space);
* copied-in form. Free any unused memory.
*/
- kr = vm_map_unwire(ipc_kernel_map,
- addr1, addr1 + vm_size_used, FALSE);
+ kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(addr1),
+ vm_map_round_page(addr1 + vm_size_used), FALSE);
assert(kr == KERN_SUCCESS);
- kr = vm_map_unwire(ipc_kernel_map,
- addr2, addr2 + vm_size_used, FALSE);
+ kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(addr2),
+ vm_map_round_page(addr2 + vm_size_used), FALSE);
assert(kr == KERN_SUCCESS);
- kr = vm_map_copyin(ipc_kernel_map, addr1, size_used,
- TRUE, &memory1);
+ kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr1,
+ (vm_map_size_t)size_used, TRUE, &memory1);
assert(kr == KERN_SUCCESS);
- kr = vm_map_copyin(ipc_kernel_map, addr2, size_used,
- TRUE, &memory2);
+ kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr2,
+ (vm_map_size_t)size_used, TRUE, &memory2);
assert(kr == KERN_SUCCESS);
if (vm_size_used != size) {
if (!MACH_PORT_VALID(name))
return KERN_INVALID_VALUE;
- kr = mach_port_allocate_full (space, right, SUBSYSTEM_NULL,
+ kr = mach_port_allocate_full (space, right, MACH_PORT_NULL,
&qos, &name);
return (kr);
}
kern_return_t kr;
mach_port_qos_t qos = qos_template;
- kr = mach_port_allocate_full (space, right, SUBSYSTEM_NULL,
+ kr = mach_port_allocate_full (space, right, MACH_PORT_NULL,
&qos, namep);
return (kr);
}
{
kern_return_t kr;
- if (qosp->name == TRUE)
+ if (qosp->name)
return KERN_INVALID_ARGUMENT;
- kr = mach_port_allocate_full (space, right, SUBSYSTEM_NULL,
+ kr = mach_port_allocate_full (space, right, MACH_PORT_NULL,
qosp, namep);
return (kr);
}
-/*
- * Routine: mach_port_allocate_subsystem [kernel call]
- * Purpose:
- * Allocates a receive right in a space. Like
- * mach_port_allocate, except that the caller specifies an
- * RPC subsystem that is to be used to implement RPC's to the
- * port. When possible, allocate rpc subsystem ports without
- * nms, since within RPC ports are intended to be used for
- * identity only (i.e. nms is painful in the distributed case
- * and we don't need or want it for RPC anyway).
- * Conditions:
- * Nothing locked.
- * Returns:
- * KERN_SUCCESS The right is allocated.
- * KERN_INVALID_TASK The space is null.
- * KERN_INVALID_TASK The space is dead.
- * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
- * KERN_NO_SPACE No room in space for another right.
- * KERN_INVALID_ARGUMENT bogus subsystem
- */
-
-kern_return_t
-mach_port_allocate_subsystem(
- ipc_space_t space,
- subsystem_t subsystem,
- mach_port_name_t *namep)
-{
- kern_return_t kr;
- ipc_port_t port;
- mach_port_qos_t qos = qos_template;
-
- kr = mach_port_allocate_full (space,
- MACH_PORT_RIGHT_RECEIVE,
- subsystem, &qos, namep);
- return (kr);
-}
-
/*
* Routine: mach_port_allocate_full [kernel call]
* Purpose:
mach_port_allocate_full(
ipc_space_t space,
mach_port_right_t right,
- subsystem_t subsystem,
+ mach_port_t proto,
mach_port_qos_t *qosp,
mach_port_name_t *namep)
{
- ipc_kmsg_t kmsg;
+ ipc_kmsg_t kmsg = IKM_NULL;
kern_return_t kr;
if (space == IS_NULL)
return (KERN_INVALID_TASK);
+ if (proto != MACH_PORT_NULL)
+ return (KERN_INVALID_VALUE);
+
if (qosp->name) {
if (!MACH_PORT_VALID (*namep))
return (KERN_INVALID_VALUE);
return (KERN_FAILURE);
}
- if (subsystem != SUBSYSTEM_NULL) {
- if (right != MACH_PORT_RIGHT_RECEIVE)
- return (KERN_INVALID_VALUE);
- }
-
if (qosp->prealloc) {
mach_msg_size_t size = qosp->len + MAX_TRAILER_SIZE;
if (right != MACH_PORT_RIGHT_RECEIVE)
return (KERN_INVALID_VALUE);
- kmsg = (ipc_kmsg_t)kalloc(ikm_plus_overhead(size));
+ kmsg = (ipc_kmsg_t)ipc_kmsg_alloc(size);
if (kmsg == IKM_NULL)
return (KERN_RESOURCE_SHORTAGE);
- ikm_init(kmsg, size);
}
switch (right) {
else
kr = ipc_port_alloc(space, namep, &port);
if (kr == KERN_SUCCESS) {
- if (qosp->prealloc)
+ if (kmsg != IKM_NULL)
ipc_kmsg_set_prealloc(kmsg, port);
- if (subsystem != SUBSYSTEM_NULL) {
- port->ip_subsystem = &subsystem->user;
- subsystem_reference (subsystem);
- }
ip_unlock(port);
- } else if (qosp->prealloc)
+ } else if (kmsg != IKM_NULL)
ipc_kmsg_free(kmsg);
break;
}
mach_port_name_t *names,
ipc_entry_num_t *actualp)
{
- ipc_pset_t ip_pset;
mach_port_name_t name;
assert(port != IP_NULL);
mach_port_name_t *names;
ipc_pset_t pset;
- kr = vm_allocate(ipc_kernel_map, &addr, size, TRUE);
+ kr = vm_allocate(ipc_kernel_map, &addr, size, VM_FLAGS_ANYWHERE);
if (kr != KERN_SUCCESS)
return KERN_RESOURCE_SHORTAGE;
* copied-in form. Free any unused memory.
*/
- kr = vm_map_unwire(ipc_kernel_map,
- addr, addr + vm_size_used, FALSE);
+ kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(addr),
+ vm_map_round_page(addr + vm_size_used), FALSE);
assert(kr == KERN_SUCCESS);
- kr = vm_map_copyin(ipc_kernel_map, addr, size_used,
- TRUE, &memory);
+ kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr,
+ (vm_map_size_t)size_used, TRUE, &memory);
assert(kr == KERN_SUCCESS);
if (vm_size_used != size)
assert(nset != IPS_NULL);
}
ip_lock(port);
- ipc_pset_remove_all(port);
+ ipc_pset_remove_from_all(port);
if (nset != IPS_NULL) {
ips_lock(nset);
ipc_port_t *previousp)
{
kern_return_t kr;
- ipc_entry_t entry;
- ipc_port_t port;
-
if (space == IS_NULL)
return KERN_INVALID_TASK;
/*
* Requesting notifications on RPC ports is an error.
*/
- kr = ipc_right_lookup_write(space, name, &entry);
- if (kr != KERN_SUCCESS)
- return kr;
+ {
+ ipc_port_t port;
+ ipc_entry_t entry;
- port = (ipc_port_t) entry->ie_object;
+ kr = ipc_right_lookup_write(space, name, &entry);
+ if (kr != KERN_SUCCESS)
+ return kr;
- if (port->ip_subsystem != NULL) {
+ port = (ipc_port_t) entry->ie_object;
+
+ if (port->ip_subsystem != NULL) {
+ is_write_unlock(space);
+ panic("mach_port_request_notification: on RPC port!!");
+ return KERN_INVALID_CAPABILITY;
+ }
is_write_unlock(space);
- panic("mach_port_request_notification: on RPC port!!");
- return KERN_INVALID_CAPABILITY;
}
- is_write_unlock(space);
#endif /* NOTYET */
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;
return kr;
}
+/*
+ * task_set_port_space:
+ *
+ * Set port name space of task to specified size.
+ */
+kern_return_t
+task_set_port_space(
+ ipc_space_t space,
+ int table_entries)
+{
+ kern_return_t kr;
+
+ is_write_lock(space);
+ kr = ipc_entry_grow_table(space, table_entries);
+ if (kr == KERN_SUCCESS)
+ is_write_unlock(space);
+ return kr;
+}
+
projects / apple / xnu.git / blobdiff