/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * gmain.c: Main loop abstraction, timeouts, and idle functions

 * Copyright 1998 Owen Taylor

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/.

 */

/*

 * MT safe

 */

#include "config.h"

#include "glibconfig.h"

#include "glib_trace.h"

/* Uncomment the next line (and the corresponding line in gpoll.c) to

 * enable debugging printouts if the environment variable

 * G_MAIN_POLL_DEBUG is set to some value.

 */

/* #define G_MAIN_POLL_DEBUG */

#ifdef _WIN32

/* Always enable debugging printout on Windows, as it is more often

 * needed there...

 */

#define G_MAIN_POLL_DEBUG

#endif

#ifdef G_OS_UNIX

#include "glib-unix.h"

#include <pthread.h>

#ifdef HAVE_EVENTFD

#include <sys/eventfd.h>

#endif

#endif

#include <signal.h>

#include <sys/types.h>

#include <time.h>

#include <stdlib.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif /* HAVE_SYS_TIME_H */

#ifdef G_OS_UNIX

#include <unistd.h>

#endif /* G_OS_UNIX */

#include <errno.h>

#include <string.h>

#ifdef G_OS_WIN32

#define STRICT

#include <windows.h>

#endif /* G_OS_WIN32 */

#ifdef HAVE_MACH_MACH_TIME_H

#include <mach/mach_time.h>

#endif

#include "glib_trace.h"

#include "gmain.h"

#include "garray.h"

#include "giochannel.h"

#include "ghash.h"

#include "ghook.h"

#include "gqueue.h"

#include "gstrfuncs.h"

#include "gtestutils.h"

#include "gthreadprivate.h"

#include "gtrace-private.h"

#ifdef G_OS_WIN32

#include "gwin32.h"

#endif

#ifdef  G_MAIN_POLL_DEBUG

#include "gtimer.h"

#endif

#include "gwakeup.h"

#include "gmain-internal.h"

#include "glib-init.h"

#include "glib-private.h"

