src/memory/mmap.hpp

Idź do dokumentacji tego pliku.

/* header file for src/memory/mmap.cpp */

#ifndef _CORE_MEMORY_MMAP_HPP
#define _CORE_MEMORY_MMAP_HPP

/* necessary includes */
#include "src/common/blist.hpp"
#include "src/ipc/lock.hpp"
#include "src/memory/heap.hpp"

/*mapent_t type consts*/
const uint32 ME_NONE            = 0x0000;       /*none*/
const uint32 ME_OTHER           = 0x0001;       /*other, reserved*/
const uint32 ME_MM_FILE         = 0x0002;       /*memory mapped file*/
const uint32 ME_MOD             = 0x0003;       /*a module*/
const uint32 ME_CODE            = 0x0004;       /*process code or data*/
const uint32 ME_STACK           = 0x0005;       /*an ia-32 stack*/
const uint32 ME_STACKGUARD      = 0x0006;       /*ia-32 stack guard against overflows*/
const uint32 ME_MEMORY          = 0x0007;       /*an allocated memory page*/
const uint32 ME_USERDATA        = 0x0008;       /*some data from kernel to user app*/
const uint32 ME_SHMEM           = 0x0009;       /*shared memory or cow*/
const uint32 ME_UDATA           = 0x000a;       /*data used by the process*/
const uint32 ME_ANY             = 0xFFFFFFFF;   /*for searching*/

namespace Thread {
        struct thread_t; }

//a single element
struct mmap_s
 {
        uint32 start;
        uint32 end;
        uint32 size;
        uint32 type;
        void *dt;
        uint64 info;    //some info
        int thread;     //threadno
        int (*destroy)(class mmap_t*, struct mmap_s*);
 };

//the memory map
class mmap_t
 {
protected:
public:
        class IPC::Lock::lock_t lock_mmap;
uint32 range_lo, range_hi;              /*the range of the map*/
blist_t map;
class Memory::Heap::heapbox *heap;

/*all the below functions work without taking care of the spinlock. they should not be
used outside the safe functions, unless the lock is used*/
        blist_s *madd(uint32 start, size_t size, uint32 type, void *dt, uint64 info, int threadno, int (*destroy)(mmap_t*,mmap_s*));//add a region
        int mdel(blist_s *item);        //del a region
        int mdel(mmap_s *item);

        blist_s *mfind(uint32 start);   /*find the region starting@ start*/
        blist_s *lower (uint32 start);  /*find the highest region below start*/
        blist_s *higher (uint32 start); /*find the lowest region above start*/
        uint32 lgth();                                  /*how many elems?*/

//these only find not alloc
        int mfirstfit(uint32 size, uint32 alignment, uint32 *loc);      /*find first place where size fits*/
        int mlastfit (uint32 size, uint32 alignment, uint32 *loc);      /*find last place where size fits*/
        int mfitabove(uint32 size, uint32 alignment, uint32 min, uint32 *loc, bool force);      /*try to put higher than min. if force, on fail tries to allocate anywhere*/
        int mfitbelow(uint32 size, uint32 alignment, uint32 max, uint32 *loc, bool force);/*put lower than max, if force on fail allocs anywhere*/

public:
        void init(uint32 start, uint32 end, class Memory::Heap::heapbox *hp);   /*init in range start:end*/
        void done();            /*done*/

/*the following functions use locks and therefore are safe.*/
        int del(blist_s *item); //del a region
//search
        blist_s *find(uint32 start);    /*find the region starting@ start*/
        blist_s *mmap_find(uint32 type, uint32 virt);   /*find in memory map the object connected*/
//add
        blist_s *add(uint32 start, size_t size, uint32 type, void *dt, uint64 info, int threadno, int (*destroy)(mmap_t*,mmap_s*));//add a region

//these find and alloc
        int firstfit(uint32 size, uint32 alignment, uint32 type, void *dt, uint64 info,
                uint32 *loc, int threadno, int (*destroy)(mmap_t*,mmap_s*));/*find&&alloc first place where size fits*/
//      int lastfit (uint32 size, uint32 alignment, uint32 *loc);       /*find&&alloc last place where size fits*/
//      int fitabove(uint32 size, uint32 alignment, uint32 min, uint32 *loc, bool force);/*try to put higher than min. if force, on fail tries to allocate anywhere*/
        int fitbelow(uint32 size, uint32 alignment, uint32 max, uint32 type, void *dt,
                        uint64 info, uint32 *loc, int threadno, int (*destroy)(mmap_t*,mmap_s*), bool force);/*put lower than max, if force on fail allocs anywhere*/
 };

int mmapcompar(const void *a, const void *b);   //compare

#endif

---