hosted/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_HOSTED_STATE_H
#define KERNEL_PROCESSOR_HOSTED_STATE_H
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
 
#include <config.h>
 
class HostedInterruptState {
  friend class HostedProcessorState;
  friend class HostedInterruptManager;
  friend class HostedIrqManager;
  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;
 
  inline uintptr_t getInterruptSource() const;
 
  inline uint64_t getFlags() const;
  inline void setFlags(uint64_t flags);
 
  static HostedInterruptState* construct(class HostedProcessorState& state, bool userMode);
 
 private:
  HostedInterruptState();
  HostedInterruptState(const HostedInterruptState&);
  HostedInterruptState& operator=(const HostedInterruptState&);
  ~HostedInterruptState();
 
  uint64_t state;
  uint64_t which;
  uint64_t fromUserspace;
  uint64_t extra;
  uint64_t meta;
 
  uintptr_t m_basePointer;
  uintptr_t m_instructionPointer;
  uintptr_t m_stackPointer;
} PACKED;
 
class HostedSyscallState {
  friend class HostedProcessorState;
  friend class HostedSyscallManager;
 
 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);
 
 public:
  uint64_t service;
  uint64_t number;
  uint64_t p1, p2, p3, p4, p5, p6;
  uint64_t error;
  uint64_t error_ptr;  // pointer to error
  uint64_t result;
  uint64_t rsp;
} PACKED;
 
class HostedProcessorState {
 public:
  inline HostedProcessorState();
  inline HostedProcessorState(const HostedProcessorState&);
  inline HostedProcessorState(const HostedInterruptState&);
  inline HostedProcessorState(const HostedSyscallState&);
  inline HostedProcessorState& operator=(const HostedProcessorState&);
  inline HostedProcessorState& operator=(const HostedInterruptState&);
  inline HostedProcessorState& operator=(const HostedSyscallState&);
  inline ~HostedProcessorState();
 
  //
  // 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 state;
};
 
class HostedSchedulerState {
 public:
  uint64_t state[128];
 
  uint64_t stackBase;
  size_t stackSize;
 
  HostedSchedulerState();
 
  inline uintptr_t getInstructionPointer() const {
    return 0;
  }
};
 
//
// Part of the Implementation
//
uintptr_t HostedInterruptState::getStackPointer() const {
  return m_stackPointer;
}
void HostedInterruptState::setStackPointer(uintptr_t stackPointer) {
  m_stackPointer = stackPointer;
}
uintptr_t HostedInterruptState::getInstructionPointer() const {
  return m_instructionPointer;
}
void HostedInterruptState::setInstructionPointer(uintptr_t instructionPointer) {
  m_instructionPointer = instructionPointer;
}
uintptr_t HostedInterruptState::getBasePointer() const {
  return m_basePointer;
}
void HostedInterruptState::setBasePointer(uintptr_t basePointer) {
  m_basePointer = basePointer;
}
size_t HostedInterruptState::getRegisterSize(size_t index) const {
  return sizeof(processor_register_t);
}
 
bool HostedInterruptState::kernelMode() const {
  return !fromUserspace;
}
size_t HostedInterruptState::getInterruptNumber() const {
  return which;
}
uintptr_t HostedInterruptState::getInterruptSource() const {
  return state;
}
 
uint64_t HostedInterruptState::getFlags() const {
  return 0;
}
void HostedInterruptState::setFlags(uint64_t flags) {}
 
uintptr_t HostedSyscallState::getStackPointer() const {
  return rsp;
}
void HostedSyscallState::setStackPointer(uintptr_t stackPointer) {
  rsp = stackPointer;
}
uintptr_t HostedSyscallState::getInstructionPointer() const {
  return 0;
}
void HostedSyscallState::setInstructionPointer(uintptr_t instructionPointer) {}
uintptr_t HostedSyscallState::getBasePointer() const {
  return 0;
}
void HostedSyscallState::setBasePointer(uintptr_t basePointer) {}
size_t HostedSyscallState::getRegisterSize(size_t index) const {
  return sizeof(processor_register_t);
}
 
size_t HostedSyscallState::getSyscallService() const {
  return service;
}
size_t HostedSyscallState::getSyscallNumber() const {
  return number;
}
uintptr_t HostedSyscallState::getSyscallParameter(size_t n) const {
  switch (n) {
    // Native Pedigree services use slots 0-5. The Linux-compatible service
    // uses slots 6-11 to match X64SyscallState's register-ABI redirection.
    case 0:
    case 6:
      return p1;
    case 1:
    case 7:
      return p2;
    case 2:
    case 8:
      return p3;
    case 3:
    case 9:
      return p4;
    case 4:
    case 10:
      return p5;
    case 5:
    case 11:
      return p6;
    default:
      return 0;
  }
}
void HostedSyscallState::setSyscallReturnValue(uintptr_t val) {
  result = val;
}
void HostedSyscallState::setSyscallErrno(uintptr_t val) {
  error = val;
}
 
HostedProcessorState::HostedProcessorState() : state() {}
HostedProcessorState::HostedProcessorState(const HostedProcessorState& x) : state(x.state) {}
HostedProcessorState::HostedProcessorState(const HostedInterruptState& x) : state(x.state) {}
HostedProcessorState::HostedProcessorState(const HostedSyscallState& x) {}
HostedProcessorState& HostedProcessorState::operator=(const HostedProcessorState& x) {
  state = x.state;
  return *this;
}
HostedProcessorState& HostedProcessorState::operator=(const HostedInterruptState& x) {
  state = x.state;
  return *this;
}
HostedProcessorState& HostedProcessorState::operator=(const HostedSyscallState& x) {
  return *this;
}
HostedProcessorState::~HostedProcessorState() {}
 
uintptr_t HostedProcessorState::getStackPointer() const {
  return 0;
}
void HostedProcessorState::setStackPointer(uintptr_t stackPointer) {}
uintptr_t HostedProcessorState::getInstructionPointer() const {
  return 0;
}
void HostedProcessorState::setInstructionPointer(uintptr_t instructionPointer) {}
uintptr_t HostedProcessorState::getBasePointer() const {
  return 0;
}
void HostedProcessorState::setBasePointer(uintptr_t basePointer) {}
 
#endif