x64/state.cc

/*
 * 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.
 */
 
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/state.h"
#include "pedigree/kernel/processor/types.h"
 
static const char* X64InterruptStateRegisterName[18] = {
    "rax", "rbx", "rcx", "rdx", "rdi", "rsi", "rbp", "r8",  "r9",
    "r10", "r11", "r12", "r13", "r14", "r15", "rsp", "rip", "rflags"};
 
static const char* X64SyscallStateRegisterName[16] = {"rax", "rbx", "rdx", "rdi",   "rsi", "rbp",
                                                      "r8",  "r9",  "r10", "r12",   "r13", "r14",
                                                      "r15", "rsp", "rip", "rflags"};
 
size_t X64InterruptState::getRegisterCount() const {
  return 18;
}
processor_register_t X64InterruptState::getRegister(size_t index) const {
  if (index == 0)
    return m_Rax;
  if (index == 1)
    return m_Rbx;
  if (index == 2)
    return m_Rcx;
  if (index == 3)
    return m_Rdx;
  if (index == 4)
    return m_Rdi;
  if (index == 5)
    return m_Rsi;
  if (index == 6)
    return m_Rbp;
  if (index == 7)
    return m_R8;
  if (index == 8)
    return m_R9;
  if (index == 9)
    return m_R10;
  if (index == 10)
    return m_R11;
  if (index == 11)
    return m_R12;
  if (index == 12)
    return m_R13;
  if (index == 13)
    return m_R14;
  if (index == 14)
    return m_R15;
  if (index == 15)
    return getStackPointer();
  if (index == 16)
    return m_Rip;
  if (index == 17)
    return m_Rflags;
  return 0;
}
void X64InterruptState::setRegister(size_t index, uintptr_t value) {
  if (index == 0)
    m_Rax = value;
  if (index == 1)
    m_Rbx = value;
  if (index == 2)
    m_Rcx = value;
  if (index == 3)
    m_Rdx = value;
  if (index == 4)
    m_Rdi = value;
  if (index == 5)
    m_Rsi = value;
  if (index == 6)
    m_Rbp = value;
  if (index == 7)
    m_R8 = value;
  if (index == 8)
    m_R9 = value;
  if (index == 9)
    m_R10 = value;
  if (index == 10)
    m_R11 = value;
  if (index == 11)
    m_R12 = value;
  if (index == 12)
    m_R13 = value;
  if (index == 13)
    m_R14 = value;
  if (index == 14)
    m_R15 = value;
  if (index == 15)
    m_Rsp = value;
  if (index == 16)
    m_Rip = value;
  if (index == 17)
    m_Rflags = value;
}
const char* X64InterruptState::getRegisterName(size_t index) const {
  return X64InterruptStateRegisterName[index];
}
 
size_t X64SyscallState::getRegisterCount() const {
  return 16;
}
processor_register_t X64SyscallState::getRegister(size_t index) const {
  if (index == 0)
    return m_Rax;
  if (index == 1)
    return m_Rbx;
  if (index == 2)
    return m_Rdx;
  if (index == 3)
    return m_Rdi;
  if (index == 4)
    return m_Rsi;
  if (index == 5)
    return m_Rbp;
  if (index == 6)
    return m_R8;
  if (index == 7)
    return m_R9;
  if (index == 8)
    return m_R10;
  if (index == 9)
    return m_R12;
  if (index == 10)
    return m_R13;
  if (index == 11)
    return m_R14;
  if (index == 12)
    return m_R15;
  if (index == 13)
    return m_Rsp;
  if (index == 14)
    return m_RipRcx;
  if (index == 15)
    return m_RFlagsR11;
  return 0;
}
void X64SyscallState::setRegister(size_t index, uintptr_t value) {
  if (index == 0)
    m_Rax = value;
  if (index == 1)
    m_Rbx = value;
  if (index == 2)
    m_Rdx = value;
  if (index == 3)
    m_Rdi = value;
  if (index == 4)
    m_Rsi = value;
  if (index == 5)
    m_Rbp = value;
  if (index == 6)
    m_R8 = value;
  if (index == 7)
    m_R9 = value;
  if (index == 8)
    m_R10 = value;
  if (index == 9)
    m_R12 = value;
  if (index == 10)
    m_R13 = value;
  if (index == 11)
    m_R14 = value;
  if (index == 12)
    m_R15 = value;
  if (index == 13)
    m_Rsp = value;
  if (index == 14)
    m_RipRcx = value;
  if (index == 15)
    m_RFlagsR11 = value;
}
const char* X64SyscallState::getRegisterName(size_t index) const {
  return X64SyscallStateRegisterName[index];
}
 
X64InterruptState* X64InterruptState::construct(X64ProcessorState& state, bool userMode,
                                                const X64UserEntryMetadata& metadata) {
  // Obtain the stack pointer.
  uintptr_t* pStack = reinterpret_cast<uintptr_t*>(state.getStackPointer());
 
  *--pStack = (userMode) ? 0x23 : 0x10;  // SS
  *--pStack = state.rsp;                 // RSP
  *--pStack = 0x200;                     // RFLAGS - IF enabled.
  *--pStack = (userMode) ? 0x1b : 0x08;  // CS
  *--pStack = state.rip;                 // RIP
  *--pStack = 0;                         // Error code
  *--pStack = 0;                         // Interrupt number
  *--pStack = state.rax;                 // RAX
  *--pStack = state.rbx;                 // RBX
  *--pStack = state.rcx;                 // RCX
  *--pStack = state.rdx;                 // RDX
  *--pStack = state.rdi;                 // RDI
  *--pStack = state.rsi;                 // RSI
  *--pStack = state.rbp;                 // RBP
  *--pStack = state.r8;
  *--pStack = state.r9;
  *--pStack = state.r10;
  *--pStack = state.r11;
  *--pStack = state.r12;
  *--pStack = state.r13;
  *--pStack = state.r14;
  *--pStack = state.r15;
 
  pStack -= sizeof(X64UserEntryMetadata) / sizeof(uintptr_t);
  X64InterruptState* toRet = reinterpret_cast<X64InterruptState*>(pStack);
  toRet->setUserEntryMetadata(metadata);
 
  return toRet;
}
 
#if X64 && !HOSTED
namespace {
uint64_t installedUserTlsBase() {
  uint32_t low, high;
  asm volatile("rdmsr" : "=a"(low), "=d"(high) : "c"(0xc0000100));
  return (uint64_t(high) << 32) | low;
}
}  // namespace
void X64InterruptState::refreshUserTlsBase() {
  pedigree_materialize_user_entry();
  m_UserEntry.fsBase = installedUserTlsBase();
  m_UserEntry.gsBase = Processor::getUserGsBase();
}
void X64SyscallState::refreshUserTlsBase() {
  pedigree_materialize_user_entry();
  m_UserEntry.fsBase = installedUserTlsBase();
  m_UserEntry.gsBase = Processor::getUserGsBase();
}
#endif