Updated to fedora-glibc-20070801T1703 fedora-glibc-2_6_90-2
authorjakub <jakub>
Wed, 1 Aug 2007 17:16:37 +0000 (17:16 +0000)
committerjakub <jakub>
Wed, 1 Aug 2007 17:16:37 +0000 (17:16 +0000)
120 files changed:
ChangeLog
fedora/branch.mk
fedora/glibc.spec.in
localedata/ChangeLog
localedata/tst-strptime.c
nptl/ChangeLog
nptl/allocatestack.c
nptl/descr.h
nptl/old_pthread_cond_broadcast.c
nptl/old_pthread_cond_signal.c
nptl/old_pthread_cond_timedwait.c
nptl/old_pthread_cond_wait.c
nptl/pthreadP.h
nptl/pthread_attr_init.c
nptl/pthread_barrier_destroy.c
nptl/pthread_barrier_init.c
nptl/pthread_barrier_wait.c
nptl/pthread_cond_broadcast.c
nptl/pthread_cond_destroy.c
nptl/pthread_cond_init.c
nptl/pthread_cond_signal.c
nptl/pthread_cond_timedwait.c
nptl/pthread_cond_wait.c
nptl/pthread_create.c
nptl/pthread_getattr_np.c
nptl/pthread_getschedparam.c
nptl/pthread_mutex_lock.c
nptl/pthread_mutex_timedlock.c
nptl/pthread_mutex_trylock.c
nptl/pthread_mutex_unlock.c
nptl/pthread_once.c
nptl/pthread_rwlock_rdlock.c
nptl/pthread_rwlock_timedrdlock.c
nptl/pthread_rwlock_timedwrlock.c
nptl/pthread_rwlock_tryrdlock.c
nptl/pthread_rwlock_trywrlock.c
nptl/pthread_rwlock_unlock.c
nptl/pthread_rwlock_wrlock.c
nptl/pthread_setschedparam.c
nptl/pthread_setschedprio.c
nptl/sem_close.c
nptl/sem_open.c
nptl/semaphoreP.h
nptl/sysdeps/pthread/bits/libc-lock.h
nptl/sysdeps/pthread/bits/stdio-lock.h
nptl/sysdeps/pthread/createthread.c
nptl/sysdeps/sparc/tls.h
nptl/sysdeps/unix/sysv/linux/alpha/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/fork.c
nptl/sysdeps/unix/sysv/linux/fork.h
nptl/sysdeps/unix/sysv/linux/i386/i486/libc-lowlevellock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/lowlevellock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/lowlevelrobustlock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_barrier_wait.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_broadcast.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_signal.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_rdlock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedrdlock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedwrlock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_unlock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_wrlock.S
nptl/sysdeps/unix/sysv/linux/i386/i486/sem_post.S
nptl/sysdeps/unix/sysv/linux/i386/i486/sem_timedwait.S
nptl/sysdeps/unix/sysv/linux/i386/i486/sem_trywait.S
nptl/sysdeps/unix/sysv/linux/i386/i486/sem_wait.S
nptl/sysdeps/unix/sysv/linux/i386/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/i386/pthread_once.S
nptl/sysdeps/unix/sysv/linux/ia64/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/lowlevellock.c
nptl/sysdeps/unix/sysv/linux/lowlevelrobustlock.c
nptl/sysdeps/unix/sysv/linux/powerpc/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/powerpc/sem_post.c
nptl/sysdeps/unix/sysv/linux/pthread_mutex_cond_lock.c
nptl/sysdeps/unix/sysv/linux/register-atfork.c
nptl/sysdeps/unix/sysv/linux/s390/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/sem_post.c
nptl/sysdeps/unix/sysv/linux/sem_timedwait.c
nptl/sysdeps/unix/sysv/linux/sem_wait.c
nptl/sysdeps/unix/sysv/linux/sparc/internaltypes.h [new file with mode: 0644]
nptl/sysdeps/unix/sysv/linux/sparc/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/sparc/pthread_barrier_destroy.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/linux/sparc/pthread_barrier_init.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/linux/sparc/pthread_barrier_wait.c [new file with mode: 0644]
nptl/sysdeps/unix/sysv/linux/sparc/sparc32/lowlevellock.c
nptl/sysdeps/unix/sysv/linux/sparc/sparc32/pthread_barrier_wait.c
nptl/sysdeps/unix/sysv/linux/sparc/sparc32/sparcv9/pthread_barrier_wait.c
nptl/sysdeps/unix/sysv/linux/unregister-atfork.c
nptl/sysdeps/unix/sysv/linux/x86_64/libc-lowlevellock.S
nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S
nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h
nptl/sysdeps/unix/sysv/linux/x86_64/lowlevelrobustlock.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_barrier_wait.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_timedrdlock.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_timedwrlock.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_unlock.S
nptl/sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S
nptl/sysdeps/unix/sysv/linux/x86_64/sem_post.S
nptl/sysdeps/unix/sysv/linux/x86_64/sem_timedwait.S
nptl/sysdeps/unix/sysv/linux/x86_64/sem_trywait.S
nptl/sysdeps/unix/sysv/linux/x86_64/sem_wait.S
nptl/tpp.c
nptl/tst-rwlock14.c
stdio-common/tst-fmemopen2.c
stdlib/tst-strtod2.c
sysdeps/generic/unwind-dw2-fde-glibc.c
sysdeps/generic/unwind-dw2-fde.c
sysdeps/generic/unwind-dw2.c
sysdeps/unix/sysv/linux/getsysstats.c
sysdeps/unix/sysv/linux/i386/posix_fallocate.c [new file with mode: 0644]
sysdeps/unix/sysv/linux/i386/posix_fallocate64.c [new file with mode: 0644]
sysdeps/unix/sysv/linux/i386/syscalls.list
sysdeps/unix/sysv/linux/posix_fallocate.c

index b10c3aa..816d935 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,38 @@
+2007-08-01  Jakub Jelinek  <jakub@redhat.com>
+
+       * sysdeps/unix/sysv/linux/i386/syscalls.list (fallocate): Add fallocate
+       syscall as __fallocate64.
+       * sysdeps/unix/sysv/linux/i386/posix_fallocate.c: New file.
+       * sysdeps/unix/sysv/linux/i386/posix_fallocate64.c: New file.
+
+2007-07-30  Jakub Jelinek  <jakub@redhat.com>
+
+       * stdlib/tst-strtod2.c (do_test): Use %tu in fmt string for ptrdiff_t
+       value.
+
+       * stdio-common/tst-fmemopen2.c (do_test): Avoid fmt string warning
+       if off_t is different rank from size_t.
+
+       * sysdeps/generic/unwind-dw2.c (extract_cie_info, execute_cfa_program,
+       uw_frame_state_for): Avoid type punning warnings.
+       * sysdeps/generic/unwind-dw2-fde-glibc.c
+       (_Unwind_IteratePhdrCallback): Likewise.
+       * sysdeps/generic/unwind-dw2-fde.c (_Unwind_Find_FDE): Likewise.
+       (binary_search_single_encoding_fdes, binary_search_mixed_encoding_fdes,
+       get_cie_encoding, linear_search_fdes): Don't mix char and unsigned char
+       pointers.
+
+2007-07-31  Ulrich Drepper  <drepper@redhat.com>
+
+       * sysdeps/unix/sysv/linux/getsysstats.c (__get_nprocs_conf): Count
+       total processors using sysfs.
+       (__get_nprocs): Use sysfs to determine which processors are online.
+
 2007-07-31  Jakub Jelinek  <jakub@redhat.com>
 
+       * sysdeps/unix/sysv/linux/posix_fallocate.c (posix_fallocate): Fix
+       syscall arguments count.
+
        * stdio-common/tfformat.c (sprint_doubles): Add 12 new tests.
 
 2007-07-30  Roland McGrath  <roland@redhat.com>
index 6725eed..ee9e449 100644 (file)
@@ -3,5 +3,5 @@ glibc-branch := fedora
 glibc-base := HEAD
 DIST_BRANCH := devel
 COLLECTION := dist-fc7
-fedora-sync-date := 2007-07-31 16:24 UTC
-fedora-sync-tag := fedora-glibc-20070731T1624
+fedora-sync-date := 2007-08-01 17:03 UTC
+fedora-sync-tag := fedora-glibc-20070801T1703
index d228db7..ae71335 100644 (file)
@@ -1,4 +1,4 @@
-%define glibcrelease 1
+%define glibcrelease 2
 %define auxarches i586 i686 athlon sparcv9 alphaev6
 %define xenarches i686 athlon
 %ifarch %{xenarches}
@@ -148,6 +148,7 @@ Obsoletes: %{name}-headers(i386)
 Obsoletes: libc-debug, libc-headers, libc-devel
 Prereq: kernel-headers
 Requires: kernel-headers >= 2.2.1, %{name} = %{version}-%{release}
+BuildRequires: kernel-headers >= 2.6.22
 Autoreq: true
 
 %description headers
@@ -243,532 +244,6 @@ package or when debugging this package.
 %endif
 %endif
 
-# Hack till glibc-kernheaders get updated, argh
-mkdir -p override_headers/linux
-cat > override_headers/linux/version.h <<EOF
-#define UTS_RELEASE "2.6.9"
-#define LINUX_VERSION_CODE 132617
-#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
-EOF
-mkdir -p override_headers/asm
-cat > override_headers/asm/unistd.h <<EOF
-#ifndef _HACK_ASM_UNISTD_H
-#include_next <asm/unistd.h>
-%ifarch alpha
-#ifndef __NR_stat64
-#define __NR_stat64                    425
-#define __NR_lstat64                   426
-#define __NR_fstat64                   427
-#endif
-#ifndef __NR_mq_open
-#define __NR_mq_open                   432
-#define __NR_mq_unlink                 433
-#define __NR_mq_timedsend              434
-#define __NR_mq_timedreceive           435
-#define __NR_mq_notify                 436
-#define __NR_mq_getsetattr             437
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid                    438
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init              444
-#define __NR_inotify_add_watch         445
-#define __NR_inotify_rm_watch          446
-#endif
-%endif
-%ifarch %{ix86}
-#ifndef __NR_mq_open
-#define __NR_mq_open           277
-#define __NR_mq_unlink         (__NR_mq_open+1)
-#define __NR_mq_timedsend      (__NR_mq_open+2)
-#define __NR_mq_timedreceive   (__NR_mq_open+3)
-#define __NR_mq_notify         (__NR_mq_open+4)
-#define __NR_mq_getsetattr     (__NR_mq_open+5)
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            284
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      291
-#define __NR_inotify_add_watch 292
-#define __NR_inotify_rm_watch  293
-#endif
-#ifndef __NR_openat
-#define __NR_openat            295
-#define __NR_mkdirat           296
-#define __NR_mknodat           297
-#define __NR_fchownat          298
-#define __NR_futimesat         299
-#define __NR_unlinkat          301
-#define __NR_renameat          302
-#define __NR_linkat            303
-#define __NR_symlinkat         304
-#define __NR_readlinkat                305
-#define __NR_fchmodat          306
-#define __NR_faccessat         307
-#endif
-#ifndef __NR_fstatat64
-#define __NR_fstatat64         300
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          308
-#define __NR_ppoll             309
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           310
-#endif
-#ifndef __NR_set_robust_list
-#define __NR_set_robust_list   311
-#define __NR_get_robust_list   312
-#endif
-#ifndef __NR_splice
-#define __NR_splice            313
-#endif
-#ifndef __NR_sync_file_range
-#define __NR_sync_file_range   314
-#endif
-#ifndef __NR_tee
-#define __NR_tee               315
-#endif
-#ifndef __NR_vmsplice
-#define __NR_vmsplice          316
-#endif
-%endif
-%ifarch ia64
-#ifndef __NR_timer_create
-#define __NR_timer_create      1248
-#define __NR_timer_settime     1249
-#define __NR_timer_gettime     1250
-#define __NR_timer_getoverrun  1251
-#define __NR_timer_delete      1252
-#define __NR_clock_settime     1253
-#define __NR_clock_gettime     1254
-#define __NR_clock_getres      1255
-#define __NR_clock_nanosleep   1256
-#endif
-#ifndef __NR_mq_open
-#define __NR_mq_open           1262
-#define __NR_mq_unlink         1263
-#define __NR_mq_timedsend      1264
-#define __NR_mq_timedreceive   1265
-#define __NR_mq_notify         1266
-#define __NR_mq_getsetattr     1267
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            1270
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      1277
-#define __NR_inotify_add_watch 1278
-#define __NR_inotify_rm_watch  1279
-#endif
-#ifndef __NR_openat
-#define __NR_openat            1281
-#define __NR_mkdirat           1282
-#define __NR_mknodat           1283
-#define __NR_fchownat          1284
-#define __NR_futimesat         1285
-#define __NR_newfstatat                1286
-#define __NR_unlinkat          1287
-#define __NR_renameat          1288
-#define __NR_linkat            1289
-#define __NR_symlinkat         1290
-#define __NR_readlinkat                1291
-#define __NR_fchmodat          1292
-#define __NR_faccessat         1293
-#endif
-#if 0
-#ifndef __NR_pselect6
-#define __NR_pselect6          1294
-#define __NR_ppoll             1295
-#endif
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           1296
-#endif
-#ifndef __NR_splice
-#define __NR_splice            1297
-#endif
-#ifndef __NR_set_robust_list
-#define __NR_set_robust_list   1298
-#define __NR_get_robust_list   1299
-#endif
-#ifndef __NR_sync_file_range
-#define __NR_sync_file_range   1300
-#endif
-#ifndef __NR_tee
-#define __NR_tee               1301
-#endif
-#ifndef __NR_vmsplice
-#define __NR_vmsplice          1302
-#endif
-%endif
-%ifarch ppc
-#ifndef __NR_utimes
-#define __NR_utimes            251
-#endif
-#ifndef __NR_statfs64
-#define __NR_statfs64          252
-#define __NR_fstatfs64         253
-#endif
-#ifndef __NR_fadvise64_64
-#define __NR_fadvise64_64      254
-#endif
-#ifndef __NR_mq_open
-#define __NR_mq_open           262
-#define __NR_mq_unlink         263
-#define __NR_mq_timedsend      264
-#define __NR_mq_timedreceive   265
-#define __NR_mq_notify         266
-#define __NR_mq_getsetattr     267
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            272
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      275
-#define __NR_inotify_add_watch 276
-#define __NR_inotify_rm_watch  277
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          280
-#define __NR_ppoll             281
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           282
-#endif
-#ifndef __NR_splice
-#define __NR_splice            283
-#endif
-#ifndef __NR_tee
-#define __NR_tee               284
-#endif
-#ifndef __NR_vmsplice
-#define __NR_vmsplice          285
-#endif
-#ifndef __NR_openat
-#define __NR_openat            286
-#define __NR_mkdirat           287
-#define __NR_mknodat           288
-#define __NR_fchownat          289
-#define __NR_futimesat         290
-#define __NR_fstatat64         291
-#define __NR_unlinkat          292
-#define __NR_renameat          293
-#define __NR_linkat            294
-#define __NR_symlinkat         295
-#define __NR_readlinkat                296
-#define __NR_fchmodat          297
-#define __NR_faccessat         298
-#endif
-%endif
-%ifarch ppc64
-#ifndef __NR_utimes
-#define __NR_utimes            251
-#endif
-#ifndef __NR_mq_open
-#define __NR_mq_open           262
-#define __NR_mq_unlink         263
-#define __NR_mq_timedsend      264
-#define __NR_mq_timedreceive   265
-#define __NR_mq_notify         266
-#define __NR_mq_getsetattr     267
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            272
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      275
-#define __NR_inotify_add_watch 276
-#define __NR_inotify_rm_watch  277
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          280
-#define __NR_ppoll             281
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           282
-#endif
-#ifndef __NR_splice
-#define __NR_splice            283
-#endif
-#ifndef __NR_tee
-#define __NR_tee               284
-#endif
-#ifndef __NR_vmsplice
-#define __NR_vmsplice          285
-#endif
-#ifndef __NR_openat
-#define __NR_openat            286
-#define __NR_mkdirat           287
-#define __NR_mknodat           288
-#define __NR_fchownat          289
-#define __NR_futimesat         290
-#define __NR_newfstatat                291
-#define __NR_unlinkat          292
-#define __NR_renameat          293
-#define __NR_linkat            294
-#define __NR_symlinkat         295
-#define __NR_readlinkat                296
-#define __NR_fchmodat          297
-#define __NR_faccessat         298
-#endif
-%endif
-%ifarch s390
-#ifndef __NR_timer_create
-#define __NR_timer_create      254
-#define __NR_timer_settime     (__NR_timer_create+1)
-#define __NR_timer_gettime     (__NR_timer_create+2)
-#define __NR_timer_getoverrun  (__NR_timer_create+3)
-#define __NR_timer_delete      (__NR_timer_create+4)
-#define __NR_clock_settime     (__NR_timer_create+5)
-#define __NR_clock_gettime     (__NR_timer_create+6)
-#define __NR_clock_getres      (__NR_timer_create+7)
-#define __NR_clock_nanosleep   (__NR_timer_create+8)
-#endif
-#ifndef __NR_fadvise64_64
-#define __NR_fadvise64_64      264
-#endif
-#ifndef __NR_statfs64
-#define __NR_statfs64          265
-#define __NR_fstatfs64         266
-#endif
-#ifndef __NR_mq_open
-#define __NR_mq_open           271
-#define __NR_mq_unlink         272
-#define __NR_mq_timedsend      273
-#define __NR_mq_timedreceive   274
-#define __NR_mq_notify         275
-#define __NR_mq_getsetattr     276
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            281
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      284
-#define __NR_inotify_add_watch 285
-#define __NR_inotify_rm_watch  286
-#endif
-#ifndef __NR_openat
-#define __NR_openat            288
-#define __NR_mkdirat           289
-#define __NR_mknodat           290
-#define __NR_fchownat          291
-#define __NR_futimesat         292
-#define __NR_fstatat64         293
-#define __NR_unlinkat          294
-#define __NR_renameat          295
-#define __NR_linkat            296
-#define __NR_symlinkat         297
-#define __NR_readlinkat                298
-#define __NR_fchmodat          299
-#define __NR_faccessat         300
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          301
-#define __NR_ppoll             302
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           303
-#endif
-%endif
-%ifarch s390x
-#ifndef __NR_timer_create
-#define __NR_timer_create      254
-#define __NR_timer_settime     (__NR_timer_create+1)
-#define __NR_timer_gettime     (__NR_timer_create+2)
-#define __NR_timer_getoverrun  (__NR_timer_create+3)
-#define __NR_timer_delete      (__NR_timer_create+4)
-#define __NR_clock_settime     (__NR_timer_create+5)
-#define __NR_clock_gettime     (__NR_timer_create+6)
-#define __NR_clock_getres      (__NR_timer_create+7)
-#define __NR_clock_nanosleep   (__NR_timer_create+8)
-#endif
-#ifndef __NR_mq_open
-#define __NR_mq_open           271
-#define __NR_mq_unlink         272
-#define __NR_mq_timedsend      273
-#define __NR_mq_timedreceive   274
-#define __NR_mq_notify         275
-#define __NR_mq_getsetattr     276
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            281
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      284
-#define __NR_inotify_add_watch 285
-#define __NR_inotify_rm_watch  286
-#endif
-#ifndef __NR_openat
-#define __NR_openat            288
-#define __NR_mkdirat           289
-#define __NR_mknodat           290
-#define __NR_fchownat          291
-#define __NR_futimesat         292
-#define __NR_newfstatat                293
-#define __NR_unlinkat          294
-#define __NR_renameat          295
-#define __NR_linkat            296
-#define __NR_symlinkat         297
-#define __NR_readlinkat                298
-#define __NR_fchmodat          299
-#define __NR_faccessat         300
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          301
-#define __NR_ppoll             302
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           303
-#endif
-%endif
-%ifarch sparc sparcv9 sparc64
-#ifndef __NR_mq_open
-#define __NR_mq_open           273
-#define __NR_mq_unlink         274
-#define __NR_mq_timedsend      275
-#define __NR_mq_timedreceive   276
-#define __NR_mq_notify         277
-#define __NR_mq_getsetattr     278
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            279
-#endif
-#ifndef __NR_stat64
-#define __NR_fstat64           63
-#define __NR_lstat64           132
-#define __NR_stat64            139
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      151
-#define __NR_inotify_add_watch 152
-#define __NR_inotify_rm_watch  156
-#endif
-#ifndef __NR_openat
-#define __NR_openat            284
-#define __NR_mkdirat           285
-#define __NR_mknodat           286
-#define __NR_fchownat          287
-#define __NR_futimesat         288
-#define __NR_newfstatat                289
-#define __NR_unlinkat          290
-#define __NR_renameat          291
-#define __NR_linkat            292
-#define __NR_symlinkat         293
-#define __NR_readlinkat                294
-#define __NR_fchmodat          295
-#define __NR_faccessat         296
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          297
-#define __NR_ppoll             298
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           299
-#endif
-%endif
-%ifarch x86_64
-#ifndef __NR_mq_open
-#define __NR_mq_open           240
-#define __NR_mq_unlink         241
-#define __NR_mq_timedsend      242
-#define __NR_mq_timedreceive   243
-#define __NR_mq_notify         244
-#define __NR_mq_getsetattr     245
-#endif
-#ifndef __NR_waitid
-#define __NR_waitid            247
-#endif
-#ifndef __NR_inotify_init
-#define __NR_inotify_init      253
-#define __NR_inotify_add_watch 254
-#define __NR_inotify_rm_watch  255
-#endif
-#ifndef __NR_openat
-#define __NR_openat            257
-#define __NR_mkdirat           258
-#define __NR_mknodat           259
-#define __NR_fchownat          260
-#define __NR_futimesat         261
-#define __NR_newfstatat                262
-#define __NR_unlinkat          263
-#define __NR_renameat          264
-#define __NR_linkat            265
-#define __NR_symlinkat         266
-#define __NR_readlinkat                267
-#define __NR_fchmodat          268
-#define __NR_faccessat         269
-#endif
-#ifndef __NR_pselect6
-#define __NR_pselect6          270
-#define __NR_ppoll             271
-#endif
-#ifndef __NR_unshare
-#define __NR_unshare           272
-#endif
-#ifndef __NR_set_robust_list
-#define __NR_set_robust_list   273
-#define __NR_get_robust_list   274
-#endif
-#ifndef __NR_splice
-#define __NR_splice            275
-#endif
-#ifndef __NR_tee
-#define __NR_tee               276
-#endif
-#ifndef __NR_sync_file_range
-#define __NR_sync_file_range   277
-#endif
-#ifndef __NR_vmsplice
-#define __NR_vmsplice          278
-#endif
-%endif
-#endif
-EOF
-cat > override_headers/asm/errno.h <<EOF
-#ifndef _HACK_ASM_ERRNO_H
-#include_next <asm/errno.h>
-%ifarch alpha
-#ifndef ENOKEY
-#define ENOKEY         132
-#define EKEYEXPIRED    133
-#define EKEYREVOKED    134
-#define EKEYREJECTED   135
-#endif
-#ifndef EOWNERDEAD
-#define EOWNERDEAD     136
-#define ENOTRECOVERABLE        137
-#endif
-%endif
-%ifarch %{ix86} ia64 ppc ppc64 s390 s390x x86_64
-#ifndef ENOKEY
-#define ENOKEY         126
-#define EKEYEXPIRED    127
-#define EKEYREVOKED    128
-#define EKEYREJECTED   129
-#endif
-#ifndef EOWNERDEAD
-#define EOWNERDEAD     130
-#define ENOTRECOVERABLE        131
-#endif
-%endif
-%ifarch sparc sparcv9 sparc64
-#ifndef ENOKEY
-#define ENOKEY         128
-#define EKEYEXPIRED    129
-#define EKEYREVOKED    130
-#define EKEYREJECTED   131
-#endif
-#ifndef EOWNERDEAD
-#define EOWNERDEAD     132
-#define ENOTRECOVERABLE        133
-#endif
-%endif
-#endif
-EOF
-
 # A lot of programs still misuse memcpy when they have to use
 # memmove. The memcpy implementation below is not tolerant at
 # all.
@@ -840,7 +315,7 @@ mkdir $builddir ; cd $builddir
 build_CFLAGS="$BuildFlags -g -O3 $*"
 CC="$GCC" CXX="$GXX" CFLAGS="$build_CFLAGS" ../configure --prefix=%{_prefix} \
        --enable-add-ons=nptl$AddOns --without-cvs $EnableKernel \
-       --with-headers=`cd ..; pwd`/override_headers:%{_prefix}/include --enable-bind-now \
+       --with-headers=%{_prefix}/include --enable-bind-now \
        --with-tls --with-__thread --build %{nptl_target_cpu}-redhat-linux \
        --host %{nptl_target_cpu}-redhat-linux \
        --disable-profile
@@ -1566,6 +1041,12 @@ rm -f *.filelist*
 %endif
 
 %changelog
+* Wed Aug  1 2007 Jakub Jelinek <jakub@redhat.com> 2.6.90-2
+- make aux-cache purely optional performance optimization in ldconfig,
+  don't issue any errors if it can't be created (#250430)
+- remove override_headers hack, BuildRequire >= 2.6.22 kernel-headers
+  and rely on its content
+
 * Tue Jul 31 2007 Jakub Jelinek <jakub@redhat.com> 2.6.90-1
 - update to trunk
   - private futex optimizations
index 7a7a62f..8eae5da 100644 (file)
@@ -1,3 +1,7 @@
+2007-07-30  Jakub Jelinek  <jakub@redhat.com>
+
+       * tst-strptime.c (do_test): Use %tu in fmt string for ptrdiff_t value.
+
 2007-07-16  Jakub Jelinek  <jakub@redhat.com>
 
        * locales/ar_SA (d_t_fmt, d_fmt, t_fmt, t_fmt_ampm): Replace %.1d
index 4ee4fcb..b5ab232 100644 (file)
@@ -15,7 +15,7 @@ do_test (void)
   static const char s[] = "\
 \x54\x68\xb8\x6e\x67\x20\x6d\xad\xea\x69\x20\x6d\xe9\x74";
   char *r = strptime (s, "%b", &tm);
-  printf ("r = %p, r-s = %ju, tm.tm_mon = %d\n", r, r - s, tm.tm_mon);
+  printf ("r = %p, r-s = %tu, tm.tm_mon = %d\n", r, r - s, tm.tm_mon);
   return r == NULL || r - s != 14 || tm.tm_mon != 10;
 }
 
