osfmk/kern/clock_oldops.c

   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  */
  70 struct  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 };
  90 typedef 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 */
  99 decl_simple_lock_data(static,alarm_lock)        /* alarm synchronization */
 100 static struct   zone            *alarm_zone;    /* zone for user alarms */
 101 static struct   alarm           *alrmfree;              /* alarm free list pointer */
 102 static struct   alarm           *alrmdone;              /* alarm done list pointer */
 103 static struct   alarm           *alrmlist;
 104 static long                                     alrm_seqno;             /* uniquely identifies alarms */
 105 static thread_call_data_t       alarm_done_call;
 106 static timer_call_data_t        alarm_expire_timer;
 107
 108 extern  struct clock    clock_list[];
 109 extern  int             clock_count;
 110
 111 static void             post_alarm(
 112                                         alarm_t                 alarm);
 113
 114 static void             set_alarm(
 115                                         mach_timespec_t *alarm_time);
 116
 117 static int              check_time(
 118                                         alarm_type_t    alarm_type,
 119                                         mach_timespec_t *alarm_time,
 120                                         mach_timespec_t *clock_time);
 121
 122 static void             alarm_done(void);
 123
 124 static void             alarm_expire(void);
 125
 126 static kern_return_t    clock_sleep_internal(
 127                                                         clock_t                         clock,
 128                                                         sleep_type_t            sleep_type,
 129                                                         mach_timespec_t         *sleep_time);
 130
 131 int             rtclock_init(void);
 132
 133 kern_return_t   rtclock_gettime(
 134         mach_timespec_t                 *cur_time);
 135
 136 kern_return_t   rtclock_getattr(
 137         clock_flavor_t                  flavor,
 138         clock_attr_t                    attr,
 139         mach_msg_type_number_t  *count);
 140
 141 SECURITY_READ_ONLY_EARLY(struct clock_ops) sysclk_ops = {
 142         NULL,                   rtclock_init,
 143         rtclock_gettime,
 144         rtclock_getattr,
 145 };
 146
 147 kern_return_t   calend_gettime(
 148         mach_timespec_t                 *cur_time);
 149
 150 kern_return_t   calend_getattr(
 151         clock_flavor_t                  flavor,
 152         clock_attr_t                    attr,
 153         mach_msg_type_number_t  *count);
 154
 155 SECURITY_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  */
 164 SECURITY_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 };
 172 int     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
 185 void
 186 clock_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
 210 void
 211 clock_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  */
 229 void
 230 clock_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  */
 257 kern_return_t
 258 host_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  */
 277 kern_return_t
 278 host_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  */
 298 kern_return_t
 299 clock_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
 308 kern_return_t
 309 rtclock_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
 322 kern_return_t
 323 calend_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  */
 339 kern_return_t
 340 clock_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
 353 kern_return_t
 354 rtclock_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
 378 kern_return_t
 379 calend_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  */
 409 kern_return_t
 410 clock_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  */
 422 kern_return_t
 423 clock_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  */
 437 kern_return_t
 438 clock_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  */
 505 kern_return_t
 506 clock_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
 543 static kern_return_t
 544 clock_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  */
 633 static void
 634 alarm_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
 701 static void
 702 alarm_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  */
 739 static void
 740 post_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
 773 static void
 774 set_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  */
 789 static int
 790 check_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
 811 mach_timespec_t
 812 clock_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
 822 mach_timespec_t
 823 clock_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__ */