vcpu

Go to the documentation of this file.

// vi:se ft=cpp:
/*
 * (c) 2010 Adam Lackorzynski <adam@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
#pragma once
 
#include <l4/re/env>
#include <l4/vcpu/vcpu.h>
 
namespace L4vcpu {
 
class State
{
public:
  State() {}
 
  explicit State(unsigned v) : _s(v) {}
 
  void add(unsigned bits) throw()    { _s |= bits; }
 
  void clear(unsigned bits) throw()  { _s &= ~bits; }
 
  void set(unsigned v) throw() { _s = v; }
 
private:
  __typeof__(((l4_vcpu_state_t *)0)->state) _s;
};
 
class Vcpu : private l4_vcpu_state_t
{
public:
  void irq_disable() throw()
  { l4vcpu_irq_disable(this); }
 
  unsigned irq_disable_save() throw()
  { return l4vcpu_irq_disable_save(this); }
 
  l4_vcpu_state_t *s() { return this; }
  l4_vcpu_state_t const *s() const { return this; }
 
  State *state() throw()
  {
    static_assert(sizeof(State) == sizeof(l4_vcpu_state_t::state),
                  "size mismatch");
    return reinterpret_cast<State *>(&(l4_vcpu_state_t::state));
  }
 
  State state() const throw()
  { return static_cast<State>(l4_vcpu_state_t::state); }
 
  State *saved_state() throw()
  {
    static_assert(sizeof(State) == sizeof(l4_vcpu_state_t::saved_state),
                  "size mismatch");
    return reinterpret_cast<State *>(&(l4_vcpu_state_t::saved_state));
  }
  State saved_state() const throw()
  { return static_cast<State>(l4_vcpu_state_t::saved_state); }
 
  l4_uint16_t sticky_flags() const throw()
  { return l4_vcpu_state_t::sticky_flags; }
 
  void irq_enable(l4_utcb_t *utcb, l4vcpu_event_hndl_t do_event_work_cb,
                  l4vcpu_setup_ipc_t setup_ipc) throw()
  { l4vcpu_irq_enable(this, utcb, do_event_work_cb, setup_ipc); }
 
  void irq_restore(unsigned s, l4_utcb_t *utcb,
                   l4vcpu_event_hndl_t do_event_work_cb,
                   l4vcpu_setup_ipc_t setup_ipc) throw()
  { l4vcpu_irq_restore(this, s, utcb, do_event_work_cb, setup_ipc); }
 
  void wait_for_event(l4_utcb_t *utcb, l4vcpu_event_hndl_t do_event_work_cb,
                      l4vcpu_setup_ipc_t setup_ipc) throw()
  { l4vcpu_wait_for_event(this, utcb, do_event_work_cb, setup_ipc); }
 
  void task(L4::Cap<L4::Task> const task = L4::Cap<L4::Task>::Invalid) throw()
  { user_task = task.cap(); }
 
  int is_page_fault_entry() const
  { return l4vcpu_is_page_fault_entry(this); }
 
  int is_irq_entry() const
  { return l4vcpu_is_irq_entry(this); }
 
  l4_vcpu_regs_t *r() throw()
  { return &(l4_vcpu_state_t::r); }
 
  l4_vcpu_regs_t const *r() const throw()
  { return &(l4_vcpu_state_t::r); }
 
  l4_vcpu_ipc_regs_t *i() throw()
  { return &(l4_vcpu_state_t::i); }
 
  l4_vcpu_ipc_regs_t const *i() const throw()
  { return &(l4_vcpu_state_t::i); }
 
  void entry_sp(l4_umword_t sp)
  { l4_vcpu_state_t::entry_sp = sp; }
 
  void entry_ip(l4_umword_t ip)
  { l4_vcpu_state_t::entry_ip = ip; }
 
  L4_CV static int
  ext_alloc(Vcpu **vcpu,
            l4_addr_t *ext_state,
            L4::Cap<L4::Task> task = L4Re::Env::env()->task(),
            L4::Cap<L4Re::Rm> rm = L4Re::Env::env()->rm()) throw();
 
  static inline Vcpu *cast(void *x) throw()
  { return reinterpret_cast<Vcpu *>(x); }
 
  static inline Vcpu *cast(l4_addr_t x) throw()
  { return reinterpret_cast<Vcpu *>(x); }
 
  void print_state(const char *prefix = "") const throw()
  { l4vcpu_print_state(this, prefix); }
};
 
 
}