index a4740c9..4e7c7d7 100644 (file)
@@ -1,3 +1,463 @@
+2007-07-31  Anton Blanchard  <anton@samba.org>
+
+       * sysdeps/unix/sysv/linux/powerpc/sem_post.c (__new_sem_post):
+       Use __asm __volatile (__lll_acq_instr ::: "memory") instead of
+       atomic_full_barrier.
+
+2007-07-31  Jakub Jelinek  <jakub@redhat.com>
+
+       * allocatestack.c (stack_cache_lock): Change type to int.
+       (get_cached_stack, allocate_stack, __deallocate_stack,
+       __make_stacks_executable, __find_thread_by_id, __nptl_setxid,
+       __pthread_init_static_tls, __wait_lookup_done): Add LLL_PRIVATE
+       as second argument to lll_lock and lll_unlock macros on
+       stack_cache_lock.
+       * pthread_create.c (__find_in_stack_list): Likewise.
+       (start_thread): Similarly with pd->lock.  Use lll_robust_dead
+       macro instead of lll_robust_mutex_dead, pass LLL_SHARED to it
+       as second argument.
+       * descr.h (struct pthread): Change lock and setxid_futex field
+       type to int.
+       * old_pthread_cond_broadcast.c (__pthread_cond_broadcast_2_0): Use
+       LLL_LOCK_INITIALIZER instead of LLL_MUTEX_LOCK_INITIALIZER.
+       * old_pthread_cond_signal.c (__pthread_cond_signal_2_0): Likewise.
+       * old_pthread_cond_timedwait.c (__pthread_cond_timedwait_2_0):
+       Likewise.
+       * old_pthread_cond_wait.c (__pthread_cond_wait_2_0): Likewise.
+       * pthread_cond_init.c (__pthread_cond_init): Likewise.
+       * pthreadP.h (__attr_list_lock): Change type to int.
+       * pthread_attr_init.c (__attr_list_lock): Likewise.
+       * pthread_barrier_destroy.c (pthread_barrier_destroy): Pass
+       ibarrier->private ^ FUTEX_PRIVATE_FLAG as second argument to
+       lll_{,un}lock.
+       * pthread_barrier_wait.c (pthread_barrier_wait): Likewise and
+       also for lll_futex_{wake,wait}.
+       * pthread_barrier_init.c (pthread_barrier_init): Make iattr
+       a pointer to const.
+       * pthread_cond_broadcast.c (__pthread_cond_broadcast): Pass
+       LLL_SHARED as second argument to lll_{,un}lock.
+       * pthread_cond_destroy.c (__pthread_cond_destroy): Likewise.
+       * pthread_cond_signal.c (__pthread_cond_singal): Likewise.
+       * pthread_cond_timedwait.c (__pthread_cond_timedwait): Likewise.
+       * pthread_cond_wait.c (__condvar_cleanup, __pthread_cond_wait):
+       Likewise.
+       * pthread_getattr_np.c (pthread_getattr_np): Add LLL_PRIVATE
+       as second argument to lll_{,un}lock macros on pd->lock.
+       * pthread_getschedparam.c (__pthread_getschedparam): Likewise.
+       * pthread_setschedparam.c (__pthread_setschedparam): Likewise.
+       * pthread_setschedprio.c (pthread_setschedprio): Likewise.
+       * tpp.c (__pthread_tpp_change_priority, __pthread_current_priority):
+       Likewise.
+       * sysdeps/pthread/createthread.c (do_clone, create_thread):
+       Likewise.
+       * pthread_once.c (once_lock): Change type to int.
+       (__pthread_once): Pass LLL_PRIVATE as second argument to
+       lll_{,un}lock macros on once_lock.
+       * pthread_rwlock_rdlock.c (__pthread_rwlock_rdlock): Use
+       lll_{,un}lock macros instead of lll_mutex_{,un}lock, pass
+       rwlock->__data.__shared as second argument to them and similarly
+       for lll_futex_w*.
+       * pthread_rwlock_timedrdlock.c (pthread_rwlock_timedrdlock):
+       Likewise.
+       * pthread_rwlock_timedwrlock.c (pthread_rwlock_timedwrlock):
+       Likewise.
+       * pthread_rwlock_tryrdlock.c (__pthread_rwlock_tryrdlock): Likewise.
+       * pthread_rwlock_trywrlock.c (__pthread_rwlock_trywrlock): Likewise.
+       * pthread_rwlock_unlock.c (__pthread_rwlock_unlock): Likewise.
+       * pthread_rwlock_wrlock.c (__pthread_rwlock_wrlock): Likewise.
+       * sem_close.c (sem_close): Pass LLL_PRIVATE as second argument
+       to lll_{,un}lock macros on __sem_mappings_lock.
+       * sem_open.c (check_add_mapping): Likewise.
+       (__sem_mappings_lock): Change type to int.
+       * semaphoreP.h (__sem_mappings_lock): Likewise.
+       * pthread_mutex_lock.c (LLL_MUTEX_LOCK, LLL_MUTEX_TRYLOCK,
+       LLL_ROBUST_MUTEX_LOCK): Use lll_{,try,robust_}lock macros
+       instead of lll_*mutex_*, pass LLL_SHARED as last
+       argument.
+       (__pthread_mutex_lock): Use lll_unlock instead of lll_mutex_unlock,
+       pass LLL_SHARED as last argument.
+       * sysdeps/unix/sysv/linux/pthread_mutex_cond_lock.c (LLL_MUTEX_LOCK,
+       LLL_MUTEX_TRYLOCK, LLL_ROBUST_MUTEX_LOCK): Use
+       lll_{cond_,cond_try,robust_cond}lock macros instead of lll_*mutex_*,
+       pass LLL_SHARED as last argument.
+       * pthread_mutex_timedlock.c (pthread_mutex_timedlock): Use
+       lll_{timed,try,robust_timed,un}lock instead of lll_*mutex*, pass
+       LLL_SHARED as last argument.
+       * pthread_mutex_trylock.c (__pthread_mutex_trylock): Similarly.
+       * pthread_mutex_unlock.c (__pthread_mutex_unlock_usercnt):
+       Similarly.
+       * sysdeps/pthread/bits/libc-lock.h (__libc_lock_lock,
+       __libc_lock_lock_recursive, __libc_lock_unlock,
+       __libc_lock_unlock_recursive): Pass LLL_PRIVATE as second
+       argument to lll_{,un}lock.
+       * sysdeps/pthread/bits/stdio-lock.h (_IO_lock_lock,
+       _IO_lock_unlock): Likewise.
+       * sysdeps/unix/sysv/linux/fork.c (__libc_fork): Don't use
+       compound literal.
+       * sysdeps/unix/sysv/linux/unregister-atfork.c (__unregister_atfork):
+       Pass LLL_PRIVATE as second argument to lll_{,un}lock macros on
+       __fork_lock.
+       * sysdeps/unix/sysv/linux/register-atfork.c (__register_atfork,
+       free_mem): Likewise.
+       (__fork_lock): Change type to int.
+       * sysdeps/unix/sysv/linux/fork.h (__fork_lock): Likewise.
+       * sysdeps/unix/sysv/linux/sem_post.c (__new_sem_post): Pass
+       isem->private ^ FUTEX_PRIVATE_FLAG as second argument to
+       lll_futex_wake.
+       * sysdeps/unix/sysv/linux/sem_timedwait.c (sem_timedwait): Likewise.
+       * sysdeps/unix/sysv/linux/sem_wait.c (__new_sem_wait): Likewise.
+       * sysdeps/unix/sysv/linux/lowlevellock.c (__lll_lock_wait_private):
+       New function.
+       (__lll_lock_wait, __lll_timedlock_wait): Add private argument and
+       pass it through to lll_futex_*wait, only compile in when
+       IS_IN_libpthread.
+       * sysdeps/unix/sysv/linux/lowlevelrobustlock.c
+       (__lll_robust_lock_wait, __lll_robust_timedlock_wait): Add private
+       argument and pass it through to lll_futex_*wait.
+       * sysdeps/unix/sysv/linux/alpha/lowlevellock.h: Renamed all
+       lll_mutex_* resp. lll_robust_mutex_* macros to lll_* resp.
+       lll_robust_*.  Renamed all __lll_mutex_* resp. __lll_robust_mutex_*
+       inline functions to __lll_* resp. __lll_robust_*.
+       (LLL_MUTEX_LOCK_INITIALIZER): Remove.
+       (lll_mutex_dead): Add private argument.
+       (__lll_lock_wait_private): New prototype.
+       (__lll_lock_wait, __lll_robust_lock_wait, __lll_lock_timedwait,
+       __lll_robust_lock_timedwait): Add private argument to prototypes.
+       (__lll_lock): Add private argument, if it is constant LLL_PRIVATE,
+       call __lll_lock_wait_private, otherwise pass private to
+       __lll_lock_wait.
+       (__lll_robust_lock, __lll_cond_lock, __lll_timedlock,
+       __lll_robust_timedlock): Add private argument, pass it to
+       __lll_*wait functions.
+       (__lll_unlock): Add private argument, if it is constant LLL_PRIVATE,
+       call __lll_unlock_wake_private, otherwise pass private to
+       __lll_unlock_wake.
+       (__lll_robust_unlock): Add private argument, pass it to
+       __lll_robust_unlock_wake.
+       (lll_lock, lll_robust_lock, lll_cond_lock, lll_timedlock,
+       lll_robust_timedlock, lll_unlock, lll_robust_unlock): Add private
+       argument, pass it through to __lll_* inline function.
+       (__lll_mutex_unlock_force, lll_mutex_unlock_force): Remove.
+       (lll_lock_t): Remove.
+       (__lll_cond_wait, __lll_cond_timedwait, __lll_cond_wake,
+       __lll_cond_broadcast, lll_cond_wait, lll_cond_timedwait,
+       lll_cond_wake, lll_cond_broadcast): Remove.
+       * sysdeps/unix/sysv/linux/ia64/lowlevellock.h: Likewise.
+       * sysdeps/unix/sysv/linux/powerpc/lowlevellock.h: Likewise.
+       * sysdeps/unix/sysv/linux/s390/lowlevellock.h: Likewise.
+       * sysdeps/unix/sysv/linux/sparc/lowlevellock.h: Likewise.
+       * sysdeps/unix/sysv/linux/i386/lowlevellock.h: Allow including
+       the header from assembler.  Renamed all lll_mutex_* resp.
+       lll_robust_mutex_* macros to lll_* resp. lll_robust_*.
+       (LOCK, FUTEX_CMP_REQUEUE, FUTEX_WAKE_OP,
+       FUTEX_OP_CLEAR_WAKE_IF_GT_ONE): Define.
+       (LLL_MUTEX_LOCK_INITIALIZER, LLL_MUTEX_LOCK_INITIALIZER_LOCKED,
+       LLL_MUTEX_LOCK_INITIALIZER_WAITERS): Remove.
+       (__lll_mutex_lock_wait, __lll_mutex_timedlock_wait,
+       __lll_mutex_unlock_wake, __lll_lock_wait, __lll_unlock_wake):
+       Remove prototype.
+       (__lll_trylock_asm, __lll_lock_asm_start, __lll_unlock_asm): Define.
+       (lll_robust_trylock, lll_cond_trylock): Use LLL_LOCK_INITIALIZER*
+       rather than LLL_MUTEX_LOCK_INITIALIZER* macros.
+       (lll_trylock): Likewise, use __lll_trylock_asm, pass
+       MULTIPLE_THREADS_OFFSET as another asm operand.
+       (lll_lock): Add private argument, use __lll_lock_asm_start, pass
+       MULTIPLE_THREADS_OFFSET as last asm operand, call
+       __lll_lock_wait_private if private is constant LLL_PRIVATE,
+       otherwise pass private as another argument to __lll_lock_wait.
+       (lll_robust_lock, lll_cond_lock, lll_robust_cond_lock,
+       lll_timedlock, lll_robust_timedlock): Add private argument, pass
+       private as another argument to __lll_*lock_wait call.
+       (lll_unlock): Add private argument, use __lll_unlock_asm, pass
+       MULTIPLE_THREADS_OFFSET as another asm operand, call
+       __lll_unlock_wake_private if private is constant LLL_PRIVATE,
+       otherwise pass private as another argument to __lll_unlock_wake.
+       (lll_robust_unlock): Add private argument, pass private as another
+       argument to __lll_unlock_wake.
+       (lll_robust_dead): Add private argument, use __lll_private_flag
+       macro.
+       (lll_islocked): Use LLL_LOCK_INITIALIZER instead of
+       LLL_MUTEX_LOCK_INITIALIZER.
+       (lll_lock_t): Remove.
+       (LLL_LOCK_INITIALIZER_WAITERS): Define.
+       (__lll_cond_wait, __lll_cond_timedwait, __lll_cond_wake,
+       __lll_cond_broadcast, lll_cond_wait, lll_cond_timedwait,
+       lll_cond_wake, lll_cond_broadcast): Remove.
+       * sysdeps/unix/sysv/linux/x86_64/lowlevellock.h: Likewise.
+       * sysdeps/unix/sysv/linux/i386/i486/libc-lowlevellock.S: Revert
+       2007-05-2{3,9} changes.
+       * sysdeps/unix/sysv/linux/i386/i486/lowlevellock.S: Include
+       kernel-features.h and lowlevellock.h.
+       (LOAD_PRIVATE_FUTEX_WAIT): Define.
+       (LOAD_FUTEX_WAIT): Rewritten.
+       (LOCK, SYS_gettimeofday, SYS_futex, FUTEX_WAIT, FUTEX_WAKE): Don't
+       define.
+       (__lll_lock_wait_private, __lll_unlock_wake_private): New functions.
+       (__lll_mutex_lock_wait): Rename to ...
+       (__lll_lock_wait): ... this.  Take futex addr from %edx instead of
+       %ecx, %ecx is now private argument.  Don't compile in for libc.so.
+       (__lll_mutex_timedlock_wait): Rename to ...
+       (__lll_timedlock_wait): ... this.  Use __NR_gettimeofday.  %esi
+       contains private argument.  Don't compile in for libc.so.
+       (__lll_mutex_unlock_wake): Rename to ...
+       (__lll_unlock_wake): ... this.  %ecx contains private argument.
+       Don't compile in for libc.so.
+       (__lll_timedwait_tid): Use __NR_gettimeofday.
+       * sysdeps/unix/sysv/linux/i386/i486/lowlevelrobustlock.S: Include
+       kernel-features.h and lowlevellock.h.
+       (LOAD_FUTEX_WAIT): Define.
+       (LOCK, SYS_gettimeofday, SYS_futex, FUTEX_WAIT, FUTEX_WAKE): Don't
+       define.
+       (__lll_robust_mutex_lock_wait): Rename to ...
+       (__lll_robust_lock_wait): ... this.  Futex addr is now in %edx
+       argument, %ecx argument contains private.  Use LOAD_FUTEX_WAIT
+       macro.
+       (__lll_robust_mutex_timedlock_wait): Rename to ...
+       (__lll_robust_timedlock_wait): ... this.  Use __NR_gettimeofday.
+       %esi argument contains private, use LOAD_FUTEX_WAIT macro.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_barrier_wait.S: Include
+       lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (pthread_barrier_wait): Rename __lll_mutex_* to __lll_*, pass
+       PRIVATE(%ebx) ^ LLL_SHARED as private argument in %ecx to
+       __lll_lock_wait and __lll_unlock_wake, pass MUTEX(%ebx) address
+       to __lll_lock_wait in %edx.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_broadcast.S:
+       Include lowlevellock.h and pthread-errnos.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE,
+       FUTEX_CMP_REQUEUE, EINVAL, LOCK): Don't define.
+       (__pthread_cond_broadcast): Rename __lll_mutex_* to __lll_*, pass
+       cond_lock address in %edx rather than %ecx to __lll_lock_wait,
+       pass LLL_SHARED in %ecx to both __lll_lock_wait and
+       __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_signal.S:
+       Include lowlevellock.h and pthread-errnos.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_WAKE_OP,
+       FUTEX_OP_CLEAR_WAKE_IF_GT_ONE, EINVAL, LOCK): Don't define.
+       (__pthread_cond_signal): Rename __lll_mutex_* to __lll_*, pass
+       cond_lock address in %edx rather than %ecx to __lll_lock_wait,
+       pass LLL_SHARED in %ecx to both __lll_lock_wait and
+       __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S:
+       Include lowlevellock.h.
+       (SYS_futex, SYS_gettimeofday, FUTEX_WAIT, FUTEX_WAKE, LOCK):
+       Don't define.
+       (__pthread_cond_timedwait): Rename __lll_mutex_* to __lll_*, pass
+       cond_lock address in %edx rather than %ecx to __lll_lock_wait,
+       pass LLL_SHARED in %ecx to both __lll_lock_wait and
+       __lll_unlock_wake.  Use __NR_gettimeofday.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (__pthread_cond_wait, __condvar_w_cleanup): Rename __lll_mutex_*
+       to __lll_*, pass cond_lock address in %edx rather than %ecx to
+       __lll_lock_wait, pass LLL_SHARED in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_rdlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (__pthread_rwlock_rdlock): Rename __lll_mutex_* to __lll_*, pass
+       MUTEX(%ebx) address in %edx rather than %ecx to
+       __lll_lock_wait, pass PSHARED(%ebx) in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.  Move return value from %ecx to %edx
+       register.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedrdlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, SYS_gettimeofday, FUTEX_WAIT, FUTEX_WAKE, LOCK):
+       Don't define.
+       (__pthread_rwlock_wrlock): Rename __lll_mutex_* to __lll_*, pass
+       MUTEX(%ebp) address in %edx rather than %ecx to
+       __lll_lock_wait, pass PSHARED(%ebp) in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.  Move return value from %ecx to %edx
+       register.  Use __NR_gettimeofday.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedwrlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, SYS_gettimeofday, FUTEX_WAIT, FUTEX_WAKE, LOCK):
+       Don't define.
+       (__pthread_rwlock_wrlock): Rename __lll_mutex_* to __lll_*, pass
+       MUTEX(%ebp) address in %edx rather than %ecx to
+       __lll_lock_wait, pass PSHARED(%ebp) in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.  Move return value from %ecx to %edx
+       register.  Use __NR_gettimeofday.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_unlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (__pthread_rwlock_unlock): Rename __lll_mutex_* to __lll_*, pass
+       MUTEX(%edi) address in %edx rather than %ecx to
+       __lll_lock_wait, pass PSHARED(%edi) in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_wrlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (__pthread_rwlock_wrlock): Rename __lll_mutex_* to __lll_*, pass
+       MUTEX(%ebx) address in %edx rather than %ecx to
+       __lll_lock_wait, pass PSHARED(%ebx) in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.  Move return value from %ecx to %edx
+       register.
+       * sysdeps/unix/sysv/linux/i386/pthread_once.S: Include
+       lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG): Don't
+       define.
+       * sysdeps/unix/sysv/linux/i386/i486/sem_post.S: Include lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAKE): Don't define.
+       * sysdeps/unix/sysv/linux/i386/i486/sem_timedwait.S: Include
+       lowlevellock.h.
+       (LOCK, SYS_futex, SYS_gettimeofday, FUTEX_WAIT): Don't define.
+       (sem_timedwait): Use __NR_gettimeofday.
+       * sysdeps/unix/sysv/linux/i386/i486/sem_trywait.S: Include
+       lowlevellock.h.
+       (LOCK): Don't define.
+       * sysdeps/unix/sysv/linux/i386/i486/sem_wait.S: Include
+       lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAIT): Don't define.
+       * sysdeps/unix/sysv/linux/powerpc/sem_post.c: Wake only when there
+       are waiters.
+       * sysdeps/unix/sysv/linux/x86_64/libc-lowlevellock.S: Revert
+       2007-05-2{3,9} changes.
+       * sysdeps/unix/sysv/linux/x86_64/lowlevellock.S: Include
+       kernel-features.h and lowlevellock.h.
+       (LOAD_PRIVATE_FUTEX_WAIT): Define.
+       (LOAD_FUTEX_WAIT): Rewritten.
+       (LOCK, SYS_futex, FUTEX_WAIT, FUTEX_WAKE): Don't define.
+       (__lll_lock_wait_private, __lll_unlock_wake_private): New functions.
+       (__lll_mutex_lock_wait): Rename to ...
+       (__lll_lock_wait): ... this.  %esi is now private argument.
+       Don't compile in for libc.so.
+       (__lll_mutex_timedlock_wait): Rename to ...
+       (__lll_timedlock_wait): ... this.  %esi contains private argument.
+       Don't compile in for libc.so.
+       (__lll_mutex_unlock_wake): Rename to ...
+       (__lll_unlock_wake): ... this.  %esi contains private argument.
+       Don't compile in for libc.so.
+       * sysdeps/unix/sysv/linux/x86_64/lowlevelrobustlock.S: Include
+       kernel-features.h and lowlevellock.h.
+       (LOAD_FUTEX_WAIT): Define.
+       (LOCK, SYS_futex, FUTEX_WAIT, FUTEX_WAKE): Don't define.
+       (__lll_robust_mutex_lock_wait): Rename to ...
+       (__lll_robust_lock_wait): ... this.  %esi argument contains private.
+       Use LOAD_FUTEX_WAIT macro.
+       (__lll_robust_mutex_timedlock_wait): Rename to ...
+       (__lll_robust_timedlock_wait): ... this. %esi argument contains
+       private, use LOAD_FUTEX_WAIT macro.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_barrier_wait.S: Include
+       lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (pthread_barrier_wait): Rename __lll_mutex_* to __lll_*, pass
+       PRIVATE(%rdi) ^ LLL_SHARED as private argument in %esi to
+       __lll_lock_wait and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S:
+       Include lowlevellock.h and pthread-errnos.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE,
+       FUTEX_CMP_REQUEUE, EINVAL, LOCK): Don't define.
+       (__pthread_cond_broadcast): Rename __lll_mutex_* to __lll_*,
+       pass LLL_SHARED in %esi to both __lll_lock_wait and
+       __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S:
+       Include lowlevellock.h and pthread-errnos.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_WAKE_OP,
+       FUTEX_OP_CLEAR_WAKE_IF_GT_ONE, EINVAL, LOCK): Don't define.
+       (__pthread_cond_signal): Rename __lll_mutex_* to __lll_*,
+       pass LLL_SHARED in %esi to both __lll_lock_wait and
+       __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (__pthread_cond_timedwait): Rename __lll_mutex_* to __lll_*,
+       pass LLL_SHARED in %esi to both __lll_lock_wait and
+       __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, LOCK): Don't define.
+       (__pthread_cond_wait, __condvar_cleanup): Rename __lll_mutex_*
+       to __lll_*, pass LLL_SHARED in %esi to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_rdlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG, LOCK):
+       Don't define.
+       (__pthread_rwlock_rdlock): Rename __lll_mutex_* to __lll_*,
+       pass PSHARED(%rdi) in %esi to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_timedrdlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG, LOCK):
+       Don't define.
+       (__pthread_rwlock_wrlock): Rename __lll_mutex_* to __lll_*,
+       pass PSHARED(%rdi) in %esi to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_timedwrlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG, LOCK):
+       Don't define.
+       (__pthread_rwlock_wrlock): Rename __lll_mutex_* to __lll_*,
+       pass PSHARED(%rdi) in %esi to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_unlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG, LOCK):
+       Don't define.
+       (__pthread_rwlock_unlock): Rename __lll_mutex_* to __lll_*,
+       pass PSHARED(%rdi) in %esi to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_rwlock_wrlock.S:
+       Include lowlevellock.h.
+       (SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG, LOCK):
+       Don't define.
+       (__pthread_rwlock_wrlock): Rename __lll_mutex_* to __lll_*,
+       pass PSHARED(%rdi) in %ecx to both __lll_lock_wait
+       and __lll_unlock_wake.
+       * sysdeps/unix/sysv/linux/x86_64/pthread_once.S: Include
+       lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_PRIVATE_FLAG): Don't
+       define.
+       * sysdeps/unix/sysv/linux/x86_64/sem_post.S: Include lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAKE): Don't define.
+       * sysdeps/unix/sysv/linux/x86_64/sem_timedwait.S: Include
+       lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAIT): Don't define.
+       * sysdeps/unix/sysv/linux/x86_64/sem_trywait.S: Include
+       lowlevellock.h.
+       (LOCK): Don't define.
+       * sysdeps/unix/sysv/linux/x86_64/sem_wait.S: Include
+       lowlevellock.h.
+       (LOCK, SYS_futex, FUTEX_WAIT): Don't define.
+       * sysdeps/unix/sysv/linux/sparc/internaltypes.h: New file.
+       * sysdeps/unix/sysv/linux/sparc/pthread_barrier_destroy.c: New file.
+       * sysdeps/unix/sysv/linux/sparc/pthread_barrier_init.c: New file.
+       * sysdeps/unix/sysv/linux/sparc/pthread_barrier_wait.c: New file.
+       * sysdeps/unix/sysv/linux/sparc/sparc32/lowlevellock.c
+       (__lll_lock_wait_private): New function.
+       (__lll_lock_wait, __lll_timedlock_wait): Add private argument, pass
+       it to lll_futex_*wait.  Don't compile in for libc.so.
+       * sysdeps/unix/sysv/linux/sparc/sparc32/pthread_barrier_init.c:
+       Remove.
+       * sysdeps/unix/sysv/linux/sparc/sparc32/pthread_barrier_wait.c
+       (struct sparc_pthread_barrier): Remove.
+       (pthread_barrier_wait): Use union sparc_pthread_barrier instead of
+       struct sparc_pthread_barrier.  Pass
+       ibarrier->s.pshared ? LLL_SHARED : LLL_PRIVATE to lll_{,un}lock
+       and lll_futex_wait macros.
+       * sysdeps/unix/sysv/linux/sparc/sparc32/sparcv9/pthread_barrier_init.c:
+       Remove.
+       * sysdeps/unix/sysv/linux/sparc/sparc32/sparcv9/pthread_barrier_wait.c:
+       Include sparc pthread_barrier_wait.c instead of generic one.
+
+2007-07-30  Jakub Jelinek  <jakub@redhat.com>
+
+       * tst-rwlock14.c (do_test): Avoid warnings on 32-bit arches.
+
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedrdlock.S
+       (pthread_rwlock_timedrdlock): Copy futex retval to %esi rather than
+       %ecx.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_timedwrlock.S
+       (pthread_rwlock_timedwrlock): Likewise.
+       * sysdeps/unix/sysv/linux/i386/i486/pthread_rwlock_unlock.S
+       (__pthread_rwlock_unlock): Fix MUTEX != 0 args to __lll_*.
+
+2007-07-31  Jakub Jelinek  <jakub@redhat.com>
+
+       * sysdeps/sparc/tls.h (tcbhead_t): Add private_futex field.
+
 2007-07-26  Jakub Jelinek  <jakub@redhat.com>
 
        * tst-locale2.c (useless): Add return statement.
index ddf91e5..f30c88f 100644 (file)
@@ -103,7 +103,7 @@ static size_t stack_cache_maxsize = 40 * 1024 * 1024; /* 40MiBi by default.  */
 static size_t stack_cache_actsize;
 
 /* Mutex protecting this variable.  */
-static lll_lock_t stack_cache_lock = LLL_LOCK_INITIALIZER;
+static int stack_cache_lock = LLL_LOCK_INITIALIZER;
 
 /* List of queued stack frames.  */
 static LIST_HEAD (stack_cache);
