---

ToyMem.c

/***************************************************************************
                          ToyMem.c  -  Core code for the Toy Memory Manager.
                             -------------------
    begin                : Sat Jan 25 2003
    copyright            : (C) 2003 by Tyler Montbriand
    student #            : 200200370
    class                : CS330
    email                : monttyle@heavyspace.ca
***************************************************************************/

#include<malloc.h>
#include<string.h>
#include<stdio.h>

#include "ToySegment.h"
#include "ToySegmentList.h"
#include "ToyProcess.h"
#include "ToyMemType.h"
#include "ToyMem.h"
#include "ToyMem_Internal.h"
#include "ToyMemPage.h"
#include "ToyVirtualMem.h"
#include "ToyLoad.h"
#include "ToySwap.h"
#include "ToyParseCmd.h"

const char *ErrMessages[] =
{
  "Invalid syntax in processor input"
, "Process already loaded"
, "Cannot open load file"
, "Load file has invalid format"
, "Excess values in load file"
, "Invalid instruction in load file"
, "Invalid data value in load file"
, "Insufficient main memory to load file"
, "Address is outside of valid segments"
, "Specified process does not exist"
, "Insufficient privilege for PrintAllMemory"
, "END command reached, parser stopped"
, "Command not yet implemented"
, "Insufficient heap space"
, "Invalid address for FreeHeap"
, "Invalid address for ReallocateHeap"
, "Invalid page size"
, "Paging has not been enabled"
, "Insufficient privilege for EnablePaging"
, NULL                                         };

void TMM_VPrintMem(ToyMM *tmm, int process, int vaddr);

ErrMessage_t TMM_PrintAllMemory(ToyMM *tmm)
{
  int n;

  if(tmm==NULL) return(ERR_UNKNOWN);

  printf(LINE_RULE);
  printf(LINE_PREFIX"Memory Contents:\n");

  for(n=0; n<tmm->memSize; n++)
  {
    TMM_PrintMem(tmm,n);
  }
  
  printf(LINE_RULE);
  
  return(ERR_NONE);
}

ErrMessage_t TMM_PrintProcessTable(ToyMM *tm, int process)
{
  int n;

  if((process<0)||(process>=MAX_PROCESSES))              return(ERR_UNKNOWN);
  else if((process!=0)&&(tm->processList[process]==NULL))return(ERR_NOPROCESS);

  printf(LINE_RULE);
  printf(LINE_PREFIX"Process Table:\n");
  printf(LINE_PREFIX" PID #SEG SEG1 LEN1 SEG2 LEN2 SEG3 LEN3 SEG4 LEN4\n");
  printf(LINE_PREFIX" --- ---- ---- ---- ---- ---- ---- ---- ---- ----\n");

  for(n=0; n<MAX_PROCESSES; n++)
  {
    int i=-1;
    int numSegs     = -1;
    int segSizes[4] = {-1,-1,-1,-1};
    int segPos[4]   = {-1,-1,-1,-1};
    SegList *list=NULL;

    if(tm->processList[n]==NULL)  continue;
    list=TMM_SeekSegListHead(tm->processList[n]->segments);

    for(numSegs=0; (list!=NULL)&&(numSegs<4); list=list->next,numSegs++ )
    {
      segSizes[numSegs]=list->seg.len;
      segPos[numSegs]=list->seg.pos;
    }
    printf(LINE_PREFIX"  P%1d    %1d",n,numSegs);
    for(i=0; i<numSegs; i++)
    {
      printf(" %4d",segPos[i]);
      printf(" %4d",segSizes[i]);
    }
    printf("\n");
  }

  printf(LINE_RULE);

  return(ERR_NONE);
}

ErrMessage_t TMM_PrintProcessMemory(ToyMM *tm, int process)
{
  int n=-1;
  int seg=0;
  SegList *list=NULL;

  if( (process<0)||(process>=MAX_PROCESSES))  return(ERR_UNKNOWN);
  if(tm->processList[process]==NULL)          return(ERR_NOPROCESS);

  printf(LINE_RULE);
  printf(LINE_PREFIX"Memory Contents:\n");

  list=tm->processList[process]->segments;
  list=TMM_SeekSegListHead(list);

  while(list!=NULL) /*  Loop through every segment. */
  {
    if(seg==SEG_HEAP)
    {
      SegList *heap=tm->processList[process]->usedheap;
      while(heap!=NULL)
      {
        int hpos=0;
        /* Loop through every address in used heap segs */
        for(hpos=heap->seg.pos; hpos<(heap->seg.pos+heap->seg.len); hpos++)
        {                    
            TMM_VPrintMem(tm,process,hpos);
        }
        heap=heap->next;
      }
    }
    else
    {
      /*  Loop through every address in segment.  */
      for(n=list->seg.pos; n<(list->seg.pos+list->seg.len); n++)
      {
        /*  Attempt to print every valid memory area.
            Invalid ones will not be printed. */
        TMM_VPrintMem(tm,process,n);
      }
    }
    
    list=list->next;
    seg++;
  }

  printf(LINE_RULE);
  return(ERR_NONE);
}

