From mboxrd@z Thu Jan 1 00:00:00 1970 X-Msuck: nntp://news.gmane.org/gmane.linux.lib.musl.general/6026 Path: news.gmane.org!not-for-mail From: Jens Gustedt Newsgroups: gmane.linux.lib.musl.general Subject: [PATCH 5/9] add the functions for mtx_t Date: Mon, 01 Sep 2014 00:46:57 +0200 Message-ID: <0f3acdbceb88a357600611d64f7b5ed13ab3eced.1409524413.git.Jens.Gustedt@inria.fr> References: Reply-To: musl@lists.openwall.com NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Transfer-Encoding: 7bit X-Trace: ger.gmane.org 1409525230 19444 80.91.229.3 (31 Aug 2014 22:47:10 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Sun, 31 Aug 2014 22:47:10 +0000 (UTC) To: musl@lists.openwall.com Original-X-From: musl-return-6033-gllmg-musl=m.gmane.org@lists.openwall.com Mon Sep 01 00:47:00 2014 Return-path: Envelope-to: gllmg-musl@plane.gmane.org Original-Received: from mother.openwall.net ([195.42.179.200]) by plane.gmane.org with smtp (Exim 4.69) (envelope-from ) id 1XODtk-0005F1-7s for gllmg-musl@plane.gmane.org; Mon, 01 Sep 2014 00:47:00 +0200 Original-Received: (qmail 13615 invoked by uid 550); 31 Aug 2014 22:46:59 -0000 Mailing-List: contact musl-help@lists.openwall.com; run by ezmlm Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: Original-Received: (qmail 13605 invoked from network); 31 Aug 2014 22:46:59 -0000 X-IronPort-AV: E=Sophos;i="5.04,438,1406584800"; d="scan'208";a="92390679" In-Reply-To: Resent-From: Jens Gustedt Resent-To: musl@lists.openwall.com X-Mailer: Evolution 3.4.4-3 Xref: news.gmane.org gmane.linux.lib.musl.general:6026 Archived-At: This is straightforward encapsulation of the corresponding pthread_mutex_t functions. --- src/thread/mtx_destroy.c | 5 +++++ src/thread/mtx_init.c | 10 ++++++++++ src/thread/mtx_lock.c | 13 +++++++++++++ src/thread/mtx_timedlock.c | 18 ++++++++++++++++++ src/thread/mtx_trylock.c | 21 +++++++++++++++++++++ src/thread/mtx_unlock.c | 9 +++++++++ 6 files changed, 76 insertions(+) create mode 100644 src/thread/mtx_destroy.c create mode 100644 src/thread/mtx_init.c create mode 100644 src/thread/mtx_lock.c create mode 100644 src/thread/mtx_timedlock.c create mode 100644 src/thread/mtx_trylock.c create mode 100644 src/thread/mtx_unlock.c diff --git a/src/thread/mtx_destroy.c b/src/thread/mtx_destroy.c new file mode 100644 index 0000000..8d593dc --- /dev/null +++ b/src/thread/mtx_destroy.c @@ -0,0 +1,5 @@ +#include + +void mtx_destroy(mtx_t *mtx) { + /* empty */ +} diff --git a/src/thread/mtx_init.c b/src/thread/mtx_init.c new file mode 100644 index 0000000..a197898 --- /dev/null +++ b/src/thread/mtx_init.c @@ -0,0 +1,10 @@ +#include "pthread_impl.h" +#include + +int mtx_init(mtx_t * m, int type) +{ + *m = (mtx_t) { + ._m_type = ((type&mtx_recursive) ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL), + }; + return thrd_success; +} diff --git a/src/thread/mtx_lock.c b/src/thread/mtx_lock.c new file mode 100644 index 0000000..4d5d75e --- /dev/null +++ b/src/thread/mtx_lock.c @@ -0,0 +1,13 @@ +#include "pthread_impl.h" +#include + +int mtx_lock(mtx_t *m) +{ + if (m->_m_type == PTHREAD_MUTEX_NORMAL && !a_cas(&m->_m_lock, 0, EBUSY)) + return thrd_success; + /* Calling mtx_timedlock with a null pointer is an + extension. Such a call is convenient, here, since it avoids + to repeat the case analysis that is already done for + mtx_timedlock. */ + return mtx_timedlock(m, 0); +} diff --git a/src/thread/mtx_timedlock.c b/src/thread/mtx_timedlock.c new file mode 100644 index 0000000..08359d8 --- /dev/null +++ b/src/thread/mtx_timedlock.c @@ -0,0 +1,18 @@ +#include +#include + +int __pthread_mutex_timedlock(mtx_t *restrict m, const struct timespec *restrict ts); + +int mtx_timedlock(mtx_t *restrict mutex, const struct timespec *restrict ts) { + int ret = __pthread_mutex_timedlock(mutex, ts); + switch (ret) { + /* May also return EINVAL or EAGAIN. EAGAIN is + specially tricky since C11 doesn't define how many recursive + calls can be done. (this *isn't* the maximum amount of nested + calls!) This implementation here deals this with a counter and + detects overflow, so this is definitively UB. */ + default: return thrd_error; + case 0: return thrd_success; + case ETIMEDOUT: return thrd_timedout; + } +} diff --git a/src/thread/mtx_trylock.c b/src/thread/mtx_trylock.c new file mode 100644 index 0000000..4f55796 --- /dev/null +++ b/src/thread/mtx_trylock.c @@ -0,0 +1,21 @@ +#include "pthread_impl.h" +#include + +int __pthread_mutex_trylock(pthread_mutex_t *restrict m); + +int mtx_trylock(mtx_t *restrict m) { + if (m->_m_type == PTHREAD_MUTEX_NORMAL) + return (a_cas(&m->_m_lock, 0, EBUSY) & EBUSY) ? thrd_busy : thrd_success; + + int ret = __pthread_mutex_trylock(m); + switch (ret) { + /* In case of UB may also return EINVAL or EAGAIN. EAGAIN is + specially tricky since C11 doesn't define how many recursive + calls can be done. (this *isn't* the maximum amount of nested + calls!) This implementation here deals this with a counter and + detects overflow, so this is definitively UB. */ + default: return thrd_error; + case 0: return thrd_success; + case EBUSY: return thrd_busy; + } +} diff --git a/src/thread/mtx_unlock.c b/src/thread/mtx_unlock.c new file mode 100644 index 0000000..e673cd5 --- /dev/null +++ b/src/thread/mtx_unlock.c @@ -0,0 +1,9 @@ +#include + +int __pthread_mutex_unlock(mtx_t *); + +int (mtx_unlock)(mtx_t *mtx) { + int ret = __pthread_mutex_unlock(mtx); + /* In case of UB may also return EPERM. */ + return ret ? thrd_error : thrd_success; +} -- 1.7.10.4