/**

 * SECTION:main

 * @title: The Main Event Loop

 * @short_description: manages all available sources of events

 *

 * The main event loop manages all the available sources of events for

 * GLib and GTK+ applications. These events can come from any number of

 * different types of sources such as file descriptors (plain files,

 * pipes or sockets) and timeouts. New types of event sources can also

 * be added using g_source_attach().

 *

 * To allow multiple independent sets of sources to be handled in

 * different threads, each source is associated with a #GMainContext.

 * A #GMainContext can only be running in a single thread, but

 * sources can be added to it and removed from it from other threads. All

 * functions which operate on a #GMainContext or a built-in #GSource are

 * thread-safe.

 *

 * Each event source is assigned a priority. The default priority,

 * #G_PRIORITY_DEFAULT, is 0. Values less than 0 denote higher priorities.

 * Values greater than 0 denote lower priorities. Events from high priority

 * sources are always processed before events from lower priority sources.

 *

 * Idle functions can also be added, and assigned a priority. These will

 * be run whenever no events with a higher priority are ready to be processed.

 *

 * The #GMainLoop data type represents a main event loop. A GMainLoop is

 * created with g_main_loop_new(). After adding the initial event sources,

 * g_main_loop_run() is called. This continuously checks for new events from

 * each of the event sources and dispatches them. Finally, the processing of

 * an event from one of the sources leads to a call to g_main_loop_quit() to

 * exit the main loop, and g_main_loop_run() returns.

 *

 * It is possible to create new instances of #GMainLoop recursively.

 * This is often used in GTK+ applications when showing modal dialog

 * boxes. Note that event sources are associated with a particular

 * #GMainContext, and will be checked and dispatched for all main

 * loops associated with that GMainContext.

 *

 * GTK+ contains wrappers of some of these functions, e.g. gtk_main(),

 * gtk_main_quit() and gtk_events_pending().

 *

 * ## Creating new source types

 *

 * One of the unusual features of the #GMainLoop functionality

 * is that new types of event source can be created and used in

 * addition to the builtin type of event source. A new event source

 * type is used for handling GDK events. A new source type is created

 * by "deriving" from the #GSource structure. The derived type of

 * source is represented by a structure that has the #GSource structure

 * as a first element, and other elements specific to the new source

 * type. To create an instance of the new source type, call

 * g_source_new() passing in the size of the derived structure and

 * a table of functions. These #GSourceFuncs determine the behavior of

 * the new source type.

 *

 * New source types basically interact with the main context

 * in two ways. Their prepare function in #GSourceFuncs can set a timeout

 * to determine the maximum amount of time that the main loop will sleep

 * before checking the source again. In addition, or as well, the source

 * can add file descriptors to the set that the main context checks using

 * g_source_add_poll().

 *

 * ## Customizing the main loop iteration

 *

 * Single iterations of a #GMainContext can be run with

 * g_main_context_iteration(). In some cases, more detailed control

 * of exactly how the details of the main loop work is desired, for

 * instance, when integrating the #GMainLoop with an external main loop.

 * In such cases, you can call the component functions of

 * g_main_context_iteration() directly. These functions are

 * g_main_context_prepare(), g_main_context_query(),

 * g_main_context_check() and g_main_context_dispatch().

 *

 * ## State of a Main Context # {#mainloop-states}

 *

 * The operation of these functions can best be seen in terms

 * of a state diagram, as shown in this image.

 *

 * ![](mainloop-states.gif)

 *

 * On UNIX, the GLib mainloop is incompatible with fork(). Any program

 * using the mainloop must either exec() or exit() from the child

 * without returning to the mainloop.

 *

 * ## Memory management of sources # {#mainloop-memory-management}

 *

 * There are two options for memory management of the user data passed to a

 * #GSource to be passed to its callback on invocation. This data is provided

 * in calls to g_timeout_add(), g_timeout_add_full(), g_idle_add(), etc. and

 * more generally, using g_source_set_callback(). This data is typically an

 * object which ‘owns’ the timeout or idle callback, such as a widget or a

 * network protocol implementation. In many cases, it is an error for the

 * callback to be invoked after this owning object has been destroyed, as that

 * results in use of freed memory.

 *

 * The first, and preferred, option is to store the source ID returned by

 * functions such as g_timeout_add() or g_source_attach(), and explicitly

 * remove that source from the main context using g_source_remove() when the

 * owning object is finalized. This ensures that the callback can only be

 * invoked while the object is still alive.

 *

 * The second option is to hold a strong reference to the object in the

 * callback, and to release it in the callback’s #GDestroyNotify. This ensures

 * that the object is kept alive until after the source is finalized, which is

 * guaranteed to be after it is invoked for the final time. The #GDestroyNotify

 * is another callback passed to the ‘full’ variants of #GSource functions (for

 * example, g_timeout_add_full()). It is called when the source is finalized,

 * and is designed for releasing references like this.

 *

 * One important caveat of this second approach is that it will keep the object

 * alive indefinitely if the main loop is stopped before the #GSource is

 * invoked, which may be undesirable.

 */

/* Types */

typedef struct _GTimeoutSource GTimeoutSource;

typedef struct _GChildWatchSource GChildWatchSource;

typedef struct _GUnixSignalWatchSource GUnixSignalWatchSource;

typedef struct _GPollRec GPollRec;

typedef struct _GSourceCallback GSourceCallback;

typedef enum

{

  G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,

  G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1),

  G_SOURCE_BLOCKED = 1 << (G_HOOK_FLAG_USER_SHIFT + 2)

} GSourceFlags;

typedef struct _GSourceList GSourceList;

struct _GSourceList

{

  GSource *head, *tail;

  gint priority;

};

typedef struct _GMainWaiter GMainWaiter;

struct _GMainWaiter

{

  GCond *cond;

  GMutex *mutex;

};

