/* Do not free the returned pointer */
const char *
sysapi_ckptpltfrm_raw(void)
{
const char *opsys;
const char *arch;
const char *kernel_version;
const char *memory_model;
#ifndef WIN32
const char *vsyscall_page;
#endif
int size;
/* compute the checkpointing signature of this machine, each thing
you want to detect should be defined in some form for every platform. */
opsys = sysapi_opsys();
arch = sysapi_condor_arch();
kernel_version = sysapi_kernel_version();
memory_model = sysapi_kernel_memory_model();
#ifndef WIN32
vsyscall_page = sysapi_vsyscall_gate_addr();
#endif
/* Currently, windows doesn't support condor_ckpt_probe, so don't put in
the vsyscall page information. */
#ifndef WIN32
size = strlen(opsys) + 1 /*space*/ +
strlen(arch) + 1 /*space*/ +
strlen(kernel_version) + 1 /*space*/ +
strlen(memory_model) + 1 /*space*/ +
strlen(vsyscall_page) + 1 /*nul*/;
#else
size = strlen(opsys) + 1 /*space*/ +
strlen(arch) + 1 /*space*/ +
strlen(kernel_version) + 1 /*space*/ +
strlen(memory_model) + 1; /*space*/
#endif
/* this will always be NULL when this function is entered */
_sysapi_ckptpltfrm = (char*)malloc(sizeof(char) * size);
if (_sysapi_ckptpltfrm == NULL) {
EXCEPT("Out of memory!");
}
strcpy(_sysapi_ckptpltfrm, opsys);
strcat(_sysapi_ckptpltfrm, " ");
strcat(_sysapi_ckptpltfrm, arch);
strcat(_sysapi_ckptpltfrm, " ");
strcat(_sysapi_ckptpltfrm, kernel_version);
strcat(_sysapi_ckptpltfrm, " ");
strcat(_sysapi_ckptpltfrm, memory_model);
#ifndef WIN32
strcat(_sysapi_ckptpltfrm, " ");
strcat(_sysapi_ckptpltfrm, vsyscall_page);
#endif
return _sysapi_ckptpltfrm;
}
/* the main entry function, this will do all the magic */
extern "C" int
sysapi_test_dump_all(int argc, char** argv)
{
int foo;
int return_val = 0;
int tests = TEST_NONE;
int failed_tests = 0;
int passed_tests = 0;
int i;
int print_help = 0;
#if defined(LINUX)
const char *linux_cpuinfo_file = NULL;
int linux_cpuinfo_debug = 0;
const char *linux_uname = NULL;
int linux_num = -1;
int linux_processors = -1;
int linux_hthreads = -1;
int linux_hthreads_core = -1;
int linux_cpus = -1;
#endif
int ncpus_trials = NCPUS_TRIALS;
int skip = 0;
const char *free_fs_dir = "/tmp";
if (argc <= 1)
tests = TEST_ALL;
for (i=1; i<argc; i++) {
if ( skip ) {
skip--;
continue;
}
if (strcmp(argv[i], "--arch") == 0)
tests |= ARCH;
else if (strcmp(argv[i], "--kern_memmod") == 0)
tests |= KERN_MEMMOD;
else if (strcmp(argv[i], "--kern_vers") == 0)
tests |= KERN_VERS;
else if (strcmp(argv[i], "--ckptpltfrm") == 0)
tests |= CKPTPLTFRM;
else if (strcmp(argv[i], "--dump") == 0)
tests |= DUMP;
else if (strcmp(argv[i], "--free_fs_blocks") == 0) {
tests |= FREE_FS_BLOCKS;
if ( ( i+1 < argc ) &&
( (*argv[i+1] == '/') || (*argv[i+1] == '.') ) ) {
skip = 1;
free_fs_dir = argv[i+1];
}
}
else if (strcmp(argv[i], "--idle_time") == 0)
tests |= IDLE_TIME;
else if (strcmp(argv[i], "--kflops") == 0)
tests |= KFLOPS;
else if (strcmp(argv[i], "--last_x_event") == 0)
tests |= LAST_X_EVENT;
else if (strcmp(argv[i], "--load_avg") == 0)
tests |= LOAD_AVG;
else if (strcmp(argv[i], "--mips") == 0)
tests |= MIPS;
else if (strcmp(argv[i], "--ncpus") == 0) {
tests |= NCPUS;
}
else if (strcmp(argv[i], "--phys_mem") == 0)
tests |= PHYS_MEM;
else if (strcmp(argv[i], "--virt_mem") == 0)
tests |= VIRT_MEM;
else if ( (strcmp(argv[i], "--debug") == 0) && (i+1 < argc) ) {
set_debug_flags( argv[i+1], 0 );
skip = 1;
}
# if defined(LINUX)
else if (strcmp(argv[i], "--proc_cpuinfo") == 0) {
tests |= NCPUS;
linux_cpuinfo_file = "/proc/cpuinfo";
linux_cpuinfo_debug = 1; // Turn on debugging
linux_num = 0;
}
else if ( (strcmp(argv[i], "--cpuinfo_file") == 0) && (i+2 < argc) ) {
tests |= NCPUS;
linux_cpuinfo_file = argv[i+1];
linux_cpuinfo_debug = 1; // Turn on debugging
if ( isdigit( *argv[i+2] ) ) {
linux_num = atoi( argv[i+2] );
} else {
linux_uname = argv[i+2];
}
skip = 2;
}
# endif
else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
print_help = 1;
else {
printf("%s is not an understood option. ", argv[i]);
print_help = 1;
}
if (print_help != 0) {
printf("Please use zero or more or:\n");
printf("--debug <D_xxx>\n");
printf("--arch\n");
printf("--kern_vers\n");
printf("--kern_memmod\n");
printf("--ckptpltfrm\n");
printf("--dump\n");
printf("--free_fs_blocks [dir]\n");
printf("--idle_time\n");
printf("--kflops\n");
printf("--last_x_event\n");
printf("--load_avg\n");
printf("--mips\n");
printf("--ncpus\n");
printf("--phys_mem\n");
printf("--virt_mem\n");
# if defined(LINUX)
printf("--proc_cpuinfo\n");
printf("--cpuinfo_file <file> <uname match string>|<cpuinfo #>\n");
# endif
return 0;
}
}
if ((tests & KERN_MEMMOD) == KERN_MEMMOD) {
dprintf(D_ALWAYS, "SysAPI: BEGIN SysAPI DUMP!\n");
dprintf(D_ALWAYS, "SysAPI: Kernel memory model: %s\n",
sysapi_kernel_memory_model());
dprintf(D_ALWAYS, "SysAPI: END SysAPI DUMP!\n\n");
}
if ((tests & KERN_VERS) == KERN_VERS) {
dprintf(D_ALWAYS, "SysAPI: BEGIN SysAPI DUMP!\n");
dprintf(D_ALWAYS, "SysAPI: Kernel version: %s\n",
sysapi_kernel_version());
dprintf(D_ALWAYS, "SysAPI: END SysAPI DUMP!\n\n");
}
if ((tests & CKPTPLTFRM) == CKPTPLTFRM) {
dprintf(D_ALWAYS, "SysAPI: BEGIN SysAPI DUMP!\n");
sysapi_ckptpltfrm();
sysapi_test_dump_internal_vars();
sysapi_reconfig();
sysapi_test_dump_internal_vars();
dprintf(D_ALWAYS, "SysAPI: Checkpoint platform: %s\n",
sysapi_ckptpltfrm());
dprintf(D_ALWAYS, "SysAPI: END SysAPI DUMP!\n\n");
}
if ((tests & DUMP) == DUMP) {
dprintf(D_ALWAYS, "SysAPI: BEGIN SysAPI DUMP!\n");
sysapi_test_dump_internal_vars();
sysapi_reconfig();
sysapi_test_dump_internal_vars();
//sysapi_test_dump_functions();
dprintf(D_ALWAYS, "SysAPI: END SysAPI DUMP!\n\n");
}
if ((tests & ARCH) == ARCH) {
dprintf(D_ALWAYS, "SysAPI: BEGIN ARCH_TEST:\n");
foo = 0;
foo = arch_test(500);
dprintf(D_ALWAYS, "SysAPI: END ARCH_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed ARCH_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed ARCH_TEST.\n\n");
failed_tests++;
}
}
if ((tests & FREE_FS_BLOCKS) == FREE_FS_BLOCKS) {
dprintf(D_ALWAYS, "SysAPI: BEGIN FREE_FS_BLOCKS_TEST:\n");
foo = 0;
foo = free_fs_blocks_test(free_fs_dir,
FREEBLOCKS_TRIALS,
FREEBLOCKS_TOLERANCE,
FREEBLOCKS_MAX_WARN_OK );
dprintf(D_ALWAYS, "SysAPI: END FREE_FS_BLOCKS_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed FREE_FS_BLOCKS_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed FREE_FS_BLOCKS_TEST.\n\n");
failed_tests++;
}
}
if ((tests & IDLE_TIME) == IDLE_TIME) {
dprintf(D_ALWAYS, "SysAPI: BEGIN IDLE_TIME_TEST:\n");
foo = 0;
foo = idle_time_test(IDLETIME_TRIALS,
IDLETIME_INTERVAL,
IDLETIME_TOLERANCE,
IDLETIME_MAX_WARN_OK );
dprintf(D_ALWAYS, "SysAPI: END IDLE_TIME_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed IDLE_TIME_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed IDLE_TIME_TEST.\n\n");
failed_tests++;
}
}
if ((tests & KFLOPS) == KFLOPS) {
dprintf(D_ALWAYS, "SysAPI: BEGIN KFLOPS_TEST:\n");
foo = 0;
foo = kflops_test(KFLOPS_TRIALS,
KFLOPS_MAX_SD_VAR,
KFLOPS_MAX_WARN_OK
);
dprintf(D_ALWAYS, "SysAPI: END KFLOPS_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed KFLOPS_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed KFLOPS_TEST.\n\n");
failed_tests++;
}
}
if ((tests & LAST_X_EVENT) == LAST_X_EVENT) {
dprintf(D_ALWAYS, "SysAPI: SKIPPING LASE_X_EVENT_TEST: internally used variable only.\n\n");
}
if ((tests & LOAD_AVG) == LOAD_AVG) {
dprintf(D_ALWAYS, "SysAPI: BEGIN LOAD_AVG_TEST:\n");
foo = 0;
foo = load_avg_test(LOADAVG_TRIALS,
LOADAVG_INTERVAL,
LOADAVG_CHILDREN,
LOADAVG_MAX_WARN_OK);
dprintf(D_ALWAYS, "SysAPI: END LOAD_AVG_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed LOAD_AVG_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed LOAD_AVG_TEST.\n\n");
failed_tests++;
}
}
if ((tests & MIPS) == MIPS) {
dprintf(D_ALWAYS, "SysAPI: BEGIN MIPS_TEST:\n");
foo = 0;
foo = mips_test(MIPS_TRIALS,
MIPS_MAX_SD_VAR,
MIPS_MAX_WARN_OK );
dprintf(D_ALWAYS, "SysAPI: END MIPS_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed MIPS_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed MIPS_TEST.\n\n");
failed_tests++;
}
}
/* Special test: /proc/cpuinfo on a file */
#if defined(LINUX)
if ((tests & NCPUS) == NCPUS && linux_cpuinfo_file ) {
bool is_proc_cpuinfo = false;
/* set_debug_flags(NULL, D_FULLDEBUG); */
if ( strcmp( linux_cpuinfo_file, "/proc/cpuinfo" ) == 0 ) {
is_proc_cpuinfo = true;
dprintf( D_ALWAYS, "Using the real /proc/cpuinfo\n" );
}
FILE *fp = safe_fopen_wrapper_follow( linux_cpuinfo_file, "r", 0644 );
if ( !fp ) {
dprintf(D_ALWAYS, "SysAPI: Can't open cpuinfo file '%s'.\n\n",
linux_cpuinfo_file);
return(++failed_tests);
}
else {
/* Skip 'til we find the "right" uname */
char buf[256];
char uname[256];
int found = 0;
int linenum = 1;
int cpuinfo_num = 0; /* # of this cpuinfo block */
if ( is_proc_cpuinfo ) {
found = true;
strcpy( uname, "" );
}
else {
while( fgets( buf, sizeof(buf), fp) ) {
linenum++;
buf[sizeof(buf)-1] = '\0';
if ( !strncmp( buf, "UNAME:", 6 ) && ( strlen(buf) > 6 ) ){
cpuinfo_num++;
if ( ( ( linux_num >= 0 ) &&
( linux_num == cpuinfo_num ) ) ||
( linux_uname &&
strstr( buf, linux_uname ) ) ) {
strncpy( uname, buf+6, sizeof(uname) );
found = linenum;
}
}
else if ( found ) {
if ( !strncmp( buf, "START", 5 ) && found ) {
break;
}
sscanf( buf, "PROCESSORS: %d", &linux_processors );
sscanf( buf, "HTHREADS: %d", &linux_hthreads );
sscanf( buf, "HTHREADS_CORE: %d",
&linux_hthreads_core );
}
}
}
// Store the current file position & file name
_SysapiProcCpuinfo.file = linux_cpuinfo_file;
_SysapiProcCpuinfo.debug = linux_cpuinfo_debug;
_SysapiProcCpuinfo.offset = ftell( fp );
fclose( fp );
fp = NULL;
// Calculate total "non-primary" hyper threads
if ( ! is_proc_cpuinfo ) {
if ( ( linux_hthreads < 0 ) &&
( linux_hthreads_core > 0 ) &&
( linux_processors > 0 ) ) {
linux_hthreads = ( linux_processors -
( linux_processors /
linux_hthreads_core ) );
}
}
// Calculate the total # of CPUs
if ( linux_processors ) {
if ( param_boolean_int("COUNT_HYPERTHREAD_CPUS", 1) ) {
linux_cpus = linux_processors;
}
else {
linux_cpus = linux_processors - linux_hthreads;
}
}
if ( !found ) {
if ( linux_num >= 0 ) {
dprintf(D_ALWAYS,
"SysAPI: Can't find uname # %d in %s.\n\n",
linux_num, linux_cpuinfo_file );
}
else {
dprintf(D_ALWAYS,
"SysAPI: Can't find uname '%s' in %s.\n\n",
linux_uname, linux_cpuinfo_file );
}
return(++failed_tests);
}
if ( strlen( uname ) ) {
dprintf(D_ALWAYS,
"SysAPI: Using uname string on line %d:\n%s\n",
found, uname );
}
ncpus_trials = 1;
}
}
#endif
if ((tests & NCPUS) == NCPUS) {
dprintf(D_ALWAYS, "SysAPI: BEGIN NUMBER_CPUS_TEST:\n");
foo = 0;
foo = ncpus_test(ncpus_trials,
NCPUS_MAX_WARN_OK);
dprintf(D_ALWAYS, "SysAPI: END NUMBER_CPUS_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed NUMBER_CPUS_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed NUMBER_CPUS_TEST.\n\n");
failed_tests++;
}
# if defined(LINUX)
if ( ( linux_processors >= 0 ) &&
( _SysapiProcCpuinfo.found_processors != linux_processors ) ) {
dprintf(D_ALWAYS,
"SysAPI/Linux: # Processors (%d) != expected (%d)\n",
_SysapiProcCpuinfo.found_processors,
linux_processors );
}
if ( ( linux_hthreads >= 0 ) &&
( _SysapiProcCpuinfo.found_hthreads != linux_hthreads ) ) {
dprintf(D_ALWAYS,
"SysAPI/Linux: # HyperThreads (%d) != expected (%d)\n",
_SysapiProcCpuinfo.found_hthreads,
linux_hthreads );
}
if ( ( linux_cpus > 0 ) &&
( _SysapiProcCpuinfo.found_ncpus != linux_cpus ) ) {
dprintf(D_ALWAYS,
"SysAPI/Linux: # CPUs (%d) != expected (%d)\n",
_SysapiProcCpuinfo.found_ncpus,
linux_cpus );
}
int level = D_FULLDEBUG;
if (linux_cpuinfo_debug) {
level = D_ALWAYS;
}
dprintf( level,
"SysAPI: Detected %d Processors, %d HyperThreads"
" => %d CPUS\n",
_SysapiProcCpuinfo.found_processors,
_SysapiProcCpuinfo.found_hthreads,
_SysapiProcCpuinfo.found_ncpus );
# endif
}
if ((tests & PHYS_MEM) == PHYS_MEM) {
dprintf(D_ALWAYS, "SysAPI: BEGIN PHYSICAL_MEMORY_TEST:\n");
foo = 0;
foo = phys_memory_test(PHYSMEM_TRIALS, PHYSMEM_MAX_WARN_OK);
dprintf(D_ALWAYS, "SysAPI: END PHYSICAL_MEMORY_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed PHYSICAL_MEMORY_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed PHYSICAL_MEMORY_TEST.\n\n");
failed_tests++;
}
}
if ((tests & VIRT_MEM) == VIRT_MEM) {
dprintf(D_ALWAYS, "SysAPI: BEGIN VIRTUAL_MEMORY_TEST:\n");
foo = 0;
foo = virt_memory_test(VIRTMEM_TESTBLOCK_SIZE,
VIRTMEM_MAX_SD_VAR,
VIRTMEM_MAX_FAIL_OK);
dprintf(D_ALWAYS, "SysAPI: END VIRTUAL_MEMORY_TEST:\n");
return_val |= foo;
if (foo == 0) {
dprintf(D_ALWAYS, "SysAPI: Passed VIRTUAL_MEMORY_TEST.\n\n");
passed_tests++;
} else {
dprintf(D_ALWAYS, "SysAPI: Failed VIRTUAL_MEMORY_TEST.\n\n");
failed_tests++;
}
}
printf("Passed tests = %d\n",passed_tests);
return(failed_tests);
}
