__l4_fpage.h

 
/*
 * (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/compiler.h>
 
enum L4_fpage_consts
{
  L4_FPAGE_RIGHTS_SHIFT = 0,  
  L4_FPAGE_TYPE_SHIFT   = 4,  
  L4_FPAGE_SIZE_SHIFT   = 6,  
  L4_FPAGE_ADDR_SHIFT   = 12, 
 
  L4_FPAGE_RIGHTS_BITS = 4,   
  L4_FPAGE_TYPE_BITS   = 2,   
  L4_FPAGE_SIZE_BITS   = 6,   
  L4_FPAGE_ADDR_BITS   = L4_MWORD_BITS - L4_FPAGE_ADDR_SHIFT,  
 
  L4_FPAGE_RIGHTS_MASK  = ((1UL << L4_FPAGE_RIGHTS_BITS) - 1)
                          << L4_FPAGE_RIGHTS_SHIFT,
  L4_FPAGE_TYPE_MASK    = ((1UL << L4_FPAGE_TYPE_BITS)   - 1)
                          << L4_FPAGE_TYPE_SHIFT,
  L4_FPAGE_SIZE_MASK    = ((1UL << L4_FPAGE_SIZE_BITS)   - 1)
                          << L4_FPAGE_SIZE_SHIFT,
  L4_FPAGE_ADDR_MASK    = ~0UL << L4_FPAGE_ADDR_SHIFT,
  L4_FPAGE_RIGHTS_ALL   = L4_FPAGE_RIGHTS_MASK,
};
 
typedef union {
  l4_umword_t fpage;          
  l4_umword_t raw;            
} l4_fpage_t;
 
enum
{
  L4_WHOLE_ADDRESS_SPACE = 63
};
 
typedef struct {
  l4_umword_t snd_base;      
  l4_fpage_t fpage;          
} l4_snd_fpage_t;
 
 
enum L4_fpage_rights
{
  L4_FPAGE_X     = 1,                        
  L4_FPAGE_W     = 2,                        
  L4_FPAGE_RO    = 4,                        
  L4_FPAGE_RW    = L4_FPAGE_RO | L4_FPAGE_W, 
  L4_FPAGE_RX    = L4_FPAGE_RO | L4_FPAGE_X, 
  L4_FPAGE_RWX   = L4_FPAGE_RW | L4_FPAGE_X, 
};
 
enum L4_cap_fpage_rights
{
  L4_CAP_FPAGE_W     = 0x1,
  L4_CAP_FPAGE_S     = 0x2,
  L4_CAP_FPAGE_R     = 0x4,
  L4_CAP_FPAGE_RO    = 0x4, 
  L4_CAP_FPAGE_D     = 0x8,
  L4_CAP_FPAGE_RW    = L4_CAP_FPAGE_R | L4_CAP_FPAGE_W,
  L4_CAP_FPAGE_RS    = L4_CAP_FPAGE_R | L4_CAP_FPAGE_S,
  L4_CAP_FPAGE_RWS   = L4_CAP_FPAGE_RW | L4_CAP_FPAGE_S,
  L4_CAP_FPAGE_RWSD  = L4_CAP_FPAGE_RWS | L4_CAP_FPAGE_D,
  L4_CAP_FPAGE_RWD  = L4_CAP_FPAGE_RW | L4_CAP_FPAGE_D,
  L4_CAP_FPAGE_RSD   = L4_CAP_FPAGE_RS | L4_CAP_FPAGE_D,
};
 
enum L4_fpage_type
{
  L4_FPAGE_SPECIAL = 0, 
  L4_FPAGE_MEMORY  = 1, 
  L4_FPAGE_IO      = 2, 
  L4_FPAGE_OBJ     = 3, 
};
 
enum L4_fpage_control
{
  L4_FPAGE_CONTROL_OFFSET_SHIFT = 12,
  L4_FPAGE_CONTROL_MASK = ~0UL << L4_FPAGE_CONTROL_OFFSET_SHIFT,
};
 
enum L4_obj_fpage_ctl
{
  L4_FPAGE_C_REF_CNT    = 0x00,  
  L4_FPAGE_C_NO_REF_CNT = 0x10,  
 
  L4_FPAGE_C_OBJ_RIGHT1 = 0x20,  
  L4_FPAGE_C_OBJ_RIGHT2 = 0x40,  
  L4_FPAGE_C_OBJ_RIGHT3 = 0x80,  
  L4_FPAGE_C_OBJ_RIGHTS = 0xe0,  
 
  L4_FPAGE_C_IPCGATE_SVR = L4_FPAGE_C_OBJ_RIGHT1
};
 
 
enum l4_fpage_cacheability_opt_t
{
  L4_FPAGE_CACHE_OPT   = 0x1,
 
  L4_FPAGE_CACHEABLE   = 0x3,
 
  L4_FPAGE_BUFFERABLE  = 0x5,
 
  L4_FPAGE_UNCACHEABLE = 0x1
};
 
 
enum
{
  L4_WHOLE_IOADDRESS_SPACE  = 16,
 
  L4_IOPORT_MAX             = (1L << L4_WHOLE_IOADDRESS_SPACE)
};
 
 
 
L4_INLINE l4_fpage_t
l4_fpage(l4_addr_t address, unsigned int size, unsigned char rights) L4_NOTHROW;
 
L4_INLINE l4_fpage_t
l4_fpage_all(void) L4_NOTHROW;
 
L4_INLINE l4_fpage_t
l4_fpage_invalid(void) L4_NOTHROW;
 
 
L4_INLINE l4_fpage_t
l4_iofpage(unsigned long port, unsigned int size) L4_NOTHROW;
 
 
L4_INLINE l4_fpage_t
l4_obj_fpage(l4_cap_idx_t obj, unsigned int order, unsigned char rights) L4_NOTHROW;
 
L4_INLINE int
l4_is_fpage_writable(l4_fpage_t fp) L4_NOTHROW;
 
 
L4_INLINE l4_umword_t
l4_map_control(l4_umword_t spot, unsigned char cache, unsigned grant) L4_NOTHROW;
 
L4_INLINE l4_umword_t
l4_map_obj_control(l4_umword_t spot, unsigned grant) L4_NOTHROW;
 
L4_INLINE unsigned
l4_fpage_rights(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE unsigned
l4_fpage_type(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE unsigned
l4_fpage_size(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE unsigned long
l4_fpage_page(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE l4_addr_t
l4_fpage_memaddr(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE l4_cap_idx_t
l4_fpage_obj(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE unsigned long
l4_fpage_ioport(l4_fpage_t f) L4_NOTHROW;
 
L4_INLINE l4_fpage_t
l4_fpage_set_rights(l4_fpage_t src, unsigned char new_rights) L4_NOTHROW;
 
L4_INLINE int
l4_fpage_contains(l4_fpage_t fpage, l4_addr_t addr, unsigned size) L4_NOTHROW;
 
L4_INLINE unsigned char
l4_fpage_max_order(unsigned char order, l4_addr_t addr,
                   l4_addr_t min_addr, l4_addr_t max_addr,
                   l4_addr_t hotspot L4_DEFAULT_PARAM(0));
 
/*************************************************************************
 * Implementations
 *************************************************************************/
 
