kip

Go to the documentation of this file.

// vim:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2008-2009 Author(s)
 *     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.
 */
#ifndef L4_SYS_KIP_H__
#define L4_SYS_KIP_H__
 
#include <l4/cxx/static_vector>
 
/* C++ version of memory descriptors */
 
namespace L4
{
  namespace Kip
  {
    class Mem_desc
    {
    public:
      enum Mem_type
      {
        Undefined    = 0x0,  
        Conventional = 0x1,  
        Reserved     = 0x2,  
        Dedicated    = 0x3,  
        Shared       = 0x4,  
 
        Info         = 0xd,  
        Bootloader   = 0xe,  
        Arch         = 0xf   
      };
 
      enum Info_sub_type
      {
        Info_acpi_rsdp = 0  
      };
 
      enum Arch_sub_type_common
      {
        Arch_acpi_tables  = 3,  
        Arch_acpi_nvs     = 4,  
      };
 
    private:
      unsigned long _l, _h;
 
      static unsigned long &memory_info(void *kip) noexcept
      { return *(reinterpret_cast<unsigned long *>(kip) + 21); }
 
      static unsigned long memory_info(void const *kip) noexcept
      { return *(reinterpret_cast<unsigned long const *>(kip) + 21); }
 
    public:
      static Mem_desc *first(void *kip) noexcept
      {
        return reinterpret_cast<Mem_desc *>(reinterpret_cast<char *>(kip)
               + (memory_info(kip) >> ((sizeof(unsigned long) / 2) * 8)));
      }
 
      static Mem_desc const *first(void const *kip) noexcept
      {
        char const *addr = reinterpret_cast<char const *>(kip)
          + (memory_info(kip) >> ((sizeof(unsigned long) / 2) * 8));
        return reinterpret_cast<Mem_desc const *>(addr);
      }
 
      static unsigned long count(void const *kip) noexcept
      {
        return memory_info(kip)
               & ((1UL << ((sizeof(unsigned long) / 2) * 8)) - 1);
      }
 
      static void count(void *kip, unsigned count) noexcept
      {
        unsigned long &mi = memory_info(kip);
        mi = (mi & ~((1UL << ((sizeof(unsigned long) / 2) * 8)) - 1)) | count;
      }
 
      static inline cxx::static_vector<Mem_desc const> all(void const *kip)
      {
        return cxx::static_vector<Mem_desc const>(Mem_desc::first(kip),
                                                  Mem_desc::count(kip));
      }
 
      static inline cxx::static_vector<Mem_desc> all(void *kip)
      {
        return cxx::static_vector<Mem_desc>(Mem_desc::first(kip),
                                            Mem_desc::count(kip));
      }
 
      Mem_desc(unsigned long start, unsigned long end,
               Mem_type t, unsigned char st = 0, bool virt = false,
               bool eager = false) noexcept
      : _l((start & ~0x3ffUL) | (t & 0x0f) | ((st << 4) & 0x0f0)
           | (virt ? 0x0200 : 0x0) | (eager ? 0x100 : 0x0)), _h(end | 0x3ffUL)
      {}
 
      unsigned long start() const noexcept { return _l & ~0x3ffUL; }
 
      unsigned long end() const noexcept { return _h | 0x3ffUL; }
 
      unsigned long size() const noexcept { return end() + 1 - start(); }
 
      Mem_type type() const noexcept
      {
        return static_cast<Mem_type>(_l & 0x0f);
      }
 
      unsigned char sub_type() const noexcept { return (_l >> 4) & 0x0f; }
 
      unsigned is_virtual() const noexcept { return _l & 0x200; }
 
      unsigned eager_map() const noexcept { return _l & 0x100; }
 
      void set(unsigned long start, unsigned long end,
               Mem_type t, unsigned char st = 0, bool virt = false,
               bool eager = false) noexcept
      {
        _l = (start & ~0x3ffUL) | (t & 0x0f) | ((st << 4) & 0x0f0)
             | (virt?0x0200:0x0) | (eager ? 0x0100 : 0x0);
 
        _h = end | 0x3ffUL;
      }
 
    };
  };
};
 
#endif