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/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/linker/Elf.h"
#include "pedigree/kernel/process/TerminationDeferral.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"
 
#include <config.h>
 
#include "modules/Module.h"
 
class BootstrapStruct_t;
class String;
struct RuntimeModuleSlot;
 
class Module {
 public:
  enum class UnloadAdmission { Ready, Busy, KeepMapped };
  using UnloadAdmissionHook = UnloadAdmission (*)(bool terminal);
  Module()
      : elf(nullptr),
        runtime(nullptr),
        name(0),
        entry(0),
        exit(0),
        unloadAdmission(nullptr),
        depends(0),
        depends_opt(0),
        buffer(0),
        buflen(0),
        loadBase(0),
        loadSize(0),
        unloadable(true),
        runtimeUnloadable(true),
        unloadComplete(false),
        progressCredits(0),
        status(Unknown) {}
 
  ~Module() {
    delete elf;
  }
 
  Elf* elf;
  RuntimeModuleSlot* runtime;
  String name;
  bool (*entry)();
  void (*exit)();
  UnloadAdmissionHook unloadAdmission;
  const char** depends;
  const char** depends_opt;
  uint8_t* buffer;
  size_t buflen;
  uintptr_t loadBase;
  size_t loadSize;
  bool unloadable;
  bool runtimeUnloadable;
  bool unloadComplete;
  size_t progressCredits;
 
  enum ModuleStatus { Unknown, Preloaded, Executing, Active, Failed, Unloading, Unloaded } status;
 
  bool isPending() const {
    return status == Preloaded;
  }
 
  bool isLoaded() const {
    return status == Preloaded || status == Active;
  }
 
  bool isUnloaded() const {
    return status == Unloaded || (status == Failed && unloadComplete);
  }
 
  bool isFailed() const {
    return status == Failed;
  }
 
  bool isActive() const {
    return status == Active;
  }
 
  bool isExecuting() const {
    return status == Executing;
  }
 
  bool isUnloading() const {
    return status == Unloading;
  }
 
  bool wasAttempted() const {
    return status == Executing || isActive() || isFailed() || isUnloading() || isUnloaded();
  }
 
 protected:
  Module(const Module&);
  Module& operator=(const Module&);
};
 
class EXPORTED_PUBLIC KernelElf : public Elf {
  friend void _cxx_main(BootstrapStruct_t&);
 
 public:
  typedef bool (*TerminalQuiesceHook)();
 
  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);
  Module* loadModule(struct ModuleInfo* info, bool silent = false);
 
  void executeModules(bool silent = false, bool progress = true);
 
  bool unloadModule(const char* name, bool silent = false, bool progress = true);
  bool unloadModule(Module* module, bool silent = false, bool progress = true);
 
  enum class RuntimeUnloadResult { Unloaded, NotFound, Busy, Pinned, DependedOn, Shutdown };
 
  RuntimeUnloadResult unloadModuleRuntime(const char* name);
 
  enum class RuntimeLoadResult {
    Ready,
    Loaded,
    InvalidImage,
    UnsupportedImage,
    ImageTooLarge,
    NoMemory,
    Busy,
    Shutdown,
    Duplicate,
    MissingDependency,
    EntryFailed,
    ProtectionFailed
  };
 
  class EXPORTED_PUBLIC RuntimeLoad {
   public:
    RuntimeLoad();
    ~RuntimeLoad();
    uint8_t* data() const;
 
   private:
    friend class KernelElf;
    RuntimeLoad(const RuntimeLoad&) = delete;
    RuntimeLoad& operator=(const RuntimeLoad&) = delete;
    TerminationDeferral lifetime;
    RuntimeModuleSlot* slot;
    size_t length;
  };
 
  bool prepareRuntimeModules();
  RuntimeLoadResult beginRuntimeModuleLoad(size_t length, RuntimeLoad& load);
  RuntimeLoadResult loadModuleRuntime(RuntimeLoad& load);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static void failRuntimeProtectionForTest(size_t operationsBeforeFailure);
#endif
 
  MUST_USE_RESULT bool unloadModules();
  bool isShuttingDown() const {
    return __atomic_load_n(&m_ModuleShutdown, __ATOMIC_ACQUIRE);
  }
 
  bool registerTerminalQuiesce(ModuleEntry ownerEntry, TerminalQuiesceHook hook);
 
  bool registerUnloadAdmission(ModuleEntry ownerEntry, Module::UnloadAdmissionHook hook);
 
  bool unregisterTerminalQuiesce(ModuleEntry ownerEntry, TerminalQuiesceHook hook);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  enum TestModuleUnloadClaim {
    TestUnloadClaimed,
    TestUnloadComplete,
    TestUnloadBusy,
    TestUnloadPinned,
    TestUnloadRuntimePinned,
    TestUnloadDependedOn,
    TestUnloadUnknown,
    TestUnloadShutdown,
  };
 
  static size_t planModuleUnloadOrderForTest(Module** modules, size_t count, Module** order,
                                             size_t capacity);
 
  static TestModuleUnloadClaim claimModuleUnloadForTest(Module* module, bool allowShutdown = true,
                                                        bool* runLifecycle = nullptr);
  static TestModuleUnloadClaim claimNamedModuleUnloadForTest(Module** modules, size_t count,
                                                             const char* name);
  static void completeModuleUnloadForTest(Module* module, bool wasFailed = false,
                                          bool runLifecycle = false);
  static bool moduleExecutionWaitsForUnloadForTest();
  static bool completeGuardedModuleUnloadForTest(Module* module, bool terminal);