ErrMessage_t TMM_StoreInteger(ToyMM *tm,int process,int addr,int val)
{  
  SegList *list;
  int raddr=-1;
  int seg=SEG_CODE;
  
  if(tm->processList[process]==NULL)  return(ERR_NOPROCESS);

  list=tm->processList[process]->segments;
  list=TMM_SeekSegListHead(list);

  list=list->next;  /*  Segment 0 is code segment, can't put data in it */
  seg++;

  while(list!=NULL) /*  Loop through segments */
  {
    /*  Test if address resides in segment  */
    if( (addr>=list->seg.pos) && (addr< (list->seg.pos+list->seg.len)) )
    {      
      if(seg==SEG_HEAP)
      {
        return(TMM_StoreHeapInteger(tm,process,addr,val));
      }

      /*  Convert virtual to real address */
      raddr=TMM_GetRealAddress(tm,process,addr);
      if(raddr<0) return(ERR_UNKNOWN);      

      /*  Set the memory type and value */
      tm->mem[raddr].type=DATA_INTEGER;
      tm->mem[raddr].integer.value=val;
      return(ERR_NONE); /*  Return success  */
    }
    list=list->next;
    seg++;
  }

  /*  If we didn't find it, return error. */
  return(ERR_INVALIDADDRESS);
}

ErrMessage_t TMM_StoreString(ToyMM *tm, int process, int addr, const char *str)
{
  SegList *list;
  int seg=SEG_CODE;
  int raddr=-1;

  if(strlen(str)>MAX_STRLEN) return(ERR_INVALIDINPUT);
  if(tm->processList[process]==NULL)  return(ERR_NOPROCESS);
/*  else if(TMM_PagingEnabled(tm)>=0)
  {
    return(TMM_PagedStoreString(tm,process,addr,str));
  }*/

  list=tm->processList[process]->segments;
  list=TMM_SeekSegListHead(list);

  list=list->next;  /*  Segment 0 is code segment, can't put data in it */
  seg++;

  while(list!=NULL) /*  Loop through segments */
  {
    /*  Test if address resides in segment  */
    if( (addr>=list->seg.pos) && (addr< (list->seg.pos+list->seg.len)) )
    {      
      if(seg==SEG_HEAP)
      {
        return(TMM_StoreHeapString(tm,process,addr,str));
      }

      /*  Convert virtual to real address */
      raddr=TMM_GetRealAddress(tm,process,addr);
      if(raddr<0) return(ERR_UNKNOWN);      

      /*  Set the memory type and value */
      tm->mem[raddr].type=DATA_STRING;
      strcpy(tm->mem[raddr].string.value,str);
      return(ERR_NONE); /*  Return success  */
    }
    list=list->next;
    seg++;
  }

  /*  If we didn't find it, return error. */
  return(ERR_INVALIDADDRESS);
}

/******************************************************************************/

ErrMessage_t TMM_TerminateProcess(ToyMM *tmm, int ID)
{
  SegList *list;

  if(tmm==NULL)                   return(ERR_UNKNOWN);
  /*  Can't free a nonexistent process  */
  if(tmm->processList[ID]==NULL)  return(ERR_NOPROCESS);
  else if(TMM_PagingEnabled(tmm)>=0)
  {
    return(TMM_PagedTerminateProcess(tmm,ID));
  }  

  /*  Get the list and go to it's start */
  list=tmm->processList[ID]->segments;
  list=TMM_SeekSegListHead(list);

  /*  Loop through entire list  */
  while(list!=NULL)
  { /*  Free every segment in process */
    TMM_FreeSegment(tmm,list->seg.pos,list->seg.len);
    list=list->next;
  }

  /*  Free the segment list itself from REAL memory */
  if(tmm->processList[ID]->segments!=NULL)
    TMM_FreeSegList(tmm->processList[ID]->segments);

  if(tmm->processList[ID]->freeheap!=NULL)
    TMM_FreeSegList(tmm->processList[ID]->freeheap);

  if(tmm->processList[ID]->usedheap!=NULL)
    TMM_FreeSegList(tmm->processList[ID]->usedheap);

  /*  Free the process itself */
  free(tmm->processList[ID]);

  /*  Mark the process slot as empty  */
  tmm->processList[ID]=NULL;

  return(ERR_NONE);
}

