/*===========================================================================*
* do_setalarm *
*===========================================================================*/
int do_setalarm(struct proc * caller, message * m_ptr)
{
/* A process requests a synchronous alarm, or wants to cancel its alarm. */
long exp_time; /* expiration time for this alarm */
int use_abs_time; /* use absolute or relative time */
timer_t *tp; /* the process' timer structure */
clock_t uptime; /* placeholder for current uptime */
/* Extract shared parameters from the request message. */
exp_time = m_ptr->ALRM_EXP_TIME; /* alarm's expiration time */
use_abs_time = m_ptr->ALRM_ABS_TIME; /* flag for absolute time */
if (! (priv(caller)->s_flags & SYS_PROC)) return(EPERM);
/* Get the timer structure and set the parameters for this alarm. */
tp = &(priv(caller)->s_alarm_timer);
tmr_arg(tp)->ta_int = caller->p_endpoint;
tp->tmr_func = cause_alarm;
/* Return the ticks left on the previous alarm. */
uptime = get_monotonic();
if ((tp->tmr_exp_time != TMR_NEVER) && (uptime < tp->tmr_exp_time) ) {
m_ptr->ALRM_TIME_LEFT = (tp->tmr_exp_time - uptime);
} else {
m_ptr->ALRM_TIME_LEFT = 0;
}
/* Finally, (re)set the timer depending on the expiration time. */
if (exp_time == 0) {
reset_timer(tp);
} else {
tp->tmr_exp_time = (use_abs_time) ? exp_time : exp_time + get_monotonic();
set_timer(tp, tp->tmr_exp_time, tp->tmr_func);
}
return(OK);
}
time_t
uptime(void)
{
struct timeval tv;
if (get_monotonic(&tv) == -1)
return -1;
return tv.tv_sec;
}
/*===========================================================================*
* prepare_shutdown *
*===========================================================================*/
void prepare_shutdown(const int how)
{
/* This function prepares to shutdown MINIX. */
static timer_t shutdown_timer;
/* Continue after 1 second, to give processes a chance to get scheduled to
* do shutdown work. Set a watchog timer to call shutdown(). The timer
* argument passes the shutdown status.
*/
printf("MINIX will now be shut down ...\n");
tmr_arg(&shutdown_timer)->ta_int = how;
set_timer(&shutdown_timer, get_monotonic() + system_hz, minix_shutdown);
}
static void statmsg(message *msg, struct proc *srcp, struct proc *dstp)
{
int src, dst, now, secs, dt;
static int lastprint;
/* Stat message. */
assert(src);
proc2slot(srcp, src);
proc2slot(dstp, dst);
messages[src][dst]++;
/* Print something? */
now = get_monotonic();
dt = now - lastprint;
secs = dt/system_hz;
if(secs >= 30) {
memset(winners, 0, sizeof(winners));
sortstats();
printstats(dt);
memset(messages, 0, sizeof(messages));
lastprint = now;
}
}
/*===========================================================================*
* do_times *
*===========================================================================*/
int do_times(struct proc * caller, message * m_ptr)
{
/* Handle sys_times(). Retrieve the accounting information. */
register const struct proc *rp;
int proc_nr;
endpoint_t e_proc_nr;
/* Insert the times needed by the SYS_TIMES kernel call in the message.
* The clock's interrupt handler may run to update the user or system time
* while in this code, but that cannot do any harm.
*/
e_proc_nr = (m_ptr->m_lsys_krn_sys_times.endpt == SELF) ?
caller->p_endpoint : m_ptr->m_lsys_krn_sys_times.endpt;
if(e_proc_nr != NONE && isokendpt(e_proc_nr, &proc_nr)) {
rp = proc_addr(proc_nr);
m_ptr->m_krn_lsys_sys_times.user_time = rp->p_user_time;
m_ptr->m_krn_lsys_sys_times.system_time = rp->p_sys_time;
}
m_ptr->m_krn_lsys_sys_times.boot_ticks = get_monotonic();
m_ptr->m_krn_lsys_sys_times.real_ticks = get_realtime();
m_ptr->m_krn_lsys_sys_times.boot_time = boottime;
return(OK);
}