kernel/machine/hosted/Timer.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_MACHINE_HOSTED_COMMON_TIMER_H
#define KERNEL_MACHINE_HOSTED_COMMON_TIMER_H
#include "pedigree/kernel/machine/IrqEventCounter.h"
#include "pedigree/kernel/machine/IrqManager.h"
#include "pedigree/kernel/machine/SchedulerTimer.h"
#include "pedigree/kernel/machine/SplitIrqHandler.h"
#include "pedigree/kernel/machine/Timer.h"
#include "pedigree/kernel/machine/TimerHandlerRegistry.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/utilities/List.h"
 
#include <config.h>
 
#include "TickSource.h"
 
class HostedTimer : public Timer, private SplitIrqHandler {
 public:
  inline static HostedTimer& instance() {
    return m_Instance;
  }
 
  //
  // Timer interface
  //
  virtual bool registerHandler(TimerHandler* handler);
  virtual bool unregisterHandler(TimerHandler* handler);
  virtual void addAlarm(class Event* pEvent, size_t alarmSecs, size_t alarmUsecs = 0);
  virtual void removeAlarm(class Event* pEvent);
  virtual size_t removeAlarm(class Event* pEvent, bool bRetZero);
  virtual size_t getYear();
  virtual uint8_t getMonth();
  virtual uint8_t getDayOfMonth();
  virtual uint8_t getDayOfWeek();
  virtual uint8_t getHour();
  virtual uint8_t getMinute();
  virtual uint8_t getSecond();
  virtual uint64_t getNanosecond();
  virtual uint64_t getTickCount();
  virtual uint64_t getTickCountNano();
 
  bool initialise1() INITIALISATION_ONLY;
  bool initialise3();
  virtual void synchronise(bool tohw = false);
  void uninitialise();
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using HandlerPinHook = TimerHandlerRegistry::HandlerPinHook;
  using HandlerPrePinHook = TimerHandlerRegistry::HandlerPrePinHook;
  using HandlerHazardClaimHook = TimerHandlerRegistry::HandlerHazardClaimHook;
  using HandlerAtomicDrainHook = TimerHandlerRegistry::HandlerAtomicDrainHook;
  using HandlerMutationLockHook = TimerHandlerRegistry::MutationLockHook;
  using AlarmSendAdmissionHook = void (*)(class Event* event);
 
  static EXPORTED_PUBLIC void setHandlerPinHook(HandlerPinHook hook);
  static EXPORTED_PUBLIC void setHandlerPrePinHook(HandlerPrePinHook hook);
  static EXPORTED_PUBLIC void setHandlerHazardClaimHook(HandlerHazardClaimHook hook);
  static EXPORTED_PUBLIC void setHandlerAtomicDrainHook(HandlerAtomicDrainHook hook);
  static EXPORTED_PUBLIC void withHandlerMutationLockForTest(HandlerMutationLockHook hook);
  static EXPORTED_PUBLIC bool dispatchHandlerForTest(TimerHandler* handler, uint64_t delta);
  static EXPORTED_PUBLIC size_t activeDispatchCountForTest(TimerHandler* handler);
  static EXPORTED_PUBLIC size_t claimedDispatchCountForTest();
  static EXPORTED_PUBLIC void setAlarmSendAdmissionHookForTest(AlarmSendAdmissionHook hook);
  static EXPORTED_PUBLIC bool alarmLockHeldForTest();
  static EXPORTED_PUBLIC bool setSignalIntervalForTest(uint64_t nanoseconds);
#endif
 
 protected:
  HostedTimer() INITIALISATION_ONLY;
  virtual ~HostedTimer();
 
 private:
  HostedTimer(const HostedTimer&);
  HostedTimer& operator=(const HostedTimer&);
 
  HardStageDisposition hardIrq(irq_id_t number, InterruptState& state, size_t& work) override;
  void threadedIrq(size_t work) override;
  bool quiesceIrqSources() override;
  void rearmIrqSources(size_t work) override;
 
  void processTimerBatch(uint64_t delta);
 
  size_t m_Year;
  uint8_t m_Month;
  uint8_t m_DayOfMonth;
  uint8_t m_DayOfWeek;
  uint8_t m_Hour;
  uint8_t m_Minute;
  uint8_t m_Second;
  uint64_t m_Nanosecond;
 
  HostedTickSource m_TickSource;
 
  irq_id_t m_IrqId;
 
  IrqEventCounter m_PendingExpirations;
 
  static HostedTimer m_Instance;
 
  TimerHandlerRegistry m_HandlerRegistry;
 
  class Alarm {
   public:
    Alarm(class Event* pEvent, size_t time, class Thread* pThread)
        : m_pEvent(pEvent), m_Time(time), m_pThread(pThread) {}
    class Event* m_pEvent;
    size_t m_Time;
    class Thread* m_pThread;
 
   private:
    Alarm(const Alarm&);
    Alarm& operator=(const Alarm&);
  };
 
  List<Alarm*> m_Alarms;
 
  Spinlock m_AlarmLock;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static AlarmSendAdmissionHook m_AlarmSendAdmissionHook;
#endif
 
  bool m_bInitialized = false;
 
  bool m_bPrepared = false;
};
 
#endif