L4_INLINE unsigned
l4_fpage_rights(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_RIGHTS_MASK) >> L4_FPAGE_RIGHTS_SHIFT;
}
 
L4_INLINE unsigned
l4_fpage_type(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_TYPE_MASK) >> L4_FPAGE_TYPE_SHIFT;
}
 
L4_INLINE unsigned
l4_fpage_size(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_SIZE_MASK) >> L4_FPAGE_SIZE_SHIFT;
}
 
L4_INLINE unsigned long
l4_fpage_page(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_ADDR_MASK) >> L4_FPAGE_ADDR_SHIFT;
}
 
L4_INLINE unsigned long
l4_fpage_ioport(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_ADDR_MASK) >> L4_FPAGE_ADDR_SHIFT;
}
 
L4_INLINE l4_addr_t
l4_fpage_memaddr(l4_fpage_t f) L4_NOTHROW
{
  return f.raw & L4_FPAGE_ADDR_MASK;
}
 
L4_INLINE l4_cap_idx_t
l4_fpage_obj(l4_fpage_t f) L4_NOTHROW
{
  return f.raw & L4_FPAGE_ADDR_MASK;
}
 
L4_INLINE l4_fpage_t
__l4_fpage_generic(unsigned long address, unsigned int type,
                   unsigned int size, unsigned char rights) L4_NOTHROW;
 
