x64/state.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_X64_STATE_H
#define KERNEL_PROCESSOR_X64_STATE_H

// IWYU pragma: private, include "pedigree/kernel/processor/state.h"

#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"

class X64InterruptState
{
    friend class X64ProcessorState;
    friend class X64InterruptManager;
    friend class PageFaultHandler;

  public:
    //
    // General Interface (InterruptState, SyscallState & ProcessorState)
    //
    inline uintptr_t getStackPointer() const;
    inline void setStackPointer(uintptr_t stackPointer);
    inline uintptr_t getInstructionPointer() const;
    inline void setInstructionPointer(uintptr_t instructionPointer);
    inline uintptr_t getBasePointer() const;
    inline void setBasePointer(uintptr_t basePointer);

    //
    // General Interface (InterruptState & SyscallState)
    //
    size_t getRegisterCount() const;
    processor_register_t getRegister(size_t index) const;
    void setRegister(size_t index, uintptr_t value);
    const char *getRegisterName(size_t index) const;
    inline size_t getRegisterSize(size_t index) const;

    //
    // InterruptState Interface
    //
    inline bool kernelMode() const;
    inline size_t getInterruptNumber() const;

    inline uint64_t getFlags() const;
    inline void setFlags(uint64_t flags);

    static X64InterruptState *
    construct(class X64ProcessorState &state, bool userMode);

  private:
    X64InterruptState();
    X64InterruptState(const X64InterruptState &);
    X64InterruptState &operator=(const X64InterruptState &);
    ~X64InterruptState();

    uint64_t m_R15;
    uint64_t m_R14;
    uint64_t m_R13;
    uint64_t m_R12;
    uint64_t m_R11;
    uint64_t m_R10;
    uint64_t m_R9;
    uint64_t m_R8;
    uint64_t m_Rbp;
    uint64_t m_Rsi;
    uint64_t m_Rdi;
    uint64_t m_Rdx;
    uint64_t m_Rcx;
    uint64_t m_Rbx;
    uint64_t m_Rax;
    uint64_t m_IntNumber;
    uint64_t m_Errorcode;
    uint64_t m_Rip;
    uint64_t m_Cs;
    uint64_t m_Rflags;
    uint64_t m_Rsp;
    uint64_t m_Ss;
} PACKED;

class X64SyscallState
{
    friend class X64ProcessorState;
    friend class X64SyscallManager;

  public:
    //
    // General Interface (InterruptState, SyscallState & ProcessorState)
    //
    inline uintptr_t getStackPointer() const;
    inline void setStackPointer(uintptr_t stackPointer);
    inline uintptr_t getInstructionPointer() const;
    inline void setInstructionPointer(uintptr_t instructionPointer);
    inline uintptr_t getBasePointer() const;
    inline void setBasePointer(uintptr_t basePointer);

    //
    // General Interface (InterruptState & SyscallState)
    //
    size_t getRegisterCount() const;
    processor_register_t getRegister(size_t index) const;
    const char *getRegisterName(size_t index) const;
    inline size_t getRegisterSize(size_t index) const;

    //
    // SyscallState Interface
    //
    inline size_t getSyscallService() const;
    inline size_t getSyscallNumber() const;
    inline uintptr_t getSyscallParameter(size_t n) const;
    inline void setSyscallReturnValue(uintptr_t val);
    inline void setSyscallErrno(uintptr_t val);

    inline uint64_t getFlags() const;
    inline void setFlags(uint64_t newFlags);

  public:
    uint64_t m_R15;
    uint64_t m_R14;
    uint64_t m_R13;
    uint64_t m_R12;
    uint64_t m_R10;
    uint64_t m_R9;
    uint64_t m_R8;
    uint64_t m_Rbp;

  public:
    uint64_t m_Rsi;
    uint64_t m_Rdi;

  private:
    uint64_t m_Rdx;
    uint64_t m_Rbx;
    uint64_t m_Rax;
    uint64_t m_RFlagsR11;
    uint64_t m_RipRcx;
    uint64_t m_Rsp;
} PACKED;

class X64ProcessorState
{
  public:
    inline X64ProcessorState();
    inline X64ProcessorState(const X64ProcessorState &);
    inline X64ProcessorState(const X64InterruptState &);
    inline X64ProcessorState(const X64SyscallState &);
    inline X64ProcessorState &operator=(const X64ProcessorState &);
    inline X64ProcessorState &operator=(const X64InterruptState &);
    inline X64ProcessorState &operator=(const X64SyscallState &);
    inline ~X64ProcessorState();

