win32.c

系统任务管理器

/* ===================================================================== */


void gkrellm_sys_net_read_data(void)
{
	gint	i;
#if defined(USE_PDH)
    DWORD type;
    PDH_FMT_COUNTERVALUE value;
#else
    DWORD* value;
#endif

    win32_read_proc_stat();

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        for (i = 0; i < numAdapters; i++) {
            status = PdhGetFormattedCounterValue(netRecCounter[i], PDH_FMT_LONG, &type, &value);
            rx[i] += value.longValue / _GK.update_HZ;

            status = PdhGetFormattedCounterValue(netSendCounter[i], PDH_FMT_LONG, &type, &value);
            tx[i] += value.longValue / _GK.update_HZ;

            gkrellm_net_assign_data(netName[i], rx[i], tx[i]);
        }
    }
#else
    for (i = 0; i < numAdapters; i++) {
        rx[i] = 0;
        tx[i] = 0;
        if (netPerfKey[i] != 0) {
            dataLen = 8192;
            RegQueryValueEx(netPerfKey[i], perfKeys[4], NULL, &dataType, data, &dataLen);
            if (dataType == REG_BINARY) {
                value = data;
                rx[i] = *value;
            }
        }
        gkrellm_net_assign_data(netName[i], rx[i], tx[i]);
    }
#endif
}

void gkrellm_sys_net_check_routes(void)
{
}


gboolean gkrellm_sys_net_isdn_online(void)
{
	return FALSE;	/* ISDN is off line */
}

gboolean gkrellm_sys_net_init(void)
{
#if !defined(USE_PDH)
    HKEY startPerf;
#endif
    DWORD size = 0;
    DWORD isize = 0;
    LPTSTR objects = NULL;
    LPTSTR instances = NULL;
    LPTSTR instance = NULL;
    TCHAR buf[1024];
    int strSize;
    int i;
    int adapter = -1;

    // turn off for now
//	gkrellm_net_add_timer_type_ppp("ppp0");
//	gkrellm_net_add_timer_type_ippp("ippp0");

    numAdapters = 0;
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing network monitor.\n");

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        PdhEnumObjectItems(NULL, NULL, TEXT("Network Interface"), NULL, &size, NULL, &isize, PERF_DETAIL_WIZARD, 0);
        if (_GK.debug_level & DEBUG_SYSDEP) {
            printf("Found %i network objects and %i network instances.\n", size, isize);
        }
        if (size > 0) {
            ++isize;
            ++size;

            objects = (LPTSTR) malloc(sizeof(TCHAR) * size);
            instances = (LPTSTR) malloc(sizeof(TCHAR) * isize);

            PdhEnumObjectItems(NULL, NULL, TEXT("Network Interface"), objects, &size, instances, &isize, PERF_DETAIL_WIZARD, 0);
            if (_GK.debug_level & DEBUG_SYSDEP) {
                printf("Enumerated %i network objects and %i network instances.\n", size, isize);
            }

            for (instance = instances; *instance != 0; instance += lstrlen(instance) + 1) {
                ++adapter;
                if (adapter >= MAX_NET_ADAPTERS) {
                    if (_GK.debug_level & DEBUG_SYSDEP)
                        printf("Hit maximum number of network adapters.\n");
                    break;
                }

                strSize = MAX_NET_NAME;
                if (_tcslen(instance) < MAX_NET_NAME) {
                    strSize = _tcslen(instance);
                }

                for (i = 0; i < strSize; i++) {
                    if (instance[i] == _T(' ')) 
                        netName[adapter][i] = _T('_');
                    else
                        netName[adapter][i] = instance[i];
                }

                netName[adapter][strSize] = _T('\0');

                gkrellm_net_add_timer_type_ppp(netName[adapter]);

                _tcscpy(buf, perfKeys[5]);
                _tcscat(buf, instance);
                _tcscat(buf, perfKeys[6]);
                rx[adapter] = 0;
                status = PdhAddCounter(query, buf, 0, &(netRecCounter[adapter]));
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Added network receive for %s interface with status %i.\n", buf, status);

                _tcscpy(buf, perfKeys[5]);
                _tcscat(buf, instance);
                _tcscat(buf, perfKeys[7]);
                status = PdhAddCounter(query, buf, 0, &(netSendCounter[adapter]));
                tx[adapter] = 0;
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Added network transmit for %s interface with status %i.\n", buf, status);
            } 

            numAdapters = adapter + 1;
        }

        if (objects != NULL)
            free(objects);
        if (instances != NULL)
            free(instances);
    }
