luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-09-19 16:56:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Support g_main_context_push_thread_default() in gio

Browse Source 
GFile allows for the possibility that external implementations may not
support thread-default contexts yet, via
g_file_supports_thread_contexts(). GVolumeMonitor is not yet
thread-default-context aware.

Add a test program to verify that basic gio async ops work correctly
in non-default contexts.

http://bugzilla.gnome.org/show_bug.cgi?id=579984
This commit is contained in:
Dan Winship 2009-06-16 20:22:58 -04:00
parent 4363f1932f
commit 65cc5d895a
23 changed files with 474 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gio/gdummyfile.c
View File

@ -425,6 +425,8 @@ g_dummy_file_file_iface_init (GFileIface *iface)
iface->get_relative_path = g_dummy_file_get_relative_path;
iface->resolve_relative_path = g_dummy_file_resolve_relative_path;
iface->get_child_for_display_name = g_dummy_file_get_child_for_display_name;
iface->supports_thread_contexts = TRUE;
}
/* Uri handling helper functions: */

25
gio/gfile.c
View File

@ -6751,5 +6751,30 @@ g_file_stop_mountable_finish (GFile *file,
return (* iface->stop_mountable_finish) (file, result, error);
}
/**
* g_file_supports_thread_contexts:
* @file: a #GFile.
*
* Checks if @file supports <link
* linkend="g-main-context-push-thread-default-context">thread-default
* contexts</link>. If this returns %FALSE, you cannot perform
* asynchronous operations on @file in a thread that has a
* thread-default context.
*
* Returns: Whether or not @file supports thread-default contexts.
*
* Since: 2.22
*/
gboolean
g_file_supports_thread_contexts (GFile *file)
{
GFileIface *iface;
g_return_val_if_fail (G_IS_FILE (file), FALSE);
iface = G_FILE_GET_IFACE (file);
return iface->supports_thread_contexts;
}
#define __G_FILE_C__
#include "gioaliasdef.c"

3
gio/gfile.h
View File

@ -505,6 +505,7 @@ struct _GFileIface
gboolean (* stop_mountable_finish) (GFile *file,
GAsyncResult *result,
GError **error);
gboolean supports_thread_contexts;
};
GType g_file_get_type (void) G_GNUC_CONST;
@ -940,6 +941,8 @@ gboolean g_file_replace_contents_finish (GFile *file,
char **new_etag,
GError **error);
gboolean g_file_supports_thread_contexts (GFile *file);
G_END_DECLS
#endif /* __G_FILE_H__ */

26
gio/gfilemonitor.c
View File

