src/memory/mmap.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       mmap.cpp, version 1.1                              *
************************************************************
*                                                          *
*memory maps for various usages, based a bit on the 0.o5   *
*branch's mmap.cpp                                         *
*                                                          *
*27'05'04- first revision (1.1)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/blist.hpp"
#include "src/common/blistsort.hpp"
#include "src/memory/align.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/mmap.hpp"

//compare
int mmapcompar(const void *a, const void *b)
 {
uint32 A, B;
        A= bli_dt(a,mmap_s*)->start;
        B= bli_dt(b,mmap_s*)->start;

        if (A>B)
                return 1;
        if (A<B)
                return -1;
        return 0;
 }

/*init in range start:end*/
void mmap_t::init(uint32 start, uint32 end, class Memory::Heap::heapbox *hp)
 {
//clear
        memset(this, 0, sizeof(mmap_t));
/*init variables*/
        lock_mmap.init(const_cast<char*>("mmap"));
        range_lo = start; range_hi = end;
        heap=hp;
        map.init(FAC_MMAP|FAC_MEMREG, hp);
 }

/*done*/
void mmap_t::done()
 {
blist_s *item, *next;
/*dispose all memory*/
        item=map.head;
        while (item)
         {
                next = item->next;
                if (bli_dt(item,mmap_s*)->destroy)
//                      cout((uint32)bli_dt(item,mmap_s*)->destroy);
                        bli_dt(item,mmap_s*)->destroy(this,bli_dt(item,mmap_s*));
                heap->free(item->data);
                map.del(item);
                item = next;
         }
/*invalidate variables*/
        memset(this, 0, sizeof(mmap_t));
 }

//add a region; unsafe
blist_s *mmap_t::madd(uint32 start, size_t size, uint32 type, void *dt, uint64 info, int threadno, int (*destroy)(mmap_t*,mmap_s*))
 {
//prepare a region
mmap_s reg;
        memset(&reg, 0, sizeof(reg));
        reg.start=start;
        reg.size=size;
        reg.end=start+size;
        reg.type=type;
        reg.dt=dt;
        reg.info=info;
        reg.thread= threadno;
        reg.destroy=destroy;
//add
        return blistsort_add(&map, &reg, sizeof(reg), NULL, &mmapcompar);
 }

//del a region
int mmap_t::mdel(blist_s *item) {
        return map.del(item);
 }

int mmap_t::mdel(mmap_s *item)
 {
blist_s *i;
        for(i=map.head;i;i=i->next)
                if (bli_dt(i,mmap_s*)==item)
                        return mdel(i);
        return EINVAL;
 }

/*find the region starting@ start*/
blist_s *mmap_t::mfind(uint32 start)
 {
blist_s *item;
        for (item=map.head;item;item=item->next)
                if (bli_dt(item,mmap_s*)->start==start)
                        return item;
        return NULL;
 }

/*find the highest region below start*/
blist_s *mmap_t::lower (uint32 start)
 {
blist_s *item;
/*
-
- start X -
- X start X -
- start X -
*/
        for (item=map.head;item;item=item->next)
                if (bli_dt(item,mmap_s*)->start > start)
                        break;
        if (!item) {
                if (!map.head)
                        return NULL;
                else
                        return map.tail;
   }
        return item->prev;
 }

/*find the lowest region above start*/
blist_s *mmap_t::higher (uint32 start)
 {
blist_s *item;
        for (item=map.tail;item;item=item->prev)
                if (bli_dt(item,mmap_s*)->start < start)
                        break;
        if (!item) {
                if (!map.head)
                        return NULL;
                else
                        return map.head;
   }
        return item->next;
 }
 
/*how many elems?*/
uint32 mmap_t::lgth()
 {
blist_s *item;
uint32 i=0;
        for (item=map.head;item;item=item->next) i++;
        return i;
 }

/*=======================================ALLOCATION=========================================*/

/*find first place where size fits*/
int mmap_t::mfirstfit(uint32 size, uint32 alignment, uint32 *loc) {
        return mfitabove(size, alignment, range_lo, loc, FALSE);
 }

/*find last place where size fits*/
int mmap_t::mlastfit (uint32 size, uint32 alignment, uint32 *loc) {
        return mfitbelow(size, alignment, range_hi, loc, FALSE);
 }

/*try to put higher than min*/
int mmap_t::mfitabove(uint32 size, uint32 alignment, uint32 min, uint32 *loc, bool force)
 {
blist_s *item = higher(min);
/*check elemcount*/
        if (item == NULL) {
        /*check size*/
                if (range_hi >= size + align_up(min,alignment))
                 { *loc= align_up(min,alignment); return ESUCCESS; }
                else
                        return EINVAL;  /*no space availlable*/
   }

/*check if range_lo is used*/
        if (bli_dt(item,mmap_s*)->start > min)
                if (bli_dt(item,mmap_s*)->start - align_up(min, alignment) >= size)             /*if the space before first elem is big enough*/
                { *loc= align_up(min, alignment); return ESUCCESS; }

/*check space after each region*/
        for (item=item; item; item = item->next)
         {
        /*check if there's a next item*/
                if (item -> next)
                /*check if space is big enough*/
                        {if (bli_dt(item->next,mmap_s*)->start - align_up(bli_dt(item,mmap_s*)->end, alignment) >= size)
                                {*loc=align_up(bli_dt(item,mmap_s*)->end, alignment); return ESUCCESS;} }
                        else
                /*if this is the last element*/
                                if (range_hi - align_up(bli_dt(item,mmap_s*)->end, alignment) >= size)
                                        {*loc= align_up(bli_dt(item,mmap_s*)->end, alignment); return ESUCCESS; }
         }
/*try allocating without the minimum value*/
        if (force)
        if (min > range_lo)
                return mfitabove(size, alignment, range_lo, loc, FALSE);
/*'ve got here? so there's not enough space*/
        return EINVAL;
 }

