win32.c

来自「系统任务管理器」· C语言 代码 · 共 2,156 行 · 第 1/5 页

} SharedSensor;

typedef struct {
    short siSMB_Base;            // SMBus base address
    BusType siSMB_Type;         // SMBus/Isa bus used to access chip
    SMBType siSMB_Code;         // SMBus sub type, Intel, AMD or ALi
    char siSMB_Addr;            // Address of sensor chip on SMBus
    unsigned char siSMB_Name[41];        // Nice name for SMBus
    short siISA_Base;            // ISA base address of sensor chip on ISA
    int siChipType;             // Chip nr, connects with Chipinfo.ini
    char siVoltageSubType;      // Subvoltage option selected
} SharedInfo;

typedef struct {
    double sdVersion;           // version number (example: 51090)
    SharedIndex sdIndex[10];     // Sensor index
    SharedSensor sdSensor[100];  // sensor info
    SharedInfo sdInfo;          // misc. info
    unsigned char sdStart[41];           // start time
    unsigned char sdCurrent[41];         // current time
    unsigned char sdPath[256];           // MBM path
} SharedData;

static int tempCount, voltCount, fanCount;

static int ReadSharedData(void)
{
  SharedData *ptr;
  SharedSensor *sens;
  HANDLE hSData;
  int i, j;
  int totalCount;

  hSData=OpenFileMapping(FILE_MAP_READ, FALSE, "$M$B$M$5$S$D$");
  if (hSData==0) 
      return 1;

  ptr = (SharedData *)MapViewOfFile(hSData, FILE_MAP_READ, 0, 0, 0);
  if (ptr == 0){
      CloseHandle(hSData);
      return 1;
  }

  totalCount = 0;
  for (i = 0; i < 5; i++) {
      totalCount += ptr->sdIndex[i].Count;
  }

  tempCount = 0;
  voltCount = 0;
  fanCount = 0;
  for (j = 0; j < totalCount; j++) {
      sens = &(ptr->sdSensor[j]);

      switch (ptr->sdSensor[j].ssType) {
      case stUnknown:
          break;
      case stTemperature:
          temperatures[tempCount] = ptr->sdSensor[j].ssCurrent;
          ++tempCount;
          break;
      case stVoltage:
          voltages[voltCount] = ptr->sdSensor[j].ssCurrent;
          ++voltCount;
          break;
      case stFan:
          fans[fanCount] = ptr->sdSensor[j].ssCurrent;
          ++fanCount;
          break;
      case stMhz:
          break;
      case stPercentage:
          break;
      }
  }
        
  UnmapViewOfFile(ptr);
  CloseHandle(hSData);

  return 0;
}

gboolean gkrellm_sys_sensors_get_voltage(gchar *device_name, gint id,
		gint iodev, gint inter, gfloat *volt)
{

    if (iodev < NrVoltage && iodev >= 0) {
        if (ReadSharedData() == 1) {
            *volt = 0;
            return FALSE;
        }

        *volt = voltages[iodev];

        return TRUE;
    }
    else {
        *volt = 0;
        return FALSE;
    }
}

gboolean gkrellm_sys_sensors_get_fan(gchar *device_name, gint id,
		gint iodev, gint inter, gfloat *fan)
{

    if (iodev < NrFan && iodev >= 0) {
        if (ReadSharedData() == 1) {
            *fan = 0;
            return FALSE;
        }

        *fan = fans[iodev];    

        return TRUE;
    }
    else {
        *fan = 0;
        return FALSE;
    }
}

gboolean gkrellm_sys_sensors_get_temperature(gchar *device_name, gint id,
		gint iodev, gint inter, gfloat *temp)
{

    if (iodev < NrTemperature && iodev >= 0) {
        if (ReadSharedData() == 1) {
            *temp = 0;
            return FALSE;
        }

        *temp = temperatures[iodev];

        return TRUE;
    }
    else {
        *temp = 0;
        return FALSE;
    }
}

