Naming: type instead of status

Author: hdiethelm

src/hal/hal.h

@@ -237,7 +237,9 @@ extern int hal_unready(int comp_id);
 */
 extern char* hal_comp_name(int comp_id);
 
-extern rtapi_realtime_status_t hal_realtime_status(void);
+/** hal_get_realtime_type() returns the type of the running real time
+*/
+extern rtapi_realtime_type_t hal_get_realtime_type(void);
 
 /** 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

@@ -537,13 +537,13 @@ char *hal_comp_name(int comp_id)
     return result;
 }
 
-int hal_realtime_status() {
+int hal_get_realtime_type() {
     if (hal_data == 0) {
 	rtapi_print_msg(RTAPI_MSG_ERR,
-	    "HAL: ERROR: hal_realtime_status called before init\n");
+	    "HAL: ERROR: hal_get_realtime_type called before init\n");
 	return -EINVAL;
     }
-    return hal_data->realtime_status;
+    return hal_data->realtime_type;
 }
 
 /***********************************************************************
@@ -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_realtime_status();
+    hal_data->realtime_type = rtapi_realtime_type();
 
     return 0;
 }
@@ -3130,7 +3130,7 @@ void rtapi_app_exit(void)
 {
     hal_thread_t *thread;
 
-    hal_data->realtime_status = -1;
+    hal_data->realtime_type = REALTIME_TYPE_UNINITIALIZED;
 
     rtapi_print_msg(RTAPI_MSG_DBG, "HAL_LIB: removing kernel lib\n");
     hal_proc_clean();
@@ -3289,7 +3289,7 @@ static int init_hal_data(void)
     list_init_entry(&(hal_data->funct_entry_free));
     hal_data->thread_free_ptr = 0;
     hal_data->exact_base_period = 0;
-    hal_data->realtime_status = -1;
+    hal_data->realtime_type = REALTIME_TYPE_UNINITIALIZED;
     /* set up for shmalloc_xx() */
     hal_data->shmem_bot = sizeof(hal_data_t);
     hal_data->shmem_top = HAL_SIZE;

src/hal/hal_priv.h

@@ -275,7 +275,7 @@ typedef struct hal_data_t {
     SHMFIELD(hal_thread_t) thread_free_ptr;	/* list of free thread structs */
     int exact_base_period;      /* if set, pretend that rtapi satisfied our
 				   period request exactly */
-    int realtime_status;        /* reflects the realtime status */
+    rtapi_realtime_type_t realtime_type;	/* reflects the realtime type */
     unsigned char lock;         /* hal locking, can be one of the HAL_LOCK_* types */
 } hal_data_t;
 

src/hal/halmodule.cc

@@ -1829,10 +1829,9 @@ PyObject *get_info_params(PyObject * /*self*/, PyObject * /*args*/) {
     return python_list;
 }
 
-static PyObject *pyhal_realtime_status(PyObject * /*self*/, PyObject * /*o*/) {
-    // hal_ready did not exist in EMC 2.0.x, make it a no-op
+static PyObject *pyhal_get_realtime_type(PyObject * /*self*/, PyObject * /*o*/) {
     TEST_HAL_SHMEM_BASE(__FUNCTION__);
-    int res = hal_realtime_status();
+    int res = hal_get_realtime_type();
     return PyLong_FromLong(res);
 }
 
@@ -2306,8 +2305,8 @@ static PyMethodDef module_methods[] = {
 	".get_info_signals(): Get a list of dicts for all the signals; {NAME:, VALUE:}"},
     {"get_info_params", get_info_params, METH_VARARGS,
 	".get_info_params(): Get a list of dicts for all the parameters; {NAME:, VALUE:}"},
-    {"realtime_status", pyhal_realtime_status, METH_NOARGS,
-        "Call realtime_status"},
+    {"get_realtime_type", pyhal_get_realtime_type, METH_NOARGS,
+        "Call get_realtime_type"},
     {},
 };
 

src/rtapi/rtai_rtapi.c

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

src/rtapi/rtapi.h

@@ -987,21 +987,21 @@ int rtapi_spawnp_as_root(pid_t *pid, const char *path,
 extern int rtapi_is_kernelspace(void);
 
 typedef enum{
-    REALTIME_STATUS_UNINITIALIZED = -1,
-    REALTIME_STATUS_NONE = 0,
-    REALTIME_STATUS_RTAI = 1,
-    REALTIME_STATUS_PREEMPT_DYNAMIC = 2,
-    REALTIME_STATUS_PREEMPT_RT = 3,
-    REALTIME_STATUS_LXRT = 4,
-    REALTIME_STATUS_XENOMAI = 5,
-    REALTIME_STATUS_XENOMAI_EVL = 6,
-} rtapi_realtime_status_t;
+    REALTIME_TYPE_UNINITIALIZED = -1, //Realtime not running, type unknown
+    REALTIME_TYPE_NONE = 0,           //No realtime available
+    REALTIME_TYPE_RTAI = 1,
+    REALTIME_TYPE_PREEMPT_DYNAMIC = 2,
+    REALTIME_TYPE_PREEMPT_RT = 3,
+    REALTIME_TYPE_LXRT = 4,
+    REALTIME_TYPE_XENOMAI = 5,
+    REALTIME_TYPE_XENOMAI_EVL = 6,
+} rtapi_realtime_type_t;
 
 #ifdef RTAPI
 //Only available in real time context
