bool
FileLock::obtain( LOCK_TYPE t )
{
int counter = 0;
#if !defined(WIN32)
start:
#endif
// lock_file uses lseeks in order to lock the first 4 bytes of the file on NT
// It DOES properly reset the lseek version of the file position, but that is
// not the same (in some very inconsistent and weird ways) as the fseek one,
// so if the user has given us a FILE *, we need to make sure we don't ruin
// their current position. The lesson here is don't use fseeks and lseeks
// interchangeably...
int status = -1;
int saved_errno = -1;
if ( m_use_kernel_mutex == -1 ) {
m_use_kernel_mutex = param_boolean_int("FILE_LOCK_VIA_MUTEX", TRUE);
}
// If we have the path, we can try to lock via a mutex.
if ( m_path && m_use_kernel_mutex ) {
status = lockViaMutex(t);
}
// We cannot lock via a mutex, or we tried and failed.
// Try via filesystem lock.
if ( status < 0) {
long lPosBeforeLock = 0;
if (m_fp) // if the user has a FILE * as well as an fd
{
// save their FILE*-based current position
lPosBeforeLock = ftell(m_fp);
}
// We're seeing sporadic test suite failures where a daemon
// takes more than 10 seconds to write to the user log.
// This will help narrow down where the delay is coming from.
time_t before = time(NULL);
status = lock_file( m_fd, t, m_blocking );
saved_errno = errno;
time_t after = time(NULL);
if ( (after - before) > 5 ) {
dprintf( D_FULLDEBUG,
"FileLock::obtain(%d): lock_file() took %ld seconds\n",
t, (after-before) );
}
if (m_fp)
{
// restore their FILE*-position
fseek(m_fp, lPosBeforeLock, SEEK_SET);
}
#ifndef WIN32
// if we deal with our own fd and are not unlocking
if (m_delete == 1 && t != UN_LOCK){
struct stat si;
fstat(m_fd, &si);
// no more hard links ... it was deleted while we were waiting
// in that case we need to reopen and restart
if ( si.st_nlink < 1 ){
release();
close(m_fd);
bool initResult;
if (m_orig_path != NULL && strcmp(m_path, m_orig_path) != 0)
initResult = initLockFile(false);
else
initResult = initLockFile(true);
if (!initResult) {
dprintf(D_FULLDEBUG, "Lock file (%s) cannot be reopened \n", m_path);
if (m_orig_path) {
dprintf(D_FULLDEBUG, "Opening and locking the actual log file (%s) since lock file cannot be accessed! \n", m_orig_path);
m_fd = safe_open_wrapper_follow(m_orig_path, O_CREAT | O_RDWR , 0644);
}
}
if (m_fd < 0) {
dprintf(D_FULLDEBUG, "Opening the log file %s to lock failed. \n", m_path);
}
++counter;
// let's retry at most 5 times
if (counter < 6) {
goto start;
}
else
status = -1;
}
}
#endif
}
if( status == 0 ) {
m_state = t;
}
if ( status != 0 ) {
dprintf( D_ALWAYS, "FileLock::obtain(%d) failed - errno %d (%s)\n",
t, saved_errno, strerror(saved_errno) );
}
else {
UtcTime now( true );
dprintf( D_FULLDEBUG,
"FileLock::obtain(%d) - @%.6f lock on %s now %s\n",
t, now.combined(), m_path, getStateString(t) );
}
return status == 0;
}
/* 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);
}
