1 | /* |
2 | * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* |
29 | * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. |
30 | * |
31 | * HISTORY |
32 | * |
33 | * 29 June 2000 (debo) |
34 | * Created. |
35 | */ |
36 | |
37 | #include <mach/mach_types.h> |
38 | #include <mach/mach_traps.h> |
39 | #include <mach/mach_port_server.h> |
40 | |
41 | #include <mach/mk_timer.h> |
42 | |
43 | #include <ipc/ipc_space.h> |
44 | |
45 | #include <kern/mk_timer.h> |
46 | #include <kern/thread_call.h> |
47 | |
48 | static zone_t mk_timer_zone; |
49 | |
50 | static mach_port_qos_t mk_timer_qos = { |
51 | FALSE, TRUE, 0, sizeof (mk_timer_expire_msg_t) |
52 | }; |
53 | |
54 | static void mk_timer_expire( |
55 | void *p0, |
56 | void *p1); |
57 | |
58 | mach_port_name_t |
59 | mk_timer_create_trap( |
60 | __unused struct mk_timer_create_trap_args *args) |
61 | { |
62 | mk_timer_t timer; |
63 | ipc_space_t myspace = current_space(); |
64 | mach_port_name_t name = MACH_PORT_NULL; |
65 | ipc_port_t port; |
66 | kern_return_t result; |
67 | |
68 | timer = (mk_timer_t)zalloc(mk_timer_zone); |
69 | if (timer == NULL) |
70 | return (MACH_PORT_NULL); |
71 | |
72 | result = mach_port_allocate_qos(myspace, MACH_PORT_RIGHT_RECEIVE, |
73 | &mk_timer_qos, &name); |
74 | if (result == KERN_SUCCESS) |
75 | result = ipc_port_translate_receive(myspace, name, &port); |
76 | |
77 | if (result != KERN_SUCCESS) { |
78 | zfree(mk_timer_zone, timer); |
79 | |
80 | return (MACH_PORT_NULL); |
81 | } |
82 | |
83 | simple_lock_init(&timer->lock, 0); |
84 | thread_call_setup(&timer->call_entry, mk_timer_expire, timer); |
85 | timer->is_armed = timer->is_dead = FALSE; |
86 | timer->active = 0; |
87 | |
88 | timer->port = port; |
89 | ipc_kobject_set_atomically(port, (ipc_kobject_t)timer, IKOT_TIMER); |
90 | |
91 | port->ip_srights++; |
92 | ip_reference(port); |
93 | ip_unlock(port); |
94 | |
95 | return (name); |
96 | } |
97 | |
98 | void |
99 | mk_timer_port_destroy( |
100 | ipc_port_t port) |
101 | { |
102 | mk_timer_t timer = NULL; |
103 | |
104 | ip_lock(port); |
105 | if (ip_kotype(port) == IKOT_TIMER) { |
106 | timer = (mk_timer_t)port->ip_kobject; |
107 | assert(timer != NULL); |
108 | ipc_kobject_set_atomically(port, IKO_NULL, IKOT_NONE); |
109 | simple_lock(&timer->lock); |
110 | assert(timer->port == port); |
111 | } |
112 | ip_unlock(port); |
113 | |
114 | if (timer != NULL) { |
115 | if (thread_call_cancel(&timer->call_entry)) |
116 | timer->active--; |
117 | timer->is_armed = FALSE; |
118 | |
119 | timer->is_dead = TRUE; |
120 | if (timer->active == 0) { |
121 | simple_unlock(&timer->lock); |
122 | zfree(mk_timer_zone, timer); |
123 | |
124 | ipc_port_release_send(port); |
125 | return; |
126 | } |
127 | |
128 | simple_unlock(&timer->lock); |
129 | } |
130 | } |
131 | |
132 | void |
133 | mk_timer_init(void) |
134 | { |
135 | int s = sizeof (mk_timer_data_t); |
136 | |
137 | assert(!(mk_timer_zone != NULL)); |
138 | |
139 | mk_timer_zone = zinit(s, (4096 * s), (16 * s), "mk_timer" ); |
140 | |
141 | zone_change(mk_timer_zone, Z_NOENCRYPT, TRUE); |
142 | } |
143 | |
144 | static void |
145 | mk_timer_expire( |
146 | void *p0, |
147 | __unused void *p1) |
148 | { |
149 | mk_timer_t timer = p0; |
150 | ipc_port_t port; |
151 | |
152 | simple_lock(&timer->lock); |
153 | |
154 | if (timer->active > 1) { |
155 | timer->active--; |
156 | simple_unlock(&timer->lock); |
157 | return; |
158 | } |
159 | |
160 | port = timer->port; |
161 | assert(port != IP_NULL); |
162 | assert(timer->active == 1); |
163 | |
164 | while (timer->is_armed && timer->active == 1) { |
165 | mk_timer_expire_msg_t msg; |
166 | |
167 | timer->is_armed = FALSE; |
168 | simple_unlock(&timer->lock); |
169 | |
170 | msg.header.msgh_bits = |
171 | MACH_MSGH_BITS_SET(MACH_MSG_TYPE_COPY_SEND, 0, 0, 0); |
172 | msg.header.msgh_remote_port = port; |
173 | msg.header.msgh_local_port = MACH_PORT_NULL; |
174 | msg.header.msgh_voucher_port = MACH_PORT_NULL; |
175 | msg.header.msgh_id = 0; |
176 | |
177 | msg.unused[0] = msg.unused[1] = msg.unused[2] = 0; |
178 | |
179 | (void) mach_msg_send_from_kernel_proper(&msg.header, sizeof (msg)); |
180 | |
181 | simple_lock(&timer->lock); |
182 | } |
183 | |
184 | if (--timer->active == 0 && timer->is_dead) { |
185 | simple_unlock(&timer->lock); |
186 | zfree(mk_timer_zone, timer); |
187 | |
188 | ipc_port_release_send(port); |
189 | return; |
190 | } |
191 | |
192 | simple_unlock(&timer->lock); |
193 | } |
194 | |
195 | /* |
196 | * mk_timer_destroy_trap: Destroy the Mach port associated with a timer |
197 | * |
198 | * Parameters: args User argument descriptor (see below) |
199 | * |
200 | * Indirect: args->name Mach port name |
201 | * |
202 | * |
203 | * Returns: 0 Success |
204 | * !0 Not success |
205 | * |
206 | */ |
207 | kern_return_t |
208 | mk_timer_destroy_trap( |
209 | struct mk_timer_destroy_trap_args *args) |
210 | { |
211 | mach_port_name_t name = args->name; |
212 | ipc_space_t myspace = current_space(); |
213 | ipc_port_t port; |
214 | kern_return_t result; |
215 | |
216 | result = ipc_port_translate_receive(myspace, name, &port); |
217 | if (result != KERN_SUCCESS) |
218 | return (result); |
219 | |
220 | if (ip_kotype(port) == IKOT_TIMER) { |
221 | ip_unlock(port); |
222 | result = mach_port_destroy(myspace, name); |
223 | } |
224 | else { |
225 | ip_unlock(port); |
226 | result = KERN_INVALID_ARGUMENT; |
227 | } |
228 | |
229 | return (result); |
230 | } |
231 | |
232 | /* |
233 | * mk_timer_arm_trap: Start (arm) a timer |
234 | * |
235 | * Parameters: args User argument descriptor (see below) |
236 | * |
237 | * Indirect: args->name Mach port name |
238 | * args->expire_time Time when timer expires |
239 | * |
240 | * |
241 | * Returns: 0 Success |
242 | * !0 Not success |
243 | * |
244 | */ |
245 | |
246 | static kern_return_t |
247 | mk_timer_arm_trap_internal(mach_port_name_t name, uint64_t expire_time, uint64_t mk_leeway, uint64_t mk_timer_flags) { |
248 | mk_timer_t timer; |
249 | ipc_space_t myspace = current_space(); |
250 | ipc_port_t port; |
251 | kern_return_t result; |
252 | |
253 | result = ipc_port_translate_receive(myspace, name, &port); |
254 | if (result != KERN_SUCCESS) |
255 | return (result); |
256 | |
257 | if (ip_kotype(port) == IKOT_TIMER) { |
258 | timer = (mk_timer_t)port->ip_kobject; |
259 | assert(timer != NULL); |
260 | |
261 | simple_lock(&timer->lock); |
262 | assert(timer->port == port); |
263 | ip_unlock(port); |
264 | |
265 | if (!timer->is_dead) { |
266 | timer->is_armed = TRUE; |
267 | |
268 | if (expire_time > mach_absolute_time()) { |
269 | uint32_t tcflags = THREAD_CALL_DELAY_USER_NORMAL; |
270 | |
271 | if (mk_timer_flags & MK_TIMER_CRITICAL) { |
272 | tcflags = THREAD_CALL_DELAY_USER_CRITICAL; |
273 | } |
274 | |
275 | if (mk_leeway != 0) { |
276 | tcflags |= THREAD_CALL_DELAY_LEEWAY; |
277 | } |
278 | |
279 | if (!thread_call_enter_delayed_with_leeway( |
280 | &timer->call_entry, NULL, |
281 | expire_time, mk_leeway, tcflags)) { |
282 | |
283 | timer->active++; |
284 | } |
285 | } else { |
286 | if (!thread_call_enter1(&timer->call_entry, NULL)) |
287 | timer->active++; |
288 | } |
289 | } |
290 | |
291 | simple_unlock(&timer->lock); |
292 | } else { |
293 | ip_unlock(port); |
294 | result = KERN_INVALID_ARGUMENT; |
295 | } |
296 | return (result); |
297 | } |
298 | |
299 | kern_return_t |
300 | mk_timer_arm_trap(struct mk_timer_arm_trap_args *args) { |
301 | return mk_timer_arm_trap_internal(args->name, args->expire_time, 0, MK_TIMER_NORMAL); |
302 | } |
303 | |
304 | kern_return_t |
305 | mk_timer_arm_leeway_trap(struct mk_timer_arm_leeway_trap_args *args) { |
306 | return mk_timer_arm_trap_internal(args->name, args->expire_time, args->mk_leeway, args->mk_timer_flags); |
307 | } |
308 | |
309 | /* |
310 | * mk_timer_cancel_trap: Cancel a timer |
311 | * |
312 | * Parameters: args User argument descriptor (see below) |
313 | * |
314 | * Indirect: args->name Mach port name |
315 | * args->result_time The armed time of the cancelled timer (return value) |
316 | * |
317 | * |
318 | * Returns: 0 Success |
319 | * !0 Not success |
320 | * |
321 | */ |
322 | kern_return_t |
323 | mk_timer_cancel_trap( |
324 | struct mk_timer_cancel_trap_args *args) |
325 | { |
326 | mach_port_name_t name = args->name; |
327 | mach_vm_address_t result_time_addr = args->result_time; |
328 | uint64_t armed_time = 0; |
329 | mk_timer_t timer; |
330 | ipc_space_t myspace = current_space(); |
331 | ipc_port_t port; |
332 | kern_return_t result; |
333 | |
334 | result = ipc_port_translate_receive(myspace, name, &port); |
335 | if (result != KERN_SUCCESS) |
336 | return (result); |
337 | |
338 | if (ip_kotype(port) == IKOT_TIMER) { |
339 | timer = (mk_timer_t)port->ip_kobject; |
340 | assert(timer != NULL); |
341 | simple_lock(&timer->lock); |
342 | assert(timer->port == port); |
343 | ip_unlock(port); |
344 | |
345 | if (timer->is_armed) { |
346 | armed_time = timer->call_entry.tc_call.deadline; |
347 | if (thread_call_cancel(&timer->call_entry)) |
348 | timer->active--; |
349 | timer->is_armed = FALSE; |
350 | } |
351 | |
352 | simple_unlock(&timer->lock); |
353 | } |
354 | else { |
355 | ip_unlock(port); |
356 | result = KERN_INVALID_ARGUMENT; |
357 | } |
358 | |
359 | if (result == KERN_SUCCESS) |
360 | if ( result_time_addr != 0 && |
361 | copyout((void *)&armed_time, result_time_addr, |
362 | sizeof (armed_time)) != 0 ) |
363 | result = KERN_FAILURE; |
364 | |
365 | return (result); |
366 | } |
367 | |