From e5de44c80d55ce0a2746163e5a39f1d6634a3c96 Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Thu, 10 Jun 2021 20:13:12 +0200 Subject: [PATCH] Restyling hwmon (2021)(2) --- include/ext_ADL.h | 14 + include/ext_nvapi.h | 11 + include/ext_nvml.h | 16 + include/ext_sysfs.h | 13 + src/ext_ADL.c | 276 +++++++++ src/ext_nvapi.c | 233 ++++++++ src/ext_nvml.c | 386 +++++++++++++ src/ext_sysfs.c | 436 ++++++++++++++ src/hwmon.c | 1317 ------------------------------------------- 9 files changed, 1385 insertions(+), 1317 deletions(-) diff --git a/include/ext_ADL.h b/include/ext_ADL.h index 18a903b70..fd8438c8e 100644 --- a/include/ext_ADL.h +++ b/include/ext_ADL.h @@ -314,4 +314,18 @@ typedef hm_adl_lib_t ADL_PTR; void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize); +int adl_init (void *hashcat_ctx); +void adl_close (void *hashcat_ctx); +int hm_ADL_Main_Control_Destroy (void *hashcat_ctx); +int hm_ADL_Main_Control_Create (void *hashcat_ctx, ADL_MAIN_MALLOC_CALLBACK callback, int iEnumConnectedAdapters); +int hm_ADL_Adapter_NumberOfAdapters_Get (void *hashcat_ctx, int *lpNumAdapters); +int hm_ADL_Adapter_AdapterInfo_Get (void *hashcat_ctx, LPAdapterInfo lpInfo, int iInputSize); +int hm_ADL_Overdrive5_Temperature_Get (void *hashcat_ctx, int iAdapterIndex, int iThermalControllerIndex, ADLTemperature *lpTemperature); +int hm_ADL_Overdrive6_Temperature_Get (void *hashcat_ctx, int iAdapterIndex, int *iTemperature); +int hm_ADL_Overdrive_CurrentActivity_Get (void *hashcat_ctx, int iAdapterIndex, ADLPMActivity *lpActivity); +int hm_ADL_Overdrive5_FanSpeed_Get (void *hashcat_ctx, int iAdapterIndex, int iThermalControllerIndex, ADLFanSpeedValue *lpFanSpeedValue); +int hm_ADL_Overdrive6_FanSpeed_Get (void *hashcat_ctx, int iAdapterIndex, ADLOD6FanSpeedInfo *lpFanSpeedInfo); +int hm_ADL_Overdrive_Caps (void *hashcat_ctx, int iAdapterIndex, int *od_supported, int *od_enabled, int *od_version); +int hm_ADL_Overdrive6_TargetTemperatureData_Get (void *hashcat_ctx, int iAdapterIndex, int *cur_temp, int *default_temp); + #endif // _EXT_ADL_H diff --git a/include/ext_nvapi.h b/include/ext_nvapi.h index 5ef6bdb1c..b72cd357c 100644 --- a/include/ext_nvapi.h +++ b/include/ext_nvapi.h @@ -239,4 +239,15 @@ typedef struct hm_nvapi_lib typedef hm_nvapi_lib_t NVAPI_PTR; +int nvapi_init (void *hashcat_ctx); +void nvapi_close (void *hashcat_ctx); +void hm_NvAPI_GetErrorMessage (NVAPI_PTR *nvapi, const NvAPI_Status NvAPI_rc, NvAPI_ShortString string); +int hm_NvAPI_Initialize (void *hashcat_ctx); +int hm_NvAPI_Unload (void *hashcat_ctx); +int hm_NvAPI_EnumPhysicalGPUs (void *hashcat_ctx, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount); +int hm_NvAPI_GPU_GetPerfPoliciesInfo (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 *perfPolicies_info); +int hm_NvAPI_GPU_GetPerfPoliciesStatus (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 *perfPolicies_status); +int hm_NvAPI_GPU_GetBusId (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId); +int hm_NvAPI_GPU_GetBusSlotId (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId); + #endif // _EXT_NVAPI_H diff --git a/include/ext_nvml.h b/include/ext_nvml.h index b2b11887d..74396810d 100644 --- a/include/ext_nvml.h +++ b/include/ext_nvml.h @@ -217,4 +217,20 @@ typedef struct hm_nvml_lib typedef hm_nvml_lib_t NVML_PTR; +int nvml_init (void *hashcat_ctx); +void nvml_close (void *hashcat_ctx); +const char *hm_NVML_nvmlErrorString (NVML_PTR *nvml, const nvmlReturn_t nvml_rc); + +int hm_NVML_nvmlInit (void *hashcat_ctx); +int hm_NVML_nvmlShutdown (void *hashcat_ctx); +int hm_NVML_nvmlDeviceGetCount (void *hashcat_ctx, unsigned int *deviceCount); +int hm_NVML_nvmlDeviceGetHandleByIndex (void *hashcat_ctx, unsigned int device_index, nvmlDevice_t *device); +int hm_NVML_nvmlDeviceGetTemperature (void *hashcat_ctx, nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp); +int hm_NVML_nvmlDeviceGetFanSpeed (void *hashcat_ctx, nvmlDevice_t device, unsigned int *speed); +int hm_NVML_nvmlDeviceGetUtilizationRates (void *hashcat_ctx, nvmlDevice_t device, nvmlUtilization_t *utilization); +int hm_NVML_nvmlDeviceGetClockInfo (void *hashcat_ctx, nvmlDevice_t device, nvmlClockType_t type, unsigned int *clockfreq); +int hm_NVML_nvmlDeviceGetTemperatureThreshold (void *hashcat_ctx, nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int *temp); +int hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (void *hashcat_ctx, nvmlDevice_t device, unsigned int *currLinkWidth); +int hm_NVML_nvmlDeviceGetPciInfo (void *hashcat_ctx, nvmlDevice_t device, nvmlPciInfo_t *pci); + #endif // _NVML_H diff --git a/include/ext_sysfs.h b/include/ext_sysfs.h index 8ce8cddd7..02dfd6177 100644 --- a/include/ext_sysfs.h +++ b/include/ext_sysfs.h @@ -6,6 +6,8 @@ #ifndef _EXT_SYSFS_H #define _EXT_SYSFS_H +#include + static const char SYS_BUS_PCI_DEVICES[] = "/sys/bus/pci/devices"; typedef int HM_ADAPTER_SYSFS; @@ -22,4 +24,15 @@ typedef struct hm_sysfs_lib typedef hm_sysfs_lib_t SYSFS_PTR; +bool sysfs_init (void *hashcat_ctx); +void sysfs_close (void *hashcat_ctx); +char *hm_SYSFS_get_syspath_device (void *hashcat_ctx, const int backend_device_idx); +char *hm_SYSFS_get_syspath_hwmon (void *hashcat_ctx, const int backend_device_idx); +int hm_SYSFS_get_fan_speed_current (void *hashcat_ctx, const int backend_device_idx, int *val); +int hm_SYSFS_get_temperature_current (void *hashcat_ctx, const int backend_device_idx, int *val); +int hm_SYSFS_get_pp_dpm_sclk (void *hashcat_ctx, const int backend_device_idx, int *val); +int hm_SYSFS_get_pp_dpm_mclk (void *hashcat_ctx, const int backend_device_idx, int *val); +int hm_SYSFS_get_pp_dpm_pcie (void *hashcat_ctx, const int backend_device_idx, int *val); +int hm_SYSFS_get_gpu_busy_percent (void *hashcat_ctx, const int backend_device_idx, int *val); + #endif // _EXT_SYSFS_H diff --git a/src/ext_ADL.c b/src/ext_ADL.c index 4d35ff9c8..e54420713 100644 --- a/src/ext_ADL.c +++ b/src/ext_ADL.c @@ -5,9 +5,285 @@ #include "common.h" #include "types.h" +#include "memory.h" +#include "event.h" #include "ext_ADL.h" +#include "dynloader.h" + void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize) { return malloc ((size_t) iSize); } + +int adl_init (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + memset (adl, 0, sizeof (ADL_PTR)); + + #if defined (_WIN) + adl->lib = hc_dlopen ("atiadlxx.dll"); + + if (!adl->lib) + { + adl->lib = hc_dlopen ("atiadlxy.dll"); + } + #elif defined (__CYGWIN__) + adl->lib = hc_dlopen ("atiadlxx.dll"); + + if (!adl->lib) + { + adl->lib = hc_dlopen ("atiadlxy.dll"); + } + #elif defined (_POSIX) + adl->lib = hc_dlopen ("libatiadlxx.so"); + #endif + + if (!adl->lib) + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "Load of ADL library failed. Proceeding without ADL HWMon enabled."); + + return -1; + } + + HC_LOAD_FUNC(adl, ADL_Main_Control_Destroy, ADL_MAIN_CONTROL_DESTROY, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Main_Control_Create, ADL_MAIN_CONTROL_CREATE, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Adapter_NumberOfAdapters_Get, ADL_ADAPTER_NUMBEROFADAPTERS_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Adapter_AdapterInfo_Get, ADL_ADAPTER_ADAPTERINFO_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Display_DisplayInfo_Get, ADL_DISPLAY_DISPLAYINFO_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Adapter_ID_Get, ADL_ADAPTER_ID_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Adapter_VideoBiosInfo_Get, ADL_ADAPTER_VIDEOBIOSINFO_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive5_ThermalDevices_Enum, ADL_OVERDRIVE5_THERMALDEVICES_ENUM, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive5_Temperature_Get, ADL_OVERDRIVE5_TEMPERATURE_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_Temperature_Get, ADL_OVERDRIVE6_TEMPERATURE_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive5_CurrentActivity_Get, ADL_OVERDRIVE5_CURRENTACTIVITY_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeedInfo_Get, ADL_OVERDRIVE5_FANSPEEDINFO_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeed_Get, ADL_OVERDRIVE5_FANSPEED_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_FanSpeed_Get, ADL_OVERDRIVE6_FANSPEED_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Adapter_Active_Get, ADL_ADAPTER_ACTIVE_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive_Caps, ADL_OVERDRIVE_CAPS, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_Capabilities_Get, ADL_OVERDRIVE6_CAPABILITIES_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_StateInfo_Get, ADL_OVERDRIVE6_STATEINFO_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_CurrentStatus_Get, ADL_OVERDRIVE6_CURRENTSTATUS_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_TargetTemperatureData_Get, ADL_OVERDRIVE6_TARGETTEMPERATUREDATA_GET, ADL, 0); + HC_LOAD_FUNC(adl, ADL_Overdrive6_TargetTemperatureRangeInfo_Get, ADL_OVERDRIVE6_TARGETTEMPERATURERANGEINFO_GET, ADL, 0); + + return 0; +} + +void adl_close (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + if (adl) + { + if (adl->lib) + hc_dlclose (adl->lib); + + hcfree (adl); + } +} + +int hm_ADL_Main_Control_Destroy (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Main_Control_Destroy (); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Main_Control_Destroy(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Main_Control_Create (void *hashcat_ctx, ADL_MAIN_MALLOC_CALLBACK callback, int iEnumConnectedAdapters) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Main_Control_Create (callback, iEnumConnectedAdapters); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Main_Control_Create(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Adapter_NumberOfAdapters_Get (void *hashcat_ctx, int *lpNumAdapters) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Adapter_NumberOfAdapters_Get (lpNumAdapters); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Adapter_NumberOfAdapters_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Adapter_AdapterInfo_Get (void *hashcat_ctx, LPAdapterInfo lpInfo, int iInputSize) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Adapter_AdapterInfo_Get (lpInfo, iInputSize); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Adapter_AdapterInfo_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive5_Temperature_Get (void *hashcat_ctx, int iAdapterIndex, int iThermalControllerIndex, ADLTemperature *lpTemperature) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive5_Temperature_Get (iAdapterIndex, iThermalControllerIndex, lpTemperature); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Overdrive5_Temperature_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive6_Temperature_Get (void *hashcat_ctx, int iAdapterIndex, int *iTemperature) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive6_Temperature_Get (iAdapterIndex, iTemperature); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Overdrive6_Temperature_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive_CurrentActivity_Get (void *hashcat_ctx, int iAdapterIndex, ADLPMActivity *lpActivity) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive5_CurrentActivity_Get (iAdapterIndex, lpActivity); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Overdrive5_CurrentActivity_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive5_FanSpeed_Get (void *hashcat_ctx, int iAdapterIndex, int iThermalControllerIndex, ADLFanSpeedValue *lpFanSpeedValue) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive5_FanSpeed_Get (iAdapterIndex, iThermalControllerIndex, lpFanSpeedValue); + + if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here + { + event_log_error (hashcat_ctx, "ADL_Overdrive5_FanSpeed_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive6_FanSpeed_Get (void *hashcat_ctx, int iAdapterIndex, ADLOD6FanSpeedInfo *lpFanSpeedInfo) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive6_FanSpeed_Get (iAdapterIndex, lpFanSpeedInfo); + + if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here + { + event_log_error (hashcat_ctx, "ADL_Overdrive6_FanSpeed_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive_Caps (void *hashcat_ctx, int iAdapterIndex, int *od_supported, int *od_enabled, int *od_version) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive_Caps (iAdapterIndex, od_supported, od_enabled, od_version); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Overdrive_Caps(): %d", ADL_rc); + + return -1; + } + + return 0; +} + +int hm_ADL_Overdrive6_TargetTemperatureData_Get (void *hashcat_ctx, int iAdapterIndex, int *cur_temp, int *default_temp) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; + + const int ADL_rc = adl->ADL_Overdrive6_TargetTemperatureData_Get (iAdapterIndex, cur_temp, default_temp); + + if (ADL_rc != ADL_OK) + { + event_log_error (hashcat_ctx, "ADL_Overdrive6_TargetTemperatureData_Get(): %d", ADL_rc); + + return -1; + } + + return 0; +} diff --git a/src/ext_nvapi.c b/src/ext_nvapi.c index 4fad053ff..d4607ad84 100644 --- a/src/ext_nvapi.c +++ b/src/ext_nvapi.c @@ -5,4 +5,237 @@ #include "common.h" #include "types.h" +#include "memory.h" +#include "event.h" #include "ext_nvapi.h" + +#include "dynloader.h" + +int nvapi_init (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + memset (nvapi, 0, sizeof (NVAPI_PTR)); + + #if defined (_WIN) + + #if defined (_WIN64) + nvapi->lib = hc_dlopen ("nvapi64.dll"); + #else + nvapi->lib = hc_dlopen ("nvapi.dll"); + #endif + + #else + + #if defined (__CYGWIN__) + + #if defined (__x86_x64__) + nvapi->lib = hc_dlopen ("nvapi64.dll"); + #else + nvapi->lib = hc_dlopen ("nvapi.dll"); + #endif + + #else + nvapi->lib = hc_dlopen ("nvapi.so"); // uhm yes, but .. yeah + #endif + + #endif + + if (!nvapi->lib) + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "Load of NVAPI library failed. Proceeding without NVAPI HWMon enabled."); + + return -1; + } + + HC_LOAD_FUNC(nvapi, nvapi_QueryInterface, NVAPI_QUERYINTERFACE, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_Initialize, NVAPI_INITIALIZE, nvapi_QueryInterface, 0x0150E828U, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_Unload, NVAPI_UNLOAD, nvapi_QueryInterface, 0xD22BDD7EU, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_GetErrorMessage, NVAPI_GETERRORMESSAGE, nvapi_QueryInterface, 0x6C2D048CU, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_EnumPhysicalGPUs, NVAPI_ENUMPHYSICALGPUS, nvapi_QueryInterface, 0xE5AC921FU, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetPerfPoliciesInfo, NVAPI_GPU_GETPERFPOLICIESINFO, nvapi_QueryInterface, 0x409D9841U, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetPerfPoliciesStatus, NVAPI_GPU_GETPERFPOLICIESSTATUS, nvapi_QueryInterface, 0x3D358A0CU, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetBusId, NVAPI_GPU_GETBUSID, nvapi_QueryInterface, 0x1BE0B8E5U, NVAPI, 0); + HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetBusSlotId, NVAPI_GPU_GETBUSSLOTID, nvapi_QueryInterface, 0x2A0A350FU, NVAPI, 0); + + return 0; +} + +void nvapi_close (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + if (nvapi) + { + if (nvapi->lib) + hc_dlclose (nvapi->lib); + + hcfree (nvapi); + } +} + +void hm_NvAPI_GetErrorMessage (NVAPI_PTR *nvapi, const NvAPI_Status NvAPI_rc, NvAPI_ShortString string) +{ + nvapi->NvAPI_GetErrorMessage (NvAPI_rc, string); +} + +int hm_NvAPI_Initialize (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_Initialize (); + + if (NvAPI_rc == NVAPI_LIBRARY_NOT_FOUND) return -1; + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_Initialize(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NvAPI_Unload (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_Unload (); + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_Unload(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NvAPI_EnumPhysicalGPUs (void *hashcat_ctx, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_EnumPhysicalGPUs (nvGPUHandle, pGpuCount); + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_EnumPhysicalGPUs(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NvAPI_GPU_GetPerfPoliciesInfo (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 *perfPolicies_info) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetPerfPoliciesInfo (hPhysicalGpu, perfPolicies_info); + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_GPU_GetPerfPoliciesInfo(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NvAPI_GPU_GetPerfPoliciesStatus (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 *perfPolicies_status) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetPerfPoliciesStatus (hPhysicalGpu, perfPolicies_status); + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_GPU_GetPerfPoliciesStatus(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NvAPI_GPU_GetBusId (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetBusId (hPhysicalGpu, pBusId); + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_GPU_GetBusId(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NvAPI_GPU_GetBusSlotId (void *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; + + const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetBusSlotId (hPhysicalGpu, pBusSlotId); + + if (NvAPI_rc != NVAPI_OK) + { + NvAPI_ShortString string = { 0 }; + + hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); + + event_log_error (hashcat_ctx, "NvAPI_GPU_GetBusSlotId(): %s", string); + + return -1; + } + + return 0; +} diff --git a/src/ext_nvml.c b/src/ext_nvml.c index 416b02bb4..25911df14 100644 --- a/src/ext_nvml.c +++ b/src/ext_nvml.c @@ -5,4 +5,390 @@ #include "common.h" #include "types.h" +#include "memory.h" +#include "shared.h" +#include "event.h" #include "ext_nvml.h" + +#include "dynloader.h" + +#if defined (__CYGWIN__) +#include +#endif + +int nvml_init (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + memset (nvml, 0, sizeof (NVML_PTR)); + + #if defined (_WIN) + + nvml->lib = hc_dlopen ("nvml.dll"); + + if (!nvml->lib) + { + DWORD BufferSize = 1024; + + DWORD Type = REG_SZ; + + char *Buffer = (char *) hcmalloc (BufferSize + 1); + + HKEY hKey = 0; + + if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE\\NVIDIA Corporation\\Global\\NVSMI", 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) + { + if (RegQueryValueExA (hKey, "NVSMIPATH", NULL, &Type, (LPBYTE)Buffer, &BufferSize) == ERROR_SUCCESS) + { + Buffer[BufferSize] = 0; + } + else + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "NVML library load failed. Proceeding without NVML HWMon enabled."); + + return -1; + } + + RegCloseKey (hKey); + } + else + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "NVML library load failed. Proceeding without NVML HWMon enabled."); + + return -1; + } + + strcat (Buffer, "\\nvml.dll"); + + nvml->lib = hc_dlopen (Buffer); + + hcfree (Buffer); + } + + #elif defined (__CYGWIN__) + + nvml->lib = hc_dlopen ("nvml.dll"); + + if (!nvml->lib) + { + HCFILE nvml_lib; + + if (hc_fopen (&nvml_lib, "/proc/registry/HKEY_LOCAL_MACHINE/SOFTWARE/NVIDIA Corporation/Global/NVSMI/NVSMIPATH", "rb") == false) + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "NVML library load failed: %m. Proceeding without NVML HWMon enabled."); + + return -1; + } + + char *nvml_winpath, *nvml_cygpath; + + nvml_winpath = (char *) hcmalloc (100); + + hc_fread (nvml_winpath, 100, 1, &nvml_lib); + + hc_fclose (&nvml_lib); + + ssize_t size = cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_PROC_CYGDRIVE, nvml_winpath, NULL, 0); + + if (size > 0) + { + nvml_cygpath = (char *) hcmalloc (size + 9); + + cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_PROC_CYGDRIVE, nvml_winpath, nvml_cygpath, size); + } + else + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "Could not find NVML on this system. Proceeding without NVML HWMon enabled."); + + return -1; + } + + strcat (nvml_cygpath, "/nvml.dll"); + + nvml->lib = hc_dlopen (nvml_cygpath); + } + + #elif defined (_POSIX) + + nvml->lib = hc_dlopen ("libnvidia-ml.so"); + + if (!nvml->lib) + { + nvml->lib = hc_dlopen ("libnvidia-ml.so.1"); + } + + #endif + + if (!nvml->lib) + { + //if (user_options->quiet == false) + // event_log_error (hashcat_ctx, "NVML library load failed. Proceeding without NVML HWMon enabled."); + + return -1; + } + + HC_LOAD_FUNC(nvml, nvmlErrorString, NVML_ERROR_STRING, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlInit, NVML_INIT, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlShutdown, NVML_SHUTDOWN, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetCount, NVML_DEVICE_GET_COUNT, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetName, NVML_DEVICE_GET_NAME, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetHandleByIndex, NVML_DEVICE_GET_HANDLE_BY_INDEX, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetTemperature, NVML_DEVICE_GET_TEMPERATURE, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetFanSpeed, NVML_DEVICE_GET_FAN_SPEED, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetUtilizationRates, NVML_DEVICE_GET_UTILIZATION_RATES, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetClockInfo, NVML_DEVICE_GET_CLOCKINFO, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetTemperatureThreshold, NVML_DEVICE_GET_THRESHOLD, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrPcieLinkGeneration, NVML_DEVICE_GET_CURRPCIELINKGENERATION, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrPcieLinkWidth, NVML_DEVICE_GET_CURRPCIELINKWIDTH, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrentClocksThrottleReasons, NVML_DEVICE_GET_CURRENTCLOCKSTHROTTLEREASONS, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetSupportedClocksThrottleReasons, NVML_DEVICE_GET_SUPPORTEDCLOCKSTHROTTLEREASONS, NVML, 0); + HC_LOAD_FUNC(nvml, nvmlDeviceGetPciInfo, NVML_DEVICE_GET_PCIINFO, NVML, 0); + + return 0; +} + +void nvml_close (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + if (nvml) + { + if (nvml->lib) + hc_dlclose (nvml->lib); + + hcfree (nvml); + } +} + +const char *hm_NVML_nvmlErrorString (NVML_PTR *nvml, const nvmlReturn_t nvml_rc) +{ + return nvml->nvmlErrorString (nvml_rc); +} + +int hm_NVML_nvmlInit (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = (nvmlReturn_t) nvml->nvmlInit (); + + if (nvml_rc != NVML_SUCCESS && nvml_rc != NVML_ERROR_DRIVER_NOT_LOADED) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlInit(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlShutdown (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = (nvmlReturn_t) nvml->nvmlShutdown (); + + if (nvml_rc != NVML_SUCCESS && nvml_rc != NVML_ERROR_DRIVER_NOT_LOADED) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlShutdown(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetCount (void *hashcat_ctx, unsigned int *deviceCount) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCount (deviceCount); + + if (nvml_rc != NVML_SUCCESS && nvml_rc != NVML_ERROR_DRIVER_NOT_LOADED) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetCount(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetHandleByIndex (void *hashcat_ctx, unsigned int device_index, nvmlDevice_t *device) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetHandleByIndex (device_index, device); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetHandleByIndex(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetTemperature (void *hashcat_ctx, nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetTemperature (device, sensorType, temp); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetTemperature(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetFanSpeed (void *hashcat_ctx, nvmlDevice_t device, unsigned int *speed) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetFanSpeed (device, speed); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetFanSpeed(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetUtilizationRates (void *hashcat_ctx, nvmlDevice_t device, nvmlUtilization_t *utilization) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetUtilizationRates (device, utilization); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetUtilizationRates(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetClockInfo (void *hashcat_ctx, nvmlDevice_t device, nvmlClockType_t type, unsigned int *clockfreq) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetClockInfo (device, type, clockfreq); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetClockInfo(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetTemperatureThreshold (void *hashcat_ctx, nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int *temp) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetTemperatureThreshold (device, thresholdType, temp); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetTemperatureThreshold(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (void *hashcat_ctx, nvmlDevice_t device, unsigned int *currLinkWidth) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCurrPcieLinkWidth (device, currLinkWidth); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetCurrPcieLinkWidth(): %s", string); + + return -1; + } + + return 0; +} + +int hm_NVML_nvmlDeviceGetPciInfo (void *hashcat_ctx, nvmlDevice_t device, nvmlPciInfo_t *pci) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; + + const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetPciInfo (device, pci); + + if (nvml_rc != NVML_SUCCESS) + { + const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); + + event_log_error (hashcat_ctx, "nvmlDeviceGetPciInfo(): %s", string); + + return -1; + } + + return 0; +} diff --git a/src/ext_sysfs.c b/src/ext_sysfs.c index b4898950d..fc50ea388 100644 --- a/src/ext_sysfs.c +++ b/src/ext_sysfs.c @@ -4,4 +4,440 @@ */ #include "common.h" +#include "types.h" +#include "memory.h" +#include "shared.h" +#include "event.h" +#include "folder.h" #include "ext_sysfs.h" + +bool sysfs_init (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + SYSFS_PTR *sysfs = (SYSFS_PTR *) hwmon_ctx->hm_sysfs; + + memset (sysfs, 0, sizeof (SYSFS_PTR)); + + char *path; + + hc_asprintf (&path, "%s", SYS_BUS_PCI_DEVICES); + + const bool r = hc_path_read (path); + + hcfree (path); + + return r; +} + +void sysfs_close (void *hashcat_ctx) +{ + hwmon_ctx_t *hwmon_ctx = ((hashcat_ctx_t *) hashcat_ctx)->hwmon_ctx; + + SYSFS_PTR *sysfs = (SYSFS_PTR *) hwmon_ctx->hm_sysfs; + + if (sysfs) + { + hcfree (sysfs); + } +} + +char *hm_SYSFS_get_syspath_device (void *hashcat_ctx, const int backend_device_idx) +{ + backend_ctx_t *backend_ctx = ((hashcat_ctx_t *) hashcat_ctx)->backend_ctx; + + hc_device_param_t *device_param = &backend_ctx->devices_param[backend_device_idx]; + + char *syspath; + + hc_asprintf (&syspath, "%s/0000:%02x:%02x.%01x", SYS_BUS_PCI_DEVICES, device_param->pcie_bus, device_param->pcie_device, device_param->pcie_function); + + return syspath; +} + +char *hm_SYSFS_get_syspath_hwmon (void *hashcat_ctx, const int backend_device_idx) +{ + char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) + { + event_log_error (hashcat_ctx, "hm_SYSFS_get_syspath_device() failed."); + + return NULL; + } + + char *hwmon = (char *) hcmalloc (HCBUFSIZ_TINY); + + snprintf (hwmon, HCBUFSIZ_TINY, "%s/hwmon", syspath); + + char *hwmonN = first_file_in_directory (hwmon); + + if (hwmonN == NULL) + { + event_log_error (hashcat_ctx, "First_file_in_directory() failed."); + + hcfree (syspath); + + hcfree (hwmon); + hcfree (hwmonN); + + return NULL; + } + + snprintf (hwmon, HCBUFSIZ_TINY, "%s/hwmon/%s", syspath, hwmonN); + + hcfree (syspath); + + hcfree (hwmonN); + + return hwmon; +} + +int hm_SYSFS_get_fan_speed_current (void *hashcat_ctx, const int backend_device_idx, int *val) +{ + char *syspath = hm_SYSFS_get_syspath_hwmon (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) return -1; + + char *path_cur; + char *path_max; + + hc_asprintf (&path_cur, "%s/pwm1", syspath); + hc_asprintf (&path_max, "%s/pwm1_max", syspath); + + hcfree (syspath); + + HCFILE fp_cur; + + if (hc_fopen (&fp_cur, path_cur, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path_cur, strerror (errno)); + + hcfree (path_cur); + hcfree (path_max); + + return -1; + } + + int pwm1_cur = 0; + + if (hc_fscanf (&fp_cur, "%d", &pwm1_cur) != 1) + { + hc_fclose (&fp_cur); + + event_log_error (hashcat_ctx, "%s: unexpected data.", path_cur); + + hcfree (path_cur); + hcfree (path_max); + + return -1; + } + + hc_fclose (&fp_cur); + + HCFILE fp_max; + + if (hc_fopen (&fp_max, path_max, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path_max, strerror (errno)); + + hcfree (path_cur); + hcfree (path_max); + + return -1; + } + + int pwm1_max = 0; + + if (hc_fscanf (&fp_max, "%d", &pwm1_max) != 1) + { + hc_fclose (&fp_max); + + event_log_error (hashcat_ctx, "%s: unexpected data.", path_max); + + hcfree (path_cur); + hcfree (path_max); + + return -1; + } + + hc_fclose (&fp_max); + + if (pwm1_max == 0) + { + event_log_error (hashcat_ctx, "%s: pwm1_max cannot be 0.", path_max); + + hcfree (path_cur); + hcfree (path_max); + + return -1; + } + + const float p1 = (float) pwm1_max / 100.0F; + + const float pwm1_percent = (float) pwm1_cur / p1; + + *val = (int) pwm1_percent; + + hcfree (path_cur); + hcfree (path_max); + + return 0; +} + +int hm_SYSFS_get_temperature_current (void *hashcat_ctx, const int backend_device_idx, int *val) +{ + char *syspath = hm_SYSFS_get_syspath_hwmon (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) return -1; + + char *path; + + hc_asprintf (&path, "%s/temp1_input", syspath); + + hcfree (syspath); + + HCFILE fp; + + if (hc_fopen (&fp, path, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); + + hcfree (path); + + return -1; + } + + int temperature = 0; + + if (hc_fscanf (&fp, "%d", &temperature) != 1) + { + hc_fclose (&fp); + + event_log_error (hashcat_ctx, "%s: unexpected data.", path); + + hcfree (path); + + return -1; + } + + hc_fclose (&fp); + + *val = temperature / 1000; + + hcfree (path); + + return 0; +} + +int hm_SYSFS_get_pp_dpm_sclk (void *hashcat_ctx, const int backend_device_idx, int *val) +{ + char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) return -1; + + char *path; + + hc_asprintf (&path, "%s/pp_dpm_sclk", syspath); + + hcfree (syspath); + + HCFILE fp; + + if (hc_fopen (&fp, path, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); + + hcfree (path); + + return -1; + } + + int clockfreq = 0; + + while (!hc_feof (&fp)) + { + char buf[HCBUFSIZ_TINY] = { 0 }; + + char *ptr = hc_fgets (buf, sizeof (buf), &fp); + + if (ptr == NULL) continue; + + size_t len = strlen (ptr); + + if (len < 2) continue; + + if (ptr[len - 2] != '*') continue; + + int profile = 0; + + int rc = sscanf (ptr, "%d: %dMHz", &profile, &clockfreq); + + if (rc == 2) break; + } + + hc_fclose (&fp); + + *val = clockfreq; + + hcfree (path); + + return 0; +} + +int hm_SYSFS_get_pp_dpm_mclk (void *hashcat_ctx, const int backend_device_idx, int *val) +{ + char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) return -1; + + char *path; + + hc_asprintf (&path, "%s/pp_dpm_mclk", syspath); + + hcfree (syspath); + + HCFILE fp; + + if (hc_fopen (&fp, path, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); + + hcfree (path); + + return -1; + } + + int clockfreq = 0; + + while (!hc_feof (&fp)) + { + char buf[HCBUFSIZ_TINY]; + + char *ptr = hc_fgets (buf, sizeof (buf), &fp); + + if (ptr == NULL) continue; + + size_t len = strlen (ptr); + + if (len < 2) continue; + + if (ptr[len - 2] != '*') continue; + + int profile = 0; + + int rc = sscanf (ptr, "%d: %dMHz", &profile, &clockfreq); + + if (rc == 2) break; + } + + hc_fclose (&fp); + + *val = clockfreq; + + hcfree (path); + + return 0; +} + +int hm_SYSFS_get_pp_dpm_pcie (void *hashcat_ctx, const int backend_device_idx, int *val) +{ + char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) return -1; + + char *path; + + hc_asprintf (&path, "%s/current_link_width", syspath); + + hcfree (syspath); + + HCFILE fp; + + if (hc_fopen (&fp, path, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); + + hcfree (path); + + return -1; + } + + int lanes = 0; + + while (!hc_feof (&fp)) + { + char buf[HCBUFSIZ_TINY]; + + char *ptr = hc_fgets (buf, sizeof (buf), &fp); + + if (ptr == NULL) continue; + + size_t len = strlen (ptr); + + if (len < 2) continue; + + int rc = sscanf (ptr, "%d", &lanes); + + if (rc == 1) break; + } + + hc_fclose (&fp); + + *val = lanes; + + hcfree (path); + + return 0; +} + +int hm_SYSFS_get_gpu_busy_percent (void *hashcat_ctx, const int backend_device_idx, int *val) +{ + char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); + + if (syspath == NULL) return -1; + + char *path; + + hc_asprintf (&path, "%s/gpu_busy_percent", syspath); + + hcfree (syspath); + + HCFILE fp; + + if (hc_fopen (&fp, path, "r") == false) + { + event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); + + hcfree (path); + + return -1; + } + + int util = 0; + + while (!hc_feof (&fp)) + { + char buf[HCBUFSIZ_TINY]; + + char *ptr = hc_fgets (buf, sizeof (buf), &fp); + + if (ptr == NULL) continue; + + size_t len = strlen (ptr); + + if (len < 1) continue; + + int rc = sscanf (ptr, "%d", &util); + + if (rc == 1) break; + } + + hc_fclose (&fp); + + *val = util; + + hcfree (path); + + return 0; +} diff --git a/src/hwmon.c b/src/hwmon.c index 502a606b6..a37faecc0 100644 --- a/src/hwmon.c +++ b/src/hwmon.c @@ -12,1323 +12,6 @@ #include "folder.h" #include "hwmon.h" -// sysfs functions - -static bool sysfs_init (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - SYSFS_PTR *sysfs = (SYSFS_PTR *) hwmon_ctx->hm_sysfs; - - memset (sysfs, 0, sizeof (SYSFS_PTR)); - - char *path; - - hc_asprintf (&path, "%s", SYS_BUS_PCI_DEVICES); - - const bool r = hc_path_read (path); - - hcfree (path); - - return r; -} - -static void sysfs_close (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - SYSFS_PTR *sysfs = (SYSFS_PTR *) hwmon_ctx->hm_sysfs; - - if (sysfs) - { - hcfree (sysfs); - } -} - -static char *hm_SYSFS_get_syspath_device (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx) -{ - backend_ctx_t *backend_ctx = hashcat_ctx->backend_ctx; - - hc_device_param_t *device_param = &backend_ctx->devices_param[backend_device_idx]; - - char *syspath; - - hc_asprintf (&syspath, "%s/0000:%02x:%02x.%01x", SYS_BUS_PCI_DEVICES, device_param->pcie_bus, device_param->pcie_device, device_param->pcie_function); - - return syspath; -} - -static char *hm_SYSFS_get_syspath_hwmon (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx) -{ - char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) - { - event_log_error (hashcat_ctx, "hm_SYSFS_get_syspath_device() failed."); - - return NULL; - } - - char *hwmon = (char *) hcmalloc (HCBUFSIZ_TINY); - - snprintf (hwmon, HCBUFSIZ_TINY, "%s/hwmon", syspath); - - char *hwmonN = first_file_in_directory (hwmon); - - if (hwmonN == NULL) - { - event_log_error (hashcat_ctx, "First_file_in_directory() failed."); - - hcfree (syspath); - - hcfree (hwmon); - hcfree (hwmonN); - - return NULL; - } - - snprintf (hwmon, HCBUFSIZ_TINY, "%s/hwmon/%s", syspath, hwmonN); - - hcfree (syspath); - - hcfree (hwmonN); - - return hwmon; -} - -static int hm_SYSFS_get_fan_speed_current (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx, int *val) -{ - char *syspath = hm_SYSFS_get_syspath_hwmon (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) return -1; - - char *path_cur; - char *path_max; - - hc_asprintf (&path_cur, "%s/pwm1", syspath); - hc_asprintf (&path_max, "%s/pwm1_max", syspath); - - hcfree (syspath); - - HCFILE fp_cur; - - if (hc_fopen (&fp_cur, path_cur, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path_cur, strerror (errno)); - - hcfree (path_cur); - hcfree (path_max); - - return -1; - } - - int pwm1_cur = 0; - - if (hc_fscanf (&fp_cur, "%d", &pwm1_cur) != 1) - { - hc_fclose (&fp_cur); - - event_log_error (hashcat_ctx, "%s: unexpected data.", path_cur); - - hcfree (path_cur); - hcfree (path_max); - - return -1; - } - - hc_fclose (&fp_cur); - - HCFILE fp_max; - - if (hc_fopen (&fp_max, path_max, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path_max, strerror (errno)); - - hcfree (path_cur); - hcfree (path_max); - - return -1; - } - - int pwm1_max = 0; - - if (hc_fscanf (&fp_max, "%d", &pwm1_max) != 1) - { - hc_fclose (&fp_max); - - event_log_error (hashcat_ctx, "%s: unexpected data.", path_max); - - hcfree (path_cur); - hcfree (path_max); - - return -1; - } - - hc_fclose (&fp_max); - - if (pwm1_max == 0) - { - event_log_error (hashcat_ctx, "%s: pwm1_max cannot be 0.", path_max); - - hcfree (path_cur); - hcfree (path_max); - - return -1; - } - - const float p1 = (float) pwm1_max / 100.0F; - - const float pwm1_percent = (float) pwm1_cur / p1; - - *val = (int) pwm1_percent; - - hcfree (path_cur); - hcfree (path_max); - - return 0; -} - -static int hm_SYSFS_get_temperature_current (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx, int *val) -{ - char *syspath = hm_SYSFS_get_syspath_hwmon (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) return -1; - - char *path; - - hc_asprintf (&path, "%s/temp1_input", syspath); - - hcfree (syspath); - - HCFILE fp; - - if (hc_fopen (&fp, path, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); - - hcfree (path); - - return -1; - } - - int temperature = 0; - - if (hc_fscanf (&fp, "%d", &temperature) != 1) - { - hc_fclose (&fp); - - event_log_error (hashcat_ctx, "%s: unexpected data.", path); - - hcfree (path); - - return -1; - } - - hc_fclose (&fp); - - *val = temperature / 1000; - - hcfree (path); - - return 0; -} - -static int hm_SYSFS_get_pp_dpm_sclk (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx, int *val) -{ - char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) return -1; - - char *path; - - hc_asprintf (&path, "%s/pp_dpm_sclk", syspath); - - hcfree (syspath); - - HCFILE fp; - - if (hc_fopen (&fp, path, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); - - hcfree (path); - - return -1; - } - - int clockfreq = 0; - - while (!hc_feof (&fp)) - { - char buf[HCBUFSIZ_TINY] = { 0 }; - - char *ptr = hc_fgets (buf, sizeof (buf), &fp); - - if (ptr == NULL) continue; - - size_t len = strlen (ptr); - - if (len < 2) continue; - - if (ptr[len - 2] != '*') continue; - - int profile = 0; - - int rc = sscanf (ptr, "%d: %dMHz", &profile, &clockfreq); - - if (rc == 2) break; - } - - hc_fclose (&fp); - - *val = clockfreq; - - hcfree (path); - - return 0; -} - -static int hm_SYSFS_get_pp_dpm_mclk (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx, int *val) -{ - char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) return -1; - - char *path; - - hc_asprintf (&path, "%s/pp_dpm_mclk", syspath); - - hcfree (syspath); - - HCFILE fp; - - if (hc_fopen (&fp, path, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); - - hcfree (path); - - return -1; - } - - int clockfreq = 0; - - while (!hc_feof (&fp)) - { - char buf[HCBUFSIZ_TINY]; - - char *ptr = hc_fgets (buf, sizeof (buf), &fp); - - if (ptr == NULL) continue; - - size_t len = strlen (ptr); - - if (len < 2) continue; - - if (ptr[len - 2] != '*') continue; - - int profile = 0; - - int rc = sscanf (ptr, "%d: %dMHz", &profile, &clockfreq); - - if (rc == 2) break; - } - - hc_fclose (&fp); - - *val = clockfreq; - - hcfree (path); - - return 0; -} - -static int hm_SYSFS_get_pp_dpm_pcie (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx, int *val) -{ - char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) return -1; - - char *path; - - hc_asprintf (&path, "%s/current_link_width", syspath); - - hcfree (syspath); - - HCFILE fp; - - if (hc_fopen (&fp, path, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); - - hcfree (path); - - return -1; - } - - int lanes = 0; - - while (!hc_feof (&fp)) - { - char buf[HCBUFSIZ_TINY]; - - char *ptr = hc_fgets (buf, sizeof (buf), &fp); - - if (ptr == NULL) continue; - - size_t len = strlen (ptr); - - if (len < 2) continue; - - int rc = sscanf (ptr, "%d", &lanes); - - if (rc == 1) break; - } - - hc_fclose (&fp); - - *val = lanes; - - hcfree (path); - - return 0; -} - -static int hm_SYSFS_get_gpu_busy_percent (hashcat_ctx_t *hashcat_ctx, const int backend_device_idx, int *val) -{ - char *syspath = hm_SYSFS_get_syspath_device (hashcat_ctx, backend_device_idx); - - if (syspath == NULL) return -1; - - char *path; - - hc_asprintf (&path, "%s/gpu_busy_percent", syspath); - - hcfree (syspath); - - HCFILE fp; - - if (hc_fopen (&fp, path, "r") == false) - { - event_log_error (hashcat_ctx, "%s: %s", path, strerror (errno)); - - hcfree (path); - - return -1; - } - - int util = 0; - - while (!hc_feof (&fp)) - { - char buf[HCBUFSIZ_TINY]; - - char *ptr = hc_fgets (buf, sizeof (buf), &fp); - - if (ptr == NULL) continue; - - size_t len = strlen (ptr); - - if (len < 1) continue; - - int rc = sscanf (ptr, "%d", &util); - - if (rc == 1) break; - } - - hc_fclose (&fp); - - *val = util; - - hcfree (path); - - return 0; -} - -// nvml functions - -static int nvml_init (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - memset (nvml, 0, sizeof (NVML_PTR)); - - #if defined (_WIN) - - nvml->lib = hc_dlopen ("nvml.dll"); - - if (!nvml->lib) - { - DWORD BufferSize = 1024; - - DWORD Type = REG_SZ; - - char *Buffer = (char *) hcmalloc (BufferSize + 1); - - HKEY hKey = 0; - - if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, "SOFTWARE\\NVIDIA Corporation\\Global\\NVSMI", 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) - { - if (RegQueryValueExA (hKey, "NVSMIPATH", NULL, &Type, (LPBYTE)Buffer, &BufferSize) == ERROR_SUCCESS) - { - Buffer[BufferSize] = 0; - } - else - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "NVML library load failed. Proceeding without NVML HWMon enabled."); - - return -1; - } - - RegCloseKey (hKey); - } - else - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "NVML library load failed. Proceeding without NVML HWMon enabled."); - - return -1; - } - - strcat (Buffer, "\\nvml.dll"); - - nvml->lib = hc_dlopen (Buffer); - - hcfree (Buffer); - } - - #elif defined (__CYGWIN__) - - nvml->lib = hc_dlopen ("nvml.dll"); - - if (!nvml->lib) - { - HCFILE nvml_lib; - - if (hc_fopen (&nvml_lib, "/proc/registry/HKEY_LOCAL_MACHINE/SOFTWARE/NVIDIA Corporation/Global/NVSMI/NVSMIPATH", "rb") == false) - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "NVML library load failed: %m. Proceeding without NVML HWMon enabled."); - - return -1; - } - - char *nvml_winpath, *nvml_cygpath; - - nvml_winpath = (char *) hcmalloc (100); - - hc_fread (nvml_winpath, 100, 1, &nvml_lib); - - hc_fclose (&nvml_lib); - - ssize_t size = cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_PROC_CYGDRIVE, nvml_winpath, NULL, 0); - - if (size > 0) - { - nvml_cygpath = (char *) hcmalloc (size + 9); - - cygwin_conv_path (CCP_WIN_A_TO_POSIX | CCP_PROC_CYGDRIVE, nvml_winpath, nvml_cygpath, size); - } - else - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "Could not find NVML on this system. Proceeding without NVML HWMon enabled."); - - return -1; - } - - strcat (nvml_cygpath, "/nvml.dll"); - - nvml->lib = hc_dlopen (nvml_cygpath); - } - - #elif defined (_POSIX) - - nvml->lib = hc_dlopen ("libnvidia-ml.so"); - - if (!nvml->lib) - { - nvml->lib = hc_dlopen ("libnvidia-ml.so.1"); - } - - #endif - - if (!nvml->lib) - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "NVML library load failed. Proceeding without NVML HWMon enabled."); - - return -1; - } - - HC_LOAD_FUNC(nvml, nvmlErrorString, NVML_ERROR_STRING, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlInit, NVML_INIT, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlShutdown, NVML_SHUTDOWN, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetCount, NVML_DEVICE_GET_COUNT, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetName, NVML_DEVICE_GET_NAME, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetHandleByIndex, NVML_DEVICE_GET_HANDLE_BY_INDEX, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetTemperature, NVML_DEVICE_GET_TEMPERATURE, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetFanSpeed, NVML_DEVICE_GET_FAN_SPEED, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetUtilizationRates, NVML_DEVICE_GET_UTILIZATION_RATES, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetClockInfo, NVML_DEVICE_GET_CLOCKINFO, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetTemperatureThreshold, NVML_DEVICE_GET_THRESHOLD, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrPcieLinkGeneration, NVML_DEVICE_GET_CURRPCIELINKGENERATION, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrPcieLinkWidth, NVML_DEVICE_GET_CURRPCIELINKWIDTH, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetCurrentClocksThrottleReasons, NVML_DEVICE_GET_CURRENTCLOCKSTHROTTLEREASONS, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetSupportedClocksThrottleReasons, NVML_DEVICE_GET_SUPPORTEDCLOCKSTHROTTLEREASONS, NVML, 0); - HC_LOAD_FUNC(nvml, nvmlDeviceGetPciInfo, NVML_DEVICE_GET_PCIINFO, NVML, 0); - - return 0; -} - -static void nvml_close (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - if (nvml) - { - if (nvml->lib) - hc_dlclose (nvml->lib); - - hcfree (nvml); - } -} - -static const char *hm_NVML_nvmlErrorString (NVML_PTR *nvml, const nvmlReturn_t nvml_rc) -{ - return nvml->nvmlErrorString (nvml_rc); -} - -static int hm_NVML_nvmlInit (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = (nvmlReturn_t) nvml->nvmlInit (); - - if (nvml_rc != NVML_SUCCESS && nvml_rc != NVML_ERROR_DRIVER_NOT_LOADED) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlInit(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlShutdown (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = (nvmlReturn_t) nvml->nvmlShutdown (); - - if (nvml_rc != NVML_SUCCESS && nvml_rc != NVML_ERROR_DRIVER_NOT_LOADED) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlShutdown(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetCount (hashcat_ctx_t *hashcat_ctx, unsigned int *deviceCount) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCount (deviceCount); - - if (nvml_rc != NVML_SUCCESS && nvml_rc != NVML_ERROR_DRIVER_NOT_LOADED) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetCount(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetHandleByIndex (hashcat_ctx_t *hashcat_ctx, unsigned int device_index, nvmlDevice_t *device) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetHandleByIndex (device_index, device); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetHandleByIndex(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetTemperature (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetTemperature (device, sensorType, temp); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetTemperature(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetFanSpeed (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, unsigned int *speed) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetFanSpeed (device, speed); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetFanSpeed(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetUtilizationRates (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, nvmlUtilization_t *utilization) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetUtilizationRates (device, utilization); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetUtilizationRates(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetClockInfo (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, nvmlClockType_t type, unsigned int *clockfreq) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetClockInfo (device, type, clockfreq); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetClockInfo(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetTemperatureThreshold (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int *temp) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetTemperatureThreshold (device, thresholdType, temp); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetTemperatureThreshold(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, unsigned int *currLinkWidth) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetCurrPcieLinkWidth (device, currLinkWidth); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetCurrPcieLinkWidth(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NVML_nvmlDeviceGetPciInfo (hashcat_ctx_t *hashcat_ctx, nvmlDevice_t device, nvmlPciInfo_t *pci) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVML_PTR *nvml = (NVML_PTR *) hwmon_ctx->hm_nvml; - - const nvmlReturn_t nvml_rc = nvml->nvmlDeviceGetPciInfo (device, pci); - - if (nvml_rc != NVML_SUCCESS) - { - const char *string = hm_NVML_nvmlErrorString (nvml, nvml_rc); - - event_log_error (hashcat_ctx, "nvmlDeviceGetPciInfo(): %s", string); - - return -1; - } - - return 0; -} - -// nvapi functions - -static int nvapi_init (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - memset (nvapi, 0, sizeof (NVAPI_PTR)); - - #if defined (_WIN) - - #if defined (_WIN64) - nvapi->lib = hc_dlopen ("nvapi64.dll"); - #else - nvapi->lib = hc_dlopen ("nvapi.dll"); - #endif - - #else - - #if defined (__CYGWIN__) - - #if defined (__x86_x64__) - nvapi->lib = hc_dlopen ("nvapi64.dll"); - #else - nvapi->lib = hc_dlopen ("nvapi.dll"); - #endif - - #else - nvapi->lib = hc_dlopen ("nvapi.so"); // uhm yes, but .. yeah - #endif - - #endif - - if (!nvapi->lib) - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "Load of NVAPI library failed. Proceeding without NVAPI HWMon enabled."); - - return -1; - } - - HC_LOAD_FUNC(nvapi, nvapi_QueryInterface, NVAPI_QUERYINTERFACE, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_Initialize, NVAPI_INITIALIZE, nvapi_QueryInterface, 0x0150E828U, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_Unload, NVAPI_UNLOAD, nvapi_QueryInterface, 0xD22BDD7EU, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_GetErrorMessage, NVAPI_GETERRORMESSAGE, nvapi_QueryInterface, 0x6C2D048CU, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_EnumPhysicalGPUs, NVAPI_ENUMPHYSICALGPUS, nvapi_QueryInterface, 0xE5AC921FU, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetPerfPoliciesInfo, NVAPI_GPU_GETPERFPOLICIESINFO, nvapi_QueryInterface, 0x409D9841U, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetPerfPoliciesStatus, NVAPI_GPU_GETPERFPOLICIESSTATUS, nvapi_QueryInterface, 0x3D358A0CU, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetBusId, NVAPI_GPU_GETBUSID, nvapi_QueryInterface, 0x1BE0B8E5U, NVAPI, 0); - HC_LOAD_ADDR(nvapi, NvAPI_GPU_GetBusSlotId, NVAPI_GPU_GETBUSSLOTID, nvapi_QueryInterface, 0x2A0A350FU, NVAPI, 0); - - return 0; -} - -static void nvapi_close (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - if (nvapi) - { - if (nvapi->lib) - hc_dlclose (nvapi->lib); - - hcfree (nvapi); - } -} - -static void hm_NvAPI_GetErrorMessage (NVAPI_PTR *nvapi, const NvAPI_Status NvAPI_rc, NvAPI_ShortString string) -{ - nvapi->NvAPI_GetErrorMessage (NvAPI_rc, string); -} - -static int hm_NvAPI_Initialize (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_Initialize (); - - if (NvAPI_rc == NVAPI_LIBRARY_NOT_FOUND) return -1; - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_Initialize(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NvAPI_Unload (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_Unload (); - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_Unload(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NvAPI_EnumPhysicalGPUs (hashcat_ctx_t *hashcat_ctx, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_EnumPhysicalGPUs (nvGPUHandle, pGpuCount); - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_EnumPhysicalGPUs(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NvAPI_GPU_GetPerfPoliciesInfo (hashcat_ctx_t *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 *perfPolicies_info) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetPerfPoliciesInfo (hPhysicalGpu, perfPolicies_info); - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_GPU_GetPerfPoliciesInfo(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NvAPI_GPU_GetPerfPoliciesStatus (hashcat_ctx_t *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 *perfPolicies_status) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetPerfPoliciesStatus (hPhysicalGpu, perfPolicies_status); - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_GPU_GetPerfPoliciesStatus(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NvAPI_GPU_GetBusId (hashcat_ctx_t *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetBusId (hPhysicalGpu, pBusId); - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_GPU_GetBusId(): %s", string); - - return -1; - } - - return 0; -} - -static int hm_NvAPI_GPU_GetBusSlotId (hashcat_ctx_t *hashcat_ctx, NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - NVAPI_PTR *nvapi = (NVAPI_PTR *) hwmon_ctx->hm_nvapi; - - const NvAPI_Status NvAPI_rc = (NvAPI_Status) nvapi->NvAPI_GPU_GetBusSlotId (hPhysicalGpu, pBusSlotId); - - if (NvAPI_rc != NVAPI_OK) - { - NvAPI_ShortString string = { 0 }; - - hm_NvAPI_GetErrorMessage (nvapi, NvAPI_rc, string); - - event_log_error (hashcat_ctx, "NvAPI_GPU_GetBusSlotId(): %s", string); - - return -1; - } - - return 0; -} - -// ADL functions - -static int adl_init (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - memset (adl, 0, sizeof (ADL_PTR)); - - #if defined (_WIN) - adl->lib = hc_dlopen ("atiadlxx.dll"); - - if (!adl->lib) - { - adl->lib = hc_dlopen ("atiadlxy.dll"); - } - #elif defined (__CYGWIN__) - adl->lib = hc_dlopen ("atiadlxx.dll"); - - if (!adl->lib) - { - adl->lib = hc_dlopen ("atiadlxy.dll"); - } - #elif defined (_POSIX) - adl->lib = hc_dlopen ("libatiadlxx.so"); - #endif - - if (!adl->lib) - { - //if (user_options->quiet == false) - // event_log_error (hashcat_ctx, "Load of ADL library failed. Proceeding without ADL HWMon enabled."); - - return -1; - } - - HC_LOAD_FUNC(adl, ADL_Main_Control_Destroy, ADL_MAIN_CONTROL_DESTROY, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Main_Control_Create, ADL_MAIN_CONTROL_CREATE, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Adapter_NumberOfAdapters_Get, ADL_ADAPTER_NUMBEROFADAPTERS_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Adapter_AdapterInfo_Get, ADL_ADAPTER_ADAPTERINFO_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Display_DisplayInfo_Get, ADL_DISPLAY_DISPLAYINFO_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Adapter_ID_Get, ADL_ADAPTER_ID_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Adapter_VideoBiosInfo_Get, ADL_ADAPTER_VIDEOBIOSINFO_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive5_ThermalDevices_Enum, ADL_OVERDRIVE5_THERMALDEVICES_ENUM, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive5_Temperature_Get, ADL_OVERDRIVE5_TEMPERATURE_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_Temperature_Get, ADL_OVERDRIVE6_TEMPERATURE_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive5_CurrentActivity_Get, ADL_OVERDRIVE5_CURRENTACTIVITY_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeedInfo_Get, ADL_OVERDRIVE5_FANSPEEDINFO_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive5_FanSpeed_Get, ADL_OVERDRIVE5_FANSPEED_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_FanSpeed_Get, ADL_OVERDRIVE6_FANSPEED_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Adapter_Active_Get, ADL_ADAPTER_ACTIVE_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive_Caps, ADL_OVERDRIVE_CAPS, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_Capabilities_Get, ADL_OVERDRIVE6_CAPABILITIES_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_StateInfo_Get, ADL_OVERDRIVE6_STATEINFO_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_CurrentStatus_Get, ADL_OVERDRIVE6_CURRENTSTATUS_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_TargetTemperatureData_Get, ADL_OVERDRIVE6_TARGETTEMPERATUREDATA_GET, ADL, 0); - HC_LOAD_FUNC(adl, ADL_Overdrive6_TargetTemperatureRangeInfo_Get, ADL_OVERDRIVE6_TARGETTEMPERATURERANGEINFO_GET, ADL, 0); - - return 0; -} - -static void adl_close (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - if (adl) - { - if (adl->lib) - hc_dlclose (adl->lib); - - hcfree (adl); - } -} - -static int hm_ADL_Main_Control_Destroy (hashcat_ctx_t *hashcat_ctx) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Main_Control_Destroy (); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Main_Control_Destroy(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Main_Control_Create (hashcat_ctx_t *hashcat_ctx, ADL_MAIN_MALLOC_CALLBACK callback, int iEnumConnectedAdapters) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Main_Control_Create (callback, iEnumConnectedAdapters); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Main_Control_Create(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Adapter_NumberOfAdapters_Get (hashcat_ctx_t *hashcat_ctx, int *lpNumAdapters) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Adapter_NumberOfAdapters_Get (lpNumAdapters); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Adapter_NumberOfAdapters_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Adapter_AdapterInfo_Get (hashcat_ctx_t *hashcat_ctx, LPAdapterInfo lpInfo, int iInputSize) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Adapter_AdapterInfo_Get (lpInfo, iInputSize); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Adapter_AdapterInfo_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive5_Temperature_Get (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, int iThermalControllerIndex, ADLTemperature *lpTemperature) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive5_Temperature_Get (iAdapterIndex, iThermalControllerIndex, lpTemperature); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Overdrive5_Temperature_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive6_Temperature_Get (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, int *iTemperature) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive6_Temperature_Get (iAdapterIndex, iTemperature); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Overdrive6_Temperature_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive_CurrentActivity_Get (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, ADLPMActivity *lpActivity) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive5_CurrentActivity_Get (iAdapterIndex, lpActivity); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Overdrive5_CurrentActivity_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive5_FanSpeed_Get (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, int iThermalControllerIndex, ADLFanSpeedValue *lpFanSpeedValue) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive5_FanSpeed_Get (iAdapterIndex, iThermalControllerIndex, lpFanSpeedValue); - - if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here - { - event_log_error (hashcat_ctx, "ADL_Overdrive5_FanSpeed_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive6_FanSpeed_Get (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, ADLOD6FanSpeedInfo *lpFanSpeedInfo) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive6_FanSpeed_Get (iAdapterIndex, lpFanSpeedInfo); - - if ((ADL_rc != ADL_OK) && (ADL_rc != ADL_ERR_NOT_SUPPORTED)) // exception allowed only here - { - event_log_error (hashcat_ctx, "ADL_Overdrive6_FanSpeed_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive_Caps (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, int *od_supported, int *od_enabled, int *od_version) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive_Caps (iAdapterIndex, od_supported, od_enabled, od_version); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Overdrive_Caps(): %d", ADL_rc); - - return -1; - } - - return 0; -} - -static int hm_ADL_Overdrive6_TargetTemperatureData_Get (hashcat_ctx_t *hashcat_ctx, int iAdapterIndex, int *cur_temp, int *default_temp) -{ - hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx; - - ADL_PTR *adl = (ADL_PTR *) hwmon_ctx->hm_adl; - - const int ADL_rc = adl->ADL_Overdrive6_TargetTemperatureData_Get (iAdapterIndex, cur_temp, default_temp); - - if (ADL_rc != ADL_OK) - { - event_log_error (hashcat_ctx, "ADL_Overdrive6_TargetTemperatureData_Get(): %d", ADL_rc); - - return -1; - } - - return 0; -} - // general functions static int get_adapters_num_adl (hashcat_ctx_t *hashcat_ctx, int *iNumberAdapters)