@@ -139,7 +139,7 @@ get_cached_stack (size_t *sizep, void **memp)
   struct pthread *result = NULL;
   list_t *entry;
 
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   /* Search the cache for a matching entry.  We search for the
      smallest stack which has at least the required size.  Note that
@@ -172,7 +172,7 @@ get_cached_stack (size_t *sizep, void **memp)
       || __builtin_expect (result->stackblock_size > 4 * size, 0))
     {
       /* Release the lock.  */
-      lll_unlock (stack_cache_lock);
+      lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
       return NULL;
     }
@@ -187,7 +187,7 @@ get_cached_stack (size_t *sizep, void **memp)
   stack_cache_actsize -= result->stackblock_size;
 
   /* Release the lock early.  */
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
   /* Report size and location of the stack to the caller.  */
   *sizep = result->stackblock_size;
@@ -400,12 +400,12 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
 
 
       /* Prepare to modify global data.  */
-      lll_lock (stack_cache_lock);
+      lll_lock (stack_cache_lock, LLL_PRIVATE);
 
       /* And add to the list of stacks in use.  */
       list_add (&pd->list, &__stack_user);
 
-      lll_unlock (stack_cache_lock);
+      lll_unlock (stack_cache_lock, LLL_PRIVATE);
     }
   else
     {
@@ -544,12 +544,12 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
 
 
          /* Prepare to modify global data.  */
-         lll_lock (stack_cache_lock);
+         lll_lock (stack_cache_lock, LLL_PRIVATE);
 
          /* And add to the list of stacks in use.  */
          list_add (&pd->list, &stack_used);
 
-         lll_unlock (stack_cache_lock);
+         lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
 
          /* There might have been a race.  Another thread might have
@@ -598,12 +598,12 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
            mprot_error:
              err = errno;
 
-             lll_lock (stack_cache_lock);
+             lll_lock (stack_cache_lock, LLL_PRIVATE);
 
              /* Remove the thread from the list.  */
              list_del (&pd->list);
 
-             lll_unlock (stack_cache_lock);
+             lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
              /* Get rid of the TLS block we allocated.  */
              _dl_deallocate_tls (TLS_TPADJ (pd), false);
@@ -699,7 +699,7 @@ void
 internal_function
 __deallocate_stack (struct pthread *pd)
 {
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   /* Remove the thread from the list of threads with user defined
      stacks.  */
@@ -715,7 +715,7 @@ __deallocate_stack (struct pthread *pd)
     /* Free the memory associated with the ELF TLS.  */
     _dl_deallocate_tls (TLS_TPADJ (pd), false);
 
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 }
 
 
@@ -732,7 +732,7 @@ __make_stacks_executable (void **stack_endp)
   const size_t pagemask = ~(__getpagesize () - 1);
 #endif
 
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   list_t *runp;
   list_for_each (runp, &stack_used)
@@ -761,7 +761,7 @@ __make_stacks_executable (void **stack_endp)
          break;
       }
 
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
   return err;
 }
@@ -837,7 +837,7 @@ __find_thread_by_id (pid_t tid)
 {
   struct pthread *result = NULL;
 
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   /* Iterate over the list with system-allocated threads first.  */
   list_t *runp;
@@ -869,7 +869,7 @@ __find_thread_by_id (pid_t tid)
     }
 
  out:
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
   return result;
 }
@@ -920,7 +920,7 @@ attribute_hidden
 __nptl_setxid (struct xid_command *cmdp)
 {
   int result;
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   __xidcmd = cmdp;
   cmdp->cntr = 0;
@@ -966,7 +966,7 @@ __nptl_setxid (struct xid_command *cmdp)
       result = -1;
     }
 
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
   return result;
 }
 
@@ -995,7 +995,7 @@ void
 attribute_hidden
 __pthread_init_static_tls (struct link_map *map)
 {
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   /* Iterate over the list with system-allocated threads first.  */
   list_t *runp;
@@ -1006,7 +1006,7 @@ __pthread_init_static_tls (struct link_map *map)
   list_for_each (runp, &__stack_user)
     init_one_static_tls (list_entry (runp, struct pthread, list), map);
 
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 }
 
 
@@ -1014,7 +1014,7 @@ void
 attribute_hidden
 __wait_lookup_done (void)
 {
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   struct pthread *self = THREAD_SELF;
 
@@ -1063,5 +1063,5 @@ __wait_lookup_done (void)
       while (*gscope_flagp == THREAD_GSCOPE_FLAG_WAIT);
     }
 
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 }
index 3a3361d..3c00e14 100644 (file)
@@ -309,10 +309,10 @@ struct pthread
   int parent_cancelhandling;
 
   /* Lock to synchronize access to the descriptor.  */
-  lll_lock_t lock;
+  int lock;
 
   /* Lock for synchronizing setxid calls.  */
-  lll_lock_t setxid_futex;
+  int setxid_futex;
 
 #if HP_TIMING_AVAIL
   /* Offset of the CPU clock at start thread start time.  */
index 3852943..5ad6fa2 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -33,7 +33,7 @@ __pthread_cond_broadcast_2_0 (cond)
     {
       pthread_cond_t *newcond;
 
-#if LLL_MUTEX_LOCK_INITIALIZER == 0
+#if LLL_LOCK_INITIALIZER == 0
       newcond = (pthread_cond_t *) calloc (sizeof (pthread_cond_t), 1);
       if (newcond == NULL)
        return ENOMEM;
index 65beb0b..5b67f11 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -33,7 +33,7 @@ __pthread_cond_signal_2_0 (cond)
     {
       pthread_cond_t *newcond;
 
-#if LLL_MUTEX_LOCK_INITIALIZER == 0
+#if LLL_LOCK_INITIALIZER == 0
       newcond = (pthread_cond_t *) calloc (sizeof (pthread_cond_t), 1);
       if (newcond == NULL)
        return ENOMEM;
index 27c1093..2f09f3b 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -35,7 +35,7 @@ __pthread_cond_timedwait_2_0 (cond, mutex, abstime)
     {
       pthread_cond_t *newcond;
 
-#if LLL_MUTEX_LOCK_INITIALIZER == 0
+#if LLL_LOCK_INITIALIZER == 0
       newcond = (pthread_cond_t *) calloc (sizeof (pthread_cond_t), 1);
       if (newcond == NULL)
        return ENOMEM;
index 0a503a1..4f1caad 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -34,7 +34,7 @@ __pthread_cond_wait_2_0 (cond, mutex)
     {
       pthread_cond_t *newcond;
 
-#if LLL_MUTEX_LOCK_INITIALIZER == 0
+#if LLL_LOCK_INITIALIZER == 0
       newcond = (pthread_cond_t *) calloc (sizeof (pthread_cond_t), 1);
       if (newcond == NULL)
        return ENOMEM;
index 85fb9b8..82c0f1e 100644 (file)
@@ -151,7 +151,7 @@ hidden_proto (__stack_user)
 
 /* Attribute handling.  */
 extern struct pthread_attr *__attr_list attribute_hidden;
-extern lll_lock_t __attr_list_lock attribute_hidden;
+extern int __attr_list_lock attribute_hidden;
 
 /* First available RT signal.  */
 extern int __current_sigrtmin attribute_hidden;
index c84b33f..d9a309a 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -27,7 +27,7 @@
 
 
 struct pthread_attr *__attr_list;
-lll_lock_t __attr_list_lock = LLL_LOCK_INITIALIZER;
+int __attr_list_lock = LLL_LOCK_INITIALIZER;
 
 
 int
index 492b294..4951621 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -31,14 +31,14 @@ pthread_barrier_destroy (barrier)
 
   ibarrier = (struct pthread_barrier *) barrier;
 
-  lll_lock (ibarrier->lock);
+  lll_lock (ibarrier->lock, ibarrier->private ^ FUTEX_PRIVATE_FLAG);
 
   if (__builtin_expect (ibarrier->left == ibarrier->init_count, 1))
     /* The barrier is not used anymore.  */
     result = 0;
   else
     /* Still used, return with an error.  */
-    lll_unlock (ibarrier->lock);
+    lll_unlock (ibarrier->lock, ibarrier->private ^ FUTEX_PRIVATE_FLAG);
 
   return result;
 }
index 8dfc444..8e6edba 100644 (file)
@@ -40,7 +40,7 @@ pthread_barrier_init (barrier, attr, count)
   if (__builtin_expect (count == 0, 0))
     return EINVAL;
 
-  struct pthread_barrierattr *iattr
+  const struct pthread_barrierattr *iattr
     = (attr != NULL
        ? iattr = (struct pthread_barrierattr *) attr
        : &default_attr);
index e96a3e5..9d80cad 100644 (file)
@@ -32,7 +32,7 @@ pthread_barrier_wait (barrier)
   int result = 0;
 
   /* Make sure we are alone.  */
-  lll_lock (ibarrier->lock);
+  lll_lock (ibarrier->lock, ibarrier->private ^ FUTEX_PRIVATE_FLAG);
 
   /* One more arrival.  */
   --ibarrier->left;
@@ -46,8 +46,7 @@ pthread_barrier_wait (barrier)
 
       /* Wake up everybody.  */
       lll_futex_wake (&ibarrier->curr_event, INT_MAX,
-                     // XYZ check mutex flag
-                     LLL_SHARED);
+                     ibarrier->private ^ FUTEX_PRIVATE_FLAG);
 
       /* This is the thread which finished the serialization.  */
       result = PTHREAD_BARRIER_SERIAL_THREAD;
@@ -59,13 +58,12 @@ pthread_barrier_wait (barrier)
       unsigned int event = ibarrier->curr_event;
 
       /* Before suspending, make the barrier available to others.  */
-      lll_unlock (ibarrier->lock);
+      lll_unlock (ibarrier->lock, ibarrier->private ^ FUTEX_PRIVATE_FLAG);
 
       /* Wait for the event counter of the barrier to change.  */
       do
        lll_futex_wait (&ibarrier->curr_event, event,
-                       // XYZ check mutex flag
-                       LLL_SHARED);
+                       ibarrier->private ^ FUTEX_PRIVATE_FLAG);
       while (event == ibarrier->curr_event);
     }
 
@@ -75,7 +73,7 @@ pthread_barrier_wait (barrier)
   /* If this was the last woken thread, unlock.  */
   if (atomic_increment_val (&ibarrier->left) == init_count)
     /* We are done.  */
-    lll_unlock (ibarrier->lock);
+    lll_unlock (ibarrier->lock, ibarrier->private ^ FUTEX_PRIVATE_FLAG);
 
   return result;
 }
index aec33f3..5c0d76e 100644 (file)
@@ -33,7 +33,7 @@ __pthread_cond_broadcast (cond)
      pthread_cond_t *cond;
 {
   /* Make sure we are alone.  */
-  lll_mutex_lock (cond->__data.__lock);
+  lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* Are there any waiters to be woken?  */
   if (cond->__data.__total_seq > cond->__data.__wakeup_seq)
@@ -47,7 +47,7 @@ __pthread_cond_broadcast (cond)
       ++cond->__data.__broadcast_seq;
 
       /* We are done.  */
-      lll_mutex_unlock (cond->__data.__lock);
+      lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
       /* Do not use requeue for pshared condvars.  */
       if (cond->__data.__mutex == (void *) ~0l)
@@ -79,7 +79,7 @@ __pthread_cond_broadcast (cond)
     }
 
   /* We are done.  */
-  lll_mutex_unlock (cond->__data.__lock);
+  lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   return 0;
 }
index 8574b61..53b5cd2 100644 (file)
@@ -27,13 +27,13 @@ __pthread_cond_destroy (cond)
      pthread_cond_t *cond;
 {
   /* Make sure we are alone.  */
-  lll_mutex_lock (cond->__data.__lock);
+  lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   if (cond->__data.__total_seq > cond->__data.__wakeup_seq)
     {
       /* If there are still some waiters which have not been
         woken up, this is an application bug.  */
-      lll_mutex_unlock (cond->__data.__lock);
+      lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
       return EBUSY;
     }
 
@@ -66,13 +66,13 @@ __pthread_cond_destroy (cond)
 
       do
        {
-         lll_mutex_unlock (cond->__data.__lock);
+         lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
          lll_futex_wait (&cond->__data.__nwaiters, nwaiters,
                          // XYZ check mutex flag
                          LLL_SHARED);
 
-         lll_mutex_lock (cond->__data.__lock);
+         lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
          nwaiters = cond->__data.__nwaiters;
        }
index 7c6d4c1..a75b82b 100644 (file)
@@ -28,7 +28,7 @@ __pthread_cond_init (cond, cond_attr)
 {
   struct pthread_condattr *icond_attr = (struct pthread_condattr *) cond_attr;
 
-  cond->__data.__lock = LLL_MUTEX_LOCK_INITIALIZER;
+  cond->__data.__lock = LLL_LOCK_INITIALIZER;
   cond->__data.__futex = 0;
   cond->__data.__nwaiters = (icond_attr != NULL
                             && ((icond_attr->value
index a4faf41..f2de58f 100644 (file)
@@ -33,7 +33,7 @@ __pthread_cond_signal (cond)
      pthread_cond_t *cond;
 {
   /* Make sure we are alone.  */
-  lll_mutex_lock (cond->__data.__lock);
+  lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* Are there any waiters to be woken?  */
   if (cond->__data.__total_seq > cond->__data.__wakeup_seq)
@@ -56,7 +56,7 @@ __pthread_cond_signal (cond)
     }
 
   /* We are done.  */
-  lll_mutex_unlock (cond->__data.__lock);
+  lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   return 0;
 }
index d1c29d2..a8d95dc 100644 (file)
@@ -54,13 +54,13 @@ __pthread_cond_timedwait (cond, mutex, abstime)
     return EINVAL;
 
   /* Make sure we are along.  */
-  lll_mutex_lock (cond->__data.__lock);
+  lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* Now we can release the mutex.  */
   int err = __pthread_mutex_unlock_usercnt (mutex, 0);
   if (err)
     {
-      lll_mutex_unlock (cond->__data.__lock);
+      lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
       return err;
     }
 
@@ -146,7 +146,7 @@ __pthread_cond_timedwait (cond, mutex, abstime)
       unsigned int futex_val = cond->__data.__futex;
 
       /* Prepare to wait.  Release the condvar futex.  */
-      lll_mutex_unlock (cond->__data.__lock);
+      lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
       /* Enable asynchronous cancellation.  Required by the standard.  */
       cbuffer.oldtype = __pthread_enable_asynccancel ();
@@ -161,7 +161,7 @@ __pthread_cond_timedwait (cond, mutex, abstime)
       __pthread_disable_asynccancel (cbuffer.oldtype);
 
       /* We are going to look at shared data again, so get the lock.  */
-      lll_mutex_lock(cond->__data.__lock);
+      lll_lock(cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
       /* If a broadcast happened, we are done.  */
       if (cbuffer.bc_seq != cond->__data.__broadcast_seq)
@@ -203,7 +203,7 @@ __pthread_cond_timedwait (cond, mutex, abstime)
                    LLL_SHARED);
 
   /* We are done with the condvar.  */
-  lll_mutex_unlock (cond->__data.__lock);
+  lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* The cancellation handling is back to normal, remove the handler.  */
   __pthread_cleanup_pop (&buffer, 0);
index e524aa6..679655f 100644 (file)
@@ -45,7 +45,7 @@ __condvar_cleanup (void *arg)
   unsigned int destroying;
 
   /* We are going to modify shared data.  */
-  lll_mutex_lock (cbuffer->cond->__data.__lock);
+  lll_lock (cbuffer->cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   if (cbuffer->bc_seq == cbuffer->cond->__data.__broadcast_seq)
     {
@@ -78,7 +78,7 @@ __condvar_cleanup (void *arg)
     }
 
   /* We are done.  */
-  lll_mutex_unlock (cbuffer->cond->__data.__lock);
+  lll_unlock (cbuffer->cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* Wake everybody to make sure no condvar signal gets lost.  */
   if (! destroying)
@@ -102,13 +102,13 @@ __pthread_cond_wait (cond, mutex)
   int err;
 
   /* Make sure we are along.  */
-  lll_mutex_lock (cond->__data.__lock);
+  lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* Now we can release the mutex.  */
   err = __pthread_mutex_unlock_usercnt (mutex, 0);
   if (__builtin_expect (err, 0))
     {
-      lll_mutex_unlock (cond->__data.__lock);
+      lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
       return err;
     }
 
@@ -144,7 +144,7 @@ __pthread_cond_wait (cond, mutex)
       unsigned int futex_val = cond->__data.__futex;
 
       /* Prepare to wait.  Release the condvar futex.  */
-      lll_mutex_unlock (cond->__data.__lock);
+      lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
       /* Enable asynchronous cancellation.  Required by the standard.  */
       cbuffer.oldtype = __pthread_enable_asynccancel ();
@@ -158,7 +158,7 @@ __pthread_cond_wait (cond, mutex)
       __pthread_disable_asynccancel (cbuffer.oldtype);
 
       /* We are going to look at shared data again, so get the lock.  */
-      lll_mutex_lock (cond->__data.__lock);
+      lll_lock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
       /* If a broadcast happened, we are done.  */
       if (cbuffer.bc_seq != cond->__data.__broadcast_seq)
@@ -186,7 +186,7 @@ __pthread_cond_wait (cond, mutex)
                    LLL_SHARED);
 
   /* We are done with the condvar.  */
-  lll_mutex_unlock (cond->__data.__lock);
+  lll_unlock (cond->__data.__lock, /* XYZ */ LLL_SHARED);
 
   /* The cancellation handling is back to normal, remove the handler.  */
   __pthread_cleanup_pop (&buffer, 0);
index ca55903..3ab2fa4 100644 (file)
@@ -63,7 +63,7 @@ __find_in_stack_list (pd)
   list_t *entry;
   struct pthread *result = NULL;
 
-  lll_lock (stack_cache_lock);
+  lll_lock (stack_cache_lock, LLL_PRIVATE);
 
   list_for_each (entry, &stack_used)
     {
@@ -90,7 +90,7 @@ __find_in_stack_list (pd)
          }
       }
 
-  lll_unlock (stack_cache_lock);
+  lll_unlock (stack_cache_lock, LLL_PRIVATE);
 
   return result;
 }
@@ -284,9 +284,9 @@ start_thread (void *arg)
          int oldtype = CANCEL_ASYNC ();
 
          /* Get the lock the parent locked to force synchronization.  */
-         lll_lock (pd->lock);
+         lll_lock (pd->lock, LLL_PRIVATE);
          /* And give it up right away.  */
-         lll_unlock (pd->lock);
+         lll_unlock (pd->lock, LLL_PRIVATE);
 
          CANCEL_RESET (oldtype);
        }
@@ -370,7 +370,7 @@ start_thread (void *arg)
 # endif
          this->__list.__next = NULL;
 
-         lll_robust_mutex_dead (this->__lock);
+         lll_robust_dead (this->__lock, /* XYZ */ LLL_SHARED);
        }
       while (robust != (void *) &pd->robust_head);
     }
index 87cf564..9c25caf 100644 (file)
@@ -39,7 +39,7 @@ pthread_getattr_np (thread_id, attr)
   struct pthread_attr *iattr = (struct pthread_attr *) attr;
   int ret = 0;
 
-  lll_lock (thread->lock);
+  lll_lock (thread->lock, LLL_PRIVATE);
 
   /* The thread library is responsible for keeping the values in the
      thread desriptor up-to-date in case the user changes them.  */
@@ -173,7 +173,7 @@ pthread_getattr_np (thread_id, attr)
        }
     }
 
-  lll_unlock (thread->lock);
+  lll_unlock (thread->lock, LLL_PRIVATE);
 
   return ret;
 }
index 5e87130..d4e9459 100644 (file)
@@ -38,7 +38,7 @@ __pthread_getschedparam (threadid, policy, param)
 
   int result = 0;
 
-  lll_lock (pd->lock);
+  lll_lock (pd->lock, LLL_PRIVATE);
 
   /* The library is responsible for maintaining the values at all
      times.  If the user uses a interface other than
@@ -68,7 +68,7 @@ __pthread_getschedparam (threadid, policy, param)
       memcpy (param, &pd->schedparam, sizeof (struct sched_param));
     }
 
-  lll_unlock (pd->lock);
+  lll_unlock (pd->lock, LLL_PRIVATE);
 
   return result;
 }
index d0d6805..a82922e 100644 (file)
@@ -27,9 +27,9 @@
 
 
 #ifndef LLL_MUTEX_LOCK
-# define LLL_MUTEX_LOCK(mutex) lll_mutex_lock (mutex)
-# define LLL_MUTEX_TRYLOCK(mutex) lll_mutex_trylock (mutex)
-# define LLL_ROBUST_MUTEX_LOCK(mutex, id) lll_robust_mutex_lock (mutex, id)
+# define LLL_MUTEX_LOCK(mutex) lll_lock (mutex, /* XYZ */ LLL_SHARED)
+# define LLL_MUTEX_TRYLOCK(mutex) lll_trylock (mutex)
+# define LLL_ROBUST_MUTEX_LOCK(mutex, id) lll_robust_lock (mutex, id, /* XYZ */ LLL_SHARED)
 #endif
 
 
@@ -198,7 +198,7 @@ __pthread_mutex_lock (mutex)
            {
              /* This mutex is now not recoverable.  */
              mutex->__data.__count = 0;
-             lll_mutex_unlock (mutex->__data.__lock);
+             lll_unlock (mutex->__data.__lock, /* XYZ */ LLL_SHARED);
              THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
              return ENOTRECOVERABLE;
            }
index 825a984..7a0ed57 100644 (file)
@@ -56,7 +56,8 @@ pthread_mutex_timedlock (mutex, abstime)
        }
 
       /* We have to get the mutex.  */
-      result = lll_mutex_timedlock (mutex->__data.__lock, abstime);
+      result = lll_timedlock (mutex->__data.__lock, abstime,
+                             /* XYZ */ LLL_SHARED);
 
       if (result != 0)
        goto out;
@@ -76,14 +77,15 @@ pthread_mutex_timedlock (mutex, abstime)
     case PTHREAD_MUTEX_TIMED_NP:
     simple:
       /* Normal mutex.  */
-      result = lll_mutex_timedlock (mutex->__data.__lock, abstime);
+      result = lll_timedlock (mutex->__data.__lock, abstime,
+                             /* XYZ */ LLL_SHARED);
       break;
 
     case PTHREAD_MUTEX_ADAPTIVE_NP:
       if (! __is_smp)
        goto simple;
 
-      if (lll_mutex_trylock (mutex->__data.__lock) != 0)
+      if (lll_trylock (mutex->__data.__lock) != 0)
        {
          int cnt = 0;
          int max_cnt = MIN (MAX_ADAPTIVE_COUNT,
@@ -92,7 +94,8 @@ pthread_mutex_timedlock (mutex, abstime)
            {
              if (cnt++ >= max_cnt)
                {
-                 result = lll_mutex_timedlock (mutex->__data.__lock, abstime);
+                 result = lll_timedlock (mutex->__data.__lock, abstime,
+                                         /* XYZ */ LLL_SHARED);
                  break;
                }
 
@@ -100,7 +103,7 @@ pthread_mutex_timedlock (mutex, abstime)
              BUSY_WAIT_NOP;
 #endif
            }
-         while (lll_mutex_trylock (mutex->__data.__lock) != 0);
+         while (lll_trylock (mutex->__data.__lock) != 0);
 
          mutex->__data.__spins += (cnt - mutex->__data.__spins) / 8;
        }
@@ -174,15 +177,15 @@ pthread_mutex_timedlock (mutex, abstime)
                }
            }
 
-         result = lll_robust_mutex_timedlock (mutex->__data.__lock, abstime,
-                                              id);
+         result = lll_robust_timedlock (mutex->__data.__lock, abstime, id,
+                                        /* XYZ */ LLL_SHARED);
 
          if (__builtin_expect (mutex->__data.__owner
                                == PTHREAD_MUTEX_NOTRECOVERABLE, 0))
            {
              /* This mutex is now not recoverable.  */
              mutex->__data.__count = 0;
-             lll_mutex_unlock (mutex->__data.__lock);
+             lll_unlock (mutex->__data.__lock, /* XYZ */ LLL_SHARED);
              THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
              return ENOTRECOVERABLE;
            }
index 9a97a6c..9478d38 100644 (file)
@@ -48,7 +48,7 @@ __pthread_mutex_trylock (mutex)
          return 0;
        }
 
-      if (lll_mutex_trylock (mutex->__data.__lock) == 0)
+      if (lll_trylock (mutex->__data.__lock) == 0)
        {
          /* Record the ownership.  */
          mutex->__data.__owner = id;
@@ -62,7 +62,7 @@ __pthread_mutex_trylock (mutex)
     case PTHREAD_MUTEX_TIMED_NP:
     case PTHREAD_MUTEX_ADAPTIVE_NP:
       /* Normal mutex.  */
-      if (lll_mutex_trylock (mutex->__data.__lock) != 0)
+      if (lll_trylock (mutex->__data.__lock) != 0)
        break;
 
       /* Record the ownership.  */
@@ -140,7 +140,7 @@ __pthread_mutex_trylock (mutex)
                }
            }
 
-         oldval = lll_robust_mutex_trylock (mutex->__data.__lock, id);
+         oldval = lll_robust_trylock (mutex->__data.__lock, id);
          if (oldval != 0 && (oldval & FUTEX_OWNER_DIED) == 0)
            {
              THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
@@ -154,7 +154,7 @@ __pthread_mutex_trylock (mutex)
              /* This mutex is now not recoverable.  */
              mutex->__data.__count = 0;
              if (oldval == id)
-               lll_mutex_unlock (mutex->__data.__lock);
+               lll_unlock (mutex->__data.__lock, /* XYZ */ LLL_SHARED);
              THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
              return ENOTRECOVERABLE;
            }
index 642e3a4..6226089 100644 (file)
@@ -47,7 +47,7 @@ __pthread_mutex_unlock_usercnt (mutex, decr)
     case PTHREAD_MUTEX_ERRORCHECK_NP:
       /* Error checking mutex.  */
       if (mutex->__data.__owner != THREAD_GETMEM (THREAD_SELF, tid)
-         || ! lll_mutex_islocked (mutex->__data.__lock))
+         || ! lll_islocked (mutex->__data.__lock))
        return EPERM;
       /* FALLTHROUGH */
 
@@ -61,7 +61,7 @@ __pthread_mutex_unlock_usercnt (mutex, decr)
        --mutex->__data.__nusers;
 
       /* Unlock.  */
-      lll_mutex_unlock (mutex->__data.__lock);
+      lll_unlock (mutex->__data.__lock, /* XYZ */ LLL_SHARED);
       break;
 
     case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:
@@ -92,7 +92,7 @@ __pthread_mutex_unlock_usercnt (mutex, decr)
     case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:
       if ((mutex->__data.__lock & FUTEX_TID_MASK)
          != THREAD_GETMEM (THREAD_SELF, tid)
-         || ! lll_mutex_islocked (mutex->__data.__lock))
+         || ! lll_islocked (mutex->__data.__lock))
        return EPERM;
 
       /* If the previous owner died and the caller did not succeed in
@@ -115,7 +115,7 @@ __pthread_mutex_unlock_usercnt (mutex, decr)
        --mutex->__data.__nusers;
 
       /* Unlock.  */
