LockGuard.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_LOCKGUARD_H
#define KERNEL_LOCKGUARD_H
#include "pedigree/kernel/compiler.h"
 
#include <config.h>
 
#if THREADS && !defined(STANDALONE_MUTEXES)
#include "pedigree/kernel/process/TerminationDeferral.h"
#endif
 
class Spinlock;
class Mutex;
class Semaphore;
 
template <class T, bool Condition>
class EXPORTED_PUBLIC ConstexprLockGuard {
 public:
  ConstexprLockGuard(T& Lock) : m_Lock(Lock) {
    if constexpr (Condition)
      m_Lock.acquire();
  }
  ~ConstexprLockGuard() {
    if (Condition)
      m_Lock.release();
  }
 
 private:
  ConstexprLockGuard() = delete;
  NOT_COPYABLE_OR_ASSIGNABLE(ConstexprLockGuard);
 
  T& m_Lock;
};
 
template <class T>
class EXPORTED_PUBLIC LockGuard {
 public:
  LockGuard(T& Lock, bool Condition = true) : m_Lock(Lock), m_bCondition(Condition) {
    if (m_bCondition)
      m_Lock.acquire();
  }
  ~LockGuard() {
    if (m_bCondition)
      m_Lock.release();
  }
 
  void disown() {
    m_bCondition = false;
  }
 
  bool ownsLock() const {
    return m_bCondition;
  }
 
 private:
  LockGuard() = delete;
  NOT_COPYABLE_OR_ASSIGNABLE(LockGuard);
 
  T& m_Lock;
  bool m_bCondition;
};
 
#if THREADS && !defined(STANDALONE_MUTEXES)
template <>
class EXPORTED_PUBLIC LockGuard<Mutex> {
 public:
  explicit LockGuard(Mutex& Lock, bool Condition = true);
  ~LockGuard();
 
  void disown();
 
  bool ownsLock() const {
    return m_bCondition;
  }
 
 private:
  LockGuard() = delete;
  NOT_COPYABLE_OR_ASSIGNABLE(LockGuard);
 
  TerminationDeferral m_TerminationDeferral;
  Mutex& m_Lock;
  bool m_bCondition;
};
 
template <>
class EXPORTED_PUBLIC ConstexprLockGuard<Mutex, true> {
 public:
  explicit ConstexprLockGuard(Mutex& Lock) : m_Guard(Lock) {}
 
 private:
  ConstexprLockGuard() = delete;
  NOT_COPYABLE_OR_ASSIGNABLE(ConstexprLockGuard);
 
  LockGuard<Mutex> m_Guard;
};
 
template <>
class LockGuard<Semaphore> {
 public:
  LockGuard(Semaphore&, bool = true) = delete;
};
#endif
 
template <class T>
class EXPORTED_PUBLIC RecursingLockGuard {
 public:
  RecursingLockGuard(T& Lock, bool Condition = true) : m_Lock(Lock), m_bCondition(Condition) {
    // T::allow_recursion must exist to be able to use RecursingLockGuard.
    if (m_bCondition)
      m_Lock.acquire(T::allow_recursion);
  }
  ~RecursingLockGuard() {
    if (m_bCondition)
      m_Lock.release();
  }
 
 private:
  RecursingLockGuard() = delete;
  NOT_COPYABLE_OR_ASSIGNABLE(RecursingLockGuard);
 
  T& m_Lock;
  bool m_bCondition;
};
 
extern template class LockGuard<Spinlock>;
extern template class RecursingLockGuard<Spinlock>;
 
#endif