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;
  class 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); }
    static Env const *env() noexcept {…}
 
    L4::Cap<Parent> parent() const noexcept
    { return L4::Cap<Parent>(_env.parent); }
    L4::Cap<Parent> parent() const noexcept {…}
    L4::Cap<Mem_alloc> mem_alloc() const noexcept
    { return L4::Cap<Mem_alloc>(_env.mem_alloc); }
    L4::Cap<Mem_alloc> mem_alloc() const noexcept {…}
    L4::Cap<L4::Factory> user_factory() const noexcept
    { return L4::Cap<L4::Factory>(_env.mem_alloc); }
    L4::Cap<L4::Factory> user_factory() const noexcept {…}
    L4::Cap<Rm> rm() const noexcept
    { return L4::Cap<Rm>(_env.rm); }
    L4::Cap<Rm> rm() const noexcept {…}
    L4::Cap<Log> log() const noexcept
    { return L4::Cap<Log>(_env.log); }
    L4::Cap<Log> log() const noexcept {…}
    L4::Cap<L4::Thread> main_thread() const noexcept
    { return L4::Cap<L4::Thread>(_env.main_thread); }
    L4::Cap<L4::Thread> main_thread() const noexcept {…}
    L4::Cap<L4::Task> task() const noexcept
    { return L4::Cap<L4::Task>(L4RE_THIS_TASK_CAP); }
    L4::Cap<L4::Task> task() const noexcept {…}
    L4::Cap<L4::Factory> factory() const noexcept
    { return L4::Cap<L4::Factory>(_env.factory); }
    L4::Cap<L4::Factory> factory() const noexcept {…}
    l4_cap_idx_t first_free_cap() const noexcept
    { return _env.first_free_cap; }
    l4_cap_idx_t first_free_cap() const noexcept {…}
    l4_fpage_t utcb_area() const noexcept
    { return _env.utcb_area; }
    l4_fpage_t utcb_area() const noexcept {…}
    l4_addr_t first_free_utcb() const noexcept
    { return _env.first_free_utcb; }
    l4_addr_t first_free_utcb() const noexcept {…}
 
    Cap_entry const *initial_caps() const noexcept
    { return _env.caps; }
    Cap_entry const *initial_caps() const noexcept {…}
 
    Cap_entry const *get(char const *name, unsigned l) const noexcept
    { return l4re_env_get_cap_l(name, l, &_env); }
    Cap_entry const *get(char const *name, unsigned l) const noexcept {…}
 
    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);
    }
    L4::Cap<T> get_cap(char const *name, unsigned l) const noexcept {…}
 
    template< typename T >
    L4::Cap<T> get_cap(char const *name) const noexcept
    { return get_cap<T>(name, __builtin_strlen(name)); }
    L4::Cap<T> get_cap(char const *name) const noexcept {…}
 
    void parent(L4::Cap<Parent> const &c) noexcept
    { _env.parent = c.cap(); }
    void parent(L4::Cap<Parent> const &c) noexcept {…}
    void mem_alloc(L4::Cap<Mem_alloc> const &c) noexcept
    { _env.mem_alloc = c.cap(); }
    void mem_alloc(L4::Cap<Mem_alloc> const &c) noexcept {…}
    void rm(L4::Cap<Rm> const &c) noexcept
    { _env.rm = c.cap(); }
    void rm(L4::Cap<Rm> const &c) noexcept {…}
    void log(L4::Cap<Log> const &c) noexcept
    { _env.log = c.cap(); }
    void log(L4::Cap<Log> const &c) noexcept {…}
    void main_thread(L4::Cap<L4::Thread> const &c) noexcept
    { _env.main_thread = c.cap(); }
    void main_thread(L4::Cap<L4::Thread> const &c) noexcept {…}
    void factory(L4::Cap<L4::Factory> const &c) noexcept
    { _env.factory = c.cap(); }
    void factory(L4::Cap<L4::Factory> const &c) noexcept {…}
    void first_free_cap(l4_cap_idx_t c) noexcept
    { _env.first_free_cap = c; }
    void first_free_cap(l4_cap_idx_t c) noexcept {…}
    void utcb_area(l4_fpage_t utcbs) noexcept
    { _env.utcb_area = utcbs; }
    void utcb_area(l4_fpage_t utcbs) noexcept {…}
    void first_free_utcb(l4_addr_t u) noexcept
    { _env.first_free_utcb = u; }
    void first_free_utcb(l4_addr_t u) noexcept {…}
 
    L4::Cap<L4::Scheduler> scheduler() const noexcept
    { return L4::Cap<L4::Scheduler>(_env.scheduler); }
    L4::Cap<L4::Scheduler> scheduler() const noexcept {…}
 
    void scheduler(L4::Cap<L4::Scheduler> const &c) noexcept
    { _env.scheduler = c.cap(); }
    void scheduler(L4::Cap<L4::Scheduler> const &c) noexcept {…}
 
    L4::Cap<Itas> itas() const noexcept
    { return L4::Cap<Itas>(_env.itas); }
    L4::Cap<Itas> itas() const noexcept {…}
 
    void itas(L4::Cap<Itas> const &c) noexcept
    { _env.itas = c.cap(); }
    void itas(L4::Cap<Itas> const &c) noexcept {…}
 
    L4::Cap<Dbg_events> dbg_events() const noexcept
    { return L4::Cap<Dbg_events>(_env.dbg_events); }
    L4::Cap<Dbg_events> dbg_events() const noexcept {…}
 
    void dbg_events(L4::Cap<Dbg_events> const &dbg_events) noexcept
    { _env.dbg_events = dbg_events.cap(); }
    void dbg_events(L4::Cap<Dbg_events> const &dbg_events) noexcept {…}
 
    void initial_caps(Cap_entry *first) noexcept
    { _env.caps = first; }
    void initial_caps(Cap_entry *first) noexcept {…}
  };
  class L4_EXPORT Env {…};
};