[apple/xnu.git] / osfmk / kern / mk_timer.c

/*
 * Copyright (c) 2000 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 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.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 2000 Apple Computer, Inc.  All rights reserved.
 *
 * HISTORY
 *
 * 29 June 2000 (debo)
 *  Created.
 */

#include <mach/mach_types.h>
#include <mach/mach_port_server.h>

#include <mach/mk_timer.h>

#include <ipc/ipc_space.h>

#include <kern/mk_timer.h>
#include <kern/thread_call.h>

static zone_t		mk_timer_zone;

static mach_port_qos_t mk_timer_qos = {
	FALSE, TRUE, 0, sizeof (mk_timer_expire_msg_t)
};

static void	mk_timer_expire(
				void			*p0,
				void			*p1);

mach_port_name_t
mk_timer_create(void)
{
	mk_timer_t			timer;
	ipc_space_t			myspace = current_space();
	mach_port_name_t	name = MACH_PORT_NULL;
	ipc_port_t			port;
	kern_return_t		result;

	timer = (mk_timer_t)zalloc(mk_timer_zone);
	if (timer == NULL)
		return (MACH_PORT_NULL);

	result = mach_port_allocate_qos(myspace, MACH_PORT_RIGHT_RECEIVE,
														&mk_timer_qos, &name);
	if (result == KERN_SUCCESS)
		result = ipc_port_translate_receive(myspace, name, &port);

	if (result != KERN_SUCCESS) {
		zfree(mk_timer_zone, (vm_offset_t)timer);

		return (MACH_PORT_NULL);
	}

	simple_lock_init(&timer->lock, ETAP_MISC_TIMER);
	call_entry_setup(&timer->call_entry, mk_timer_expire, timer);
	timer->is_armed = timer->is_dead = FALSE;
	timer->active = 0;

	timer->port = port;
	ipc_kobject_set_atomically(port, (ipc_kobject_t)timer, IKOT_TIMER);

	port->ip_srights++;
	ip_reference(port);
	ip_unlock(port);

	return (name);
}

void
mk_timer_port_destroy(
	ipc_port_t			port)
{
	mk_timer_t			timer = NULL;

	ip_lock(port);
	if (ip_kotype(port) == IKOT_TIMER) {
		timer = (mk_timer_t)port->ip_kobject;
		assert(timer != NULL);
		ipc_kobject_set_atomically(port, IKO_NULL, IKOT_NONE);
		simple_lock(&timer->lock);
		assert(timer->port == port);
	}
	ip_unlock(port);

	if (timer != NULL) {
		if (thread_call_cancel(&timer->call_entry))
			timer->active--;
		timer->is_armed = FALSE;

		timer->is_dead = TRUE;
		if (timer->active == 0) {
			simple_unlock(&timer->lock);
			zfree(mk_timer_zone, (vm_offset_t)timer);

			ipc_port_release_send(port);
			return;
		}

		simple_unlock(&timer->lock);
	}
}

void
mk_timer_initialize(void)
{
	int			s = sizeof (mk_timer_data_t);

	assert(!(mk_timer_zone != NULL));

	mk_timer_zone = zinit(s, (4096 * s), (16 * s), "mk_timer");
}

static void
mk_timer_expire(
	void			*p0,
	void			*p1)
{
	uint64_t			time_of_posting;
	mk_timer_t			timer = p0;
	ipc_port_t			port;

	clock_get_uptime(&time_of_posting);

	simple_lock(&timer->lock);

	if (timer->active > 1) {
		timer->active--;
		simple_unlock(&timer->lock);
		return;
	}

	port = timer->port;
	assert(port != IP_NULL);

	while (		timer->is_armed										&&
				!thread_call_is_delayed(&timer->call_entry, NULL)		) {
		mk_timer_expire_msg_t		msg;

		timer->is_armed = FALSE;

		msg.time_of_arming = timer->time_of_arming;
		msg.armed_time = timer->call_entry.deadline;
		msg.time_of_posting = time_of_posting;

		simple_unlock(&timer->lock);

		msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
		msg.header.msgh_remote_port = port;
		msg.header.msgh_local_port = MACH_PORT_NULL;
		msg.header.msgh_reserved = msg.header.msgh_id = 0;

		(void) mach_msg_send_from_kernel(&msg.header, sizeof (msg));

		simple_lock(&timer->lock);
	}

	if (--timer->active == 0 && timer->is_dead) {
		simple_unlock(&timer->lock);
		zfree(mk_timer_zone, (vm_offset_t)timer);

		ipc_port_release_send(port);
		return;
	}

	simple_unlock(&timer->lock);
}