#else

    // need to enumerate these
    // and pick up names
    numAdapters = 0;
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing interface for %s with name of %s\n", perfKeys[4], perfKeys[5]);
    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StartStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        if (RegQueryValueEx(startPerf, perfKeys[4], NULL, &dataType, data, &dataLen) != ERROR_SUCCESS) { 
            // failed
            netPerfKey[numAdapters] = 0;
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initizialization failed.\n");
        }
        else {
            if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StatData", &(netPerfKey[numAdapters])) != ERROR_SUCCESS) {
                // failed
                netPerfKey[numAdapters] = 0;
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Initizialization failed.\n");
            }
            else {
                // success
                _tcscpy(netName[numAdapters], perfKeys[5]);
                gkrellm_net_add_timer_type_ppp(netName[numAdapters]);
                numAdapters = 1;
            }
        }
        RegCloseKey(startPerf);
    }
    else {
        // failed
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Initizialization failed.\n");
        netPerfKey[0] = 0;
    }
#endif

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

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

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

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

/* ===================================================================== */
/* Disk monitor interface */
/* ===================================================================== */

static gint numDisks = 0;
static long diskread[MAX_DISKS], diskwrite[MAX_DISKS];

gchar * gkrellm_sys_disk_name_from_device(gint device_number, gint unit_number,
			gint *order)
{
	static gchar name[32];

	sprintf(name, "Disk%s", diskName[device_number]);
	*order = device_number;
	return name;
}

gint gkrellm_sys_disk_order_from_name(gchar *name)
{
	return 0;	/* Disk by name not implemented in Windows */
}

void gkrellm_sys_disk_read_data(void)
{
	/* One routine reads cpu, disk, and swap data.  All three monitors will
	| call it, but only the first call per timer tick will do the work.
	*/
#if defined(USE_PDH)
    DWORD type;
    PDH_FMT_COUNTERVALUE value;
#else
    DWORD* value;
#endif
    double readInt = 0, writeInt = 0;
    int i;

    win32_read_proc_stat();

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        for (i = 0; i < numDisks; i++) {
            status = PdhGetFormattedCounterValue(diskReadCounter[i], PDH_FMT_DOUBLE, &type, &value);
            readInt = value.doubleValue / _GK.update_HZ;

            status = PdhGetFormattedCounterValue(diskWriteCounter[i], PDH_FMT_DOUBLE, &type, &value);
            writeInt = value.doubleValue / _GK.update_HZ;

            diskread[i] += readInt;
            diskwrite[i] += writeInt;

        }
    }
#else
    if (diskreadPerfKey != 0) {
        dataLen = 8192;
        RegQueryValueEx(diskreadPerfKey, perfKeys[2], NULL, &dataType, data, &dataLen);
        if (dataType == REG_BINARY) {
            value = data;
            readInt = *value;
        }
    }

    if (diskwritePerfKey != 0) {
        dataLen = 8192;
        RegQueryValueEx(diskwritePerfKey, perfKeys[3], NULL, &dataType, data, &dataLen);
        if (dataType == REG_BINARY) {
            value = data;
            writeInt = *value;
        }
    }

    // readInt & writeInt appear to be cumulative already
    diskread[0] = readInt;
    diskwrite[0] = writeInt;

#endif

	for (i = 0; i < numDisks; i++)
		{
//    		gkrellm_disk_assign_data_nth(i, diskread[i], diskwrite[i]);
    	    gkrellm_disk_assign_data_by_device(i, 0,
						diskread[i], diskwrite[i], FALSE);
		}
	}

