Esempio n. 1
0
//==============================================================
void MakeBackupFile(const char *fname)
//--------------------------------------------------------------
// PATH_BACKUP にバックアップをとる
//--------------------------------------------------------------
// in:	file = バックアップを取るファイル名
//--------------------------------------------------------------
// out:	なし
//==============================================================
{
	char d_name[FNAME_MAXLEN];
	void *tmp_buf;
	sFILE *fd_src, *fd_dst;
	size_t len, size;

	// オリジナルのファイルを開く
	//----------------------------
	fd_src = FsOpen(fname);
	if(!fd_src)
	{
		return;
	}

	// バックアップファイルの作成
	//----------------------------
	sprintf(d_name, PATH_BACKUP"/%s.%s", GetFileBaseName(fname), StrMakeUniqueName());
	fd_dst = FsCreate(d_name);
	if (!fd_dst)
	{
		FsClose(fd_src);
		return;
	}

	// 作業バッファを確保
	//--------------------
	tmp_buf = devMalloc(TMPBUF_LEN, "MakeBackupFile");

	len = FsGetSizeOrig(fd_src);
	while(len)
	{
		size = (len >= TMPBUF_LEN) ? TMPBUF_LEN : len;
		FsRead(fd_src, tmp_buf, size);
		FsWrite(fd_dst, tmp_buf, size);

		len -= size;
	}

	FsClose(fd_src);
	FsClose(fd_dst);

	Free(tmp_buf);

//	SYSINFODSP("Make Backup file");
//	SYSINFODSP("%s", MSG_FILE(d_name));
//	SYSINFO("Make Backup file");
//	SYSINFO("%s", MSG_FILE(d_name));
//	SYSINFOCNS("Make Backup file");
//	SYSINFOCNS("%s", MSG_FILE(d_name));
}
Esempio n. 2
0
//==============================================================
void *_MmFileLoadB(const char *file, int area)
//--------------------------------------------------------------
// malloc して読み込む
// ※ブロックタイプ
//--------------------------------------------------------------
// in:	file = ファイル名
//		area = 読み込みエリア
//--------------------------------------------------------------
// out:	読み込みアドレス
//==============================================================
{
	sFILE *fp;
	size_t len;
	void *p;

	fp = FsOpen(file);
	ASSERT(fp);
	len = FsGetSizeOrig(fp);
	p = MemMalloc(area, len, GetFileBaseName(file));
	ASSERT(p);
	FsRead(fp, p, len);
	FsClose(fp);

	mn_read_size = len;							// FIXME:実ファイルサイズを返すべきか?

//	PRINTF("File '%s' Loaded.(%d bytes)\n", file, len);

	return p;
}
Esempio n. 3
0
//==============================================================
void *MmTextFileLoad(const char *file)
//--------------------------------------------------------------
// テキストファイルを読み込む
// ※データ終端に '\0' を付加します
//--------------------------------------------------------------
// in:	file = ファイル名
//--------------------------------------------------------------
// out:	読み込みアドレス
//==============================================================
{
	sFILE *fp;
	size_t len;
	char *p;

	fp = FsOpen(file);
	ASSERT(fp);
	len = FsGetSizeOrig(fp);
	p = (char *)fsMalloc(len + 1, "text data");
	ASSERT(p);
	FsRead(fp, p, len);
	FsClose(fp);

	*(p + len) = '\0';

	return p;
}
Esempio n. 4
0
// List all files and subdirectories recursively
static void list_files(const char *filepath, ListCallback list_callback)
{
	char DirSpec[255+1], SubDir[255+1];
	FsEntry entry;
	void * hFind;
	char *fname;
	u32 dwError;

	strncpy(DirSpec, filepath, ARRAY_SIZE(DirSpec));
	DirSpec[255] = 0 ; // hard limit the string here

	hFind = FsReadFirst(DirSpec, &entry);
	if (hFind == NULL) return;

	do {
		fname = (strlen(entry.cAlternateFileName)>0) ? entry.cAlternateFileName : entry.cFileName;
		list_callback(&entry,EListCallbackArg_Item);
		printf("cflash added %s\n",entry.cFileName);

		if ((entry.flags & FS_IS_DIR) && (strcmp(fname, ".")) && (strcmp(fname, ".."))) 
		{
			if (strlen(fname)+strlen(filepath)+2 < 256) 
			{
				sprintf(SubDir, "%s%c%s", filepath, FS_SEPARATOR, fname);
				list_files(SubDir, list_callback);
				list_callback(&entry, EListCallbackArg_Pop);
			}
		}
	} while (FsReadNext(hFind, &entry) != 0);

	dwError = FsError();
	FsClose(hFind);
	if (dwError != FS_ERR_NO_MORE_FILES) return;
}
Esempio n. 5
0
int DiskCreate() {
  char *filename = NULL;
  int fsfd = -1;
  disk_block b;
  int i;

  // Check that you remembered to rename the filename for your group
  filename = DISK_FILENAME;
  if (filename[11] == 'X') {
    printf("DiskCreate: you didn't change the filesystem filename in include/os/disk.h.  Cowardly refusing to do anything.\n");
    GracefulExit();
  }
  // Open the hard disk file
  if ((fsfd = FsOpen(DISK_FILENAME, FS_MODE_WRITE)) < 0) {
    printf ("DiskCreate: File system %s cannot be opened!\n", DISK_FILENAME);
    return DISK_FAIL;
  }

  // Write all zeros to the hard disk file to make sure it is the right size.
  // You need to do this because the writeblock/readblock operations are allowed in
  // random order.
  bzero(b.data, DISK_BLOCKSIZE);
  for(i=0; i<DISK_NUMBLOCKS; i++) {
    FsWrite(fsfd, b.data, DISK_BLOCKSIZE);
  }
  
  // Close the hard disk file
  if (FsClose(fsfd) < 0) {
    printf("DiskCreate: unable to close open file!\n");
    return DISK_FAIL;
  }
  return DISK_SUCCESS;
}
Esempio n. 6
0
int DiskWriteBlock (uint32 blocknum, disk_block *b) {
  int fsfd = -1;
  uint32 intrvals = 0;
  char *filename = NULL;

  if (blocknum >= DISK_NUMBLOCKS) {
    printf("DiskWriteBlock: cannot write to block larger than filesystem size\n");
    return DISK_FAIL;
  }

  // Check that you remembered to rename the filename for your group
  filename = DISK_FILENAME;
  if (filename[11] == 'X') {
    printf("DiskWriteBlock: you didn't change the filesystem filename in include/os/disk.h.  Cowardly refusing to do anything.\n");
    GracefulExit();
  }

  intrvals = DisableIntrs();

  // Open the hard disk file
  if ((fsfd = FsOpen(DISK_FILENAME, FS_MODE_RW)) < 0) {
    printf ("DiskWriteBlock: File system %s cannot be opened!\n", DISK_FILENAME);
    return DISK_FAIL;
  }

  /* printf("DiskWriteBlock: fsfd = %d\n", fsfd); */

  // Write data to virtual disk
  FsSeek(fsfd, blocknum * DISK_BLOCKSIZE, FS_SEEK_SET);
  if (FsWrite(fsfd, b->data, DISK_BLOCKSIZE) != DISK_BLOCKSIZE) {
    printf ("DiskWriteBlock: Block %d could not be written!\n", blocknum);
    FsClose (fsfd);
    return DISK_FAIL;
  }

  // Close the hard disk file
  FsClose (fsfd);

  RestoreIntrs(intrvals);
  return DISK_BLOCKSIZE;
}
Esempio n. 7
0
//==============================================================
static void PNGAPI flushFunc(png_structp png_ptr)
//--------------------------------------------------------------
// 
//--------------------------------------------------------------
// in:	
//--------------------------------------------------------------
// out:	
//==============================================================
{
	sFILE *fp;

	fp = (sFILE *)png_get_io_ptr(png_ptr);
	FsClose(fp);
}
Esempio n. 8
0
//==============================================================
BOOL MmFileCheck(const char *file)
//--------------------------------------------------------------
// ファイルが存在するかチェック
//--------------------------------------------------------------
// in:	file = ファイル名
//--------------------------------------------------------------
// out:	TRUE = 存在する
//==============================================================
{
	sFILE *fp;

	fp = FsOpen(file);
	if(fp)	FsClose(fp);

	return fp ? TRUE : FALSE;
}
Esempio n. 9
0
//==============================================================
void MmFileWriteB(const char *file, void *ptr, size_t len)
//--------------------------------------------------------------
// ファイルを書き出す
// ※ブロックタイプ
//--------------------------------------------------------------
// in:	file = ファイル名
//		ptr  = データポインタ
//		len  = データサイズ
//--------------------------------------------------------------
// out:	なし
//==============================================================
{
	sFILE *fp;

	fp = FsCreate(file);
	ASSERT(fp);
	FsWrite(fp, ptr, len);
	FsClose(fp);
}
Esempio n. 10
0
//----------------------------------------------------------------------
//
//	ProcessGetCodeSizes
//
//	Get the code sizes (stack & data) for a file.  A file descriptor
//	for the named file is returned.  This descriptor MUST be closed
//	(presumably by the caller) at some point.
//
//----------------------------------------------------------------------
int
ProcessGetCodeInfo (const char *file, uint32 *startAddr,
		    uint32 *codeStart, uint32 *codeSize,
		     uint32 *dataStart, uint32 *dataSize)
{
  int		fd;
  int		totalsize;
  char		buf[100];
  char		*pos;

  // Open the file for reading.  If it returns a negative number, the open
  // didn't work.
  if ((fd = FsOpen (file, FS_MODE_READ)) < 0) {
    dbprintf ('f', "ProcessGetCodeInfo: open of %s failed (%d).\n",
	      file, fd);
    return (-1);
  }
  dbprintf ('f', "File descriptor is now %d.\n", fd);
  if ((totalsize = FsRead (fd, buf, sizeof (buf))) != sizeof (buf)) {
    dbprintf ('f', "ProcessGetCodeInfo: read got %d (not %d) bytes from %s\n",
	      totalsize, (int)sizeof (buf), file);
    FsClose (fd);
    return (-1);
  }
  if (dstrstr (buf, "start:") == NULL) {
    dbprintf ('f', "ProcessGetCodeInfo: %s missing start line (not a DLX executable?)\n", file);
    return (-1);
  }
  pos = (char *)dindex (buf, ':') + 1;
  // Get the start address and overall size
  *startAddr = dstrtol (pos, &pos, 16);
  totalsize = dstrtol (pos, &pos, 16);
  // Get code & data section start & sizes
  *codeStart = dstrtol (pos, &pos, 16);
  *codeSize = dstrtol (pos, &pos, 16);
  *dataStart = dstrtol (pos, &pos, 16);
  *dataSize = dstrtol (pos, &pos, 16);
  // Seek to start of first real line
  FsSeek (fd, 1 + dindex (buf, '\n') - buf, 0);
  return (fd);
}
Esempio n. 11
0
//----------------------------------------------------------------------
//
//	main
//
//	This routine is called when the OS starts up.  It allocates a
//	PCB for the first process - the one corresponding to the initial
//	thread of execution.  Note that the stack pointer is already
//	set correctly by _osinit (assembly language code) to point
//	to the stack for the 0th process.  This stack isn't very big,
//	though, so it should be replaced by the system stack of the
//	currently running process.
//
//----------------------------------------------------------------------
void main (int argc, char *argv[])
{
  int		i,j;
  int		n;
  char	buf[120];
  char		*userprog = (char *)0;
  int base=0;
  int numargs=0;
  char allargs[SIZE_ARG_BUFF];
  int allargs_offset = 0;
  
  debugstr[0] = '\0';

  printf ("Got %d arguments.\n", argc);
  printf ("Available memory: 0x%x -> 0x%x.\n", (int)lastosaddress, MemoryGetSize ());
  printf ("Argument count is %d.\n", argc);
  for (i = 0; i < argc; i++) {
    printf ("Argument %d is %s.\n", i, argv[i]);
  }

  FsModuleInit ();
  for (i = 0; i < argc; i++) 
  {
    if (argv[i][0] == '-') 
    {
      switch (argv[i][1]) 
      {
      case 'D':
	dstrcpy (debugstr, argv[++i]);
	break;
      case 'i':
	n = dstrtol (argv[++i], (void *)0, 0);
	ditoa (n, buf);
	printf ("Converted %s to %d=%s\n", argv[i], n, buf);
	break;
      case 'f':
      {
	int	start, codeS, codeL, dataS, dataL, fd, j;
	int	addr = 0;
	static unsigned char buf[200];
	fd = ProcessGetCodeInfo (argv[++i], &start, &codeS, &codeL, &dataS,
				 &dataL);
	printf ("File %s -> start=0x%08x\n", argv[i], start);
	printf ("File %s -> code @ 0x%08x (size=0x%08x)\n", argv[i], codeS,
		codeL);
	printf ("File %s -> data @ 0x%08x (size=0x%08x)\n", argv[i], dataS,
		dataL);
	while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0) 
	{
	  for (j = 0; j < n; j += 4) 
	  {
	    printf ("%08x: %02x%02x%02x%02x\n", addr + j - n, buf[j], buf[j+1],
		    buf[j+2], buf[j+3]);
	  }
	}
	close (fd);
	break;
      }
      case 'u':
	userprog = argv[++i];
        base = i; // Save the location of the user program's name 
	break;
      default:
	printf ("Option %s not recognized.\n", argv[i]);
	break;
      }
      if(userprog)
        break;
    }
  }
  dbprintf ('i', "About to initialize queues.\n");
  AQueueModuleInit ();
  dbprintf ('i', "After initializing queues.\n");
  MemoryModuleInit ();
  dbprintf ('i', "After initializing memory.\n");

  ProcessModuleInit ();
  dbprintf ('i', "After initializing processes.\n");
  SynchModuleInit ();
  dbprintf ('i', "After initializing synchronization tools.\n");
  KbdModuleInit ();
  dbprintf ('i', "After initializing keyboard.\n");
  ClkModuleInit ();
  dbprintf ('i', "After initializing clock.\n");
  for (i = 0; i < 100; i++) {
    buf[i] = 'a';
  }
  i = FsOpen ("vm", FS_MODE_WRITE);
  dbprintf ('i', "VM Descriptor is %d\n", i);
  FsSeek (i, 0, FS_SEEK_SET);
  FsWrite (i, buf, 80);
  FsClose (i);

  // Setup command line arguments
  if (userprog != (char *)0) {
    numargs=0;
    allargs_offset = 0;
    // Move through each of the argv addresses
    for(i=0; i<argc-base; i++) {
      // At each argv address, copy the string into allargs, including the '\0'
      for(j=0; allargs_offset < SIZE_ARG_BUFF; j++) {
        allargs[allargs_offset++] = argv[i+base][j];
        if (argv[i+base][j] == '\0') break; // end of this string
      }
      numargs++;
    }
    allargs[SIZE_ARG_BUFF-1] = '\0'; // set last char to NULL for safety
    ProcessFork(0, (uint32)allargs, userprog, 1);
  } else {
    dbprintf('i', "No user program passed!\n");
  }
  ClkStart();
  dbprintf ('i', "Set timer quantum to %d, about to run first process.\n",
	    processQuantum);
  intrreturn ();
  // Should never be called because the scheduler exits when there
  // are no runnable processes left.
  exitsim();	// NEVER RETURNS!
}
Esempio n. 12
0
//----------------------------------------------------------------------
//
//	ProcessFork
//
//	Create a new process and make it runnable.  This involves the
//	following steps:
//	* Allocate resources for the process (PCB, memory, etc.)
//	* Initialize the resources
//	* Place the PCB on the runnable queue
//
//	NOTE: This code has been tested for system processes, but not
//	for user processes.
//
//----------------------------------------------------------------------
int ProcessFork (VoidFunc func, uint32 param, char *name, int isUser) {
  int i,j;                   // Loop index variable
  int fd, n;               // Used for reading code from files.
  int start, codeS, codeL; // Used for reading code from files.
  int dataS, dataL;        // Used for reading code from files.
  int addr = 0;            // Used for reading code from files.
  unsigned char buf[100];  // Used for reading code from files.
  uint32 *stackframe;      // Stores address of current stack frame.
  PCB *pcb;                // Holds pcb while we build it for this process.
  int intrs;               // Stores previous interrupt settings.
  uint32  initial_user_params[MAX_ARGS+2]; // Initial memory for user parameters (argc, argv)
                                           // initial_user_params[0] = argc
                                           // initial_user_params[1] = argv, points to initial_user_params[2]
                                           // initial_user_params[2] = address of string for argv[0]
                                           // initial_user_params[3] = address of string for argv[1]
                                           //                           ...
  uint32 argc=0;           // running counter for number of arguments
  uint32 offset;           // Used in parsing command line argument strings, holds offset (in bytes) from 
                           // beginning of the string to the current argument.
  uint32 initial_user_params_bytes;  // total number of bytes in initial user parameters array

  int newpage;
  int index;
  int *p;


  intrs = DisableIntrs ();
  dbprintf ('I', "ProcessFork-Old interrupt value was 0x%x.\n", intrs);
  dbprintf ('p', "ProcessFork-Entering ProcessFork args=0x%x 0x%x %s %d\n", (int)func,
	    param, name, isUser);
  // Get a free PCB for the new process
  if (AQueueEmpty(&freepcbs)) {
    printf ("ProcessFork-FATAL error: no free processes!\n");
    exitsim ();	// NEVER RETURNS!
  }
  pcb = (PCB *)AQueueObject(AQueueFirst (&freepcbs));
  dbprintf ('p', "ProcessFork-Got a link @ 0x%x\n", (int)(pcb->l));
  if (AQueueRemove (&(pcb->l)) != QUEUE_SUCCESS) {
    printf("ProcessFork-FATAL ERROR: could not remove link from freepcbsQueue in ProcessFork!\n");
    exitsim();
  }
  // This prevents someone else from grabbing this process
  ProcessSetStatus (pcb, PROCESS_STATUS_RUNNABLE);

  // At this point, the PCB is allocated and nobody else can get it.
  // However, it's not in the run queue, so it won't be run.  Thus, we
  // can turn on interrupts here.
  RestoreIntrs (intrs);

  // Copy the process name into the PCB.
  dstrcpy(pcb->name, name);

  //----------------------------------------------------------------------
  // This section initializes the memory for this process
  //----------------------------------------------------------------------
  // Allocate 1 page for system stack, 1 page for user stack (at top of
  // virtual address space), and 4 pages for user code and global data.

  //---------------------------------------------------------
  // STUDENT: allocate pages for a new process here.  The
  // code below assumes that you set the "stackframe" variable
  // equal to the last 4-byte-aligned address in physical page
  // for the system stack.
  //---------------------------------------------------------

  ////////////////////////////////////////////////////////////////
  // JSM, allocate 6 physical pages for new process

  // First, get L2 Page Table for index 0 of L1 Page Table
  index = MemoryAllocateL2PT();
	if (index == -1)
	{
		printf ("ProcessFork-FATAL: couldn't allocate L2 Page Table for index 0 of L1 Page Table - no free page tables!\n");
		exitsim ();	// NEVER RETURNS!
	}
  // Assign L1 entry to address of start of L2 Page Table
	pcb->pagetable[0] = (uint32)&level2_pt_block[index];

	p = (uint32 *)pcb->pagetable[0];//L2

  // Allocate 4 pages for code and data
  for(i = 0; i < 4; i++)
  {
		newpage = MemoryAllocatePage();
		if (newpage == 0)
		{
			printf ("ProcessFork-FATAL: couldn't allocate memory - no free pages!\n");
			exitsim ();	// NEVER RETURNS!
		}
		dbprintf('p', "ProcessFork-Allocating physical page #%d (Address 0x%.8X) for process virtual page #%d (data/code)\n", newpage, (newpage*MEM_PAGE_SIZE), i);

		*(p+i) = ((newpage*MEM_PAGE_SIZE) | MEM_PTE_VALID);
		dbprintf('p', "Contents at 0x%.8X: 0x%.8X\n\n", (int)(p+i), *(p+i));
  }
	/////////////////////////////////////////////////////
	//YF ADDED allocate page for heap
  // First, initialize the heapfree map
  for (j=0; j<MEM_MAX_HEAP_FREEMAP; j++){
  	pcb->HeapFreeMap[j] = 0;
  }
  for (j =0; j<MEM_MAX_HEAP_POINTER_ARRAY; j++){
  	pcb->HeapPtrSizes[j] = 0;
  }

  index = MemoryAllocateL2PT();
	if (index == -1)
	{
		printf ("ProcessFork-FATAL: couldn't allocate L2 Page Table for index 0 of L1 Page Table - no free page tables!\n");
		exitsim ();	// NEVER RETURNS!
	}
  // Assign L1 entry to address of start of L2 Page Table
	pcb->pagetable[0] = (uint32)&level2_pt_block[index];
	p = (uint32 *)pcb->pagetable[0];

	newpage = MemoryAllocatePage();
	if (newpage == 0)
	{
		printf ("ProcessFork-FATAL: couldn't allocate memory - no free pages!\n");
		exitsim ();	// NEVER RETURNS!
	}
	dbprintf('p', "ProcessFork-Allocating physical page #%d (Address 0x%.8X) for process virtual page #%d (Heap Allocation)\n", newpage, (newpage*MEM_PAGE_SIZE), i);
	//address for catch in Memory translate. UserHeap Address =0x4000 =
	*(p+i) = ((newpage*MEM_PAGE_SIZE) | MEM_PTE_VALID | MEM_PTE_HEAP); //TODO ProcessFork: marked as a heap.
	pcb->userHeapArea = (uint32 *)(newpage*MEM_PAGE_SIZE);
	dbprintf('p', "Heap area is at physical address:0x%.8X   L2 Address: 0x%.8X\n", (int)(newpage*MEM_PAGE_SIZE), *(p+i));
	dbprintf('p', "Contents at 0x%.8X: 0x%.8X\n\n", (int)(p+i), *(p+i));
	//Done with Heap allocation

///////////////////////////////////////////////////////////////////////////////////////////////////
  // Allocate page for user stack
  // First, get L2 Page Table for index 15 of L1 Page Table
  index = MemoryAllocateL2PT();
	if (index == -1)
	{
		printf ("ProcessFork-FATAL: couldn't allocate L2 Page Table for index 0 of L1 Page Table - no free page tables!\n");
		exitsim ();	// NEVER RETURNS!
	}
  // Assign L1 entry to address of start of L2 Page Table
	pcb->pagetable[MEM_L1_PAGE_TABLE_SIZE-1] = (uint32)&level2_pt_block[index];
	p = (uint32 *)pcb->pagetable[MEM_L1_PAGE_TABLE_SIZE-1];

	newpage = MemoryAllocatePage();
	if (newpage == 0)
	{
		printf ("ProcessFork-FATAL: couldn't allocate memory - no free pages!\n");
		exitsim ();	// NEVER RETURNS!
	}
	dbprintf('p', "ProcessFork-Allocating physical page #%d (Address 0x%.8X) for process virtual page #%d (user stack)\n\n", newpage, (newpage*MEM_PAGE_SIZE), (MEM_L1_PAGE_TABLE_SIZE*MEM_L2_PAGE_TABLE_SIZE)-1);

	*(p+(MEM_L2_PAGE_TABLE_SIZE-1)) = ((newpage*MEM_PAGE_SIZE) | MEM_PTE_VALID);
	dbprintf('p', "Contents at 0x%.8X: 0x%.8X\n\n", (int)(p+(MEM_L2_PAGE_TABLE_SIZE-1)), *(p+(MEM_L2_PAGE_TABLE_SIZE-1)));

  // Allocate page for system stack
	newpage = MemoryAllocatePage();
	if (newpage == 0)
	{
		printf ("ProcessFork-FATAL: couldn't allocate memory - no free pages!\n");
		exitsim ();	// NEVER RETURNS!
	}
	dbprintf('p', "ProcessFork-Allocating physical page #%d (Address 0x%.8X) for process system stack\n\n", newpage, (newpage*MEM_PAGE_SIZE));
	pcb->sysStackArea = newpage * MEM_PAGE_SIZE;
	stackframe = (uint32 *)(pcb->sysStackArea + (MEM_PAGE_SIZE-4));
	dbprintf('p', "ProcessFork-Initializing system stack pointer to 0x%.8X\n\n", (uint32)stackframe);

  ////////////////////////////////////////////////////////////////

  // Now that the stack frame points at the bottom of the system stack memory area, we need to
  // move it up (decrement it) by one stack frame size because we're about to fill in the
  // initial stack frame that will be loaded for this PCB when it gets switched in by 
  // ProcessSchedule the first time.
  stackframe -= PROCESS_STACK_FRAME_SIZE;

  // The system stack pointer is set to the base of the current interrupt stack frame.
  pcb->sysStackPtr = stackframe;
  // The current stack frame pointer is set to the same thing.
  pcb->currentSavedFrame = stackframe;

  //----------------------------------------------------------------------
  // This section sets up the stack frame for the process.  This is done
  // so that the frame looks to the interrupt handler like the process
  // was "suspended" right before it began execution.  The standard
  // mechanism of swapping in the registers and returning to the place
  // where it was "interrupted" will then work.
  //----------------------------------------------------------------------

  // The previous stack frame pointer is set to 0, meaning there is no
  // previous frame.
  dbprintf('m', "ProcessFork-ProcessFork: stackframe = 0x%x\n", (int)stackframe);
  stackframe[PROCESS_STACK_PREV_FRAME] = 0;

  //----------------------------------------------------------------------
  // STUDENT: setup the PTBASE, PTBITS, and PTSIZE here on the current
  // stack frame.
  //----------------------------------------------------------------------

  // JSM added PTBASE, PTBITS, and PTSIZE on stack frame
  //////////////////////////////////////////////////////////
  stackframe[PROCESS_STACK_PTBASE] = (uint32)&(pcb->pagetable[0]);
  dbprintf('p', "ProcessFork-PTBASE: 0x%.8X\n\n", (uint32)&(pcb->pagetable[0]));
  stackframe[PROCESS_STACK_PTSIZE] = MEM_L1_PAGE_TABLE_SIZE;
  dbprintf('p', "ProcessFork-PTSIZE: 0x%.8X\n\n", MEM_L1_PAGE_TABLE_SIZE);
  stackframe[PROCESS_STACK_PTBITS] = (MEM_L2FIELD_FIRST_BITNUM << 16) | MEM_L1FIELD_FIRST_BITNUM;
  dbprintf('p', "ProcessFork-PTBITS: 0x%.8X\n\n", (MEM_L2FIELD_FIRST_BITNUM << 16) | MEM_L1FIELD_FIRST_BITNUM);

  //////////////////////////////////////////////////////////

  if (isUser) {//user prog .dlx.obj
    dbprintf ('p', "ProcessFork-About to load %s\n", name);
    fd = ProcessGetCodeInfo (name, &start, &codeS, &codeL, &dataS, &dataL);
    if (fd < 0) {
      // Free newpage and pcb so we don't run out...
      ProcessFreeResources (pcb);
      return (-1);
    }

    dbprintf ('p', "ProcessFork-File %s -> start=0x%08x\n", name, start);
    dbprintf ('p', "ProcessFork-File %s -> code @ 0x%08x (size=0x%08x)\n", name, codeS,
	      codeL);
    dbprintf ('p', "ProcessFork-File %s -> data @ 0x%08x (size=0x%08x)\n", name, dataS,
	      dataL);

    while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0) {
      dbprintf ('p', "ProcessFork-Placing %d bytes at vaddr %08x.\n", n, addr - n);
      // Copy the data to user memory.  Note that the user memory needs to
      // have enough space so that this copy will succeed!
      MemoryCopySystemToUser (pcb, buf, (char *)(addr - n), n);
    }
    FsClose (fd);
    stackframe[PROCESS_STACK_ISR] = PROCESS_INIT_ISR_USER;

    //----------------------------------------------------------------------
    // STUDENT: setup the initial user stack pointer here as the top
    // of the process's virtual address space (4-byte aligned).
    //----------------------------------------------------------------------

    // JSM initialized user stack pointer
    //////////////////////////////////////////////////////////
    stackframe[PROCESS_STACK_USER_STACKPOINTER] = (MEM_MAX_VIRTUAL_ADDRESS-3);
    dbprintf('p', "ProcessFork-USER_STACKPOINTER: 0x%.8X\n\n", stackframe[PROCESS_STACK_USER_STACKPOINTER]);
    //////////////////////////////////////////////////////////

    //--------------------------------------------------------------------
    // This part is setting up the initial user stack with argc and argv.
    //--------------------------------------------------------------------

    // Copy the entire set of strings of command line parameters onto the user stack.
    // The "param" variable is a pointer to the start of a sequenial set of strings,
    // each ending with its own '\0' character.  The final "string" of the sequence
    // must be an empty string to indicate that the sequence is done.  Since we
    // can't figure out how long the set of strings actually is in this scenario,
    // we have to copy the maximum possible string length and parse things manually.
    stackframe[PROCESS_STACK_USER_STACKPOINTER] -= SIZE_ARG_BUFF;
    MemoryCopySystemToUser (pcb, (char *)param, (char *)stackframe[PROCESS_STACK_USER_STACKPOINTER], SIZE_ARG_BUFF);

    // Now that the main string is copied into the user space, we need to setup
    // argv as an array of pointers into that string, and argc as the total
    // number of arguments found in the string.  The first call to get_argument
    // should return 0 as the offset of the first string.
    offset = get_argument((char *)param);
   
    // Compute the addresses in user space of where each string for the command line arguments
    // begins.  These addresses make up the argv array.
    for(argc=0; argc < MAX_ARGS; argc++) {
      // The "+2" is because initial_user_params[0] is argc, and initial_user_params[1] is argv.
      // The address can be found as the current stack pointer (which points to the start of
      // the params list) plus the byte offset of the parameter from the beginning of
      // the list of parameters.
      initial_user_params[argc+2] = stackframe[PROCESS_STACK_USER_STACKPOINTER] + offset;
      offset = get_argument(NULL);
      if (offset == 0) {
        initial_user_params[argc+2+1] = 0; // last entry should be a null value
        break;
      }
    }
    // argc is currently the index of the last command line argument.  We need it to instead
    // be the number of command line arguments, so we increment it by 1.
    argc++;

    // Now argc can be stored properly
    initial_user_params[0] = argc;

    // Compute where initial_user_params[3] will be copied in user space as the 
    // base of the array of string addresses.  The entire initial_user_params array
    // of uint32's will be copied onto the stack.  We'll move the stack pointer by
    // the necessary amount, then start copying the array.  Therefore, initial_user_params[3]
    // will reside at the current stack pointer value minus the number of command line
    // arguments (argc).
    initial_user_params[1] = stackframe[PROCESS_STACK_USER_STACKPOINTER] - (argc*sizeof(uint32));

    // Now copy the actual memory.  Remember that stacks grow down from the top of memory, so 
    // we need to move the stack pointer first, then do the copy.  The "+2", as before, is 
    // because initial_user_params[0] is argc, and initial_user_params[1] is argv.
    initial_user_params_bytes = (argc + 2) * sizeof(uint32);

    stackframe[PROCESS_STACK_USER_STACKPOINTER] -= initial_user_params_bytes;
    MemoryCopySystemToUser (pcb, (char *)initial_user_params, (char *)(stackframe[PROCESS_STACK_USER_STACKPOINTER]), initial_user_params_bytes);

    // Set the correct address at which to execute a user process.
    stackframe[PROCESS_STACK_IAR] = (uint32)start;

    // Flag this as a user process
    pcb->flags |= PROCESS_TYPE_USER;
  } else {
    // Don't worry about messing with any code here for kernel processes because
    // there aren't any kernel processes in DLXOS.

    // Set r31 to ProcessExit().  This will only be called for a system
    // process; user processes do an exit() trap.
    stackframe[PROCESS_STACK_IREG+31] = (uint32)ProcessExit;

    // Set the stack register to the base of the system stack.
    //stackframe[PROCESS_STACK_IREG+29]=pcb->sysStackArea + MEM_PAGESIZE;

    // Set the initial parameter properly by placing it on the stack frame
    // at the location pointed to by the "saved" stack pointer (r29).
    *((uint32 *)(stackframe[PROCESS_STACK_IREG+29])) = param;

    // Set up the initial address at which to execute.  This is done by
    // placing the address into the IAR slot of the stack frame.
    stackframe[PROCESS_STACK_IAR] = (uint32)func;

    // Set the initial value for the interrupt status register
    stackframe[PROCESS_STACK_ISR] = PROCESS_INIT_ISR_SYS;

    // Mark this as a system process.
    pcb->flags |= PROCESS_TYPE_SYSTEM;
  }

  // Place the PCB onto the run queue.
  intrs = DisableIntrs ();
  if ((pcb->l = AQueueAllocLink(pcb)) == NULL) {
    printf("FATAL ERROR: could not get link for forked PCB in ProcessFork!\n");
    exitsim();
  }
  if (AQueueInsertLast(&runQueue, pcb->l) != QUEUE_SUCCESS) {
    printf("FATAL ERROR: could not insert link into runQueue in ProcessFork!\n");
    exitsim();
  }
  RestoreIntrs (intrs);

  // If this is the first process, make it the current one
  if (currentPCB == NULL) {
    dbprintf ('p', "Setting currentPCB=0x%x, stackframe=0x%x\n",
	      (int)pcb, (int)(pcb->currentSavedFrame));
    currentPCB = pcb;
  }

  dbprintf ('p', "Leaving ProcessFork (%s)\n", name);
  // Return the process number (found by subtracting the PCB number
  // from the base of the PCB array).
  return (pcb - pcbs);
}
Esempio n. 13
0
//----------------------------------------------------------------------
//
//	ProcessFork
//
//	Create a new process and make it runnable.  This involves the
//	following steps:
//	* Allocate resources for the process (PCB, memory, etc.)
//	* Initialize the resources
//	* Place the PCB on the runnable queue
//
//	NOTE: This code has been tested for system processes, but not
//	for user processes.
//
//----------------------------------------------------------------------
int ProcessFork (VoidFunc func, uint32 param, char *name, int isUser) {
  int i;                   // Loop index variable
  int fd, n;               // Used for reading code from files.
  int start, codeS, codeL; // Used for reading code from files.
  int dataS, dataL;        // Used for reading code from files.
  int addr = 0;            // Used for reading code from files.
  unsigned char buf[100];  // Used for reading code from files.
  uint32 *stackframe;      // Stores address of current stack frame.
  PCB *pcb;                // Holds pcb while we build it for this process.
  int intrs;               // Stores previous interrupt settings.
  uint32  initial_user_params[MAX_ARGS+2]; // Initial memory for user parameters (argc, argv)
                                           // initial_user_params[0] = argc
                                           // initial_user_params[1] = argv, points to initial_user_params[2]
                                           // initial_user_params[2] = address of string for argv[0]
                                           // initial_user_params[3] = address of string for argv[1]
                                           //                           ...
  uint32 argc=0;           // running counter for number of arguments
  uint32 offset;           // Used in parsing command line argument strings, holds offset (in bytes) from
                           // beginning of the string to the current argument.
  uint32 initial_user_params_bytes;  // total number of bytes in initial user parameters array
  int newPage;


  intrs = DisableIntrs ();
  dbprintf ('I', "Old interrupt value was 0x%x.\n", intrs);
  dbprintf ('p', "Entering ProcessFork args=0x%x 0x%x %s %d\n", (int)func,
	    param, name, isUser);
  // Get a free PCB for the new process
  if (AQueueEmpty(&freepcbs)) {
    printf ("FATAL error: no free processes!\n");
    exitsim ();	// NEVER RETURNS!
  }
  pcb = (PCB *)AQueueObject(AQueueFirst (&freepcbs));
  dbprintf ('p', "Got a link @ 0x%x\n", (int)(pcb->l));
  if (AQueueRemove (&(pcb->l)) != QUEUE_SUCCESS) {
    printf("FATAL ERROR: could not remove link from freepcbsQueue in ProcessFork!\n");
    exitsim();
  }
  // This prevents someone else from grabbing this process
  ProcessSetStatus (pcb, PROCESS_STATUS_RUNNABLE);

  // At this point, the PCB is allocated and nobody else can get it.
  // However, it's not in the run queue, so it won't be run.  Thus, we
  // can turn on interrupts here.
  RestoreIntrs (intrs);

  // Copy the process name into the PCB.
  dstrcpy(pcb->name, name);

  //----------------------------------------------------------------------
  // This section initializes the memory for this process
  //----------------------------------------------------------------------
  // Allocate 1 page for system stack, 1 page for user stack (at top of
  // virtual address space), and 4 pages for user code and global data.
  //---------------------------------------------------------
  // STUDENT: allocate pages for a new process here.  The
  // code below assumes that you set the "stackframe" variable
  // equal to the last 4-byte-aligned address in physical page
  // for the system stack.
  //---------------------------------------------------------
  // Pages for code and global data and Heap
  pcb->npages = 5;
  for(i = 0; i < pcb->npages; i++) {
    newPage = MemoryAllocPage();
    if(newPage == MEM_FAIL) {
      printf ("FATAL: couldn't allocate memory - no free pages!\n");
      ProcessFreeResources (pcb);
      return PROCESS_FORK_FAIL;
    }
    pcb->pagetable[i] = MemorySetupPte (newPage);
  }
  // Initialize nodes in pool
  for (i = 1; i <= MEM_HEAP_MAX_NODES; i++) {
    pcb->htree_array[i].parent = NULL;
    pcb->htree_array[i].cleft = NULL;
    pcb->htree_array[i].crght = NULL;
    pcb->htree_array[i].index = i;
    pcb->htree_array[i].size = -1;
    pcb->htree_array[i].addr = -1;
    pcb->htree_array[i].inuse = 0;
    pcb->htree_array[i].order = -1;
  }
  // Initialize Heap tree
  pcb->htree_array[1].size = MEM_PAGESIZE;
  pcb->htree_array[1].addr = 0;
  pcb->htree_array[1].order = 7;
  // user stack
  pcb->npages += 1;
  newPage = MemoryAllocPage();
  if(newPage == MEM_FAIL) {
    printf ("FATAL: couldn't allocate user stack - no free pages!\n");
    ProcessFreeResources (pcb);
    return PROCESS_FORK_FAIL;
  }
  pcb->pagetable[MEM_ADDRESS_TO_PAGE(MEM_MAX_VIRTUAL_ADDRESS)] = MemorySetupPte (newPage);

  // for system stack
  newPage = MemoryAllocPage ();
  if(newPage == MEM_FAIL) {
    printf ("FATAL: couldn't allocate system stack - no free pages!\n");
    ProcessFreeResources (pcb);
    return PROCESS_FORK_FAIL;
  }

  pcb->sysStackArea = newPage * MEM_PAGESIZE;
  //----------------------------------------------------------------------
  // Stacks grow down from the top.  The current system stack pointer has
  // to be set to the bottom of the interrupt stack frame, which is at the
  // high end (address-wise) of the system stack.
  stackframe = (uint32 *)(pcb->sysStackArea + MEM_PAGESIZE - 4);
  dbprintf('p', "ProcessFork: SystemStack page=%d sysstackarea=0x%x\n", newPage, pcb->sysStackArea);

  // Now that the stack frame points at the bottom of the system stack memory area, we need to
  // move it up (decrement it) by one stack frame size because we're about to fill in the
  // initial stack frame that will be loaded for this PCB when it gets switched in by
  // ProcessSchedule the first time.
  stackframe -= PROCESS_STACK_FRAME_SIZE;

  // The system stack pointer is set to the base of the current interrupt stack frame.
  pcb->sysStackPtr = stackframe;
  // The current stack frame pointer is set to the same thing.
  pcb->currentSavedFrame = stackframe;

  dbprintf ('p', "Setting up PCB @ 0x%x (sys stack=0x%x, mem=0x%x, size=0x%x)\n",
    (int)pcb, pcb->sysStackArea, pcb->pagetable[0], pcb->npages * MEM_PAGESIZE);

  //----------------------------------------------------------------------
  // This section sets up the stack frame for the process.  This is done
  // so that the frame looks to the interrupt handler like the process
  // was "suspended" right before it began execution.  The standard
  // mechanism of swapping in the registers and returning to the place
  // where it was "interrupted" will then work.
  //----------------------------------------------------------------------

  // The previous stack frame pointer is set to 0, meaning there is no
  // previous frame.
  dbprintf('p', "ProcessFork: stackframe = 0x%x\n", (int)stackframe);
  stackframe[PROCESS_STACK_PREV_FRAME] = 0;

  //----------------------------------------------------------------------
  // STUDENT: setup the PTBASE, PTBITS, and PTSIZE here on the current
  // stack frame.
  //----------------------------------------------------------------------
  // Set the base of the level 1 page table.  If there's only one page
  // table level, this is it.  For 2-level page tables, put the address
  // of the level 1 page table here.  For 2-level page tables, we'll also
  // have to build up the necessary tables....
  stackframe[PROCESS_STACK_PTBASE] = (uint32)(&(pcb->pagetable[0]));

  // Set the size (maximum number of entries) of the level 1 page table.
  // In our case, it's just one page, but it could be larger.
  stackframe[PROCESS_STACK_PTSIZE] = MEM_PAGE_TBL_SIZE;

  // Set the number of bits for both the level 1 and level 2 page tables.
  // This can be changed on a per-process basis if desired.  For now,
  // though, it's fixed.
  stackframe[PROCESS_STACK_PTBITS] = (MEM_L1FIELD_FIRST_BITNUM << 16) + MEM_L1FIELD_FIRST_BITNUM;

  if (isUser) {
    dbprintf ('p', "About to load %s\n", name);
    fd = ProcessGetCodeInfo (name, &start, &codeS, &codeL, &dataS, &dataL);
    if (fd < 0) {
      // Free newPage and pcb so we don't run out...
      ProcessFreeResources (pcb);
      return (-1);
    }

    dbprintf ('p', "File %s -> start=0x%08x\n", name, start);
    dbprintf ('p', "File %s -> code @ 0x%08x (size=0x%08x)\n", name, codeS,
	      codeL);
    dbprintf ('p', "File %s -> data @ 0x%08x (size=0x%08x)\n", name, dataS,
	      dataL);

    while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0) {
      dbprintf ('i', "Placing %d bytes at vaddr %08x.\n", n, addr - n);
      // Copy the data to user memory.  Note that the user memory needs to
      // have enough space so that this copy will succeed!
      MemoryCopySystemToUser (pcb, buf, (char *)(addr - n), n);
    }
    FsClose (fd);
    stackframe[PROCESS_STACK_ISR] = PROCESS_INIT_ISR_USER;

    //----------------------------------------------------------------------
    // STUDENT: setup the initial user stack pointer here as the top
    // of the process's virtual address space (4-byte aligned).
    //----------------------------------------------------------------------
    stackframe[PROCESS_STACK_USER_STACKPOINTER] = MEM_MAX_VIRTUAL_ADDRESS - 3;
    dbprintf('p', "ProcessFork: UserStack usrsp=0x%x\n", stackframe[PROCESS_STACK_USER_STACKPOINTER]);

    //--------------------------------------------------------------------
    // This part is setting up the initial user stack with argc and argv.
    //--------------------------------------------------------------------

    // Copy the entire set of strings of command line parameters onto the user stack.
    // The "param" variable is a pointer to the start of a sequenial set of strings,
    // each ending with its own '\0' character.  The final "string" of the sequence
    // must be an empty string to indicate that the sequence is done.  Since we
    // can't figure out how long the set of strings actually is in this scenario,
    // we have to copy the maximum possible string length and parse things manually.
    stackframe[PROCESS_STACK_USER_STACKPOINTER] -= SIZE_ARG_BUFF;
    MemoryCopySystemToUser (pcb, (char *)param, (char *)stackframe[PROCESS_STACK_USER_STACKPOINTER], SIZE_ARG_BUFF);

    // Now that the main string is copied into the user space, we need to setup
    // argv as an array of pointers into that string, and argc as the total
    // number of arguments found in the string.  The first call to get_argument
    // should return 0 as the offset of the first string.
    offset = get_argument((char *)param);

    // Compute the addresses in user space of where each string for the command line arguments
    // begins.  These addresses make up the argv array.
    for(argc=0; argc < MAX_ARGS; argc++) {
      // The "+2" is because initial_user_params[0] is argc, and initial_user_params[1] is argv.
      // The address can be found as the current stack pointer (which points to the start of
      // the params list) plus the byte offset of the parameter from the beginning of
      // the list of parameters.
      initial_user_params[argc+2] = stackframe[PROCESS_STACK_USER_STACKPOINTER] + offset;
      offset = get_argument(NULL);
      if (offset == 0) {
        initial_user_params[argc+2+1] = 0; // last entry should be a null value
        break;
      }
    }
    // argc is currently the index of the last command line argument.  We need it to instead
    // be the number of command line arguments, so we increment it by 1.
    argc++;

    // Now argc can be stored properly
    initial_user_params[0] = argc;

    // Compute where initial_user_params[3] will be copied in user space as the
    // base of the array of string addresses.  The entire initial_user_params array
    // of uint32's will be copied onto the stack.  We'll move the stack pointer by
    // the necessary amount, then start copying the array.  Therefore, initial_user_params[3]
    // will reside at the current stack pointer value minus the number of command line
    // arguments (argc).
    initial_user_params[1] = stackframe[PROCESS_STACK_USER_STACKPOINTER] - (argc*sizeof(uint32));

    // Now copy the actual memory.  Remember that stacks grow down from the top of memory, so
    // we need to move the stack pointer first, then do the copy.  The "+2", as before, is
    // because initial_user_params[0] is argc, and initial_user_params[1] is argv.
    initial_user_params_bytes = (argc + 2) * sizeof(uint32);

    stackframe[PROCESS_STACK_USER_STACKPOINTER] -= initial_user_params_bytes;
    MemoryCopySystemToUser (pcb, (char *)initial_user_params, (char *)(stackframe[PROCESS_STACK_USER_STACKPOINTER]), initial_user_params_bytes);

    // Set the correct address at which to execute a user process.
    stackframe[PROCESS_STACK_IAR] = (uint32)start;

    // Flag this as a user process
    pcb->flags |= PROCESS_TYPE_USER;
  } else {
    // Don't worry about messing with any code here for kernel processes because
    // there aren't any kernel processes in DLXOS.

    // Set r31 to ProcessExit().  This will only be called for a system
    // process; user processes do an exit() trap.
    stackframe[PROCESS_STACK_IREG+31] = (uint32)ProcessExit;

    // Set the stack register to the base of the system stack.
    //stackframe[PROCESS_STACK_IREG+29]=pcb->sysStackArea + MEM_PAGESIZE;

    // Set the initial parameter properly by placing it on the stack frame
    // at the location pointed to by the "saved" stack pointer (r29).
    *((uint32 *)(stackframe[PROCESS_STACK_IREG+29])) = param;

    // Set up the initial address at which to execute.  This is done by
    // placing the address into the IAR slot of the stack frame.
    stackframe[PROCESS_STACK_IAR] = (uint32)func;

    // Set the initial value for the interrupt status register
    stackframe[PROCESS_STACK_ISR] = PROCESS_INIT_ISR_SYS;

    // Mark this as a system process.
    pcb->flags |= PROCESS_TYPE_SYSTEM;
  }

  // Place the PCB onto the run queue.
  intrs = DisableIntrs ();
  if ((pcb->l = AQueueAllocLink(pcb)) == NULL) {
    printf("FATAL ERROR: could not get link for forked PCB in ProcessFork!\n");
    exitsim();
  }
  if (AQueueInsertLast(&runQueue, pcb->l) != QUEUE_SUCCESS) {
    printf("FATAL ERROR: could not insert link into runQueue in ProcessFork!\n");
    exitsim();
  }
  RestoreIntrs (intrs);

  // If this is the first process, make it the current one
  if (currentPCB == NULL) {
    dbprintf ('p', "Setting currentPCB=0x%x, stackframe=0x%x\n",
	      (int)pcb, (int)(pcb->currentSavedFrame));
    currentPCB = pcb;
  }

  dbprintf ('p', "Leaving ProcessFork (%s)\n", name);
  // Return the process number (found by subtracting the PCB number
  // from the base of the PCB array).
  return (pcb - pcbs);
}
Esempio n. 14
0
//----------------------------------------------------------------------
//
//	main
//
//	This routine is called when the OS starts up.  It allocates a
//	PCB for the first process - the one corresponding to the initial
//	thread of execution.  Note that the stack pointer is already
//	set correctly by _osinit (assembly language code) to point
//	to the stack for the 0th process.  This stack isn't very big,
//	though, so it should be replaced by the system stack of the
//	currently running process.
//
//----------------------------------------------------------------------
main (int argc, char *argv[])
{
  int		i, j;
  int		n;
  char	buf[120];
  char		*userprog = (char *)0;
  static PCB	temppcb;
  uint32	addr;
  extern void	SysprocCreateProcesses ();
  char *param[12]={NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  	 	   NULL, NULL, NULL, NULL};
  int base;

  debugstr[0] = '\0';
  MyFuncRetZero();
  printf ("Got %d arguments.\n", argc);
  printf ("Available memory: 0x%x -> 0x%x.\n", lastosaddress,
	  MemoryGetSize ());
  printf ("Argument count is %d.\n", argc);
  for (i = 0; i < argc; i++) {
    printf ("Argument %d is %s.\n", i, argv[i]);
  }
//  *((int *)0xfff00100) = 't';
  FsModuleInit ();
  for (i = 0; i < argc; i++)
  {
    if (argv[i][0] == '-')
    {
      switch (argv[i][1])
      {
      case 'D':
	dstrcpy (debugstr, argv[++i]);
	break;
      case 'i':
	n = dstrtol (argv[++i], (void *)0, 0);
	ditoa (n, buf);
	printf ("Converted %s to %d=%s\n", argv[i], n, buf);
	break;
      case 'f':
      {
	int	start, codeS, codeL, dataS, dataL, fd, j;
	int	addr = 0;
	static unsigned char buf[200];
	fd = ProcessGetCodeInfo (argv[++i], &start, &codeS, &codeL, &dataS,
				 &dataL);
	printf ("File %s -> start=0x%08x\n", argv[i], start);
	printf ("File %s -> code @ 0x%08x (size=0x%08x)\n", argv[i], codeS,
		codeL);
	printf ("File %s -> data @ 0x%08x (size=0x%08x)\n", argv[i], dataS,
		dataL);
	while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0)
	{
	  for (j = 0; j < n; j += 4)
	  {
	    printf ("%08x: %02x%02x%02x%02x\n", addr + j - n, buf[j], buf[j+1],
		    buf[j+2], buf[j+3]);
	  }
	}
	close (fd);
	break;
      }
      case 'u':
	userprog = argv[++i];
        base = i;
	break;
      default:
	printf ("Option %s not recognized.\n", argv[i]);
	break;
      }
      if(userprog)
        break;
    }
  }
  dbprintf ('i', "About to initialize queues.\n");
  QueueModuleInit ();
  dbprintf ('i', "After initializing queues.\n");
  MemoryModuleInit ();
  dbprintf ('i', "After initializing memory.\n");

  ProcessModuleInit ();
  dbprintf ('i', "After initializing processes.\n");
  ShareModuleInit ();
  dbprintf ('i', "After initializing shared memory.\n");
  SynchModuleInit ();
  dbprintf ('i', "After initializing synchronization tools.\n");
  KbdModuleInit ();
  dbprintf ('i', "After initializing keyboard.\n");
  for (i = 0; i < 100; i++) {
    buf[i] = 'a';
  }
  i = FsOpen ("vm", FS_MODE_WRITE);
  dbprintf ('i', "VM Descriptor is %d\n", i);
  FsSeek (i, 0, FS_SEEK_SET);
  FsWrite (i, buf, 80);
  FsClose (i);
  if (userprog != (char *)0) {
      for(i=base;i<argc&&i-base<11; i++)
      {
        param[i-base] = argv[i];
      }
      process_create(0,0,param[0], param[1], param[2], param[3], param[4],
      		     param[5], param[6], param[7], param[8], param[9],
		     param[10], param[11]);
//    ProcessFork (0, (uint32)"Help Me man!", userprog, 1);
  }
  SysprocCreateProcesses ();
  dbprintf ('i', "Created processes - about to set timer quantum.\n");
  TimerSet (processQuantum);
  dbprintf ('i', "Set timer quantum to %d, about to run first process.\n",
	    processQuantum);
  intrreturn ();
  // Should never be called because the scheduler exits when there
  // are no runnable processes left.
  exitsim();	// NEVER RETURNS!
}
Esempio n. 15
0
//----------------------------------------------------------------------
//
//	ProcessFork
//
//	Create a new process and make it runnable.  This involves the
//	following steps:
//	* Allocate resources for the process (PCB, memory, etc.)
//	* Initialize the resources
//	* Place the PCB on the runnable queue
//
//	NOTE: This code has been tested for system processes, but not
//	for user processes.
//
//----------------------------------------------------------------------
int
ProcessFork (VoidFunc func, uint32 param, int p_nice, int p_info,char *name, int isUser)
{
  int		i, j, fd, n;
  Link		*l;
  int		start, codeS, codeL, dataS, dataL;
  uint32	*stackframe;
  int		newPage;
  PCB		*pcb;
  int	addr = 0;
  int		intrs;
  unsigned char buf[100];
  uint32 dum[MAX_ARGS+8], count, offset;
  char *str;


  intrs = DisableIntrs ();
  dbprintf ('I', "Old interrupt value was 0x%x.\n", intrs);
  dbprintf ('p', "Entering ProcessFork args=0x%x 0x%x %s %d\n", func,
	    param, name, isUser);
  // Get a free PCB for the new process
  if (QueueEmpty (&freepcbs)) {
    printf ("FATAL error: no free processes!\n");
    exitsim ();	// NEVER RETURNS!
  }
  l = QueueFirst (&freepcbs);
  dbprintf ('p', "Got a link @ 0x%x\n", l);
  QueueRemove (l);
  pcb = (PCB *)(l->object);
  // This prevents someone else from grabbing this process
  ProcessSetStatus (pcb, PROCESS_STATUS_RUNNABLE);

  // At this point, the PCB is allocated and nobody else can get it.
  // However, it's not in the run queue, so it won't be run.  Thus, we
  // can turn on interrupts here.
  dbprintf ('I', "Before restore interrupt value is 0x%x.\n", CurrentIntrs());
  RestoreIntrs (intrs);
  dbprintf ('I', "New interrupt value is 0x%x.\n", CurrentIntrs());

  // Copy the process name into the PCB.
  dstrcpy (pcb->name, name);

  //----------------------------------------------------------------------
  // This section initializes the memory for this process
  //----------------------------------------------------------------------
  // For now, we'll use one user page and a page for the system stack.
  // For system processes, though, all pages must be contiguous.
  // Of course, system processes probably need just a single page for
  // their stack, and don't need any code or data pages allocated for them.
  pcb->npages = 1;
  newPage = MemoryAllocPage ();
  if (newPage == 0) {
    printf ("aFATAL: couldn't allocate memory - no free pages!\n");
    exitsim ();	// NEVER RETURNS!
  }
  pcb->pagetable[0] = MemorySetupPte (newPage);
  newPage = MemoryAllocPage ();
  if (newPage == 0) {
    printf ("bFATAL: couldn't allocate system stack - no free pages!\n");
    exitsim ();	// NEVER RETURNS!
  }
  pcb->sysStackArea = newPage * MEMORY_PAGE_SIZE;


  //---------------------------------------
  // Lab3: initialized pcb member for your scheduling algorithm here
  //--------------------------------------
  pcb->p_nice = p_nice < 0 ? 0 : p_nice;
  pcb->p_info = p_info;
  pcb->sleeptime = my_timer_get();
  pcb->estcpu = 0;
  pcb->prio = PUSER;
  pcb->processed = 1 - processedFlag;
  pcb->estcputime = 0;
  //----------------------------------------------------------------------
  // Stacks grow down from the top.  The current system stack pointer has
  // to be set to the bottom of the interrupt stack frame, which is at the
  // high end (address-wise) of the system stack.
  stackframe = ((uint32 *)(pcb->sysStackArea + MEMORY_PAGE_SIZE)) -
    (PROCESS_STACK_FRAME_SIZE + 8);
  // The system stack pointer is set to the base of the current interrupt
  // stack frame.
  pcb->sysStackPtr = stackframe;
  // The current stack frame pointer is set to the same thing.
  pcb->currentSavedFrame = stackframe;

  dbprintf ('p',
	    "Setting up PCB @ 0x%x (sys stack=0x%x, mem=0x%x, size=0x%x)\n",
	    pcb, pcb->sysStackArea, pcb->pagetable[0],
	    pcb->npages * MEMORY_PAGE_SIZE);

  //----------------------------------------------------------------------
  // This section sets up the stack frame for the process.  This is done
  // so that the frame looks to the interrupt handler like the process
  // was "suspended" right before it began execution.  The standard
  // mechanism of swapping in the registers and returning to the place
  // where it was "interrupted" will then work.
  //----------------------------------------------------------------------

  // The previous stack frame pointer is set to 0, meaning there is no
  // previous frame.
  stackframe[PROCESS_STACK_PREV_FRAME] = 0;

  // Set the base of the level 1 page table.  If there's only one page
  // table level, this is it.  For 2-level page tables, put the address
  // of the level 1 page table here.  For 2-level page tables, we'll also
  // have to build up the necessary tables....
  stackframe[PROCESS_STACK_PTBASE] = (uint32)&(pcb->pagetable[0]);

  // Set the size (maximum number of entries) of the level 1 page table.
  // In our case, it's just one page, but it could be larger.
  stackframe[PROCESS_STACK_PTSIZE] = pcb->npages;

  // Set the number of bits for both the level 1 and level 2 page tables.
  // This can be changed on a per-process basis if desired.  For now,
  // though, it's fixed.
  stackframe[PROCESS_STACK_PTBITS] = (MEMORY_L1_PAGE_SIZE_BITS
					  + (MEMORY_L2_PAGE_SIZE_BITS << 16));


  if (isUser) {
    dbprintf ('p', "About to load %s\n", name);
    fd = ProcessGetCodeInfo (name, &start, &codeS, &codeL, &dataS, &dataL);
    if (fd < 0) {
      // Free newpage and pcb so we don't run out...
      ProcessFreeResources (pcb);
      return (-1);
    }
    dbprintf ('p', "File %s -> start=0x%08x\n", name, start);
    dbprintf ('p', "File %s -> code @ 0x%08x (size=0x%08x)\n", name, codeS,
	      codeL);
    dbprintf ('p', "File %s -> data @ 0x%08x (size=0x%08x)\n", name, dataS,
	      dataL);
    while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0) {
      dbprintf ('p', "Placing %d bytes at vaddr %08x.\n", n, addr - n);
      // Copy the data to user memory.  Note that the user memory needs to
      // have enough space so that this copy will succeed!
      MemoryCopySystemToUser (pcb, buf, addr - n, n);
    }
    FsClose (fd);
    stackframe[PROCESS_STACK_ISR] = PROCESS_INIT_ISR_USER;
    // Set the initial stack pointer correctly.  Currently, it's just set
    // to the top of the (single) user address space allocated to this
    // process.
    str = (char *)param;
    stackframe[PROCESS_STACK_IREG+29] = MEMORY_PAGE_SIZE - SIZE_ARG_BUFF;
    // Copy the initial parameter to the top of stack

    MemoryCopySystemToUser (pcb, (char *)str,
			    (char *)stackframe[PROCESS_STACK_IREG+29],
			    SIZE_ARG_BUFF-32);

    offset = get_argument((char *)param);

    dum[2] = MEMORY_PAGE_SIZE - SIZE_ARG_BUFF + offset;
    for(count=3;;count++)
    {
      offset=get_argument(NULL);
      dum[count] = MEMORY_PAGE_SIZE - SIZE_ARG_BUFF + offset;
      if(offset==0)
      {
        break;
      }
    }
    dum[0] = count-2;
    dum[1] = MEMORY_PAGE_SIZE - SIZE_ARG_BUFF - (count-2)*4;
    MemoryCopySystemToUser (pcb, (char *)dum,
			    (char *)(stackframe[PROCESS_STACK_IREG+29]-count*4),
			    (count)*sizeof(uint32));
    stackframe[PROCESS_STACK_IREG+29] -= 4*count;
    // Set the correct address at which to execute a user process.
    stackframe[PROCESS_STACK_IAR] = (uint32)start;
    pcb->flags |= PROCESS_TYPE_USER;
  } else {
    // Set r31 to ProcessExit().  This will only be called for a system
    // process; user processes do an exit() trap.
    stackframe[PROCESS_STACK_IREG+31] = (uint32)ProcessExit;

    // Set the stack register to the base of the system stack.
    stackframe[PROCESS_STACK_IREG+29]=pcb->sysStackArea + MEMORY_PAGE_SIZE-32;

    // Set the initial parameter properly by placing it on the stack frame
    // at the location pointed to by the "saved" stack pointer (r29).
    *((uint32 *)(stackframe[PROCESS_STACK_IREG+29])) = param;

    // Set up the initial address at which to execute.  This is done by
    // placing the address into the IAR slot of the stack frame.
    stackframe[PROCESS_STACK_IAR] = (uint32)func;

    // Set the initial value for the interrupt status register
    stackframe[PROCESS_STACK_ISR] = PROCESS_INIT_ISR_SYS;

    // Mark this as a system process.
    pcb->flags |= PROCESS_TYPE_SYSTEM;
  }

  // Place the PCB onto the run queue.
  intrs = DisableIntrs ();
  QueueInsertLast (&runQueue[pcb->prio/4], l);
  RestoreIntrs (intrs);

  // If this is the first process, make it the current one
  if (currentPCB == NULL) {
    dbprintf ('p', "Setting currentPCB=0x%x, stackframe=0x%x\n",
	      pcb, pcb->currentSavedFrame);
    currentPCB = pcb;
  }
  dbprintf ('p', "Leaving ProcessFork (%s)\n", name);
  // Return the process number (found by subtracting the PCB number
  // from the base of the PCB array).
  return (pcb - pcbs);
}
Esempio n. 16
0
//==============================================================
void PngWrite(char *file, int w, int h, u_char *ptr)
//--------------------------------------------------------------
// データ出力
// 32bit → 32bit
//--------------------------------------------------------------
// in:	file = ファイル名
//		w, h = データサイズ
//		ptr  = データポインタ
//--------------------------------------------------------------
// out:	なし
//==============================================================
{
	sFILE *fp;
	png_structp png_ptr;
	png_infop info_ptr;
	png_color_8 sig_bit;
	png_text text_ptr[1];
	png_bytep *row_pointers;
	int k;

#ifdef USE_USER_MEMORY
	png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL, NULL, libpng_Malloc, libpng_Free);
