user.c~

The main purpose of this project is to add a new scheduling algorithm to GeekOS and to implement a s

/*
 * Common user mode functions
 * Copyright (c) 2001,2003,2004 David H. Hovemeyer <[e-mail]>
 * $Revision: 1.50 $
 * 
 * This is free software.  You are permitted to use,
 * redistribute, and modify it as specified in the file "COPYING".
 */

#include <geekos/errno.h>
#include <geekos/ktypes.h>
#include <geekos/kassert.h>
#include <geekos/int.h>
#include <geekos/mem.h>
#include <geekos/malloc.h>
#include <geekos/kthread.h>
#include <geekos/vfs.h>
#include <geekos/tss.h>
#include <geekos/user.h>

/*
 * This module contains common functions for implementation of user
 * mode processes.
 */

/*
 * Associate the given user context with a kernel thread.
 * This makes the thread a user process.
 */
void Attach_User_Context(struct Kernel_Thread* kthread, struct User_Context* context)
{
    KASSERT(context != 0);
    kthread->userContext = context;

    Disable_Interrupts();

    /*
     * We don't actually allow multiple threads
     * to share a user context (yet)
     */
    KASSERT(context->refCount == 0);

    ++context->refCount;
    Enable_Interrupts();
}

/*
 * If the given thread has a user context, detach it
 * and destroy it.  This is called when a thread is
 * being destroyed.
 */
void Detach_User_Context(struct Kernel_Thread* kthread)
{
    struct User_Context* old = kthread->userContext;

    kthread->userContext = 0;

    if (old != 0) {
	int refCount;

	Disable_Interrupts();
        --old->refCount;
	refCount = old->refCount;
	Enable_Interrupts();

	/*Print("User context refcount == %d\n", refCount);*/
        if (refCount == 0)
            Destroy_User_Context(old);
    }
}

/*
 * Spawn a user process.
 * Params:
 *   program - the full path of the program executable file
 *   command - the command, including name of program and arguments
 *   pThread - reference to Kernel_Thread pointer where a pointer to
 *     the newly created user mode thread (process) should be
 *     stored
 * Returns:
 *   The process id (pid) of the new process, or an error code
 *   if the process couldn't be created.  Note that this function
 *   should return ENOTFOUND if the reason for failure is that
 *   the executable file doesn't exist.
 */

////////////////
////////////////
int Spawn(const char *program, const char *command, struct Kernel_Thread **pThread)
{
 	int result;
	char *exeFileData = 0;
	ulong_t exeFileLength;
	struct User_Context *UserContext = 0;
	struct Exe_Format exeFormat;
	struct Kernel_Thread * thread;

	Print("there is here\n");
	
	if ((result = Read_Fully(program,(void **) &exeFileData, &exeFileLength)) != 0)
	{
		Print("Failed to read file %s\n", program);
		goto fail;
	}

	
	if ((result = Parse_ELF_Executable(exeFileData, exeFileLength, &exeFormat)) != 0)
	{
		Print("Failed to parse ELF file \n");
		goto fail;
	}


	if ((result = Load_User_Program(exeFileData, exeFileLength, &exeFormat, command, &UserContext)) != 0)
	{
		Print("Failed to Load User Program\n");
		goto fail;
	}


	Free(exeFileData);
	exeFileData = 0;

	thread = Start_User_Thread(UserContext, false);

	if (thread != 0)
	{
		*pThread = thread;
		result = thread->pid;
	}
	else 
	{
		result = ENOMEM;
	}
	return result;

fail:
	if (exeFileData != 0)
	{
		Print("free(exeFileData)\n");
		Free(exeFileData);
	}
	if (UserContext != 0)
	{
		Print("Destroy_User_Context(UserContext);\n");
		Destroy_User_Context(UserContext);
	}
	return result;
}

/*
 * If the given thread has a User_Context,
 * switch to its memory space.
 *
 * Params:
 *   kthread - the thread that is about to execute
 *   state - saved processor registers describing the state when
 *      the thread was interrupted
 */
void Switch_To_User_Context(struct Kernel_Thread* kthread, struct Interrupt_State* state)
{
    /*
     * Hint: Before executing in user mode, you will need to call
     * the Set_Kernel_Stack_Pointer() and Switch_To_Address_Space()
     * functions.
     */
	struct User_Context * UserContext = kthread->userContext;

	if (UserContext == 0)
	{
		return ;
	}

	Switch_To_Address_Space(UserContext);
	Set_Kernel_Stack_Pointer((ulong_t)(kthread->stackPage + PAGE_SIZE));
	
}