#endif
 
  bool moduleIsLoaded(char* name);
 
  char* getDependingModule(char* name);
 
  uintptr_t globalLookupSymbol(const char* pName);
  const char* globalLookupSymbol(uintptr_t addr, uintptr_t* startAddr = 0);
 
  size_t getModuleCount();
 
  const Module* getModule(size_t index);
 
  MemoryAllocator& getModuleAllocator() {
    return m_ModuleAllocator;
  }
 
  bool hasPendingModules() const;
 
  void updateModuleStatus(Module* module, bool status, bool runFailureLifecycle = true);
 
  void waitForModulesToLoad();
 
  void invokeInitModule();
 
 private:
  KernelElf() INITIALISATION_ONLY;
  KernelElf(const KernelElf&);
  virtual ~KernelElf();
  KernelElf& operator=(const KernelElf&);
 
  bool moduleDependenciesSatisfiedLocked(Module* module) const;
  bool claimModuleExecutionLocked(Module* module);
  bool executeModule(Module* module);
 
  enum ModuleUnloadClaim {
    UnloadClaimed,
    UnloadComplete,
    UnloadBusy,
    UnloadPinned,
    UnloadRuntimePinned,
    UnloadDependedOn,
    UnloadUnknown,
    UnloadShutdown,
  };
 
  enum TerminalQuiesceState {
    QuiesceOpen,
    QuiesceInvoking,
    QuiesceComplete,
    QuiesceFailed,
  };
 
  enum ModuleShutdownState {
    ShutdownOpen,
    ShutdownRunning,
    ShutdownComplete,
    ShutdownFailed,
  };
 
  void abandonRuntimeModuleLoad(RuntimeLoad& load);
  bool retireRuntimeModule(Module* module, bool runLifecycle);
  uintptr_t runtimeExportLocked(const char* name, Module* owner = nullptr) const;
  const char* runtimeLookupSymbolLocked(uintptr_t addr, uintptr_t* startAddr) const;
  uintptr_t resolveRuntimeImport(const char* name, Module* consumer);
  bool beginModuleLoad();
  void finishModuleLoad();
  bool moduleRegisteredLocked(Module* module) const;
  static Module* findModuleByName(const Vector<Module*>& modules, const String& name);
  static bool moduleDependsOn(Module* consumer, Module* provider);
  static bool hasLiveDependent(const Vector<Module*>& modules, Module* provider);
  static Module* findUnloadCandidate(const Vector<Module*>& modules, bool& waiting);
  ModuleUnloadClaim claimModuleUnloadLocked(Module* module, bool allowShutdown,
                                            bool requireMembership, bool enforceDependencies,
                                            bool& wasFailed, bool& runLifecycle);
  bool completeUnloadAttempt(Module* module, ModuleUnloadClaim claim, bool wasFailed,
                             bool runLifecycle, bool silent, bool progress, bool terminal = false);
  void finishClaimedUnload(Module* module, bool wasFailed);
 
  template <class T>
  static T* rebase(Module* module, T* ptr) {
    EMIT_IF(STATIC_DRIVERS) {
      return ptr;
    }
 
    if (module->runtime) {
      return ptr;
    }
 
    uintptr_t value = reinterpret_cast<uintptr_t>(ptr);
 
    // Don't rebase pointers that are already rebased
    if (module->loadBase <= value && value <= (module->loadBase + module->loadSize)) {
      return ptr;
    }
 
    return adjust_pointer(ptr, module->loadBase);
  }
 
  void lockModules();
 
  void unlockModules();
 
  MemoryRegion m_AdditionalSectionContents;
  MemoryRegion* m_AdditionalSectionHeaders;
 
  static KernelElf m_Instance;
 
  Vector<Module*> m_Modules;
  MemoryAllocator m_ModuleAllocator;
  bool m_ModuleAllocatorInitialised;
  bool m_RuntimeModulesPrepared;
 
  ElfSectionHeader_t* m_pSectionHeaders;
  ElfSymbol_t* m_pSymbolTable;
 
  typedef ElfSectionHeader_t KernelElfSectionHeader_t;
  typedef ElfSymbol_t KernelElfSymbol_t;
 
  Spinlock m_ModuleAdjustmentLock;
  bool m_ModuleShutdown;
  ModuleShutdownState m_ModuleShutdownStatus;
  bool m_ModuleLoading;
  Module* m_UnloadingModule;
  size_t m_ModuleExecutions;
  size_t m_ModuleExecutionPasses;
  Module* m_TerminalQuiesceOwner;
  TerminalQuiesceHook m_TerminalQuiesceHook;
  TerminalQuiesceState m_TerminalQuiesceStatus;
 
  Module* m_InitModule;
};
 
#endif