minix/kernel/clock.c

287 lines
11 KiB
C
Raw Normal View History

2005-04-21 16:53:53 +02:00
/* The file contais the clock task, which handles all time related functions.
* Important events that are handled by the CLOCK include alarm timers and
* (re)scheduling user processes.
* The CLOCK offers a direct interface to kernel processes. System services
* can access its services through system calls, such as sys_setalarm(). The
* CLOCK task thus is hidden for the outside world.
2005-04-21 16:53:53 +02:00
*
* Changes:
* Mar 18, 2004 clock interface moved to SYSTEM task (Jorrit N. Herder)
* Sep 30, 2004 source code documentation updated (Jorrit N. Herder)
* Sep 24, 2004 redesigned alarm timers (Jorrit N. Herder)
2005-04-21 16:53:53 +02:00
*
* The function do_clocktick() is not triggered by the clock's interrupt
* handler when a watchdog timer has expired or a process must be scheduled.
2005-04-21 16:53:53 +02:00
*
* In addition to the main clock_task() entry point, which starts the main
* loop, there are several other minor entry points:
* clock_stop: called just before MINIX shutdown
* get_uptime: get realtime since boot in clock ticks
* set_timer: set a watchdog timer (+)
* reset_timer: reset a watchdog timer (+)
2005-04-21 16:53:53 +02:00
* calc_elapsed: do timing measurements: get delta ticks and pulses
* read_clock: read the counter of channel 0 of the 8253A timer
*
* (+) The CLOCK task keeps tracks of watchdog timers for the entire kernel.
2005-04-21 16:53:53 +02:00
* The watchdog functions of expired timers are executed in do_clocktick().
* It is crucial that watchdog functions cannot block, or the CLOCK task may
* be blocked. Do not send() a message when the receiver is not expecting it.
* Instead, notify(), which always returns, should be used.
2005-04-21 16:53:53 +02:00
*/
#include "kernel.h"
#include "proc.h"
#include <signal.h>
#include <minix/com.h>
/* Function prototype for PRIVATE functions. */
FORWARD _PROTOTYPE( void init_clock, (void) );
FORWARD _PROTOTYPE( int clock_handler, (irq_hook_t *hook) );
FORWARD _PROTOTYPE( int do_clocktick, (message *m_ptr) );
/* Clock parameters. */
#if (CHIP == INTEL)
#define COUNTER_FREQ (2*TIMER_FREQ) /* counter frequency using square wave */
#define LATCH_COUNT 0x00 /* cc00xxxx, c = channel, x = any */
#define SQUARE_WAVE 0x36 /* ccaammmb, a = access, m = mode, b = BCD */
/* 11x11, 11 = LSB then MSB, x11 = sq wave */
#define TIMER_COUNT ((unsigned) (TIMER_FREQ/HZ)) /* initial value for counter*/
#define TIMER_FREQ 1193182L /* clock frequency for timer in PC and AT */
#define CLOCK_ACK_BIT 0x80 /* PS/2 clock interrupt acknowledge bit */
#endif
#if (CHIP == M68000)
#define TIMER_FREQ 2457600L /* timer 3 input clock frequency */
#endif
/* The CLOCK's timers queue. The functions in <timers.h> operate on this.
* All system processes possess a single synchronous alarm timer. If other
* kernel parts want to use additional timers, they must declare their own
* persistent (static) timer structure, which can be passed to the clock
2005-04-21 16:53:53 +02:00
* via (re)set_timer().
* When a timer expires its watchdog function is run by the CLOCK task.
*/
PRIVATE timer_t *clock_timers; /* queue of CLOCK timers */
PRIVATE clock_t next_timeout; /* realtime that next timer expires */
/* The time is incremented by the interrupt handler on each clock tick. */
2005-04-21 16:53:53 +02:00
PRIVATE clock_t realtime; /* real time clock */
PRIVATE irq_hook_t clock_hook; /* interrupt handler hook */
2005-04-21 16:53:53 +02:00
/*===========================================================================*
* clock_task *
*===========================================================================*/
PUBLIC void clock_task()
{
/* Main program of clock task. It determines which call this is by looking at
* the message type and dispatches.
2005-04-21 16:53:53 +02:00
*/
message m; /* message buffer for both input and output */
int result; /* result returned by the handler */
2005-04-21 16:53:53 +02:00
init_clock(); /* initialize clock task */
/* Main loop of the clock task. Get work, process it, sometimes reply. */
while (TRUE) {
2005-04-21 16:53:53 +02:00
/* Go get a message. */
receive(ANY, &m);
/* Handle the request. Only clock ticks are expected. */
2005-04-21 16:53:53 +02:00
switch (m.m_type) {
case HARD_INT:
result = do_clocktick(&m); /* handle clock tick */
break;
default: /* illegal request type */
kprintf("CLOCK: illegal request %d from %d.\n", m.m_type,m.m_source);
2005-04-21 16:53:53 +02:00
}
}
}
/*===========================================================================*
* do_clocktick *
*===========================================================================*/
PRIVATE int do_clocktick(m_ptr)
message *m_ptr; /* pointer to request message */
{
/* Despite its name, this routine is not called on every clock tick. It
* is called on those clock ticks when a lot of work needs to be done.
*/
/* A process used up a full quantum. The interrupt handler stored this
* process in 'prev_ptr'. First make sure that the process is not on the
* scheduling queues. Then announce the process ready again. Since it has
* no more time left, it will get a new quantum and inserted at the right
* place in the queues. As a side-effect a new process will be scheduled.
*/
if (prev_ptr->p_ticks_left <= 0 && priv(prev_ptr)->s_flags & PREEMPTIBLE) {
lock_dequeue(prev_ptr); /* take it off the queues */
lock_enqueue(prev_ptr); /* and reinsert it again */
}
2005-04-21 16:53:53 +02:00
/* Check if a clock timer expired and run its watchdog function. */
if (next_timeout <= realtime) {
tmrs_exptimers(&clock_timers, realtime, NULL);
2005-04-21 16:53:53 +02:00
next_timeout = clock_timers == NULL ?
TMR_NEVER : clock_timers->tmr_exp_time;
}
/* Inhibit sending a reply. */
return(EDONTREPLY);
}
/*===========================================================================*
* clock_handler *
*===========================================================================*/
PRIVATE int clock_handler(hook)
irq_hook_t *hook;
{
/* This executes on each clock tick (i.e., every time the timer chip generates
* an interrupt). It does a little bit of work so the clock task does not have
* to be called on every tick. The clock task is called when:
2005-04-21 16:53:53 +02:00
*
* (1) the scheduling quantum of the running process has expired, or
* (2) a timer has expired and the watchdog function should be run.
2005-04-21 16:53:53 +02:00
*
* Many global global and static variables are accessed here. The safety of
* this must be justified. All scheduling and message passing code acquires a
* lock by temporarily disabling interrupts, so no conflicts with calls from
* the task level can occur. Furthermore, interrupts are not reentrant, the
* interrupt handler cannot be bothered by other interrupts.
*
* Variables that are updated in the clock's interrupt handler:
* lost_ticks:
* Clock ticks counted outside the clock task. This for example
* is used when the boot monitor processes a real mode interrupt.
* realtime:
* The current uptime is incremented with all outstanding ticks.
2005-04-21 16:53:53 +02:00
* proc_ptr, bill_ptr:
* These are used for accounting. It does not matter if proc.c
* is changing them, provided they are always valid pointers,
* since at worst the previous process would be billed.
*/
register unsigned ticks;
/* Acknowledge the PS/2 clock interrupt. */
2005-04-29 17:36:43 +02:00
if (machine.ps_mca) outb(PORT_B, inb(PORT_B) | CLOCK_ACK_BIT);
2005-04-21 16:53:53 +02:00
/* Get number of ticks and update realtime. */
ticks = lost_ticks + 1;
lost_ticks = 0;
realtime += ticks;
2005-04-21 16:53:53 +02:00
/* Update user and system accounting times. Charge the current process for
* user time. If the current process is not billable, that is, if a non-user
* process is running, charge the billable process for system time as well.
* Thus the unbillable process' user time is the billable user's system time.
*/
proc_ptr->p_user_time += ticks;
if (priv(proc_ptr)->s_flags & PREEMPTIBLE) {
proc_ptr->p_ticks_left -= ticks;
}
if (! (priv(proc_ptr)->s_flags & BILLABLE)) {
bill_ptr->p_sys_time += ticks;
bill_ptr->p_ticks_left -= ticks;
}
2005-04-21 16:53:53 +02:00
/* Check if do_clocktick() must be called. Done for alarms and scheduling.
* Some processes, such as the kernel tasks, cannot be preempted.
2005-04-21 16:53:53 +02:00
*/
if ((next_timeout <= realtime) || (proc_ptr->p_ticks_left <= 0)) {
prev_ptr = proc_ptr; /* store running process */
lock_notify(HARDWARE, CLOCK); /* send notification */
2005-04-21 16:53:53 +02:00
}
return(1); /* reenable interrupts */
2005-04-21 16:53:53 +02:00
}
/*===========================================================================*
* get_uptime *
*===========================================================================*/
PUBLIC clock_t get_uptime()
{
/* Get and return the current clock uptime in ticks. */
return(realtime);
2005-04-21 16:53:53 +02:00
}
/*===========================================================================*
* set_timer *
*===========================================================================*/
PUBLIC void set_timer(tp, exp_time, watchdog)
struct timer *tp; /* pointer to timer structure */
clock_t exp_time; /* expiration realtime */
tmr_func_t watchdog; /* watchdog to be called */
{
/* Insert the new timer in the active timers list. Always update the
* next timeout time by setting it to the front of the active list.
*/
tmrs_settimer(&clock_timers, tp, exp_time, watchdog, NULL);
2005-04-21 16:53:53 +02:00
next_timeout = clock_timers->tmr_exp_time;
}
/*===========================================================================*
* reset_timer *
*===========================================================================*/
PUBLIC void reset_timer(tp)
struct timer *tp; /* pointer to timer structure */
{
/* The timer pointed to by 'tp' is no longer needed. Remove it from both the
* active and expired lists. Always update the next timeout time by setting
* it to the front of the active list.
*/
tmrs_clrtimer(&clock_timers, tp, NULL);
2005-04-21 16:53:53 +02:00
next_timeout = (clock_timers == NULL) ?
TMR_NEVER : clock_timers->tmr_exp_time;
}
#if (CHIP == INTEL)
/*===========================================================================*
* init_clock *
*===========================================================================*/
PRIVATE void init_clock()
{
/* Initialize the CLOCK's interrupt hook. */
clock_hook.proc_nr = CLOCK;
2005-04-21 16:53:53 +02:00
/* Initialize channel 0 of the 8253A timer to, e.g., 60 Hz. */
2005-04-21 16:53:53 +02:00
outb(TIMER_MODE, SQUARE_WAVE); /* set timer to run continuously */
outb(TIMER0, TIMER_COUNT); /* load timer low byte */
outb(TIMER0, TIMER_COUNT >> 8); /* load timer high byte */
put_irq_handler(&clock_hook, CLOCK_IRQ, clock_handler);/* register handler */
enable_irq(&clock_hook); /* ready for clock interrupts */
}
/*===========================================================================*
* clock_stop *
*===========================================================================*/
PUBLIC void clock_stop()
{
/* Reset the clock to the BIOS rate. (For rebooting) */
outb(TIMER_MODE, 0x36);
outb(TIMER0, 0);
outb(TIMER0, 0);
}
/*===========================================================================*
* read_clock *
*===========================================================================*/
PUBLIC unsigned long read_clock()
{
/* Read the counter of channel 0 of the 8253A timer. This counter counts
* down at a rate of TIMER_FREQ and restarts at TIMER_COUNT-1 when it
* reaches zero. A hardware interrupt (clock tick) occurs when the counter
* gets to zero and restarts its cycle.
*/
unsigned count;
outb(TIMER_MODE, LATCH_COUNT);
count = inb(TIMER0);
count |= (inb(TIMER0) << 8);
return count;
}
#endif /* (CHIP == INTEL) */