signals.hh

#pragma once
 
 
#include "lix/libutil/error.hh"
#include "lix/libutil/result.hh"
 
#include <kj/async.h>
#include <memory>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <signal.h>
 
#include <atomic>
#include <functional>
 
namespace nix {
 
/* User interruption. */
 
class Interrupted;
 
extern std::atomic<bool> _isInterrupted;
 
extern thread_local std::function<bool()> interruptCheck;
 
Interrupted makeInterrupted();
void _interrupted();
 
void inline checkInterrupt()
{
    if (_isInterrupted || (interruptCheck && interruptCheck()))
        _interrupted();
}
 
MakeError(Interrupted, BaseError);
 
void restoreSignals();
 

enum class DoSignalSave
{
    Save,
    DontSaveBecauseAdvancedProcess,
};

void startSignalHandlerThread(DoSignalSave doSave = DoSignalSave::Save);

void saveSignalMask();

void setChildSignalMask(sigset_t *sigs);
 
struct InterruptCallback
{
    virtual ~InterruptCallback() { };
};

std::unique_ptr<InterruptCallback> createInterruptCallback(
    std::function<void()> callback);
 
template<typename T>
kj::Promise<Result<T>> makeInterruptible(kj::Promise<Result<T>> p)
{
    auto onInterrupt = kj::newPromiseAndCrossThreadFulfiller<Result<T>>();
    auto interruptCallback = createInterruptCallback([fulfiller{onInterrupt.fulfiller.get()}] {
        fulfiller->fulfill(result::failure(std::make_exception_ptr(makeInterrupted())));
    });
    return p.attach(std::move(onInterrupt.fulfiller), std::move(interruptCallback))
        .exclusiveJoin(std::move(onInterrupt.promise));
}
 
void triggerInterrupt();

struct ReceiveInterrupts
{
    pthread_t target;
    std::unique_ptr<InterruptCallback> callback;
 
    ReceiveInterrupts()
        : target(pthread_self())
        , callback(createInterruptCallback([&]() { pthread_kill(target, SIGUSR1); }))
    { }
};
 
};