dataspace

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/bid_config.h>
#include <l4/sys/types.h>
#include <l4/sys/l4int.h>
#include <l4/sys/capability>
#include <l4/re/protocols.h>
#include <l4/sys/cxx/ipc_types>
#include <l4/sys/cxx/ipc_iface>
#include <l4/sys/cxx/types>
 
namespace L4Re
{
 
  // MISSING:
  // * size support in map, mapped size in reply
 
class L4_EXPORT Dataspace :
  public L4::Kobject_t<Dataspace, L4::Kobject, L4RE_PROTO_DATASPACE,
                       L4::Type_info::Demand_t<1> >
{
public:
 
  struct F
  {
    enum
    {
      Caching_shift = 4,    
    };
 
    enum Flags
    {
      R   = L4_FPAGE_RO,
      Ro  = L4_FPAGE_RO,
      RW  = L4_FPAGE_RW,
      W   = L4_FPAGE_W,
      X   = L4_FPAGE_X,
      RX  = L4_FPAGE_RX,
      RWX = L4_FPAGE_RWX,
      Rights_mask = 0x0f,
 
      Normal        = 0x00,
      Cacheable     = Normal,
      Bufferable    = 0x10,
      Uncacheable   = 0x20,
      Caching_mask  = 0x30,
    };
    enum Flags {…};
 
    L4_TYPES_FLAGS_OPS_DEF(Flags);
  };
  struct F {…};
 
  struct Flags : L4::Types::Flags_ops_t<Flags>
  {
    unsigned long raw;
    Flags() = default;
    explicit constexpr Flags(unsigned long f) : raw(f) {}
    constexpr Flags(F::Flags f) : raw(f) {}
    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 long fpage_rights() const
    { return raw & 0xf; }
  };
 
  typedef l4_uint64_t Size;
  typedef l4_uint64_t Offset;
  typedef l4_uint64_t Map_addr;
 
  struct Stats
  {
    Size size;    
    Flags flags;  
  };
  struct Stats {…};
 
 
  long map(Offset offset, Flags flags, Map_addr local_addr,
           Map_addr min_addr, Map_addr max_addr,
           L4::Cap<L4::Task> dst = L4::Cap<L4::Task>::Invalid) const noexcept;
 
  long map_region(Offset offset, Flags flags,
                  Map_addr min_addr, Map_addr max_addr,
                  L4::Cap<L4::Task> dst = L4::Cap<L4::Task>::Invalid) const noexcept;
 
  L4_RPC(long, clear, (Offset offset, Size size));
 
  L4_RPC(long, allocate, (Offset offset, Size size));
 
  L4_RPC(long, copy_in, (Offset dst_offs, L4::Ipc::Cap<Dataspace> src,
                         Offset src_offs, Size size));
 
  Size size() const noexcept;
 
  Flags flags() const noexcept;
 
  L4_RPC(long, info, (Stats *stats));
 
  L4_RPC_NF(long, map, (Offset offset, Map_addr spot,
                        Flags flags, L4::Ipc::Rcv_fpage r,
                        L4::Ipc::Snd_fpage &fp));
 
#ifdef CONFIG_MMU
  L4_RPC_NF(long, map_info, (l4_addr_t *start_addr, l4_addr_t *end_addr));
  inline long map_info([[maybe_unused]] l4_addr_t *start_addr,
                       [[maybe_unused]] l4_addr_t *end_addr)
  { return 0; }
  inline long map_info([[maybe_unused]] l4_addr_t *start_addr, {…}
#else
  L4_RPC(long, map_info, (l4_addr_t *start_addr, l4_addr_t *end_addr));
#endif
 
private:
 
  long __map(Offset offset, unsigned char *order, Flags flags,
             Map_addr local_addr, L4::Cap<L4::Task> dst) const noexcept;
 
public:
  typedef L4::Typeid::Rpcs<map_t, clear_t, info_t, copy_in_t,
                           allocate_t, map_info_t> Rpcs;
 
};
class L4_EXPORT Dataspace : {…};
 
}