diff --git a/0001-Revert-v4l2-handle-inotify-errors.patch b/0001-Revert-v4l2-handle-inotify-errors.patch new file mode 100644 index 0000000..029134a --- /dev/null +++ b/0001-Revert-v4l2-handle-inotify-errors.patch @@ -0,0 +1,70 @@ +From 1110dbb7c1a179558db72daaa099a8c23a2a1351 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Barnab=C3=A1s=20P=C5=91cze?= +Date: Thu, 7 Sep 2023 01:51:10 +0200 +Subject: [PATCH] Revert "v4l2: handle inotify errors" + +This reverts commit 07b8954dc864ab38d69fecae0b8fd2b5c6d18251. +--- + spa/plugins/v4l2/v4l2-udev.c | 32 +++++++++++++------------------- + 1 file changed, 13 insertions(+), 19 deletions(-) + +diff --git a/spa/plugins/v4l2/v4l2-udev.c b/spa/plugins/v4l2/v4l2-udev.c +index 464acf6fca..0fdcf165ca 100644 +--- a/spa/plugins/v4l2/v4l2-udev.c ++++ b/spa/plugins/v4l2/v4l2-udev.c +@@ -393,19 +393,6 @@ static void process_device(struct impl *impl, uint32_t action, struct udev_devic + } + } + +-static int stop_inotify(struct device *dev) +-{ +- struct impl *impl = dev->impl; +- if (dev->notify.fd == -1) +- return 0; +- spa_log_info(impl->log, "stop inotify for /dev/video%u", dev->id); +- spa_loop_remove_source(impl->main_loop, &dev->notify); +- close(dev->notify.fd); +- dev->notify.fd = -1; +- return 0; +-} +- +- + static void impl_on_notify_events(struct spa_source *source) + { + struct device *dev = source->data; +@@ -415,12 +402,7 @@ static void impl_on_notify_events(struct spa_source *source) + struct inotify_event e; /* for appropriate alignment */ + } buf; + +- if (source->rmask & (SPA_IO_ERR | SPA_IO_HUP)) { +- spa_log_warn(impl->log, "notify error on /dev/video%u", dev->id); +- stop_inotify(dev); +- return; +- } +- while (source->rmask & SPA_IO_IN) { ++ while (true) { + ssize_t len; + const struct inotify_event *event; + void *p, *e; +@@ -487,6 +469,18 @@ static int start_inotify(struct device *dev) + return 0; + } + ++static int stop_inotify(struct device *dev) ++{ ++ struct impl *impl = dev->impl; ++ if (dev->notify.fd == -1) ++ return 0; ++ spa_log_info(impl->log, "stop inotify for /dev/video%u", dev->id); ++ spa_loop_remove_source(impl->main_loop, &dev->notify); ++ close(dev->notify.fd); ++ dev->notify.fd = -1; ++ return 0; ++} ++ + static void impl_on_fd_events(struct spa_source *source) + { + struct impl *impl = source->data; +-- +GitLab + diff --git a/0001-pulse-server-allow-monitors-when-selecting-source-by-index.patch b/0001-pulse-server-allow-monitors-when-selecting-source-by-index.patch new file mode 100644 index 0000000..6b668ba --- /dev/null +++ b/0001-pulse-server-allow-monitors-when-selecting-source-by-index.patch @@ -0,0 +1,31 @@ +From 89fab13c77ba35fd617bd77afd29d373e9fbab4d Mon Sep 17 00:00:00 2001 +From: Wim Taymans +Date: Wed, 30 Aug 2023 09:59:37 +0200 +Subject: [PATCH] pulse-server: allow monitors when selecting source by index + +Fixes #3476 +--- + src/modules/module-protocol-pulse/pulse-server.c | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +diff --git a/src/modules/module-protocol-pulse/pulse-server.c b/src/modules/module-protocol-pulse/pulse-server.c +index 09e4a8d2ee..593f47da56 100644 +--- a/src/modules/module-protocol-pulse/pulse-server.c ++++ b/src/modules/module-protocol-pulse/pulse-server.c +@@ -2505,8 +2505,12 @@ static struct pw_manager_object *find_device(struct client *client, + allow_monitor = true; + } + } +- } else if (index == SPA_ID_INVALID) ++ } else if (index != SPA_ID_INVALID) { ++ if (!sink) ++ allow_monitor = true; ++ } else { + return NULL; ++ } + + + spa_zero(sel); +-- +GitLab + diff --git a/0002-Revert-v4l2-dont-set-inotify-on-_dev.patch b/0002-Revert-v4l2-dont-set-inotify-on-_dev.patch new file mode 100644 index 0000000..5420dc2 --- /dev/null +++ b/0002-Revert-v4l2-dont-set-inotify-on-_dev.patch @@ -0,0 +1,611 @@ +From 53ce1ee5765832ebdda00117361f0f5c698dba73 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Barnab=C3=A1s=20P=C5=91cze?= +Date: Thu, 7 Sep 2023 01:51:25 +0200 +Subject: [PATCH] Revert "v4l2: don't set inotify on /dev" + +This reverts commit 88f0dbd6fcd0a412fc4bece22afdc3ba0151e4cf. +--- + spa/plugins/v4l2/v4l2-udev.c | 307 ++++++++++++++++++----------------- + 1 file changed, 154 insertions(+), 153 deletions(-) + +diff --git a/spa/plugins/v4l2/v4l2-udev.c b/spa/plugins/v4l2/v4l2-udev.c +index 0fdcf165ca..3c2504dcb6 100644 +--- a/spa/plugins/v4l2/v4l2-udev.c ++++ b/spa/plugins/v4l2/v4l2-udev.c +@@ -33,10 +33,8 @@ + #define ACTION_DISABLE 2 + + struct device { +- struct impl *impl; + uint32_t id; + struct udev_device *dev; +- struct spa_source notify; + unsigned int accessible:1; + unsigned int ignored:1; + unsigned int emitted:1; +@@ -61,79 +59,66 @@ struct impl { + uint32_t n_devices; + + struct spa_source source; ++ struct spa_source notify; + }; + +-static int stop_inotify(struct device *dev); +-static int start_inotify(struct device *dev); +- +-static int impl_udev_open(struct impl *impl) ++static int impl_udev_open(struct impl *this) + { +- if (impl->udev == NULL) { +- impl->udev = udev_new(); +- if (impl->udev == NULL) ++ if (this->udev == NULL) { ++ this->udev = udev_new(); ++ if (this->udev == NULL) + return -ENOMEM; + } + return 0; + } + +-static int impl_udev_close(struct impl *impl) ++static int impl_udev_close(struct impl *this) + { +- if (impl->udev != NULL) +- udev_unref(impl->udev); +- impl->udev = NULL; ++ if (this->udev != NULL) ++ udev_unref(this->udev); ++ this->udev = NULL; + return 0; + } + +-static struct device *add_device(struct impl *impl, uint32_t id, struct udev_device *dev) ++static struct device *add_device(struct impl *this, uint32_t id, struct udev_device *dev) + { + struct device *device; + +- if (impl->n_devices >= MAX_DEVICES) ++ if (this->n_devices >= MAX_DEVICES) + return NULL; +- device = &impl->devices[impl->n_devices++]; ++ device = &this->devices[this->n_devices++]; + spa_zero(*device); +- device->impl = impl; +- device->notify.fd = -1; + device->id = id; + udev_device_ref(dev); + device->dev = dev; +- start_inotify(device); + return device; + } + +-static struct device *find_device(struct impl *impl, uint32_t id) ++static struct device *find_device(struct impl *this, uint32_t id) + { + uint32_t i; +- for (i = 0; i < impl->n_devices; i++) { +- if (impl->devices[i].id == id) +- return &impl->devices[i]; ++ for (i = 0; i < this->n_devices; i++) { ++ if (this->devices[i].id == id) ++ return &this->devices[i]; + } + return NULL; + } + +-static void clear_device(struct device *device) +-{ +- stop_inotify(device); +- if (device->dev) +- udev_device_unref(device->dev); +-} +- +-static void remove_device(struct device *device) ++static void remove_device(struct impl *this, struct device *device) + { +- struct impl *impl = device->impl; +- clear_device(device); +- *device = impl->devices[--impl->n_devices]; ++ udev_device_unref(device->dev); ++ *device = this->devices[--this->n_devices]; + } + +-static void clear_devices(struct impl *impl) ++static void clear_devices(struct impl *this) + { + uint32_t i; +- for (i = 0; i < impl->n_devices; i++) +- clear_device(&impl->devices[i]); +- impl->n_devices = 0; ++ for (i = 0; i < this->n_devices; i++) ++ udev_device_unref(this->devices[i].dev); ++ this->n_devices = 0; + } + +-static uint32_t get_device_id(struct impl *impl, struct udev_device *dev) ++static uint32_t get_device_id(struct impl *this, struct udev_device *dev) + { + const char *str; + +@@ -229,9 +214,8 @@ static void unescape(const char *src, char *dst) + *d = 0; + } + +-static int emit_object_info(struct device *device) ++static int emit_object_info(struct impl *this, struct device *device) + { +- struct impl *impl = device->impl; + struct spa_device_object_info info; + uint32_t id = device->id; + struct udev_device *dev = device->dev; +@@ -331,55 +315,54 @@ static int emit_object_info(struct device *device) + items[n_items++] = SPA_DICT_ITEM_INIT(SPA_KEY_DEVICE_CAPABILITIES, str); + } + info.props = &SPA_DICT_INIT(items, n_items); +- spa_device_emit_object_info(&impl->hooks, id, &info); ++ spa_device_emit_object_info(&this->hooks, id, &info); + device->emitted = true; + + return 1; + } + +-static bool check_access(struct device *device) ++static bool check_access(struct impl *this, struct device *device) + { + char path[128]; + + snprintf(path, sizeof(path), "/dev/video%u", device->id); + device->accessible = access(path, R_OK|W_OK) >= 0; +- spa_log_debug(device->impl->log, "%s accessible:%u", path, device->accessible); ++ spa_log_debug(this->log, "%s accessible:%u", path, device->accessible); + + return device->accessible; + } + +-static void process_device(struct impl *impl, uint32_t action, struct udev_device *dev) ++static void process_device(struct impl *this, uint32_t action, struct udev_device *dev) + { + uint32_t id; + struct device *device; + bool emitted; + +- if ((id = get_device_id(impl, dev)) == SPA_ID_INVALID) ++ if ((id = get_device_id(this, dev)) == SPA_ID_INVALID) + return; + +- device = find_device(impl, id); ++ device = find_device(this, id); + if (device && device->ignored) + return; + + switch (action) { + case ACTION_ADD: + if (device == NULL) +- device = add_device(impl, id, dev); ++ device = add_device(this, id, dev); + if (device == NULL) + return; +- if (!check_access(device)) ++ if (!check_access(this, device)) + return; +- else +- emit_object_info(device); ++ emit_object_info(this, device); + break; + + case ACTION_REMOVE: + if (device == NULL) + return; + emitted = device->emitted; +- remove_device(device); ++ remove_device(this, device); + if (emitted) +- spa_device_emit_object_info(&impl->hooks, id, NULL); ++ spa_device_emit_object_info(&this->hooks, id, NULL); + break; + + case ACTION_DISABLE: +@@ -387,16 +370,27 @@ static void process_device(struct impl *impl, uint32_t action, struct udev_devic + return; + if (device->emitted) { + device->emitted = false; +- spa_device_emit_object_info(&impl->hooks, id, NULL); ++ spa_device_emit_object_info(&this->hooks, id, NULL); + } + break; + } + } + ++static int stop_inotify(struct impl *this) ++{ ++ if (this->notify.fd == -1) ++ return 0; ++ spa_log_info(this->log, "stop inotify"); ++ spa_loop_remove_source(this->main_loop, &this->notify); ++ close(this->notify.fd); ++ this->notify.fd = -1; ++ return 0; ++} ++ + static void impl_on_notify_events(struct spa_source *source) + { +- struct device *dev = source->data; +- struct impl *impl = dev->impl; ++ bool deleted = false; ++ struct impl *this = source->data; + union { + unsigned char name[sizeof(struct inotify_event) + NAME_MAX + 1]; + struct inotify_event e; /* for appropriate alignment */ +@@ -417,138 +411,143 @@ static void impl_on_notify_events(struct spa_source *source) + + for (p = &buf; p < e; + p = SPA_PTROFF(p, sizeof(struct inotify_event) + event->len, void)) { ++ unsigned int id; ++ struct device *device; + + event = (const struct inotify_event *) p; + + if ((event->mask & IN_ATTRIB)) { + bool access; +- access = check_access(dev); +- if (access && !dev->emitted) +- process_device(impl, ACTION_ADD, dev->dev); +- else if (!access && dev->emitted) +- process_device(impl, ACTION_DISABLE, dev->dev); ++ if (sscanf(event->name, "video%u", &id) != 1) ++ continue; ++ if ((device = find_device(this, id)) == NULL) ++ continue; ++ access = check_access(this, device); ++ if (access && !device->emitted) ++ process_device(this, ACTION_ADD, device->dev); ++ else if (!access && device->emitted) ++ process_device(this, ACTION_DISABLE, device->dev); + } ++ /* /dev/ might have been removed */ ++ if ((event->mask & (IN_DELETE_SELF | IN_MOVE_SELF))) ++ deleted = true; + } + } ++ if (deleted) ++ stop_inotify(this); + } + +-static int start_inotify(struct device *dev) ++static int start_inotify(struct impl *this) + { +- struct impl *impl = dev->impl; + int res, notify_fd; +- char name[32]; + +- if (dev->notify.fd != -1) ++ if (this->notify.fd != -1) + return 0; + + if ((notify_fd = inotify_init1(IN_CLOEXEC | IN_NONBLOCK)) < 0) + return -errno; + +- snprintf(name, sizeof(name), "/dev/video%u", dev->id); +- +- res = inotify_add_watch(notify_fd, name, IN_ATTRIB | IN_CLOSE_WRITE); ++ res = inotify_add_watch(notify_fd, "/dev", ++ IN_ATTRIB | IN_CLOSE_WRITE | IN_DELETE_SELF | IN_MOVE_SELF); + if (res < 0) { + res = -errno; + close(notify_fd); + + if (res == -ENOENT) { +- spa_log_debug(impl->log, "%s does not exist yet", name); ++ spa_log_debug(this->log, "/dev/ does not exist yet"); + return 0; + } +- spa_log_error(impl->log, "inotify_add_watch() failed: %s", spa_strerror(res)); ++ spa_log_error(this->log, "inotify_add_watch() failed: %s", spa_strerror(res)); + return res; + } +- spa_log_info(impl->log, "start inotify for %s", name); +- dev->notify.func = impl_on_notify_events; +- dev->notify.data = dev; +- dev->notify.fd = notify_fd; +- dev->notify.mask = SPA_IO_IN | SPA_IO_ERR; ++ spa_log_info(this->log, "start inotify"); ++ this->notify.func = impl_on_notify_events; ++ this->notify.data = this; ++ this->notify.fd = notify_fd; ++ this->notify.mask = SPA_IO_IN | SPA_IO_ERR; + +- spa_loop_add_source(impl->main_loop, &dev->notify); ++ spa_loop_add_source(this->main_loop, &this->notify); + + return 0; + } + +-static int stop_inotify(struct device *dev) +-{ +- struct impl *impl = dev->impl; +- if (dev->notify.fd == -1) +- return 0; +- spa_log_info(impl->log, "stop inotify for /dev/video%u", dev->id); +- spa_loop_remove_source(impl->main_loop, &dev->notify); +- close(dev->notify.fd); +- dev->notify.fd = -1; +- return 0; +-} +- + static void impl_on_fd_events(struct spa_source *source) + { +- struct impl *impl = source->data; ++ struct impl *this = source->data; + struct udev_device *dev; + const char *action; + +- dev = udev_monitor_receive_device(impl->umonitor); ++ dev = udev_monitor_receive_device(this->umonitor); + if (dev == NULL) + return; + + if ((action = udev_device_get_action(dev)) == NULL) + action = "change"; + +- spa_log_debug(impl->log, "action %s", action); ++ spa_log_debug(this->log, "action %s", action); ++ ++ start_inotify(this); + + if (spa_streq(action, "add") || + spa_streq(action, "change")) { +- process_device(impl, ACTION_ADD, dev); ++ process_device(this, ACTION_ADD, dev); + } else if (spa_streq(action, "remove")) { +- process_device(impl, ACTION_REMOVE, dev); ++ process_device(this, ACTION_REMOVE, dev); + } + udev_device_unref(dev); + } + +-static int start_monitor(struct impl *impl) ++static int start_monitor(struct impl *this) + { +- if (impl->umonitor != NULL) ++ int res; ++ ++ if (this->umonitor != NULL) + return 0; + +- impl->umonitor = udev_monitor_new_from_netlink(impl->udev, "udev"); +- if (impl->umonitor == NULL) ++ this->umonitor = udev_monitor_new_from_netlink(this->udev, "udev"); ++ if (this->umonitor == NULL) + return -ENOMEM; + +- udev_monitor_filter_add_match_subsystem_devtype(impl->umonitor, ++ udev_monitor_filter_add_match_subsystem_devtype(this->umonitor, + "video4linux", NULL); +- udev_monitor_enable_receiving(impl->umonitor); ++ udev_monitor_enable_receiving(this->umonitor); ++ ++ this->source.func = impl_on_fd_events; ++ this->source.data = this; ++ this->source.fd = udev_monitor_get_fd(this->umonitor); ++ this->source.mask = SPA_IO_IN | SPA_IO_ERR; + +- impl->source.func = impl_on_fd_events; +- impl->source.data = impl; +- impl->source.fd = udev_monitor_get_fd(impl->umonitor); +- impl->source.mask = SPA_IO_IN | SPA_IO_ERR; ++ spa_log_debug(this->log, "monitor %p", this->umonitor); ++ spa_loop_add_source(this->main_loop, &this->source); + +- spa_log_debug(impl->log, "monitor %p", impl->umonitor); +- spa_loop_add_source(impl->main_loop, &impl->source); ++ if ((res = start_inotify(this)) < 0) ++ return res; + + return 0; + } + +-static int stop_monitor(struct impl *impl) ++static int stop_monitor(struct impl *this) + { +- if (impl->umonitor == NULL) ++ if (this->umonitor == NULL) + return 0; + +- clear_devices(impl); ++ clear_devices (this); ++ ++ spa_loop_remove_source(this->main_loop, &this->source); ++ udev_monitor_unref(this->umonitor); ++ this->umonitor = NULL; + +- spa_loop_remove_source(impl->main_loop, &impl->source); +- udev_monitor_unref(impl->umonitor); +- impl->umonitor = NULL; ++ stop_inotify(this); + + return 0; + } + +-static int enum_devices(struct impl *impl) ++static int enum_devices(struct impl *this) + { + struct udev_enumerate *enumerate; + struct udev_list_entry *devices; + +- enumerate = udev_enumerate_new(impl->udev); ++ enumerate = udev_enumerate_new(this->udev); + if (enumerate == NULL) + return -ENOMEM; + +@@ -559,11 +558,11 @@ static int enum_devices(struct impl *impl) + devices = udev_list_entry_get_next(devices)) { + struct udev_device *dev; + +- dev = udev_device_new_from_syspath(impl->udev, udev_list_entry_get_name(devices)); ++ dev = udev_device_new_from_syspath(this->udev, udev_list_entry_get_name(devices)); + if (dev == NULL) + continue; + +- process_device(impl, ACTION_ADD, dev); ++ process_device(this, ACTION_ADD, dev); + + udev_device_unref(dev); + } +@@ -578,24 +577,24 @@ static const struct spa_dict_item device_info_items[] = { + { SPA_KEY_API_UDEV_MATCH, "video4linux" }, + }; + +-static void emit_device_info(struct impl *impl, bool full) ++static void emit_device_info(struct impl *this, bool full) + { +- uint64_t old = full ? impl->info.change_mask : 0; ++ uint64_t old = full ? this->info.change_mask : 0; + if (full) +- impl->info.change_mask = impl->info_all; +- if (impl->info.change_mask) { +- impl->info.props = &SPA_DICT_INIT_ARRAY(device_info_items); +- spa_device_emit_info(&impl->hooks, &impl->info); +- impl->info.change_mask = old; ++ this->info.change_mask = this->info_all; ++ if (this->info.change_mask) { ++ this->info.props = &SPA_DICT_INIT_ARRAY(device_info_items); ++ spa_device_emit_info(&this->hooks, &this->info); ++ this->info.change_mask = old; + } + } + + static void impl_hook_removed(struct spa_hook *hook) + { +- struct impl *impl = hook->priv; +- if (spa_hook_list_is_empty(&impl->hooks)) { +- stop_monitor(impl); +- impl_udev_close(impl); ++ struct impl *this = hook->priv; ++ if (spa_hook_list_is_empty(&this->hooks)) { ++ stop_monitor(this); ++ impl_udev_close(this); + } + } + +@@ -604,29 +603,29 @@ impl_device_add_listener(void *object, struct spa_hook *listener, + const struct spa_device_events *events, void *data) + { + int res; +- struct impl *impl = object; ++ struct impl *this = object; + struct spa_hook_list save; + +- spa_return_val_if_fail(impl != NULL, -EINVAL); ++ spa_return_val_if_fail(this != NULL, -EINVAL); + spa_return_val_if_fail(events != NULL, -EINVAL); + +- if ((res = impl_udev_open(impl)) < 0) ++ if ((res = impl_udev_open(this)) < 0) + return res; + +- spa_hook_list_isolate(&impl->hooks, &save, listener, events, data); ++ spa_hook_list_isolate(&this->hooks, &save, listener, events, data); + +- emit_device_info(impl, true); ++ emit_device_info(this, true); + +- if ((res = enum_devices(impl)) < 0) ++ if ((res = enum_devices(this)) < 0) + return res; + +- if ((res = start_monitor(impl)) < 0) ++ if ((res = start_monitor(this)) < 0) + return res; + +- spa_hook_list_join(&impl->hooks, &save); ++ spa_hook_list_join(&this->hooks, &save); + + listener->removed = impl_hook_removed; +- listener->priv = impl; ++ listener->priv = this; + + return 0; + } +@@ -638,15 +637,15 @@ static const struct spa_device_methods impl_device = { + + static int impl_get_interface(struct spa_handle *handle, const char *type, void **interface) + { +- struct impl *impl; ++ struct impl *this; + + spa_return_val_if_fail(handle != NULL, -EINVAL); + spa_return_val_if_fail(interface != NULL, -EINVAL); + +- impl = (struct impl *) handle; ++ this = (struct impl *) handle; + + if (spa_streq(type, SPA_TYPE_INTERFACE_Device)) +- *interface = &impl->device; ++ *interface = &this->device; + else + return -ENOENT; + +@@ -655,9 +654,9 @@ static int impl_get_interface(struct spa_handle *handle, const char *type, void + + static int impl_clear(struct spa_handle *handle) + { +- struct impl *impl = (struct impl *) handle; +- stop_monitor(impl); +- impl_udev_close(impl); ++ struct impl *this = (struct impl *) handle; ++ stop_monitor(this); ++ impl_udev_close(this); + return 0; + } + +@@ -675,7 +674,7 @@ impl_init(const struct spa_handle_factory *factory, + const struct spa_support *support, + uint32_t n_support) + { +- struct impl *impl; ++ struct impl *this; + + spa_return_val_if_fail(factory != NULL, -EINVAL); + spa_return_val_if_fail(handle != NULL, -EINVAL); +@@ -683,25 +682,27 @@ impl_init(const struct spa_handle_factory *factory, + handle->get_interface = impl_get_interface; + handle->clear = impl_clear; + +- impl = (struct impl *) handle; +- impl->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log); +- impl->main_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Loop); ++ this = (struct impl *) handle; ++ this->notify.fd = -1; ++ ++ this->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log); ++ this->main_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Loop); + +- if (impl->main_loop == NULL) { +- spa_log_error(impl->log, "a main-loop is needed"); ++ if (this->main_loop == NULL) { ++ spa_log_error(this->log, "a main-loop is needed"); + return -EINVAL; + } +- spa_hook_list_init(&impl->hooks); ++ spa_hook_list_init(&this->hooks); + +- impl->device.iface = SPA_INTERFACE_INIT( ++ this->device.iface = SPA_INTERFACE_INIT( + SPA_TYPE_INTERFACE_Device, + SPA_VERSION_DEVICE, +- &impl_device, impl); ++ &impl_device, this); + +- impl->info = SPA_DEVICE_INFO_INIT(); +- impl->info_all = SPA_DEVICE_CHANGE_MASK_FLAGS | ++ this->info = SPA_DEVICE_INFO_INIT(); ++ this->info_all = SPA_DEVICE_CHANGE_MASK_FLAGS | + SPA_DEVICE_CHANGE_MASK_PROPS; +- impl->info.flags = 0; ++ this->info.flags = 0; + + return 0; + } +-- +GitLab + diff --git a/0003-spa-v4l2-use-a-separate-watch-for-each-device.patch b/0003-spa-v4l2-use-a-separate-watch-for-each-device.patch new file mode 100644 index 0000000..c6dcf40 --- /dev/null +++ b/0003-spa-v4l2-use-a-separate-watch-for-each-device.patch @@ -0,0 +1,198 @@ +From 3bbccccd05e65fd0c5e6196343fa3a18f1484c96 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Barnab=C3=A1s=20P=C5=91cze?= +Date: Thu, 7 Sep 2023 02:10:04 +0200 +Subject: [PATCH] spa: v4l2: use a separate watch for each device + +Instead of watching /dev, use a separate watch for each device. +This is supposed to achieve the same result as the now reverted +88f0dbd6fcd0a412fc4bece22afdc3ba0151e4cf ("v4l2: don't set inotify on /dev"): + + Doing inotify on /dev is not a good idea because we will be woken up by + a lot of unrelated events. + + There is a report of a performance regression on some IO benchmark + because of lock contention within the fsnotify subsystem due to this. + + Instead, just watch for attribute changes on the /dev/videoX files + directly. We are only interested in attribute changes, udev should + notify us when the file is added or removed. + +Fixes #3439 +--- + spa/plugins/v4l2/v4l2-udev.c | 85 +++++++++++++++++++++--------------- + 1 file changed, 51 insertions(+), 34 deletions(-) + +diff --git a/spa/plugins/v4l2/v4l2-udev.c b/spa/plugins/v4l2/v4l2-udev.c +index 3c2504dcb6..e1c844ba53 100644 +--- a/spa/plugins/v4l2/v4l2-udev.c ++++ b/spa/plugins/v4l2/v4l2-udev.c +@@ -35,6 +35,7 @@ + struct device { + uint32_t id; + struct udev_device *dev; ++ int inotify_wd; + unsigned int accessible:1; + unsigned int ignored:1; + unsigned int emitted:1; +@@ -80,6 +81,28 @@ static int impl_udev_close(struct impl *this) + return 0; + } + ++static void start_watching_device(struct impl *this, struct device *device) ++{ ++ if (this->notify.fd < 0 || device->inotify_wd >= 0) ++ return; ++ ++ char path[64]; ++ snprintf(path, sizeof(path), "/dev/video%" PRIu32, device->id); ++ ++ device->inotify_wd = inotify_add_watch(this->notify.fd, path, IN_ATTRIB); ++} ++ ++static void stop_watching_device(struct impl *this, struct device *device) ++{ ++ if (device->inotify_wd < 0) ++ return; ++ ++ spa_assert(this->notify.fd >= 0); ++ ++ inotify_rm_watch(this->notify.fd, device->inotify_wd); ++ device->inotify_wd = -1; ++} ++ + static struct device *add_device(struct impl *this, uint32_t id, struct udev_device *dev) + { + struct device *device; +@@ -91,6 +114,10 @@ static struct device *add_device(struct impl *this, uint32_t id, struct udev_dev + device->id = id; + udev_device_ref(dev); + device->dev = dev; ++ device->inotify_wd = -1; ++ ++ start_watching_device(this, device); ++ + return device; + } + +@@ -106,16 +133,15 @@ static struct device *find_device(struct impl *this, uint32_t id) + + static void remove_device(struct impl *this, struct device *device) + { +- udev_device_unref(device->dev); ++ device->dev = udev_device_unref(device->dev); ++ stop_watching_device(this, device); + *device = this->devices[--this->n_devices]; + } + + static void clear_devices(struct impl *this) + { +- uint32_t i; +- for (i = 0; i < this->n_devices; i++) +- udev_device_unref(this->devices[i].dev); +- this->n_devices = 0; ++ while (this->n_devices > 0) ++ remove_device(this, &this->devices[0]); + } + + static uint32_t get_device_id(struct impl *this, struct udev_device *dev) +@@ -381,6 +407,10 @@ static int stop_inotify(struct impl *this) + if (this->notify.fd == -1) + return 0; + spa_log_info(this->log, "stop inotify"); ++ ++ for (size_t i = 0; i < this->n_devices; i++) ++ stop_watching_device(this, &this->devices[i]); ++ + spa_loop_remove_source(this->main_loop, &this->notify); + close(this->notify.fd); + this->notify.fd = -1; +@@ -389,7 +419,6 @@ static int stop_inotify(struct impl *this) + + static void impl_on_notify_events(struct spa_source *source) + { +- bool deleted = false; + struct impl *this = source->data; + union { + unsigned char name[sizeof(struct inotify_event) + NAME_MAX + 1]; +@@ -411,35 +440,33 @@ static void impl_on_notify_events(struct spa_source *source) + + for (p = &buf; p < e; + p = SPA_PTROFF(p, sizeof(struct inotify_event) + event->len, void)) { +- unsigned int id; +- struct device *device; +- + event = (const struct inotify_event *) p; + + if ((event->mask & IN_ATTRIB)) { +- bool access; +- if (sscanf(event->name, "video%u", &id) != 1) +- continue; +- if ((device = find_device(this, id)) == NULL) +- continue; +- access = check_access(this, device); ++ struct device *device = NULL; ++ ++ for (size_t i = 0; i < this->n_devices; i++) { ++ if (this->devices[i].inotify_wd == event->wd) { ++ device = &this->devices[i]; ++ break; ++ } ++ } ++ ++ spa_assert(device); ++ ++ bool access = check_access(this, device); + if (access && !device->emitted) + process_device(this, ACTION_ADD, device->dev); + else if (!access && device->emitted) + process_device(this, ACTION_DISABLE, device->dev); + } +- /* /dev/ might have been removed */ +- if ((event->mask & (IN_DELETE_SELF | IN_MOVE_SELF))) +- deleted = true; + } + } +- if (deleted) +- stop_inotify(this); + } + + static int start_inotify(struct impl *this) + { +- int res, notify_fd; ++ int notify_fd; + + if (this->notify.fd != -1) + return 0; +@@ -447,19 +474,6 @@ static int start_inotify(struct impl *this) + if ((notify_fd = inotify_init1(IN_CLOEXEC | IN_NONBLOCK)) < 0) + return -errno; + +- res = inotify_add_watch(notify_fd, "/dev", +- IN_ATTRIB | IN_CLOSE_WRITE | IN_DELETE_SELF | IN_MOVE_SELF); +- if (res < 0) { +- res = -errno; +- close(notify_fd); +- +- if (res == -ENOENT) { +- spa_log_debug(this->log, "/dev/ does not exist yet"); +- return 0; +- } +- spa_log_error(this->log, "inotify_add_watch() failed: %s", spa_strerror(res)); +- return res; +- } + spa_log_info(this->log, "start inotify"); + this->notify.func = impl_on_notify_events; + this->notify.data = this; +@@ -468,6 +482,9 @@ static int start_inotify(struct impl *this) + + spa_loop_add_source(this->main_loop, &this->notify); + ++ for (size_t i = 0; i < this->n_devices; i++) ++ start_watching_device(this, &this->devices[i]); ++ + return 0; + } + +-- +GitLab + diff --git a/pipewire.changes b/pipewire.changes index 26325e8..91bd610 100644 --- a/pipewire.changes +++ b/pipewire.changes @@ -1,3 +1,15 @@ +------------------------------------------------------------------- +Mon Sep 11 09:56:03 UTC 2023 - Antonio Larrosa + +- Add patch from upstream to fix a regression introduced in 0.3.77 + which made it fail to open a monitor device as source: + * 0001-pulse-server-allow-monitors-when-selecting-source-by-index.patch +- Add patch from upstream to fix a bug which caused 100% cpu usage + under some circumstances: + * 0001-Revert-v4l2-handle-inotify-errors.patch + * 0002-Revert-v4l2-dont-set-inotify-on-_dev.patch + * 0003-spa-v4l2-use-a-separate-watch-for-each-device.patch + ------------------------------------------------------------------- Tue Aug 29 17:32:30 UTC 2023 - Alexei Sorokin diff --git a/pipewire.spec b/pipewire.spec index b178386..47d34e0 100644 --- a/pipewire.spec +++ b/pipewire.spec @@ -70,6 +70,11 @@ Source0: %{name}-%{version}.tar.xz Source99: baselibs.conf # PATCH-FIX-OPENSUSE reduce-meson-dependency.patch Patch0: reduce-meson-dependency.patch +Patch1: 0001-pulse-server-allow-monitors-when-selecting-source-by-index.patch +Patch2: 0001-Revert-v4l2-handle-inotify-errors.patch +Patch3: 0002-Revert-v4l2-dont-set-inotify-on-_dev.patch +Patch4: 0003-spa-v4l2-use-a-separate-watch-for-each-device.patch + BuildRequires: docutils BuildRequires: doxygen BuildRequires: fdupes @@ -382,6 +387,10 @@ JACK libraries. sed -ie "s/version : '0.3.72'/version : '%{version}'/" %{P:0} %patch0 -p1 %endif +%patch1 -p1 +%patch2 -p1 +%patch3 -p1 +%patch4 -p1 %build %if %{pkg_vcmp gcc < 8}