1 /* 2 * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved. 3 * AUTHOR : William Roske/Richard Logan 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 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, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 12 * 13 * Further, this software is distributed without any warranty that it is 14 * free of the rightful claim of any third person regarding infringement 15 * or the like. Any license provided herein, whether implied or 16 * otherwise, applies only to this software file. Patent licenses, if 17 * any, provided herein do not apply to combinations of this program with 18 * other software, or any other product whatsoever. 19 * 20 * You should have received a copy of the GNU General Public License along 21 * with this program; if not, write the Free Software Foundation, Inc., 22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 23 * 24 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, 25 * Mountain View, CA 94043, or: 26 * 27 * http://www.sgi.com 28 * 29 * For further information regarding this notice, see: 30 * 31 * http://oss.sgi.com/projects/GenInfo/NoticeExplan/ 32 */ 33 34 #include "config.h" 35 #include <errno.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <sys/param.h> 39 #include <sys/signal.h> 40 #include <sys/types.h> 41 #include <unistd.h> 42 #include <sys/time.h> 43 #include <stdint.h> 44 45 #include "test.h" 46 #include "ltp_priv.h" 47 #include "usctest.h" 48 49 #ifndef UNIT_TEST 50 #define UNIT_TEST 0 51 #endif 52 53 /* Define flags and args for standard options */ 54 static int STD_INFINITE = 0; /* flag indciating to loop forever */ 55 int STD_LOOP_COUNT = 1; /* number of iterations */ 56 57 static float STD_LOOP_DURATION = 0.0; /* duration value in fractional seconds */ 58 59 static char **STD_opt_arr = NULL; /* array of option strings */ 60 static int STD_argind = 1; /* argv index to next argv element */ 61 /* (first argument) */ 62 /* To getopt users, it is like optind */ 63 64 /* 65 * The following variables are to support system testing additions. 66 */ 67 static int STD_TP_barrier = 0; /* flag to do barrier in TEST_PAUSE */ 68 /* 2 - wait_barrier(), 3 - set_barrier(), * - barrier() */ 69 static int STD_LP_barrier = 0; /* flag to do barrier in TEST_LOOPING */ 70 /* 2 - wait_barrier(), 3 - set_barrier(), * - barrier() */ 71 static int STD_TP_shmem_sz = 0; /* shmalloc this many words per pe in TEST_PAUSE */ 72 static int STD_LD_shmem = 0; /* flag to do shmem_puts and shmem_gets during delay */ 73 static int STD_LP_shmem = 0; /* flag to do shmem_puts and gets during TEST_LOOPING */ 74 static int STD_LD_recfun = 0; /* do recressive function calls in loop delay */ 75 static int STD_LP_recfun = 0; /* do recressive function calls in TEST_LOOPING */ 76 static int STD_TP_sbrk = 0; /* do sbrk in TEST_PAUSE */ 77 static int STD_LP_sbrk = 0; /* do sbrk in TEST_LOOPING */ 78 static char *STD_start_break = 0; /* original sbrk size */ 79 static int Debug = 0; 80 81 static struct std_option_t { 82 char *optstr; 83 char *help; 84 char *flag; 85 char **arg; 86 } std_options[] = { 87 {"h", " -h Show this help screen\n", NULL, NULL}, 88 {"i:", " -i n Execute test n times\n", NULL, NULL}, 89 {"I:", " -I x Execute test for x seconds\n", NULL, NULL}, 90 #ifdef UCLINUX 91 {"C:", 92 " -C ARG Run the child process with arguments ARG (for internal use)\n", 93 NULL, NULL}, 94 #endif 95 {NULL, NULL, NULL, NULL} 96 }; 97 98 /* 99 * Structure for usc_recressive_func argument 100 */ 101 struct usc_bigstack_t { 102 char space[4096]; 103 }; 104 105 static struct usc_bigstack_t *STD_bigstack = NULL; 106 107 /* define the string length for Mesg and Mesg2 strings */ 108 #define STRLEN 2048 109 110 static char Mesg2[STRLEN]; /* holds possible return string */ 111 static void usc_recressive_func(); 112 113 /* 114 * Define bits for options that might have env variable default 115 */ 116 #define OPT_iteration 01 117 #define OPT_duration 04 118 #define OPT_delay 010 119 120 #ifdef UCLINUX 121 /* Allocated and used in self_exec.c: */ 122 extern char *child_args; /* Arguments to child when -C is used */ 123 #endif 124 125 static void print_help(void (*user_help)(void)) 126 { 127 int i; 128 129 for (i = 0; std_options[i].optstr; ++i) { 130 if (std_options[i].help) 131 printf("%s", std_options[i].help); 132 } 133 134 if (user_help) 135 user_help(); 136 } 137 138 /********************************************************************** 139 * parse_opts: 140 **********************************************************************/ 141 const char *parse_opts(int ac, char **av, const option_t * user_optarr, 142 void (*uhf)(void)) 143 { 144 int found; /* flag to indicate that an option specified was */ 145 /* found in the user's list */ 146 int k; /* scratch integer for returns and short time usage */ 147 float ftmp; /* tmp float for parsing env variables */ 148 char *ptr; /* used in getting env variables */ 149 int options = 0; /* no options specified */ 150 int optstrlen, i; 151 char *optionstr; 152 int opt; 153 154 /* 155 * If not the first time this function is called, release the old STD_opt_arr 156 * vector. 157 */ 158 if (STD_opt_arr != NULL) { 159 free(STD_opt_arr); 160 STD_opt_arr = NULL; 161 } 162 /* Calculate how much space we need for the option string */ 163 optstrlen = 0; 164 for (i = 0; std_options[i].optstr; ++i) 165 optstrlen += strlen(std_options[i].optstr); 166 if (user_optarr) 167 for (i = 0; user_optarr[i].option; ++i) { 168 if (strlen(user_optarr[i].option) > 2) 169 return 170 "parse_opts: ERROR - Only short options are allowed"; 171 optstrlen += strlen(user_optarr[i].option); 172 } 173 optstrlen += 1; 174 175 /* Create the option string for getopt */ 176 optionstr = malloc(optstrlen); 177 if (!optionstr) 178 return 179 "parse_opts: ERROR - Could not allocate memory for optionstr"; 180 181 optionstr[0] = '\0'; 182 183 for (i = 0; std_options[i].optstr; ++i) 184 strcat(optionstr, std_options[i].optstr); 185 if (user_optarr) 186 for (i = 0; user_optarr[i].option; ++i) 187 /* only add the option if it wasn't there already */ 188 if (strchr(optionstr, user_optarr[i].option[0]) == NULL) 189 strcat(optionstr, user_optarr[i].option); 190 191 /* 192 * Loop through av parsing options. 193 */ 194 while ((opt = getopt(ac, av, optionstr)) > 0) { 195 196 STD_argind = optind; 197 198 switch (opt) { 199 case '?': /* Unknown option */ 200 return "Unknown option"; 201 break; 202 case ':': /* Missing Arg */ 203 return "Missing argument"; 204 break; 205 case 'i': /* Iterations */ 206 options |= OPT_iteration; 207 STD_LOOP_COUNT = atoi(optarg); 208 if (STD_LOOP_COUNT == 0) 209 STD_INFINITE = 1; 210 break; 211 case 'I': /* Time duration */ 212 options |= OPT_duration; 213 STD_LOOP_DURATION = atof(optarg); 214 if (STD_LOOP_DURATION == 0.0) 215 STD_INFINITE = 1; 216 break; 217 case 'h': /* Help */ 218 print_help(uhf); 219 exit(0); 220 break; 221 #ifdef UCLINUX 222 case 'C': /* Run child */ 223 child_args = optarg; 224 break; 225 #endif 226 default: 227 228 /* Check all the user specified options */ 229 found = 0; 230 for (i = 0; user_optarr[i].option; ++i) { 231 232 if (opt == user_optarr[i].option[0]) { 233 /* Yup, This is a user option, set the flag and look for argument */ 234 if (user_optarr[i].flag) { 235 *user_optarr[i].flag = 1; 236 } 237 found++; 238 239 /* save the argument at the user's location */ 240 if (user_optarr[i]. 241 option[strlen(user_optarr[i].option) 242 - 1] == ':') { 243 *user_optarr[i].arg = optarg; 244 } 245 break; /* option found - break out of the for loop */ 246 } 247 } 248 /* This condition "should never happen". SO CHECK FOR IT!!!! */ 249 if (!found) { 250 sprintf(Mesg2, 251 "parse_opts: ERROR - option:\"%c\" NOT FOUND... INTERNAL " 252 "ERROR", opt); 253 return (Mesg2); 254 } 255 } 256 257 } 258 free(optionstr); 259 260 STD_argind = optind; 261 262 /* 263 * Turn on debug 264 */ 265 if (getenv("USC_DEBUG") != NULL) { 266 Debug = 1; 267 printf("env USC_DEBUG is defined, turning on debug\n"); 268 } 269 if (getenv("USC_VERBOSE") != NULL) { 270 Debug = 1; 271 printf("env USC_VERBOSE is defined, turning on debug\n"); 272 } 273 274 /* 275 * If the USC_ITERATION_ENV environmental variable is set to 276 * a number, use that number as iteration count (same as -c option). 277 * The -c option with arg will be used even if this env var is set. 278 */ 279 if (!(options & OPT_iteration) 280 && (ptr = getenv(USC_ITERATION_ENV)) != NULL) { 281 if (sscanf(ptr, "%i", &k) == 1) { 282 if (k == 0) { /* if arg is 0, set infinite loop flag */ 283 STD_INFINITE = 1; 284 if (Debug) 285 printf 286 ("Using env %s, set STD_INFINITE to 1\n", 287 USC_ITERATION_ENV); 288 } else { /* else, set the loop count to the arguement */ 289 STD_LOOP_COUNT = k; 290 if (Debug) 291 printf 292 ("Using env %s, set STD_LOOP_COUNT to %d\n", 293 USC_ITERATION_ENV, k); 294 } 295 } 296 } 297 298 /* 299 * If the USC_LOOP_WALLTIME environmental variable is set, 300 * use that number as duration (same as -I option). 301 * The -I option with arg will be used even if this env var is set. 302 */ 303 304 if (!(options & OPT_duration) && 305 (ptr = getenv(USC_LOOP_WALLTIME)) != NULL) { 306 if (sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0) { 307 STD_LOOP_DURATION = ftmp; 308 if (Debug) 309 printf 310 ("Using env %s, set STD_LOOP_DURATION to %f\n", 311 USC_LOOP_WALLTIME, ftmp); 312 if (STD_LOOP_DURATION == 0.0) { /* if arg is 0, set infinite loop flag */ 313 STD_INFINITE = 1; 314 if (Debug) 315 printf 316 ("Using env %s, set STD_INFINITE to 1\n", 317 USC_LOOP_WALLTIME); 318 } 319 } 320 } 321 if (!(options & OPT_duration) && (ptr = getenv("USC_DURATION")) != NULL) { 322 if (sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0) { 323 STD_LOOP_DURATION = ftmp; 324 if (Debug) 325 printf 326 ("Using env USC_DURATION, set STD_LOOP_DURATION to %f\n", 327 ftmp); 328 if (STD_LOOP_DURATION == 0.0) { /* if arg is 0, set infinite loop flag */ 329 STD_INFINITE = 1; 330 if (Debug) 331 printf 332 ("Using env USC_DURATION, set STD_INFINITE to 1\n"); 333 } 334 } 335 } 336 337 /* 338 * The following are special system testing envs to turn on special 339 * hooks in the code. 340 */ 341 if ((ptr = getenv("USC_TP_BARRIER")) != NULL) { 342 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) 343 STD_TP_barrier = k; 344 else 345 STD_TP_barrier = 1; 346 if (Debug) 347 printf 348 ("using env USC_TP_BARRIER, Set STD_TP_barrier to %d\n", 349 STD_TP_barrier); 350 } 351 352 if ((ptr = getenv("USC_LP_BARRIER")) != NULL) { 353 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) 354 STD_LP_barrier = k; 355 else 356 STD_LP_barrier = 1; 357 if (Debug) 358 printf 359 ("using env USC_LP_BARRIER, Set STD_LP_barrier to %d\n", 360 STD_LP_barrier); 361 } 362 363 if ((ptr = getenv("USC_TP_SHMEM")) != NULL) { 364 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 365 STD_TP_shmem_sz = k; 366 if (Debug) 367 printf 368 ("Using env USC_TP_SHMEM, Set STD_TP_shmem_sz to %d\n", 369 STD_TP_shmem_sz); 370 } 371 } 372 373 if ((ptr = getenv("USC_LP_SHMEM")) != NULL) { 374 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 375 STD_LP_shmem = k; 376 if (Debug) 377 printf 378 ("Using env USC_LP_SHMEM, Set STD_LP_shmem to %d\n", 379 STD_LP_shmem); 380 } 381 } 382 383 if ((ptr = getenv("USC_LD_SHMEM")) != NULL) { 384 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 385 STD_LD_shmem = k; 386 if (Debug) 387 printf 388 ("Using env USC_LD_SHMEM, Set STD_LD_shmem to %d\n", 389 STD_LD_shmem); 390 } 391 } 392 393 if ((ptr = getenv("USC_TP_SBRK")) != NULL) { 394 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 395 STD_TP_sbrk = k; 396 if (Debug) 397 printf 398 ("Using env USC_TP_SBRK, Set STD_TP_sbrk to %d\n", 399 STD_TP_sbrk); 400 } 401 } 402 #if !defined(UCLINUX) 403 if ((ptr = getenv("USC_LP_SBRK")) != NULL) { 404 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 405 STD_LP_sbrk = k; 406 if (Debug) 407 printf 408 ("Using env USC_LP_SBRK, Set STD_LP_sbrk to %d\n", 409 STD_LP_sbrk); 410 } 411 } 412 #endif /* if !defined(UCLINUX) */ 413 414 if ((ptr = getenv("USC_LP_RECFUN")) != NULL) { 415 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 416 STD_LP_recfun = k; 417 if (STD_bigstack != NULL) 418 STD_bigstack = 419 malloc(sizeof(struct usc_bigstack_t)); 420 if (Debug) 421 printf 422 ("Using env USC_LP_RECFUN, Set STD_LP_recfun to %d\n", 423 STD_LP_recfun); 424 } 425 } 426 427 if ((ptr = getenv("USC_LD_RECFUN")) != NULL) { 428 if (sscanf(ptr, "%i", &k) == 1 && k >= 0) { 429 STD_LD_recfun = k; 430 if (STD_bigstack != NULL) 431 STD_bigstack = 432 malloc(sizeof(struct usc_bigstack_t)); 433 if (Debug) 434 printf 435 ("Using env USC_LD_RECFUN, Set STD_LD_recfun to %d\n", 436 STD_LD_recfun); 437 } 438 } 439 #if UNIT_TEST 440 printf("The following variables after option and env parsing:\n"); 441 printf("STD_LOOP_DURATION = %f\n", STD_LOOP_DURATION); 442 printf("STD_LOOP_COUNT = %d\n", STD_LOOP_COUNT); 443 printf("STD_INFINITE = %d\n", STD_INFINITE); 444 #endif 445 446 return NULL; 447 } 448 449 /*********************************************************************** 450 * This function will do desired end of global setup test 451 * hooks. 452 ***********************************************************************/ 453 int usc_global_setup_hook(void) 454 { 455 #ifndef UCLINUX 456 if (STD_TP_sbrk || STD_LP_sbrk) 457 STD_start_break = sbrk(0); /* get original sbreak size */ 458 459 if (STD_TP_sbrk) { 460 sbrk(STD_TP_sbrk); 461 if (Debug) 462 printf("after sbrk(%d)\n", STD_TP_sbrk); 463 } 464 #endif 465 return 0; 466 } 467 468 #define USECS_PER_SEC 1000000 /* microseconds per second */ 469 470 /*********************************************************************** 471 * Returns current time in microseconds since 1970. 472 ***********************************************************************/ 473 static uint64_t get_current_time(void) 474 { 475 struct timeval curtime; 476 477 gettimeofday(&curtime, NULL); 478 479 return (((uint64_t) curtime.tv_sec) * USECS_PER_SEC) + curtime.tv_usec; 480 } 481 482 /*********************************************************************** 483 * 484 * This function will determine if test should continue iterating 485 * If the STD_INFINITE flag is set, return 1. 486 * If the STD_LOOP_COUNT variable is set, compare it against 487 * the counter. 488 * If the STD_LOOP_DURATION variable is set, compare current time against 489 * calculated stop_time. 490 * This function will return 1 until all desired looping methods 491 * have been met. 492 * 493 * counter integer is supplied by the user program. 494 ***********************************************************************/ 495 int usc_test_looping(int counter) 496 { 497 static int first_time = 1; 498 static uint64_t stop_time = 0; 499 int keepgoing = 0; 500 501 /* 502 * If this is the first iteration and we are looping for 503 * duration of STD_LOOP_DURATION seconds (fractional) or 504 * doing loop delays, get the clocks per second. 505 */ 506 if (first_time) { 507 first_time = 0; 508 509 /* 510 * If looping for duration, calculate stop time in 511 * clocks. 512 */ 513 if (STD_LOOP_DURATION) { 514 stop_time = 515 (uint64_t) (USECS_PER_SEC * STD_LOOP_DURATION) 516 + get_current_time(); 517 } 518 } 519 520 if (STD_INFINITE) 521 keepgoing++; 522 523 if (STD_LOOP_COUNT && counter < STD_LOOP_COUNT) 524 keepgoing++; 525 526 if (STD_LOOP_DURATION != 0.0 && get_current_time() < stop_time) 527 keepgoing++; 528 529 if (keepgoing == 0) 530 return 0; 531 532 /* 533 * The following code allows special system testing hooks. 534 */ 535 536 if (STD_LP_recfun) { 537 if (Debug) 538 printf 539 ("calling usc_recressive_func(0, %d, *STD_bigstack)\n", 540 STD_LP_recfun); 541 usc_recressive_func(0, STD_LP_recfun, *STD_bigstack); 542 } 543 #if !defined(UCLINUX) 544 if (STD_LP_sbrk) { 545 if (Debug) 546 printf("about to do sbrk(%d)\n", STD_LP_sbrk); 547 sbrk(STD_LP_sbrk); 548 } 549 #endif 550 551 if (keepgoing) 552 return 1; 553 else 554 return 0; 555 } 556 557 /* 558 * This function recressively calls itself max times. 559 */ 560 static void usc_recressive_func(int cnt, int max, struct usc_bigstack_t bstack) 561 { 562 if (cnt < max) 563 usc_recressive_func(cnt + 1, max, bstack); 564 565 } 566 567 #if UNIT_TEST 568 #include <time.h> 569 570 /****************************************************************************** 571 * UNIT TEST CODE 572 * UNIT TEST CODE 573 * 574 * this following code is provide so that unit testing can 575 * be done fairly easily. 576 ******************************************************************************/ 577 578 int Help = 0; 579 int Help2 = 0; 580 char *ptr; 581 582 long TEST_RETURN; 583 int TEST_ERRNO; 584 585 /* for test specific parse_opts options */ 586 option_t Options[] = { 587 {"help", &Help2, NULL}, /* -help option */ 588 {"h", &Help, NULL}, /* -h option */ 589 590 #if INVALID_TEST_CASES 591 {"missingflag", NULL, &ptr}, /* error */ 592 {"missingarg:", &Help, NULL}, /* error */ 593 #endif /* INVALID_TEST_CASES */ 594 595 {NULL, NULL, NULL} 596 }; 597 598 int main(int argc, char **argv) 599 { 600 int lc; 601 char *msg; 602 struct timeval t; 603 int cnt; 604 605 if ((msg = parse_opts(argc, argv, Options, NULL)) != NULL) { 606 printf("ERROR: %s\n", msg); 607 exit(1); 608 } 609 610 TEST_PAUSE; 611 612 for (lc = 0; TEST_LOOPING(lc); lc++) { 613 614 TEST(gettimeofday(&t, NULL)); 615 printf("iter=%d: sec:%d, usec:%6.6d %s", lc + 1, t.tv_sec, 616 t.tv_usec, ctime(&t.tv_sec)); 617 } 618 619 TEST_CLEANUP; 620 621 exit(0); 622 } 623 624 #endif /* UNIT_TEST */ 625
