capability.h

 
#pragma once
 
#include <l4/sys/consts.h>
#include <l4/sys/types.h>
#include <l4/sys/task.h>
 
namespace L4 {
 
class Task;
class Kobject;
 
template< typename T > class L4_EXPORT Cap;
 
class L4_EXPORT Cap_base
{
public:
  enum No_init_type
  {
     No_init
  };
 
  enum Cap_type
  {
    Invalid = L4_INVALID_CAP 
  };
 
  l4_cap_idx_t cap() const noexcept { return _c; }
 
  bool is_valid() const noexcept { return !(_c & L4_INVALID_CAP_BIT); }
 
  explicit operator bool () const noexcept
  { return !(_c & L4_INVALID_CAP_BIT); }
 
  l4_fpage_t fpage(unsigned rights = L4_CAP_FPAGE_RWS) const noexcept
  { return l4_obj_fpage(_c, 0, rights); }
 
  l4_umword_t snd_base(unsigned grant = L4_MAP_ITEM_MAP,
                       l4_cap_idx_t base = L4_INVALID_CAP) const noexcept
  {
    if (base == L4_INVALID_CAP)
      base = _c;
    return l4_map_obj_control(base, grant);
  }
 
 
  bool operator == (Cap_base const &o) const noexcept
  { return _c == o._c; }
 
  bool operator != (Cap_base const &o) const noexcept
  { return _c != o._c; }
 
  inline l4_msgtag_t validate(l4_utcb_t *u = l4_utcb()) const noexcept;
 
  inline l4_msgtag_t validate(Cap<Task> task,
                              l4_utcb_t *u = l4_utcb()) const noexcept;
 
  void invalidate() noexcept { _c = L4_INVALID_CAP; }
protected:
  explicit Cap_base(l4_cap_idx_t c) noexcept : _c(c) {}
  explicit Cap_base(Cap_type cap) noexcept : _c(cap) {}
 
  explicit Cap_base(l4_default_caps_t cap) noexcept : _c(cap) {}
 
  explicit Cap_base() noexcept {}
 
  void move(Cap_base const &src) const
  {
    if (!is_valid() || !src.is_valid())
      return;
 
    l4_task_map(L4_BASE_TASK_CAP, L4_BASE_TASK_CAP, src.fpage(L4_CAP_FPAGE_RWSD),
                snd_base(L4_MAP_ITEM_GRANT) | L4_FPAGE_C_OBJ_RIGHTS);
  }
 
  void copy(Cap_base const &src) const
  {
    if (!is_valid() || !src.is_valid())
      return;
 
    l4_task_map(L4_BASE_TASK_CAP, L4_BASE_TASK_CAP, src.fpage(L4_CAP_FPAGE_RWSD),
                snd_base() | L4_FPAGE_C_OBJ_RIGHTS);
  }
 
  l4_cap_idx_t _c;
};
 
 
template< typename T >
class L4_EXPORT Cap : public Cap_base
{
private:
  friend class L4::Kobject;
 
  explicit Cap(T const *p) noexcept
  : Cap_base(reinterpret_cast<l4_cap_idx_t>(p)) {}
 
public:
 
  template< typename From >
  static void check_convertible_from() noexcept
  {
    using To = T;
    [[maybe_unused]] To* t = static_cast<From*>(nullptr);
  }
 
  template< typename From >
  static void check_castable_from() noexcept
  {
    using To = T;
    [[maybe_unused]] To *t = static_cast<To *>(static_cast<From *>(nullptr));
  }
 
  template< typename O >
  Cap(Cap<O> const &o) noexcept : Cap_base(o.cap())
  { check_convertible_from<O>(); }
 
  Cap(Cap_type cap) noexcept : Cap_base(cap) {}
 
  Cap(l4_default_caps_t cap) noexcept : Cap_base(cap) {}
 
  explicit Cap(l4_cap_idx_t idx = L4_INVALID_CAP) noexcept : Cap_base(idx) {}
 
  explicit Cap(No_init_type) noexcept {}
 
  Cap move(Cap const &src) const
  {
    Cap_base::move(src);
    return *this;
  }
 
  Cap copy(Cap const &src) const
  {
    Cap_base::copy(src);
    return *this;
  }
 
  T *operator -> () const noexcept { return reinterpret_cast<T*>(_c); }
};
 
 
template<>
class L4_EXPORT Cap<void> : public Cap_base
{
public:
 
  explicit Cap(void const *p) noexcept
  : Cap_base(reinterpret_cast<l4_cap_idx_t>(p)) {}
 
  Cap(Cap_type cap) noexcept : Cap_base(cap) {}
 
  Cap(l4_default_caps_t cap) noexcept : Cap_base(cap) {}
 
  explicit Cap(l4_cap_idx_t idx = L4_INVALID_CAP) noexcept : Cap_base(idx) {}
  explicit Cap(No_init_type) noexcept {}
 
  template< typename From >
  static void check_convertible_from() noexcept {}
 
  template< typename From >
  static void check_castable_from() noexcept {}
 
  Cap move(Cap const &src) const
  {
    Cap_base::move(src);
    return *this;
  }
 
  Cap copy(Cap const &src) const
  {
    Cap_base::copy(src);
    return *this;
  }
 
  template< typename T >
  Cap(Cap<T> const &o) noexcept : Cap_base(o.cap()) {}
};
 
template< typename T, typename F >
inline
Cap<T> cap_cast(Cap<F> const &c) noexcept
{
  Cap<T>::template check_castable_from<F>();
  return Cap<T>(c.cap());
}
 
// gracefully deal with L4::Kobject ambiguity
template< typename T >
inline
Cap<T> cap_cast(Cap<L4::Kobject> const &c) noexcept
{
  return Cap<T>(c.cap());
}
 
template< typename T, typename F >
inline
Cap<T> cap_reinterpret_cast(Cap<F> const &c) noexcept
{
  return Cap<T>(c.cap());
}
 
}