/* * 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;}