Thread.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef THREAD_H
#define THREAD_H

#ifdef THREADS

#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Event.h"
#include "pedigree/kernel/process/SchedulingAlgorithm.h"
#include "pedigree/kernel/processor/ProcessorInformation.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/RequestQueue.h"
#include "pedigree/kernel/utilities/SharedPointer.h"
#include "pedigree/kernel/utilities/new"

class ExtensibleBitmap;
class Process;

#define THREAD_TLS_SIZE 0x1000

class EXPORTED_PUBLIC Thread
{
    friend class PerProcessorScheduler;
    // To set uninterruptible state.
    friend class Uninterruptible;

  public:
    enum Status
    {
        Ready,
        Running,
        Sleeping,
        Zombie,
        AwaitingJoin,
        Suspended,  
    };

    enum DebugState
    {
        None,
        SemWait,
        CondWait,
        Joining
    };

    enum WakeReason
    {
        NotWoken,  // can be used to check if a reason has been set yet
        WokenByAlarm,
        WokenByEvent,
        WokenBecauseTerminating,
        WokenBecauseUnwinding,
        Unknown
    };

    typedef int (*ThreadStartFunc)(void *);

    Thread(
        Process *pParent, ThreadStartFunc pStartFunction, void *pParam,
        void *pStack = 0, bool semiUser = false, bool bDontPickCore = false,
        bool delayedStart = false);

    Thread(Process *pParent);

    Thread(Process *pParent, SyscallState &state, bool delayedStart = false);

    virtual ~Thread();

    void shutdown();

    /* Forces the thread to run on the bootstrap processor. */
    void forceToStartupProcessor();

    SchedulerState &state();

    SchedulerState &pushState();

    void popState(bool clean = true);

    VirtualAddressSpace::Stack *getStateUserStack();

    void setStateUserStack(VirtualAddressSpace::Stack *st);

    size_t getStateLevel() const;

    void allocateStackAtLevel(size_t stateLevel);

    void setKernelStack();

    void pokeState(size_t stateLevel, SchedulerState &state);

    Process *getParent() const
    {
        return m_pParent;
    }

    void setParent(Process *p)
    {
        m_pParent = p;
    }

    Status getStatus() const
    {
        return m_Status;
    }

    void setStatus(Status s);

    int getExitCode()
    {
        return m_ExitCode;
    }

    void *getKernelStack();

    size_t getId()
    {
        return m_Id;
    }

    size_t getErrno()
    {
        return m_Errno;
    }

    void setErrno(size_t err)
    {
        m_Errno = err;
    }

    bool wasInterrupted()
    {
        return m_bInterrupted;
    }

    void setInterrupted(bool b)
    {
        m_bInterrupted = b;
    }

    enum UnwindType
    {
        Continue = 0,           
        ReleaseBlockingThread,  
        Exit                    
    };

    UnwindType getUnwindState()
    {
        return m_UnwindState;
    }
    void setUnwindState(UnwindType ut)
    {
        m_UnwindState = ut;

        if (ut != Continue)
        {
            reportWakeup(WokenBecauseUnwinding);
        }
    }

    void setBlockingThread(Thread *pT)
    {
        m_StateLevels[getStateLevel()].m_pBlockingThread = pT;
    }
    Thread *getBlockingThread(size_t level = ~0UL)
    {
        if (level == ~0UL)
            level = getStateLevel();
        return m_StateLevels[level].m_pBlockingThread;
    }

    DebugState getDebugState(uintptr_t &address)
    {
        address = m_DebugStateAddress;
        return m_DebugState;
    }
    void setDebugState(DebugState state, uintptr_t address)
    {
        m_DebugState = state;
        m_DebugStateAddress = address;
    }

    Spinlock &getLock()
    {
        return m_Lock;
    }

    bool sendEvent(Event *pEvent);

    void inhibitEvent(size_t eventNumber, bool bInhibit);

    void cullEvent(Event *pEvent);

    void cullEvent(size_t eventNumber);

    Event *getNextEvent();

    bool hasEvents();

    bool hasEvent(Event *pEvent);
    bool hasEvent(size_t eventNumber);

    void setPriority(size_t p)
    {
        m_Priority = p;
    }
    size_t getPriority()
    {
        return m_Priority;
    }

    void addRequest(RequestQueue::Request *req);

    void removeRequest(RequestQueue::Request *req);

    void unexpectedExit();

    uintptr_t getTlsBase();

    void resetTlsBase();

    void setTlsBase(uintptr_t base);

    inline
#ifdef MULTIPROCESSOR
        ProcessorId
#else
        size_t
#endif
        getCpuId()
    {
        return m_ProcId;
    }

    inline void setCpuId(
#ifdef MULTIPROCESSOR
        ProcessorId
#else
        size_t
#endif
            id)
    {
        m_ProcId = id;
    }

    bool join();

    bool detach();

    bool detached() const
    {
        return m_bDetached;
    }

    static void threadExited() NORETURN;

    bool isInterruptible();

    void addWakeupWatcher(WakeReason *watcher);

    void removeWakeupWatcher(WakeReason *watcher);

    class PerProcessorScheduler *getScheduler() const;

  protected:
    void setScheduler(class PerProcessorScheduler *pScheduler);

    void setInterruptible(bool state);

  private:
    Thread(const Thread &);
    Thread &operator=(const Thread &);

    void cleanStateLevel(size_t level);

    void reportWakeup(WakeReason reason);
    void reportWakeupUnlocked(WakeReason reason);

    struct StateLevel
    {
        StateLevel();
        ~StateLevel();

        StateLevel(const StateLevel &s);
        StateLevel &operator=(const StateLevel &s);

        SchedulerState *m_State;

        VirtualAddressSpace::Stack *m_pKernelStack;

        VirtualAddressSpace::Stack *m_pUserStack;

        VirtualAddressSpace::Stack *m_pAuxillaryStack;

        SharedPointer<ExtensibleBitmap> m_InhibitMask;

        Thread *m_pBlockingThread;
    };

    size_t m_nStateLevel = 0;

    Process *m_pParent = nullptr;

    void *m_pAllocatedStack = nullptr;

    size_t m_Id = 0;

    size_t m_Errno = 0;

    uintptr_t m_DebugStateAddress = 0;

    class PerProcessorScheduler *m_pScheduler = nullptr;

    size_t m_Priority = DEFAULT_PRIORITY;

    void *m_pTlsBase = nullptr;

#ifdef MULTIPROCESSOR
    ProcessorId
#else
    size_t
#endif
        m_ProcId = 0;

    Thread *m_pWaiter = nullptr;

    Spinlock m_Lock;

    Spinlock m_ConcurrencyLock;

    List<Event *> m_EventQueue;

    List<RequestQueue::Request *> m_PendingRequests;

    List<WakeReason *> m_WakeWatchers;

    StateLevel m_StateLevels[MAX_NESTED_EVENTS];

    volatile Status m_Status = Ready;

    int m_ExitCode = 0;

    DebugState m_DebugState = None;

    UnwindType m_UnwindState = Continue;

    bool m_bInterrupted = false;

    bool m_bTlsBaseOverride = false;

    bool m_bRemovingRequests = false;

    bool m_bDetached = false;

    bool m_bInterruptible = true;
};

#endif

#endif