mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/spa/plugins/support/loop.c

998 lines
25 KiB
C
Raw Normal View History

Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
/* Spa
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Copyright © 2018 Wim Taymans
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*
Relicense as MIT/X11 Remove some obsolete files
2018-11-05 17:48:52 +01:00
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*/
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/support/loop.h>
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
#include <spa/support/system.h>
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/support/log.h>
#include <spa/support/plugin.h>
#include <spa/utils/list.h>
names: add standard factory name definitions Define a set of standard factory names and document what they contain. This makes it possible to change the implementation by mapping the factory-name to a different shared library.
2019-06-21 13:31:34 +02:00
#include <spa/utils/names.h>
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
#include <spa/utils/result.h>
Remove dynamic types Do not use dynamic types anymore. The reason is that it's difficult: - to maintain a shared type database over a network. - the extra overhead when translating between processes and for maintaining the translation tables. - race conditions in translating in RT-threads, this is a problem because we want to make event streams. We now have simple enums with types and extension points for all types. This is also nicer to use in general. We don't need the mapper anymore or pass strings around as types. There is a parallel type info system to get more info about ids and enums and their hierarchy. It can also be used for debugging.
2018-08-23 17:47:57 +02:00
#include <spa/utils/type.h>
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/utils/ringbuffer.h>
treewide: replace strcmp() == 0 with spa_streq() This change is only done in source files for now, header files will be done separately.
2021-05-18 11:36:13 +10:00
#include <spa/utils/string.h>
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
static struct spa_log_topic log_topic = SPA_LOG_TOPIC(0, "spa.loop");
#undef SPA_LOG_TOPIC_DEFAULT
#define SPA_LOG_TOPIC_DEFAULT &log_topic
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
support: use defines for alignment
2022-01-03 11:14:15 +01:00
#define MAX_ALIGN 8
#define ITEM_ALIGN 8
#define DATAS_SIZE (4096*8)
loop: handle remove while dispatching better Keep the array of dispatched sources around in the loop. When a source is removed while dispatching, set the data to NULL so that we don't try to deref the source again or call its function. Fixes #2114
2022-02-08 10:09:06 +01:00
#define MAX_EP 32
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
/** \cond */
struct invoke_item {
size_t item_size;
spa_invoke_func_t func;
uint32_t seq;
void *data;
cleanups Follow the data/size argument order convention to make the api more consistent.
2017-11-20 15:26:44 +01:00
size_t size;
loop: add block flag to invoke Remove async shutdown and block instead.
2017-06-26 10:41:19 +02:00
bool block;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
void *user_data;
loop: add block flag to invoke Remove async shutdown and block instead.
2017-06-26 10:41:19 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
improve error handling Make sure we free properties we take ownership of. Add some more return values to functions that can fail.
2019-06-19 18:15:04 +02:00
static int loop_signal_event(void *object, struct spa_source *source);
loop: add block flag to invoke Remove async shutdown and block instead.
2017-06-26 10:41:19 +02:00
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct impl {
struct spa_handle handle;
struct spa_loop loop;
struct spa_loop_control control;
struct spa_loop_utils utils;
struct spa_log *log;
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
struct spa_system *system;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct spa_list source_list;
Revert "loop: remove destroy list" This reverts commit c474846c42967c44db069a23b76a29da6f496f33. In addition, `s->loop` is also checked before dispatching a source. The destroy list is needed in the presence of threads. The issue is that a source may be destroyed between `epoll_wait()` returning and thread loop lock being acquired. If this source is active, then a use-after-free will be triggered when the thread loop acquires the lock and starts dispatching the sources. thread 1 thread 2 ---------- ---------- loop_iterate spa_loop_control_hook_before // release lock pw_thread_loop_lock spa_system_pollfd_wait // assume it returns with source A pw_loop_destroy_source(..., A) // frees storage of A pw_thread_loop_unlock spa_loop_control_hook_after // acquire the lock for (...) { struct spa_source *s = ep[i].data; s->rmask = ep[i].events; // use-after-free if `s` refers to // the previously freed `A` Fixes #2147
2022-02-18 18:36:36 +01:00
struct spa_list destroy_list;
Move listeners to spa and rename to hooks The listeners are generally useful in spa, move it there and rename to hooks. Implement loop hooks with it. Fix some cleanup issues in stream and remote
2017-08-08 16:56:29 +02:00
struct spa_hook_list hooks_list;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
int poll_fd;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
pthread_t thread;
support: loop_enter/leave hardening This commit adds a counter for loop_enter/leave and checks: - consecutive enter are used on the same thread - leave is used on the same thread as enter - at destruction, the enter_count must be 0
2022-02-08 10:58:36 +01:00
int enter_count;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: add block flag to invoke Remove async shutdown and block instead.
2017-06-26 10:41:19 +02:00
struct spa_source *wakeup;
int ack_fd;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct spa_ringbuffer buffer;
loop: align buffer and invoke_items to 8 bytes To avoid unaligned access messages from sanitizer See #497
2020-12-21 20:46:13 +01:00
uint8_t *buffer_data;
support: use defines for alignment
2022-01-03 11:14:15 +01:00
uint8_t buffer_mem[DATAS_SIZE + MAX_ALIGN];
loop: don't recursively flush If we are already in the loop thread and flushing, this means we added a new invoke item on the list from a callback. Place the item on the queue and let the flush code take care of it after the callback completes. Required to fix some issues with draining in pulse where a stream is destroyed from the drained callback which then invokes a pause.
2020-09-17 11:45:25 +02:00
unsigned int flushing:1;
spa: support: loop: add `polling` flag Store whether or not the loop is currently polling, i.e. calling `spa_system_pollfd_wait()`.
2022-02-19 11:44:04 +01:00
unsigned int polling:1;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
struct source_impl {
struct spa_source source;
struct impl *impl;
struct spa_list link;
union {
spa_source_io_func_t io;
spa_source_idle_func_t idle;
spa_source_event_func_t event;
spa_source_timer_func_t timer;
spa_source_signal_func_t signal;
} func;
spa: support: loop: move struct members Move the boolean members of `struct source_impl` to the end of the struct. This changes the size of the struct from 104 bytes to 96 bytes on x86-64. Before: struct source_impl { struct spa_source source; /* 0 48 */ struct impl * impl; /* 48 8 */ struct spa_list link; /* 56 16 */ /* --- cacheline 1 boundary (64 bytes) was 8 bytes ago --- */ _Bool close; /* 72 1 */ /* XXX 7 bytes hole, try to pack */ union { spa_source_io_func_t io; /* 80 8 */ spa_source_idle_func_t idle; /* 80 8 */ spa_source_event_func_t event; /* 80 8 */ spa_source_timer_func_t timer; /* 80 8 */ spa_source_signal_func_t signal; /* 80 8 */ } func; /* 80 8 */ _Bool enabled; /* 88 1 */ /* XXX 7 bytes hole, try to pack */ struct spa_source * fallback; /* 96 8 */ /* size: 104, cachelines: 2, members: 7 */ /* sum members: 90, holes: 2, sum holes: 14 */ /* last cacheline: 40 bytes */ }; After: struct source_impl { struct spa_source source; /* 0 48 */ struct impl * impl; /* 48 8 */ struct spa_list link; /* 56 16 */ /* --- cacheline 1 boundary (64 bytes) was 8 bytes ago --- */ union { spa_source_io_func_t io; /* 72 8 */ spa_source_idle_func_t idle; /* 72 8 */ spa_source_event_func_t event; /* 72 8 */ spa_source_timer_func_t timer; /* 72 8 */ spa_source_signal_func_t signal; /* 72 8 */ } func; /* 72 8 */ struct spa_source * fallback; /* 80 8 */ _Bool close; /* 88 1 */ _Bool enabled; /* 89 1 */ /* size: 96, cachelines: 2, members: 7 */ /* padding: 6 */ /* last cacheline: 32 bytes */ };
2022-02-19 15:12:31 +01:00
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
struct spa_source *fallback;
spa: support: loop: move struct members Move the boolean members of `struct source_impl` to the end of the struct. This changes the size of the struct from 104 bytes to 96 bytes on x86-64. Before: struct source_impl { struct spa_source source; /* 0 48 */ struct impl * impl; /* 48 8 */ struct spa_list link; /* 56 16 */ /* --- cacheline 1 boundary (64 bytes) was 8 bytes ago --- */ _Bool close; /* 72 1 */ /* XXX 7 bytes hole, try to pack */ union { spa_source_io_func_t io; /* 80 8 */ spa_source_idle_func_t idle; /* 80 8 */ spa_source_event_func_t event; /* 80 8 */ spa_source_timer_func_t timer; /* 80 8 */ spa_source_signal_func_t signal; /* 80 8 */ } func; /* 80 8 */ _Bool enabled; /* 88 1 */ /* XXX 7 bytes hole, try to pack */ struct spa_source * fallback; /* 96 8 */ /* size: 104, cachelines: 2, members: 7 */ /* sum members: 90, holes: 2, sum holes: 14 */ /* last cacheline: 40 bytes */ }; After: struct source_impl { struct spa_source source; /* 0 48 */ struct impl * impl; /* 48 8 */ struct spa_list link; /* 56 16 */ /* --- cacheline 1 boundary (64 bytes) was 8 bytes ago --- */ union { spa_source_io_func_t io; /* 72 8 */ spa_source_idle_func_t idle; /* 72 8 */ spa_source_event_func_t event; /* 72 8 */ spa_source_timer_func_t timer; /* 72 8 */ spa_source_signal_func_t signal; /* 72 8 */ } func; /* 72 8 */ struct spa_source * fallback; /* 80 8 */ _Bool close; /* 88 1 */ _Bool enabled; /* 89 1 */ /* size: 96, cachelines: 2, members: 7 */ /* padding: 6 */ /* last cacheline: 32 bytes */ };
2022-02-19 15:12:31 +01:00
bool close;
bool enabled;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
/** \endcond */
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int loop_add_source(void *object, struct spa_source *source)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: cleanups
2019-05-23 15:11:49 +02:00
source->loop = &impl->loop;
support: also protect against recursive invocations Add an extra private field to the source to store the pollevent of the current iteration. This changes ABI but it seems an embedded source is not used outside of our own plugins and the unit test doesn't test this ABI case. Whenever a source is removed, we can set the data field of the pollevent to NULL so that it won't be handled in any iteration anymore. Avoid dispatching the same event multiple times when doing recursive iterations. Add some more unit tests for this. Fixes #2114
2022-02-08 17:21:10 +01:00
source->priv = NULL;
spa: support: loop: initialize rmask Set `rmask` to zero when a source is added to, or removed from the loop.
2022-02-19 09:40:27 +01:00
source->rmask = 0;
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
return spa_system_pollfd_add(impl->system, impl->poll_fd, source->fd, source->mask, source);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int loop_update_source(void *object, struct spa_source *source)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa_assert(source->loop == &impl->loop);
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
return spa_system_pollfd_mod(impl->system, impl->poll_fd, source->fd, source->mask, source);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
static void detach_source(struct spa_source *source)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
support: also protect against recursive invocations Add an extra private field to the source to store the pollevent of the current iteration. This changes ABI but it seems an embedded source is not used outside of our own plugins and the unit test doesn't test this ABI case. Whenever a source is removed, we can set the data field of the pollevent to NULL so that it won't be handled in any iteration anymore. Avoid dispatching the same event multiple times when doing recursive iterations. Add some more unit tests for this. Fixes #2114
2022-02-08 17:21:10 +01:00
struct spa_poll_event *e;
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
source->loop = NULL;
source->rmask = 0;
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
support: also protect against recursive invocations Add an extra private field to the source to store the pollevent of the current iteration. This changes ABI but it seems an embedded source is not used outside of our own plugins and the unit test doesn't test this ABI case. Whenever a source is removed, we can set the data field of the pollevent to NULL so that it won't be handled in any iteration anymore. Avoid dispatching the same event multiple times when doing recursive iterations. Add some more unit tests for this. Fixes #2114
2022-02-08 17:21:10 +01:00
if ((e = source->priv)) {
/* active in an iteration of the loop, remove it from there */
e->data = NULL;
source->priv = NULL;
loop: handle remove while dispatching better Keep the array of dispatched sources around in the loop. When a source is removed while dispatching, set the data to NULL so that we don't try to deref the source again or call its function. Fixes #2114
2022-02-08 10:09:06 +01:00
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
}
static int remove_from_poll(struct impl *impl, struct spa_source *source)
{
spa_assert(source->loop == &impl->loop);
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
return spa_system_pollfd_del(impl->system, impl->poll_fd, source->fd);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
static int loop_remove_source(void *object, struct spa_source *source)
{
spa: support: loop: assert loop is not polling when source is removed `spa_source`s whose backing storage is not managed by the loop cannot be safely removed while the loop is polling. Assert that it does not happen.
2022-03-04 16:53:26 +01:00
struct impl *impl = object;
spa_assert(!impl->polling);
int res = remove_from_poll(impl, source);
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
detach_source(source);
return res;
}
loop: always wake up blocking items We should always wake up the blocking items if we scheduled the item.
2020-11-13 16:50:23 +01:00
static void flush_items(struct impl *impl)
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
{
uint32_t index;
int res;
loop: don't recursively flush If we are already in the loop thread and flushing, this means we added a new invoke item on the list from a callback. Place the item on the queue and let the flush code take care of it after the callback completes. Required to fix some issues with draining in pulse where a stream is destroyed from the drained callback which then invokes a pause.
2020-09-17 11:45:25 +02:00
impl->flushing = true;
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
while (spa_ringbuffer_get_read_index(&impl->buffer, &index) > 0) {
struct invoke_item *item;
bool block;
spa/buffer: rename SPA_MEMBER to SPA_PTROFF SPA_MEMBER is misleading, all we're doing here is pointer+offset and a type-casting the result. Rename to SPA_PTROFF which is more expressive (and has the same number of characters so we don't need to re-indent).
2021-05-06 13:41:44 +10:00
item = SPA_PTROFF(impl->buffer_data, index & (DATAS_SIZE - 1), struct invoke_item);
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
block = item->block;
move some debug to fastpath
2022-03-28 16:25:00 +02:00
spa_log_trace_fp(impl->log, "%p: flush item %p", impl, item);
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
item->res = item->func ? item->func(&impl->loop,
true, item->seq, item->data, item->size,
item->user_data) : 0;
spa_ringbuffer_read_update(&impl->buffer, index + item->item_size);
loop: always wake up blocking items We should always wake up the blocking items if we scheduled the item.
2020-11-13 16:50:23 +01:00
if (block) {
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
if ((res = spa_system_eventfd_write(impl->system, impl->ack_fd, 1)) < 0)
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(impl->log, "%p: failed to write event fd:%d: %s",
impl, impl->ack_fd, spa_strerror(res));
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
}
}
loop: don't recursively flush If we are already in the loop thread and flushing, this means we added a new invoke item on the list from a callback. Place the item on the queue and let the flush code take care of it after the callback completes. Required to fix some issues with draining in pulse where a stream is destroyed from the drained callback which then invokes a pause.
2020-09-17 11:45:25 +02:00
impl->flushing = false;
loop: flush items in invoke from thread When we do invoke from the loop thread, first process the pending invoke items before handling ours. This can be used to sync the invoke queue before cleanup.
2019-08-16 15:04:27 +02:00
}
loop: avoid corruption of ringbuffer The ringbuffer can't be written to from multiple threads. When both the main loop and data thread do _invoke, they both write to the ringbuffer and cause it to be corrupted because the ringbuffer is not multi-writer safe. Doing invoke from the thread itself is usually done to flush things out so we really only need to flush the ringbuffer and call the callback. See #1451
2021-07-26 11:39:48 +02:00
static int
loop_invoke_inthread(struct impl *impl,
spa_invoke_func_t func,
uint32_t seq,
const void *data,
size_t size,
bool block,
void *user_data)
{
if (!impl->flushing)
flush_items(impl);
return func ? func(&impl->loop, true, seq, data, size, user_data) : 0;
}
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
loop_invoke(void *object,
loop: add block flag to invoke Remove async shutdown and block instead.
2017-06-26 10:41:19 +02:00
spa_invoke_func_t func,
uint32_t seq,
Use remote to join nodes on remote graphs Make a new method that can take a local node and run it in a remote pipeline. This basically replaces all functionality of the streams and more. Add 2 examples for exporting a sink and a v4l2 node Make some more things const Cleanups Make it possible to do things when the node needs scheduling. The default node will schedule the local pipeline but the remote node might also schedule the remote pipeline.
2017-07-25 19:52:31 +02:00
const void *data,
cleanups Follow the data/size argument order convention to make the api more consistent.
2017-11-20 15:26:44 +01:00
size_t size,
loop: add block flag to invoke Remove async shutdown and block instead.
2017-06-26 10:41:19 +02:00
bool block,
void *user_data)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct invoke_item *item;
int res;
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
int32_t filled;
uint32_t avail, idx, offset, l0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: invoke immediately when loop is not running Or else we might never get our callback called or worse, block forever, waiting for the response.
2022-01-18 20:03:01 +01:00
if (impl->thread == 0 || pthread_equal(impl->thread, pthread_self()))
loop: avoid corruption of ringbuffer The ringbuffer can't be written to from multiple threads. When both the main loop and data thread do _invoke, they both write to the ringbuffer and cause it to be corrupted because the ringbuffer is not multi-writer safe. Doing invoke from the thread itself is usually done to flush things out so we really only need to flush the ringbuffer and call the callback. See #1451
2021-07-26 11:39:48 +02:00
return loop_invoke_inthread(impl, func, seq, data, size, block, user_data);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
filled = spa_ringbuffer_get_write_index(&impl->buffer, &idx);
if (filled < 0 || filled > DATAS_SIZE) {
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_warn(impl->log, "%p: queue xrun %d", impl, filled);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
return -EPIPE;
}
avail = DATAS_SIZE - filled;
if (avail < sizeof(struct invoke_item)) {
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_warn(impl->log, "%p: queue full %d", impl, avail);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
return -EPIPE;
}
offset = idx & (DATAS_SIZE - 1);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
/* l0 is remaining size in ringbuffer, this should always be larger than
* invoke_item, see below */
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
l0 = DATAS_SIZE - offset;
spa/buffer: rename SPA_MEMBER to SPA_PTROFF SPA_MEMBER is misleading, all we're doing here is pointer+offset and a type-casting the result. Rename to SPA_PTROFF which is more expressive (and has the same number of characters so we don't need to re-indent).
2021-05-06 13:41:44 +10:00
item = SPA_PTROFF(impl->buffer_data, offset, struct invoke_item);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
item->func = func;
item->seq = seq;
item->size = size;
loop: avoid corruption of ringbuffer The ringbuffer can't be written to from multiple threads. When both the main loop and data thread do _invoke, they both write to the ringbuffer and cause it to be corrupted because the ringbuffer is not multi-writer safe. Doing invoke from the thread itself is usually done to flush things out so we really only need to flush the ringbuffer and call the callback. See #1451
2021-07-26 11:39:48 +02:00
item->block = block;
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
item->user_data = user_data;
support: use defines for alignment
2022-01-03 11:14:15 +01:00
item->item_size = SPA_ROUND_UP_N(sizeof(struct invoke_item) + size, ITEM_ALIGN);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
move some debug to fastpath
2022-03-28 16:25:00 +02:00
spa_log_trace_fp(impl->log, "%p: add item %p filled:%d", impl, item, filled);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
loop: improve invoke avail check First calculate the size of the aligned payload and then check if we can fit this aligned payload in the remaining space in the ringbuffer. Otherwise we might be able to fit the item + payload in the remaining space but then place the alignment bytes at the begginning, which would break alignment of the next invoke_item struct.
2021-07-19 10:12:15 +02:00
if (l0 >= item->item_size) {
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
/* item + size fit in current ringbuffer idx */
spa/buffer: rename SPA_MEMBER to SPA_PTROFF SPA_MEMBER is misleading, all we're doing here is pointer+offset and a type-casting the result. Rename to SPA_PTROFF which is more expressive (and has the same number of characters so we don't need to re-indent).
2021-05-06 13:41:44 +10:00
item->data = SPA_PTROFF(item, sizeof(struct invoke_item), void);
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
if (l0 < sizeof(struct invoke_item) + item->item_size) {
/* not enough space for next invoke_item, fill up till the end
* so that the next item will be at the start */
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
item->item_size = l0;
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
}
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
} else {
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
/* item does not fit, place the invoke_item at idx and start the
* data at the start of the ringbuffer */
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
item->data = impl->buffer_data;
support: use defines for alignment
2022-01-03 11:14:15 +01:00
item->item_size = SPA_ROUND_UP_N(l0 + size, ITEM_ALIGN);
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
}
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
if (avail < item->item_size) {
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_warn(impl->log, "%p: queue full %d, need %zd", impl, avail,
loop: Fix crash because of overflow Also check if there is enough space to write the payload bytes. We check if there is enough space for the invoke_item structure first. Then we calculate how much bytes we need to use for the payload but we fail to check if we can actually write that much data, risking overwriting existing data from the ringbuffer and causing a crash later when we try to jump to invalid memory. Add some more comments.
2021-07-19 09:53:23 +02:00
item->item_size);
return -EPIPE;
}
loop: align buffer and invoke_items to 8 bytes To avoid unaligned access messages from sanitizer See #497
2020-12-21 20:46:13 +01:00
if (data && size > 0)
memcpy(item->data, data, size);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
spa_ringbuffer_write_update(&impl->buffer, idx + item->item_size);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: avoid corruption of ringbuffer The ringbuffer can't be written to from multiple threads. When both the main loop and data thread do _invoke, they both write to the ringbuffer and cause it to be corrupted because the ringbuffer is not multi-writer safe. Doing invoke from the thread itself is usually done to flush things out so we really only need to flush the ringbuffer and call the callback. See #1451
2021-07-26 11:39:48 +02:00
loop_signal_event(impl, impl->wakeup);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: avoid corruption of ringbuffer The ringbuffer can't be written to from multiple threads. When both the main loop and data thread do _invoke, they both write to the ringbuffer and cause it to be corrupted because the ringbuffer is not multi-writer safe. Doing invoke from the thread itself is usually done to flush things out so we really only need to flush the ringbuffer and call the callback. See #1451
2021-07-26 11:39:48 +02:00
if (block) {
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
uint64_t count = 1;
loop: blocking wait Release the locks before waiting.
2018-04-19 22:01:18 +02:00
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
spa_loop_control_hook_before(&impl->hooks_list);
loop: blocking wait Release the locks before waiting.
2018-04-19 22:01:18 +02:00
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
if ((res = spa_system_eventfd_read(impl->system, impl->ack_fd, &count)) < 0)
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(impl->log, "%p: failed to read event fd:%d: %s",
impl, impl->ack_fd, spa_strerror(res));
port: work on port commands
2017-11-14 15:44:48 +01:00
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
spa_loop_control_hook_after(&impl->hooks_list);
loop: blocking wait Release the locks before waiting.
2018-04-19 22:01:18 +02:00
loop: always place the invoke item in the queue Always place the invoke item in the queue and then either signal the other thread or flush the queue when not already flushing.
2020-11-16 15:16:20 +01:00
res = item->res;
}
else {
if (seq != SPA_ID_INVALID)
res = SPA_RESULT_RETURN_ASYNC(seq);
else
res = 0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
return res;
}
Improve loop callbacks Pass just one data item to the callbacks. Add properties to port. Add user data to link Handle autolink with multiple ports More work on jack support
2017-08-11 19:16:30 +02:00
static void wakeup_func(void *data, uint64_t count)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
struct impl *impl = data;
loop: always wake up blocking items We should always wake up the blocking items if we scheduled the item.
2020-11-13 16:50:23 +01:00
flush_items(impl);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int loop_get_fd(void *object)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
return impl->poll_fd;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static void
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
loop_add_hook(void *object,
struct spa_hook *hook,
const struct spa_loop_control_hooks *hooks,
void *data)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
Move listeners to spa and rename to hooks The listeners are generally useful in spa, move it there and rename to hooks. Implement loop hooks with it. Fix some cleanup issues in stream and remote
2017-08-08 16:56:29 +02:00
spa_hook_list_append(&impl->hooks_list, hook, hooks, data);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static void loop_enter(void *object)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
support: loop_enter/leave hardening This commit adds a counter for loop_enter/leave and checks: - consecutive enter are used on the same thread - leave is used on the same thread as enter - at destruction, the enter_count must be 0
2022-02-08 10:58:36 +01:00
pthread_t thread_id = pthread_self();
if (impl->enter_count == 0) {
spa_return_if_fail(impl->thread == 0);
impl->thread = thread_id;
impl->enter_count = 1;
} else {
spa_return_if_fail(impl->enter_count > 0);
spa_return_if_fail(impl->thread == thread_id);
impl->enter_count++;
}
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_trace(impl->log, "%p: enter %lu", impl, impl->thread);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static void loop_leave(void *object)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
support: loop_enter/leave hardening This commit adds a counter for loop_enter/leave and checks: - consecutive enter are used on the same thread - leave is used on the same thread as enter - at destruction, the enter_count must be 0
2022-02-08 10:58:36 +01:00
pthread_t thread_id = pthread_self();
spa_return_if_fail(impl->enter_count > 0);
spa_return_if_fail(impl->thread == thread_id);
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_trace(impl->log, "%p: leave %lu", impl, impl->thread);
support: loop_enter/leave hardening This commit adds a counter for loop_enter/leave and checks: - consecutive enter are used on the same thread - leave is used on the same thread as enter - at destruction, the enter_count must be 0
2022-02-08 10:58:36 +01:00
loop: clean polling flag when leaving the loop When we leave the last recursive enter of the loop, clear the polling flag. It might be possible that it was not cleared because the loop might have been killed with pthread_kill. In any case, the _leave calls need to be made in this case as well. This fixes issues when jack clients stop because it triggers and assert because the polling flag is still active when the object is cleared. See !1171
2022-03-07 10:27:22 +01:00
if (--impl->enter_count == 0) {
support: loop_enter/leave hardening This commit adds a counter for loop_enter/leave and checks: - consecutive enter are used on the same thread - leave is used on the same thread as enter - at destruction, the enter_count must be 0
2022-02-08 10:58:36 +01:00
impl->thread = 0;
loop: flush items before stopping Before leaving the loop, flush out any pending items in the invoke queue. See #2631
2022-08-09 20:38:06 +02:00
flush_items(impl);
loop: clean polling flag when leaving the loop When we leave the last recursive enter of the loop, clear the polling flag. It might be possible that it was not cleared because the loop might have been killed with pthread_kill. In any case, the _leave calls need to be made in this case as well. This fixes issues when jack clients stop because it triggers and assert because the polling flag is still active when the object is cleared. See !1171
2022-03-07 10:27:22 +01:00
impl->polling = false;
}
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
static inline void free_source(struct source_impl *s)
{
detach_source(&s->source);
free(s);
}
Revert "loop: remove destroy list" This reverts commit c474846c42967c44db069a23b76a29da6f496f33. In addition, `s->loop` is also checked before dispatching a source. The destroy list is needed in the presence of threads. The issue is that a source may be destroyed between `epoll_wait()` returning and thread loop lock being acquired. If this source is active, then a use-after-free will be triggered when the thread loop acquires the lock and starts dispatching the sources. thread 1 thread 2 ---------- ---------- loop_iterate spa_loop_control_hook_before // release lock pw_thread_loop_lock spa_system_pollfd_wait // assume it returns with source A pw_loop_destroy_source(..., A) // frees storage of A pw_thread_loop_unlock spa_loop_control_hook_after // acquire the lock for (...) { struct spa_source *s = ep[i].data; s->rmask = ep[i].events; // use-after-free if `s` refers to // the previously freed `A` Fixes #2147
2022-02-18 18:36:36 +01:00
static inline void process_destroy(struct impl *impl)
{
struct source_impl *source, *tmp;
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
Revert "loop: remove destroy list" This reverts commit c474846c42967c44db069a23b76a29da6f496f33. In addition, `s->loop` is also checked before dispatching a source. The destroy list is needed in the presence of threads. The issue is that a source may be destroyed between `epoll_wait()` returning and thread loop lock being acquired. If this source is active, then a use-after-free will be triggered when the thread loop acquires the lock and starts dispatching the sources. thread 1 thread 2 ---------- ---------- loop_iterate spa_loop_control_hook_before // release lock pw_thread_loop_lock spa_system_pollfd_wait // assume it returns with source A pw_loop_destroy_source(..., A) // frees storage of A pw_thread_loop_unlock spa_loop_control_hook_after // acquire the lock for (...) { struct spa_source *s = ep[i].data; s->rmask = ep[i].events; // use-after-free if `s` refers to // the previously freed `A` Fixes #2147
2022-02-18 18:36:36 +01:00
spa_list_for_each_safe(source, tmp, &impl->destroy_list, link)
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
free_source(source);
Revert "loop: remove destroy list" This reverts commit c474846c42967c44db069a23b76a29da6f496f33. In addition, `s->loop` is also checked before dispatching a source. The destroy list is needed in the presence of threads. The issue is that a source may be destroyed between `epoll_wait()` returning and thread loop lock being acquired. If this source is active, then a use-after-free will be triggered when the thread loop acquires the lock and starts dispatching the sources. thread 1 thread 2 ---------- ---------- loop_iterate spa_loop_control_hook_before // release lock pw_thread_loop_lock spa_system_pollfd_wait // assume it returns with source A pw_loop_destroy_source(..., A) // frees storage of A pw_thread_loop_unlock spa_loop_control_hook_after // acquire the lock for (...) { struct spa_source *s = ep[i].data; s->rmask = ep[i].events; // use-after-free if `s` refers to // the previously freed `A` Fixes #2147
2022-02-18 18:36:36 +01:00
spa_list_init(&impl->destroy_list);
}
spa: support: loop: handle cancellation better Register a pthread cleanup handler to guarantee that `spa_source::{priv, rmask}` are cleared even if the thread is cancelled while the loop is dispatching. This is necessary, otherwise `spa_source::priv` could point to the stack of the cancelled thread, which will lead to problems like this later: Program terminated with signal SIGSEGV, Segmentation fault. #0 0x00007f846b025be2 in detach_source (source=0x7f845f435f60) at ../spa/plugins/support/loop.c:144 144 e->data = NULL; [Current thread is 1 (LWP 5274)] (gdb) p e $1 = (struct spa_poll_event *) 0x7f845e297820 (gdb) bt #0 0x00007f846b025be2 in detach_source (source=0x7f845f435f60) at ../spa/plugins/support/loop.c:144 #1 0x00007f846b0276ad in free_source (s=0x7f845f435f60) at ../spa/plugins/support/loop.c:359 #2 0x00007f846b02a453 in loop_destroy_source (object=0x7f845f3af478, source=0x7f845f435f60) at ../spa/plugins/support/loop.c:786 #3 0x00007f846b02a886 in impl_clear (handle=0x7f845f3af478) at ../spa/plugins/support/loop.c:859 #4 0x00007f846b172f40 in unref_handle (handle=0x7f845f3af450) at ../src/pipewire/pipewire.c:211 #5 0x00007f846b173579 in pw_unload_spa_handle (handle=0x7f845f3af478) at ../src/pipewire/pipewire.c:346 #6 0x00007f846b15a761 in pw_loop_destroy (loop=0x7f845f434e30) at ../src/pipewire/loop.c:159 #7 0x00007f846b135d8e in pw_data_loop_destroy (loop=0x7f845f434cb0) at ../src/pipewire/data-loop.c:166 #8 0x00007f846b12c31c in pw_context_destroy (context=0x7f845f41c690) at ../src/pipewire/context.c:485 #9 0x00007f846b3ddf9e in jack_client_close (client=0x7f845f3c1030) at ../pipewire-jack/src/pipewire-jack.c:3481 ...
2022-06-01 16:36:56 +02:00
struct cancellation_handler_data {
struct spa_poll_event *ep;
int ep_count;
};
static void cancellation_handler(void *closure)
{
const struct cancellation_handler_data *data = closure;
for (int i = 0; i < data->ep_count; i++) {
struct spa_source *s = data->ep[i].data;
if (SPA_LIKELY(s)) {
s->rmask = 0;
s->priv = NULL;
}
}
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static int loop_iterate(void *object, int timeout)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
support: also protect against recursive invocations Add an extra private field to the source to store the pollevent of the current iteration. This changes ABI but it seems an embedded source is not used outside of our own plugins and the unit test doesn't test this ABI case. Whenever a source is removed, we can set the data field of the pollevent to NULL so that it won't be handled in any iteration anymore. Avoid dispatching the same event multiple times when doing recursive iterations. Add some more unit tests for this. Fixes #2114
2022-02-08 17:21:10 +01:00
struct spa_poll_event ep[MAX_EP], *e;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int i, nfds;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: add `polling` flag Store whether or not the loop is currently polling, i.e. calling `spa_system_pollfd_wait()`.
2022-02-19 11:44:04 +01:00
impl->polling = true;
loop: simplify before and after events Because the signal can't be removed from the callback we can simply iterate backwards and then forwards. The first added hook (the unlock/lock pair) is called last before going into the poll and first when leaving. This executes all other callbacks inside a locked situation. And removing them with the lock is not going to cause problems.
2020-09-16 13:20:19 +02:00
spa_loop_control_hook_before(&impl->hooks_list);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: get array size using macro
2022-02-21 17:28:43 +01:00
nfds = spa_system_pollfd_wait(impl->system, impl->poll_fd, ep, SPA_N_ELEMENTS(ep), timeout);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: simplify before and after events Because the signal can't be removed from the callback we can simply iterate backwards and then forwards. The first added hook (the unlock/lock pair) is called last before going into the poll and first when leaving. This executes all other callbacks inside a locked situation. And removing them with the lock is not going to cause problems.
2020-09-16 13:20:19 +02:00
spa_loop_control_hook_after(&impl->hooks_list);
spa: support: loop: add `polling` flag Store whether or not the loop is currently polling, i.e. calling `spa_system_pollfd_wait()`.
2022-02-19 11:44:04 +01:00
impl->polling = false;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: handle cancellation better Register a pthread cleanup handler to guarantee that `spa_source::{priv, rmask}` are cleared even if the thread is cancelled while the loop is dispatching. This is necessary, otherwise `spa_source::priv` could point to the stack of the cancelled thread, which will lead to problems like this later: Program terminated with signal SIGSEGV, Segmentation fault. #0 0x00007f846b025be2 in detach_source (source=0x7f845f435f60) at ../spa/plugins/support/loop.c:144 144 e->data = NULL; [Current thread is 1 (LWP 5274)] (gdb) p e $1 = (struct spa_poll_event *) 0x7f845e297820 (gdb) bt #0 0x00007f846b025be2 in detach_source (source=0x7f845f435f60) at ../spa/plugins/support/loop.c:144 #1 0x00007f846b0276ad in free_source (s=0x7f845f435f60) at ../spa/plugins/support/loop.c:359 #2 0x00007f846b02a453 in loop_destroy_source (object=0x7f845f3af478, source=0x7f845f435f60) at ../spa/plugins/support/loop.c:786 #3 0x00007f846b02a886 in impl_clear (handle=0x7f845f3af478) at ../spa/plugins/support/loop.c:859 #4 0x00007f846b172f40 in unref_handle (handle=0x7f845f3af450) at ../src/pipewire/pipewire.c:211 #5 0x00007f846b173579 in pw_unload_spa_handle (handle=0x7f845f3af478) at ../src/pipewire/pipewire.c:346 #6 0x00007f846b15a761 in pw_loop_destroy (loop=0x7f845f434e30) at ../src/pipewire/loop.c:159 #7 0x00007f846b135d8e in pw_data_loop_destroy (loop=0x7f845f434cb0) at ../src/pipewire/data-loop.c:166 #8 0x00007f846b12c31c in pw_context_destroy (context=0x7f845f41c690) at ../src/pipewire/context.c:485 #9 0x00007f846b3ddf9e in jack_client_close (client=0x7f845f3c1030) at ../pipewire-jack/src/pipewire-jack.c:3481 ...
2022-06-01 16:36:56 +02:00
struct cancellation_handler_data cdata = { ep, nfds };
pthread_cleanup_push(cancellation_handler, &cdata);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
/* first we set all the rmasks, then call the callbacks. The reason is that
* some callback might also want to look at other sources it manages and
* can then reset the rmask to suppress the callback */
for (i = 0; i < nfds; i++) {
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
struct spa_source *s = ep[i].data;
spa: support: loop: assert source's loop when dispatching
2022-03-06 14:56:29 +01:00
spa_assert(s->loop == &impl->loop);
support: also protect against recursive invocations Add an extra private field to the source to store the pollevent of the current iteration. This changes ABI but it seems an embedded source is not used outside of our own plugins and the unit test doesn't test this ABI case. Whenever a source is removed, we can set the data field of the pollevent to NULL so that it won't be handled in any iteration anymore. Avoid dispatching the same event multiple times when doing recursive iterations. Add some more unit tests for this. Fixes #2114
2022-02-08 17:21:10 +01:00
s->rmask = ep[i].events;
/* already active in another iteration of the loop,
* remove it from that iteration */
if (SPA_UNLIKELY(e = s->priv))
e->data = NULL;
s->priv = &ep[i];
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
if (SPA_UNLIKELY(!spa_list_is_empty(&impl->destroy_list)))
process_destroy(impl);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
for (i = 0; i < nfds; i++) {
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
struct spa_source *s = ep[i].data;
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
if (SPA_LIKELY(s && s->rmask))
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
s->func(s);
spa: support: loop: reset rmask after dispatch Reset the `rmask` of the sources to zero after dispatching the callbacks. This way the sources are always as up-to-date as possible.
2022-02-19 09:42:49 +01:00
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
spa: support: loop: handle cancellation better Register a pthread cleanup handler to guarantee that `spa_source::{priv, rmask}` are cleared even if the thread is cancelled while the loop is dispatching. This is necessary, otherwise `spa_source::priv` could point to the stack of the cancelled thread, which will lead to problems like this later: Program terminated with signal SIGSEGV, Segmentation fault. #0 0x00007f846b025be2 in detach_source (source=0x7f845f435f60) at ../spa/plugins/support/loop.c:144 144 e->data = NULL; [Current thread is 1 (LWP 5274)] (gdb) p e $1 = (struct spa_poll_event *) 0x7f845e297820 (gdb) bt #0 0x00007f846b025be2 in detach_source (source=0x7f845f435f60) at ../spa/plugins/support/loop.c:144 #1 0x00007f846b0276ad in free_source (s=0x7f845f435f60) at ../spa/plugins/support/loop.c:359 #2 0x00007f846b02a453 in loop_destroy_source (object=0x7f845f3af478, source=0x7f845f435f60) at ../spa/plugins/support/loop.c:786 #3 0x00007f846b02a886 in impl_clear (handle=0x7f845f3af478) at ../spa/plugins/support/loop.c:859 #4 0x00007f846b172f40 in unref_handle (handle=0x7f845f3af450) at ../src/pipewire/pipewire.c:211 #5 0x00007f846b173579 in pw_unload_spa_handle (handle=0x7f845f3af478) at ../src/pipewire/pipewire.c:346 #6 0x00007f846b15a761 in pw_loop_destroy (loop=0x7f845f434e30) at ../src/pipewire/loop.c:159 #7 0x00007f846b135d8e in pw_data_loop_destroy (loop=0x7f845f434cb0) at ../src/pipewire/data-loop.c:166 #8 0x00007f846b12c31c in pw_context_destroy (context=0x7f845f41c690) at ../src/pipewire/context.c:485 #9 0x00007f846b3ddf9e in jack_client_close (client=0x7f845f3c1030) at ../pipewire-jack/src/pipewire-jack.c:3481 ...
2022-06-01 16:36:56 +02:00
pthread_cleanup_pop(true);
Revert "loop: remove destroy list" This reverts commit c474846c42967c44db069a23b76a29da6f496f33. In addition, `s->loop` is also checked before dispatching a source. The destroy list is needed in the presence of threads. The issue is that a source may be destroyed between `epoll_wait()` returning and thread loop lock being acquired. If this source is active, then a use-after-free will be triggered when the thread loop acquires the lock and starts dispatching the sources. thread 1 thread 2 ---------- ---------- loop_iterate spa_loop_control_hook_before // release lock pw_thread_loop_lock spa_system_pollfd_wait // assume it returns with source A pw_loop_destroy_source(..., A) // frees storage of A pw_thread_loop_unlock spa_loop_control_hook_after // acquire the lock for (...) { struct spa_source *s = ep[i].data; s->rmask = ep[i].events; // use-after-free if `s` refers to // the previously freed `A` Fixes #2147
2022-02-18 18:36:36 +01:00
loop: return number of dispatched fds and update docs
2018-06-01 11:16:53 +02:00
return nfds;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static void source_io_func(struct spa_source *source)
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
spa_log_trace_fp(s->impl->log, "%p: io %08x", s, source->rmask);
s->func.io(source->data, source->fd, source->rmask);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static struct spa_source *loop_add_io(void *object,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
int fd,
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
uint32_t mask,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
bool close, spa_source_io_func_t func, void *data)
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct source_impl *source;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source = calloc(1, sizeof(struct source_impl));
if (source == NULL)
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.func = source_io_func;
source->source.data = data;
source->source.fd = fd;
source->source.mask = mask;
source->impl = impl;
source->close = close;
source->func.io = func;
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
if ((res = loop_add_source(impl, &source->source)) < 0) {
if (res != -EPERM)
goto error_exit_free;
/* file fds (stdin/stdout/...) give EPERM in epoll. Those fds always
* return from epoll with the mask set, so we can handle this with
* an idle source */
source->source.rmask = mask;
source->fallback = spa_loop_utils_add_idle(&impl->utils,
mask & (SPA_IO_IN | SPA_IO_OUT) ? true : false,
(spa_source_idle_func_t) source_io_func, source);
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_trace(impl->log, "%p: adding fallback %p", impl,
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
source->fallback);
}
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_list_insert(&impl->source_list, &source->link);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
return &source->source;
error_exit_free:
free(source);
errno = -res;
error_exit:
return NULL;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
static int loop_update_io(void *object, struct spa_source *source, uint32_t mask)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
struct impl *impl = object;
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
int res;
spa: support: loop: print previous mask when updating Print the previous event mask in `loop_update_io()` as well as the new one.
2022-02-19 19:38:08 +01:00
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa_assert(s->impl == object);
spa: support: loop: assert source type
2022-02-19 19:17:42 +01:00
spa_assert(source->func == source_io_func);
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa: support: loop: print previous mask when updating Print the previous event mask in `loop_update_io()` as well as the new one.
2022-02-19 19:38:08 +01:00
spa_log_trace(impl->log, "%p: update %08x -> %08x", s, source->mask, mask);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->mask = mask;
spa: support: loop: print previous mask when updating Print the previous event mask in `loop_update_io()` as well as the new one.
2022-02-19 19:38:08 +01:00
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
if (s->fallback)
res = spa_loop_utils_enable_idle(&impl->utils, s->fallback,
mask & (SPA_IO_IN | SPA_IO_OUT) ? true : false);
else
res = loop_update_source(object, source);
return res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static void source_idle_func(struct spa_source *source)
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
s->func.idle(source->data);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
improve error handling Make sure we free properties we take ownership of. Add some more return values to functions that can fail.
2019-06-19 18:15:04 +02:00
static int loop_enable_idle(void *object, struct spa_source *source, bool enabled)
loop: cleanups
2019-05-23 15:11:49 +02:00
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
improve error handling Make sure we free properties we take ownership of. Add some more return values to functions that can fail.
2019-06-19 18:15:04 +02:00
int res = 0;
loop: cleanups
2019-05-23 15:11:49 +02:00
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa_assert(s->impl == object);
spa: support: loop: assert source type
2022-02-19 19:17:42 +01:00
spa_assert(source->func == source_idle_func);
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if (enabled && !s->enabled) {
if ((res = spa_system_eventfd_write(s->impl->system, source->fd, 1)) < 0)
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(s->impl->log, "%p: failed to write idle fd:%d: %s",
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
source, source->fd, spa_strerror(res));
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
} else if (!enabled && s->enabled) {
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
uint64_t count;
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if ((res = spa_system_eventfd_read(s->impl->system, source->fd, &count)) < 0)
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(s->impl->log, "%p: failed to read idle fd:%d: %s",
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
source, source->fd, spa_strerror(res));
loop: cleanups
2019-05-23 15:11:49 +02:00
}
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
s->enabled = enabled;
improve error handling Make sure we free properties we take ownership of. Add some more return values to functions that can fail.
2019-06-19 18:15:04 +02:00
return res;
loop: cleanups
2019-05-23 15:11:49 +02:00
}
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static struct spa_source *loop_add_idle(void *object,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
bool enabled, spa_source_idle_func_t func, void *data)
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct source_impl *source;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source = calloc(1, sizeof(struct source_impl));
if (source == NULL)
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit;
if ((res = spa_system_eventfd_create(impl->system, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK)) < 0)
goto error_exit_free;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.func = source_idle_func;
source->source.data = data;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
source->source.fd = res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->impl = impl;
source->close = true;
source->source.mask = SPA_IO_IN;
source->func.idle = func;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
if ((res = loop_add_source(impl, &source->source)) < 0)
goto error_exit_close;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_list_insert(&impl->source_list, &source->link);
if (enabled)
loop: cleanups
2019-05-23 15:11:49 +02:00
loop_enable_idle(impl, &source->source, true);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
return &source->source;
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit_close:
spa_system_close(impl->system, source->source.fd);
error_exit_free:
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
free(source);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
errno = -res;
error_exit:
return NULL;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static void source_event_func(struct spa_source *source)
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
loop: initialize some variables Just in case the read fails.
2021-03-27 19:23:34 +01:00
uint64_t count = 0;
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if ((res = spa_system_eventfd_read(s->impl->system, source->fd, &count)) < 0)
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(s->impl->log, "%p: failed to read event fd:%d: %s",
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
source, source->fd, spa_strerror(res));
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
s->func.event(source->data, count);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static struct spa_source *loop_add_event(void *object,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_source_event_func_t func, void *data)
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct source_impl *source;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source = calloc(1, sizeof(struct source_impl));
if (source == NULL)
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit;
if ((res = spa_system_eventfd_create(impl->system, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK)) < 0)
goto error_exit_free;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.func = source_event_func;
source->source.data = data;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
source->source.fd = res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.mask = SPA_IO_IN;
source->impl = impl;
source->close = true;
source->func.event = func;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
if ((res = loop_add_source(impl, &source->source)) < 0)
goto error_exit_close;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_list_insert(&impl->source_list, &source->link);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
return &source->source;
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit_close:
spa_system_close(impl->system, source->source.fd);
error_exit_free:
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
free(source);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
errno = -res;
error_exit:
return NULL;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
improve error handling Make sure we free properties we take ownership of. Add some more return values to functions that can fail.
2019-06-19 18:15:04 +02:00
static int loop_signal_event(void *object, struct spa_source *source)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa_assert(s->impl == object);
spa: support: loop: assert source type
2022-02-19 19:17:42 +01:00
spa_assert(source->func == source_event_func);
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if (SPA_UNLIKELY((res = spa_system_eventfd_write(s->impl->system, source->fd, 1)) < 0))
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(s->impl->log, "%p: failed to write event fd:%d: %s",
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
source, source->fd, spa_strerror(res));
improve error handling Make sure we free properties we take ownership of. Add some more return values to functions that can fail.
2019-06-19 18:15:04 +02:00
return res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static void source_timer_func(struct spa_source *source)
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
loop: initialize some variables Just in case the read fails.
2021-03-27 19:23:34 +01:00
uint64_t expirations = 0;
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if (SPA_UNLIKELY((res = spa_system_timerfd_read(s->impl->system,
sprinkly SPA_LIKELY/UNLIKELY around
2020-03-16 12:52:28 +01:00
source->fd, &expirations)) < 0))
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(s->impl->log, "%p: failed to read timer fd:%d: %s",
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
source, source->fd, spa_strerror(res));
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
s->func.timer(source->data, expirations);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static struct spa_source *loop_add_timer(void *object,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_source_timer_func_t func, void *data)
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct source_impl *source;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source = calloc(1, sizeof(struct source_impl));
if (source == NULL)
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit;
if ((res = spa_system_timerfd_create(impl->system, CLOCK_MONOTONIC,
SPA_FD_CLOEXEC | SPA_FD_NONBLOCK)) < 0)
goto error_exit_free;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.func = source_timer_func;
source->source.data = data;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
source->source.fd = res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.mask = SPA_IO_IN;
source->impl = impl;
source->close = true;
source->func.timer = func;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
if ((res = loop_add_source(impl, &source->source)) < 0)
goto error_exit_close;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_list_insert(&impl->source_list, &source->link);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
return &source->source;
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit_close:
spa_system_close(impl->system, source->source.fd);
error_exit_free:
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
free(source);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
errno = -res;
error_exit:
return NULL;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static int
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
loop_update_timer(void *object, struct spa_source *source,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct timespec *value, struct timespec *interval, bool absolute)
{
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct itimerspec its;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int flags = 0, res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa_assert(s->impl == object);
spa: support: loop: assert source type
2022-02-19 19:17:42 +01:00
spa_assert(source->func == source_timer_func);
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_zero(its);
sprinkly SPA_LIKELY/UNLIKELY around
2020-03-16 12:52:28 +01:00
if (SPA_LIKELY(value)) {
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
its.it_value = *value;
} else if (interval) {
its.it_value = *interval;
absolute = true;
}
sprinkly SPA_LIKELY/UNLIKELY around
2020-03-16 12:52:28 +01:00
if (SPA_UNLIKELY(interval))
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
its.it_interval = *interval;
sprinkly SPA_LIKELY/UNLIKELY around
2020-03-16 12:52:28 +01:00
if (SPA_LIKELY(absolute))
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
flags |= SPA_FD_TIMER_ABSTIME;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
if (SPA_UNLIKELY((res = spa_system_timerfd_settime(s->impl->system, source->fd, flags, &its, NULL)) < 0))
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
return res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static void source_signal_func(struct spa_source *source)
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
loop: initialize some variables Just in case the read fails.
2021-03-27 19:23:34 +01:00
int res, signal_number = 0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if ((res = spa_system_signalfd_read(s->impl->system, source->fd, &signal_number)) < 0)
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
spa_log_warn(s->impl->log, "%p: failed to read signal fd:%d: %s",
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
source, source->fd, spa_strerror(res));
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
s->func.signal(source->data, signal_number);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static struct spa_source *loop_add_signal(void *object,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
int signal_number,
spa_source_signal_func_t func, void *data)
{
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
struct impl *impl = object;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
struct source_impl *source;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source = calloc(1, sizeof(struct source_impl));
if (source == NULL)
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit;
if ((res = spa_system_signalfd_create(impl->system,
signal_number, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK)) < 0)
goto error_exit_free;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.func = source_signal_func;
source->source.data = data;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
source->source.fd = res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
source->source.mask = SPA_IO_IN;
source->impl = impl;
source->close = true;
source->func.signal = func;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
if ((res = loop_add_source(impl, &source->source)) < 0)
goto error_exit_close;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_list_insert(&impl->source_list, &source->link);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
return &source->source;
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit_close:
spa_system_close(impl->system, source->source.fd);
error_exit_free:
improve error handling Set errno for functions returning NULL if relevant. Propagate errno and result codes better. Handle more error cases.
2019-06-07 10:11:23 +02:00
free(source);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
errno = -res;
error_exit:
return NULL;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static void loop_destroy_source(void *object, struct spa_source *source)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
struct source_impl *s = SPA_CONTAINER_OF(source, struct source_impl, source);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: add some invariant assertions
2022-02-19 14:12:44 +01:00
spa_assert(s->impl == object);
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
spa_log_trace(s->impl->log, "%p ", s);
loop: handle file fd with eventfd epoll return EPERM for file fds like stdin/stdout because they are always ready for IO. use an idle source to handle these cases.
2020-04-14 18:05:45 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
spa_list_remove(&s->link);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if (s->fallback)
loop_destroy_source(s->impl, s->fallback);
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
else
remove_from_poll(s->impl, source);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa: support: loop: rename variables It may be a little confusing that both the loop object and the `source_impl` objects are referred to with variables named `impl`. For this reason, rename all source_impl objects named `impl` to `s`.
2022-02-21 16:24:34 +01:00
if (source->fd != -1 && s->close) {
spa_system_close(s->impl->system, source->fd);
Move listeners to spa and rename to hooks The listeners are generally useful in spa, move it there and rename to hooks. Implement loop hooks with it. Fix some cleanup issues in stream and remote
2017-08-08 16:56:29 +02:00
source->fd = -1;
}
spa: support: loop: fix use-after-free when loop is reentered The core of the issue is the following: what happens if an active source is destroyed before it could be dispatched? For loop-managed sources (`struct source_impl`) this was addressed by storing all destroyed sources in a list, and only freeing them after dispatching has been finished. (0eb73f0f06a2e40362990080007db295141f6f1f) This approach works for both strictly single-threaded and `pw_thread_loop` loops assuming the loop is not reentered. However, if the loop is reentered, there can still be issues. Assume that in one iteration sources A and B are active, and returned from the system call, and source B is destroyed before the loop starts dispatching. Consider what happens when "A" is dispatched first, and it reenters the loop with timeout 0. Imagine there are no new events, so `loop_iterate()` will immediately return, but it will first destroy everything in the destroy list (this is done at the end of `loop_iterate()`). And herein lies the problem. In the previous iteration, there exists a `spa_poll_event` object which points to source "B", but that has just been destroyed at the end of the recursive iteration. This will trigger a use-after-free once the previous iteration inspects it. Fix that by processing the destroy list right after first processing the returned `spa_poll_event` objects, and "detach" the source from the loop and its iterations in `process_destroy()` before the source is destroyed. See #2114 #2147
2022-02-19 13:31:01 +01:00
if (!s->impl->polling)
free_source(s);
else
spa_list_insert(&s->impl->destroy_list, &s->link);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct spa_loop_methods impl_loop = {
SPA_VERSION_LOOP_METHODS,
.add_source = loop_add_source,
.update_source = loop_update_source,
.remove_source = loop_remove_source,
.invoke = loop_invoke,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct spa_loop_control_methods impl_loop_control = {
SPA_VERSION_LOOP_CONTROL_METHODS,
.get_fd = loop_get_fd,
.add_hook = loop_add_hook,
.enter = loop_enter,
.leave = loop_leave,
.iterate = loop_iterate,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
static const struct spa_loop_utils_methods impl_loop_utils = {
SPA_VERSION_LOOP_UTILS_METHODS,
.add_io = loop_add_io,
.update_io = loop_update_io,
.add_idle = loop_add_idle,
.enable_idle = loop_enable_idle,
.add_event = loop_add_event,
.signal_event = loop_signal_event,
.add_timer = loop_add_timer,
.update_timer = loop_update_timer,
.add_signal = loop_add_signal,
.destroy_source = loop_destroy_source,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
static int impl_get_interface(struct spa_handle *handle, const char *type, void **interface)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
struct impl *impl;
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(handle != NULL, -EINVAL);
spa_return_val_if_fail(interface != NULL, -EINVAL);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
impl = (struct impl *) handle;
treewide: replace strcmp() == 0 with spa_streq() This change is only done in source files for now, header files will be done separately.
2021-05-18 11:36:13 +10:00
if (spa_streq(type, SPA_TYPE_INTERFACE_Loop))
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*interface = &impl->loop;
treewide: replace strcmp() == 0 with spa_streq() This change is only done in source files for now, header files will be done separately.
2021-05-18 11:36:13 +10:00
else if (spa_streq(type, SPA_TYPE_INTERFACE_LoopControl))
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*interface = &impl->control;
treewide: replace strcmp() == 0 with spa_streq() This change is only done in source files for now, header files will be done separately.
2021-05-18 11:36:13 +10:00
else if (spa_streq(type, SPA_TYPE_INTERFACE_LoopUtils))
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
*interface = &impl->utils;
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
else
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return -ENOENT;
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static int impl_clear(struct spa_handle *handle)
{
struct impl *impl;
use _list_consume to destroy objects
2018-09-25 13:05:13 +02:00
struct source_impl *source;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(handle != NULL, -EINVAL);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
impl = (struct impl *) handle;
loop: don't assert in cleanup Just issue a warning instead of asserting. Firefox does strange things to the fds that make things crash otherwise.
2022-11-08 15:45:55 +01:00
if (impl->enter_count != 0 || impl->polling)
spa_log_warn(impl->log, "%p: loop is entered %d times polling:%d",
impl, impl->enter_count, impl->polling);
spa: support: loop: assert loop is not polling when destroyed Assert that the loop is not polling when `impl_clear()` is called.
2022-03-05 22:00:18 +01:00
use _list_consume to destroy objects
2018-09-25 13:05:13 +02:00
spa_list_consume(source, &impl->source_list, link)
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
loop_destroy_source(impl, &source->source);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
support: abstract some system functions Make a new API to hide some the implementation of eventfd, timerfd and signalfd along with clock and read/write/ioctl/close functions. We would like to have plugins use the abstractions so that we can switch them to something else when needed.
2019-06-04 17:07:34 +02:00
spa_system_close(impl->system, impl->ack_fd);
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
spa_system_close(impl->system, impl->poll_fd);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
handle: make method to get size
2018-04-09 10:06:17 +02:00
static size_t
impl_get_size(const struct spa_handle_factory *factory,
const struct spa_dict *params)
{
return sizeof(struct impl);
}
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
static int
impl_init(const struct spa_handle_factory *factory,
struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
{
struct impl *impl;
improve error handling
2019-06-18 10:47:12 -04:00
int res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(handle != NULL, -EINVAL);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
handle->get_interface = impl_get_interface;
handle->clear = impl_clear;
impl = (struct impl *) handle;
interface: add an interface struct The interface struct has the type,version and methods of the interface. Make spa interfaces extend from spa_interface and make a separate structure for the methods. Pass a generic void* as the first argument of methods, like we don in PipeWire. Bundle the methods + implementation in a versioned inteface and use that to invoke methods. This way we can do version checks on the methods. Make resource and proxy interfaces that we can can call. We can then make the core interfaces independent on proxy/resource and hide them in the lower layers. Add add_listener method to methods of core interfaces, just like SPA.
2019-05-20 16:11:23 +02:00
impl->loop.iface = SPA_INTERFACE_INIT(
SPA_TYPE_INTERFACE_Loop,
SPA_VERSION_LOOP,
&impl_loop, impl);
impl->control.iface = SPA_INTERFACE_INIT(
SPA_TYPE_INTERFACE_LoopControl,
SPA_VERSION_LOOP_CONTROL,
&impl_loop_control, impl);
impl->utils.iface = SPA_INTERFACE_INIT(
SPA_TYPE_INTERFACE_LoopUtils,
SPA_VERSION_LOOP_UTILS,
&impl_loop_utils, impl);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
impl->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log);
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_topic_init(impl->log, &log_topic);
Make interface types a string This is more in line with wayland and it allows us to create new interfaces in modules without having to add anything to the type enum. It also removes some lookups to map type_id to readable name in debug.
2019-12-19 13:15:10 +01:00
impl->system = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_System);
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
if (impl->system == NULL) {
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_error(impl->log, "%p: a System is needed", impl);
improve error handling
2019-06-18 10:47:12 -04:00
res = -EINVAL;
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit;
System: More work on making system functions pluggable Move the epoll functions to the system functions and make the loop use those. Use simple mask for events instead of enum. Add the used system api in pw_loop. Add System API to spa_support and use it where possible. Pass the system API used in the realtime loops in spa_support as well and use this in the realtime paths. Improve bootstrapping, load only the log and cpu interfaces because those can/need to be shared between instances. Let the core load the other interfaces. Add keys to configure the System and Loop implementations used in pw_loop.
2019-06-06 15:21:40 +02:00
}
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
if ((res = spa_system_pollfd_create(impl->system, SPA_FD_CLOEXEC)) < 0) {
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_error(impl->log, "%p: can't create pollfd: %s",
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
impl, spa_strerror(res));
goto error_exit;
improve error handling
2019-06-18 10:47:12 -04:00
}
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
impl->poll_fd = res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
spa_list_init(&impl->source_list);
Revert "loop: remove destroy list" This reverts commit c474846c42967c44db069a23b76a29da6f496f33. In addition, `s->loop` is also checked before dispatching a source. The destroy list is needed in the presence of threads. The issue is that a source may be destroyed between `epoll_wait()` returning and thread loop lock being acquired. If this source is active, then a use-after-free will be triggered when the thread loop acquires the lock and starts dispatching the sources. thread 1 thread 2 ---------- ---------- loop_iterate spa_loop_control_hook_before // release lock pw_thread_loop_lock spa_system_pollfd_wait // assume it returns with source A pw_loop_destroy_source(..., A) // frees storage of A pw_thread_loop_unlock spa_loop_control_hook_after // acquire the lock for (...) { struct spa_source *s = ep[i].data; s->rmask = ep[i].events; // use-after-free if `s` refers to // the previously freed `A` Fixes #2147
2022-02-18 18:36:36 +01:00
spa_list_init(&impl->destroy_list);
Move listeners to spa and rename to hooks The listeners are generally useful in spa, move it there and rename to hooks. Implement loop hooks with it. Fix some cleanup issues in stream and remote
2017-08-08 16:56:29 +02:00
spa_hook_list_init(&impl->hooks_list);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
support: use defines for alignment
2022-01-03 11:14:15 +01:00
impl->buffer_data = SPA_PTR_ALIGN(impl->buffer_mem, MAX_ALIGN, uint8_t);
Meta: rework ringbuffer meta ringbuffer: remove size and mask from the ringbuffer, we have that elsewhere in the user of the ringbuffer. Remove the buffer data offset and size fields and replace with a ringbuffer. We then have a ringbuffer in all buffer data, which simplifies things. We can now remove the ringbuffer metadata.
2017-11-15 17:25:36 +01:00
spa_ringbuffer_init(&impl->buffer);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
loop: cleanups
2019-05-23 15:11:49 +02:00
impl->wakeup = loop_add_event(impl, wakeup_func, impl);
improve error handling
2019-06-18 10:47:12 -04:00
if (impl->wakeup == NULL) {
res = -errno;
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_error(impl->log, "%p: can't create wakeup event: %m", impl);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
goto error_exit_free_poll;
improve error handling
2019-06-18 10:47:12 -04:00
}
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
if ((res = spa_system_eventfd_create(impl->system,
SPA_FD_EVENT_SEMAPHORE | SPA_FD_CLOEXEC)) < 0) {
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_error(impl->log, "%p: can't create ack event: %s",
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
impl, spa_strerror(res));
goto error_exit_free_wakeup;
improve error handling
2019-06-18 10:47:12 -04:00
}
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
impl->ack_fd = res;
spa: sprinkle more log topics into spa
2021-09-27 15:31:35 +10:00
spa_log_debug(impl->log, "%p: initialized", impl);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
return 0;
improve error handling
2019-06-18 10:47:12 -04:00
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit_free_wakeup:
improve error handling
2019-06-18 10:47:12 -04:00
loop_destroy_source(impl, impl->wakeup);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit_free_poll:
improve error handling
2019-06-18 10:47:12 -04:00
spa_system_close(impl->system, impl->poll_fd);
system: make system functions return error on error Return -errno from system functions instead of -1 in errors. This makes it easier to pass along the result without having to go to errno etc..
2019-06-20 17:31:29 +02:00
error_exit:
improve error handling
2019-06-18 10:47:12 -04:00
return res;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
static const struct spa_interface_info impl_interfaces[] = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
{SPA_TYPE_INTERFACE_Loop,},
{SPA_TYPE_INTERFACE_LoopControl,},
{SPA_TYPE_INTERFACE_LoopUtils,},
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
static int
impl_enum_interface_info(const struct spa_handle_factory *factory,
const struct spa_interface_info **info,
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
uint32_t *index)
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
{
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(info != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
if (*index >= SPA_N_ELEMENTS(impl_interfaces))
return 0;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
*info = &impl_interfaces[(*index)++];
return 1;
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
}
spa: don't use constructor attribute to register factories
2019-02-06 11:38:12 +01:00
const struct spa_handle_factory spa_support_loop_factory = {
Add versions to structures Use versions instead of size Remove user_data from callbacks, we can simply pass the callback struct.
2017-06-14 18:32:39 +02:00
SPA_VERSION_HANDLE_FACTORY,
names: add standard factory name definitions Define a set of standard factory names and document what they contain. This makes it possible to change the implementation by mapping the factory-name to a different shared library.
2019-06-21 13:31:34 +02:00
SPA_NAME_SUPPORT_LOOP,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
NULL,
handle: make method to get size
2018-04-09 10:06:17 +02:00
impl_get_size,
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
impl_init,
Add versions to structures Use versions instead of size Remove user_data from callbacks, we can simply pass the callback struct.
2017-06-14 18:32:39 +02:00
impl_enum_interface_info
loop: move to plugin Move the loop implementation to a plugin. Organize the hooks in a list so that we can add many.
2017-06-14 16:10:07 +02:00
};
Reference in a new issue Copy permalink