Event.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 EVENT_H
#define EVENT_H
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/new"
 
#include <config.h>
 
class Thread;
 
#define EVENT_LIMIT 4096
#define EVENT_TID_MAX 255
#define MAX_NESTED_EVENTS 16
 
#define EVENT_MAGIC 0x8899AABBCCDDEEFFULL
 
class EXPORTED_PUBLIC Event {
 public:
  enum class HandlerPrivilege {
    Kernel,
    User,
  };
 
  enum class UserReturnDelivery {
    NotApplicable,
    Delivered,
    Failed,
  };
 
  class SendLease {
   public:
    SendLease();
    SendLease(SendLease&& other) noexcept;
    ~SendLease();
 
    SendLease& operator=(SendLease&& other) noexcept;
 
    explicit operator bool() const {
      return m_pEvent != nullptr;
    }
 
   private:
    friend class Event;
    friend class Thread;
 
    explicit SendLease(Event* event);
    void reset();
 
    SendLease(const SendLease&) = delete;
    SendLease& operator=(const SendLease&) = delete;
 
    Event* m_pEvent;
  };
 
  class Retirement {
   public:
    Retirement();
    Retirement(Retirement&& other) noexcept;
    ~Retirement();
 
    Retirement& operator=(Retirement&& other) noexcept;
 
   private:
    friend class Event;
 
    explicit Retirement(Event* event);
    void reset();
 
    Retirement(const Retirement&) = delete;
    Retirement& operator=(const Retirement&) = delete;
 
    Event* m_pEvent;
  };
 
  class Delivery {
   public:
    Delivery();
    Delivery(Delivery&& other) noexcept;
    ~Delivery();
 
    Delivery& operator=(Delivery&& other) noexcept;
 
    Event* get() const {
      return m_pEvent;
    }
 
    Event* operator->() const {
      return m_pEvent;
    }
 
    explicit operator bool() const {
      return m_pEvent != nullptr;
    }
 
    void reset();
 
   private:
    friend class Event;
    friend class Thread;
    friend class PerProcessorScheduler;
 
    Delivery(Event* event, Thread* thread);
    void beginDispatch();
 
    Delivery(const Delivery&) = delete;
    Delivery& operator=(const Delivery&) = delete;
 
    Event* m_pEvent;
    Thread* m_pThread;
    Delivery* m_pPreviousActive;
    Delivery* m_pNextActive;
    bool m_bActive;
  };
 
  Event(uintptr_t handlerAddress, bool isDeletable, size_t specificNestingLevel = ~0UL,
        HandlerPrivilege handlerPrivilege = HandlerPrivilege::Kernel);
  virtual ~Event();
 
  static uintptr_t getTrampoline();
 
  static uintptr_t getSecondaryTrampoline();
 
  static uintptr_t getHandlerBuffer();
 
  static size_t getHandlerBufferSize();
 
  static uintptr_t getLastHandlerBuffer();
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static constexpr size_t getHostedHandlerBufferSize(size_t pageSize) {
    return pageSize ? handlerBufferSize(pageSize) : 0;
  }
#endif
 
  virtual bool isDeletable();
 
  virtual size_t serialize(uint8_t* pBuffer) = 0;
 
  static bool unserialize(uint8_t* pBuffer, Event& event);
 
  static size_t getEventType(uint8_t* pBuffer);
 
  uintptr_t getHandlerAddress() {
    return m_HandlerAddress;
  }
 
  HandlerPrivilege getHandlerPrivilege() const {
    return m_HandlerPrivilege;
  }
 
  bool isValidHandlerMapping(size_t mappingFlags) const;
 
  virtual bool isSignalEvent() const {
    return false;
  }
 
  virtual bool prefersAlternateUserStack() const {
    return false;
  }
 
  virtual bool requiresExactUserReturnState() const {
    return false;
  }
 
  virtual UserReturnDelivery deliverAtUserReturn(InterruptState&) {
    return UserReturnDelivery::NotApplicable;
  }
 
  virtual UserReturnDelivery deliverAtUserReturn(SyscallState&) {
    return UserReturnDelivery::NotApplicable;
  }
 
  virtual bool isDeliverableWhileProcessSuspended() const {
    return true;
  }
 
  virtual Event* cloneForDelivery() {
    return this;
  }
 
  size_t getSpecificNestingLevel() {
    return m_NestingLevel;
  }
 
  virtual size_t getNumber() = 0;
 
  Event(const Event& other);
  Event& operator=(const Event& other);
 
  size_t pendingCount();
 
  bool tryAcquireRegistration(SendLease& registration);
 
  virtual void waitForDeliveries();
 
  void retire();
 
  void beginRetirement(Retirement& retirement);
 
 protected:
  uintptr_t m_HandlerAddress;
 
  HandlerPrivilege m_HandlerPrivilege;
 
  bool m_bIsDeletable;
 
  size_t m_NestingLevel;
 
  uint64_t m_Magic;
 
  List<Thread*> m_Threads;
 
  Spinlock m_Lock;
 
 private:
  friend class Thread;
 
  static constexpr size_t handlerBufferSize(size_t pageSize) {
    const size_t pageCount = (EVENT_LIMIT / pageSize) + ((EVENT_LIMIT % pageSize) ? 1 : 0);
    return pageCount * pageSize;
  }
 
  SendLease beginSend();
  void endSend();
  void finishRetirement();
 
  bool registerThread(Thread* thread);
 
  void deregisterThread(Thread* thread);
 
  void completeDelivery(Thread* thread);
 
  void beginDispatch(Delivery* delivery);
  void endDispatch(Delivery* delivery);
 
  bool m_DeleteWhenUnused;
 
  bool m_DeliveriesClosed;
 
  bool m_DrainClaimed;
 
  size_t m_SendersInFlight;
 
  Delivery* m_pFirstActiveDelivery;
 
  WaitQueue m_DeliveryWaiters;
};
 
#endif