ErrMessage_t TMM_AllocateProcessAt(ToyMM *tmm, int ID, int pos, int nSegs, int size[])
{
  int n=-1,startpos=-1;
  Process *p=NULL;
  SegList *list=NULL;

  if((ID>=MAX_PROCESSES)||(ID<0)) return(ERR_UNKNOWN);
  if(tmm->processList[ID]!=NULL)  return(ERR_NOPROCESS);
 
  p=(Process *)malloc(sizeof(Process));
  if(p==NULL) return(ERR_UNKNOWN);

  p->ptr=NULL;
  p->freeheap=NULL;
  p->usedheap=NULL;
  p->segments=NULL;
  p->ID=ID;
  p->pagetable=NULL;

  /*  Add the process in the memory manager */
  tmm->processList[ID]=p;

  /*  check for overlapping memory areas  */
  for(n=0,startpos=pos; n<nSegs; n++)
  {
    SegList *node=NULL;

    /*  Try and create a new segment at specified pos */
    if(TMM_AllocateSegmentAt(tmm,startpos,size[n])!=ERR_NONE)
    {
      /*  Free p and all it's segments  */
      TMM_TerminateProcess(tmm,ID);
      return(ERR_INSUFFICIENTMEM);
    }

    /*  Create a node representing the new segment  */
    node=TMM_CreateSegList(startpos,size[n],NULL,NULL);

    /*  Add it to the list of valid segs in p */
    p->segments=TMM_AppendSegList(p->segments,node);

    /*  Increment starting position for next segment */
    startpos+=size[n];
  }

  /*  Seek to the head of the list  */
  p->segments=TMM_SeekSegListHead(p->segments);

  list=TMM_GetSegmentNode(tmm,ID,SEG_HEAP);
  if(list!=NULL)  /* If a heap segment exists for this process */
  {    /* This node represents free memory in the heap segment */
    SegList *node=TMM_CreateSegList(list->seg.pos,list->seg.len,NULL,NULL);
    p->freeheap=node;
    p->ptr=p->freeheap;
  }

  return(ERR_NONE);    /*  Yay!  It worked!  */
}

ErrMessage_t TMM_AllocateSegmentAt(ToyMM *tmm, int pos, int size)
{
  int i=-1,overlap=0;
  ToySegment mySeg;
  mySeg.pos=pos;
  mySeg.len=size;

  /*  Test for out-of-range mem */
  if((pos+size)>tmm->memSize)  return(ERR_INSUFFICIENTMEM);

  /*  Test for overlapping segments */
  for(i=0,overlap=0; (i<MAX_PROCESSES)&&(overlap==0); i++)
  {
    SegList *list=NULL;
    /*  Don't check nonexistent processes */
    if(tmm->processList[i]!=NULL) list=tmm->processList[i]->segments;
    while(list!=NULL)
    {
      ToySegment seg;
      /* Translate virtual segment to real segment */
      seg.pos=TMM_GetRealAddress(tmm,i,list->seg.pos);
      seg.len=TMM_GetFramedSize(tmm,list->seg.len);
      
      overlap|=TMM_AreaIntersectsSeg(&mySeg,&seg);
      list=list->next;
    }
  }

  if(overlap!=0)
  {
    return(ERR_INSUFFICIENTMEM); /*  memory range not free */
  }
  else
  {
    /*  Clear the memory so we can see what's been used */
    for(i=pos; i<(pos+size); i++) tmm->mem[i].type=DATA_ERROR;
    tmm->memFree=TMM_RemoveAreaFromSegList(tmm->memFree,pos,size);
    return(ERR_NONE);
  }
}

