PageFaultHandler.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_CORE_PROCESSOR_PAGEFAULTHANDLER_H_
#define KERNEL_CORE_PROCESSOR_PAGEFAULTHANDLER_H_
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/AtomicStateCleanup.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/InterruptHandler.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
 
#include <config.h>
 
class Thread;
 
class EXPORTED_PUBLIC MemoryTrapHandler {
 public:
  virtual ~MemoryTrapHandler();
 
  virtual bool trap(InterruptState& state, uintptr_t address, bool bIsWrite, bool bWasPresent) = 0;
};
 
class PageFaultHandler : private InterruptHandler {
 public:
  inline static PageFaultHandler& instance() {
    return m_Instance;
  }
 
  bool initialise();
 
  EXPORTED_PUBLIC bool registerHandler(MemoryTrapHandler* pHandler);
 
  EXPORTED_PUBLIC bool unregisterHandler(MemoryTrapHandler* pHandler);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using HandlerPinHook = void (*)(MemoryTrapHandler*);
  using HandlerPrePinHook = void (*)(MemoryTrapHandler*);
  using AtomicDrainHook = void (*)(MemoryTrapHandler*);
  using MutationLockHook = void (*)();
 
  static EXPORTED_PUBLIC void setHandlerPinHook(HandlerPinHook hook);
 
  static EXPORTED_PUBLIC void setHandlerPrePinHook(HandlerPrePinHook hook);
 
  static EXPORTED_PUBLIC void setAtomicDrainHook(AtomicDrainHook hook);
 
  EXPORTED_PUBLIC void withMutationLockForTest(MutationLockHook hook);
 
  EXPORTED_PUBLIC bool dispatchHandlerForTest(MemoryTrapHandler* pHandler);
 
  EXPORTED_PUBLIC size_t activeDispatchCountForTest(MemoryTrapHandler* pHandler);
#endif
 
  //
  // InterruptHandler interface.
  //
  virtual void interrupt(size_t interruptNumber, InterruptState& state);
 
 private:
  PageFaultHandler() INITIALISATION_ONLY;
 
  PageFaultHandler(const PageFaultHandler&);
 
  bool dispatchHandlers(InterruptState& state, uintptr_t address, bool bIsWrite, bool bWasPresent,
                        MemoryTrapHandler* pOnlyHandler = nullptr);
 
  static const size_t MaxMemoryTrapHandlers = 16;
  static const size_t MaxActiveDispatches = 64;
 
  enum class SlotMode : size_t {
    Empty = 0,
    Enabled,
    Draining,
    Deferred,
    Retiring,
  };
 
  static const size_t ModeBits = 3;
  static const size_t ModeMask = (1 << ModeBits) - 1;
  static const size_t GenerationShift = ModeBits;
 
  struct HandlerSlot;
 
  struct ActiveDispatch {
    ActiveDispatch() : token(nullptr), generation(0), owner(nullptr), slot(nullptr) {}
 
    void* token;
    size_t generation;
    void* owner;
    HandlerSlot* slot;
  };
 
  struct HandlerSlot {
    HandlerSlot() : handler(nullptr), publication(0) {}
 
    MemoryTrapHandler* handler;
    size_t publication;
  };
 
  struct DispatchCleanup {
    explicit DispatchCleanup(PageFaultHandler* registry)
        : registry(registry), activeDispatch(nullptr), cleanup() {}
 
    PageFaultHandler* registry;
    ActiveDispatch* activeDispatch;
    AtomicStateCleanupRecord cleanup;
  };
 
  static size_t makePublication(size_t generation, SlotMode mode);
  static size_t generationOf(size_t publication);
  static SlotMode modeOf(size_t publication);
 
  bool retireSlot(HandlerSlot& slot, size_t expectedPublication,
                  MemoryTrapHandler* expectedHandler);
  bool publishDispatch(HandlerSlot& slot, void* owner, DispatchCleanup& cleanup);
  void unpublishDispatch(DispatchCleanup& cleanup);
  static void abandonedHandlerCleanup(void* context);
  bool hasActiveDispatch(HandlerSlot& slot) const;
  bool findCurrentDispatch(void* owner, HandlerSlot* target, bool& callbackContext) const;
  static void* currentDispatchOwner();
 
  HandlerSlot m_Handlers[MaxMemoryTrapHandlers];
  ActiveDispatch m_ActiveDispatches[MaxActiveDispatches];
  WaitQueue m_DispatchWaiters;
  Spinlock m_HandlerLock;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static HandlerPinHook m_HandlerPinHook;
  static HandlerPrePinHook m_HandlerPrePinHook;
  static AtomicDrainHook m_AtomicDrainHook;
#endif
 
  EXPORTED_PUBLIC static PageFaultHandler m_Instance;
};
 
#endif /* KERNEL_CORE_PROCESSOR_X86_PAGEFAULTHANDLER_H_ */