/*put lower than max*/
int mmap_t::mfitbelow(uint32 size, uint32 alignment, uint32 max, uint32 *loc, bool force)
 {
blist_s *inode = lower(max);
mmap_s *reg;
uint32 high_lim;        /*the high limit of the block*/
int i = ESUCCESS;
/*check elemcount*/
        if (lgth() == 0) {
        /*check size*/
//              if (max - align_up(range_lo,alignment) >= size)
                if (align_down(max-size,alignment) >= range_lo)
                        { *loc=align_down(max-size,alignment);return ESUCCESS;}
//                      {cout("(2)");*loc=align_up(range_lo,alignment);return ESUCCESS;}
                else
                        return EINVAL;  /*no space availlable*/
   }
/*check range_hi*/
        reg = bli_dt(inode,mmap_s*);

        if (reg->end < max)
        if (align_down (max - size, alignment) >= reg->end)
                { *loc= align_down(max - size, alignment); return ESUCCESS;}
        high_lim = reg->start;
/*parse list*/
        while (i == ESUCCESS)
         {
                if (align_down (high_lim - size, alignment) >= reg->end)
                        {*loc= align_down(high_lim-size, alignment); return ESUCCESS;}
        /*next*/
                inode = inode->prev;
                if (inode == NULL)
                        { i = EINVAL; break; }
                high_lim=reg->start;
                reg = bli_dt(inode,mmap_s*);
         }
/*check if below the lowest*/
        inode = map.head;
        reg=bli_dt(inode,mmap_s*);
        if (align_down (reg->start - size,alignment) >= range_lo)
                { *loc= align_down (reg->start - size, alignment); return ESUCCESS;}
/*try allocating without the max value*/
        if (force)
        if (max < range_hi)
                return mfitabove(size, alignment, range_hi, loc, FALSE);
/*'ve got here? so there's not enough space*/
        return EINVAL;
 }

/*=================================SAFE FUNCS=============================*/

//add
blist_s *mmap_t::add(uint32 start, size_t size, uint32 type, void *dt, uint64 info, int threadno, int (*destroy)(mmap_t*,mmap_s*))
 {
blist_s *i;
        lock_mmap.lock();
        i= madd(start,size,type,dt,info,threadno,destroy);
        lock_mmap.ulock();

        return i;
 }

/*find in memory map the object connected*/
blist_s *mmap_t::mmap_find(uint32 type, uint32 virt)
 {
blist_s *item;
blist_s *el = NULL;
mmap_s *quux;
        lock_mmap.lock();
        for (item=map.head;item;item=item->next)
         {
                quux = (mmap_s*)item->data;
                if ((type == ME_ANY) || (quux -> type == type))
                        if (quux -> start <= virt)
                                if (quux->end >= virt)
                                        el = item;
         }

        lock_mmap.ulock();

        if (el == NULL)
                return NULL;

        return el;
 }

//del a region
int mmap_t::del(blist_s *item)
 {
int i;
        lock_mmap.lock();
        i= mdel(item);
        lock_mmap.ulock();

        return i;
 }

/*find the region starting@ start*/
blist_s *mmap_t::find(uint32 start)
 {
blist_s *item;
        lock_mmap.lock();
        item= mfind(start);
        lock_mmap.ulock();

        return item;
 }

/*find&&alloc first place where size fits*/
int mmap_t::firstfit(uint32 size, uint32 alignment, uint32 type, void *dt, uint64 info,
                uint32 *loc, int threadno, int (*destroy)(mmap_t*,mmap_s*))
 {
int i;
        lock_mmap.lock();
        i= mfirstfit(size,alignment,loc);
        if (i!= ESUCCESS)
         {      lock_mmap.ulock();
                return i; }
        i= (madd(*loc, size, type, dt, info, threadno, destroy) != NULL);
        lock_mmap.ulock();

        if (i == false)
                return EFAIL;
        return ESUCCESS;
 }

/*put lower than max, if force on fail allocs anywhere*/
int mmap_t::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)
 {
int i;
        lock_mmap.lock();
        i= mfitbelow(size,alignment,max,loc,force);
        if (i!= ESUCCESS)
         {      lock_mmap.ulock();
                return i; }
        i= (int) madd(*loc, size, type, dt, info, threadno,destroy);
        lock_mmap.ulock();

        if (i == NULL)
                return EFAIL;
        return ESUCCESS;
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---