---

ToyMemPage.c

/***************************************************************************
                          ToyMemPage.c  -  Implements the extra commands
    available in Paged mode.
                             -------------------
    begin                : Thu Feb 20 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 "ToyLoad.h"
#include "ToyMemPage.h"
#include "ToyVirtualMem.h"
#include "ToySwap.h"


/* Glue functions */
void TMM_PrintInvPage(ToyMM *tmm, int frame, int show_framestatus);
ErrMessage_t TMM_FindNextSegPos(ToyMM *,int,int *, int *, int *);

ErrMessage_t TMM_PrintPages(ToyMM *tm, int process)
{
  int n=-1;
  int numpages;
  Process *proc=NULL;

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

  printf(LINE_RULE);
  printf(LINE_PREFIX"Page Table for Process P%d:\n",process);
  printf(LINE_PREFIX"PAGE#  FRAME# PageStatus\n");
  printf(LINE_PREFIX"-----  ------ ----------\n");

  proc=tm->processList[process];

  numpages=TMM_GetNumPages(tm);

  for(n=0; n<numpages; n++)
  {
    PageTable ptable=proc->pagetable[n];
    if(TMM_PageFree(tm,process,n)<0)    
    {
      if(TMM_PageSwappedOut(tm,process,n)>=0)
      {
        printf(LINE_PREFIX"%5d  %6s   %s\n",n,"-","Disk");
      }
      else
      {
        printf(LINE_PREFIX"%5d  %6d   %s\n",n,ptable.frame,"Memory");        
      }
    }
  }

  printf(LINE_RULE);

  return(ERR_NONE);
}

ErrMessage_t TMM_PrintFrames(ToyMM *tmm)
{
  int n;
  if(tmm==NULL)               return(ERR_UNKNOWN);
  if(TMM_PagingEnabled(tmm)<0)return(ERR_NOPAGING);

  printf(LINE_RULE);
  printf(LINE_PREFIX"Inverted Page Table:\n");
  printf(LINE_PREFIX"FRAME#  PID PAGE# FrameStatus\n");
  printf(LINE_PREFIX"------  --- ----- -----------\n");

  for(n=0; n<TMM_GetNumPages(tmm); n++)
  {
    TMM_PrintInvPage(tmm,n,1);
  }

  printf(LINE_RULE);
  return(ERR_NONE);
}

ErrMessage_t TMM_WatchPaging(ToyMM *tmm, int process, int enable)
{
  if(tmm==NULL)        return(ERR_UNKNOWN);
  else if(process!=0)  return(ERR_UNKNOWN);

  if(enable==0)  /* turn off page watching */
  {
    tmm->watchPaging=0;
    return(ERR_NONE);
  }
  else if(enable==1)  /* turn on page watching */
  {
    tmm->watchPaging=1;
    return(ERR_NONE);
  }
  else  /* Only 0 or 1 are valid. */
  {
    return(ERR_INVALIDINPUT);
  }
}


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

  if(tm==NULL)        return(ERR_UNKNOWN);
  else if(process!=0) return(ERR_NOENABLEPAGEPRIVELEGE);
  else if((tm->memSize%pagesize!=0)||(pagesize>=tm->memSize))
  { /*  Memory must be evenly divisible by page size  */
    return(ERR_INVALIDPAGESIZE);
  }

  /*  Kill all processes */
  for(n=1; n<MAX_PROCESSES; n++)  
  if(tm->processList[n]!=NULL)
  {
    TMM_TerminateProcess(tm,n);
  }

  /* We don't use the global free-list in Paged mode */
  if(tm->memFree!=NULL)  TMM_FreeSegList(tm->memFree);
  tm->memFree=NULL;  

  /*  Create inverted page table  */
  tm->invPageTable=(InvPageTable *)malloc(sizeof(InvPageTable)*(tm->memSize/pagesize));

  /*  Couldn't allocate memory  */
  if(tm->invPageTable==NULL)
  {
    return(ERR_UNKNOWN);
  }

  /*  Set page size */
  tm->pageSize=pagesize;

  /*  Mark all pages as free. */
  for(n=0; n<TMM_GetNumPages(tm); n++)
  {
    tm->invPageTable[n].ID=-1;
    tm->invPageTable[n].status=0;
    tm->invPageTable[n].page=-1;    
  }

  /* Create swap file LAST */
  if(TMM_SwapCreate(tm)<0)
  {
    return(ERR_UNKNOWN);
  }

  tm->page=0;

  
  return(ERR_NONE);
}

ErrMessage_t TMM_PrintInvertedPageTable(ToyMM *tmm, int process)
{
  int n;
  if(tmm==NULL)       return(ERR_UNKNOWN);

  printf(LINE_RULE);
  printf(LINE_PREFIX"Inverted Page Table:\n");
  printf(LINE_PREFIX"FRAME#  PID PAGE#\n");
  printf(LINE_PREFIX"------  --- -----\n");

  for(n=0; n<TMM_GetNumPages(tmm); n++)
  {
    TMM_PrintInvPage(tmm,n,0);
  }

  printf(LINE_RULE);
  return(ERR_NONE);  
}

