#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <stdbool.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/epoll.h>

#include <sys/file.h>

#include <sys/inotify.h>

#include <sys/ioctl.h>

#include <sys/mount.h>

#include <sys/prctl.h>

#include <sys/signalfd.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/wait.h>

#include <unistd.h>

#include "sd-daemon.h"

#include "sd-event.h"

#include "alloc-util.h"

#include "cgroup-setup.h"

#include "cgroup-util.h"

#include "cpu-set-util.h"

#include "dev-setup.h"

#include "device-monitor-private.h"

#include "device-private.h"

#include "device-util.h"

#include "errno-list.h"

#include "event-util.h"

#include "fd-util.h"

#include "fileio.h"

#include "format-util.h"

#include "fs-util.h"

#include "hashmap.h"

#include "inotify-util.h"

#include "io-util.h"

#include "limits-util.h"

#include "list.h"

#include "main-func.h"

#include "mkdir.h"

#include "netlink-util.h"

#include "parse-util.h"

#include "path-util.h"

#include "pretty-print.h"

#include "proc-cmdline.h"

#include "process-util.h"

#include "selinux-util.h"

#include "signal-util.h"

#include "socket-util.h"

#include "string-util.h"

#include "strv.h"

#include "strxcpyx.h"

#include "syslog-util.h"

#include "udevd.h"

#include "udev-builtin.h"

#include "udev-ctrl.h"

#include "udev-event.h"

#include "udev-util.h"

#include "udev-watch.h"

#include "user-util.h"

#include "version.h"

#define WORKER_NUM_MAX 2048U

#define EVENT_RETRY_INTERVAL_USEC (200 * USEC_PER_MSEC)

#define EVENT_RETRY_TIMEOUT_USEC (3 * USEC_PER_MINUTE)

static bool arg_debug = false;

static int arg_daemonize = false;

static ResolveNameTiming arg_resolve_name_timing = RESOLVE_NAME_EARLY;

static unsigned arg_children_max = 0;

static usec_t arg_exec_delay_usec = 0;

static usec_t arg_event_timeout_usec = 180 * USEC_PER_SEC;

static int arg_timeout_signal = SIGKILL;

static bool arg_blockdev_read_only = false;

typedef struct Event Event;

typedef struct Worker Worker;

typedef struct Manager {

} Manager;

typedef enum EventState {

} EventState;

typedef struct Event {

} Event;

typedef enum WorkerState {

} WorkerState;

typedef struct Worker {

} Worker;

typedef enum EventResult {

} EventResult;

static Event *event_free(Event *event) {

if (!event)

return NULL;

assert(event->manager);

LIST_REMOVE(event, event->manager->events, event);

sd_device_unref(event->dev);

/* Do not use sd_event_source_disable_unref() here, as this is called by both workers and the

sd_event_source_unref(event->timeout_warning_event);

sd_event_source_unref(event->timeout_event);

if (event->worker)

event->worker->event = NULL;

return mfree(event);

}

static void event_queue_cleanup(Manager *manager, EventState match_state) {

LIST_FOREACH(event, event, manager->events) {

if (match_state != EVENT_UNDEF && match_state != event->state)

continue;

event_free(event);

}

}

static Worker *worker_free(Worker *worker) {

if (!worker)

return NULL;

assert(worker->manager);

hashmap_remove(worker->manager->workers, PID_TO_PTR(worker->pid));

sd_device_monitor_unref(worker->monitor);

event_free(worker->event);

return mfree(worker);

}

DEFINE_TRIVIAL_CLEANUP_FUNC(Worker*, worker_free);

DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(worker_hash_op, void, trivial_hash_func, trivial_compare_func, Worker, worker_free);

static void manager_clear_for_worker(Manager *manager) {

assert(manager);

/* Do not use sd_event_source_disable_unref() here, as this is called by both workers and the

manager->inotify_event = sd_event_source_unref(manager->inotify_event);

manager->kill_workers_event = sd_event_source_unref(manager->kill_workers_event);

manager->event = sd_event_unref(manager->event);

manager->workers = hashmap_free(manager->workers);

event_queue_cleanup(manager, EVENT_UNDEF);

manager->monitor = sd_device_monitor_unref(manager->monitor);

manager->ctrl = udev_ctrl_unref(manager->ctrl);

manager->worker_watch[READ_END] = safe_close(manager->worker_watch[READ_END]);

}

static Manager* manager_free(Manager *manager) {

if (!manager)

return NULL;

udev_builtin_exit();

manager_clear_for_worker(manager);

sd_netlink_unref(manager->rtnl);

hashmap_free_free_free(manager->properties);

udev_rules_free(manager->rules);

safe_close(manager->inotify_fd);

safe_close_pair(manager->worker_watch);

free(manager->cgroup);

return mfree(manager);

}

DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);

static int worker_new(Worker **ret, Manager *manager, sd_device_monitor *worker_monitor, pid_t pid) {

_cleanup_(worker_freep) Worker *worker = NULL;

int r;

assert(ret);

assert(manager);

assert(worker_monitor);

assert(pid > 1);

/* close monitor, but keep address around */

device_monitor_disconnect(worker_monitor);

worker = new(Worker, 1);

if (!worker)

return -ENOMEM;

*worker = (Worker) {

.manager = manager,

.monitor = sd_device_monitor_ref(worker_monitor),

.pid = pid,

};

r = hashmap_ensure_put(&manager->workers, &worker_hash_op, PID_TO_PTR(pid), worker);

if (r < 0)

return r;

*ret = TAKE_PTR(worker);

return 0;

}

