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)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
 
#pragma once
 
#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,
    };
 
    L4_TYPES_FLAGS_OPS_DEF(Flags);
  };
 
  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;  
  };
 
 
  long map(Offset offset, Flags flags, Map_addr local_addr,
           Map_addr min_addr, Map_addr max_addr) const noexcept;
 
  long map_region(Offset offset, Flags flags,
                  Map_addr min_addr, Map_addr max_addr) 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));
 
private:
 
  long __map(Offset offset, unsigned char *order, Flags flags,
             Map_addr local_addr) const noexcept;
 
public:
  typedef L4::Typeid::Rpcs<map_t, clear_t, info_t, copy_in_t,
                           allocate_t> Rpcs;
 
};
 
}