Importing Egor's testsuite.

1 files changed, 876 insertions, 0 deletions

diff --git a/winsup/testsuite/libltp/lib/parse_opts.c b/winsup/testsuite/libltp/lib/parse_opts.c
new file mode 100644
index 000000000..2758ebfb7
--- /dev/null
+++ b/winsup/testsuite/libltp/lib/parse_opts.c
@@ -0,0 +1,876 @@
+/*
+ * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it would be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ * 
+ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
+ * Mountain View, CA  94043, or:
+ * 
+ * http://www.sgi.com 
+ * 
+ * For further information regarding this notice, see: 
+ * 
+ * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
+ */
+
+/* $Id$ */
+
+/**********************************************************
+ * 
+ *    OS Testing - Silicon Graphics, Inc.
+ * 
+ *    FUNCTION NAME 	: parse_opts
+ * 
+ *    FUNCTION TITLE	: parse standard & user options for system call tests
+ * 
+ *    SYNOPSIS:
+ *	#include "usctest.h"
+ *
+ * 	char *parse_opts(ac, av, user_optarr, uhf)
+ *	int    ac;
+ * 	char **av;
+ *	option_t user_optarr[];
+ *	void (*uhf)();
+ * 
+ *    AUTHOR		: William Roske/Richard Logan
+ * 
+ *    INITIAL RELEASE	: UNICOS 7.0
+ * 
+ *    DESCRIPTION
+ * 	The parse_opts library routine takes that argc and argv parameters
+ *	recevied by main() and an array of structures defining user options.
+ *	It parses the command line setting flag and argument locations
+ *      associated with the options.  It uses getopt to do the actual cmd line
+ *      parsing.  uhf() is a function to print user define help
+ *
+ *      This module contains the functions usc_global_setup_hook and
+ *      usc_test_looping, which are called by marcos defined in usctest.h.
+ * 
+ *    RETURN VALUE
+ * 	parse_opts returns a pointer to an error message if an error occurs.
+ *	This pointer is (char *)NULL if parsing is successful.
+ * 
+ *#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#**/
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/signal.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+#ifdef __CYGWIN__
+#include <getopt.h>
+#endif
+
+
+#if UNIT_TEST
+#include <time.h>
+#endif /* UNIT_TEST */
+
+#include "test.h"
+#define _USC_LIB_   1	/* indicates we are the library to the usctest.h include */
+#include "usctest.h"
+
+#ifndef USC_COPIES
+#define USC_COPIES   "USC_COPIES"
+#endif
+
+#ifndef UNIT_TEST
+#define UNIT_TEST	0
+#endif
+
+#ifndef DEBUG
+#define DEBUG	0
+#endif
+
+/* The timing information block. */
+struct tblock tblock={0,((long) -1)>>1,0,0};
+
+
+/* Define flags and args for standard options */
+int STD_FUNCTIONAL_TEST=1,	/* flag indicating to do functional testing code */
+    STD_TIMING_ON=0,		/* flag indicating to print timing stats */
+    STD_PAUSE=0,		/* flag indicating to pause before actual start, */
+				/* for contention mode */
+    STD_INFINITE=0,		/* flag indciating to loop forever */
+    STD_LOOP_COUNT=1,		/* number of iterations */
+    STD_COPIES=1,		/* number of copies */
+    STD_ERRNO_LOG=0;		/* flag indicating to do errno logging */
+
+float STD_LOOP_DURATION=0.0,    /* duration value in fractional seconds */
+      STD_LOOP_DELAY=0.0;	/* loop delay value in fractional seconds */
+
+
+char **STD_opt_arr = NULL;	/* array of option strings */
+int    STD_nopts=0,		/* number of elements in STD_opt_arr */
+       STD_argind=1;		/* argv index to next argv element */
+				/* (first argument) */
+				/* To getopt users, it is like optind */
+
+/*
+ * The following variables are to support system testing additions.
+ */
+static int  STD_TP_barrier=0;	/* flag to do barrier in TEST_PAUSE */
+				/* 2 - wait_barrier(), 3 - set_barrier(), * - barrier() */
+static int  STD_LP_barrier=0;	/* flag to do barrier in TEST_LOOPING */
+				/* 2 - wait_barrier(), 3 - set_barrier(), * - barrier() */
+static int  STD_TP_shmem_sz=0;	/* shmalloc this many words per pe in TEST_PAUSE */
+static int  STD_LD_shmem=0; 	/* flag to do shmem_puts and shmem_gets during delay */
+static int  STD_LP_shmem=0; 	/* flag to do shmem_puts and gets during TEST_LOOPING */
+static int  STD_LD_recfun=0;	/* do recressive function calls in loop delay */
+static int  STD_LP_recfun=0;	/* do recressive function calls in TEST_LOOPING */
+static int  STD_TP_sbrk=0;	/* do sbrk in TEST_PAUSE */
+static int  STD_LP_sbrk=0;	/* do sbrk in TEST_LOOPING */
+static char *STD_start_break=0; /* original sbrk size */
+static int  Debug=0;
+
+struct std_option_t {
+    char *optstr;
+    char *help;
+    char *flag;
+    char **arg;
+} std_options[] = {
+    { "c:", "  -c n    Run n copies concurrently\n", NULL, NULL},
+    { "e" , "  -e      Turn on errno logging\n", NULL, NULL},
+    { "f" , "  -f      Turn off functional testing\n", NULL, NULL},
+    { "h" , "  -h      Show this help screen\n", NULL, NULL},
+    { "i:", "  -i n    Execute test n times\n", NULL, NULL},
+    { "I:", "  -I x    Execute test for x seconds\n", NULL, NULL},
+    { "p" , "  -p      Pause for SIGUSR1 before starting\n", NULL, NULL}, 
+    { "P:", "  -P x    Pause for x seconds between iterations\n", NULL, NULL},
+    { "t" , "  -t      Turn on syscall timing\n", NULL, NULL},
+    {NULL, NULL, NULL, NULL}};
+
+void print_help(void (*user_help)());
+
+/*
+ * Structure for usc_recressive_func argument
+ */
+struct usc_bigstack_t {
+   char space[4096];
+};
+
+static struct usc_bigstack_t *STD_bigstack=NULL;
+
+/*
+ * Counter of errnos returned (-e option).  Indexed by errno.
+ * Make the array USC_MAX_ERRNO long.  That is the first Fortran
+ * Lib errno.  No syscall should return an errno that high.
+ */
+int STD_ERRNO_LIST[USC_MAX_ERRNO];
+
+/* define the string length for Mesg and Mesg2 strings */
+#define STRLEN 2048
+
+static char Mesg2[STRLEN];	/* holds possible return string */
+static void usc_recressive_func();
+
+/*
+ * Define bits for options that might have env variable default
+ */
+#define  OPT_iteration 		01
+#define  OPT_nofunccheck	02
+#define  OPT_duration		04
+#define  OPT_delay		010
+#define  OPT_copies		020
+
+
+/**********************************************************************
+ * parse_opts: 
+ **********************************************************************/
+char *
+parse_opts(int ac, char **av, option_t *user_optarr, void (*uhf)())
+{
+    int found;		/* flag to indicate that an option specified was */
+			/* found in the user's list */
+    int k;		/* scratch integer for returns and short time usage */
+    float  ftmp;	/* tmp float for parsing env variables */
+    char *ptr;		/* used in getting env variables */
+    int options=0;	/* no options specified */
+    int optstrlen, i;
+    char *optionstr;
+    int opt;		/* return of getopt */
+
+    /*
+     * If not the first time this function is called, release the old STD_opt_arr
+     * vector.
+     */
+
+    if ( STD_opt_arr != NULL ) {
+	free(STD_opt_arr);
+	STD_opt_arr=NULL;
+    }
+    /* Calculate how much space we need for the option string */
+    optstrlen = 0;
+    for (i = 0; std_options[i].optstr; ++i) 
+	optstrlen += strlen(std_options[i].optstr);
+    if (user_optarr)
+	for (i = 0; user_optarr[i].option; ++i) {
+	    if (strlen(user_optarr[i].option) > 2)
+		return "parse_opts: ERROR - Only short options are allowed";
+	    optstrlen += strlen(user_optarr[i].option);
+	}
+    optstrlen += 1;
+
+    /* Create the option string for getopt */
+    optionstr = (char *)malloc(optstrlen);
+    if (!optionstr) 
+	return "parse_opts: ERROR - Could not allocate memory for optionstr";
+
+    for (i = 0; std_options[i].optstr; ++i)
+	strcat(optionstr, std_options[i].optstr);
+    if (user_optarr)
+	for (i = 0; user_optarr[i].option; ++i)
+	    /* only add the option if it wasn't there already */
+	    if (strchr(optionstr, user_optarr[i].option[0]) == NULL) 
+		strcat(optionstr, user_optarr[i].option);
+
+#if DEBUG > 1
+    printf("STD_nopts = %d\n", STD_nopts);
+#endif
+
+    /*
+     *  Loop through av parsing options.
+     */
+    while ( (opt = getopt(ac, av, optionstr)) > 0) {
+
+	STD_argind = optind;
+#if DEBUG > 0
+	printf("parse_opts: getopt returned '%c'\n", opt);
+#endif
+
+	switch (opt) {
+		case '?': /* Unknown option */
+			return "Unknown option";
+			break;
+		case ':': /* Missing Arg */
+			return "Missing argument";
+			break;
+		case 'i': /* Iterations */
+			options |= OPT_iteration;
+			STD_LOOP_COUNT = atoi(optarg);
+			if (STD_LOOP_COUNT == 0) STD_INFINITE = 1;
+			break;
+		case 'P': /* Delay between iterations */
+			options |= OPT_delay;
+			STD_LOOP_DELAY = atof(optarg);
+			break;
+		case 'I': /* Time duration */
+			options |= OPT_duration;
+			STD_LOOP_DURATION = atof(optarg);
+			if ( STD_LOOP_DURATION == 0.0 ) STD_INFINITE=1; 
+			break;
+		case 'c': /* Copies */
+			options |= OPT_copies;
+			STD_COPIES = atoi(optarg);
+			break;
+		case 'f': /* Functional testing */
+			STD_FUNCTIONAL_TEST = 0;
+			break;
+		case 'p': /* Pause for SIGUSR1 */
+			STD_PAUSE = 1;
+			break;
+		case 't': /* syscall timing */
+			STD_TIMING_ON = 1;
+			break;
+		case 'e': /* errno loggin */
+			STD_ERRNO_LOG = 1;
+			break;
+		case 'h': /* Help */
+			print_help(uhf);
+			exit(0);
+			break;
+		default:
+			
+            /* Check all the user specified options */
+            found=0;
+	    for(i = 0; user_optarr[i].option; ++i) {
+
+		if (opt == user_optarr[i].option[0]) {
+                    /* Yup, This is a user option, set the flag and look for argument */
+		    if ( user_optarr[i].flag ) {
+                        *user_optarr[i].flag=1;
+		    }
+                    found++;
+
+		    /* save the argument at the user's location */
+                    if ( user_optarr[i].option[strlen(user_optarr[i].option)-1] == ':' ) {  
+                        *user_optarr[i].arg=optarg;
+                    }
+                    break;  /* option found - break out of the for loop */
+                }
+            }
+	    /* This condition "should never happen".  SO CHECK FOR IT!!!! */
+            if ( ! found ) { 
+                sprintf(Mesg2,
+		    "parse_opts: ERROR - option:\"%c\" NOT FOUND... INTERNAL ERROR", opt);
+                return(Mesg2);
+            }
+	}
+
+    }    /* end of while */
+
+    STD_argind = optind;
+
+    /*
+     * Turn on debug
+     */
+    if ( (ptr=getenv("USC_DEBUG")) != NULL ) {
+	Debug=1;
+        printf("env USC_DEBUG is defined, turning on debug\n");
+    }
+    if ( (ptr=getenv("USC_VERBOSE")) != NULL ) {
+	Debug=1;
+        printf("env USC_VERBOSE is defined, turning on debug\n");
+    }
+
+    /*
+     * If the USC_ITERATION_ENV environmental variable is set to
+     * a number, use that number as iteration count (same as -c option).
+     * The -c option with arg will be used even if this env var is set.
+     */
+    if ( !(options & OPT_iteration) && (ptr=getenv(USC_ITERATION_ENV)) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1) {
+            if ( k == 0 ) {   /* if arg is 0, set infinite loop flag */
+                STD_INFINITE=1;
+		if ( Debug )
+		   printf("Using env %s, set STD_INFINITE to 1\n",
+			USC_ITERATION_ENV);
+            } else {            /* else, set the loop count to the arguement */
+                STD_LOOP_COUNT=k;
+		if ( Debug )
+		   printf("Using env %s, set STD_LOOP_COUNT to %d\n",
+			USC_ITERATION_ENV, k);
+            }
+        }
+    }
+
+    /*
+     * If the USC_NO_FUNC_CHECK environmental variable is set, we'll
+     * unset the STD_FUNCTIONAL_TEST variable.
+     */
+    if ( !(options & OPT_nofunccheck) && (ptr=getenv(USC_NO_FUNC_CHECK)) != NULL ) {
+        STD_FUNCTIONAL_TEST=0; /* Turn off functional testing */
+	if ( Debug )
+	    printf("Using env %s, set STD_FUNCTIONAL_TEST to 0\n",
+		USC_NO_FUNC_CHECK);
+    }
+
+    /*
+     * If the USC_LOOP_WALLTIME environmental variable is set,
+     * use that number as duration (same as -I option).
+     * The -I option with arg will be used even if this env var is set.
+     */
+
+    if ( !(options & OPT_duration) && (ptr=getenv(USC_LOOP_WALLTIME)) != NULL ) {
+        if ( sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0 ) {
+	    STD_LOOP_DURATION=ftmp;
+	    if ( Debug )
+	        printf("Using env %s, set STD_LOOP_DURATION to %f\n",
+		    USC_LOOP_WALLTIME, ftmp);
+            if ( STD_LOOP_DURATION == 0.0 ) {   /* if arg is 0, set infinite loop flag */
+                STD_INFINITE=1;
+	        if ( Debug )
+	            printf("Using env %s, set STD_INFINITE to 1\n", USC_LOOP_WALLTIME);
+	    }
+        }
+    }
+    if ( !(options & OPT_duration) && (ptr=getenv("USC_DURATION")) != NULL ) {
+        if ( sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0 ) {
+	    STD_LOOP_DURATION=ftmp;
+	    if ( Debug )
+	        printf("Using env USC_DURATION, set STD_LOOP_DURATION to %f\n", ftmp);
+            if ( STD_LOOP_DURATION == 0.0 ) {   /* if arg is 0, set infinite loop flag */
+                STD_INFINITE=1;
+	        if ( Debug )
+	            printf("Using env USC_DURATION, set STD_INFINITE to 1\n");
+	    }
+        }
+    }
+    /*
+     * If the USC_LOOP_DELAY environmental variable is set,
+     * use that number as delay in factional seconds (same as -P option).
+     * The -P option with arg will be used even if this env var is set.
+     */
+    if ( !(options & OPT_delay) && (ptr=getenv(USC_LOOP_DELAY)) != NULL ) {
+        if ( sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0 ) {
+	    STD_LOOP_DELAY=ftmp;
+	    if ( Debug )
+		printf("Using env %s, set STD_LOOP_DELAY = %f\n",
+		    USC_LOOP_DELAY, ftmp);
+        }
+    }
+
+    /*
+     * If the USC_COPIES environmental variable is set,
+     * use that number as copies (same as -c option).
+     * The -c option with arg will be used even if this env var is set.
+     */
+    if ( !(options & OPT_copies) && (ptr=getenv(USC_COPIES)) != NULL ) {
+        if ( sscanf(ptr, "%d", &STD_COPIES) == 1 && STD_COPIES >= 0 ) {
+	    if ( Debug )
+		printf("Using env %s, set STD_COPIES = %d\n",
+		    USC_COPIES, STD_COPIES);
+        }
+    }
+
+    /*
+     * The following are special system testing envs to turn on special
+     * hooks in the code.
+     */
+    if ( (ptr=getenv("USC_TP_BARRIER")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+	    STD_TP_barrier=k;
+	}
+        else
+	    STD_TP_barrier=1;
+	if ( Debug )
+	    printf("using env USC_TP_BARRIER, Set STD_TP_barrier to %d\n",
+	        STD_TP_barrier);
+    }
+
+    if ( (ptr=getenv("USC_LP_BARRIER")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+	    STD_LP_barrier=k;
+	}
+        else
+	    STD_LP_barrier=1;
+	if ( Debug ) 
+	    printf("using env USC_LP_BARRIER, Set STD_LP_barrier to %d\n",
+	        STD_LP_barrier);
+    }
+
+    if ( (ptr=getenv("USC_TP_SHMEM")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+            STD_TP_shmem_sz=k;
+	    if ( Debug )
+	        printf("Using env USC_TP_SHMEM, Set STD_TP_shmem_sz to %d\n",
+		    STD_TP_shmem_sz);
+        }
+    }
+
+    if ( (ptr=getenv("USC_LP_SHMEM")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+            STD_LP_shmem=k;
+	    if ( Debug )
+	        printf("Using env USC_LP_SHMEM, Set STD_LP_shmem to %d\n",
+		    STD_LP_shmem);
+        }
+    }
+
+    if ( (ptr=getenv("USC_LD_SHMEM")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+            STD_LD_shmem=k;
+	    if ( Debug )
+	        printf("Using env USC_LD_SHMEM, Set STD_LD_shmem to %d\n",
+		    STD_LD_shmem);
+        }
+    }
+
+    if ( (ptr=getenv("USC_TP_SBRK")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+            STD_TP_sbrk=k;
+	    if ( Debug )
+	        printf("Using env USC_TP_SBRK, Set STD_TP_sbrk to %d\n",
+		    STD_TP_sbrk);
+        }
+    }
+
+    if ( (ptr=getenv("USC_LP_SBRK")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+            STD_LP_sbrk=k;
+	    if ( Debug )
+	        printf("Using env USC_LP_SBRK, Set STD_LP_sbrk to %d\n",
+		    STD_LP_sbrk);
+        }
+    }
+
+    if ( (ptr=getenv("USC_LP_RECFUN")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+	    STD_LP_recfun=k;
+	    if ( STD_bigstack != (struct usc_bigstack_t *)NULL )
+		STD_bigstack=(struct usc_bigstack_t *)
+			malloc(sizeof(struct usc_bigstack_t));
+	    if ( Debug )
+                printf("Using env USC_LP_RECFUN, Set STD_LP_recfun to %d\n",
+		    STD_LP_recfun);
+        }
+    }
+
+    if ( (ptr=getenv("USC_LD_RECFUN")) != NULL ) {
+        if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+	    STD_LD_recfun=k;
+	    if ( STD_bigstack != (struct usc_bigstack_t *)NULL )
+		STD_bigstack=(struct usc_bigstack_t *)
+			malloc(sizeof(struct usc_bigstack_t));
+	    if ( Debug )
+                printf("Using env USC_LD_RECFUN, Set STD_LD_recfun to %d\n",
+		    STD_LD_recfun);
+        }
+    }
+ 
+#if UNIT_TEST
+    printf("The following variables after option and env parsing:\n");
+    printf("STD_FUNCTIONAL_TEST = %d\n", STD_FUNCTIONAL_TEST);
+    printf("STD_LOOP_DURATION   = %f\n", STD_LOOP_DURATION);
+    printf("STD_LOOP_DELAY      = %f\n", STD_LOOP_DELAY);
+    printf("STD_COPIES          = %d\n", STD_COPIES);
+    printf("STD_LOOP_COUNT      = %d\n", STD_LOOP_COUNT);
+    printf("STD_INFINITE        = %d\n", STD_INFINITE);
+    printf("STD_TIMING_ON       = %d\n", STD_TIMING_ON);
+    printf("STD_ERRNO_LOG       = %d\n", STD_ERRNO_LOG);
+    printf("STD_PAUSE           = %d\n", STD_PAUSE);
+#endif
+
+    return((char *) NULL);
+
+}    /* end of parse_opts */
+
+/*********************************************************************
+ * print_help() - print help message and user help message
+ *********************************************************************/
+void print_help(void (*user_help)())
+{
+    STD_opts_help();
+
+    if (user_help) user_help();
+}
+
+/*********************************************************************
+ * STD_opts_help() - return a help string for the STD_OPTIONS.
+ *********************************************************************/
+void
+STD_opts_help()
+{
+    int i;
+
+    for(i = 0; std_options[i].optstr; ++i) {
+	if (std_options[i].help)
+	    printf(std_options[i].help);
+    }
+}
+
+/* 
+ * routine to goto when we get the SIGUSR1 for STD_PAUSE
+ */
+void STD_go(int sig)
+{
+   return;
+}
+
+/***********************************************************************
+ * This function will do desired end of global setup test
+ * hooks.
+ * Currently it will only do a pause waiting for sigusr1 if
+ * STD_PAUSE is set.
+ *
+ ***********************************************************************/
+int
+usc_global_setup_hook()
+{
+    int cnt;
+    /* temp variable to store old signal action to be restored after pause */
+    int (*_TMP_FUNC)(void);
+
+    /*
+     * Fork STD_COPIES-1 copies.
+     */
+    for(cnt=1;cnt<STD_COPIES;cnt++) {
+        switch(fork() ) {
+	    case -1:
+		fprintf(stderr, "%s: fork() failed, errno:%d %s\n",
+                __FILE__, errno, strerror(errno));
+		break;
+	    case 0:  /* child */
+	        cnt=STD_COPIES;   /* to stop the forking */
+		break;
+
+	    default: /* parent */
+		break;
+	}
+    }
+    
+    /*
+     * pause waiting for sigusr1.
+     */
+    if ( STD_PAUSE ) {                                      
+        _TMP_FUNC = (int (*)())signal(SIGUSR1, STD_go);   
+        pause();                                          
+        signal(SIGUSR1, (void (*)())_TMP_FUNC);          
+    }
+
+
+    if ( STD_TP_sbrk || STD_LP_sbrk) {
+	STD_start_break=sbrk(0);	/* get original sbreak size */
+    }
+
+    if ( STD_TP_sbrk ) {
+	sbrk(STD_TP_sbrk);
+	if ( Debug ) 
+	    printf("after sbrk(%d)\n", STD_TP_sbrk);
+    }
+    return 0;
+}
+
+#define USECS_PER_SEC	1000000  /* microseconds per second */
+
+/***********************************************************************
+ * This function returns the number of get_current_time()'s return
+ * per second.
+ ***********************************************************************/
+
+static int
+get_timepersec()
+{
+    return  USECS_PER_SEC;   /* microseconds per second */
+
+}
+
+/***********************************************************************
+ * this function will get current time in microseconds since 1970.
+ ***********************************************************************/
+static int
+get_current_time()
+{
+    struct timeval curtime;
+
+    gettimeofday(&curtime, NULL);
+
+    /* microseconds since 1970 */
+    return (curtime.tv_sec*USECS_PER_SEC) + curtime.tv_usec;
+
+
+}
+
+/***********************************************************************
+ *
+ * This function will determine if test should continue iterating
+ * If the STD_INFINITE flag is set, return 1.
+ * If the STD_LOOP_COUNT variable is set, compare it against
+ * the counter.
+ * If the STD_LOOP_DURATION variable is set, compare current time against
+ * calculated stop_time.
+ * This function will return 1 until all desired looping methods
+ * have been met.  
+ *
+ * counter integer is supplied by the user program.
+ ***********************************************************************/
+int
+usc_test_looping(counter)
+int counter;
+{
+    static int first_time = 1;
+    static int stop_time = 0;	/* stop time in rtc or usecs */
+    static int delay;		/* delay in clocks or usecs  */
+    int hz=0;			/* clocks per second or usecs per second */
+    int ct, end;		/* current time, end delay time */
+    int keepgoing=0;		/* used to determine return value */
+
+    /*
+     * If this is the first iteration and we are looping for 
+     * duration of STD_LOOP_DURATION seconds (fractional) or
+     * doing loop delays, get the clocks per second.
+     */
+    if ( first_time ) {
+
+	first_time=0;
+	if ( STD_LOOP_DELAY || STD_LOOP_DURATION ) {
+	    hz = get_timepersec();
+	}
+
+	/*
+	 * If looping for duration, calculate stop time in
+	 * clocks.
+	 */
+	
+	if ( STD_LOOP_DURATION) {
+	    ct=get_current_time();
+	    stop_time=(int)((float)hz * STD_LOOP_DURATION) + ct;
+	}
+
+	/*
+	 * If doing delay each iteration, calcuate the number
+	 * of clocks for each delay.
+	 */
+	if ( STD_LOOP_DELAY ) {
+	    delay=(int)((float)hz * STD_LOOP_DELAY);
+	}
+
+    }
+	
+    /*
+     * if delay each iteration, loop for delay clocks.
+     * This will not be done on first iteration.
+     * The delay will happen before determining if
+     * there will be another iteration.
+     */
+    else if ( STD_LOOP_DELAY ) {
+	ct=get_current_time();
+        end=ct+delay;
+        while ( ct < end ) {
+	    /*
+	     * The following are special test hooks in the delay loop.
+	     */
+	    if ( STD_LD_recfun ) {
+		if ( Debug )
+		    printf("calling usc_recressive_func(0, %d, &STD_bigstack)\n", 
+		        STD_LD_recfun);
+		usc_recressive_func(0, STD_LD_recfun, &STD_bigstack);
+	    }
+
+	    ct=get_current_time();
+	}
+    }
+
+    if ( STD_INFINITE ) {
+	keepgoing++;
+    }
+
+    if ( STD_LOOP_COUNT && counter < STD_LOOP_COUNT ) {
+	keepgoing++;
+    }
+
+    if ( STD_LOOP_DURATION != 0.0 && get_current_time() < stop_time ) {
+	keepgoing++;
+    }
+
+    if ( keepgoing == 0 )
+	return 0;
+
+    /*
+     * The following code allows special system testing hooks.
+     */
+
+    if ( STD_LP_recfun ) {
+	if ( Debug )
+	    printf("calling usc_recressive_func(0, %d, &STD_bigstack)\n", 
+	        STD_LP_recfun);
+	usc_recressive_func(0, STD_LP_recfun, &STD_bigstack);
+    }
+
+    if ( STD_LP_sbrk ) {
+	if ( Debug )
+	    printf("about to do sbrk(%d)\n", STD_LP_sbrk);
+	sbrk(STD_LP_sbrk);
+    }
+
+
+    if ( keepgoing )
+	return 1;
+    else
+        return 0;	/* done - stop iterating */
+}
+
+
+/*
+ * This function recressively calls itself max times.
+ */ 
+static void
+usc_recressive_func(cnt, max, bstack)
+int cnt;
+int max;
+struct usc_bigstack_t bstack;
+{
+    if ( cnt < max )
+	usc_recressive_func(cnt+1, max, bstack);
+
+}
+
+#if UNIT_TEST
+/******************************************************************************
+ * UNIT TEST CODE
+ * UNIT TEST CODE
+ * 
+ * this following code is provide so that unit testing can
+ * be done fairly easily.
+ ******************************************************************************/
+
+int Help = 0;
+int Help2 = 0;
+char *ptr;
+
+/*
+ * Code from usctest.h that not part of this file since we are the library.
+ */
+
+struct usc_errno_t TEST_VALID_ENO[USC_MAX_ERRNO];
+
+  /***********************************************************************
+   * Globals for returning the return code and errno from the system call
+   * test macros.
+   ***********************************************************************/
+int TEST_RETURN;
+int TEST_ERRNO;
+
+  /***********************************************************************
+   * temporary variables for determining max and min times in TEST macro
+   ***********************************************************************/
+long btime, etime, tmptime;
+
+
+
+/* for test specific parse_opts options */
+option_t Options[] = {
+        { "help",  &Help2, NULL },      /* -help option */
+        { "h",  &Help, NULL },          /* -h option */
+ 	{ TIMING, NULL, NULL},		/* disable -timing option */
+
+#if INVALID_TEST_CASES
+ 	{ "missingflag", NULL, &ptr },  /* error */
+ 	{ "missingarg:", &Help, NULL },  /* error */
+#endif  /* INVALID_TEST_CASES */
+
+        { NULL, NULL, NULL }
+};
+
+
+main(argc, argv)
+int argc;
+char **argv;
+{
+    int lc;
+    char *msg;
+    struct timeval t;
+    int cnt;
+
+    if ( (msg=parse_opts(argc, argv,
+			(option_t *) Options)) != (char *) NULL ) {
+	printf("ERROR : %s\n", msg);
+	exit(1);
+    }
+
+    TEST_PAUSE;
+
+    for (lc=0; TEST_LOOPING(lc); lc++) {
+    
+        TEST( gettimeofday(&t, NULL) );
+        printf("iter=%d: sec:%d, usec:%6.6d %s", lc+1, t.tv_sec,
+	    t.tv_usec, ctime(&t.tv_sec));
+    }
+
+
+    TEST_CLEANUP;
+
+    exit(0);
+}
+
+#endif /* UNIT_TEST */