dbus/dbus-mainloop.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-mainloop.c  Main loop utility
   3  *
   4  * Copyright © 2003, 2004  Red Hat, Inc.
   5  * Copyright © 2011 Nokia Corporation
   6  *
   7  * Licensed under the Academic Free License version 2.1
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #include <config.h>
  26 #include "dbus-mainloop.h"
  27
  28 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  29
  30 #include <dbus/dbus-hash.h>
  31 #include <dbus/dbus-list.h>
  32 #include <dbus/dbus-socket-set.h>
  33 #include <dbus/dbus-watch.h>
  34
  35 #define MAINLOOP_SPEW 0
  36
  37 #if MAINLOOP_SPEW
  38 #ifdef DBUS_ENABLE_VERBOSE_MODE
  39 static const char*
  40 watch_flags_to_string (int flags)
  41 {
  42   const char *watch_type;
  43
  44   if ((flags & DBUS_WATCH_READABLE) &&
  45       (flags & DBUS_WATCH_WRITABLE))
  46     watch_type = "readwrite";
  47   else if (flags & DBUS_WATCH_READABLE)
  48     watch_type = "read";
  49   else if (flags & DBUS_WATCH_WRITABLE)
  50     watch_type = "write";
  51   else
  52     watch_type = "not read or write";
  53   return watch_type;
  54 }
  55 #endif /* DBUS_ENABLE_VERBOSE_MODE */
  56 #endif /* MAINLOOP_SPEW */
  57
  58 struct DBusLoop
  59 {
  60   int refcount;
  61   /** fd => dbus_malloc'd DBusList ** of references to DBusWatch */
  62   DBusHashTable *watches;
  63   DBusSocketSet *socket_set;
  64   DBusList *timeouts;
  65   int callback_list_serial;
  66   int watch_count;
  67   int timeout_count;
  68   int depth; /**< number of recursive runs */
  69   DBusList *need_dispatch;
  70   /** TRUE if we will skip a watch next time because it was OOM; becomes
  71    * FALSE between polling, and dealing with the results of the poll */
  72   unsigned oom_watch_pending : 1;
  73 };
  74
  75 typedef struct
  76 {
  77   DBusTimeout *timeout;
  78   unsigned long last_tv_sec;
  79   unsigned long last_tv_usec;
  80 } TimeoutCallback;
  81
  82 #define TIMEOUT_CALLBACK(callback) ((TimeoutCallback*)callback)
  83
  84 static TimeoutCallback*
  85 timeout_callback_new (DBusTimeout         *timeout)
  86 {
  87   TimeoutCallback *cb;
  88
  89   cb = dbus_new (TimeoutCallback, 1);
  90   if (cb == NULL)
  91     return NULL;
  92
  93   cb->timeout = timeout;
  94   _dbus_get_monotonic_time (&cb->last_tv_sec,
  95                             &cb->last_tv_usec);
  96   return cb;
  97 }
  98
  99 static void
 100 timeout_callback_free (TimeoutCallback *cb)
 101 {
 102   dbus_free (cb);
 103 }
 104
 105 static void
 106 free_watch_table_entry (void *data)
 107 {
 108   DBusList **watches = data;
 109   DBusWatch *watch;
 110
 111   /* DBusHashTable sometimes calls free_function(NULL) even if you never
 112    * have NULL as a value */
 113   if (watches == NULL)
 114     return;
 115
 116   for (watch = _dbus_list_pop_first (watches);
 117       watch != NULL;
 118       watch = _dbus_list_pop_first (watches))
 119     {
 120       _dbus_watch_unref (watch);
 121     }
 122
 123   _dbus_assert (*watches == NULL);
 124   dbus_free (watches);
 125 }
 126
 127 DBusLoop*
 128 _dbus_loop_new (void)
 129 {
 130   DBusLoop *loop;
 131
 132   loop = dbus_new0 (DBusLoop, 1);
 133   if (loop == NULL)
 134     return NULL;
 135
 136   loop->watches = _dbus_hash_table_new (DBUS_HASH_INT, NULL,
 137                                         free_watch_table_entry);
 138
 139   loop->socket_set = _dbus_socket_set_new (0);
 140
 141   if (loop->watches == NULL || loop->socket_set == NULL)
 142     {
 143       if (loop->watches != NULL)
 144         _dbus_hash_table_unref (loop->watches);
 145
 146       if (loop->socket_set != NULL)
 147         _dbus_socket_set_free (loop->socket_set);
 148
 149       dbus_free (loop);
 150       return NULL;
 151     }
 152
 153   loop->refcount = 1;
 154
 155   return loop;
 156 }
 157
 158 DBusLoop *
 159 _dbus_loop_ref (DBusLoop *loop)
 160 {
 161   _dbus_assert (loop != NULL);
 162   _dbus_assert (loop->refcount > 0);
 163
 164   loop->refcount += 1;
 165
 166   return loop;
 167 }
 168
 169 void
 170 _dbus_loop_unref (DBusLoop *loop)
 171 {
 172   _dbus_assert (loop != NULL);
 173   _dbus_assert (loop->refcount > 0);
 174
 175   loop->refcount -= 1;
 176   if (loop->refcount == 0)
 177     {
 178       while (loop->need_dispatch)
 179         {
 180           DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);
 181
 182           dbus_connection_unref (connection);
 183         }
 184
 185       _dbus_hash_table_unref (loop->watches);
 186       _dbus_socket_set_free (loop->socket_set);
 187       dbus_free (loop);
 188     }
 189 }
 190
 191 static DBusList **
 192 ensure_watch_table_entry (DBusLoop *loop,
 193                           int       fd)
 194 {
 195   DBusList **watches;
 196
 197   watches = _dbus_hash_table_lookup_int (loop->watches, fd);
 198
 199   if (watches == NULL)
 200     {
 201       watches = dbus_new0 (DBusList *, 1);
 202
 203       if (watches == NULL)
 204         return watches;
 205
 206       if (!_dbus_hash_table_insert_int (loop->watches, fd, watches))
 207         {
 208           dbus_free (watches);
 209           watches = NULL;
 210         }
 211     }
 212
 213   return watches;
 214 }
 215
 216 static void
 217 cull_watches_for_invalid_fd (DBusLoop  *loop,
 218                              int        fd)
 219 {
 220   DBusList *link;
 221   DBusList **watches;
 222
 223   _dbus_warn ("invalid request, socket fd %d not open\n", fd);
 224   watches = _dbus_hash_table_lookup_int (loop->watches, fd);
 225
 226   if (watches != NULL)
 227     {
 228       for (link = _dbus_list_get_first_link (watches);
 229           link != NULL;
 230           link = _dbus_list_get_next_link (watches, link))
 231         _dbus_watch_invalidate (link->data);
 232     }
 233
 234   _dbus_hash_table_remove_int (loop->watches, fd);
 235 }
 236
 237 static dbus_bool_t
 238 gc_watch_table_entry (DBusLoop  *loop,
 239                       DBusList **watches,
 240                       int        fd)
 241 {
 242   /* If watches is already NULL we have nothing to do */
 243   if (watches == NULL)
 244     return FALSE;
 245
 246   /* We can't GC hash table entries if they're non-empty lists */
 247   if (*watches != NULL)
 248     return FALSE;
 249
 250   _dbus_hash_table_remove_int (loop->watches, fd);
 251   return TRUE;
 252 }
 253
 254 static void
 255 refresh_watches_for_fd (DBusLoop  *loop,
 256                         DBusList **watches,
 257                         int        fd)
 258 {
 259   DBusList *link;
 260   unsigned int flags = 0;
 261   dbus_bool_t interested = FALSE;
 262
 263   _dbus_assert (fd != -1);
 264
 265   if (watches == NULL)
 266     watches = _dbus_hash_table_lookup_int (loop->watches, fd);
 267
 268   /* we allocated this in the first _dbus_loop_add_watch for the fd, and keep
 269    * it until there are none left */
 270   _dbus_assert (watches != NULL);
 271
 272   for (link = _dbus_list_get_first_link (watches);
 273       link != NULL;
 274       link = _dbus_list_get_next_link (watches, link))
 275     {
 276       if (dbus_watch_get_enabled (link->data) &&
 277           !_dbus_watch_get_oom_last_time (link->data))
 278         {
 279           flags |= dbus_watch_get_flags (link->data);
 280           interested = TRUE;
 281         }
 282     }
 283
 284   if (interested)
 285     _dbus_socket_set_enable (loop->socket_set, fd, flags);
 286   else
 287     _dbus_socket_set_disable (loop->socket_set, fd);
 288 }
 289
 290 dbus_bool_t
 291 _dbus_loop_add_watch (DBusLoop  *loop,
 292                       DBusWatch *watch)
 293 {
 294   int fd;
 295   DBusList **watches;
 296
 297   fd = dbus_watch_get_socket (watch);
 298   _dbus_assert (fd != -1);
 299
 300   watches = ensure_watch_table_entry (loop, fd);
 301
 302   if (watches == NULL)
 303     return FALSE;
 304
 305   if (!_dbus_list_append (watches, _dbus_watch_ref (watch)))
 306     {
 307       _dbus_watch_unref (watch);
 308       gc_watch_table_entry (loop, watches, fd);
 309
 310       return FALSE;
 311     }
 312
 313   if (_dbus_list_length_is_one (watches))
 314     {
 315       if (!_dbus_socket_set_add (loop->socket_set, fd,
 316                                  dbus_watch_get_flags (watch),
 317                                  dbus_watch_get_enabled (watch)))
 318         {
 319           _dbus_hash_table_remove_int (loop->watches, fd);
 320           return FALSE;
 321         }
 322     }
 323   else
 324     {
 325       /* we're modifying, not adding, which can't fail with OOM */
 326       refresh_watches_for_fd (loop, watches, fd);
 327     }
 328
 329   loop->callback_list_serial += 1;
 330   loop->watch_count += 1;
 331   return TRUE;
 332 }
 333
 334 void
 335 _dbus_loop_toggle_watch (DBusLoop          *loop,
 336                          DBusWatch         *watch)
 337 {
 338   refresh_watches_for_fd (loop, NULL, dbus_watch_get_socket (watch));
 339 }
 340
 341 void
 342 _dbus_loop_remove_watch (DBusLoop         *loop,
 343                          DBusWatch        *watch)
 344 {
 345   DBusList **watches;
 346   DBusList *link;
 347   int fd;
 348
 349   /* This relies on people removing watches before they invalidate them,
 350    * which has been safe since fd.o #33336 was fixed. Assert about it
 351    * so we don't regress. */
 352   fd = dbus_watch_get_socket (watch);
 353   _dbus_assert (fd != -1);
 354
 355   watches = _dbus_hash_table_lookup_int (loop->watches, fd);
 356
 357   if (watches != NULL)
 358     {
 359       link = _dbus_list_get_first_link (watches);
 360       while (link != NULL)
 361         {
 362           DBusList *next = _dbus_list_get_next_link (watches, link);
 363           DBusWatch *this = link->data;
 364
 365           if (this == watch)
 366             {
 367               _dbus_list_remove_link (watches, link);
 368               loop->callback_list_serial += 1;
 369               loop->watch_count -= 1;
 370               _dbus_watch_unref (this);
 371
 372               /* if that was the last watch for that fd, drop the hash table
 373                * entry, and stop reserving space for it in the socket set */
 374               if (gc_watch_table_entry (loop, watches, fd))
 375                 {
 376                   _dbus_socket_set_remove (loop->socket_set, fd);
 377                 }
 378
 379               return;
 380             }
 381
 382           link = next;
 383          }
 384      }
 385
 386   _dbus_warn ("could not find watch %p to remove\n", watch);
 387 }
 388
 389 dbus_bool_t
 390 _dbus_loop_add_timeout (DBusLoop           *loop,
 391                         DBusTimeout        *timeout)
 392 {
 393   TimeoutCallback *tcb;
 394
 395   tcb = timeout_callback_new (timeout);
 396   if (tcb == NULL)
 397     return FALSE;
 398
 399   if (_dbus_list_append (&loop->timeouts, tcb))
 400     {
 401       loop->callback_list_serial += 1;
 402       loop->timeout_count += 1;
 403     }
 404   else
 405     {
 406       timeout_callback_free (tcb);
 407       return FALSE;
 408     }
 409
 410   return TRUE;
 411 }
 412
 413 void
 414 _dbus_loop_remove_timeout (DBusLoop           *loop,
 415                            DBusTimeout        *timeout)
 416 {
 417   DBusList *link;
 418
 419   link = _dbus_list_get_first_link (&loop->timeouts);
 420   while (link != NULL)
 421     {
 422       DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
 423       TimeoutCallback *this = link->data;
 424
 425       if (this->timeout == timeout)
 426         {
 427           _dbus_list_remove_link (&loop->timeouts, link);
 428           loop->callback_list_serial += 1;
 429           loop->timeout_count -= 1;
 430           timeout_callback_free (this);
 431
 432           return;
 433         }
 434
 435       link = next;
 436     }
 437
 438   _dbus_warn ("could not find timeout %p to remove\n", timeout);
 439 }
 440
 441 /* Convolutions from GLib, there really must be a better way
 442  * to do this.
 443  */
 444 static dbus_bool_t
 445 check_timeout (unsigned long    tv_sec,
 446                unsigned long    tv_usec,
 447                TimeoutCallback *tcb,
 448                int             *timeout)
 449 {
 450   long sec_remaining;
 451   long msec_remaining;
 452   unsigned long expiration_tv_sec;
 453   unsigned long expiration_tv_usec;
 454   long interval_seconds;
 455   long interval_milliseconds;
 456   int interval;
 457
 458   /* I'm pretty sure this function could suck (a lot) less */
 459
 460   interval = dbus_timeout_get_interval (tcb->timeout);
 461
 462   interval_seconds = interval / 1000L;
 463   interval_milliseconds = interval % 1000L;
 464
 465   expiration_tv_sec = tcb->last_tv_sec + interval_seconds;
 466   expiration_tv_usec = tcb->last_tv_usec + interval_milliseconds * 1000;
 467   if (expiration_tv_usec >= 1000000)
 468     {
 469       expiration_tv_usec -= 1000000;
 470       expiration_tv_sec += 1;
 471     }
 472
 473   sec_remaining = expiration_tv_sec - tv_sec;
 474   /* need to force this to be signed, as it is intended to sometimes
 475    * produce a negative result
 476    */
 477   msec_remaining = ((long) expiration_tv_usec - (long) tv_usec) / 1000L;
 478
 479 #if MAINLOOP_SPEW
 480   _dbus_verbose ("Interval is %ld seconds %ld msecs\n",
 481                  interval_seconds,
 482                  interval_milliseconds);
 483   _dbus_verbose ("Now is  %lu seconds %lu usecs\n",
 484                  tv_sec, tv_usec);
 485   _dbus_verbose ("Last is %lu seconds %lu usecs\n",
 486                  tcb->last_tv_sec, tcb->last_tv_usec);
 487   _dbus_verbose ("Exp is  %lu seconds %lu usecs\n",
 488                  expiration_tv_sec, expiration_tv_usec);
 489   _dbus_verbose ("Pre-correction, sec_remaining %ld msec_remaining %ld\n",
 490                  sec_remaining, msec_remaining);
 491 #endif
 492
 493   /* We do the following in a rather convoluted fashion to deal with
 494    * the fact that we don't have an integral type big enough to hold
 495    * the difference of two timevals in milliseconds.
 496    */
 497   if (sec_remaining < 0 || (sec_remaining == 0 && msec_remaining < 0))
 498     {
 499       *timeout = 0;
 500     }
 501   else
 502     {
 503       if (msec_remaining < 0)
 504         {
 505           msec_remaining += 1000;
 506           sec_remaining -= 1;
 507         }
 508
 509       if (sec_remaining > (_DBUS_INT_MAX / 1000) ||
 510           msec_remaining > _DBUS_INT_MAX)
 511         *timeout = _DBUS_INT_MAX;
 512       else
 513         *timeout = sec_remaining * 1000 + msec_remaining;
 514     }
 515
 516   if (*timeout > interval)
 517     {
 518       /* This indicates that the system clock probably moved backward */
 519       _dbus_verbose ("System clock set backward! Resetting timeout.\n");
 520
 521       tcb->last_tv_sec = tv_sec;
 522       tcb->last_tv_usec = tv_usec;
 523
 524       *timeout = interval;
 525     }
 526
 527 #if MAINLOOP_SPEW
 528   _dbus_verbose ("  timeout expires in %d milliseconds\n", *timeout);
 529 #endif
 530
 531   return *timeout == 0;
 532 }
 533
 534 dbus_bool_t
 535 _dbus_loop_dispatch (DBusLoop *loop)
 536 {
 537
 538 #if MAINLOOP_SPEW
 539   _dbus_verbose ("  %d connections to dispatch\n", _dbus_list_get_length (&loop->need_dispatch));
 540 #endif
 541
 542   if (loop->need_dispatch == NULL)
 543     return FALSE;
 544
 545  next:
 546   while (loop->need_dispatch != NULL)
 547     {
 548       DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);
 549
 550       while (TRUE)
 551         {
 552           DBusDispatchStatus status;
 553
 554           status = dbus_connection_dispatch (connection);
 555
 556           if (status == DBUS_DISPATCH_COMPLETE)
 557             {
 558               dbus_connection_unref (connection);
 559               goto next;
 560             }
 561           else
 562             {
 563               if (status == DBUS_DISPATCH_NEED_MEMORY)
 564                 _dbus_wait_for_memory ();
 565             }
 566         }
 567     }
 568
 569   return TRUE;
 570 }
 571
 572 dbus_bool_t
 573 _dbus_loop_queue_dispatch (DBusLoop       *loop,
 574                            DBusConnection *connection)
 575 {
 576   if (_dbus_list_append (&loop->need_dispatch, connection))
 577     {
 578       dbus_connection_ref (connection);
 579       return TRUE;
 580     }
 581   else
 582     return FALSE;
 583 }
 584
 585 /* Returns TRUE if we invoked any timeouts or have ready file
 586  * descriptors, which is just used in test code as a debug hack
 587  */
 588
 589 dbus_bool_t
 590 _dbus_loop_iterate (DBusLoop     *loop,
 591                     dbus_bool_t   block)
 592 {
 593 #define N_STACK_DESCRIPTORS 64
 594   dbus_bool_t retval;
 595   DBusSocketEvent ready_fds[N_STACK_DESCRIPTORS];
 596   int i;
 597   DBusList *link;
 598   int n_ready;
 599   int initial_serial;
 600   long timeout;
 601   int orig_depth;
 602
 603   retval = FALSE;
 604
 605   orig_depth = loop->depth;
 606
 607 #if MAINLOOP_SPEW
 608   _dbus_verbose ("Iteration block=%d depth=%d timeout_count=%d watch_count=%d\n",
 609                  block, loop->depth, loop->timeout_count, loop->watch_count);
 610 #endif
 611
 612   if (_dbus_hash_table_get_n_entries (loop->watches) == 0 &&
 613       loop->timeouts == NULL)
 614     goto next_iteration;
 615
 616   timeout = -1;
 617   if (loop->timeout_count > 0)
 618     {
 619       unsigned long tv_sec;
 620       unsigned long tv_usec;
 621
 622       _dbus_get_monotonic_time (&tv_sec, &tv_usec);
 623
 624       link = _dbus_list_get_first_link (&loop->timeouts);
 625       while (link != NULL)
 626         {
 627           DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
 628           TimeoutCallback *tcb = link->data;
 629
 630           if (dbus_timeout_get_enabled (tcb->timeout))
 631             {
 632               int msecs_remaining;
 633
 634               check_timeout (tv_sec, tv_usec, tcb, &msecs_remaining);
 635
 636               if (timeout < 0)
 637                 timeout = msecs_remaining;
 638               else
 639                 timeout = MIN (msecs_remaining, timeout);
 640
 641 #if MAINLOOP_SPEW
 642               _dbus_verbose ("  timeout added, %d remaining, aggregate timeout %ld\n",
 643                              msecs_remaining, timeout);
 644 #endif
 645
 646               _dbus_assert (timeout >= 0);
 647
 648               if (timeout == 0)
 649                 break; /* it's not going to get shorter... */
 650             }
 651 #if MAINLOOP_SPEW
 652           else
 653             {
 654               _dbus_verbose ("  skipping disabled timeout\n");
 655             }
 656 #endif
 657
 658           link = next;
 659         }
 660     }
 661
 662   /* Never block if we have stuff to dispatch */
 663   if (!block || loop->need_dispatch != NULL)
 664     {
 665       timeout = 0;
 666 #if MAINLOOP_SPEW
 667       _dbus_verbose ("  timeout is 0 as we aren't blocking\n");
 668 #endif
 669     }
 670
 671   /* if a watch was OOM last time, don't wait longer than the OOM
 672    * wait to re-enable it
 673    */
 674   if (loop->oom_watch_pending)
 675     timeout = MIN (timeout, _dbus_get_oom_wait ());
 676
 677 #if MAINLOOP_SPEW
 678   _dbus_verbose ("  polling on %d descriptors timeout %ld\n", n_fds, timeout);
 679 #endif
 680
 681   n_ready = _dbus_socket_set_poll (loop->socket_set, ready_fds,
 682                                    _DBUS_N_ELEMENTS (ready_fds), timeout);
 683
 684   /* re-enable any watches we skipped this time */
 685   if (loop->oom_watch_pending)
 686     {
 687       DBusHashIter hash_iter;
 688
 689       loop->oom_watch_pending = FALSE;
 690
 691       _dbus_hash_iter_init (loop->watches, &hash_iter);
 692
 693       while (_dbus_hash_iter_next (&hash_iter))
 694         {
 695           DBusList **watches;
 696           int fd;
 697           dbus_bool_t changed;
 698
 699           changed = FALSE;
 700           fd = _dbus_hash_iter_get_int_key (&hash_iter);
 701           watches = _dbus_hash_iter_get_value (&hash_iter);
 702
 703           for (link = _dbus_list_get_first_link (watches);
 704               link != NULL;
 705               link = _dbus_list_get_next_link (watches, link))
 706             {
 707               DBusWatch *watch = link->data;
 708
 709               if (_dbus_watch_get_oom_last_time (watch))
 710                 {
 711                   _dbus_watch_set_oom_last_time (watch, FALSE);
 712                   changed = TRUE;
 713                 }
 714             }
 715
 716           if (changed)
 717             refresh_watches_for_fd (loop, watches, fd);
 718         }
 719
 720       retval = TRUE; /* return TRUE here to keep the loop going,
 721                       * since we don't know the watch was inactive */
 722     }
 723
 724   initial_serial = loop->callback_list_serial;
 725
 726   if (loop->timeout_count > 0)
 727     {
 728       unsigned long tv_sec;
 729       unsigned long tv_usec;
 730
 731       _dbus_get_monotonic_time (&tv_sec, &tv_usec);
 732
 733       /* It'd be nice to avoid this O(n) thingy here */
 734       link = _dbus_list_get_first_link (&loop->timeouts);
 735       while (link != NULL)
 736         {
 737           DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
 738           TimeoutCallback *tcb = link->data;
 739
 740           if (initial_serial != loop->callback_list_serial)
 741             goto next_iteration;
 742
 743           if (loop->depth != orig_depth)
 744             goto next_iteration;
 745
 746           if (dbus_timeout_get_enabled (tcb->timeout))
 747             {
 748               int msecs_remaining;
 749
 750               if (check_timeout (tv_sec, tv_usec,
 751                                  tcb, &msecs_remaining))
 752                 {
 753                   /* Save last callback time and fire this timeout */
 754                   tcb->last_tv_sec = tv_sec;
 755                   tcb->last_tv_usec = tv_usec;
 756
 757 #if MAINLOOP_SPEW
 758                   _dbus_verbose ("  invoking timeout\n");
 759 #endif
 760
 761                   /* can theoretically return FALSE on OOM, but we just
 762                    * let it fire again later - in practice that's what
 763                    * every wrapper callback in dbus-daemon used to do */
 764                   dbus_timeout_handle (tcb->timeout);
 765
 766                   retval = TRUE;
 767                 }
 768               else
 769                 {
 770 #if MAINLOOP_SPEW
 771                   _dbus_verbose ("  timeout has not expired\n");
 772 #endif
 773                 }
 774             }
 775 #if MAINLOOP_SPEW
 776           else
 777             {
 778               _dbus_verbose ("  skipping invocation of disabled timeout\n");
 779             }
 780 #endif
 781
 782           link = next;
 783         }
 784     }
 785
 786   if (n_ready > 0)
 787     {
 788       for (i = 0; i < n_ready; i++)
 789         {
 790           DBusList **watches;
 791           DBusList *next;
 792           unsigned int condition;
 793           dbus_bool_t any_oom;
 794
 795           /* FIXME I think this "restart if we change the watches"
 796            * approach could result in starving watches
 797            * toward the end of the list.
 798            */
 799           if (initial_serial != loop->callback_list_serial)
 800             goto next_iteration;
 801
 802           if (loop->depth != orig_depth)
 803             goto next_iteration;
 804
 805           _dbus_assert (ready_fds[i].flags != 0);
 806
 807           if (_DBUS_UNLIKELY (ready_fds[i].flags & _DBUS_WATCH_NVAL))
 808             {
 809               cull_watches_for_invalid_fd (loop, ready_fds[i].fd);
 810               goto next_iteration;
 811             }
 812
 813           condition = ready_fds[i].flags;
 814           _dbus_assert ((condition & _DBUS_WATCH_NVAL) == 0);
 815
 816           /* condition may still be 0 if we got some
 817            * weird POLLFOO thing like POLLWRBAND
 818            */
 819           if (condition == 0)
 820             continue;
 821
 822           watches = _dbus_hash_table_lookup_int (loop->watches,
 823                                                  ready_fds[i].fd);
 824
 825           if (watches == NULL)
 826             continue;
 827
 828           any_oom = FALSE;
 829
 830           for (link = _dbus_list_get_first_link (watches);
 831               link != NULL;
 832               link = next)
 833             {
 834               DBusWatch *watch = link->data;
 835
 836               next = _dbus_list_get_next_link (watches, link);
 837
 838               if (dbus_watch_get_enabled (watch))
 839                 {
 840                   dbus_bool_t oom;
 841
 842                   oom = !dbus_watch_handle (watch, condition);
 843
 844                   if (oom)
 845                     {
 846                       _dbus_watch_set_oom_last_time (watch, TRUE);
 847                       loop->oom_watch_pending = TRUE;
 848                       any_oom = TRUE;
 849                     }
 850
 851 #if MAINLOOP_SPEW
 852                   _dbus_verbose ("  Invoked watch, oom = %d\n", oom);
 853 #endif
 854                   retval = TRUE;
 855
 856                   /* We re-check this every time, in case the callback
 857                    * added/removed watches, which might make our position in
 858                    * the linked list invalid. See the FIXME above. */
 859                   if (initial_serial != loop->callback_list_serial ||
 860                       loop->depth != orig_depth)
 861                     {
 862                       if (any_oom)
 863                         refresh_watches_for_fd (loop, NULL, ready_fds[i].fd);
 864
 865                       goto next_iteration;
 866                     }
 867                 }
 868             }
 869
 870           if (any_oom)
 871             refresh_watches_for_fd (loop, watches, ready_fds[i].fd);
 872         }
 873     }
 874
 875  next_iteration:
 876 #if MAINLOOP_SPEW
 877   _dbus_verbose ("  moving to next iteration\n");
 878 #endif
 879
 880   if (_dbus_loop_dispatch (loop))
 881     retval = TRUE;
 882
 883 #if MAINLOOP_SPEW
 884   _dbus_verbose ("Returning %d\n", retval);
 885 #endif
 886
 887   return retval;
 888 }
 889
 890 void
 891 _dbus_loop_run (DBusLoop *loop)
 892 {
 893   int our_exit_depth;
 894
 895   _dbus_assert (loop->depth >= 0);
 896
 897   _dbus_loop_ref (loop);
 898
 899   our_exit_depth = loop->depth;
 900   loop->depth += 1;
 901
 902   _dbus_verbose ("Running main loop, depth %d -> %d\n",
 903                  loop->depth - 1, loop->depth);
 904
 905   while (loop->depth != our_exit_depth)
 906     _dbus_loop_iterate (loop, TRUE);
 907
 908   _dbus_loop_unref (loop);
 909 }
 910
 911 void
 912 _dbus_loop_quit (DBusLoop *loop)
 913 {
 914   _dbus_assert (loop->depth > 0);
 915
 916   loop->depth -= 1;
 917
 918   _dbus_verbose ("Quit main loop, depth %d -> %d\n",
 919                  loop->depth + 1, loop->depth);
 920 }
 921
 922 int
 923 _dbus_get_oom_wait (void)
 924 {
 925 #ifdef DBUS_BUILD_TESTS
 926   /* make tests go fast */
 927   return 0;
 928 #else
 929   return 500;
 930 #endif
 931 }
 932
 933 void
 934 _dbus_wait_for_memory (void)
 935 {
 936   _dbus_verbose ("Waiting for more memory\n");
 937   _dbus_sleep_milliseconds (_dbus_get_oom_wait ());
 938 }
 939
 940 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */