thread_test.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <pwd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <signal.h>

Include dependency graph for thread_test.c:

Go to the source code of this file.

Macros
#define	TEMP_FILENAME_1   "thread_test.1"
#define	TEMP_FILENAME_2   "thread_test.2"

Functions
int	sigwait (const sigset_t *set, int *sig)
static void	func_call_1 (void)
static void	func_call_2 (void)
int	main (int argc, char *argv[])

Variables
static pthread_mutex_t	init_mutex = PTHREAD_MUTEX_INITIALIZER
static volatile int	thread1_done = 0
static volatile int	thread2_done = 0
static volatile int	errno1_set = 0
static volatile int	errno2_set = 0
static char *	strerror_p1
static char *	strerror_p2
static int	strerror_threadsafe = 0
static struct passwd *	passwd_p1
static struct passwd *	passwd_p2
static int	getpwuid_threadsafe = 0
static struct hostent *	hostent_p1
static struct hostent *	hostent_p2
static char	myhostname [MAXHOSTNAMELEN]
static int	gethostbyname_threadsafe = 0
static int	platform_is_threadsafe = 1

Macro Definition Documentation

TEMP_FILENAME_1

#define TEMP_FILENAME_1   "thread_test.1"

Definition at line 51 of file thread_test.c.

Referenced by func_call_1().

TEMP_FILENAME_2

#define TEMP_FILENAME_2   "thread_test.2"

Definition at line 52 of file thread_test.c.

Referenced by func_call_2().

Function Documentation

func_call_1()

static void func_call_1 ( void  )

static

Definition at line 242 of file thread_test.c.

References close, errno1_set, errno2_set, fd(), fprintf, hostent_p1, init_mutex, myhostname, passwd_p1, printf, pthread_mutex_lock(), pthread_mutex_unlock(), strerror, strerror_p1, TEMP_FILENAME_1, and thread1_done.

Referenced by main().

{
#if !defined(HAVE_GETPWUID_R) || \
    (!defined(HAVE_GETADDRINFO) && \
     !defined(HAVE_GETHOSTBYNAME_R))
    void       *p;
#endif
#ifdef WIN32
    HANDLE      h1;
#else
    int         fd;
#endif

    unlink(TEMP_FILENAME_1);

    /* Set errno = EEXIST */

    /* create, then try to fail on exclusive create open */

    /*
     * It would be great to check errno here but if errno is not thread-safe
     * we might get a value from the other thread and mis-report the cause of
     * the failure.
     */
#ifdef WIN32
    if ((h1 = CreateFile(TEMP_FILENAME_1, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, 0, NULL)) ==
        INVALID_HANDLE_VALUE)
#else
    if ((fd = open(TEMP_FILENAME_1, O_RDWR | O_CREAT, 0600)) < 0)
#endif
    {
        fprintf(stderr, "Could not create file %s in current directory\n",
                TEMP_FILENAME_1);
        exit(1);
    }

#ifdef WIN32
    if (CreateFile(TEMP_FILENAME_1, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL)
        != INVALID_HANDLE_VALUE)
#else
    if (open(TEMP_FILENAME_1, O_RDWR | O_CREAT | O_EXCL, 0600) >= 0)
#endif
    {
        fprintf(stderr,
                "Could not generate failure for exclusive file create of %s in current directory **\nexiting\n",
                TEMP_FILENAME_1);
        exit(1);
    }

    /*
     * Wait for other thread to set errno. We can't use thread-specific
     * locking here because it might affect errno.
     */
    errno1_set = 1;
    while (errno2_set == 0)
        sched_yield();

#ifdef WIN32
    if (GetLastError() != ERROR_FILE_EXISTS)
#else
    if (errno != EEXIST)
#endif
    {
#ifdef WIN32
        fprintf(stderr, "GetLastError() not thread-safe **\nexiting\n");
#else
        fprintf(stderr, "errno not thread-safe **\nexiting\n");
#endif
        unlink(TEMP_FILENAME_1);
        exit(1);
    }

#ifdef WIN32
    CloseHandle(h1);
#else
    close(fd);
#endif
    unlink(TEMP_FILENAME_1);

#ifndef HAVE_STRERROR_R

    /*
     * If strerror() uses sys_errlist, the pointer might change for different
     * errno values, so we don't check to see if it varies within the thread.
     */
    strerror_p1 = strerror(EACCES);
#endif

#if !defined(WIN32) && !defined(HAVE_GETPWUID_R)
    passwd_p1 = getpwuid(0);
    p = getpwuid(1);
    if (passwd_p1 != p)
    {
        printf("Your getpwuid() changes the static memory area between calls\n");
        passwd_p1 = NULL;       /* force thread-safe failure report */
    }
#endif

#if !defined(HAVE_GETADDRINFO) && !defined(HAVE_GETHOSTBYNAME_R)
    /* threads do this in opposite order */
    hostent_p1 = gethostbyname(myhostname);
    p = gethostbyname("localhost");
    if (hostent_p1 != p)
    {
        printf("Your gethostbyname() changes the static memory area between calls\n");
        hostent_p1 = NULL;      /* force thread-safe failure report */
    }
#endif

    thread1_done = 1;
    pthread_mutex_lock(&init_mutex);    /* wait for parent to test */
    pthread_mutex_unlock(&init_mutex);
}

