arno
/
hashcat
mirror of https://github.com/hashcat/hashcat.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Improve handling of temporary skipped devices (due to JiT build failure or unstable_warning)

Browse Source
pull/1940/head
jsteube 5 years ago
parent a9bafb7edb
commit 1537fc4e5d
10 changed files with 126 additions and 38 deletions
Show Stats Download Patch File Download Diff File

1
include/status.h
Unescape View File

@ -20,6 +20,7 @@ void format_speed_display_1k (double val, char *buf, size_t len);
int status_get_device_info_cnt (const hashcat_ctx_t *hashcat_ctx);
int status_get_device_info_active (const hashcat_ctx_t *hashcat_ctx);
bool status_get_skipped_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
bool status_get_skipped_warning_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
char *status_get_session (const hashcat_ctx_t *hashcat_ctx);
const char *status_get_status_string (const hashcat_ctx_t *hashcat_ctx);
int status_get_status_number (const hashcat_ctx_t *hashcat_ctx);

7
include/types.h
Unescape View File

@ -1048,10 +1048,10 @@ typedef struct hc_device_param
cl_device_type device_type;
u32 device_id;
u32 platform_devices_id; // for mapping with hms devices
u32 platform_devices_id; // for mapping with hms devices
bool skipped;
bool unstable_warning;
bool skipped; // permanent
bool skipped_warning; // iteration
st_status_t st_status;
@ -2020,6 +2020,7 @@ typedef struct cpt_ctx
typedef struct device_info
{
bool skipped_dev;
bool skipped_warning_dev;
double hashes_msec_dev;
double hashes_msec_dev_benchmark;
double exec_msec_dev;

2
src/autotune.c
Unescape View File

@ -292,6 +292,8 @@ HC_API_CALL void *thread_autotune (void *p)
if (device_param->skipped == true) return NULL;
if (device_param->skipped_warning == true) return NULL;
const int rc_autotune = autotune (hashcat_ctx, device_param);
if (rc_autotune == -1)

8
src/dispatch.c
Unescape View File

@ -35,6 +35,8 @@ static u64 get_highest_words_done (const hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
const u64 words_done = device_param->words_done;
if (words_done > words_cur) words_cur = words_done;
@ -55,6 +57,8 @@ static u64 get_lowest_words_done (const hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
const u64 words_done = device_param->words_done;
if (words_done < words_cur) words_cur = words_done;
@ -345,6 +349,8 @@ HC_API_CALL void *thread_calc_stdin (void *p)
if (device_param->skipped) return NULL;
if (device_param->skipped_warning == true) return NULL;
const int rc_calc = calc_stdin (hashcat_ctx, device_param);
if (rc_calc == -1)
@ -1662,6 +1668,8 @@ HC_API_CALL void *thread_calc (void *p)
if (device_param->skipped) return NULL;
if (device_param->skipped_warning == true) return NULL;
const int rc_calc = calc (hashcat_ctx, device_param);
if (rc_calc == -1)

1
src/hashcat.c
Unescape View File

@ -1460,6 +1460,7 @@ int hashcat_get_status (hashcat_ctx_t *hashcat_ctx, hashcat_status_t *hashcat_st
device_info_t *device_info = hashcat_status->device_info_buf + device_id;
device_info->skipped_dev = status_get_skipped_dev (hashcat_ctx, device_id);
device_info->skipped_warning_dev = status_get_skipped_warning_dev (hashcat_ctx, device_id);
device_info->hashes_msec_dev = status_get_hashes_msec_dev (hashcat_ctx, device_id);
device_info->hashes_msec_dev_benchmark = status_get_hashes_msec_dev_benchmark (hashcat_ctx, device_id);
device_info->exec_msec_dev = status_get_exec_msec_dev (hashcat_ctx, device_id);

4
src/monitor.c
Unescape View File

@ -140,6 +140,8 @@ static int monitor (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
const int rc_throttle = hm_get_throttle_with_device_id (hashcat_ctx, device_id);
if (rc_throttle == -1) continue;
@ -238,6 +240,8 @@ static int monitor (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
exec_cnt++;
const double exec = status_get_exec_msec_dev (hashcat_ctx, device_id);

41
src/opencl.c
Unescape View File

@ -4155,12 +4155,16 @@ void opencl_ctx_devices_sync_tuning (hashcat_ctx_t *hashcat_ctx)
if (device_param_src->skipped == true) continue;
if (device_param_src->skipped_warning == true) continue;
for (u32 device_id_dst = device_id_src; device_id_dst < opencl_ctx->devices_cnt; device_id_dst++)
{
hc_device_param_t *device_param_dst = &opencl_ctx->devices_param[device_id_dst];
if (device_param_dst->skipped == true) continue;
if (device_param_dst->skipped_warning == true) continue;
if (is_same_device_type (device_param_src, device_param_dst) == false) continue;
device_param_dst->kernel_accel = device_param_src->kernel_accel;
@ -4195,6 +4199,8 @@ void opencl_ctx_devices_update_power (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
kernel_power_all += device_param->kernel_power;
}
@ -4239,6 +4245,8 @@ void opencl_ctx_devices_kernel_loops (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
device_param->kernel_loops_min = device_param->kernel_loops_min_sav;
device_param->kernel_loops_max = device_param->kernel_loops_max_sav;
@ -4493,6 +4501,8 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
* module depending checks
*/
device_param->skipped_warning = false;
if (module_ctx->module_unstable_warning != MODULE_DEFAULT)
{
const bool unstable_warning = module_ctx->module_unstable_warning (hashconfig, user_options, user_options_extra, device_param);
@ -4502,9 +4512,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
event_log_warning (hashcat_ctx, "* Device #%u: Skipping unstable hash-mode %u for this device.", device_id + 1, hashconfig->hash_mode);
event_log_warning (hashcat_ctx, " You can use --force to override, but do not report related errors.");
device_param->skipped = true;
device_param->unstable_warning = true;
device_param->skipped_warning = true;
continue;
}
@ -5008,7 +5016,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (CL_rc == -1)
{
device_param->skipped = true;
device_param->skipped_warning = true;
event_log_error (hashcat_ctx, "* Device #%u: Kernel %s build failed - proceeding without this device.", device_id + 1, source_file);
@ -5087,7 +5095,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (CL_rc == -1)
{
device_param->skipped = true;
device_param->skipped_warning = true;
event_log_error (hashcat_ctx, "* Device #%u: Kernel %s build failed - proceeding without this device.", device_id + 1, source_file);
@ -5201,7 +5209,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (CL_rc == -1)
{
device_param->skipped = true;
device_param->skipped_warning = true;
event_log_error (hashcat_ctx, "* Device #%u: Kernel %s build failed - proceeding without this device.", device_id + 1, source_file);
@ -5348,7 +5356,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (CL_rc == -1)
{
device_param->skipped = true;
device_param->skipped_warning = true;
event_log_error (hashcat_ctx, "* Device #%u: Kernel %s build failed - proceeding without this device.", device_id + 1, source_file);
@ -6749,8 +6757,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
}
// Prevent exit from benchmark mode if all devices are skipped due to unstable hash-modes (macOS)
// if (hardware_power_all == 0) return -1;
// if (hardware_power_all == 0) return -1;
opencl_ctx->hardware_power_all = hardware_power_all;
@ -6928,15 +6935,7 @@ void opencl_session_reset (hashcat_ctx_t *hashcat_ctx)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true)
{
if (device_param->unstable_warning == true)
{
device_param->skipped = false;
}
continue;
}
if (device_param->skipped == true) continue;
device_param->speed_pos = 0;
@ -6991,6 +6990,8 @@ int opencl_session_update_combinator (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
// kernel_params
device_param->kernel_params_buf32[33] = combinator_ctx->combs_mode;
@ -7048,6 +7049,8 @@ int opencl_session_update_mp (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
device_param->kernel_params_mp_buf64[3] = 0;
device_param->kernel_params_mp_buf32[4] = mask_ctx->css_cnt;
@ -7079,6 +7082,8 @@ int opencl_session_update_mp_rl (hashcat_ctx_t *hashcat_ctx, const u32 css_cnt_l
if (device_param->skipped == true) continue;
if (device_param->skipped_warning == true) continue;
device_param->kernel_params_mp_l_buf64[3] = 0;
device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;

2
src/selftest.c
Unescape View File

@ -579,6 +579,8 @@ HC_API_CALL void *thread_selftest (void *p)
if (device_param->skipped == true) return NULL;
if (device_param->skipped_warning == true) return NULL;
const int rc_selftest = selftest (hashcat_ctx, device_param);
if (user_options->benchmark == true)

64
src/status.c
Unescape View File

@ -223,6 +223,15 @@ bool status_get_skipped_dev (const hashcat_ctx_t *hashcat_ctx, const int device_
return device_param->skipped;
}
bool status_get_skipped_warning_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id)
{
const opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
return device_param->skipped_warning;
}
char *status_get_session (const hashcat_ctx_t *hashcat_ctx)
{
const user_options_t *user_options = hashcat_ctx->user_options;
@ -839,6 +848,13 @@ char *status_get_guess_candidates_dev (const hashcat_ctx_t *hashcat_ctx, const i
char *display = (char *) hcmalloc (HCBUFSIZ_TINY);
if ((device_param->skipped == true) || (device_param->skipped_warning == true))
{
snprintf (display, HCBUFSIZ_TINY, "[Skipped]");
return display;
}
if (user_options_extra->attack_kern == ATTACK_KERN_BF)
{
snprintf (display, HCBUFSIZ_TINY, "[Generating]");
@ -848,8 +864,6 @@ char *status_get_guess_candidates_dev (const hashcat_ctx_t *hashcat_ctx, const i
snprintf (display, HCBUFSIZ_TINY, "[Copying]");
}
if (device_param->skipped == true) return display;
if ((device_param->outerloop_left == 0) || (device_param->innerloop_left == 0)) return display;
const u64 outerloop_first = 0;
@ -1419,7 +1433,7 @@ double status_get_hashes_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int d
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
const u32 speed_pos = MAX (device_param->speed_pos, 1);
@ -1454,7 +1468,7 @@ double status_get_hashes_msec_dev_benchmark (const hashcat_ctx_t *hashcat_ctx, c
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
const u32 speed_pos = MAX (device_param->speed_pos, 1);
@ -1494,7 +1508,7 @@ double status_get_exec_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int dev
double exec_dev_msec = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
exec_dev_msec = get_avg_exec_time (device_param, EXEC_CACHE);
}
@ -1694,7 +1708,7 @@ int status_get_salt_pos_dev (const hashcat_ctx_t *hashcat_ctx, const int device_
int salt_pos = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
salt_pos = (int) device_param->kernel_params_buf32[27];
}
@ -1710,7 +1724,7 @@ int status_get_innerloop_pos_dev (const hashcat_ctx_t *hashcat_ctx, const int de
int innerloop_pos = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
innerloop_pos = (int) device_param->innerloop_pos;
}
@ -1726,7 +1740,7 @@ int status_get_innerloop_left_dev (const hashcat_ctx_t *hashcat_ctx, const int d
int innerloop_left = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
innerloop_left = (int) device_param->innerloop_left;
}
@ -1742,7 +1756,7 @@ int status_get_iteration_pos_dev (const hashcat_ctx_t *hashcat_ctx, const int de
int iteration_pos = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
iteration_pos = (int) device_param->kernel_params_buf32[28];
}
@ -1758,7 +1772,7 @@ int status_get_iteration_left_dev (const hashcat_ctx_t *hashcat_ctx, const int d
int iteration_left = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
iteration_left = (int) device_param->kernel_params_buf32[29];
}
@ -1775,7 +1789,7 @@ int status_get_brain_link_client_id_dev (const hashcat_ctx_t *hashcat_ctx, const
int brain_client_id = -1;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
brain_client_id = device_param->brain_link_client_fd;
}
@ -1791,7 +1805,7 @@ int status_get_brain_link_status_dev (const hashcat_ctx_t *hashcat_ctx, const in
int brain_link_status_dev = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
if (device_param->brain_link_client_fd != -1) brain_link_status_dev = BRAIN_LINK_STATUS_CONNECTED;
if (device_param->brain_link_recv_active == true) brain_link_status_dev = BRAIN_LINK_STATUS_RECEIVING;
@ -1809,7 +1823,7 @@ char *status_get_brain_link_recv_bytes_dev (const hashcat_ctx_t *hashcat_ctx, co
u64 brain_link_recv_bytes = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
brain_link_recv_bytes = device_param->brain_link_recv_bytes;
}
@ -1829,7 +1843,7 @@ char *status_get_brain_link_send_bytes_dev (const hashcat_ctx_t *hashcat_ctx, co
u64 brain_link_send_bytes = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
brain_link_send_bytes = device_param->brain_link_send_bytes;
}
@ -1849,7 +1863,7 @@ char *status_get_brain_link_recv_bytes_sec_dev (const hashcat_ctx_t *hashcat_ctx
u64 brain_link_recv_bytes = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
for (int idx = 0; idx < LINK_SPEED_COUNT; idx++)
{
@ -1876,7 +1890,7 @@ char *status_get_brain_link_send_bytes_sec_dev (const hashcat_ctx_t *hashcat_ctx
u64 brain_link_send_bytes = 0;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
for (int idx = 0; idx < LINK_SPEED_COUNT; idx++)
{
@ -1908,6 +1922,8 @@ char *status_get_hwmon_dev (const hashcat_ctx_t *hashcat_ctx, const int device_i
if (device_param->skipped == true) return output_buf;
if (device_param->skipped_warning == true) return output_buf;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
hc_thread_mutex_lock (status_ctx->mux_hwmon);
@ -1975,6 +1991,8 @@ int status_get_corespeed_dev (const hashcat_ctx_t *hashcat_ctx, const int device
if (device_param->skipped == true) return -1;
if (device_param->skipped_warning == true) return -1;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
hc_thread_mutex_lock (status_ctx->mux_hwmon);
@ -1994,6 +2012,8 @@ int status_get_memoryspeed_dev (const hashcat_ctx_t *hashcat_ctx, const int devi
if (device_param->skipped == true) return -1;
if (device_param->skipped_warning == true) return -1;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
hc_thread_mutex_lock (status_ctx->mux_hwmon);
@ -2013,6 +2033,8 @@ u64 status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int device_
if (device_param->skipped == true) return 0;
if (device_param->skipped_warning == true) return 0;
return device_param->outerloop_left;
}
@ -2024,6 +2046,8 @@ double status_get_runtime_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int
if (device_param->skipped == true) return 0;
if (device_param->skipped_warning == true) return 0;
return device_param->outerloop_msec;
}
@ -2035,6 +2059,8 @@ int status_get_kernel_accel_dev (const hashcat_ctx_t *hashcat_ctx, const int dev
if (device_param->skipped == true) return 0;
if (device_param->skipped_warning == true) return 0;
if (device_param->kernel_accel_prev) return device_param->kernel_accel_prev;
return device_param->kernel_accel;
@ -2048,6 +2074,8 @@ int status_get_kernel_loops_dev (const hashcat_ctx_t *hashcat_ctx, const int dev
if (device_param->skipped == true) return 0;
if (device_param->skipped_warning == true) return 0;
if (device_param->kernel_loops_prev) return device_param->kernel_loops_prev;
return device_param->kernel_loops;
@ -2061,6 +2089,8 @@ int status_get_kernel_threads_dev (const hashcat_ctx_t *hashcat_ctx, const int d
if (device_param->skipped == true) return 0;
if (device_param->skipped_warning == true) return 0;
return device_param->kernel_threads;
}
@ -2072,6 +2102,8 @@ int status_get_vector_width_dev (const hashcat_ctx_t *hashcat_ctx, const int dev
if (device_param->skipped == true) return 0;
if (device_param->skipped_warning == true) return 0;
return device_param->vector_width;
}

34
src/terminal.c
Unescape View File

@ -766,7 +766,7 @@ void opencl_info_compact (hashcat_ctx_t *hashcat_ctx)
u64 device_maxmem_alloc = device_param->device_maxmem_alloc;
u64 device_global_mem = device_param->device_global_mem;
if (device_param->skipped == false)
if ((device_param->skipped == false) && (device_param->skipped_warning == false))
{
event_log_info (hashcat_ctx, "* Device #%u: %s, %" PRIu64 "/%" PRIu64 " MB allocatable, %uMCU",
devices_idx + 1,
@ -812,6 +812,8 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
printf ("%" PRIu64 "\t", (u64) (device_info->hashes_msec_dev * 1000));
// that 1\t is for backward compatibility
@ -826,6 +828,8 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
printf ("%f\t", device_info->exec_msec_dev);
}
@ -847,6 +851,8 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
const int temp = hm_get_temperature_with_device_id (hashcat_ctx, device_id);
printf ("%d\t", temp);
@ -863,6 +869,8 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
// ok, little cheat here again...
const int util = hm_get_utilization_with_device_id (hashcat_ctx, device_id);
@ -1241,6 +1249,8 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx,
"Speed.#%d.........: %9sH/s (%0.2fms) @ Accel:%d Loops:%d Thr:%d Vec:%d", device_id + 1,
device_info->speed_sec_dev,
@ -1314,6 +1324,8 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
if (device_info->brain_link_status_dev == BRAIN_LINK_STATUS_CONNECTED)
{
event_log_info (hashcat_ctx,
@ -1389,6 +1401,8 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx,
"Restore.Sub.#%d...: Salt:%d Amplifier:%d-%d Iteration:%d-%d", device_id + 1,
device_info->salt_pos_dev,
@ -1404,6 +1418,8 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
if (device_info->guess_candidates_dev == NULL) continue;
event_log_info (hashcat_ctx,
@ -1419,6 +1435,8 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
if (device_info->hwmon_dev == NULL) continue;
event_log_info (hashcat_ctx,
@ -1455,6 +1473,8 @@ void status_benchmark_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx, "%d:%u:%d:%d:%.2f:%" PRIu64, device_id + 1, hash_mode, device_info->corespeed_dev, device_info->memoryspeed_dev, device_info->exec_msec_dev, (u64) (device_info->hashes_msec_dev_benchmark * 1000));
}
@ -1491,6 +1511,8 @@ void status_benchmark (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx,
"Speed.#%d.........: %9sH/s (%0.2fms) @ Accel:%d Loops:%d Thr:%d Vec:%d", device_id + 1,
device_info->speed_sec_dev,
@ -1532,6 +1554,8 @@ void status_speed_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx, "%d:%" PRIu64, device_id + 1, (u64) (device_info->hashes_msec_dev_benchmark * 1000));
}
@ -1568,6 +1592,8 @@ void status_speed (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx,
"Speed.#%d.........: %9sH/s (%0.2fms)", device_id + 1,
device_info->speed_sec_dev,
@ -1605,6 +1631,8 @@ void status_progress_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx, "%d:%" PRIu64 ":%0.2f", device_id + 1, device_info->progress_dev, device_info->runtime_msec_dev);
}
@ -1641,6 +1669,8 @@ void status_progress (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx,
"Progress.#%d......: %" PRIu64, device_id + 1,
device_info->progress_dev);
@ -1652,6 +1682,8 @@ void status_progress (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue;
if (device_info->skipped_warning_dev == true) continue;
event_log_info (hashcat_ctx,
"Runtime.#%d.......: %0.2fms", device_id + 1,
device_info->runtime_msec_dev);

Write Preview
Loading…
Cancel
Save