aboutsummaryrefslogtreecommitdiff
path: root/linuxthreads/mutex.c
diff options
context:
space:
mode:
Diffstat (limited to 'linuxthreads/mutex.c')
-rw-r--r--linuxthreads/mutex.c234
1 files changed, 234 insertions, 0 deletions
diff --git a/linuxthreads/mutex.c b/linuxthreads/mutex.c
new file mode 100644
index 0000000000..d4ebcb827a
--- /dev/null
+++ b/linuxthreads/mutex.c
@@ -0,0 +1,234 @@
+/* Linuxthreads - a simple clone()-based implementation of Posix */
+/* threads for Linux. */
+/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
+/* */
+/* This program is free software; you can redistribute it and/or */
+/* modify it under the terms of the GNU Library General Public License */
+/* as published by the Free Software Foundation; either version 2 */
+/* of the License, or (at your option) any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
+/* GNU Library General Public License for more details. */
+
+/* Mutexes */
+
+#include <errno.h>
+#include <sched.h>
+#include <stddef.h>
+#include "pthread.h"
+#include "internals.h"
+#include "spinlock.h"
+#include "queue.h"
+#include "restart.h"
+
+int __pthread_mutex_init(pthread_mutex_t * mutex,
+ const pthread_mutexattr_t * mutex_attr)
+{
+ mutex->m_spinlock = 0;
+ mutex->m_count = 0;
+ mutex->m_owner = NULL;
+ mutex->m_kind =
+ mutex_attr == NULL ? PTHREAD_MUTEX_FAST_NP : mutex_attr->mutexkind;
+ queue_init(&mutex->m_waiting);
+ return 0;
+}
+weak_alias (__pthread_mutex_init, pthread_mutex_init)
+
+int __pthread_mutex_destroy(pthread_mutex_t * mutex)
+{
+ int count;
+ acquire(&mutex->m_spinlock);
+ count = mutex->m_count;
+ release(&mutex->m_spinlock);
+ if (count > 0) return EBUSY;
+ return 0;
+}
+weak_alias (__pthread_mutex_destroy, pthread_mutex_destroy)
+
+int __pthread_mutex_trylock(pthread_mutex_t * mutex)
+{
+ pthread_descr self;
+
+ acquire(&mutex->m_spinlock);
+ switch(mutex->m_kind) {
+ case PTHREAD_MUTEX_FAST_NP:
+ if (mutex->m_count == 0) {
+ mutex->m_count = 1;
+ release(&mutex->m_spinlock);
+ return 0;
+ }
+ break;
+ case PTHREAD_MUTEX_RECURSIVE_NP:
+ self = thread_self();
+ if (mutex->m_count == 0 || mutex->m_owner == self) {
+ mutex->m_count++;
+ mutex->m_owner = self;
+ release(&mutex->m_spinlock);
+ return 0;
+ }
+ break;
+ case PTHREAD_MUTEX_ERRORCHECK_NP:
+ self = thread_self();
+ if (mutex->m_count == 0) {
+ mutex->m_count = 1;
+ mutex->m_owner = self;
+ release(&mutex->m_spinlock);
+ return 0;
+ }
+ break;
+ default:
+ release(&mutex->m_spinlock);
+ return EINVAL;
+ }
+ release(&mutex->m_spinlock);
+ return EBUSY;
+}
+weak_alias (__pthread_mutex_trylock, pthread_mutex_trylock)
+
+int __pthread_mutex_lock(pthread_mutex_t * mutex)
+{
+ pthread_descr self;
+
+ while(1) {
+ acquire(&mutex->m_spinlock);
+ switch(mutex->m_kind) {
+ case PTHREAD_MUTEX_FAST_NP:
+ if (mutex->m_count == 0) {
+ mutex->m_count = 1;
+ release(&mutex->m_spinlock);
+ return 0;
+ }
+ self = thread_self();
+ break;
+ case PTHREAD_MUTEX_RECURSIVE_NP:
+ self = thread_self();
+ if (mutex->m_count == 0 || mutex->m_owner == self) {
+ mutex->m_count++;
+ mutex->m_owner = self;
+ release(&mutex->m_spinlock);
+ return 0;
+ }
+ break;
+ case PTHREAD_MUTEX_ERRORCHECK_NP:
+ self = thread_self();
+ if (mutex->m_count == 0) {
+ mutex->m_count = 1;
+ mutex->m_owner = self;
+ release(&mutex->m_spinlock);
+ return 0;
+ } else if (mutex->m_owner == self) {
+ release(&mutex->m_spinlock);
+ return EDEADLK;
+ }
+ break;
+ default:
+ release(&mutex->m_spinlock);
+ return EINVAL;
+ }
+ /* Suspend ourselves, then try again */
+ enqueue(&mutex->m_waiting, self);
+ release(&mutex->m_spinlock);
+ suspend(self); /* This is not a cancellation point */
+ }
+}
+weak_alias (__pthread_mutex_lock, pthread_mutex_lock)
+
+int __pthread_mutex_unlock(pthread_mutex_t * mutex)
+{
+ pthread_descr th;
+
+ acquire(&mutex->m_spinlock);
+ switch (mutex->m_kind) {
+ case PTHREAD_MUTEX_FAST_NP:
+ mutex->m_count = 0;
+ break;
+ case PTHREAD_MUTEX_RECURSIVE_NP:
+ mutex->m_count--;
+ if (mutex->m_count > 0) {
+ release(&mutex->m_spinlock);
+ return 0;
+ }
+ mutex->m_count = 0; /* so that excess unlocks do not break everything */
+ break;
+ case PTHREAD_MUTEX_ERRORCHECK_NP:
+ if (mutex->m_count == 0 || mutex->m_owner != thread_self()) {
+ release(&mutex->m_spinlock);
+ return EPERM;
+ }
+ mutex->m_count = 0;
+ break;
+ default:
+ release(&mutex->m_spinlock);
+ return EINVAL;
+ }
+ th = dequeue(&mutex->m_waiting);
+ release(&mutex->m_spinlock);
+ if (th != NULL) restart(th);
+ return 0;
+}
+weak_alias (__pthread_mutex_unlock, pthread_mutex_unlock)
+
+int __pthread_mutexattr_init(pthread_mutexattr_t *attr)
+{
+ attr->mutexkind = PTHREAD_MUTEX_FAST_NP;
+ return 0;
+}
+weak_alias (__pthread_mutexattr_init, pthread_mutexattr_init)
+
+int __pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
+{
+ return 0;
+}
+weak_alias (__pthread_mutexattr_destroy, pthread_mutexattr_destroy)
+
+int __pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind)
+{
+ if (kind != PTHREAD_MUTEX_FAST_NP
+ && kind != PTHREAD_MUTEX_RECURSIVE_NP
+ && kind != PTHREAD_MUTEX_ERRORCHECK_NP)
+ return EINVAL;
+ attr->mutexkind = kind;
+ return 0;
+}
+weak_alias (__pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np)
+
+int __pthread_mutexattr_getkind_np(const pthread_mutexattr_t *attr, int *kind)
+{
+ *kind = attr->mutexkind;
+ return 0;
+}
+weak_alias (__pthread_mutexattr_getkind_np, pthread_mutexattr_getkind_np)
+
+/* Once-only execution */
+
+static pthread_mutex_t once_masterlock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t once_finished = PTHREAD_COND_INITIALIZER;
+
+enum { NEVER = 0, IN_PROGRESS = 1, DONE = 2 };
+
+int __pthread_once(pthread_once_t * once_control, void (*init_routine)(void))
+{
+ /* Test without locking first for speed */
+ if (*once_control == DONE) return 0;
+ /* Lock and test again */
+ pthread_mutex_lock(&once_masterlock);
+ /* If init_routine is being called from another routine, wait until
+ it completes. */
+ while (*once_control == IN_PROGRESS) {
+ pthread_cond_wait(&once_finished, &once_masterlock);
+ }
+ /* Here *once_control is stable and either NEVER or DONE. */
+ if (*once_control == NEVER) {
+ *once_control = IN_PROGRESS;
+ pthread_mutex_unlock(&once_masterlock);
+ init_routine();
+ pthread_mutex_lock(&once_masterlock);
+ *once_control = DONE;
+ pthread_cond_broadcast(&once_finished);
+ }
+ pthread_mutex_unlock(&once_masterlock);
+ return 0;
+}
+weak_alias (__pthread_once, pthread_once)
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-06 19:20:33 +0000