--- /dev/null
+/*
+ * Copyright (c) 2000-2004,2011,2014 Apple Inc. All Rights Reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+
+//
+// threading - multi-threading support
+//
+// Once upon a time, this file provided a system-independent abstraction layer
+// for various thread models. These times are long gone, and we might as well
+// admit that we're sitting on top of pthreads (plus certain other system facilities).
+//
+#ifndef _H_THREADING
+#define _H_THREADING
+
+#include <security_utilities/utilities.h>
+#include <security_utilities/errors.h>
+#include <security_utilities/debugging.h>
+# include <pthread.h>
+
+#include <security_utilities/threading_internal.h>
+
+
+namespace Security {
+
+
+//
+// Potentially, debug-logging all Mutex activity can really ruin your
+// performance day. We take some measures to reduce the impact, but if
+// you really can't stomach any overhead, define THREAD_NDEBUG to turn
+// (only) thread debug-logging off. NDEBUG will turn this on automatically.
+// On the other hand, throwing out all debug code will change the ABI of
+// Mutexi in incompatible ways. Thus, we still generate the debug-style out-of-line
+// code even with THREAD_NDEBUG, so that debug-style code will work with us.
+// If you want to ditch it completely, #define THREAD_CLEAN_NDEBUG.
+//
+#if defined(NDEBUG) || defined(THREAD_CLEAN_NDEBUG)
+# if !defined(THREAD_NDEBUG)
+# define THREAD_NDEBUG
+# endif
+#endif
+
+
+//
+// An abstraction of a per-thread untyped storage slot of pointer size.
+// Do not use this in ordinary code; this is for implementing other primitives only.
+// Use a PerThreadPointer or ThreadNexus.
+//
+class ThreadStoreSlot {
+public:
+ typedef void Destructor(void *);
+ ThreadStoreSlot(Destructor *destructor = NULL);
+ ~ThreadStoreSlot();
+
+ void *get() const { return pthread_getspecific(mKey); }
+ operator void * () const { return get(); }
+ void operator = (void *value) const
+ {
+ if (int err = pthread_setspecific(mKey, value))
+ UnixError::throwMe(err);
+ }
+
+private:
+ pthread_key_t mKey;
+};
+
+
+//
+// Per-thread pointers are implemented using the pthread TLS (thread local storage)
+// facility.
+// Let's be clear on what gets destroyed when, here. Following the pthread lead,
+// when a thread dies its PerThreadPointer object(s) are properly destroyed.
+// However, if a PerThreadPointer itself is destroyed, NOTHING HAPPENS. Yes, there are
+// reasons for this. This is not (on its face) a bug, so don't yell. But be aware...
+//
+template <class T>
+class PerThreadPointer : public ThreadStoreSlot {
+public:
+ PerThreadPointer(bool cleanup = true) : ThreadStoreSlot(cleanup ? destructor : NULL) { }
+ operator bool() const { return get() != NULL; }
+ operator T * () const { return reinterpret_cast<T *>(get()); }
+ T *operator -> () const { return static_cast<T *>(*this); }
+ T &operator * () const { return *static_cast<T *>(get()); }
+ void operator = (T *t) { ThreadStoreSlot::operator = (t); }
+
+private:
+ static void destructor(void *element)
+ { delete reinterpret_cast<T *>(element); }
+};
+
+
+//
+// Pthread Synchronization primitives.
+// These have a common header, strictly for our convenience.
+//
+class LockingPrimitive {
+protected:
+ LockingPrimitive() { }
+
+ void check(int err) { if (err) UnixError::throwMe(err); }
+};
+
+
+//
+// Mutexi
+//
+class Mutex : public LockingPrimitive {
+ NOCOPY(Mutex)
+ friend class Condition;
+
+public:
+ enum Type {
+ normal,
+ recursive
+ };
+
+ Mutex(); // normal
+ Mutex(Type type); // recursive
+ ~Mutex(); // destroy (must be unlocked)
+ void lock(); // lock and wait
+ bool tryLock(); // instantaneous lock (return false if busy)
+ void unlock(); // unlock (must be locked)
+
+private:
+ pthread_mutex_t me;
+};
+
+
+class RecursiveMutex : public Mutex
+{
+public:
+ RecursiveMutex() : Mutex(recursive) {}
+ ~RecursiveMutex() {}
+};
+
+//
+// Condition variables
+//
+class Condition : public LockingPrimitive {
+ NOCOPY(Condition)
+
+public:
+ Condition(Mutex &mutex); // create with specific Mutex
+ ~Condition();
+ void wait(); // wait for signal
+ void signal(); // signal one
+ void broadcast(); // signal all
+
+ Mutex &mutex; // associated Mutex
+
+private:
+ pthread_cond_t me;
+};
+
+
+//
+// A CountingMutex adds a counter to a Mutex.
+// NOTE: This is not officially a semaphore - it's an automatically managed
+// counter married to a Mutex.
+//
+class CountingMutex : public Mutex {
+public:
+ CountingMutex() : mCount(0) { }
+ ~CountingMutex() { assert(mCount == 0); }
+
+ void enter(); // lock, add one, unlock
+ bool tryEnter(); // enter or return false
+ void exit(); // lock, subtract one, unlock
+
+ // these methods do not lock - use only while you hold the lock
+ unsigned int count() const { return mCount; }
+ bool isIdle() const { return mCount == 0; }
+
+ // convert Mutex lock to CountingMutex enter/exit. Expert use only
+ void finishEnter(); // all but the initial lock
+ void finishExit(); // all but the initial lock
+
+private:
+ unsigned int mCount; // counter level
+};
+
+
+//
+// A guaranteed-unlocker stack-based class.
+// By default, this will use lock/unlock methods, but you can provide your own
+// alternates (to, e.g., use enter/exit, or some more specialized pair of operations).
+//
+// NOTE: StLock itself is not thread-safe. It is intended for use (usually on the stack)
+// by a single thread.
+//
+template <class Lock,
+ void (Lock::*_lock)() = &Lock::lock,
+ void (Lock::*_unlock)() = &Lock::unlock>
+class StLock {
+public:
+ StLock(Lock &lck) : me(lck) { (me.*_lock)(); mActive = true; }
+ StLock(Lock &lck, bool option) : me(lck), mActive(option) { }
+ ~StLock() { if (mActive) (me.*_unlock)(); }
+
+ bool isActive() const { return mActive; }
+ void lock() { if(!mActive) { (me.*_lock)(); mActive = true; }}
+ void unlock() { if(mActive) { (me.*_unlock)(); mActive = false; }}
+ void release() { assert(mActive); mActive = false; }
+
+ operator const Lock &() const { return me; }
+
+protected:
+ Lock &me;
+ bool mActive;
+};
+
+template <class TakeLock, class ReleaseLock,
+ void (TakeLock::*_lock)() = &TakeLock::lock,
+ void (TakeLock::*_unlock)() = &TakeLock::unlock,
+ void (ReleaseLock::*_rlock)() = &ReleaseLock::lock,
+ void (ReleaseLock::*_runlock)() = &ReleaseLock::unlock>
+class StSyncLock {
+public:
+ StSyncLock(TakeLock &tlck, ReleaseLock &rlck) : taken(tlck), released(rlck) {
+ (released.*_unlock)();
+ (taken.*_lock)();
+ mActive = true;
+ }
+ StSyncLock(TakeLock &tlck, ReleaseLock &rlck, bool option) : taken(tlck), released(rlck), mActive(option) { }
+ ~StSyncLock() { if (mActive) { (taken.*_unlock)(); (released.*_rlock)(); }}
+
+ bool isActive() const { return mActive; }
+ void lock() { if(!mActive) { (released.*_runlock)(); (taken.*_lock)(); mActive = true; }}
+ void unlock() { if(mActive) { (taken.*_unlock)(); (released.*_rlock)(); mActive = false; }}
+ void release() { assert(mActive); mActive = false; }
+
+protected:
+ TakeLock &taken;
+ ReleaseLock &released;
+ bool mActive;
+};
+
+
+//
+// Atomic increment/decrement operations.
+// The default implementation uses a Mutex. However, many architectures can do
+// much better than that.
+// Be very clear on the nature of AtomicCounter. It implies no memory barriers of
+// any kind. This means that (1) you cannot protect any other memory region with it
+// (use a Mutex for that), and (2) it may not enforce cross-processor ordering, which
+// means that you have no guarantee that you'll see modifications by other processors
+// made earlier (unless another mechanism provides the memory barrier).
+// On the other hand, if your compiler has brains, this is blindingly fast...
+//
+template <class Integer = uint32_t>
+class StaticAtomicCounter {
+protected:
+ Integer mValue;
+
+public:
+ operator Integer() const { return mValue; }
+
+ // infix versions (primary)
+ Integer operator ++ () { return Atomic<Integer>::increment(mValue); }
+ Integer operator -- () { return Atomic<Integer>::decrement(mValue); }
+
+ // postfix versions
+ Integer operator ++ (int) { return Atomic<Integer>::increment(mValue) - 1; }
+ Integer operator -- (int) { return Atomic<Integer>::decrement(mValue) + 1; }
+
+ // generic offset
+ Integer operator += (int delta) { return Atomic<Integer>::add(delta, mValue); }
+};
+
+
+template <class Integer = int>
+class AtomicCounter : public StaticAtomicCounter<Integer> {
+public:
+ AtomicCounter(Integer init = 0) { StaticAtomicCounter<Integer>::mValue = init; }
+};
+
+
+//
+// A class implementing a separate thread of execution.
+// Do not expect many high-level semantics to be portable. If you can,
+// restrict yourself to expect parallel execution and little else.
+//
+class Thread {
+ NOCOPY(Thread)
+public:
+ class Identity {
+ friend class Thread;
+
+ Identity(pthread_t id) : mIdent(id) { }
+ public:
+ Identity() { }
+
+ static Identity current() { return pthread_self(); }
+
+ bool operator == (const Identity &other) const
+ { return pthread_equal(mIdent, other.mIdent); }
+
+ bool operator != (const Identity &other) const
+ { return !(*this == other); }
+
+ private:
+ pthread_t mIdent;
+ };
+
+public:
+ Thread() { } // constructor
+ virtual ~Thread(); // virtual destructor
+ void run(); // begin running the thread
+
+public:
+ static void yield(); // unstructured short-term processor yield
+
+protected:
+ virtual void action() = 0; // the action to be performed
+
+private:
+ Identity self; // my own identity (instance constant)
+
+ static void *runner(void *); // argument to pthread_create
+};
+
+
+//
+// A "just run this function in a thread" variant of Thread
+//
+class ThreadRunner : public Thread {
+ typedef void Action();
+public:
+ ThreadRunner(Action *todo);
+
+private:
+ void action();
+ Action *mAction;
+};
+
+
+} // end namespace Security
+
+#endif //_H_THREADING
projects / apple / security.git / blobdiff