tools/tests/xnu_quick_test/main.c

   1 /*
   2  * xnu_quick_test - this tool will do a quick test of every (well, to be
   3  * honest most) system calls we support in xnu.
   4  *
   5  * WARNING - this is not meant to be a full regression test of all the
   6  * system calls.  The intent is to have a quick test of each system call that
   7  * can be run very easily and quickly when a new kerenl is built.
   8  *
   9  * This tool is meant to grow as we find xnu problems that could have be
  10  * caught before we submit to a build train.  So please add more tests and
  11  * make the existing ones better.  Some of the original tests are nothing
  12  * more than place holders and quite lame.  Just keep in mind that the tool
  13  * should run as fast as possible.  If it gets too slow then most people
  14  * will stop running it.
  15  *
  16  * LP64 testing tip - when adding or modifying tests, keep in mind the
  17  * variants in the LP64 world.  If xnu gets passed a structure the varies in
  18  * size between 32 and 64-bit processes, try to test that a field in the
  19  * sructure contains valid data.  For example if we know foo structure
  20  * looks like:
  21  * struct foo {
  22  *              int             an_int;
  23  *              long    a_long;
  24  *              int             another_int;
  25  * }
  26  * And if we know what another_int should contain then test for the known
  27  * value since it's offset will vary depending on whether the calling process
  28  * is 32 or 64 bits.
  29  *
  30  * NOTE - we have several workarounds and test exceptions for some
  31  * outstanding bugs in xnu.  All the workarounds are marked with "todo" and
  32  * some comments noting the radar number of the offending bug.  Do a seach
  33  * for "todo" in the source files for this project to locate which tests have
  34  * known failures.   And please tag any new exceptions you find with "todo"
  35  * in the comment and the radar number of the bug.
  36  */
  37
  38 #include <errno.h>
  39 #include <fcntl.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <time.h>
  44 #include <grp.h>
  45 #include <unistd.h>
  46 #include <sys/mount.h>
  47 #include <sys/param.h>
  48 #include <sys/select.h>
  49 #include <sys/stat.h>
  50 #include <sys/syslimits.h>
  51 #include <sys/types.h>
  52 #include <sys/ucred.h>
  53 #include <sys/uio.h>
  54 #include <mach-o/ldsyms.h>
  55 #include <mach-o/loader.h>
  56 #include <mach-o/arch.h>
  57 #include "tests.h"
  58
  59 #if !TARGET_OS_EMBEDDED
  60 #include <XILog/XILog.h>
  61 #endif
  62
  63
  64
  65 /* our table of tests to run  */
  66 struct test_entry   g_tests[] =
  67 {
  68         {1, &syscall_test, NULL, "syscall"},
  69         {1, &fork_wait4_exit_test, NULL, "fork, wait4, exit"},
  70         {1, &read_write_test, NULL, "fsync, ftruncate, lseek, pread, pwrite, read, readv, truncate, write, writev"},
  71         {1, &open_close_test, NULL, "close, fpathconf, fstat, open, pathconf"},
  72         {1, &link_stat_unlink_test, NULL, "link, stat, unlink"},
  73         {1, &chdir_fchdir_test, NULL, "chdir, fchdir"},
  74         {1, &access_chmod_fchmod_test, NULL, "access, chmod, fchmod"},
  75         {1, &chown_fchown_lchown_lstat_symlink_test, NULL, "chown, fchown, lchown, lstat, readlink, symlink"},
  76         {1, &fs_stat_tests, NULL, "fstatfs, getfsstat, statfs, fstatfs64, getfsstat64, statfs64"},
  77 #if !TARGET_OS_EMBEDDED
  78         {1, &statfs_32bit_inode_tests, NULL, "32-bit inode versions: fstatfs, getfsstat, statfs"},
  79 #endif
  80         {1, &getpid_getppid_pipe_test, NULL, "getpid, getppid, pipe"},
  81         {1, &uid_tests, NULL, "getauid, gettid, getuid, geteuid, issetugid, setaudit_addr, seteuid, settid, settid_with_pid, setuid"},
  82         {1, &mkdir_rmdir_umask_test, NULL, "mkdir, rmdir, umask"},
  83         {1, &mknod_sync_test, NULL, "mknod, sync"},
  84         {1, &socket2_tests, NULL, "fsync, getsockopt, poll, select, setsockopt, socketpair"},
  85         {1, &socket_tests, NULL, "accept, bind, connect, getpeername, getsockname, listen, socket, recvmsg, sendmsg, sendto, sendfile"},
  86         {1, &chflags_fchflags_test, NULL, "chflags, fchflags"},
  87         {1, &execve_kill_vfork_test, NULL, "kill, vfork, execve, posix_spawn"},
  88         {1, &groups_test, NULL, "getegid, getgid, getgroups, setegid, setgid, setgroups"},
  89         {1, &dup_test, NULL, "dup, dup2, getdtablesize"},
  90         {1, &getrusage_test, NULL, "getrusage"},
  91         {1, &signals_test, NULL, "getitimer, setitimer, sigaction, sigpending, sigprocmask, sigsuspend, sigwait"},
  92         {1, &acct_test, NULL, "acct"},
  93         {1, &ioctl_test, NULL, "ioctl"},
  94         {1, &chroot_test, NULL, "chroot"},
  95         {1, &memory_tests, NULL, "madvise, mincore, minherit, mlock, mlock, mmap, mprotect, msync, munmap"},
  96         {1, &process_group_test, NULL, "getpgrp, getpgid, getsid, setpgid, setpgrp, setsid"},
  97         {1, &fcntl_test, NULL, "fcntl"},
  98         {1, &getlogin_setlogin_test, NULL, "getlogin, setlogin"},
  99         {1, &getpriority_setpriority_test, NULL, "getpriority, setpriority"},
 100         {1, &time_tests, NULL, "futimes, gettimeofday, settimeofday, utimes"},
 101         {1, &rename_test, NULL, "rename, stat"},
 102         {1, &locking_test, NULL, "flock"},
 103         {1, &mkfifo_test, NULL, "mkfifo, read, write"},
 104         {1, &quotactl_test, NULL, "quotactl"},
 105         {1, &limit_tests, NULL, "getrlimit, setrlimit"},
 106         {1, &directory_tests, NULL, "getattrlist, getdirentriesattr, setattrlist"},
 107 #if !TARGET_OS_EMBEDDED
 108         {1, &getdirentries_test, NULL, "getdirentries"},
 109 #endif
 110         {1, &exchangedata_test, NULL, "exchangedata"},
 111         {1, &searchfs_test, NULL, "searchfs"},
 112         {1, &sema2_tests, NULL, "sem_close, sem_open, sem_post, sem_trywait, sem_unlink, sem_wait"},
 113         {1, &sema_tests, NULL, "semctl, semget, semop"},
 114         {1, &bsd_shm_tests, NULL, "shm_open, shm_unlink"},
 115         {1, &shm_tests, NULL, "shmat, shmctl, shmdt, shmget"},
 116         {1, &xattr_tests, NULL, "fgetxattr, flistxattr, fremovexattr, fsetxattr, getxattr, listxattr, removexattr, setxattr"},
 117         {1, &aio_tests, NULL, "aio_cancel, aio_error, aio_read, aio_return, aio_suspend, aio_write, fcntl, lio_listio"},
 118         {1, &kqueue_tests, NULL, "kevent, kqueue"},
 119         {1, &message_queue_tests, NULL, "msgctl, msgget, msgrcv, msgsnd"},
 120         {1, &data_exec_tests, NULL, "data/stack execution"},
 121         {1, &machvm_tests, NULL, "Mach VM calls"},
 122         {0, NULL, NULL, "last one"}
 123 };
 124
 125 static void create_target_directory( const char * the_targetp );
 126 static void list_all_tests( void );
 127 static void mark_tests_to_run( long my_start, long my_end );
 128 static int parse_tests_to_run( int argc, const char * argv[], int * indexp );
 129 static void usage( void );
 130 static int setgroups_if_single_user(void);
 131 static const char *current_arch( void );
 132
 133 /* globals */
 134 long            g_max_failures = 0;
 135 int             g_skip_setuid_tests = 0;
 136 int             g_xilog_active = 0;
 137 const char *    g_cmd_namep;
 138 char            g_target_path[ PATH_MAX ];
 139 int             g_is_under_rosetta = 0;
 140 int             g_is_single_user = 0;
 141
 142 int main( int argc, const char * argv[] )
 143 {
 144         int                             my_tests_count, i;
 145         int                             err;
 146         int                             my_failures = 0;
 147         int                             list_the_tests = 0;
 148         const char *    my_targetp;
 149         time_t                  my_start_time, my_end_time;
 150         struct stat             my_stat_buf;
 151         char                    my_buffer[64];
 152         /* vars for XILog */
 153 #if !TARGET_OS_EMBEDDED
 154         XILogRef                logRef;
 155         char                    *logPath = "";
 156         char                    *config = NULL;
 157         int                             echo = 0;
 158         int                             xml = 0;
 159 #endif
 160         sranddev( );                            /* set up seed for our random name generator */
 161         g_cmd_namep = argv[0];
 162
 163         /* NOTE - code in create_target_directory will append '/' if it is necessary */
 164         my_targetp = getenv("TMPDIR");
 165         if ( my_targetp == NULL )
 166                 my_targetp = "/tmp";
 167
 168         /* make sure our executable is owned by root and has set uid bit */
 169         err = stat( g_cmd_namep, &my_stat_buf );
 170         if ( err != 0 ) {
 171                 err = errno;
 172                 printf( "stat call on our executable failed -  \"%s\" \n", g_cmd_namep );
 173                 printf( " failed with error %d - \"%s\" \n", err, strerror( err) );
 174                 exit( -1 );
 175         }
 176         if ( my_stat_buf.st_uid != 0 || (my_stat_buf.st_mode & S_ISUID) == 0 ) {
 177                 printf( "executable file -  \"%s\" \n", g_cmd_namep );
 178                 printf( "does not have correct owner (must be root) or setuid bit is not set \n" );
 179                 exit( -1 );
 180         }
 181
 182         /* parse input parameters */
 183         for ( i = 1; i < argc; i++ ) {
 184                 if ( strcmp( argv[i], "-u" ) == 0 ) {
 185                         usage( );
 186                 }
 187                 if ( strcmp( argv[i], "-t" ) == 0 ||
 188                          strcmp( argv[i], "-target" ) == 0 ) {
 189                         if ( ++i >= argc ) {
 190                                 printf( "invalid target parameter \n" );
 191                                 usage( );
 192                         }
 193                         /* verify our target directory exists */
 194                         my_targetp = argv[i];
 195                         err = stat( my_targetp, &my_stat_buf );
 196                         if ( err != 0 || S_ISDIR(my_stat_buf.st_mode) == 0 ) {
 197                                 printf( "invalid target path \n" );
 198                                 if ( err != 0 ) {
 199                                         printf( "stat call failed with error %d - \"%s\" \n", errno, strerror( errno) );
 200                                 }
 201                                 usage( );
 202                         }
 203                         continue;
 204                 }
 205                 if ( strcmp( argv[i], "-f" ) == 0 ||
 206                          strcmp( argv[i], "-failures" ) == 0 ) {
 207                         if ( ++i >= argc ) {
 208                                 printf( "invalid failures parameter \n" );
 209                                 usage( );
 210                         }
 211
 212                         /* get our max number of failures */
 213                         g_max_failures = strtol( argv[i], NULL, 10 );
 214                         continue;
 215                 }
 216                 if ( strcmp( argv[i], "-l" ) == 0 ||
 217                          strcmp( argv[i], "-list" ) == 0 ) {
 218                         /* list all the tests this tool will do.
 219                          */
 220                         list_the_tests = 1;
 221                         continue;
 222                 }
 223                 if ( strcmp( argv[i], "-r" ) == 0 ||
 224                          strcmp( argv[i], "-run" ) == 0 ) {
 225                         if ( ++i >= argc ) {
 226                                 printf( "invalid run tests parameter \n" );
 227                                 usage( );
 228                         }
 229
 230                         /* get which tests to run */
 231                         if ( parse_tests_to_run( argc, argv, &i ) != 0 ) {
 232                                 printf( "invalid run tests parameter \n" );
 233                                 usage( );
 234                         }
 235                         continue;
 236                 }
 237                 if ( strcmp( argv[i], "-s" ) == 0 ||
 238                          strcmp( argv[i], "-skip" ) == 0 ) {
 239                         /* set that want to skip the setuid related tests - this is useful for debgugging since since I can't
 240                          * get setuid tests to work while in gdb.
 241                          */
 242                         g_skip_setuid_tests = 1;
 243                         continue;
 244                 }
 245 #if !TARGET_OS_EMBEDDED
 246                 if ( strcmp( argv[i], "-x" ) == 0 ||
 247                          strcmp( argv[i], "-xilog" ) == 0 ) {
 248                         g_xilog_active = 1;
 249                         continue;
 250                 }
 251 #endif
 252                 printf( "invalid argument \"%s\" \n", argv[i] );
 253                 usage( );
 254         }
 255
 256         /* done parsing.
 257          */
 258
 259 #ifdef __ppc__
 260         /* determine if we are running under Rosetta
 261          */
 262         {
 263             int val = 0;
 264             size_t size = sizeof val;
 265             if (sysctlbyname("sysctl.proc_native", &val, &size, NULL, 0) == -1)
 266                 g_is_under_rosetta = 0;
 267             else
 268                 g_is_under_rosetta = val ? 0 : 1;
 269         }
 270 #endif
 271
 272         /* Populate groups list if we're in single user mode */
 273         if (setgroups_if_single_user()) {
 274                 return 1;
 275         }
 276
 277         if ( list_the_tests != 0 ) {
 278                 list_all_tests( );
 279                 return 0;
 280         }
 281 #if !TARGET_OS_EMBEDDED
 282         if (g_xilog_active == 1) {
 283                 logRef = XILogOpenLogExtended( logPath, "xnu_quick_test", "com.apple.coreos",
 284                                                                                 config, xml, echo, NULL, "ResultOwner",
 285                                                                                 "com.apple.coreos", NULL );
 286                 if( logRef == NULL )  {
 287                         fprintf(stderr,"Couldn't create log: %s",logPath);
 288                         exit(-1);
 289                 }
 290         }
 291 #endif
 292
 293         /* build a test target directory that we use as our path to create any test
 294          * files and directories.
 295          */
 296         create_target_directory( my_targetp );
 297         printf( "Will allow %ld failures before testing is aborted \n", g_max_failures );
 298
 299         if (g_is_under_rosetta) {
 300                 printf("Running under Rosetta.\n");
 301         }
 302
 303         my_start_time = time( NULL );
 304         printf( "\nBegin testing - %s \n", ctime_r( &my_start_time, &my_buffer[0] ) );
 305         printf( "Current architecture is %s\n", current_arch() );
 306
 307         /* run each test that is marked to run in our table until we complete all of them or
 308          * hit the maximum number of failures.
 309          */
 310         my_tests_count = (sizeof( g_tests ) / sizeof( g_tests[0] ));
 311         for ( i = 0; i < (my_tests_count - 1); i++ ) {
 312                 int                             my_err;
 313                 test_entryp             my_testp;
 314
 315                 my_testp = &g_tests[i];
 316                 if ( my_testp->test_run_it == 0 || my_testp->test_routine == NULL )
 317                         continue;
 318 #if !TARGET_OS_EMBEDDED
 319                 if (g_xilog_active == 1) {
 320                         XILogBeginTestCase( logRef, my_testp->test_infop, my_testp->test_infop );
 321                         XILogMsg( "test #%d - %s \n", (i + 1), my_testp->test_infop );
 322                 }
 323 #endif
 324                 printf( "test #%d - %s \n", (i + 1), my_testp->test_infop );
 325                 my_err = my_testp->test_routine( my_testp->test_input );
 326                 if ( my_err != 0 ) {
 327                         printf("\t--> FAILED \n");
 328 #if !TARGET_OS_EMBEDDED
 329                         if (g_xilog_active == 1) {
 330                                 XILogMsg("SysCall %s failed", my_testp->test_infop);
 331                                 XILogErr("Result %d", my_err);
 332                         }
 333 #endif
 334                         my_failures++;
 335                         if ( my_failures > g_max_failures ) {
 336 #if !TARGET_OS_EMBEDDED
 337                                 if (g_xilog_active == 1) {
 338                                         XILogEndTestCase( logRef, kXILogTestPassOnErrorLevel );
 339                                 }
 340 #endif
 341                                 printf( "\n too many failures - test aborted \n" );
 342                                 goto exit_this_routine;
 343                         }
 344                 }
 345 #if !TARGET_OS_EMBEDDED
 346                 if (g_xilog_active == 1) {
 347                         XILogEndTestCase(logRef, kXILogTestPassOnErrorLevel);
 348                 }
 349 #endif
 350         }
 351
 352 exit_this_routine:
 353         my_end_time = time( NULL );
 354         printf( "\nEnd testing - %s \n", ctime_r( &my_end_time, &my_buffer[0] ) );
 355
 356         /* clean up our test directory */
 357         rmdir( &g_target_path[0] );
 358
 359 #if !TARGET_OS_EMBEDDED
 360         if (g_xilog_active == 1) {
 361                 XILogCloseLog(logRef);
 362         }
 363 #endif
 364
 365     return 0;
 366 } /* main */
 367
 368
 369 /*
 370  * parse_tests_to_run - parse the -run argument parameters.  the run argument tells us which tests the user
 371  * wants to run.  we accept ranges (example  1 - 44) and runs of tests (example 2, 33, 34, 100) or a mix of
 372  * both (example  1, 44 - 100, 200, 250)
 373  */
 374 static int parse_tests_to_run( int argc, const char * argv[], int * indexp )
 375 {
 376         int                             my_tests_count, is_range = 0, i;
 377         const char *    my_ptr;
 378         char *                  my_temp_ptr;
 379         long                    my_first_test_number, my_last_test_number;
 380         char                    my_buffer[ 128 ];
 381
 382         /* set tests table to not run any tests then go back and set the specific tests the caller asked for */
 383         my_tests_count = (sizeof( g_tests ) / sizeof( g_tests[0] ));
 384         for ( i = 0; i < (my_tests_count - 1); i++ ) {
 385                 g_tests[ i ].test_run_it = 0;
 386         }
 387
 388         for ( i = *indexp; i < argc; i++ ) {
 389                 my_ptr = argv[ i ];
 390                 if ( strlen( my_ptr ) > 1 && *my_ptr == '-' && isalpha( *(my_ptr + 1) ) ) {
 391                         /* we have hit a new argument - need to make sure caller uses this argument on the next
 392                          * pass through its parse loop (which will bump the index value so we want to be one less
 393                          * than the actual index).
 394                          */
 395                         *indexp = (i - 1);
 396                         return 0;
 397                 }
 398
 399                 if ( strlen( my_ptr ) == 1 && *my_ptr == '-' ) {
 400                         /* we are dealing with a range of tests, for example:  33 - 44  */
 401                         is_range = 1;
 402                         continue;
 403                 }
 404
 405                 if ( strlen( my_ptr ) > (sizeof( my_buffer ) - 1) ) {
 406                         printf( "-run argument has too many test parameters (max of %lu characters) \n", sizeof( my_buffer ) );
 407                         return -1;
 408                 }
 409                 /* get a local copy of the parameter string to work with - break range into two strings */
 410                 strcpy( &my_buffer[0], my_ptr );
 411
 412                 my_temp_ptr = strrchr( &my_buffer[0], '-' );
 413                 if ( my_temp_ptr != NULL ) {
 414                         /* we are dealing with a range of tests with no white space, for example:  33-44  or  33- 44  */
 415                         my_temp_ptr = strrchr( &my_buffer[0], '-' );
 416                         *my_temp_ptr = 0x00;
 417                         my_first_test_number = strtol( &my_buffer[0], NULL, 10 );
 418                         if ( *(my_temp_ptr + 1) == 0x00 ) {
 419                                 /* we hit the case where the range indicator is at the end of one string, for example:  33-  */
 420                                 is_range = 1;
 421                                 continue;
 422                         }
 423                         my_last_test_number = strtol( (my_temp_ptr + 1), NULL, 10 );
 424                         if ( my_first_test_number < 1 || my_first_test_number > my_last_test_number ) {
 425                                 printf( "-run argument has invalid range parmeters \n" );
 426                                 return -1;
 427                         }
 428                         mark_tests_to_run( my_first_test_number, my_last_test_number );
 429                         is_range = 0;
 430                         continue;
 431                 }
 432
 433                 if ( is_range ) {
 434                         /* should be the second part of the test number range */
 435                         my_last_test_number = strtol( &my_buffer[0], NULL, 10 );
 436                         if ( my_first_test_number < 1 || my_first_test_number > my_last_test_number ) {
 437                                 printf( "-run argument has invalid range parmeters \n" );
 438                                 return -1;
 439                         }
 440
 441                         mark_tests_to_run( my_first_test_number, my_last_test_number );
 442                         is_range = 0;
 443                         continue;
 444                 }
 445                 else {
 446                         my_first_test_number = strtol( &my_buffer[0], NULL, 10 );
 447                         if ( my_first_test_number < 1 ) {
 448                                 printf( "-run argument has invalid test number parameter \n" );
 449                                 return -1;
 450                         }
 451                         mark_tests_to_run( my_first_test_number, my_first_test_number );
 452                         continue;
 453                 }
 454         }
 455
 456         *indexp = i;
 457         return 0;
 458
 459 } /* parse_tests_to_run */
 460
 461
 462 static void create_target_directory( const char * the_targetp )
 463 {
 464         int                     err;
 465
 466         if ( strlen( the_targetp ) > (sizeof(g_target_path) - 1) ) {
 467                 printf( "target path too long - \"%s\" \n", the_targetp );
 468                 exit( 1 );
 469         }
 470
 471         for ( ;; ) {
 472         int                     my_rand;
 473         char            my_name[64];
 474
 475         my_rand = rand( );
 476         sprintf( &my_name[0], "xnu_quick_test-%d", my_rand );
 477         if ( (strlen( &my_name[0] ) + strlen( the_targetp ) + 2) > PATH_MAX ) {
 478                         printf( "target path plus our test directory name is too long: \n" );
 479                         printf( "target path - \"%s\"  \n", the_targetp );
 480                         printf( "test directory name - \"%s\"  \n", &my_name[0] );
 481                         exit( 1 );
 482                 }
 483
 484         /* append generated directory name onto our path */
 485                 g_target_path[0] = 0x00;
 486         strcat( &g_target_path[0], the_targetp );
 487                 if ( g_target_path[ (strlen(the_targetp) - 1) ] != '/' ) {
 488                         strcat( &g_target_path[0], "/" );
 489                 }
 490         strcat( &g_target_path[0], &my_name[0] );
 491
 492                 /* try to create the test directory */
 493                 err = mkdir( &g_target_path[0], (S_IRWXU | S_IRWXG | S_IROTH) );
 494                 if ( err == 0 ) {
 495                         break;
 496                 }
 497                 err = errno;
 498                 if ( EEXIST != err ) {
 499                         printf( "test directory creation failed - \"%s\" \n", &g_target_path[0] );
 500                         printf( "mkdir call failed with error %d - \"%s\" \n", errno, strerror( err) );
 501                         exit( 1 );
 502                 }
 503         }
 504         printf( "created test directory at \"%s\" \n", &g_target_path[0] );
 505
 506 } /* create_target_directory */
 507
 508
 509 static void mark_tests_to_run( long my_start, long my_end )
 510 {
 511         int                     my_tests_count, i;
 512
 513         my_tests_count = (sizeof( g_tests ) / sizeof( g_tests[0] ));
 514         my_end = (my_end < (my_tests_count - 1)) ? my_end : (my_tests_count - 1);
 515         for ( i = (my_start - 1); i < my_end; i++ ) {
 516                 g_tests[ i ].test_run_it = 1;  /* run this test */
 517         }
 518         return;
 519 } /* mark_tests_to_run */
 520
 521
 522 static void usage( void )
 523 {
 524         char *          my_ptr;
 525
 526         /* skip past full path and just show the tool name */
 527         my_ptr = strrchr( g_cmd_namep, '/' );
 528         if ( my_ptr != NULL ) {
 529                 my_ptr++;
 530         }
 531
 532         printf( "\nUSAGE:  %s -target TARGET_PATH \n\n", (my_ptr != NULL) ? my_ptr : g_cmd_namep );
 533         printf( "\t -f[ailures] MAX_FAILS_ALLOWED   # number of test cases that may fail before we give up.  defaults to 0  \n" );
 534         printf( "\t -l[ist]                         # list all the tests this tool performs   \n" );
 535         printf( "\t -r[un] 1, 3, 10 - 19            # run specific tests.  enter individual test numbers and/or range of numbers.  use -list to list tests.   \n" );
 536         printf( "\t -s[kip]                         # skip setuid tests   \n" );
 537         printf( "\t -t[arget] TARGET_PATH           # path to directory where tool will create test files.  defaults to \"/tmp/\"   \n" );
 538 #if !TARGET_OS_EMBEDDED
 539         printf( "\t -x[ilog]                        # use XILog\n");
 540 #endif
 541         printf( "\nexamples:  \n" );
 542         printf( "--- Place all test files and directories at the root of volume \"test_vol\" --- \n" );
 543         printf( "%s -t /Volumes/test_vol/ \n", (my_ptr != NULL) ? my_ptr : g_cmd_namep );
 544         printf( " \n" );
 545         printf( "--- Run the tool for tests 10 thru 15, test 18 and test 20 --- \n" );
 546         printf( "%s -r 10-15, 18, 20 \n", (my_ptr != NULL) ? my_ptr : g_cmd_namep );
 547         printf( " \n" );
 548         exit( 1 );
 549
 550 } /* usage */
 551
 552 /* This is a private API between Libinfo, Libc, and the DirectoryService daemon.
 553  * Since we are trying to determine if an external provider will back group
 554  * lookups, we can use this, without relying on additional APIs or tools
 555  * that might not work yet */
 556 extern int _ds_running(void);
 557
 558 #define NUM_GROUPS      6
 559 static int
 560 setgroups_if_single_user(void)
 561 {
 562         int i, retval = -1;
 563         struct group *grp;
 564         gid_t gids[NUM_GROUPS];
 565
 566         if (!_ds_running()) {
 567                 printf("In single-user mode.\n");
 568                 g_is_single_user = 1;
 569
 570                 /* We skip 'nobody' and 'anyone' */
 571                 getgrent();
 572                 getgrent();
 573                 for (i = 0; i < NUM_GROUPS; i++) {
 574                         grp = getgrent();
 575                         if (!grp) {
 576                                 break;
 577                         }
 578
 579                         gids[i] = grp->gr_gid;
 580                 }
 581
 582                 endgrent();
 583
 584                 /* Only succeed if we find at least NUM_GROUPS */
 585                 if (i == NUM_GROUPS) {
 586                         retval = setgroups(NUM_GROUPS, gids);
 587                         if (retval == 0) {
 588                                 getgroups(NUM_GROUPS, gids);
 589                                 printf("After single-user hack, groups are: ");
 590                                 for (i = 0; i < NUM_GROUPS; i++) {
 591                                         printf("%d, ", gids[i]);
 592                                 }
 593                                 putchar('\n');
 594                         } else {
 595                                 printf("Setgroups failed.\n");
 596                         }
 597                 } else {
 598                         printf("Couldn't get sufficient number of groups.\n");
 599                 }
 600         } else {
 601                 printf("Not in single user mode.\n");
 602                 retval = 0;
 603         }
 604
 605
 606         return retval;
 607 }
 608
 609 static const char *current_arch( void )
 610 {
 611         cpu_type_t cputype = _mh_execute_header.cputype;
 612         cpu_subtype_t cpusubtype = _mh_execute_header.cpusubtype;
 613
 614         const NXArchInfo *arch = NXGetArchInfoFromCpuType(cputype, cpusubtype);
 615
 616         if (arch) {
 617                 return arch->name;
 618         } else {
 619                 return "<unknown>";
 620         }
 621 }
 622
 623 #undef printf   /* this makes the "-l" output easier to read */
 624 static void list_all_tests( void )
 625 {
 626         int             i, my_tests_count;
 627
 628         my_tests_count = (sizeof( g_tests ) / sizeof( g_tests[0] ));
 629         printf( "\nList of all tests this tool performs... \n" );
 630
 631         for ( i = 0; i < (my_tests_count - 1); i++ ) {
 632                 printf( " %d \t   %s \n", (i + 1), g_tests[ i ].test_infop );
 633         }
 634
 635         return;
 636 } /* list_all_tests */