Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
** File: ntioto.c
** Description:
** This test, ntioto.c, was designed to reproduce a bug reported by NES
** on WindowsNT (fibers implementation). NSPR was asserting in ntio.c
** after PR_AcceptRead() had timed out. I/O performed subsequent to the
** call to PR_AcceptRead() could complete on a CPU other than the one
** on which it was started. The assert in ntio.c detected this, then
** asserted.
**
** Design:
** This test will fail with an assert in ntio.c if the problem it was
** designed to catch occurs. It returns 0 otherwise.
**
** The main() thread initializes and tears things down. A file is
** opened for writing; this file will be written to by AcceptThread()
** and JitterThread(). Main() creates a socket for reading, listens
** and binds the socket.
**
** ConnectThread() connects to the socket created by main, then polls
** the "state" variable. When state is AllDone, ConnectThread() exits.
**
** AcceptThread() calls PR_AcceptRead() on the socket. He fully expects
** it to time out. After the timeout, AccpetThread() interacts with
** JitterThread() via a common condition variable and the state
** variable. The two threads ping-pong back and forth, each thread
** writes the the file opened by main. This should provoke the
** condition reported by NES (if we didn't fix it).
**
** The failure is not solid. It may fail within a few ping-pongs between
** AcceptThread() and JitterThread() or may take a while. The default
** iteration count, jitter, is set by DEFAULT_JITTER. This may be
** modified at the command line with the -j option.
**
*/
#include <plgetopt.h>
#include <nspr.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
** Test harness infrastructure
*/
PRLogModuleInfo* lm;
PRLogModuleLevel msgLevel = PR_LOG_NONE;
PRIntn debug = 0;
PRIntn verbose = 0;
PRUint32 failed_already = 0;
/* end Test harness infrastructure */
/* JITTER_DEFAULT: the number of times AcceptThread() and JitterThread()
* ping-pong */
#define JITTER_DEFAULT 100000
#ifdef DEBUG
# define PORT_INC_DO +100
#else
# define PORT_INC_DO
#endif
#ifdef IS_64
# define PORT_INC_3264 +200
#else
# define PORT_INC_3264
#endif
#define BASE_PORT 9867 PORT_INC_DO PORT_INC_3264
PRIntervalTime timeout;
PRNetAddr listenAddr;
PRFileDesc* listenSock;
PRLock* ml;
PRCondVar* cv;
volatile enum { RunJitter, RunAcceptRead, AllDone } state = RunAcceptRead;
PRFileDesc* file1;
PRIntn iCounter = 0;
PRIntn jitter = JITTER_DEFAULT;
PRBool resume = PR_FALSE;
/*
** Emit help text for this test
*/
static void Help(void) {
printf("Template: Help(): display your help message(s) here");
exit(1);
} /* end Help() */
/*
** static computation of PR_AcceptRead() buffer size.
*/
#define ACCEPT_READ_DATASIZE 10
#define ACCEPT_READ_BUFSIZE (PR_ACCEPT_READ_BUF_OVERHEAD + ACCEPT_READ_DATASIZE)
static void AcceptThread(void* arg) {
PRIntn bytesRead;
char dataBuf[ACCEPT_READ_BUFSIZE];
PRFileDesc* arSock;
PRNetAddr* arAddr;
bytesRead = PR_AcceptRead(listenSock, &arSock, &arAddr, dataBuf,
ACCEPT_READ_DATASIZE, PR_SecondsToInterval(1));
if (bytesRead == -1 && PR_GetError() == PR_IO_TIMEOUT_ERROR) {
if (debug) {
printf("AcceptRead timed out\n");
}
} else {
if (debug) {
printf("Oops! read: %d, error: %d\n", bytesRead, PR_GetError());
}
}
while (state != AllDone) {
PR_Lock(ml);
while (state != RunAcceptRead) {
PR_WaitCondVar(cv, PR_INTERVAL_NO_TIMEOUT);
}
if (++iCounter >= jitter) {
state = AllDone;
} else {
state = RunJitter;
}
if (verbose) {
printf(".");
}
PR_NotifyCondVar(cv);
PR_Unlock(ml);
PR_Write(file1, ".", 1);
}
return;
} /* end AcceptThread() */
static void JitterThread(void* arg) {
while (state != AllDone) {
PR_Lock(ml);
while (state != RunJitter && state != AllDone) {
PR_WaitCondVar(cv, PR_INTERVAL_NO_TIMEOUT);
}
if (state != AllDone) {
state = RunAcceptRead;
}
if (verbose) {
printf("+");
}
PR_NotifyCondVar(cv);
PR_Unlock(ml);
PR_Write(file1, "+", 1);
}
return;
} /* end Goofy() */
static void ConnectThread(void* arg) {
PRStatus rv;
PRFileDesc* clientSock;
PRNetAddr serverAddress;
clientSock = PR_NewTCPSocket();
PR_ASSERT(clientSock);
if (resume) {
if (debug) {
printf("pausing 3 seconds before connect\n");
}
PR_Sleep(PR_SecondsToInterval(3));
}
memset(&serverAddress, 0, sizeof(serverAddress));
rv = PR_InitializeNetAddr(PR_IpAddrLoopback, BASE_PORT, &serverAddress);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Connect(clientSock, &serverAddress, PR_SecondsToInterval(1));
PR_ASSERT(PR_SUCCESS == rv);
/* that's all we do. ... Wait for the acceptread() to timeout */
while (state != AllDone) {
PR_Sleep(PR_SecondsToInterval(1));
}
return;
} /* end ConnectThread() */
int main(int argc, char** argv) {
PRThread* tJitter;
PRThread* tAccept;
PRThread* tConnect;
PRStatus rv;
/* This test if valid for WinNT only! */
#if !defined(WINNT)
return 0;
#endif
{
/*
** Get command line options
*/
PLOptStatus os;
PLOptState* opt = PL_CreateOptState(argc, argv, "hdrvj:");
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) {
if (PL_OPT_BAD == os) {
continue;
}
switch (opt->option) {
case 'd': /* debug */
debug = 1;
msgLevel = PR_LOG_ERROR;
break;
case 'v': /* verbose mode */
verbose = 1;
msgLevel = PR_LOG_DEBUG;
break;
case 'j':
jitter = atoi(opt->value);
if (jitter == 0) {
jitter = JITTER_DEFAULT;
}
break;
case 'r':
resume = PR_TRUE;
break;
case 'h': /* help message */
Help();
break;
default:
break;
}
}
PL_DestroyOptState(opt);
}
lm = PR_NewLogModule("Test"); /* Initialize logging */
/* set concurrency */
PR_SetConcurrency(4);
/* setup thread synchronization mechanics */
ml = PR_NewLock();
cv = PR_NewCondVar(ml);
/* setup a tcp socket */
memset(&listenAddr, 0, sizeof(listenAddr));
rv = PR_InitializeNetAddr(PR_IpAddrAny, BASE_PORT, &listenAddr);
PR_ASSERT(PR_SUCCESS == rv);
listenSock = PR_NewTCPSocket();
PR_ASSERT(listenSock);
rv = PR_Bind(listenSock, &listenAddr);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(listenSock, 5);
PR_ASSERT(PR_SUCCESS == rv);
/* open a file for writing, provoke bug */
file1 = PR_Open("xxxTestFile", PR_CREATE_FILE | PR_RDWR, 666);
/* create Connect thread */
tConnect =
PR_CreateThread(PR_USER_THREAD, ConnectThread, NULL, PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(tConnect);
/* create jitter off thread */
tJitter =
PR_CreateThread(PR_USER_THREAD, JitterThread, NULL, PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(tJitter);
/* create acceptread thread */
tAccept =
PR_CreateThread(PR_USER_THREAD, AcceptThread, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(tAccept);
/* wait for all threads to quit, then terminate gracefully */
PR_JoinThread(tConnect);
PR_JoinThread(tAccept);
PR_JoinThread(tJitter);
PR_Close(listenSock);
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
PR_Close(file1);
PR_Delete("xxxTestFile");
/* test return and exit */
if (debug) {
printf("%s\n", (failed_already) ? "FAIL" : "PASS");
}
return ((failed_already == PR_TRUE) ? 1 : 0);
} /* main() */
/* end ntioto.c */