typedef struct _GMainDispatch GMainDispatch;

struct _GMainDispatch

{

  gint depth;

  GSource *source;

};

#ifdef G_MAIN_POLL_DEBUG

gboolean _g_main_poll_debug = FALSE;

#endif

struct _GMainContext

{

  /* The following lock is used for both the list of sources

   * and the list of poll records

   */

  GMutex mutex;

  GCond cond;

  GThread *owner;

  guint owner_count;

  GSList *waiters;

  gint ref_count;  /* (atomic) */

  GHashTable *sources;              /* guint -> GSource */

  GPtrArray *pending_dispatches;

  gint timeout;     /* Timeout for current iteration */

  guint next_id;

  GList *source_lists;

  gint in_check_or_prepare;

  GPollRec *poll_records;

  guint n_poll_records;

  GPollFD *cached_poll_array;

  guint cached_poll_array_size;

  GWakeup *wakeup;

  GPollFD wake_up_rec;

/* Flag indicating whether the set of fd's changed during a poll */

  gboolean poll_changed;

  GPollFunc poll_func;

  gint64   time;

  gboolean time_is_fresh;

};

struct _GSourceCallback

{

  gint ref_count;  /* (atomic) */

  GSourceFunc func;

  gpointer    data;

  GDestroyNotify notify;

};

struct _GMainLoop

{

  GMainContext *context;

  gboolean is_running; /* (atomic) */

  gint ref_count;  /* (atomic) */

};

struct _GTimeoutSource

{

  GSource     source;

  /* Measured in seconds if 'seconds' is TRUE, or milliseconds otherwise. */

  guint       interval;

  gboolean    seconds;

};

struct _GChildWatchSource

{

  GSource     source;

  GPid        pid;

  gint        child_status;

#ifdef G_OS_WIN32

  GPollFD     poll;

#else /* G_OS_WIN32 */

  gboolean    child_exited; /* (atomic) */

#endif /* G_OS_WIN32 */

};

struct _GUnixSignalWatchSource

{

  GSource     source;

  int         signum;

  gboolean    pending; /* (atomic) */

};

struct _GPollRec

{

  GPollFD *fd;

  GPollRec *prev;

  GPollRec *next;

  gint priority;

};

struct _GSourcePrivate

{

  GSList *child_sources;

  GSource *parent_source;

  gint64 ready_time;

  /* This is currently only used on UNIX, but we always declare it (and

   * let it remain empty on Windows) to avoid #ifdef all over the place.

   */

  GSList *fds;

  GSourceDisposeFunc dispose;

};

typedef struct _GSourceIter

{

  GMainContext *context;

  gboolean may_modify;

  GList *current_list;

  GSource *source;

} GSourceIter;

#define LOCK_CONTEXT(context) g_mutex_lock (&context->mutex)

#define UNLOCK_CONTEXT(context) g_mutex_unlock (&context->mutex)

#define G_THREAD_SELF g_thread_self ()

#define SOURCE_DESTROYED(source) (((source)->flags & G_HOOK_FLAG_ACTIVE) == 0)

#define SOURCE_BLOCKED(source) (((source)->flags & G_SOURCE_BLOCKED) != 0)

/* Forward declarations */

static void g_source_unref_internal             (GSource      *source,

             GMainContext *context,

             gboolean      have_lock);

static void g_source_destroy_internal           (GSource      *source,

             GMainContext *context,

             gboolean      have_lock);

static void g_source_set_priority_unlocked      (GSource      *source,

             GMainContext *context,

             gint          priority);

static void g_child_source_remove_internal      (GSource      *child_source,

                                                 GMainContext *context);

static void g_main_context_poll                 (GMainContext *context,

             gint          timeout,

             gint          priority,

             GPollFD      *fds,

             gint          n_fds);

static void g_main_context_add_poll_unlocked    (GMainContext *context,

             gint          priority,

             GPollFD      *fd);