kern_return_t
mk_timer_destroy(
	mach_port_name_t	name)
{
	ipc_space_t			myspace = current_space();
	ipc_port_t			port;
	kern_return_t		result;

	result = ipc_port_translate_receive(myspace, name, &port);
	if (result != KERN_SUCCESS)
		return (result);

	if (ip_kotype(port) == IKOT_TIMER) {
		ip_unlock(port);
		result = mach_port_destroy(myspace, name);
	}
	else {
		ip_unlock(port);
		result = KERN_INVALID_ARGUMENT;
	}

	return (result);
}

kern_return_t
mk_timer_arm(
	mach_port_name_t	name,
	uint64_t			expire_time)
{
	uint64_t			time_of_arming;
	mk_timer_t			timer;
	ipc_space_t			myspace = current_space();
	ipc_port_t			port;
	kern_return_t		result;

	clock_get_uptime(&time_of_arming);

	result = ipc_port_translate_receive(myspace, name, &port);
	if (result != KERN_SUCCESS)
		return (result);

	if (ip_kotype(port) == IKOT_TIMER) {
		timer = (mk_timer_t)port->ip_kobject;
		assert(timer != NULL);
		simple_lock(&timer->lock);
		assert(timer->port == port);
		ip_unlock(port);

		timer->time_of_arming = time_of_arming;
		timer->is_armed = TRUE;

		if (!thread_call_enter_delayed(&timer->call_entry, expire_time))
			timer->active++;
		simple_unlock(&timer->lock);
	}
	else {
		ip_unlock(port);
		result = KERN_INVALID_ARGUMENT;
	}

	return (result);
}

