---

ToySwap.c

/***************************************************************************
             ToySwap.c  -  Implements the interface to the swap file.
    Provides the functions TMM_Swap, TMM_SwapIn, TMM_SwapOut,
    TMM_SwapCreate, TMM_SwapDestroy.
                             -------------------
    begin                : Mon Mar 24 2003
    copyright            : (C) 2003 by Tyler Montbriand
    email                : monttyle@heavyspace.ca
 ***************************************************************************/

#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 "ToyVirtualMem.h"
#include "ToySwap.h"

#define SWAP_FILEDELETE

ToyMem *TMM_GetPageMem(ToyMM *tmm, int process, int page);
int TMM_SwapRawWrite(ToyMM *tmm, ToyMem data[],int elements);
int TMM_SwapRawRead(ToyMM *tmm, ToyMem data[], int elements);
int TMM_SwapSeek(ToyMM *tmm, int process, int page);
int TMM_SwapWriteHeader(ToyMM *tmm);
void TMM_SwapNotify(ToyMM *tmm, int process, int page, int in);
int TMM_CalculateFilePos(ToyMM *tmm, int process, int page);
int TMM_SwapWrite(ToyMM *tmm, int process, int page);
int TMM_SwapRawRead(ToyMM *tmm, ToyMem data[], int elements);
int TMM_SwapRead(ToyMM *tmm, int process, int page);

int TMM_SwapIn(ToyMM *tmm, int process, int page, int frame)
{
  /* Not an error, but don't need to do anything */
  if(TMM_PageSwappedIn(tmm,process,page)>=0)  return(0);
  /* Sanity checking */
  if(TMM_PageSwappedOut(tmm,process,page)<0)  return(-1);
  if(TMM_FrameFree(tmm,frame)<0)              return(-1);
  
  /* OK, now we're cookin'.  Assign specified free page to process */
  TMM_AssignFrame(tmm,process,frame,page);

  /* Read in swap data from file */
  if(TMM_SwapRead(tmm,process,page)<0)
  {
    TMM_FreeFrame(tmm,process,page);
    return(-1);
  }


  if(tmm->watchPaging>0)
  {
    TMM_SwapNotify(tmm,process,page,1);
  }

  /* OK.  We're done!*/
  return(0);  /* Return success */
}

int TMM_SwapOut(ToyMM *tmm, int process, int page)
{
  
  /* Check if page exists */
  if(TMM_PageFree(tmm,process,page)>=0)        return(-1);
  
  
  /* Check if page is already paged out */  
  if(TMM_PageSwappedOut(tmm,process,page)>=0)  return(0);

  
  /* Write to file */
  if(TMM_SwapWrite(tmm,process,page)<0)        return(-1);

  /* Disassociate from process */      
  TMM_FreeFrame(tmm,process,page);

  /* Mark page as paged out */
  TMM_MarkPageSwappedOut(tmm,process,page);
  /* Success! */


  if(tmm->watchPaging>0)
  {
    TMM_SwapNotify(tmm,process,page,0);
  }

  return(0);
}

int TMM_SwapWrite(ToyMM *tmm, int process, int page)
{
  ToyMem *memptr=TMM_GetPageMem(tmm,process,page);
  if(memptr==NULL)                                      return(-1);  
  else if(TMM_SwapSeek(tmm,process,page)<0)             return(-1);
  else if(TMM_SwapRawWrite(tmm,memptr,tmm->pageSize)<0) return(-1);
  else                                                  return(0); 
}



int TMM_SwapRead(ToyMM *tmm, int process, int page)
{
  ToyMem *memptr=TMM_GetPageMem(tmm,process,page);
  
  if(memptr==NULL)                                      return(-1);
  else if(TMM_SwapSeek(tmm,process,page)<0)             return(-1);
  else if(TMM_SwapRawRead(tmm,memptr,tmm->pageSize)<0)  return(-1);
  else                                                  return(0);
}

int TMM_SwapRawRead(ToyMM *tmm, ToyMem data[], int elements)
{
  if((data==NULL)||(elements<0))                            return(-1);
  /* Attempt to read memory elements from swapfile */
  else if(fread(data,elements,sizeof(ToyMem),tmm->swap)<=0) return(-1);
  /* Return success */
  else                                                      return(0);
}

int TMM_SwapRawWrite(ToyMM *tmm, ToyMem data[],int elements)
{
  if((data==NULL)||(elements<0))                            return(-1);
  /* Attempt to write memory elements to swapfile */
  else if(fwrite(data,elements,sizeof(ToyMem),tmm->swap)<=0)return(-1);
  /* Return success */
  else                                                      return(0);  
}

int TMM_SwapSeek(ToyMM *tmm, int process, int page)
{ /* Calculate position in file */
  int pos=TMM_CalculateFilePos(tmm,process,page);
  /* Invalid position, return error */
  if(pos<0)                                 return(-1);
  /* Couldn't seek, return error */
  else if(fseek(tmm->swap,pos,SEEK_SET)<0)  return(-1);
  /* Seek succeeded - return success */
  else                                      return(0);
}

