mirror of
https://github.com/genodelabs/genode.git
synced 2025-06-13 04:38:20 +00:00
base-foc: coding style
- Cosmetic adjustments according to https://genode.org/documentation/developer-resources/coding_style - Replace manual inclusion of kernel headers by one new compound header foc/syscall.h - Rename namespace Fiasco to Foc
This commit is contained in:
Norman Feske
@ -11,13 +11,13 @@
|
||||
* under the terms of the GNU Affero General Public License version 3.
|
||||
*/
|
||||
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/cache.h>
|
||||
}
|
||||
|
||||
#include <cpu/cache.h>
|
||||
#include <foc/syscall.h>
|
||||
|
||||
void Genode::cache_coherent(Genode::addr_t addr, Genode::size_t size)
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
void Genode::cache_coherent(addr_t addr, size_t size)
|
||||
{
|
||||
Fiasco::l4_cache_coherent(addr, addr + size);
|
||||
Foc::l4_cache_coherent(addr, addr + size);
|
||||
}
|
||||
|
||||
@ -13,8 +13,11 @@
|
||||
|
||||
#include <base/internal/cap_alloc.h>
|
||||
|
||||
Genode::Cap_index_allocator &Genode::cap_idx_alloc()
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
Cap_index_allocator &Genode::cap_idx_alloc()
|
||||
{
|
||||
static Genode::Cap_index_allocator_tpl<Cap_index,4096> alloc;
|
||||
static Cap_index_allocator_tpl<Cap_index,4096> alloc;
|
||||
return alloc;
|
||||
}
|
||||
|
||||
@ -29,14 +29,11 @@
|
||||
* our expectations below macro can be used.
|
||||
*/
|
||||
#ifdef TEST_KERN_CAP_EQUAL
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/debugger.h>
|
||||
}
|
||||
inline bool CHECK_CAP_EQUAL(bool equal, Genode::addr_t cap1,
|
||||
Genode::addr_t cap2)
|
||||
{
|
||||
unsigned long id1 = Fiasco::l4_debugger_global_id(cap1),
|
||||
id2 = Fiasco::l4_debugger_global_id(cap2);
|
||||
unsigned long id1 = Foc::l4_debugger_global_id(cap1),
|
||||
id2 = Foc::l4_debugger_global_id(cap2);
|
||||
ASSERT(((id1 == id2) == equal), "CAPS NOT EQUAL!!!");
|
||||
return equal;
|
||||
}
|
||||
@ -49,6 +46,9 @@ inline bool CHECK_CAP_EQUAL(bool equal, Genode::addr_t,
|
||||
#endif /* TEST_KERN_CAP_EQUAL */
|
||||
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
/***********************
|
||||
** Cap_index class **
|
||||
***********************/
|
||||
@ -56,13 +56,11 @@ inline bool CHECK_CAP_EQUAL(bool equal, Genode::addr_t,
|
||||
static volatile int _cap_index_spinlock = SPINLOCK_UNLOCKED;
|
||||
|
||||
|
||||
bool Genode::Cap_index::higher(Genode::Cap_index *n) { return n->_id > _id; }
|
||||
bool Cap_index::higher(Cap_index *n) { return n->_id > _id; }
|
||||
|
||||
|
||||
Genode::Cap_index* Genode::Cap_index::find_by_id(Genode::uint16_t id)
|
||||
Cap_index* Cap_index::find_by_id(uint16_t id)
|
||||
{
|
||||
using namespace Genode;
|
||||
|
||||
if (_id == id) return this;
|
||||
|
||||
Cap_index *n = Avl_node<Cap_index>::child(id > _id);
|
||||
@ -70,31 +68,33 @@ Genode::Cap_index* Genode::Cap_index::find_by_id(Genode::uint16_t id)
|
||||
}
|
||||
|
||||
|
||||
Genode::addr_t Genode::Cap_index::kcap() const {
|
||||
return cap_idx_alloc().idx_to_kcap(this); }
|
||||
addr_t Cap_index::kcap() const
|
||||
{
|
||||
return cap_idx_alloc().idx_to_kcap(this);
|
||||
}
|
||||
|
||||
|
||||
Genode::uint8_t Genode::Cap_index::inc()
|
||||
uint8_t Cap_index::inc()
|
||||
{
|
||||
/* con't ref-count index that are controlled by core */
|
||||
if (cap_idx_alloc().static_idx(this))
|
||||
return 1;
|
||||
|
||||
spinlock_lock(&_cap_index_spinlock);
|
||||
Genode::uint8_t ret = ++_ref_cnt;
|
||||
uint8_t ret = ++_ref_cnt;
|
||||
spinlock_unlock(&_cap_index_spinlock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
Genode::uint8_t Genode::Cap_index::dec()
|
||||
uint8_t Cap_index::dec()
|
||||
{
|
||||
/* con't ref-count index that are controlled by core */
|
||||
if (cap_idx_alloc().static_idx(this))
|
||||
return 1;
|
||||
|
||||
spinlock_lock(&_cap_index_spinlock);
|
||||
Genode::uint8_t ret = --_ref_cnt;
|
||||
uint8_t ret = --_ref_cnt;
|
||||
spinlock_unlock(&_cap_index_spinlock);
|
||||
return ret;
|
||||
}
|
||||
@ -104,18 +104,16 @@ Genode::uint8_t Genode::Cap_index::dec()
|
||||
** Capability_map class **
|
||||
****************************/
|
||||
|
||||
Genode::Cap_index* Genode::Capability_map::find(int id)
|
||||
Cap_index* Capability_map::find(int id)
|
||||
{
|
||||
Genode::Lock_guard<Spin_lock> guard(_lock);
|
||||
Lock_guard<Spin_lock> guard(_lock);
|
||||
|
||||
return _tree.first() ? _tree.first()->find_by_id(id) : 0;
|
||||
}
|
||||
|
||||
|
||||
Genode::Cap_index* Genode::Capability_map::insert(int id)
|
||||
Cap_index* Capability_map::insert(int id)
|
||||
{
|
||||
using namespace Genode;
|
||||
|
||||
Lock_guard<Spin_lock> guard(_lock);
|
||||
|
||||
ASSERT(!_tree.first() || !_tree.first()->find_by_id(id),
|
||||
@ -130,10 +128,8 @@ Genode::Cap_index* Genode::Capability_map::insert(int id)
|
||||
}
|
||||
|
||||
|
||||
Genode::Cap_index* Genode::Capability_map::insert(int id, addr_t kcap)
|
||||
Cap_index* Capability_map::insert(int id, addr_t kcap)
|
||||
{
|
||||
using namespace Genode;
|
||||
|
||||
Lock_guard<Spin_lock> guard(_lock);
|
||||
|
||||
/* remove potentially existent entry */
|
||||
@ -150,10 +146,9 @@ Genode::Cap_index* Genode::Capability_map::insert(int id, addr_t kcap)
|
||||
}
|
||||
|
||||
|
||||
Genode::Cap_index* Genode::Capability_map::insert_map(int id, addr_t kcap)
|
||||
Cap_index* Capability_map::insert_map(int id, addr_t kcap)
|
||||
{
|
||||
using namespace Genode;
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
Lock_guard<Spin_lock> guard(_lock);
|
||||
|
||||
@ -196,9 +191,9 @@ Genode::Cap_index* Genode::Capability_map::insert_map(int id, addr_t kcap)
|
||||
}
|
||||
|
||||
|
||||
Genode::Capability_map &Genode::cap_map()
|
||||
Capability_map &Genode::cap_map()
|
||||
{
|
||||
static Genode::Capability_map map;
|
||||
static Capability_map map;
|
||||
return map;
|
||||
}
|
||||
|
||||
@ -207,22 +202,23 @@ Genode::Capability_map &Genode::cap_map()
|
||||
** Capability_space **
|
||||
**********************/
|
||||
|
||||
Fiasco::l4_cap_idx_t Genode::Capability_space::alloc_kcap()
|
||||
Foc::l4_cap_idx_t Capability_space::alloc_kcap()
|
||||
{
|
||||
return cap_idx_alloc().alloc_range(1)->kcap();
|
||||
}
|
||||
|
||||
|
||||
void Genode::Capability_space::free_kcap(Fiasco::l4_cap_idx_t kcap)
|
||||
void Capability_space::free_kcap(Foc::l4_cap_idx_t kcap)
|
||||
{
|
||||
Genode::Cap_index *idx = Genode::cap_idx_alloc().kcap_to_idx(kcap);
|
||||
Genode::cap_idx_alloc().free(idx, 1);
|
||||
Cap_index *idx = cap_idx_alloc().kcap_to_idx(kcap);
|
||||
cap_idx_alloc().free(idx, 1);
|
||||
}
|
||||
|
||||
|
||||
Fiasco::l4_cap_idx_t Genode::Capability_space::kcap(Native_capability cap)
|
||||
Foc::l4_cap_idx_t Capability_space::kcap(Native_capability cap)
|
||||
{
|
||||
if (cap.data() == nullptr)
|
||||
Genode::raw("Native_capability data is NULL!");
|
||||
raw("Native_capability data is NULL!");
|
||||
|
||||
return cap.data()->kcap();
|
||||
}
|
||||
|
||||
@ -15,10 +15,11 @@
|
||||
|
||||
#include <base/internal/cap_map.h>
|
||||
|
||||
void Genode::Capability_map::remove(Genode::Cap_index* i)
|
||||
{
|
||||
using namespace Genode;
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
void Capability_map::remove(Genode::Cap_index* i)
|
||||
{
|
||||
Lock_guard<Spin_lock> guard(_lock);
|
||||
|
||||
if (i) {
|
||||
|
||||
@ -11,10 +11,8 @@
|
||||
* under the terms of the GNU Affero General Public License version 3.
|
||||
*/
|
||||
|
||||
/* Fiasco includes */
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/types.h>
|
||||
}
|
||||
/* Fiasco.OC includes */
|
||||
#include <foc/syscall.h>
|
||||
|
||||
/* base-internal includes */
|
||||
#include <base/internal/cap_map.h>
|
||||
|
||||
@ -20,7 +20,6 @@
|
||||
* --------------------------------------------------------------
|
||||
*/
|
||||
|
||||
|
||||
/* Genode includes */
|
||||
#include <base/blocking.h>
|
||||
#include <base/ipc.h>
|
||||
@ -35,15 +34,10 @@
|
||||
#include <base/internal/foc_assert.h>
|
||||
|
||||
/* Fiasco.OC includes */
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/consts.h>
|
||||
#include <l4/sys/ipc.h>
|
||||
#include <l4/sys/types.h>
|
||||
#include <l4/sys/utcb.h>
|
||||
}
|
||||
#include <foc/syscall.h>
|
||||
|
||||
using namespace Genode;
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
|
||||
/***************
|
||||
@ -55,7 +49,7 @@ enum Debug { DEBUG_MSG = 1 };
|
||||
|
||||
static inline bool ipc_error(l4_msgtag_t tag, bool print)
|
||||
{
|
||||
int ipc_error = l4_ipc_error(tag, l4_utcb());
|
||||
int const ipc_error = l4_ipc_error(tag, l4_utcb());
|
||||
if (ipc_error && print) raw("Ipc error: ", ipc_error, " occurred!");
|
||||
return ipc_error;
|
||||
}
|
||||
@ -305,8 +299,7 @@ static bool badge_matches_label(unsigned long badge, unsigned long label)
|
||||
}
|
||||
|
||||
|
||||
void Genode::ipc_reply(Native_capability, Rpc_exception_code exc,
|
||||
Msgbuf_base &snd_msg)
|
||||
void Genode::ipc_reply(Native_capability, Rpc_exception_code exc, Msgbuf_base &snd_msg)
|
||||
{
|
||||
l4_msgtag_t tag = copy_msgbuf_to_utcb(snd_msg, exc.value);
|
||||
|
||||
@ -316,10 +309,10 @@ void Genode::ipc_reply(Native_capability, Rpc_exception_code exc,
|
||||
}
|
||||
|
||||
|
||||
Genode::Rpc_request Genode::ipc_reply_wait(Reply_capability const &,
|
||||
Rpc_exception_code exc,
|
||||
Msgbuf_base &reply_msg,
|
||||
Msgbuf_base &request_msg)
|
||||
Rpc_request Genode::ipc_reply_wait(Reply_capability const &,
|
||||
Rpc_exception_code exc,
|
||||
Msgbuf_base &reply_msg,
|
||||
Msgbuf_base &request_msg)
|
||||
{
|
||||
Receive_window &rcv_window = Thread::myself()->native_thread().rcv_window;
|
||||
|
||||
@ -372,7 +365,7 @@ Genode::Rpc_request Genode::ipc_reply_wait(Reply_capability const &,
|
||||
|
||||
Ipc_server::Ipc_server()
|
||||
:
|
||||
Native_capability((Cap_index*)Fiasco::l4_utcb_tcr()->user[Fiasco::UTCB_TCR_BADGE])
|
||||
Native_capability((Cap_index*)Foc::l4_utcb_tcr()->user[Foc::UTCB_TCR_BADGE])
|
||||
{
|
||||
Thread::myself()->native_thread().rcv_window.init();
|
||||
}
|
||||
@ -406,6 +399,6 @@ addr_t Receive_window::rcv_cap_sel_base()
|
||||
|
||||
addr_t Receive_window::rcv_cap_sel(unsigned i)
|
||||
{
|
||||
return rcv_cap_sel_base() + i*Fiasco::L4_CAP_SIZE;
|
||||
return rcv_cap_sel_base() + i*Foc::L4_CAP_SIZE;
|
||||
}
|
||||
|
||||
|
||||
@ -23,12 +23,9 @@
|
||||
#include <base/internal/capability_data.h>
|
||||
#include <base/internal/native_thread.h>
|
||||
|
||||
/* Fiasco includes */
|
||||
/* Fiasco.OC includes */
|
||||
#include <foc_native_cpu/client.h>
|
||||
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/irq.h>
|
||||
}
|
||||
#include <foc/syscall.h>
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
@ -40,7 +37,7 @@ Signal_source_client::Signal_source_client(Capability<Signal_source> cap)
|
||||
/* request mapping of semaphore capability selector */
|
||||
_sem(call<Rpc_request_semaphore>())
|
||||
{
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
Foc_native_cpu_client cpu_client(env_deprecated()->cpu_session()->native_cpu());
|
||||
Native_capability thread_cap = cpu_client.native_cap(Thread::myself()->cap());
|
||||
@ -52,7 +49,7 @@ Signal_source_client::Signal_source_client(Capability<Signal_source> cap)
|
||||
|
||||
Signal_source_client::~Signal_source_client()
|
||||
{
|
||||
Fiasco::l4_irq_detach(_sem.data()->kcap());
|
||||
Foc::l4_irq_detach(_sem.data()->kcap());
|
||||
}
|
||||
|
||||
|
||||
@ -60,7 +57,7 @@ __attribute__((optimize("-fno-omit-frame-pointer")))
|
||||
__attribute__((noinline))
|
||||
Signal_source_client::Signal Signal_source_client::wait_for_signal()
|
||||
{
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
Signal signal;
|
||||
do {
|
||||
|
||||
@ -17,11 +17,13 @@
|
||||
#include <base/internal/cap_map.h>
|
||||
#include <base/internal/spin_lock.h>
|
||||
|
||||
|
||||
Genode::Spin_lock::Spin_lock() : _spinlock(SPINLOCK_UNLOCKED) {}
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
void Genode::Spin_lock::lock() { spinlock_lock(&_spinlock); }
|
||||
Spin_lock::Spin_lock() : _spinlock(SPINLOCK_UNLOCKED) {}
|
||||
|
||||
|
||||
void Genode::Spin_lock::unlock() { spinlock_unlock(&_spinlock); }
|
||||
void Spin_lock::lock() { spinlock_lock(&_spinlock); }
|
||||
|
||||
|
||||
void Spin_lock::unlock() { spinlock_unlock(&_spinlock); }
|
||||
|
||||
@ -22,6 +22,8 @@
|
||||
#include <base/internal/native_utcb.h>
|
||||
#include <base/internal/cap_map.h>
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
/*****************************
|
||||
** Startup library support **
|
||||
@ -29,17 +31,15 @@
|
||||
|
||||
void prepare_init_main_thread()
|
||||
{
|
||||
using namespace Genode;
|
||||
enum { THREAD_CAP_ID = 1 };
|
||||
Cap_index * ci(cap_map().insert(THREAD_CAP_ID, Fiasco::MAIN_THREAD_CAP));
|
||||
Fiasco::l4_utcb_tcr()->user[Fiasco::UTCB_TCR_BADGE] = (unsigned long)ci;
|
||||
Fiasco::l4_utcb_tcr()->user[Fiasco::UTCB_TCR_THREAD_OBJ] = 0;
|
||||
Cap_index * ci(cap_map().insert(THREAD_CAP_ID, Foc::MAIN_THREAD_CAP));
|
||||
Foc::l4_utcb_tcr()->user[Foc::UTCB_TCR_BADGE] = (unsigned long)ci;
|
||||
Foc::l4_utcb_tcr()->user[Foc::UTCB_TCR_THREAD_OBJ] = 0;
|
||||
}
|
||||
|
||||
|
||||
void prepare_reinit_main_thread()
|
||||
{
|
||||
using namespace Genode;
|
||||
construct_at<Capability_map>(&cap_map());
|
||||
cap_idx_alloc().reinit();
|
||||
prepare_init_main_thread();
|
||||
@ -50,13 +50,11 @@ void prepare_reinit_main_thread()
|
||||
** Thread **
|
||||
************/
|
||||
|
||||
void Genode::Thread::_thread_bootstrap() { }
|
||||
void Thread::_thread_bootstrap() { }
|
||||
|
||||
|
||||
void Genode::Thread::_thread_start()
|
||||
void Thread::_thread_start()
|
||||
{
|
||||
using namespace Genode;
|
||||
|
||||
Thread::myself()->_thread_bootstrap();
|
||||
Thread::myself()->entry();
|
||||
Thread::myself()->_join.wakeup();
|
||||
|
||||
@ -17,10 +17,12 @@
|
||||
/* base-internal includes */
|
||||
#include <base/internal/native_utcb.h>
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
Genode::Thread *Genode::Thread::myself()
|
||||
|
||||
Thread *Thread::myself()
|
||||
{
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
return reinterpret_cast<Thread*>(l4_utcb_tcr()->user[UTCB_TCR_THREAD_OBJ]);
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* \brief Fiasco-specific implementation of the non-core startup Thread API
|
||||
* \brief Fiasco.OC-specific implementation of the non-core startup Thread API
|
||||
* \author Norman Feske
|
||||
* \author Stefan Kalkowski
|
||||
* \author Martin Stein
|
||||
@ -27,17 +27,15 @@
|
||||
#include <base/internal/cap_map.h>
|
||||
#include <base/internal/globals.h>
|
||||
|
||||
/* Fiasco includes */
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/utcb.h>
|
||||
}
|
||||
/* Fiasco.OC includes */
|
||||
#include <foc/syscall.h>
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
void Thread::_deinit_platform_thread()
|
||||
{
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
if (native_thread().kcap && _thread_cap.valid()) {
|
||||
Cap_index *i = (Cap_index*)l4_utcb_tcr_u(utcb()->foc_utcb)->user[UTCB_TCR_BADGE];
|
||||
@ -51,8 +49,8 @@ void Thread::_init_platform_thread(size_t weight, Type type)
|
||||
{
|
||||
_init_cpu_session_and_trace_control();
|
||||
|
||||
if (type == NORMAL)
|
||||
{
|
||||
if (type == NORMAL) {
|
||||
|
||||
/* create thread at core */
|
||||
_thread_cap = _cpu_session->create_thread(env_deprecated()->pd_session_cap(),
|
||||
name(), _affinity,
|
||||
@ -64,22 +62,23 @@ void Thread::_init_platform_thread(size_t weight, Type type)
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* adjust values whose computation differs for a main thread */
|
||||
native_thread().kcap = Fiasco::MAIN_THREAD_CAP;
|
||||
native_thread().kcap = Foc::MAIN_THREAD_CAP;
|
||||
_thread_cap = main_thread_cap();
|
||||
|
||||
if (!_thread_cap.valid())
|
||||
throw Cpu_session::Thread_creation_failed();
|
||||
|
||||
/* make thread object known to the Fiasco environment */
|
||||
/* make thread object known to the Fiasco.OC environment */
|
||||
addr_t const t = (addr_t)this;
|
||||
Fiasco::l4_utcb_tcr()->user[Fiasco::UTCB_TCR_THREAD_OBJ] = t;
|
||||
Foc::l4_utcb_tcr()->user[Foc::UTCB_TCR_THREAD_OBJ] = t;
|
||||
}
|
||||
|
||||
|
||||
void Thread::start()
|
||||
{
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
|
||||
Foc_native_cpu_client native_cpu(_cpu_session->native_cpu());
|
||||
|
||||
@ -89,7 +88,7 @@ void Thread::start()
|
||||
catch (...) { throw Cpu_session::Thread_creation_failed(); }
|
||||
|
||||
/* remember UTCB of the new thread */
|
||||
Fiasco::l4_utcb_t * const foc_utcb = (Fiasco::l4_utcb_t *)state.utcb;
|
||||
Foc::l4_utcb_t * const foc_utcb = (Foc::l4_utcb_t *)state.utcb;
|
||||
utcb()->foc_utcb = foc_utcb;
|
||||
|
||||
native_thread() = Native_thread(state.kcap);
|
||||
|
||||
@ -11,32 +11,31 @@
|
||||
* under the terms of the GNU Affero General Public License version 3.
|
||||
*/
|
||||
|
||||
/* Genode includes */
|
||||
#include <base/allocator.h>
|
||||
#include <base/attached_rom_dataspace.h>
|
||||
#include <base/env.h>
|
||||
#include <base/registry.h>
|
||||
#include <vm_session/client.h>
|
||||
|
||||
#include <cpu/vm_state.h>
|
||||
|
||||
#include <trace/timestamp.h>
|
||||
|
||||
namespace Fiasco {
|
||||
#include <l4/sys/consts.h>
|
||||
#include <l4/sys/irq.h>
|
||||
#include <l4/sys/thread.h>
|
||||
#include <l4/sys/types.h>
|
||||
/* Fiasco.OC includes */
|
||||
#include <foc/syscall.h>
|
||||
#include <foc/native_thread.h>
|
||||
#include <foc/native_capability.h>
|
||||
|
||||
namespace Foc {
|
||||
#include <l4/sys/vcpu.h>
|
||||
#include <l4/sys/__vm-svm.h>
|
||||
#include <l4/sys/__vm-vmx.h>
|
||||
}
|
||||
|
||||
#include <foc/native_thread.h>
|
||||
#include <foc/native_capability.h>
|
||||
using namespace Genode;
|
||||
|
||||
|
||||
enum Virt { VMX, SVM, UNKNOWN };
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
static uint32_t svm_features()
|
||||
{
|
||||
@ -45,13 +44,17 @@ static uint32_t svm_features()
|
||||
return edx;
|
||||
}
|
||||
|
||||
|
||||
static bool svm_np() { return svm_features() & (1U << 0); }
|
||||
|
||||
|
||||
struct Vcpu;
|
||||
|
||||
static Genode::Registry<Genode::Registered<Vcpu> > vcpus;
|
||||
|
||||
struct Vcpu : Genode::Thread
|
||||
static Registry<Registered<Vcpu> > vcpus;
|
||||
|
||||
|
||||
struct Vcpu : Thread
|
||||
{
|
||||
private:
|
||||
|
||||
@ -82,40 +85,40 @@ struct Vcpu : Genode::Thread
|
||||
CS_AR = 0x4816,
|
||||
CS_BASE = 0x6808,
|
||||
|
||||
SS_SEL = 0x0804,
|
||||
SS_LIMIT = 0x4804,
|
||||
SS_AR = 0x4818,
|
||||
SS_BASE = 0x680a,
|
||||
SS_SEL = 0x0804,
|
||||
SS_LIMIT = 0x4804,
|
||||
SS_AR = 0x4818,
|
||||
SS_BASE = 0x680a,
|
||||
|
||||
ES_SEL = 0x0800,
|
||||
ES_LIMIT = 0x4800,
|
||||
ES_AR = 0x4814,
|
||||
ES_BASE = 0x6806,
|
||||
ES_SEL = 0x0800,
|
||||
ES_LIMIT = 0x4800,
|
||||
ES_AR = 0x4814,
|
||||
ES_BASE = 0x6806,
|
||||
|
||||
DS_SEL = 0x0806,
|
||||
DS_LIMIT = 0x4806,
|
||||
DS_AR = 0x481a,
|
||||
DS_BASE = 0x680c,
|
||||
DS_SEL = 0x0806,
|
||||
DS_LIMIT = 0x4806,
|
||||
DS_AR = 0x481a,
|
||||
DS_BASE = 0x680c,
|
||||
|
||||
FS_SEL = 0x0808,
|
||||
FS_LIMIT = 0x4808,
|
||||
FS_AR = 0x481c,
|
||||
FS_BASE = 0x680e,
|
||||
FS_SEL = 0x0808,
|
||||
FS_LIMIT = 0x4808,
|
||||
FS_AR = 0x481c,
|
||||
FS_BASE = 0x680e,
|
||||
|
||||
GS_SEL = 0x080a,
|
||||
GS_LIMIT = 0x480a,
|
||||
GS_AR = 0x481e,
|
||||
GS_BASE = 0x6810,
|
||||
GS_SEL = 0x080a,
|
||||
GS_LIMIT = 0x480a,
|
||||
GS_AR = 0x481e,
|
||||
GS_BASE = 0x6810,
|
||||
|
||||
LDTR_SEL = 0x080c,
|
||||
LDTR_LIMIT = 0x480c,
|
||||
LDTR_AR = 0x4820,
|
||||
LDTR_BASE = 0x6812,
|
||||
|
||||
TR_SEL = 0x080e,
|
||||
TR_LIMIT = 0x480e,
|
||||
TR_AR = 0x4822,
|
||||
TR_BASE = 0x6814,
|
||||
TR_SEL = 0x080e,
|
||||
TR_LIMIT = 0x480e,
|
||||
TR_AR = 0x4822,
|
||||
TR_BASE = 0x6814,
|
||||
|
||||
IDTR_LIMIT = 0x4812,
|
||||
IDTR_BASE = 0x6818,
|
||||
@ -135,12 +138,13 @@ struct Vcpu : Genode::Thread
|
||||
|
||||
INTR_INFO = 0x4016,
|
||||
INTR_ERROR = 0x4018,
|
||||
|
||||
ENTRY_INST_LEN = 0x401a,
|
||||
|
||||
IDT_INFO = 0x4408,
|
||||
IDT_ERROR = 0x440a,
|
||||
IDT_INFO = 0x4408,
|
||||
IDT_ERROR = 0x440a,
|
||||
|
||||
EXIT_CTRL = 0x400c,
|
||||
EXIT_CTRL = 0x400c,
|
||||
ENTRY_CTRL = 0x4012,
|
||||
|
||||
TSC_OFF_LO = 0x2010,
|
||||
@ -149,22 +153,24 @@ struct Vcpu : Genode::Thread
|
||||
MSR_FMASK = 0x2842,
|
||||
MSR_LSTAR = 0x2844,
|
||||
MSR_STAR = 0x284a,
|
||||
|
||||
KERNEL_GS_BASE = 0x284c,
|
||||
|
||||
CR4_VMX = 1 << 13,
|
||||
CR4_VMX = 1 << 13,
|
||||
|
||||
INTEL_EXIT_INVALID = 0x21,
|
||||
|
||||
};
|
||||
|
||||
enum Vmcb
|
||||
{
|
||||
CTRL0_VINTR = 1u << 4,
|
||||
CTRL0_IO = 1u << 27,
|
||||
CTRL0_MSR = 1u << 28,
|
||||
CTRL0_VINTR = 1u << 4,
|
||||
CTRL0_IO = 1u << 27,
|
||||
CTRL0_MSR = 1u << 28,
|
||||
|
||||
AMD_SVM_ENABLE = 1 << 12,
|
||||
AMD_SVM_ENABLE = 1 << 12,
|
||||
|
||||
AMD_EXIT_INVALID = 0xfd,
|
||||
AMD_EXIT_INVALID = 0xfd,
|
||||
};
|
||||
|
||||
enum {
|
||||
@ -212,14 +218,12 @@ struct Vcpu : Genode::Thread
|
||||
uint8_t _fpu_ep[512] __attribute__((aligned(0x10)));
|
||||
uint8_t _fpu_vcpu[512] __attribute__((aligned(0x10)));
|
||||
|
||||
enum
|
||||
{
|
||||
enum {
|
||||
VMEXIT_STARTUP = 0xfe,
|
||||
VMEXIT_PAUSED = 0xff,
|
||||
STACK_SIZE = 0x3000,
|
||||
};
|
||||
|
||||
|
||||
enum State {
|
||||
NONE = 0,
|
||||
PAUSE = 1,
|
||||
@ -246,15 +250,15 @@ struct Vcpu : Genode::Thread
|
||||
}
|
||||
|
||||
/* reserved ranged for state of vCPUs - see platform.cc */
|
||||
Genode::addr_t const vcpu_addr = 0x1000 + 0x1000 * _id.id;
|
||||
Fiasco::l4_vcpu_state_t * const vcpu = reinterpret_cast<Fiasco::l4_vcpu_state_t*>(vcpu_addr);
|
||||
addr_t const vcpu_addr = 0x1000 + 0x1000 * _id.id;
|
||||
Foc::l4_vcpu_state_t * const vcpu = reinterpret_cast<Foc::l4_vcpu_state_t*>(vcpu_addr);
|
||||
|
||||
if (!l4_vcpu_check_version(vcpu))
|
||||
Genode::error("vCPU version mismatch kernel vs user-land - ",
|
||||
vcpu->version, "!=",
|
||||
(int)Fiasco::L4_VCPU_STATE_VERSION);
|
||||
error("vCPU version mismatch kernel vs user-land - ",
|
||||
vcpu->version, "!=",
|
||||
(int)Foc::L4_VCPU_STATE_VERSION);
|
||||
|
||||
using namespace Fiasco;
|
||||
using namespace Foc;
|
||||
l4_vm_svm_vmcb_t *vmcb = reinterpret_cast<l4_vm_svm_vmcb_t *>(vcpu_addr + L4_VCPU_OFFSET_EXT_STATE);
|
||||
void * vmcs = reinterpret_cast<void *>(vcpu_addr + L4_VCPU_OFFSET_EXT_STATE);
|
||||
|
||||
@ -265,15 +269,14 @@ struct Vcpu : Genode::Thread
|
||||
state = Vm_state {};
|
||||
|
||||
/* initial startup VM exit to get valid VM state */
|
||||
if (_vm_type == Virt::VMX) {
|
||||
if (_vm_type == Virt::VMX)
|
||||
_read_intel_state(state, vmcs, vcpu);
|
||||
}
|
||||
if (_vm_type == Virt::SVM) {
|
||||
|
||||
if (_vm_type == Virt::SVM)
|
||||
_read_amd_state(state, vmcb, vcpu);
|
||||
}
|
||||
|
||||
state.exit_reason = VMEXIT_STARTUP;
|
||||
Genode::Signal_transmitter(_signal).submit();
|
||||
Signal_transmitter(_signal).submit();
|
||||
|
||||
_handler_ready.down();
|
||||
_wake_up.down();
|
||||
@ -281,9 +284,9 @@ struct Vcpu : Genode::Thread
|
||||
/*
|
||||
* Fiasoc.OC peculiarities
|
||||
*/
|
||||
if (_vm_type == Virt::SVM) {
|
||||
if (_vm_type == Virt::SVM)
|
||||
state.efer.value(state.efer.value() | AMD_SVM_ENABLE);
|
||||
}
|
||||
|
||||
if (_vm_type == Virt::SVM) {
|
||||
vmcb->control_area.intercept_instruction0 = vmcb_ctrl0;
|
||||
vmcb->control_area.intercept_instruction1 = vmcb_ctrl1;
|
||||
@ -298,21 +301,22 @@ struct Vcpu : Genode::Thread
|
||||
vmcb->state_save_area.g_pat = 0x7040600070406ull;
|
||||
}
|
||||
if (_vm_type == Virt::VMX) {
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::CR0_MASK, vmcs_cr0_mask);
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::CR4_MASK, vmcs_cr4_mask);
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::CR4_SHADOW, 0);
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::CR0_MASK, vmcs_cr0_mask);
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::CR4_MASK, vmcs_cr4_mask);
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::CR4_SHADOW, 0);
|
||||
state.cr4.value(vmcs_cr4_set);
|
||||
|
||||
enum {
|
||||
EXIT_SAVE_EFER = 1U << 20,
|
||||
ENTRY_LOAD_EFER = 1U << 15,
|
||||
};
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::EXIT_CTRL, EXIT_SAVE_EFER);
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::ENTRY_CTRL, ENTRY_LOAD_EFER);
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::EXIT_CTRL, EXIT_SAVE_EFER);
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::ENTRY_CTRL, ENTRY_LOAD_EFER);
|
||||
}
|
||||
|
||||
if (_vm_type == Virt::SVM)
|
||||
_write_amd_state(state, vmcb, vcpu);
|
||||
|
||||
if (_vm_type == Virt::VMX)
|
||||
_write_intel_state(state, vmcs, vcpu);
|
||||
|
||||
@ -332,7 +336,7 @@ struct Vcpu : Genode::Thread
|
||||
}
|
||||
|
||||
if (_state_current != RUN && _state_current != PAUSE) {
|
||||
Genode::error("unknown vcpu state ", (int)_state_current);
|
||||
error("unknown vcpu state ", (int)_state_current);
|
||||
while (true) { _remote_mutex.acquire(); }
|
||||
}
|
||||
|
||||
@ -362,7 +366,6 @@ struct Vcpu : Genode::Thread
|
||||
});
|
||||
asm volatile ("fxrstor %0" : : "m" (*_fpu_ep) : "memory");
|
||||
|
||||
|
||||
/* got VM exit or interrupted by asynchronous signal */
|
||||
uint64_t reason = 0;
|
||||
|
||||
@ -384,8 +387,8 @@ struct Vcpu : Genode::Thread
|
||||
|
||||
/* consume notification */
|
||||
while (vcpu->sticky_flags) {
|
||||
Fiasco::l4_cap_idx_t tid = native_thread().kcap;
|
||||
Fiasco::l4_cap_idx_t irq = tid + Fiasco::TASK_VCPU_IRQ_CAP;
|
||||
Foc::l4_cap_idx_t tid = native_thread().kcap;
|
||||
Foc::l4_cap_idx_t irq = tid + Foc::TASK_VCPU_IRQ_CAP;
|
||||
l4_irq_receive(irq, L4_IPC_RECV_TIMEOUT_0);
|
||||
}
|
||||
}
|
||||
@ -396,7 +399,7 @@ struct Vcpu : Genode::Thread
|
||||
}
|
||||
|
||||
if (_vm_type == Virt::VMX) {
|
||||
reason = Fiasco::l4_vm_vmx_read_32(vmcs, Vmcs::EXI_REASON);
|
||||
reason = Foc::l4_vm_vmx_read_32(vmcs, Vmcs::EXI_REASON);
|
||||
|
||||
{
|
||||
Mutex::Guard guard(_remote_mutex);
|
||||
@ -409,8 +412,8 @@ struct Vcpu : Genode::Thread
|
||||
|
||||
/* consume notification */
|
||||
while (vcpu->sticky_flags) {
|
||||
Fiasco::l4_cap_idx_t tid = native_thread().kcap;
|
||||
Fiasco::l4_cap_idx_t irq = tid + Fiasco::TASK_VCPU_IRQ_CAP;
|
||||
Foc::l4_cap_idx_t tid = native_thread().kcap;
|
||||
Foc::l4_cap_idx_t irq = tid + Foc::TASK_VCPU_IRQ_CAP;
|
||||
l4_irq_receive(irq, L4_IPC_RECV_TIMEOUT_0);
|
||||
}
|
||||
}
|
||||
@ -421,7 +424,7 @@ struct Vcpu : Genode::Thread
|
||||
}
|
||||
|
||||
/* notify VM handler */
|
||||
Genode::Signal_transmitter(_signal).submit();
|
||||
Signal_transmitter(_signal).submit();
|
||||
|
||||
/*
|
||||
* Wait until VM handler is really really done,
|
||||
@ -444,7 +447,7 @@ struct Vcpu : Genode::Thread
|
||||
return ((value & 0x1f000) >> 4) | (value & 0xff); }
|
||||
|
||||
void _read_intel_state(Vm_state &state, void *vmcs,
|
||||
Fiasco::l4_vcpu_state_t *vcpu)
|
||||
Foc::l4_vcpu_state_t *vcpu)
|
||||
{
|
||||
state.ax.value(vcpu->r.ax);
|
||||
state.cx.value(vcpu->r.cx);
|
||||
@ -455,14 +458,14 @@ struct Vcpu : Genode::Thread
|
||||
state.di.value(vcpu->r.di);
|
||||
state.si.value(vcpu->r.si);
|
||||
|
||||
state.flags.value(Fiasco::l4_vm_vmx_read(vmcs, Vmcs::FLAGS));
|
||||
state.flags.value(Foc::l4_vm_vmx_read(vmcs, Vmcs::FLAGS));
|
||||
|
||||
state.sp.value(Fiasco::l4_vm_vmx_read(vmcs, Vmcs::SP));
|
||||
state.sp.value(Foc::l4_vm_vmx_read(vmcs, Vmcs::SP));
|
||||
|
||||
state.ip.value(Fiasco::l4_vm_vmx_read(vmcs, Vmcs::IP));
|
||||
state.ip_len.value(Fiasco::l4_vm_vmx_read(vmcs, Vmcs::INST_LEN));
|
||||
state.ip.value(Foc::l4_vm_vmx_read(vmcs, Vmcs::IP));
|
||||
state.ip_len.value(Foc::l4_vm_vmx_read(vmcs, Vmcs::INST_LEN));
|
||||
|
||||
state.dr7.value(Fiasco::l4_vm_vmx_read(vmcs, Vmcs::DR7));
|
||||
state.dr7.value(Foc::l4_vm_vmx_read(vmcs, Vmcs::DR7));
|
||||
|
||||
#ifdef __x86_64__
|
||||
state.r8.value(vcpu->r.r8);
|
||||
@ -476,32 +479,32 @@ struct Vcpu : Genode::Thread
|
||||
#endif
|
||||
|
||||
{
|
||||
addr_t const cr0 = Fiasco::l4_vm_vmx_read(vmcs, Vmcs::CR0);
|
||||
addr_t const cr0_shadow = Fiasco::l4_vm_vmx_read(vmcs, Vmcs::CR0_SHADOW);
|
||||
addr_t const cr0 = Foc::l4_vm_vmx_read(vmcs, Vmcs::CR0);
|
||||
addr_t const cr0_shadow = Foc::l4_vm_vmx_read(vmcs, Vmcs::CR0_SHADOW);
|
||||
state.cr0.value((cr0 & ~vmcs_cr0_mask) | (cr0_shadow & vmcs_cr0_mask));
|
||||
if (state.cr0.value() != cr0_shadow)
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::CR0_SHADOW, state.cr0.value());
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::CR0_SHADOW, state.cr0.value());
|
||||
}
|
||||
|
||||
unsigned const cr2 = Fiasco::l4_vm_vmx_get_cr2_index(vmcs);
|
||||
state.cr2.value(Fiasco::l4_vm_vmx_read(vmcs, cr2));
|
||||
state.cr3.value(Fiasco::l4_vm_vmx_read(vmcs, Vmcs::CR3));
|
||||
unsigned const cr2 = Foc::l4_vm_vmx_get_cr2_index(vmcs);
|
||||
state.cr2.value(Foc::l4_vm_vmx_read(vmcs, cr2));
|
||||
state.cr3.value(Foc::l4_vm_vmx_read(vmcs, Vmcs::CR3));
|
||||
|
||||
{
|
||||
addr_t const cr4 = Fiasco::l4_vm_vmx_read(vmcs, Vmcs::CR4);
|
||||
addr_t const cr4_shadow = Fiasco::l4_vm_vmx_read(vmcs, Vmcs::CR4_SHADOW);
|
||||
addr_t const cr4 = Foc::l4_vm_vmx_read(vmcs, Vmcs::CR4);
|
||||
addr_t const cr4_shadow = Foc::l4_vm_vmx_read(vmcs, Vmcs::CR4_SHADOW);
|
||||
state.cr4.value((cr4 & ~vmcs_cr4_mask) | (cr4_shadow & vmcs_cr4_mask));
|
||||
if (state.cr4.value() != cr4_shadow)
|
||||
Fiasco::l4_vm_vmx_write(vmcs, Vmcs::CR4_SHADOW,
|
||||
Foc::l4_vm_vmx_write(vmcs, Vmcs::CR4_SHADOW,
|
||||
state.cr4.value());
|
||||
}
|
||||
|
||||
using Fiasco::l4_vm_vmx_read;
|
||||
using Fiasco::l4_vm_vmx_read_16;
|
||||
using Fiasco::l4_vm_vmx_read_32;
|
||||
using Fiasco::l4_vm_vmx_read_nat;
|
||||
typedef Genode::Vm_state::Segment Segment;
|
||||
typedef Genode::Vm_state::Range Range;
|
||||
using Foc::l4_vm_vmx_read;
|
||||
using Foc::l4_vm_vmx_read_16;
|
||||
using Foc::l4_vm_vmx_read_32;
|
||||
using Foc::l4_vm_vmx_read_nat;
|
||||
typedef Vm_state::Segment Segment;
|
||||
typedef Vm_state::Range Range;
|
||||
|
||||
{
|
||||
Segment cs { l4_vm_vmx_read_16(vmcs, Vmcs::CS_SEL),
|
||||
@ -621,8 +624,8 @@ struct Vcpu : Genode::Thread
|
||||
#endif
|
||||
}
|
||||
|
||||
void _read_amd_state(Vm_state &state, Fiasco::l4_vm_svm_vmcb_t *vmcb,
|
||||
Fiasco::l4_vcpu_state_t * const vcpu)
|
||||
void _read_amd_state(Vm_state &state, Foc::l4_vm_svm_vmcb_t *vmcb,
|
||||
Foc::l4_vcpu_state_t * const vcpu)
|
||||
{
|
||||
state.ax.value(vmcb->state_save_area.rax);
|
||||
state.cx.value(vcpu->r.cx);
|
||||
@ -668,7 +671,7 @@ struct Vcpu : Genode::Thread
|
||||
vmcb_cr4_shadow = state.cr4.value();
|
||||
}
|
||||
|
||||
typedef Genode::Vm_state::Segment Segment;
|
||||
typedef Vm_state::Segment Segment;
|
||||
|
||||
state.cs.value(Segment{vmcb->state_save_area.cs.selector,
|
||||
vmcb->state_save_area.cs.attrib,
|
||||
@ -710,7 +713,7 @@ struct Vcpu : Genode::Thread
|
||||
vmcb->state_save_area.ldtr.limit,
|
||||
(addr_t)vmcb->state_save_area.ldtr.base});
|
||||
|
||||
typedef Genode::Vm_state::Range Range;
|
||||
typedef Vm_state::Range Range;
|
||||
|
||||
state.gdtr.value(Range{(addr_t)vmcb->state_save_area.gdtr.base,
|
||||
vmcb->state_save_area.gdtr.limit});
|
||||
@ -750,24 +753,24 @@ struct Vcpu : Genode::Thread
|
||||
if (state.pdpte_0.valid() || state.pdpte_1.valid() ||
|
||||
state.pdpte_2.valid() || state.pdpte_3.valid()) {
|
||||
|
||||
Genode::error("pdpte not implemented");
|
||||
error("pdpte not implemented");
|
||||
}
|
||||
|
||||
if (state.star.valid() || state.lstar.valid() ||
|
||||
state.fmask.valid() || state.kernel_gs_base.valid()) {
|
||||
|
||||
Genode::error("star, fstar, fmask, kernel_gs_base not implemented");
|
||||
error("star, fstar, fmask, kernel_gs_base not implemented");
|
||||
}
|
||||
|
||||
if (state.tpr.valid() || state.tpr_threshold.valid()) {
|
||||
Genode::error("tpr not implemented");
|
||||
error("tpr not implemented");
|
||||
}
|
||||
}
|
||||
|
||||
void _write_intel_state(Vm_state &state, void *vmcs,
|
||||
Fiasco::l4_vcpu_state_t *vcpu)
|
||||
Foc::l4_vcpu_state_t *vcpu)
|
||||
{
|
||||
using Fiasco::l4_vm_vmx_write;
|
||||
using Foc::l4_vm_vmx_write;
|
||||
|
||||
if (state.ax.valid() || state.cx.valid() || state.dx.valid() ||
|
||||
state.bx.valid()) {
|
||||
@ -819,7 +822,7 @@ struct Vcpu : Genode::Thread
|
||||
if (state.tpr.valid() || state.tpr_threshold.valid()) {
|
||||
if (_show_error_unsupported_tpr) {
|
||||
_show_error_unsupported_tpr = false;
|
||||
Genode::error("TPR & TPR_THRESHOLD not supported on Fiasco.OC");
|
||||
error("TPR & TPR_THRESHOLD not supported on Fiasco.OC");
|
||||
}
|
||||
}
|
||||
|
||||
@ -831,12 +834,12 @@ struct Vcpu : Genode::Thread
|
||||
l4_vm_vmx_write(vmcs, Vmcs::CR0_SHADOW, state.cr0.value());
|
||||
|
||||
#if 0 /* if CPU has xsave feature bit ... see Vm::load_guest_xcr0 */
|
||||
l4_vm_vmx_write(vmcs, Fiasco::L4_VM_VMX_VMCS_XCR0, state.cr0.value());
|
||||
l4_vm_vmx_write(vmcs, Foc::L4_VM_VMX_VMCS_XCR0, state.cr0.value());
|
||||
#endif
|
||||
}
|
||||
|
||||
if (state.cr2.valid()) {
|
||||
unsigned const cr2 = Fiasco::l4_vm_vmx_get_cr2_index(vmcs);
|
||||
unsigned const cr2 = Foc::l4_vm_vmx_get_cr2_index(vmcs);
|
||||
l4_vm_vmx_write(vmcs, cr2, state.cr2.value());
|
||||
}
|
||||
|
||||
@ -852,10 +855,13 @@ struct Vcpu : Genode::Thread
|
||||
if (state.inj_info.valid() || state.inj_error.valid()) {
|
||||
addr_t ctrl_0 = state.ctrl_primary.valid() ?
|
||||
state.ctrl_primary.value() :
|
||||
Fiasco::l4_vm_vmx_read(vmcs, Vmcs::CTRL_0);
|
||||
Foc::l4_vm_vmx_read(vmcs, Vmcs::CTRL_0);
|
||||
|
||||
if (state.inj_info.value() & 0x2000)
|
||||
Genode::warning("unimplemented ", state.inj_info.value() & 0x1000, " ", state.inj_info.value() & 0x2000, " ", Genode::Hex(ctrl_0), " ", Genode::Hex(state.ctrl_secondary.value()));
|
||||
warning("unimplemented ", state.inj_info.value() & 0x1000, " ",
|
||||
state.inj_info.value() & 0x2000, " ",
|
||||
Hex(ctrl_0), " ",
|
||||
Hex(state.ctrl_secondary.value()));
|
||||
|
||||
if (state.inj_info.value() & 0x1000)
|
||||
ctrl_0 |= Vmcs::IRQ_WINDOW;
|
||||
@ -972,7 +978,7 @@ struct Vcpu : Genode::Thread
|
||||
{
|
||||
if (_show_error_unsupported_pdpte) {
|
||||
_show_error_unsupported_pdpte = false;
|
||||
Genode::error("PDPTE 0/1/2/3 not supported on Fiasco.OC");
|
||||
error("PDPTE 0/1/2/3 not supported on Fiasco.OC");
|
||||
}
|
||||
}
|
||||
|
||||
@ -987,8 +993,8 @@ struct Vcpu : Genode::Thread
|
||||
state.sysenter_ip.value());
|
||||
}
|
||||
|
||||
void _write_amd_state(Vm_state &state, Fiasco::l4_vm_svm_vmcb_t *vmcb,
|
||||
Fiasco::l4_vcpu_state_t *vcpu)
|
||||
void _write_amd_state(Vm_state &state, Foc::l4_vm_svm_vmcb_t *vmcb,
|
||||
Foc::l4_vcpu_state_t *vcpu)
|
||||
{
|
||||
if (state.ax.valid() || state.cx.valid() || state.dx.valid() ||
|
||||
state.bx.valid()) {
|
||||
@ -1028,12 +1034,12 @@ struct Vcpu : Genode::Thread
|
||||
|
||||
if (state.star.value() || state.lstar.value() ||
|
||||
state.fmask.value() || state.kernel_gs_base.value())
|
||||
Genode::error(__LINE__, " not implemented");
|
||||
error(__LINE__, " not implemented");
|
||||
|
||||
if (state.tpr.valid() || state.tpr_threshold.valid()) {
|
||||
if (_show_error_unsupported_tpr) {
|
||||
_show_error_unsupported_tpr = false;
|
||||
Genode::error("TPR & TPR_THRESHOLD not supported on Fiasco.OC");
|
||||
error("TPR & TPR_THRESHOLD not supported on Fiasco.OC");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1173,7 +1179,7 @@ struct Vcpu : Genode::Thread
|
||||
{
|
||||
if (_show_error_unsupported_pdpte) {
|
||||
_show_error_unsupported_pdpte = false;
|
||||
Genode::error("PDPTE 0/1/2/3 not supported on Fiasco.OC");
|
||||
error("PDPTE 0/1/2/3 not supported on Fiasco.OC");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1200,14 +1206,15 @@ struct Vcpu : Genode::Thread
|
||||
|
||||
bool match(Vm_session_client::Vcpu_id id) { return id.id == _id.id; }
|
||||
|
||||
Genode::Vm_session_client::Vcpu_id id() const { return _id; }
|
||||
void id(Genode::Vm_session_client::Vcpu_id id) { _id = id; }
|
||||
Vm_session_client::Vcpu_id id() const { return _id; }
|
||||
|
||||
void id(Vm_session_client::Vcpu_id id) { _id = id; }
|
||||
|
||||
void assign_ds_state(Region_map &rm, Dataspace_capability cap)
|
||||
{
|
||||
_state = rm.attach(cap);
|
||||
_task = *reinterpret_cast<Fiasco::l4_cap_idx_t *>(_state);
|
||||
*reinterpret_cast<Fiasco::l4_cap_idx_t *>(_state) = 0UL;
|
||||
_task = *reinterpret_cast<Foc::l4_cap_idx_t *>(_state);
|
||||
*reinterpret_cast<Foc::l4_cap_idx_t *>(_state) = 0UL;
|
||||
}
|
||||
|
||||
void resume()
|
||||
@ -1233,9 +1240,9 @@ struct Vcpu : Genode::Thread
|
||||
_state_request = PAUSE;
|
||||
|
||||
/* recall vCPU */
|
||||
Fiasco::l4_cap_idx_t tid = native_thread().kcap;
|
||||
Fiasco::l4_cap_idx_t irq = tid + Fiasco::TASK_VCPU_IRQ_CAP;
|
||||
Fiasco::l4_irq_trigger(irq);
|
||||
Foc::l4_cap_idx_t tid = native_thread().kcap;
|
||||
Foc::l4_cap_idx_t irq = tid + Foc::TASK_VCPU_IRQ_CAP;
|
||||
Foc::l4_irq_trigger(irq);
|
||||
|
||||
if (_state_current == NONE)
|
||||
_wake_up.up();
|
||||
@ -1249,11 +1256,11 @@ struct Vcpu : Genode::Thread
|
||||
};
|
||||
|
||||
|
||||
static enum Virt virt_type(Genode::Env &env)
|
||||
static enum Virt virt_type(Env &env)
|
||||
{
|
||||
try {
|
||||
Genode::Attached_rom_dataspace const info(env, "platform_info");
|
||||
Genode::Xml_node const features = info.xml().sub_node("hardware").sub_node("features");
|
||||
Attached_rom_dataspace const info(env, "platform_info");
|
||||
Xml_node const features = info.xml().sub_node("hardware").sub_node("features");
|
||||
|
||||
if (features.attribute_value("svm", false))
|
||||
return Virt::SVM;
|
||||
@ -1272,7 +1279,7 @@ Vm_session_client::create_vcpu(Allocator &alloc, Env &env,
|
||||
{
|
||||
enum Virt vm_type = virt_type(env);
|
||||
if (vm_type == Virt::UNKNOWN) {
|
||||
Genode::error("unsupported hardware virtualisation");
|
||||
error("unsupported hardware virtualisation");
|
||||
return Vm_session::Vcpu_id();
|
||||
}
|
||||
|
||||
@ -1304,6 +1311,7 @@ Vm_session_client::create_vcpu(Allocator &alloc, Env &env,
|
||||
return vcpu->id();
|
||||
}
|
||||
|
||||
|
||||
void Vm_session_client::run(Vcpu_id vcpu_id)
|
||||
{
|
||||
vcpus.for_each([&] (Vcpu &vcpu) {
|
||||
@ -1312,6 +1320,7 @@ void Vm_session_client::run(Vcpu_id vcpu_id)
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
void Vm_session_client::pause(Vm_session_client::Vcpu_id vcpu_id)
|
||||
{
|
||||
vcpus.for_each([&] (Vcpu &vcpu) {
|
||||
@ -1322,6 +1331,7 @@ void Vm_session_client::pause(Vm_session_client::Vcpu_id vcpu_id)
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
Dataspace_capability Vm_session_client::cpu_state(Vcpu_id vcpu_id)
|
||||
{
|
||||
Dataspace_capability cap;
|
||||
@ -1334,6 +1344,7 @@ Dataspace_capability Vm_session_client::cpu_state(Vcpu_id vcpu_id)
|
||||
return cap;
|
||||
}
|
||||
|
||||
|
||||
Vm_session::~Vm_session()
|
||||
{
|
||||
vcpus.for_each([&] (Vcpu &vc) {
|
||||
|
||||
Reference in New Issue
Block a user