win32.c

系统任务管理器

#endif

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Found %i disks for monitoring.\n", numDisks);

    if (numDisks == 0)
        return FALSE;
    else
        return TRUE;
	}

void win32_sys_disk_stop(void)
{
#if !defined(USE_PDH)
    HKEY startPerf;

    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StopStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        RegQueryValueEx(startPerf, perfKeys[2], NULL, &dataType, data, &dataLen);
        cpuperfKey = 0;
        RegCloseKey(startPerf);
    }
    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StopStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        RegQueryValueEx(startPerf, perfKeys[3], NULL, &dataType, data, &dataLen);
        cpuperfKey = 0;
        RegCloseKey(startPerf);
    }
#endif
}

/* ===================================================================== */
/* Proc monitor interface */
/* ===================================================================== */

void gkrellm_sys_proc_read_data(void)
	{
#if defined(USE_PDH)
    DWORD type;
    PDH_FMT_COUNTERVALUE value;
#else
    DWORD* value;
    HANDLE hSnap;
#endif
    gint	n_running = 0, n_processes = 0;
	gulong	n_forks = 0;
    static gulong last_n_forks = 0;
    gulong new_forks;
	static gfloat	fload = 0;
    gfloat a;

    win32_read_proc_stat();

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        status = PdhGetFormattedCounterValue(processCounter, PDH_FMT_LONG, &type, &value);
        n_processes = value.longValue;

        status = PdhGetFormattedCounterValue(threadCounter, PDH_FMT_LONG, &type, &value);
        n_forks = value.longValue;
    }
#else
    if (threadPerfKey != 0) {
        dataLen = 8192;
        RegQueryValueEx(threadPerfKey, perfKeys[1], NULL, &dataType, data, &dataLen);
        if (dataType == REG_BINARY) {
            value = data;
            n_forks = *value;
        }
    }

    hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap != -1) {
        PROCESSENTRY32 entry;

        entry.dwSize = sizeof(PROCESSENTRY32);
        n_processes = 1;
        Process32First(hSnap, &entry);

        while (Process32Next(hSnap, &entry) == TRUE)
            ++n_processes;

        CloseHandle(hSnap);
    }
    else
        n_processes = n_forks;

#endif

    n_running = n_processes;

    //fload - is the system load average, an exponential moving average over a period
    //    of a minute of n_running.  It measures how heavily a system is loaded
    //    with processes or threads competing for cpu time slices.

    //All the unix OSs have a system call for getting the load average.  But if
    //you don't and can get a n_running number, you can calculate fload.  An
    //exponential moving average (ema) is done like:

    //    a = 2 / (period + 1)
    //    ema = ema + a * (new_value - ema)


    a = 2. / ((_GK.update_HZ * 60.) + 1.);
    new_forks = n_forks - last_n_forks;
    if (new_forks < 0)
        new_forks = 0;
    fload = fload + a * (new_forks - fload);
    if (fload < 0) 
        fload = 0;

	gkrellm_proc_assign_data(n_processes, n_running, n_forks, fload);

    last_n_forks = n_forks;
	}

void gkrellm_sys_proc_read_users(void)
	{
	static time_t	utmp_mtime;
	gint			n_users = 0;
#if defined(USE_PDH)
    DWORD t1, t2;
    LPWKSTA_USER_INFO_0 ptr = 0;
    NET_API_STATUS err;

    err = NetWkstaUserEnum(NULL, 0, (LPBYTE*) &ptr, 1024, &t1, &t2, NULL);
    if (err != 0 && err != ERROR_MORE_DATA)
    	n_users = 1;
    else
        n_users = t2;
    NetApiBufferFree(ptr);
#else
        n_users = 1;
#endif

	gkrellm_proc_assign_users(n_users);

	}

gboolean gkrellm_sys_proc_init(void)
{
    HKEY startPerf;

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing process monitor.\n");

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Adding %s as process monitor.\n", perfKeys[2]);
        status = PdhAddCounter(query, perfKeys[2], 0, &processCounter);
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Adding %s as thread monitor.\n", perfKeys[3]);
        status = PdhAddCounter(query, perfKeys[3], 0, &threadCounter);
    }
