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

include/status.h

@@ -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);

include/types.h

@@ -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    skipped;              // permanent
-  bool    unstable_warning;
+  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;

src/autotune.c

@@ -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)

src/dispatch.c

@@ -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)

src/hashcat.c

@@ -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);

src/monitor.c

@@ -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);

src/opencl.c

@@ -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->skipped_warning = true;
-
-        device_param->unstable_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->skipped == true) continue;
-    {
-      if (device_param->unstable_warning == true)
-      {
-        device_param->skipped = false;
-      }
-
-      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;

src/selftest.c

@@ -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)

src/status.c

@@ -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;
 }
 

src/terminal.c

@@ -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);