static void g_main_context_remove_poll_unlocked (GMainContext *context,

             GPollFD      *fd);

static void     g_source_iter_init  (GSourceIter   *iter,

             GMainContext  *context,

             gboolean       may_modify);

static gboolean g_source_iter_next  (GSourceIter   *iter,

             GSource      **source);

static void     g_source_iter_clear (GSourceIter   *iter);

static gboolean g_timeout_dispatch (GSource     *source,

            GSourceFunc  callback,

            gpointer     user_data);

static gboolean g_child_watch_prepare  (GSource     *source,

                gint        *timeout);

static gboolean g_child_watch_check    (GSource     *source);

static gboolean g_child_watch_dispatch (GSource     *source,

          GSourceFunc  callback,

          gpointer     user_data);

static void     g_child_watch_finalize (GSource     *source);

#ifdef G_OS_UNIX

static void g_unix_signal_handler (int signum);

static gboolean g_unix_signal_watch_prepare  (GSource     *source,

                gint        *timeout);

static gboolean g_unix_signal_watch_check    (GSource     *source);

static gboolean g_unix_signal_watch_dispatch (GSource     *source,

                GSourceFunc  callback,

                gpointer     user_data);

static void     g_unix_signal_watch_finalize  (GSource     *source);

#endif

static gboolean g_idle_prepare     (GSource     *source,

            gint        *timeout);

static gboolean g_idle_check       (GSource     *source);

static gboolean g_idle_dispatch    (GSource     *source,

            GSourceFunc  callback,

            gpointer     user_data);

static void block_source (GSource *source);

static GMainContext *glib_worker_context;

#ifndef G_OS_WIN32

/* UNIX signals work by marking one of these variables then waking the

 * worker context to check on them and dispatch accordingly.

 *

 * Both variables must be accessed using atomic primitives, unless those atomic

 * primitives are implemented using fallback mutexes (as those aren’t safe in

 * an interrupt context).

 *

 * If using atomic primitives, the variables must be of type `int` (so they’re

 * the right size for the atomic primitives). Otherwise, use `sig_atomic_t` if

 * it’s available, which is guaranteed to be async-signal-safe (but it’s *not*

 * guaranteed to be thread-safe, which is why we use atomic primitives if

 * possible).

 *

 * Typically, `sig_atomic_t` is a typedef to `int`, but that’s not the case on

 * FreeBSD, so we can’t use it unconditionally if it’s defined.

 */

#if (defined(G_ATOMIC_LOCK_FREE) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)) || !defined(HAVE_SIG_ATOMIC_T)

static volatile int unix_signal_pending[NSIG];

static volatile int any_unix_signal_pending;

#else

static volatile sig_atomic_t unix_signal_pending[NSIG];

static volatile sig_atomic_t any_unix_signal_pending;

#endif

/* Guards all the data below */

G_LOCK_DEFINE_STATIC (unix_signal_lock);

static guint unix_signal_refcount[NSIG];

static GSList *unix_signal_watches;

static GSList *unix_child_watches;

GSourceFuncs g_unix_signal_funcs =

{

  g_unix_signal_watch_prepare,

  g_unix_signal_watch_check,

  g_unix_signal_watch_dispatch,

  g_unix_signal_watch_finalize,

  NULL, NULL

};

#endif /* !G_OS_WIN32 */

G_LOCK_DEFINE_STATIC (main_context_list);

static GSList *main_context_list = NULL;

GSourceFuncs g_timeout_funcs =

{

  NULL, /* prepare */

  NULL, /* check */

  g_timeout_dispatch,

  NULL, NULL, NULL

};

GSourceFuncs g_child_watch_funcs =

{

  g_child_watch_prepare,

  g_child_watch_check,

  g_child_watch_dispatch,

  g_child_watch_finalize,

  NULL, NULL

};

GSourceFuncs g_idle_funcs =

