env

Go to the documentation of this file.

// -*- Mode: C++ -*-
// vim:ft=cpp
/*
 * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *               Alexander Warg <warg@os.inf.tu-dresden.de>,
 *               Björn Döbel <doebel@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#pragma once
 
#include <l4/sys/types.h>
 
#include <l4/re/rm>
#include <l4/re/parent>
#include <l4/re/mem_alloc>
#include <l4/re/log>
#include <l4/re/consts>
 
#include <l4/re/env.h>
 
namespace L4 {
class Scheduler;
}

namespace L4Re
{
  class Itas;
  struct Dbg_events;

  class L4_EXPORT Env
  {
  private:
    l4re_env_t _env;
  public:

    typedef l4re_env_cap_entry_t Cap_entry;

    static Env const *env() noexcept
    { return reinterpret_cast<Env*>(l4re_global_env); }

    L4::Cap<Parent> parent() const noexcept
    { return L4::Cap<Parent>(_env.parent); }

    L4::Cap<Mem_alloc> mem_alloc() const noexcept
    { return L4::Cap<Mem_alloc>(_env.mem_alloc); }

    L4::Cap<L4::Factory> user_factory() const noexcept
    { return L4::Cap<L4::Factory>(_env.mem_alloc); }

    L4::Cap<Rm> rm() const noexcept
    { return L4::Cap<Rm>(_env.rm); }

    L4::Cap<Log> log() const noexcept
    { return L4::Cap<Log>(_env.log); }

    L4::Cap<L4::Thread> main_thread() const noexcept
    { return L4::Cap<L4::Thread>(_env.main_thread); }

    L4::Cap<L4::Task> task() const noexcept
    { return L4::Cap<L4::Task>(L4RE_THIS_TASK_CAP); }

    L4::Cap<L4::Factory> factory() const noexcept
    { return L4::Cap<L4::Factory>(_env.factory); }

    l4_cap_idx_t first_free_cap() const noexcept
    { return _env.first_free_cap; }

    l4_umword_t first_free_reply_cap() const noexcept
    { return _env.first_free_reply_cap; }

    l4_fpage_t utcb_area() const noexcept
    { return _env.utcb_area; }

    l4_addr_t first_free_utcb() const noexcept
    { return _env.first_free_utcb; }

    Cap_entry const *initial_caps() const noexcept
    { return _env.caps; }

    Cap_entry const *get(char const *name, unsigned l) const noexcept
    { return l4re_env_get_cap_l(name, l, &_env); }

    template< typename T >
    L4::Cap<T> get_cap(char const *name, unsigned l) const noexcept
    {
      if (Cap_entry const *e = get(name, l))
  return L4::Cap<T>(e->cap);
 
      return L4::Cap<T>(-L4_ENOENT);
    }

    template< typename T >
    L4::Cap<T> get_cap(char const *name) const noexcept
    { return get_cap<T>(name, __builtin_strlen(name)); }

    void parent(L4::Cap<Parent> const &c) noexcept
    { _env.parent = c.cap(); }

    void mem_alloc(L4::Cap<Mem_alloc> const &c) noexcept
    { _env.mem_alloc = c.cap(); }

    void rm(L4::Cap<Rm> const &c) noexcept
    { _env.rm = c.cap(); }

    void log(L4::Cap<Log> const &c) noexcept
    { _env.log = c.cap(); }

    void main_thread(L4::Cap<L4::Thread> const &c) noexcept
    { _env.main_thread = c.cap(); }

    void factory(L4::Cap<L4::Factory> const &c) noexcept
    { _env.factory = c.cap(); }

    void first_free_cap(l4_cap_idx_t c) noexcept
    { _env.first_free_cap = c; }

    void first_free_reply_cap(l4_umword_t c) noexcept
    { _env.first_free_reply_cap = c; }

    void utcb_area(l4_fpage_t utcbs) noexcept
    { _env.utcb_area = utcbs; }

    void first_free_utcb(l4_addr_t u) noexcept
    { _env.first_free_utcb = u; }

    L4::Cap<L4::Scheduler> scheduler() const noexcept
    { return L4::Cap<L4::Scheduler>(_env.scheduler); }

    void scheduler(L4::Cap<L4::Scheduler> const &c) noexcept
    { _env.scheduler = c.cap(); }

    L4::Cap<Itas> itas() const noexcept
    { return L4::Cap<Itas>(_env.itas); }

    void itas(L4::Cap<Itas> const &c) noexcept
    { _env.itas = c.cap(); }

    L4::Cap<Dbg_events> dbg_events() const noexcept
    { return L4::Cap<Dbg_events>(_env.dbg_events); }

    void dbg_events(L4::Cap<Dbg_events> const &dbg_events) noexcept
    { _env.dbg_events = dbg_events.cap(); }

    void initial_caps(Cap_entry *first) noexcept
    { _env.caps = first; }
  };
};