Make xfstests build use -O2 by default.
[xfstests-dev.git] / include / usctest.h
1 /*
2  * Copyright (c) 2000 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 /* $Id: usctest.h,v 1.2 2005/11/09 02:50:19 nathans.longdrop.melbourne.sgi.com Exp $ */
20
21 /**********************************************************
22  * 
23  *    IRIX/Linux Feature Test and Evaluation - Silicon Graphics, Inc.
24  * 
25  *    FUNCTION NAME     : usctest.h
26  * 
27  *    FUNCTION TITLE    : System Call Test Macros
28  * 
29  *    SYNOPSIS:
30  *      See DESCRIPTION below.
31  * 
32  *    AUTHOR            : William Roske
33  * 
34  *    INITIAL RELEASE   : UNICOS 7.0
35  * 
36  *    DESCRIPTION
37  *      TEST(SCALL) - calls a system call
38  *      TEST_VOID(SCALL) - same as TEST() but for syscalls with no return value.
39  *      TEST_CLEANUP - print the log of errno return counts if STD_ERRNO_LOG 
40  *                     is set.
41  *      TEST_PAUSEF(HAND) - Pause for SIGUSR1 if the pause flag is set.
42  *                    Use "hand" as the interrupt handling function
43  *      TEST_PAUSE -  Pause for SIGUSR1 if the pause flag is set.
44  *                    Use internal function to do nothing on signal and go on.
45  *      TEST_LOOPING(COUNTER) - Conditional to check if test should
46  *                    loop.  Evaluates to TRUE (1) or FALSE (0).
47  *      TEST_ERROR_LOG(eno) - log that this errno was received,
48  *                    if STD_ERRNO_LOG is set.
49  *      TEST_EXP_ENOS(array) - set the bits in TEST_VALID_ENO array at
50  *                    positions specified in integer "array"
51  *
52  *    RETURN VALUE
53  *      TEST(SCALL) - Global Variables set:
54  *                      int TEST_RETURN=return code from SCALL
55  *                      int TEST_ERRNO=value of errno at return from SCALL
56  *      TEST_VOID(SCALL) - Global Variables set:
57  *                      int TEST_ERRNO=value of errno at return from SCALL
58  *      TEST_CLEANUP - None.
59  *      TEST_PAUSEF(HAND) -  None.
60  *      TEST_PAUSE -  None.
61  *      TEST_LOOPING(COUNTER) - True if COUNTER < STD_LOOP_COUNT or
62  *                      STD_INFINITE is set.
63  *      TEST_ERROR_LOG(eno) - None
64  *      TEST_EXP_ENOS(array) - None
65  *
66  *    KNOWN BUGS
67  *      If you use the TEST_PAUSE or TEST_LOOPING macros, you must
68  *      link in parse_opts.o, which contains the code for those functions.
69  *
70  *#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#**/
71
72 #ifndef  __USCTEST_H__
73 #define __USCTEST_H__ 1
74
75 #ifndef _SC_CLK_TCK
76 #include <unistd.h>
77 #endif
78
79 #include <sys/param.h>
80
81 /* 
82  * Ensure that PATH_MAX is defined 
83  */
84 #ifndef PATH_MAX
85 #ifdef MAXPATHLEN
86 #define PATH_MAX  MAXPATHLEN
87 #else
88 #define PATH_MAX  1024
89 #endif
90 #endif
91
92 #ifndef CRAY
93 #ifndef BSIZE 
94 #define BSIZE BBSIZE
95 #endif
96 #endif
97
98 /***********************************************************************
99  * Define option_t structure type.
100  * Entries in this struct are used by the parse_opts routine
101  * to indicate valid options and return option arguments
102  ***********************************************************************/
103 typedef struct {                
104   char *option;         /* Valid option string (one option only) like "a:" */
105   int  *flag;           /* pointer to location to set true if option given */
106   char **arg;           /* pointer to location to place argument, if needed */
107 } option_t;
108
109 /***********************************************************************
110  * The following globals are defined in parse_opts.c but must be 
111  * externed here because they are used in the macros defined below.
112  ***********************************************************************/
113 extern int STD_FUNCTIONAL_TEST, /* turned off by -f to not do functional test */
114            STD_TIMING_ON,       /* turned on by -t to print timing stats */
115            STD_PAUSE,           /* turned on by -p to pause before loop */
116            STD_INFINITE,        /* turned on by -i0 to loop forever */
117            STD_LOOP_COUNT,      /* changed by -in to set loop count to n */
118            STD_ERRNO_LOG,       /* turned on by -e to log errnos returned */
119            STD_ERRNO_LIST[],    /* counts of errnos returned.  indexed by errno */
120            STD_COPIES,
121            STD_argind;
122
123 extern float STD_LOOP_DURATION, /* wall clock time to iterate */
124              STD_LOOP_DELAY;    /* delay time after each iteration */
125
126 #define USC_MAX_ERRNO   2000
127     
128 /**********************************************************************
129  * Prototype for parse_opts routine
130  **********************************************************************/
131 extern char *parse_opts(int ac, char **av, option_t *user_optarr, void (*uhf)());
132
133
134 /*
135  * define a structure 
136  */
137 struct usc_errno_t {
138     int flag;
139 };
140
141 /***********************************************************************
142  ****
143  **** 
144  ****
145  **********************************************************************/
146 #ifdef  _USC_LIB_
147
148 extern int TEST_RETURN;
149 extern int TEST_ERRNO;
150
151 #else
152 /***********************************************************************
153  * Global array of bit masks to indicate errnos that are expected.
154  * Bits set by TEST_EXP_ENOS() macro and used by TEST_CLEANUP() macro.
155  ***********************************************************************/
156 struct usc_errno_t TEST_VALID_ENO[USC_MAX_ERRNO];
157
158 /***********************************************************************
159  * Globals for returning the return code and errno from the system call
160  * test macros.
161  ***********************************************************************/
162 int TEST_RETURN;
163 int TEST_ERRNO;
164
165 /***********************************************************************
166  * temporary variables for determining max and min times in TEST macro
167  ***********************************************************************/
168 long btime, etime, tmptime;     
169
170 #endif  /* _USC_LIB_ */
171
172 /***********************************************************************
173  * structure for timing accumulator and counters 
174  ***********************************************************************/
175 struct tblock {
176     long tb_max;
177     long tb_min;
178     long tb_total;
179     long tb_count;
180 };
181
182 /***********************************************************************
183  * The following globals are externed here so that they are accessable
184  * in the macros that follow.
185  ***********************************************************************/
186 extern struct tblock tblock;
187 extern void STD_go();
188 extern int (*_TMP_FUNC)(void);
189 extern void STD_opts_help();
190
191
192 /***********************************************************************
193  * TEST: calls a system call 
194  * 
195  * parameters:
196  *      SCALL = system call and parameters to execute
197  *
198  ***********************************************************************/
199 #define TEST(SCALL) errno=0; TEST_RETURN = (unsigned) SCALL;  TEST_ERRNO=errno;
200
201 /***********************************************************************
202  * TEST_VOID: calls a system call
203  * 
204  * parameters:
205  *      SCALL = system call and parameters to execute
206  *
207  * Note: This is IDENTICAL to the TEST() macro except that it is intended
208  * for use with syscalls returning no values (void syscall()).  The 
209  * Typecasting nothing (void) into an unsigned integer causes compilation
210  * errors.
211  *
212  ***********************************************************************/
213 #define TEST_VOID(SCALL)  errno=0; SCALL; TEST_ERRNO=errno;
214
215 /***********************************************************************
216  * TEST_CLEANUP: print system call timing stats and errno log entries
217  * to stdout if STD_TIMING_ON and STD_ERRNO_LOG are set, respectively.
218  * Do NOT print ANY information if no system calls logged.
219  * 
220  * parameters:
221  *      none
222  *
223  ***********************************************************************/
224 #define TEST_CLEANUP    \
225 if ( STD_ERRNO_LOG ) {                                          \
226         for (tmptime=0; tmptime<USC_MAX_ERRNO; tmptime++) {             \
227              if ( STD_ERRNO_LIST[tmptime] )     {                       \
228                  if ( TEST_VALID_ENO[tmptime].flag )                    \
229                      tst_resm(TINFO, "ERRNO %d:\tReceived %d Times",    \
230                               tmptime, STD_ERRNO_LIST[tmptime]);        \
231                  else                                                   \
232                      tst_resm(TINFO,                                    \
233                               "ERRNO %d:\tReceived %d Times ** UNEXPECTED **",  \
234                               tmptime, STD_ERRNO_LIST[tmptime]);        \
235              }                                                          \
236         }                                                               \
237 }
238
239 /***********************************************************************
240  * TEST_PAUSEF: Pause for SIGUSR1 if the pause flag is set.
241  *               Set the user specified function as the interrupt
242  *               handler instead of "STD_go"
243  * 
244  * parameters:
245  *      none
246  *
247  ***********************************************************************/
248 #define TEST_PAUSEF(HANDLER)                                    \
249 if ( STD_PAUSE ) {                                      \
250     _TMP_FUNC = (int (*)())signal(SIGUSR1, HANDLER);    \
251     pause();                                            \
252     signal(SIGUSR1, (void (*)())_TMP_FUNC);             \
253 }
254
255 /***********************************************************************
256  * TEST_PAUSE: Pause for SIGUSR1 if the pause flag is set.
257  *             Just continue when signal comes in.
258  * 
259  * parameters:
260  *      none
261  *
262  ***********************************************************************/
263 #define TEST_PAUSE usc_global_setup_hook();
264 int usc_global_setup_hook();
265
266 /***********************************************************************
267  * TEST_LOOPING now call the usc_test_looping function.
268  * The function will return 1 if the test should continue
269  * iterating.
270  *
271  ***********************************************************************/
272 #define TEST_LOOPING usc_test_looping
273 int usc_test_looping(int counter);
274
275 /***********************************************************************
276  * TEST_ERROR_LOG(eno): log this errno if STD_ERRNO_LOG flag set
277  * 
278  * parameters:
279  *      int eno: the errno location in STD_ERRNO_LIST to log.
280  *
281  ***********************************************************************/
282 #define TEST_ERROR_LOG(eno)             \
283     if ( STD_ERRNO_LOG )                \
284         if ( eno < USC_MAX_ERRNO )              \
285             STD_ERRNO_LIST[eno]++;      \
286
287
288 /***********************************************************************
289  * TEST_EXP_ENOS(array): set the bits associated with the nput errnos
290  *      in the TEST_VALID_ENO array.
291  * 
292  * parameters:
293  *      int array[]: a zero terminated array of errnos expected.
294  *
295  ***********************************************************************/
296 #define TEST_EXP_ENOS(array)                            \
297     tmptime=0;                                          \
298     while (array[tmptime] != 0) {                       \
299         if (array[tmptime] < USC_MAX_ERRNO)             \
300             TEST_VALID_ENO[array[tmptime]].flag=1;      \
301         tmptime++;                                      \
302     }
303                                         
304
305 #endif  /* end of __USCTEST_H__ */