kern_return_t
mk_timer_cancel(
	mach_port_name_t	name,
	uint64_t			*result_time)
{
	uint64_t			armed_time = 0;
	mk_timer_t			timer;
	ipc_space_t			myspace = current_space();
	ipc_port_t			port;
	kern_return_t		result;

	result = ipc_port_translate_receive(myspace, name, &port);
	if (result != KERN_SUCCESS)
		return (result);

	if (ip_kotype(port) == IKOT_TIMER) {
		timer = (mk_timer_t)port->ip_kobject;
		assert(timer != NULL);
		simple_lock(&timer->lock);
		assert(timer->port == port);
		ip_unlock(port);

		if (timer->is_armed) {
			armed_time = timer->call_entry.deadline;
			if (thread_call_cancel(&timer->call_entry))
				timer->active--;
			timer->is_armed = FALSE;
		}

		simple_unlock(&timer->lock);
	}
	else {
		ip_unlock(port);
		result = KERN_INVALID_ARGUMENT;
	}

	if (result == KERN_SUCCESS)
		if (	result_time	!= NULL										&&
				copyout((void *)&armed_time, (void *)result_time,
								sizeof (armed_time)) != 0					)
			result = KERN_FAILURE;

	return (result);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	24	*
	25	* HISTORY
	26	*
	27	* 29 June 2000 (debo)
	28	* Created.
	29	*/
	30
	31	#include <mach/mach_types.h>
	32	#include <mach/mach_port_server.h>
	33
	34	#include <mach/mk_timer.h>
	35
	36	#include <ipc/ipc_space.h>
	37
	38	#include <kern/mk_timer.h>
	39	#include <kern/thread_call.h>
	40
	41	static zone_t mk_timer_zone;
	42
	43	static mach_port_qos_t mk_timer_qos = {
	44	FALSE, TRUE, 0, sizeof (mk_timer_expire_msg_t)
	45	};
	46
	47	static void mk_timer_expire(
	48	void *p0,
	49	void *p1);
	50
	51	mach_port_name_t
	52	mk_timer_create(void)
	53	{
	54	mk_timer_t timer;
	55	ipc_space_t myspace = current_space();
	56	mach_port_name_t name = MACH_PORT_NULL;
	57	ipc_port_t port;
	58	kern_return_t result;
	59
	60	timer = (mk_timer_t)zalloc(mk_timer_zone);
	61	if (timer == NULL)
	62	return (MACH_PORT_NULL);
	63
	64	result = mach_port_allocate_qos(myspace, MACH_PORT_RIGHT_RECEIVE,
65	&mk_timer_qos, &name);
66	if (result == KERN_SUCCESS)
67	result = ipc_port_translate_receive(myspace, name, &port);
68
69	if (result != KERN_SUCCESS) {
70	zfree(mk_timer_zone, (vm_offset_t)timer);
71
72	return (MACH_PORT_NULL);
73	}
74
75	simple_lock_init(&timer->lock, ETAP_MISC_TIMER);
76	call_entry_setup(&timer->call_entry, mk_timer_expire, timer);
77	timer->is_armed = timer->is_dead = FALSE;
78	timer->active = 0;
79
80	timer->port = port;
81	ipc_kobject_set_atomically(port, (ipc_kobject_t)timer, IKOT_TIMER);
82
83	port->ip_srights++;
84	ip_reference(port);
85	ip_unlock(port);
86
87	return (name);
88	}
89
90	void
91	mk_timer_port_destroy(
92	ipc_port_t port)
93	{
94	mk_timer_t timer = NULL;
95
96	ip_lock(port);
97	if (ip_kotype(port) == IKOT_TIMER) {
98	timer = (mk_timer_t)port->ip_kobject;
99	assert(timer != NULL);
100	ipc_kobject_set_atomically(port, IKO_NULL, IKOT_NONE);
101	simple_lock(&timer->lock);
102	assert(timer->port == port);
103	}
104	ip_unlock(port);
105
106	if (timer != NULL) {
107	if (thread_call_cancel(&timer->call_entry))
108	timer->active--;
109	timer->is_armed = FALSE;
110
111	timer->is_dead = TRUE;
112	if (timer->active == 0) {
113	simple_unlock(&timer->lock);
114	zfree(mk_timer_zone, (vm_offset_t)timer);
115
116	ipc_port_release_send(port);
117	return;
118	}
119
120	simple_unlock(&timer->lock);
121	}
122	}
123
124	void
125	mk_timer_initialize(void)
126	{
127	int s = sizeof (mk_timer_data_t);
128
129	assert(!(mk_timer_zone != NULL));
130
131	mk_timer_zone = zinit(s, (4096 * s), (16 * s), "mk_timer");
132	}
133
134	static void
135	mk_timer_expire(
136	void *p0,
137	void *p1)
138	{
0b4e3aa0	139	uint64_t time_of_posting;
1c79356b A	140	mk_timer_t timer = p0;
	141	ipc_port_t port;
	142
	143	clock_get_uptime(&time_of_posting);
	144
	145	simple_lock(&timer->lock);
	146
	147	if (timer->active > 1) {
	148	timer->active--;
	149	simple_unlock(&timer->lock);
	150	return;
	151	}
	152
	153	port = timer->port;
	154	assert(port != IP_NULL);
	155
	156	while ( timer->is_armed &&
	157	!thread_call_is_delayed(&timer->call_entry, NULL) ) {
	158	mk_timer_expire_msg_t msg;
	159
	160	timer->is_armed = FALSE;
	161
	162	msg.time_of_arming = timer->time_of_arming;
	163	msg.armed_time = timer->call_entry.deadline;
	164	msg.time_of_posting = time_of_posting;
	165
	166	simple_unlock(&timer->lock);
	167
	168	msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
	169	msg.header.msgh_remote_port = port;
	170	msg.header.msgh_local_port = MACH_PORT_NULL;
	171	msg.header.msgh_reserved = msg.header.msgh_id = 0;
	172
	173	(void) mach_msg_send_from_kernel(&msg.header, sizeof (msg));
	174
	175	simple_lock(&timer->lock);
	176	}
	177
	178	if (--timer->active == 0 && timer->is_dead) {
	179	simple_unlock(&timer->lock);
	180	zfree(mk_timer_zone, (vm_offset_t)timer);
	181
	182	ipc_port_release_send(port);
	183	return;
	184	}
	185
	186	simple_unlock(&timer->lock);
	187	}
	188
	189	kern_return_t
	190	mk_timer_destroy(
	191	mach_port_name_t name)
	192	{
	193	ipc_space_t myspace = current_space();
	194	ipc_port_t port;
	195	kern_return_t result;
	196
	197	result = ipc_port_translate_receive(myspace, name, &port);
	198	if (result != KERN_SUCCESS)
	199	return (result);
	200
	201	if (ip_kotype(port) == IKOT_TIMER) {
	202	ip_unlock(port);
	203	result = mach_port_destroy(myspace, name);
204	}
205	else {
206	ip_unlock(port);
207	result = KERN_INVALID_ARGUMENT;
208	}
209
210	return (result);
211	}
212
213	kern_return_t
214	mk_timer_arm(
215	mach_port_name_t name,
0b4e3aa0	216	uint64_t expire_time)
1c79356b	217	{
0b4e3aa0	218	uint64_t time_of_arming;
1c79356b A	219	mk_timer_t timer;
	220	ipc_space_t myspace = current_space();
	221	ipc_port_t port;
	222	kern_return_t result;
	223
	224	clock_get_uptime(&time_of_arming);
	225
	226	result = ipc_port_translate_receive(myspace, name, &port);
	227	if (result != KERN_SUCCESS)
	228	return (result);
	229
	230	if (ip_kotype(port) == IKOT_TIMER) {
	231	timer = (mk_timer_t)port->ip_kobject;
	232	assert(timer != NULL);
	233	simple_lock(&timer->lock);
	234	assert(timer->port == port);
	235	ip_unlock(port);
	236
	237	timer->time_of_arming = time_of_arming;
	238	timer->is_armed = TRUE;
	239
	240	if (!thread_call_enter_delayed(&timer->call_entry, expire_time))
	241	timer->active++;
	242	simple_unlock(&timer->lock);
	243	}
	244	else {
	245	ip_unlock(port);
	246	result = KERN_INVALID_ARGUMENT;
	247	}
	248
	249	return (result);
	250	}
	251
	252	kern_return_t
	253	mk_timer_cancel(
	254	mach_port_name_t name,
0b4e3aa0	255	uint64_t *result_time)
1c79356b	256	{
0b4e3aa0	257	uint64_t armed_time = 0;
1c79356b A	258	mk_timer_t timer;
	259	ipc_space_t myspace = current_space();
	260	ipc_port_t port;
	261	kern_return_t result;
	262
	263	result = ipc_port_translate_receive(myspace, name, &port);
	264	if (result != KERN_SUCCESS)
	265	return (result);
	266
	267	if (ip_kotype(port) == IKOT_TIMER) {
	268	timer = (mk_timer_t)port->ip_kobject;
	269	assert(timer != NULL);
	270	simple_lock(&timer->lock);
	271	assert(timer->port == port);
	272	ip_unlock(port);
	273
	274	if (timer->is_armed) {
	275	armed_time = timer->call_entry.deadline;
	276	if (thread_call_cancel(&timer->call_entry))
	277	timer->active--;
	278	timer->is_armed = FALSE;
	279	}
	280
	281	simple_unlock(&timer->lock);
	282	}
	283	else {
	284	ip_unlock(port);
	285	result = KERN_INVALID_ARGUMENT;
	286	}
	287
	288	if (result == KERN_SUCCESS)
	289	if ( result_time != NULL &&
	290	copyout((void )&armed_time, (void )result_time,
	291	sizeof (armed_time)) != 0 )
	292	result = KERN_FAILURE;
	293
	294	return (result);
	295	}