ErrMessage_t TMM_PagedAllocateSegment(ToyMM *tmm, int process, int size)
{
  SegList *newnode=NULL;

  int pages=-1;  
  int page=0;
  int seg=SEG_CODE;
  Process *proc=NULL;
  
  if(tmm==NULL)                             return(ERR_UNKNOWN);
  else if(tmm->processList[process]==NULL)  return(ERR_NOPROCESS);

  proc=tmm->processList[process];

  if(TMM_FindNextSegPos(tmm,process,&seg,&page,&size)!=ERR_NONE)
  {
    return(ERR_UNKNOWN);
  }

  pages=TMM_GetNumFrames(tmm,size);

  /* Loop through frames in segment, assigning frames to the new process */
  while(pages>0)
  {
    /* Commented out because we don't want to load frames in
       TMM_PagedAllocateSegment, but TMM_Load */
/*    n=TMM_FindFreeFrame(tmm);
    if(n<0) break;
    TMM_AssignFrame(tmm,process,n,page);*/
    page++;
    pages--;    
  }

  page-=TMM_GetNumFrames(tmm,size);

  if(pages!=0)
  {
    /* Couldn't allocate every page */
    return(ERR_INSUFFICIENTMEM);
  }

  /* Create node representing new segment in ToyMM */
  newnode=TMM_CreateSegList(page*tmm->pageSize,size,NULL,NULL);
  if(newnode==NULL) return(ERR_UNKNOWN);
  /* Add new segment to list */
  proc->segments=TMM_AppendSegList(proc->segments,newnode);
  
  return(ERR_NONE);
}

ErrMessage_t TMM_PagedAllocateProcess(ToyMM *tmm, int ID, int nSegs, int sizes[])
{
  int n=-1;
  int newsizes[]={1,1,1,1};
  int numpages;
  Process *proc=NULL;
  SegList *list=NULL;
  
  /*  Can't allocate process in nonexistent TMM */
  if(tmm==NULL) return(ERR_UNKNOWN);
  /*  Can't allocate negative or out-of-bounds processes  */
  else if((ID<0)||(ID>=MAX_PROCESSES))  return(ERR_UNKNOWN);
  else if(tmm->processList[ID]!=NULL)
  { /*  Can't replace existing process */
    return(ERR_PROCESSEXISTS);
  }

  /*  Create empty process  */  
  proc=(Process *)malloc(sizeof(Process));
  if(proc==NULL)  return(ERR_UNKNOWN);

  numpages=TMM_GetNumPages(tmm);

  proc->ID=ID;
  proc->freeheap=proc->usedheap=proc->ptr=NULL;
  proc->segments=NULL;
  proc->pagetable=(PageTable *)malloc(sizeof(PageTable)*numpages);
  
  for(n=0; n<numpages; n++)
  {
    proc->pagetable[n].frame=-1;
    proc->pagetable[n].paged=0;
  }  

  /*  Put the process in the Toy Memory Manager.  */
  tmm->processList[ID]=proc;

  for(n=0; n<nSegs; n++)
  {
    newsizes[n]=sizes[n];
  }

  /*  For each segment  */
  for(n=0; n<=SEG_STACK; n++)
  {
    if(TMM_PagedAllocateSegment(tmm,ID,newsizes[n])!=ERR_NONE)
    {
      TMM_PagedTerminateProcess(tmm,ID);
      return(ERR_INSUFFICIENTMEM);
    }        
  }

  /* Get the Heap segment */
  list=TMM_GetSegmentNode(tmm,ID,SEG_HEAP);

  /* Make a copy of it and put it in the freeheap */
  proc->freeheap=TMM_CreateSegList(list->seg.pos,list->seg.len,NULL,NULL);
  proc->ptr=proc->freeheap;
  proc->usedheap=NULL;

  return(ERR_NONE);  
}

ErrMessage_t TMM_PrintPageTable(ToyMM *tm, int process)
{
  int n=-1;
  int numpages;
  Process *proc=NULL;
  if(tm==NULL)                                  return(ERR_UNKNOWN);
  else if((process<0)||(process>=MAX_PROCESSES))return(ERR_UNKNOWN);
  else if(tm->processList[process]==NULL)       return(ERR_NOPROCESS);

  printf(LINE_RULE);
  printf(LINE_PREFIX"Page Table for Process P%d:\n",process);
  printf(LINE_PREFIX"PAGE#  FRAME#\n");
  printf(LINE_PREFIX"-----  ------\n");

  proc=tm->processList[process];

  numpages=TMM_GetNumPages(tm);

  for(n=0; n<numpages; n++)
  {
    if(proc->pagetable[n].frame!=-1)
    {
      printf(LINE_PREFIX"%5d  %6d\n",n,proc->pagetable[n].frame);
    }
  }
  
  printf(LINE_RULE);
  
  return(ERR_NONE);
}