-      lll_robust_mutex_unlock (mutex->__data.__lock);
+      lll_robust_unlock (mutex->__data.__lock, /* XYZ */ LLL_SHARED);
 
       THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
       break;
@@ -161,7 +161,7 @@ __pthread_mutex_unlock_usercnt (mutex, decr)
     case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
       if ((mutex->__data.__lock & FUTEX_TID_MASK)
          != THREAD_GETMEM (THREAD_SELF, tid)
-         || ! lll_mutex_islocked (mutex->__data.__lock))
+         || ! lll_islocked (mutex->__data.__lock))
        return EPERM;
 
       /* If the previous owner died and the caller did not succeed in
index 9b2cef8..306af0a 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -22,7 +22,7 @@
 
 
 
-static lll_lock_t once_lock = LLL_LOCK_INITIALIZER;
+static int once_lock = LLL_LOCK_INITIALIZER;
 
 
 int
@@ -35,7 +35,7 @@ __pthread_once (once_control, init_routine)
      object.  */
   if (*once_control == PTHREAD_ONCE_INIT)
     {
-      lll_lock (once_lock);
+      lll_lock (once_lock, LLL_PRIVATE);
 
       /* XXX This implementation is not complete.  It doesn't take
         cancelation and fork into account.  */
@@ -46,7 +46,7 @@ __pthread_once (once_control, init_routine)
          *once_control = !PTHREAD_ONCE_INIT;
        }
 
-      lll_unlock (once_lock);
+      lll_unlock (once_lock, LLL_PRIVATE);
     }
 
   return 0;
index b8f9d41..31eb508 100644 (file)
@@ -32,7 +32,7 @@ __pthread_rwlock_rdlock (rwlock)
   int result = 0;
 
   /* Make sure we are along.  */
-  lll_mutex_lock (rwlock->__data.__lock);
+  lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   while (1)
     {
@@ -74,21 +74,20 @@ __pthread_rwlock_rdlock (rwlock)
       int waitval = rwlock->__data.__readers_wakeup;
 
       /* Free the lock.  */
-      lll_mutex_unlock (rwlock->__data.__lock);
+      lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* Wait for the writer to finish.  */
-      lll_futex_wait (&rwlock->__data.__readers_wakeup, waitval, 
-                     // XYZ check mutex flag
-                     LLL_SHARED);
+      lll_futex_wait (&rwlock->__data.__readers_wakeup, waitval,
+                     rwlock->__data.__shared);
 
       /* Get the lock.  */
-      lll_mutex_lock (rwlock->__data.__lock);
+      lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       --rwlock->__data.__nr_readers_queued;
     }
 
   /* We are done, free the lock.  */
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   return result;
 }
index 654d628..fcd10aa 100644 (file)
@@ -33,7 +33,7 @@ pthread_rwlock_timedrdlock (rwlock, abstime)
   int result = 0;
 
   /* Make sure we are along.  */
-  lll_mutex_lock(rwlock->__data.__lock);
+  lll_lock(rwlock->__data.__lock, rwlock->__data.__shared);
 
   while (1)
     {
@@ -110,16 +110,14 @@ pthread_rwlock_timedrdlock (rwlock, abstime)
       int waitval = rwlock->__data.__readers_wakeup;
 
       /* Free the lock.  */
-      lll_mutex_unlock (rwlock->__data.__lock);
+      lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* Wait for the writer to finish.  */
       err = lll_futex_timed_wait (&rwlock->__data.__readers_wakeup,
-                                 waitval, &rt,
-                                 // XYZ check mutex flag
-                                 LLL_SHARED);
+                                 waitval, &rt, rwlock->__data.__shared);
 
       /* Get the lock.  */
-      lll_mutex_lock (rwlock->__data.__lock);
+      lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       --rwlock->__data.__nr_readers_queued;
 
@@ -133,7 +131,7 @@ pthread_rwlock_timedrdlock (rwlock, abstime)
     }
 
   /* We are done, free the lock.  */
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   return result;
 }
index 354beb0..e6283f4 100644 (file)
@@ -33,7 +33,7 @@ pthread_rwlock_timedwrlock (rwlock, abstime)
   int result = 0;
 
   /* Make sure we are along.  */
-  lll_mutex_lock (rwlock->__data.__lock);
+  lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   while (1)
     {
@@ -100,16 +100,14 @@ pthread_rwlock_timedwrlock (rwlock, abstime)
       int waitval = rwlock->__data.__writer_wakeup;
 
       /* Free the lock.  */
-      lll_mutex_unlock (rwlock->__data.__lock);
+      lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* Wait for the writer or reader(s) to finish.  */
       err = lll_futex_timed_wait (&rwlock->__data.__writer_wakeup,
-                                 waitval, &rt,
-                                 // XYZ check mutex flag
-                                 LLL_SHARED);
+                                 waitval, &rt, rwlock->__data.__shared);
 
       /* Get the lock.  */
-      lll_mutex_lock (rwlock->__data.__lock);
+      lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* To start over again, remove the thread from the writer list.  */
       --rwlock->__data.__nr_writers_queued;
@@ -123,7 +121,7 @@ pthread_rwlock_timedwrlock (rwlock, abstime)
     }
 
   /* We are done, free the lock.  */
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   return result;
 }
index df8863b..8461e1b 100644 (file)
@@ -28,7 +28,7 @@ __pthread_rwlock_tryrdlock (rwlock)
 {
   int result = EBUSY;
 
-  lll_mutex_lock (rwlock->__data.__lock);
+  lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   if (rwlock->__data.__writer == 0
       && (rwlock->__data.__nr_writers_queued == 0
@@ -43,7 +43,7 @@ __pthread_rwlock_tryrdlock (rwlock)
        result = 0;
     }
 
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   return result;
 }
index b754a19..5111f9c 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -28,7 +28,7 @@ __pthread_rwlock_trywrlock (rwlock)
 {
   int result = EBUSY;
 
-  lll_mutex_lock (rwlock->__data.__lock);
+  lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   if (rwlock->__data.__writer == 0 && rwlock->__data.__nr_readers == 0)
     {
@@ -36,7 +36,7 @@ __pthread_rwlock_trywrlock (rwlock)
       result = 0;
     }
 
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   return result;
 }
index 87a77a9..a7ef71a 100644 (file)
@@ -27,7 +27,7 @@
 int
 __pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
 {
-  lll_mutex_lock (rwlock->__data.__lock);
+  lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
   if (rwlock->__data.__writer)
     rwlock->__data.__writer = 0;
   else
@@ -37,23 +37,21 @@ __pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
       if (rwlock->__data.__nr_writers_queued)
        {
          ++rwlock->__data.__writer_wakeup;
-         lll_mutex_unlock (rwlock->__data.__lock);
+         lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
          lll_futex_wake (&rwlock->__data.__writer_wakeup, 1,
-                         // XYZ check mutex flag
-                         LLL_SHARED);
+                         rwlock->__data.__shared);
          return 0;
        }
       else if (rwlock->__data.__nr_readers_queued)
        {
          ++rwlock->__data.__readers_wakeup;
-         lll_mutex_unlock (rwlock->__data.__lock);
+         lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
          lll_futex_wake (&rwlock->__data.__readers_wakeup, INT_MAX,
-                         // XYZ check mutex flag
-                         LLL_SHARED);
+                         rwlock->__data.__shared);
          return 0;
        }
     }
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
   return 0;
 }
 
index 134b3e9..64fe970 100644 (file)
@@ -32,7 +32,7 @@ __pthread_rwlock_wrlock (rwlock)
   int result = 0;
 
   /* Make sure we are along.  */
-  lll_mutex_lock (rwlock->__data.__lock);
+  lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   while (1)
     {
@@ -65,22 +65,21 @@ __pthread_rwlock_wrlock (rwlock)
       int waitval = rwlock->__data.__writer_wakeup;
 
       /* Free the lock.  */
-      lll_mutex_unlock (rwlock->__data.__lock);
+      lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* Wait for the writer or reader(s) to finish.  */
       lll_futex_wait (&rwlock->__data.__writer_wakeup, waitval,
-                     // XYZ check mutex flag
-                     LLL_SHARED);
+                     rwlock->__data.__shared);
 
       /* Get the lock.  */
-      lll_mutex_lock (rwlock->__data.__lock);
+      lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* To start over again, remove the thread from the writer list.  */
       --rwlock->__data.__nr_writers_queued;
     }
 
   /* We are done, free the lock.  */
-  lll_mutex_unlock (rwlock->__data.__lock);
+  lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
   return result;
 }
index 8129dec..1b0062f 100644 (file)
@@ -39,7 +39,7 @@ __pthread_setschedparam (threadid, policy, param)
 
   int result = 0;
 
-  lll_lock (pd->lock);
+  lll_lock (pd->lock, LLL_PRIVATE);
 
   struct sched_param p;
   const struct sched_param *orig_param = param;
@@ -67,7 +67,7 @@ __pthread_setschedparam (threadid, policy, param)
       pd->flags |= ATTR_FLAG_SCHED_SET | ATTR_FLAG_POLICY_SET;
     }
 
-  lll_unlock (pd->lock);
+  lll_unlock (pd->lock, LLL_PRIVATE);
 
   return result;
 }
index 59462ec..c99f7ce 100644 (file)
@@ -41,7 +41,7 @@ pthread_setschedprio (threadid, prio)
   struct sched_param param;
   param.sched_priority = prio;
 
-  lll_lock (pd->lock);
+  lll_lock (pd->lock, LLL_PRIVATE);
 
   /* If the thread should have higher priority because of some
      PTHREAD_PRIO_PROTECT mutexes it holds, adjust the priority.  */
@@ -60,7 +60,7 @@ pthread_setschedprio (threadid, prio)
       pd->flags |= ATTR_FLAG_SCHED_SET;
     }
 
-  lll_unlock (pd->lock);
+  lll_unlock (pd->lock, LLL_PRIVATE);
 
   return result;
 }
index 279522d..9bde63d 100644 (file)
@@ -47,7 +47,7 @@ sem_close (sem)
   int result = 0;
 
   /* Get the lock.  */
-  lll_lock (__sem_mappings_lock);
+  lll_lock (__sem_mappings_lock, LLL_PRIVATE);
 
   /* Locate the entry for the mapping the caller provided.  */
   rec = NULL;
@@ -75,7 +75,7 @@ sem_close (sem)
     }
 
   /* Release the lock.  */
-  lll_unlock (__sem_mappings_lock);
+  lll_unlock (__sem_mappings_lock, LLL_PRIVATE);
 
   return result;
 }
index 27d308e..e58dde9 100644 (file)
@@ -147,7 +147,7 @@ __sem_search (const void *a, const void *b)
 void *__sem_mappings attribute_hidden;
 
 /* Lock to protect the search tree.  */
-lll_lock_t __sem_mappings_lock attribute_hidden = LLL_LOCK_INITIALIZER;
+int __sem_mappings_lock attribute_hidden = LLL_LOCK_INITIALIZER;
 
 
 /* Search for existing mapping and if possible add the one provided.  */
@@ -161,7 +161,7 @@ check_add_mapping (const char *name, size_t namelen, int fd, sem_t *existing)
   if (__fxstat64 (_STAT_VER, fd, &st) == 0)
     {
       /* Get the lock.  */
-      lll_lock (__sem_mappings_lock);
+      lll_lock (__sem_mappings_lock, LLL_PRIVATE);
 
       /* Search for an existing mapping given the information we have.  */
       struct inuse_sem *fake;
@@ -210,7 +210,7 @@ check_add_mapping (const char *name, size_t namelen, int fd, sem_t *existing)
        }
 
       /* Release the lock.  */
-      lll_unlock (__sem_mappings_lock);
+      lll_unlock (__sem_mappings_lock, LLL_PRIVATE);
     }
 
   if (result != existing && existing != SEM_FAILED && existing != MAP_FAILED)
index 9659059..7d6fd25 100644 (file)
@@ -48,7 +48,7 @@ extern pthread_once_t __namedsem_once attribute_hidden;
 extern void *__sem_mappings attribute_hidden;
 
 /* Lock to protect the search tree.  */
-extern lll_lock_t __sem_mappings_lock attribute_hidden;
+extern int __sem_mappings_lock attribute_hidden;
 
 
 /* Initializer for mountpoint.  */
index 0c8c0ad..45eba06 100644 (file)
@@ -228,7 +228,7 @@ typedef pthread_key_t __libc_key_t;
 /* Lock the named lock variable.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # define __libc_lock_lock(NAME) \
-  ({ lll_lock (NAME); 0; })
+  ({ lll_lock (NAME, LLL_PRIVATE); 0; })
 #else
 # define __libc_lock_lock(NAME) \
   __libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0)
@@ -245,7 +245,7 @@ typedef pthread_key_t __libc_key_t;
     void *self = THREAD_SELF;                                                \
     if ((NAME).owner != self)                                                \
       {                                                                              \
-       lll_lock ((NAME).lock);                                               \
+       lll_lock ((NAME).lock, LLL_PRIVATE);                                  \
        (NAME).owner = self;                                                  \
       }                                                                              \
     ++(NAME).cnt;                                                            \
@@ -299,7 +299,7 @@ typedef pthread_key_t __libc_key_t;
 /* Unlock the named lock variable.  */
 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
 # define __libc_lock_unlock(NAME) \
-  lll_unlock (NAME)
+  lll_unlock (NAME, LLL_PRIVATE)
 #else
 # define __libc_lock_unlock(NAME) \
   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
@@ -315,7 +315,7 @@ typedef pthread_key_t __libc_key_t;
     if (--(NAME).cnt == 0)                                                   \
       {                                                                              \
        (NAME).owner = NULL;                                                  \
-       lll_unlock ((NAME).lock);                                             \
+       lll_unlock ((NAME).lock, LLL_PRIVATE);                                \
       }                                                                              \
   } while (0)
 #else
index 5f23821..b8efdd8 100644 (file)
@@ -42,7 +42,7 @@ typedef struct { int lock; int cnt; void *owner; } _IO_lock_t;
     void *__self = THREAD_SELF;                                                      \
     if ((_name).owner != __self)                                             \
       {                                                                              \
-        lll_lock ((_name).lock);                                             \
+       lll_lock ((_name).lock, LLL_PRIVATE);                                 \
         (_name).owner = __self;                                                      \
       }                                                                              \
     ++(_name).cnt;                                                           \
@@ -72,7 +72,7 @@ typedef struct { int lock; int cnt; void *owner; } _IO_lock_t;
     if (--(_name).cnt == 0)                                                  \
       {                                                                              \
         (_name).owner = NULL;                                                \
-        lll_unlock ((_name).lock);                                           \
+       lll_unlock ((_name).lock, LLL_PRIVATE);                               \
       }                                                                              \
   } while (0)
 
index 88658a1..66571b2 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -60,7 +60,7 @@ do_clone (struct pthread *pd, const struct pthread_attr *attr,
     /* We Make sure the thread does not run far by forcing it to get a
        lock.  We lock it here too so that the new thread cannot continue
        until we tell it to.  */
-    lll_lock (pd->lock);
+    lll_lock (pd->lock, LLL_PRIVATE);
 
   /* One more thread.  We cannot have the thread do this itself, since it
      might exist but not have been scheduled yet by the time we've returned
@@ -223,7 +223,7 @@ create_thread (struct pthread *pd, const struct pthread_attr *attr,
              __nptl_create_event ();
 
              /* And finally restart the new thread.  */
-             lll_unlock (pd->lock);
+             lll_unlock (pd->lock, LLL_PRIVATE);
            }
 
          return res;
@@ -250,7 +250,7 @@ create_thread (struct pthread *pd, const struct pthread_attr *attr,
 
   if (res == 0 && stopped)
     /* And finally restart the new thread.  */
-    lll_unlock (pd->lock);
+    lll_unlock (pd->lock, LLL_PRIVATE);
 
   return res;
 }
index 601b537..dc1b386 100644 (file)
@@ -27,6 +27,7 @@
 # include <stdint.h>
 # include <stdlib.h>
 # include <list.h>
+# include <kernel-features.h>
 
 /* Type for the dtv.  */
 typedef union dtv
@@ -55,6 +56,9 @@ typedef struct
 #if __WORDSIZE != 64
   int gscope_flag;
 #endif
+#ifndef __ASSUME_PRIVATE_FUTEX
+  int private_futex;
+#endif
 } tcbhead_t;
 
 #else /* __ASSEMBLER__ */
index 5f08673..f3f2919 100644 (file)
@@ -70,9 +70,6 @@
 #endif
 
 
-/* Initializer for compatibility lock. */
-#define LLL_MUTEX_LOCK_INITIALIZER (0)
-
 #define lll_futex_wait(futexp, val, private) \
   lll_futex_timed_wait (futexp, val, NULL, private)
 
@@ -96,7 +93,7 @@
     INTERNAL_SYSCALL_ERROR_P (__ret, __err)? -__ret : __ret;                 \
   })
 
-#define lll_robust_mutex_dead(futexv) \
+#define lll_robust_dead(futexv) \
   do                                                                         \
     {                                                                        \
       int *__futexp = &(futexv);                                             \
 
 
 static inline int __attribute__((always_inline))
-__lll_mutex_trylock(int *futex)
+__lll_trylock(int *futex)
 {
   return atomic_compare_and_exchange_val_acq (futex, 1, 0) != 0;
 }
-#define lll_mutex_trylock(lock)        __lll_mutex_trylock (&(lock))
+#define lll_trylock(lock)      __lll_trylock (&(lock))
 
 
 static inline int __attribute__((always_inline))
-__lll_mutex_cond_trylock(int *futex)
+__lll_cond_trylock(int *futex)
 {
   return atomic_compare_and_exchange_val_acq (futex, 2, 0) != 0;
 }
-#define lll_mutex_cond_trylock(lock)   __lll_mutex_cond_trylock (&(lock))
+#define lll_cond_trylock(lock) __lll_cond_trylock (&(lock))
 
 
 static inline int __attribute__((always_inline))
-__lll_robust_mutex_trylock(int *futex, int id)
+__lll_robust_trylock(int *futex, int id)
 {
   return atomic_compare_and_exchange_val_acq (futex, id, 0) != 0;
 }
-#define lll_robust_mutex_trylock(lock, id) \
-  __lll_robust_mutex_trylock (&(lock), id)
+#define lll_robust_trylock(lock, id) \
+  __lll_robust_trylock (&(lock), id)
 
-extern void __lll_lock_wait (int *futex) attribute_hidden;
-extern int __lll_robust_lock_wait (int *futex) attribute_hidden;
+extern void __lll_lock_wait_private (int *futex) attribute_hidden;
+extern void __lll_lock_wait (int *futex, int private) attribute_hidden;
+extern int __lll_robust_lock_wait (int *futex, int private) attribute_hidden;
 
 static inline void __attribute__((always_inline))
-__lll_mutex_lock(int *futex)
+__lll_lock(int *futex, int private)
 {
   if (atomic_compare_and_exchange_bool_acq (futex, 1, 0) != 0)
-    __lll_lock_wait (futex);
+    {
+      if (__builtin_constant_p (private) && private == LLL_PRIVATE)
+       __lll_lock_wait_private (futex);
+      else
+       __lll_lock_wait (futex, private);
+    }
 }
-#define lll_mutex_lock(futex) __lll_mutex_lock (&(futex))
+#define lll_lock(futex, private) __lll_lock (&(futex), private)
 
 
 static inline int __attribute__ ((always_inline))
-__lll_robust_mutex_lock (int *futex, int id)
+__lll_robust_lock (int *futex, int id, int private)
 {
   int result = 0;
   if (atomic_compare_and_exchange_bool_acq (futex, id, 0) != 0)
-    result = __lll_robust_lock_wait (futex);
+    result = __lll_robust_lock_wait (futex, private);
   return result;
 }
-#define lll_robust_mutex_lock(futex, id) \
-  __lll_robust_mutex_lock (&(futex), id)
+#define lll_robust_lock(futex, id, private) \
+  __lll_robust_lock (&(futex), id, private)
 
 
 static inline void __attribute__ ((always_inline))
-__lll_mutex_cond_lock (int *futex)
+__lll_cond_lock (int *futex, int private)
 {
   if (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0)
-    __lll_lock_wait (futex);
+    __lll_lock_wait (futex, private);
 }
-#define lll_mutex_cond_lock(futex) __lll_mutex_cond_lock (&(futex))
+#define lll_cond_lock(futex, private) __lll_cond_lock (&(futex), private)
 
 
-#define lll_robust_mutex_cond_lock(futex, id) \
-  __lll_robust_mutex_lock (&(futex), (id) | FUTEX_WAITERS)
+#define lll_robust_cond_lock(futex, id, private) \
+  __lll_robust_lock (&(futex), (id) | FUTEX_WAITERS, private)
 
 
-extern int __lll_timedlock_wait (int *futex, const struct timespec *)
-       attribute_hidden;
-extern int __lll_robust_timedlock_wait (int *futex, const struct timespec *)
-       attribute_hidden;
+extern int __lll_timedlock_wait (int *futex, const struct timespec *,
+                                int private) attribute_hidden;
+extern int __lll_robust_timedlock_wait (int *futex, const struct timespec *,
+                                       int private) attribute_hidden;
 
 static inline int __attribute__ ((always_inline))
-__lll_mutex_timedlock (int *futex, const struct timespec *abstime)
+__lll_timedlock (int *futex, const struct timespec *abstime, int private)
 {
   int result = 0;
   if (atomic_compare_and_exchange_bool_acq (futex, 1, 0) != 0)
-    result = __lll_timedlock_wait (futex, abstime);
+    result = __lll_timedlock_wait (futex, abstime, private);
   return result;
 }
-#define lll_mutex_timedlock(futex, abstime) \
-  __lll_mutex_timedlock (&(futex), abstime)
+#define lll_timedlock(futex, abstime, private) \
+  __lll_timedlock (&(futex), abstime, private)
 
 
 static inline int __attribute__ ((always_inline))
-__lll_robust_mutex_timedlock (int *futex, const struct timespec *abstime,
-                             int id)
+__lll_robust_timedlock (int *futex, const struct timespec *abstime,
+                       int id, int private)
 {
   int result = 0;
   if (atomic_compare_and_exchange_bool_acq (futex, id, 0) != 0)
     result = __lll_robust_timedlock_wait (futex, abstime);
   return result;
 }
-#define lll_robust_mutex_timedlock(futex, abstime, id) \
-  __lll_robust_mutex_timedlock (&(futex), abstime, id)
+#define lll_robust_timedlock(futex, abstime, id, private) \
+  __lll_robust_timedlock (&(futex), abstime, id, private)
 
 
 static inline void __attribute__ ((always_inline))
-__lll_mutex_unlock (int *futex)
+__lll_unlock (int *futex, int private)
 {
   int val = atomic_exchange_rel (futex, 0);
   if (__builtin_expect (val > 1, 0))
-    lll_futex_wake (futex, 1, LLL_SHARED);
+    lll_futex_wake (futex, 1, private);
 }
-#define lll_mutex_unlock(futex) __lll_mutex_unlock(&(futex))
+#define lll_unlock(futex, private) __lll_unlock(&(futex), private)
 
 
 static inline void __attribute__ ((always_inline))
-__lll_robust_mutex_unlock (int *futex, int mask)
+__lll_robust_unlock (int *futex, int private)
 {
   int val = atomic_exchange_rel (futex, 0);
-  if (__builtin_expect (val & mask, 0))
-    lll_futex_wake (futex, 1, LLL_SHARED);
+  if (__builtin_expect (val & FUTEX_WAITERS, 0))
+    lll_futex_wake (futex, 1, private);
 }
-#define lll_robust_mutex_unlock(futex) \
-  __lll_robust_mutex_unlock(&(futex), FUTEX_WAITERS)
-
+#define lll_robust_unlock(futex, private) \
+  __lll_robust_unlock(&(futex), private)
 
-static inline void __attribute__ ((always_inline))
-__lll_mutex_unlock_force (int *futex)
-{
-  (void) atomic_exchange_rel (futex, 0);
-  lll_futex_wake (futex, 1, LLL_SHARED);
-}
-#define lll_mutex_unlock_force(futex) __lll_mutex_unlock_force(&(futex))
 
-
-#define lll_mutex_islocked(futex) \
+#define lll_islocked(futex) \
   (futex != 0)
 
-
-/* Our internal lock implementation is identical to the binary-compatible
-   mutex implementation. */
-
-/* Type for lock object.  */
-typedef int lll_lock_t;
-
 /* Initializers for lock.  */
 #define LLL_LOCK_INITIALIZER           (0)
 #define LLL_LOCK_INITIALIZER_LOCKED    (1)
 
-/* The states of a lock are:
-    0  -  untaken
-    1  -  taken by one user
-   >1  -  taken by more users */
-
-#define lll_trylock(lock)      lll_mutex_trylock (lock)
-#define lll_lock(lock)         lll_mutex_lock (lock)
-#define lll_unlock(lock)       lll_mutex_unlock (lock)
-#define lll_islocked(lock)     lll_mutex_islocked (lock)
 
 /* The kernel notifies a process which uses CLONE_CLEARTID via futex
    wakeup when the clone terminates.  The memory location contains the
@@ -298,26 +276,4 @@ extern int __lll_timedwait_tid (int *, const struct timespec *)
     __res;                                             \
   })
 
-
-/* Conditional variable handling.  */
-
-extern void __lll_cond_wait (pthread_cond_t *cond)
-     attribute_hidden;
-extern int __lll_cond_timedwait (pthread_cond_t *cond,
-                                const struct timespec *abstime)
-     attribute_hidden;
-extern void __lll_cond_wake (pthread_cond_t *cond)
-     attribute_hidden;
-extern void __lll_cond_broadcast (pthread_cond_t *cond)
-     attribute_hidden;
-
-#define lll_cond_wait(cond) \
-  __lll_cond_wait (cond)
-#define lll_cond_timedwait(cond, abstime) \
-  __lll_cond_timedwait (cond, abstime)
-#define lll_cond_wake(cond) \
-  __lll_cond_wake (cond)
-#define lll_cond_broadcast(cond) \
-  __lll_cond_broadcast (cond)
-
 #endif /* lowlevellock.h */
index f9913c3..1683de8 100644 (file)
@@ -183,7 +183,7 @@ __libc_fork (void)
        }
 
       /* Initialize the fork lock.  */