static void manager_kill_workers(Manager *manager, bool force) {

Worker *worker;

assert(manager);

HASHMAP_FOREACH(worker, manager->workers) {

if (worker->state == WORKER_KILLED)

continue;

if (worker->state == WORKER_RUNNING && !force) {

worker->state = WORKER_KILLING;

continue;

}

worker->state = WORKER_KILLED;

(void) kill(worker->pid, SIGTERM);

}

}

static void manager_exit(Manager *manager) {

assert(manager);

manager->exit = true;

sd_notify(false,

"STOPPING=1\n"

"STATUS=Starting shutdown...");

/* close sources of new events and discard buffered events */

manager->ctrl = udev_ctrl_unref(manager->ctrl);

manager->inotify_event = sd_event_source_disable_unref(manager->inotify_event);

manager->inotify_fd = safe_close(manager->inotify_fd);

manager->monitor = sd_device_monitor_unref(manager->monitor);

/* discard queued events and kill workers */

event_queue_cleanup(manager, EVENT_QUEUED);

manager_kill_workers(manager, true);

}

static void notify_ready(void) {

int r;

r = sd_notifyf(false,

"READY=1\n"

"STATUS=Processing with %u children at max", arg_children_max);

if (r < 0)

log_warning_errno(r, "Failed to send readiness notification, ignoring: %m");

}

static void manager_reload(Manager *manager) {

assert(manager);

sd_notify(false,

"RELOADING=1\n"

"STATUS=Flushing configuration...");

manager_kill_workers(manager, false);

manager->rules = udev_rules_free(manager->rules);

udev_builtin_exit();

notify_ready();

}

static int on_kill_workers_event(sd_event_source *s, uint64_t usec, void *userdata) {

Manager *manager = userdata;

assert(manager);

log_debug("Cleanup idle workers");

manager_kill_workers(manager, false);

return 1;

}

static void device_broadcast(sd_device_monitor *monitor, sd_device *dev, int result) {

int r;

assert(dev);

/* On exit, manager->monitor is already NULL. */

if (!monitor)

return;

if (result != 0) {

(void) device_add_property(dev, "UDEV_WORKER_FAILED", "1");

switch (result) {

case EVENT_RESULT_NERRNO_MIN ... EVENT_RESULT_NERRNO_MAX: {

const char *str;

(void) device_add_propertyf(dev, "UDEV_WORKER_ERRNO", "%i", -result);

str = errno_to_name(result);

if (str)

(void) device_add_property(dev, "UDEV_WORKER_ERRNO_NAME", str);

break;

}

case EVENT_RESULT_EXIT_STATUS_BASE ... EVENT_RESULT_EXIT_STATUS_MAX:

(void) device_add_propertyf(dev, "UDEV_WORKER_EXIT_STATUS", "%i", result - EVENT_RESULT_EXIT_STATUS_BASE);

break;

case EVENT_RESULT_TRY_AGAIN:

assert_not_reached();

break;

case EVENT_RESULT_SIGNAL_BASE ... EVENT_RESULT_SIGNAL_MAX: {

const char *str;

(void) device_add_propertyf(dev, "UDEV_WORKER_SIGNAL", "%i", result - EVENT_RESULT_SIGNAL_BASE);

str = signal_to_string(result - EVENT_RESULT_SIGNAL_BASE);

if (str)

(void) device_add_property(dev, "UDEV_WORKER_SIGNAL_NAME", str);

break;

}

default:

log_device_warning(dev, "Unknown event result \"%i\", ignoring.", result);

}

}

r = device_monitor_send_device(monitor, NULL, dev);

if (r < 0)

log_device_warning_errno(dev, r,

"Failed to broadcast event to libudev listeners, ignoring: %m");

}