func_call_2()

static void func_call_2 ( void  )

static

Definition at line 361 of file thread_test.c.

References errno1_set, errno2_set, fprintf, hostent_p2, init_mutex, myhostname, passwd_p2, printf, pthread_mutex_lock(), pthread_mutex_unlock(), strerror, strerror_p2, TEMP_FILENAME_2, and thread2_done.

Referenced by main().

{
#if !defined(HAVE_GETPWUID_R) || \
    (!defined(HAVE_GETADDRINFO) && \
     !defined(HAVE_GETHOSTBYNAME_R))
    void       *p;
#endif

    unlink(TEMP_FILENAME_2);

    /* Set errno = ENOENT */

    /* This will fail, but we can't check errno yet */
    if (unlink(TEMP_FILENAME_2) != -1)
    {
        fprintf(stderr,
                "Could not generate failure for unlink of %s in current directory **\nexiting\n",
                TEMP_FILENAME_2);
        exit(1);
    }

    /*
     * Wait for other thread to set errno. We can't use thread-specific
     * locking here because it might affect errno.
     */
    errno2_set = 1;
    while (errno1_set == 0)
        sched_yield();

#ifdef WIN32
    if (GetLastError() != ENOENT)
#else
    if (errno != ENOENT)
#endif
    {
#ifdef WIN32
        fprintf(stderr, "GetLastError() not thread-safe **\nexiting\n");
#else
        fprintf(stderr, "errno not thread-safe **\nexiting\n");
#endif
        exit(1);
    }

#ifndef HAVE_STRERROR_R

    /*
     * If strerror() uses sys_errlist, the pointer might change for different
     * errno values, so we don't check to see if it varies within the thread.
     */
    strerror_p2 = strerror(EINVAL);
#endif

#if !defined(WIN32) && !defined(HAVE_GETPWUID_R)
    passwd_p2 = getpwuid(2);
    p = getpwuid(3);
    if (passwd_p2 != p)
    {
        printf("Your getpwuid() changes the static memory area between calls\n");
        passwd_p2 = NULL;       /* force thread-safe failure report */
    }
#endif

#if !defined(HAVE_GETADDRINFO) && !defined(HAVE_GETHOSTBYNAME_R)
    /* threads do this in opposite order */
    hostent_p2 = gethostbyname("localhost");
    p = gethostbyname(myhostname);
    if (hostent_p2 != p)
    {
        printf("Your gethostbyname() changes the static memory area between calls\n");
        hostent_p2 = NULL;      /* force thread-safe failure report */
    }
#endif

    thread2_done = 1;
    pthread_mutex_lock(&init_mutex);    /* wait for parent to test */
    pthread_mutex_unlock(&init_mutex);
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 87 of file thread_test.c.

References close, fprintf, func_call_1(), func_call_2(), gethostbyname_threadsafe, getpwuid_threadsafe, hostent_p1, hostent_p2, init_mutex, myhostname, passwd_p1, passwd_p2, platform_is_threadsafe, printf, pthread_mutex_lock(), pthread_mutex_unlock(), strerror, strerror_p1, strerror_p2, strerror_threadsafe, thread1_done, and thread2_done.

Referenced by aes_cbc_decrypt(), DoubleMetaphone(), and update_spins_per_delay().

{
    pthread_t   thread1,
                thread2;
    int         rc;

#ifdef WIN32
    WSADATA     wsaData;
    int         err;
#endif

    if (argc > 1)
    {
        fprintf(stderr, "Usage: %s\n", argv[0]);
        return 1;
    }

    /* Send stdout to 'config.log' */
    close(1);
    dup(5);

#ifdef WIN32
    err = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (err != 0)
    {
        fprintf(stderr, "Cannot start the network subsystem - %d**\nexiting\n", err);
        exit(1);
    }
#endif

#if !defined(HAVE_GETADDRINFO) && !defined(HAVE_GETHOSTBYNAME_R)
    if (gethostname(myhostname, MAXHOSTNAMELEN) != 0)
    {
        fprintf(stderr, "Cannot get local hostname **\nexiting\n");
        exit(1);
    }
#endif

    /* Hold lock until we are ready for the child threads to exit. */
    pthread_mutex_lock(&init_mutex);

    rc = pthread_create(&thread1, NULL, (void *(*) (void *)) func_call_1, NULL);
    if (rc != 0)
    {
        fprintf(stderr, "Failed to create thread 1: %s **\nexiting\n",
                strerror(errno));
        exit(1);
    }
    rc = pthread_create(&thread2, NULL, (void *(*) (void *)) func_call_2, NULL);
    if (rc != 0)
    {
        /*
         * strerror() might not be thread-safe, and we already spawned thread
         * 1 that uses it, so avoid using it.
         */
        fprintf(stderr, "Failed to create thread 2 **\nexiting\n");
        exit(1);
    }

    while (thread1_done == 0 || thread2_done == 0)
        sched_yield();          /* if this is a portability problem, remove it */

    /* Test things while we have thread-local storage */

    /* If we got here, we didn't exit() from a thread */
#ifdef WIN32
    printf("Your GetLastError() is thread-safe.\n");
#else
    printf("Your errno is thread-safe.\n");
#endif

#ifndef HAVE_STRERROR_R
    if (strerror_p1 != strerror_p2)
        strerror_threadsafe = 1;
#endif

#if !defined(WIN32) && !defined(HAVE_GETPWUID_R)
    if (passwd_p1 != passwd_p2)
        getpwuid_threadsafe = 1;
#endif

#if !defined(HAVE_GETADDRINFO) && !defined(HAVE_GETHOSTBYNAME_R)
    if (hostent_p1 != hostent_p2)
        gethostbyname_threadsafe = 1;
#endif

    /* close down threads */

    pthread_mutex_unlock(&init_mutex);  /* let children exit  */

    pthread_join(thread1, NULL);    /* clean up children */
    pthread_join(thread2, NULL);

    /* report results */

#ifdef HAVE_STRERROR_R
    printf("Your system has strerror_r(); it does not need strerror().\n");
#else
    printf("Your system uses strerror() which is ");
    if (strerror_threadsafe)
        printf("thread-safe.\n");
    else
    {
        printf("not thread-safe. **\n");
        platform_is_threadsafe = 0;
    }
#endif

#ifdef WIN32
    printf("getpwuid_r()/getpwuid() are not applicable to Win32 platforms.\n");
#elif defined(HAVE_GETPWUID_R)
    printf("Your system has getpwuid_r();  it does not need getpwuid().\n");
#else
    printf("Your system uses getpwuid() which is ");
    if (getpwuid_threadsafe)
        printf("thread-safe.\n");
    else
    {
        printf("not thread-safe. **\n");
        platform_is_threadsafe = 0;
    }
#endif

#ifdef HAVE_GETADDRINFO
    printf("Your system has getaddrinfo();  it does not need gethostbyname()\n"
           "  or gethostbyname_r().\n");
#elif defined(HAVE_GETHOSTBYNAME_R)
    printf("Your system has gethostbyname_r();  it does not need gethostbyname().\n");
#else
    printf("Your system uses gethostbyname which is ");
    if (gethostbyname_threadsafe)
        printf("thread-safe.\n");
    else
    {
        printf("not thread-safe. **\n");
        platform_is_threadsafe = 0;
    }
#endif

    if (platform_is_threadsafe)
    {
        printf("\nYour platform is thread-safe.\n");
        return 0;
    }
    else
    {
        printf("\n** YOUR PLATFORM IS NOT THREAD-SAFE. **\n");
        return 1;
    }
}

sigwait()

int sigwait	(	const sigset_t *	set,
		int *	sig
	)

Referenced by PQgssEncInUse().

Variable Documentation

errno1_set

volatile int errno1_set = 0

static

Definition at line 62 of file thread_test.c.

Referenced by func_call_1(), and func_call_2().

errno2_set

volatile int errno2_set = 0

static

Definition at line 63 of file thread_test.c.

Referenced by func_call_1(), and func_call_2().

gethostbyname_threadsafe

int gethostbyname_threadsafe = 0

static

Definition at line 81 of file thread_test.c.

Referenced by main().

getpwuid_threadsafe

int getpwuid_threadsafe = 0

static

Definition at line 74 of file thread_test.c.

Referenced by main().

hostent_p1

struct hostent* hostent_p1

static

Definition at line 78 of file thread_test.c.

Referenced by func_call_1(), and main().

hostent_p2

struct hostent* hostent_p2

static

Definition at line 79 of file thread_test.c.

Referenced by func_call_2(), and main().

init_mutex

pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER

static

Definition at line 57 of file thread_test.c.

Referenced by func_call_1(), func_call_2(), and main().

myhostname

char myhostname[MAXHOSTNAMELEN]

static

Definition at line 80 of file thread_test.c.

Referenced by func_call_1(), func_call_2(), and main().

passwd_p1

struct passwd* passwd_p1

static

Definition at line 72 of file thread_test.c.

Referenced by func_call_1(), and main().

passwd_p2

struct passwd* passwd_p2

static

Definition at line 73 of file thread_test.c.

Referenced by func_call_2(), and main().

platform_is_threadsafe

int platform_is_threadsafe = 1

static

Definition at line 84 of file thread_test.c.

Referenced by main().

strerror_p1

char* strerror_p1

static

Definition at line 66 of file thread_test.c.

Referenced by func_call_1(), and main().

strerror_p2

char* strerror_p2

static

Definition at line 67 of file thread_test.c.

Referenced by func_call_2(), and main().

strerror_threadsafe

int strerror_threadsafe = 0

static

Definition at line 68 of file thread_test.c.

Referenced by main().

thread1_done

volatile int thread1_done = 0

static

Definition at line 59 of file thread_test.c.

Referenced by func_call_1(), and main().

thread2_done

volatile int thread2_done = 0

static

Definition at line 60 of file thread_test.c.

Referenced by func_call_2(), and main().