-      __fork_lock = (lll_lock_t) LLL_LOCK_INITIALIZER;
+      __fork_lock = LLL_LOCK_INITIALIZER;
     }
   else
     {
index 6458977..032b68f 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -26,7 +26,7 @@ extern unsigned long int __fork_generation attribute_hidden;
 extern unsigned long int *__fork_generation_pointer attribute_hidden;
 
 /* Lock to protect allocation and deallocation of fork handlers.  */
-extern lll_lock_t __fork_lock attribute_hidden;
+extern int __fork_lock attribute_hidden;
 
 /* Elements of the fork handler lists.  */
 struct fork_handler
index 830f628..ce8ad27 100644 (file)
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#include <kernel-features.h>
-
-/* All locks in libc are private.  Use the kernel feature if possible.  */
-#define FUTEX_PRIVATE_FLAG     128
-#ifdef __ASSUME_PRIVATE_FUTEX
-# define FUTEX_WAIT            (0 | FUTEX_PRIVATE_FLAG)
-# define FUTEX_WAKE            (1 | FUTEX_PRIVATE_FLAG)
-#else
-# define LOAD_FUTEX_WAIT(reg) \
-       movl    %gs:PRIVATE_FUTEX, reg
-# define LOAD_FUTEX_WAKE(reg) \
-       movl    %gs:PRIVATE_FUTEX, reg ; \
-       orl     $FUTEX_WAKE, reg
-#endif
-
 #include "lowlevellock.S"
index cfcc7da..745ab91 100644 (file)
 
 #include <sysdep.h>
 #include <pthread-errnos.h>
+#include <kernel-features.h>
+#include <lowlevellock.h>
 
        .text
 
-#ifndef LOCK
-# ifdef UP
-#  define LOCK
+#ifdef __ASSUME_PRIVATE_FUTEX
+# define LOAD_PRIVATE_FUTEX_WAIT(reg) \
+       movl    $(FUTEX_WAIT | FUTEX_PRIVATE_FLAG), reg
+# define LOAD_PRIVATE_FUTEX_WAKE(reg) \
+       movl    $(FUTEX_WAKE | FUTEX_PRIVATE_FLAG), reg
+# define LOAD_FUTEX_WAIT(reg) \
+       xorl    $(FUTEX_WAIT | FUTEX_PRIVATE_FLAG), reg
+# define LOAD_FUTEX_WAKE(reg) \
+       xorl    $(FUTEX_WAKE | FUTEX_PRIVATE_FLAG), reg
+#else
+# if FUTEX_WAIT == 0
+#  define LOAD_PRIVATE_FUTEX_WAIT(reg) \
+       movl    %gs:PRIVATE_FUTEX, reg
 # else
-#  define LOCK lock
+#  define LOAD_PRIVATE_FUTEX_WAIT(reg) \
+       movl    %gs:PRIVATE_FUTEX, reg ; \
+       orl     $FUTEX_WAIT, reg
 # endif
-#endif
-
-#define SYS_gettimeofday       __NR_gettimeofday
-#define SYS_futex              240
-#ifndef FUTEX_WAIT
-# define FUTEX_WAIT            0
-# define FUTEX_WAKE            1
-#endif
-
-#ifndef LOAD_FUTEX_WAIT
+# define LOAD_PRIVATE_FUTEX_WAKE(reg) \
+       movl    %gs:PRIVATE_FUTEX, reg ; \
+       orl     $FUTEX_WAKE, reg
 # if FUTEX_WAIT == 0
 #  define LOAD_FUTEX_WAIT(reg) \
-       xorl    reg, reg
+       xorl    $FUTEX_PRIVATE_FLAG, reg ; \
+       andl    %gs:PRIVATE_FUTEX, reg
 # else
 #  define LOAD_FUTEX_WAIT(reg) \
-       movl    $FUTEX_WAIT, reg
+       xorl    $FUTEX_PRIVATE_FLAG, reg ; \
+       andl    %gs:PRIVATE_FUTEX, reg ; \
+       orl     $FUTEX_WAIT, reg
 # endif
 # define LOAD_FUTEX_WAKE(reg) \
-       movl    $FUTEX_WAKE, reg
+       xorl    $FUTEX_PRIVATE_FLAG, reg ; \
+       andl    %gs:PRIVATE_FUTEX, reg ; \
+       orl     $FUTEX_WAKE, reg
 #endif
 
-
-       .globl  __lll_mutex_lock_wait
-       .type   __lll_mutex_lock_wait,@function
-       .hidden __lll_mutex_lock_wait
+       .globl  __lll_lock_wait_private
+       .type   __lll_lock_wait_private,@function
+       .hidden __lll_lock_wait_private
        .align  16
-__lll_mutex_lock_wait:
+__lll_lock_wait_private:
        cfi_startproc
        pushl   %edx
        cfi_adjust_cfa_offset(4)
@@ -69,7 +80,7 @@ __lll_mutex_lock_wait:
        movl    $2, %edx
        movl    %ecx, %ebx
        xorl    %esi, %esi      /* No timeout.  */
-       LOAD_FUTEX_WAIT (%ecx)
+       LOAD_PRIVATE_FUTEX_WAIT (%ecx)
 
        cmpl    %edx, %eax      /* NB:   %edx == 2 */
        jne 2f
@@ -94,15 +105,60 @@ __lll_mutex_lock_wait:
        cfi_restore(%edx)
        ret
        cfi_endproc
-       .size   __lll_mutex_lock_wait,.-__lll_mutex_lock_wait
-
+       .size   __lll_lock_wait_private,.-__lll_lock_wait_private
 
 #ifdef NOT_IN_libc
-       .globl  __lll_mutex_timedlock_wait
-       .type   __lll_mutex_timedlock_wait,@function
-       .hidden __lll_mutex_timedlock_wait
+       .globl  __lll_lock_wait
+       .type   __lll_lock_wait,@function
+       .hidden __lll_lock_wait
        .align  16
-__lll_mutex_timedlock_wait:
+__lll_lock_wait:
+       cfi_startproc
+       pushl   %edx
+       cfi_adjust_cfa_offset(4)
+       pushl   %ebx
+       cfi_adjust_cfa_offset(4)
+       pushl   %esi
+       cfi_adjust_cfa_offset(4)
+       cfi_offset(%edx, -8)
+       cfi_offset(%ebx, -12)
+       cfi_offset(%esi, -16)
+
+       movl    %edx, %ebx
+       movl    $2, %edx
+       xorl    %esi, %esi      /* No timeout.  */
+       LOAD_FUTEX_WAIT (%ecx)
+
+       cmpl    %edx, %eax      /* NB:   %edx == 2 */
+       jne 2f
+
+1:     movl    $SYS_futex, %eax
+       ENTER_KERNEL
+
+2:     movl    %edx, %eax
+       xchgl   %eax, (%ebx)    /* NB:   lock is implied */
+
+       testl   %eax, %eax
+       jnz     1b
+
+       popl    %esi
+       cfi_adjust_cfa_offset(-4)
+       cfi_restore(%esi)
+       popl    %ebx
+       cfi_adjust_cfa_offset(-4)
+       cfi_restore(%ebx)
+       popl    %edx
+       cfi_adjust_cfa_offset(-4)
+       cfi_restore(%edx)
+       ret
+       cfi_endproc
+       .size   __lll_lock_wait,.-__lll_lock_wait
+
+       .globl  __lll_timedlock_wait
+       .type   __lll_timedlock_wait,@function
+       .hidden __lll_timedlock_wait
+       .align  16
+__lll_timedlock_wait:
        cfi_startproc
        /* Check for a valid timeout value.  */
        cmpl    $1000000000, 4(%edx)
@@ -132,7 +188,7 @@ __lll_mutex_timedlock_wait:
        /* Get current time.  */
        movl    %esp, %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
 
        /* Compute relative timeout.  */
@@ -165,6 +221,7 @@ __lll_mutex_timedlock_wait:
 
        /* Futex call.  */
        movl    %esp, %esi
+       movl    16(%esp), %ecx
        LOAD_FUTEX_WAIT (%ecx)
        movl    $SYS_futex, %eax
        ENTER_KERNEL
@@ -215,15 +272,51 @@ __lll_mutex_timedlock_wait:
 5:     movl    $ETIMEDOUT, %eax
        jmp     6b
        cfi_endproc
-       .size   __lll_mutex_timedlock_wait,.-__lll_mutex_timedlock_wait
+       .size   __lll_timedlock_wait,.-__lll_timedlock_wait
 #endif
 
+       .globl  __lll_unlock_wake_private
+       .type   __lll_unlock_wake_private,@function
+       .hidden __lll_unlock_wake_private
+       .align  16
+__lll_unlock_wake_private:
+       cfi_startproc
+       pushl   %ebx
+       cfi_adjust_cfa_offset(4)
+       pushl   %ecx
+       cfi_adjust_cfa_offset(4)
+       pushl   %edx
+       cfi_adjust_cfa_offset(4)
+       cfi_offset(%ebx, -8)
+       cfi_offset(%ecx, -12)
+       cfi_offset(%edx, -16)
+
+       movl    %eax, %ebx
+       movl    $0, (%eax)
+       LOAD_PRIVATE_FUTEX_WAKE (%ecx)
+       movl    $1, %edx        /* Wake one thread.  */
+       movl    $SYS_futex, %eax
+       ENTER_KERNEL
+
+       popl    %edx
+       cfi_adjust_cfa_offset(-4)
+       cfi_restore(%edx)
+       popl    %ecx
+       cfi_adjust_cfa_offset(-4)
+       cfi_restore(%ecx)
+       popl    %ebx
+       cfi_adjust_cfa_offset(-4)
+       cfi_restore(%ebx)
+       ret
+       cfi_endproc
+       .size   __lll_unlock_wake_private,.-__lll_unlock_wake_private
 
-       .globl  __lll_mutex_unlock_wake
-       .type   __lll_mutex_unlock_wake,@function
-       .hidden __lll_mutex_unlock_wake
+#ifdef NOT_IN_libc
+       .globl  __lll_unlock_wake
+       .type   __lll_unlock_wake,@function
+       .hidden __lll_unlock_wake
        .align  16
-__lll_mutex_unlock_wake:
+__lll_unlock_wake:
        cfi_startproc
        pushl   %ebx
        cfi_adjust_cfa_offset(4)
@@ -253,10 +346,8 @@ __lll_mutex_unlock_wake:
        cfi_restore(%ebx)
        ret
        cfi_endproc
-       .size   __lll_mutex_unlock_wake,.-__lll_mutex_unlock_wake
+       .size   __lll_unlock_wake,.-__lll_unlock_wake
 
-
-#ifdef NOT_IN_libc
        .globl  __lll_timedwait_tid
        .type   __lll_timedwait_tid,@function
        .hidden __lll_timedwait_tid
@@ -274,7 +365,7 @@ __lll_timedwait_tid:
        /* Get current time.  */
 2:     movl    %esp, %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
 
        /* Compute relative timeout.  */
index 73d8bc4..7c2e1d1 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
 
 #include <sysdep.h>
 #include <pthread-errnos.h>
+#include <lowlevellock.h>
 #include <lowlevelrobustlock.h>
+#include <kernel-features.h>
 
        .text
 
-#ifndef LOCK
-# ifdef UP
-#  define LOCK
-# else
-#  define LOCK lock
-# endif
-#endif
-
-#define SYS_gettimeofday       __NR_gettimeofday
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
 #define FUTEX_WAITERS          0x80000000
 #define FUTEX_OWNER_DIED       0x40000000
 
+#ifdef __ASSUME_PRIVATE_FUTEX
+# define LOAD_FUTEX_WAIT(reg) \
+       xorl    $(FUTEX_WAIT | FUTEX_PRIVATE_FLAG), reg
+#else
+# if FUTEX_WAIT == 0
+#  define LOAD_FUTEX_WAIT(reg) \
+       xorl    $FUTEX_PRIVATE_FLAG, reg ; \
+       andl    %gs:PRIVATE_FUTEX, reg
+# else
+#  define LOAD_FUTEX_WAIT(reg) \
+       xorl    $FUTEX_PRIVATE_FLAG, reg ; \
+       andl    %gs:PRIVATE_FUTEX, reg ; \
+       orl     $FUTEX_WAIT, reg
+# endif
+#endif
 
-       .globl  __lll_robust_mutex_lock_wait
-       .type   __lll_robust_mutex_lock_wait,@function
-       .hidden __lll_robust_mutex_lock_wait
+       .globl  __lll_robust_lock_wait
+       .type   __lll_robust_lock_wait,@function
+       .hidden __lll_robust_lock_wait
        .align  16
-__lll_robust_mutex_lock_wait:
+__lll_robust_lock_wait:
        cfi_startproc
        pushl   %edx
        cfi_adjust_cfa_offset(4)
@@ -55,9 +60,9 @@ __lll_robust_mutex_lock_wait:
        cfi_offset(%ebx, -12)
        cfi_offset(%esi, -16)
 
-       movl    %ecx, %ebx
+       movl    %edx, %ebx
        xorl    %esi, %esi      /* No timeout.  */
-       xorl    %ecx, %ecx      /* movl $FUTEX_WAIT, %ecx */
+       LOAD_FUTEX_WAIT (%ecx)
 
 4:     movl    %eax, %edx
        orl     $FUTEX_WAITERS, %edx
@@ -98,14 +103,14 @@ __lll_robust_mutex_lock_wait:
        cfi_restore(%edx)
        ret
        cfi_endproc
-       .size   __lll_robust_mutex_lock_wait,.-__lll_robust_mutex_lock_wait
+       .size   __lll_robust_lock_wait,.-__lll_robust_lock_wait
 
 
-       .globl  __lll_robust_mutex_timedlock_wait
-       .type   __lll_robust_mutex_timedlock_wait,@function
-       .hidden __lll_robust_mutex_timedlock_wait
+       .globl  __lll_robust_timedlock_wait
+       .type   __lll_robust_timedlock_wait,@function
+       .hidden __lll_robust_timedlock_wait
        .align  16
-__lll_robust_mutex_timedlock_wait:
+__lll_robust_timedlock_wait:
        cfi_startproc
        /* Check for a valid timeout value.  */
        cmpl    $1000000000, 4(%edx)
@@ -136,7 +141,7 @@ __lll_robust_mutex_timedlock_wait:
        /* Get current time.  */
        movl    %esp, %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
 
        /* Compute relative timeout.  */
@@ -177,7 +182,8 @@ __lll_robust_mutex_timedlock_wait:
 2:
        /* Futex call.  */
        movl    %esp, %esi
-       xorl    %ecx, %ecx      /* movl $FUTEX_WAIT, %ecx */
+       movl    20(%esp), %ecx
+       LOAD_FUTEX_WAIT (%ecx)
        movl    $SYS_futex, %eax
        ENTER_KERNEL
        movl    %eax, %ecx
@@ -224,4 +230,4 @@ __lll_robust_mutex_timedlock_wait:
 8:     movl    $ETIMEDOUT, %eax
        jmp     6b
        cfi_endproc
-       .size   __lll_robust_mutex_timedlock_wait,.-__lll_robust_mutex_timedlock_wait
+       .size   __lll_robust_timedlock_wait,.-__lll_robust_timedlock_wait
index 2985719..77d252d 100644 (file)
    02111-1307 USA.  */
 
 #include <sysdep.h>
+#include <lowlevellock.h>
 #include <lowlevelbarrier.h>
 
-#define SYS_futex      240
-#define FUTEX_WAIT     0
-#define FUTEX_WAKE     1
-
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-
        .text
 
        .globl  pthread_barrier_wait
@@ -152,19 +142,27 @@ pthread_barrier_wait:
        popl    %ebx
        ret
 
-1:     leal    MUTEX(%ebx), %ecx
-       call    __lll_mutex_lock_wait
+1:     movl    PRIVATE(%ebx), %ecx
+       leal    MUTEX(%ebx), %edx
+       xorl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     2b
 
-4:     leal    MUTEX(%ebx), %eax
-       call    __lll_mutex_unlock_wake
+4:     movl    PRIVATE(%ebx), %ecx
+       leal    MUTEX(%ebx), %eax
+       xorl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     5b
 
-6:     leal    MUTEX(%ebx), %eax
-       call    __lll_mutex_unlock_wake
+6:     movl    PRIVATE(%ebx), %ecx
+       leal    MUTEX(%ebx), %eax
+       xorl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     7b
 
-9:     leal    MUTEX(%ebx), %eax
-       call    __lll_mutex_unlock_wake
+9:     movl    PRIVATE(%ebx), %ecx
+       leal    MUTEX(%ebx), %eax
+       xorl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     10b
        .size   pthread_barrier_wait,.-pthread_barrier_wait
index 56f7be8..122d83a 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
 
 #include <sysdep.h>
 #include <shlib-compat.h>
+#include <lowlevellock.h>
 #include <lowlevelcond.h>
 #include <kernel-features.h>
 #include <pthread-pi-defines.h>
-
-#ifdef UP
-# define LOCK
-#else
-# define LOCK lock
-#endif
-
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-#define FUTEX_REQUEUE          3
-#define FUTEX_CMP_REQUEUE      4
-
-#define EINVAL                 22
-
+#include <pthread-errnos.h>
 
        .text
 
@@ -141,21 +128,27 @@ __pthread_cond_broadcast:
        /* Initial locking failed.  */
 1:
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     2b
 
        /* Unlock in loop requires waekup.  */
 5:     leal    cond_lock-cond_futex(%ebx), %eax
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     6b
 
        /* Unlock in loop requires waekup.  */
 7:     leal    cond_lock-cond_futex(%ebx), %eax
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     8b
 
 9:     /* The futex requeue functionality is not available.  */
index d0f931f..e3510c8 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
 
 #include <sysdep.h>
 #include <shlib-compat.h>
+#include <lowlevellock.h>
 #include <lowlevelcond.h>
 #include <kernel-features.h>
-
-#ifdef UP
-# define LOCK
-#else
-# define LOCK lock
-#endif
-
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-#define FUTEX_WAKE_OP          5
-
-#define FUTEX_OP_CLEAR_WAKE_IF_GT_ONE  ((4 << 24) | 1)
-
-#define EINVAL                 22
+#include <pthread-errnos.h>
 
 
        .text
@@ -119,17 +106,21 @@ __pthread_cond_signal:
 
        /* Unlock in loop requires wakeup.  */
 5:     movl    %edi, %eax
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     6b
 
        /* Initial locking failed.  */
 1:
 #if cond_lock == 0
-       movl    %edi, %ecx
+       movl    %edi, %edx
 #else
-       leal    cond_lock(%edi), %ecx
+       leal    cond_lock(%edi), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     2b
 
        .size   __pthread_cond_signal, .-__pthread_cond_signal
index 93f4d56..79a7497 100644 (file)
 
 #include <sysdep.h>
 #include <shlib-compat.h>
+#include <lowlevellock.h>
 #include <lowlevelcond.h>
 #include <pthread-errnos.h>
 
-#ifdef UP
-# define LOCK
-#else
-# define LOCK lock
-#endif
-
-#define SYS_gettimeofday       __NR_gettimeofday
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
 
        .text
 
@@ -127,7 +117,7 @@ __pthread_cond_timedwait:
        /* Get the current time.  */
        leal    4(%esp), %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
        movl    %edx, %ebx
 
@@ -285,11 +275,13 @@ __pthread_cond_timedwait:
 1:
 .LSbl1:
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     2b
 
        /* Unlock in loop requires wakeup.  */
@@ -300,17 +292,21 @@ __pthread_cond_timedwait:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     4b
 
        /* Locking in loop failed.  */
 5:
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     6b
 
        /* Unlock after loop requires wakeup.  */
@@ -320,7 +316,9 @@ __pthread_cond_timedwait:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     11b
 
        /* The initial unlocking of the mutex failed.  */
@@ -340,7 +338,9 @@ __pthread_cond_timedwait:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
 
        movl    %esi, %eax
        jmp     18b
@@ -350,7 +350,7 @@ __pthread_cond_timedwait:
 .LSbl4:
 19:    leal    4(%esp), %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
        movl    %edx, %ebx
 
@@ -396,11 +396,13 @@ __condvar_tw_cleanup:
        jz      1f
 
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
 
 1:     movl    broadcast_seq(%ebx), %eax
        cmpl    20(%esp), %eax
@@ -457,7 +459,9 @@ __condvar_tw_cleanup:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
 
        /* Wake up all waiters to make sure no signal gets lost.  */
 2:     testl   %edi, %edi
index c92cfbc..68741bf 100644 (file)
 
 #include <sysdep.h>
 #include <shlib-compat.h>
+#include <lowlevellock.h>
 #include <lowlevelcond.h>
 #include <tcb-offsets.h>
 
-#ifdef UP
-# define LOCK
-#else
-# define LOCK lock
-#endif
-
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
 
        .text
 
@@ -202,11 +193,13 @@ __pthread_cond_wait:
 1:
 .LSbl1:
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     2b
 
        /* Unlock in loop requires waekup.  */
@@ -217,17 +210,21 @@ __pthread_cond_wait:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     4b
 
        /* Locking in loop failed.  */
 5:
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
        jmp     6b
 
        /* Unlock after loop requires wakeup.  */
@@ -237,7 +234,9 @@ __pthread_cond_wait:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
        jmp     11b
 
        /* The initial unlocking of the mutex failed.  */
@@ -257,7 +256,9 @@ __pthread_cond_wait:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
 
        movl    %esi, %eax
        jmp     14b
@@ -287,11 +288,13 @@ __condvar_w_cleanup:
        jz      1f
 
 #if cond_lock == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    cond_lock(%ebx), %ecx
+       leal    cond_lock(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_lock_wait
 
 1:     movl    broadcast_seq(%ebx), %eax
        cmpl    12(%esp), %eax
@@ -348,7 +351,9 @@ __condvar_w_cleanup:
 #else
        leal    cond_lock(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       /* XYZ */
+       movl    $LLL_SHARED, %ecx
+       call    __lll_unlock_wake
 
        /* Wake up all waiters to make sure no signal gets lost.  */
 2:     testl   %edi, %edi
index c61c697..d8a62ed 100644 (file)
    02111-1307 USA.  */
 
 #include <sysdep.h>
+#include <lowlevellock.h>
 #include <lowlevelrwlock.h>
 #include <pthread-errnos.h>
 
 
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-
        .text
 
        .globl  __pthread_rwlock_rdlock
@@ -108,7 +98,7 @@ __pthread_rwlock_rdlock:
 13:    subl    $1, READERS_QUEUED(%ebx)
        jmp     2b
 
-5:     xorl    %ecx, %ecx
+5:     xorl    %edx, %edx
        addl    $1, NR_READERS(%ebx)
        je      8f
 9:     LOCK
@@ -120,24 +110,25 @@ __pthread_rwlock_rdlock:
        jne     6f
 7:
 
-       movl    %ecx, %eax
+       movl    %edx, %eax
        popl    %ebx
        popl    %esi
        ret
 
 1:
 #if MUTEX == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    MUTEX(%ebx), %ecx
+       leal    MUTEX(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_lock_wait
        jmp     2b
 
 14:    cmpl    %gs:TID, %eax
        jne     3b
        /* Deadlock detected.  */
-       movl    $EDEADLK, %ecx
+       movl    $EDEADLK, %edx
        jmp     9b
 
 6:
@@ -146,17 +137,18 @@ __pthread_rwlock_rdlock:
 #else
        leal    MUTEX(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_unlock_wake
        jmp     7b
 
        /* Overflow.  */
 8:     subl    $1, NR_READERS(%ebx)
-       movl    $EAGAIN, %ecx
+       movl    $EAGAIN, %edx
        jmp     9b
 
        /* Overflow.  */
 4:     subl    $1, READERS_QUEUED(%ebx)
-       movl    $EAGAIN, %ecx
+       movl    $EAGAIN, %edx
        jmp     9b
 
 10:
@@ -165,16 +157,18 @@ __pthread_rwlock_rdlock:
 #else
        leal    MUTEX(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_unlock_wake
        jmp     11b
 
 12:
 #if MUTEX == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    MUTEX(%ebx), %ecx
+       leal    MUTEX(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_lock_wait
        jmp     13b
        .size   __pthread_rwlock_rdlock,.-__pthread_rwlock_rdlock
 
index c6a584f..71b97c6 100644 (file)
    02111-1307 USA.  */
 
 #include <sysdep.h>
+#include <lowlevellock.h>
 #include <lowlevelrwlock.h>
 #include <pthread-errnos.h>
 
 
-#define SYS_gettimeofday       __NR_gettimeofday
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-
        .text
 
        .globl  pthread_rwlock_timedrdlock
@@ -88,7 +77,7 @@ pthread_rwlock_timedrdlock:
        /* Get current time.  */
 11:    movl    %esp, %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
 
        /* Compute relative timeout.  */
@@ -124,7 +113,7 @@ pthread_rwlock_timedrdlock:
        leal    READERS_WAKEUP(%ebp), %ebx
        movl    $SYS_futex, %eax
        ENTER_KERNEL
-       movl    %eax, %ecx
+       movl    %eax, %esi
 17:
 
        /* Reget the lock.  */
@@ -139,14 +128,14 @@ pthread_rwlock_timedrdlock:
        jnz     12f
 
 13:    subl    $1, READERS_QUEUED(%ebp)
-       cmpl    $-ETIMEDOUT, %ecx
+       cmpl    $-ETIMEDOUT, %esi
        jne     2b
 
-18:    movl    $ETIMEDOUT, %ecx
+18:    movl    $ETIMEDOUT, %edx
        jmp     9f
 
 
-5:     xorl    %ecx, %ecx
+5:     xorl    %edx, %edx
        addl    $1, NR_READERS(%ebp)
        je      8f
 9:     LOCK
@@ -157,7 +146,7 @@ pthread_rwlock_timedrdlock:
 #endif
        jne     6f
 
-7:     movl    %ecx, %eax
+7:     movl    %edx, %eax
 
        addl    $8, %esp
        popl    %ebp
@@ -168,16 +157,17 @@ pthread_rwlock_timedrdlock:
 
 1:
 #if MUTEX == 0
-       movl    %ebp, %ecx
+       movl    %ebp, %edx
 #else
-       leal    MUTEX(%ebp), %ecx
+       leal    MUTEX(%ebp), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_lock_wait
        jmp     2b
 
 14:    cmpl    %gs:TID, %eax
        jne     3b
-       movl    $EDEADLK, %ecx
+       movl    $EDEADLK, %edx
        jmp     9b
 
 6:
@@ -186,17 +176,18 @@ pthread_rwlock_timedrdlock:
 #else
        leal    MUTEX(%ebp), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_unlock_wake
        jmp     7b
 
        /* Overflow.  */
 8:     subl    $1, NR_READERS(%ebp)
-       movl    $EAGAIN, %ecx
+       movl    $EAGAIN, %edx
        jmp     9b
 
        /* Overflow.  */
 4:     subl    $1, READERS_QUEUED(%ebp)
-       movl    $EAGAIN, %ecx
+       movl    $EAGAIN, %edx
        jmp     9b
 
 10:
@@ -205,21 +196,23 @@ pthread_rwlock_timedrdlock:
 #else
        leal    MUTEX(%ebp), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_unlock_wake
        jmp     11b
 
 12:
 #if MUTEX == 0
-       movl    %ebp, %ecx
+       movl    %ebp, %edx
 #else
-       leal    MUTEX(%ebp), %ecx
+       leal    MUTEX(%ebp), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_lock_wait
        jmp     13b
 
-16:    movl    $-ETIMEDOUT, %ecx
+16:    movl    $-ETIMEDOUT, %esi
        jmp     17b
 
-19:    movl    $EINVAL, %ecx
+19:    movl    $EINVAL, %edx
        jmp     9b
        .size   pthread_rwlock_timedrdlock,.-pthread_rwlock_timedrdlock
index 5e9faf9..c002472 100644 (file)
    02111-1307 USA.  */
 
 #include <sysdep.h>
+#include <lowlevellock.h>
 #include <lowlevelrwlock.h>
 #include <pthread-errnos.h>
 
 
-#define SYS_gettimeofday       __NR_gettimeofday
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-
        .text
 
        .globl  pthread_rwlock_timedwrlock
@@ -86,7 +75,7 @@ pthread_rwlock_timedwrlock:
        /* Get current time.  */
 11:    movl    %esp, %ebx
        xorl    %ecx, %ecx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
 
        /* Compute relative timeout.  */
@@ -122,7 +111,7 @@ pthread_rwlock_timedwrlock:
        leal    WRITERS_WAKEUP(%ebp), %ebx
        movl    $SYS_futex, %eax
        ENTER_KERNEL
-       movl    %eax, %ecx
+       movl    %eax, %esi
 17:
 
        /* Reget the lock.  */
@@ -137,14 +126,14 @@ pthread_rwlock_timedwrlock:
        jnz     12f
 
 13:    subl    $1, WRITERS_QUEUED(%ebp)
-       cmpl    $-ETIMEDOUT, %ecx
+       cmpl    $-ETIMEDOUT, %esi
        jne     2b
 
-18:    movl    $ETIMEDOUT, %ecx
+18:    movl    $ETIMEDOUT, %edx
        jmp     9f
 
 
-5:     xorl    %ecx, %ecx
+5:     xorl    %edx, %edx
        movl    %gs:TID, %eax
        movl    %eax, WRITER(%ebp)
 9:     LOCK
@@ -155,7 +144,7 @@ pthread_rwlock_timedwrlock:
 #endif
        jne     6f
 
-7:     movl    %ecx, %eax
+7:     movl    %edx, %eax
 
        addl    $8, %esp
        popl    %ebp
@@ -166,16 +155,17 @@ pthread_rwlock_timedwrlock:
 
 1:
 #if MUTEX == 0
-       movl    %ebp, %ecx
+       movl    %ebp, %edx
 #else
-       leal    MUTEX(%ebp), %ecx
+       leal    MUTEX(%ebp), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_lock_wait
        jmp     2b
 
 14:    cmpl    %gs:TID, %eax
        jne     3b
-20:    movl    $EDEADLK, %ecx
+20:    movl    $EDEADLK, %edx
        jmp     9b
 
 6:
@@ -184,12 +174,13 @@ pthread_rwlock_timedwrlock:
 #else
        leal    MUTEX(%ebp), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_unlock_wake
        jmp     7b
 
        /* Overflow.  */
 4:     subl    $1, WRITERS_QUEUED(%ebp)
-       movl    $EAGAIN, %ecx
+       movl    $EAGAIN, %edx
        jmp     9b
 
 10:
@@ -198,21 +189,23 @@ pthread_rwlock_timedwrlock:
 #else
        leal    MUTEX(%ebp), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_unlock_wake
        jmp     11b
 
 12:
 #if MUTEX == 0
-       movl    %ebp, %ecx
+       movl    %ebp, %edx
 #else
-       leal    MUTEX(%ebp), %ecx
+       leal    MUTEX(%ebp), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebp), %ecx
+       call    __lll_lock_wait
        jmp     13b
 
-16:    movl    $-ETIMEDOUT, %ecx
+16:    movl    $-ETIMEDOUT, %esi
        jmp     17b
 
-19:    movl    $EINVAL, %ecx
+19:    movl    $EINVAL, %edx
        jmp     9b
        .size   pthread_rwlock_timedwrlock,.-pthread_rwlock_timedwrlock
index 35c40c2..fdad432 100644 (file)
    02111-1307 USA.  */
 
 #include <sysdep.h>
+#include <lowlevellock.h>
 #include <lowlevelrwlock.h>
 
 
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-
        .text
 
        .globl  __pthread_rwlock_unlock
@@ -115,29 +105,32 @@ __pthread_rwlock_unlock:
 
 1:
 #if MUTEX == 0
-       movl    %edi, %ecx
+       movl    %edi, %edx
 #else
-       leal    MUTEX(%edx), %ecx
+       leal    MUTEX(%edi), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%edi), %ecx
+       call    __lll_lock_wait
        jmp     2b
 
 3:
 #if MUTEX == 0
        movl    %edi, %eax
 #else
-       leal    MUTEX(%edx), %eax
+       leal    MUTEX(%edi), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%edi), %ecx
+       call    __lll_unlock_wake
        jmp     4b
 
 7:
 #if MUTEX == 0
        movl    %edi, %eax
 #else
-       leal    MUTEX(%edx), %eax
+       leal    MUTEX(%edi), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%edi), %ecx
+       call    __lll_unlock_wake
        jmp     8b
 
        .size   __pthread_rwlock_unlock,.-__pthread_rwlock_unlock
index 88044c0..3f55c82 100644 (file)
    02111-1307 USA.  */
 
 #include <sysdep.h>
+#include <lowlevellock.h>
 #include <lowlevelrwlock.h>
 #include <pthread-errnos.h>
 
 
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-
        .text
 
        .globl  __pthread_rwlock_wrlock
@@ -106,7 +96,7 @@ __pthread_rwlock_wrlock:
 13:    subl    $1, WRITERS_QUEUED(%ebx)
        jmp     2b
 
-5:     xorl    %ecx, %ecx
+5:     xorl    %edx, %edx
        movl    %gs:TID, %eax
        movl    %eax, WRITER(%ebx)
 9:     LOCK
@@ -118,23 +108,24 @@ __pthread_rwlock_wrlock:
        jne     6f
 7:
 
-       movl    %ecx, %eax
+       movl    %edx, %eax
        popl    %ebx
        popl    %esi
        ret
 
 1:
 #if MUTEX == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    MUTEX(%ebx), %ecx
+       leal    MUTEX(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_lock_wait
        jmp     2b
 
 14:    cmpl    %gs:TID , %eax
        jne     3b
-       movl    $EDEADLK, %ecx
+       movl    $EDEADLK, %edx
        jmp     9b
 
 6:
@@ -143,11 +134,12 @@ __pthread_rwlock_wrlock:
 #else
        leal    MUTEX(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_unlock_wake
        jmp     7b
 
 4:     subl    $1, WRITERS_QUEUED(%ebx)
-       movl    $EAGAIN, %ecx
+       movl    $EAGAIN, %edx
        jmp     9b
 
 10:
@@ -156,16 +148,18 @@ __pthread_rwlock_wrlock:
 #else
        leal    MUTEX(%ebx), %eax
 #endif
-       call    __lll_mutex_unlock_wake
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_unlock_wake
        jmp     11b
 
 12:
 #if MUTEX == 0
-       movl    %ebx, %ecx
+       movl    %ebx, %edx
 #else
-       leal    MUTEX(%ebx), %ecx
+       leal    MUTEX(%ebx), %edx
 #endif
-       call    __lll_mutex_lock_wait
+       movl    PSHARED(%ebx), %ecx
+       call    __lll_lock_wait
        jmp     13b
        .size   __pthread_rwlock_wrlock,.-__pthread_rwlock_wrlock
 
index 280dc2f..8f656b4 100644 (file)
 #include <shlib-compat.h>
 #include <pthread-errnos.h>
 #include <structsem.h>
-
-#ifndef UP
-# define LOCK lock
-#else
-# define
-#endif
-
-#define SYS_futex              240
-#define FUTEX_WAKE             1
+#include <lowlevellock.h>
 
 
        .text
index 57b5b58..13a36d6 100644 (file)
 #include <shlib-compat.h>
 #include <pthread-errnos.h>
 #include <structsem.h>
-
-#ifndef UP
-# define LOCK lock
-#else
-# define
-#endif
-
-#define SYS_gettimeofday       __NR_gettimeofday
-#define SYS_futex              240
-#define FUTEX_WAIT             0
+#include <lowlevellock.h>
 
 
 #if VALUE != 0
@@ -82,7 +73,7 @@ sem_timedwait:
 7:     xorl    %ecx, %ecx
        movl    %esp, %ebx
        movl    %ecx, %edx
-       movl    $SYS_gettimeofday, %eax
+       movl    $__NR_gettimeofday, %eax
        ENTER_KERNEL
 
        /* Compute relative timeout.  */
index fbc3b3c..2d49934 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2005, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
 #include <sysdep.h>
 #include <shlib-compat.h>
 #include <pthread-errnos.h>
-
-#ifndef UP
-# define LOCK lock
-#else
-# define
-#endif
+#include <lowlevellock.h>
 
        .text
 
index d0eef75..93c0a64 100644 (file)
 #include <shlib-compat.h>
 #include <pthread-errnos.h>
 #include <structsem.h>
-
-#ifndef UP
-# define LOCK lock
-#else
-# define
-#endif
-
-#define SYS_futex              240
-#define FUTEX_WAIT             0
+#include <lowlevellock.h>
 
 
 #if VALUE != 0
index 56f63a4..2f663aa 100644 (file)
 #ifndef _LOWLEVELLOCK_H
 #define _LOWLEVELLOCK_H        1
 
-#include <time.h>
-#include <sys/param.h>
-#include <bits/pthreadtypes.h>
-#include <kernel-features.h>
-#include <tcb-offsets.h>
-
-#ifndef LOCK_INSTR
-# ifdef UP
-#  define LOCK_INSTR   /* nothing */
-# else
-#  define LOCK_INSTR "lock;"
+#ifndef __ASSEMBLER__
+# include <time.h>
+# include <sys/param.h>
+# include <bits/pthreadtypes.h>
+# include <kernel-features.h>
+# include <tcb-offsets.h>
+
+# ifndef LOCK_INSTR
+#  ifdef UP
+#   define LOCK_INSTR  /* nothing */
+#  else
+#   define LOCK_INSTR "lock;"
+#  endif
+# endif
+#else
+# ifndef LOCK
+#  ifdef UP
+#   define LOCK
+#  else
+#   define LOCK lock
+#  endif
 # endif
 #endif
 
 #define SYS_futex              240
 #define FUTEX_WAIT             0
 #define FUTEX_WAKE             1
+#define FUTEX_CMP_REQUEUE      4
+#define FUTEX_WAKE_OP          5
 #define FUTEX_LOCK_PI          6
 #define FUTEX_UNLOCK_PI                7
 #define FUTEX_TRYLOCK_PI       8
 #define FUTEX_PRIVATE_FLAG     128
 
+#define FUTEX_OP_CLEAR_WAKE_IF_GT_ONE  ((4 << 24) | 1)
 
 /* Values for 'private' parameter of locking macros.  Yes, the
    definition seems to be backwards.  But it is not.  The bit will be
 # endif              
 #endif
 
+#ifndef __ASSEMBLER__
 
 /* Initializer for compatibility lock.  */
-#define LLL_MUTEX_LOCK_INITIALIZER             (0)
-#define LLL_MUTEX_LOCK_INITIALIZER_LOCKED      (1)
-#define LLL_MUTEX_LOCK_INITIALIZER_WAITERS     (2)
+#define LLL_LOCK_INITIALIZER           (0)
+#define LLL_LOCK_INITIALIZER_LOCKED    (1)
+#define LLL_LOCK_INITIALIZER_WAITERS   (2)
 
 
 #ifdef PIC
 #endif
 
 /* Delay in spinlock loop.  */
-#define BUSY_WAIT_NOP          asm ("rep; nop")
+#define BUSY_WAIT_NOP  asm ("rep; nop")
 
 
 #define LLL_STUB_UNWIND_INFO_START \
@@ -217,332 +231,309 @@ LLL_STUB_UNWIND_INFO_END
   } while (0)
 
 
-/* Does not preserve %eax and %ecx.  */
-extern int __lll_mutex_lock_wait (int val, int *__futex)
-     __attribute ((regparm (2))) attribute_hidden;
-/* Does not preserve %eax, %ecx, and %edx.  */
-extern int __lll_mutex_timedlock_wait (int val, int *__futex,
-                                      const struct timespec *abstime)
-     __attribute ((regparm (3))) attribute_hidden;
-/* Preserves all registers but %eax.  */
-extern int __lll_mutex_unlock_wake (int *__futex)
-     __attribute ((regparm (1))) attribute_hidden;
-
-
-/* NB: in the lll_mutex_trylock macro we simply return the value in %eax
+/* NB: in the lll_trylock macro we simply return the value in %eax
    after the cmpxchg instruction.  In case the operation succeded this
    value is zero.  In case the operation failed, the cmpxchg instruction
    has loaded the current value of the memory work which is guaranteed
    to be nonzero.  */
-#define lll_mutex_trylock(futex) \
+#if defined NOT_IN_libc || defined UP
+# define __lll_trylock_asm LOCK_INSTR "cmpxchgl %2, %1"
+#else
+# define __lll_trylock_asm "cmpl $0, %%gs:%P5\n\t" \
+                          "je 0f\n\t"                                        \
+                          "lock\n"                                           \
+                          "0:\tcmpxchgl %2, %1"
+#endif
+
+#define lll_trylock(futex) \
   ({ int ret;                                                                \
-     __asm __volatile (LOCK_INSTR "cmpxchgl %2, %1"                          \
+     __asm __volatile (__lll_trylock_asm                                     \
                       : "=a" (ret), "=m" (futex)                             \
-                      : "r" (LLL_MUTEX_LOCK_INITIALIZER_LOCKED), "m" (futex),\
-                        "0" (LLL_MUTEX_LOCK_INITIALIZER)                     \
+                      : "r" (LLL_LOCK_INITIALIZER_LOCKED), "m" (futex),      \
+                        "0" (LLL_LOCK_INITIALIZER),                          \
+                        "i" (MULTIPLE_THREADS_OFFSET)                        \
                       : "memory");                                           \
      ret; })
 
-
-#define lll_robust_mutex_trylock(futex, id) \
+#define lll_robust_trylock(futex, id) \
   ({ int ret;                                                                \
      __asm __volatile (LOCK_INSTR "cmpxchgl %2, %1"                          \
                       : "=a" (ret), "=m" (futex)                             \
                       : "r" (id), "m" (futex),                               \
-                        "0" (LLL_MUTEX_LOCK_INITIALIZER)                     \
+                        "0" (LLL_LOCK_INITIALIZER)                           \
                       : "memory");                                           \
      ret; })
 
 
-#define lll_mutex_cond_trylock(futex) \
+#define lll_cond_trylock(futex) \
   ({ int ret;                                                                \
      __asm __volatile (LOCK_INSTR "cmpxchgl %2, %1"                          \
                       : "=a" (ret), "=m" (futex)                             \
-                      : "r" (LLL_MUTEX_LOCK_INITIALIZER_WAITERS),            \
-                         "m" (futex), "0" (LLL_MUTEX_LOCK_INITIALIZER)       \
+                      : "r" (LLL_LOCK_INITIALIZER_WAITERS),                  \
+                        "m" (futex), "0" (LLL_LOCK_INITIALIZER)              \
                       : "memory");                                           \
      ret; })
 
+#if defined NOT_IN_libc || defined UP
+# define __lll_lock_asm_start LOCK_INSTR "cmpxchgl %1, %2\n\t"
+#else
+# define __lll_lock_asm_start "cmpl $0, %%gs:%P6\n\t"                        \
+                             "je 0f\n\t"                                     \
+                             "lock\n"                                        \
+                             "0:\tcmpxchgl %1, %2\n\t"
+#endif
 
-#define lll_mutex_lock(futex) \
-  (void) ({ int ignore1, ignore2;                                            \
-           __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                \
-                             "jnz _L_mutex_lock_%=\n\t"                      \
-                             ".subsection 1\n\t"                             \
-                             ".type _L_mutex_lock_%=,@function\n"            \
-                             "_L_mutex_lock_%=:\n"                           \
-                             "1:\tleal %2, %%ecx\n"                          \
-                             "2:\tcall __lll_mutex_lock_wait\n"              \
-                             "3:\tjmp 18f\n"                                 \
-                             "4:\t.size _L_mutex_lock_%=, 4b-1b\n\t"         \
-                             ".previous\n"                                   \
-                             LLL_STUB_UNWIND_INFO_3                          \
-                             "18:"                                           \
-                             : "=a" (ignore1), "=c" (ignore2), "=m" (futex)  \
-                             : "0" (0), "1" (1), "m" (futex)                 \
-                             : "memory"); })
-
-
-#define lll_robust_mutex_lock(futex, id) \
-  ({ int result, ignore;                                                     \
+#define lll_lock(futex, private) \
+  (void)                                                                     \
+    ({ int ignore1, ignore2;                                                 \
+       if (__builtin_constant_p (private) && (private) == LLL_PRIVATE)       \
+        __asm __volatile (__lll_lock_asm_start                               \
+                          "jnz _L_lock_%=\n\t"                               \
+                          ".subsection 1\n\t"                                \
+                          ".type _L_lock_%=,@function\n"                     \
+                          "_L_lock_%=:\n"                                    \
+                          "1:\tleal %2, %%ecx\n"                             \
+                          "2:\tcall __lll_lock_wait_private\n"               \
+                          "3:\tjmp 18f\n"                                    \
+                          "4:\t.size _L_lock_%=, 4b-1b\n\t"                  \
+                          ".previous\n"                                      \
+                          LLL_STUB_UNWIND_INFO_3                             \
+                          "18:"                                              \
+                          : "=a" (ignore1), "=c" (ignore2), "=m" (futex)     \
+                          : "0" (0), "1" (1), "m" (futex),                   \
+                            "i" (MULTIPLE_THREADS_OFFSET)                    \
+                          : "memory");                                       \
+       else                                                                  \
+        {                                                                    \
+          int ignore3;                                                       \
+          __asm __volatile (__lll_lock_asm_start                             \
+                            "jnz _L_lock_%=\n\t"                             \
+                            ".subsection 1\n\t"                              \
+                            ".type _L_lock_%=,@function\n"                   \
+                            "_L_lock_%=:\n"                                  \
+                            "1:\tleal %2, %%edx\n"                           \
+                            "0:\tmovl %8, %%ecx\n"                           \
+                            "2:\tcall __lll_lock_wait\n"                     \
+                            "3:\tjmp 18f\n"                                  \
+                            "4:\t.size _L_lock_%=, 4b-1b\n\t"                \
+                            ".previous\n"                                    \
+                            LLL_STUB_UNWIND_INFO_4                           \
+                            "18:"                                            \
+                            : "=a" (ignore1), "=c" (ignore2),                \
+                              "=m" (futex), "=&d" (ignore3)                  \
+                            : "1" (1), "m" (futex),                          \
+                              "i" (MULTIPLE_THREADS_OFFSET), "0" (0),        \
+                              "g" (private)                                  \
+                            : "memory");                                     \
+        }                                                                    \
+    })
+
+#define lll_robust_lock(futex, id, private) \
+  ({ int result, ignore1, ignore2;                                           \
      __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                              \
-                      "jnz _L_robust_mutex_lock_%=\n\t"                      \
+                      "jnz _L_robust_lock_%=\n\t"                            \
                       ".subsection 1\n\t"                                    \
-                      ".type _L_robust_mutex_lock_%=,@function\n"            \
-                      "_L_robust_mutex_lock_%=:\n"                           \
-                      "1:\tleal %2, %%ecx\n"                                 \
-                      "2:\tcall __lll_robust_mutex_lock_wait\n"              \
+                      ".type _L_robust_lock_%=,@function\n"                  \
+                      "_L_robust_lock_%=:\n"                                 \
+                      "1:\tleal %2, %%edx\n"                                 \
+                      "0:\tmovl %7, %%ecx\n"                                 \
+                      "2:\tcall __lll_robust_lock_wait\n"                    \
                       "3:\tjmp 18f\n"                                        \
-                      "4:\t.size _L_robust_mutex_lock_%=, 4b-1b\n\t"         \
+                      "4:\t.size _L_robust_lock_%=, 4b-1b\n\t"               \
                       ".previous\n"                                          \
-                      LLL_STUB_UNWIND_INFO_3                                 \
+                      LLL_STUB_UNWIND_INFO_4                                 \
                       "18:"                                                  \
-                      : "=a" (result), "=c" (ignore), "=m" (futex)           \
-                      : "0" (0), "1" (id), "m" (futex)                       \
+                      : "=a" (result), "=c" (ignore1), "=m" (futex),         \
+                        "=&d" (ignore2)                                      \
+                      : "0" (0), "1" (id), "m" (futex), "g" (private)        \
                       : "memory");                                           \
      result; })
 
 
-/* Special version of lll_mutex_lock which causes the unlock function to
+/* Special version of lll_lock which causes the unlock function to
    always wakeup waiters.  */
-#define lll_mutex_cond_lock(futex) \
-  (void) ({ int ignore1, ignore2;                                            \
-           __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                \
-                             "jnz _L_mutex_cond_lock_%=\n\t"                 \
-                             ".subsection 1\n\t"                             \
-                             ".type _L_mutex_cond_lock_%=,@function\n"       \
-                             "_L_mutex_cond_lock_%=:\n"                      \
-                             "1:\tleal %2, %%ecx\n"                          \
-                             "2:\tcall __lll_mutex_lock_wait\n"              \
-                             "3:\tjmp 18f\n"                                 \
-                             "4:\t.size _L_mutex_cond_lock_%=, 4b-1b\n\t"    \
-                             ".previous\n"                                   \
-                             LLL_STUB_UNWIND_INFO_3                          \
-                             "18:"                                           \
-                             : "=a" (ignore1), "=c" (ignore2), "=m" (futex)  \
-                             : "0" (0), "1" (2), "m" (futex)                 \
-                             : "memory"); })
-
-
-#define lll_robust_mutex_cond_lock(futex, id) \
-  ({ int result, ignore;                                                     \
+#define lll_cond_lock(futex, private) \
+  (void)                                                                     \
+    ({ int ignore1, ignore2, ignore3;                                        \
+       __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                    \
+                        "jnz _L_cond_lock_%=\n\t"                            \
+                        ".subsection 1\n\t"                                  \
+                        ".type _L_cond_lock_%=,@function\n"                  \
+                        "_L_cond_lock_%=:\n"                                 \
+                        "1:\tleal %2, %%edx\n"                               \
+                        "0:\tmovl %7, %%ecx\n"                               \
+                        "2:\tcall __lll_lock_wait\n"                         \
+                        "3:\tjmp 18f\n"                                      \
+                        "4:\t.size _L_cond_lock_%=, 4b-1b\n\t"               \
+                        ".previous\n"                                        \
+                        LLL_STUB_UNWIND_INFO_4                               \
+                        "18:"                                                \
+                        : "=a" (ignore1), "=c" (ignore2), "=m" (futex),      \
+                          "=&d" (ignore3)                                    \
+                        : "0" (0), "1" (2), "m" (futex), "g" (private)       \
+                        : "memory");                                         \
+    })
+
+
+#define lll_robust_cond_lock(futex, id, private) \
+  ({ int result, ignore1, ignore2;                                           \
      __asm __volatile (LOCK_INSTR "cmpxchgl %1, %2\n\t"                              \
-                      "jnz _L_robust_mutex_cond_lock_%=\n\t"                 \
+                      "jnz _L_robust_cond_lock_%=\n\t"                       \
                       ".subsection 1\n\t"                                    \
-                      ".type _L_robust_mutex_cond_lock_%=,@function\n"       \
-                      "_L_robust_mutex_cond_lock_%=:\n"                      \
-                      "1:\tleal %2, %%ecx\n"                                 \
-                      "2:\tcall __lll_robust_mutex_lock_wait\n"              \
+                      ".type _L_robust_cond_lock_%=,@function\n"             \
+                      "_L_robust_cond_lock_%=:\n"                            \
+                      "1:\tleal %2, %%edx\n"                                 \
+                      "0:\tmovl %7, %%ecx\n"                                 \
+                      "2:\tcall __lll_robust_lock_wait\n"                    \
                       "3:\tjmp 18f\n"                                        \
-                      "4:\t.size _L_robust_mutex_cond_lock_%=, 4b-1b\n\t"    \
+                      "4:\t.size _L_robust_cond_lock_%=, 4b-1b\n\t"          \
                       ".previous\n"                                          \
-                      LLL_STUB_UNWIND_INFO_3                                 \
+                      LLL_STUB_UNWIND_INFO_4                                 \
                       "18:"                                                  \
-                      : "=a" (result), "=c" (ignore), "=m" (futex)           \
-                      : "0" (0), "1" (id | FUTEX_WAITERS), "m" (futex)       \
+                      : "=a" (result), "=c" (ignore1), "=m" (futex),         \
+                        "=&d" (ignore2)                                      \
+                      : "0" (0), "1" (id | FUTEX_WAITERS), "m" (futex),      \
+                        "g" (private)                                        \
                       : "memory");                                           \
      result; })
 
 
-#define lll_mutex_timedlock(futex, timeout) \
-  ({ int result, ignore1, ignore2;                                           \
+#define lll_timedlock(futex, timeout, private) \
+  ({ int result, ignore1, ignore2, ignore3;                                  \
      __asm __volatile (LOCK_INSTR "cmpxchgl %1, %3\n\t"                              \
-                      "jnz _L_mutex_timedlock_%=\n\t"                        \
+                      "jnz _L_timedlock_%=\n\t"                              \
                       ".subsection 1\n\t"                                    \
-                      ".type _L_mutex_timedlock_%=,@function\n"              \
-                      "_L_mutex_timedlock_%=:\n"                             \
+                      ".type _L_timedlock_%=,@function\n"                    \
+                      "_L_timedlock_%=:\n"                                   \
                       "1:\tleal %3, %%ecx\n"                                 \
-                      "0:\tmovl %7, %%edx\n"                                 \
-                      "2:\tcall __lll_mutex_timedlock_wait\n"                \
+                      "0:\tmovl %8, %%edx\n"                                 \
+                      "2:\tcall __lll_timedlock_wait\n"                      \
                       "3:\tjmp 18f\n"                                        \
-                      "4:\t.size _L_mutex_timedlock_%=, 4b-1b\n\t"           \
+                      "4:\t.size _L_timedlock_%=, 4b-1b\n\t"                 \
                       ".previous\n"                                          \
                       LLL_STUB_UNWIND_INFO_4                                 \
                       "18:"                                                  \
                       : "=a" (result), "=c" (ignore1), "=&d" (ignore2),      \
-                        "=m" (futex)                                         \
-                      : "0" (0), "1" (1), "m" (futex), "m" (timeout)         \
+                        "=m" (futex), "=S" (ignore3)                         \
+                      : "0" (0), "1" (1), "m" (futex), "m" (timeout),        \
+                        "4" (private)                                        \
                       : "memory");                                           \
      result; })
 
 
-#define lll_robust_mutex_timedlock(futex, timeout, id) \
-  ({ int result, ignore1, ignore2;                                           \
+#define lll_robust_timedlock(futex, timeout, id, private) \
+  ({ int result, ignore1, ignore2, ignore3;                                  \
      __asm __volatile (LOCK_INSTR "cmpxchgl %1, %3\n\t"                              \
-                      "jnz _L_robust_mutex_timedlock_%=\n\t"                 \
+                      "jnz _L_robust_timedlock_%=\n\t"                       \
                       ".subsection 1\n\t"                                    \
-                      ".type _L_robust_mutex_timedlock_%=,@function\n"       \
-                      "_L_robust_mutex_timedlock_%=:\n"                      \
+                      ".type _L_robust_timedlock_%=,@function\n"             \
+                      "_L_robust_timedlock_%=:\n"                            \
                       "1:\tleal %3, %%ecx\n"                                 \
-                      "0:\tmovl %7, %%edx\n"                                 \
-                      "2:\tcall __lll_robust_mutex_timedlock_wait\n"         \
+                      "0:\tmovl %8, %%edx\n"                                 \
+                      "2:\tcall __lll_robust_timedlock_wait\n"               \
                       "3:\tjmp 18f\n"                                        \
-                      "4:\t.size _L_robust_mutex_timedlock_%=, 4b-1b\n\t"    \
+                      "4:\t.size _L_robust_timedlock_%=, 4b-1b\n\t"          \
                       ".previous\n"                                          \
                       LLL_STUB_UNWIND_INFO_4                                 \
                       "18:"                                                  \
                       : "=a" (result), "=c" (ignore1), "=&d" (ignore2),      \
-                        "=m" (futex)                                         \
-                      : "0" (0), "1" (id), "m" (futex), "m" (timeout)        \
+                        "=m" (futex), "=S" (ignore3)                         \
+                      : "0" (0), "1" (id), "m" (futex), "m" (timeout),       \
+                        "4" (private)                                        \
                       : "memory");                                           \
      result; })
 
-
-#define lll_mutex_unlock(futex) \
-  (void) ({ int ignore;                                                              \
-            __asm __volatile (LOCK_INSTR "subl $1, %0\n\t"                   \
-                             "jne _L_mutex_unlock_%=\n\t"                    \
-                             ".subsection 1\n\t"                             \
-                             ".type _L_mutex_unlock_%=,@function\n"          \
-                             "_L_mutex_unlock_%=:\n"                         \
-                             "1:\tleal %0, %%eax\n"                          \
-                             "2:\tcall __lll_mutex_unlock_wake\n"            \
-                             "3:\tjmp 18f\n"                                 \
-                             "4:\t.size _L_mutex_unlock_%=, 4b-1b\n\t"       \
-                             ".previous\n"                                   \
-                             LLL_STUB_UNWIND_INFO_3                          \
-                             "18:"                                           \
-                             : "=m" (futex), "=&a" (ignore)                  \
-                             : "m" (futex)                                   \
-                             : "memory"); })
-
-
-#define lll_robust_mutex_unlock(futex) \
-  (void) ({ int ignore;                                                              \
-            __asm __volatile (LOCK_INSTR "andl %2, %0\n\t"                   \
-                             "jne _L_robust_mutex_unlock_%=\n\t"             \
-                             ".subsection 1\n\t"                             \
-                             ".type _L_robust_mutex_unlock_%=,@function\n"   \
-                             "_L_robust_mutex_unlock_%=:\n\t"                \
-                             "1:\tleal %0, %%eax\n"                          \
-                             "2:\tcall __lll_mutex_unlock_wake\n"            \
-                             "3:\tjmp 18f\n"                                 \
-                             "4:\t.size _L_robust_mutex_unlock_%=, 4b-1b\n\t"\
-                             ".previous\n"                                   \
-                             LLL_STUB_UNWIND_INFO_3                          \
-                             "18:"                                           \
-                             : "=m" (futex), "=&a" (ignore)                  \
-                             : "i" (FUTEX_WAITERS), "m" (futex)              \
-                             : "memory"); })
-
-
-#define lll_robust_mutex_dead(futex) \
-  (void) ({ int __ignore;                                                    \
-           register int _nr asm ("edx") = 1;                                 \
-           __asm __volatile (LOCK_INSTR "orl %5, (%2)\n\t"                   \
-                             LLL_EBX_LOAD                                    \
-                             LLL_ENTER_KERNEL                                \
-                             LLL_EBX_LOAD                                    \
-                             : "=a" (__ignore)                               \
-                             : "0" (SYS_futex), LLL_EBX_REG (&(futex)),      \
-                               "c" (FUTEX_WAKE), "d" (_nr),                  \
-                               "i" (FUTEX_OWNER_DIED),                       \
-                               "i" (offsetof (tcbhead_t, sysinfo))); })
-
-
-#define lll_mutex_islocked(futex) \
-  (futex != 0)
-
-
-/* We have a separate internal lock implementation which is not tied
-   to binary compatibility.  */
-
-/* Type for lock object.  */
-typedef int lll_lock_t;
-
-/* Initializers for lock.  */
-#define LLL_LOCK_INITIALIZER           (0)
-#define LLL_LOCK_INITIALIZER_LOCKED    (1)
-
-
-extern int __lll_lock_wait (int val, int *__futex)
-     __attribute ((regparm (2))) attribute_hidden;
-extern int __lll_unlock_wake (int *__futex)
-     __attribute ((regparm (1))) attribute_hidden;
-
-
-/* The states of a lock are:
-    0  -  untaken
-    1  -  taken by one user
-    2  -  taken by more users */
-
-
 #if defined NOT_IN_libc || defined UP
-# define lll_trylock(futex) lll_mutex_trylock (futex)
-# define lll_lock(futex) lll_mutex_lock (futex)
-# define lll_unlock(futex) lll_mutex_unlock (futex)
+# define __lll_unlock_asm LOCK_INSTR "subl $1, %0\n\t"
 #else
-/* Special versions of the macros for use in libc itself.  They avoid
-   the lock prefix when the thread library is not used.
-
-   XXX In future we might even want to avoid it on UP machines.  */
-# include <tls.h>
-
-# define lll_trylock(futex) \
-  ({ unsigned char ret;                                                              \
-     __asm __volatile ("cmpl $0, %%gs:%P5\n\t"                               \
-                      "je 0f\n\t"                                            \
-                      "lock\n"                                               \
-                      "0:\tcmpxchgl %2, %1; setne %0"                        \
-                      : "=a" (ret), "=m" (futex)                             \
-                      : "r" (LLL_MUTEX_LOCK_INITIALIZER_LOCKED), "m" (futex),\
-                        "0" (LLL_MUTEX_LOCK_INITIALIZER),                    \
-                        "i" (offsetof (tcbhead_t, multiple_threads))         \
-                      : "memory");                                           \
-     ret; })
-
-
-# define lll_lock(futex) \
-  (void) ({ int ignore1, ignore2;                                            \
-           __asm __volatile ("cmpl $0, %%gs:%P6\n\t"                         \
-                             "je 0f\n\t"                                     \
-                             "lock\n"                                        \
-                             "0:\tcmpxchgl %1, %2\n\t"                       \
-                             "jnz _L_lock_%=\n\t"                            \
-                             ".subsection 1\n\t"                             \
-                             ".type _L_lock_%=,@function\n"                  \
-                             "_L_lock_%=:\n"                                 \
-                             "1:\tleal %2, %%ecx\n"                          \
-                             "2:\tcall __lll_mutex_lock_wait\n"              \
-                             "3:\tjmp 18f\n"                                 \
-                             "4:\t.size _L_lock_%=, 4b-1b\n\t"               \
-                             ".previous\n"                                   \
-                             LLL_STUB_UNWIND_INFO_3                          \
-                             "18:"                                           \
-                             : "=a" (ignore1), "=c" (ignore2), "=m" (futex)  \
-                             : "0" (0), "1" (1), "m" (futex),                \
-                               "i" (offsetof (tcbhead_t, multiple_threads))  \
-                             : "memory"); })
-
-
-# define lll_unlock(futex) \
-  (void) ({ int ignore;                                                              \
-            __asm __volatile ("cmpl $0, %%gs:%P3\n\t"                        \
-                             "je 0f\n\t"                                     \
-                             "lock\n"                                        \
-                             "0:\tsubl $1,%0\n\t"                            \
-                             "jne _L_unlock_%=\n\t"                          \
-                             ".subsection 1\n\t"                             \
-                             ".type _L_unlock_%=,@function\n"                \
-                             "_L_unlock_%=:\n"                               \
-                             "1:\tleal %0, %%eax\n"                          \
-                             "2:\tcall __lll_mutex_unlock_wake\n"            \
-                             "3:\tjmp 18f\n\t"                               \
-                             "4:\t.size _L_unlock_%=, 4b-1b\n\t"             \
-                             ".previous\n"                                   \
-                             LLL_STUB_UNWIND_INFO_3                          \
-                             "18:"                                           \
-                             : "=m" (futex), "=&a" (ignore)                  \
-                             : "m" (futex),                                  \
-                               "i" (offsetof (tcbhead_t, multiple_threads))  \
-                             : "memory"); })
+# define __lll_unlock_asm "cmpl $0, %%gs:%P3\n\t"                            \
+                         "je 0f\n\t"                                         \
+                         "lock\n"                                            \
+                         "0:\tsubl $1,%0\n\t"
 #endif
 
+#define lll_unlock(futex, private) \
+  (void)                                                                     \
+    ({ int ignore;                                                           \
+       if (__builtin_constant_p (private) && (private) == LLL_PRIVATE)       \
+        __asm __volatile (__lll_unlock_asm                                   \
+                          "jne _L_unlock_%=\n\t"                             \
+                          ".subsection 1\n\t"                                \
+                          ".type _L_unlock_%=,@function\n"                   \
+                          "_L_unlock_%=:\n"                                  \
+                          "1:\tleal %0, %%eax\n"                             \
+                          "2:\tcall __lll_unlock_wake_private\n"             \
+                          "3:\tjmp 18f\n"                                    \
+                          "4:\t.size _L_unlock_%=, 4b-1b\n\t"                \
+                          ".previous\n"                                      \
+                          LLL_STUB_UNWIND_INFO_3                             \
+                          "18:"                                              \
+                          : "=m" (futex), "=&a" (ignore)                     \
+                          : "m" (futex), "i" (MULTIPLE_THREADS_OFFSET)       \
+                          : "memory");                                       \
+       else                                                                  \
+        {                                                                    \
+          int ignore2;                                                       \
+          __asm __volatile (__lll_unlock_asm                                 \
+                            "jne _L_unlock_%=\n\t"                           \
+                            ".subsection 1\n\t"                              \
+                            ".type _L_unlock_%=,@function\n"                 \
+                            "_L_unlock_%=:\n"                                \
+                            "1:\tleal %0, %%eax\n"                           \
+                            "0:\tmovl %5, %%ecx\n"                           \
+                            "2:\tcall __lll_unlock_wake\n"                   \
+                            "3:\tjmp 18f\n"                                  \
+                            "4:\t.size _L_unlock_%=, 4b-1b\n\t"              \
+                            ".previous\n"                                    \
+                            LLL_STUB_UNWIND_INFO_4                           \
+                            "18:"                                            \
+                            : "=m" (futex), "=&a" (ignore), "=&c" (ignore2)  \
+                            : "i" (MULTIPLE_THREADS_OFFSET), "m" (futex),    \
+                              "g" (private)                                  \
+                            : "memory");                                     \
+        }                                                                    \
+    })
+
+#define lll_robust_unlock(futex, private) \
+  (void)                                                                     \
+    ({ int ignore, ignore2;                                                  \
+       __asm __volatile (LOCK_INSTR "andl %3, %0\n\t"                        \
+                        "jne _L_robust_unlock_%=\n\t"                        \
+                        ".subsection 1\n\t"                                  \
+                        ".type _L_robust_unlock_%=,@function\n"              \
+                        "_L_robust_unlock_%=:\n\t"                           \
+                        "1:\tleal %0, %%eax\n"                               \
+                        "0:\tmovl %5, %%ecx\n"                               \
+                        "2:\tcall __lll_unlock_wake\n"                       \
+                        "3:\tjmp 18f\n"                                      \
+                        "4:\t.size _L_robust_unlock_%=, 4b-1b\n\t"           \
+                        ".previous\n"                                        \
+                        LLL_STUB_UNWIND_INFO_4                               \
+                        "18:"                                                \
+                        : "=m" (futex), "=&a" (ignore), "=&c" (ignore2)      \
+                        : "i" (FUTEX_WAITERS), "m" (futex), "g" (private)    \
+                        : "memory");                                         \
+    })
+
+
+#define lll_robust_dead(futex, private) \
+  (void)                                                                     \
+    ({ int __ignore;                                                         \
+       register int _nr asm ("edx") = 1;                                     \
+       __asm __volatile (LOCK_INSTR "orl %5, (%2)\n\t"                       \
+                        LLL_EBX_LOAD                                         \
+                        LLL_ENTER_KERNEL                                     \
+                        LLL_EBX_LOAD                                         \
+                        : "=a" (__ignore)                                    \
+                        : "0" (SYS_futex), LLL_EBX_REG (&(futex)),           \
+                          "c" (__lll_private_flag (FUTEX_WAKE, private)),    \
+                          "d" (_nr), "i" (FUTEX_OWNER_DIED),                 \
+                          "i" (offsetof (tcbhead_t, sysinfo)));              \
+    })
 
 #define lll_islocked(futex) \
   (futex != LLL_LOCK_INITIALIZER)
 
-
 /* The kernel notifies a process with uses CLONE_CLEARTID via futex
    wakeup when the clone terminates.  The memory location contains the
    thread ID while the clone is running and is reset to zero
@@ -581,28 +572,6 @@ extern int __lll_timedwait_tid (int *tid, const struct timespec *abstime)
       }                                                                              \
     __result; })
 
-
-/* Conditional variable handling.  */
-
-extern void __lll_cond_wait (pthread_cond_t *cond)
-     __attribute ((regparm (1))) attribute_hidden;
-extern int __lll_cond_timedwait (pthread_cond_t *cond,
-                                const struct timespec *abstime)
-     __attribute ((regparm (2))) attribute_hidden;
-extern void __lll_cond_wake (pthread_cond_t *cond)
-     __attribute ((regparm (1))) attribute_hidden;
-extern void __lll_cond_broadcast (pthread_cond_t *cond)
-     __attribute ((regparm (1))) attribute_hidden;
-
-
-#define lll_cond_wait(cond) \
-  __lll_cond_wait (cond)
-#define lll_cond_timedwait(cond, abstime) \
-  __lll_cond_timedwait (cond, abstime)
-#define lll_cond_wake(cond) \
-  __lll_cond_wake (cond)
-#define lll_cond_broadcast(cond) \
-  __lll_cond_broadcast (cond)
-
+#endif  /* !__ASSEMBLER__ */
 
 #endif /* lowlevellock.h */
index 8ff0dad..f31d968 100644 (file)
 #include <unwindbuf.h>
 #include <sysdep.h>
 #include <kernel-features.h>
+#include <lowlevellock.h>
 
 
-#ifndef UP
-# define LOCK lock
-#else
-# define LOCK
-#endif
-
-#define SYS_futex              240
-#define FUTEX_WAIT             0
-#define FUTEX_WAKE             1
-#define FUTEX_PRIVATE_FLAG     128
-
        .comm   __fork_generation, 4, 4
 
        .text
index 095f0e8..3c28a39 100644 (file)
@@ -73,9 +73,6 @@
 /* Delay in spinlock loop.  */
 #define BUSY_WAIT_NOP          asm ("hint @pause")
 
-/* Initializer for compatibility lock. */
-#define LLL_MUTEX_LOCK_INITIALIZER (0)
-
 #define lll_futex_wait(futex, val, private) \
   lll_futex_timed_wait (futex, val, NULL, private)
 
    _r10 == -1 ? -_retval : _retval;                                    \
 })
 
-#define lll_robust_mutex_dead(futexv)                                  \
+#define lll_robust_dead(futexv, private)                               \
 do                                                                     \
   {                                                                    \
     int *__futexp = &(futexv);                                         \
     atomic_or (__futexp, FUTEX_OWNER_DIED);                            \
-    DO_INLINE_SYSCALL(futex, 3, (long) __futexp, FUTEX_WAKE, 1);       \
+    DO_INLINE_SYSCALL(futex, 3, (long) __futexp,                       \
+                     __lll_private_flag (FUTEX_WAKE, private), 1);     \
   }                                                                    \
 while (0)
 
@@ -123,156 +121,144 @@ while (0)
 })
 
 
-#define __lll_mutex_trylock(futex) \
+#define __lll_trylock(futex) \
   (atomic_compare_and_exchange_val_acq (futex, 1, 0) != 0)
-#define lll_mutex_trylock(futex) __lll_mutex_trylock (&(futex))
+#define lll_trylock(futex) __lll_trylock (&(futex))
 
 
-#define __lll_robust_mutex_trylock(futex, id) \
+#define __lll_robust_trylock(futex, id) \
   (atomic_compare_and_exchange_val_acq (futex, id, 0) != 0)
-#define lll_robust_mutex_trylock(futex, id) \
-  __lll_robust_mutex_trylock (&(futex), id)
+#define lll_robust_trylock(futex, id) \
+  __lll_robust_trylock (&(futex), id)
 
 
-#define __lll_mutex_cond_trylock(futex) \
+#define __lll_cond_trylock(futex) \
   (atomic_compare_and_exchange_val_acq (futex, 2, 0) != 0)
-#define lll_mutex_cond_trylock(futex) __lll_mutex_cond_trylock (&(futex))
+#define lll_cond_trylock(futex) __lll_cond_trylock (&(futex))
 
 
-extern void __lll_lock_wait (int *futex) attribute_hidden;
-extern int __lll_robust_lock_wait (int *futex) attribute_hidden;
+extern void __lll_lock_wait_private (int *futex) attribute_hidden;
+extern void __lll_lock_wait (int *futex, int private) attribute_hidden;
+extern int __lll_robust_lock_wait (int *futex, int private) attribute_hidden;
 
 
-#define __lll_mutex_lock(futex)                                                \
-  ((void) ({                                                           \
-    int *__futex = (futex);                                            \
-    if (atomic_compare_and_exchange_bool_acq (__futex, 1, 0) != 0)     \
-      __lll_lock_wait (__futex);                                       \
+#define __lll_lock(futex, private)                                           \
+  ((void) ({                                                                 \
+    int *__futex = (futex);                                                  \
+    if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex,      \
+                                                               1, 0), 0))    \
+      {                                                                              \
+       if (__builtin_constant_p (private) && (private) == LLL_PRIVATE)       \
+         __lll_lock_wait_private (__futex);                                  \
+       else                                                                  \
+         __lll_lock_wait (__futex, private);                                 \
   }))
-#define lll_mutex_lock(futex) __lll_mutex_lock (&(futex))
-
-
-#define __lll_robust_mutex_lock(futex, id)                             \
-  ({                                                                   \
-    int *__futex = (futex);                                            \
-    int __val = 0;                                                     \
-                                                                       \
-    if (atomic_compare_and_exchange_bool_acq (__futex, id, 0) != 0)    \
-      __val = __lll_robust_lock_wait (__futex);                                \
-    __val;                                                             \
+#define lll_lock(futex, private) __lll_lock (&(futex), private)
+
+
+#define __lll_robust_lock(futex, id, private)                                \
+  ({                                                                         \
+    int *__futex = (futex);                                                  \
+    int __val = 0;                                                           \
+                                                                             \
+    if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, id,  \
+                                                               0), 0))       \
+      __val = __lll_robust_lock_wait (__futex, private);                     \
+    __val;                                                                   \
   })
-#define lll_robust_mutex_lock(futex, id) __lll_robust_mutex_lock (&(futex), id)
+#define lll_robust_lock(futex, id, private) \
+  __lll_robust_lock (&(futex), id, private)
 
 
-#define __lll_mutex_cond_lock(futex)                                   \
-  ((void) ({                                                           \
-    int *__futex = (futex);                                            \
-    if (atomic_compare_and_exchange_bool_acq (__futex, 2, 0) != 0)     \
-      __lll_lock_wait (__futex);                                       \
+#define __lll_cond_lock(futex, private)                                              \
+  ((void) ({                                                                 \
+    int *__futex = (futex);                                                  \
+    if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, 2,   \
+                                                               0), 0))       \
+      __lll_lock_wait (__futex, private);                                    \
   }))
-#define lll_mutex_cond_lock(futex) __lll_mutex_cond_lock (&(futex))
-
-
-#define __lll_robust_mutex_cond_lock(futex, id)                                \
-  ({                                                                   \
-    int *__futex = (futex);                                            \
-    int __val = 0;                                                     \
-    int __id = (id) | FUTEX_WAITERS;                                   \
-                                                                       \
-    if (atomic_compare_and_exchange_bool_acq (__futex, __id, 0) != 0)  \
-      __val = __lll_robust_lock_wait (__futex);                                \
-    __val;                                                             \
+#define lll_cond_lock(futex, private) __lll_cond_lock (&(futex), private)
+
+
+#define __lll_robust_cond_lock(futex, id, private)                           \
+  ({                                                                         \
+    int *__futex = (futex);                                                  \
+    int __val = 0;                                                           \
+    int __id = (id) | FUTEX_WAITERS;                                         \
+                                                                             \
+    if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex,      \
+                                                               __id, 0), 0)) \
+      __val = __lll_robust_lock_wait (__futex, private);                     \
+    __val;                                                                   \
   })
-#define lll_robust_mutex_cond_lock(futex, id) \
-  __lll_robust_mutex_cond_lock (&(futex), id)
+#define lll_robust_cond_lock(futex, id, private) \
+  __lll_robust_cond_lock (&(futex), id, private)
 
 
-extern int __lll_timedlock_wait (int *futex, const struct timespec *)
-     attribute_hidden;
-extern int __lll_robust_timedlock_wait (int *futex, const struct timespec *)
-     attribute_hidden;
+extern int __lll_timedlock_wait (int *futex, const struct timespec *,
+                                int private) attribute_hidden;
+extern int __lll_robust_timedlock_wait (int *futex, const struct timespec *,
+                                       int private) attribute_hidden;
 
 
-#define __lll_mutex_timedlock(futex, abstime)                          \
-  ({                                                                   \
-     int *__futex = (futex);                                           \
-     int __val = 0;                                                    \
-                                                                       \
-     if (atomic_compare_and_exchange_bool_acq (__futex, 1, 0) != 0)    \
-       __val = __lll_timedlock_wait (__futex, abstime);                        \
-     __val;                                                            \
+#define __lll_timedlock(futex, abstime, private)                             \
+  ({                                                                         \
+     int *__futex = (futex);                                                 \
+     int __val = 0;                                                          \
+                                                                             \
+     if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, 1,  \
+                                                                0), 0))      \
+       __val = __lll_timedlock_wait (__futex, abstime, private);             \
+     __val;                                                                  \
   })
-#define lll_mutex_timedlock(futex, abstime) \
-  __lll_mutex_timedlock (&(futex), abstime)
-
-
-#define __lll_robust_mutex_timedlock(futex, abstime, id)               \
-  ({                                                                   \
-    int *__futex = (futex);                                            \
-    int __val = 0;                                                     \
-                                                                       \
-    if (atomic_compare_and_exchange_bool_acq (__futex, id, 0) != 0)    \
-      __val = __lll_robust_timedlock_wait (__futex, abstime);          \
-    __val;                                                             \
+#define lll_timedlock(futex, abstime, private) \
+  __lll_timedlock (&(futex), abstime, private)
+
+
+#define __lll_robust_timedlock(futex, abstime, id, private)                  \
+  ({                                                                         \
+    int *__futex = (futex);                                                  \
+    int __val = 0;                                                           \
+                                                                             \
+    if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, id,  \
+                                                               0), 0))       \
+      __val = __lll_robust_timedlock_wait (__futex, abstime, private);       \
+    __val;                                                                   \
   })
-#define lll_robust_mutex_timedlock(futex, abstime, id) \
-  __lll_robust_mutex_timedlock (&(futex), abstime, id)
+#define lll_robust_timedlock(futex, abstime, id, private) \
+  __lll_robust_timedlock (&(futex), abstime, id, private)
 
 
-#define __lll_mutex_unlock(futex)                      \
-  ((void) ({                                           \
-    int *__futex = (futex);                            \
-    int __val = atomic_exchange_rel (__futex, 0);      \
-                                                       \
-    if (__builtin_expect (__val > 1, 0))               \
-      lll_futex_wake (__futex, 1, LLL_SHARED);         \
+#define __lll_unlock(futex, private)                                         \
+  ((void) ({                                                                 \
+    int *__futex = (futex);                                                  \
+    int __val = atomic_exchange_rel (__futex, 0);                            \
+                                                                             \
+    if (__builtin_expect (__val > 1, 0))                                     \
+      lll_futex_wake (__futex, 1, private);                                  \
   }))
-#define lll_mutex_unlock(futex) \
-  __lll_mutex_unlock(&(futex))
+#define lll_unlock(futex, private) __lll_unlock(&(futex), private)
 
 
-#define __lll_robust_mutex_unlock(futex)               \
-  ((void) ({                                           \
-    int *__futex = (futex);                            \
-    int __val = atomic_exchange_rel (__futex, 0);      \
-                                                       \
-    if (__builtin_expect (__val & FUTEX_WAITERS, 0))   \
-      lll_futex_wake (__futex, 1, LLL_SHARED);         \
+#define __lll_robust_unlock(futex, private)                                  \
+  ((void) ({                                                                 \
+    int *__futex = (futex);                                                  \
+    int __val = atomic_exchange_rel (__futex, 0);                            \
+                                                                             \
+    if (__builtin_expect (__val & FUTEX_WAITERS, 0))                         \
+      lll_futex_wake (__futex, 1, private);                                  \
   }))
-#define lll_robust_mutex_unlock(futex) \
-  __lll_robust_mutex_unlock(&(futex))
+#define lll_robust_unlock(futex, private) \
+  __lll_robust_unlock(&(futex), private)
 
 
-#define __lll_mutex_unlock_force(futex)                \
-  ((void) ({                                   \
-    int *__futex = (futex);                    \
-    (void) atomic_exchange_rel (__futex, 0);   \
-    lll_futex_wake (__futex, 1, LLL_SHARED);   \
-  }))
-#define lll_mutex_unlock_force(futex) \
-  __lll_mutex_unlock_force(&(futex))
-
-
-#define lll_mutex_islocked(futex) \
+#define lll_islocked(futex) \
   (futex != 0)
 
-
-/* We have a separate internal lock implementation which is not tied
-   to binary compatibility.  We can use the lll_mutex_*.  */
-
-/* Type for lock object.  */
-typedef int lll_lock_t;
-
 /* Initializers for lock.  */
 #define LLL_LOCK_INITIALIZER           (0)
 #define LLL_LOCK_INITIALIZER_LOCKED    (1)
 
-#define lll_trylock(futex)     lll_mutex_trylock (futex)
-#define lll_lock(futex)                lll_mutex_lock (futex)
-#define lll_unlock(futex)      lll_mutex_unlock (futex)
-#define lll_islocked(futex)    lll_mutex_islocked (futex)
-
-
 /* The kernel notifies a process with uses CLONE_CLEARTID via futex
    wakeup when the clone terminates.  The memory location contains the
    thread ID while the clone is running and is reset to zero
@@ -297,26 +283,4 @@ extern int __lll_timedwait_tid (int *, const struct timespec *)
     __res;                                             \
   })
 
-
-/* Conditional variable handling.  */
-
-extern void __lll_cond_wait (pthread_cond_t *cond)
-     attribute_hidden;
-extern int __lll_cond_timedwait (pthread_cond_t *cond,
-                                const struct timespec *abstime)
-     attribute_hidden;
-extern void __lll_cond_wake (pthread_cond_t *cond)
-     attribute_hidden;
-extern void __lll_cond_broadcast (pthread_cond_t *cond)
-     attribute_hidden;
-
-#define lll_cond_wait(cond) \
-  __lll_cond_wait (cond)
-#define lll_cond_timedwait(cond, abstime) \
-  __lll_cond_timedwait (cond, abstime)
-#define lll_cond_wake(cond) \
-  __lll_cond_wake (cond)
-#define lll_cond_broadcast(cond) \
-  __lll_cond_broadcast (cond)
-
 #endif /* lowlevellock.h */
index ab7f605..1187800 100644 (file)
 
 
 void
-__lll_lock_wait (int *futex)
+__lll_lock_wait_private (int *futex)
 {
   do
     {
       int oldval = atomic_compare_and_exchange_val_acq (futex, 2, 1);
       if (oldval != 0)
-       lll_futex_wait (futex, 2,
-                       // XYZ check mutex flag
-                       LLL_SHARED);
+       lll_futex_wait (futex, 2, LLL_PRIVATE);
+    }
+  while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0);
+}
+
+
+/* These functions doesn't get included in libc.so  */
+#ifdef IS_IN_libpthread
+void
+__lll_lock_wait (int *futex, int private)
+{
+  do
+    {
+      int oldval = atomic_compare_and_exchange_val_acq (futex, 2, 1);
+      if (oldval != 0)
+       lll_futex_wait (futex, 2, private);
     }
   while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0);
 }
 
 
 int
-__lll_timedlock_wait (int *futex, const struct timespec *abstime)
+__lll_timedlock_wait (int *futex, const struct timespec *abstime, int private)
 {
   /* Reject invalid timeouts.  */
   if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
@@ -70,9 +83,7 @@ __lll_timedlock_wait (int *futex, const struct timespec *abstime)
       /* Wait.  */
       int oldval = atomic_compare_and_exchange_val_acq (futex, 2, 1);
       if (oldval != 0)
-       lll_futex_timed_wait (futex, 2, &rt,
-                             // XYZ check mutex flag
-                             LLL_SHARED);
+       lll_futex_timed_wait (futex, 2, &rt, private);
     }
   while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0);
 
@@ -80,8 +91,6 @@ __lll_timedlock_wait (int *futex, const struct timespec *abstime)
 }
 
 
-/* This function doesn't get included in libc.so  */
-#ifdef IS_IN_libpthread
 int
 __lll_timedwait_tid (int *tidp, const struct timespec *abstime)
 {
index 54cee08..3830f94 100644 (file)
@@ -25,7 +25,7 @@
 
 
 int
-__lll_robust_lock_wait (int *futex)
+__lll_robust_lock_wait (int *futex, int private)
 {
   int oldval = *futex;
   int tid = THREAD_GETMEM (THREAD_SELF, tid);
@@ -44,9 +44,7 @@ __lll_robust_lock_wait (int *futex)
          && atomic_compare_and_exchange_bool_acq (futex, newval, oldval))
        continue;
 
-      lll_futex_wait (futex, newval,
-                     // XYZ check mutex flag
-                     LLL_SHARED);
+      lll_futex_wait (futex, newval, private);
 
     try:
       ;
@@ -59,7 +57,8 @@ __lll_robust_lock_wait (int *futex)
 
 
 int
-__lll_robust_timedlock_wait (int *futex, const struct timespec *abstime)
+__lll_robust_timedlock_wait (int *futex, const struct timespec *abstime,
+                            int private)
 {
   /* Reject invalid timeouts.  */
   if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
@@ -102,9 +101,7 @@ __lll_robust_timedlock_wait (int *futex, const struct timespec *abstime)
          && atomic_compare_and_exchange_bool_acq (futex, newval, oldval))
        continue;
 
-      lll_futex_timed_wait (futex, newval, &rt,
-                           // XYZ check mutex flag
-                           LLL_SHARED);
+      lll_futex_timed_wait (futex, newval, &rt, private);
 
     try:
       ;
index cf91f21..41804d1 100644 (file)
@@ -69,9 +69,6 @@
 # endif              
 #endif
 
-/* Initializer for compatibility lock. */
-#define LLL_MUTEX_LOCK_INITIALIZER (0)
-
 #define lll_futex_wait(futexp, val, private) \
   lll_futex_timed_wait (futexp, val, NULL, private)
 
     INTERNAL_SYSCALL_ERROR_P (__ret, __err) ? -__ret : __ret;                \
   })
 
-#define lll_robust_mutex_dead(futexv) \
+#define lll_robust_dead(futexv, private) \
   do                                                                         \
     {                                                                        \
       INTERNAL_SYSCALL_DECL (__err);                                         \
       int *__futexp = &(futexv);                                             \
                                                                              \
       atomic_or (__futexp, FUTEX_OWNER_DIED);                                \
-      INTERNAL_SYSCALL (futex, __err, 4, __futexp, FUTEX_WAKE, 1, 0);        \
+      INTERNAL_SYSCALL (futex, __err, 4, __futexp,                           \
+                       __lll_private_flag (FUTEX_WAKE, private), 1, 0);      \
     }                                                                        \
   while (0)
 
      __val;                                                                  \
   })
 
-#define lll_robust_mutex_trylock(lock, id) __lll_robust_trylock (&(lock), id)
+#define lll_robust_trylock(lock, id) __lll_robust_trylock (&(lock), id)
 
 /* Set *futex to 1 if it is 0, atomically.  Returns the old value */
 #define __lll_trylock(futex) __lll_robust_trylock (futex, 1)
 
-#define lll_mutex_trylock(lock)        __lll_trylock (&(lock))
+#define lll_trylock(lock)      __lll_trylock (&(lock))
 
 /* Set *futex to 2 if it is 0, atomically.  Returns the old value */
 #define __lll_cond_trylock(futex) __lll_robust_trylock (futex, 2)
 
-#define lll_mutex_cond_trylock(lock)   __lll_cond_trylock (&(lock))
+#define lll_cond_trylock(lock) __lll_cond_trylock (&(lock))
 
 
-extern void __lll_lock_wait (int *futex) attribute_hidden;
-extern int __lll_robust_lock_wait (int *futex) attribute_hidden;
+extern void __lll_lock_wait_private (int *futex) attribute_hidden;
+extern void __lll_lock_wait (int *futex, int private) attribute_hidden;
+extern int __lll_robust_lock_wait (int *futex, int private) attribute_hidden;
 
-#define lll_mutex_lock(lock) \
+#define lll_lock(lock, private) \
   (void) ({                                                                  \
     int *__futex = &(lock);                                                  \
     if (__builtin_expect (atomic_compare_and_exchange_val_acq (__futex, 1, 0),\
                          0) != 0)                                            \
-      __lll_lock_wait (__futex);                                             \
+      {                                                                              \
+       if (__builtin_constant_p (private) && (private) == LLL_PRIVATE)       \
+         __lll_lock_wait_private (__futex);                                  \
+       else                                                                  \
+         __lll_lock_wait (__futex, private);                                 \
+      }                                                                              \
   })
 
-#define lll_robust_mutex_lock(lock, id) \
+#define lll_robust_lock(lock, id, private) \
   ({                                                                         \
     int *__futex = &(lock);                                                  \
     int __val = 0;                                                           \
     if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, id,  \
                                                                0), 0))       \
