1/*
2 * Copyright (c) 2000-2008 Apple 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 * @OSF_COPYRIGHT@
30 */
31/*
32 * DEPRECATED INTERFACES - Should be removed
33 *
34 * Purpose: Routines for the creation and use of kernel
35 * alarm clock services. This file and the ipc
36 * routines in kern/ipc_clock.c constitute the
37 * machine-independent clock service layer.
38 */
39
40#include <mach/mach_types.h>
41
42#include <kern/host.h>
43#include <kern/spl.h>
44#include <kern/sched_prim.h>
45#include <kern/thread.h>
46#include <kern/ipc_host.h>
47#include <kern/clock.h>
48#include <kern/zalloc.h>
49
50#include <ipc/ipc_types.h>
51#include <ipc/ipc_port.h>
52
53#include <mach/mach_traps.h>
54#include <mach/mach_time.h>
55
56#include <mach/clock_server.h>
57#include <mach/clock_reply.h>
58#include <mach/clock_priv_server.h>
59
60#include <mach/mach_host_server.h>
61#include <mach/host_priv_server.h>
62#include <libkern/section_keywords.h>
63
64/*
65 * Actual clock alarm structure. Used for user clock_sleep() and
66 * clock_alarm() calls. Alarms are allocated from the alarm free
67 * list and entered in time priority order into the active alarm
68 * chain of the target clock.
69 */
70struct alarm {
71 struct alarm *al_next; /* next alarm in chain */
72 struct alarm *al_prev; /* previous alarm in chain */
73 int al_status; /* alarm status */
74 mach_timespec_t al_time; /* alarm time */
75 struct { /* message alarm data */
76 int type; /* alarm type */
77 ipc_port_t port; /* alarm port */
78 mach_msg_type_name_t
79 port_type; /* alarm port type */
80 struct clock *clock; /* alarm clock */
81 void *data; /* alarm data */
82 } al_alrm;
83#define al_type al_alrm.type
84#define al_port al_alrm.port
85#define al_port_type al_alrm.port_type
86#define al_clock al_alrm.clock
87#define al_data al_alrm.data
88 long al_seqno; /* alarm sequence number */
89};
90typedef struct alarm alarm_data_t;
91
92/* alarm status */
93#define ALARM_FREE 0 /* alarm is on free list */
94#define ALARM_SLEEP 1 /* active clock_sleep() */
95#define ALARM_CLOCK 2 /* active clock_alarm() */
96#define ALARM_DONE 4 /* alarm has expired */
97
98/* local data declarations */
99decl_simple_lock_data(static,alarm_lock) /* alarm synchronization */
100static struct zone *alarm_zone; /* zone for user alarms */
101static struct alarm *alrmfree; /* alarm free list pointer */
102static struct alarm *alrmdone; /* alarm done list pointer */
103static struct alarm *alrmlist;
104static long alrm_seqno; /* uniquely identifies alarms */
105static thread_call_data_t alarm_done_call;
106static timer_call_data_t alarm_expire_timer;
107
108extern struct clock clock_list[];
109extern int clock_count;
110
111static void post_alarm(
112 alarm_t alarm);
113
114static void set_alarm(
115 mach_timespec_t *alarm_time);
116
117static int check_time(
118 alarm_type_t alarm_type,
119 mach_timespec_t *alarm_time,
120 mach_timespec_t *clock_time);
121
122static void alarm_done(void);
123
124static void alarm_expire(void);
125
126static kern_return_t clock_sleep_internal(
127 clock_t clock,
128 sleep_type_t sleep_type,
129 mach_timespec_t *sleep_time);
130
131int rtclock_init(void);
132
133kern_return_t rtclock_gettime(
134 mach_timespec_t *cur_time);
135
136kern_return_t rtclock_getattr(
137 clock_flavor_t flavor,
138 clock_attr_t attr,
139 mach_msg_type_number_t *count);
140
141SECURITY_READ_ONLY_EARLY(struct clock_ops) sysclk_ops = {
142 NULL, rtclock_init,
143 rtclock_gettime,
144 rtclock_getattr,
145};
146
147kern_return_t calend_gettime(
148 mach_timespec_t *cur_time);
149
150kern_return_t calend_getattr(
151 clock_flavor_t flavor,
152 clock_attr_t attr,
153 mach_msg_type_number_t *count);
154
155SECURITY_READ_ONLY_EARLY(struct clock_ops) calend_ops = {
156 NULL, NULL,
157 calend_gettime,
158 calend_getattr,
159};
160
161/*
162 * List of clock devices.
163 */
164SECURITY_READ_ONLY_LATE(struct clock) clock_list[] = {
165
166 /* SYSTEM_CLOCK */
167 { &sysclk_ops, 0, 0 },
168
169 /* CALENDAR_CLOCK */
170 { &calend_ops, 0, 0 }
171};
172int clock_count = sizeof(clock_list) / sizeof(clock_list[0]);
173
174/*
175 * Macros to lock/unlock clock system.
176 */
177#define LOCK_ALARM(s) \
178 s = splclock(); \
179 simple_lock(&alarm_lock);
180
181#define UNLOCK_ALARM(s) \
182 simple_unlock(&alarm_lock); \
183 splx(s);
184
185void
186clock_oldconfig(void)
187{
188 clock_t clock;
189 int i;
190
191 simple_lock_init(&alarm_lock, 0);
192 thread_call_setup(&alarm_done_call, (thread_call_func_t)alarm_done, NULL);
193 timer_call_setup(&alarm_expire_timer, (timer_call_func_t)alarm_expire, NULL);
194
195 /*
196 * Configure clock devices.
197 */
198 for (i = 0; i < clock_count; i++) {
199 clock = &clock_list[i];
200 if (clock->cl_ops && clock->cl_ops->c_config) {
201 if ((*clock->cl_ops->c_config)() == 0)
202 clock->cl_ops = NULL;
203 }
204 }
205
206 /* start alarm sequence numbers at 0 */
207 alrm_seqno = 0;
208}
209
210void
211clock_oldinit(void)
212{
213 clock_t clock;
214 int i;
215
216 /*
217 * Initialize basic clock structures.
218 */
219 for (i = 0; i < clock_count; i++) {
220 clock = &clock_list[i];
221 if (clock->cl_ops && clock->cl_ops->c_init)
222 (*clock->cl_ops->c_init)();
223 }
224}
225
226/*
227 * Initialize the clock ipc service facility.
228 */
229void
230clock_service_create(void)
231{
232 clock_t clock;
233 int i;
234
235 /*
236 * Initialize ipc clock services.
237 */
238 for (i = 0; i < clock_count; i++) {
239 clock = &clock_list[i];
240 if (clock->cl_ops) {
241 ipc_clock_init(clock);
242 ipc_clock_enable(clock);
243 }
244 }
245
246 /*
247 * Perform miscellaneous late
248 * initialization.
249 */
250 i = sizeof(struct alarm);
251 alarm_zone = zinit(i, (4096/i)*i, 10*i, "alarms");
252}
253
254/*
255 * Get the service port on a clock.
256 */
257kern_return_t
258host_get_clock_service(
259 host_t host,
260 clock_id_t clock_id,
261 clock_t *clock) /* OUT */
262{
263 if (host == HOST_NULL || clock_id < 0 || clock_id >= clock_count) {
264 *clock = CLOCK_NULL;
265 return (KERN_INVALID_ARGUMENT);
266 }
267
268 *clock = &clock_list[clock_id];
269 if ((*clock)->cl_ops == 0)
270 return (KERN_FAILURE);
271 return (KERN_SUCCESS);
272}
273
274/*
275 * Get the control port on a clock.
276 */
277kern_return_t
278host_get_clock_control(
279 host_priv_t host_priv,
280 clock_id_t clock_id,
281 clock_t *clock) /* OUT */
282{
283 if (host_priv == HOST_PRIV_NULL ||
284 clock_id < 0 || clock_id >= clock_count) {
285 *clock = CLOCK_NULL;
286 return (KERN_INVALID_ARGUMENT);
287 }
288
289 *clock = &clock_list[clock_id];
290 if ((*clock)->cl_ops == 0)
291 return (KERN_FAILURE);
292 return (KERN_SUCCESS);
293}
294
295/*
296 * Get the current clock time.
297 */
298kern_return_t
299clock_get_time(
300 clock_t clock,
301 mach_timespec_t *cur_time) /* OUT */
302{
303 if (clock == CLOCK_NULL)
304 return (KERN_INVALID_ARGUMENT);
305 return ((*clock->cl_ops->c_gettime)(cur_time));
306}
307
308kern_return_t
309rtclock_gettime(
310 mach_timespec_t *time) /* OUT */
311{
312 clock_sec_t secs;
313 clock_nsec_t nsecs;
314
315 clock_get_system_nanotime(&secs, &nsecs);
316 time->tv_sec = (unsigned int)secs;
317 time->tv_nsec = nsecs;
318
319 return (KERN_SUCCESS);
320}
321
322kern_return_t
323calend_gettime(
324 mach_timespec_t *time) /* OUT */
325{
326 clock_sec_t secs;
327 clock_nsec_t nsecs;
328
329 clock_get_calendar_nanotime(&secs, &nsecs);
330 time->tv_sec = (unsigned int)secs;
331 time->tv_nsec = nsecs;
332
333 return (KERN_SUCCESS);
334}
335
336/*
337 * Get clock attributes.
338 */
339kern_return_t
340clock_get_attributes(
341 clock_t clock,
342 clock_flavor_t flavor,
343 clock_attr_t attr, /* OUT */
344 mach_msg_type_number_t *count) /* IN/OUT */
345{
346 if (clock == CLOCK_NULL)
347 return (KERN_INVALID_ARGUMENT);
348 if (clock->cl_ops->c_getattr)
349 return (clock->cl_ops->c_getattr(flavor, attr, count));
350 return (KERN_FAILURE);
351}
352
353kern_return_t
354rtclock_getattr(
355 clock_flavor_t flavor,
356 clock_attr_t attr, /* OUT */
357 mach_msg_type_number_t *count) /* IN/OUT */
358{
359 if (*count != 1)
360 return (KERN_FAILURE);
361
362 switch (flavor) {
363
364 case CLOCK_GET_TIME_RES: /* >0 res */
365 case CLOCK_ALARM_CURRES: /* =0 no alarm */
366 case CLOCK_ALARM_MINRES:
367 case CLOCK_ALARM_MAXRES:
368 *(clock_res_t *) attr = NSEC_PER_SEC / 100;
369 break;
370
371 default:
372 return (KERN_INVALID_VALUE);
373 }
374
375 return (KERN_SUCCESS);
376}
377
378kern_return_t
379calend_getattr(
380 clock_flavor_t flavor,
381 clock_attr_t attr, /* OUT */
382 mach_msg_type_number_t *count) /* IN/OUT */
383{
384 if (*count != 1)
385 return (KERN_FAILURE);
386
387 switch (flavor) {
388
389 case CLOCK_GET_TIME_RES: /* >0 res */
390 *(clock_res_t *) attr = NSEC_PER_SEC / 100;
391 break;
392
393 case CLOCK_ALARM_CURRES: /* =0 no alarm */
394 case CLOCK_ALARM_MINRES:
395 case CLOCK_ALARM_MAXRES:
396 *(clock_res_t *) attr = 0;
397 break;
398
399 default:
400 return (KERN_INVALID_VALUE);
401 }
402
403 return (KERN_SUCCESS);
404}
405
406/*
407 * Set the current clock time.
408 */
409kern_return_t
410clock_set_time(
411 clock_t clock,
412__unused mach_timespec_t new_time)
413{
414 if (clock == CLOCK_NULL)
415 return (KERN_INVALID_ARGUMENT);
416 return (KERN_FAILURE);
417}
418
419/*
420 * Set the clock alarm resolution.
421 */
422kern_return_t
423clock_set_attributes(
424 clock_t clock,
425__unused clock_flavor_t flavor,
426__unused clock_attr_t attr,
427__unused mach_msg_type_number_t count)
428{
429 if (clock == CLOCK_NULL)
430 return (KERN_INVALID_ARGUMENT);
431 return (KERN_FAILURE);
432}
433
434/*
435 * Setup a clock alarm.
436 */
437kern_return_t
438clock_alarm(
439 clock_t clock,
440 alarm_type_t alarm_type,
441 mach_timespec_t alarm_time,
442 ipc_port_t alarm_port,
443 mach_msg_type_name_t alarm_port_type)
444{
445 alarm_t alarm;
446 mach_timespec_t clock_time;
447 int chkstat;
448 kern_return_t reply_code;
449 spl_t s;
450
451 if (clock == CLOCK_NULL)
452 return (KERN_INVALID_ARGUMENT);
453 if (clock != &clock_list[SYSTEM_CLOCK])
454 return (KERN_FAILURE);
455 if (IP_VALID(alarm_port) == 0)
456 return (KERN_INVALID_CAPABILITY);
457
458 /*
459 * Check alarm parameters. If parameters are invalid,
460 * send alarm message immediately.
461 */
462 (*clock->cl_ops->c_gettime)(&clock_time);
463 chkstat = check_time(alarm_type, &alarm_time, &clock_time);
464 if (chkstat <= 0) {
465 reply_code = (chkstat < 0 ? KERN_INVALID_VALUE : KERN_SUCCESS);
466 clock_alarm_reply(alarm_port, alarm_port_type,
467 reply_code, alarm_type, clock_time);
468 return (KERN_SUCCESS);
469 }
470
471 /*
472 * Get alarm and add to clock alarm list.
473 */
474
475 LOCK_ALARM(s);
476 if ((alarm = alrmfree) == 0) {
477 UNLOCK_ALARM(s);
478 alarm = (alarm_t) zalloc(alarm_zone);
479 if (alarm == 0)
480 return (KERN_RESOURCE_SHORTAGE);
481 LOCK_ALARM(s);
482 }
483 else
484 alrmfree = alarm->al_next;
485
486 alarm->al_status = ALARM_CLOCK;
487 alarm->al_time = alarm_time;
488 alarm->al_type = alarm_type;
489 alarm->al_port = alarm_port;
490 alarm->al_port_type = alarm_port_type;
491 alarm->al_clock = clock;
492 alarm->al_seqno = alrm_seqno++;
493 post_alarm(alarm);
494 UNLOCK_ALARM(s);
495
496 return (KERN_SUCCESS);
497}
498
499/*
500 * Sleep on a clock. System trap. User-level libmach clock_sleep
501 * interface call takes a mach_timespec_t sleep_time argument which it
502 * converts to sleep_sec and sleep_nsec arguments which are then
503 * passed to clock_sleep_trap.
504 */
505kern_return_t
506clock_sleep_trap(
507 struct clock_sleep_trap_args *args)
508{
509 mach_port_name_t clock_name = args->clock_name;
510 sleep_type_t sleep_type = args->sleep_type;
511 int sleep_sec = args->sleep_sec;
512 int sleep_nsec = args->sleep_nsec;
513 mach_vm_address_t wakeup_time_addr = args->wakeup_time;
514 clock_t clock;
515 mach_timespec_t swtime = {};
516 kern_return_t rvalue;
517
518 /*
519 * Convert the trap parameters.
520 */
521 if (clock_name == MACH_PORT_NULL)
522 clock = &clock_list[SYSTEM_CLOCK];
523 else
524 clock = port_name_to_clock(clock_name);
525
526 swtime.tv_sec = sleep_sec;
527 swtime.tv_nsec = sleep_nsec;
528
529 /*
530 * Call the actual clock_sleep routine.
531 */
532 rvalue = clock_sleep_internal(clock, sleep_type, &swtime);
533
534 /*
535 * Return current time as wakeup time.
536 */
537 if (rvalue != KERN_INVALID_ARGUMENT && rvalue != KERN_FAILURE) {
538 copyout((char *)&swtime, wakeup_time_addr, sizeof(mach_timespec_t));
539 }
540 return (rvalue);
541}
542
543static kern_return_t
544clock_sleep_internal(
545 clock_t clock,
546 sleep_type_t sleep_type,
547 mach_timespec_t *sleep_time)
548{
549 alarm_t alarm;
550 mach_timespec_t clock_time;
551 kern_return_t rvalue;
552 int chkstat;
553 spl_t s;
554
555 if (clock == CLOCK_NULL)
556 return (KERN_INVALID_ARGUMENT);
557
558 if (clock != &clock_list[SYSTEM_CLOCK])
559 return (KERN_FAILURE);
560
561 /*
562 * Check sleep parameters. If parameters are invalid
563 * return an error, otherwise post alarm request.
564 */
565 (*clock->cl_ops->c_gettime)(&clock_time);
566
567 chkstat = check_time(sleep_type, sleep_time, &clock_time);
568 if (chkstat < 0)
569 return (KERN_INVALID_VALUE);
570 rvalue = KERN_SUCCESS;
571 if (chkstat > 0) {
572 wait_result_t wait_result;
573
574 /*
575 * Get alarm and add to clock alarm list.
576 */
577
578 LOCK_ALARM(s);
579 if ((alarm = alrmfree) == 0) {
580 UNLOCK_ALARM(s);
581 alarm = (alarm_t) zalloc(alarm_zone);
582 if (alarm == 0)
583 return (KERN_RESOURCE_SHORTAGE);
584 LOCK_ALARM(s);
585 }
586 else
587 alrmfree = alarm->al_next;
588
589 /*
590 * Wait for alarm to occur.
591 */
592 wait_result = assert_wait((event_t)alarm, THREAD_ABORTSAFE);
593 if (wait_result == THREAD_WAITING) {
594 alarm->al_time = *sleep_time;
595 alarm->al_status = ALARM_SLEEP;
596 post_alarm(alarm);
597 UNLOCK_ALARM(s);
598
599 wait_result = thread_block(THREAD_CONTINUE_NULL);
600
601 /*
602 * Note if alarm expired normally or whether it
603 * was aborted. If aborted, delete alarm from
604 * clock alarm list. Return alarm to free list.
605 */
606 LOCK_ALARM(s);
607 if (alarm->al_status != ALARM_DONE) {
608 assert(wait_result != THREAD_AWAKENED);
609 if (((alarm->al_prev)->al_next = alarm->al_next) != NULL)
610 (alarm->al_next)->al_prev = alarm->al_prev;
611 rvalue = KERN_ABORTED;
612 }
613 *sleep_time = alarm->al_time;
614 alarm->al_status = ALARM_FREE;
615 } else {
616 assert(wait_result == THREAD_INTERRUPTED);
617 assert(alarm->al_status == ALARM_FREE);
618 rvalue = KERN_ABORTED;
619 }
620 alarm->al_next = alrmfree;
621 alrmfree = alarm;
622 UNLOCK_ALARM(s);
623 }
624 else
625 *sleep_time = clock_time;
626
627 return (rvalue);
628}
629
630/*
631 * Service clock alarm expirations.
632 */
633static void
634alarm_expire(void)
635{
636 clock_t clock;
637 alarm_t alrm1;
638 alarm_t alrm2;
639 mach_timespec_t clock_time;
640 mach_timespec_t *alarm_time;
641 spl_t s;
642
643 clock = &clock_list[SYSTEM_CLOCK];
644 (*clock->cl_ops->c_gettime)(&clock_time);
645
646 /*
647 * Update clock alarm list. Alarms that are due are moved
648 * to the alarmdone list to be serviced by a thread callout.
649 */
650 LOCK_ALARM(s);
651 alrm1 = (alarm_t)&alrmlist;
652 while ((alrm2 = alrm1->al_next) != NULL) {
653 alarm_time = &alrm2->al_time;
654 if (CMP_MACH_TIMESPEC(alarm_time, &clock_time) > 0)
655 break;
656
657 /*
658 * Alarm has expired, so remove it from the
659 * clock alarm list.
660 */
661 if ((alrm1->al_next = alrm2->al_next) != NULL)
662 (alrm1->al_next)->al_prev = alrm1;
663
664 /*
665 * If a clock_sleep() alarm, wakeup the thread
666 * which issued the clock_sleep() call.
667 */
668 if (alrm2->al_status == ALARM_SLEEP) {
669 alrm2->al_next = NULL;
670 alrm2->al_status = ALARM_DONE;
671 alrm2->al_time = clock_time;
672 thread_wakeup((event_t)alrm2);
673 }
674
675 /*
676 * If a clock_alarm() alarm, place the alarm on
677 * the alarm done list and schedule the alarm
678 * delivery mechanism.
679 */
680 else {
681 assert(alrm2->al_status == ALARM_CLOCK);
682 if ((alrm2->al_next = alrmdone) != NULL)
683 alrmdone->al_prev = alrm2;
684 else
685 thread_call_enter(&alarm_done_call);
686 alrm2->al_prev = (alarm_t)&alrmdone;
687 alrmdone = alrm2;
688 alrm2->al_status = ALARM_DONE;
689 alrm2->al_time = clock_time;
690 }
691 }
692
693 /*
694 * Setup to expire for the next pending alarm.
695 */
696 if (alrm2)
697 set_alarm(alarm_time);
698 UNLOCK_ALARM(s);
699}
700
701static void
702alarm_done(void)
703{
704 alarm_t alrm;
705 kern_return_t code;
706 spl_t s;
707
708 LOCK_ALARM(s);
709 while ((alrm = alrmdone) != NULL) {
710 if ((alrmdone = alrm->al_next) != NULL)
711 alrmdone->al_prev = (alarm_t)&alrmdone;
712 UNLOCK_ALARM(s);
713
714 code = (alrm->al_status == ALARM_DONE? KERN_SUCCESS: KERN_ABORTED);
715 if (alrm->al_port != IP_NULL) {
716 /* Deliver message to designated port */
717 if (IP_VALID(alrm->al_port)) {
718 clock_alarm_reply(alrm->al_port, alrm->al_port_type, code,
719 alrm->al_type, alrm->al_time);
720 }
721
722 LOCK_ALARM(s);
723 alrm->al_status = ALARM_FREE;
724 alrm->al_next = alrmfree;
725 alrmfree = alrm;
726 }
727 else
728 panic("clock_alarm_deliver");
729 }
730
731 UNLOCK_ALARM(s);
732}
733
734/*
735 * Post an alarm on the active alarm list.
736 *
737 * Always called from within a LOCK_ALARM() code section.
738 */
739static void
740post_alarm(
741 alarm_t alarm)
742{
743 alarm_t alrm1, alrm2;
744 mach_timespec_t *alarm_time;
745 mach_timespec_t *queue_time;
746
747 /*
748 * Traverse alarm list until queue time is greater
749 * than alarm time, then insert alarm.
750 */
751 alarm_time = &alarm->al_time;
752 alrm1 = (alarm_t)&alrmlist;
753 while ((alrm2 = alrm1->al_next) != NULL) {
754 queue_time = &alrm2->al_time;
755 if (CMP_MACH_TIMESPEC(queue_time, alarm_time) > 0)
756 break;
757 alrm1 = alrm2;
758 }
759 alrm1->al_next = alarm;
760 alarm->al_next = alrm2;
761 alarm->al_prev = alrm1;
762 if (alrm2)
763 alrm2->al_prev = alarm;
764
765 /*
766 * If the inserted alarm is the 'earliest' alarm,
767 * reset the device layer alarm time accordingly.
768 */
769 if (alrmlist == alarm)
770 set_alarm(alarm_time);
771}
772
773static void
774set_alarm(
775 mach_timespec_t *alarm_time)
776{
777 uint64_t abstime;
778
779 nanotime_to_absolutetime(alarm_time->tv_sec, alarm_time->tv_nsec, &abstime);
780 timer_call_enter_with_leeway(&alarm_expire_timer, NULL, abstime, 0, TIMER_CALL_USER_NORMAL, FALSE);
781}
782
783/*
784 * Check the validity of 'alarm_time' and 'alarm_type'. If either
785 * argument is invalid, return a negative value. If the 'alarm_time'
786 * is now, return a 0 value. If the 'alarm_time' is in the future,
787 * return a positive value.
788 */
789static int
790check_time(
791 alarm_type_t alarm_type,
792 mach_timespec_t *alarm_time,
793 mach_timespec_t *clock_time)
794{
795 int result;
796
797 if (BAD_ALRMTYPE(alarm_type))
798 return (-1);
799 if (BAD_MACH_TIMESPEC(alarm_time))
800 return (-1);
801 if ((alarm_type & ALRMTYPE) == TIME_RELATIVE)
802 ADD_MACH_TIMESPEC(alarm_time, clock_time);
803
804 result = CMP_MACH_TIMESPEC(alarm_time, clock_time);
805
806 return ((result >= 0)? result: 0);
807}
808
809#ifndef __LP64__
810
811mach_timespec_t
812clock_get_system_value(void)
813{
814 clock_t clock = &clock_list[SYSTEM_CLOCK];
815 mach_timespec_t value;
816
817 (void) (*clock->cl_ops->c_gettime)(&value);
818
819 return value;
820}
821
822mach_timespec_t
823clock_get_calendar_value(void)
824{
825 clock_t clock = &clock_list[CALENDAR_CLOCK];
826 mach_timespec_t value = MACH_TIMESPEC_ZERO;
827
828 (void) (*clock->cl_ops->c_gettime)(&value);
829
830 return value;
831}
832
833#endif /* __LP64__ */
834