KernelElf.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef KERNEL_LINKER_KERNELELF_H
#define KERNEL_LINKER_KERNELELF_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/linker/Elf.h"
#include "pedigree/kernel/processor/MemoryRegion.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/MemoryAllocator.h"
#include "pedigree/kernel/utilities/SharedPointer.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/utility.h"

#ifdef THREADS
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/process/Semaphore.h"
#endif

#ifdef STATIC_DRIVERS
#include "modules/Module.h"
#endif

class BootstrapStruct_t;
class String;

class Module
{
  public:
    Module()
        : elf(nullptr), name(0), entry(0), exit(0), depends(0), depends_opt(0),
          buffer(0), buflen(0), status(Unknown)
    {
    }

    ~Module()
    {
        delete elf;
    }

    Elf *elf;
    String name;
    bool (*entry)();
    void (*exit)();
    const char **depends;
    const char **depends_opt;
    uint8_t *buffer;
    size_t buflen;
    uintptr_t loadBase;
    size_t loadSize;

    enum ModuleStatus
    {
        Unknown,
        Preloaded,
        Executing,
        Active,
        Failed,
        Unloaded
    } status;

    bool isPending() const
    {
        return status == Preloaded;
    }

    bool isLoaded() const
    {
        return status == Preloaded || status == Active;
    }

    bool isUnloaded() const
    {
        return status == Unloaded || status == Failed;
    }

    bool isFailed() const
    {
        return status == Failed;
    }

    bool isActive() const
    {
        return status == Active;
    }

    bool isExecuting() const
    {
        return status == Executing;
    }

    bool wasAttempted() const
    {
        return status == Executing || isActive() || isFailed() || isUnloaded();
    }

  protected:
    Module(const Module &);
    Module &operator=(const Module &);
};

class EXPORTED_PUBLIC KernelElf : public Elf
{
    friend void system_reset();

  public:
    inline static KernelElf &instance()
    {
        return m_Instance;
    }

    bool initialise(const BootstrapStruct_t &pBootstrap) INITIALISATION_ONLY;

    Module *loadModule(uint8_t *pModule, size_t len, bool silent = false);
#ifdef STATIC_DRIVERS
    Module *loadModule(struct ModuleInfo *info, bool silent = false);
#endif

    void executeModules(bool silent = false, bool progress = true);

    void
    unloadModule(const char *name, bool silent = false, bool progress = true);
    void
    unloadModule(Module *module, bool silent = false, bool progress = true);

    void unloadModules();

    bool moduleIsLoaded(char *name);

    char *getDependingModule(char *name);

    uintptr_t globalLookupSymbol(const char *pName);
    const char *globalLookupSymbol(uintptr_t addr, uintptr_t *startAddr = 0);

    MemoryAllocator &getModuleAllocator()
    {
        return m_ModuleAllocator;
    }

    bool hasPendingModules() const;

    void updateModuleStatus(Module *module, bool status);

    void waitForModulesToLoad();

  private:
    KernelElf() INITIALISATION_ONLY;
    KernelElf(const KernelElf &);
    virtual ~KernelElf();
    KernelElf &operator=(const KernelElf &);

    bool moduleDependenciesSatisfied(Module *module);
    bool executeModule(Module *module);

    template <class T>
    static T *rebase(Module *module, T *ptr)
    {
        return adjust_pointer(ptr, module->loadBase);
    }

    void lockModules();

    void unlockModules();

#if defined(X86_COMMON)
    MemoryRegion m_AdditionalSectionContents;
    MemoryRegion *m_AdditionalSectionHeaders;
#endif

    static KernelElf m_Instance;

    Vector<Module *> m_Modules;
    MemoryAllocator m_ModuleAllocator;

#if defined(X86_COMMON)
    Elf32SectionHeader_t *m_pSectionHeaders;
    Elf32Symbol_t *m_pSymbolTable;

    typedef Elf32SectionHeader_t KernelElfSectionHeader_t;
    typedef Elf32Symbol_t KernelElfSymbol_t;
#else
    ElfSectionHeader_t *m_pSectionHeaders;
    ElfSymbol_t *m_pSymbolTable;

    typedef ElfSectionHeader_t KernelElfSectionHeader_t;
    typedef ElfSymbol_t KernelElfSymbol_t;
#endif

#ifdef THREADS
    Semaphore m_ModuleProgress;
    Spinlock m_ModuleAdjustmentLock;
#endif
};

#endif