Processor.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 KERNEL_PROCESSOR_PROCESSOR_H
#define KERNEL_PROCESSOR_PROCESSOR_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/ProcessorInformation.h"  // exported
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/StaticString.h"
#if defined(MULTIPROCESSOR)
template <class T>
class Vector;
#endif

class VirtualAddressSpace;
#ifdef MULTIBOOT
class BootstrapStruct_t;
#else
struct BootstrapStruct_t;
#endif

namespace DebugFlags
{
enum FaultType
{
    InstructionFetch = 0,
    DataWrite = 1,
    IOReadWrite = 2,
    DataReadWrite = 3
};
}

#define DEBUG_BREAKPOINT_0 0x01  
#define DEBUG_BREAKPOINT_1 0x02  
#define DEBUG_BREAKPOINT_2 0x04  
#define DEBUG_BREAKPOINT_3 0x08  
#define DEBUG_REG_ACCESS \
    0x2000  
#define DEBUG_SINGLE_STEP \
    0x4000  
#define DEBUG_TASK_SWITCH \
    0x8000  

#ifdef MULTIPROCESSOR

extern void apMain() NORETURN;
#endif

class EXPORTED_PUBLIC Processor
{
    friend class Multiprocessor;
    friend class X86GdtManager;
    friend class X64GdtManager;
#ifdef THREADS
    friend class Scheduler;
#endif
  public:
    static void initialise1(const BootstrapStruct_t &Info) INITIALISATION_ONLY;
    static void initialise2(const BootstrapStruct_t &Info) INITIALISATION_ONLY;
    static void initialisationDone();
    static void deinitialise();
    static size_t isInitialised();

    static uintptr_t getBasePointer();
    static uintptr_t getStackPointer();
    static uintptr_t getInstructionPointer();

    static void switchAddressSpace(VirtualAddressSpace &AddressSpace);

    static bool saveState(SchedulerState &state)
#ifdef SYSTEM_REQUIRES_ATOMIC_CONTEXT_SWITCH
        DEPRECATED
#endif
        ;
    static void
    restoreState(SchedulerState &state, volatile uintptr_t *pLock = 0) NORETURN;
    static void
    restoreState(SyscallState &state, volatile uintptr_t *pLock = 0) NORETURN;
#ifdef SYSTEM_REQUIRES_ATOMIC_CONTEXT_SWITCH

    static void switchState(
        bool bInterrupts, SchedulerState &a, SchedulerState &b,
        volatile uintptr_t *pLock = 0);
    static void switchState(
        bool bInterrupts, SchedulerState &a, SyscallState &b,
        volatile uintptr_t *pLock = 0);
    static void saveAndJumpKernel(
        bool bInterrupts, SchedulerState &s, volatile uintptr_t *pLock,
        uintptr_t address, uintptr_t stack, uintptr_t p1 = 0, uintptr_t p2 = 0,
        uintptr_t p3 = 0, uintptr_t p4 = 0);
    static void saveAndJumpUser(
        bool bInterrupts, SchedulerState &s, volatile uintptr_t *pLock,
        uintptr_t address, uintptr_t stack, uintptr_t p1 = 0, uintptr_t p2 = 0,
        uintptr_t p3 = 0, uintptr_t p4 = 0);
#endif  // SYSTEM_REQUIRES_ATOMIC_CONTEXT_SWITCH

    static void jumpKernel(
        volatile uintptr_t *pLock, uintptr_t address, uintptr_t stack,
        uintptr_t p1 = 0, uintptr_t p2 = 0, uintptr_t p3 = 0,
        uintptr_t p4 = 0) NORETURN;
    static void jumpUser(
        volatile uintptr_t *pLock, uintptr_t address, uintptr_t stack,
        uintptr_t p1 = 0, uintptr_t p2 = 0, uintptr_t p3 = 0,
        uintptr_t p4 = 0) NORETURN;

    static void breakpoint();
    static void halt();
    static void reset();