-//In userspace context, use hal_realtime_status()
+//In userspace context, use hal_realtime_type()
 extern int rtapi_is_realtime(void);
-extern rtapi_realtime_status_t rtapi_realtime_status(void);
+extern rtapi_realtime_type_t rtapi_realtime_type(void);
 #endif
 
 int rtapi_open_as_root(const char *filename, int mode);

src/rtapi/uspace_rtapi_main.cc

@@ -221,40 +221,40 @@ static int can_set_sched_fifo(void) {
     return 1;
 }
 
-rtapi_realtime_status_t rtapi_realtime_status(void){
-    static rtapi_realtime_status_t cached = REALTIME_STATUS_UNINITIALIZED;
-    if(cached != REALTIME_STATUS_UNINITIALIZED){
+rtapi_realtime_type_t rtapi_realtime_type(void){
+    static rtapi_realtime_type_t cached = REALTIME_TYPE_UNINITIALIZED;
+    if(cached != REALTIME_TYPE_UNINITIALIZED){
         return cached;
     }
 
     if(!detect_force() && !can_set_sched_fifo()){
-        cached = REALTIME_STATUS_NONE;
+        cached = REALTIME_TYPE_NONE;
         return cached;
     }
 
     if(detect_rtai_lxrt()){
-        cached = REALTIME_STATUS_LXRT;
+        cached = REALTIME_TYPE_LXRT;
         return cached;
     }
     if(detect_xenomai()){
-        cached = REALTIME_STATUS_XENOMAI;
+        cached = REALTIME_TYPE_XENOMAI;
         return cached;
     }
     if(detect_xenomai_evl()){
-        cached = REALTIME_STATUS_XENOMAI_EVL;
+        cached = REALTIME_TYPE_XENOMAI_EVL;
         return cached;
     }
     if(detect_preempt_rt()){
-        cached = REALTIME_STATUS_PREEMPT_RT;
+        cached = REALTIME_TYPE_PREEMPT_RT;
         return cached;
     }
     if(detect_preempt_dynamic()){
-        cached = REALTIME_STATUS_PREEMPT_DYNAMIC;
+        cached = REALTIME_TYPE_PREEMPT_DYNAMIC;
         return cached;
     }
 
-    rtapi_print_msg(RTAPI_MSG_ERR, "rtapi_realtime_status(): Bug, something unknown is running\n");
-    cached = REALTIME_STATUS_PREEMPT_DYNAMIC;
+    rtapi_print_msg(RTAPI_MSG_ERR, "rtapi_realtime_type(): Bug, something unknown is running\n");
+    cached = REALTIME_TYPE_PREEMPT_DYNAMIC;
     return cached;
 }
 
@@ -266,7 +266,7 @@ rtapi_realtime_status_t rtapi_realtime_status(void){
 // wrapper-based installs like NixOS /run/wrappers) and silently masked
 // LINUXCNC_FORCE_REALTIME (see issue #3928).
 int rtapi_is_realtime() {
-    return rtapi_realtime_status() > 0;
+    return rtapi_realtime_type() > 0;
 }
 
 struct message_t {
@@ -1263,25 +1263,25 @@ static void raise_net_admin_ambient(void) {
 
 static RtapiApp *makeApp() {
     RtapiApp *app;
-    rtapi_realtime_status_t rt_status = rtapi_realtime_status();
-    if (rt_status == REALTIME_STATUS_NONE) {
+    rtapi_realtime_type_t rt_type = rtapi_realtime_type();
+    if (rt_type == REALTIME_TYPE_NONE) {
         app = makeDllApp("liblinuxcnc-uspace-posix.so.0", SCHED_OTHER);
     } else {
         WithRoot r;
         harden_rt();
-        if (rt_status == REALTIME_STATUS_XENOMAI_EVL) {
+        if (rt_type == REALTIME_TYPE_XENOMAI_EVL) {
             app = makeDllApp("liblinuxcnc-uspace-xenomai-evl.so.0", SCHED_FIFO);
-        } else if (rt_status == REALTIME_STATUS_XENOMAI) {
+        } else if (rt_type == REALTIME_TYPE_XENOMAI) {
             app = makeDllApp("liblinuxcnc-uspace-xenomai.so.0", SCHED_FIFO);
-        } else if (rt_status == REALTIME_STATUS_LXRT) {
+        } else if (rt_type == REALTIME_TYPE_LXRT) {
             app = makeDllApp("liblinuxcnc-uspace-rtai.so.0", SCHED_FIFO);
-        } else if (rt_status == REALTIME_STATUS_PREEMPT_RT || rt_status == REALTIME_STATUS_PREEMPT_DYNAMIC) {
+        } else if (rt_type == REALTIME_TYPE_PREEMPT_RT || rt_type == REALTIME_TYPE_PREEMPT_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 (rt_status == REALTIME_STATUS_PREEMPT_DYNAMIC) {
+            if (rt_type == REALTIME_TYPE_PREEMPT_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 "
@@ -1290,7 +1290,7 @@ static RtapiApp *makeApp() {
             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);
+            rtapi_print_msg(RTAPI_MSG_ERR, "Bug: rt_type = %i in not handled\n", rt_type);
         }
     }