__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)
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#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,
};


#define L4_FPAGE_C_REF_CNT      0x00

#define L4_FPAGE_C_NO_REF_CNT   0x10

#define L4_FPAGE_C_OBJ_RIGHT1   0x20

#define L4_FPAGE_C_OBJ_RIGHT2   0x40

#define L4_FPAGE_C_OBJ_RIGHT3   0x80

#define L4_FPAGE_C_OBJ_RIGHTS   0xe0

#define 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_CONSTEXPR l4_fpage_t
l4_fpage(l4_addr_t address, unsigned int order, unsigned char rights) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_fpage_all(void) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_fpage_invalid(void) L4_NOTHROW;
 

L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_iofpage(unsigned long port, unsigned int order) L4_NOTHROW;
 

L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_obj_fpage(l4_cap_idx_t obj, unsigned int order, unsigned char rights) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR int
l4_is_fpage_writable(l4_fpage_t fp) L4_NOTHROW;
 


L4_INLINE L4_CONSTEXPR l4_umword_t
l4_map_control(l4_umword_t spot, unsigned char cache, unsigned grant) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR l4_umword_t
l4_map_obj_control(l4_umword_t spot, unsigned grant) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_rights(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_type(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_size(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_order(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR unsigned long
l4_fpage_page(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR l4_addr_t
l4_fpage_memaddr(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR l4_cap_idx_t
l4_fpage_obj(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR unsigned long
l4_fpage_ioport(l4_fpage_t f) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_fpage_set_rights(l4_fpage_t src, unsigned char new_rights) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR int
l4_fpage_contains(l4_fpage_t fpage, l4_addr_t addr, unsigned order) L4_NOTHROW;

L4_INLINE L4_CONSTEXPR 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));

L4_INLINE L4_CONSTEXPR int
l4_is_fpage_valid(l4_fpage_t fp) L4_NOTHROW;
 
/*************************************************************************
 * Implementations
 *************************************************************************/
 
L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_rights(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_RIGHTS_MASK) >> L4_FPAGE_RIGHTS_SHIFT;
}
 
L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_type(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_TYPE_MASK) >> L4_FPAGE_TYPE_SHIFT;
}
 
L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_size(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_SIZE_MASK) >> L4_FPAGE_SIZE_SHIFT;
}
 
L4_INLINE L4_CONSTEXPR unsigned
l4_fpage_order(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_SIZE_MASK) >> L4_FPAGE_SIZE_SHIFT;
}
 
L4_INLINE L4_CONSTEXPR unsigned long
l4_fpage_page(l4_fpage_t f) L4_NOTHROW
{
  return (f.raw & L4_FPAGE_ADDR_MASK) >> L4_FPAGE_ADDR_SHIFT;
}
 
L4_INLINE L4_CONSTEXPR 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_CONSTEXPR l4_addr_t
l4_fpage_memaddr(l4_fpage_t f) L4_NOTHROW
{
  return f.raw & L4_FPAGE_ADDR_MASK;
}
 
L4_INLINE L4_CONSTEXPR l4_cap_idx_t
l4_fpage_obj(l4_fpage_t f) L4_NOTHROW
{
  return f.raw & L4_FPAGE_ADDR_MASK;
}

L4_INLINE L4_CONSTEXPR l4_fpage_t
__l4_fpage_generic(unsigned long address, unsigned int type,
                   unsigned int order, unsigned char rights) L4_NOTHROW;
 
L4_INLINE L4_CONSTEXPR l4_fpage_t
__l4_fpage_generic(unsigned long address, unsigned int type,
                   unsigned int order, unsigned char rights) L4_NOTHROW
{
  l4_fpage_t t =
    {
            ((rights  << L4_FPAGE_RIGHTS_SHIFT) & L4_FPAGE_RIGHTS_MASK)
          | ((type    << L4_FPAGE_TYPE_SHIFT)   & L4_FPAGE_TYPE_MASK)
    | ((order   << L4_FPAGE_SIZE_SHIFT)   & L4_FPAGE_SIZE_MASK)
    | ((address                       )   & L4_FPAGE_ADDR_MASK)
    };
  return t;
}
 
L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_fpage_set_rights(l4_fpage_t src, unsigned char new_rights) L4_NOTHROW
{
  l4_fpage_t f =
    {
      ((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_CONSTEXPR l4_fpage_t
l4_fpage(l4_addr_t address, unsigned int order, unsigned char rights) L4_NOTHROW
{
  return __l4_fpage_generic(address, L4_FPAGE_MEMORY, order, rights);
}
 
L4_INLINE L4_CONSTEXPR l4_fpage_t
l4_iofpage(unsigned long port, unsigned int order) L4_NOTHROW
{
  return __l4_fpage_generic(port << L4_FPAGE_ADDR_SHIFT, L4_FPAGE_IO, order, L4_FPAGE_RW);
}
 
L4_INLINE L4_CONSTEXPR 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_CONSTEXPR 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_CONSTEXPR l4_fpage_t
l4_fpage_invalid(void) L4_NOTHROW
{
  return __l4_fpage_generic(0, L4_FPAGE_SPECIAL, 0, 0);
}
 
 
L4_INLINE L4_CONSTEXPR int
l4_is_fpage_writable(l4_fpage_t fp) L4_NOTHROW
{
  return l4_fpage_rights(fp) & L4_FPAGE_W;
}
 
L4_INLINE L4_CONSTEXPR 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_CONSTEXPR 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 L4_CONSTEXPR 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_order(fpage)) >= addr + (1UL << log2size));
}
 
L4_INLINE L4_CONSTEXPR 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 = ~(~0UL << (order + 1));
      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;
 
      if (hotspot == ~0UL || ((addr ^ hotspot) & mask))
        break;
 
      ++order;
    }
 
  return order;
}
 
L4_INLINE L4_CONSTEXPR int
l4_is_fpage_valid(l4_fpage_t fp) L4_NOTHROW
{
  return l4_fpage_type(fp) != L4_FPAGE_SPECIAL || l4_fpage_order(fp) != 0;
}