/*
- * Copyright (C) 2016, 2017, 2018 "IoT.bzh"
+ * Copyright (C) 2016-2019 "IoT.bzh"
* Author José Bollo <jose.bollo@iot.bzh>
*
* Licensed under the Apache License, Version 2.0 (the "License");
#define _GNU_SOURCE
-#if defined(NO_JOBS_WATCHDOG)
-# define HAS_WATCHDOG 0
-#else
-# define HAS_WATCHDOG 1
-#endif
-
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/eventfd.h>
#include <systemd/sd-event.h>
-#include "fdev.h"
-#if HAS_WATCHDOG
-#include <systemd/sd-daemon.h>
-#endif
#include "jobs.h"
+#include "evmgr.h"
#include "sig-monitor.h"
#include "verbose.h"
-
-#if defined(REMOVE_SYSTEMD_EVENT)
-#include "fdev-epoll.h"
-#endif
+#include "systemd.h"
#define EVENT_TIMEOUT_TOP ((uint64_t)-1)
#define EVENT_TIMEOUT_CHILD ((uint64_t)10000)
unsigned dropped: 1; /**< is removed ? */
};
-/** Description of handled event loops */
-struct evloop
-{
- unsigned state; /**< encoded state */
- int efd; /**< event notification */
- struct sd_event *sdev; /**< the systemd event loop */
- struct fdev *fdev; /**< handling of events */
- struct thread *holder; /**< holder of the evloop */
-};
-
-#define EVLOOP_STATE_WAIT 1U
-#define EVLOOP_STATE_RUN 2U
-
/** Description of threads */
struct thread
{
static struct job *free_jobs;
/* event loop */
-static struct evloop evloop;
-
-#if defined(REMOVE_SYSTEMD_EVENT)
-static struct fdev_epoll *fdevepoll;
-static int waitevt;
-#endif
+static struct evmgr *evmgr;
/**
* Create a new job with the given parameters
job->callback(SIGABRT, job->arg);
}
-#if defined(REMOVE_SYSTEMD_EVENT)
-/**
- * Gets a fdev_epoll item.
- * @return a fdev_epoll or NULL in case of error
- */
-static struct fdev_epoll *get_fdevepoll()
-{
- struct fdev_epoll *result;
-
- result = fdevepoll;
- if (!result)
- result = fdevepoll = fdev_epoll_create();
-
- return result;
-}
-#endif
-
-/**
- * Monitored normal callback for events.
- * This function is called by the monitor
- * to run the event loop when the safe environment
- * is set.
- * @param signum 0 on normal flow or the number
- * of the signal that interrupted the normal
- * flow
- * @param arg the events to run
- */
-static void evloop_run(int signum, void *arg)
-{
- int rc;
- struct sd_event *se;
-
- if (!signum) {
- se = evloop.sdev;
- rc = sd_event_prepare(se);
- if (rc < 0) {
- errno = -rc;
- CRITICAL("sd_event_prepare returned an error (state: %d): %m", sd_event_get_state(se));
- abort();
- } else {
- if (rc == 0) {
- rc = sd_event_wait(se, (uint64_t)(int64_t)-1);
- if (rc < 0) {
- errno = -rc;
- ERROR("sd_event_wait returned an error (state: %d): %m", sd_event_get_state(se));
- }
- }
- evloop.state = EVLOOP_STATE_RUN;
- if (rc > 0) {
- rc = sd_event_dispatch(se);
- if (rc < 0) {
- errno = -rc;
- ERROR("sd_event_dispatch returned an error (state: %d): %m", sd_event_get_state(se));
- }
- }
- }
- }
-}
-
-/**
- * Internal callback for evloop management.
- * The effect of this function is hidden: it exits
- * the waiting poll if any.
- */
-static void evloop_on_efd_event()
-{
- uint64_t x;
- read(evloop.efd, &x, sizeof x);
-}
-
/**
* wakeup the event loop if needed by sending
* an event.
*/
static void evloop_wakeup()
{
- uint64_t x;
-
- if (evloop.state & EVLOOP_STATE_WAIT) {
- x = 1;
- write(evloop.efd, &x, sizeof x);
- }
+ if (evmgr)
+ evmgr_wakeup(evmgr);
}
/**
{
struct thread *nh, *ct = current_thread;
- if (evloop.holder == ct) {
+ if (ct && evmgr && evmgr_release_if(evmgr, ct)) {
nh = ct->nholder;
- evloop.holder = nh;
- if (nh)
+ ct->nholder = 0;
+ if (nh) {
+ evmgr_try_hold(evmgr, nh);
pthread_cond_signal(nh->cwhold);
+ }
}
}
*/
static int evloop_get()
{
- struct thread *ct = current_thread;
-
- if (evloop.holder)
- return evloop.holder == ct;
-
- ct->nholder = NULL;
- evloop.holder = ct;
- return 1;
+ return evmgr && evmgr_try_hold(evmgr, current_thread);
}
/**
*/
static void evloop_acquire()
{
- struct thread **pwait, *ct;
+ struct thread *pwait, *ct;
pthread_cond_t cond;
/* try to get the evloop */
pthread_cond_init(&cond, NULL);
/* queue current thread in holder list */
- pwait = &evloop.holder;
- while (*pwait)
- pwait = &(*pwait)->nholder;
- *pwait = ct;
+ pwait = evmgr_holder(evmgr);
+ while (pwait->nholder)
+ pwait = pwait->nholder;
+ pwait->nholder = ct;
/* wake up the evloop */
evloop_wakeup();
}
}
-#if defined(REMOVE_SYSTEMD_EVENT)
-/**
- * Monitored normal loop for waiting events.
- * @param signum 0 on normal flow or the number
- * of the signal that interrupted the normal
- * flow
- * @param arg the events to run
- */
-static void monitored_wait_and_dispatch(int signum, void *arg)
-{
- struct fdev_epoll *fdev_epoll = arg;
- if (!signum) {
- fdev_epoll_wait_and_dispatch(fdev_epoll, -1);
- }
-}
-#endif
-
/**
* Enter the thread
* @param me the description of the thread to enter
*/
static void thread_enter(volatile struct thread *me)
{
+ evloop_release();
/* initialize description of itself and link it in the list */
me->tid = pthread_self();
me->stop = 0;
me->waits = 0;
+ me->nholder = 0;
me->upper = current_thread;
me->next = threads;
threads = (struct thread*)me;
/* release the run job */
job_release(job);
-#if !defined(REMOVE_SYSTEMD_EVENT)
/* no job, check event loop wait */
} else if (evloop_get()) {
- if (evloop.state != 0) {
+ if (!evmgr_can_run(evmgr)) {
/* busy ? */
CRITICAL("Can't enter dispatch while in dispatch!");
abort();
}
/* run the events */
- evloop.state = EVLOOP_STATE_RUN|EVLOOP_STATE_WAIT;
pthread_mutex_unlock(&mutex);
- sig_monitor(0, evloop_run, NULL);
+ sig_monitor(0, (void(*)(int,void*))evmgr_job_run, evmgr);
pthread_mutex_lock(&mutex);
- evloop.state = 0;
} else {
/* no job and no event loop */
running--;
pthread_cond_wait(&cond, &mutex);
me->waits = 0;
running++;
-#else
- } else if (waitevt) {
- /* no job and not events */
- running--;
- if (!running)
- ERROR("Entering job deep sleep! Check your bindings.");
- me->waits = 1;
- pthread_cond_wait(&cond, &mutex);
- me->waits = 0;
- running++;
- } else {
- /* wait for events */
- waitevt = 1;
- pthread_mutex_unlock(&mutex);
- sig_monitor(0, monitored_wait_and_dispatch, get_fdevepoll());
- pthread_mutex_lock(&mutex);
- waitevt = 0;
-#endif
}
}
/* cleanup */
}
/**
- * Internal callback for evloop management.
- * The effect of this function is hidden: it exits
- * the waiting poll if any. Then it wakes up a thread
- * awaiting the evloop using signal.
- */
-static int on_evloop_efd(sd_event_source *s, int fd, uint32_t revents, void *userdata)
-{
- evloop_on_efd_event();
- return 1;
-}
-
-/* temporary hack */
-#if !defined(REMOVE_SYSTEMD_EVENT)
-__attribute__((unused))
-#endif
-static void evloop_callback(void *arg, uint32_t event, struct fdev *fdev)
-{
- sig_monitor(0, evloop_run, arg);
-}
-
-/**
- * Gets a sd_event item for the current thread.
- * @return a sd_event or NULL in case of error
- */
-static struct sd_event *get_sd_event_locked()
-{
- int rc;
-
- /* creates the evloop on need */
- if (!evloop.sdev) {
- /* start the creation */
- evloop.state = 0;
- /* creates the eventfd for waking up polls */
- evloop.efd = eventfd(0, EFD_CLOEXEC|EFD_SEMAPHORE);
- if (evloop.efd < 0) {
- ERROR("can't make eventfd for events");
- goto error1;
- }
- /* create the systemd event loop */
- rc = sd_event_new(&evloop.sdev);
- if (rc < 0) {
- ERROR("can't make new event loop");
- goto error2;
- }
- /* put the eventfd in the event loop */
- rc = sd_event_add_io(evloop.sdev, NULL, evloop.efd, EPOLLIN, on_evloop_efd, NULL);
- if (rc < 0) {
- ERROR("can't register eventfd");
-#if !defined(REMOVE_SYSTEMD_EVENT)
- sd_event_unref(evloop.sdev);
- evloop.sdev = NULL;
-error2:
- close(evloop.efd);
-error1:
- return NULL;
- }
-#else
- goto error3;
- }
- /* handle the event loop */
- evloop.fdev = fdev_epoll_add(get_fdevepoll(), sd_event_get_fd(evloop.sdev));
- if (!evloop.fdev) {
- ERROR("can't create fdev");
-error3:
- sd_event_unref(evloop.sdev);
-error2:
- close(evloop.efd);
-error1:
- memset(&evloop, 0, sizeof evloop);
- return NULL;
- }
- fdev_set_autoclose(evloop.fdev, 0);
- fdev_set_events(evloop.fdev, EPOLLIN);
- fdev_set_callback(evloop.fdev, evloop_callback, NULL);
-#endif
- }
-
- /* acquire the event loop */
- evloop_acquire();
-
- return evloop.sdev;
-}
-
-/**
- * Gets a sd_event item for the current thread.
- * @return a sd_event or NULL in case of error
+ * Ensure that the current running thread can control the event loop.
*/
-struct sd_event *jobs_get_sd_event()
+void jobs_acquire_event_manager()
{
- struct sd_event *result;
struct thread lt;
/* ensure an existing thread environment */
current_thread = <
}
- /* process */
+ /* lock */
pthread_mutex_lock(&mutex);
- result = get_sd_event_locked();
+
+ /* creates the evloop on need */
+ if (!evmgr)
+ evmgr_create(&evmgr);
+
+ /* acquire the event loop under lock */
+ if (evmgr)
+ evloop_acquire();
+
+ /* unlock */
pthread_mutex_unlock(&mutex);
/* release the faked thread environment if needed */
* A workaround to achieve that goal is for the caller to
* require the event loop a second time after having modified it.
*/
- NOTICE("Requiring sd_event loop out of binder callbacks is hazardous!");
+ NOTICE("Requiring event manager/loop from outside of binder's callback is hazardous!");
if (verbose_wants(Log_Level_Info))
sig_monitor_dumpstack();
evloop_release();
current_thread = NULL;
}
-
- return result;
-}
-
-#if defined(REMOVE_SYSTEMD_EVENT)
-/**
- * Gets the fdev_epoll item.
- * @return a fdev_epoll or NULL in case of error
- */
-struct fdev_epoll *jobs_get_fdev_epoll()
-{
- struct fdev_epoll *result;
-
- pthread_mutex_lock(&mutex);
- result = get_fdevepoll();
- pthread_mutex_unlock(&mutex);
-
- return result;
}
-#endif
/**
* Enter the jobs processing loop.
running = 0;
remains = waiter_count;
-#if HAS_WATCHDOG
- /* set the watchdog */
- if (sd_watchdog_enabled(0, NULL))
- sd_event_set_watchdog(get_sd_event_locked(), 1);
-#endif
-
/* start at least one thread: the current one */
launched = 1;
while (launched < start_count) {