home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.0 / LINUX-1.0 / LINUX-1 / linux / kernel / itimer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-22  |  2.7 KB  |  127 lines
  1. /*
  2.  * linux/kernel/itimer.c
  3.  *
  4.  * Copyright (C) 1992 Darren Senn
  5.  */
  6.  
  7. /* These are all the functions necessary to implement itimers */
  8.  
  9. #include <linux/signal.h>
  10. #include <linux/sched.h>
  11. #include <linux/string.h>
  12. #include <linux/errno.h>
  13. #include <linux/time.h>
  14.  
  15. #include <asm/segment.h>
  16.  
  17. static unsigned long tvtojiffies(struct timeval *value)
  18. {
  19.     return((unsigned long )value->tv_sec * HZ +
  20.         (unsigned long )(value->tv_usec + (1000000 / HZ - 1)) /
  21.         (1000000 / HZ));
  22. }
  23.  
  24. static void jiffiestotv(unsigned long jiffies, struct timeval *value)
  25. {
  26.     value->tv_usec = (jiffies % HZ) * (1000000 / HZ);
  27.     value->tv_sec = jiffies / HZ;
  28.     return;
  29. }
  30.  
  31. int _getitimer(int which, struct itimerval *value)
  32. {
  33.     register unsigned long val, interval;
  34.  
  35.     switch (which) {
  36.     case ITIMER_REAL:
  37.         val = current->it_real_value;
  38.         interval = current->it_real_incr;
  39.         break;
  40.     case ITIMER_VIRTUAL:
  41.         val = current->it_virt_value;
  42.         interval = current->it_virt_incr;
  43.         break;
  44.     case ITIMER_PROF:
  45.         val = current->it_prof_value;
  46.         interval = current->it_prof_incr;
  47.         break;
  48.     default:
  49.         return(-EINVAL);
  50.     }
  51.     jiffiestotv(val, &value->it_value);
  52.     jiffiestotv(interval, &value->it_interval);
  53.     return(0);
  54. }
  55.  
  56. asmlinkage int sys_getitimer(int which, struct itimerval *value)
  57. {
  58.     int error;
  59.     struct itimerval get_buffer;
  60.  
  61.     if (!value)
  62.         return -EFAULT;
  63.     error = _getitimer(which, &get_buffer);
  64.     if (error)
  65.         return error;
  66.     error = verify_area(VERIFY_WRITE, value, sizeof(struct itimerval));
  67.     if (error)
  68.         return error;
  69.     memcpy_tofs(value, &get_buffer, sizeof(get_buffer));
  70.     return 0;
  71. }
  72.  
  73. int _setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
  74. {
  75.     register unsigned long i, j;
  76.     int k;
  77.  
  78.     i = tvtojiffies(&value->it_interval);
  79.     j = tvtojiffies(&value->it_value);
  80.     if (ovalue && (k = _getitimer(which, ovalue)) < 0)
  81.         return k;
  82.     switch (which) {
  83.         case ITIMER_REAL:
  84.             if (j) {
  85.                 j += 1+itimer_ticks;
  86.                 if (j < itimer_next)
  87.                     itimer_next = j;
  88.             }
  89.             current->it_real_value = j;
  90.             current->it_real_incr = i;
  91.             break;
  92.         case ITIMER_VIRTUAL:
  93.             if (j)
  94.                 j++;
  95.             current->it_virt_value = j;
  96.             current->it_virt_incr = i;
  97.             break;
  98.         case ITIMER_PROF:
  99.             if (j)
  100.                 j++;
  101.             current->it_prof_value = j;
  102.             current->it_prof_incr = i;
  103.             break;
  104.         default:
  105.             return -EINVAL;
  106.     }
  107.     return 0;
  108. }
  109.  
  110. asmlinkage int sys_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
  111. {
  112.     int error;
  113.     struct itimerval set_buffer, get_buffer;
  114.  
  115.     if (!value)
  116.         memset((char *) &set_buffer, 0, sizeof(set_buffer));
  117.     else
  118.         memcpy_fromfs(&set_buffer, value, sizeof(set_buffer));
  119.     error = _setitimer(which, &set_buffer, ovalue ? &get_buffer : 0);
  120.     if (error || !ovalue)
  121.         return error;
  122.     error = verify_area(VERIFY_WRITE, ovalue, sizeof(struct itimerval));
  123.     if (!error)
  124.         memcpy_tofs(ovalue, &get_buffer, sizeof(get_buffer));
  125.     return error;
  126. }
  127.