static int worker_send_result(Manager *manager, int result) {

assert(manager);

assert(manager->worker_watch[WRITE_END] >= 0);

return loop_write(manager->worker_watch[WRITE_END], &result, sizeof(result), false);

}

static int device_get_whole_disk(sd_device *dev, sd_device **ret_device, const char **ret_devname) {

const char *val;

int r;

assert(dev);

if (device_for_action(dev, SD_DEVICE_REMOVE))

goto irrelevant;

r = sd_device_get_subsystem(dev, &val);

if (r < 0)

return log_device_debug_errno(dev, r, "Failed to get subsystem: %m");

if (!streq(val, "block"))

goto irrelevant;

r = sd_device_get_sysname(dev, &val);

if (r < 0)

return log_device_debug_errno(dev, r, "Failed to get sysname: %m");

if (STARTSWITH_SET(val, "dm-", "md", "drbd"))

goto irrelevant;

r = sd_device_get_devtype(dev, &val);

if (r < 0 && r != -ENOENT)

return log_device_debug_errno(dev, r, "Failed to get devtype: %m");

if (r >= 0 && streq(val, "partition")) {

r = sd_device_get_parent(dev, &dev);

if (r == -ENOENT) /* The device may be already removed. */

goto irrelevant;

if (r < 0)

return log_device_debug_errno(dev, r, "Failed to get parent device: %m");

}

r = sd_device_get_devname(dev, &val);

if (r == -ENOENT)

goto irrelevant;

if (r < 0)

return log_device_debug_errno(dev, r, "Failed to get devname: %m");

if (ret_device)

*ret_device = dev;

if (ret_devname)

*ret_devname = val;

return 1;

irrelevant:

if (ret_device)

*ret_device = NULL;

if (ret_devname)

*ret_devname = NULL;

return 0;

}

