OSSelectWakeup.hxx

Go to the documentation of this file.

 
#ifndef _OS_OSSELECTWAKEUP_HXX_
#define _OS_OSSELECTWAKEUP_HXX_
 
#include <unistd.h>
 
#include "openmrn_features.h"
#include "utils/Atomic.hxx"
#include "os/os.h"
 
#if OPENMRN_FEATURE_DEVICE_SELECT
#include "Devtab.hxx"
#endif
 
#if OPENMRN_HAVE_PSELECT
#include <signal.h>
#endif
 
#ifdef __WINNT__
#include <winsock2.h>
#elif OPENMRN_HAVE_SELECT
#include <sys/select.h>
#endif
 
#ifdef ESP_PLATFORM
#include "sdkconfig.h"
 
#ifdef CONFIG_VFS_SUPPORT_TERMIOS
// remove defines added by arduino-esp32 core/esp32/binary.h which are
// duplicated in sys/termios.h which may be included by esp_vfs.h
#undef B110
#undef B1000000
#endif // CONFIG_VFS_SUPPORT_TERMIOS
 
#include <esp_vfs.h>
 
#endif // ESP_PLATFORM
 
void empty_signal_handler(int sig);
 
class OSSelectWakeup : private Atomic
{
public:
    OSSelectWakeup()
        : pendingWakeup_(false)
        , inSelect_(false)
    {
    }
 
    ~OSSelectWakeup()
    {
#ifdef ESP_PLATFORM
        esp_deallocate_vfs_fd();
#endif
    }
 
    os_thread_t main_thread()
    {
        return thread_;
    }
 
    void lock_to_thread()
    {
        // Gets the current thread.
        thread_ = os_thread_self();
#ifdef ESP_PLATFORM
        esp_allocate_vfs_fd();
#endif
#if OPENMRN_FEATURE_DEVICE_SELECT
        Device::select_insert(&selectInfo_);
#elif OPENMRN_HAVE_PSELECT
        // Blocks SIGUSR1 in the signal mask of the current thread.
        sigset_t usrmask;
        HASSERT(!sigemptyset(&usrmask));
        HASSERT(!sigaddset(&usrmask, WAKEUP_SIG));
        HASSERT(!sigprocmask(SIG_BLOCK, &usrmask, &origMask_));
        HASSERT(!sigdelset(&origMask_, WAKEUP_SIG));
        struct sigaction action;
        action.sa_handler = &empty_signal_handler;
        HASSERT(!sigemptyset(&action.sa_mask));
        action.sa_flags = 0;
        HASSERT(!sigaction(WAKEUP_SIG, &action, nullptr));
#endif
    }
 
    void wakeup()
    {
        bool need_wakeup = false;
        {
            AtomicHolder l(this);
            pendingWakeup_ = true;
            if (inSelect_)
            {
                need_wakeup = true;
            }
        }
        if (need_wakeup)
        {
#if OPENMRN_FEATURE_DEVICE_SELECT
            HASSERT(selectInfo_.event);
            // We cannot destroy the thread ID in the local object.
            Device::SelectInfo copy(selectInfo_);
            Device::select_wakeup(&copy);
#elif OPENMRN_HAVE_PSELECT
            pthread_kill(thread_, WAKEUP_SIG);
#elif defined(ESP_PLATFORM)
            esp_wakeup();
#elif !defined(OPENMRN_FEATURE_SINGLE_THREADED)
            DIE("need wakeup code");
#endif
        }
    }
 
    void clear_wakeup()
    {
        pendingWakeup_ = false;
    }
 
#if OPENMRN_FEATURE_RTOS_FROM_ISR
    void wakeup_from_isr()
    {
#if defined(ESP_PLATFORM)
        // On multi-core ESP32s we need to lock objects even in ISRs.
        AtomicHolder h(this);
#endif
        pendingWakeup_ = true;
        if (inSelect_)
        {
#if OPENMRN_FEATURE_DEVICE_SELECT
            HASSERT(selectInfo_.event);
            Device::SelectInfo copy(selectInfo_);
            int woken;
            Device::select_wakeup_from_isr(&copy, &woken);
            os_isr_exit_yield_test(woken);
// TODO: confirm if pthread_kill is ISR safe
//#elif OPENMRN_HAVE_PSELECT
//            pthread_kill(thread_, WAKEUP_SIG);
#elif defined(ESP_PLATFORM)
            esp_wakeup_from_isr();
#else
            DIE("need wakeup code");
#endif
        }
    }
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
 
    int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
               long long deadline_nsec);
 
private:
#ifdef ESP_PLATFORM
    void esp_allocate_vfs_fd();
    void esp_deallocate_vfs_fd();
    void esp_wakeup();
    void esp_wakeup_from_isr();
public:
    void esp_start_select(fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
                          esp_vfs_select_sem_t signal_sem);
    void esp_end_select();
 
private:
    int vfsFd_{-1};
 
    esp_vfs_select_sem_t espSem_;
 
    fd_set *exceptFds_;
 
    fd_set exceptFdsOrig_;
 
#endif // ESP_PLATFORM
 
#if OPENMRN_HAVE_PSELECT
    static const int WAKEUP_SIG = SIGUSR1;
#endif
    bool pendingWakeup_;
    bool inSelect_;
    os_thread_t thread_;
#if OPENMRN_FEATURE_DEVICE_SELECT
    Device::SelectInfo selectInfo_;
#endif
#if OPENMRN_HAVE_PSELECT
    sigset_t origMask_;
#endif
};
 
#endif // _OS_OSSELECTWAKEUP_HXX_