X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/43866e378188c25dd1e2208016ab3cbeb086ae6c..f427ee49d309d8fc33ebf3042c3a775f2f530ded:/osfmk/kern/ipc_sync.c diff --git a/osfmk/kern/ipc_sync.c b/osfmk/kern/ipc_sync.c index 37ced9071..643c38fbb 100644 --- a/osfmk/kern/ipc_sync.c +++ b/osfmk/kern/ipc_sync.c @@ -1,17 +1,20 @@ /* * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ - * - * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. - * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * * 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. - * + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * * 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, @@ -19,12 +22,12 @@ * 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@ + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * @OSF_COPYRIGHT@ - * + * */ #include @@ -34,18 +37,26 @@ #include #include #include +#include #include #include #include #include +/* + * Routine: port_name_to_semaphore + * Purpose: + * Convert from a port name in the current space to a semaphore. + * Produces a semaphore ref, which may be null. + * Conditions: + * Nothing locked. + */ kern_return_t port_name_to_semaphore( - mach_port_name_t name, - semaphore_t *semaphorep) + mach_port_name_t name, + semaphore_t *semaphorep) { - semaphore_t semaphore; ipc_port_t kern_port; kern_return_t kr; @@ -53,9 +64,8 @@ port_name_to_semaphore( *semaphorep = SEMAPHORE_NULL; return KERN_INVALID_NAME; } - - kr = ipc_object_translate(current_space(), name, MACH_PORT_RIGHT_SEND, - (ipc_object_t *) &kern_port); + + kr = ipc_port_translate_send(current_space(), name, &kern_port); if (kr != KERN_SUCCESS) { *semaphorep = SEMAPHORE_NULL; return kr; @@ -63,79 +73,113 @@ port_name_to_semaphore( /* have the port locked */ assert(IP_VALID(kern_port)); - if (!ip_active(kern_port) || (ip_kotype(kern_port) != IKOT_SEMAPHORE)) { - ip_unlock(kern_port); - *semaphorep = SEMAPHORE_NULL; - return KERN_INVALID_ARGUMENT; + *semaphorep = convert_port_to_semaphore(kern_port); + if (*semaphorep == SEMAPHORE_NULL) { + /* the port is valid, but doesn't denote a semaphore */ + kr = KERN_INVALID_CAPABILITY; + } else { + kr = KERN_SUCCESS; } - - semaphore = (semaphore_t) kern_port->ip_kobject; - assert(semaphore != SEMAPHORE_NULL); - semaphore_reference(semaphore); ip_unlock(kern_port); - *semaphorep = semaphore; - return KERN_SUCCESS; + return kr; } - + +/* + * Routine: convert_port_to_semaphore + * Purpose: + * Convert from a port to a semaphore. + * Doesn't consume the port [send-right] ref; + * produces a semaphore ref, which may be null. + * Conditions: + * Caller has a send-right reference to port. + * Port may or may not be locked. + */ semaphore_t -convert_port_to_semaphore (ipc_port_t port) +convert_port_to_semaphore(ipc_port_t port) { - semaphore_t semaphore = SEMAPHORE_NULL; - - if (IP_VALID (port)) { - ip_lock(port); - if (ip_active(port) && (ip_kotype(port) == IKOT_SEMAPHORE)) { - semaphore = (semaphore_t) port->ip_kobject; + if (IP_VALID(port)) { + semaphore_t semaphore; + + /* + * No need to lock because we have a reference on the + * port, and if it is a true semaphore port, that reference + * keeps the semaphore bound to the port (and active). + */ + if (ip_kotype(port) == IKOT_SEMAPHORE) { + require_ip_active(port); + semaphore = (semaphore_t) ip_get_kobject(port); semaphore_reference(semaphore); + return semaphore; } - ip_unlock(port); } - - return (semaphore); + return SEMAPHORE_NULL; } +/* + * Routine: convert_semaphore_to_port + * Purpose: + * Convert a semaphore reference to a send right to a + * semaphore port. + * + * Consumes the semaphore reference. If the semaphore + * port currently has no send rights (or doesn't exist + * yet), the reference is donated to the port to represent + * all extant send rights collectively. + */ ipc_port_t -convert_semaphore_to_port (semaphore_t semaphore) +convert_semaphore_to_port(semaphore_t semaphore) { - ipc_port_t port; - - if (semaphore != SEMAPHORE_NULL) - port = ipc_port_make_send(semaphore->port); - else - port = IP_NULL; + if (semaphore == SEMAPHORE_NULL) { + return IP_NULL; + } - return (port); + /* + * make a send right and donate our reference for + * semaphore_notify if this is the first send right + */ + if (!ipc_kobject_make_send_lazy_alloc_port(&semaphore->port, + (ipc_kobject_t) semaphore, IKOT_SEMAPHORE, false, 0)) { + semaphore_dereference(semaphore); + } + return semaphore->port; } -lock_set_t -convert_port_to_lock_set (ipc_port_t port) +/* + * Routine: semaphore_notify + * Purpose: + * Called whenever the Mach port system detects no-senders + * on the semaphore port. + * + * When a send-right is first created, a no-senders + * notification is armed (and a semaphore reference is donated). + * + * A no-senders notification will be posted when no one else holds a + * send-right (reference) to the semaphore's port. This notification function + * will consume the semaphore reference donated to the extant collection of + * send-rights. + */ +void +semaphore_notify(mach_msg_header_t *msg) { - lock_set_t lock_set = LOCK_SET_NULL; + mach_no_senders_notification_t *notification = (void *)msg; + ipc_port_t port = notification->not_header.msgh_remote_port; - if (IP_VALID (port)) { - ip_lock(port); - if (ip_active(port) && (ip_kotype(port) == IKOT_LOCK_SET)) { - lock_set = (lock_set_t) port->ip_kobject; - lock_set_reference(lock_set); - } - ip_unlock(port); - } + require_ip_active(port); + assert(IKOT_SEMAPHORE == ip_kotype(port)); - return (lock_set); + semaphore_dereference((semaphore_t) ip_get_kobject(port)); } -ipc_port_t -convert_lock_set_to_port (lock_set_t lock_set) +lock_set_t +convert_port_to_lock_set(__unused ipc_port_t port) { - ipc_port_t port; - - if (lock_set != LOCK_SET_NULL) - port = ipc_port_make_send(lock_set->port); - else - port = IP_NULL; - - return (port); + return LOCK_SET_NULL; } +ipc_port_t +convert_lock_set_to_port(__unused lock_set_t lock_set) +{ + return IP_NULL; +}