-      __val = __lll_robust_lock_wait (__futex);                                      \
+      __val = __lll_robust_lock_wait (__futex, private);                     \
     __val;                                                                   \
   })
 
-#define lll_mutex_cond_lock(lock) \
+#define lll_cond_lock(lock, private) \
   (void) ({                                                                  \
     int *__futex = &(lock);                                                  \
     if (__builtin_expect (atomic_compare_and_exchange_val_acq (__futex, 2, 0),\
                          0) != 0)                                            \
-      __lll_lock_wait (__futex);                                             \
+      __lll_lock_wait (__futex, private);                                    \
   })
 
-#define lll_robust_mutex_cond_lock(lock, id) \
+#define lll_robust_cond_lock(lock, id, private) \
   ({                                                                         \
     int *__futex = &(lock);                                                  \
     int __val = 0;                                                           \
     int __id = id | FUTEX_WAITERS;                                           \
     if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, __id,\
                                                                0), 0))       \
-      __val = __lll_robust_lock_wait (__futex);                                      \
+      __val = __lll_robust_lock_wait (__futex, private);                     \
     __val;                                                                   \
   })
 
 
 extern int __lll_timedlock_wait
-  (int *futex, const struct timespec *) attribute_hidden;
+  (int *futex, const struct timespec *, int private) attribute_hidden;
 extern int __lll_robust_timedlock_wait
