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"

class HostedInterruptState
{
    friend class HostedProcessorState;
    friend class HostedInterruptManager;
    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 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 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;
    uint64_t error;
    uint64_t error_ptr;  // pointer to error
    uint64_t result;
    uint64_t rsp;
    uint64_t _align0;  // deterministically pad to 16 bytes
} 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];
};

//
// 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 true;
}
size_t HostedInterruptState::getInterruptNumber() const
{
    return which;
}

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
{
    if (n == 0)
        return p1;
    if (n == 1)
        return p2;
    if (n == 2)
        return p3;
    if (n == 3)
        return p4;
    if (n == 4)
        return p5;
    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