// file_read(uint32 handle, void *mem, int num_bytes)
int TrapFileReadHandler(uint32 *trapArgs, int sysMode) {
uint32 handle;
char *user_mem;
char mem[FILE_MAX_READWRITE_BYTES];
int num_bytes;
int ret;
// If we're not in system mode, we need to copy everything from the
// user-space virtual address to the kernel space address
if (!sysMode) {
// Get the arguments themselves into system space
// Argument 0: handle to file descriptor
MemoryCopyUserToSystem (currentPCB, (trapArgs+0), &handle, sizeof(uint32));
// Argument 1: userland address of where to copy newly read data
MemoryCopyUserToSystem (currentPCB, (trapArgs+1), &user_mem, sizeof(uint32));
// Argument 2: integer number of bytes to read
MemoryCopyUserToSystem (currentPCB, (trapArgs+2), &num_bytes, sizeof(uint32));
} else {
// Already in kernel space, no address translation necessary
handle = trapArgs[0];
user_mem = (char *)(trapArgs[1]);
num_bytes = trapArgs[2];
}
if (num_bytes > FILE_MAX_READWRITE_BYTES) {
printf("TrapFileReadHandler: ERROR: you cannot read more than %d bytes at a time!\n", num_bytes);
return FILE_FAIL;
}
if ((ret = FileRead(handle, mem, num_bytes)) == FILE_FAIL) {
return FILE_FAIL;
}
// Copy bytes that we just read into user mem
if (!sysMode) {
MemoryCopySystemToUser(currentPCB, mem, user_mem, num_bytes);
} else {
bcopy(mem, user_mem, num_bytes);
}
return ret;
}
//---------------------------------------------------------------------
// Mbox receive handler
//
// handle mbox receive trap
// int mbox_recv(mbox_t handle, int maxlength, void* message);
//----------------------------------------------------------------------
static int TrapMboxRecvHandler (uint32 *trapArgs, int sysMode) {
mbox_t handle; // Holds handle to mailbox
char msg[MBOX_MAX_MESSAGE_LENGTH]; // Holds message in kernel space
char *usermessage = NULL; // Pointer to user-space message
int maxlength=-1; // Holds max length of message (in bytes)
int retval; // Return value of MBoxReceive call
// If we're not in system mode, we need to copy everything from the
// user-space virtual address to the kernel space address
if (!sysMode) {
// Get the arguments themselves into system space
// Argument 0: handle to mailbox
MemoryCopyUserToSystem (currentPCB, (trapArgs+0), &handle, sizeof(mbox_t));
// Argument 1: max length of message (in bytes)
MemoryCopyUserToSystem (currentPCB, (trapArgs+1), &maxlength, sizeof(int));
// Argument 2: pointer to message data (user space)
MemoryCopyUserToSystem (currentPCB, (trapArgs+2), &usermessage, sizeof(char *));
} else {
// Already in kernel space, no address translation necessary
handle = (mbox_t)trapArgs[0];
maxlength = (int)trapArgs[1];
usermessage = (char *)trapArgs[2];
}
retval = MboxRecv(handle, maxlength, msg);
if (retval == MBOX_FAIL) {
// No copying necessary, user should assume msg is not filled in
return retval;
} else {
// Copy message from msg to user space. Number of bytes is returned by MboxRecv
if (!sysMode) {
MemoryCopySystemToUser(currentPCB, msg, usermessage, retval);
} else {
bcopy(msg, usermessage, retval);
}
}
return retval;
}
//----------------------------------------------------------------------
//
// 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);
}
//----------------------------------------------------------------------
//
// 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);
}
//----------------------------------------------------------------------
//
// 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);
}