gboolean gkrellm_sys_sensors_init(void)
{
    int haveMBM = 0;
    char buf[25];
//    SharedData *ptr;
//    SharedSensor *sens;
//    HANDLE hSData;
    int i;
//    int j;
//    int totalCount;

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

//    hSData=OpenFileMapping(FILE_MAP_READ, FALSE, "$M$B$M$5$S$D$");
//    if (hSData != 0) { 
//        ptr = (SharedData *)MapViewOfFile(hSData, FILE_MAP_READ, 0, 0, 0);
//        if (ptr == 0){
//          CloseHandle(hSData);
//          haveMBM = 0;
//        }
//        else {
//            haveMBM = 1;
//        }
//    }
//    else {
//        haveMBM = 0;
//    }

/*    if (haveMBM == 1) {
        totalCount = 0;
        for (i = 0; i < 5; i++) {
          totalCount += ptr->sdIndex[i].Count;
        }

        tempCount = 0;
        voltCount = 0;
        fanCount = 0;
        for (j = 0; j < totalCount; j++) {
          sens = &(ptr->sdSensor[j]);

          switch (ptr->sdSensor[j].ssType) {
          case stUnknown:
              break;
          case stTemperature:
                gkrellm_sensors_add_sensor(SENSOR_TEMPERATURE, NULL, sens->ssName,
			        tempCount, tempCount, 0,
			        1, 0, NULL, sens->ssName);
                ++tempCount;
              break;
          case stVoltage:
                if (strlen(sens->ssName) == 0) 
                    gkrellm_sensors_add_sensor(SENSOR_VOLTAGE, NULL, "Volt",
		                voltCount, voltCount, 0,
		                1, 0, NULL, "Volt");
                else 
                    gkrellm_sensors_add_sensor(SENSOR_VOLTAGE, NULL, sens->ssName,
		                voltCount, voltCount, 0,
		                1, 0, NULL, sens->ssName);
                ++voltCount;
              break;
          case stFan:
                gkrellm_sensors_add_sensor(SENSOR_FAN, NULL, sens->ssName,
	                fanCount, fanCount, 0,
	                1, 0, NULL, sens->ssName);
                ++fanCount;
              break;
          case stMhz:
              break;
          case stPercentage:
              break;
          }
        }
    
        UnmapViewOfFile(ptr);
        CloseHandle(hSData);
    }
    else  */
    {   
        tempCount = 0;
        voltCount = 0;
        fanCount = 0;

        for (i = 0; i < NrTemperature; i++) {
            sprintf(buf, "Temp %i", i);
            gkrellm_sensors_add_sensor(SENSOR_TEMPERATURE, NULL, buf,
	            tempCount, tempCount, 0,
	            1, 0, NULL, buf);
            ++tempCount;
        }

        for (i = 0; i < NrVoltage; i++) {
            sprintf(buf, "Volt %i", i);
            gkrellm_sensors_add_sensor(SENSOR_VOLTAGE, NULL, buf,
		        voltCount, voltCount, 0,
		        1, 0, NULL, buf);
            ++voltCount;
        }
    
        for (i = 0; i < NrFan; i++) {
            sprintf(buf, "Fan %i", i);
            gkrellm_sensors_add_sensor(SENSOR_FAN, NULL, buf,
	            fanCount, fanCount, 0,
	            1, 0, NULL, buf);
            ++fanCount;
        }
    }

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initialized sensors for %i temps, %i volts, %i fans.\n", tempCount, voltCount, fanCount);

    return TRUE;
}

/* ===================================================================== */
/* CPU monitor interface */
/* ===================================================================== */

void
gkrellm_sys_cpu_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)
    static gulong user[MAX_CPU], nice[MAX_CPU], sys[MAX_CPU], idle[MAX_CPU];
    DWORD type;
    PDH_FMT_COUNTERVALUE value;
    int i;
#else
    static gulong user, nice, sys, idle;
    DWORD* value;
