am 8e1ee7fd: merge from open-source master
diff --git a/libc/Android.mk b/libc/Android.mk
index 590afbe..0271f10 100644
--- a/libc/Android.mk
+++ b/libc/Android.mk
@@ -322,6 +322,7 @@
# up any thumb code.
libc_common_src_files += \
bionic/pthread.c.arm \
+ bionic/pthread-rwlocks.c.arm \
bionic/pthread-timers.c.arm \
bionic/ptrace.c.arm
@@ -356,6 +357,7 @@
arch-x86/string/strncmp_wrapper.S \
arch-x86/string/strlen.S \
bionic/pthread.c \
+ bionic/pthread-rwlocks.c \
bionic/pthread-timers.c \
bionic/ptrace.c
@@ -393,6 +395,7 @@
string/strlen.c \
bionic/eabi.c \
bionic/pthread.c \
+ bionic/pthread-rwlocks.c \
bionic/pthread-timers.c \
bionic/ptrace.c \
unistd/socketcalls.c
diff --git a/libc/arch-arm/bionic/_setjmp.S b/libc/arch-arm/bionic/_setjmp.S
index 6a27af2..5626219 100644
--- a/libc/arch-arm/bionic/_setjmp.S
+++ b/libc/arch-arm/bionic/_setjmp.S
@@ -3,6 +3,7 @@
/*
* Copyright (c) 1997 Mark Brinicombe
+ * Copyright (c) 2010 Android Open Source Project.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -35,6 +36,7 @@
#include <machine/asm.h>
#include <machine/setjmp.h>
+#include <machine/cpu-features.h>
/*
* C library -- _setjmp, _longjmp
@@ -51,18 +53,20 @@
ENTRY(_setjmp)
ldr r1, .L_setjmp_magic
- str r1, [r0], #4
-#ifdef SOFTFLOAT
- add r0, r0, #52
-#else
- /* Store fp registers */
- sfm f4, 4, [r0], #48
- /* Store fpsr */
- rfs r1
- str r1, [r0], #0x0004
-#endif /* SOFTFLOAT */
- /* Store integer registers */
- stmia r0, {r4-r14}
+ str r1, [r0, #(_JB_MAGIC * 4)]
+
+ /* Store core registers */
+ add r1, r0, #(_JB_CORE_BASE * 4)
+ stmia r1, {r4-r14}
+
+#ifdef __ARM_HAVE_VFP
+ /* Store floating-point registers */
+ add r1, r0, #(_JB_FLOAT_BASE * 4)
+ vstmia r1, {d8-d15}
+ /* Store floating-point state */
+ fmrx r1, fpscr
+ str r1, [r0, #(_JB_FLOAT_STATE * 4)]
+#endif /* __ARM_HAVE_VFP */
mov r0, #0x00000000
bx lr
@@ -72,21 +76,22 @@
ENTRY(_longjmp)
ldr r2, .L_setjmp_magic
- ldr r3, [r0], #4
+ ldr r3, [r0, #(_JB_MAGIC * 4)]
teq r2, r3
bne botch
-#ifdef SOFTFLOAT
- add r0, r0, #52
-#else
- /* Restore fp registers */
- lfm f4, 4, [r0], #48
- /* Restore fpsr */
- ldr r4, [r0], #0x0004
- wfs r4
-#endif /* SOFTFLOAT */
- /* Restore integer registers */
- ldmia r0, {r4-r14}
+#ifdef __ARM_HAVE_VFP
+ /* Restore floating-point registers */
+ add r2, r0, #(_JB_FLOAT_BASE * 4)
+ vldmia r2, {d8-d15}
+ /* Restore floating-point state */
+ ldr r2, [r0, #(_JB_FLOAT_STATE * 4)]
+ fmxr fpscr, r2
+#endif /* __ARM_HAVE_VFP */
+
+ /* Restore core registers */
+ add r2, r0, #(_JB_CORE_BASE * 4)
+ ldmia r2, {r4-r14}
/* Validate sp and r14 */
teq sp, #0
diff --git a/libc/arch-arm/bionic/setjmp.S b/libc/arch-arm/bionic/setjmp.S
index a9f6ea4..59aff66 100644
--- a/libc/arch-arm/bionic/setjmp.S
+++ b/libc/arch-arm/bionic/setjmp.S
@@ -3,6 +3,7 @@
/*
* Copyright (c) 1997 Mark Brinicombe
+ * Copyright (c) 2010 Android Open Source Project.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -35,6 +36,7 @@
#include <machine/asm.h>
#include <machine/setjmp.h>
+#include <machine/cpu-features.h>
/*
* C library -- setjmp, longjmp
@@ -57,24 +59,26 @@
ldmfd sp!, {r0, r14}
/* Store signal mask */
- str r1, [r0, #(25 * 4)]
+ str r1, [r0, #(_JB_SIGMASK * 4)]
ldr r1, .Lsetjmp_magic
- str r1, [r0], #4
+ str r1, [r0, #(_JB_MAGIC * 4)]
-#ifdef SOFTFLOAT
- add r0, r0, #52
-#else
- /* Store fp registers */
- sfm f4, 4, [r0], #48
- /* Store fpsr */
- rfs r1
- str r1, [r0], #0x0004
-#endif /*SOFTFLOAT*/
- /* Store integer registers */
- stmia r0, {r4-r14}
- mov r0, #0x00000000
- bx lr
+ /* Store core registers */
+ add r1, r0, #(_JB_CORE_BASE * 4)
+ stmia r1, {r4-r14}
+
+#ifdef __ARM_HAVE_VFP
+ /* Store floating-point registers */
+ add r1, r0, #(_JB_FLOAT_BASE * 4)
+ vstmia r1, {d8-d15}
+ /* Store floating-point state */
+ fmrx r1, fpscr
+ str r1, [r0, #(_JB_FLOAT_STATE * 4)]
+#endif /* __ARM_HAVE_VFP */
+
+ mov r0, #0x00000000
+ bx lr
.Lsetjmp_magic:
.word _JB_MAGIC_SETJMP
@@ -82,12 +86,12 @@
ENTRY(longjmp)
ldr r2, .Lsetjmp_magic
- ldr r3, [r0]
+ ldr r3, [r0, #(_JB_MAGIC * 4)]
teq r2, r3
bne botch
/* Fetch signal mask */
- ldr r2, [r0, #(25 * 4)]
+ ldr r2, [r0, #(_JB_SIGMASK * 4)]
/* Set signal mask */
stmfd sp!, {r0, r1, r14}
@@ -99,18 +103,18 @@
add sp, sp, #4 /* unalign the stack */
ldmfd sp!, {r0, r1, r14}
- add r0, r0, #4
-#ifdef SOFTFLOAT
- add r0, r0, #52
-#else
- /* Restore fp registers */
- lfm f4, 4, [r0], #48
- /* Restore FPSR */
- ldr r4, [r0], #0x0004
- wfs r4
-#endif /* SOFTFLOAT */
- /* Restore integer registers */
- ldmia r0, {r4-r14}
+#ifdef __ARM_HAVE_VFP
+ /* Restore floating-point registers */
+ add r2, r0, #(_JB_FLOAT_BASE * 4)
+ vldmia r2, {d8-d15}
+ /* Restore floating-point state */
+ ldr r2, [r0, #(_JB_FLOAT_STATE * 4)]
+ fmxr fpscr, r2
+#endif /* __ARM_HAVE_VFP */
+
+ /* Restore core registers */
+ add r2, r0, #(_JB_CORE_BASE * 4)
+ ldmia r2, {r4-r14}
/* Validate sp and r14 */
teq sp, #0
diff --git a/libc/arch-arm/include/machine/cpu-features.h b/libc/arch-arm/include/machine/cpu-features.h
index ecf6ff6..abf226a 100644
--- a/libc/arch-arm/include/machine/cpu-features.h
+++ b/libc/arch-arm/include/machine/cpu-features.h
@@ -156,6 +156,19 @@
# define _ARM_HAVE_LDREX_STREX
#endif
+/* define _ARM_HAVE_VFP if we have VFPv3
+ */
+#if __ARM_ARCH__ >= 7 && defined __VFP_FP__
+# define __ARM_HAVE_VFP
+#endif
+
+/* define _ARM_HAVE_NEON for ARMv7 architecture if we support the
+ * Neon SIMD instruction set extensions. This also implies
+ * that VFPv3-D32 is supported.
+ */
+#if __ARM_ARCH__ >= 7 && defined __ARM_NEON__
+# define __ARM_HAVE_NEON
+#endif
/* Assembly-only macros */
diff --git a/libc/arch-arm/include/machine/setjmp.h b/libc/arch-arm/include/machine/setjmp.h
index f20cab2..0941202 100644
--- a/libc/arch-arm/include/machine/setjmp.h
+++ b/libc/arch-arm/include/machine/setjmp.h
@@ -1,87 +1,82 @@
-/* $OpenBSD: setjmp.h,v 1.1 2004/02/01 05:09:49 drahn Exp $ */
-/* $NetBSD: setjmp.h,v 1.2 2001/08/25 14:45:59 bjh21 Exp $ */
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
/*
* machine/setjmp.h: machine dependent setjmp-related information.
*/
-#ifdef __ELF__
-#define _JBLEN 64 /* size, in longs, of a jmp_buf */
-#else
-#define _JBLEN 29 /* size, in longs, of a jmp_buf */
-#endif
-
-/*
- * NOTE: The internal structure of a jmp_buf is *PRIVATE*
- * This information is provided as there is software
- * that fiddles with this with obtain the stack pointer
- * (yes really ! and its commercial !).
+/* _JBLEN is the size of a jmp_buf in longs.
+ * Do not modify this value or you will break the ABI !
*
- * Description of the setjmp buffer
- *
- * word 0 magic number (dependant on creator)
- * 1 - 3 f4 fp register 4
- * 4 - 6 f5 fp register 5
- * 7 - 9 f6 fp register 6
- * 10 - 12 f7 fp register 7
- * 13 fpsr fp status register
- * 14 r4 register 4
- * 15 r5 register 5
- * 16 r6 register 6
- * 17 r7 register 7
- * 18 r8 register 8
- * 19 r9 register 9
- * 20 r10 register 10 (sl)
- * 21 r11 register 11 (fp)
- * 22 r12 register 12 (ip)
- * 23 r13 register 13 (sp)
- * 24 r14 register 14 (lr)
- * 25 signal mask (dependant on magic)
- * 26 (con't)
- * 27 (con't)
- * 28 (con't)
- *
- * The magic number number identifies the jmp_buf and
- * how the buffer was created as well as providing
- * a sanity check
- *
- * A side note I should mention - Please do not tamper
- * with the floating point fields. While they are
- * always saved and restored at the moment this cannot
- * be garenteed especially if the compiler happens
- * to be generating soft-float code so no fp
- * registers will be used.
- *
- * Whilst this can be seen an encouraging people to
- * use the setjmp buffer in this way I think that it
- * is for the best then if changes occur compiles will
- * break rather than just having new builds falling over
- * mysteriously.
+ * This value comes from the original OpenBSD ARM-specific header
+ * that was replaced by this one.
*/
+#define _JBLEN 64
+
+/* According to the ARM AAPCS document, we only need to save
+ * the following registers:
+ *
+ * Core r4-r14
+ *
+ * VFP d8-d15 (see section 5.1.2.1)
+ *
+ * Registers s16-s31 (d8-d15, q4-q7) must be preserved across subroutine
+ * calls; registers s0-s15 (d0-d7, q0-q3) do not need to be preserved
+ * (and can be used for passing arguments or returning results in standard
+ * procedure-call variants). Registers d16-d31 (q8-q15), if present, do
+ * not need to be preserved.
+ *
+ * FPSCR saved because GLibc does saves it too.
+ *
+ */
+
+/* The internal structure of a jmp_buf is totally private.
+ * Current layout (may change in the future):
+ *
+ * word name description
+ * 0 magic magic number
+ * 1 sigmask signal mask (not used with _setjmp / _longjmp)
+ * 2 float_base base of float registers (d8 to d15)
+ * 18 float_state floating-point status and control register
+ * 19 core_base base of core registers (r4 to r14)
+ * 30 reserved reserved entries (room to grow)
+ * 64
+ *
+ * NOTE: float_base must be at an even word index, since the
+ * FP registers will be loaded/stored with instructions
+ * that expect 8-byte alignment.
+ */
+
+#define _JB_MAGIC 0
+#define _JB_SIGMASK (_JB_MAGIC+1)
+#define _JB_FLOAT_BASE (_JB_SIGMASK+1)
+#define _JB_FLOAT_STATE (_JB_FLOAT_BASE + (15-8+1)*2)
+#define _JB_CORE_BASE (_JB_FLOAT_STATE+1)
#define _JB_MAGIC__SETJMP 0x4278f500
#define _JB_MAGIC_SETJMP 0x4278f501
-
-/* Valid for all jmp_buf's */
-
-#define _JB_MAGIC 0
-#define _JB_REG_F4 1
-#define _JB_REG_F5 4
-#define _JB_REG_F6 7
-#define _JB_REG_F7 10
-#define _JB_REG_FPSR 13
-#define _JB_REG_R4 14
-#define _JB_REG_R5 15
-#define _JB_REG_R6 16
-#define _JB_REG_R7 17
-#define _JB_REG_R8 18
-#define _JB_REG_R9 19
-#define _JB_REG_R10 20
-#define _JB_REG_R11 21
-#define _JB_REG_R12 22
-#define _JB_REG_R13 23
-#define _JB_REG_R14 24
-
-/* Only valid with the _JB_MAGIC_SETJMP magic */
-
-#define _JB_SIGMASK 25
diff --git a/libc/bionic/pthread-rwlocks.c b/libc/bionic/pthread-rwlocks.c
new file mode 100644
index 0000000..ca3e95c
--- /dev/null
+++ b/libc/bionic/pthread-rwlocks.c
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "pthread_internal.h"
+#include <errno.h>
+
+/* Technical note:
+ *
+ * Possible states of a read/write lock:
+ *
+ * - no readers and no writer (unlocked)
+ * - one or more readers sharing the lock at the same time (read-locked)
+ * - one writer holding the lock (write-lock)
+ *
+ * Additionally:
+ * - trying to get the write-lock while there are any readers blocks
+ * - trying to get the read-lock while there is a writer blocks
+ * - a single thread can acquire the lock multiple times in the same mode
+ *
+ * - Posix states that behaviour is undefined it a thread tries to acquire
+ * the lock in two distinct modes (e.g. write after read, or read after write).
+ *
+ * - This implementation tries to avoid writer starvation by making the readers
+ * block as soon as there is a waiting writer on the lock. However, it cannot
+ * completely eliminate it: each time the lock is unlocked, all waiting threads
+ * are woken and battle for it, which one gets it depends on the kernel scheduler
+ * and is semi-random.
+ *
+ */
+
+#define __likely(cond) __builtin_expect(!!(cond), 1)
+#define __unlikely(cond) __builtin_expect(!!(cond), 0)
+
+#define RWLOCKATTR_DEFAULT 0
+#define RWLOCKATTR_SHARED_MASK 0x0010
+
+extern pthread_internal_t* __get_thread(void);
+
+/* Return a global kernel ID for the current thread */
+static int __get_thread_id(void)
+{
+ return __get_thread()->kernel_id;
+}
+
+int pthread_rwlockattr_init(pthread_rwlockattr_t *attr)
+{
+ if (!attr)
+ return EINVAL;
+
+ *attr = PTHREAD_PROCESS_PRIVATE;
+ return 0;
+}
+
+int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr)
+{
+ if (!attr)
+ return EINVAL;
+
+ *attr = -1;
+ return 0;
+}
+
+int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared)
+{
+ if (!attr)
+ return EINVAL;
+
+ switch (pshared) {
+ case PTHREAD_PROCESS_PRIVATE:
+ case PTHREAD_PROCESS_SHARED:
+ *attr = pshared;
+ return 0;
+ default:
+ return EINVAL;
+ }
+}
+
+int pthread_rwlockattr_getpshared(pthread_rwlockattr_t *attr, int *pshared)
+{
+ if (!attr || !pshared)
+ return EINVAL;
+
+ *pshared = *attr;
+ return 0;
+}
+
+int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr)
+{
+ pthread_mutexattr_t* lock_attr = NULL;
+ pthread_condattr_t* cond_attr = NULL;
+ pthread_mutexattr_t lock_attr0;
+ pthread_condattr_t cond_attr0;
+ int ret;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ if (attr && *attr == PTHREAD_PROCESS_SHARED) {
+ lock_attr = &lock_attr0;
+ pthread_mutexattr_init(lock_attr);
+ pthread_mutexattr_setpshared(lock_attr, PTHREAD_PROCESS_SHARED);
+
+ cond_attr = &cond_attr0;
+ pthread_condattr_init(cond_attr);
+ pthread_condattr_setpshared(cond_attr, PTHREAD_PROCESS_SHARED);
+ }
+
+ ret = pthread_mutex_init(&rwlock->lock, lock_attr);
+ if (ret != 0)
+ return ret;
+
+ ret = pthread_cond_init(&rwlock->cond, cond_attr);
+ if (ret != 0) {
+ pthread_mutex_destroy(&rwlock->lock);
+ return ret;
+ }
+
+ rwlock->numLocks = 0;
+ rwlock->pendingReaders = 0;
+ rwlock->pendingWriters = 0;
+ rwlock->writerThreadId = 0;
+
+ return 0;
+}
+
+int pthread_rwlock_destroy(pthread_rwlock_t *rwlock)
+{
+ int ret;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ if (rwlock->numLocks > 0)
+ return EBUSY;
+
+ pthread_cond_destroy(&rwlock->cond);
+ pthread_mutex_destroy(&rwlock->lock);
+ return 0;
+}
+
+/* Returns TRUE iff we can acquire a read lock. */
+static __inline__ int read_precondition(pthread_rwlock_t *rwlock, int thread_id)
+{
+ /* We can't have the lock if any writer is waiting for it (writer bias).
+ * This tries to avoid starvation when there are multiple readers racing.
+ */
+ if (rwlock->pendingWriters > 0)
+ return 0;
+
+ /* We can have the lock if there is no writer, or if we write-own it */
+ /* The second test avoids a self-dead lock in case of buggy code. */
+ if (rwlock->writerThreadId == 0 || rwlock->writerThreadId == thread_id)
+ return 1;
+
+ /* Otherwise, we can't have it */
+ return 0;
+}
+
+/* returns TRUE iff we can acquire a write lock. */
+static __inline__ int write_precondition(pthread_rwlock_t *rwlock, int thread_id)
+{
+ /* We can get the lock if nobody has it */
+ if (rwlock->numLocks == 0)
+ return 1;
+
+ /* Or if we already own it */
+ if (rwlock->writerThreadId == thread_id)
+ return 1;
+
+ /* Otherwise, not */
+ return 0;
+}
+
+/* This function is used to waken any waiting thread contending
+ * for the lock. One of them should be able to grab it after
+ * that.
+ */
+static void _pthread_rwlock_pulse(pthread_rwlock_t *rwlock)
+{
+ if (rwlock->pendingReaders > 0 || rwlock->pendingWriters > 0)
+ pthread_cond_broadcast(&rwlock->cond);
+}
+
+
+int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
+{
+ return pthread_rwlock_timedrdlock(rwlock, NULL);
+}
+
+int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock)
+{
+ int ret = 0;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ pthread_mutex_lock(&rwlock->lock);
+ if (__unlikely(!read_precondition(rwlock, __get_thread_id())))
+ ret = EBUSY;
+ else
+ rwlock->numLocks ++;
+ pthread_mutex_unlock(&rwlock->lock);
+
+ return ret;
+}
+
+int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *abs_timeout)
+{
+ int thread_id, ret = 0;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ pthread_mutex_lock(&rwlock->lock);
+ thread_id = __get_thread_id();
+ if (__unlikely(!read_precondition(rwlock, thread_id))) {
+ rwlock->pendingReaders += 1;
+ do {
+ ret = pthread_cond_timedwait(&rwlock->cond, &rwlock->lock, abs_timeout);
+ } while (ret == 0 && !read_precondition(rwlock, thread_id));
+ rwlock->pendingReaders -= 1;
+ if (ret != 0)
+ goto EXIT;
+ }
+ rwlock->numLocks ++;
+EXIT:
+ pthread_mutex_unlock(&rwlock->lock);
+ return ret;
+}
+
+
+int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
+{
+ return pthread_rwlock_timedwrlock(rwlock, NULL);
+}
+
+int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock)
+{
+ int thread_id, ret = 0;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ pthread_mutex_lock(&rwlock->lock);
+ thread_id = __get_thread_id();
+ if (__unlikely(!write_precondition(rwlock, thread_id))) {
+ ret = EBUSY;
+ } else {
+ rwlock->numLocks ++;
+ rwlock->writerThreadId = thread_id;
+ }
+ pthread_mutex_unlock(&rwlock->lock);
+ return ret;
+}
+
+int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *abs_timeout)
+{
+ int thread_id, ret = 0;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ pthread_mutex_lock(&rwlock->lock);
+ thread_id = __get_thread_id();
+ if (__unlikely(!write_precondition(rwlock, thread_id))) {
+ /* If we can't read yet, wait until the rwlock is unlocked
+ * and try again. Increment pendingReaders to get the
+ * cond broadcast when that happens.
+ */
+ rwlock->pendingWriters += 1;
+ do {
+ ret = pthread_cond_timedwait(&rwlock->cond, &rwlock->lock, abs_timeout);
+ } while (ret == 0 && !write_precondition(rwlock, thread_id));
+ rwlock->pendingWriters -= 1;
+ if (ret != 0)
+ goto EXIT;
+ }
+ rwlock->numLocks ++;
+ rwlock->writerThreadId = thread_id;
+EXIT:
+ pthread_mutex_unlock(&rwlock->lock);
+ return ret;
+}
+
+
+int pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
+{
+ int ret = 0;
+
+ if (rwlock == NULL)
+ return EINVAL;
+
+ pthread_mutex_lock(&rwlock->lock);
+
+ /* The lock must be held */
+ if (rwlock->numLocks == 0) {
+ ret = EPERM;
+ goto EXIT;
+ }
+
+ /* If it has only readers, writerThreadId is 0 */
+ if (rwlock->writerThreadId == 0) {
+ if (--rwlock->numLocks == 0)
+ _pthread_rwlock_pulse(rwlock);
+ }
+ /* Otherwise, it has only a single writer, which
+ * must be ourselves.
+ */
+ else {
+ if (rwlock->writerThreadId != __get_thread_id()) {
+ ret = EPERM;
+ goto EXIT;
+ }
+ if (--rwlock->numLocks == 0) {
+ rwlock->writerThreadId = 0;
+ _pthread_rwlock_pulse(rwlock);
+ }
+ }
+EXIT:
+ pthread_mutex_unlock(&rwlock->lock);
+ return ret;
+}
diff --git a/libc/docs/CHANGES.TXT b/libc/docs/CHANGES.TXT
index 9080685..e72b422 100644
--- a/libc/docs/CHANGES.TXT
+++ b/libc/docs/CHANGES.TXT
@@ -1,7 +1,14 @@
Bionic ChangeLog:
-----------------
-Differences between current and Android 2.1:
+Differences between current and Android 2.2:
+
+- <pthread.h>: Add reader/writer locks implementation.
+
+-------------------------------------------------------------------------------
+Differences between Android 2.2. and Android 2.1:
+
+- Support FP register save/load in setjmp()/longjmp() on ARMv7 builds.
- Add support for SH-4 CPU architecture !
diff --git a/libc/include/pthread.h b/libc/include/pthread.h
index eb2d169..33039b9 100644
--- a/libc/include/pthread.h
+++ b/libc/include/pthread.h
@@ -219,6 +219,41 @@
*/
int pthread_mutex_lock_timeout_np(pthread_mutex_t *mutex, unsigned msecs);
+/* read-write lock support */
+
+typedef int pthread_rwlockattr_t;
+
+typedef struct {
+ pthread_mutex_t lock;
+ pthread_cond_t cond;
+ int numLocks;
+ int writerThreadId;
+ int pendingReaders;
+ int pendingWriters;
+ void* reserved[4]; /* for future extensibility */
+} pthread_rwlock_t;
+
+#define PTHREAD_RWLOCK_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0, NULL, 0, 0 }
+
+int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
+int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
+int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared);
+int pthread_rwlockattr_getpshared(pthread_rwlockattr_t *attr, int *pshared);
+
+int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
+int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
+
+int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
+int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
+int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *abs_timeout);
+
+int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
+int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
+int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *abs_timeout);
+
+int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
+
+
int pthread_key_create(pthread_key_t *key, void (*destructor_function)(void *));
int pthread_key_delete (pthread_key_t);
int pthread_setspecific(pthread_key_t key, const void *value);
diff --git a/libthread_db/include/thread_db.h b/libthread_db/include/thread_db.h
index 9c76d40..1b36cb2 100644
--- a/libthread_db/include/thread_db.h
+++ b/libthread_db/include/thread_db.h
@@ -10,6 +10,8 @@
#include <stdint.h>
#include <sys/types.h>
+typedef void *psaddr_t;
+typedef pid_t lwpid_t;
#define TD_THR_ANY_USER_FLAGS 0xffffffff
#define TD_THR_LOWEST_PRIORITY -20
@@ -67,6 +69,7 @@
typedef struct
{
pid_t pid;
+ struct ps_prochandle *ph;
} td_thragent_t;
typedef struct
@@ -123,19 +126,37 @@
extern "C"{
#endif
-extern td_err_e td_ta_new(struct ps_prochandle const * proc_handle, td_thragent_t ** thread_agent);
+extern td_err_e td_ta_new(struct ps_prochandle * proc_handle, td_thragent_t ** thread_agent);
+
+extern td_err_e td_ta_delete(td_thragent_t * ta);
extern td_err_e td_ta_set_event(td_thragent_t const * agent, td_thr_events_t * event);
extern td_err_e td_ta_event_addr(td_thragent_t const * agent, td_event_e event, td_notify_t * notify);
+extern td_err_e td_ta_clear_event(const td_thragent_t * ta_arg,
+ td_thr_events_t * event);
+
extern td_err_e td_ta_event_getmsg(td_thragent_t const * agent, td_event_msg_t * event);
+extern td_err_e td_ta_map_lwp2thr(td_thragent_t const * agent, lwpid_t lwpid,
+ td_thrhandle_t *th);
+
+extern td_err_e td_thr_get_info(td_thrhandle_t const * handle,
+ td_thrinfo_t * info);
+
+extern td_err_e td_thr_event_enable(td_thrhandle_t const * handle,
+ td_event_e event);
+
extern td_err_e td_ta_thr_iter(td_thragent_t const * agent, td_thr_iter_f * func, void * cookie,
td_thr_state_e state, int32_t prio, sigset_t * sigmask, uint32_t user_flags);
extern char const ** td_symbol_list(void);
+extern td_err_e td_thr_tls_get_addr(const td_thrhandle_t * th,
+ psaddr_t map_address, size_t offset,
+ psaddr_t * address);
+
#ifdef __cplusplus
}
#endif
diff --git a/libthread_db/libthread_db.c b/libthread_db/libthread_db.c
index f1a78ac..2cf4d38 100644
--- a/libthread_db/libthread_db.c
+++ b/libthread_db/libthread_db.c
@@ -10,12 +10,7 @@
#include <stdio.h>
extern int ps_pglobal_lookup (void *, const char *obj, const char *name, void **sym_addr);
-
-struct ps_prochandle
-{
- pid_t pid;
-};
-
+extern pid_t ps_getpid(struct ps_prochandle *ph);
/*
* This is the list of "special" symbols we care about whose addresses are
@@ -41,7 +36,7 @@
td_err_e
-td_ta_new(struct ps_prochandle const * proc_handle, td_thragent_t ** agent_out)
+td_ta_new(struct ps_prochandle * proc_handle, td_thragent_t ** agent_out)
{
td_thragent_t * agent;
@@ -50,7 +45,8 @@
return TD_MALLOC;
}
- agent->pid = proc_handle->pid;
+ agent->pid = ps_getpid(proc_handle);
+ agent->ph = proc_handle;
*agent_out = agent;
return TD_OK;
@@ -58,14 +54,28 @@
td_err_e
+td_ta_delete(td_thragent_t * ta)
+{
+ free(ta);
+ // FIXME: anything else to do?
+ return TD_OK;
+}
+
+
+/* NOTE: not used by gdb 7.0 */
+
+td_err_e
td_ta_set_event(td_thragent_t const * agent, td_thr_events_t * events)
{
return TD_OK;
}
+/* NOTE: not used by gdb 7.0 */
static td_thrhandle_t gEventMsgHandle;
+/* NOTE: not used by gdb 7.0 */
+
static int
_event_getmsg_helper(td_thrhandle_t const * handle, void * bkpt_addr)
{
@@ -83,6 +93,8 @@
return 0;
}
+/* NOTE: not used by gdb 7.0 */
+
td_err_e
td_ta_event_getmsg(td_thragent_t const * agent, td_event_msg_t * event)
{
@@ -107,6 +119,16 @@
td_err_e
+td_ta_map_lwp2thr(td_thragent_t const * agent, lwpid_t lwpid,
+ td_thrhandle_t *th)
+{
+ th->pid = ps_getpid(agent->ph);
+ th->tid = lwpid;
+ return TD_OK;
+}
+
+
+td_err_e
td_thr_get_info(td_thrhandle_t const * handle, td_thrinfo_t * info)
{
info->ti_tid = handle->tid;
@@ -117,6 +139,8 @@
}
+/* NOTE: not used by gdb 7.0 */
+
td_err_e
td_thr_event_enable(td_thrhandle_t const * handle, td_event_e event)
{
@@ -125,6 +149,8 @@
}
+/* NOTE: not used by gdb 7.0 */
+
td_err_e
td_ta_event_addr(td_thragent_t const * agent, td_event_e event, td_notify_t * notify_out)
{
@@ -149,6 +175,15 @@
td_err_e
+td_ta_clear_event(const td_thragent_t * ta_arg, td_thr_events_t * event)
+{
+ /* Given that gdb 7.0 doesn't use thread events,
+ there's nothing we need to do here. */
+ return TD_OK;
+}
+
+
+td_err_e
td_ta_thr_iter(td_thragent_t const * agent, td_thr_iter_f * func, void * cookie,
td_thr_state_e state, int32_t prio, sigset_t * sigmask, uint32_t user_flags)
{
@@ -170,8 +205,8 @@
continue;
}
handle.tid = atoi(entry->d_name);
- err = func(&handle, cookie);
- if (err) {
+ if (func(&handle, cookie) != 0) {
+ err = TD_DBERR;
break;
}
}
@@ -181,3 +216,9 @@
return err;
}
+td_err_e
+td_thr_tls_get_addr(const td_thrhandle_t * th,
+ psaddr_t map_address, size_t offset, psaddr_t * address)
+{
+ return TD_NOAPLIC; // FIXME: TODO
+}