/* 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); }
MachAttributes::MachAttributes() : m_user_specified(NULL, ";"), m_user_settings_init(false), m_named_chroot() { m_mips = -1; m_kflops = -1; m_last_benchmark = 0; m_last_keypress = time(0)-1; m_seen_keypress = false; m_arch = NULL; m_opsys = NULL; m_opsysver = 0; m_opsys_and_ver = NULL; m_opsys_major_ver = 0; m_opsys_name = NULL; m_opsys_long_name = NULL; m_opsys_short_name = NULL; m_opsys_legacy = NULL; m_uid_domain = NULL; m_filesystem_domain = NULL; m_idle_interval = -1; m_ckptpltfrm = NULL; m_clock_day = -1; m_clock_min = -1; m_condor_load = -1.0; m_console_idle = 0; m_idle = 0; m_load = -1.0; m_owner_load = -1.0; m_virt_mem = 0; // Number of CPUs. Since this is used heavily by the ResMgr // instantiation and initialization, we need to have a real // value for this as soon as the MachAttributes object exists. m_num_cpus = sysapi_ncpus(); m_num_real_cpus = sysapi_ncpus_raw(); // The same is true of physical memory. If we had an error in // sysapi_phys_memory(), we need to just EXCEPT with a message // telling the user to define MEMORY manually. m_phys_mem = sysapi_phys_memory(); if( m_phys_mem <= 0 ) { dprintf( D_ALWAYS, "Error computing physical memory with calc_phys_mem().\n" ); dprintf( D_ALWAYS | D_NOHEADER, "\t\tMEMORY parameter not defined in config file.\n" ); dprintf( D_ALWAYS | D_NOHEADER, "\t\tTry setting MEMORY to the number of megabytes of RAM.\n" ); EXCEPT( "Can't compute physical memory." ); } dprintf( D_FULLDEBUG, "Memory: Detected %d megs RAM\n", m_phys_mem ); // identification of the checkpointing platform signature const char * ckptpltfrm = param( ATTR_CHECKPOINT_PLATFORM ); if( ckptpltfrm == NULL ) { ckptpltfrm = sysapi_ckptpltfrm(); } m_ckptpltfrm = strdup( ckptpltfrm ); // temporary attributes for raw utsname info m_utsname_sysname = NULL; m_utsname_nodename = NULL; m_utsname_release = NULL; m_utsname_version = NULL; m_utsname_machine = NULL; #if defined ( WIN32 ) // Get the version information of the copy of Windows // we are running ZeroMemory ( &m_window_version_info, sizeof ( OSVERSIONINFOEX ) ); m_window_version_info.dwOSVersionInfoSize = sizeof ( OSVERSIONINFOEX ); m_got_windows_version_info = GetVersionEx ( (OSVERSIONINFO*) &m_window_version_info ); if ( !m_got_windows_version_info ) { m_window_version_info.dwOSVersionInfoSize = sizeof ( OSVERSIONINFO ); m_got_windows_version_info = GetVersionEx ( (OSVERSIONINFO*) &m_window_version_info ); if ( !m_got_windows_version_info ) { dprintf ( D_ALWAYS, "MachAttributes: failed to " "get Windows version information.\n" ); } } m_local_credd = NULL; m_last_credd_test = 0; m_dot_Net_Versions = NULL; #endif }
/* this function calls every function in sysapi that makes sense to call and prints out its value */ extern "C" void sysapi_test_dump_functions(void) { int foo = 0; long long loo = 0; float bar = 0; const char *qux = NULL; time_t t0, t1; dprintf(D_ALWAYS, "SysAPI: Calling SysAPI functions....\n"); qux = sysapi_ckptpltfrm_raw(); dprintf(D_ALWAYS, "SysAPI: sysapi_ckptpltfrm_raw -> %s\n", qux); qux = sysapi_ckptpltfrm(); dprintf(D_ALWAYS, "SysAPI: sysapi_ckptpltfrm -> %s\n", qux); foo = sysapi_phys_memory_raw(); dprintf(D_ALWAYS, "SysAPI: sysapi_phys_memory_raw() -> %d\n", foo); foo = sysapi_phys_memory(); dprintf(D_ALWAYS, "SysAPI: sysapi_phys_memory() -> %d\n", foo); loo = sysapi_disk_space_raw("/"); dprintf(D_ALWAYS, "SysAPI: sysapi_disk_space_raw() -> %" PRIi64 "\n", loo); loo = sysapi_disk_space("/"); dprintf(D_ALWAYS, "SysAPI: sysapi_disk_space() -> %" PRIi64 "\n", loo); sysapi_ncpus_raw(&foo,NULL); dprintf(D_ALWAYS, "SysAPI: sysapi_ncpus_raw() -> %d\n", foo); sysapi_ncpus_raw(&foo, NULL); dprintf(D_ALWAYS, "SysAPI: sysapi_ncpus() -> %d\n", foo); foo = sysapi_mips_raw(); dprintf(D_ALWAYS, "SysAPI: sysapi_mips_raw() -> %d\n", foo); foo = sysapi_mips(); dprintf(D_ALWAYS, "SysAPI: sysapi_mips() -> %d\n", foo); foo = sysapi_kflops_raw(); dprintf(D_ALWAYS, "SysAPI: sysapi_kflops_raw() -> %d\n", foo); foo = sysapi_kflops(); dprintf(D_ALWAYS, "SysAPI: sysapi_kflops() -> %d\n", foo); sysapi_idle_time_raw(&t0, &t1); dprintf(D_ALWAYS,"SysAPI: sysapi_idle_time_raw() -> (%f,%f)\n",(float)t0,(float)t1); sysapi_idle_time(&t0, &t1); dprintf(D_ALWAYS, "SysAPI: sysapi_idle_time() -> (%f,%f)\n", (float)t0, (float)t1); bar = sysapi_load_avg_raw(); dprintf(D_ALWAYS, "SysAPI: sysapi_load_avg_raw() -> %f\n", bar); bar = sysapi_load_avg(); dprintf(D_ALWAYS, "SysAPI: sysapi_load_avg() -> %f\n", bar); qux = sysapi_condor_arch(); dprintf(D_ALWAYS, "SysAPI: sysapi_condor_arch -> %s\n", qux); qux = sysapi_uname_arch(); dprintf(D_ALWAYS, "SysAPI: sysapi_uname_arch -> %s\n", qux); qux = sysapi_opsys(); dprintf(D_ALWAYS, "SysAPI: sysapi_opsys -> %s\n", qux); foo = sysapi_swap_space_raw(); dprintf(D_ALWAYS, "SysAPI: sysapi_swap_space_raw() -> %d\n", foo); foo = sysapi_swap_space(); dprintf(D_ALWAYS, "SysAPI: sysapi_swap_space() -> %d\n", foo); }
void MachAttributes::compute( amask_t how_much ) { // the startd doesn't normally call the init() method (bug?), // it just starts calling compute, so in order to gurantee that // init happens, we put check here to see if user settings have been initialized if ( ! m_user_settings_init) init_user_settings(); if( IS_STATIC(how_much) && IS_SHARED(how_much) ) { // Since we need real values for them as soon as a // MachAttributes object is instantiated, we handle number // of CPUs and physical memory in the constructor, not // here. -Derek Wright 2/5/99 // Arch, OpSys, FileSystemDomain and UidDomain. Note: // these will always return something, since config() will // insert values if we don't have them in the config file. if( m_arch ) { free( m_arch ); } m_arch = param( "ARCH" ); if( m_opsys ) { free( m_opsys ); } m_opsys = param( "OPSYS" ); m_opsysver = param_integer( "OPSYSVER", 0 ); if( m_opsys_and_ver ) { free( m_opsys_and_ver ); } m_opsys_and_ver = param( "OPSYSANDVER" ); m_opsys_major_ver = param_integer( "OPSYSMAJORVER", 0 ); if( m_opsys_name ) { free( m_opsys_name ); } m_opsys_name = param( "OPSYSNAME" ); if( m_opsys_long_name ) { free( m_opsys_long_name ); } m_opsys_long_name = param( "OPSYSLONGNAME" ); if( m_opsys_short_name ) { free( m_opsys_short_name ); } m_opsys_short_name = param( "OPSYSSHORTNAME" ); if( m_opsys_legacy ) { free( m_opsys_legacy ); } m_opsys_legacy = param( "OPSYSLEGACY" ); // temporary attributes for raw utsname info if( m_utsname_sysname ) { free( m_utsname_sysname ); } if( m_utsname_nodename ) { free( m_utsname_nodename ); } if( m_utsname_release ) { free( m_utsname_release ); } if( m_utsname_version ) { free( m_utsname_version ); } if( m_utsname_machine ) { free( m_utsname_machine ); } m_utsname_sysname = param( "UTSNAME_SYSNAME" ); m_utsname_nodename = param( "UTSNAME_NODENAME" ); m_utsname_release = param( "UTSNAME_RELEASE" ); m_utsname_version = param( "UTSNAME_VERSION" ); m_utsname_machine = param( "UTSNAME_MACHINE" ); if( m_uid_domain ) { free( m_uid_domain ); } m_uid_domain = param( "UID_DOMAIN" ); dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_UID_DOMAIN, m_uid_domain ); if( m_filesystem_domain ) { free( m_filesystem_domain ); } m_filesystem_domain = param( "FILESYSTEM_DOMAIN" ); dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_FILE_SYSTEM_DOMAIN, m_filesystem_domain ); m_idle_interval = param_integer( "IDLE_INTERVAL", -1 ); // checkpoint platform signature if (m_ckptpltfrm) { free(m_ckptpltfrm); } const char * ckptpltfrm = param( ATTR_CHECKPOINT_PLATFORM ); if( ckptpltfrm == NULL ) { ckptpltfrm = sysapi_ckptpltfrm(); } m_ckptpltfrm = strdup( ckptpltfrm ); pair_strings_vector root_dirs = root_dir_list(); std::stringstream result; unsigned int chroot_count = 0; for (pair_strings_vector::const_iterator it=root_dirs.begin(); it != root_dirs.end(); ++it, ++chroot_count) { if (chroot_count) { result << ", "; } result << it->first; } if (chroot_count > 1) { std::string result_str = result.str(); dprintf(D_FULLDEBUG, "Named chroots: %s\n", result_str.c_str() ); m_named_chroot = result_str; } } if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) { m_virt_mem = sysapi_swap_space(); dprintf( D_FULLDEBUG, "Swap space: %lu\n", m_virt_mem ); #if defined(WIN32) credd_test(); #endif } if( IS_TIMEOUT(how_much) && IS_SHARED(how_much) ) { m_load = sysapi_load_avg(); sysapi_idle_time( &m_idle, &m_console_idle ); time_t my_timer; struct tm *the_time; time( &my_timer ); the_time = localtime(&my_timer); m_clock_min = (the_time->tm_hour * 60) + the_time->tm_min; m_clock_day = the_time->tm_wday; if (m_last_keypress < my_timer - m_idle) { if (m_idle_interval >= 0) { int duration = my_timer - m_last_keypress; if (duration > m_idle_interval) { if (m_seen_keypress) { dprintf(D_IDLE, "end idle interval of %d sec.\n", duration); } else { dprintf(D_IDLE, "first keyboard event %d sec. after startup\n", duration); } } } m_last_keypress = my_timer; m_seen_keypress = true; } #ifdef WIN32 update_all_WinPerf_results(); #endif AttribValue *pav = NULL; m_lst_dynamic.Rewind(); while ((pav = m_lst_dynamic.Next()) ) { if (pav) { #ifdef WIN32 if ( ! update_WinPerf_Value(pav)) pav->vtype = AttribValue_DataType_Max; // undefined vtype #else if (pav->pquery) { // insert code to update pav from pav->pquery } #endif } } } if( IS_TIMEOUT(how_much) && IS_SUMMED(how_much) ) { m_condor_load = resmgr->sum( &Resource::condor_load ); if( m_condor_load > m_load ) { m_condor_load = m_load; } } }