Beispiel #1
0
CoreServer::CoreServer()
    : ChannelServer<CoreServer, FileSystemMessage>(this)
{
    /*
     * TODO:
     * discover other CPUs with libarch APIC. Determine the memory
     * splitup. Claim the memory for that CPU. Fill the boot struct with various argument
     * inside the cpu1 memory so that IntelBoot.S can find its base.
     * start new kernel with /boot/kernel (or any other kernel, depending on configuration)
     * introduce a IntelGeometry, which uses APIC. CoreServer uses the Arch::Geometry to discover CPUs here.
     * once CPU1 is up & running, we can implement libmpi! :-)
     */
    m_numRegions = 0;
    m_kernel = ZERO;
    m_kernelImage = ZERO;
    m_coreInfo = ZERO;

#ifdef INTEL
    m_cores = ZERO;
    m_toMaster = ZERO;
    m_fromMaster = ZERO;
    m_toSlave = ZERO;
    m_fromSlave = ZERO;
#endif

    // Register IPC handlers
    addIPCHandler(ReadFile,  &CoreServer::getCoreCount);

    // TODO: hack: because of waitpid() we must send the reply manually before waitpid().
    addIPCHandler(CreateFile, &CoreServer::createProcess, false);
}
Beispiel #2
0
FileSystem::FileSystem(const char *path)
    : IPCServer<FileSystem, FileSystemMessage>(this)
{
    // Set members
    m_root      = 0;
    m_mountPath = path;
    m_requests  = new List<FileSystemRequest *>();
        
    // Register message handlers
    addIPCHandler(CreateFile, &FileSystem::pathHandler, false);
    addIPCHandler(StatFile,   &FileSystem::pathHandler, false);
    addIPCHandler(DeleteFile, &FileSystem::pathHandler, false);
    addIPCHandler(ReadFile,   &FileSystem::pathHandler, false);
    addIPCHandler(WriteFile,  &FileSystem::pathHandler, false);
}
Beispiel #3
0
ProcessServer::ProcessServer()
    : IPCServer<ProcessServer, ProcessMessage>(this)
{
    MemoryMessage mem;

    /* Register message handlers. */
    addIPCHandler(ReadProcess,  &ProcessServer::readProcessHandler);
    addIPCHandler(ExitProcess,  &ProcessServer::exitProcessHandler,  false);
    addIPCHandler(SpawnProcess, &ProcessServer::spawnProcessHandler);
    addIPCHandler(CloneProcess, &ProcessServer::cloneProcessHandler, false);
    addIPCHandler(WaitProcess,  &ProcessServer::waitProcessHandler,  false);
    addIPCHandler(SetCurrentDirectory, &ProcessServer::setCurrentDirectory);

    /* Load shared objects. */
    procs.load(USER_PROCESS_KEY, MAX_PROCS);
    files = new Array<Shared<FileDescriptor> >(MAX_PROCS);
}
Beispiel #4
0
CoreServer::CoreServer()
    : IPCServer<CoreServer, CoreMessage>(this)
{
    SystemInformation info;
    Memory::Range range;
    BootImage *image;
    BootSymbol *symbol;

    /* Register message handlers. */
    addIPCHandler(CreatePrivate,  &CoreServer::createPrivate);
    addIPCHandler(ReleasePrivate, &CoreServer::releasePrivate);
    addIPCHandler(ReadProcess,    &CoreServer::readProcessHandler);
    addIPCHandler(GetMounts,      &CoreServer::getMountsHandler);
    addIPCHandler(SetMount,       &CoreServer::setMountHandler);
    addIPCHandler(ExitProcess,    &CoreServer::exitProcessHandler,  false);
    addIPCHandler(SpawnProcess,   &CoreServer::spawnProcessHandler);
    addIPCHandler(WaitProcess,    &CoreServer::waitProcessHandler,  false);

    /* Allocate a user process table. */
    procs = new UserProcess[MAX_PROCS];
    memset(procs, 0, sizeof(UserProcess) * MAX_PROCS);

    /* Allocate FileSystemMounts table. */
    mounts = new FileSystemMount[FILESYSTEM_MAXMOUNTS];
    memset(mounts, 0, sizeof(FileSystemMount) * FILESYSTEM_MAXMOUNTS);

    /* We only guarantee that / and /dev, /proc are mounted. */
    strlcpy(mounts[0].path, "/dev", PATHLEN);
    strlcpy(mounts[1].path, "/", PATHLEN);
    strlcpy(mounts[2].path, "/proc", PATHLEN);
    mounts[0].procID  = DEVSRV_PID;
    mounts[0].options = ZERO;
    mounts[1].procID  = ROOTSRV_PID;
    mounts[1].options = ZERO;
    mounts[2].procID  = 13;
    mounts[2].options = ZERO;

    // Attempt to load the boot image
    range.virt    = ZERO;
    range.phys    = info.bootImageAddress;
    range.access  = Arch::Memory::Present | Arch::Memory::User | Arch::Memory::Readable;
    range.size    = info.bootImageSize;
    VMCtl(SELF, Map, &range);
    
    image = (BootImage *) range.virt;

    /* Loop all embedded programs. */
    for (Size j = 0; j < image->symbolTableCount; j++)
    {
        /* Read out the next program. */
        symbol = (BootSymbol *)(((Address)image) + image->symbolTableOffset);
        symbol += j;

        if (symbol->type != BootProgram)
            continue;

        /* Write commandline. */
        snprintf(procs[j].command, COMMANDLEN,
                "[%s]", symbol->name);

        /* Set user and group identities. */
        procs[j].userID  = 0;
        procs[j].groupID = 0;
    }
}
Beispiel #5
0
MemoryServer::MemoryServer()
    : IPCServer<MemoryServer, MemoryMessage>(this)
{
    SystemInformation info;
    MemoryRange range;
    BootImage *image;
    BootProgram *program;

    /* Register message handlers. */
    addIPCHandler(CreatePrivate,  &MemoryServer::createPrivate);
    addIPCHandler(ReservePrivate, &MemoryServer::reservePrivate);
    addIPCHandler(ReleasePrivate, &MemoryServer::releasePrivate);
    addIPCHandler(CreateShared,   &MemoryServer::createShared);
    addIPCHandler(SystemMemory,   &MemoryServer::systemMemory);
    
    /* Allocate a user process table. */
    insertShared(SELF, USER_PROCESS_KEY,
		 sizeof(UserProcess) * MAX_PROCS, &range);

    /* Clear it. */
    procs = (UserProcess *) range.virtualAddress;
    memset(procs, 0, sizeof(UserProcess) * MAX_PROCS);

    /* Allocate FileSystemMounts table. */		 
    insertShared(SELF, FILE_SYSTEM_MOUNT_KEY,
		 sizeof(FileSystemMount) * MAX_MOUNTS, &range);
		 
    /* Also Clear it. */
    mounts = (FileSystemMount *) range.virtualAddress;
    memset(mounts, 0, sizeof(FileSystemMount) * MAX_MOUNTS);

    /* We only guarantee that / and /dev are mounted. */
    strlcpy(mounts[0].path, "/dev", PATHLEN);
    strlcpy(mounts[1].path, "/", PATHLEN);
    mounts[0].procID  = DEVSRV_PID;
    mounts[0].options = ZERO;
    mounts[1].procID  = ROOTSRV_PID;
    mounts[1].options = ZERO;

    /* Attempt to load the boot image. */
    for (Size i = 0; i < info.moduleCount; i++)
    {
        if (strcmp(info.modules[i].string, "/boot/boot.img.gz") == 0)
        {
	    range.virtualAddress  = findFreeRange(SELF, PAGESIZE * 2);
	    range.physicalAddress = info.modules[i].modStart;
	    range.access          = Memory::Present | Memory::User | Memory::Readable;
#warning Dangerous value for bytes here?
	    range.bytes           = PAGESIZE * 2;
	    VMCtl(SELF, Map, &range);
	    
	    image = (BootImage *) range.virtualAddress;
	    break;
	}
    }
    /* Loop all embedded programs. */
    for (Size j = 0; j < image->programsTableCount; j++)
    {
        /* Read out the next program. */
        program = (BootProgram *)(((Address)image) + image->programsTableOffset);
	program += j;

        /* Write commandline. */
        snprintf(procs[j].command, COMMANDLEN,
                "[%s]", program->path);

	/* Set current directory. */
	snprintf(procs[j].currentDirectory, PATHLEN, "/");

        /* Set user and group identities. */
        procs[j].userID  = 0;
        procs[j].groupID = 0;
    }
}