L4_INLINE l4_fpage_t
__l4_fpage_generic(unsigned long address, unsigned int type,
                   unsigned int size, unsigned char rights) L4_NOTHROW
{
  l4_fpage_t t;
  t.raw =   ((rights  << L4_FPAGE_RIGHTS_SHIFT) & L4_FPAGE_RIGHTS_MASK)
          | ((type    << L4_FPAGE_TYPE_SHIFT)   & L4_FPAGE_TYPE_MASK)
    | ((size    << L4_FPAGE_SIZE_SHIFT)   & L4_FPAGE_SIZE_MASK)
    | ((address                       )   & L4_FPAGE_ADDR_MASK);
  return t;
}
 
L4_INLINE l4_fpage_t
l4_fpage_set_rights(l4_fpage_t src, unsigned char new_rights) L4_NOTHROW
{
  l4_fpage_t f;
  f.raw = ((L4_FPAGE_TYPE_MASK | L4_FPAGE_SIZE_MASK | L4_FPAGE_ADDR_MASK) & src.raw)
          | ((new_rights << L4_FPAGE_RIGHTS_SHIFT) & L4_FPAGE_RIGHTS_MASK);
  return f;
}
 
L4_INLINE l4_fpage_t
l4_fpage(l4_addr_t address, unsigned int size, unsigned char rights) L4_NOTHROW
{
  return __l4_fpage_generic(address, L4_FPAGE_MEMORY, size, rights);
}
 
L4_INLINE l4_fpage_t
l4_iofpage(unsigned long port, unsigned int size) L4_NOTHROW
{
  return __l4_fpage_generic(port << L4_FPAGE_ADDR_SHIFT, L4_FPAGE_IO, size, L4_FPAGE_RW);
}
 
L4_INLINE l4_fpage_t
l4_obj_fpage(l4_cap_idx_t obj, unsigned int order, unsigned char rights) L4_NOTHROW
{
  static_assert((unsigned long)L4_CAP_SHIFT >= L4_FPAGE_ADDR_SHIFT,
                "Capability index does not fit into fpage.");
  return __l4_fpage_generic(obj, L4_FPAGE_OBJ, order, rights);
}
 
L4_INLINE l4_fpage_t
l4_fpage_all(void) L4_NOTHROW
{
  return __l4_fpage_generic(0, L4_FPAGE_SPECIAL, L4_WHOLE_ADDRESS_SPACE, 0);
}
 
L4_INLINE l4_fpage_t
l4_fpage_invalid(void) L4_NOTHROW
{
  return __l4_fpage_generic(0, L4_FPAGE_SPECIAL, 0, 0);
}
 
 
L4_INLINE int
l4_is_fpage_writable(l4_fpage_t fp) L4_NOTHROW
{
  return l4_fpage_rights(fp) & L4_FPAGE_W;
}
 
L4_INLINE l4_umword_t
l4_map_control(l4_umword_t snd_base, unsigned char cache, unsigned grant) L4_NOTHROW
{
  return (snd_base & L4_FPAGE_CONTROL_MASK)
         | ((l4_umword_t)cache << 4) | L4_ITEM_MAP | grant;
}
 
L4_INLINE l4_umword_t
l4_map_obj_control(l4_umword_t snd_base, unsigned grant) L4_NOTHROW
{
  return l4_map_control(snd_base, 0, grant);
}
 
L4_INLINE int
l4_fpage_contains(l4_fpage_t fpage, l4_addr_t addr, unsigned log2size) L4_NOTHROW
{
  l4_addr_t fa = l4_fpage_memaddr(fpage);
  return (fa <= addr)
         && (fa + (1UL << l4_fpage_size(fpage)) >= addr + (1UL << log2size));
}
 
L4_INLINE unsigned char
l4_fpage_max_order(unsigned char order, l4_addr_t addr,
                   l4_addr_t min_addr, l4_addr_t max_addr,
                   l4_addr_t hotspot)
{
  while (order < 30 /* limit to 1GB flexpages */)
    {
      l4_addr_t mask;
      l4_addr_t base = l4_trunc_size(addr, order + 1);
      if (base < min_addr)
        return order;
 
      if (base + (1UL << (order + 1)) - 1 > max_addr - 1)
        return order;
 
      mask = ~(~0UL << (order + 1));
      if (hotspot == ~0UL || ((addr ^ hotspot) & mask))
        break;
 
      ++order;
    }
 
  return order;
}