d91f738bd8
Please note that this information is for use by system services only! The clock facility is not ready to be used directly by userland, and thus, this kernel page extension is NOT part of the userland ABI. For service programmers' convenience, change the prototype of the getticks(3) to return the uptime clock value directly, since the call can no longer fail. Correct the sys_times(2) reply message to use the right field type for the boot time. Restructure the kernel internals a bit so as to have all the clock stuff closer together. Change-Id: Ifc050b7bd253aecbe46e3bd7d7cc75bd86e45555
101 lines
2.7 KiB
C
101 lines
2.7 KiB
C
/* Helper functions that allow driver writers to easily busy-wait (spin) for a
|
|
* condition to become satisfied within a certain maximum time span.
|
|
*/
|
|
/* This implementation first spins without making any system calls for a
|
|
* while, and then starts using system calls (specifically, the system call to
|
|
* obtain the current time) while spinning. The reason for this is that in
|
|
* many cases, the condition to be checked will become satisfied rather
|
|
* quickly, and we want to avoid getting descheduled in that case. However,
|
|
* after a while, running out of scheduling quantum will cause our priority to
|
|
* be lowered, and we can avoid this by voluntarily giving up the CPU, by
|
|
* making a system call.
|
|
*/
|
|
#include "sysutil.h"
|
|
#include <minix/spin.h>
|
|
#include <minix/minlib.h>
|
|
|
|
/* Number of microseconds to keep spinning initially, without performing a
|
|
* system call. We pick a value somewhat smaller than a typical clock tick.
|
|
* Note that for the above reasons, we want to avoid using sys_hz() here.
|
|
*/
|
|
#define TSC_SPIN 1000 /* in microseconds */
|
|
|
|
/* Internal spin states. */
|
|
enum {
|
|
STATE_INIT, /* simply check the condition (once) */
|
|
STATE_BASE_TS, /* get the initial TSC value (once) */
|
|
STATE_TS, /* use the TSC to spin (up to TSC_SPIN us) */
|
|
STATE_UPTIME /* use the clock to spin */
|
|
};
|
|
|
|
void spin_init(spin_t *s, u32_t usecs)
|
|
{
|
|
/* Initialize the given spin state structure, set to spin at most the
|
|
* given number of microseconds.
|
|
*/
|
|
s->s_state = STATE_INIT;
|
|
s->s_usecs = usecs;
|
|
s->s_timeout = FALSE;
|
|
}
|
|
|
|
int spin_check(spin_t *s)
|
|
{
|
|
/* Check whether a timeout has taken place. Return TRUE if the caller
|
|
* should continue spinning, and FALSE if a timeout has occurred. The
|
|
* implementation assumes that it is okay to spin a little bit too long
|
|
* (up to a full clock tick extra).
|
|
*/
|
|
u64_t cur_tsc, tsc_delta;
|
|
clock_t now, micro_delta;
|
|
|
|
switch (s->s_state) {
|
|
case STATE_INIT:
|
|
s->s_state = STATE_BASE_TS;
|
|
break;
|
|
|
|
case STATE_BASE_TS:
|
|
s->s_state = STATE_TS;
|
|
read_tsc_64(&s->s_base_tsc);
|
|
break;
|
|
|
|
case STATE_TS:
|
|
read_tsc_64(&cur_tsc);
|
|
|
|
tsc_delta = cur_tsc - s->s_base_tsc;
|
|
|
|
micro_delta = tsc_64_to_micros(tsc_delta);
|
|
|
|
if (micro_delta >= s->s_usecs) {
|
|
s->s_timeout = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
if (micro_delta >= TSC_SPIN) {
|
|
s->s_usecs -= micro_delta;
|
|
s->s_base_uptime = getticks();
|
|
s->s_state = STATE_UPTIME;
|
|
}
|
|
|
|
break;
|
|
|
|
case STATE_UPTIME:
|
|
now = getticks();
|
|
|
|
/* We assume that sys_hz() caches its return value. */
|
|
micro_delta = ((now - s->s_base_uptime) * 1000 / sys_hz()) *
|
|
1000;
|
|
|
|
if (micro_delta >= s->s_usecs) {
|
|
s->s_timeout = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
panic("spin_check: invalid state %d", s->s_state);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|