sys/kern/kern_timeout.c

   1 /*
   2  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 /*
  35  * Copyright (c) 1982, 1986, 1991, 1993
  36  *      The Regents of the University of California.  All rights reserved.
  37  * (c) UNIX System Laboratories, Inc.
  38  * All or some portions of this file are derived from material licensed
  39  * to the University of California by American Telephone and Telegraph
  40  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  41  * the permission of UNIX System Laboratories, Inc.
  42  *
  43  * Redistribution and use in source and binary forms, with or without
  44  * modification, are permitted provided that the following conditions
  45  * are met:
  46  * 1. Redistributions of source code must retain the above copyright
  47  *    notice, this list of conditions and the following disclaimer.
  48  * 2. Redistributions in binary form must reproduce the above copyright
  49  *    notice, this list of conditions and the following disclaimer in the
  50  *    documentation and/or other materials provided with the distribution.
  51  * 3. All advertising materials mentioning features or use of this software
  52  *    must display the following acknowledgement:
  53  *      This product includes software developed by the University of
  54  *      California, Berkeley and its contributors.
  55  * 4. Neither the name of the University nor the names of its contributors
  56  *    may be used to endorse or promote products derived from this software
  57  *    without specific prior written permission.
  58  *
  59  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  69  * SUCH DAMAGE.
  70  *
  71  *      From: @(#)kern_clock.c  8.5 (Berkeley) 1/21/94
  72  * $FreeBSD: src/sys/kern/kern_timeout.c,v 1.59.2.1 2001/11/13 18:24:52 archie Exp $
  73  * $DragonFly: src/sys/kern/kern_timeout.c,v 1.13 2004/09/17 09:53:27 dillon Exp $
  74  */
  75 /*
  76  * DRAGONFLY BGL STATUS
  77  *
  78  *      All the API functions should be MP safe.
  79  *
  80  *      The callback functions will be flagged as being MP safe if the
  81  *      timeout structure is initialized with callout_init_mp() instead of
  82  *      callout_init().
  83  *
  84  *      The helper threads cannot be made preempt-capable until after we
  85  *      clean up all the uses of splsoftclock() and related interlocks (which
  86  *      require the related functions to be MP safe as well).
  87  */
  88 /*
  89  * The callout mechanism is based on the work of Adam M. Costello and
  90  * George Varghese, published in a technical report entitled "Redesigning
  91  * the BSD Callout and Timer Facilities" and modified slightly for inclusion
  92  * in FreeBSD by Justin T. Gibbs.  The original work on the data structures
  93  * used in this implementation was published by G. Varghese and T. Lauck in
  94  * the paper "Hashed and Hierarchical Timing Wheels: Data Structures for
  95  * the Efficient Implementation of a Timer Facility" in the Proceedings of
  96  * the 11th ACM Annual Symposium on Operating Systems Principles,
  97  * Austin, Texas Nov 1987.
  98  *
  99  * The per-cpu augmentation was done by Matthew Dillon.
 100  */
 101
 102 #include "opt_ddb.h"
 103
 104 #include <sys/param.h>
 105 #include <sys/systm.h>
 106 #include <sys/callout.h>
 107 #include <sys/kernel.h>
 108 #include <sys/interrupt.h>
 109 #include <sys/thread.h>
 110 #include <sys/thread2.h>
 111 #include <machine/ipl.h>
 112 #include <ddb/ddb.h>
 113
 114 #ifndef MAX_SOFTCLOCK_STEPS
 115 #define MAX_SOFTCLOCK_STEPS 100 /* Maximum allowed value of steps. */
 116 #endif
 117
 118
 119 struct softclock_pcpu {
 120         struct callout_list callfree;
 121         struct callout_tailq *callwheel;
 122         struct callout * volatile next;
 123         int softticks;          /* softticks index */
 124         int curticks;           /* per-cpu ticks counter */
 125         int isrunning;
 126         struct thread thread;
 127
 128 };
 129
 130 typedef struct softclock_pcpu *softclock_pcpu_t;
 131
 132 /*
 133  * TODO:
 134  *      allocate more timeout table slots when table overflows.
 135  */
 136 static MALLOC_DEFINE(M_CALLOUT, "callout", "callout structures");
 137 static int callwheelsize;
 138 static int callwheelbits;
 139 static int callwheelmask;
 140 static struct softclock_pcpu softclock_pcpu_ary[MAXCPU];
 141
 142 static void softclock_handler(void *arg);
 143
 144 static void
 145 swi_softclock_setup(void *arg)
 146 {
 147         int cpu;
 148         int i;
 149
 150         /*
 151          * Figure out how large a callwheel we need.  It must be a power of 2.
 152          */
 153         callwheelsize = 1;
 154         callwheelbits = 0;
 155         while (callwheelsize < ncallout) {
 156                 callwheelsize <<= 1;
 157                 ++callwheelbits;
 158         }
 159         callwheelmask = callwheelsize - 1;
 160
 161         /*
 162          * Initialize per-cpu data structures.
 163          */
 164         for (cpu = 0; cpu < ncpus; ++cpu) {
 165                 softclock_pcpu_t sc;
 166                 struct callout *callout;
 167
 168                 sc = &softclock_pcpu_ary[cpu];
 169
 170                 sc->callwheel = malloc(sizeof(*sc->callwheel) * callwheelsize,
 171                                         M_CALLOUT, M_WAITOK|M_ZERO);
 172                 for (i = 0; i < callwheelsize; ++i)
 173                         TAILQ_INIT(&sc->callwheel[i]);
 174
 175                 SLIST_INIT(&sc->callfree);
 176                 callout = malloc(sizeof(struct callout) * ncallout,
 177                                         M_CALLOUT, M_WAITOK|M_ZERO);
 178                 for (i = 0; i < ncallout; ++i) {
 179                         callout_init(&callout[i]);
 180                         callout[i].c_flags |= CALLOUT_LOCAL_ALLOC;
 181                         SLIST_INSERT_HEAD(&sc->callfree, &callout[i],
 182                                         c_links.sle);
 183                 }
 184
 185                 /*
 186                  * Create a preemption-capable thread for each cpu to handle
 187                  * softclock timeouts on that cpu.  The preemption can only
 188                  * be blocked by a critical section.  The thread can itself
 189                  * be preempted by normal interrupts.
 190                  */
 191                 lwkt_create(softclock_handler, sc, NULL,
 192                             &sc->thread, TDF_STOPREQ|TDF_INTTHREAD, -1,
 193                             "softclock %d", cpu);
 194                 lwkt_setpri(&sc->thread, TDPRI_SOFT_NORM);
 195 #if 0
 196                 /*
 197                  * Do not make the thread preemptable until we clean up all
 198                  * the splsoftclock() calls in the system.  Since the threads
 199                  * are no longer operated as a software interrupt, the
 200                  * splsoftclock() calls will not have any effect on them.
 201                  */
 202                 sc->thread.td_preemptable = lwkt_preempt;
 203 #endif
 204         }
 205 }
 206
 207 SYSINIT(softclock_setup, SI_SUB_CPU, SI_ORDER_ANY, swi_softclock_setup, NULL);
 208
 209 /*
 210  * This routine is called from the hardclock() (basically a FASTint/IPI) on
 211  * each cpu in the system.  sc->curticks is this cpu's notion of the timebase.
 212  * It IS NOT NECESSARILY SYNCHRONIZED WITH 'ticks'!  sc->softticks is where
 213  * the callwheel is currently indexed.
 214  *
 215  * WARNING!  The MP lock is not necessarily held on call, nor can it be
 216  * safely obtained.
 217  *
 218  * sc->softticks is adjusted by either this routine or our helper thread
 219  * depending on whether the helper thread is running or not.
 220  */
 221 void
 222 hardclock_softtick(globaldata_t gd)
 223 {
 224         softclock_pcpu_t sc;
 225
 226         sc = &softclock_pcpu_ary[gd->gd_cpuid];
 227         ++sc->curticks;
 228         if (sc->isrunning)
 229                 return;
 230         if (sc->softticks == sc->curticks) {
 231                 /*
 232                  * in sync, only wakeup the thread if there is something to
 233                  * do.
 234                  */
 235                 if (TAILQ_FIRST(&sc->callwheel[sc->softticks & callwheelmask]))
 236                 {
 237                         sc->isrunning = 1;
 238                         lwkt_schedule(&sc->thread);
 239                 } else {
 240                         ++sc->softticks;
 241                 }
 242         } else {
 243                 /*
 244                  * out of sync, wakeup the thread unconditionally so it can
 245                  * catch up.
 246                  */
 247                 sc->isrunning = 1;
 248                 lwkt_schedule(&sc->thread);
 249         }
 250 }
 251
 252 /*
 253  * This procedure is the main loop of our per-cpu helper thread.  The
 254  * sc->isrunning flag prevents us from racing hardclock_softtick() and
 255  * a critical section is sufficient to interlock sc->curticks and protect
 256  * us from remote IPI's / list removal.
 257  *
 258  * The thread starts with the MP lock held and not in a critical section.
 259  * The loop itself is MP safe while individual callbacks may or may not
 260  * be, so we obtain or release the MP lock as appropriate.
 261  */
 262 static void
 263 softclock_handler(void *arg)
 264 {
 265         softclock_pcpu_t sc;
 266         struct callout *c;
 267         struct callout_tailq *bucket;
 268         void (*c_func)(void *);
 269         void *c_arg;
 270 #ifdef SMP
 271         int mpsafe = 0;
 272 #endif
 273
 274         sc = arg;
 275         crit_enter();
 276 loop:
 277         while (sc->softticks != (int)(sc->curticks + 1)) {
 278                 bucket = &sc->callwheel[sc->softticks & callwheelmask];
 279
 280                 for (c = TAILQ_FIRST(bucket); c; c = sc->next) {
 281                         if (c->c_time != sc->softticks) {
 282                                 sc->next = TAILQ_NEXT(c, c_links.tqe);
 283                                 continue;
 284                         }
 285 #ifdef SMP
 286                         if (c->c_flags & CALLOUT_MPSAFE) {
 287                                 if (mpsafe == 0) {
 288                                         mpsafe = 1;
 289                                         rel_mplock();
 290                                 }
 291                         } else {
 292                                 /*
 293                                  * The request might be removed while we
 294                                  * are waiting to get the MP lock.  If it
 295                                  * was removed sc->next will point to the
 296                                  * next valid request or NULL, loop up.
 297                                  */
 298                                 if (mpsafe) {
 299                                         mpsafe = 0;
 300                                         sc->next = c;
 301                                         get_mplock();
 302                                         if (c != sc->next)
 303                                                 continue;
 304                                 }
 305                         }
 306 #endif
 307                         sc->next = TAILQ_NEXT(c, c_links.tqe);
 308                         TAILQ_REMOVE(bucket, c, c_links.tqe);
 309
 310                         c_func = c->c_func;
 311                         c_arg = c->c_arg;
 312                         c->c_func = NULL;
 313                         KKASSERT(c->c_flags & CALLOUT_DID_INIT);
 314
 315                         if (c->c_flags & CALLOUT_LOCAL_ALLOC) {
 316                                 c->c_flags = CALLOUT_LOCAL_ALLOC |
 317                                              CALLOUT_DID_INIT;
 318                                 SLIST_INSERT_HEAD(&sc->callfree,
 319                                                     c, c_links.sle);
 320                         } else {
 321                                 c->c_flags &= ~CALLOUT_PENDING;
 322                         }
 323                         crit_exit();
 324                         c_func(c_arg);
 325                         crit_enter();
 326                         /* NOTE: list may have changed */
 327                 }
 328                 ++sc->softticks;
 329         }
 330         sc->isrunning = 0;
 331         lwkt_deschedule_self(&sc->thread);      /* == curthread */
 332         lwkt_switch();
 333         goto loop;
 334         /* NOT REACHED */
 335 }
 336
 337 /*
 338  * timeout --
 339  *      Execute a function after a specified length of time.
 340  *
 341  * untimeout --
 342  *      Cancel previous timeout function call.
 343  *
 344  * callout_handle_init --
 345  *      Initialize a handle so that using it with untimeout is benign.
 346  *
 347  *      See AT&T BCI Driver Reference Manual for specification.  This
 348  *      implementation differs from that one in that although an
 349  *      identification value is returned from timeout, the original
 350  *      arguments to timeout as well as the identifier are used to
 351  *      identify entries for untimeout.
 352  */
 353 struct callout_handle
 354 timeout(timeout_t *ftn, void *arg, int to_ticks)
 355 {
 356         softclock_pcpu_t sc;
 357         struct callout *new;
 358         struct callout_handle handle;
 359
 360         sc = &softclock_pcpu_ary[mycpu->gd_cpuid];
 361         crit_enter();
 362
 363         /* Fill in the next free callout structure. */
 364         new = SLIST_FIRST(&sc->callfree);
 365         if (new == NULL) {
 366                 /* XXX Attempt to malloc first */
 367                 panic("timeout table full");
 368         }
 369         SLIST_REMOVE_HEAD(&sc->callfree, c_links.sle);
 370
 371         callout_reset(new, to_ticks, ftn, arg);
 372
 373         handle.callout = new;
 374         crit_exit();
 375         return (handle);
 376 }
 377
 378 void
 379 untimeout(timeout_t *ftn, void *arg, struct callout_handle handle)
 380 {
 381         /*
 382          * Check for a handle that was initialized
 383          * by callout_handle_init, but never used
 384          * for a real timeout.
 385          */
 386         if (handle.callout == NULL)
 387                 return;
 388
 389         crit_enter();
 390         if (handle.callout->c_func == ftn && handle.callout->c_arg == arg)
 391                 callout_stop(handle.callout);
 392         crit_exit();
 393 }
 394
 395 void
 396 callout_handle_init(struct callout_handle *handle)
 397 {
 398         handle->callout = NULL;
 399 }
 400
 401 /*
 402  * New interface; clients allocate their own callout structures.
 403  *
 404  * callout_reset() - establish or change a timeout
 405  * callout_stop() - disestablish a timeout
 406  * callout_init() - initialize a callout structure so that it can
 407  *                      safely be passed to callout_reset() and callout_stop()
 408  * callout_init_mp() - same but any installed functions must be MP safe.
 409  *
 410  * <sys/callout.h> defines three convenience macros:
 411  *
 412  * callout_active() - returns truth if callout has not been serviced
 413  * callout_pending() - returns truth if callout is still waiting for timeout
 414  * callout_deactivate() - marks the callout as having been serviced
 415  */
 416
 417 /*
 418  * Start or restart a timeout.  Install the callout structure in the
 419  * callwheel.  Callers may legally pass any value, even if 0 or negative,
 420  * but since the sc->curticks index may have already been processed a
 421  * minimum timeout of 1 tick will be enforced.
 422  *
 423  * The callout is installed on and will be processed on the current cpu's
 424  * callout wheel.
 425  */
 426 void
 427 callout_reset(struct callout *c, int to_ticks, void (*ftn)(void *),
 428                 void *arg)
 429 {
 430         softclock_pcpu_t sc;
 431         globaldata_t gd;
 432
 433 #ifdef INVARIANTS
 434         if ((c->c_flags & CALLOUT_DID_INIT) == 0) {
 435                 callout_init(c);
 436                 printf(
 437                     "callout_reset(%p) from %p: callout was not initialized\n",
 438                     c, ((int **)&c)[-1]);
 439 #ifdef DDB
 440                 db_print_backtrace();
 441 #endif
 442         }
 443 #endif
 444         gd = mycpu;
 445         sc = &softclock_pcpu_ary[gd->gd_cpuid];
 446         crit_enter_gd(gd);
 447
 448         if (c->c_flags & CALLOUT_PENDING)
 449                 callout_stop(c);
 450
 451         if (to_ticks <= 0)
 452                 to_ticks = 1;
 453
 454         c->c_arg = arg;
 455         c->c_flags |= (CALLOUT_ACTIVE | CALLOUT_PENDING);
 456         c->c_func = ftn;
 457         c->c_time = sc->curticks + to_ticks;
 458 #ifdef SMP
 459         c->c_gd = gd;
 460 #endif
 461
 462         TAILQ_INSERT_TAIL(&sc->callwheel[c->c_time & callwheelmask],
 463                           c, c_links.tqe);
 464         crit_exit_gd(gd);
 465 }
 466
 467 /*
 468  * Stop a running timer.  WARNING!  If called on a cpu other then the one
 469  * the callout was started on this function will liveloop on its IPI to
 470  * the target cpu to process the request.  It is possible for the callout
 471  * to execute in that case.
 472  *
 473  * WARNING! This routine may be called from an IPI
 474  */
 475 int
 476 callout_stop(struct callout *c)
 477 {
 478         globaldata_t gd = mycpu;
 479 #ifdef SMP
 480         globaldata_t tgd;
 481 #endif
 482         softclock_pcpu_t sc;
 483
 484 #ifdef INVARIANTS
 485         if ((c->c_flags & CALLOUT_DID_INIT) == 0) {
 486                 callout_init(c);
 487                 printf(
 488                     "callout_reset(%p) from %p: callout was not initialized\n",
 489                     c, ((int **)&c)[-1]);
 490 #ifdef DDB
 491                 db_print_backtrace();
 492 #endif
 493         }
 494 #endif
 495         crit_enter_gd(gd);
 496
 497         /*
 498          * Don't attempt to delete a callout that's not on the queue.
 499          */
 500         if ((c->c_flags & CALLOUT_PENDING) == 0) {
 501                 c->c_flags &= ~CALLOUT_ACTIVE;
 502                 crit_exit_gd(gd);
 503                 return (0);
 504         }
 505 #ifdef SMP
 506         if ((tgd = c->c_gd) != gd) {
 507                 /*
 508                  * If the callout is owned by a different CPU we have to
 509                  * execute the function synchronously on the target cpu.
 510                  */
 511                 int seq;
 512
 513                 cpu_mb1();      /* don't let tgd alias c_gd */
 514                 seq = lwkt_send_ipiq(tgd, (void *)callout_stop, c);
 515                 lwkt_wait_ipiq(tgd, seq);
 516         } else
 517 #endif
 518         {
 519                 /*
 520                  * If the callout is owned by the same CPU we can
 521                  * process it directly, but if we are racing our helper
 522                  * thread (sc->next), we have to adjust sc->next.  The
 523                  * race is interlocked by a critical section.
 524                  */
 525                 sc = &softclock_pcpu_ary[gd->gd_cpuid];
 526
 527                 c->c_flags &= ~(CALLOUT_ACTIVE | CALLOUT_PENDING);
 528                 if (sc->next == c)
 529                         sc->next = TAILQ_NEXT(c, c_links.tqe);
 530
 531                 TAILQ_REMOVE(&sc->callwheel[c->c_time & callwheelmask],
 532                                 c, c_links.tqe);
 533                 c->c_func = NULL;
 534
 535                 if (c->c_flags & CALLOUT_LOCAL_ALLOC) {
 536                         SLIST_INSERT_HEAD(&sc->callfree, c, c_links.sle);
 537                 }
 538         }
 539         crit_exit_gd(gd);
 540         return (1);
 541 }
 542
 543 /*
 544  * Prepare a callout structure for use by callout_reset() and/or
 545  * callout_stop().  The MP version of this routine requires that the callback
 546  * function installed by callout_reset() by MP safe.
 547  */
 548 void
 549 callout_init(struct callout *c)
 550 {
 551         bzero(c, sizeof *c);
 552         c->c_flags = CALLOUT_DID_INIT;
 553 }
 554
 555 void
 556 callout_init_mp(struct callout *c)
 557 {
 558         callout_init(c);
 559         c->c_flags |= CALLOUT_MPSAFE;
 560 }
 561
 562 /* What, are you joking?  This is nuts! -Matt */
 563 #if 0
 564 #ifdef APM_FIXUP_CALLTODO
 565 /*
 566  * Adjust the kernel calltodo timeout list.  This routine is used after
 567  * an APM resume to recalculate the calltodo timer list values with the
 568  * number of hz's we have been sleeping.  The next hardclock() will detect
 569  * that there are fired timers and run softclock() to execute them.
 570  *
 571  * Please note, I have not done an exhaustive analysis of what code this
 572  * might break.  I am motivated to have my select()'s and alarm()'s that
 573  * have expired during suspend firing upon resume so that the applications
 574  * which set the timer can do the maintanence the timer was for as close
 575  * as possible to the originally intended time.  Testing this code for a
 576  * week showed that resuming from a suspend resulted in 22 to 25 timers
 577  * firing, which seemed independant on whether the suspend was 2 hours or
 578  * 2 days.  Your milage may vary.   - Ken Key <key@cs.utk.edu>
 579  */
 580 void
 581 adjust_timeout_calltodo(struct timeval *time_change)
 582 {
 583         struct callout *p;
 584         unsigned long delta_ticks;
 585         int s;
 586
 587         /*
 588          * How many ticks were we asleep?
 589          * (stolen from tvtohz()).
 590          */
 591
 592         /* Don't do anything */
 593         if (time_change->tv_sec < 0)
 594                 return;
 595         else if (time_change->tv_sec <= LONG_MAX / 1000000)
 596                 delta_ticks = (time_change->tv_sec * 1000000 +
 597                                time_change->tv_usec + (tick - 1)) / tick + 1;
 598         else if (time_change->tv_sec <= LONG_MAX / hz)
 599                 delta_ticks = time_change->tv_sec * hz +
 600                               (time_change->tv_usec + (tick - 1)) / tick + 1;
 601         else
 602                 delta_ticks = LONG_MAX;
 603
 604         if (delta_ticks > INT_MAX)
 605                 delta_ticks = INT_MAX;
 606
 607         /*
 608          * Now rip through the timer calltodo list looking for timers
 609          * to expire.
 610          */
 611
 612         /* don't collide with softclock() */
 613         s = splhigh();
 614         for (p = calltodo.c_next; p != NULL; p = p->c_next) {
 615                 p->c_time -= delta_ticks;
 616
 617                 /* Break if the timer had more time on it than delta_ticks */
 618                 if (p->c_time > 0)
 619                         break;
 620
 621                 /* take back the ticks the timer didn't use (p->c_time <= 0) */
 622                 delta_ticks = -p->c_time;
 623         }
 624         splx(s);
 625
 626         return;
 627 }
 628 #endif /* APM_FIXUP_CALLTODO */
 629 #endif
 630