{

  g_idle_prepare,

  g_idle_check,

  g_idle_dispatch,

  NULL, NULL, NULL

};

/**

 * g_main_context_ref:

 * @context: a #GMainContext

 * 

 * Increases the reference count on a #GMainContext object by one.

 *

 * Returns: the @context that was passed in (since 2.6)

 **/

GMainContext *

g_main_context_ref (GMainContext *context)

{

  g_return_val_if_fail (context != NULL, NULL);

  g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL); 

  g_atomic_int_inc (&context->ref_count);

  return context;

}

static inline void

poll_rec_list_free (GMainContext *context,

        GPollRec     *list)

{

  g_slice_free_chain (GPollRec, list, next);

}

/**

 * g_main_context_unref:

 * @context: a #GMainContext

 * 

 * Decreases the reference count on a #GMainContext object by one. If

 * the result is zero, free the context and free all associated memory.

 **/

void

g_main_context_unref (GMainContext *context)

{

  GSourceIter iter;

  GSource *source;

  GList *sl_iter;

  GSList *s_iter, *remaining_sources = NULL;

  GSourceList *list;

  guint i;

  g_return_if_fail (context != NULL);

  g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0); 

  if (!g_atomic_int_dec_and_test (&context->ref_count))

    return;

  G_LOCK (main_context_list);

  main_context_list = g_slist_remove (main_context_list, context);

  G_UNLOCK (main_context_list);

  /* Free pending dispatches */

  for (i = 0; i < context->pending_dispatches->len; i++)

    g_source_unref_internal (context->pending_dispatches->pdata[i], context, FALSE);

  /* g_source_iter_next() assumes the context is locked. */

  LOCK_CONTEXT (context);

  /* First collect all remaining sources from the sources lists and store a

   * new reference in a separate list. Also set the context of the sources

   * to NULL so that they can't access a partially destroyed context anymore.

   *

   * We have to do this first so that we have a strong reference to all

   * sources and destroying them below does not also free them, and so that

   * none of the sources can access the context from their finalize/dispose

   * functions. */

  g_source_iter_init (&iter, context, FALSE);

  while (g_source_iter_next (&iter, &source))

    {

      source->context = NULL;

      remaining_sources = g_slist_prepend (remaining_sources, g_source_ref (source));

    }

  g_source_iter_clear (&iter);

  /* Next destroy all sources. As we still hold a reference to all of them,

   * this won't cause any of them to be freed yet and especially prevents any

   * source that unrefs another source from its finalize function to be freed.

   */

  for (s_iter = remaining_sources; s_iter; s_iter = s_iter->next)

    {

      source = s_iter->data;

      g_source_destroy_internal (source, context, TRUE);

    }

  for (sl_iter = context->source_lists; sl_iter; sl_iter = sl_iter->next)

    {

      list = sl_iter->data;

      g_slice_free (GSourceList, list);

    }

  g_list_free (context->source_lists);

  g_hash_table_destroy (context->sources);

  UNLOCK_CONTEXT (context);

  g_mutex_clear (&context->mutex);

  g_ptr_array_free (context->pending_dispatches, TRUE);

  g_free (context->cached_poll_array);

  poll_rec_list_free (context, context->poll_records);

  g_wakeup_free (context->wakeup);

  g_cond_clear (&context->cond);

  g_free (context);

  /* And now finally get rid of our references to the sources. This will cause

   * them to be freed unless something else still has a reference to them. Due

   * to setting the context pointers in the sources to NULL above, this won't

   * ever access the context or the internal linked list inside the GSource.

   * We already removed the sources completely from the context above. */

  for (s_iter = remaining_sources; s_iter; s_iter = s_iter->next)

    {

      source = s_iter->data;

      g_source_unref_internal (source, NULL, FALSE);

    }

  g_slist_free (remaining_sources);

}

/* Helper function used by mainloop/overflow test.

 */

GMainContext *

g_main_context_new_with_next_id (guint next_id)