    //
    // General Interface (InterruptState, SyscallState & ProcessorState)
    //
    inline uintptr_t getStackPointer() const;
    inline void setStackPointer(uintptr_t stackPointer);
    inline uintptr_t getInstructionPointer() const;
    inline void setInstructionPointer(uintptr_t instructionPointer);
    inline uintptr_t getBasePointer() const;
    inline void setBasePointer(uintptr_t basePointer);

    uint64_t r15;
    uint64_t r14;
    uint64_t r13;
    uint64_t r12;
    uint64_t r11;
    uint64_t r10;
    uint64_t r9;
    uint64_t r8;
    uint64_t rbp;
    uint64_t rsi;
    uint64_t rdi;
    uint64_t rdx;
    uint64_t rcx;
    uint64_t rbx;
    uint64_t rax;
    uint64_t rip;
    uint64_t rflags;
    uint64_t rsp;
};

class X64SchedulerState
{
  public:
    uint64_t r8, r9, r10, r11, r12, r13, r14, r15;
    uint64_t rbx;
    uint64_t rbp;
    uint64_t rsp;
    uint64_t rip;

    // bit 0: Has FPU
    // bit 1: Used SSE
    uint32_t flags;

    uint8_t x87FPU_MMX_XMM_MXCSR_State[512 + 16] __attribute__((aligned(16)));
};

//
// Part of the Implementation
//
uintptr_t X64InterruptState::getStackPointer() const
{
    return m_Rsp;
}
void X64InterruptState::setStackPointer(uintptr_t stackPointer)
{
    m_Rsp = stackPointer;
}
uintptr_t X64InterruptState::getInstructionPointer() const
{
    return m_Rip;
}
void X64InterruptState::setInstructionPointer(uintptr_t instructionPointer)
{
    m_Rip = instructionPointer;
}
uintptr_t X64InterruptState::getBasePointer() const
{
    return m_Rbp;
}
void X64InterruptState::setBasePointer(uintptr_t basePointer)
{
    m_Rbp = basePointer;
}
size_t X64InterruptState::getRegisterSize(size_t index) const
{
    return 8;
}

bool X64InterruptState::kernelMode() const
{
    return (m_Cs == 0x08);
}
size_t X64InterruptState::getInterruptNumber() const
{
    return m_IntNumber;
}

uint64_t X64InterruptState::getFlags() const
{
    return m_Rflags;
}
void X64InterruptState::setFlags(uint64_t flags)
{
    m_Rflags = flags;
}

uintptr_t X64SyscallState::getStackPointer() const
{
    return m_Rsp;
}
void X64SyscallState::setStackPointer(uintptr_t stackPointer)
{
    m_Rsp = stackPointer;
}
uintptr_t X64SyscallState::getInstructionPointer() const
{
    return m_RipRcx;
}
void X64SyscallState::setInstructionPointer(uintptr_t instructionPointer)
{
    m_RipRcx = instructionPointer;
}
uintptr_t X64SyscallState::getBasePointer() const
{
    return m_Rbp;
}
void X64SyscallState::setBasePointer(uintptr_t basePointer)
{
    m_Rbp = basePointer;
}
size_t X64SyscallState::getRegisterSize(size_t index) const
{
    return 8;
}

size_t X64SyscallState::getSyscallService() const
{
    return ((m_Rax >> 16) & 0xFFFF);
}
size_t X64SyscallState::getSyscallNumber() const
{
    return (m_Rax & 0xFFFF);
}
uintptr_t X64SyscallState::getSyscallParameter(size_t n) const
{
    switch (n)
    {
        case 0:
            return m_Rbx;
        case 1:
            return m_Rdx;
        case 2:
            return m_Rsi;
        case 3:
            return m_Rdi;
        case 4:
            return m_R8;
        case 5:
            return m_R9;

        // redirection for linux syscall parameters
        case 6:
            return m_Rdi;
        case 7:
            return m_Rsi;
        case 8:
            return m_Rdx;
        case 9:
            return m_R10;
        case 10:
            return m_R8;
        case 11:
            return m_R9;

        default:
            WARNING("Bad syscall parameter requested: " << Dec << n);
            return 0;
    }
}
void X64SyscallState::setSyscallReturnValue(uintptr_t val)
{
    m_Rax = val;
}
void X64SyscallState::setSyscallErrno(uintptr_t val)
{
    m_Rbx = val;
}
uint64_t X64SyscallState::getFlags() const
{
    return m_RFlagsR11;
}
void X64SyscallState::setFlags(uint64_t newFlags)
{
    m_RFlagsR11 = newFlags;
}