#else
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing %s as thread and process monitor.\n", perfKeys[1]);
    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StartStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        if (RegQueryValueEx(startPerf, perfKeys[1], NULL, &dataType, data, &dataLen) != ERROR_SUCCESS) {
            // failed
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initialization failed.\n");
            threadPerfKey = 0;
        }
        else {
            if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StatData", &threadPerfKey) != ERROR_SUCCESS) {
                // failed
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Initialization failed.\n");
                threadPerfKey = 0;
            }
        }
        RegCloseKey(startPerf);
    }
    else {
        // failed
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Initialization failed.\n");
        threadPerfKey = 0;
    }
#endif

	return TRUE;
	}

void win32_sys_process_stop(void)
{
#if !defined(USE_PDH)
    HKEY startPerf;

    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StopStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        RegQueryValueEx(startPerf, perfKeys[1], NULL, &dataType, data, &dataLen);
        threadPerfKey = 0;
        RegCloseKey(startPerf);
    }
#endif
}


/* ===================================================================== */
/* Memory/Swap monitor interface */
/* ===================================================================== */

void gkrellm_sys_mem_read_data(void)
{
	gboolean	using_tagged = FALSE;
	guint64		total, used, x_used, free, shared, buffers;
    MEMORYSTATUS memStatus;
    long pageAvail, pageTot;
    long physAvail, physTot;
    long virtAvail, virtTot;
    long len;
    long load;
    long cached;

    GlobalMemoryStatus(&memStatus);

    pageAvail = memStatus.dwAvailPageFile;
    physAvail = memStatus.dwAvailPhys;
    virtAvail = memStatus.dwAvailVirtual;
    len = memStatus.dwLength;
    load = memStatus.dwMemoryLoad;
    physTot = memStatus.dwTotalPhys;
    pageTot = memStatus.dwTotalPageFile;
    virtTot = memStatus.dwTotalVirtual;

    total = physTot;
    free = physAvail; 

    // don't know how to get at these
    shared = 0;
    buffers = 0;

    // don't know if this is correct
    cached = (virtTot - virtAvail) - (pageTot - pageAvail);
    if (cached < 0) {
        cached = 0;
    }

    x_used = total - free;

	used = x_used - buffers - cached;
	gkrellm_mem_assign_data(total, used, free, shared, buffers, cached);
}

void gkrellm_sys_swap_read_data(void)
{
    MEMORYSTATUS memStatus;
    long pageAvail, pageTot;
    long physAvail, physTot;
    long virtAvail, virtTot;
    long swapAvail, swapTot;
    long len;
    long load;
    long used;

    GlobalMemoryStatus(&memStatus);

    pageAvail = memStatus.dwAvailPageFile;
    physAvail = memStatus.dwAvailPhys;
    virtAvail = memStatus.dwAvailVirtual;
    len = memStatus.dwLength;
    load = memStatus.dwMemoryLoad;
    physTot = memStatus.dwTotalPhys;
    pageTot = memStatus.dwTotalPageFile;
    virtTot = memStatus.dwTotalVirtual;

    // what are these?
    swapin = 0;
    swapout = 0;

    // is this right?
    swapTot = pageTot - physTot;
    swapAvail = pageAvail - physAvail;

    used = swapTot - swapAvail;
    if (used < 0)
        used = 0;

    gkrellm_swap_assign_data(swapTot, used, swapin, swapout);
}

gboolean gkrellm_sys_mem_init(void)
{
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initialized Memory monitor.\n");

	return TRUE;
}


/* ===================================================================== */
/* Battery monitor interface */
/* ===================================================================== */

#define	L_NO_BATTERY	0x80
#define	L_ON_LINE		1
#define	L_CHARGING		8
#define L_UNKNOWN		0xFF