-  (int *futex, const struct timespec *) attribute_hidden;
+  (int *futex, const struct timespec *, int private) attribute_hidden;
 
-#define lll_mutex_timedlock(lock, abstime) \
+#define lll_timedlock(lock, abstime, private) \
   ({                                                                         \
     int *__futex = &(lock);                                                  \
     int __val = 0;                                                           \
     if (__builtin_expect (atomic_compare_and_exchange_val_acq (__futex, 1, 0),\
                          0) != 0)                                            \
-      __val = __lll_timedlock_wait (__futex, abstime);                       \
+      __val = __lll_timedlock_wait (__futex, abstime, private);                      \
     __val;                                                                   \
   })
 
-#define lll_robust_mutex_timedlock(lock, abstime, id) \
+#define lll_robust_timedlock(lock, abstime, id, private) \
   ({                                                                         \
     int *__futex = &(lock);                                                  \
     int __val = 0;                                                           \
     if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex, id,  \
                                                                0), 0))       \
-      __val = __lll_robust_timedlock_wait (__futex, abstime);                \
+      __val = __lll_robust_timedlock_wait (__futex, abstime, private);       \
     __val;                                                                   \
   })
 
-#define lll_mutex_unlock(lock) \
+#define lll_unlock(lock, private) \
   ((void) ({                                                                 \
     int *__futex = &(lock);                                                  \
     int __val = atomic_exchange_rel (__futex, 0);                            \
     if (__builtin_expect (__val > 1, 0))                                     \
-      lll_futex_wake (__futex, 1, LLL_SHARED);                               \
+      lll_futex_wake (__futex, 1, private);                                  \
   }))
 
