_sim_debug_flush(): Use fsync().

Fix race condition in _debug_fwrite_all() where the FILE *f output
file can be permanently NULL, causing fwrite() to permanently return
zero and resulting in an infinite loop on mulithreaded SIMH. This
pathology primarily occurs when main thread calls flush_svc() and
one of the Ethernet threads (reader, writer) emits debugging output.

Linux, macOS invoke fsync(). Windows invokes a fsync() wrapper that
invokes _commit().

Issue traced to _sim_debug_flush() calling sim_set_deboff(0, NULL) to
simulate fsync().

Author: bscottm

scp.c

@@ -253,6 +253,22 @@
 #include ".git-commit-id.h"
 #endif
 
+/* fsync() and _commit(). Update the preprocessor conditional below for add'l
+ * platforms. Minimally supports Linux and macOS. */
+#if _BSD_SOURCE || _XOPEN_SOURCE || _POSIX_C_SOURCE >= 200112L
+#define HAVE_FSYNC
+#include <unistd.h>
+#elif defined(_WIN32) || defined(_WIN64)
+#define HAVE_FSYNC
+#include <io.h>
+
+/* fsync() wrapper for Windows. */
+static inline int fsync(int fd)
+{
+    return _commit(fd);
+}
+#endif
+
 #ifndef MAX
 #define MAX(a,b)  (((a) >= (b)) ? (a) : (b))
 #endif
@@ -13611,6 +13627,16 @@ static void _debug_fwrite_all (const char *buf, size_t len, FILE *f)
 {
 size_t len_written;
 
+/* NOTE: This is UNSAFE in a multithreaded SIMH if not using fsync() or _commit().
+ *
+ * _sim_debug_flush() calls sim_set_deboff(0, NULL), which NULLs sim_deb (aka f).
+ * This causes a race on sim_deb between threads -- a thread can read a NULL sim_deb
+ * and call _debug_fwrite_all() with f == NULL.
+ * 
+ * f == NULL: fwrite() returns 0 on Linux and Windows. len never gets decremented
+ * and an infinite loop ensues (cue "Forever NULL" sung to the tune of Alphaville's
+ * "Forever Young".)
+ */
 while (len > 0) {
     errno = 0;
     len_written = fwrite (buf, 1, len, f);
@@ -13755,23 +13781,31 @@ _sim_debug_write_flush (buf, len, FALSE);
 
 static t_stat _sim_debug_flush (void)
 {
-int32 saved_quiet = sim_quiet;
-int32 saved_sim_switches = sim_switches;
-int32 saved_deb_switches = sim_deb_switches;
-struct timespec saved_deb_basetime = sim_deb_basetime;
-char saved_debug_filename[CBUFSIZE];
-
 if (sim_deb == NULL)                                    /* no debug? */
     return SCPE_OK;
 
 _sim_debug_write_flush ("", 0, TRUE);
+fflush (sim_deb);
 
-if (sim_deb == sim_log) {                               /* debug is log */
-    fflush (sim_deb);                                   /* fflush is the best we can do */
-    return SCPE_OK;
-    }
-
+#if defined(HAVE_FSYNC)
+/* Linux, macOS: Use fsync() to flush sim_deb contents and metadata. Windows has
+ * equivalent functionality in an inline wrapper. */
+fsync(fileno(sim_deb));
+#else
 if (!(saved_deb_switches & SWMASK ('B'))) {
+    /* Simulated fsync(). This cannot be used in a multithreaded SIMH because NULL-ing
+     * sim_deb in sim_set_deboff() can cause another thread to infinitely loop in
+     * _debug_fwrite_all(). 
+     * 
+     * N.B. _sim_debug_flush() is eventually called by flush_svc() on 30 second
+     * intervals. */
+
+    int32 saved_quiet = sim_quiet;
+    int32 saved_sim_switches = sim_switches;
+    int32 saved_deb_switches = sim_deb_switches;
+    struct timespec saved_deb_basetime = sim_deb_basetime;
+    char saved_debug_filename[CBUFSIZE];
+
     strcpy (saved_debug_filename, sim_logfile_name (sim_deb, sim_deb_ref));
 
     sim_quiet = 1;
@@ -13782,6 +13816,8 @@ if (!(saved_deb_switches & SWMASK ('B'))) {
     sim_switches = saved_sim_switches;
     sim_quiet = saved_quiet;
     }
+#endif
+
 return SCPE_OK;
 }