ErrMessage_t TMM_FreeSegment(ToyMM *tmm, int pos, int size)
{
  int n;
  SegList *list;

  for(n=0; n<MAX_PROCESSES; n++)
  {
    if(tmm->processList[n]==NULL)       continue;

    list=tmm->processList[n]->segments;
    while(list!=NULL)
    {
      if((list->seg.len==size)&&(list->seg.pos==pos))
      {
        list=TMM_AddAreaToSegList(tmm->memFree,pos,size);
        if(list==NULL)
        {
          /* Error in deallocation */
          return(ERR_UNKNOWN);
        }
        else
        {
          tmm->memFree=list;
          return(ERR_NONE);
        }
      }

      list=list->next;
    }
  }
  /* Couldn't find it. */
  return(ERR_UNKNOWN);
}


ToyMM *TMM_Create(int memSize)
{
  int n;

  ToyMM *tmm = (ToyMM *)malloc(sizeof(ToyMM));

  if(tmm==NULL) /*  Out of memory */
  {
    return(NULL);
  }
  else
  {
    for(n=0; n<MAX_PROCESSES; n++)
    {
      tmm->processList[n]=NULL;
    }

    /*  Starts in Legacy mode, no paging */
    tmm->pageSize=0;
    tmm->invPageTable=NULL;
    tmm->page=0;
    tmm->swap=NULL;
    tmm->watchPaging=0;

    /*  Allocate memory elements */
    tmm->mem=(ToyMem *)malloc(memSize*sizeof(ToyMem));
    tmm->memSize = memSize;    

    /*  Mark memory elements as empty */
    for(n=0; n<memSize; n++)
    {
      tmm->mem[n].type=DATA_ERROR;
    }

    /* Create free list */
    tmm->memFree = TMM_CreateSegList(0,memSize,NULL,NULL);
    
    /* Return new memory manager */
    return(tmm);
  }
}

ErrMessage_t TMM_Free(ToyMM *tmm)
{
  int n;

  if(tmm==NULL) return(ERR_UNKNOWN);

  /*  Kill all processes  */
  for(n=0; n<MAX_PROCESSES; n++)
  {
    if(tmm->processList[n])
    {
      if(TMM_PagingEnabled(tmm) )      {
        TMM_PagedTerminateProcess(tmm,n);
      }
      else
      {
        TMM_TerminateProcess(tmm,n);        
      }
    }
  }

  /*  Free page table, if any */
  if(tmm->invPageTable!=NULL)
  {
    free(tmm->invPageTable);    
  }

  /* Destroy swap file, if any */
  TMM_SwapDestroy(tmm);

  free(tmm->mem);
  TMM_FreeSegList(tmm->memFree);

  return(ERR_NONE);
}

void TMM_VPrintMem(ToyMM *tmm, int process, int vaddr)
{
  ToyMem *mem=NULL;
  int raddr=TMM_GetRealAddress(tmm,process,vaddr);
  if(raddr<0) return;

  mem=tmm->mem+raddr;

  if(mem->type==DATA_ERROR) return;

  printf(LINE_PREFIX" %3d ",vaddr);
  
  switch(mem->type)
  {
  case DATA_ERROR:
    break;

  case DATA_INTEGER:
    printf("%d\n",mem->integer.value);
    break;
  case DATA_INSTRUCTION:
    printf("%s\n",DataType_List[DATA_INSTRUCTION][mem->instruction.value]);
    break;
  case DATA_STRING:
    printf("%s\n",mem->string.value);
    break;

  default:

    printf("Unknown mem type %d, ",mem->type);
    printf("Email me at monttyle@heavyspace.ca and tell me how you did this.\n");
    break;
  }  
}

void TMM_PrintMem(ToyMM *tmm, int addr)
{
  ToyMem *mem=tmm->mem+addr;


  if(mem->type==DATA_ERROR) return;

  printf(LINE_PREFIX" %3d ",addr);
  switch(mem->type)
  {
  case DATA_ERROR:
    break;

  case DATA_INTEGER:
    printf("%d\n",mem->integer.value);
    break;
  case DATA_INSTRUCTION:
    printf("%s\n",DataType_List[DATA_INSTRUCTION][mem->instruction.value]);
    break;
  case DATA_STRING:
    printf("%s\n",mem->string.value);
    break;

  default:

    printf("Unknown mem type %d, ",mem->type);
    printf("Email me at monttyle@heavyspace.ca and tell me how you did this.\n");
    break;
  }
}

