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
#include <config.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"
 
struct X64UserEntryMetadata {
  uint16_t ds, es, fs, gs;
  uint64_t fsBase, gsBase, origRax;
} PACKED;
 
static_assert(sizeof(X64UserEntryMetadata) == 32, "x64 entry metadata layout");
 
#if X64 && !HOSTED
extern "C" EXPORTED_PUBLIC void pedigree_materialize_user_entry();
#endif
 
class EXPORTED_PUBLIC X64InterruptState {
  friend class X64ProcessorState;
  friend class X64InterruptManager;
  friend class PageFaultHandler;
 
 public:
  const X64UserEntryMetadata& getUserEntryMetadata() const {
    return m_UserEntry;
  }
  void setUserEntryMetadata(const X64UserEntryMetadata& metadata) {
#if X64 && !HOSTED
    pedigree_materialize_user_entry();
#endif
    m_UserEntry = metadata;
  }
  void refreshUserTlsBase();
 
  //
  // 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 uintptr_t getErrorCode() const;
  inline uint16_t getCodeSegment() const;
  inline uint16_t getStackSegment() const;
 
  inline uint64_t getFlags() const;
  inline void setFlags(uint64_t flags);
 
  static X64InterruptState* construct(class X64ProcessorState& state, bool userMode,
                                      const X64UserEntryMetadata& metadata);
 
 private:
  X64InterruptState();
  X64InterruptState(const X64InterruptState&);
  X64InterruptState& operator=(const X64InterruptState&);
  ~X64InterruptState();
 
  X64UserEntryMetadata m_UserEntry;
 
  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:
  const X64UserEntryMetadata& getUserEntryMetadata() const {
#if X64 && !HOSTED
    pedigree_materialize_user_entry();
#endif
    return m_UserEntry;
  }
  void setUserEntryMetadata(const X64UserEntryMetadata& metadata) {
#if X64 && !HOSTED
    pedigree_materialize_user_entry();
#endif
    m_UserEntry = metadata;
  }
  void refreshUserTlsBase();
 
  //
  // 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;
  EXPORTED_PUBLIC processor_register_t getRegister(size_t index) const;
  EXPORTED_PUBLIC void setRegister(size_t index, uintptr_t value);
  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;
  ALWAYS_INLINE 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:
  X64UserEntryMetadata m_UserEntry;
 
  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;
 
  uintptr_t getInstructionPointer() const {
    return 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;
}
uintptr_t X64InterruptState::getErrorCode() const {
  return m_Errorcode;
}
uint16_t X64InterruptState::getCodeSegment() const {
  return static_cast<uint16_t>(m_Cs);
}
uint16_t X64InterruptState::getStackSegment() const {
  return static_cast<uint16_t>(m_Ss);
}
 
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