static int worker_lock_whole_disk(sd_device *dev, int *ret_fd) {

_cleanup_close_ int fd = -1;

sd_device *dev_whole_disk;

const char *val;

int r;

assert(dev);

assert(ret_fd);

/* Take a shared lock on the device node; this establishes a concept of device "ownership" to

r = device_get_whole_disk(dev, &dev_whole_disk, &val);

if (r < 0)

return r;

if (r == 0)

goto nolock;

fd = sd_device_open(dev_whole_disk, O_RDONLY|O_CLOEXEC|O_NONBLOCK);

if (fd < 0) {

bool ignore = ERRNO_IS_DEVICE_ABSENT(fd);

log_device_debug_errno(dev, fd, "Failed to open '%s'%s: %m", val, ignore ? ", ignoring" : "");

if (!ignore)

return fd;

goto nolock;

}

if (flock(fd, LOCK_SH|LOCK_NB) < 0)

return log_device_debug_errno(dev, errno, "Failed to flock(%s): %m", val);

*ret_fd = TAKE_FD(fd);

return 1;

nolock:

*ret_fd = -1;

return 0;

}

static int worker_mark_block_device_read_only(sd_device *dev) {

_cleanup_close_ int fd = -1;

const char *val;

int state = 1, r;

assert(dev);

if (!arg_blockdev_read_only)

return 0;

/* Do this only once, when the block device is new. If the device is later retriggered let's not

if (!device_for_action(dev, SD_DEVICE_ADD))

return 0;

r = sd_device_get_subsystem(dev, &val);

if (r < 0)

return log_device_debug_errno(dev, r, "Failed to get subsystem: %m");

if (!streq(val, "block"))

return 0;

r = sd_device_get_sysname(dev, &val);

if (r < 0)

return log_device_debug_errno(dev, r, "Failed to get sysname: %m");

/* Exclude synthetic devices for now, this is supposed to be a safety feature to avoid modification

if (STARTSWITH_SET(val, "dm-", "md", "drbd", "loop", "nbd", "zram"))

return 0;

fd = sd_device_open(dev, O_RDONLY|O_CLOEXEC|O_NONBLOCK);

if (fd < 0)

return log_device_debug_errno(dev, fd, "Failed to open '%s', ignoring: %m", val);

if (ioctl(fd, BLKROSET, &state) < 0)

return log_device_warning_errno(dev, errno, "Failed to mark block device '%s' read-only: %m", val);

log_device_info(dev, "Successfully marked block device '%s' read-only.", val);

return 0;

}

static int worker_process_device(Manager *manager, sd_device *dev) {

_cleanup_(udev_event_freep) UdevEvent *udev_event = NULL;

_cleanup_close_ int fd_lock = -1;

int r;

assert(manager);

assert(dev);

log_device_uevent(dev, "Processing device");

udev_event = udev_event_new(dev, arg_exec_delay_usec, manager->rtnl, manager->log_level);

if (!udev_event)

return -ENOMEM;

/* If this is a block device and the device is locked currently via the BSD advisory locks,

r = worker_lock_whole_disk(dev, &fd_lock);

if (r == -EAGAIN)

return EVENT_RESULT_TRY_AGAIN;

if (r < 0)

return r;

(void) worker_mark_block_device_read_only(dev);

/* apply rules, create node, symlinks */

r = udev_event_execute_rules(

udev_event,

manager->inotify_fd,

arg_event_timeout_usec,

arg_timeout_signal,

manager->properties,

manager->rules);

if (r < 0)

return r;

udev_event_execute_run(udev_event, arg_event_timeout_usec, arg_timeout_signal);

if (!manager->rtnl)

/* in case rtnl was initialized */

manager->rtnl = sd_netlink_ref(udev_event->rtnl);

r = udev_event_process_inotify_watch(udev_event, manager->inotify_fd);

if (r < 0)

return r;

log_device_uevent(dev, "Device processed");

return 0;

}

static int worker_device_monitor_handler(sd_device_monitor *monitor, sd_device *dev, void *userdata) {

Manager *manager = userdata;

int r;

assert(dev);

assert(manager);

r = worker_process_device(manager, dev);

if (r == EVENT_RESULT_TRY_AGAIN)

/* if we couldn't acquire the flock(), then requeue the event */

log_device_debug(dev, "Block device is currently locked, requeueing the event.");

else {

if (r < 0)

log_device_warning_errno(dev, r, "Failed to process device, ignoring: %m");

/* send processed event back to libudev listeners */

device_broadcast(monitor, dev, r);

}

/* send udevd the result of the event execution */

r = worker_send_result(manager, r);

if (r < 0)

log_device_warning_errno(dev, r, "Failed to send signal to main daemon, ignoring: %m");

/* Reset the log level, as it might be changed by "OPTIONS=log_level=". */

log_set_max_level(manager->log_level);

return 1;

}

static int worker_main(Manager *_manager, sd_device_monitor *monitor, sd_device *first_device) {

_cleanup_(sd_device_unrefp) sd_device *dev = first_device;

_cleanup_(manager_freep) Manager *manager = _manager;

int r;

assert(manager);

assert(monitor);

assert(dev);

assert_se(unsetenv("NOTIFY_SOCKET") == 0);

assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, -1) >= 0);

/* Reset OOM score, we only protect the main daemon. */

r = set_oom_score_adjust(0);

if (r < 0)

log_debug_errno(r, "Failed to reset OOM score, ignoring: %m");

/* Clear unnecessary data in Manager object. */

manager_clear_for_worker(manager);

r = sd_event_new(&manager->event);

if (r < 0)

return log_error_errno(r, "Failed to allocate event loop: %m");

r = sd_event_add_signal(manager->event, NULL, SIGTERM, NULL, NULL);

if (r < 0)

return log_error_errno(r, "Failed to set SIGTERM event: %m");

r = sd_device_monitor_attach_event(monitor, manager->event);

if (r < 0)

return log_error_errno(r, "Failed to attach event loop to device monitor: %m");

r = sd_device_monitor_start(monitor, worker_device_monitor_handler, manager);

if (r < 0)

return log_error_errno(r, "Failed to start device monitor: %m");

