AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 10:50:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update.

Browse Source 
* Makefile (tests): Add tst-once3 and tst-once4.
	* tst-once4.c: New file.
This commit is contained in:
Ulrich Drepper 2003-02-10 23:43:49 +00:00
parent 2a8a8a8461
commit defd18709c
4 changed files with 187 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
nptl/ChangeLog
View File

@ -2,8 +2,9 @@
* sysdeps/unix/sysv/linux/i386/pthread_once.S (clear_once_control): Fix
clearing of control variable.
* Makefile (tests): Add tst-once3.
* Makefile (tests): Add tst-once3 and tst-once4.
* tst-once3.c: New file.
* tst-once4.c: New file.
2003-02-08 kaz Kojima <kkojima@rr.iij4u.or.jp>

2
nptl/Makefile
View File

@ -130,7 +130,7 @@ tests = tst-mutex1 tst-mutex2 tst-mutex3 tst-mutex4 tst-mutex5 tst-mutex6 \
tst-cond1 tst-cond2 tst-cond3 tst-cond4 tst-cond5 tst-cond6 tst-cond7 \
tst-rwlock1 tst-rwlock2 tst-rwlock3 tst-rwlock4 tst-rwlock5 \
tst-rwlock6 tst-rwlock7 \
tst-once1 tst-once2 tst-once3 \
tst-once1 tst-once2 tst-once3 tst-once4 \
tst-key1 tst-key2 tst-key3 \
tst-sem1 tst-sem2 tst-sem3 tst-sem4 tst-sem5 \
tst-barrier1 tst-barrier2 tst-barrier3 \

4
nptl/sysdeps/unix/sysv/linux/i386/pthread_once.S
View File

@ -147,8 +147,8 @@ clear_once_control:
pushl %esi
pushl %ebx
movl 12(%esp), %eax
movl $0, (%eax)
movl 12(%esp), %ebx
movl $0, (%ebx)
xorl %esi, %esi
movl $0x7fffffff, %edx

182
nptl/tst-once4.c Normal file
View File

@ -0,0 +1,182 @@
/* Copyright (C) 2003 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#define N 100
static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_barrier_t bar;
static int global;
static void
once_handler1 (void)
{
if (pthread_mutex_lock (&mut) != 0)
{
puts ("once_handler1: mutex_lock failed");
exit (1);
}
int r = pthread_barrier_wait (&bar);
if (r != 0 && r!= PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("once_handler1: barrier_wait failed");
exit (1);
}
pthread_cond_wait (&cond, &mut);
/* We should never get here. */
}
static void
once_handler2 (void)
{
global = 1;
}
static void *
tf1 (void *arg)
{
pthread_once (&once, once_handler1);
/* We should never get here. */
puts ("pthread_once in tf returned");
exit (1);
}
static void *
tf2 (void *arg)
{
int r = pthread_barrier_wait (&bar);
if (r != 0 && r!= PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("once_handler2: barrier_wait failed");
exit (1);
}
pthread_once (&once, once_handler2);
return NULL;
}
static int
do_test (void)
{
pthread_t th[2];
if (pthread_barrier_init (&bar, NULL, 2) != 0)
{
puts ("barrier_init failed");
exit (1);
}
if (pthread_create (&th[0], NULL, tf1, NULL) != 0)
{
puts ("first create failed");
exit (1);
}
int r = pthread_barrier_wait (&bar);
if (r != 0 && r!= PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("first barrier_wait failed");
exit (1);
}
if (pthread_mutex_lock (&mut) != 0)
{
puts ("mutex_lock failed");
exit (1);
}
/* We unlock the mutex so that we catch the case where the pthread_cond_wait
call incorrectly resumes and tries to get the mutex. */
if (pthread_mutex_unlock (&mut) != 0)
{
puts ("mutex_unlock failed");
exit (1);
}
if (pthread_create (&th[1], NULL, tf2, NULL) != 0)
{
puts ("second create failed");
exit (1);
}
r = pthread_barrier_wait (&bar);
if (r != 0 && r!= PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("second barrier_wait failed");
exit (1);
}
/* Give the second thread a chance to reach the pthread_once call. */
sleep (2);
/* Cancel the thread. */
if (pthread_cancel (th[0]) != 0)
{
puts ("cancel failed");
exit (1);
}
void *result;
pthread_join (th[0], &result);
if (result != PTHREAD_CANCELED)
{
puts ("first join didn't return PTHREAD_CANCELED");
exit (1);
}
puts ("joined first thread");
pthread_join (th[1], &result);
if (result != NULL)
{
puts ("second join didn't return PTHREAD_CANCELED");
exit (1);
}
if (global != 1)
{
puts ("global still 0");
exit (1);
}
return 0;
}
#define TEST_FUNCTION do_test ()
#define TIMEOUT 4
#include "../test-skeleton.c"