FreeBSD/Linux Kernel Cross Reference
sys/sys/timeout.h

     /*      $OpenBSD: timeout.h,v 1.47 2022/12/31 16:06:24 cheloha Exp $    */
     /*
      * Copyright (c) 2000-2001 Artur Grabowski <art@openbsd.org>
      * All rights reserved. 
      *
      * Redistribution and use in source and binary forms, with or without 
      * modification, are permitted provided that the following conditions 
      * are met: 
      *
     * 1. Redistributions of source code must retain the above copyright 
     *    notice, this list of conditions and the following disclaimer. 
     * 2. The name of the author may not be used to endorse or promote products
     *    derived from this software without specific prior written permission. 
     *
     * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
     * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
     * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
     * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     */
    
    #ifndef _SYS_TIMEOUT_H_
    #define _SYS_TIMEOUT_H_
    
    #include <sys/time.h>
    
    struct circq {
            struct circq *next;             /* next element */
            struct circq *prev;             /* previous element */
    };
    
    struct timeout {
            struct circq to_list;                   /* timeout queue, don't move */
            struct timespec to_abstime;             /* absolute time to run at */
            void (*to_func)(void *);                /* function to call */
            void *to_arg;                           /* function argument */
    #if 1 /* NKCOV > 0 */
            struct process *to_process;             /* kcov identifier */
    #endif
            int to_time;                            /* ticks on event */
            int to_flags;                           /* misc flags */
            int to_kclock;                          /* abstime's kernel clock */
    };
    
    /*
     * flags in the to_flags field.
     */
    #define TIMEOUT_PROC            0x01    /* needs a process context */
    #define TIMEOUT_ONQUEUE         0x02    /* on any timeout queue */
    #define TIMEOUT_INITIALIZED     0x04    /* initialized */
    #define TIMEOUT_TRIGGERED       0x08    /* running or ran */
    
    struct timeoutstat {
            uint64_t tos_added;             /* timeout_add*(9) calls */
            uint64_t tos_cancelled;         /* dequeued during timeout_del*(9) */
            uint64_t tos_deleted;           /* timeout_del*(9) calls */
            uint64_t tos_late;              /* run after deadline */
            uint64_t tos_pending;           /* number currently ONQUEUE */
            uint64_t tos_readded;           /* timeout_add*(9) + already ONQUEUE */
            uint64_t tos_rescheduled;       /* bucketed + already SCHEDULED */
            uint64_t tos_run_softclock;     /* run from softclock() */
            uint64_t tos_run_thread;        /* run from softclock_thread() */
            uint64_t tos_scheduled;         /* bucketed during softclock() */
            uint64_t tos_softclocks;        /* softclock() calls */
            uint64_t tos_thread_wakeups;    /* wakeups in softclock_thread() */
    };
    
    #ifdef _KERNEL
    int timeout_sysctl(void *, size_t *, void *, size_t);
    
    /*
     * special macros
     *
     * timeout_pending(to) - is this timeout already scheduled to run?
     * timeout_initialized(to) - is this timeout initialized?
     */
    #define timeout_pending(to) ((to)->to_flags & TIMEOUT_ONQUEUE)
    #define timeout_initialized(to) ((to)->to_flags & TIMEOUT_INITIALIZED)
    #define timeout_triggered(to) ((to)->to_flags & TIMEOUT_TRIGGERED)
    
    #define KCLOCK_NONE     (-1)            /* dummy clock for sanity checks */
    #define KCLOCK_UPTIME   0               /* uptime clock; time since boot */
    #define KCLOCK_MAX      1
    
    #define TIMEOUT_INITIALIZER_FLAGS(_fn, _arg, _kclock, _flags) {         \
            .to_list = { NULL, NULL },                                      \
            .to_abstime = { .tv_sec = 0, .tv_nsec = 0 },                    \
            .to_func = (_fn),                                               \
            .to_arg = (_arg),                                               \
            .to_time = 0,                                                   \
            .to_flags = (_flags) | TIMEOUT_INITIALIZED,                     \
            .to_kclock = (_kclock)                                          \
    }
    
   #define TIMEOUT_INITIALIZER(_f, _a)                                     \
       TIMEOUT_INITIALIZER_FLAGS((_f), (_a), KCLOCK_NONE, 0)
   
   void timeout_set(struct timeout *, void (*)(void *), void *);
   void timeout_set_flags(struct timeout *, void (*)(void *), void *, int, int);
   void timeout_set_proc(struct timeout *, void (*)(void *), void *);
   
   int timeout_add(struct timeout *, int);
   int timeout_add_tv(struct timeout *, const struct timeval *);
   int timeout_add_sec(struct timeout *, int);
   int timeout_add_msec(struct timeout *, int);
   int timeout_add_usec(struct timeout *, int);
   int timeout_add_nsec(struct timeout *, int);
   
   int timeout_abs_ts(struct timeout *, const struct timespec *);
   
   int timeout_del(struct timeout *);
   int timeout_del_barrier(struct timeout *);
   void timeout_barrier(struct timeout *);
   
   void timeout_adjust_ticks(int);
   void timeout_hardclock_update(void);
   void timeout_startup(void);
   
   #endif /* _KERNEL */
   
   #endif  /* _SYS_TIMEOUT_H_ */

Cache object: e7dd23c3341eaec17cfcda0d8f493f73