clock.c revision 38494
1/* 2 * Copyright (c) 1997-1998 Erez Zadok 3 * Copyright (c) 1989 Jan-Simon Pendry 4 * Copyright (c) 1989 Imperial College of Science, Technology & Medicine 5 * Copyright (c) 1989 The Regents of the University of California. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to Berkeley by 9 * Jan-Simon Pendry at Imperial College, London. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the University of 22 * California, Berkeley and its contributors. 23 * 4. Neither the name of the University nor the names of its contributors 24 * may be used to endorse or promote products derived from this software 25 * without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 37 * SUCH DAMAGE. 38 * 39 * %W% (Berkeley) %G% 40 * 41 * $Id: clock.c,v 5.2.2.1 1992/02/09 15:08:20 jsp beta $ 42 * 43 */ 44 45/* 46 * Callouts. 47 * 48 * Modelled on kernel object of the same name. 49 * See usual references. 50 * 51 * Use of a heap-based mechanism was rejected: 52 * 1. more complex implementation needed. 53 * 2. not obvious that a list is too slow for Amd. 54 */ 55 56#ifdef HAVE_CONFIG_H 57# include <config.h> 58#endif /* HAVE_CONFIG_H */ 59#include <am_defs.h> 60#include <amd.h> 61 62int timeout(u_int secs, void (*fn) (voidp), voidp closure); 63void reschedule_timeouts(time_t now, time_t then); 64 65typedef struct callout callout; 66struct callout { 67 callout *c_next; /* List of callouts */ 68 void (*c_fn) (voidp); /* Function to call */ 69 voidp c_closure; /* Closure to pass to call */ 70 time_t c_time; /* Time of call */ 71 int c_id; /* Unique identifier */ 72}; 73 74static callout callouts; /* List of pending callouts */ 75static callout *free_callouts; /* Cache of free callouts */ 76static int nfree_callouts; /* Number on free list */ 77static int callout_id; /* Next free callout identifier */ 78 79time_t next_softclock; /* Time of next call to softclock() */ 80 81 82/* 83 * Number of callout slots we keep on the free list 84 */ 85#define CALLOUT_FREE_SLOP 10 86 87/* 88 * Global assumption: valid id's are non-zero. 89 */ 90#define CID_ALLOC(struct ) (++callout_id) 91#define CID_UNDEF (0) 92 93 94static callout * 95alloc_callout(void) 96{ 97 callout *cp = free_callouts; 98 99 if (cp) { 100 --nfree_callouts; 101 free_callouts = free_callouts->c_next; 102 return cp; 103 } 104 return ALLOC(struct callout); 105} 106 107 108static void 109free_callout(callout *cp) 110{ 111 if (nfree_callouts > CALLOUT_FREE_SLOP) { 112 XFREE(cp); 113 } else { 114 cp->c_next = free_callouts; 115 free_callouts = cp; 116 nfree_callouts++; 117 } 118} 119 120 121/* 122 * Schedule a callout. 123 * 124 * (*fn)(closure) will be called at clocktime() + secs 125 */ 126int 127timeout(u_int secs, void (*fn) (voidp), voidp closure) 128{ 129 callout *cp, *cp2; 130 time_t t = clocktime() + secs; 131 132 /* 133 * Allocate and fill in a new callout structure 134 */ 135 callout *cpnew = alloc_callout(); 136 cpnew->c_closure = closure; 137 cpnew->c_fn = fn; 138 cpnew->c_time = t; 139 cpnew->c_id = CID_ALLOC(struct ); 140 141 if (t < next_softclock) 142 next_softclock = t; 143 144 /* 145 * Find the correct place in the list 146 */ 147 for (cp = &callouts; (cp2 = cp->c_next); cp = cp2) 148 if (cp2->c_time >= t) 149 break; 150 151 /* 152 * And link it in 153 */ 154 cp->c_next = cpnew; 155 cpnew->c_next = cp2; 156 157 /* 158 * Return callout identifier 159 */ 160 return cpnew->c_id; 161} 162 163 164/* 165 * De-schedule a callout 166 */ 167void 168untimeout(int id) 169{ 170 callout *cp, *cp2; 171 for (cp = &callouts; (cp2 = cp->c_next); cp = cp2) { 172 if (cp2->c_id == id) { 173 cp->c_next = cp2->c_next; 174 free_callout(cp2); 175 break; 176 } 177 } 178} 179 180 181/* 182 * Reschedule after clock changed 183 */ 184void 185reschedule_timeouts(time_t now, time_t then) 186{ 187 callout *cp; 188 189 for (cp = callouts.c_next; cp; cp = cp->c_next) { 190 if (cp->c_time >= now && cp->c_time <= then) { 191 plog(XLOG_WARNING, "job %d rescheduled to run immediately", cp->c_id); 192#ifdef DEBUG 193 dlog("rescheduling job %d back %d seconds", cp->c_id, cp->c_time - now); 194#endif /* DEBUG */ 195 next_softclock = cp->c_time = now; 196 } 197 } 198} 199 200 201/* 202 * Clock handler 203 */ 204int 205softclock(void) 206{ 207 time_t now; 208 callout *cp; 209 210 do { 211 if (task_notify_todo) 212 do_task_notify(); 213 214 now = clocktime(); 215 216 /* 217 * While there are more callouts waiting... 218 */ 219 while ((cp = callouts.c_next) && cp->c_time <= now) { 220 /* 221 * Extract first from list, save fn & closure and 222 * unlink callout from list and free. 223 * Finally call function. 224 * 225 * The free is done first because 226 * it is quite common that the 227 * function will call timeout() 228 * and try to allocate a callout 229 */ 230 void (*fn) (voidp) = cp->c_fn; 231 voidp closure = cp->c_closure; 232 233 callouts.c_next = cp->c_next; 234 free_callout(cp); 235 (*fn) (closure); 236 } 237 238 } while (task_notify_todo); 239 240 /* 241 * Return number of seconds to next event, 242 * or 0 if there is no event. 243 */ 244 if ((cp = callouts.c_next)) 245 return cp->c_time - now; 246 return 0; 247} 248