void gkrellm_sys_battery_read_data(void)
{
	gboolean	available, on_line, charging;
	gint		percent, time_left;
	gchar		units[32];

    SYSTEM_POWER_STATUS power;

    GetSystemPowerStatus(&power);

	if ((power.BatteryFlag & L_NO_BATTERY) == L_NO_BATTERY || (power.BatteryFlag & L_UNKNOWN) == L_UNKNOWN)
		available = FALSE;
	else
		available = TRUE;

	on_line = ((power.ACLineStatus & L_ON_LINE) == L_ON_LINE) ? TRUE : FALSE;
	charging= ((power.BatteryFlag & L_CHARGING) == L_CHARGING) ? TRUE : FALSE;

    time_left = power.BatteryLifeTime;
	if (!strcmp(units, "sec"))
		time_left /= 60;

    percent = power.BatteryLifePercent;

	gkrellm_battery_assign_data(0, available, on_line, charging,
					percent, time_left);
}

gboolean gkrellm_sys_battery_init()
{
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initialized Battery monitor.\n");

	return TRUE;
}


/* ============================================== */
/* FS monitor interfaces */
/* ===================================================================== */

gboolean gkrellm_sys_fs_fstab_modified(void)
{
    return FALSE;
}

void eject_win32_cdrom(gchar *device)
{
    HANDLE hFile;
    BOOL err;
    char buf[25];
    DWORD numBytes;

    if (strlen(device) <= 0)
        return;

    sprintf(buf, "\\\\.\\%c:", device[0]);
    hFile = CreateFile(buf, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);

    if (hFile != 0 && hFile != INVALID_HANDLE_VALUE) {
        // this should be safe for non-removable drives
        err = DeviceIoControl(hFile, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &numBytes, NULL);
        err = DeviceIoControl(hFile, IOCTL_STORAGE_EJECT_MEDIA, NULL, 0, NULL, 0, &numBytes, NULL);

        CloseHandle(hFile);
    }
}

gboolean gkrellm_sys_fs_init(void) 
{
    gkrellm_fs_mounting_unsupported();

    gkrellm_fs_setup_eject(NULL, NULL, eject_win32_cdrom, NULL);

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing file system monitor.\n");

    return TRUE;
}

void gkrellm_sys_fs_get_fsusage(gpointer fs, gchar *dir)
{
	//gkrellm_fs_assign_fsusage_data(fs,
	//			(gulong) st.f_blocks, (gulong) st.f_bavail,
	//			(gulong) st.f_bfree, (gulong) st.f_bsize);

    BOOL err = 0;
    ULARGE_INTEGER freeAvailableToCaller;
    ULARGE_INTEGER totalBytes;
    ULARGE_INTEGER freeBytes;
    gulong total, freeCaller, free;
    gulong secPerCluster, bytesPerSector, freeClusters, totalClusters;
    HANDLE hFile;
    char buf[1024];

    if (strlen(dir) <= 0)
        return;

    if (winVer > 0) {
        sprintf(buf, "\\\\.\\%c:", dir[0]);

        hFile = CreateFile(buf, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, NULL);

        if (hFile == 0 || hFile == INVALID_HANDLE_VALUE) {
            return;
        }
        CloseHandle(hFile);
    }

    if (fswin95 == 1) {
        err = GetDiskFreeSpaceEx(dir, &freeAvailableToCaller, &totalBytes, &freeBytes);

        if (err != 0) {
            total = EnlargedUnsignedDivide(totalBytes, 1024, 0);
            freeCaller = EnlargedUnsignedDivide(freeAvailableToCaller, 1024, 0);
            free = EnlargedUnsignedDivide(freeBytes, 1024, 0);

            // fs, blocks, avail, free, size
	        gkrellm_fs_assign_fsusage_data(fs, total, freeCaller, free, 1024);
        }
    }
    if (err == 0 && fswin95 == 0) {
        err = GetDiskFreeSpace(dir, &secPerCluster, &bytesPerSector, &freeClusters, &totalClusters);
        if (err != 0) {