    static size_t getDebugBreakpointCount();
    static uintptr_t getDebugBreakpoint(
        size_t nBpNumber, DebugFlags::FaultType &nFaultType, size_t &nLength,
        bool &bEnabled);
    static void enableDebugBreakpoint(
        size_t nBpNumber, uintptr_t nLinearAddress,
        DebugFlags::FaultType nFaultType, size_t nLength);
    static void disableDebugBreakpoint(size_t nBpNumber);
    static uintptr_t getDebugStatus();

    static void haltUntilInterrupt();
    static void pause();

    static void setInterrupts(bool bEnable);
    static bool getInterrupts();
    static void setSingleStep(bool bEnable, InterruptState &state);

#if defined(X86_COMMON)

    static uint64_t readMachineSpecificRegister(uint32_t index);
    static void writeMachineSpecificRegister(uint32_t index, uint64_t value);
    static void cpuid(
        uint32_t inEax, uint32_t inEcx, uint32_t &eax, uint32_t &ebx,
        uint32_t &ecx, uint32_t &edx);
#endif

#ifdef PPC_COMMON
    inline
#endif
        static void
        invalidate(void *pAddress);

#if defined(X86_COMMON)
    static physical_uintptr_t readCr3();
#endif

#if defined(ARMV7)

    static physical_uintptr_t readTTBR0();
    static physical_uintptr_t readTTBR1();
    static uint32_t readTTBCR();
    static void writeTTBR0(physical_uintptr_t value);
    static void writeTTBR1(physical_uintptr_t value);
    static void writeTTBCR(uint32_t value);
#endif

#if defined(MIPS_COMMON) || defined(PPC_COMMON)

    static void invalidateICache(uintptr_t nAddr);
    static void invalidateDCache(uintptr_t nAddr);
    static void flushDCache(uintptr_t nAddr);
    static void
    flushDCacheAndInvalidateICache(uintptr_t startAddr, uintptr_t endAddr);
#endif

    static void identify(HugeStaticString &str);

#if !defined(MULTIPROCESSOR)
    static ProcessorId id();
#else
    static ProcessorId id();
#endif

#if !defined(MULTIPROCESSOR)
    static ProcessorInformation &information();
#else
    static ProcessorInformation &information();
#endif

#if !defined(MULTIPROCESSOR)
    static size_t getCount();
#else
    static size_t getCount();
#endif

#ifdef PPC_COMMON
    static void
    setSegmentRegisters(uint32_t segmentBase, bool supervisorKey, bool userKey);
#endif

    static void setTlsBase(uintptr_t newBase);

    static size_t m_Initialised;

  private:
#if defined(HOSTED)

    static void _breakpoint();
    static void _reset() NORETURN;
    static void _haltUntilInterrupt();

    static bool m_bInterrupts;
#endif

#if !defined(MULTIPROCESSOR)
    static ProcessorInformation m_ProcessorInformation;
#else
    static Vector<ProcessorInformation *> m_ProcessorInformation;

    static ProcessorInformation m_SafeBspProcessorInformation;
#endif

    static size_t m_nProcessors;
};

#if defined(X86_COMMON)
#include "pedigree/kernel/processor/x86_common/Processor.h"  // IWYU pragma: export
#elif defined(MIPS_COMMON)
#include "pedigree/kernel/processor/mips_common/Processor.h"  // IWYU pragma: export
#elif defined(ARM_COMMON)
#include "pedigree/kernel/processor/arm_common/Processor.h"  // IWYU pragma: export
#elif defined(PPC_COMMON)
#include "pedigree/kernel/processor/ppc_common/Processor.h"  // IWYU pragma: export
#elif defined(HOSTED)
#include "pedigree/kernel/processor/hosted/Processor.h"  // IWYU pragma: export
#endif

#ifdef X86
#include "pedigree/kernel/processor/x86/Processor.h"  // IWYU pragma: export
#endif
#ifdef X64
#include "pedigree/kernel/processor/x64/Processor.h"  // IWYU pragma: export
#endif

class EnsureInterrupts
{
  public:
    EnsureInterrupts(bool desired);
    virtual ~EnsureInterrupts();

  private:
    bool m_bPrevious;
};

#endif