mapdb.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef mapdb_h
#define mapdb_h

#include "types.h"

//
// INTERFACE definition follows 
//


struct Mapping_tree;            // forward decls
class Mapdb_tree;
class Physframe;

class Mapdb_defs
{
public:
  enum {
    slab_align = 1,
  };
};

class Mapping_entry
{
public:
  unsigned space:11;            
  unsigned size:1;              
  unsigned address:20;          
  unsigned depth:8;             

public:  
  inline bool space_is_sigma0();
  
  inline void set_space_to_sigma0();
} __attribute__((packed));

enum Mapping_type { Map_mem = 0, Map_io };

class Mapping 
{
  friend class Mapdb;
  friend class Mapping_tree;
  friend class Jdb_mapdb;
  friend struct Physframe;

  // CREATORS
  Mapping(const Mapping&);      // this constructor is undefined.

  // DATA
  Mapping_entry _data __attribute__((packed));

public:  
  inline unsigned space();
  
  inline Address vaddr();
  
  inline size_t size();
  
  inline Mapping_type type();
  
  Mapping * parent();
  
  Mapping * next_iter();
  
  Mapping * next_child(Mapping *parent);
  
  inline bool space_is_sigma0();

private:  
  inline Mapping();
  
  inline Mapping_entry * data();
  
  inline bool unused();
  
  inline bool is_end_tag();
  
  inline Mapping * next(const Mapping* end_of_tree);
  
  // A utility function to find the tree header belonging to a mapping. 
  // XXX This should probably be a static member of Mapping_tree to reduce 
  // coupling between Mapping and Mapping_tree.
  
  Mapping_tree * tree();
};

class Mapdb
{
  friend class Jdb_mapdb;

private:
  // DATA
#if 0
  Mapdb_tree* _tree;
#else
  Physframe* physframe;
#endif
  Address _start;


public:  
  // 
  // class Mapdb
  // 
  
  Mapdb(Address start, Address end);
  
  ~Mapdb();
  
  static Mapping * insert(Mapping *parent, unsigned space, Address va, size_t size, Mapping_type type);
  
  Mapping * lookup(unsigned space, Address va, Address phys);   // Mapping_type type
  
  void free(Mapping* mapping_of_tree);
  
  static void flush(Mapping *m, bool me_too);
  
  void grant(Mapping *m, unsigned new_space, Address va);
  
  static inline bool valid_address(Address phys);
};

//
// IMPLEMENTATION includes follow (for use by inline functions)
//


#include "config.h"
#include "kip.h"

//
// IMPLEMENTATION of inline functions (and needed classes)
//



inline bool Mapping_entry::space_is_sigma0()
{ return space == Config::sigma0_taskno; }


inline void Mapping_entry::set_space_to_sigma0()
{ space = Config::sigma0_taskno; }



inline Mapping_entry *
Mapping::data()
{
  return &_data;
}


inline unsigned
Mapping::space()
{
  return data()->space;
}


inline Address 
Mapping::vaddr()
{
  return (data()->address << Config::PAGE_SHIFT);
}


inline size_t 
Mapping::size()
{
  return data()->size
         ? Config::SUPERPAGE_SIZE
         : Config::PAGE_SIZE;
}


inline Mapping_type 
Mapping::type()
{
  // return data()->type;;
  return Map_mem;
}



inline bool
Mapping::space_is_sigma0()
{
  return space() == Config::sigma0_taskno;
}



inline bool
Mapdb::valid_address(Address phys)
{
  return !Config::Mapdb_ram_only || phys < Kip::k()->main_memory_high();
}

#endif // mapdb_h

---