#endif
    long userInt = 0, idleInt = 0, sysInt = 0;

    win32_read_proc_stat();

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        for (i = 0; i < numCPUs; i++) {
            status = PdhGetFormattedCounterValue(cpuUserCounter[i], PDH_FMT_LONG, &type, &value);
            if (status != 0) 
                userInt = 0;
            else 
                userInt = value.longValue;
    
            status = PdhGetFormattedCounterValue(cpuSysCounter[i], PDH_FMT_LONG, &type, &value);
            if (status != 0)
                sysInt = 0;
            else
                sysInt = value.longValue;

            // user time defined as total - system
            userInt -= sysInt;

            idleInt = 100 - userInt - sysInt;

            user[i] += userInt;
            sys[i] += sysInt;
            idle[i] += idleInt;
   
	        gkrellm_cpu_assign_data(i, user[i], nice[i], sys[i], idle[i]);
        }
    }
#else
    if (cpuperfKey != 0) {
        dataLen = 8192;
        RegQueryValueEx(cpuperfKey, perfKeys[0], NULL, &dataType, data, &dataLen);
        if (dataType == REG_BINARY) {
            sysInt = 0;
            value = data;
            userInt = *value;
        }
    }

    // user time defined as total - system
    userInt -= sysInt;

    idleInt = 100 - userInt - sysInt;

    user += userInt;
    sys += sysInt;
    idle += idleInt;
   
	gkrellm_cpu_assign_data(0, user, nice, sys, idle);
#endif
	}

gboolean
gkrellm_sys_cpu_init(void)
	{
#if !defined(USE_PDH)
    HKEY startPerf;
#else
    SYSTEM_INFO sysInfo;
    int i;
    TCHAR buf[50];
    TCHAR buf2[10];
#endif

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

    gkrellm_cpu_nice_time_unsupported();

#if defined(USE_PDH)
    GetSystemInfo(&sysInfo);

    numCPUs = sysInfo.dwNumberOfProcessors;

    if (numCPUs < 1) {
        numCPUs = 1;
    }
    if (numCPUs > MAX_CPU) {
        numCPUs = MAX_CPU;
    }

    if (winVer > 0 && query != 0) {
        for (i = 0; i < numCPUs; i++) {
            _tcscpy(buf, perfKeys[11]);
            _itot(i, buf2, 10);
            _tcscat(buf, buf2);
            _tcscat(buf, perfKeys[0]);
            status = PdhAddCounter(query, buf, 0, &cpuUserCounter[i]);
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initialized cpu %i user portion (%s) with error code %i\n", i, buf, status);

            _tcscpy(buf, perfKeys[11]);
            _itot(i, buf2, 10);
            _tcscat(buf, buf2);
            _tcscat(buf, perfKeys[1]);
            status = PdhAddCounter(query, buf, 0, &cpuSysCounter[i]);
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initialized cpu %i system portion (%s) with error code %i\n", i, buf, status);
        }
    }
#else
    numCPUs = 1;
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing cpu (%s)\n", perfKeys[0]);
    if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StartStat", &startPerf) == ERROR_SUCCESS) {
        // success
        dataLen = 8192;
        if (RegQueryValueEx(startPerf, perfKeys[0], NULL, &dataType, data, &dataLen) != ERROR_SUCCESS) {
            // failed
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Initializing cpu failed.\n");
            cpuperfKey = 0;
        }
        else {
            if (RegOpenKey(HKEY_DYN_DATA, "PerfStats\\StatData", &cpuperfKey) != ERROR_SUCCESS) {
                // failed
                if (_GK.debug_level & DEBUG_SYSDEP)
                    printf("Initializing cpu failed.\n");
                cpuperfKey = 0;
            }
        }
        RegCloseKey(startPerf);
    }
    else {
        // failed
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Initializing cpu failed.\n");
        cpuperfKey = 0;
    }
#endif

	gkrellm_cpu_set_number_of_cpus(numCPUs);

	return TRUE;
	}

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

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

/* ===================================================================== */
/* Net monitor interface */