rm

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>,
 *               Torsten Frenzel <frenzel@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/sys/l4int.h>
#include <l4/sys/capability>
#include <l4/re/protocols.h>
#include <l4/sys/pager>
#include <l4/sys/cxx/ipc_iface>
#include <l4/sys/cxx/ipc_ret_array>
#include <l4/sys/cxx/types>
#include <l4/re/consts>
#include <l4/re/dataspace>
 
namespace L4Re {


class L4_EXPORT Rm :
  public L4::Kobject_t<Rm, L4::Pager, L4RE_PROTO_RM,
                       L4::Type_info::Demand_t<1> >
{
public:
  typedef L4Re::Dataspace::Offset Offset;

  enum Detach_result
  {
    Detached_ds  = 0,      
    Kept_ds      = 1,      
    Split_ds     = 2,      
    Detach_result_mask = 3,
 
    Detach_again = 4,      
  };

  enum Region_flag_shifts
  {
    Caching_shift    = Dataspace::F::Caching_shift,
  };

  struct F
  {
    enum Attach_flags : l4_uint32_t
    {
      Search_addr  =  0x20000,
      In_area      =  0x40000,
      Eager_map    =  0x80000,
      No_eager_map = 0x100000,

      Attach_mask  = 0x1f0000,
    };
 
    friend void enum_bitops_enable(Attach_flags);

    enum Region_flags : l4_uint16_t
    {
      Rights_mask = 0x0f,
      R         = Dataspace::F::R,
      W         = Dataspace::F::W,
      X         = Dataspace::F::X,
      RW        = Dataspace::F::RW,
      RX        = Dataspace::F::RX,
      RWX       = Dataspace::F::RWX,

      Kernel      = 0x100,
      Detach_free = 0x200,
      Pager       = 0x400,
      Reserved    = 0x800,
 

      Caching_mask   = Dataspace::F::Caching_mask,
      Cache_normal   = Dataspace::F::Normal,
      Cache_buffered = Dataspace::F::Bufferable,
      Cache_uncached = Dataspace::F::Uncacheable,

      Ds_map_mask    = 0xff,

      Region_flags_mask = 0xffff,
    };
 
    friend void enum_bitops_enable(Region_flags);
 
    friend constexpr Dataspace::Flags map_flags(Region_flags rf)
    { return Dataspace::Flags(static_cast<l4_uint16_t>(rf) & Ds_map_mask); }
 
    struct Flags : L4::Types::Flags_ops_t<Flags>
    {
      l4_uint32_t raw;
 
      Flags() = default;
      explicit constexpr Flags(l4_uint32_t f) : raw(f) {}
      constexpr Flags(Attach_flags af) : raw(static_cast<l4_uint32_t>(af)) {}
      constexpr Flags(Region_flags rf) : raw(static_cast<l4_uint32_t>(rf)) {}
 
      constexpr Dataspace::Flags map_flags() const
      { return Dataspace::Flags(raw & Ds_map_mask); }
 
      constexpr Region_flags region_flags() const
      { return Region_flags(raw & Region_flags_mask); }
 
      constexpr Attach_flags attach_flags() const
      { return Attach_flags(raw & Attach_mask); }
 
      constexpr bool r() const { return raw & L4_FPAGE_RO; }
      constexpr bool w() const { return raw & L4_FPAGE_W; }
      constexpr bool x() const { return raw & L4_FPAGE_X; }
 
      constexpr unsigned cap_rights() const
      { return w() ? L4_CAP_FPAGE_RW : L4_CAP_FPAGE_RO; }
    };
 
    friend constexpr Flags operator | (Region_flags l, Attach_flags r)
    { return Flags(l) | Flags(r); }
 
    friend constexpr Flags operator | (Attach_flags l, Region_flags r)
    { return Flags(l) | Flags(r); }
  };
 
  using Attach_flags = F::Attach_flags;
  using Region_flags = F::Region_flags;
  using Flags = F::Flags;

  enum Detach_flags
  {
    Detach_exact   = 1,

    Detach_overlap = 2,

    Detach_keep = 4,
  };

  long reserve_area(l4_addr_t *start, unsigned long size,
                    Flags flags = Flags(0),
                    unsigned char align = L4_PAGESHIFT) const noexcept
  { return reserve_area_t::call(c(), start, size, flags, align); }
 
  L4_RPC_NF(long, reserve_area, (L4::Ipc::In_out<l4_addr_t *> start,
                                 unsigned long size,
                                 Flags flags,
                                 unsigned char align));

  template<typename T>
  long reserve_area(T **start, unsigned long size,
                    Flags flags = Flags(0),
                    unsigned char align = L4_PAGESHIFT) const noexcept
  {
    return reserve_area_t::call(c(), reinterpret_cast<l4_addr_t*>(start), size,
                                flags, align);
  }

  L4_RPC(long, free_area, (l4_addr_t addr));
 
  L4_RPC_NF(long, attach, (L4::Ipc::In_out<l4_addr_t *> start,
                           unsigned long size, Flags flags,
                           L4::Ipc::Opt<L4::Ipc::Cap<Dataspace>> mem,
                           Offset offs, unsigned char align,
                           L4::Ipc::Opt<l4_cap_idx_t> client_cap,
                           L4::Ipc::String<> name, Offset backing_offset));
 
  L4_RPC_NF(long, detach, (l4_addr_t addr, unsigned long size, unsigned flags,
                           l4_addr_t &start, l4_addr_t &rsize,
                           l4_cap_idx_t &mem_cap));

  long attach(l4_addr_t *start, unsigned long size, Flags flags,
              L4::Ipc::Cap<Dataspace> mem, Offset offs = 0,
              unsigned char align = L4_PAGESHIFT,
              L4::Cap<L4::Task> const task
                = L4::Cap<L4::Task>::Invalid,
              char const *name = nullptr,
              Offset backing_offset = 0) const noexcept;

  template<typename T>
  long attach(T **start, unsigned long size, Flags flags,
              L4::Ipc::Cap<Dataspace> mem, Offset offs = 0,
              unsigned char align = L4_PAGESHIFT,
              L4::Cap<L4::Task> const task
                = L4::Cap<L4::Task>::Invalid,
              char const *name = nullptr,
              Offset backing_offset = 0) const noexcept
  {
    union X { l4_addr_t a; T* t; };
    X *x = reinterpret_cast<X*>(start);
    return attach(&x->a, size, flags, mem, offs, align, task,
                  name, backing_offset);
  }
 
#if __cplusplus >= 201103L
  template<typename T>
  class Unique_region
  {
  private:
    T _addr;
    L4::Cap<Rm> _rm;
 
  public:
    Unique_region(Unique_region const &) = delete;
    Unique_region &operator = (Unique_region const &) = delete;

    Unique_region() noexcept
    : _addr(0), _rm(L4::Cap<Rm>::Invalid) {}

    explicit Unique_region(T addr) noexcept
    : _addr(addr), _rm(L4::Cap<Rm>::Invalid) {}

    Unique_region(T addr, L4::Cap<Rm> const &rm) noexcept
    : _addr(addr), _rm(rm) {}

    Unique_region(Unique_region &&o) noexcept : _addr(o.get()), _rm(o._rm)
    { o.release(); }

    Unique_region &operator = (Unique_region &&o) noexcept
    {
      if (&o != this)
        {
          if (_rm.is_valid())
            _rm->detach(reinterpret_cast<l4_addr_t>(_addr), 0);
          _rm = o._rm;
          _addr = o.release();
        }
      return *this;
    }

    ~Unique_region() noexcept
    {
      if (_rm.is_valid())
        _rm->detach(reinterpret_cast<l4_addr_t>(_addr), 0);
    }

    T get() const noexcept
    { return _addr; }

    T release() noexcept
    {
      _rm = L4::Cap<Rm>::Invalid;
      return _addr;
    }

    void reset(T addr, L4::Cap<Rm> const &rm) noexcept
    {
      if (_rm.is_valid())
        _rm->detach(l4_addr_t(_addr), 0);
 
      _rm = rm;
      _addr = addr;
    }

    void reset() noexcept
    { reset(0, L4::Cap<Rm>::Invalid); }

    bool is_valid() const noexcept
    { return _rm.is_valid(); }

    T operator * () const noexcept { return _addr; }

    T operator -> () const noexcept { return _addr; }
  };
 
  template<typename T>
  long attach(Unique_region<T> *start, unsigned long size, Flags flags,
              L4::Ipc::Cap<Dataspace> mem, Offset offs = 0,
              unsigned char align = L4_PAGESHIFT,
              L4::Cap<L4::Task> const task
                = L4::Cap<L4::Task>::Invalid,
              char const *name = nullptr,
              Offset backing_offset = 0) const noexcept
  {
    l4_addr_t addr = reinterpret_cast<l4_addr_t>(start->get());
 
    long res = attach(&addr, size, flags, mem, offs, align, task,
                      name, backing_offset);
    if (res < 0)
      return res;
 
    start->reset(reinterpret_cast<T>(addr), L4::Cap<Rm>(cap()));
    return res;
  }
#endif

  int detach(l4_addr_t addr, L4::Cap<Dataspace> *mem,
             L4::Cap<L4::Task> const &task = This_task) const noexcept;

  int detach(void *addr, L4::Cap<Dataspace> *mem,
             L4::Cap<L4::Task> const &task = This_task) const noexcept;

  int detach(l4_addr_t start, unsigned long size, L4::Cap<Dataspace> *mem,
             L4::Cap<L4::Task> const &task) const noexcept;

  long find(l4_addr_t *addr, unsigned long *size, Offset *offset,
            L4Re::Rm::Flags *flags, L4::Cap<Dataspace> *m) noexcept
  { return find_t::call(c(), addr, size, flags, offset, m); }
 
  L4_RPC_NF(long, find, (L4::Ipc::In_out<l4_addr_t *> addr,
                         L4::Ipc::In_out<unsigned long *> size,
                         L4Re::Rm::Flags *flags, Offset *offset,
                         L4::Ipc::As_value<L4::Cap<Dataspace>> *m));

  struct Region
  {
    l4_addr_t start;
    l4_addr_t end;
    F::Region_flags flags;
  };

  struct Area
  {
    l4_addr_t start;
    l4_addr_t end;
  };

  L4_RPC(long, get_regions, (l4_addr_t start, L4::Ipc::Ret_array<Region> regions));

  L4_RPC(long, get_areas, (l4_addr_t start, L4::Ipc::Ret_array<Area> areas));

  L4_RPC(long, get_info, (l4_addr_t addr, L4::Ipc::String<char> &name,
                          Offset &backing_offset));
 
  int detach(l4_addr_t start, unsigned long size, L4::Cap<Dataspace> *mem,
             L4::Cap<L4::Task> task, unsigned flags) const noexcept;
 
  typedef L4::Typeid::Rpcs<attach_t, detach_t, find_t,
                           reserve_area_t, free_area_t,
                           get_regions_t, get_areas_t,
                           get_info_t> Rpcs;
};
 
inline int
Rm::detach(l4_addr_t addr, L4::Cap<Dataspace> *mem,
           L4::Cap<L4::Task> const &task) const noexcept
{  return detach(addr, 1, mem, task, Detach_overlap); }
 
inline int
Rm::detach(void *addr, L4::Cap<Dataspace> *mem,
           L4::Cap<L4::Task> const &task) const noexcept
{
  return detach(reinterpret_cast<l4_addr_t>(addr), 1, mem, task,
                Detach_overlap);
}
 
inline int
Rm::detach(l4_addr_t addr, unsigned long size, L4::Cap<Dataspace> *mem,
           L4::Cap<L4::Task> const &task) const noexcept
{  return detach(addr, size, mem, task, Detach_exact); }
 
};