src/memory/zone.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                             *
************************************************************
*       zone.cpp, version 1.0                              *
************************************************************
*                                                          *
*the following file suplies code to manage zones of pages, *
*on which we get and free pages. based on stacks           *
*                                                          *
*25'04'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/tty/teletype.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/zone.hpp"

namespace Memory {


/*init a zone*/
void zone::init (uint32 *buf, uint32 elems, size_t pg_siz) {
        page_list.nw((char*)buf,elems);
        one_page=pg_siz;
 }

/*free memory*/
void zone::done()
 {
        sysfail("zone::done() not permitted");
 }

/*set the page count*/
void zone::set_length(size_t n) {
        page_list.stack_ptr=n;
 }

/*allocate pages*/
addr_t zone::alloc(size_t cnt)
 {
        if (page_list.lgth() < cnt)
                return NULL;
/*allocate a single page*/
        if (cnt == 1)
                return (addr_t) page_list.pop();
/*allocate more pages. the stack is sorted with lesser values at top*/
uint32 first_ptr, first, count;
int sp=page_list.stack_ptr-1;
bool flag=false;
bool found=false;

        while (sp >= 0) {
                if (!flag) {
                        first_ptr=sp; first=page_list.stack[sp];
                        sp--; flag=true;count=1;
                } else {
                        if (page_list.stack[sp]!=first+count*one_page)
                         { flag=false;} else
                         { count++; sp--; if (count==cnt) {found=true;break;} }
                 }
         }
/*found it?*/
        if (!found)
                return NULL;

/*eliminate pages from stack*/
        if (first_ptr+1 != page_list.stack_ptr)
                memmove(page_list.stack+first_ptr-cnt+1,//dest
                        page_list.stack+first_ptr+1,//src
                        sizeof(uint32)*(page_list.stack_ptr-first_ptr-1));//count
        page_list.stack_ptr-=cnt;

        return first;
 }

/*free a page to the zone*/
int zone::free(addr_t physical)
 {
/*sanity*/
        if (physical & 0xfff)
         {
                complain("bad page addr");
                return -1;
         }

        page_list.verify();
/*the stack has to be sorted in shrinking order*/
/*the only num?*/

        if (page_list.stack_ptr == 0)
         {page_list.stack_ptr=1;
         page_list.stack[0]=physical;return 1;}

/*is this the biggest num yet?*/
        if (page_list.stack[0] < physical)
         {
                memmove(page_list.stack+1,page_list.stack,page_list.stack_ptr*4);
                page_list.stack[0]=physical;
                page_list.stack_ptr++; return 1;
         }
/*the lowest?*/
        if (page_list.stack[page_list.stack_ptr-1] > physical)
         {
                page_list.stack[page_list.stack_ptr]=physical;
                page_list.stack_ptr++; return 1; }
/*in the middle?*/
uint32 sp=0;
        while (page_list.stack[sp]>physical) sp++;
/*now, sp points to first element which is smaller than physical*/
        memmove(page_list.stack+sp+1,
                page_list.stack+sp,
                4*(page_list.stack_ptr-sp));
        page_list.stack[sp]=physical;

        page_list.stack_ptr++;
        return 1;
 }

/*get page count*/
size_t zone::length() {
        return page_list.lgth();
 }


 };     /*namespace Memory*/

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

---