bus/expirelist.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* expirelist.c  List of items that expire
   3  *
   4  * Copyright (C) 2003  Red Hat, Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #include <config.h>
  25 #include "expirelist.h"
  26 #include "test.h"
  27 #include <dbus/dbus-internals.h>
  28 #include <dbus/dbus-mainloop.h>
  29 #include <dbus/dbus-timeout.h>
  30
  31 struct BusExpireList
  32 {
  33   DBusList      *items; /**< List of BusExpireItem */
  34   DBusTimeout   *timeout;
  35   DBusLoop      *loop;
  36   BusExpireFunc  expire_func;
  37   void          *data;
  38   int            expire_after; /**< Expire after milliseconds (thousandths) */
  39 };
  40
  41 static dbus_bool_t expire_timeout_handler (void *data);
  42
  43 BusExpireList*
  44 bus_expire_list_new (DBusLoop      *loop,
  45                      int            expire_after,
  46                      BusExpireFunc  expire_func,
  47                      void          *data)
  48 {
  49   BusExpireList *list;
  50
  51   list = dbus_new0 (BusExpireList, 1);
  52   if (list == NULL)
  53     return NULL;
  54
  55   list->expire_func = expire_func;
  56   list->data = data;
  57   list->loop = loop;
  58   list->expire_after = expire_after;
  59
  60   list->timeout = _dbus_timeout_new (100, /* irrelevant */
  61                                      expire_timeout_handler,
  62                                      list, NULL);
  63   if (list->timeout == NULL)
  64     goto failed;
  65
  66   _dbus_timeout_set_enabled (list->timeout, FALSE);
  67
  68   if (!_dbus_loop_add_timeout (list->loop, list->timeout))
  69     goto failed;
  70
  71   return list;
  72
  73  failed:
  74   if (list->timeout)
  75     _dbus_timeout_unref (list->timeout);
  76
  77   dbus_free (list);
  78
  79   return NULL;
  80 }
  81
  82 void
  83 bus_expire_list_free (BusExpireList *list)
  84 {
  85   _dbus_assert (list->items == NULL);
  86
  87   _dbus_loop_remove_timeout (list->loop, list->timeout);
  88
  89   _dbus_timeout_unref (list->timeout);
  90
  91   dbus_free (list);
  92 }
  93
  94 void
  95 bus_expire_timeout_set_interval (DBusTimeout   *timeout,
  96                                  int            next_interval)
  97 {
  98   if (next_interval >= 0)
  99     {
 100       _dbus_timeout_set_interval (timeout,
 101                                   next_interval);
 102       _dbus_timeout_set_enabled (timeout, TRUE);
 103
 104       _dbus_verbose ("Enabled an expire timeout with interval %d\n",
 105                      next_interval);
 106     }
 107   else if (dbus_timeout_get_enabled (timeout))
 108     {
 109       _dbus_timeout_set_enabled (timeout, FALSE);
 110
 111       _dbus_verbose ("Disabled an expire timeout\n");
 112     }
 113   else
 114     _dbus_verbose ("No need to disable this expire timeout\n");
 115 }
 116
 117 void
 118 bus_expire_list_recheck_immediately (BusExpireList *list)
 119 {
 120   _dbus_verbose ("setting interval on expire list to 0 for immediate recheck\n");
 121
 122   bus_expire_timeout_set_interval (list->timeout, 0);
 123 }
 124
 125 static int
 126 do_expiration_with_monotonic_time (BusExpireList *list,
 127                                    long           tv_sec,
 128                                    long           tv_usec)
 129 {
 130   DBusList *link;
 131   int next_interval, min_wait_time, items_to_expire;
 132
 133   next_interval = -1;
 134   min_wait_time = 3600 * 1000; /* this is reset anyway if used */
 135   items_to_expire = 0;
 136
 137   link = _dbus_list_get_first_link (&list->items);
 138   while (link != NULL)
 139     {
 140       DBusList *next = _dbus_list_get_next_link (&list->items, link);
 141       double elapsed;
 142       BusExpireItem *item;
 143
 144       item = link->data;
 145
 146       elapsed = ELAPSED_MILLISECONDS_SINCE (item->added_tv_sec,
 147                                             item->added_tv_usec,
 148                                             tv_sec, tv_usec);
 149
 150       if (((item->added_tv_sec == 0) && (item->added_tv_usec == 0)) ||
 151           ((list->expire_after > 0) && (elapsed >= (double) list->expire_after)))
 152         {
 153           _dbus_verbose ("Expiring an item %p\n", item);
 154
 155           /* If the expire function fails, we just end up expiring
 156            * this item next time we walk through the list. This would
 157            * be an indeterminate time normally, so we set up the
 158            * next_interval to be "shortly" (just enough to avoid
 159            * a busy loop)
 160            */
 161           if (!(* list->expire_func) (list, link, list->data))
 162             {
 163               next_interval = _dbus_get_oom_wait ();
 164               break;
 165             }
 166         }
 167       else if (list->expire_after > 0)
 168         {
 169           double to_wait;
 170
 171           items_to_expire = 1;
 172           to_wait = (double) list->expire_after - elapsed;
 173           if (min_wait_time > to_wait)
 174             min_wait_time = to_wait;
 175         }
 176
 177       link = next;
 178     }
 179
 180   if (next_interval < 0 && items_to_expire)
 181     next_interval = min_wait_time;
 182
 183   return next_interval;
 184 }
 185
 186 static void
 187 bus_expirelist_expire (BusExpireList *list)
 188 {
 189   int next_interval;
 190
 191   next_interval = -1;
 192
 193   if (list->items != NULL)
 194     {
 195       long tv_sec, tv_usec;
 196
 197       _dbus_get_monotonic_time (&tv_sec, &tv_usec);
 198
 199       next_interval = do_expiration_with_monotonic_time (list, tv_sec, tv_usec);
 200     }
 201
 202   bus_expire_timeout_set_interval (list->timeout, next_interval);
 203 }
 204
 205 static dbus_bool_t
 206 expire_timeout_handler (void *data)
 207 {
 208   BusExpireList *list = data;
 209
 210   _dbus_verbose ("Running\n");
 211
 212   /* note that this may remove the timeout */
 213   bus_expirelist_expire (list);
 214
 215   return TRUE;
 216 }
 217
 218 void
 219 bus_expire_list_remove_link (BusExpireList *list,
 220                              DBusList      *link)
 221 {
 222   _dbus_list_remove_link (&list->items, link);
 223 }
 224
 225 dbus_bool_t
 226 bus_expire_list_remove (BusExpireList *list,
 227                         BusExpireItem *item)
 228 {
 229   return _dbus_list_remove (&list->items, item);
 230 }
 231
 232 void
 233 bus_expire_list_unlink (BusExpireList *list,
 234                         DBusList      *link)
 235 {
 236   _dbus_list_unlink (&list->items, link);
 237 }
 238
 239 dbus_bool_t
 240 bus_expire_list_add (BusExpireList *list,
 241                      BusExpireItem *item)
 242 {
 243   dbus_bool_t ret;
 244
 245   ret = _dbus_list_prepend (&list->items, item);
 246   if (ret && !dbus_timeout_get_enabled (list->timeout))
 247     bus_expire_timeout_set_interval (list->timeout, 0);
 248
 249   return ret;
 250 }
 251
 252 void
 253 bus_expire_list_add_link (BusExpireList *list,
 254                           DBusList      *link)
 255 {
 256   _dbus_assert (link->data != NULL);
 257
 258   _dbus_list_prepend_link (&list->items, link);
 259
 260   if (!dbus_timeout_get_enabled (list->timeout))
 261     bus_expire_timeout_set_interval (list->timeout, 0);
 262 }
 263
 264 DBusList*
 265 bus_expire_list_get_first_link (BusExpireList *list)
 266 {
 267   return _dbus_list_get_first_link (&list->items);
 268 }
 269
 270 DBusList*
 271 bus_expire_list_get_next_link (BusExpireList *list,
 272                                DBusList      *link)
 273 {
 274   return _dbus_list_get_next_link (&list->items, link);
 275 }
 276
 277 dbus_bool_t
 278 bus_expire_list_contains_item (BusExpireList *list,
 279                                BusExpireItem *item)
 280 {
 281   return _dbus_list_find_last (&list->items, item) != NULL;
 282 }
 283
 284 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
 285
 286 typedef struct
 287 {
 288   BusExpireItem item;
 289   int expire_count;
 290 } TestExpireItem;
 291
 292 static dbus_bool_t
 293 test_expire_func (BusExpireList *list,
 294                   DBusList      *link,
 295                   void          *data)
 296 {
 297   TestExpireItem *t;
 298
 299   t = (TestExpireItem*) link->data;
 300
 301   t->expire_count += 1;
 302
 303   return TRUE;
 304 }
 305
 306 static void
 307 time_add_milliseconds (long *tv_sec,
 308                        long *tv_usec,
 309                        int   milliseconds)
 310 {
 311   *tv_sec = *tv_sec + milliseconds / 1000;
 312   *tv_usec = *tv_usec + milliseconds * 1000;
 313   if (*tv_usec >= 1000000)
 314     {
 315       *tv_usec -= 1000000;
 316       *tv_sec += 1;
 317     }
 318 }
 319
 320 dbus_bool_t
 321 bus_expire_list_test (const DBusString *test_data_dir)
 322 {
 323   DBusLoop *loop;
 324   BusExpireList *list;
 325   long tv_sec, tv_usec;
 326   long tv_sec_not_expired, tv_usec_not_expired;
 327   long tv_sec_expired, tv_usec_expired;
 328   long tv_sec_past, tv_usec_past;
 329   TestExpireItem *item;
 330   int next_interval;
 331   dbus_bool_t result = FALSE;
 332
 333
 334   loop = _dbus_loop_new ();
 335   _dbus_assert (loop != NULL);
 336
 337 #define EXPIRE_AFTER 100
 338
 339   list = bus_expire_list_new (loop, EXPIRE_AFTER,
 340                               test_expire_func, NULL);
 341   _dbus_assert (list != NULL);
 342
 343   _dbus_get_monotonic_time (&tv_sec, &tv_usec);
 344
 345   tv_sec_not_expired = tv_sec;
 346   tv_usec_not_expired = tv_usec;
 347   time_add_milliseconds (&tv_sec_not_expired,
 348                          &tv_usec_not_expired, EXPIRE_AFTER - 1);
 349
 350   tv_sec_expired = tv_sec;
 351   tv_usec_expired = tv_usec;
 352   time_add_milliseconds (&tv_sec_expired,
 353                          &tv_usec_expired, EXPIRE_AFTER);
 354
 355
 356   tv_sec_past = tv_sec - 1;
 357   tv_usec_past = tv_usec;
 358
 359   item = dbus_new0 (TestExpireItem, 1);
 360
 361   if (item == NULL)
 362     goto oom;
 363
 364   item->item.added_tv_sec = tv_sec;
 365   item->item.added_tv_usec = tv_usec;
 366   if (!bus_expire_list_add (list, &item->item))
 367     _dbus_assert_not_reached ("out of memory");
 368
 369   next_interval =
 370     do_expiration_with_monotonic_time (list, tv_sec_not_expired,
 371                                        tv_usec_not_expired);
 372   _dbus_assert (item->expire_count == 0);
 373   _dbus_verbose ("next_interval = %d\n", next_interval);
 374   _dbus_assert (next_interval == 1);
 375
 376   next_interval =
 377     do_expiration_with_monotonic_time (list, tv_sec_expired,
 378                                        tv_usec_expired);
 379   _dbus_assert (item->expire_count == 1);
 380   _dbus_verbose ("next_interval = %d\n", next_interval);
 381   _dbus_assert (next_interval == -1);
 382
 383   next_interval =
 384     do_expiration_with_monotonic_time (list, tv_sec_past,
 385                                        tv_usec_past);
 386   _dbus_assert (item->expire_count == 1);
 387   _dbus_verbose ("next_interval = %d\n", next_interval);
 388   _dbus_assert (next_interval == 1000 + EXPIRE_AFTER);
 389
 390   bus_expire_list_remove (list, &item->item);
 391   dbus_free (item);
 392
 393   bus_expire_list_free (list);
 394   _dbus_loop_unref (loop);
 395
 396   result = TRUE;
 397
 398  oom:
 399   return result;
 400 }
 401
 402 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */