clock.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2 clock.c
    3 
    4 Copyright 1995 Philip Homburg
    5 */
    6 
    7 #include "inet.h"
    8 #include "proto.h"
    9 #include "generic/assert.h"
   10 #include "generic/buf.h"
   11 #include "generic/clock.h"
   12 #include "generic/type.h"
   13 
   14 THIS_FILE
   15 
   16 PUBLIC int clck_call_expire;
   17 
   18 PRIVATE time_t curr_time;
   19 PRIVATE time_t prev_time;
   20 PRIVATE timer_t *timer_chain;
   21 PRIVATE time_t next_timeout;
   22 #ifdef __minix_vmd
   23 PRIVATE int clck_tasknr= ANY;
   24 #endif
   25 
   26 FORWARD _PROTOTYPE( void clck_fast_release, (timer_t *timer) );
   27 FORWARD _PROTOTYPE( void set_timer, (void) );
   28 
   29 PUBLIC void clck_init()
   30 {
   31         int r;
   32 
   33         clck_call_expire= 0;
   34         curr_time= 0;
   35         prev_time= 0;
   36         next_timeout= 0;
   37         timer_chain= 0;
   38 
   39 #ifdef __minix_vmd
   40         r= sys_findproc(CLOCK_NAME, &clck_tasknr, 0);
   41         if (r != OK)
   42                 ip_panic(( "unable to find clock task: %d\n", r ));
   43 #endif
   44 }
   45 
   46 PUBLIC time_t get_time()
   47 {
   48         if (!curr_time)
   49         {
   50 #ifdef __minix_vmd
   51                 static message mess;
   52 
   53                 mess.m_type= GET_UPTIME;
   54                 if (sendrec (clck_tasknr, &mess) < 0)
   55                         ip_panic(("unable to sendrec"));
   56                 if (mess.m_type != OK)
   57                         ip_panic(("can't read clock"));
   58                 curr_time= mess.NEW_TIME;
   59 #else /* Minix 3 */
   60                 int s;
   61                 if ((s=getuptime(&curr_time)) != OK)
   62                         ip_panic(("can't read clock"));
   63 #endif
   64                 assert(curr_time >= prev_time);
   65         }
   66         return curr_time;
   67 }
   68 
   69 PUBLIC void set_time (tim)
   70 time_t tim;
   71 {
   72         if (!curr_time && tim >= prev_time)
   73         {
   74                 /* Some code assumes that no time elapses while it is
   75                  * running.
   76                  */
   77                 curr_time= tim;
   78         }
   79         else if (!curr_time)
   80         {
   81                 DBLOCK(0x20, printf("set_time: new time %ld < prev_time %ld\n",
   82                         tim, prev_time));
   83         }
   84 }
   85 
   86 PUBLIC void reset_time()
   87 {
   88         prev_time= curr_time;
   89         curr_time= 0;
   90 }
   91 
   92 PUBLIC void clck_timer(timer, timeout, func, fd)
   93 timer_t *timer;
   94 time_t timeout;
   95 timer_func_t func;
   96 int fd;
   97 {
   98         timer_t *timer_index;
   99 
  100         if (timer->tim_active)
  101                 clck_fast_release(timer);
  102         assert(!timer->tim_active);
  103 
  104         timer->tim_next= 0;
  105         timer->tim_func= func;
  106         timer->tim_ref= fd;
  107         timer->tim_time= timeout;
  108         timer->tim_active= 1;
  109 
  110         if (!timer_chain)
  111                 timer_chain= timer;
  112         else if (timeout < timer_chain->tim_time)
  113         {
  114                 timer->tim_next= timer_chain;
  115                 timer_chain= timer;
  116         }
  117         else
  118         {
  119                 timer_index= timer_chain;
  120                 while (timer_index->tim_next &&
  121                         timer_index->tim_next->tim_time < timeout)
  122                         timer_index= timer_index->tim_next;
  123                 timer->tim_next= timer_index->tim_next;
  124                 timer_index->tim_next= timer;
  125         }
  126         if (next_timeout == 0 || timer_chain->tim_time < next_timeout)
  127                 set_timer();
  128 }
  129 
  130 PUBLIC void clck_tick (mess)
  131 message *mess;
  132 {
  133         next_timeout= 0;
  134         set_timer();
  135 }
  136 
  137 PRIVATE void clck_fast_release (timer)
  138 timer_t *timer;
  139 {
  140         timer_t *timer_index;
  141 
  142         if (!timer->tim_active)
  143                 return;
  144 
  145         if (timer == timer_chain)
  146                 timer_chain= timer_chain->tim_next;
  147         else
  148         {
  149                 timer_index= timer_chain;
  150                 while (timer_index && timer_index->tim_next != timer)
  151                         timer_index= timer_index->tim_next;
  152                 assert(timer_index);
  153                 timer_index->tim_next= timer->tim_next;
  154         }
  155         timer->tim_active= 0;
  156 }
  157 
  158 PRIVATE void set_timer()
  159 {
  160         time_t new_time;
  161         time_t curr_time;
  162 
  163         if (!timer_chain)
  164                 return;
  165 
  166         curr_time= get_time();
  167         new_time= timer_chain->tim_time;
  168         if (new_time <= curr_time)
  169         {
  170                 clck_call_expire= 1;
  171                 return;
  172         }
  173 
  174         if (next_timeout == 0 || new_time < next_timeout)
  175         {
  176 #ifdef __minix_vmd
  177                 static message mess;
  178 
  179                 next_timeout= new_time;
  180 
  181                 new_time -= curr_time;
  182 
  183                 mess.m_type= SET_SYNC_AL;
  184                 mess.CLOCK_PROC_NR= this_proc;
  185                 mess.DELTA_TICKS= new_time;
  186                 if (sendrec (clck_tasknr, &mess) < 0)
  187                         ip_panic(("unable to sendrec"));
  188                 if (mess.m_type != OK)
  189                         ip_panic(("can't set timer"));
  190 #else /* Minix 3 */
  191                 next_timeout= new_time;
  192                 new_time -= curr_time;
  193 
  194                 if (sys_setalarm(new_time, 0) != OK)
  195                         ip_panic(("can't set timer"));
  196 #endif
  197         }
  198 }
  199 
  200 PUBLIC void clck_untimer (timer)
  201 timer_t *timer;
  202 {
  203         clck_fast_release (timer);
  204         set_timer();
  205 }
  206 
  207 PUBLIC void clck_expire_timers()
  208 {
  209         time_t curr_time;
  210         timer_t *timer_index;
  211 
  212         clck_call_expire= 0;
  213 
  214         if (timer_chain == NULL)
  215                 return;
  216 
  217         curr_time= get_time();
  218         while (timer_chain && timer_chain->tim_time<=curr_time)
  219         {
  220                 assert(timer_chain->tim_active);
  221                 timer_chain->tim_active= 0;
  222                 timer_index= timer_chain;
  223                 timer_chain= timer_chain->tim_next;
  224                 (*timer_index->tim_func)(timer_index->tim_ref, timer_index);
  225         }
  226         set_timer();
  227 }
  228 
  229 /*
  230  * $PchId: clock.c,v 1.10 2005/06/28 14:23:40 philip Exp $
  231  */

Cache object: 377e26e5a8d9ac78c4b86173de3815c3

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/servers/inet/clock.c

FreeBSD/Linux Kernel Cross Reference
sys/servers/inet/clock.c