{

  GMainContext *ret = g_main_context_new ();

  ret->next_id = next_id;

  return ret;

}

/**

 * g_main_context_new:

 * 

 * Creates a new #GMainContext structure.

 * 

 * Returns: the new #GMainContext

 **/

GMainContext *

g_main_context_new (void)

{

  static gsize initialised;

  GMainContext *context;

  if (g_once_init_enter (&initialised))

    {

#ifdef G_MAIN_POLL_DEBUG

      if (g_getenv ("G_MAIN_POLL_DEBUG") != NULL)

        _g_main_poll_debug = TRUE;

#endif

      g_once_init_leave (&initialised, TRUE);

    }

  context = g_new0 (GMainContext, 1);

  TRACE (GLIB_MAIN_CONTEXT_NEW (context));

  g_mutex_init (&context->mutex);

  g_cond_init (&context->cond);

  context->sources = g_hash_table_new (NULL, NULL);

  context->owner = NULL;

  context->waiters = NULL;

  context->ref_count = 1;

  context->next_id = 1;

  context->source_lists = NULL;

  context->poll_func = g_poll;

  context->cached_poll_array = NULL;

  context->cached_poll_array_size = 0;

  context->pending_dispatches = g_ptr_array_new ();

  context->time_is_fresh = FALSE;

  context->wakeup = g_wakeup_new ();

  g_wakeup_get_pollfd (context->wakeup, &context->wake_up_rec);

  g_main_context_add_poll_unlocked (context, 0, &context->wake_up_rec);

  G_LOCK (main_context_list);

  main_context_list = g_slist_append (main_context_list, context);

#ifdef G_MAIN_POLL_DEBUG

  if (_g_main_poll_debug)

    g_print ("created context=%p\n", context);

#endif

  G_UNLOCK (main_context_list);

  return context;

}

/**

 * g_main_context_default:

 *

 * Returns the global default main context. This is the main context

 * used for main loop functions when a main loop is not explicitly

 * specified, and corresponds to the "main" main loop. See also

 * g_main_context_get_thread_default().

 *

 * Returns: (transfer none): the global default main context.

 **/

GMainContext *

g_main_context_default (void)

{

  static GMainContext *default_main_context = NULL;

  if (g_once_init_enter (&default_main_context))

    {

      GMainContext *context;

      context = g_main_context_new ();

      TRACE (GLIB_MAIN_CONTEXT_DEFAULT (context));

#ifdef G_MAIN_POLL_DEBUG

      if (_g_main_poll_debug)

        g_print ("default context=%p\n", context);

#endif

      g_once_init_leave (&default_main_context, context);

    }

  return default_main_context;

}

static void

free_context (gpointer data)

{

  GMainContext *context = data;

  TRACE (GLIB_MAIN_CONTEXT_FREE (context));

  g_main_context_release (context);

  if (context)

    g_main_context_unref (context);

}

static void

free_context_stack (gpointer data)

{

  g_queue_free_full((GQueue *) data, (GDestroyNotify) free_context);

}

static GPrivate thread_context_stack = G_PRIVATE_INIT (free_context_stack);

