From 81c7dd4433dfe4f432f66d8a00abdb90994e24f0 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Tue, 4 Jun 2019 17:07:34 +0200 Subject: [PATCH] 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. --- spa/include/spa/meson.build | 1 + spa/include/spa/support/loop.h | 1 - spa/include/spa/support/system.h | 120 ++++++++++++ spa/include/spa/utils/type-info.h | 1 + spa/include/spa/utils/type.h | 1 + spa/plugins/support/loop.c | 89 ++++----- spa/plugins/support/meson.build | 3 +- spa/plugins/support/plugin.c | 8 +- spa/plugins/support/system.c | 300 ++++++++++++++++++++++++++++++ src/pipewire/core.c | 3 +- src/pipewire/node.c | 3 +- src/pipewire/pipewire.c | 12 +- 12 files changed, 492 insertions(+), 50 deletions(-) create mode 100644 spa/include/spa/support/system.h create mode 100644 spa/plugins/support/system.c diff --git a/spa/include/spa/meson.build b/spa/include/spa/meson.build index c079a1a2a..6e039c359 100644 --- a/spa/include/spa/meson.build +++ b/spa/include/spa/meson.build @@ -89,6 +89,7 @@ spa_support_headers = [ 'support/log-impl.h', 'support/loop.h', 'support/plugin.h', + 'support/system.h', ] install_headers(spa_support_headers, diff --git a/spa/include/spa/support/loop.h b/spa/include/spa/support/loop.h index e797ea6cf..1591f50b7 100644 --- a/spa/include/spa/support/loop.h +++ b/spa/include/spa/support/loop.h @@ -202,7 +202,6 @@ struct spa_loop_control_methods { #define spa_loop_control_leave(l) spa_loop_control_method_v(l,leave,0) #define spa_loop_control_iterate(l,...) spa_loop_control_method_r(l,iterate,0,__VA_ARGS__) - typedef void (*spa_source_io_func_t) (void *data, int fd, enum spa_io mask); typedef void (*spa_source_idle_func_t) (void *data); typedef void (*spa_source_event_func_t) (void *data, uint64_t count); diff --git a/spa/include/spa/support/system.h b/spa/include/spa/support/system.h new file mode 100644 index 000000000..8a28f6b09 --- /dev/null +++ b/spa/include/spa/support/system.h @@ -0,0 +1,120 @@ +/* Simple Plugin API + * + * Copyright © 2019 Wim Taymans + * + * 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: + * + * 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. + */ + +#ifndef SPA_SYSTEM_H +#define SPA_SYSTEM_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/** + * a collection of system functions + */ +#define SPA_VERSION_SYSTEM 0 +struct spa_system { struct spa_interface iface; }; + + +#define SPA_FD_CLOEXEC (1<<0) +#define SPA_FD_NONBLOCK (1<<1) +#define SPA_FD_EVENT_SEMAPHORE (1<<2) +#define SPA_FD_TIMER_ABSTIME (1<<3) +#define SPA_FD_TIMER_CANCEL_ON_SET (1<<4) + +struct spa_system_methods { +#define SPA_VERSION_SYSTEM_METHODS 0 + uint32_t version; + + /* read/write/ioctl */ + ssize_t (*read) (void *object, int fd, void *buf, size_t count); + ssize_t (*write) (void *object, int fd, const void *buf, size_t count); + int (*ioctl) (void *object, int fd, unsigned long request, ...); + int (*close) (void *object, int fd); + + /* clock */ + int (*clock_gettime) (void *object, + int clockid, struct timespec *value); + int (*clock_getres) (void *object, + int clockid, struct timespec *res); + + /* timers */ + int (*timerfd_create) (void *object, int clockid, int flags); + int (*timerfd_settime) (void *object, + int fd, int flags, + const struct itimerspec *new_value, + struct itimerspec *old_value); + int (*timerfd_gettime) (void *object, + int fd, struct itimerspec *curr_value); + int (*timerfd_read) (void *object, int fd, uint64_t *expirations); + + /* events */ + int (*eventfd_create) (void *object, int flags); + int (*eventfd_write) (void *object, int fd, uint64_t count); + int (*eventfd_read) (void *object, int fd, uint64_t *count); + + /* signals */ + int (*signalfd_create) (void *object, int signal, int flags); + int (*signalfd_read) (void *object, int fd, int *signal); +}; + +#define spa_system_method_r(o,method,version,...) \ +({ \ + int _res = -ENOTSUP; \ + struct spa_system *_o = o; \ + spa_interface_call_res(&_o->iface, \ + struct spa_system_methods, _res, \ + method, version, ##__VA_ARGS__); \ + _res; \ +}) + + +#define spa_system_read(s,...) spa_system_method_r(s,read,0,__VA_ARGS__) +#define spa_system_write(s,...) spa_system_method_r(s,write,0,__VA_ARGS__) +#define spa_system_ioctl(s,...) spa_system_method_r(s,ioctl,0,__VA_ARGS__) +#define spa_system_close(s,...) spa_system_method_r(s,close,0,__VA_ARGS__) + +#define spa_system_clock_gettime(s,...) spa_system_method_r(s,clock_gettime,0,__VA_ARGS__) +#define spa_system_clock_getres(s,...) spa_system_method_r(s,clock_getres,0,__VA_ARGS__) + +#define spa_system_timerfd_create(s,...) spa_system_method_r(s,timerfd_create,0,__VA_ARGS__) +#define spa_system_timerfd_settime(s,...) spa_system_method_r(s,timerfd_settime,0,__VA_ARGS__) +#define spa_system_timerfd_gettime(s,...) spa_system_method_r(s,timerfd_gettime,0,__VA_ARGS__) +#define spa_system_timerfd_read(s,...) spa_system_method_r(s,timerfd_read,0,__VA_ARGS__) + +#define spa_system_eventfd_create(s,...) spa_system_method_r(s,eventfd_create,0,__VA_ARGS__) +#define spa_system_eventfd_write(s,...) spa_system_method_r(s,eventfd_write,0,__VA_ARGS__) +#define spa_system_eventfd_read(s,...) spa_system_method_r(s,eventfd_read,0,__VA_ARGS__) + +#define spa_system_signalfd_create(s,...) spa_system_method_r(s,signalfd_create,0,__VA_ARGS__) +#define spa_system_signalfd_read(s,...) spa_system_method_r(s,signalfd_read,0,__VA_ARGS__) + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* SPA_SYSTEM_H */ diff --git a/spa/include/spa/utils/type-info.h b/spa/include/spa/utils/type-info.h index 4f4c0a39c..188fedaa9 100644 --- a/spa/include/spa/utils/type-info.h +++ b/spa/include/spa/utils/type-info.h @@ -103,6 +103,7 @@ static const struct spa_type_info spa_types[] = { { SPA_TYPE_INTERFACE_Handle, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "Handle", NULL }, { SPA_TYPE_INTERFACE_HandleFactory, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "HandleFactory", NULL }, { SPA_TYPE_INTERFACE_Log, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "Log", NULL }, + { SPA_TYPE_INTERFACE_System, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "System", NULL }, { SPA_TYPE_INTERFACE_Loop, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "Loop", NULL }, { SPA_TYPE_INTERFACE_LoopControl, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "LoopControl", NULL }, { SPA_TYPE_INTERFACE_LoopUtils, SPA_TYPE_Pointer, SPA_TYPE_INFO_INTERFACE_BASE "LoopUtils", NULL }, diff --git a/spa/include/spa/utils/type.h b/spa/include/spa/utils/type.h index 0fce79340..472275047 100644 --- a/spa/include/spa/utils/type.h +++ b/spa/include/spa/utils/type.h @@ -68,6 +68,7 @@ enum { SPA_TYPE_INTERFACE_Handle, /**< object handle */ SPA_TYPE_INTERFACE_HandleFactory, /**< factory for object handles */ SPA_TYPE_INTERFACE_Log, /**< log interface */ + SPA_TYPE_INTERFACE_System, /**< System functions */ SPA_TYPE_INTERFACE_Loop, /**< poll loop support */ SPA_TYPE_INTERFACE_LoopControl, /**< control of loops */ SPA_TYPE_INTERFACE_LoopUtils, /**< loop utilities */ diff --git a/spa/plugins/support/loop.c b/spa/plugins/support/loop.c index 7677022e0..7887b943b 100644 --- a/spa/plugins/support/loop.c +++ b/spa/plugins/support/loop.c @@ -29,12 +29,10 @@ #include #include #include -#include -#include -#include #include #include +#include #include #include #include @@ -68,6 +66,7 @@ struct impl { struct spa_loop_utils utils; struct spa_log *log; + struct spa_system *system; struct spa_list source_list; struct spa_list destroy_list; @@ -97,7 +96,6 @@ struct source_impl { spa_source_timer_func_t timer; spa_source_signal_func_t signal; } func; - int signal_number; bool enabled; }; /** \endcond */ @@ -242,9 +240,9 @@ loop_invoke(void *object, spa_loop_control_hook_before(&impl->hooks_list); - if (read(impl->ack_fd, &count, sizeof(uint64_t)) != sizeof(uint64_t)) + if ((res = spa_system_eventfd_read(impl->system, impl->ack_fd, &count)) < 0) spa_log_warn(impl->log, NAME " %p: failed to read event fd: %s", - impl, strerror(errno)); + impl, spa_strerror(res)); spa_loop_control_hook_after(&impl->hooks_list); @@ -264,6 +262,8 @@ static void wakeup_func(void *data, uint64_t count) { struct impl *impl = data; uint32_t index; + int res; + while (spa_ringbuffer_get_read_index(&impl->buffer, &index) > 0) { struct invoke_item *item; bool block; @@ -278,10 +278,9 @@ static void wakeup_func(void *data, uint64_t count) spa_ringbuffer_read_update(&impl->buffer, index + item->item_size); if (block) { - uint64_t c = 1; - if (write(impl->ack_fd, &c, sizeof(uint64_t)) != sizeof(uint64_t)) + if ((res = spa_system_eventfd_write(impl->system, impl->ack_fd, 1)) < 0) spa_log_warn(impl->log, NAME " %p: failed to write event fd: %s", - impl, strerror(errno)); + impl, spa_strerror(res)); } } } @@ -407,17 +406,17 @@ static void source_idle_func(struct spa_source *source) static void loop_enable_idle(void *object, struct spa_source *source, bool enabled) { struct source_impl *impl = SPA_CONTAINER_OF(source, struct source_impl, source); - uint64_t count; + int res; if (enabled && !impl->enabled) { - count = 1; - if (write(source->fd, &count, sizeof(uint64_t)) != sizeof(uint64_t)) + if ((res = spa_system_eventfd_write(impl->impl->system, source->fd, 1)) < 0) spa_log_warn(impl->impl->log, NAME " %p: failed to write idle fd %d: %s", - source, source->fd, strerror(errno)); + source, source->fd, spa_strerror(res)); } else if (!enabled && impl->enabled) { - if (read(source->fd, &count, sizeof(uint64_t)) != sizeof(uint64_t)) + uint64_t count; + if ((res = spa_system_eventfd_read(impl->impl->system, source->fd, &count)) < 0) spa_log_warn(impl->impl->log, NAME " %p: failed to read idle fd %d: %s", - source, source->fd, strerror(errno)); + source, source->fd, spa_strerror(res)); } impl->enabled = enabled; } @@ -434,7 +433,7 @@ static struct spa_source *loop_add_idle(void *object, source->source.loop = &impl->loop; source->source.func = source_idle_func; source->source.data = data; - source->source.fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); + source->source.fd = spa_system_eventfd_create(impl->system, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK); source->impl = impl; source->close = true; source->source.mask = SPA_IO_IN; @@ -454,10 +453,11 @@ static void source_event_func(struct spa_source *source) { struct source_impl *impl = SPA_CONTAINER_OF(source, struct source_impl, source); uint64_t count; + int res; - if (read(source->fd, &count, sizeof(uint64_t)) != sizeof(uint64_t)) + if ((res = spa_system_eventfd_read(impl->impl->system, source->fd, &count)) < 0) spa_log_warn(impl->impl->log, NAME " %p: failed to read event fd %d: %s", - source, source->fd, strerror(errno)); + source, source->fd, spa_strerror(res)); impl->func.event(source->data, count); } @@ -475,7 +475,7 @@ static struct spa_source *loop_add_event(void *object, source->source.loop = &impl->loop; source->source.func = source_event_func; source->source.data = data; - source->source.fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); + source->source.fd = spa_system_eventfd_create(impl->system, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK); source->source.mask = SPA_IO_IN; source->impl = impl; source->close = true; @@ -491,21 +491,23 @@ static struct spa_source *loop_add_event(void *object, static void loop_signal_event(void *object, struct spa_source *source) { struct source_impl *impl = SPA_CONTAINER_OF(source, struct source_impl, source); - uint64_t count = 1; + int res; - if (write(source->fd, &count, sizeof(uint64_t)) != sizeof(uint64_t)) + if ((res = spa_system_eventfd_write(impl->impl->system, source->fd, 1)) < 0) spa_log_warn(impl->impl->log, NAME " %p: failed to write event fd %d: %s", - source, source->fd, strerror(errno)); + source, source->fd, spa_strerror(res)); } static void source_timer_func(struct spa_source *source) { struct source_impl *impl = SPA_CONTAINER_OF(source, struct source_impl, source); uint64_t expirations; + int res; - if (read(source->fd, &expirations, sizeof(uint64_t)) != sizeof(uint64_t)) + if ((res = spa_system_timerfd_read(impl->impl->system, + source->fd, &expirations)) < 0) spa_log_warn(impl->impl->log, NAME " %p: failed to read timer fd %d: %s", - source, source->fd, strerror(errno)); + source, source->fd, spa_strerror(res)); impl->func.timer(source->data, expirations); } @@ -523,7 +525,8 @@ static struct spa_source *loop_add_timer(void *object, source->source.loop = &impl->loop; source->source.func = source_timer_func; source->source.data = data; - source->source.fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); + source->source.fd = spa_system_timerfd_create(impl->system, CLOCK_MONOTONIC, + SPA_FD_CLOEXEC | SPA_FD_NONBLOCK); source->source.mask = SPA_IO_IN; source->impl = impl; source->close = true; @@ -540,6 +543,7 @@ static int loop_update_timer(void *object, struct spa_source *source, struct timespec *value, struct timespec *interval, bool absolute) { + struct impl *impl = object; struct itimerspec its; int flags = 0; @@ -553,9 +557,9 @@ loop_update_timer(void *object, struct spa_source *source, if (interval) its.it_interval = *interval; if (absolute) - flags |= TFD_TIMER_ABSTIME; + flags |= SPA_FD_TIMER_ABSTIME; - if (timerfd_settime(source->fd, flags, &its, NULL) < 0) + if (spa_system_timerfd_settime(impl->system, source->fd, flags, &its, NULL) < 0) return errno; return 0; @@ -564,15 +568,13 @@ loop_update_timer(void *object, struct spa_source *source, static void source_signal_func(struct spa_source *source) { struct source_impl *impl = SPA_CONTAINER_OF(source, struct source_impl, source); - struct signalfd_siginfo signal_info; - int len; + int res, signal_number; - len = read(source->fd, &signal_info, sizeof signal_info); - if (!(len == -1 && errno == EAGAIN) && len != sizeof signal_info) + if ((res = spa_system_signalfd_read(impl->impl->system, source->fd, &signal_number)) < 0) spa_log_warn(impl->impl->log, NAME " %p: failed to read signal fd %d: %s", - source, source->fd, strerror(errno)); + source, source->fd, spa_strerror(res)); - impl->func.signal(source->data, impl->signal_number); + impl->func.signal(source->data, signal_number); } static struct spa_source *loop_add_signal(void *object, @@ -581,7 +583,6 @@ static struct spa_source *loop_add_signal(void *object, { struct impl *impl = object; struct source_impl *source; - sigset_t mask; source = calloc(1, sizeof(struct source_impl)); if (source == NULL) @@ -591,16 +592,13 @@ static struct spa_source *loop_add_signal(void *object, source->source.func = source_signal_func; source->source.data = data; - sigemptyset(&mask); - sigaddset(&mask, signal_number); - source->source.fd = signalfd(-1, &mask, SFD_CLOEXEC | SFD_NONBLOCK); - sigprocmask(SIG_BLOCK, &mask, NULL); + source->source.fd = spa_system_signalfd_create(impl->system, + signal_number, SPA_FD_CLOEXEC | SPA_FD_NONBLOCK); source->source.mask = SPA_IO_IN; source->impl = impl; source->close = true; source->func.signal = func; - source->signal_number = signal_number; loop_add_source(impl, &source->source); @@ -695,7 +693,7 @@ static int impl_clear(struct spa_handle *handle) process_destroy(impl); - close(impl->ack_fd); + spa_system_close(impl->system, impl->ack_fd); close(impl->epoll_fd); return 0; @@ -739,8 +737,14 @@ impl_init(const struct spa_handle_factory *factory, &impl_loop_utils, impl); for (i = 0; i < n_support; i++) { - if (support[i].type == SPA_TYPE_INTERFACE_Log) + switch (support[i].type) { + case SPA_TYPE_INTERFACE_Log: impl->log = support[i].data; + break; + case SPA_TYPE_INTERFACE_System: + impl->system = support[i].data; + break; + } } impl->epoll_fd = epoll_create1(EPOLL_CLOEXEC); @@ -754,7 +758,8 @@ impl_init(const struct spa_handle_factory *factory, spa_ringbuffer_init(&impl->buffer); impl->wakeup = loop_add_event(impl, wakeup_func, impl); - impl->ack_fd = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC); + impl->ack_fd = spa_system_eventfd_create(impl->system, + SPA_FD_EVENT_SEMAPHORE | SPA_FD_CLOEXEC); spa_log_debug(impl->log, NAME " %p: initialized", impl); diff --git a/spa/plugins/support/meson.build b/spa/plugins/support/meson.build index b322792f3..a5a008939 100644 --- a/spa/plugins/support/meson.build +++ b/spa/plugins/support/meson.build @@ -1,7 +1,8 @@ spa_support_sources = ['cpu.c', 'logger.c', 'loop.c', - 'plugin.c'] + 'plugin.c', + 'system.c'] spa_support_lib = shared_library('spa-support', spa_support_sources, diff --git a/spa/plugins/support/plugin.c b/spa/plugins/support/plugin.c index ea41b69ba..24e8055b0 100644 --- a/spa/plugins/support/plugin.c +++ b/spa/plugins/support/plugin.c @@ -28,8 +28,9 @@ #include extern const struct spa_handle_factory spa_support_logger_factory; -extern const struct spa_handle_factory spa_support_loop_factory; +extern const struct spa_handle_factory spa_support_system_factory; extern const struct spa_handle_factory spa_support_cpu_factory; +extern const struct spa_handle_factory spa_support_loop_factory; SPA_EXPORT int spa_handle_factory_enum(const struct spa_handle_factory **factory, uint32_t *index) @@ -42,11 +43,14 @@ int spa_handle_factory_enum(const struct spa_handle_factory **factory, uint32_t *factory = &spa_support_logger_factory; break; case 1: - *factory = &spa_support_loop_factory; + *factory = &spa_support_system_factory; break; case 2: *factory = &spa_support_cpu_factory; break; + case 3: + *factory = &spa_support_loop_factory; + break; default: return 0; } diff --git a/spa/plugins/support/system.c b/spa/plugins/support/system.c new file mode 100644 index 000000000..f9e1819d8 --- /dev/null +++ b/spa/plugins/support/system.c @@ -0,0 +1,300 @@ +/* Spa + * + * Copyright © 2019 Wim Taymans + * + * 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: + * + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define NAME "system" + +struct impl { + struct spa_handle handle; + struct spa_system system; + + struct spa_log *log; +}; + +static ssize_t impl_read(void *object, int fd, void *buf, size_t count) +{ + return read(fd, buf, count); +} + +static ssize_t impl_write(void *object, int fd, const void *buf, size_t count) +{ + return write(fd, buf, count); +} + +static int impl_ioctl(void *object, int fd, unsigned long request, ...) +{ + int res; + va_list ap; + long arg; + + va_start(ap, request); + arg = va_arg(ap, long); + res = ioctl(fd, request, arg); + va_end(ap); + + return res; +} + +static int impl_close(void *object, int fd) +{ + return close(fd); +} + +/* clock */ +static int impl_clock_gettime(void *object, + int clockid, struct timespec *value) +{ + return clock_gettime(clockid, value); +} + +static int impl_clock_getres(void *object, + int clockid, struct timespec *res) +{ + return clock_getres(clockid, res); +} + +/* timers */ +static int impl_timerfd_create(void *object, int clockid, int flags) +{ + int fl = 0; + if (flags & SPA_FD_CLOEXEC) + fl |= TFD_CLOEXEC; + if (flags & SPA_FD_NONBLOCK) + fl |= TFD_NONBLOCK; + return timerfd_create(clockid, flags); +} + +static int impl_timerfd_settime(void *object, + int fd, int flags, + const struct itimerspec *new_value, + struct itimerspec *old_value) +{ + int fl = 0; + if (flags & SPA_FD_TIMER_ABSTIME) + fl |= TFD_TIMER_ABSTIME; + if (flags & SPA_FD_TIMER_CANCEL_ON_SET) + fl |= TFD_TIMER_CANCEL_ON_SET; + return timerfd_settime(fd, fl, new_value, old_value); +} + +static int impl_timerfd_gettime(void *object, + int fd, struct itimerspec *curr_value) +{ + return timerfd_gettime(fd, curr_value); + +} +static int impl_timerfd_read(void *object, int fd, uint64_t *expirations) +{ + int res; + if ((res = read(fd, expirations, sizeof(uint64_t))) != sizeof(uint64_t)) + return -errno; + return 0; +} + +/* events */ +static int impl_eventfd_create(void *object, int flags) +{ + int fl = 0; + if (flags & SPA_FD_CLOEXEC) + fl |= EFD_CLOEXEC; + if (flags & SPA_FD_NONBLOCK) + fl |= EFD_NONBLOCK; + if (flags & SPA_FD_EVENT_SEMAPHORE) + fl |= EFD_SEMAPHORE; + return eventfd(0, fl); +} + +static int impl_eventfd_write(void *object, int fd, uint64_t count) +{ + if (write(fd, &count, sizeof(uint64_t)) != sizeof(uint64_t)) + return -errno; + return 0; +} + +static int impl_eventfd_read(void *object, int fd, uint64_t *count) +{ + if (read(fd, count, sizeof(uint64_t)) != sizeof(uint64_t)) + return -errno; + return 0; +} + +/* signals */ +static int impl_signalfd_create(void *object, int signal, int flags) +{ + sigset_t mask; + int res, fl = 0; + + if (flags & SPA_FD_CLOEXEC) + fl |= SFD_CLOEXEC; + if (flags & SPA_FD_NONBLOCK) + fl |= SFD_NONBLOCK; + + sigemptyset(&mask); + sigaddset(&mask, signal); + res = signalfd(-1, &mask, fl); + sigprocmask(SIG_BLOCK, &mask, NULL); + + return res; +} + +static int impl_signalfd_read(void *object, int fd, int *signal) +{ + struct signalfd_siginfo signal_info; + int len; + + len = read(fd, &signal_info, sizeof signal_info); + if (!(len == -1 && errno == EAGAIN) && len != sizeof signal_info) + return -errno; + + *signal = signal_info.ssi_signo; + + return 0; +} + +static const struct spa_system_methods impl_system = { + SPA_VERSION_SYSTEM_METHODS, + .read = impl_read, + .write = impl_write, + .ioctl = impl_ioctl, + .close = impl_close, + .clock_gettime = impl_clock_gettime, + .clock_getres = impl_clock_getres, + .timerfd_create = impl_timerfd_create, + .timerfd_settime = impl_timerfd_settime, + .timerfd_gettime = impl_timerfd_gettime, + .timerfd_read = impl_timerfd_read, + .eventfd_create = impl_eventfd_create, + .eventfd_write = impl_eventfd_write, + .eventfd_read = impl_eventfd_read, + .signalfd_create = impl_signalfd_create, + .signalfd_read = impl_signalfd_read, +}; + +static int impl_get_interface(struct spa_handle *handle, uint32_t type, void **interface) +{ + struct impl *impl; + + spa_return_val_if_fail(handle != NULL, -EINVAL); + spa_return_val_if_fail(interface != NULL, -EINVAL); + + impl = (struct impl *) handle; + + switch (type) { + case SPA_TYPE_INTERFACE_System: + *interface = &impl->system; + break; + default: + return -ENOENT; + } + return 0; +} + +static int impl_clear(struct spa_handle *handle) +{ + spa_return_val_if_fail(handle != NULL, -EINVAL); + return 0; +} + +static size_t +impl_get_size(const struct spa_handle_factory *factory, + const struct spa_dict *params) +{ + return sizeof(struct impl); +} + +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; + uint32_t i; + + spa_return_val_if_fail(factory != NULL, -EINVAL); + spa_return_val_if_fail(handle != NULL, -EINVAL); + + handle->get_interface = impl_get_interface; + handle->clear = impl_clear; + + impl = (struct impl *) handle; + impl->system.iface = SPA_INTERFACE_INIT( + SPA_TYPE_INTERFACE_System, + SPA_VERSION_SYSTEM, + &impl_system, impl); + + for (i = 0; i < n_support; i++) { + if (support[i].type == SPA_TYPE_INTERFACE_Log) + impl->log = support[i].data; + } + + spa_log_debug(impl->log, NAME " %p: initialized", impl); + + return 0; +} + +static const struct spa_interface_info impl_interfaces[] = { + {SPA_TYPE_INTERFACE_System,}, +}; + +static int +impl_enum_interface_info(const struct spa_handle_factory *factory, + const struct spa_interface_info **info, + uint32_t *index) +{ + spa_return_val_if_fail(factory != NULL, -EINVAL); + spa_return_val_if_fail(info != NULL, -EINVAL); + spa_return_val_if_fail(index != NULL, -EINVAL); + + if (*index >= SPA_N_ELEMENTS(impl_interfaces)) + return 0; + + *info = &impl_interfaces[(*index)++]; + return 1; +} + +const struct spa_handle_factory spa_support_system_factory = { + SPA_VERSION_HANDLE_FACTORY, + NAME, + NULL, + impl_get_size, + impl_init, + impl_enum_interface_info +}; diff --git a/src/pipewire/core.c b/src/pipewire/core.c index 0f4663a21..ba43bfb14 100644 --- a/src/pipewire/core.c +++ b/src/pipewire/core.c @@ -1030,9 +1030,8 @@ static int collect_nodes(struct pw_node *driver) } quantum = SPA_MAX(quantum, MIN_QUANTUM); - if (driver->rt.position && quantum != driver->rt.position->size) { + if (driver->rt.position && quantum != driver->rt.position->size) driver->rt.position->size = quantum; - } return 0; } diff --git a/src/pipewire/node.c b/src/pipewire/node.c index 2cf7954a2..5c258f26b 100644 --- a/src/pipewire/node.c +++ b/src/pipewire/node.c @@ -576,6 +576,7 @@ int pw_node_set_driver(struct pw_node *node, struct pw_node *driver) return 0; node->master = node->driver && driver == node; + pw_log_info("node %p: driver %p master:%u", node, driver, node->master); node->driver_node = driver; pw_node_emit_driver_changed(node, old, driver); @@ -1382,7 +1383,7 @@ static void node_activate(struct pw_node *this) } } -/** Set th node state +/** Set the node state * \param node a \ref pw_node * \param state a \ref pw_node_state * \return 0 on success < 0 on error diff --git a/src/pipewire/pipewire.c b/src/pipewire/pipewire.c index f6d10cb8e..7bf115760 100644 --- a/src/pipewire/pipewire.c +++ b/src/pipewire/pipewire.c @@ -378,8 +378,18 @@ void pw_init(int *argc, char **argv[]) SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, iface); pw_log_set(iface); } + handle = load_handle(plugin, "system", NULL, support->n_support, support->support); + if (handle == NULL || + (res = spa_handle_get_interface(&handle->handle, + SPA_TYPE_INTERFACE_System, &iface)) < 0) { + fprintf(stderr, "can't get System interface %d\n", res); + } + else { + support->support[support->n_support++] = + SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_System, iface); + } - handle = load_handle(plugin, "cpu", &info, support->n_support, support->support); + handle = load_handle(plugin, "cpu", NULL, support->n_support, support->support); if (handle == NULL || (res = spa_handle_get_interface(&handle->handle, SPA_TYPE_INTERFACE_CPU, &iface)) < 0) {