int TMM_SwapWriteHeader(ToyMM *tmm)
{
  ToySwapHeader header;  
  char          blank[SWAP_OFFSET-sizeof(ToySwapHeader)];
  
  /* Set all values in structure to NULL */
  memset(&header,0,sizeof(ToySwapHeader));
  memset(blank,0,sizeof(blank));
  
  /* Copy appropriate values into structure */
  strcpy(header.FileStr,SWAP_FILENAME);
  header.Version=0x004;
  header.MemSize=tmm->memSize;
  header.PageSize=tmm->pageSize;
  header.CurrentPage=tmm->page;

  /* Attempt to seek to start of file */
  if(fseek(tmm->swap,0,SEEK_SET)<0)  return(-1);

  /* Write the header itself */
  if(fwrite(&header,1,sizeof(ToySwapHeader),tmm->swap)<=0)  return(-1);
  /* Write the blank bytes up 'till the Swap data itself */
  if(fwrite(blank,1,sizeof(blank),tmm->swap)<=0)            return(-1);  

  return(0); /* Success */
}

int TMM_SwapDestroy(ToyMM *tmm)
{
  if(tmm==NULL)
  {
    return(-1);
  }
  else if(tmm->swap!=NULL)
  {    
    fclose(tmm->swap);  /* Close swap file */        
    tmm->swap=NULL;     /* Mark tmm as having no swap */
    
/* When SWAP_FILEDELETE is defined, we don't
   just close the file, we delete it.        */
#ifdef SWAP_FILEDELETE
    remove(SWAP_FILENAME);
#endif    
  }
  
  /* Return success */  
  return(0);  
}

void TMM_SwapNotify(ToyMM *tmm, int process, int page, int in)
{
  if(TMM_PagingEnabled(tmm)<0) return;
  else if(tmm->watchPaging)
  {    
    if(in)  printf(SWAP_IN_PREFIX SWAP_CMD_STR  "in\n",page,process);
    else    printf(SWAP_OUT_PREFIX SWAP_CMD_STR"out\n",page,process);
  }
}

int TMM_CalculateFilePos(ToyMM *tmm, int process, int page)
{
  int pos=-1;
  /* Sanity checking */
  if(TMM_PagingEnabled(tmm)<0)        return(-1);
  if(process<0)                       return(-1);
  else if(process>=MAX_PROCESSES)     return(-1);
  else if(page<0)                     return(-1);
  else if(page>=TMM_GetNumPages(tmm)) return(-1);

  pos=SWAP_OFFSET;  /* Swap data starts at SWAP_OFFSET */
  /* Calculate position in file */
  pos+=(process*tmm->memSize)*sizeof(ToyMem);
  pos+=(page*tmm->pageSize)*sizeof(ToyMem);
  return(pos);
}

int TMM_SwapCreate(ToyMM *tmm)
{
  FILE *fp=NULL;
  ToyMem mem;

  if(tmm==NULL)                 return(-1);
  /* We don't use swap files in legacy mode */
  if(TMM_PagingEnabled(tmm)<0)  return(-1);

  /* Initialize data variable */
  memset(&mem,0,sizeof(ToyMem));
  mem.type=DATA_ERROR;

  /* If a swap file already exists, get rid of it */
  if(tmm->swap!=NULL)
  {
    TMM_SwapDestroy(tmm);
  }

  /* Open the file for writing, reading, and seeking */
  fp=fopen(SWAP_FILENAME,"wb+");
  tmm->swap=fp;

  if(fp==NULL)  /* Return error if we can't create the file */
  {
    return(-1);
  }
  else if(TMM_SwapWriteHeader(tmm)<0) /* Attempt to write header */
  {
    TMM_SwapDestroy(tmm);
    return(-1);
  }
  else if(TMM_SwapSeek(tmm,0,0)<0)
  {
    TMM_SwapDestroy(tmm);
    return(-1);
  }
  else  /* Write empty swap data */
  {
    int n=-1,m=-1;

    /* Write memsize elements for every process */
    for(n=0; n<tmm->memSize; n++)
    for(m=0; m<MAX_PROCESSES; m++)
    if(TMM_SwapRawWrite(tmm,&mem,1)<0)
    {
      TMM_SwapDestroy(tmm);
      return(-1);
    }

    return(0);    /* Success */
  }
}

ToyMem *TMM_GetPageMem(ToyMM *tmm, int process, int page)
{
  ToyMem *mem=NULL;
  PageTable *pt=TMM_GetPage(tmm,process,page);

  if(pt==NULL)            return(NULL);
  else if(pt->paged==1)   return(NULL);
  else if(pt->frame<0)    return(NULL);
  else if(tmm->mem==NULL) return(NULL);
  mem=tmm->mem;
  mem+=(pt->frame*tmm->pageSize);

  return(mem);
}

---