gboolean gkrellm_sys_disk_init(void)
	{
#if defined(USE_PDH)
    DWORD size = 0;
    DWORD isize = 0;
    LPTSTR objects = NULL;
    LPTSTR instances = NULL;
    LPTSTR instance = NULL;
    TCHAR buf[1024];
    int strSize;
    int i;
    int disk = -1;

    numDisks = 0;

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

    if (winVer > 0 && query != 0) {
        PdhEnumObjectItems(NULL, NULL, TEXT("PhysicalDisk"), NULL, &size, NULL, &isize, PERF_DETAIL_WIZARD, 0);
        if (size > 0) {
            ++isize;
            ++size;

            objects = (LPTSTR) malloc(sizeof(TCHAR) * size);
            instances = (LPTSTR) malloc(sizeof(TCHAR) * isize);

            PdhEnumObjectItems(NULL, NULL, TEXT("PhysicalDisk"), objects, &size, instances, &isize, PERF_DETAIL_WIZARD, 0);

            for (instance = instances; *instance != 0; instance += lstrlen(instance) + 1) {
                ++disk;
                if (disk >= MAX_DISKS)
                    break;

                strSize = MAX_DISK_NAME;
                if (_tcsclen(instance) < MAX_DISK_NAME) {
                    strSize = _tcsclen(instance);
                }

                for (i = 0; i < strSize; i++) {
                    if (instance[i] == _T(' ')) 
                        diskName[disk][i] = _T('_');
                    else
                        diskName[disk][i] = instance[i];
                }

                diskName[disk][strSize] = _T('\0');

                _tcscpy(buf, perfKeys[8]);
                _tcscat(buf, instance);
                _tcscat(buf, perfKeys[9]);
                status = PdhAddCounter(query, buf, 0, &(diskReadCounter[disk]));
                diskread[disk] = 0;
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Adding disk %s for read monitoring with status code %i\n", buf, status);

                _tcscpy(buf, perfKeys[8]);
                _tcscat(buf, instance);
                _tcscat(buf, perfKeys[10]);
                status = PdhAddCounter(query, buf, 0, &(diskWriteCounter[disk]));
                diskwrite[disk] = 0;
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Adding disk %s for write monitoring with status code %i\n", buf, status);
            }

            numDisks = disk + 1;
        }
        if (objects != NULL)
            free(objects);
        if (instances != NULL)
            free(instances);
    }
#else
    HKEY startPerf;

    numDisks = 0;
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing disk key %s for read monitoring\n", perfKeys[2]);

    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StartStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        if (RegQueryValueEx(startPerf, perfKeys[2], NULL, &dataType, data, &dataLen) != ERROR_SUCCESS) {
            // failed
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initialization failed.\n");
            diskreadPerfKey = 0;
        }
        else {
            if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StatData", &diskreadPerfKey) != ERROR_SUCCESS) {
                // failed
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Initialization failed.\n");
                diskreadPerfKey = 0;
            }
        }
        RegCloseKey(startPerf);
    }
    else {
        // failed
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Initialization failed.\n");
        diskreadPerfKey = 0;
    }

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing disk key %s for write monitoring\n", perfKeys[3]);

    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StartStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        if (RegQueryValueEx(startPerf, perfKeys[3], NULL, &dataType, data, &dataLen) != ERROR_SUCCESS) {
            // failed
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initialization failed.\n");
            diskwritePerfKey = 0;
        }
        else {
            if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StatData", &diskwritePerfKey) != ERROR_SUCCESS) {
                // failed
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Initialization failed.\n");
                diskwritePerfKey = 0;
            }
            else {
                numDisks = 1;
                _tcscpy(diskName[0], _T("Total"));
            }
        }
        RegCloseKey(startPerf);
    }
    else {
        // failed
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Initialization failed.\n");
        diskwritePerfKey = 0;
    }