(void) sd_event_source_set_description(sd_device_monitor_get_event_source(monitor), "worker-device-monitor");

/* Process first device */

(void) worker_device_monitor_handler(monitor, dev, manager);

r = sd_event_loop(manager->event);

if (r < 0)

return log_error_errno(r, "Event loop failed: %m");

return 0;

}

static int on_event_timeout(sd_event_source *s, uint64_t usec, void *userdata) {

Event *event = userdata;

assert(event);

assert(event->worker);

kill_and_sigcont(event->worker->pid, arg_timeout_signal);

event->worker->state = WORKER_KILLED;

log_device_error(event->dev, "Worker ["PID_FMT"] processing SEQNUM=%"PRIu64" killed", event->worker->pid, event->seqnum);

return 1;

}

static int on_event_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {

Event *event = userdata;

assert(event);

assert(event->worker);

log_device_warning(event->dev, "Worker ["PID_FMT"] processing SEQNUM=%"PRIu64" is taking a long time", event->worker->pid, event->seqnum);

return 1;

}

static void worker_attach_event(Worker *worker, Event *event) {

sd_event *e;

assert(worker);

assert(worker->manager);

assert(event);

assert(!event->worker);

assert(!worker->event);

worker->state = WORKER_RUNNING;

worker->event = event;

event->state = EVENT_RUNNING;

event->worker = worker;

e = worker->manager->event;

(void) sd_event_add_time_relative(e, &event->timeout_warning_event, CLOCK_MONOTONIC,

udev_warn_timeout(arg_event_timeout_usec), USEC_PER_SEC,

on_event_timeout_warning, event);

(void) sd_event_add_time_relative(e, &event->timeout_event, CLOCK_MONOTONIC,

arg_event_timeout_usec, USEC_PER_SEC,

on_event_timeout, event);

}

static int worker_spawn(Manager *manager, Event *event) {

_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *worker_monitor = NULL;

Worker *worker;

pid_t pid;

int r;

/* listen for new events */

r = device_monitor_new_full(&worker_monitor, MONITOR_GROUP_NONE, -1);

if (r < 0)

return r;

/* allow the main daemon netlink address to send devices to the worker */

r = device_monitor_allow_unicast_sender(worker_monitor, manager->monitor);

if (r < 0)

return log_error_errno(r, "Worker: Failed to set unicast sender: %m");

r = device_monitor_enable_receiving(worker_monitor);

if (r < 0)

return log_error_errno(r, "Worker: Failed to enable receiving of device: %m");

r = safe_fork(NULL, FORK_DEATHSIG, &pid);

if (r < 0) {

event->state = EVENT_QUEUED;

return log_error_errno(r, "Failed to fork() worker: %m");

}

if (r == 0) {

DEVICE_TRACE_POINT(worker_spawned, event->dev, getpid());

/* Worker process */

r = worker_main(manager, worker_monitor, sd_device_ref(event->dev));

log_close();

_exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);

}

r = worker_new(&worker, manager, worker_monitor, pid);

if (r < 0)

return log_error_errno(r, "Failed to create worker object: %m");

worker_attach_event(worker, event);

log_device_debug(event->dev, "Worker ["PID_FMT"] is forked for processing SEQNUM=%"PRIu64".", pid, event->seqnum);

return 0;

}

static int event_run(Event *event) {

static bool log_children_max_reached = true;

Manager *manager;

Worker *worker;

int r;

assert(event);

assert(event->manager);

log_device_uevent(event->dev, "Device ready for processing");

manager = event->manager;

HASHMAP_FOREACH(worker, manager->workers) {

if (worker->state != WORKER_IDLE)

continue;

r = device_monitor_send_device(manager->monitor, worker->monitor, event->dev);

if (r < 0) {

log_device_error_errno(event->dev, r, "Worker ["PID_FMT"] did not accept message, killing the worker: %m",

worker->pid);

(void) kill(worker->pid, SIGKILL);

worker->state = WORKER_KILLED;

continue;

}

worker_attach_event(worker, event);

return 1; /* event is now processing. */

}

if (hashmap_size(manager->workers) >= arg_children_max) {

/* Avoid spamming the debug logs if the limit is already reached and

if (log_children_max_reached && arg_children_max > 1) {

log_debug("Maximum number (%u) of children reached.", hashmap_size(manager->workers));

log_children_max_reached = false;

}

return 0; /* no free worker */

}

/* Re-enable the debug message for the next batch of events */

log_children_max_reached = true;

/* start new worker and pass initial device */

r = worker_spawn(manager, event);

if (r < 0)

return r;

return 1; /* event is now processing. */

}

