exec/tlist.h

   1 /*
   2  * Copyright (c) 2003-2004 MontaVista Software, Inc.
   3  * Copyright (c) 2006-2007 Red Hat, Inc.
   4  *
   5  * All rights reserved.
   6  *
   7  * Author: Steven Dake (sdake@mvista.com)
   8  *
   9  * This software licensed under BSD license, the text of which follows:
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions are met:
  13  *
  14  * - Redistributions of source code must retain the above copyright notice,
  15  *   this list of conditions and the following disclaimer.
  16  * - Redistributions in binary form must reproduce the above copyright notice,
  17  *   this list of conditions and the following disclaimer in the documentation
  18  *   and/or other materials provided with the distribution.
  19  * - Neither the name of the MontaVista Software, Inc. nor the names of its
  20  *   contributors may be used to endorse or promote products derived from this
  21  *   software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  33  * THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #ifndef TLIST_H_DEFINED
  37 #define TLIST_H_DEFINED
  38
  39 #include <sys/time.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <errno.h>
  43 #include <string.h>
  44 #include <sys/param.h>
  45
  46 #include "../include/list.h"
  47
  48 #ifndef HZ
  49         #define HZ 100  /* 10ms */
  50 #endif
  51
  52 #ifndef TIMER_HANDLE
  53 typedef void * timer_handle;
  54 #define TIMER_HANDLE
  55 #endif
  56
  57 struct timerlist {
  58         struct list_head timer_head;
  59         struct list_head *timer_iter;
  60 };
  61
  62 struct timerlist_timer {
  63         struct list_head list;
  64         unsigned long long nano_from_epoch;
  65         void (*timer_fn)(void *data);
  66         void *data;
  67         timer_handle handle_addr;
  68 };
  69
  70 static inline void timerlist_init (struct timerlist *timerlist)
  71 {
  72         list_init (&timerlist->timer_head);
  73 }
  74
  75 static inline unsigned long long timerlist_nano_from_epoch (void)
  76 {
  77         unsigned long long nano_from_epoch;
  78         struct timeval time_from_epoch;
  79         gettimeofday (&time_from_epoch, 0);
  80
  81         nano_from_epoch = ((time_from_epoch.tv_sec * 1000000000ULL) + (time_from_epoch.tv_usec * 1000ULL));
  82         return (nano_from_epoch);
  83 }
  84
  85 static inline void timerlist_add (struct timerlist *timerlist, struct timerlist_timer *timer)
  86 {
  87         struct list_head *timer_list = 0;
  88         struct timerlist_timer *timer_from_list;
  89         int found;
  90
  91         for (found = 0, timer_list = timerlist->timer_head.next;
  92                 timer_list != &timerlist->timer_head;
  93                 timer_list = timer_list->next) {
  94
  95                 timer_from_list = list_entry (timer_list,
  96                         struct timerlist_timer, list);
  97
  98                 if (timer_from_list->nano_from_epoch > timer->nano_from_epoch) {
  99                         list_add (&timer->list, timer_list->prev);
 100                         found = 1;
 101                         break; /* for timer iteration */
 102                 }
 103         }
 104         if (found == 0) {
 105                 list_add (&timer->list, timerlist->timer_head.prev);
 106         }
 107 }
 108
 109 static inline int timerlist_add_absolute (struct timerlist *timerlist,
 110         void (*timer_fn) (void *data),
 111         void *data,
 112         unsigned long long nano_from_epoch,
 113         timer_handle *handle)
 114 {
 115         struct timerlist_timer *timer;
 116
 117         timer = (struct timerlist_timer *)malloc (sizeof (struct timerlist_timer));
 118         if (timer == 0) {
 119                 errno = ENOMEM;
 120                 return (-1);
 121         }
 122
 123         timer->nano_from_epoch = nano_from_epoch;
 124         timer->data = data;
 125         timer->timer_fn = timer_fn;
 126         timer->handle_addr = handle;
 127         timerlist_add (timerlist, timer);
 128
 129         *handle = timer;
 130         return (0);
 131 }
 132
 133 static inline int timerlist_add_duration (struct timerlist *timerlist,
 134         void (*timer_fn) (void *data),
 135         void *data,
 136         unsigned long long nano_duration,
 137         timer_handle *handle)
 138 {
 139         struct timerlist_timer *timer;
 140
 141         timer = (struct timerlist_timer *)malloc (sizeof (struct timerlist_timer));
 142         if (timer == 0) {
 143                 errno = ENOMEM;
 144                 return (-1);
 145         }
 146
 147         timer->nano_from_epoch = timerlist_nano_from_epoch() + nano_duration;
 148         timer->data = data;
 149         timer->timer_fn = timer_fn;
 150         timer->handle_addr = handle;
 151         timerlist_add (timerlist, timer);
 152
 153         *handle = timer;
 154         return (0);
 155 }
 156
 157 static inline void timerlist_del (struct timerlist *timerlist, timer_handle timer_handle)
 158 {
 159         struct timerlist_timer *timer = (struct timerlist_timer *)timer_handle;
 160
 161         memset (timer->handle_addr, 0, sizeof (struct timerlist_timer *));
 162         /*
 163          * If the next timer after the currently expiring timer because
 164          * timerlist_del is called from a timer handler, get to the next
 165          * timer
 166          */
 167         if (timerlist->timer_iter == &timer->list) {
 168                 timerlist->timer_iter = timerlist->timer_iter->next;
 169         }
 170         list_del (&timer->list);
 171         list_init (&timer->list);
 172         free (timer);
 173 }
 174
 175 static inline void timerlist_pre_dispatch (struct timerlist *timerlist, timer_handle timer_handle)
 176 {
 177         struct timerlist_timer *timer = (struct timerlist_timer *)timer_handle;
 178
 179         memset (timer->handle_addr, 0, sizeof (struct timerlist_timer *));
 180         list_del (&timer->list);
 181         list_init (&timer->list);
 182 }
 183
 184 static inline void timerlist_post_dispatch (struct timerlist *timerlist, timer_handle timer_handle)
 185 {
 186         struct timerlist_timer *timer = (struct timerlist_timer *)timer_handle;
 187
 188         free (timer);
 189 }
 190
 191 /*
 192  * returns the number of msec until the next timer will expire for use with poll
 193  */
 194 static inline unsigned long long timerlist_msec_duration_to_expire (struct timerlist *timerlist)
 195 {
 196         struct timerlist_timer *timer_from_list;
 197         volatile unsigned long long nano_from_epoch;
 198         volatile unsigned long long msec_duration_to_expire;
 199
 200         /*
 201          * empty list, no expire
 202          */
 203         if (timerlist->timer_head.next == &timerlist->timer_head) {
 204                 return (-1);
 205         }
 206
 207         timer_from_list = list_entry (timerlist->timer_head.next,
 208                 struct timerlist_timer, list);
 209
 210         nano_from_epoch = timerlist_nano_from_epoch();
 211
 212         /*
 213          * timer at head of list is expired, zero msecs required
 214          */
 215         if (timer_from_list->nano_from_epoch < nano_from_epoch) {
 216                 return (0);
 217         }
 218
 219
 220         msec_duration_to_expire = ((timer_from_list->nano_from_epoch - nano_from_epoch) / 1000000ULL) +
 221                 (1000 / HZ);
 222         return (msec_duration_to_expire);
 223 }
 224
 225 /*
 226  * Expires any timers that should be expired
 227  */
 228 static inline void timerlist_expire (struct timerlist *timerlist)
 229 {
 230         struct timerlist_timer *timer_from_list;
 231         unsigned long long nano_from_epoch;
 232
 233         nano_from_epoch = timerlist_nano_from_epoch();
 234
 235         for (timerlist->timer_iter = timerlist->timer_head.next;
 236                 timerlist->timer_iter != &timerlist->timer_head;) {
 237
 238                 timer_from_list = list_entry (timerlist->timer_iter,
 239                         struct timerlist_timer, list);
 240
 241                 if (timer_from_list->nano_from_epoch < nano_from_epoch) {
 242                         timerlist->timer_iter = timerlist->timer_iter->next;
 243
 244                         timerlist_pre_dispatch (timerlist, timer_from_list);
 245
 246                         timer_from_list->timer_fn (timer_from_list->data);
 247
 248                         timerlist_post_dispatch (timerlist, timer_from_list);
 249                 } else {
 250                         break; /* for timer iteration */
 251                 }
 252         }
 253         timerlist->timer_iter = 0;
 254 }
 255 #endif /* TLIST_H_DEFINED */