-#define lll_robust_mutex_unlock(lock) \
+#define lll_robust_unlock(lock, private) \
   ((void) ({                                                                 \
     int *__futex = &(lock);                                                  \
     int __val = atomic_exchange_rel (__futex, 0);                            \
     if (__builtin_expect (__val & FUTEX_WAITERS, 0))                         \
-      lll_futex_wake (__futex, 1, LLL_SHARED);                               \
-  }))
-
-#define lll_mutex_unlock_force(lock) \
-  ((void) ({                                                                 \
-    int *__futex = &(lock);                                                  \
-    *__futex = 0;                                                            \
-    __asm __volatile (__lll_rel_instr ::: "memory");                         \
-    lll_futex_wake (__futex, 1, LLL_SHARED);                                 \
+      lll_futex_wake (__futex, 1, private);                                  \
   }))
 
-#define lll_mutex_islocked(futex) \
+#define lll_islocked(futex) \
   (futex != 0)
 
 
-/* Our internal lock implementation is identical to the binary-compatible
-   mutex implementation. */
-
-/* Type for lock object.  */
-typedef int lll_lock_t;
-
 /* Initializers for lock.  */
 #define LLL_LOCK_INITIALIZER           (0)
 #define LLL_LOCK_INITIALIZER_LOCKED    (1)
@@ -293,11 +283,6 @@ typedef int lll_lock_t;
     1  -  taken by one user
    >1  -  taken by more users */
 
-#define lll_trylock(lock)      lll_mutex_trylock (lock)
-#define lll_lock(lock)         lll_mutex_lock (lock)
-#define lll_unlock(lock)       lll_mutex_unlock (lock)
-#define lll_islocked(lock)     lll_mutex_islocked (lock)
-
 /* The kernel notifies a process which uses CLONE_CLEARTID via futex
    wakeup when the clone terminates.  The memory location contains the
    thread ID while the clone is running and is reset to zero
@@ -320,26 +305,4 @@ extern int __lll_timedwait_tid (int *, const struct timespec *)
     __res;                                                                   \
   })
 
-
-/* Conditional variable handling.  */
-
-extern void __lll_cond_wait (pthread_cond_t *cond)
-     attribute_hidden;
-extern int __lll_cond_timedwait (pthread_cond_t *cond,
-                                const struct timespec *abstime)
-     attribute_hidden;
-extern void __lll_cond_wake (pthread_cond_t *cond)
-     attribute_hidden;
-extern void __lll_cond_broadcast (pthread_cond_t *cond)
-     attribute_hidden;
-
-#define lll_cond_wait(cond) \
-  __lll_cond_wait (cond)
-#define lll_cond_timedwait(cond, abstime) \
-  __lll_cond_timedwait (cond, abstime)
-#define lll_cond_wake(cond) \
-  __lll_cond_wake (cond)
-#define lll_cond_broadcast(cond) \
-  __lll_cond_broadcast (cond)
-
 #endif /* lowlevellock.h */
index 0b18cdb..fd92f7b 100644 (file)
 int
 __new_sem_post (sem_t *sem)
 {
+  struct new_sem *isem = (struct new_sem *) sem;
+
+  __asm __volatile (__lll_rel_instr ::: "memory");
+  atomic_increment (&isem->value);
+  __asm __volatile (__lll_acq_instr ::: "memory");
+  if (isem->nwaiters > 0)
+    {
+      int err = lll_futex_wake (&isem->value, 1,
+                               isem->private ^ FUTEX_PRIVATE_FLAG);
+      if (__builtin_expect (err, 0) < 0)
+       {
+         __set_errno (-err);
+         return -1;
+       }
+    }
+  return 0;
+}
+versioned_symbol (libpthread, __new_sem_post, sem_post, GLIBC_2_1);
+
+#if SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_1)
+
+int
+attribute_compat_text_section
+__old_sem_post (sem_t *sem)
+{
   int *futex = (int *) sem;
 
   __asm __volatile (__lll_rel_instr ::: "memory");
   int nr = atomic_increment_val (futex);
-  int err = lll_futex_wake (futex, nr, LLL_SHARED);
+  /* We always have to assume it is a shared semaphore.  */
+  int err = lll_futex_wake (futex, 1, LLL_SHARED);
   if (__builtin_expect (err, 0) < 0)
     {
       __set_errno (-err);
@@ -41,8 +67,6 @@ __new_sem_post (sem_t *sem)
     }
   return 0;
 }
-versioned_symbol (libpthread, __new_sem_post, sem_post, GLIBC_2_1);
-#if SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_1)
-strong_alias (__new_sem_post, __old_sem_post)
+
 compat_symbol (libpthread, __old_sem_post, sem_post, GLIBC_2_0);
 #endif
index a97351f..81ecd65 100644 (file)
@@ -1,8 +1,8 @@
 #include <pthreadP.h>
 
-#define LLL_MUTEX_LOCK(mutex) lll_mutex_cond_lock (mutex)
-#define LLL_MUTEX_TRYLOCK(mutex) lll_mutex_cond_trylock (mutex)
-#define LLL_ROBUST_MUTEX_LOCK(mutex, id) lll_robust_mutex_cond_lock (mutex, id)
+#define LLL_MUTEX_LOCK(mutex) lll_cond_lock (mutex, /* XYZ */ LLL_SHARED)
+#define LLL_MUTEX_TRYLOCK(mutex) lll_cond_trylock (mutex)
+#define LLL_ROBUST_MUTEX_LOCK(mutex, id) lll_robust_cond_lock (mutex, id, /* XYZ */ LLL_SHARED)
 #define __pthread_mutex_lock __pthread_mutex_cond_lock
 #define NO_INCR
 
index cb5b2b8..231fc9b 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2005, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -24,7 +24,7 @@
 
 
 /* Lock to protect allocation and deallocation of fork handlers.  */
-lll_lock_t __fork_lock = LLL_LOCK_INITIALIZER;
+int __fork_lock = LLL_LOCK_INITIALIZER;
 
 
 /* Number of pre-allocated handler entries.  */
@@ -85,7 +85,7 @@ __register_atfork (prepare, parent, child, dso_handle)
      void *dso_handle;
 {
   /* Get the lock to not conflict with other allocations.  */
-  lll_lock (__fork_lock);
+  lll_lock (__fork_lock, LLL_PRIVATE);
 
   struct fork_handler *newp = fork_handler_alloc ();
 
@@ -102,7 +102,7 @@ __register_atfork (prepare, parent, child, dso_handle)
     }
 
   /* Release the lock.  */
-  lll_unlock (__fork_lock);
+  lll_unlock (__fork_lock, LLL_PRIVATE);
 
   return newp == NULL ? ENOMEM : 0;
 }
@@ -112,7 +112,7 @@ libc_hidden_def (__register_atfork)
 libc_freeres_fn (free_mem)
 {
   /* Get the lock to not conflict with running forks.  */
-  lll_lock (__fork_lock);
+  lll_lock (__fork_lock, LLL_PRIVATE);
 
   /* No more fork handlers.  */
   __fork_handlers = NULL;
@@ -123,7 +123,7 @@ libc_freeres_fn (free_mem)
   memset (&fork_handler_pool, '\0', sizeof (fork_handler_pool));
 
   /* Release the lock.  */
-  lll_unlock (__fork_lock);
+  lll_unlock (__fork_lock, LLL_PRIVATE);
 
   /* We can free the memory after releasing the lock.  */
   while (runp != NULL)
index 4758b63..ad4d273 100644 (file)
@@ -68,9 +68,6 @@
 # endif              
 #endif
 
-/* Initializer for compatibility lock. */
-#define LLL_MUTEX_LOCK_INITIALIZER (0)
-
 #define lll_futex_wait(futex, val, private) \
   lll_futex_timed_wait (futex, val, NULL, private)
 
   })
 
 
-#define lll_robust_mutex_dead(futexv) \
+#define lll_robust_dead(futexv, private) \
   do                                                                         \
     {                                                                        \
       int *__futexp = &(futexv);                                             \
                                                                              \
       atomic_or (__futexp, FUTEX_OWNER_DIED);                                \
-      lll_futex_wake (__futexp, 1, LLL_SHARED);                                      \
+      lll_futex_wake (__futexp, 1, private);                                 \
     }                                                                        \
   while (0)
 
 
 static inline int
 __attribute__ ((always_inline))
-__lll_mutex_trylock (int *futex)
+__lll_trylock (int *futex)
 {
     unsigned int old;
 
@@ -184,12 +181,12 @@ __lll_mutex_trylock (int *futex)
                       : "0" (0), "d" (1), "m" (*futex) : "cc", "memory" );
     return old != 0;
 }
-#define lll_mutex_trylock(futex) __lll_mutex_trylock (&(futex))
+#define lll_trylock(futex) __lll_trylock (&(futex))
 
 
 static inline int
 __attribute__ ((always_inline))
-__lll_mutex_cond_trylock (int *futex)
+__lll_cond_trylock (int *futex)
 {
     unsigned int old;
 
@@ -198,12 +195,12 @@ __lll_mutex_cond_trylock (int *futex)
                       : "0" (0), "d" (2), "m" (*futex) : "cc", "memory" );
     return old != 0;
 }
-#define lll_mutex_cond_trylock(futex) __lll_mutex_cond_trylock (&(futex))
+#define lll_cond_trylock(futex) __lll_cond_trylock (&(futex))
 
 
 static inline int
 __attribute__ ((always_inline))
-__lll_robust_mutex_trylock (int *futex, int id)
+__lll_robust_trylock (int *futex, int id)
 {
     unsigned int old;
 
@@ -212,141 +209,121 @@ __lll_robust_mutex_trylock (int *futex, int id)
                       : "0" (0), "d" (id), "m" (*futex) : "cc", "memory" );
     return old != 0;
 }
-#define lll_robust_mutex_trylock(futex, id) \
-  __lll_robust_mutex_trylock (&(futex), id)
+#define lll_robust_trylock(futex, id) \
+  __lll_robust_trylock (&(futex), id)
 
 
-extern void __lll_lock_wait (int *futex) attribute_hidden;
-extern int __lll_robust_lock_wait (int *futex) attribute_hidden;
+extern void __lll_lock_wait_private (int *futex) attribute_hidden;
+extern void __lll_lock_wait (int *futex, int private) attribute_hidden;
+extern int __lll_robust_lock_wait (int *futex, int private) attribute_hidden;
 
 static inline void
 __attribute__ ((always_inline))
-__lll_mutex_lock (int *futex)
+__lll_lock (int *futex, int private)
 {
-  if (atomic_compare_and_exchange_bool_acq (futex, 1, 0) != 0)
-    __lll_lock_wait (futex);
+  if (__builtin_expect (atomic_compare_and_exchange_bool_acq (futex, 1, 0), 0))
+    {
+      if (__builtin_constant_p (private) && private == LLL_PRIVATE)
+       __lll_lock_wait_private (futex);
+      else
+       __lll_lock_wait (futex, private);
+    }
 }
-#define lll_mutex_lock(futex) __lll_mutex_lock (&(futex))
+#define lll_lock(futex, private) __lll_lock (&(futex), private)
 
 static inline int
 __attribute__ ((always_inline))
-__lll_robust_mutex_lock (int *futex, int id)
+__lll_robust_lock (int *futex, int id, int private)
 {
   int result = 0;
-  if (atomic_compare_and_exchange_bool_acq (futex, id, 0) != 0)
-    result = __lll_robust_lock_wait (futex);
+  if (__builtin_expect (atomic_compare_and_exchange_bool_acq (futex, id, 0),
+                       0))
+    result = __lll_robust_lock_wait (futex, private);
   return result;
 }
-#define lll_robust_mutex_lock(futex, id) __lll_robust_mutex_lock (&(futex), id)
+#define lll_robust_lock(futex, id, private) \
+  __lll_robust_lock (&(futex), id, private)
 
 static inline void
 __attribute__ ((always_inline))
-__lll_mutex_cond_lock (int *futex)
+__lll_cond_lock (int *futex, int private)
 {
-  if (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0)
-    __lll_lock_wait (futex);
+  if (__builtin_expect (atomic_compare_and_exchange_bool_acq (futex, 2, 0), 0))
+    __lll_lock_wait (futex, private);
 }
-#define lll_mutex_cond_lock(futex) __lll_mutex_cond_lock (&(futex))
+#define lll_cond_lock(futex, private) __lll_cond_lock (&(futex), private)
 
-#define lll_robust_mutex_cond_lock(futex, id) \
-  __lll_robust_mutex_lock (&(futex), (id) | FUTEX_WAITERS)
+#define lll_robust_cond_lock(futex, id, private) \
+  __lll_robust_lock (&(futex), (id) | FUTEX_WAITERS, private)
 
 extern int __lll_timedlock_wait
-  (int *futex, const struct timespec *) attribute_hidden;
+  (int *futex, const struct timespec *, int private) attribute_hidden;
 extern int __lll_robust_timedlock_wait
-  (int *futex, const struct timespec *) attribute_hidden;
+  (int *futex, const struct timespec *, int private) attribute_hidden;
 
 static inline int
 __attribute__ ((always_inline))
-__lll_mutex_timedlock (int *futex, const struct timespec *abstime)
+__lll_timedlock (int *futex, const struct timespec *abstime, int private)
 {
   int result = 0;
-  if (atomic_compare_and_exchange_bool_acq (futex, 1, 0) != 0)
-    result = __lll_timedlock_wait (futex, abstime);
+  if (__builtin_expect (atomic_compare_and_exchange_bool_acq (futex, 1, 0), 0))
+    result = __lll_timedlock_wait (futex, abstime, private);
   return result;
 }
-#define lll_mutex_timedlock(futex, abstime) \
-  __lll_mutex_timedlock (&(futex), abstime)
+#define lll_timedlock(futex, abstime, private) \
+  __lll_timedlock (&(futex), abstime, private)
 
 static inline int
 __attribute__ ((always_inline))
-__lll_robust_mutex_timedlock (int *futex, const struct timespec *abstime,
-                             int id)
+__lll_robust_timedlock (int *futex, const struct timespec *abstime,
+                       int id, int private)
 {
   int result = 0;
-  if (atomic_compare_and_exchange_bool_acq (futex, id, 0) != 0)
-    result = __lll_robust_timedlock_wait (futex, abstime);
+  if (__builtin_expect (atomic_compare_and_exchange_bool_acq (futex, id, 0),
+                       0))
+    result = __lll_robust_timedlock_wait (futex, abstime, private);
   return result;
 }
-#define lll_robust_mutex_timedlock(futex, abstime, id) \
-  __lll_robust_mutex_timedlock (&(futex), abstime, id)
+#define lll_robust_timedlock(futex, abstime, id, private) \
+  __lll_robust_timedlock (&(futex), abstime, id, private)
 
 
 static inline void
 __attribute__ ((always_inline))
-__lll_mutex_unlock (int *futex)
+__lll_unlock (int *futex, int private)
 {
   int oldval;
   int newval = 0;
 
   lll_compare_and_swap (futex, oldval, newval, "slr %2,%2");
-  if (oldval > 1)
-    lll_futex_wake (futex, 1, LLL_SHARED);
+  if (__builtin_expect (oldval > 1, 0))
+    lll_futex_wake (futex, 1, private);
 }
-#define lll_mutex_unlock(futex) \
-  __lll_mutex_unlock(&(futex))
+#define lll_unlock(futex, private) __lll_unlock(&(futex), private)
 
 
 static inline void
 __attribute__ ((always_inline))
-__lll_robust_mutex_unlock (int *futex, int mask)
+__lll_robust_unlock (int *futex, int private)
 {
   int oldval;
   int newval = 0;
 
   lll_compare_and_swap (futex, oldval, newval, "slr %2,%2");
-  if (oldval & mask)
-    lll_futex_wake (futex, 1, LLL_SHARED);
-}
-#define lll_robust_mutex_unlock(futex) \
-  __lll_robust_mutex_unlock(&(futex), FUTEX_WAITERS)
-
-
-static inline void
-__attribute__ ((always_inline))