cap_alloc

Go to the documentation of this file.

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *          Alexander Warg <warg@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/task>
#include <l4/sys/smart_capability>
#include <l4/re/consts>
#include <l4/cxx/type_traits>
 
namespace L4Re {
 
class Cap_alloc
{
private:
  void operator = (Cap_alloc const &);
 
protected:
  Cap_alloc(Cap_alloc const &) {}
  Cap_alloc() {}
 
public:
 
  virtual L4::Cap<void> alloc() noexcept = 0;
  virtual void take(L4::Cap<void> cap) noexcept = 0;
 
  template< typename T >
  L4::Cap<T> alloc() noexcept
  { return L4::cap_cast<T>(alloc()); }
  L4::Cap<T> alloc() noexcept {…}
 
  virtual void free(L4::Cap<void> cap, l4_cap_idx_t task = L4_INVALID_CAP,
                       unsigned unmap_flags = L4_FP_ALL_SPACES) noexcept = 0;
  virtual bool release(L4::Cap<void> cap, l4_cap_idx_t task = L4_INVALID_CAP,
                       unsigned unmap_flags = L4_FP_ALL_SPACES) noexcept = 0;
 
  virtual ~Cap_alloc() = 0;
};
class Cap_alloc {…};
 
template<typename ALLOC>
struct Cap_alloc_t : ALLOC, L4Re::Cap_alloc
{
  template<typename ...ARGS>
  Cap_alloc_t(ARGS &&...args) : ALLOC(cxx::forward<ARGS>(args)...) {}
 
  L4::Cap<void> alloc() noexcept override { return ALLOC::alloc(); }
  void take(L4::Cap<void> cap) noexcept override { ALLOC::take(cap); }
 
  template <typename T>
  L4::Cap<T> alloc() noexcept
  {
    return L4::cap_cast<T>(alloc());
  }
 
  void free(L4::Cap<void> cap, l4_cap_idx_t task = L4_INVALID_CAP,
            unsigned unmap_flags = L4_FP_ALL_SPACES) noexcept override
  { ALLOC::free(cap, task, unmap_flags); }
 
  bool release(L4::Cap<void> cap, l4_cap_idx_t task,
               unsigned unmap_flags) noexcept override
  { return ALLOC::release(cap, task, unmap_flags); }
 
  void operator delete(void *) {}
};
 
inline
Cap_alloc::~Cap_alloc()
{}
Cap_alloc::~Cap_alloc() {…}
 
extern Cap_alloc *virt_cap_alloc;
 
template< unsigned long Unmap_flags = L4_FP_ALL_SPACES >
class Smart_cap_auto
{
private:
  Cap_alloc *_ca;
 
public:
  Smart_cap_auto() : _ca(0) {}
  Smart_cap_auto(Cap_alloc *ca) : _ca(ca) {}
 
  void free(L4::Cap_base &c)
  {
    if (c.is_valid() && _ca)
      _ca->free(L4::Cap<void>(c.cap()), This_task, Unmap_flags);
 
    invalidate(c);
  }
 
  static void invalidate(L4::Cap_base &c)
  {
    if (c.is_valid())
      c.invalidate();
  }
 
};
class Smart_cap_auto {…};
 
template< unsigned long Unmap_flags = L4_FP_ALL_SPACES >
class Smart_count_cap
{
private:
  Cap_alloc *_ca;
 
public:
  Smart_count_cap() : _ca(nullptr) {}
  Smart_count_cap(Cap_alloc *ca) : _ca(ca) {}
  void free(L4::Cap_base &c) noexcept
  {
    if (c.is_valid())
      {
        if (_ca && _ca->release(L4::Cap<void>(c.cap()), This_task, Unmap_flags))
          c.invalidate();
      }
  }
  void free(L4::Cap_base &c) noexcept {…}
 
  static void invalidate(L4::Cap_base &c) noexcept
  {
    if (c.is_valid())
      c.invalidate();
  }
  static void invalidate(L4::Cap_base &c) noexcept {…}
 
  L4::Cap_base copy(L4::Cap_base const &src)
  {
    if (src.is_valid())
      _ca->take(L4::Cap<void>(src.cap()));
    return src;
  }
  L4::Cap_base copy(L4::Cap_base const &src) {…}
};
class Smart_count_cap {…};
}