blob: e1743c563206211488b87702718cef320056c0dc [file] [log] [blame]
/*
* linux/kernel/itimer.c
*
* Copyright (C) 1992 Darren Senn
*/
/* These are all the functions necessary to implement itimers */
#include <linux/mm.h>
#include <linux/smp_lock.h>
#include <linux/interrupt.h>
#include <linux/syscalls.h>
#include <linux/time.h>
#include <asm/uaccess.h>
int do_getitimer(int which, struct itimerval *value)
{
register unsigned long val;
switch (which) {
case ITIMER_REAL:
val = 0;
/*
* FIXME! This needs to be atomic, in case the kernel timer happens!
*/
if (timer_pending(&current->real_timer)) {
val = current->real_timer.expires - jiffies;
/* look out for negative/zero itimer.. */
if ((long) val <= 0)
val = 1;
}
jiffies_to_timeval(val, &value->it_value);
jiffies_to_timeval(current->it_real_incr, &value->it_interval);
break;
case ITIMER_VIRTUAL:
cputime_to_timeval(current->it_virt_value, &value->it_value);
cputime_to_timeval(current->it_virt_incr, &value->it_interval);
break;
case ITIMER_PROF:
cputime_to_timeval(current->it_prof_value, &value->it_value);
cputime_to_timeval(current->it_prof_incr, &value->it_interval);
break;
default:
return(-EINVAL);
}
return 0;
}
/* SMP: Only we modify our itimer values. */
asmlinkage long sys_getitimer(int which, struct itimerval __user *value)
{
int error = -EFAULT;
struct itimerval get_buffer;
if (value) {
error = do_getitimer(which, &get_buffer);
if (!error &&
copy_to_user(value, &get_buffer, sizeof(get_buffer)))
error = -EFAULT;
}
return error;
}
void it_real_fn(unsigned long __data)
{
struct task_struct * p = (struct task_struct *) __data;
unsigned long interval;
send_group_sig_info(SIGALRM, SEND_SIG_PRIV, p);
interval = p->it_real_incr;
if (interval) {
if (interval > (unsigned long) LONG_MAX)
interval = LONG_MAX;
p->real_timer.expires = jiffies + interval;
add_timer(&p->real_timer);
}
}
int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
{
unsigned long expire;
cputime_t cputime;
int k;
if (ovalue && (k = do_getitimer(which, ovalue)) < 0)
return k;
switch (which) {
case ITIMER_REAL:
del_timer_sync(&current->real_timer);
expire = timeval_to_jiffies(&value->it_value);
current->it_real_value = expire;
current->it_real_incr =
timeval_to_jiffies(&value->it_interval);
if (!expire)
break;
if (expire > (unsigned long) LONG_MAX)
expire = LONG_MAX;
current->real_timer.expires = jiffies + expire;
add_timer(&current->real_timer);
break;
case ITIMER_VIRTUAL:
cputime = timeval_to_cputime(&value->it_value);
if (cputime_gt(cputime, cputime_zero))
cputime = cputime_add(cputime,
jiffies_to_cputime(1));
current->it_virt_value = cputime;
cputime = timeval_to_cputime(&value->it_interval);
current->it_virt_incr = cputime;
break;
case ITIMER_PROF:
cputime = timeval_to_cputime(&value->it_value);
if (cputime_gt(cputime, cputime_zero))
cputime = cputime_add(cputime,
jiffies_to_cputime(1));
current->it_prof_value = cputime;
cputime = timeval_to_cputime(&value->it_interval);
current->it_prof_incr = cputime;
break;
default:
return -EINVAL;
}
return 0;
}
/* SMP: Again, only we play with our itimers, and signals are SMP safe
* now so that is not an issue at all anymore.
*/
asmlinkage long sys_setitimer(int which,
struct itimerval __user *value,
struct itimerval __user *ovalue)
{
struct itimerval set_buffer, get_buffer;
int error;
if (value) {
if(copy_from_user(&set_buffer, value, sizeof(set_buffer)))
return -EFAULT;
} else
memset((char *) &set_buffer, 0, sizeof(set_buffer));
error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : NULL);
if (error || !ovalue)
return error;
if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer)))
return -EFAULT;
return 0;
}