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

Revert "v4l2: don't set inotify on /dev"

Browse source 
This reverts commit 88f0dbd6fc.
This commit is contained in:
Barnabás Pőcze 2023-09-07 01:51:25 +02:00 • committed by Wim Taymans
parent 1110dbb7c1
commit 53ce1ee576
1 changed files with 154 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

307
spa/plugins/v4l2/v4l2-udev.c
View file

@ -33,10 +33,8 @@
#define ACTION_DISABLE 2 #define ACTION_DISABLE 2
struct device { struct device {
struct impl *impl;
uint32_t id; uint32_t id;
struct udev_device *dev; struct udev_device *dev;
struct spa_source notify;
unsigned int accessible:1; unsigned int accessible:1;
unsigned int ignored:1; unsigned int ignored:1;
unsigned int emitted:1; unsigned int emitted:1;
@ -61,79 +59,66 @@ struct impl {
uint32_t n_devices; uint32_t n_devices;
struct spa_source source; struct spa_source source;
struct spa_source notify;
}; };
static int stop_inotify(struct device *dev); static int impl_udev_open(struct impl *this)
static int start_inotify(struct device *dev);
static int impl_udev_open(struct impl *impl)
{ {
if (impl->udev == NULL) { if (this->udev == NULL) {
impl->udev = udev_new(); this->udev = udev_new();
if (impl->udev == NULL) if (this->udev == NULL)
return -ENOMEM; return -ENOMEM;
} }
return 0; return 0;
} }
static int impl_udev_close(struct impl *impl) static int impl_udev_close(struct impl *this)
{ {
if (impl->udev != NULL) if (this->udev != NULL)
udev_unref(impl->udev); udev_unref(this->udev);
impl->udev = NULL; this->udev = NULL;
return 0; 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; struct device *device;
if (impl->n_devices >= MAX_DEVICES) if (this->n_devices >= MAX_DEVICES)
return NULL; return NULL;
device = &impl->devices[impl->n_devices++]; device = &this->devices[this->n_devices++];
spa_zero(*device); spa_zero(*device);
device->impl = impl;
device->notify.fd = -1;
device->id = id; device->id = id;
udev_device_ref(dev); udev_device_ref(dev);
device->dev = dev; device->dev = dev;
start_inotify(device);
return 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; uint32_t i;
for (i = 0; i < impl->n_devices; i++) { for (i = 0; i < this->n_devices; i++) {
if (impl->devices[i].id == id) if (this->devices[i].id == id)
return &impl->devices[i]; return &this->devices[i];
} }
return NULL; return NULL;
} }
static void clear_device(struct device *device) static void remove_device(struct impl *this, struct device *device)
{ {
stop_inotify(device);
if (device->dev)
udev_device_unref(device->dev); udev_device_unref(device->dev);
*device = this->devices[--this->n_devices];
} }
static void remove_device(struct device *device) static void clear_devices(struct impl *this)
{
struct impl *impl = device->impl;
clear_device(device);
*device = impl->devices[--impl->n_devices];
}
static void clear_devices(struct impl *impl)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < impl->n_devices; i++) for (i = 0; i < this->n_devices; i++)
clear_device(&impl->devices[i]); udev_device_unref(this->devices[i].dev);
impl->n_devices = 0; 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; const char *str;
@ -229,9 +214,8 @@ static void unescape(const char *src, char *dst)
*d = 0; *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; struct spa_device_object_info info;
uint32_t id = device->id; uint32_t id = device->id;
struct udev_device *dev = device->dev; 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); items[n_items++] = SPA_DICT_ITEM_INIT(SPA_KEY_DEVICE_CAPABILITIES, str);
} }
info.props = &SPA_DICT_INIT(items, n_items); 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; device->emitted = true;
return 1; return 1;
} }
static bool check_access(struct device *device) static bool check_access(struct impl *this, struct device *device)
{ {
char path[128]; char path[128];
snprintf(path, sizeof(path), "/dev/video%u", device->id); snprintf(path, sizeof(path), "/dev/video%u", device->id);
device->accessible = access(path, R_OK|W_OK) >= 0; 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; 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; uint32_t id;
struct device *device; struct device *device;
bool emitted; bool emitted;
if ((id = get_device_id(impl, dev)) == SPA_ID_INVALID) if ((id = get_device_id(this, dev)) == SPA_ID_INVALID)
return; return;
device = find_device(impl, id); device = find_device(this, id);
if (device && device->ignored) if (device && device->ignored)
return; return;
switch (action) { switch (action) {
case ACTION_ADD: case ACTION_ADD:
if (device == NULL) if (device == NULL)
device = add_device(impl, id, dev); device = add_device(this, id, dev);
if (device == NULL) if (device == NULL)
return; return;
if (!check_access(device)) if (!check_access(this, device))
return; return;
else emit_object_info(this, device);
emit_object_info(device);
break; break;
case ACTION_REMOVE: case ACTION_REMOVE:
if (device == NULL) if (device == NULL)
return; return;
emitted = device->emitted; emitted = device->emitted;
remove_device(device); remove_device(this, device);
if (emitted) if (emitted)
spa_device_emit_object_info(&impl->hooks, id, NULL); spa_device_emit_object_info(&this->hooks, id, NULL);
break; break;
case ACTION_DISABLE: case ACTION_DISABLE:
@ -387,16 +370,27 @@ static void process_device(struct impl *impl, uint32_t action, struct udev_devic
return; return;
if (device->emitted) { if (device->emitted) {
device->emitted = false; device->emitted = false;
spa_device_emit_object_info(&impl->hooks, id, NULL); spa_device_emit_object_info(&this->hooks, id, NULL);
} }
break; 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) static void impl_on_notify_events(struct spa_source *source)
{ {
struct device *dev = source->data; bool deleted = false;
struct impl *impl = dev->impl; struct impl *this = source->data;
union { union {
unsigned char name[sizeof(struct inotify_event) + NAME_MAX + 1]; unsigned char name[sizeof(struct inotify_event) + NAME_MAX + 1];
struct inotify_event e; /* for appropriate alignment */ 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; for (p = &buf; p < e;
p = SPA_PTROFF(p, sizeof(struct inotify_event) + event->len, void)) { p = SPA_PTROFF(p, sizeof(struct inotify_event) + event->len, void)) {
unsigned int id;
struct device *device;
event = (const struct inotify_event *) p; event = (const struct inotify_event *) p;
if ((event->mask & IN_ATTRIB)) { if ((event->mask & IN_ATTRIB)) {
bool access; bool access;
access = check_access(dev); if (sscanf(event->name, "video%u", &id) != 1)
if (access && !dev->emitted) continue;
process_device(impl, ACTION_ADD, dev->dev); if ((device = find_device(this, id)) == NULL)
else if (!access && dev->emitted) continue;
process_device(impl, ACTION_DISABLE, dev->dev); 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; int res, notify_fd;
char name[32];
if (dev->notify.fd != -1) if (this->notify.fd != -1)
return 0; return 0;
if ((notify_fd = inotify_init1(IN_CLOEXEC | IN_NONBLOCK)) < 0) if ((notify_fd = inotify_init1(IN_CLOEXEC | IN_NONBLOCK)) < 0)
return -errno; return -errno;
snprintf(name, sizeof(name), "/dev/video%u", dev->id); res = inotify_add_watch(notify_fd, "/dev",
IN_ATTRIB | IN_CLOSE_WRITE | IN_DELETE_SELF | IN_MOVE_SELF);
res = inotify_add_watch(notify_fd, name, IN_ATTRIB | IN_CLOSE_WRITE);
if (res < 0) { if (res < 0) {
res = -errno; res = -errno;
close(notify_fd); close(notify_fd);
if (res == -ENOENT) { 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; 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; return res;
} }
spa_log_info(impl->log, "start inotify for %s", name); spa_log_info(this->log, "start inotify");
dev->notify.func = impl_on_notify_events; this->notify.func = impl_on_notify_events;
dev->notify.data = dev; this->notify.data = this;
dev->notify.fd = notify_fd; this->notify.fd = notify_fd;
dev->notify.mask = SPA_IO_IN | SPA_IO_ERR; 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; 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) static void impl_on_fd_events(struct spa_source *source)
{ {
struct impl *impl = source->data; struct impl *this = source->data;
struct udev_device *dev; struct udev_device *dev;
const char *action; const char *action;
dev = udev_monitor_receive_device(impl->umonitor); dev = udev_monitor_receive_device(this->umonitor);
if (dev == NULL) if (dev == NULL)
return; return;
if ((action = udev_device_get_action(dev)) == NULL) if ((action = udev_device_get_action(dev)) == NULL)
action = "change"; 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") || if (spa_streq(action, "add") ||
spa_streq(action, "change")) { spa_streq(action, "change")) {
process_device(impl, ACTION_ADD, dev); process_device(this, ACTION_ADD, dev);
} else if (spa_streq(action, "remove")) { } else if (spa_streq(action, "remove")) {
process_device(impl, ACTION_REMOVE, dev); process_device(this, ACTION_REMOVE, dev);
} }
udev_device_unref(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; return 0;
impl->umonitor = udev_monitor_new_from_netlink(impl->udev, "udev"); this->umonitor = udev_monitor_new_from_netlink(this->udev, "udev");
if (impl->umonitor == NULL) if (this->umonitor == NULL)
return -ENOMEM; return -ENOMEM;
udev_monitor_filter_add_match_subsystem_devtype(impl->umonitor, udev_monitor_filter_add_match_subsystem_devtype(this->umonitor,
"video4linux", NULL); "video4linux", NULL);
udev_monitor_enable_receiving(impl->umonitor); udev_monitor_enable_receiving(this->umonitor);
impl->source.func = impl_on_fd_events; this->source.func = impl_on_fd_events;
impl->source.data = impl; this->source.data = this;
impl->source.fd = udev_monitor_get_fd(impl->umonitor); this->source.fd = udev_monitor_get_fd(this->umonitor);
impl->source.mask = SPA_IO_IN | SPA_IO_ERR; this->source.mask = SPA_IO_IN | SPA_IO_ERR;
spa_log_debug(impl->log, "monitor %p", impl->umonitor); spa_log_debug(this->log, "monitor %p", this->umonitor);
spa_loop_add_source(impl->main_loop, &impl->source); spa_loop_add_source(this->main_loop, &this->source);
if ((res = start_inotify(this)) < 0)
return res;
return 0; 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; return 0;
clear_devices(impl); clear_devices (this);
spa_loop_remove_source(impl->main_loop, &impl->source); spa_loop_remove_source(this->main_loop, &this->source);
udev_monitor_unref(impl->umonitor); udev_monitor_unref(this->umonitor);
impl->umonitor = NULL; this->umonitor = NULL;
stop_inotify(this);
return 0; return 0;
} }
static int enum_devices(struct impl *impl) static int enum_devices(struct impl *this)
{ {
struct udev_enumerate *enumerate; struct udev_enumerate *enumerate;
struct udev_list_entry *devices; struct udev_list_entry *devices;
enumerate = udev_enumerate_new(impl->udev); enumerate = udev_enumerate_new(this->udev);
if (enumerate == NULL) if (enumerate == NULL)
return -ENOMEM; return -ENOMEM;
@ -559,11 +558,11 @@ static int enum_devices(struct impl *impl)
devices = udev_list_entry_get_next(devices)) { devices = udev_list_entry_get_next(devices)) {
struct udev_device *dev; 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) if (dev == NULL)
continue; continue;
process_device(impl, ACTION_ADD, dev); process_device(this, ACTION_ADD, dev);
udev_device_unref(dev); udev_device_unref(dev);
} }
@ -578,24 +577,24 @@ static const struct spa_dict_item device_info_items[] = {
{ SPA_KEY_API_UDEV_MATCH, "video4linux" }, { 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) if (full)
impl->info.change_mask = impl->info_all; this->info.change_mask = this->info_all;
if (impl->info.change_mask) { if (this->info.change_mask) {
impl->info.props = &SPA_DICT_INIT_ARRAY(device_info_items); this->info.props = &SPA_DICT_INIT_ARRAY(device_info_items);
spa_device_emit_info(&impl->hooks, &impl->info); spa_device_emit_info(&this->hooks, &this->info);
impl->info.change_mask = old; this->info.change_mask = old;
} }
} }
static void impl_hook_removed(struct spa_hook *hook) static void impl_hook_removed(struct spa_hook *hook)
{ {
struct impl *impl = hook->priv; struct impl *this = hook->priv;
if (spa_hook_list_is_empty(&impl->hooks)) { if (spa_hook_list_is_empty(&this->hooks)) {
stop_monitor(impl); stop_monitor(this);
impl_udev_close(impl); 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) const struct spa_device_events *events, void *data)
{ {
int res; int res;
struct impl *impl = object; struct impl *this = object;
struct spa_hook_list save; 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); spa_return_val_if_fail(events != NULL, -EINVAL);
if ((res = impl_udev_open(impl)) < 0) if ((res = impl_udev_open(this)) < 0)
return res; 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; return res;
if ((res = start_monitor(impl)) < 0) if ((res = start_monitor(this)) < 0)
return res; return res;
spa_hook_list_join(&impl->hooks, &save); spa_hook_list_join(&this->hooks, &save);
listener->removed = impl_hook_removed; listener->removed = impl_hook_removed;
listener->priv = impl; listener->priv = this;
return 0; 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) 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(handle != NULL, -EINVAL);
spa_return_val_if_fail(interface != 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)) if (spa_streq(type, SPA_TYPE_INTERFACE_Device))
*interface = &impl->device; *interface = &this->device;
else else
return -ENOENT; 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) static int impl_clear(struct spa_handle *handle)
{ {
struct impl *impl = (struct impl *) handle; struct impl *this = (struct impl *) handle;
stop_monitor(impl); stop_monitor(this);
impl_udev_close(impl); impl_udev_close(this);
return 0; return 0;
} }
@ -675,7 +674,7 @@ impl_init(const struct spa_handle_factory *factory,
const struct spa_support *support, const struct spa_support *support,
uint32_t n_support) uint32_t n_support)
{ {
struct impl *impl; struct impl *this;
spa_return_val_if_fail(factory != NULL, -EINVAL); spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(handle != 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->get_interface = impl_get_interface;
handle->clear = impl_clear; handle->clear = impl_clear;
impl = (struct impl *) handle; this = (struct impl *) handle;
impl->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log); this->notify.fd = -1;
impl->main_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Loop);
if (impl->main_loop == NULL) { this->log = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Log);
spa_log_error(impl->log, "a main-loop is needed"); this->main_loop = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_Loop);
if (this->main_loop == NULL) {
spa_log_error(this->log, "a main-loop is needed");
return -EINVAL; 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_TYPE_INTERFACE_Device,
SPA_VERSION_DEVICE, SPA_VERSION_DEVICE,
&impl_device, impl); &impl_device, this);
impl->info = SPA_DEVICE_INFO_INIT(); this->info = SPA_DEVICE_INFO_INIT();
impl->info_all = SPA_DEVICE_CHANGE_MASK_FLAGS | this->info_all = SPA_DEVICE_CHANGE_MASK_FLAGS |
SPA_DEVICE_CHANGE_MASK_PROPS; SPA_DEVICE_CHANGE_MASK_PROPS;
impl->info.flags = 0; this->info.flags = 0;
return 0; return 0;
} }