ErrMessage_t TMM_PagedTerminateProcess(ToyMM *tm, int process)
{
  int n=-1;
  int numpages;
  
  Process *proc=NULL;

  if(tm==NULL)                             return(ERR_UNKNOWN);
  else if(tm->processList[process]==NULL)  return(ERR_NOPROCESS);
  
  proc=tm->processList[process];

  /*  Free list of segments */
  if(proc->segments!=NULL)
  {
    TMM_FreeSegList(proc->segments);
    proc->segments=NULL;
  }

  if(proc->freeheap!=NULL)
  {
    TMM_FreeSegList(proc->freeheap);
    proc->freeheap=NULL;
  }

  if(proc->usedheap!=NULL)
  {
    TMM_FreeSegList(proc->usedheap);
    proc->usedheap=NULL;
  }

  numpages=TMM_GetNumPages(tm);

  /*  Mark frames as free */
  for(n=0; n<numpages; n++)
  {
    if((proc->pagetable[n].frame!=-1)&&(proc->pagetable[n].paged==0))
    {
      TMM_FreeFrame(tm,process,n);
    }
    else
    {
      proc->pagetable[n].frame=-1;
      proc->pagetable[n].paged=0;
    }
  }
  
  /* Remove from process list */
  tm->processList[process]=NULL;

  if(proc->pagetable!=NULL)
  {
    free(proc->pagetable);
  }  

  /* Free the process struct itself */
  free(proc);
  
  return(ERR_NONE);
}

void TMM_PrintInvPage(ToyMM *tmm, int frame, int show_framestatus)
{
  /* Special case - printing unused page when scanning pointer matches */
  if((tmm->invPageTable[frame].ID<0)  &&
     (frame==tmm->page)              &&
     (show_framestatus)                   )
  {
    printf(LINE_PREFIX"%6d  %3d %5d %11d *\n",frame,0,0,0);
    return;
  }
  else if(show_framestatus)
  {
    if((frame!=tmm->page)&&(tmm->invPageTable[frame].ID==-1))  return;
    printf(LINE_PREFIX"%6d  %3d %5d %11d",frame,
                                          tmm->invPageTable[frame].ID,
                                          tmm->invPageTable[frame].page,
                                          tmm->invPageTable[frame].status
                                          );

    if(frame==tmm->page)  printf(" *");
    printf("\n");
  }
  else
  {
    if(tmm->invPageTable[frame].ID==-1) return;

    printf(LINE_PREFIX"%6d  %3d %5d\n",frame,tmm->invPageTable[frame].ID,
                                       tmm->invPageTable[frame].page);
  }
}


ErrMessage_t TMM_PagedAddSegment(ToyMM *tmm, int process, int pos, int len)
{
  SegList *node=NULL;
  if(tmm==NULL)                             return(ERR_UNKNOWN);
  else if(TMM_PagingEnabled(tmm)<0)         return(ERR_UNKNOWN);
  else if((pos<0)||(len<=0))      return(ERR_UNKNOWN);
  else if(tmm->processList[process]==NULL)  return(ERR_NOPROCESS);

  node=TMM_CreateSegList(pos,len,NULL,NULL);
  tmm->processList[process]->segments=TMM_AppendSegList(tmm->processList[process]->segments,node);

  return(ERR_NONE);
}

/* \brief Returns the page #, segment #, and size of what the next segment should be. */
ErrMessage_t TMM_FindNextSegPos(ToyMM *tmm, int process, int *seg, int *page, int *size)
{
  SegList *list=NULL;
  (*seg)=SEG_CODE;

  if((tmm==NULL)||(page==NULL)||(size==NULL)||(seg==NULL)) return(ERR_UNKNOWN);
  else if(tmm->processList[process]==NULL)                 return(ERR_NOPROCESS);

  (*page)=0;
  (*seg)=0;

  list=tmm->processList[process]->segments;
  while(list!=NULL)
  {
    (*page)=(list->seg.pos/tmm->pageSize)+TMM_GetFramedSize(tmm,list->seg.len)/(tmm->pageSize);
    list=list->next;
    (*seg)++;
  }

  switch(*seg)
  { /*  Don't do anything special for code/data segs  */
  case SEG_CODE:
  case SEG_DATA:
    break;

  /*  Stack segment must be bottom-up and one page in size */
  case SEG_STACK:
    (*page)=(TMM_GetNumPages(tmm))-1;
    (*size)=tmm->pageSize;
    break;

  /*  Heap segment must be one page in size */
  case SEG_HEAP:
    (*size)=tmm->pageSize;
    break;

  /*  Can't have more than 4 segments */
  default:
    return(ERR_UNKNOWN);
  }

  return(ERR_NONE);
}

---