/**

 * g_main_context_push_thread_default:

 * @context: (nullable): a #GMainContext, or %NULL for the global default context

 *

 * Acquires @context and sets it as the thread-default context for the

 * current thread. This will cause certain asynchronous operations

 * (such as most [gio][gio]-based I/O) which are

 * started in this thread to run under @context and deliver their

 * results to its main loop, rather than running under the global

 * default context in the main thread. Note that calling this function

 * changes the context returned by g_main_context_get_thread_default(),

 * not the one returned by g_main_context_default(), so it does not affect

 * the context used by functions like g_idle_add().

 *

 * Normally you would call this function shortly after creating a new

 * thread, passing it a #GMainContext which will be run by a

 * #GMainLoop in that thread, to set a new default context for all

 * async operations in that thread. In this case you may not need to

 * ever call g_main_context_pop_thread_default(), assuming you want the

 * new #GMainContext to be the default for the whole lifecycle of the

 * thread.

 *

 * If you don't have control over how the new thread was created (e.g.

 * in the new thread isn't newly created, or if the thread life

 * cycle is managed by a #GThreadPool), it is always suggested to wrap

 * the logic that needs to use the new #GMainContext inside a

 * g_main_context_push_thread_default() / g_main_context_pop_thread_default()

 * pair, otherwise threads that are re-used will end up never explicitly

 * releasing the #GMainContext reference they hold.

 *

 * In some cases you may want to schedule a single operation in a

 * non-default context, or temporarily use a non-default context in

 * the main thread. In that case, you can wrap the call to the

 * asynchronous operation inside a

 * g_main_context_push_thread_default() /

 * g_main_context_pop_thread_default() pair, but it is up to you to

 * ensure that no other asynchronous operations accidentally get

 * started while the non-default context is active.

 *

 * Beware that libraries that predate this function may not correctly

 * handle being used from a thread with a thread-default context. Eg,

 * see g_file_supports_thread_contexts().

 *

 * Since: 2.22

 **/

void

g_main_context_push_thread_default (GMainContext *context)

{

  GQueue *stack;

  gboolean acquired_context;

  acquired_context = g_main_context_acquire (context);

  g_return_if_fail (acquired_context);

  if (context == g_main_context_default ())

    context = NULL;

  else if (context)

    g_main_context_ref (context);

  stack = g_private_get (&thread_context_stack);

  if (!stack)

    {

      stack = g_queue_new ();

      g_private_set (&thread_context_stack, stack);

    }

  g_queue_push_head (stack, context);

  TRACE (GLIB_MAIN_CONTEXT_PUSH_THREAD_DEFAULT (context));

}

/**

 * g_main_context_pop_thread_default:

 * @context: (nullable): a #GMainContext object, or %NULL

 *

 * Pops @context off the thread-default context stack (verifying that

 * it was on the top of the stack).

 *

 * Since: 2.22

 **/

void

g_main_context_pop_thread_default (GMainContext *context)

{

  GQueue *stack;

  if (context == g_main_context_default ())

    context = NULL;

  stack = g_private_get (&thread_context_stack);

  g_return_if_fail (stack != NULL);

  g_return_if_fail (g_queue_peek_head (stack) == context);

  TRACE (GLIB_MAIN_CONTEXT_POP_THREAD_DEFAULT (context));

  g_queue_pop_head (stack);

  g_main_context_release (context);

  if (context)

    g_main_context_unref (context);

}

/**

 * g_main_context_get_thread_default:

 *

 * Gets the thread-default #GMainContext for this thread. Asynchronous

 * operations that want to be able to be run in contexts other than

 * the default one should call this method or

 * g_main_context_ref_thread_default() to get a #GMainContext to add

 * their #GSources to. (Note that even in single-threaded

 * programs applications may sometimes want to temporarily push a

 * non-default context, so it is not safe to assume that this will

 * always return %NULL if you are running in the default thread.)

 *

 * If you need to hold a reference on the context, use

 * g_main_context_ref_thread_default() instead.

 *

 * Returns: (transfer none) (nullable): the thread-default #GMainContext, or

 * %NULL if the thread-default context is the global default context.

 *

 * Since: 2.22

 **/

GMainContext *

g_main_context_get_thread_default (void)

{

  GQueue *stack;

  stack = g_private_get (&thread_context_stack);

  if (stack)

    return g_queue_peek_head (stack);

  else

    return NULL;

}

/**

 * g_main_context_ref_thread_default:

 *

 * Gets the thread-default #GMainContext for this thread, as with

 * g_main_context_get_thread_default(), but also adds a reference to

 * it with g_main_context_ref(). In addition, unlike

 * g_main_context_get_thread_default(), if the thread-default context

 * is the global default context, this will return that #GMainContext

 * (with a ref added to it) rather than returning %NULL.

 *

 * Returns: (transfer full): the thread-default #GMainContext. Unref

 *     with g_main_context_unref() when you are done with it.

 *

 * Since: 2.32

 */

