src/dps8/dps8

/* */
This source file includes following definitions.
restore_thread_sched
watchdog_recover
watchdog_writer
watchdog_reader
save_thread_sched
realtime_max_priority
set_realtime_priority
check_realtime_priority_impl
check_realtime_priority
check_not_realtime_priority
watchdog_startup
   1 /*
   2  * vim: filetype=c:tabstop=2:ai:expandtab
   3  * SPDX-License-Identifier: ICU
   4  * scspell-id: d18b0dfa-fd83-11ef-a2d3-80ee73e9b8e7
   5  *
   6  * ---------------------------------------------------------------------------
   7  *
   8  * Copyright (c) 2025 Jeffrey H. Johnson
   9  * Copyright (c) 2025 The DPS8M Development Team
  10  *
  11  * This software is made available under the terms of the ICU License.
  12  * See the LICENSE.md file at the top-level directory of this distribution.
  13  *
  14  * ---------------------------------------------------------------------------
  15  */
  16 
  17 /*
  18  * Real-time watchdog and priority helpers
  19  *
  20  * Supported: IBM AIX, Android, Linux/glibc, Linux/musl,
  21  *            macOS, QNX, SerenityOS, FreeBSD, NetBSD,
  22  *            OpenBSD, Haiku, Solaris, and illumos.
  23  *
  24  * Unsupported: Microsoft Windows, Cygwin, GNU/Hurd,
  25  *              IBM z/OS USS, and PASE for IBM i.
  26  */
  27 
  28 #if !defined(_GNU_SOURCE)
  29 # define _GNU_SOURCE
  30 #endif
  31 
  32 #include <pthread.h>
  33 #include <time.h>
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36 #include <sched.h>
  37 #include <stdio.h>
  38 #include <errno.h>
  39 #include <string.h>
  40 #include <stdbool.h>
  41 
  42 #include "dps8.h"
  43 #include "dps8_cpu.h"
  44 #include "dps8_priv.h"
  45 #include "dps8_sir.h"
  46 
  47 #include "../simh/sim_timer.h"
  48 
  49 #if !defined(WATCHDOG_INTERVAL)
  50 # define WATCHDOG_INTERVAL (5000000) /* 5 seconds */
  51 #endif
  52 
  53 #if !defined(WATCHDOG_MAX_MISSES)
  54 # define WATCHDOG_MAX_MISSES (6)
  55 #endif
  56 
  57 #if !defined(WD_MS_SEC)
  58 # define WD_MS_SEC 1000000
  59 #endif
  60 
  61 /* RT scheduler class */
  62 #if !defined(RT_SCHEDULER)
  63 # define RT_SCHEDULER SCHED_RR
  64 #endif
  65 
  66 /* SCP xstrerror_l */
  67 #if defined(NO_LOCALE)
  68 # define xstrerror_l strerror
  69 #else
  70 extern const char *xstrerror_l(int errnum);
  71 #endif
  72 
  73 /* Globals */
  74 volatile time_t watchdog_timestamp;
  75 volatile bool realtime_ok = false;
  76 
  77 struct g_sched_info {
  78   int policy;
  79   struct sched_param param;
  80 };
  81 struct g_sched_info global_sched_info;
  82 
  83 /* restore_thread_sched: sets thread scheduler and priority as stashed by save_thread_sched */
  84 int
  85 restore_thread_sched(const pthread_t thread_id)
     /*  */
  86 {
  87   return pthread_setschedparam(thread_id, global_sched_info.policy, &global_sched_info.param);
  88 }
  89 
  90 /* watchdog_recover: recovery procedure */
  91 void
  92 watchdog_recover(void)
     /*  */
  93 {
  94   static unsigned long watchdog_triggered = 0;
  95 
  96   watchdog_triggered++;
  97   realtime_ok = false;
  98 
  99   (void)sir_alert("RT watchdog activated after %d missed updates (%d seconds)",
 100                   WATCHDOG_MAX_MISSES, WATCHDOG_MAX_MISSES * (WATCHDOG_INTERVAL / WD_MS_SEC));
 101 
 102   if (watchdog_triggered == 1) {
 103     (void)sir_notice("Resetting supervisor thread parameters");
 104     int ret = restore_thread_sched(main_thread_id);
 105     if (0 != ret) {
 106       (void)sir_error("Error #%d resetting supervisor thread parameters: %s",
 107                       ret, xstrerror_l(ret));
 108     }
 109 
 110 #if defined(THREADZ) || defined(LOCKLESS)
 111     ret = 0;
 112     for (uint32_t cpuNo = 0; cpuNo < N_CPU_UNITS_MAX; cpuNo++) {
 113       if (cpus[cpuNo].cycleCnt) {
 114         (void)sir_notice("Resetting CPU %c thread parameters", cpuNo + 'A');
 115         ret = restore_thread_sched(cpus[cpuNo].thread_id);
 116         if (0 != ret) {
 117           (void)sir_error("Error #%d resetting CPU %c thread parameters: %s",
 118                           ret, cpuNo + 'A', xstrerror_l(ret));
 119         }
 120       }
 121     }
 122 #endif
 123   } else {
 124     (void)sir_warn("RT watchdog count is %lu; not resetting thread parameters!",
 125                    watchdog_triggered);
 126   }
 127 }
 128 
 129 /* watchdog_writer thread runs at standard or lowered priority */
 130 void
 131 *watchdog_writer(void *arg)
     /*  */
 132 {
 133   const bool forever = true;
 134   (void)arg;
 135 
 136   (void)_sir_setthreadname("watchdog_writer");
 137 
 138 #if !defined(__QNX__)
 139   (void)sim_os_set_thread_priority(PRIORITY_BELOW_NORMAL);
 140 #endif
 141 
 142   while (forever) { //-V654
 143     watchdog_timestamp = time(NULL);
 144     (void)sim_usleep(WATCHDOG_INTERVAL);
 145   }
 146 
 147   /*NOTREACHED*/ /* unreachable */
 148   return NULL;
 149 }
 150 
 151 /* watchdog_reader thread runs at maximum real-time priority */
 152 void
 153 *watchdog_reader(void *arg)
     /*  */
 154 {
 155   const bool forever = true;
 156   int miss_count = 0;
 157   (void)arg;
 158 
 159   (void)_sir_setthreadname("rt_watchdog");
 160 
 161   (void)sim_usleep(WATCHDOG_INTERVAL);
 162   time_t prev_timestamp = watchdog_timestamp;
 163 
 164   while (forever) { //-V654
 165     (void)sim_usleep(WATCHDOG_INTERVAL);
 166 
 167     time_t current_timestamp = watchdog_timestamp;
 168 
 169     if (current_timestamp == prev_timestamp) {
 170       miss_count++;
 171       if (miss_count >= WATCHDOG_MAX_MISSES) {
 172         watchdog_recover();
 173       }
 174     } else {
 175       miss_count = 0;
 176     }
 177 
 178     prev_timestamp = current_timestamp;
 179   }
 180 
 181   /*NOTREACHED*/ /* unreachable */
 182   return NULL;
 183 }
 184 
 185 /*
 186  * To simplify the implementation, all of the following
 187  * functions will exit on failure!  Call watchdog_startup
 188  * early in the start-up process to avoid nasty surprises.
 189  */
 190 
 191 /* save_thread_sched: stash current scheduler and priority */
 192 void
 193 save_thread_sched(const pthread_t thread_id)
     /*  */
 194 {
 195   int ret = pthread_getschedparam(thread_id, &global_sched_info.policy, &global_sched_info.param);
 196   if (0 != ret) {
 197     (void)sir_emerg("FATAL: Failed to save current scheduler parameters!");
 198     (void)sir_emerg("Error #%d - %s", ret, xstrerror_l(ret));
 199     exit(EXIT_FAILURE);
 200     }
 201 }
 202 
 203 /* realtime_max_priority: get maximum realtime priority */
 204 int
 205 realtime_max_priority(void)
     /*  */
 206 {
 207   static int max_priority;
 208 
 209 #if defined(_AIX) && defined(__PASE__)
 210   max_priority = 127;
 211 #else
 212   max_priority = sched_get_priority_max(RT_SCHEDULER);
 213   if (-1 == max_priority) {
 214     (void)sir_emerg("FATAL: Failed to query maximum priority level!");
 215     (void)sir_emerg("Error #%d - %s", errno, xstrerror_l(errno));
 216     exit(EXIT_FAILURE);
 217   }
 218 #endif
 219 
 220   return max_priority;
 221 }
 222 
 223 /* set_realtime_priority: set thread_id to realtime priority level */
 224 void
 225 set_realtime_priority(const pthread_t thread_id, const int priority)
     /*  */
 226 {
 227   struct sched_param param;
 228   param.sched_priority = priority;
 229 
 230   int ret = pthread_setschedparam(thread_id, RT_SCHEDULER, &param);
 231   if (0 != ret) {
 232     (void)sir_emerg("FATAL: Failed to set real-time watchdog priority!");
 233     (void)sir_emerg("Error #%d - %s", ret, xstrerror_l(ret));
 234     exit(EXIT_FAILURE);
 235   }
 236 }
 237 
 238 /* check_realtime_priority and check_not_realtime_priority implementation */
 239 static void
 240 check_realtime_priority_impl(const pthread_t thread_id, const int priority, const bool verify)
     /*  */
 241 {
 242   int policy;
 243   struct sched_param param_check;
 244   int ret = pthread_getschedparam(thread_id, &policy, &param_check);
 245   if (0 == ret) {
 246     if (verify) {
 247       if (RT_SCHEDULER != policy) {
 248         (void)sir_emerg("FATAL: Failed to validate real-time policy (%d != %d)!",
 249                         RT_SCHEDULER, policy);
 250         exit(EXIT_FAILURE);
 251       }
 252       if (priority != param_check.sched_priority) {
 253         (void)sir_emerg("FATAL: Failed to validate real-time priority (%d != %d)!",
 254                         priority, param_check.sched_priority);
 255         exit(EXIT_FAILURE);
 256       }
 257     } else {
 258       if (priority == param_check.sched_priority) {
 259         (void)sir_emerg("FATAL: Failed to validate real-time priority (%d)!",
 260                         param_check.sched_priority);
 261         exit(EXIT_FAILURE);
 262       }
 263     }
 264   } else {
 265     (void)sir_emerg("FATAL: Failed to query real-time parameters!");
 266     (void)sir_emerg("Error #%d - %s", ret, xstrerror_l(ret));
 267     exit(EXIT_FAILURE);
 268   }
 269 }
 270 
 271 /* check_realtime_priority: verify thread_id set to realtime priority level */
 272 void
 273 check_realtime_priority(const pthread_t thread_id, const int priority)
     /*  */
 274 {
 275   check_realtime_priority_impl(thread_id, priority, true);
 276 }
 277 
 278 /* check_not_realtime_priority: verify thread_id not set to realtime priority level */
 279 void
 280 check_not_realtime_priority(const pthread_t thread_id, const int priority)
     /*  */
 281 {
 282   check_realtime_priority_impl(thread_id, priority, false);
 283 }
 284 
 285 /* watchdog_startup: start the watchdog threads */
 286 void
 287 watchdog_startup(void)
     /*  */
 288 {
 289   const int max_priority = realtime_max_priority();
 290   int ret;
 291   watchdog_timestamp = time(NULL);
 292 
 293   /* watchdog_reader: create reader/receiver thread */
 294   pthread_t watchdog_reader_id;
 295   ret = pthread_create(&watchdog_reader_id, NULL, watchdog_reader, NULL);
 296   if (0 != ret) {
 297     (void)sir_emerg("FATAL: Failed to start real-time watchdog (watchdog_reader)!");
 298     (void)sir_emerg("Error #%d - %s", ret, xstrerror_l(ret));
 299     exit(EXIT_FAILURE);
 300   }
 301 
 302   /* watchdog_reader: set real-time priority */
 303   set_realtime_priority(watchdog_reader_id, max_priority);
 304 
 305   /* watchdog_reader: verify watchdog_reader is both real-time and max_priority */
 306   check_realtime_priority(watchdog_reader_id, max_priority);
 307 
 308 #if !defined(TESTING_WATCHDOG)
 309   /* watchdog_writer: create writer/sender thread */
 310   pthread_t watchdog_writer_id;
 311   ret = pthread_create(&watchdog_writer_id, NULL, watchdog_writer, NULL);
 312   if (0 != ret) {
 313     (void)sir_emerg("FATAL: Failed to start watchdog (watchdog_writer)!");
 314     (void)sir_emerg("Error #%d - %s", ret, xstrerror_l(ret));
 315     exit(EXIT_FAILURE);
 316   }
 317 
 318   /* watchdog_writer: verify watchdog_writer is NOT max_priority */
 319   check_not_realtime_priority(watchdog_writer_id, max_priority);
 320 #endif
 321 
 322   realtime_ok = true;
 323 }
/* */
root/src/dps8/dps8_rt.c

DEFINITIONS
