Method signal

source/kernel/kthread.cpp:155–210

}

U32 KThread::signal(U32 signal, bool wait) {
    if (signal==0) {
        return 0;
    }
    BOXEDWINE_CRITICAL_SECTION_WITH_CONDITION(this->sigWaitCond);
    if (this->sigWaitMask & signal) {
        this->foundWaitSignal = signal;
        BOXEDWINE_CONDITION_SIGNAL(this->sigWaitCond);        
        return 0;
    }
    memset(process->sigActions[signal].sigInfo, 0, sizeof(process->sigActions[signal].sigInfo));
    process->sigActions[signal].sigInfo[0] = signal;
    process->sigActions[signal].sigInfo[2] = K_SI_USER;
    process->sigActions[signal].sigInfo[3] = process->id;
    process->sigActions[signal].sigInfo[4] = process->userId;

    if (signal == K_SIGKILL || signal == K_SIGSTOP || readyForSignal(signal)) {
        // don't return -K_WAIT, we don't want to re-enter tgkill, instead we will return 0 once the thread wakes up

        // must set CPU state before runSignal since it will be stored
        if (this==KThread::currentThread()) {
            this->cpu->reg[0].u32 = 0; 
            this->cpu->eip.u32+=2;
        } 
#ifdef BOXEDWINE_MULTI_THREADED                     
        else {
            // :TODO: how to interrupt the thread (the current approache assumes the thread will yield to the signal)
            {    
                bool handled = false;

                BOXEDWINE_CONDITION cond = waitingCond;
                if (signal == K_SIGQUIT && cond) {
                    BOXEDWINE_CRITICAL_SECTION_WITH_CONDITION(cond);
                    if (waitingCond) {
                        this->startSignal = true;
                        this->runSignal(K_SIGQUIT, -1, 0);
                        BOXEDWINE_CONDITION_SIGNAL(cond);
                        handled = true;
                    }
                }
                if (!handled) {
                    BOXEDWINE_CRITICAL_SECTION_WITH_MUTEX(this->pendingSignalsMutex);
                    this->pendingSignals |= ((U64)1 << (signal - 1));
                }
            }
            if (wait && !this->terminating) {
                BOXEDWINE_CONDITION c = this->waitingCond;
                if (c) {
                    BOXEDWINE_CRITICAL_SECTION_WITH_CONDITION(c);
                    BOXEDWINE_CONDITION_SIGNAL_ALL(c);
                }
                BOXEDWINE_CRITICAL_SECTION_WITH_CONDITION(this->waitingForSignalToEndCond);
                BOXEDWINE_CONDITION_WAIT_TIMEOUT(this->waitingForSignalToEndCond, 1000);
            }
            return 0;
        }
#endif
        this->runSignal(signal, -1, 0);