x86/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_X86_STATE_H
#define KERNEL_PROCESSOR_X86_STATE_H

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

class X86InterruptState
{
    friend class X86ProcessorState;
    friend class X86InterruptManager;
    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;
    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;

    //
    // 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 uint32_t getFlags() const;
    inline void setFlags(uint32_t flags);

    static X86InterruptState *
    construct(class X86ProcessorState &state, bool userMode);

    //  private:
    X86InterruptState();
    X86InterruptState(const X86InterruptState &);
    X86InterruptState &operator=(const X86InterruptState &);
    ~X86InterruptState();

    uint32_t m_Ds;
    uint32_t m_Edi;
    uint32_t m_Esi;
    uint32_t m_Ebp;
    uint32_t m_Res;
    uint32_t m_Ebx;
    uint32_t m_Edx;
    uint32_t m_Ecx;
    uint32_t m_Eax;
    uint32_t m_IntNumber;
    uint32_t m_Errorcode;
    uint32_t m_Eip;
    uint32_t m_Cs;
    uint32_t m_Eflags;
    uint32_t m_Esp;
    uint32_t m_Ss;
} PACKED;

typedef X86InterruptState X86SyscallState;

class X86ProcessorState
{
  public:
    inline X86ProcessorState();
    inline X86ProcessorState(const X86ProcessorState &x);
    inline X86ProcessorState(const X86InterruptState &x);
    inline X86ProcessorState &operator=(const X86ProcessorState &x);
    inline X86ProcessorState &operator=(const X86InterruptState &x);
    inline ~X86ProcessorState();

    //
    // 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);

    inline void setSyscallReturnValue(uintptr_t val);

    uint32_t edi;
    uint32_t esi;
    uint32_t ebp;
    uint32_t ebx;
    uint32_t edx;
    uint32_t ecx;
    uint32_t eax;
    uint32_t eip;
    uint32_t eflags;
    uint32_t esp;
};

class __attribute__((aligned(16))) X86SchedulerState
{
  public:
    uint32_t edi;
    uint32_t esi;
    uint32_t ebx;
    uint32_t ebp;
    uint32_t esp;
    uint32_t eip;

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

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

//
// Part of the Implementation
//
uintptr_t X86InterruptState::getStackPointer() const
{
    if (kernelMode())
        return (m_Res + 20);
    return m_Esp;
}
void X86InterruptState::setStackPointer(uintptr_t stackPointer)
{
    if (!kernelMode())
        m_Esp = stackPointer;
}
uintptr_t X86InterruptState::getInstructionPointer() const
{
    return m_Eip;
}
void X86InterruptState::setInstructionPointer(uintptr_t instructionPointer)
{
    m_Eip = instructionPointer;
}
uintptr_t X86InterruptState::getBasePointer() const
{
    return m_Ebp;
}
void X86InterruptState::setBasePointer(uintptr_t basePointer)
{
    m_Ebp = basePointer;
}
size_t X86InterruptState::getRegisterSize(size_t index) const
{
    return 4;
}

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

size_t X86InterruptState::getSyscallService() const
{
    return ((m_Eax >> 16) & 0xFFFF);
}
size_t X86InterruptState::getSyscallNumber() const
{
    return (m_Eax & 0xFFFF);
}
uintptr_t X86InterruptState::getSyscallParameter(size_t n) const
{
    switch (n)
    {
        case 0:
            return m_Ebx;
        case 1:
            return m_Ecx;
        case 2:
            return m_Edx;
        case 3:
            return m_Esi;
        case 4:
            return m_Edi;
        default:
            WARNING("Bad syscall parameter requested: " << Dec << n);
            return 0;
    }
}
void X86InterruptState::setSyscallReturnValue(uintptr_t val)
{
    m_Eax = val;
}

uint32_t X86InterruptState::getFlags() const
{
    return m_Eflags;
}
void X86InterruptState::setFlags(uint32_t flags)
{
    m_Eflags = flags;
}

X86ProcessorState::X86ProcessorState()
    : edi(), esi(), ebp(), ebx(), edx(), ecx(), eax(), eip(), eflags(), esp()
{
}
X86ProcessorState::X86ProcessorState(const X86ProcessorState &x)
    : edi(x.edi), esi(x.esi), ebp(x.ebp), ebx(x.ebx), edx(x.edx), ecx(x.ecx),
      eax(x.eax), eip(x.eip), eflags(x.eflags), esp(x.esp)
{
}
X86ProcessorState::X86ProcessorState(const X86InterruptState &x)
    : edi(x.m_Edi), esi(x.m_Esi), ebp(x.m_Ebp), ebx(x.m_Ebx), edx(x.m_Edx),
      ecx(x.m_Ecx), eax(x.m_Eax), eip(x.m_Eip), eflags(x.m_Eflags),
      esp(x.getStackPointer())
{
}
X86ProcessorState &X86ProcessorState::operator=(const X86ProcessorState &x)
{
    edi = x.edi;
    esi = x.esi;
    ebp = x.ebp;
    ebx = x.ebx;
    edx = x.edx;
    ecx = x.ecx;
    eax = x.eax;
    eip = x.eip;
    eflags = x.eflags;
    esp = x.esp;
    return *this;
}
X86ProcessorState &X86ProcessorState::operator=(const X86InterruptState &x)
{
    edi = x.m_Edi;
    esi = x.m_Esi;
    ebp = x.m_Ebp;
    ebx = x.m_Ebx;
    edx = x.m_Edx;
    ecx = x.m_Ecx;
    eax = x.m_Eax;
    eip = x.m_Eip;
    eflags = x.m_Eflags;
    esp = x.getStackPointer();
    return *this;
}
X86ProcessorState::~X86ProcessorState()
{
}

uintptr_t X86ProcessorState::getStackPointer() const
{
    return esp;
}
void X86ProcessorState::setStackPointer(uintptr_t stackPointer)
{
    esp = stackPointer;
}
uintptr_t X86ProcessorState::getInstructionPointer() const
{
    return eip;
}
void X86ProcessorState::setInstructionPointer(uintptr_t instructionPointer)
{
    eip = instructionPointer;
}
uintptr_t X86ProcessorState::getBasePointer() const
{
    return ebp;
}
void X86ProcessorState::setBasePointer(uintptr_t basePointer)
{
    ebp = basePointer;
}
void X86ProcessorState::setSyscallReturnValue(uintptr_t val)
{
    eax = val;
}

#endif