@ -47,8 +47,14 @@ static void file_change_free (FileChange *change);
* g_file_monitor(), g_file_monitor_file(), or
* g_file_monitor_directory().
*
* To get informed about changes to the file or directory you
* are monitoring, connect to the #GFileMonitor::changed signal.
* To get informed about changes to the file or directory you are
* monitoring, connect to the #GFileMonitor::changed signal. The
* signal will be emitted in the <link
* linkend="g-main-context-push-thread-default">thread-default main
* context</link> of the thread that the monitor was created in
* (though if the global default main context is blocked, this may
* cause notifications to be blocked even if the thread-default
* context is still running).
**/
G_LOCK_DEFINE_STATIC(cancelled);
@ -82,6 +88,8 @@ struct _GFileMonitorPrivate {
GSource *timeout;
guint32 timeout_fires_at;
GMainContext *context;
};
enum {
@ -169,6 +177,9 @@ g_file_monitor_finalize (GObject *object)
g_hash_table_destroy (monitor->priv->rate_limiter);
if (monitor->priv->context)
g_main_context_unref (monitor->priv->context);
G_OBJECT_CLASS (g_file_monitor_parent_class)->finalize (object);
}
@ -258,6 +269,7 @@ g_file_monitor_init (GFileMonitor *monitor)
monitor->priv->rate_limit_msec = DEFAULT_RATE_LIMIT_MSECS;
monitor->priv->rate_limiter = g_hash_table_new_full (g_file_hash, (GEqualFunc)g_file_equal,
NULL, (GDestroyNotify) rate_limiter_free);
monitor->priv->context = g_main_context_get_thread_default ();
}
/**
@ -414,7 +426,7 @@ emit_in_idle (GFileMonitor *monitor,
* pending idles.
*/
g_source_set_callback (source, emit_cb, monitor, NULL);
g_source_attach (source, NULL);
g_source_attach (source, monitor->priv->context);
}
/* We reverse this in the processor */
priv->pending_file_changes = g_slist_prepend (priv->pending_file_changes, change);
@ -570,7 +582,7 @@ rate_limiter_timeout (gpointer timeout_data)
{
source = g_timeout_source_new (data.min_time + 1); /* + 1 to make sure we've really passed the time */
g_source_set_callback (source, rate_limiter_timeout, monitor, NULL);
g_source_attach (source, NULL);
g_source_attach (source, monitor->priv->context);
monitor->priv->timeout = source;
monitor->priv->timeout_fires_at = data.time_now + data.min_time;
@ -622,7 +634,7 @@ update_rate_limiter_timeout (GFileMonitor *monitor,
{
source = g_timeout_source_new (data.min_time + 1); /* + 1 to make sure we've really passed the time */
g_source_set_callback (source, rate_limiter_timeout, monitor, NULL);
g_source_attach (source, NULL);
g_source_attach (source, monitor->priv->context);
monitor->priv->timeout = source;
monitor->priv->timeout_fires_at = data.time_now + data.min_time;
@ -640,7 +652,9 @@ update_rate_limiter_timeout (GFileMonitor *monitor,
* has taken place. Should be called from file monitor
* implementations only.
*
* The signal will be emitted from an idle handler.
* The signal will be emitted from an idle handler (in the <link
* linkend="g-main-context-push-thread-default">thread-default main
* context</link>).
**/
void
g_file_monitor_emit_event (GFileMonitor *monitor,

1
gio/gio.symbols
View File

@ -343,6 +343,7 @@ g_file_start_mountable
g_file_start_mountable_finish
g_file_stop_mountable
g_file_stop_mountable_finish
g_file_supports_thread_contexts
#endif
#endif

29
gio/gioscheduler.c
View File

@ -55,6 +55,7 @@ struct _GIOSchedulerJob {
gint io_priority;
GCancellable *cancellable;
GMainContext *context;
guint idle_tag;
};
@ -72,6 +73,8 @@ g_io_job_free (GIOSchedulerJob *job)
{
if (job->cancellable)
g_object_unref (job->cancellable);
if (job->context)
g_main_context_unref (job->context);
g_free (job);
}
@ -242,6 +245,10 @@ g_io_scheduler_push_job (GIOSchedulerJobFunc job_func,
if (cancellable)
job->cancellable = g_object_ref (cancellable);
job->context = g_main_context_get_thread_default ();
if (job->context)
g_main_context_ref (job->context);
G_LOCK (active_jobs);
active_jobs = g_slist_prepend (active_jobs, job);
job->active_link = active_jobs;
@ -341,12 +348,12 @@ mainloop_proxy_free (MainLoopProxy *proxy)
/**
* g_io_scheduler_job_send_to_mainloop:
* @job: a #GIOSchedulerJob
* @func: a #GSourceFunc callback that will be called in the main thread
* @func: a #GSourceFunc callback that will be called in the original thread
* @user_data: data to pass to @func
* @notify: a #GDestroyNotify for @user_data, or %NULL
*
* Used from an I/O job to send a callback to be run in the
* main loop (main thread), waiting for the result (and thus
* Used from an I/O job to send a callback to be run in the thread
* that the job was started from, waiting for the result (and thus
* blocking the I/O job).
*
* Returns: The return value of @func
@ -359,7 +366,6 @@ g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
{
GSource *source;
MainLoopProxy *proxy;
guint id;
gboolean ret_val;
g_return_val_if_fail (job != NULL, FALSE);
@ -389,7 +395,7 @@ g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
g_source_set_callback (source, mainloop_proxy_func, proxy,
NULL);
id = g_source_attach (source, NULL);
g_source_attach (source, job->context);
g_source_unref (source);
g_cond_wait (proxy->ack_condition, proxy->ack_lock);
@ -404,14 +410,14 @@ g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
/**
* g_io_scheduler_job_send_to_mainloop_async:
* @job: a #GIOSchedulerJob
* @func: a #GSourceFunc callback that will be called in the main thread
* @func: a #GSourceFunc callback that will be called in the original thread
* @user_data: data to pass to @func
* @notify: a #GDestroyNotify for @user_data, or %NULL
*
* Used from an I/O job to send a callback to be run asynchronously
* in the main loop (main thread). The callback will be run when the
* main loop is available, but at that time the I/O job might have
* finished. The return value from the callback is ignored.
* Used from an I/O job to send a callback to be run asynchronously in
* the thread that the job was started from. The callback will be run
* when the main loop is available, but at that time the I/O job might
* have finished. The return value from the callback is ignored.
*
* Note that if you are passing the @user_data from g_io_scheduler_push_job()
* on to this function you have to ensure that it is not freed before
@ -426,7 +432,6 @@ g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
{
GSource *source;
MainLoopProxy *proxy;
guint id;
g_return_if_fail (job != NULL);
g_return_if_fail (func != NULL);
@ -452,7 +457,7 @@ g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
g_source_set_callback (source, mainloop_proxy_func, proxy,
(GDestroyNotify)mainloop_proxy_free);
id = g_source_attach (source, NULL);
g_source_attach (source, job->context);
g_source_unref (source);
}

2
gio/glocalfile.c
View File

@ -2392,4 +2392,6 @@ g_local_file_file_iface_init (GFileIface *iface)
iface->move = g_local_file_move;
iface->monitor_dir = g_local_file_monitor_dir;
iface->monitor_file = g_local_file_monitor_file;
iface->supports_thread_contexts = TRUE;
}

62
gio/gsimpleasyncresult.c
View File

@ -89,11 +89,13 @@
*
* GSimpleAsyncResult can integrate into GLib's event loop, #GMainLoop,
* or it can use #GThread<!-- -->s if available.
* g_simple_async_result_complete() will finish an I/O task directly within
* the main event loop. g_simple_async_result_complete_in_idle() will
* integrate the I/O task into the main event loop as an idle function and
* g_simple_async_result_run_in_thread() will run the job in a separate
* thread.
* g_simple_async_result_complete() will finish an I/O task directly
* from the point where it is called. g_simple_async_result_complete_in_idle()
* will finish it from an idle handler in the <link
* linkend="g-main-context-push-thread-default">thread-default main
* context</link>. g_simple_async_result_run_in_thread() will run the
* job in a separate thread and then deliver the result to the
* thread-default main context.
*
* To set the results of an asynchronous function,
* g_simple_async_result_set_op_res_gpointer(),
@ -119,6 +121,7 @@ struct _GSimpleAsyncResult
GObject *source_object;
GAsyncReadyCallback callback;
gpointer user_data;
GMainContext *context;
GError *error;
gboolean failed;
gboolean handle_cancellation;
@ -163,6 +166,9 @@ g_simple_async_result_finalize (GObject *object)
if (simple->source_object)
g_object_unref (simple->source_object);
if (simple->context)
g_main_context_unref (simple->context);
clear_op_res (simple);
if (simple->error)
@ -183,6 +189,10 @@ static void
g_simple_async_result_init (GSimpleAsyncResult *simple)
{
simple->handle_cancellation = TRUE;
simple->context = g_main_context_get_thread_default ();
if (simple->context)
g_main_context_ref (simple->context);
}
/**
@ -547,16 +557,35 @@ g_simple_async_result_set_error (GSimpleAsyncResult *simple,
* g_simple_async_result_complete:
* @simple: a #GSimpleAsyncResult.
*
* Completes an asynchronous I/O job.
* Must be called in the main thread, as it invokes the callback that
* should be called in the main thread. If you are in a different thread
* use g_simple_async_result_complete_in_idle().
* Completes an asynchronous I/O job immediately. Must be called in
* the thread where the asynchronous result was to be delivered, as it
* invokes the callback directly. If you are in a different thread use
* g_simple_async_result_complete_in_idle().
**/
void
g_simple_async_result_complete (GSimpleAsyncResult *simple)
{
#ifndef G_DISABLE_CHECKS
GSource *current_source;
GMainContext *current_context;
#endif
g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
#ifndef G_DISABLE_CHECKS
current_source = g_main_current_source ();
if (current_source)
{
current_context = g_source_get_context (current_source);
if (current_context == g_main_context_default ())
current_context = NULL;
if (simple->context != current_context)
g_warning ("g_simple_async_result_complete() called from wrong context!");
}
else
g_warning ("g_simple_async_result_complete() called from outside main loop!");
#endif
if (simple->callback)
simple->callback (simple->source_object,
G_ASYNC_RESULT (simple),
@ -577,14 +606,14 @@ complete_in_idle_cb (gpointer data)
* g_simple_async_result_complete_in_idle:
* @simple: a #GSimpleAsyncResult.
*
* Completes an asynchronous function in the main event loop using
* an idle function.
* Completes an asynchronous function in an idle handler in the <link
* linkend="g-main-context-push-thread-default">thread-default main
* loop</link> of the thread that @simple was initially created in.
**/
void
g_simple_async_result_complete_in_idle (GSimpleAsyncResult *simple)
{
GSource *source;
guint id;
g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
@ -594,7 +623,7 @@ g_simple_async_result_complete_in_idle (GSimpleAsyncResult *simple)
g_source_set_priority (source, G_PRIORITY_DEFAULT);
g_source_set_callback (source, complete_in_idle_cb, simple, g_object_unref);
id = g_source_attach (source, NULL);
g_source_attach (source, simple->context);
g_source_unref (source);
}
@ -638,7 +667,6 @@ run_in_thread (GIOSchedulerJob *job,
RunInThreadData *data = _data;
GSimpleAsyncResult *simple = data->simple;
GSource *source;
guint id;
if (simple->handle_cancellation &&
g_cancellable_is_cancelled (c))
@ -655,7 +683,7 @@ run_in_thread (GIOSchedulerJob *job,
g_source_set_priority (source, G_PRIORITY_DEFAULT);
g_source_set_callback (source, complete_in_idle_cb_for_thread, data, NULL);
id = g_source_attach (source, NULL);
g_source_attach (source, simple->context);
g_source_unref (source);
return FALSE;
@ -668,7 +696,9 @@ run_in_thread (GIOSchedulerJob *job,
* @io_priority: the io priority of the request.
* @cancellable: optional #GCancellable object, %NULL to ignore.
*
* Runs the asynchronous job in a separated thread.
* Runs the asynchronous job in a separate thread and then calls
* g_simple_async_result_complete_in_idle() on @simple to return
* the result to the appropriate main loop.
**/
void
g_simple_async_result_run_in_thread (GSimpleAsyncResult *simple,

2
gio/gsocketclient.c
View File

@ -796,7 +796,7 @@ g_socket_client_enumerator_callback (GObject *object,
g_source_set_callback (source,
(GSourceFunc) g_socket_client_socket_callback,
data, NULL);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
g_object_unref (address);

2
gio/gsocketinputstream.c
View File

@ -188,7 +188,7 @@ g_socket_input_stream_read_async (GInputStream *stream,
g_source_set_callback (source,
(GSourceFunc) g_socket_input_stream_read_ready,
g_object_ref (input_stream), g_object_unref);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
}
else

2
gio/gsocketlistener.c
View File

@ -765,7 +765,7 @@ g_socket_listener_accept_socket_async (GSocketListener *listener,
accept_ready,
data,
cancellable,
NULL);
g_main_context_get_thread_default ());
}
/**

2
gio/gsocketoutputstream.c
View File

@ -190,7 +190,7 @@ g_socket_output_stream_write_async (GOutputStream *stream,
g_source_set_callback (source,
(GSourceFunc) g_socket_output_stream_write_ready,
g_object_ref (output_stream), g_object_unref);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
}
else

2
gio/gtcpconnection.c
View File

@ -321,7 +321,7 @@ g_tcp_connection_close_async (GIOStream *stream,
g_source_set_callback (source,
(GSourceFunc) close_read_ready,
data, (GDestroyNotify)close_async_data_free);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
return;

4
gio/gunixinputstream.c
View File

@ -507,7 +507,7 @@ g_unix_input_stream_read_async (GInputStream *stream,
cancellable);
g_source_set_callback (source, (GSourceFunc)read_async_cb, data, g_free);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
}
@ -635,7 +635,7 @@ g_unix_input_stream_close_async (GInputStream *stream,
idle = g_idle_source_new ();
g_source_set_callback (idle, (GSourceFunc)close_async_cb, data, close_async_data_free);
g_source_attach (idle, NULL);
g_source_attach (idle, g_main_context_get_thread_default ());
g_source_unref (idle);
}

4
gio/gunixmount.c
View File

@ -361,11 +361,11 @@ eject_unmount_do_cb (gpointer user_data)
data->error_channel_source = g_io_create_watch (data->error_channel, G_IO_IN);
g_source_set_callback (data->error_channel_source,
(GSourceFunc) eject_unmount_read_error, data, NULL);
g_source_attach (data->error_channel_source, NULL);
g_source_attach (data->error_channel_source, g_main_context_get_thread_default ());
child_watch = g_child_watch_source_new (child_pid);
g_source_set_callback (child_watch, (GSourceFunc) eject_unmount_cb, data, NULL);
g_source_attach (child_watch, NULL);
g_source_attach (child_watch, g_main_context_get_thread_default ());
g_source_unref (child_watch);
handle_error:

4
gio/gunixoutputstream.c
View File

@ -494,7 +494,7 @@ g_unix_output_stream_write_async (GOutputStream *stream,
cancellable);
g_source_set_callback (source, (GSourceFunc)write_async_cb, data, g_free);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
}
@ -591,7 +591,7 @@ g_unix_output_stream_close_async (GOutputStream *stream,
idle = g_idle_source_new ();
g_source_set_callback (idle, (GSourceFunc)close_async_cb, data, g_free);
g_source_attach (idle, NULL);
g_source_attach (idle, g_main_context_get_thread_default ());
g_source_unref (idle);
}

207
gio/gunixresolver.c
View File

@ -84,21 +84,16 @@ g_unix_resolver_finalize (GObject *object)
* a. The resolution completes: g_unix_resolver_watch() sees that
* the request has completed, and calls
* g_unix_resolver_request_complete(), which detaches the
* "cancelled" signal handler (if it was present) and then
* immediately completes the async_result (since
* g_unix_resolver_watch() is already run from main-loop
* time.) After completing the async_result, it unrefs it,
* causing the req to be freed as well.
* "cancelled" signal handler (if it was present), queues the
* async_result to be completed, and then unrefs it.
*
* b. The resolution is cancelled: request_cancelled() calls
* _g_asyncns_cancel() to cancel the resolution. Then it calls
* g_unix_resolver_request_complete(), which detaches the
* signal handler, and queues async_result to complete in an
* idle handler. It then unrefs the async_result to ensure
* that after its callback runs, it will be destroyed, in turn
* causing the req to be freed. Because the asyncns resolution
* was cancelled, g_unix_resolver_watch() will never be
* triggered for this req.
* idle handler. Because the asyncns resolution was cancelled,
* g_unix_resolver_watch() will never be triggered for this
* req.
*
* Since there's only a single thread, it's not possible for the
* request to both complete and be cancelled "at the same time",
@ -108,18 +103,29 @@ g_unix_resolver_finalize (GObject *object)
*/
typedef struct _GUnixResolverRequest GUnixResolverRequest;
typedef void (*GUnixResolverFreeFunc) (GUnixResolverRequest *);
typedef void (*GUnixResolverFunc) (GUnixResolverRequest *);
struct _GUnixResolverRequest {
GUnixResolver *gur;
_g_asyncns_query_t *qy;
union {
gchar *hostname;
GInetAddress *address;
gchar *service;
struct {
gchar *hostname;
GList *addresses;
} name;
struct {
GInetAddress *address;
gchar *hostname;
} address;
struct {
gchar *service;
GList *targets;
} service;
} u;
GUnixResolverFreeFunc free_func;
GUnixResolverFunc process_func, free_func;
GCancellable *cancellable;
GSimpleAsyncResult *async_result;
@ -133,7 +139,8 @@ static void request_cancelled (GCancellable *cancellable,
static GUnixResolverRequest *
g_unix_resolver_request_new (GUnixResolver *gur,
_g_asyncns_query_t *qy,
GUnixResolverFreeFunc free_func,
GUnixResolverFunc process_func,
GUnixResolverFunc free_func,
GCancellable *cancellable,
GSimpleAsyncResult *async_result)
{
@ -142,6 +149,7 @@ g_unix_resolver_request_new (GUnixResolver *gur,
req = g_slice_new0 (GUnixResolverRequest);
req->gur = g_object_ref (gur);
req->qy = qy;
req->process_func = process_func;
req->free_func = free_func;
if (cancellable)
@ -161,9 +169,8 @@ g_unix_resolver_request_new (GUnixResolver *gur,
static void
g_unix_resolver_request_free (GUnixResolverRequest *req)
{
/* If the user didn't call _finish the qy will still be around. */
if (req->qy)
_g_asyncns_cancel (req->gur->asyncns, req->qy);
req->free_func (req);
g_object_unref (req->gur);
/* We don't have to free req->cancellable and req->async_result,
* since they must already have been freed if we're here.
@ -173,8 +180,7 @@ g_unix_resolver_request_free (GUnixResolverRequest *req)
}
static void
g_unix_resolver_request_complete (GUnixResolverRequest *req,
gboolean need_idle)
g_unix_resolver_request_complete (GUnixResolverRequest *req)
{
if (req->cancellable)
{
@ -183,16 +189,11 @@ g_unix_resolver_request_complete (GUnixResolverRequest *req,
req->cancellable = NULL;
}
if (need_idle)
g_simple_async_result_complete_in_idle (req->async_result);
else
g_simple_async_result_complete (req->async_result);
/* If we completed_in_idle, that will have taken an extra ref on
* req->async_result; if not, then we're already done. Either way we
* need to unref the async_result to make sure it eventually is
* destroyed, causing req to be freed.
/* We always complete_in_idle, even if we were called from
* g_unix_resolver_watch(), since we might have been started under a
* non-default g_main_context_get_thread_default().
*/
g_simple_async_result_complete_in_idle (req->async_result);
g_object_unref (req->async_result);
}
@ -210,7 +211,7 @@ request_cancelled (GCancellable *cancellable,
g_simple_async_result_set_from_error (req->async_result, error);
g_error_free (error);
g_unix_resolver_request_complete (req, TRUE);
g_unix_resolver_request_complete (req);
}
static gboolean
@ -234,7 +235,8 @@ g_unix_resolver_watch (GIOChannel *iochannel,
(qy = _g_asyncns_getnext (gur->asyncns)) != NULL)
{
req = _g_asyncns_getuserdata (gur->asyncns, qy);
g_unix_resolver_request_complete (req, FALSE);
req->process_func (req);
g_unix_resolver_request_complete (req);
}
return TRUE;
@ -243,7 +245,8 @@ g_unix_resolver_watch (GIOChannel *iochannel,
static GUnixResolverRequest *
resolve_async (GUnixResolver *gur,
_g_asyncns_query_t *qy,
GUnixResolverFreeFunc free_func,
GUnixResolverFunc process_func,
GUnixResolverFunc free_func,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data,
@ -253,17 +256,41 @@ resolve_async (GUnixResolver *gur,
GUnixResolverRequest *req;
result = g_simple_async_result_new (G_OBJECT (gur), callback, user_data, tag);
req = g_unix_resolver_request_new (gur, qy, free_func, cancellable, result);
req = g_unix_resolver_request_new (gur, qy, process_func, free_func,
cancellable, result);
g_object_unref (result);
_g_asyncns_setuserdata (gur->asyncns, qy, req);
return req;
}
static void
lookup_by_name_process (GUnixResolverRequest *req)
{
struct addrinfo *res;
gint retval;
GError *error = NULL;
retval = _g_asyncns_getaddrinfo_done (req->gur->asyncns, req->qy, &res);
req->u.name.addresses =
_g_resolver_addresses_from_addrinfo (req->u.name.hostname,
res, retval, &error);
if (res)
freeaddrinfo (res);
if (error)
{
g_simple_async_result_set_from_error (req->async_result, error);
g_error_free (error);
}
}
static void
lookup_by_name_free (GUnixResolverRequest *req)
{
g_free (req->u.hostname);
g_free (req->u.name.hostname);
if (req->u.name.addresses)
g_resolver_free_addresses (req->u.name.addresses);
}
static void
@ -279,9 +306,9 @@ lookup_by_name_async (GResolver *resolver,
qy = _g_asyncns_getaddrinfo (gur->asyncns, hostname, NULL,
&_g_resolver_addrinfo_hints);
req = resolve_async (gur, qy, lookup_by_name_free, cancellable,
callback, user_data, lookup_by_name_async);
req->u.hostname = g_strdup (hostname);
req = resolve_async (gur, qy, lookup_by_name_process, lookup_by_name_free,
cancellable, callback, user_data, lookup_by_name_async);
req->u.name.hostname = g_strdup (hostname);
}
static GList *
@ -291,28 +318,48 @@ lookup_by_name_finish (GResolver *resolver,
{
GSimpleAsyncResult *simple;
GUnixResolverRequest *req;
struct addrinfo *res;
gint retval;
GList *addresses;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_by_name_async), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
req = g_simple_async_result_get_op_res_gpointer (simple);
retval = _g_asyncns_getaddrinfo_done (req->gur->asyncns, req->qy, &res);
req->qy = NULL;
addresses = _g_resolver_addresses_from_addrinfo (req->u.hostname, res, retval, error);
if (res)
freeaddrinfo (res);
addresses = req->u.name.addresses;
req->u.name.addresses = NULL;
return addresses;
}
static void
lookup_by_address_process (GUnixResolverRequest *req)
{
gchar host[NI_MAXHOST];
gint retval;
GError *error = NULL;
retval = _g_asyncns_getnameinfo_done (req->gur->asyncns, req->qy,
host, sizeof (host), NULL, 0);
req->u.address.hostname =
_g_resolver_name_from_nameinfo (req->u.address.address,
host, retval, &error);
if (error)
{
g_simple_async_result_set_from_error (req->async_result, error);
g_error_free (error);
}
}
static void
lookup_by_address_free (GUnixResolverRequest *req)
{
g_object_unref (req->u.address);
g_object_unref (req->u.address.address);
if (req->u.address.hostname)
g_free (req->u.address.hostname);
}
static void
@ -332,9 +379,10 @@ lookup_by_address_async (GResolver *resolver,
qy = _g_asyncns_getnameinfo (gur->asyncns,
(struct sockaddr *)&sockaddr, sockaddr_size,
NI_NAMEREQD, TRUE, FALSE);
req = resolve_async (gur, qy, lookup_by_address_free, cancellable,
req = resolve_async (gur, qy, lookup_by_address_process,
lookup_by_address_free, cancellable,
callback, user_data, lookup_by_address_async);
req->u.address = g_object_ref (address);
req->u.address.address = g_object_ref (address);
}
static gchar *
@ -344,26 +392,53 @@ lookup_by_address_finish (GResolver *resolver,
{
GSimpleAsyncResult *simple;
GUnixResolverRequest *req;
gchar host[NI_MAXHOST], *name;
gint retval;
gchar *name;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_by_address_async), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
req = g_simple_async_result_get_op_res_gpointer (simple);
retval = _g_asyncns_getnameinfo_done (req->gur->asyncns, req->qy,
host, sizeof (host), NULL, 0);
req->qy = NULL;
name = _g_resolver_name_from_nameinfo (req->u.address, host, retval, error);
name = req->u.address.hostname;
req->u.address.hostname = NULL;
return name;
}
static void
lookup_service_process (GUnixResolverRequest *req)
{
guchar *answer;
gint len, herr;
GError *error = NULL;
len = _g_asyncns_res_done (req->gur->asyncns, req->qy, &answer);
if (len < 0)
herr = h_errno;
else
herr = 0;
req->u.service.targets =
_g_resolver_targets_from_res_query (req->u.service.service,
answer, len, herr, &error);
_g_asyncns_freeanswer (answer);
if (error)
{
g_simple_async_result_set_from_error (req->async_result, error);
g_error_free (error);
}
}
static void
lookup_service_free (GUnixResolverRequest *req)
{
g_free (req->u.service);
g_free (req->u.service.service);
if (req->u.service.targets)
g_resolver_free_targets (req->u.service.targets);
}
static void
@ -378,9 +453,9 @@ lookup_service_async (GResolver *resolver,
_g_asyncns_query_t *qy;
qy = _g_asyncns_res_query (gur->asyncns, rrname, C_IN, T_SRV);
req = resolve_async (gur, qy, lookup_service_free, cancellable,
callback, user_data, lookup_service_async);
req->u.service = g_strdup (rrname);
req = resolve_async (gur, qy, lookup_service_process, lookup_service_free,
cancellable, callback, user_data, lookup_service_async);
req->u.service.service = g_strdup (rrname);
}
static GList *
@ -390,23 +465,17 @@ lookup_service_finish (GResolver *resolver,
{
GSimpleAsyncResult *simple;
GUnixResolverRequest *req;
guchar *answer;
gint len, herr;
GList *targets;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (resolver), lookup_service_async), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
req = g_simple_async_result_get_op_res_gpointer (simple);
len = _g_asyncns_res_done (req->gur->asyncns, req->qy, &answer);
req->qy = NULL;
if (len < 0)
herr = h_errno;
else
herr = 0;
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
targets = _g_resolver_targets_from_res_query (req->u.service, answer, len, herr, error);
_g_asyncns_freeanswer (answer);
req = g_simple_async_result_get_op_res_gpointer (simple);
targets = req->u.service.targets;
req->u.service.targets = NULL;
return targets;
}

4
gio/gunixvolume.c
View File

@ -420,11 +420,11 @@ eject_mount_do (GVolume *volume,
data->error_channel_source = g_io_create_watch (data->error_channel, G_IO_IN);
g_source_set_callback (data->error_channel_source,
(GSourceFunc) eject_mount_read_error, data, NULL);
g_source_attach (data->error_channel_source, NULL);
g_source_attach (data->error_channel_source, g_main_context_get_thread_default ());
child_watch = g_child_watch_source_new (child_pid);
g_source_set_callback (child_watch, (GSourceFunc) eject_mount_cb, data, NULL);
g_source_attach (child_watch, NULL);
g_source_attach (child_watch, g_main_context_get_thread_default ());
g_source_unref (child_watch);
handle_error:

7
gio/gvolumemonitor.c
View File

@ -41,7 +41,12 @@
* #GVolumeMonitor is for listing the user interesting devices and volumes
* on the computer. In other words, what a file selector or file manager
* would show in a sidebar.
**/
*
* #GVolumeMonitor is not <link
* linkend="g-main-context-push-thread-default">thread-default-context
* aware</link>, and so should not be used other than from the main
* thread, with no thread-default-context active.
**/
G_DEFINE_TYPE (GVolumeMonitor, g_volume_monitor, G_TYPE_OBJECT);

4
gio/gwin32resolver.c
View File

@ -234,7 +234,7 @@ request_cancelled (GCancellable *cancellable,
req->cancelled_idle = g_idle_source_new ();
g_source_set_callback (req->cancelled_idle,
(GSourceFunc)request_cancelled_idle, req, NULL);
g_source_attach (req->cancelled_idle, NULL);
g_source_attach (req->cancelled_idle, g_main_context_get_thread_default ());
}
static DWORD WINAPI
@ -479,7 +479,7 @@ g_win32_handle_source_add (HANDLE handle,
g_source_add_poll (source, &hsource->pollfd);
g_source_set_callback (source, callback, user_data, NULL);
g_source_attach (source, NULL);
g_source_attach (source, g_main_context_get_thread_default ());
return source;
}

1
gio/tests/.gitignore vendored
View File

@ -21,3 +21,4 @@ send-data
socket-client
socket-server
srvtarget
contexts

10
gio/tests/Makefile.am
View File

@ -7,7 +7,8 @@ INCLUDES = \
-I$(top_srcdir)/gmodule \
-I$(top_srcdir)/gobject \
-I$(top_srcdir)/gio \
$(GLIB_DEBUG_FLAGS)
$(GLIB_DEBUG_FLAGS) \
-DSRCDIR=\""$(srcdir)"\"
noinst_PROGRAMS = $(TEST_PROGS) $(SAMPLE_PROGS)
progs_ldadd = \
@ -29,7 +30,8 @@ TEST_PROGS += \
sleepy-stream \
filter-streams \
simple-async-result \
srvtarget
srvtarget \
contexts
SAMPLE_PROGS = resolver socket-server socket-client echo-server httpd send-data
@ -110,4 +112,8 @@ send_data_LDADD = $(progs_ldadd) \
srvtarget_SOURCES = srvtarget.c
srvtarget_LDADD = $(progs_ldadd)
contexts_SOURCES = contexts.c
contexts_LDADD = $(progs_ldadd) \
$(top_builddir)/gthread/libgthread-2.0.la
DISTCLEAN_FILES = applications/mimeinfo.cache

190
gio/tests/contexts.c Normal file
View File

@ -0,0 +1,190 @@
#include <gio/gio.h>
#include <stdlib.h>
#include <string.h>
#define TEST_FILE (SRCDIR "/Makefile.am")
char *test_file_buffer;
gsize test_file_size;
static char async_read_buffer[8192];
static void
read_data (GObject *source, GAsyncResult *result, gpointer loop)
{
GInputStream *in = G_INPUT_STREAM (source);
GError *error = NULL;
gssize nread;
nread = g_input_stream_read_finish (in, result, &error);
g_assert_no_error (error);
g_assert_cmpint (nread, >, 0);
g_assert_cmpint (nread, <=, MIN(sizeof (async_read_buffer), test_file_size));
g_assert (memcmp (async_read_buffer, test_file_buffer, nread) == 0);
g_main_loop_quit (loop);
}
static void
opened_for_read (GObject *source, GAsyncResult *result, gpointer loop)
{
GFile *file = G_FILE (source);
GFileInputStream *in;
GError *error = NULL;
in = g_file_read_finish (file, result, &error);
g_assert_no_error (error);
memset (async_read_buffer, 0, sizeof (async_read_buffer));
g_input_stream_read_async (G_INPUT_STREAM (in),
async_read_buffer, sizeof (async_read_buffer),
G_PRIORITY_DEFAULT, NULL,
read_data, loop);
}
/* Test 1: Async I/O started in a thread with a thread-default context
* will stick to that thread, and will complete even if the default
* main loop is blocked. (NB: the last part would not be true if we
* were testing GFileMonitor!)
*/
static gboolean idle_start_test1_thread (gpointer loop);
static gpointer test1_thread (gpointer user_data);
static GCond *test1_cond;
static GMutex *test1_mutex;
static void
test_thread_independence (void)
{
GMainLoop *loop;
test1_cond = g_cond_new ();
test1_mutex = g_mutex_new ();
loop = g_main_loop_new (NULL, FALSE);
g_idle_add (idle_start_test1_thread, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_mutex_free (test1_mutex);
g_cond_free (test1_cond);
}
static gboolean
idle_start_test1_thread (gpointer loop)
{
GTimeVal time;
GThread *thread;
gboolean io_completed;
g_mutex_lock (test1_mutex);
thread = g_thread_create (test1_thread, NULL, TRUE, NULL);
g_get_current_time (&time);
time.tv_sec += 2;
io_completed = g_cond_timed_wait (test1_cond, test1_mutex, &time);
g_assert (io_completed);
g_thread_join (thread);
g_mutex_unlock (test1_mutex);
g_main_loop_quit (loop);
return FALSE;
}
static gpointer
test1_thread (gpointer user_data)
{
GMainContext *context;
GMainLoop *loop;
GFile *file;
/* Wait for main thread to be waiting on test1_cond */
g_mutex_lock (test1_mutex);
g_mutex_unlock (test1_mutex);
context = g_main_context_new ();
g_assert (g_main_context_get_thread_default () == NULL);
g_main_context_push_thread_default (context);
g_assert (g_main_context_get_thread_default () == context);
file = g_file_new_for_path (TEST_FILE);
g_assert (g_file_supports_thread_contexts (file));
loop = g_main_loop_new (context, FALSE);
g_file_read_async (file, G_PRIORITY_DEFAULT, NULL,
opened_for_read, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_cond_signal (test1_cond);
return NULL;
}
/* Test 2: If we push a thread-default context in the main thread, we
* can run async ops in that context without running the default
* context.
*/
static gboolean test2_fail (gpointer user_data);
static void
test_context_independence (void)
{
GMainContext *context;
GMainLoop *loop;
GFile *file;
guint default_timeout;
GSource *thread_default_timeout;
context = g_main_context_new ();
g_assert (g_main_context_get_thread_default () == NULL);
g_main_context_push_thread_default (context);
g_assert (g_main_context_get_thread_default () == context);
file = g_file_new_for_path (TEST_FILE);
g_assert (g_file_supports_thread_contexts (file));
/* Add a timeout to the main loop, to fail immediately if it gets run */
default_timeout = g_timeout_add_full (G_PRIORITY_HIGH, 0,
test2_fail, NULL, NULL);
/* Add a timeout to the alternate loop, to fail if the I/O *doesn't* run */
thread_default_timeout = g_timeout_source_new_seconds (2);
g_source_set_callback (thread_default_timeout, test2_fail, NULL, NULL);
g_source_attach (thread_default_timeout, context);
loop = g_main_loop_new (context, FALSE);
g_file_read_async (file, G_PRIORITY_DEFAULT, NULL,
opened_for_read, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_source_remove (default_timeout);
g_source_destroy (thread_default_timeout);
g_source_unref (thread_default_timeout);
}
static gboolean
test2_fail (gpointer user_data)
{
g_assert_not_reached ();
return FALSE;
}
int
main (int argc, char **argv)
{
GError *error = NULL;
g_thread_init (NULL);
g_type_init ();
g_test_init (&argc, &argv, NULL);
g_file_get_contents (TEST_FILE, &test_file_buffer,
&test_file_size, &error);
g_assert_no_error (error);
g_test_add_func ("/gio/contexts/thread-independence", test_thread_independence);
g_test_add_func ("/gio/contexts/context-independence", test_context_independence);
return g_test_run();
}