GMainContext *

g_main_context_ref_thread_default (void)

{

  GMainContext *context;

  context = g_main_context_get_thread_default ();

  if (!context)

    context = g_main_context_default ();

  return g_main_context_ref (context);

}

/* Hooks for adding to the main loop */

/**

 * g_source_new:

 * @source_funcs: structure containing functions that implement

 *                the sources behavior.

 * @struct_size: size of the #GSource structure to create.

 * 

 * Creates a new #GSource structure. The size is specified to

 * allow creating structures derived from #GSource that contain

 * additional data. The size passed in must be at least

 * `sizeof (GSource)`.

 * 

 * The source will not initially be associated with any #GMainContext

 * and must be added to one with g_source_attach() before it will be

 * executed.

 * 

 * Returns: the newly-created #GSource.

 **/

GSource *

g_source_new (GSourceFuncs *source_funcs,

        guint         struct_size)

{

  GSource *source;

  g_return_val_if_fail (source_funcs != NULL, NULL);

  g_return_val_if_fail (struct_size >= sizeof (GSource), NULL);

  source = (GSource*) g_malloc0 (struct_size);

  source->priv = g_slice_new0 (GSourcePrivate);

  source->source_funcs = source_funcs;

  source->ref_count = 1;

  source->priority = G_PRIORITY_DEFAULT;

  source->flags = G_HOOK_FLAG_ACTIVE;

  source->priv->ready_time = -1;

  /* NULL/0 initialization for all other fields */

  TRACE (GLIB_SOURCE_NEW (source, source_funcs->prepare, source_funcs->check,

                          source_funcs->dispatch, source_funcs->finalize,

                          struct_size));

  return source;

}

/**

 * g_source_set_dispose_function:

 * @source: A #GSource to set the dispose function on

 * @dispose: #GSourceDisposeFunc to set on the source

 *

 * Set @dispose as dispose function on @source. @dispose will be called once

 * the reference count of @source reaches 0 but before any of the state of the

 * source is freed, especially before the finalize function is called.

 *

 * This means that at this point @source is still a valid #GSource and it is

 * allow for the reference count to increase again until @dispose returns.

 *

 * The dispose function can be used to clear any "weak" references to the

 * @source in other data structures in a thread-safe way where it is possible

 * for another thread to increase the reference count of @source again while

 * it is being freed.

 *

 * The finalize function can not be used for this purpose as at that point

 * @source is already partially freed and not valid anymore.

 *

 * This should only ever be called from #GSource implementations.

 *

 * Since: 2.64

 **/

void

g_source_set_dispose_function (GSource            *source,

             GSourceDisposeFunc  dispose)

{

  g_return_if_fail (source != NULL);

  g_return_if_fail (source->priv->dispose == NULL);

  g_return_if_fail (g_atomic_int_get (&source->ref_count) > 0);

  source->priv->dispose = dispose;

}

/* Holds context's lock */

static void

g_source_iter_init (GSourceIter  *iter,

        GMainContext *context,

        gboolean      may_modify)

{

  iter->context = context;

  iter->current_list = NULL;

  iter->source = NULL;

  iter->may_modify = may_modify;

}

/* Holds context's lock */

static gboolean

g_source_iter_next (GSourceIter *iter, GSource **source)

{

  GSource *next_source;

  if (iter->source)

    next_source = iter->source->next;

  else

    next_source = NULL;

  if (!next_source)

    {

      if (iter->current_list)

  iter->current_list = iter->current_list->next;

      else

  iter->current_list = iter->context->source_lists;

      if (iter->current_list)

  {

    GSourceList *source_list = iter->current_list->data;

    next_source = source_list->head;

  }