SegList *TMM_GetSegmentNode(ToyMM *tm, int process, SegType_e sg)
{
  SegList *list;
  int seg=sg;

  if((process<0)||(process>=MAX_PROCESSES)) return(NULL);
  if(seg<0)                                 return(NULL);
  if(tm->processList[process]==NULL)        return(NULL);

  list=TMM_SeekSegListHead(tm->processList[process]->segments);

  while((list!=NULL)&&(seg>0))
  {
    seg--;
    list=list->next;
  }

  return(list);
}

int TMM_GetSegmentAddr(ToyMM *tm, int process, SegType_e seg)
{
  SegList *list=TMM_GetSegmentNode(tm,process,seg);

  if(list!=NULL)  return(list->seg.pos);
  else            return(-1);
}

ErrMessage_t TMM_MarkMemEmpty(ToyMM *tmm,int addr, int len)
{
  int n;
  for(n=addr; n<(addr+len); n++)
  {
    tmm->mem[n].type=DATA_ERROR;
  }
  return(ERR_NONE);
}

ErrMessage_t TMM_CopyMem(ToyMM *tmm, int destaddr, int srcaddr, int len)
{
  if(tmm==NULL)  return(ERR_UNKNOWN);

  while(len>0)
  {
    tmm->mem[destaddr++]=tmm->mem[srcaddr++];
    len--;
  }
  return(ERR_NONE);
}

int TMM_FindFreeMem(ToyMM *tmm, int size)
{
  SegList *list=NULL;

  if(tmm==NULL)                       return(-1);
  list=tmm->memFree;

  while(list!=NULL)
  {
    if(list->seg.len>=size)  return(list->seg.pos);

    list=list->next;
  }

  return(-1);
}

Process *TMM_GetProcess(ToyMM *tmm, int process)
{
  if(tmm==NULL)                           return(NULL);
  else if(process<0)                      return(NULL);
  else if(process>=MAX_PROCESSES)         return(NULL);
  else return(tmm->processList[process]);
}

int TMM_ParseFilePtr(FILE *fp, ToyMM *tm, int prompt)
{
  int line=0;
  char buf[160]; /* ={'\0'}; */
  ErrMessage_t error=ERR_UNKNOWN;
  
  buf[0]='\0';  /* Mark buffer as empty */

  if(fp==NULL)  return(-1);   /*  NULL file pointer, return error   */

  if(prompt)  printf(TMM_CONSOLE_PROMPT,line+1);  
  fgets(buf,160,fp);    /*  Read first line  */

  /*  Ignore blank lines  */
  if(strlen(buf)>1) error=TMM_ParseLine(buf,tm,++line);    /*  Parse line  */
  else              error=ERR_NONE;

  do  /*  Loop until we've read it all  */
  {
    if(error!=ERR_NONE)     /*  if the line caused an error */
    {
      if(error==ERR_UNKNOWN)
      {
        /*  Unknown errors have no string in the error table.  */
        printf(ERR_PREFIX"Unknown error.\n");
      }
      else
      {
        /*  But other errors do.  */
        PRINT_ERROR(error);
      }
      if(error==ERR_PARSEEND) /*  END command, stop parsing */
      {
        fclose(fp);
        return(-1);
      }
    }
    buf[0]='\0';        /*  Empty the buffer  */
    
    if(prompt)  printf(TMM_CONSOLE_PROMPT,line+1);    
    fgets(buf,160,fp);  /*  Read line         */

    /*  Ignore blank lines  */
    if(strlen(buf)>1) error=TMM_ParseLine(buf,tm,++line);    /*  Parse line  */
    else              error=ERR_NONE;
  }
  while(!feof(fp));     /*  Loop until end-of-file  */

  /*  Print the last error, if any  */
  if(error!=ERR_NONE)
  {
      if(error==ERR_UNKNOWN)
      {
        /*  Unknown errors have no string in the error table.  */
        printf(ERR_PREFIX"Unknown error.\n");
      }
      else
      {
        /*  But other errors do.  */
        printf(ERR_PREFIX"%s\n",ErrMessages[error]);
      }
  }
  
  return(0);  /*  Return success. */
}

int TMM_ParseFile(const char *fname, ToyMM *tm)
{
  int retval=-1;
  FILE *fp=NULL;

  fp=fopen(fname,"r");        /*  Open specified file for textmode reading  */
  if(fp==NULL)  return(-1);   /*  If we didn't get the file, return error   */

  retval=TMM_ParseFilePtr(fp,tm,0);

  fclose(fp);           /*  Close the file  */

  return(retval);  /*  Return success. */
}

---