l4/pkg/l4re-core/moe/server/src/dataspace_cont.cc

   1 /*
   2  * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
   3  *               Alexander Warg <warg@os.inf.tu-dresden.de>
   4  *     economic rights: Technische Universität Dresden (Germany)
   5  *
   6  * This file is part of TUD:OS and distributed under the terms of the
   7  * GNU General Public License 2.
   8  * Please see the COPYING-GPL-2 file for details.
   9  */
  10 #include <l4/cxx/minmax>
  11
  12 #include "dataspace_cont.h"
  13 #include "pages.h"
  14
  15 Moe::Dataspace_cont::Dataspace_cont(void *start, unsigned long size,
  16                                     unsigned short flags,
  17                                     unsigned char page_shift)
  18 : Dataspace(size, flags, page_shift), _start((char*)start)
  19 {
  20   if (!can_cow())
  21     return;
  22
  23   char *end = _start + l4_round_page(this->size());
  24   for (char *x = (char *)l4_trunc_page((l4_addr_t)_start); x < end;
  25        x += L4_PAGESIZE)
  26     Moe::Pages::share(x);
  27 }
  28
  29
  30 Moe::Dataspace::Address
  31 Moe::Dataspace_cont::address(l4_addr_t offset,
  32                              Ds_rw rw, l4_addr_t hot_spot,
  33                              l4_addr_t min, l4_addr_t max) const
  34 {
  35   if (!check_limit(offset))
  36     return Address(-L4_ERANGE);
  37
  38   min = l4_trunc_page(min);
  39   //max = l4_round_page(max);
  40
  41   l4_addr_t adr = l4_addr_t(_start) + offset;
  42   unsigned char order = L4_PAGESHIFT;
  43
  44   while (order < 30 /* limit to 1GB flexpage */)
  45     {
  46       l4_addr_t map_base = l4_trunc_size(adr, order + 1);
  47       if (map_base < l4_addr_t(_start))
  48         break;
  49
  50       if (map_base + (1UL << (order + 1)) -1 > (l4_addr_t(_start) + round_size() - 1))
  51         break;
  52
  53       map_base = l4_trunc_size(hot_spot, order + 1);
  54       if (map_base < min)
  55         break;
  56
  57       if (map_base + (1UL << (order + 1)) -1 > max)
  58         break;
  59
  60       l4_addr_t mask = ~(~0UL << (order + 1));
  61       if (hot_spot == ~0UL || ((adr ^ hot_spot) & mask))
  62         break;
  63
  64       ++order;
  65     }
  66
  67   l4_addr_t map_base = l4_trunc_size(adr, order);
  68   l4_addr_t offs = adr & ~(~0UL << order);
  69
  70   if (!is_writable())
  71     rw = Read_only;
  72
  73   return Address(map_base, order, rw, offs);
  74 }
  75
  76 void Moe::Dataspace_cont::unmap(bool ro) const throw()
  77 {
  78   unsigned long _size = round_size();
  79   l4_addr_t offs = 0;
  80
  81   while (_size)
  82     {
  83       Address addr = address(offs, Writable, ~0);
  84       l4_fpage_t fp
  85         = l4_fpage_set_rights(addr.fp(), ro ? L4_FPAGE_W : L4_FPAGE_RWX);
  86       l4_task_unmap(L4_BASE_TASK_CAP, fp, L4_FP_OTHER_SPACES);
  87       _size -= (1UL << l4_fpage_size(fp));
  88       offs  += (1UL << l4_fpage_size(fp));
  89     }
  90 }
  91
  92 int
  93 Moe::Dataspace_cont::dma_map(Dma_space *dma, l4_addr_t offset, l4_size_t *size,
  94                              Dma_attribs dma_attr, Dma_space::Direction dir,
  95                              Dma_space::Dma_addr *dma_addr)
  96 {
  97   (void)dma;
  98   (void)dma_attr;
  99   (void)dir;
 100
 101   if (offset >= this->size())
 102     return -L4_ERANGE;
 103
 104   *dma_addr = (l4_addr_t)start() + offset;
 105   *size = cxx::min(*size, (l4_size_t)(this->size() - offset));
 106   return 0;
 107 }
 108
 109 int
 110 Moe::Dataspace_cont::dma_unmap(Dma_space *, l4_addr_t, l4_size_t,
 111                                Dma_attribs, Dma_space::Direction)
 112 {
 113   return 0;
 114 }