#else
	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
#endif
	if(!png_ptr)
	{
		return;
	}

	info_ptr = png_create_info_struct(png_ptr);
	if(!info_ptr)
	{
		png_destroy_write_struct(&png_ptr, png_infopp_NULL);
		return;
	}

	// ファイルの新規作成
	//--------------------
	fp = FsCreate(file);
	ASSERT(fp);

	png_set_write_fn(png_ptr, (png_voidp)fp, writeFunc, flushFunc);
	png_set_IHDR(png_ptr, info_ptr, w, h, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_BASE);

	sig_bit.red = 8;
	sig_bit.green = 8;
	sig_bit.blue = 8;
	sig_bit.alpha = 0;
	png_set_sBIT(png_ptr, info_ptr, &sig_bit);

	text_ptr[0].key = "Description";
	text_ptr[0].text = "ktcDIB::Save() Data";
	text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
	png_set_text(png_ptr, info_ptr, text_ptr, 1);

	png_write_info(png_ptr, info_ptr);
	png_set_bgr(png_ptr);

	row_pointers = (png_bytep *)fsMalloc(sizeof(png_bytep *) * h, "png_bytep");
	ASSERT(row_pointers);
	for(k = 0; k < h; ++k)
	{
		png_byte *p;

		p = (png_byte *)fsMalloc(sizeof(png_byte) * w * 3, "png_byte");
		ASSERT(p);
		row_pointers[k] = (png_bytep)p;
		memcpy(p, ptr, w * 3);
		ptr += w * 3;
	}

	png_write_image(png_ptr, row_pointers);
	png_write_end(png_ptr, info_ptr);

	for(k = 0; k < h; ++k)
	{
		Free(row_pointers[k]);
	}
	Free(row_pointers);

	png_destroy_write_struct(&png_ptr, &info_ptr);
	FsClose(fp);
}