Realtime detection rework

Author: hdiethelm

src/hal/hal.h

@@ -237,7 +237,7 @@ extern int hal_unready(int comp_id);
 */
 extern char* hal_comp_name(int comp_id);
 
-extern int hal_realtime_status();
+extern rtapi_realtime_status_t hal_realtime_status();
 
 /** The HAL maintains lists of variables, functions, and so on in
     a central database, located in shared memory so all components

src/hal/hal_lib.c

@@ -3121,7 +3121,7 @@ int rtapi_app_main(void)
     rtapi_print_msg(RTAPI_MSG_DBG,
 	"HAL_LIB: kernel lib installed successfully\n");
 
-    hal_data->realtime_status = rtapi_is_realtime();
+    hal_data->realtime_status = rtapi_realtime_status();
 
     return 0;
 }

src/rtapi/rtai_rtapi.c

@@ -1689,6 +1689,7 @@ unsigned char rtapi_inb(unsigned int port)
 }
 
 int rtapi_is_realtime() { return 1; }
+rtapi_realtime_status_t rtapi_realtime_status(void){ return REALTIME_STATUS_RTAI; }
 int rtapi_is_kernelspace() { return 1; }
 
 /* starting with kernel 2.6, symbols that are used by other modules

src/rtapi/rtapi.h

@@ -985,7 +985,24 @@ int rtapi_spawnp_as_root(pid_t *pid, const char *path,
 #endif
 
 extern int rtapi_is_kernelspace(void);
+
+typedef enum{
+    REALTIME_STATUS_UNINITIALIZED = -1,
+    REALTIME_STATUS_NONE = 0,
+    REALTIME_STATUS_RTAI = 1,
+    REALTIME_STATUS_PREEMT_DYNAMIC = 2,
+    REALTIME_STATUS_PREEMT_RT = 3,
+    REALTIME_STATUS_LXRT = 4,
+    REALTIME_STATUS_XENOMAI = 5,
+    REALTIME_STATUS_XENOMAI_EVL = 6,
+} rtapi_realtime_status_t;
+
+#ifdef RTAPI
+//Only available in real time context
+//In userspace context, use hal_realtime_status()
 extern int rtapi_is_realtime(void);
+extern rtapi_realtime_status_t rtapi_realtime_status(void);
+#endif
 
 int rtapi_open_as_root(const char *filename, int mode);
 

src/rtapi/uspace_rtapi_main.cc

@@ -79,6 +79,20 @@ static inline int detect_preempt_rt() {
 }
 #endif
 
+#ifdef __linux__
+// detect_preempt_dynamic() inspects uname for the PREEMPT_DYNAMIC marker.
+static inline int detect_preempt_dynamic() {
+    struct utsname u;
+    if(uname(&u) < 0) return 0;
+    return strcasestr(u.version, "PREEMPT_DYNAMIC") != 0
+        || strcasestr(u.version, "PREEMPT_DYNAMIC") != 0;
+}
+#else
+static inline int detect_preempt_dynamic() {
+    return 0;
+}
+#endif
+
 // FIXME: detect_rtai/detect_xenomai/detect_xenomai_evl currently gate on
 // setuid because the RTAI/Xenomai backends still need root for iopl()
 // (RTAI) or RTDM device access (Xenomai/EVL).  Long-term these should
@@ -127,10 +141,52 @@ static int detect_xenomai_evl() {
 }
 #endif
 
-// errno from the most recent sched_setscheduler(SCHED_FIFO) probe.  Zero
-// when the probe succeeded or has not run yet.  Read via
-// rtapi_sched_fifo_errno() from diagnostic code.
-static int rtapi_sched_fifo_last_errno = 0;
+static int detect_force(){
+    const char *force = getenv("LINUXCNC_FORCE_REALTIME");
+    if(force != NULL && atoi(force) != 0){
+        return 1;
+    }else{
+        return 0;
+    }
+}
+
+#ifdef __linux__
+// Diagnostic helper: report cap_effective state for a single capability.
+// Returns "yes", "no", or "unknown" if libcap could not introspect.
+static const char *cap_effective_str(cap_t caps, cap_value_t cap) {
+    if (!caps) return "unknown";
+    cap_flag_value_t v;
+    if (cap_get_flag(caps, cap, CAP_EFFECTIVE, &v) != 0) return "unknown";
+    return v == CAP_SET ? "yes" : "no";
+}
+#else
+static const char *cap_effective_str(cap_t caps, cap_value_t cap) {
+    return "unknown";
+}
+#endif
+
+static void report_sched_fifo_error(int sched_err){
+        // Surface the actual reason so the user does not have to guess
+        // between "no caps", "stock kernel", or "wrong rlimits" (issue
+        // #3928).  errno comes from the SCHED_FIFO probe in
+        // can_set_sched_fifo(); cap state comes from libcap.
+        cap_t caps = cap_get_proc();
+        const char *nice_s = cap_effective_str(caps, CAP_SYS_NICE);
+        const char *lock_s = cap_effective_str(caps, CAP_IPC_LOCK);
+        rtapi_print_msg(RTAPI_MSG_ERR,
+            "Note: realtime scheduling unavailable "
+            "(sched_setscheduler SCHED_FIFO: %s).\n"
+            "  Process capabilities: cap_sys_nice=%s cap_ipc_lock=%s.\n"
+            "  Falling back to POSIX non-realtime.\n"
+            "  Fix: 'sudo make setcap' (preferred) or 'sudo make setuid' "
+            "on rtapi_app.\n"
+            "  Override (testing only): set LINUXCNC_FORCE_REALTIME=1.\n",
+            sched_err ? strerror(sched_err) : "denied",
+            nice_s, lock_s);
+#ifdef __linux__
+        if (caps) cap_free(caps);
+#endif
+}
 
 // Success-probe for realtime scheduling: briefly try to set SCHED_FIFO on
 // the calling thread and restore the previous policy.  Succeeds when the
@@ -142,29 +198,63 @@ static int can_set_sched_fifo(void) {
     struct sched_param old_param, probe_param;
     int old_policy = sched_getscheduler(0);
     if(old_policy < 0) {
-        rtapi_sched_fifo_last_errno = errno;
+        report_sched_fifo_error(errno);
         return 0;
     }
     if(sched_getparam(0, &old_param) < 0) {
-        rtapi_sched_fifo_last_errno = errno;
+        report_sched_fifo_error(errno);
         return 0;
     }
 
     memset(&probe_param, 0, sizeof(probe_param));
     probe_param.sched_priority = sched_get_priority_min(SCHED_FIFO);
     if(sched_setscheduler(0, SCHED_FIFO, &probe_param) < 0) {
-        rtapi_sched_fifo_last_errno = errno;
+        report_sched_fifo_error(errno);
         return 0;
     }
 
     // Best-effort restore; if this fails we are still on SCHED_FIFO at
     // minimum priority, which is no worse than where we started.
     sched_setscheduler(0, old_policy, &old_param);
-    rtapi_sched_fifo_last_errno = 0;
     return 1;
 }
 
-static inline int rtapi_sched_fifo_errno(void) { return rtapi_sched_fifo_last_errno; }
+rtapi_realtime_status_t rtapi_realtime_status(void){
+    static rtapi_realtime_status_t cached = REALTIME_STATUS_UNINITIALIZED;
+    if(cached != REALTIME_STATUS_UNINITIALIZED){
+        return cached;
+    }
+
+    if(!detect_force() && !can_set_sched_fifo()){
+        cached = REALTIME_STATUS_NONE;
+        return cached;
+    }
+
+    if(detect_rtai()){
+        cached = REALTIME_STATUS_LXRT;
+        return cached;
+    }
+    if(detect_xenomai()){
+        cached = REALTIME_STATUS_XENOMAI;
+        return cached;
+    }
+    if(detect_xenomai_evl()){
+        cached = REALTIME_STATUS_XENOMAI_EVL;
+        return cached;
+    }
+    if(detect_preempt_rt()){
+        cached = REALTIME_STATUS_PREEMT_RT;
+        return cached;
+    }
+    if(detect_preempt_dynamic()){
+        cached = REALTIME_STATUS_PREEMT_DYNAMIC;
+        return cached;
+    }
+
+    rtapi_print_msg(RTAPI_MSG_ERR, "rtapi_realtime_status(): Bug, something unknown is running\n");
+    cached = REALTIME_STATUS_NONE;
+    return cached;
+}
 
 // rtapi_is_realtime() reports whether this process can actually run
 // realtime code.  This matches the convention used by JACK, PipeWire,
@@ -174,17 +264,7 @@ static inline int rtapi_sched_fifo_errno(void) { return rtapi_sched_fifo_last_er
 // wrapper-based installs like NixOS /run/wrappers) and silently masked
 // LINUXCNC_FORCE_REALTIME (see issue #3928).
 int rtapi_is_realtime() {
-    static int cached = -1;
-    if(cached != -1) return cached;
-
-    const char *force = getenv("LINUXCNC_FORCE_REALTIME");
-    if(force != NULL && atoi(force) != 0)
-        return (cached = 1);
-
-    if(detect_rtai() || detect_xenomai() || detect_xenomai_evl())
-        return (cached = 1);
-
-    return (cached = can_set_sched_fifo());
+    return rtapi_realtime_status() > 0;
 }
 
 struct message_t {
@@ -1149,16 +1229,7 @@ static RtapiApp *makeDllApp(const std::string &dllName, int policy) {
     return result;
 }
 
-// Diagnostic helper: report cap_effective state for a single capability.
-// Returns "yes", "no", or "unknown" if libcap could not introspect.
 #ifdef __linux__
-static const char *cap_effective_str(cap_t caps, cap_value_t cap) {
-    if (!caps) return "unknown";
-    cap_flag_value_t v;
-    if (cap_get_flag(caps, cap, CAP_EFFECTIVE, &v) != 0) return "unknown";
-    return v == CAP_SET ? "yes" : "no";
-}
-
 // Raise CAP_NET_ADMIN into the ambient set so it survives execve() into
 // child processes (iptables, ip6tables) launched by HAL drivers like
 // hm2_eth.  Linux file capabilities on rtapi_app give cap_net_admin in
@@ -1190,59 +1261,34 @@ static void raise_net_admin_ambient(void) {
 
 static RtapiApp *makeApp() {
     RtapiApp *app;
-    bool rt_ok = rtapi_is_realtime();
-    if (!rt_ok) {
-        // Surface the actual reason so the user does not have to guess
-        // between "no caps", "stock kernel", or "wrong rlimits" (issue
-        // #3928).  errno comes from the SCHED_FIFO probe in
-        // can_set_sched_fifo(); cap state comes from libcap.
-        int sched_err = rtapi_sched_fifo_errno();
-#ifdef __linux__
-        cap_t caps = cap_get_proc();
-        const char *nice_s = cap_effective_str(caps, CAP_SYS_NICE);
-        const char *lock_s = cap_effective_str(caps, CAP_IPC_LOCK);
-#else
-        const char *nice_s = "unknown";
-        const char *lock_s = "unknown";
-#endif
-        rtapi_print_msg(RTAPI_MSG_ERR,
-            "Note: realtime scheduling unavailable "
-            "(sched_setscheduler SCHED_FIFO: %s).\n"
-            "  Process capabilities: cap_sys_nice=%s cap_ipc_lock=%s.\n"
-            "  Falling back to POSIX non-realtime.\n"
-            "  Fix: 'sudo make setcap' (preferred) or 'sudo make setuid' "
-            "on rtapi_app.\n"
-            "  Override (testing only): set LINUXCNC_FORCE_REALTIME=1.\n",
-            sched_err ? strerror(sched_err) : "denied",
-            nice_s, lock_s);
-#ifdef __linux__
-        if (caps) cap_free(caps);
-#endif
-    }
-    if (!rt_ok) {
+    rtapi_realtime_status_t rt_status = rtapi_realtime_status();
+    if (rt_status == REALTIME_STATUS_NONE) {
         app = makeDllApp("liblinuxcnc-uspace-posix.so.0", SCHED_OTHER);
     } else {
         WithRoot r;
         harden_rt();
-        if (detect_xenomai_evl()) {
+        if (rt_status == REALTIME_STATUS_XENOMAI_EVL) {
             app = makeDllApp("liblinuxcnc-uspace-xenomai-evl.so.0", SCHED_FIFO);
-        } else if (detect_xenomai()) {
+        } else if (rt_status == REALTIME_STATUS_XENOMAI) {
             app = makeDllApp("liblinuxcnc-uspace-xenomai.so.0", SCHED_FIFO);
-        } else if (detect_rtai()) {
+        } else if (rt_status == REALTIME_STATUS_RTAI) {
             app = makeDllApp("liblinuxcnc-uspace-rtai.so.0", SCHED_FIFO);
-        } else {
+        } else if (rt_status == REALTIME_STATUS_PREEMT_RT || rt_status == REALTIME_STATUS_PREEMT_DYNAMIC) {
             // SCHED_FIFO available but no Xenomai/RTAI backend.  Warn if the
             // kernel is not PREEMPT_RT: SCHED_FIFO still beats SCHED_OTHER,
             // but latency on a PREEMPT_DYNAMIC stock kernel can be tens of
             // milliseconds, which will surprise users who expect the same
             // bounds as a PREEMPT_RT or Xenomai setup.
-            if (!detect_preempt_rt()) {
+            if (rt_status == REALTIME_STATUS_PREEMT_DYNAMIC) {
                 rtapi_print_msg(RTAPI_MSG_ERR,
                     "Note: SCHED_FIFO available but kernel is not PREEMPT_RT.  "
                     "Latency may be unbounded; install a PREEMPT_RT kernel "
                     "for hard realtime guarantees.\n");
             }
             app = makeDllApp("liblinuxcnc-uspace-posix.so.0", SCHED_FIFO);
+        } else {
+            app = nullptr;
+            rtapi_print_msg(RTAPI_MSG_ERR, "Bug: rt_status = %i in not handled\n", rt_status);
         }
     }