Debian Codegraph @

lib/wp/event-dispatcher.c

raw
1 /* WirePlumber
2 *
3 * Copyright © 2022 Collabora Ltd.
4 * @author George Kiagiadakis <[email protected]>
5 *
6 * SPDX-License-Identifier: MIT
7 */
8
9 #include "event-dispatcher.h"
10 #include "log.h"
11
12 #include <spa/support/plugin.h>
13 #include <spa/support/system.h>
14 #include <pipewire/pipewire.h>
15
16 WP_DEFINE_LOCAL_LOG_TOPIC ("wp-event-dispatcher")
17
18 typedef struct _HookData HookData;
19 struct _HookData
20 {
21 struct spa_list link;
22 WpEventHook *hook;
23 GPtrArray *dependencies;
24 };
25
26 static inline HookData *
27 hook_data_new (WpEventHook * hook)
28 {
29 HookData *hook_data = g_new0 (HookData, 1);
30 spa_list_init (&hook_data->link);
31 hook_data->hook = g_object_ref (hook);
32 hook_data->dependencies = g_ptr_array_new ();
33 return hook_data;
34 }
35
36 static void
37 hook_data_free (HookData *self)
38 {
39 g_clear_object (&self->hook);
40 g_clear_pointer (&self->dependencies, g_ptr_array_unref);
41 g_free (self);
42 }
43
44 static inline void
45 record_dependency (struct spa_list *list, const gchar *target,
46 const gchar *dependency)
47 {
48 HookData *hook_data;
49 spa_list_for_each (hook_data, list, link) {
50 if (g_pattern_match_simple (target, wp_event_hook_get_name (hook_data->hook))) {
51 g_ptr_array_insert (hook_data->dependencies, -1, (gchar *) dependency);
52 break;
53 }
54 }
55 }
56
57 static inline gboolean
58 hook_exists_in (const gchar *hook_name, struct spa_list *list)
59 {
60 HookData *hook_data;
61 if (!spa_list_is_empty (list)) {
62 spa_list_for_each (hook_data, list, link) {
63 if (g_pattern_match_simple (hook_name, wp_event_hook_get_name (hook_data->hook))) {
64 return TRUE;
65 }
66 }
67 }
68 return FALSE;
69 }
70
71 static gboolean
72 sort_hooks (GPtrArray *hooks)
73 {
74 struct spa_list collected, result, remaining;
75 HookData *sorted_hook_data = NULL;
76
77 spa_list_init (&collected);
78 spa_list_init (&result);
79 spa_list_init (&remaining);
80
81 for (guint i = 0; i < hooks->len; i++) {
82 WpEventHook *hook = g_ptr_array_index (hooks, i);
83 HookData *hook_data = hook_data_new (hook);
84
85 /* record "after" dependencies directly */
86 const gchar * const * strv =
87 wp_event_hook_get_runs_after_hooks (hook_data->hook);
88 while (strv && *strv) {
89 g_ptr_array_insert (hook_data->dependencies, -1, (gchar *) *strv);
90 strv++;
91 }
92
93 spa_list_append (&collected, &hook_data->link);
94 }
95
96 if (!spa_list_is_empty (&collected)) {
97 HookData *hook_data;
98
99 /* convert "before" dependencies into "after" dependencies */
100 spa_list_for_each (hook_data, &collected, link) {
101 const gchar * const * strv =
102 wp_event_hook_get_runs_before_hooks (hook_data->hook);
103 while (strv && *strv) {
104 /* record hook_data->hook as a dependency of the *strv hook */
105 record_dependency (&collected, *strv,
106 wp_event_hook_get_name (hook_data->hook));
107 strv++;
108 }
109 }
110
111 /* sort */
112 while (!spa_list_is_empty (&collected)) {
113 gboolean made_progress = FALSE;
114
115 /* examine each hook to see if its dependencies are satisfied in the
116 result list; if yes, then append it to the result too */
117 spa_list_consume (hook_data, &collected, link) {
118 guint deps_satisfied = 0;
119
120 spa_list_remove (&hook_data->link);
121
122 for (guint i = 0; i < hook_data->dependencies->len; i++) {
123 const gchar *dep = g_ptr_array_index (hook_data->dependencies, i);
124 /* if the dependency is already in the sorted result list or if
125 it doesn't exist at all, we consider it satisfied */
126 if (hook_exists_in (dep, &result) ||
127 !(hook_exists_in (dep, &collected) ||
128 hook_exists_in (dep, &remaining))) {
129 deps_satisfied++;
130 }
131 }
132
133 if (deps_satisfied == hook_data->dependencies->len) {
134 spa_list_append (&result, &hook_data->link);
135 made_progress = TRUE;
136 } else {
137 spa_list_append (&remaining, &hook_data->link);
138 }
139 }
140
141 if (made_progress) {
142 /* run again with the remaining hooks */
143 spa_list_insert_list (&collected, &remaining);
144 spa_list_init (&remaining);
145 }
146 else if (!spa_list_is_empty (&remaining)) {
147 /* if we did not make any progress towards growing the result list,
148 it means the dependencies cannot be satisfied because of circles */
149 spa_list_consume (hook_data, &result, link) {
150 spa_list_remove (&hook_data->link);
151 hook_data_free (hook_data);
152 }
153 spa_list_consume (hook_data, &remaining, link) {
154 spa_list_remove (&hook_data->link);
155 hook_data_free (hook_data);
156 }
157 return FALSE;
158 }
159 }
160 }
161
162 /* clear hooks and add the sorted ones */
163 g_ptr_array_set_size (hooks, 0);
164 spa_list_consume (sorted_hook_data, &result, link) {
165 spa_list_remove (&sorted_hook_data->link);
166 g_ptr_array_add (hooks, g_object_ref (sorted_hook_data->hook));
167 hook_data_free (sorted_hook_data);
168 }
169
170 return TRUE;
171 }
172
173 typedef struct _EventData EventData;
174 struct _EventData
175 {
176 WpEvent *event;
177 WpIterator *hooks_iter;
178 WpEventHook *current_hook_in_async;
179 gint64 seq;
180 };
181
182 static inline EventData *
183 event_data_new (WpEvent * event)
184 {
185 static gint64 seqn = 0;
186 EventData *event_data = g_new0 (EventData, 1);
187 event_data->event = wp_event_ref (event);
188 event_data->hooks_iter = wp_event_new_hooks_iterator (event);
189 event_data->seq = seqn++;
190 return event_data;
191 }
192
193 static void
194 event_data_free (EventData * self)
195 {
196 g_clear_pointer (&self->event, wp_event_unref);
197 g_clear_pointer (&self->hooks_iter, wp_iterator_unref);
198 g_clear_object (&self->current_hook_in_async);
199 g_free (self);
200 }
201
202 struct _WpEventDispatcher
203 {
204 GObject parent;
205
206 GWeakRef core;
207 GHashTable *defined_hooks; /* registered hooks for defined events */
208 GPtrArray *undefined_hooks; /* registered hooks for undefined events */
209 GSource *source; /* the event loop source */
210 GList *events; /* the events stack */
211 struct spa_system *system;
212 int eventfd;
213 };
214
215 G_DEFINE_TYPE (WpEventDispatcher, wp_event_dispatcher, G_TYPE_OBJECT)
216
217 #define WP_EVENT_SOURCE_DISPATCHER(x) \
218 WP_EVENT_DISPATCHER (((WpEventSource *) x)->dispatcher)
219
220 typedef struct _WpEventSource WpEventSource;
221 struct _WpEventSource
222 {
223 GSource parent;
224 WpEventDispatcher *dispatcher;
225 };
226
227 static gboolean
228 wp_event_source_check (GSource * s)
229 {
230 WpEventDispatcher *d = WP_EVENT_SOURCE_DISPATCHER (s);
231 return d && d->events &&
232 !((EventData *) g_list_first (d->events)->data)->current_hook_in_async;
233 }
234
235 static void
236 on_event_hook_done (WpEventHook * hook, GAsyncResult * res, EventData * data)
237 {
238 g_autoptr (GError) error = NULL;
239 g_autoptr (WpEventDispatcher) dispatcher =
240 wp_event_hook_get_dispatcher (hook);
241
242 g_assert (data->current_hook_in_async == hook);
243
244 if (!wp_event_hook_finish (hook, res, &error) && error &&
245 error->domain != G_IO_ERROR && error->code != G_IO_ERROR_CANCELLED)
246 wp_notice_object (hook, "failed: %s", error->message);
247
248 g_clear_object (&data->current_hook_in_async);
249 spa_system_eventfd_write (dispatcher->system, dispatcher->eventfd, 1);
250 }
251
252 static gboolean
253 wp_event_source_dispatch (GSource * s, GSourceFunc callback, gpointer user_data)
254 {
255 WpEventDispatcher *d = WP_EVENT_SOURCE_DISPATCHER (s);
256 uint64_t count;
257
258 /* clear the eventfd */
259 spa_system_eventfd_read (d->system, d->eventfd, &count);
260
261 /* get the highest priority event */
262 GList *levent = g_list_first (d->events);
263 while (levent) {
264 EventData *event_data = (EventData *) (levent->data);
265 WpEvent *event = event_data->event;
266 GCancellable *cancellable = wp_event_get_cancellable (event);
267 g_auto (GValue) value = G_VALUE_INIT;
268 gboolean has_next = FALSE;
269
270 /* event hook is still in progress, we will continue later */
271 if (event_data->current_hook_in_async)
272 return G_SOURCE_CONTINUE;
273
274 /* check if the event was cancelled */
275 if (g_cancellable_is_cancelled (cancellable)) {
276 wp_debug_object (d, "event(%p) cancelled remove it", event);
277 has_next = FALSE;
278 } else {
279 /* get the highest priority hook */
280 has_next = wp_iterator_next (event_data->hooks_iter, &value);
281 }
282
283 if (has_next) {
284 WpEventHook *hook = g_value_get_object (&value);
285 const gchar *name = wp_event_hook_get_name (hook);
286
287 event_data->current_hook_in_async = g_object_ref (hook);
288
289 wp_trace_object(d, "dispatching event (%s) running hook <%p>(%s)",
290 wp_event_get_name(event), hook, name);
291
292 /* execute the hook, possibly async */
293 wp_event_hook_run (hook, event, cancellable,
294 (GAsyncReadyCallback) on_event_hook_done, event_data);
295 } else {
296 /* clear the event after all hooks are done */
297 d->events = g_list_delete_link (d->events, g_steal_pointer (&levent));
298 g_clear_pointer (&event_data, event_data_free);
299 }
300
301 /* get the next event */
302 levent = g_list_first (d->events);
303 }
304
305 return G_SOURCE_CONTINUE;
306 }
307
308 static GSourceFuncs source_funcs = {
309 NULL,
310 wp_event_source_check,
311 wp_event_source_dispatch,
312 NULL
313 };
314
315 static void
316 wp_event_dispatcher_init (WpEventDispatcher * self)
317 {
318 g_weak_ref_init (&self->core, NULL);
319 self->defined_hooks = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
320 (GDestroyNotify)g_ptr_array_unref);
321 self->undefined_hooks = g_ptr_array_new_with_free_func (g_object_unref);
322
323 self->source = g_source_new (&source_funcs, sizeof (WpEventSource));
324 ((WpEventSource *) self->source)->dispatcher = self;
325
326 /* this is higher than normal "idle" operations but lower than the default
327 priority, which is used for events from the PipeWire socket and timers */
328 g_source_set_priority (self->source, G_PRIORITY_HIGH_IDLE);
329 }
330
331 static void
332 wp_event_dispatcher_finalize (GObject * object)
333 {
334 WpEventDispatcher *self = WP_EVENT_DISPATCHER (object);
335
336 g_list_free_full (g_steal_pointer (&self->events),
337 (GDestroyNotify) event_data_free);
338
339 ((WpEventSource *) self->source)->dispatcher = NULL;
340 g_source_destroy (self->source);
341 g_clear_pointer (&self->source, g_source_unref);
342
343 close (self->eventfd);
344
345 g_clear_pointer (&self->defined_hooks, g_hash_table_unref);
346 g_clear_pointer (&self->undefined_hooks, g_ptr_array_unref);
347 g_weak_ref_clear (&self->core);
348
349 G_OBJECT_CLASS (wp_event_dispatcher_parent_class)->finalize (object);
350 }
351
352 static void
353 wp_event_dispatcher_class_init (WpEventDispatcherClass * klass)
354 {
355 GObjectClass *object_class = (GObjectClass *) klass;
356
357 object_class->finalize = wp_event_dispatcher_finalize;
358 }
359
360 /*!
361 * \brief Returns the event dispatcher instance that is associated with the
362 * given core.
363 *
364 * This method will also create the instance and register it with the core,
365 * if it had not been created before.
366 *
367 * \ingroup wpeventdispatcher
368 * \param core the core
369 * \return (transfer full): the event dispatcher instance
370 */
371 WpEventDispatcher *
372 wp_event_dispatcher_get_instance (WpCore * core)
373 {
374 WpEventDispatcher *dispatcher = wp_core_find_object (core,
375 (GEqualFunc) WP_IS_EVENT_DISPATCHER, NULL);
376
377 if (G_UNLIKELY (!dispatcher)) {
378 dispatcher = g_object_new (WP_TYPE_EVENT_DISPATCHER, NULL);
379 g_weak_ref_set (&dispatcher->core, core);
380
381 struct pw_context *context = wp_core_get_pw_context (core);
382 uint32_t n_support;
383 const struct spa_support *support =
384 pw_context_get_support (context, &n_support);
385 dispatcher->system =
386 spa_support_find (support, n_support, SPA_TYPE_INTERFACE_System);
387
388 dispatcher->eventfd = spa_system_eventfd_create (dispatcher->system, 0);
389 g_source_add_unix_fd (dispatcher->source, dispatcher->eventfd, G_IO_IN);
390
391 g_source_attach (dispatcher->source, wp_core_get_g_main_context (core));
392 wp_core_register_object (core, g_object_ref (dispatcher));
393
394 wp_info_object (dispatcher, "event-dispatcher inited");
395 }
396
397 return dispatcher;
398 }
399
400 static gint
401 event_cmp_func (const EventData *a, const EventData *b)
402 {
403 gint c = wp_event_get_priority (b->event) - wp_event_get_priority (a->event);
404 return (c != 0) ? c : (gint)(a->seq - b->seq);
405 }
406
407 /*!
408 * \brief Pushes a new event onto the event stack for dispatching only if there
409 * are any hooks are available for it.
410 * \ingroup wpeventdispatcher
411 *
412 * \param self the dispatcher
413 * \param event (transfer full): the new event
414 */
415 void
416 wp_event_dispatcher_push_event (WpEventDispatcher * self, WpEvent * event)
417 {
418 g_return_if_fail (WP_IS_EVENT_DISPATCHER (self));
419 g_return_if_fail (event != NULL);
420
421 if (wp_event_collect_hooks (event, self)) {
422 EventData *event_data = event_data_new (event);
423
424 self->events = g_list_insert_sorted (self->events, event_data,
425 (GCompareFunc) event_cmp_func);
426 wp_debug_object (self, "pushed event (%s)", wp_event_get_name (event));
427
428 /* wakeup the GSource */
429 spa_system_eventfd_write (self->system, self->eventfd, 1);
430 }
431
432 wp_event_unref (event);
433 }
434
435 /*!
436 * \brief Registers an event hook
437 * \ingroup wpeventdispatcher
438 *
439 * \param self the event dispatcher
440 * \param hook (transfer none): the hook to register
441 */
442 void
443 wp_event_dispatcher_register_hook (WpEventDispatcher * self,
444 WpEventHook * hook)
445 {
446 g_autoptr (GPtrArray) event_types = NULL;
447 gboolean is_defined = FALSE;
448 const gchar *hook_name;
449
450 g_return_if_fail (WP_IS_EVENT_DISPATCHER (self));
451 g_return_if_fail (WP_IS_EVENT_HOOK (hook));
452
453 g_autoptr (WpEventDispatcher) already_registered_dispatcher =
454 wp_event_hook_get_dispatcher (hook);
455 g_return_if_fail (already_registered_dispatcher == NULL);
456
457 wp_event_hook_set_dispatcher (hook, self);
458
459 /* Register the event hook in the defined hooks table if it is defined */
460 hook_name = wp_event_hook_get_name (hook);
461 event_types = wp_event_hook_get_matching_event_types (hook);
462 if (event_types) {
463 for (guint i = 0; i < event_types->len; i++) {
464 const gchar *event_type = g_ptr_array_index (event_types, i);
465 GPtrArray *hooks;
466
467 wp_debug_object (self, "Registering hook %s for defined event type %s",
468 hook_name, event_type);
469
470 /* Check if the event type was registered in the hash table */
471 hooks = g_hash_table_lookup (self->defined_hooks, event_type);
472 if (hooks) {
473 g_ptr_array_add (hooks, g_object_ref (hook));
474 if (!sort_hooks (hooks))
475 goto sort_error;
476 } else {
477 GPtrArray *new_hooks = g_ptr_array_new_with_free_func (g_object_unref);
478 /* Add undefined hooks */
479 for (guint i = 0; i < self->undefined_hooks->len; i++) {
480 WpEventHook *uh = g_ptr_array_index (self->undefined_hooks, i);
481 g_ptr_array_add (new_hooks, g_object_ref (uh));
482 }
483 /* Add current hook */
484 g_ptr_array_add (new_hooks, g_object_ref (hook));
485 g_hash_table_insert (self->defined_hooks, g_strdup (event_type),
486 new_hooks);
487 if (!sort_hooks (new_hooks))
488 goto sort_error;
489 }
490
491 is_defined = TRUE;
492 }
493 }
494
495 /* Otherwise just register it as undefined hook */
496 if (!is_defined) {
497 GHashTableIter iter;
498 gpointer value;
499
500 wp_debug_object (self, "Registering hook %s for undefined event types",
501 hook_name);
502
503 /* Add it to the defined hooks table */
504 g_hash_table_iter_init (&iter, self->defined_hooks);
505 while (g_hash_table_iter_next (&iter, NULL, &value)) {
506 GPtrArray *defined_hooks = value;
507 g_ptr_array_add (defined_hooks, g_object_ref (hook));
508 if (!sort_hooks (defined_hooks))
509 goto sort_error;
510 }
511
512 /* Add it to the undefined hooks */
513 g_ptr_array_add (self->undefined_hooks, g_object_ref (hook));
514 if (!sort_hooks (self->undefined_hooks))
515 goto sort_error;
516 }
517
518 wp_info_object (self, "Registered hook %s successfully", hook_name);
519 return;
520
521 sort_error:
522 /* Unregister hook */
523 wp_event_dispatcher_unregister_hook (self, hook);
524 wp_warning_object (self,
525 "Could not register hook %s because of circular dependencies", hook_name);
526 }
527
528 /*!
529 * \brief Unregisters an event hook
530 * \ingroup wpeventdispatcher
531 *
532 * \param self the event dispatcher
533 * \param hook (transfer none): the hook to unregister
534 */
535 void
536 wp_event_dispatcher_unregister_hook (WpEventDispatcher * self,
537 WpEventHook * hook)
538 {
539 GHashTableIter iter;
540 gpointer value;
541
542 g_return_if_fail (WP_IS_EVENT_DISPATCHER (self));
543 g_return_if_fail (WP_IS_EVENT_HOOK (hook));
544
545 g_autoptr (WpEventDispatcher) already_registered_dispatcher =
546 wp_event_hook_get_dispatcher (hook);
547 g_return_if_fail (already_registered_dispatcher == self);
548
549 wp_event_hook_set_dispatcher (hook, NULL);
550
551 /* Remove hook from defined table and undefined list */
552 g_hash_table_iter_init (&iter, self->defined_hooks);
553 while (g_hash_table_iter_next (&iter, NULL, &value)) {
554 GPtrArray *defined_hooks = value;
555 g_ptr_array_remove (defined_hooks, hook);
556 }
557 g_ptr_array_remove (self->undefined_hooks, hook);
558 }
559
560 static void
561 add_unique (GPtrArray *array, WpEventHook * hook)
562 {
563 for (guint i = 0; i < array->len; i++)
564 if (g_ptr_array_index (array, i) == hook)
565 return;
566 g_ptr_array_add (array, g_object_ref (hook));
567 }
568
569 /*!
570 * \brief Returns an iterator to iterate over all the registered hooks
571 * \deprecated Use \ref wp_event_dispatcher_new_hooks_for_event_type_iterator
572 * instead.
573 * \ingroup wpeventdispatcher
574 *
575 * \param self the event dispatcher
576 * \return (transfer full): a new iterator
577 */
578 WpIterator *
579 wp_event_dispatcher_new_hooks_iterator (WpEventDispatcher * self)
580 {
581 GPtrArray *items = g_ptr_array_new_with_free_func (g_object_unref);
582 GHashTableIter iter;
583 gpointer value;
584
585 /* Add all defined hooks */
586 g_hash_table_iter_init (&iter, self->defined_hooks);
587 while (g_hash_table_iter_next (&iter, NULL, &value)) {
588 GPtrArray *hooks = value;
589 for (guint i = 0; i < hooks->len; i++) {
590 WpEventHook *hook = g_ptr_array_index (hooks, i);
591 add_unique (items, hook);
592 }
593 }
594
595 /* Add all undefined hooks */
596 for (guint i = 0; i < self->undefined_hooks->len; i++) {
597 WpEventHook *hook = g_ptr_array_index (self->undefined_hooks, i);
598 add_unique (items, hook);
599 }
600
601 return wp_iterator_new_ptr_array (items, WP_TYPE_EVENT_HOOK);
602 }
603
604 /*!
605 * \brief Returns an iterator to iterate over the registered hooks for a
606 * particular event type.
607 * \ingroup wpeventdispatcher
608 *
609 * \param self the event dispatcher
610 * \param event_type the event type
611 * \return (transfer full): a new iterator
612 * \since 0.5.13
613 */
614 WpIterator *
615 wp_event_dispatcher_new_hooks_for_event_type_iterator (
616 WpEventDispatcher * self, const gchar *event_type)
617 {
618 GPtrArray *items;
619 GPtrArray *hooks;
620
621 hooks = g_hash_table_lookup (self->defined_hooks, event_type);
622 if (hooks) {
623 wp_debug_object (self, "Using %d defined hooks for event type %s",
624 hooks->len, event_type);
625 } else {
626 hooks = self->undefined_hooks;
627 wp_debug_object (self, "Using %d undefined hooks for event type %s",
628 hooks->len, event_type);
629 }
630
631 items = g_ptr_array_copy (hooks, (GCopyFunc) g_object_ref, NULL);
632 return wp_iterator_new_ptr_array (items, WP_TYPE_EVENT_HOOK);
633 }