1 /* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 *
5 * SPDX-License-Identifier: LGPL-2.1-or-later
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 *
20 * Author: Alexander Larsson <alexl@redhat.com>
21 */
22
23 #include "config.h"
24
25 #include "gioscheduler.h"
26 #include "gcancellable.h"
27 #include "gtask.h"
28
29 struct _GIOSchedulerJob {
30 GList *active_link;
31 GTask *task;
32
33 GIOSchedulerJobFunc job_func;
34 gpointer data;
35 GDestroyNotify destroy_notify;
36
37 GCancellable *cancellable;
38 gulong cancellable_id;
39 GMainContext *context;
40 };
41
42 G_LOCK_DEFINE_STATIC(active_jobs);
43 static GList *active_jobs = NULL;
44
45 static void
46 g_io_job_free (GIOSchedulerJob *job)
47 {
48 if (job->destroy_notify)
49 job->destroy_notify (job->data);
50
51 G_LOCK (active_jobs);
52 active_jobs = g_list_delete_link (active_jobs, job->active_link);
53 G_UNLOCK (active_jobs);
54
55 if (job->cancellable)
56 g_object_unref (job->cancellable);
57 g_main_context_unref (job->context);
58 g_slice_free (GIOSchedulerJob, job);
59 }
60
61 static void
62 io_job_thread (GTask *task,
63 gpointer source_object,
64 gpointer task_data,
65 GCancellable *cancellable)
66 {
67 GIOSchedulerJob *job = task_data;
68 gboolean result;
69
70 if (job->cancellable)
71 g_cancellable_push_current (job->cancellable);
72
73 do
74 {
75 result = job->job_func (job, job->cancellable, job->data);
76 }
77 while (result);
78
79 if (job->cancellable)
80 g_cancellable_pop_current (job->cancellable);
81 }
82
83 /**
84 * g_io_scheduler_push_job:
85 * @job_func: a #GIOSchedulerJobFunc.
86 * @user_data: data to pass to @job_func
87 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
88 * @io_priority: the [I/O priority][io-priority]
89 * of the request.
90 * @cancellable: optional #GCancellable object, %NULL to ignore.
91 *
92 * Schedules the I/O job to run in another thread.
93 *
94 * @notify will be called on @user_data after @job_func has returned,
95 * regardless whether the job was cancelled or has run to completion.
96 *
97 * If @cancellable is not %NULL, it can be used to cancel the I/O job
98 * by calling g_cancellable_cancel() or by calling
99 * g_io_scheduler_cancel_all_jobs().
100 *
101 * Deprecated: 2.36: use #GThreadPool or g_task_run_in_thread()
102 **/
103 void
104 g_io_scheduler_push_job (GIOSchedulerJobFunc job_func,
105 gpointer user_data,
106 GDestroyNotify notify,
107 gint io_priority,
108 GCancellable *cancellable)
109 {
110 GIOSchedulerJob *job;
111 GTask *task;
112
113 g_return_if_fail (job_func != NULL);
114
115 job = g_slice_new0 (GIOSchedulerJob);
116 job->job_func = job_func;
117 job->data = user_data;
118 job->destroy_notify = notify;
119
120 if (cancellable)
121 job->cancellable = g_object_ref (cancellable);
122
123 job->context = g_main_context_ref_thread_default ();
124
125 G_LOCK (active_jobs);
126 active_jobs = g_list_prepend (active_jobs, job);
127 job->active_link = active_jobs;
128 G_UNLOCK (active_jobs);
129
130 task = g_task_new (NULL, cancellable, NULL, NULL);
131 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
132 g_task_set_source_tag (task, g_io_scheduler_push_job);
133 G_GNUC_END_IGNORE_DEPRECATIONS
134 g_task_set_task_data (task, job, (GDestroyNotify)g_io_job_free);
135 g_task_set_priority (task, io_priority);
136 g_task_run_in_thread (task, io_job_thread);
137 g_object_unref (task);
138 }
139
140 /**
141 * g_io_scheduler_cancel_all_jobs:
142 *
143 * Cancels all cancellable I/O jobs.
144 *
145 * A job is cancellable if a #GCancellable was passed into
146 * g_io_scheduler_push_job().
147 *
148 * Deprecated: 2.36: You should never call this function, since you don't
149 * know how other libraries in your program might be making use of
150 * gioscheduler.
151 **/
152 void
153 g_io_scheduler_cancel_all_jobs (void)
154 {
155 GList *cancellable_list, *l;
156
157 G_LOCK (active_jobs);
158 cancellable_list = NULL;
159 for (l = active_jobs; l != NULL; l = l->next)
160 {
161 GIOSchedulerJob *job = l->data;
162 if (job->cancellable)
163 cancellable_list = g_list_prepend (cancellable_list,
164 g_object_ref (job->cancellable));
165 }
166 G_UNLOCK (active_jobs);
167
168 for (l = cancellable_list; l != NULL; l = l->next)
169 {
170 GCancellable *c = l->data;
171 g_cancellable_cancel (c);
172 g_object_unref (c);
173 }
174 g_list_free (cancellable_list);
175 }
176
177 typedef struct {
178 GSourceFunc func;
179 gboolean ret_val;
180 gpointer data;
181 GDestroyNotify notify;
182
183 GMutex ack_lock;
184 GCond ack_condition;
185 gboolean ack;
186 } MainLoopProxy;
187
188 static gboolean
189 mainloop_proxy_func (gpointer data)
190 {
191 MainLoopProxy *proxy = data;
192
193 proxy->ret_val = proxy->func (proxy->data);
194
195 if (proxy->notify)
196 proxy->notify (proxy->data);
197
198 g_mutex_lock (&proxy->ack_lock);
199 proxy->ack = TRUE;
200 g_cond_signal (&proxy->ack_condition);
201 g_mutex_unlock (&proxy->ack_lock);
202
203 return FALSE;
204 }
205
206 static void
207 mainloop_proxy_free (MainLoopProxy *proxy)
208 {
209 g_mutex_clear (&proxy->ack_lock);
210 g_cond_clear (&proxy->ack_condition);
211 g_free (proxy);
212 }
213
214 /**
215 * g_io_scheduler_job_send_to_mainloop:
216 * @job: a #GIOSchedulerJob
217 * @func: a #GSourceFunc callback that will be called in the original thread
218 * @user_data: data to pass to @func
219 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
220 *
221 * Used from an I/O job to send a callback to be run in the thread
222 * that the job was started from, waiting for the result (and thus
223 * blocking the I/O job).
224 *
225 * Returns: The return value of @func
226 *
227 * Deprecated: 2.36: Use g_main_context_invoke().
228 **/
229 gboolean
230 g_io_scheduler_job_send_to_mainloop (GIOSchedulerJob *job,
231 GSourceFunc func,
232 gpointer user_data,
233 GDestroyNotify notify)
234 {
235 GSource *source;
236 MainLoopProxy *proxy;
237 gboolean ret_val;
238
239 g_return_val_if_fail (job != NULL, FALSE);
240 g_return_val_if_fail (func != NULL, FALSE);
241
242 proxy = g_new0 (MainLoopProxy, 1);
243 proxy->func = func;
244 proxy->data = user_data;
245 proxy->notify = notify;
246 g_mutex_init (&proxy->ack_lock);
247 g_cond_init (&proxy->ack_condition);
248 g_mutex_lock (&proxy->ack_lock);
249
250 source = g_idle_source_new ();
251 g_source_set_priority (source, G_PRIORITY_DEFAULT);
252 g_source_set_callback (source, mainloop_proxy_func, proxy,
253 NULL);
254 g_source_set_static_name (source, "[gio] mainloop_proxy_func");
255
256 g_source_attach (source, job->context);
257 g_source_unref (source);
258
259 while (!proxy->ack)
260 g_cond_wait (&proxy->ack_condition, &proxy->ack_lock);
261 g_mutex_unlock (&proxy->ack_lock);
262
263 ret_val = proxy->ret_val;
264 mainloop_proxy_free (proxy);
265
266 return ret_val;
267 }
268
269 /**
270 * g_io_scheduler_job_send_to_mainloop_async:
271 * @job: a #GIOSchedulerJob
272 * @func: a #GSourceFunc callback that will be called in the original thread
273 * @user_data: data to pass to @func
274 * @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
275 *
276 * Used from an I/O job to send a callback to be run asynchronously in
277 * the thread that the job was started from. The callback will be run
278 * when the main loop is available, but at that time the I/O job might
279 * have finished. The return value from the callback is ignored.
280 *
281 * Note that if you are passing the @user_data from g_io_scheduler_push_job()
282 * on to this function you have to ensure that it is not freed before
283 * @func is called, either by passing %NULL as @notify to
284 * g_io_scheduler_push_job() or by using refcounting for @user_data.
285 *
286 * Deprecated: 2.36: Use g_main_context_invoke().
287 **/
288 void
289 g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
290 GSourceFunc func,
291 gpointer user_data,
292 GDestroyNotify notify)
293 {
294 GSource *source;
295 MainLoopProxy *proxy;
296
297 g_return_if_fail (job != NULL);
298 g_return_if_fail (func != NULL);
299
300 proxy = g_new0 (MainLoopProxy, 1);
301 proxy->func = func;
302 proxy->data = user_data;
303 proxy->notify = notify;
304 g_mutex_init (&proxy->ack_lock);
305 g_cond_init (&proxy->ack_condition);
306
307 source = g_idle_source_new ();
308 g_source_set_priority (source, G_PRIORITY_DEFAULT);
309 g_source_set_callback (source, mainloop_proxy_func, proxy,
310 (GDestroyNotify)mainloop_proxy_free);
311 g_source_set_static_name (source, "[gio] mainloop_proxy_func");
312
313 g_source_attach (source, job->context);
314 g_source_unref (source);
315 }