static int event_is_blocked(Event *event) {

const char *subsystem, *devpath, *devpath_old = NULL;

dev_t devnum = makedev(0, 0);

Event *loop_event = NULL;

size_t devpath_len;

int r, ifindex = 0;

bool is_block;

/* lookup event for identical, parent, child device */

assert(event);

assert(event->manager);

assert(event->blocker_seqnum <= event->seqnum);

if (event->retry_again_next_usec > 0) {

usec_t now_usec;

r = sd_event_now(event->manager->event, CLOCK_BOOTTIME, &now_usec);

if (r < 0)

return r;

if (event->retry_again_next_usec <= now_usec)

return true;

}

if (event->blocker_seqnum == event->seqnum)

/* we have checked previously and no blocker found */

return false;

LIST_FOREACH(event, e, event->manager->events) {

loop_event = e;

/* we already found a later event, earlier cannot block us, no need to check again */

if (loop_event->seqnum < event->blocker_seqnum)

continue;

/* event we checked earlier still exists, no need to check again */

if (loop_event->seqnum == event->blocker_seqnum)

return true;

/* found ourself, no later event can block us */

if (loop_event->seqnum >= event->seqnum)

goto no_blocker;

/* found event we have not checked */

break;

}

assert(loop_event);

assert(loop_event->seqnum > event->blocker_seqnum &&

loop_event->seqnum < event->seqnum);

r = sd_device_get_subsystem(event->dev, &subsystem);

if (r < 0)

return r;

is_block = streq(subsystem, "block");

r = sd_device_get_devpath(event->dev, &devpath);

if (r < 0)

return r;

devpath_len = strlen(devpath);

r = sd_device_get_property_value(event->dev, "DEVPATH_OLD", &devpath_old);

if (r < 0 && r != -ENOENT)

return r;

r = sd_device_get_devnum(event->dev, &devnum);

if (r < 0 && r != -ENOENT)

return r;

r = sd_device_get_ifindex(event->dev, &ifindex);

if (r < 0 && r != -ENOENT)

return r;

/* check if queue contains events we depend on */

LIST_FOREACH(event, e, loop_event) {

size_t loop_devpath_len, common;

const char *loop_devpath;

loop_event = e;

/* found ourself, no later event can block us */

if (loop_event->seqnum >= event->seqnum)

goto no_blocker;

/* check major/minor */

if (major(devnum) != 0) {

const char *s;

dev_t d;

if (sd_device_get_subsystem(loop_event->dev, &s) < 0)

continue;

if (sd_device_get_devnum(loop_event->dev, &d) >= 0 &&

devnum == d && is_block == streq(s, "block"))

break;

}

/* check network device ifindex */

if (ifindex > 0) {

int i;

if (sd_device_get_ifindex(loop_event->dev, &i) >= 0 &&

ifindex == i)

break;

}

if (sd_device_get_devpath(loop_event->dev, &loop_devpath) < 0)

continue;

/* check our old name */

if (devpath_old && streq(devpath_old, loop_devpath))

break;

loop_devpath_len = strlen(loop_devpath);

/* compare devpath */

common = MIN(devpath_len, loop_devpath_len);

/* one devpath is contained in the other? */

if (!strneq(devpath, loop_devpath, common))

continue;

/* identical device event found */

if (devpath_len == loop_devpath_len)

break;

/* parent device event found */

if (devpath[common] == '/')

break;

/* child device event found */

if (loop_devpath[common] == '/')

break;

}

assert(loop_event);

log_device_debug(event->dev, "SEQNUM=%" PRIu64 " blocked by SEQNUM=%" PRIu64,

event->seqnum, loop_event->seqnum);

event->blocker_seqnum = loop_event->seqnum;

return true;

no_blocker:

event->blocker_seqnum = event->seqnum;

return false;

}

static int event_queue_start(Manager *manager) {

usec_t usec;

int r;

assert(manager);

if (LIST_IS_EMPTY(manager->events) ||

manager->exit || manager->stop_exec_queue)

return 0;

assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);