X64ProcessorState::X64ProcessorState()
    : r15(), r14(), r13(), r12(), r11(), r10(), r9(), r8(), rbp(), rsi(), rdi(),
      rdx(), rcx(), rbx(), rax(), rip(), rflags(), rsp()
{
}
X64ProcessorState::X64ProcessorState(const X64ProcessorState &x)
    : r15(x.r15), r14(x.r14), r13(x.r13), r12(x.r12), r11(x.r11), r10(x.r10),
      r9(x.r9), r8(x.r8), rbp(x.rbp), rsi(x.rsi), rdi(x.rdi), rdx(x.rdx),
      rcx(x.rcx), rbx(x.rbx), rax(x.rax), rip(x.rip), rflags(x.rflags),
      rsp(x.rsp)
{
}
X64ProcessorState::X64ProcessorState(const X64InterruptState &x)
    : r15(x.m_R15), r14(x.m_R14), r13(x.m_R13), r12(x.m_R12), r11(x.m_R11),
      r10(x.m_R10), r9(x.m_R9), r8(x.m_R8), rbp(x.m_Rbp), rsi(x.m_Rsi),
      rdi(x.m_Rdi), rdx(x.m_Rdx), rcx(x.m_Rcx), rbx(x.m_Rbx), rax(x.m_Rax),
      rip(x.m_Rip), rflags(x.m_Rflags), rsp(x.m_Rsp)
{
}
X64ProcessorState::X64ProcessorState(const X64SyscallState &x)
    : r15(x.m_R15), r14(x.m_R14), r13(x.m_R13), r12(x.m_R12),
      r11(x.m_RFlagsR11), r10(x.m_R10), r9(x.m_R9), r8(x.m_R8), rbp(x.m_Rbp),
      rsi(x.m_Rsi), rdi(x.m_Rdi), rdx(x.m_Rdx), rcx(x.m_RipRcx), rbx(x.m_Rbx),
      rax(x.m_Rax), rip(x.m_RipRcx), rflags(x.m_RFlagsR11), rsp(x.m_Rsp)
{
}
X64ProcessorState &X64ProcessorState::operator=(const X64ProcessorState &x)
{
    r15 = x.r15;
    r14 = x.r14;
    r13 = x.r13;
    r12 = x.r12;
    r11 = x.r11;
    r10 = x.r10;
    r9 = x.r9;
    r8 = x.r8;
    rbp = x.rbp;
    rsi = x.rsi;
    rdi = x.rdi;
    rdx = x.rdx;
    rcx = x.rcx;
    rbx = x.rbx;
    rax = x.rax;
    rip = x.rip;
    rflags = x.rflags;
    rsp = x.rsp;
    return *this;
}
X64ProcessorState &X64ProcessorState::operator=(const X64InterruptState &x)
{
    r15 = x.m_R15;
    r14 = x.m_R14;
    r13 = x.m_R13;
    r12 = x.m_R12;
    r11 = x.m_R11;
    r10 = x.m_R10;
    r9 = x.m_R9;
    r8 = x.m_R8;
    rbp = x.m_Rbp;
    rsi = x.m_Rsi;
    rdi = x.m_Rdi;
    rdx = x.m_Rdx;
    rcx = x.m_Rcx;
    rbx = x.m_Rbx;
    rax = x.m_Rax;
    rip = x.m_Rip;
    rflags = x.m_Rflags;
    rsp = x.m_Rsp;
    return *this;
}
X64ProcessorState &X64ProcessorState::operator=(const X64SyscallState &x)
{
    r15 = x.m_R15;
    r14 = x.m_R14;
    r13 = x.m_R13;
    r12 = x.m_R12;
    r11 = x.m_RFlagsR11;
    r10 = x.m_R10;
    r9 = x.m_R9;
    r8 = x.m_R8;
    rbp = x.m_Rbp;
    rsi = x.m_Rsi;
    rdi = x.m_Rdi;
    rdx = x.m_Rdx;
    rcx = x.m_RipRcx;
    rbx = x.m_Rbx;
    rax = x.m_Rax;
    rip = x.m_RipRcx;
    rflags = x.m_RFlagsR11;
    rsp = x.m_Rsp;
    return *this;
}
X64ProcessorState::~X64ProcessorState()
{
}

uintptr_t X64ProcessorState::getStackPointer() const
{
    return rsp;
}
void X64ProcessorState::setStackPointer(uintptr_t stackPointer)
{
    rsp = stackPointer;
}
uintptr_t X64ProcessorState::getInstructionPointer() const
{
    return rip;
}
void X64ProcessorState::setInstructionPointer(uintptr_t instructionPointer)
{
    rip = instructionPointer;
}
uintptr_t X64ProcessorState::getBasePointer() const
{
    return rbp;
}
void X64ProcessorState::setBasePointer(uintptr_t basePointer)
{
    rbp = basePointer;
}

#endif