![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to clock.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 ! root 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: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * File: kern/clock.c ! 27: * Purpose: Routines for the creation and use of kernel ! 28: * alarm clock services. This file and the ipc ! 29: * routines in kern/ipc_clock.c constitute the ! 30: * machine-independent clock service layer. ! 31: */ ! 32: ! 33: #include <cpus.h> ! 34: #include <mach_host.h> ! 35: ! 36: #include <mach/boolean.h> ! 37: #include <mach/policy.h> ! 38: #include <mach/processor_info.h> ! 39: #include <mach/vm_param.h> ! 40: #include <machine/mach_param.h> ! 41: #include <kern/cpu_number.h> ! 42: #include <kern/misc_protos.h> ! 43: #include <kern/lock.h> ! 44: #include <kern/host.h> ! 45: #include <kern/processor.h> ! 46: #include <kern/sched.h> ! 47: #include <kern/spl.h> ! 48: #include <kern/thread.h> ! 49: #include <kern/thread_swap.h> ! 50: #include <kern/ipc_host.h> ! 51: #include <kern/clock.h> ! 52: #include <kern/zalloc.h> ! 53: #include <kern/sf.h> ! 54: #include <ipc/ipc_port.h> ! 55: #include <mach/mach_syscalls.h> ! 56: ! 57: #include <mach/clock_reply.h> ! 58: ! 59: /* ! 60: * Exported interface ! 61: */ ! 62: ! 63: #include <mach/clock_server.h> ! 64: #include <mach/mach_host_server.h> ! 65: ! 66: /* local data declarations */ ! 67: decl_simple_lock_data(static,ClockLock) /* clock system synchronization */ ! 68: static struct zone *alarm_zone; /* zone for user alarms */ ! 69: static struct alarm *alrmfree; /* alarm free list pointer */ ! 70: static struct alarm *alrmdone; /* alarm done list pointer */ ! 71: static long alrm_seqno; /* uniquely identifies alarms */ ! 72: static thread_call_data_t alarm_deliver; ! 73: ! 74: /* backwards compatibility */ ! 75: int hz = HZ; /* GET RID OF THIS !!! */ ! 76: int tick = (1000000 / HZ); /* GET RID OF THIS !!! */ ! 77: ! 78: /* external declarations */ ! 79: extern struct clock clock_list[]; ! 80: extern int clock_count; ! 81: ! 82: /* local clock subroutines */ ! 83: static ! 84: void flush_alarms( ! 85: clock_t clock); ! 86: ! 87: static ! 88: void post_alarm( ! 89: clock_t clock, ! 90: alarm_t alarm); ! 91: ! 92: static ! 93: int check_time( ! 94: alarm_type_t alarm_type, ! 95: mach_timespec_t *alarm_time, ! 96: mach_timespec_t *clock_time); ! 97: ! 98: static void clock_alarm_deliver(void); ! 99: ! 100: /* ! 101: * Macros to lock/unlock clock system. ! 102: */ ! 103: #define LOCK_CLOCK(s) \ ! 104: s = splclock(); \ ! 105: simple_lock(&ClockLock); ! 106: ! 107: #define UNLOCK_CLOCK(s) \ ! 108: simple_unlock(&ClockLock); \ ! 109: splx(s); ! 110: ! 111: /* ! 112: * Configure the clock system. (Not sure if we need this, ! 113: * as separate from clock_init()). ! 114: */ ! 115: void ! 116: clock_config(void) ! 117: { ! 118: clock_t clock; ! 119: register int i; ! 120: ! 121: if (cpu_number() != master_cpu) ! 122: panic("clock_config"); ! 123: ! 124: /* ! 125: * Configure clock devices. ! 126: */ ! 127: simple_lock_init(&ClockLock, ETAP_MISC_CLOCK); ! 128: for (i = 0; i < clock_count; i++) { ! 129: clock = &clock_list[i]; ! 130: if (clock->cl_ops) { ! 131: if ((*clock->cl_ops->c_config)() == 0) ! 132: clock->cl_ops = 0; ! 133: } ! 134: } ! 135: ! 136: /* start alarm sequence numbers at 0 */ ! 137: alrm_seqno = 0; ! 138: } ! 139: ! 140: /* ! 141: * Initialize the clock system. ! 142: */ ! 143: void ! 144: clock_init(void) ! 145: { ! 146: clock_t clock; ! 147: register int i; ! 148: ! 149: /* ! 150: * Initialize basic clock structures. ! 151: */ ! 152: for (i = 0; i < clock_count; i++) { ! 153: clock = &clock_list[i]; ! 154: if (clock->cl_ops) ! 155: (*clock->cl_ops->c_init)(); ! 156: } ! 157: } ! 158: ! 159: /* ! 160: * Initialize the clock ipc service facility. ! 161: */ ! 162: void ! 163: clock_service_create(void) ! 164: { ! 165: clock_t clock; ! 166: register int i; ! 167: ! 168: /* ! 169: * Initialize ipc clock services. ! 170: */ ! 171: for (i = 0; i < clock_count; i++) { ! 172: clock = &clock_list[i]; ! 173: if (clock->cl_ops) { ! 174: ipc_clock_init(clock); ! 175: ipc_clock_enable(clock); ! 176: } ! 177: } ! 178: ! 179: /* ! 180: * Initialize clock service alarms. ! 181: */ ! 182: i = sizeof(struct alarm); ! 183: alarm_zone = zinit(i, (4096/i)*i, 10*i, "alarms"); ! 184: ! 185: /* ! 186: * Initialize the clock alarm delivery mechanism. ! 187: */ ! 188: thread_call_setup(&alarm_deliver, clock_alarm_deliver, NULL); ! 189: } ! 190: ! 191: /* ! 192: * Get the service port on a clock. ! 193: */ ! 194: kern_return_t ! 195: host_get_clock_service( ! 196: host_t host, ! 197: clock_id_t clock_id, ! 198: clock_t *clock) /* OUT */ ! 199: { ! 200: if (host == HOST_NULL || clock_id < 0 || clock_id >= clock_count) { ! 201: *clock = CLOCK_NULL; ! 202: return (KERN_INVALID_ARGUMENT); ! 203: } ! 204: ! 205: *clock = &clock_list[clock_id]; ! 206: if ((*clock)->cl_ops == 0) ! 207: return (KERN_FAILURE); ! 208: return (KERN_SUCCESS); ! 209: } ! 210: ! 211: /* ! 212: * Get the control port on a clock. ! 213: */ ! 214: kern_return_t ! 215: host_get_clock_control( ! 216: host_t host, ! 217: clock_id_t clock_id, ! 218: clock_t *clock) /* OUT */ ! 219: { ! 220: if (host == HOST_NULL || clock_id < 0 || clock_id >= clock_count) { ! 221: *clock = CLOCK_NULL; ! 222: return (KERN_INVALID_ARGUMENT); ! 223: } ! 224: ! 225: *clock = &clock_list[clock_id]; ! 226: if ((*clock)->cl_ops == 0) ! 227: return (KERN_FAILURE); ! 228: return (KERN_SUCCESS); ! 229: } ! 230: ! 231: /* ! 232: * Get the current clock time. ! 233: */ ! 234: kern_return_t ! 235: clock_get_time( ! 236: clock_t clock, ! 237: mach_timespec_t *cur_time) /* OUT */ ! 238: { ! 239: if (clock == CLOCK_NULL) ! 240: return (KERN_INVALID_ARGUMENT); ! 241: return ((*clock->cl_ops->c_gettime)(cur_time)); ! 242: } ! 243: ! 244: /* ! 245: * Get clock attributes. ! 246: */ ! 247: kern_return_t ! 248: clock_get_attributes( ! 249: clock_t clock, ! 250: clock_flavor_t flavor, ! 251: clock_attr_t attr, /* OUT */ ! 252: mach_msg_type_number_t *count) /* IN/OUT */ ! 253: { ! 254: kern_return_t (*getattr)( ! 255: clock_flavor_t flavor, ! 256: clock_attr_t attr, ! 257: mach_msg_type_number_t *count); ! 258: ! 259: if (clock == CLOCK_NULL) ! 260: return (KERN_INVALID_ARGUMENT); ! 261: if (getattr = clock->cl_ops->c_getattr) ! 262: return((*getattr)(flavor, attr, count)); ! 263: else ! 264: return (KERN_FAILURE); ! 265: } ! 266: ! 267: /* ! 268: * Set the current clock time. ! 269: */ ! 270: kern_return_t ! 271: clock_set_time( ! 272: clock_t clock, ! 273: mach_timespec_t new_time) ! 274: { ! 275: mach_timespec_t *clock_time; ! 276: kern_return_t (*settime)( ! 277: mach_timespec_t *clock_time); ! 278: ! 279: if (clock == CLOCK_NULL) ! 280: return (KERN_INVALID_ARGUMENT); ! 281: if ((settime = clock->cl_ops->c_settime) == 0) ! 282: return (KERN_FAILURE); ! 283: clock_time = &new_time; ! 284: if (BAD_MACH_TIMESPEC(clock_time)) ! 285: return (KERN_INVALID_VALUE); ! 286: ! 287: /* ! 288: * Flush all outstanding alarms. ! 289: */ ! 290: flush_alarms(clock); ! 291: ! 292: /* ! 293: * Set the new time. ! 294: */ ! 295: return ((*settime)(clock_time)); ! 296: } ! 297: ! 298: /* ! 299: * Set the clock alarm resolution. ! 300: */ ! 301: kern_return_t ! 302: clock_set_attributes( ! 303: clock_t clock, ! 304: clock_flavor_t flavor, ! 305: clock_attr_t attr, ! 306: mach_msg_type_number_t count) ! 307: { ! 308: kern_return_t (*setattr)( ! 309: clock_flavor_t flavor, ! 310: clock_attr_t attr, ! 311: mach_msg_type_number_t count); ! 312: ! 313: if (clock == CLOCK_NULL) ! 314: return (KERN_INVALID_ARGUMENT); ! 315: if (setattr = clock->cl_ops->c_setattr) ! 316: return ((*setattr)(flavor, attr, count)); ! 317: else ! 318: return (KERN_FAILURE); ! 319: } ! 320: ! 321: /* ! 322: * Setup a clock alarm. ! 323: */ ! 324: kern_return_t ! 325: clock_alarm( ! 326: clock_t clock, ! 327: alarm_type_t alarm_type, ! 328: mach_timespec_t alarm_time, ! 329: ipc_port_t alarm_port, ! 330: mach_msg_type_name_t alarm_port_type) ! 331: { ! 332: alarm_t alarm; ! 333: mach_timespec_t clock_time; ! 334: int chkstat; ! 335: kern_return_t reply_code; ! 336: spl_t s; ! 337: ! 338: if (clock == CLOCK_NULL) ! 339: return (KERN_INVALID_ARGUMENT); ! 340: if (clock->cl_ops->c_setalrm == 0) ! 341: return (KERN_FAILURE); ! 342: if (IP_VALID(alarm_port) == 0) ! 343: return (KERN_INVALID_CAPABILITY); ! 344: ! 345: /* ! 346: * Check alarm parameters. If parameters are invalid, ! 347: * send alarm message immediately. ! 348: */ ! 349: (*clock->cl_ops->c_gettime)(&clock_time); ! 350: chkstat = check_time(alarm_type, &alarm_time, &clock_time); ! 351: if (chkstat <= 0) { ! 352: reply_code = (chkstat < 0 ? KERN_INVALID_VALUE : KERN_SUCCESS); ! 353: clock_alarm_reply(alarm_port, alarm_port_type, ! 354: reply_code, alarm_type, clock_time); ! 355: return (KERN_SUCCESS); ! 356: } ! 357: ! 358: /* ! 359: * Get alarm and add to clock alarm list. ! 360: */ ! 361: ! 362: LOCK_CLOCK(s); ! 363: if ((alarm = alrmfree) == 0) { ! 364: UNLOCK_CLOCK(s); ! 365: alarm = (alarm_t) zalloc(alarm_zone); ! 366: if (alarm == 0) ! 367: return (KERN_RESOURCE_SHORTAGE); ! 368: LOCK_CLOCK(s); ! 369: } ! 370: else ! 371: alrmfree = alarm->al_next; ! 372: ! 373: alarm->al_status = ALARM_CLOCK; ! 374: alarm->al_time = alarm_time; ! 375: alarm->al_type = alarm_type; ! 376: alarm->al_port = alarm_port; ! 377: alarm->al_port_type = alarm_port_type; ! 378: alarm->al_clock = clock; ! 379: alarm->al_policy = POLICY_NULL; ! 380: alarm->al_seqno = alrm_seqno++; ! 381: post_alarm(clock, alarm); ! 382: UNLOCK_CLOCK(s); ! 383: ! 384: return (KERN_SUCCESS); ! 385: } ! 386: ! 387: /* ! 388: * Set a clock alarm for a scheduling policy. ! 389: */ ! 390: kern_return_t ! 391: clock_alarm_sp( ! 392: alarm_type_t alarm_type, ! 393: mach_timespec_t alarm_time, ! 394: long *alarm_id, ! 395: int policy, ! 396: void *alarm_data, ! 397: alarm_t alarm) ! 398: { ! 399: clock_t clock; ! 400: mach_timespec_t clock_time; ! 401: int chkstat; ! 402: spl_t s; ! 403: ! 404: /* Always use system clock. */ ! 405: clock = &clock_list[SYSTEM_CLOCK]; ! 406: ! 407: if (clock->cl_ops->c_setalrm == 0) ! 408: return (KERN_FAILURE); ! 409: ! 410: assert(alarm != 0); ! 411: ! 412: /* ! 413: * Check alarm parameters. If parameters are invalid, ! 414: * send alarm message immediately. ! 415: */ ! 416: (*clock->cl_ops->c_gettime)(&clock_time); ! 417: chkstat = check_time(alarm_type, &alarm_time, &clock_time); ! 418: if (chkstat <= 0) { ! 419: return(chkstat < 0 ? KERN_INVALID_VALUE : KERN_RETURN_MAX); ! 420: /*** ??? define a better value for `KERN_RETURN_MAX' ***/ ! 421: } ! 422: ! 423: /* ! 424: * Get alarm and add to clock alarm list. ! 425: */ ! 426: ! 427: LOCK_CLOCK(s); ! 428: alarm->al_status = ALARM_CLOCK; ! 429: alarm->al_time = alarm_time; ! 430: alarm->al_type = alarm_type; ! 431: alarm->al_port = IP_NULL; ! 432: alarm->al_port_type = 0; ! 433: alarm->al_clock = clock; ! 434: alarm->al_data = alarm_data; ! 435: alarm->al_policy = policy; ! 436: alarm->al_seqno = alrm_seqno++; ! 437: *alarm_id = alarm->al_seqno; ! 438: post_alarm(clock, alarm); ! 439: UNLOCK_CLOCK(s); ! 440: ! 441: return (KERN_SUCCESS); ! 442: } ! 443: ! 444: /* ! 445: * Cancel a clock alarm on behalf of a scheduling policy. ! 446: */ ! 447: kern_return_t ! 448: clock_alarm_cancel_sp( ! 449: long alarm_id) ! 450: { ! 451: clock_t clock; ! 452: alarm_t alrm1, alrm2; ! 453: kern_return_t kr = KERN_FAILURE; ! 454: spl_t s; ! 455: ! 456: /* ! 457: * Cancel alarm with ID `alarm_id.' ! 458: */ ! 459: ! 460: /* Always use system clock. */ ! 461: clock = &clock_list[SYSTEM_CLOCK]; ! 462: ! 463: /* Assume you can't cancel alarms if you can't set them */ ! 464: if (clock->cl_ops->c_setalrm == 0) ! 465: return (KERN_FAILURE); ! 466: ! 467: LOCK_CLOCK(s); ! 468: alrm1 = (alarm_t) &clock->cl_alarm; ! 469: while (alrm2 = alrm1->al_next) { ! 470: /* ! 471: * See if alarm is still in alarm list. ! 472: */ ! 473: if (alrm2->al_seqno == alarm_id) { ! 474: /* Found it. Now remove it. */ ! 475: if (alrm1->al_next = alrm2->al_next) { ! 476: (alrm1->al_next)->al_prev = alrm1; ! 477: } ! 478: ! 479: /* Indicate success */ ! 480: kr = KERN_SUCCESS; ! 481: ! 482: /* ! 483: * If the canceled alarm is the 'earliest' alarm, ! 484: * reset the device layer alarm time accordingly. ! 485: */ ! 486: if (clock->cl_alarm.al_next == alrm2) ! 487: (*clock->cl_ops->c_setalrm) ! 488: (&((clock->cl_alarm.al_next)->al_time)); ! 489: ! 490: /* Quit looking */ ! 491: break; ! 492: } ! 493: } ! 494: UNLOCK_CLOCK(s); ! 495: ! 496: return(kr); ! 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: mach_port_name_t clock_name, ! 508: sleep_type_t sleep_type, ! 509: int sleep_sec, ! 510: int sleep_nsec, ! 511: mach_timespec_t *wakeup_time) ! 512: { ! 513: clock_t clock; ! 514: mach_timespec_t swtime; ! 515: kern_return_t rvalue; ! 516: ! 517: /* ! 518: * Convert the trap parameters. ! 519: */ ! 520: clock = port_name_to_clock(clock_name); ! 521: swtime.tv_sec = sleep_sec; ! 522: swtime.tv_nsec = sleep_nsec; ! 523: ! 524: /* ! 525: * Call the actual clock_sleep routine. ! 526: */ ! 527: rvalue = clock_sleep_internal(clock, sleep_type, &swtime); ! 528: ! 529: /* ! 530: * Return current time as wakeup time. ! 531: */ ! 532: if (rvalue != KERN_INVALID_ARGUMENT && rvalue != KERN_FAILURE) { ! 533: copyout((char *)&swtime, (char *)wakeup_time, ! 534: sizeof(mach_timespec_t)); ! 535: } ! 536: return (rvalue); ! 537: } ! 538: ! 539: /* ! 540: * Kernel internally callable clock sleep routine. The calling ! 541: * thread is suspended until the requested sleep time is reached. ! 542: */ ! 543: 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: if (clock->cl_ops->c_setalrm == 0) ! 558: return (KERN_FAILURE); ! 559: ! 560: /* ! 561: * Check sleep parameters. If parameters are invalid ! 562: * return an error, otherwise post alarm request. ! 563: */ ! 564: (*clock->cl_ops->c_gettime)(&clock_time); ! 565: ! 566: chkstat = check_time(sleep_type, sleep_time, &clock_time); ! 567: if (chkstat < 0) ! 568: return (KERN_INVALID_VALUE); ! 569: rvalue = KERN_SUCCESS; ! 570: if (chkstat > 0) { ! 571: /* ! 572: * Get alarm and add to clock alarm list. ! 573: */ ! 574: ! 575: LOCK_CLOCK(s); ! 576: if ((alarm = alrmfree) == 0) { ! 577: UNLOCK_CLOCK(s); ! 578: alarm = (alarm_t) zalloc(alarm_zone); ! 579: if (alarm == 0) ! 580: return (KERN_RESOURCE_SHORTAGE); ! 581: LOCK_CLOCK(s); ! 582: } ! 583: else ! 584: alrmfree = alarm->al_next; ! 585: ! 586: alarm->al_time = *sleep_time; ! 587: alarm->al_status = ALARM_SLEEP; ! 588: post_alarm(clock, alarm); ! 589: ! 590: /* ! 591: * Wait for alarm to occur. ! 592: */ ! 593: assert_wait((event_t)alarm, THREAD_ABORTSAFE); ! 594: UNLOCK_CLOCK(s); ! 595: /* should we force spl(0) at this point? */ ! 596: thread_block((void (*)(void)) 0); ! 597: /* we should return here at ipl0 */ ! 598: ! 599: /* ! 600: * Note if alarm expired normally or whether it ! 601: * was aborted. If aborted, delete alarm from ! 602: * clock alarm list. Return alarm to free list. ! 603: */ ! 604: LOCK_CLOCK(s); ! 605: if (alarm->al_status != ALARM_DONE) { ! 606: /* This means we were interrupted and that ! 607: thread->wait_result != THREAD_AWAKENED. */ ! 608: if ((alarm->al_prev)->al_next = alarm->al_next) ! 609: (alarm->al_next)->al_prev = alarm->al_prev; ! 610: rvalue = KERN_ABORTED; ! 611: } ! 612: *sleep_time = alarm->al_time; ! 613: alarm->al_status = ALARM_FREE; ! 614: alarm->al_next = alrmfree; ! 615: alrmfree = alarm; ! 616: UNLOCK_CLOCK(s); ! 617: } ! 618: else ! 619: *sleep_time = clock_time; ! 620: ! 621: return (rvalue); ! 622: } ! 623: ! 624: /* ! 625: * CLOCK INTERRUPT SERVICE ROUTINES. ! 626: */ ! 627: ! 628: /* ! 629: * Service clock alarm interrupts. Called from machine dependent ! 630: * layer at splclock(). The clock_id argument specifies the clock, ! 631: * and the clock_time argument gives that clock's current time. ! 632: */ ! 633: void ! 634: clock_alarm_intr( ! 635: clock_id_t clock_id, ! 636: mach_timespec_t *clock_time) ! 637: { ! 638: clock_t clock; ! 639: register alarm_t alrm1; ! 640: register alarm_t alrm2; ! 641: mach_timespec_t *alarm_time; ! 642: spl_t s; ! 643: ! 644: clock = &clock_list[clock_id]; ! 645: ! 646: /* ! 647: * Update clock alarm list. All alarms that are due are moved ! 648: * to the alarmdone list to be serviced by the alarm_thread. ! 649: */ ! 650: ! 651: LOCK_CLOCK(s); ! 652: alrm1 = (alarm_t) &clock->cl_alarm; ! 653: while (alrm2 = alrm1->al_next) { ! 654: alarm_time = &alrm2->al_time; ! 655: if (CMP_MACH_TIMESPEC(alarm_time, clock_time) > 0) ! 656: break; ! 657: ! 658: /* ! 659: * Alarm has expired, so remove it from the ! 660: * clock alarm list. ! 661: */ ! 662: if (alrm1->al_next = alrm2->al_next) ! 663: (alrm1->al_next)->al_prev = alrm1; ! 664: ! 665: /* ! 666: * If a clock_sleep() alarm, wakeup the thread ! 667: * which issued the clock_sleep() call. ! 668: */ ! 669: if (alrm2->al_status == ALARM_SLEEP) { ! 670: alrm2->al_next = 0; ! 671: alrm2->al_status = ALARM_DONE; ! 672: alrm2->al_time = *clock_time; ! 673: thread_wakeup((event_t)alrm2); ! 674: } ! 675: ! 676: /* ! 677: * If a clock_alarm() alarm, place the alarm on ! 678: * the alarm done list and schedule the alarm ! 679: * delivery mechanism. ! 680: */ ! 681: else { ! 682: assert(alrm2->al_status == ALARM_CLOCK); ! 683: if (alrm2->al_next = alrmdone) ! 684: alrmdone->al_prev = alrm2; ! 685: else ! 686: thread_call_enter(&alarm_deliver); ! 687: alrm2->al_prev = (alarm_t) &alrmdone; ! 688: alrmdone = alrm2; ! 689: alrm2->al_status = ALARM_DONE; ! 690: alrm2->al_time = *clock_time; ! 691: } ! 692: } ! 693: ! 694: /* ! 695: * Setup the clock dependent layer to deliver another ! 696: * interrupt for the next pending alarm. ! 697: */ ! 698: if (alrm2) ! 699: (*clock->cl_ops->c_setalrm)(alarm_time); ! 700: UNLOCK_CLOCK(s); ! 701: } ! 702: ! 703: /* ! 704: * ALARM DELIVERY ROUTINES. ! 705: */ ! 706: ! 707: static ! 708: void ! 709: clock_alarm_deliver(void) ! 710: { ! 711: register alarm_t alrm; ! 712: kern_return_t code; ! 713: sched_policy_t *policy; ! 714: spl_t s; ! 715: ! 716: LOCK_CLOCK(s); ! 717: while (alrm = alrmdone) { ! 718: if (alrmdone = alrm->al_next) ! 719: alrmdone->al_prev = (alarm_t) &alrmdone; ! 720: UNLOCK_CLOCK(s); ! 721: ! 722: code = (alrm->al_status == ALARM_DONE? KERN_SUCCESS: KERN_ABORTED); ! 723: if (alrm->al_port != IP_NULL) { ! 724: /* Deliver message to designated port */ ! 725: if (IP_VALID(alrm->al_port)) { ! 726: clock_alarm_reply(alrm->al_port, alrm->al_port_type, code, ! 727: alrm->al_type, alrm->al_time); ! 728: } ! 729: ! 730: LOCK_CLOCK(s); ! 731: alrm->al_status = ALARM_FREE; ! 732: alrm->al_next = alrmfree; ! 733: alrmfree = alrm; ! 734: } ! 735: else { ! 736: /* Call designated scheduling policy's alarm routine */ ! 737: assert(alrm->al_policy != POLICY_NULL); ! 738: policy = &sched_policy[alrm->al_policy]; ! 739: policy->sp_ops.sp_alarm_expired(policy, alrm->al_seqno, code, ! 740: alrm->al_type, alrm->al_time, alrm->al_data); ! 741: ! 742: LOCK_CLOCK(s); ! 743: } ! 744: } ! 745: ! 746: UNLOCK_CLOCK(s); ! 747: } ! 748: ! 749: /* ! 750: * CLOCK PRIVATE SERVICING SUBROUTINES. ! 751: */ ! 752: ! 753: /* ! 754: * Flush all pending alarms on a clock. All alarms ! 755: * are activated and timestamped correctly, so any ! 756: * programs waiting on alarms/threads will proceed ! 757: * with accurate information. ! 758: */ ! 759: static ! 760: void ! 761: flush_alarms( ! 762: clock_t clock) ! 763: { ! 764: register alarm_t alrm1, alrm2; ! 765: spl_t s; ! 766: ! 767: /* ! 768: * Flush all outstanding alarms. ! 769: */ ! 770: LOCK_CLOCK(s); ! 771: alrm1 = (alarm_t) &clock->cl_alarm; ! 772: while (alrm2 = alrm1->al_next) { ! 773: /* ! 774: * Remove alarm from the clock alarm list. ! 775: */ ! 776: if (alrm1->al_next = alrm2->al_next) ! 777: (alrm1->al_next)->al_prev = alrm1; ! 778: ! 779: /* ! 780: * If a clock_sleep() alarm, wakeup the thread ! 781: * which issued the clock_sleep() call. ! 782: */ ! 783: if (alrm2->al_status == ALARM_SLEEP) { ! 784: alrm2->al_next = 0; ! 785: thread_wakeup((event_t)alrm2); ! 786: } ! 787: else { ! 788: /* ! 789: * If a clock_alarm() alarm, place the alarm on ! 790: * the alarm done list and wakeup the dedicated ! 791: * kernel alarm_thread to service the alarm. ! 792: */ ! 793: assert(alrm2->al_status == ALARM_CLOCK); ! 794: if (alrm2->al_next = alrmdone) ! 795: alrmdone->al_prev = alrm2; ! 796: else ! 797: thread_wakeup((event_t)&alrmdone); ! 798: alrm2->al_prev = (alarm_t) &alrmdone; ! 799: alrmdone = alrm2; ! 800: } ! 801: } ! 802: UNLOCK_CLOCK(s); ! 803: } ! 804: ! 805: /* ! 806: * Post an alarm on a clock's active alarm list. The alarm is ! 807: * inserted in time-order into the clock's active alarm list. ! 808: * Always called from within a LOCK_CLOCK() code section. ! 809: */ ! 810: static ! 811: void ! 812: post_alarm( ! 813: clock_t clock, ! 814: alarm_t alarm) ! 815: { ! 816: register alarm_t alrm1, alrm2; ! 817: mach_timespec_t *alarm_time; ! 818: mach_timespec_t *queue_time; ! 819: ! 820: /* ! 821: * Traverse alarm list until queue time is greater ! 822: * than alarm time, then insert alarm. ! 823: */ ! 824: alarm_time = &alarm->al_time; ! 825: alrm1 = (alarm_t) &clock->cl_alarm; ! 826: while (alrm2 = alrm1->al_next) { ! 827: queue_time = &alrm2->al_time; ! 828: if (CMP_MACH_TIMESPEC(queue_time, alarm_time) > 0) ! 829: break; ! 830: alrm1 = alrm2; ! 831: } ! 832: alrm1->al_next = alarm; ! 833: alarm->al_next = alrm2; ! 834: alarm->al_prev = alrm1; ! 835: if (alrm2) ! 836: alrm2->al_prev = alarm; ! 837: ! 838: /* ! 839: * If the inserted alarm is the 'earliest' alarm, ! 840: * reset the device layer alarm time accordingly. ! 841: */ ! 842: if (clock->cl_alarm.al_next == alarm) ! 843: (*clock->cl_ops->c_setalrm)(alarm_time); ! 844: } ! 845: ! 846: /* ! 847: * Check the validity of 'alarm_time' and 'alarm_type'. If either ! 848: * argument is invalid, return a negative value. If the 'alarm_time' ! 849: * is now, return a 0 value. If the 'alarm_time' is in the future, ! 850: * return a positive value. ! 851: */ ! 852: static ! 853: int ! 854: check_time( ! 855: alarm_type_t alarm_type, ! 856: mach_timespec_t *alarm_time, ! 857: mach_timespec_t *clock_time) ! 858: { ! 859: int result; ! 860: ! 861: if (BAD_ALRMTYPE(alarm_type)) ! 862: return (-1); ! 863: if (BAD_MACH_TIMESPEC(alarm_time)) ! 864: return (-1); ! 865: if ((alarm_type & ALRMTYPE) == TIME_RELATIVE) ! 866: ADD_MACH_TIMESPEC(alarm_time, clock_time); ! 867: ! 868: result = CMP_MACH_TIMESPEC(alarm_time, clock_time); ! 869: ! 870: return ((result >= 0)? result: 0); ! 871: } ! 872: ! 873: mach_timespec_t ! 874: clock_get_system_value(void) ! 875: { ! 876: clock_t clock = &clock_list[SYSTEM_CLOCK]; ! 877: mach_timespec_t value; ! 878: ! 879: (void) (*clock->cl_ops->c_gettime)(&value); ! 880: ! 881: return value; ! 882: } ! 883: ! 884: mach_timespec_t ! 885: clock_get_calendar_value(void) ! 886: { ! 887: clock_t clock = &clock_list[CALENDAR_CLOCK]; ! 888: mach_timespec_t value = MACH_TIMESPEC_ZERO; ! 889: ! 890: (void) (*clock->cl_ops->c_gettime)(&value); ! 891: ! 892: return value; ! 893: } ! 894: ! 895: void ! 896: clock_set_calendar_value( ! 897: mach_timespec_t value) ! 898: { ! 899: clock_t clock = &clock_list[CALENDAR_CLOCK]; ! 900: ! 901: (void) (*clock->cl_ops->c_settime)(&value); ! 902: } ! 903: ! 904: void ! 905: clock_deadline_for_periodic_event( ! 906: AbsoluteTime interval, ! 907: AbsoluteTime abstime, ! 908: AbsoluteTime *deadline) ! 909: { ! 910: assert(AbsoluteTime_to_scalar(&interval) != 0); ! 911: ! 912: ADD_ABSOLUTETIME(deadline, &interval); ! 913: ! 914: if ( AbsoluteTime_to_scalar(deadline) <= ! 915: AbsoluteTime_to_scalar(&abstime) ) { ! 916: *deadline = abstime; ! 917: clock_get_uptime(&abstime); ! 918: ADD_ABSOLUTETIME(deadline, &interval); ! 919: ! 920: if ( AbsoluteTime_to_scalar(deadline) <= ! 921: AbsoluteTime_to_scalar(&abstime) ) { ! 922: *deadline = abstime; ! 923: ADD_ABSOLUTETIME(deadline, &interval); ! 924: } ! 925: } ! 926: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.