+ SDL diagram

~ refactoring

Bearbeiten2.c

@@ -3,6 +3,10 @@
 
 #include <uint128.h>
 #include <sys/rtai_modbus.h>
+#include "include/rtai_lxrt.h"
+#include "include/rtai_modbus.h"
+#include "include/rtai_sem.h"
+#include "include/rtai_mbx.h"
 
 #define SENSOR_PART_TURNTABLE 1<<0
 #define SENSOR_PART_DRILL 1<<1
@@ -24,21 +28,40 @@
 MODULE_LICENSE("GPL");
 
 static RT_TASK turntable_task, drill_task, tester_task, output_task;
-static MBX drill_mbx, tester_mbx, output_mbx;
+static MBX tester_mbx, output_mbx;
 static SEM semaphore;
 
+int connection;
+
 char node[] = "modbus-node";
 
+void fail() {
+    rt_modbus_disconnect(connection);
+    rt_task_delete(&turntable_task);
+    rt_task_delete(&tester_task);
+    rt_task_delete(&drill_task);
+    rt_task_delete(&output_task);
+
+    rt_mbx_delete(&tester_mbx);
+    rt_mbx_delete(&output_mbx);
+    rt_sem_delete(&semaphore);
+
+    stop_rt_timer();
+
+    rt_printk("failed to read/send Modbus message.\n");
+    rt_printk("module needs to be restarted.\n");
+}
+
 /**
- * read all bits of the specified type
+ * readData all bits of the specified type
  * this function is *not* thread safe.
  * @param type (DIGITAL_IN, DIGITAL_OUT, ANALOG_IN, ANALOG_OUT)
  * @param connection modbus connection id
  * @param result value to write the result to
  * @return status code(0: success, 1: failure)
  */
-int readAll(int type, int connection, int *result) {
+int readAll(int type, int *result) {
-    return rt_modbus_get(fd_node, type, 0, (unsigned short *) &result));
+    return rt_modbus_get(connection, type, 0, (unsigned short *) &result));
 }
 
 /**
@@ -49,10 +72,10 @@ int readAll(int type, int connection, int *result) {
  * @param result value to write the result to
  * @return status code(0: success, 1: failure)
  */
-int read(int connection, int part, int *result) {
+int readData(int part, int *result) {
     rt_sem_wait(&semaphore);
     int value;
-    int code = readAll(DIGITAL_IN, connection, &value);
+    int code = readAll(DIGITAL_IN, &value);
     *result = (value & part) != 0;
     rt_sem_signal(&semaphore);
     return code;
@@ -63,16 +86,15 @@ int read(int connection, int part, int *result) {
  * this function is thread safe.
  * @param connection modbus connection id
  * @param actor bitmask of the actor to disable
- * @return status code(0: success, 1: failure)
  */
-int disable(int connection, int actor) {
+void disable(int actor) {
     rt_sem_wait(&semaphore);
     int value;
-    int code = readAll(DIGITAL_OUT, connection, &value);
+    int code = readAll(DIGITAL_OUT, &value);
-    if (code) return code;
+    if(code) fail();
-    int result = rt_modbus_set(connection, DIGITAL_OUT, output &= ~actor)
+    int result = rt_modbus_set(connection, DIGITAL_OUT, value &= ~actor)
     rt_sem_signal(&semaphore);
-    return result;
+    if (result) fail();
 }
 
 /**
@@ -80,155 +102,99 @@ int disable(int connection, int actor) {
  * this function is thread safe.
  * @param connection modbus connection id
  * @param actor bitmask of the actor to enable
- * @return status code (0: success, 1: failure)
  */
-int enable(int connection, int actor) {
+void enable(int actor) {
     rt_sem_wait(&semaphore);
     int output;
-    int code = readAll(DIGITAL_OUT, connection, &output);
+    int code = readAll(DIGITAL_OUT, &output);
-    if (code) return code;
+    if (code) fail();
     int result = rt_modbus_set(connection, DIGITAL_OUT, output |= actor)
     rt_sem_signal(&semaphore);
-    return result;
+    if(result) fail();
 }
 
-void sleep() {
+void sleepStuff() {
     rt_sleep(1000 * nano2count(1000000));
 }
 
 static void turntable(long x) {
-    int connection;
-
-    rt_printk("turntable: task started\n");
-
-    if ((connection = rt_modbus_connect(node)) == -1) {
-        rt_printk("turntable: could not connect to %s\n", node);
-        return;
-    }
     rt_printk("turntable: MODBUS communication opened\n");
 
-    disable(connection, ACTOR_TURNTABLE);
+    disable(ACTOR_TURNTABLE);
 
     while (1) {
         int partOnTable;
-        if (read(connection, SENSOR_PART_TURNTABLE, &partOnTable)) goto fail;
+        readData(SENSOR_PART_TURNTABLE, &partOnTable);
-
         if (partOnTable) {
-            if (enable(connection, ACTOR_TURNTABLE)) goto fail;
+            enable(ACTOR_TURNTABLE);
 
         } else {
-            if (disable(connection, ACTOR_TURNTABLE)) goto fail;
+            disable(ACTOR_TURNTABLE);
         }
 
         rt_task_resume(&drill_task);
         rt_task_resume(&tester_task);
         rt_task_resume(&output_task);
-
-        //rt_sleep(1000 * nano2count(1000000));
     }
 
-/* Aufraeumen */
-    fail:
-    rt_modbus_disconnect(connection);
-    rt_printk("turntable: task exited with failure\n");
 }
 
 static void drill(long x) {
-    int connection;
 
-    rt_printk("drill: task started\n");
-    if ((connection = rt_modbus_connect(node)) == -1) {
-        rt_printk("drill: could not connect to %s\n", node);
-        return;
-    }
     rt_printk("drill: MODBUS communication opened\n");
-    disable(connection, ACTOR_DRILL);
+    disable(ACTOR_DRILL);
-    disable(connection, ACTOR_PART_HOLD);
+    disable(ACTOR_PART_HOLD);
-    disable(connection, ACTOR_DRILL_DOWN);
+    disable(ACTOR_DRILL_DOWN);
 
-    enable(connection, ACTOR_DRILL_UP);
+    enable(ACTOR_DRILL_UP);
+    rt_sem_wait(&semaphore);
     int drill_up = 0;
-    if (read(connection, SENSOR_DRILL_UP, drill_up)) goto fail;
+    readData(SENSOR_DRILL_UP, drill_up);
     if (!drill_up) {
         do {
-            read(connection, SENSOR_DRILL_UP, drill_up);
+            readData(SENSOR_DRILL_UP, drill_up);
         } while (drill_up == 0);
     }
-    disable(connection, ACTOR_DRILL_UP);
+    rt_sem_signal(&semaphore);
+    disable(ACTOR_DRILL_UP);
 
     while (1) {
 
-        sleep();
+        sleepStuff();
     }
-
-
-    fail:
-    rt_modbus_disconnect(connection);
-    rt_printk("drill: task exited with failure\n");
 }
 
 static void tester(long x) {
-    int connection;
-
-    rt_printk("tester: task started\n");
-    if ((connection = rt_modbus_connect(node)) == -1) {
-        rt_printk("tester: could not connect to %s\n", node);
-        return;
-    }
 
     while (1) {
 
-        sleep();
+        sleepStuff();
     }
-
-
-    fail:
-    rt_modbus_disconnect(connection);
-    rt_printk("tester: task exited with failure\n");
 }
 
 static void output(long x) {
-    int connection;
-
-    rt_printk("output: task started\n");
-    if ((connection = rt_modbus_connect(node)) == -1) {
-        rt_printk("output: could not connect to %s\n", node);
-        return;
-    }
-
     while (1) {
 
-        sleep();
+        sleepStuff();
     }
-
-
-    fail:
-    rt_modbus_disconnect(connection);
-    rt_printk("output: task exited with failure\n");
-}
-
-static void __exit
-
-example_exit(void) {
-    rt_task_delete(&turntable_task);
-    rt_task_delete(&drill_task);
-    rt_task_delete(&tester_task);
-    rt_task_delete(&output_task);
-    stop_rt_timer();
-    rt_sem_delete(&semaphore);
-    printk("module Bearbeiten2 unloaded\n");
 }
 
 static int __init
-
 example_init(void) {
     rt_set_oneshot_mode();
     start_rt_timer(0);
     modbus_init();
 
+
+    rt_printk("init: task started\n");
+    if ((connection = rt_modbus_connect(node)) == -1) {
+        rt_printk("init: could not connect to %s\n", node);
+        return;
+    }
+
     rt_sem_init(&semaphore, 1);
 
-    if (rt_task_init(&turntable_task, turntable, 0, 1024, 0, 0, NULL)) {
+    if (rt_task_init(&turntable_task, turntable, 0, 1024, 10, 0, NULL)) {
         printk("turntable: cannot initialize task\n");
         goto fail;
     }
@@ -254,5 +220,16 @@ example_init(void) {
     return (1);
 }
 
+static void __exit
+example_exit(void) {
+    rt_task_delete(&turntable_task);
+    rt_task_delete(&drill_task);
+    rt_task_delete(&tester_task);
+    rt_task_delete(&output_task);
+    stop_rt_timer();
+    rt_sem_delete(&semaphore);
+    printk("module Bearbeiten2 unloaded\n");
+}
+
 module_exit(example_exit)
 module_init(example_init)

CMakeLists.txt

@@ -1,4 +1,7 @@
 cmake_minimum_required(VERSION 3.3)
 project(Echtzeitdatenverarbeitung)
 
+SET(CMAKE_C_STANDARD C99)
+
+include_directories("include")
 add_executable(Bearbeiten2 Bearbeiten2.c)

README.md

@@ -0,0 +1 @@
+![SDL Diagramm](https://files.joethei.space/documentation/diagram.png)

diagram.puml

@@ -0,0 +1,96 @@
+@startuml
+
+partition Drehteller {
+
+start
+
+:Drehteller ausschalten;
+while(true) is (true)
+ if(Sensor aktiv ?) then (true)
+    :drehen an;
+ else (false)
+    :drehen aus;
+ endif
+
+endwhile (false)
+stop
+}
+
+partition Prüfer {
+
+start
+:Prüfer einfahren;
+while(Dauerschleife) is (true)
+ if(Werkstück vorhanden ?) then (true)
+    :Prüfer ausfahren;
+    if(Werkstück Normallage ?) then (true)
+        :Bohrer(on)>
+    else (false)
+        :Bohrer(off)>
+    endif
+    :Prüfer einfahren;
+ else (false)
+ endif
+
+endwhile (false)
+stop
+}
+
+partition Bohrer {
+
+start
+:Bohrer ausschalten;
+:Bohrer hochfahren;
+:Werkstück loslassen;
+while(Dauerschleife) is (true)
+
+if(Werkstück vorhanden?) then(true)
+    :Bohrer<
+    :Auswerfer>
+    if(Normallage) then(true)
+        :Werkstück festhalten;
+        :Bohrer anschalten;
+        :Bohrer herunterfahren;
+    if(Bohrer unten) then (true)
+        :sleepStuff 500ms;
+        :Bohrer hochfahren;
+    endif
+
+    if(Bohrer oben) then (true)
+        :Bohrer ausschalten;
+        :Werkstück loslassen;
+    endif
+    else(false)
+    endif
+
+else (false)
+endif
+
+endwhile(false)
+
+stop
+
+}
+
+partition Auswerfer {
+
+start
+:Auswerfer einfahren;
+while(Dauerschleife) is (true)
+
+:Auswerfer<
+note right
+    oder eher ne if hier ?
+end note
+:Auswerfen;
+
+endwhile(false)
+
+stop
+
+}
+
+
+
+
+@enduml

include/rtai.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 1999-2015 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_RTAI_H
+#define _RTAI_RTAI_H
+
+#ifdef __KERNEL__
+#include <linux/version.h>
+#endif /* __KERNEL__ */
+
+#include <asm/rtai.h>
+
+#ifdef __KERNEL__
+// see: Computing Practices, ACM, vol. 31, n. 10, 1988, pgs 1192-1201.
+
+#define TWOPWR31M1 2147483647  // 2^31 - 1
+
+static inline long next_rand(long rand)
+{
+	const long a = 16807;
+	const long m = TWOPWR31M1;
+	const long q = 127773;
+	const long r = 2836;
+
+	long lo, hi;
+
+	hi = rand/q;
+	lo = rand - hi*q;
+	rand = a*lo - r*hi;
+	if (rand <= 0) {
+		rand += m;
+	}
+	return rand;
+}
+
+static inline long irandu(unsigned long range)
+{
+	static long seed = 783637;
+	const long m = TWOPWR31M1;
+
+	seed = next_rand(seed);
+	return rtai_imuldiv(seed, range, m);
+}
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_RTAI_H */

include/rtai_defs.h.in

@@ -0,0 +1,26 @@
+/*
+ * Re-written and fixed by Alec Ari
+ * Copyright (C) 1999-2016 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef RTAI_DEFS_H
+#define RTAI_DEFS_H
+
+#define RTAI_INSTALL_DIR	"@prefix@"
+
+#endif /* RTAI_DEFS_H */

include/rtai_fifos.h

@@ -0,0 +1,797 @@
+/**
+ * @ingroup fifos
+ * @ingroup fifos_ipc
+ * @ingroup fifos_sem
+ * @file
+ *
+ * Interface of the @ref fifos "RTAI FIFO module".
+ *
+ * @note Copyright &copy; 1999-2003 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_FIFOS_H
+#define _RTAI_FIFOS_H
+
+#include <rtai_types.h>
+
+#define MAX_FIFOS 64
+
+#define RTAI_FIFOS_MAJOR 150
+
+#define RESET		 	1
+#define RESIZE		 	2
+#define RTF_SUSPEND_TIMED	3
+#define OPEN_SIZED	 	4
+#define READ_ALL_AT_ONCE 	5
+#define READ_TIMED	 	6
+#define WRITE_TIMED	 	7
+#define RTF_SEM_INIT	 	8
+#define RTF_SEM_WAIT	 	9
+#define RTF_SEM_TRYWAIT		10
+#define RTF_SEM_TIMED_WAIT	11
+#define RTF_SEM_POST		12
+#define RTF_SEM_DESTROY		13
+#define SET_ASYNC_SIG		14
+#define EAVESDROP		19
+#define OVRWRITE		20
+#define READ_IF         	21
+#define WRITE_IF        	22
+#define RTF_NAMED_CREATE    	23
+
+#define RTF_GET_N_FIFOS		15
+#define RTF_GET_FIFO_INFO	16
+#define RTF_CREATE_NAMED	17
+#define RTF_NAME_LOOKUP		18
+
+#define RTF_NAMELEN 15
+
+struct rt_fifo_info_struct{
+    	unsigned int fifo_number;
+	unsigned int size;
+	unsigned int opncnt;
+	int avbs, frbs;
+	char name[RTF_NAMELEN+1];
+};
+
+struct rt_fifo_get_info_struct{
+    	unsigned int fifo;
+	unsigned int n;
+	struct rt_fifo_info_struct *ptr;
+};
+
+#define  FUN_FIFOS_LXRT_INDX 10
+
+#define _CREATE         0
+#define _DESTROY        1
+#define _PUT            2
+#define _GET            3
+#define _RESET          4
+#define _RESIZE         5
+#define _SEM_INIT       6
+#define _SEM_DESTRY     7
+#define _SEM_POST       8
+#define _SEM_TRY        9
+#define _CREATE_NAMED  10
+#define _GETBY_NAME    11
+#define _OVERWRITE     12
+#define _PUT_IF        13
+#define _GET_IF        14
+#define _NAMED_CREATE  15
+#define _AVBS          16
+#define _FRBS          17
+
+#ifdef __KERNEL__
+
+#include <rtai.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+int __rtai_fifos_init(void);
+
+void __rtai_fifos_exit(void);
+
+int rtf_init(void);
+
+typedef int (*rtf_handler_t)(unsigned int fifo, int rw);
+
+/* Attach a handler to an RT-FIFO.
+ *
+ * Allow function handler to be called when a user process reads or writes to 
+ * the FIFO. When the function is called, it is passed the fifo number as the 
+ * argument.
+ */
+
+int rtf_create_handler(unsigned int fifo,	/* RT-FIFO */
+		       void *handler		/* function to be called */);
+
+
+/**
+ * @ingroup fifos_ipc
+ * Extended fifo handler.
+ *
+ * The usage of X_FIFO_HANDLER(handler) allows to install an extended handler,
+ * i.e. one prototyped as:
+ * @code
+ * int (*handler)(unsigned int fifo, int rw);
+ * @endcode
+ * to allow the user to easily understand if the handler was called at fifo
+ * read (@a rw is 'r') or write (rw is 'w').
+ */
+#define X_FIFO_HANDLER(handler) ((int (*)(unsigned int, int rw))(handler))
+
+/* Create an RT-FIFO.
+ * 
+ * An RT-FIFO fifo is created with initial size of size.
+ * Return value: On success, 0 is returned. On error, -1 is returned.
+ */
+#undef rtf_create
+RTAI_SYSCALL_MODE int rtf_create(unsigned int fifo, int size);
+
+/* Create an RT-FIFO with a name and size.
+ *
+ * An RT-FIFO is created with a name of name, it will be allocated
+ * the first unused minor number and will have a user assigned size.
+ * Return value: On success, the allocated minor number is returned.
+ *               On error, -errno is returned.
+ */
+
+int rtf_named_create(const char *name, int size);
+
+/* Create an RT-FIFO with a name.
+ *
+ * An RT-FIFO is created with a name of name, it will be allocated
+ * the first unused minor number and will have a default size.
+ * Return value: On success, the allocated minor number is returned. 
+ *               On error, -errno is returned.
+ */
+
+RTAI_SYSCALL_MODE int rtf_create_named(const char *name);
+
+/* Look up a named RT-FIFO.
+ *
+ * Find the RT-FIFO with the name name.
+ * Return value: On success, the minor number is returned. 
+ *               On error, -errno is returned.
+ */
+
+RTAI_SYSCALL_MODE int rtf_getfifobyname(const char *name);
+
+/* Reset an RT-FIFO.
+ * 
+ * An RT-FIFO fifo is reset by setting its buffer pointers to zero, so
+ * that any existing data is discarded and the fifo started anew like at its
+ * creation.
+ */
+
+RTAI_SYSCALL_MODE int rtf_reset(unsigned int fifo);
+
+/* destroy an RT-FIFO.
+ * 
+ * Return value: On success, 0 is returned.
+ */
+
+RTAI_SYSCALL_MODE int rtf_destroy(unsigned int fifo);
+
+
+/* Resize an RT-FIFO.
+ * 
+ * Return value: size is returned on success. On error, a negative value
+ * is returned.
+ */
+
+RTAI_SYSCALL_MODE int rtf_resize(unsigned int minor, int size);
+
+
+/* Write to an RT-FIFO.
+ *
+ * Try to write count bytes to an FIFO. Returns the number of bytes written.
+ */
+
+RTAI_SYSCALL_MODE int rtf_put(unsigned int fifo,	/* RT-FIFO */
+	    void * buf,		/* buffer address */
+	    int count		/* number of bytes to write */);
+
+
+
+/* Write to an RT-FIFO, over writing if there is not enough space.
+ *
+ * Try to write count bytes to an FIFO. Returns 0.
+ */
+
+RTAI_SYSCALL_MODE int rtf_ovrwr_put(unsigned int fifo,	/* RT-FIFO */
+		  void * buf,		/* buffer address */
+		  int count		/* number of bytes to write */);
+
+
+
+/* Write atomically to an RT-FIFO.
+ *
+ * Try to write count bytes in block to an FIFO. Returns the number of bytes
+ * written.
+ */
+
+extern RTAI_SYSCALL_MODE int rtf_put_if (unsigned int fifo,	/* RT-FIFO */
+		void * buf,			/* buffer address */
+	       	int count			/* number of bytes to write */);
+
+/* Read from an RT-FIFO.
+ *
+ * Try to read count bytes from a FIFO. Returns the number of bytes read.
+ */
+
+RTAI_SYSCALL_MODE int rtf_get(unsigned int fifo,	/* RT-FIFO */
+	    void * buf, 		/* buffer address */
+	    int count		/* number of bytes to read */);
+
+
+/* Atomically read from an RT-FIFO.
+ *
+ * Try to read count bytes in a block from an FIFO. Returns the number of bytes read.
+ */
+
+RTAI_SYSCALL_MODE int rtf_get_if(unsigned int fifo,	/* RT-FIFO */
+	    void * buf, 		/* buffer address */
+	    int count		/* number of bytes to read */);
+
+
+/* 
+ * Preview the an RT-FIFO content.
+ */
+
+int rtf_evdrp(unsigned int fifo,	/* RT-FIFO */
+	      void * buf, 		/* buffer address */
+	      int count		/* number of bytes to read */);
+
+/* Open an RT-FIFO semaphore.
+ *
+ */
+
+RTAI_SYSCALL_MODE int rtf_sem_init(unsigned int fifo,	/* RT-FIFO */
+		 int value			/* initial semaphore value */);
+
+
+/* Post to an RT-FIFO semaphore.
+ *
+ */
+
+RTAI_SYSCALL_MODE int rtf_sem_post(unsigned int fifo	/* RT-FIFO */);
+
+
+/* Try to acquire an RT-FIFO semaphore.
+ *
+ */
+
+RTAI_SYSCALL_MODE int rtf_sem_trywait(unsigned int fifo	/* RT-FIFO */);
+
+
+/* Destroy an RT-FIFO semaphore.
+ *
+ */
+
+RTAI_SYSCALL_MODE int rtf_sem_destroy(unsigned int fifo	/* RT-FIFO */);
+
+#define rtf_sem_delete rtf_sem_destroy
+
+
+/* Get an RT-FIFO free bytes in buffer.
+ *
+ */
+
+RTAI_SYSCALL_MODE int rtf_get_frbs(unsigned int fifo /* RT-FIFO */);
+
+/* Just for compatibility with earlier rtai_fifos releases. No more bh and user
+buffers. Fifos are now awakened immediately and buffers > 128K are vmalloced */
+
+#define rtf_create_using_bh(fifo, size, bh_list) rtf_create(fifo, size)
+#define rtf_create_using_bh_and_usr_buf(fifo, buf, size, bh_list) rtf_create(fifo, size)
+#define rtf_destroy_using_usr_buf(fifo) rtf_destroy(fifo)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else  /* !__KERNEL__ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <rtai_lxrt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+RTAI_PROTO(int, rtf_create,(unsigned int fifo, int size))
+{
+	struct { unsigned long fifo, size; } arg = { fifo, size }; 
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _CREATE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_destroy,(unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _DESTROY, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_put,(unsigned int fifo, const void *buf, int count))
+{
+	struct { unsigned long fifo; const void *buf; long count; } arg = { fifo, buf, count };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _PUT, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_put_if,(unsigned int fifo, const void *buf, int count))
+{
+	struct { unsigned long fifo; const void *buf; long count; } arg = { fifo, buf, count };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _PUT_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_get,(unsigned int fifo, void *buf, int count))
+{
+	struct { unsigned long fifo; void *buf; long count; } arg = { fifo, buf, count };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _GET, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_get_if,(unsigned int fifo, void *buf, int count))
+{
+	struct { unsigned long fifo; void *buf; long count; } arg = { fifo, buf, count };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _GET_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_get_avbs, (unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _AVBS, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_get_frbs, (unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _FRBS, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_reset_lxrt,(unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _RESET, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_resize_lxrt,(unsigned int fifo, int size))
+{
+	struct { unsigned long fifo, size; } arg = { fifo, size }; 
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _RESIZE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_sem_init_lxrt,(unsigned int fifo, int value))
+{
+	struct { unsigned long fifo, value; } arg = { fifo, value }; 
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_INIT, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_sem_post_lxrt,(unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo }; 
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_POST, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_sem_trywait_lxrt,(unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo }; 
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_TRY, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_sem_destroy_lxrt,(unsigned int fifo))
+{
+	struct { unsigned long fifo; } arg = { fifo }; 
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_DESTRY, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_named_create_lxrt,(const char *name, int size))
+{
+	int len;
+	char lname[len = strlen(name)];
+	struct { char * name; long size; } arg = { lname, size };
+	strncpy(lname, name, len);
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _NAMED_CREATE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_create_named_lxrt,(const char *name))
+{
+	int len;
+	char lname[len = strlen(name)];
+	struct { char * name; } arg = { lname };
+	strncpy(lname, name, len);
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _CREATE_NAMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_getfifobyname_lxrt,(const char *name))
+{
+	int len;
+	char lname[len = strlen(name)];
+	struct { char * name; } arg = { lname };
+	strncpy(lname, name, len);
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _GETBY_NAME, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_ovrwr_put,(unsigned int fifo, const void *buf, int count))
+{
+	struct { unsigned long fifo; const void *buf; long count; } arg = { fifo, buf, count };
+	return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _OVERWRITE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rtf_reset,(int fd))
+{
+	int ret = ioctl(fd, RESET);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_resize,(int fd, int size))
+{
+	int ret = ioctl(fd, RESIZE, size);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_ipc
+ * Suspend a process for some time
+ *
+ * rtf_suspend_timed suspends a Linux process according to @a delay.
+ *
+ * @param fd is the file descriptor returned at fifo open, rtf_suspend_timed
+ * needs a fifo support.
+ * @param ms_delay is the timeout time in milliseconds.
+ *
+ * @note The standard, clumsy, way to achieve the same result is to use select
+ * with null file arguments, for long sleeps, with seconds resolution, sleep is
+ * also available.
+ */
+RTAI_PROTO(int, rtf_suspend_timed,(int fd, int ms_delay))
+{
+	int ret = ioctl(fd, RTF_SUSPEND_TIMED, ms_delay);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_ipc
+ * Create a real-time FIFO
+ *
+ * rtf_open_sized is the equivalent of rtf_create() in user space; it creates a
+ * real-time fifo (RT-FIFO) of initial size @a size.
+ *
+ * @param size is the requested size for the fifo. 
+ * 
+ * The RT-FIFO is a character based mechanism to communicate among real-time
+ * tasks and ordinary Linux processes. The rtf_* functions are used by the
+ * real-time tasks; Linux processes use standard character device access
+ * functions such as read, write, and select.
+ *
+ * If this function finds an existing fifo of lower size it resizes it to the
+ * larger new size. Note that the same condition apply to the standard Linux
+ * device open, except that when it does not find any already existing fifo it
+ * creates it with a default size of 1K bytes.
+ *
+ * It must be remarked that practically any fifo size can be asked for. In
+ * fact if @a size is within the constraint allowed by kmalloc such a function
+ * is used, otherwise vmalloc is called, thus allowing any size that can fit
+ * into the available core memory.
+ *
+ * Multiple calls of this function are allowed, a counter is kept internally to
+ * track their number, and avoid destroying/closing a fifo that is still used.
+ *
+ * @return the usual Unix file descriptor on succes, to be used in standard reads
+ * and writes. 
+ * @retval -ENOMEM if the necessary size could not be allocated for the RT-FIFO.
+ *
+ * @note In user space, the standard UNIX open acts like rtf_open_sized with a
+ * default 1K size.
+ */
+RTAI_PROTO(int, rtf_open_sized,(const char *dev, int perm, int size))
+{
+	int fd;
+
+	if ((fd = open(dev, perm)) < 0) { 
+		return -errno;
+	}
+	if (ioctl(fd, RESIZE, size) < 0) {
+	    	close(fd);
+		return -errno;
+	}
+	return fd; 
+}
+
+RTAI_PROTO(int, rtf_evdrp,(int fd, void *buf, int count))
+{
+	struct { void *buf; long count; } args = { buf, count };
+	int ret = ioctl(fd, EAVESDROP, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_ipc
+ * Read data from FIFO in user space, waiting for all of them
+ *
+ * rtf_read_all_at_once reads a block of data from a real-time fifo identified
+ * by the file descriptor @a fd blocking till all waiting at most @a count
+ * bytes are available, whichever option was used at the related device
+ * opening.
+ *
+ * @param fd is the file descriptor returned at fifo open.
+ * @param buf points the block of data to be written.
+ * @param count is the size in bytes of the buffer.
+ *
+ * @return the number of bytes read on success.
+ * @retval -EINVAL if @a fd refers to a not opened fifo.
+ */
+RTAI_PROTO(int, rtf_read_all_at_once,(int fd, void *buf, int count))
+{
+	struct { void *buf; long count; } args = { buf, count };
+	int ret = ioctl(fd, READ_ALL_AT_ONCE, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_ipc
+ * Read data from FIFO in user space, with timeout.
+ *
+ * rtf_read_timed reads a block of data from a real-time fifo identified by the
+ * file descriptor @a fd waiting at most @a delay milliseconds to complete the
+ * operation.
+ *
+ * @param fd is the file descriptor returned at fifo open.
+ * @param buf points the block of data to be written.
+ * @param count is the size of the block in bytes.
+ * @param ms_delay is the timeout time in milliseconds.
+ *
+ * @return the number of bytes read is returned on success or timeout. Note that
+ * this value may be less than @a count if @a count bytes of free space is not
+ * available in the fifo or a timeout occured.
+ * @retval -EINVAL if @a fd refers to a not opened fifo.
+ *
+ * @note The standard, clumsy, Unix way to achieve the same result is to use
+ * select.
+ */
+RTAI_PROTO(int, rtf_read_timed,(int fd, void *buf, int count, int ms_delay))
+{
+	struct { void *buf; long count, delay; } args = { buf, count, ms_delay };
+	int ret = ioctl(fd, READ_TIMED, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_read_if,(int fd, void *buf, int count))
+{
+	struct { void *buf; long count; } args = { buf, count };
+	int ret = ioctl(fd, READ_IF, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_ipc
+ * Write data to FIFO in user space, with timeout.
+ *
+ * rtf_write_timed writes a block of data to a real-time fifo identified by the
+ * file descriptor @a fd waiting at most @æ delay milliseconds to complete the
+ * operation.
+ *
+ * @param fd is the file descriptor returned at fifo open.
+ * @param buf points the block of data to be written.
+ * @param count is the size of the block in bytes.
+ * @param ms_delay is the timeout time in milliseconds.
+ *
+ * @return the number of bytes written on succes. Note that this value may
+ * be less than @a count if @a count bytes of free space is not available in the
+ * fifo.
+ * @retval -EINVAL if @a fd refers to a not opened fifo.
+ *
+ * @note The standard, clumsy, Unix way to achieve the same result is to use
+ * select.
+ */
+RTAI_PROTO(int, rtf_write_timed,(int fd, void *buf, int count, int ms_delay))
+{
+	struct { void *buf; long count, delay; } args = { buf, count, ms_delay };
+	int ret = ioctl(fd, WRITE_TIMED, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_overwrite,(int fd, void *buf, int count))
+{
+	struct { void *buf; long count; } args = { buf, count };
+	int ret = ioctl(fd, OVRWRITE, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_write_if,(int fd, void *buf, int count))
+{
+	struct { void *buf; long count; } args = { buf, count };
+	int ret = ioctl(fd, WRITE_IF, &args);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_sem_init,(int fd, int value))
+{
+	int ret = ioctl(fd, RTF_SEM_INIT, value);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_sem
+ * Take a semaphore.
+ *
+ * rtf_sem_wait waits for a event to be posted (signaled) to a semaphore. The
+ * semaphore value is set to tested and set to zero.   If it was one
+ * rtf_sem_wait returns immediately. Otherwise the caller process is blocked and
+ * queued up in a priority order based on is POSIX real time priority.
+ *
+ * A process blocked on a semaphore returns when:
+ * - the caller task is in the first place of the waiting queue and somebody
+ *   issues a rtf_sem_post; 
+ * - an error occurs (e.g. the semaphore is destroyed).
+ *
+ * @param fd is the file descriptor returned by standard UNIX open in user space
+ * 
+ * Since it is blocking rtf_sem_waitcannot be used both in kernel and user
+ * space.
+ *
+ * @retval 0 on success.
+ * @retval -EINVAL if @a fd_fifo  refers to an invalid file descriptor or fifo.
+ */
+RTAI_PROTO(int, rtf_sem_wait,(int fd))
+{
+	int ret = ioctl(fd, RTF_SEM_WAIT);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_sem_trywait,(int fd))
+{
+	int ret = ioctl(fd, RTF_SEM_TRYWAIT);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_sem
+ * Wait a semaphore with timeout
+ *
+ * rtf_sem_timed_wait is a timed version of the standard semaphore wait
+ * call. The semaphore value is tested and set to zero. If it was one
+ * rtf_sem_timed_wait returns immediately. Otherwise the caller process is
+ * blocked and queued up in a priority order based on is POSIX real time
+ * priority.
+ *
+ * A process blocked on a semaphore returns when:
+ * - the caller task is in the first place of the waiting queue and somebody
+ *   issues a rtf_sem_post;
+ * - timeout occurs;
+ * - an error occurs (e.g. the semaphore is destroyed).
+ *
+ * @param fd is the file descriptor returned by standard UNIX open in user
+ * space. In case of timeout the semaphore value is set to one before return.
+ * @param ms_delay is in milliseconds and is relative to the Linux current time.
+ *
+ * Since it is blocking rtf_sem_timed_wait cannot be used both in kernel and
+ * user space.
+ *
+ * @retval 0 on success.
+ * @retval -EINVAL if fd_fifo refers to an invalid file descriptor or fifo.
+ */
+RTAI_PROTO(int, rtf_sem_timed_wait,(int fd, int ms_delay))
+{
+	int ret = ioctl(fd, RTF_SEM_TIMED_WAIT, ms_delay);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_sem_post,(int fd))
+{
+	int ret = ioctl(fd, RTF_SEM_POST);
+	return ret < 0 ? -errno : ret;
+}
+
+RTAI_PROTO(int, rtf_sem_destroy,(int fd))
+{
+	int ret = ioctl(fd, RTF_SEM_DESTROY);
+	return ret < 0 ? -errno : ret;
+}
+
+/**
+ * @ingroup fifos_ipc
+ * Activate asynchronous notification of data availability
+ *
+ * rtf_set_async_sig activate an asynchronous signals to notify data
+ * availability by catching a user set signal signum.
+ *
+ * @param signum is a user chosen signal number to be used, default is SIGIO.
+ *
+ * @retval -EINVAL if fd refers to a not opened fifo.
+ */
+RTAI_PROTO(int, rtf_set_async_sig,(int fd, int signum))
+{
+	int ret = ioctl(fd, SET_ASYNC_SIG, signum);
+	return ret < 0 ? -errno : ret;
+}
+
+/*
+ * Support for named FIFOS : Ian Soanes (ians@zentropix.com)
+ * Based on ideas from Stuart Hughes and David Schleef
+ */
+
+RTAI_PROTO_ALWAYS_INLINE(char *, rtf_getfifobyminor,(int minor, char *buf, int len))
+{
+    snprintf(buf,len,CONFIG_RTAI_FIFOS_TEMPLATE,minor);
+    return buf;
+}
+
+RTAI_PROTO(int, rtf_getfifobyname,(const char *name))
+{
+    	int fd, minor;
+	char nm[RTF_NAMELEN+1];
+
+	if (strlen(name) > RTF_NAMELEN) {
+	    	return -1;
+	}
+	if ((fd = open(rtf_getfifobyminor(0,nm,sizeof(nm)), O_RDONLY)) < 0) {
+	    	return -errno;
+	}
+	strncpy(nm, name, RTF_NAMELEN+1);
+	minor = ioctl(fd, RTF_NAME_LOOKUP, nm);
+	close(fd);
+	return minor < 0 ? -errno : minor;
+}
+
+RTAI_PROTO(int, rtf_named_create,(const char *name, int size))
+{
+	int fd, minor;
+	char nm[RTF_NAMELEN+1];
+
+	if (strlen(name) > RTF_NAMELEN) {
+		return -1;
+	}
+	if ((fd = open(rtf_getfifobyminor(0,nm,sizeof(nm)), O_RDONLY)) < 0) {
+		return -errno;
+	}
+	strncpy(nm, name, RTF_NAMELEN+1);
+	minor = ioctl(fd, RTF_NAMED_CREATE, nm, size);
+	close(fd);
+	return minor < 0 ? -errno : minor;
+}
+
+RTAI_PROTO(int, rtf_create_named,(const char *name))
+{
+	int fd, minor;
+	char nm[RTF_NAMELEN+1];
+
+	if (strlen(name) > RTF_NAMELEN) {
+	    	return -1;
+	}
+	if ((fd = open(rtf_getfifobyminor(0,nm,sizeof(nm)), O_RDONLY)) < 0) { 
+		return -errno;
+	}
+	strncpy(nm, name, RTF_NAMELEN+1);
+	minor = ioctl(fd, RTF_CREATE_NAMED, nm);
+	close(fd);
+	return minor < 0 ? -errno : minor;
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_FIFOS_H */

include/rtai_hal_names.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2015 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef _RTAI_HAL_NAMES_H
+#define _RTAI_HAL_NAMES_H
+
+#include <linux/version.h>
+
+#define TSKEXT0  0
+#define TSKEXT1  1
+#define TSKEXT2  2
+#define TSKEXT3  3
+
+#define hal_processor_id      ipipe_processor_id
+
+#define hal_domain_struct     ipipe_domain 
+#define hal_root_domain       ipipe_root_domain 
+
+#define hal_critical_enter    ipipe_critical_enter
+#define hal_critical_exit     ipipe_critical_exit
+
+#define hal_sysinfo_struct    ipipe_sysinfo
+#define hal_get_sysinfo       ipipe_get_sysinfo
+
+#define hal_set_irq_affinity  ipipe_set_irq_affinity
+
+#define hal_alloc_irq         ipipe_alloc_virq
+#define hal_free_irq          ipipe_free_virq
+
+#define hal_reenter_root()  __ipipe_reenter_root() 
+
+#endif /* _RTAI_HAL_NAMES_H */

include/rtai_malloc.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2001,2002,2003,2004 Philippe Gerum <rpm@xenomai.org>.
+ *
+ * RTAI is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * RTAI is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with RTAI; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * This file provides the interface to the RTAI dynamic memory
+ * allocator based on the algorithm described in "Design of a General
+ * Purpose Memory Allocator for the 4.3BSD Unix Kernel" by Marshall
+ * K. McKusick and Michael J. Karels.
+ */
+
+#ifndef _RTAI_MALLOC_H
+#define _RTAI_MALLOC_H
+
+#include <rtai_types.h>
+
+#ifdef __KERNEL__
+
+#ifndef __cplusplus
+
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+
+/*
+ * LIMITS:
+ *
+ * Minimum page size is 2 ** RTHEAP_MINLOG2 (must be large enough to
+ * hold a pointer).
+ *
+ * Maximum page size is 2 ** RTHEAP_MAXLOG2.
+ *
+ * Minimum block size equals the minimum page size.
+ *
+ * Requested block size smaller than the minimum block size is
+ * rounded to the minimum block size.
+ *
+ * Requested block size larger than 2 times the page size is rounded
+ * to the next page boundary and obtained from the free page
+ * list. So we need a bucket for each power of two between
+ * RTHEAP_MINLOG2 and RTHEAP_MAXLOG2 inclusive, plus one to honor
+ * requests ranging from the maximum page size to twice this size.
+ */
+
+#define	RTHEAP_MINLOG2    4
+#define	RTHEAP_MAXLOG2    22
+#define	RTHEAP_MINALLOCSZ (1 << RTHEAP_MINLOG2)
+#define	RTHEAP_MINALIGNSZ RTHEAP_MINALLOCSZ
+#define	RTHEAP_NBUCKETS   (RTHEAP_MAXLOG2 - RTHEAP_MINLOG2 + 2)
+#define	RTHEAP_MAXEXTSZ   0x7FFFFFFF
+#define RTHEAP_GLOBALSZ   (CONFIG_RTAI_MALLOC_HEAPSZ * 1024)
+
+#define RTHEAP_PFREE   0
+#define RTHEAP_PCONT   1
+#define RTHEAP_PLIST   2
+
+#define KMALLOC_LIMIT  (128 * 1024)
+
+#define RTHEAP_NOMEM   (-1)
+#define RTHEAP_PARAM   (-2)
+
+typedef struct rtextent {
+
+    struct list_head link;
+
+    caddr_t membase,	/* Base address of the page array */
+	    memlim,	/* Memory limit of page array */
+	    freelist;	/* Head of the free page list */
+
+    u_char pagemap[1];	/* Beginning of page map */
+
+} rtextent_t;
+
+/* Creation flag */
+#define RTHEAP_EXTENDABLE 0x1
+
+/* Allocation flags */
+#define RTHEAP_EXTEND    0x1
+
+typedef struct rtheap {
+
+    spinlock_t lock;
+
+    int flags;
+
+    u_long extentsize,
+           pagesize,
+           pageshift,
+	   hdrsize,
+	   npages,	/* Number of pages per extent */
+	   ubytes,
+           maxcont;
+
+    struct list_head extents;
+
+    caddr_t buckets[RTHEAP_NBUCKETS];
+
+} rtheap_t;
+
+#else /* __cplusplus */
+
+struct rtheap;
+
+typedef struct rtheap rtheap_t;
+
+#endif /* !__cplusplus */
+
+extern rtheap_t rtai_global_heap;
+
+#define rtheap_page_size(heap)   ((heap)->pagesize)
+#define rtheap_page_count(heap)  ((heap)->npages)
+#define rtheap_used_mem(heap)    ((heap)->ubytes)
+
+#ifdef CONFIG_RTAI_MALLOC
+#define rt_malloc(sz)  rtheap_alloc(&rtai_global_heap, sz, 0)
+#define rt_free(p)     rtheap_free(&rtai_global_heap, p)
+#else
+#define rt_malloc(sz)  kmalloc(sz, GFP_KERNEL)
+#define rt_free(p)     kfree(p)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __rtai_heap_init(void);
+
+void __rtai_heap_exit(void);
+
+int rtheap_init(rtheap_t *heap, void *heapaddr, u_long heapsize, u_long pagesize, int suprt);
+
+void rtheap_destroy(rtheap_t *heap, int suprt);
+
+void *rtheap_alloc(rtheap_t *heap, u_long size, int flags);
+
+int rtheap_free(rtheap_t *heap, void *block);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_MALLOC_H */

include/rtai_mbx.h

@@ -0,0 +1,288 @@
+/**
+ * @ingroup lxrt
+ * @file
+ *
+ * @author Paolo Mantegazza
+ *
+ * @note Copyright &copy; 1999-2003 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_MBX_H
+#define _RTAI_MBX_H
+
+#include <rtai_sem.h>
+
+#define RT_MBX_MAGIC 0x3f81aab  // nam2num("rtmbx")
+
+struct rt_task_struct;
+struct rt_mailbox;
+
+#ifdef __KERNEL__
+
+#ifndef __cplusplus
+
+typedef struct rt_mailbox {
+	int magic;
+	SEM sndsem, rcvsem;
+	struct rt_task_struct *waiting_task, *owndby;
+	char *bufadr;
+	int size, fbyte, lbyte, avbs, frbs;
+	spinlock_t lock;
+#ifdef CONFIG_RTAI_RT_POLL
+	struct rt_poll_ql poll_recv;
+	struct rt_poll_ql poll_send;
+#endif
+} MBX;
+
+#else /* __cplusplus */
+extern "C" {
+#endif /* !__cplusplus */
+
+int __rtai_mbx_init(void);
+
+void __rtai_mbx_exit(void);
+
+RTAI_SYSCALL_MODE int rt_typed_mbx_init(struct rt_mailbox *mbx, int size, int qtype);
+
+int rt_mbx_init(struct rt_mailbox *mbx, int size);
+
+RTAI_SYSCALL_MODE int rt_mbx_delete(struct rt_mailbox *mbx);
+
+RTAI_SYSCALL_MODE int _rt_mbx_send(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_send(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_send(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_send_wp(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_send_wp(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_send_wp(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_send_if(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_send_if(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_send_if(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_send_until(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME timei, int space);
+static inline int rt_mbx_send_until(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME time)
+{
+	return _rt_mbx_send_until(mbx, msg, msg_size, time, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_send_timed(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME delay, int space);
+static inline int rt_mbx_send_timed(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME delay)
+{
+	return _rt_mbx_send_timed(mbx, msg, msg_size, delay, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_ovrwr_send(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_ovrwr_send(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_ovrwr_send(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_evdrp(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_evdrp(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_evdrp(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_receive(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_receive(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_receive(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_receive_wp(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_receive_wp(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_receive_wp(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_receive_if(struct rt_mailbox *mbx, void *msg, int msg_size, int space);
+static inline int rt_mbx_receive_if(struct rt_mailbox *mbx, void *msg, int msg_size)
+{
+	return _rt_mbx_receive_if(mbx, msg, msg_size, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_receive_until(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME time, int space);
+static inline int rt_mbx_receive_until(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME time)
+{
+	return _rt_mbx_receive_until(mbx, msg, msg_size, time, 1);
+}
+
+RTAI_SYSCALL_MODE int _rt_mbx_receive_timed(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME delay, int space);
+static inline int rt_mbx_receive_timed(struct rt_mailbox *mbx, void *msg, int msg_size, RTIME delay)
+{
+	return _rt_mbx_receive_timed(mbx, msg, msg_size, delay, 1);
+}
+
+RTAI_SYSCALL_MODE struct rt_mailbox *_rt_typed_named_mbx_init(unsigned long mbx_name, int size, int qtype);
+static inline struct rt_mailbox *rt_typed_named_mbx_init(const char *mbx_name, int size, int qtype)
+{
+	return _rt_typed_named_mbx_init(nam2num(mbx_name), size, qtype);
+}
+
+RTAI_SYSCALL_MODE int rt_named_mbx_delete(struct rt_mailbox *mbx);
+
+#define rt_named_mbx_init(mbx_name, size)  rt_typed_named_mbx_init(mbx_name, size, FIFO_Q)
+     
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else /* !__KERNEL__ */
+
+#include <rtai_lxrt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+RTAI_PROTO(struct rt_mailbox *, rt_typed_mbx_init, (unsigned long name, int size, int qtype))
+{
+	struct { unsigned long name; long size; long qtype; } arg = { name, size, qtype };
+	return (struct rt_mailbox *)rtai_lxrt(BIDX, SIZARG, LXRT_MBX_INIT, &arg).v[LOW];
+}
+
+/**
+ * @ingroup lxrt
+ * Initialize mailbox.
+ * 
+ * Initializes a mailbox referred to by @a name of size @a size.
+ * 
+ * It is important to remark that the returned task pointer cannot be used
+ * directly, they are for kernel space data, but just passed as arguments when
+ * needed.
+ *
+ * @return On success a pointer to the mail box to be used in related calls.
+ * @return A 0 value is returned if it was not possible to setup the semaphore
+ * or something using the same name was found.
+ */
+#define rt_mbx_init(name, size) rt_typed_mbx_init(name, size, FIFO_Q)
+
+RTAI_PROTO(int, rt_mbx_delete, (struct rt_mailbox *mbx))
+{
+	void *arg = mbx;
+	return rtai_lxrt(BIDX, SIZARG, LXRT_MBX_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(struct rt_mailbox *, rt_typed_named_mbx_init, (const char *name, int size, int type))
+{
+	struct { unsigned long name; long size, type; } arg = { nam2num(name), size, type };
+	return (struct rt_mailbox *)rtai_lxrt(BIDX, SIZARG, NAMED_MBX_INIT, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_named_mbx_delete, (struct rt_mailbox *mbx))
+{
+	struct { struct rt_mailbox *mbx; } arg = { mbx };
+	return rtai_lxrt(BIDX, SIZARG, NAMED_MBX_DELETE, &arg).i[LOW];
+}
+
+#define rt_named_mbx_init(mbx_name, size) \
+	rt_typed_named_mbx_init(mbx_name, size, FIFO_Q)
+
+RTAI_PROTO(int, rt_mbx_send, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_SEND, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_send_wp, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_SEND_WP, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_send_if, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_SEND_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_send_until, (struct rt_mailbox *mbx, void *msg, int msg_size, RTIME time))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; RTIME time; long space; } arg = { mbx, (char *)msg, msg_size, time, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_SEND_UNTIL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_send_timed, (struct rt_mailbox *mbx, void *msg, int msg_size, RTIME delay))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; RTIME delay; long space; } arg = { mbx, (char *)msg, msg_size, delay, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_SEND_TIMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_ovrwr_send, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_OVRWR_SEND, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_evdrp, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_EVDRP, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_receive, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_RECEIVE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_receive_wp, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_RECEIVE_WP, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_receive_if, (struct rt_mailbox *mbx, void *msg, int msg_size))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; long space; } arg = { mbx, (char *)msg, msg_size, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_RECEIVE_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_receive_until, (struct rt_mailbox *mbx, void *msg, int msg_size, RTIME time))
+{
+	struct { struct rt_mailbox *mbx; void *msg; long msg_size; RTIME time; long space; } arg = { mbx, (char *)msg, msg_size, time, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_RECEIVE_UNTIL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_mbx_receive_timed, (struct rt_mailbox *mbx, void *msg, int msg_size, RTIME delay))
+{
+	struct { struct rt_mailbox *mbx; char *msg; long msg_size; RTIME delay; long space; } arg = { mbx, (char *)msg, msg_size, delay, 0 };
+	return (int)rtai_lxrt(BIDX, SIZARG, MBX_RECEIVE_TIMED, &arg).i[LOW];
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#if !defined(__KERNEL__) || defined(__cplusplus)
+
+typedef struct rt_mailbox {
+    int opaque;
+} MBX;
+
+#endif /* !__KERNEL__ || __cplusplus */
+
+#endif /* !_RTAI_MBX_H */

include/rtai_modbus.h

@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+const int DIGITAL_IN = 0;
+const int DIGITAL_OUT = 1;
+const int ANALOG_IN = 2;
+const int IB_IL_AO = 3;
+
+
+int rt_modbus_connect(char * hostname);
+int rt_modbus_disconnect(int cno);
+int rt_modbus_get(int cno, int type, uint16_t addr, uint16_t * value);
+int rt_modbus_set(int cno, int type, uint16_t addr, uint16_t value);

include/rtai_msg.h

@@ -0,0 +1,706 @@
+/*
+ * Copyright (C) 2002 POSEIDON CONTROLS INC <pcloutier@poseidoncontrols.com>
+ * Copyright (C) 2002 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_MSG_H
+#define _RTAI_MSG_H
+
+#include <rtai_types.h>
+
+#define MSG_ERR ((RT_TASK *)RTE_OBJINV)
+
+struct rt_task_struct;
+struct QueueBlock;
+struct QueueHook;
+
+#ifdef __KERNEL__
+
+typedef struct t_msgcb { /* Message control block structure. */
+    int  cmd;
+    void *sbuf;
+    size_t sbytes;
+    void *rbuf;
+    size_t rbytes;
+} MSGCB;
+
+#define PROXY_MIN_STACK_SIZE 2048
+
+struct proxy_t {
+    struct rt_task_struct *receiver;
+    int nmsgs, nbytes;
+    char *msg;
+};
+
+#define SYNCMSG          0
+#define PROXY           -1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+int __rtai_msg_init(void);
+
+void __rtai_msg_exit(void);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_send(struct rt_task_struct *task,
+			       unsigned long msg);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_send_if(struct rt_task_struct *task,
+				  unsigned long msg);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_send_until(struct rt_task_struct *task,
+				     unsigned long msg,
+				     RTIME time);
+    
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_send_timed(struct rt_task_struct *task,
+				     unsigned long msg,
+				     RTIME delay);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_evdrp(struct rt_task_struct *task,
+				void *msg);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receive(struct rt_task_struct *task,
+				  void *msg);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receive_if(struct rt_task_struct *task,
+				     void *msg);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receive_until(struct rt_task_struct *task,
+					void *msg,
+					RTIME time);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receive_timed(struct rt_task_struct *task,
+					void *msg,
+					RTIME delay);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpc(struct rt_task_struct *task,
+			      unsigned long to_do,
+			      void *result);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpc_if(struct rt_task_struct *task,
+				 unsigned long to_do,
+				 void *result);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpc_until(struct rt_task_struct *task,
+				    unsigned long to_do,
+				    void *result,
+				    RTIME time);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpc_timed(struct rt_task_struct *task,
+				    unsigned long to_do,
+				    void *result,
+				    RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_isrpc(struct rt_task_struct *task);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_return(struct rt_task_struct *task,
+				 unsigned long result);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpcx(struct rt_task_struct *task,
+			       void *smsg,
+			       void *rmsg,
+			       int ssize,
+			       int rsize);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpcx_if(struct rt_task_struct *task,
+				  void *smsg,
+				  void *rmsg,
+				  int ssize,
+				  int rsize);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpcx_until(struct rt_task_struct *task,
+				     void *smsg,
+				     void *rmsg,
+				     int ssize,
+				     int rsize,
+				     RTIME time);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_rpcx_timed(struct rt_task_struct *task,
+				     void *smsg,
+				     void *rmsg,
+				     int ssize,
+				     int rsize,
+				     RTIME delay);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_sendx(struct rt_task_struct *task,
+				void *msg,
+				int size);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_sendx_if(struct rt_task_struct *task,
+				   void *msg,
+				   int size);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_sendx_until(struct rt_task_struct *task,
+				      void *msg,
+				      int size,
+				      RTIME time);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_sendx_timed(struct rt_task_struct *task,
+				      void *msg,
+				      int size,
+				      RTIME delay);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_returnx(struct rt_task_struct *task,
+				  void *msg,
+				  int size);
+
+#define rt_isrpcx(task) rt_isrpc(task)
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_evdrpx(struct rt_task_struct *task,
+				 void *msg,
+				 int size,
+				 long *len);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receivex(struct rt_task_struct *task,
+				   void *msg,
+				   int size,
+				   long *len);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receivex_if(struct rt_task_struct *task,
+				      void *msg,
+				      int size,
+				      long *len);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receivex_until(struct rt_task_struct *task,
+					 void *msg,
+					 int size,
+					 long *len,
+					 RTIME time);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_receivex_timed(struct rt_task_struct *task,
+					 void *msg,
+					 int size,
+					 long *len,
+					 RTIME delay);
+
+struct rt_task_struct *__rt_proxy_attach(void (*func)(long),
+					 struct rt_task_struct *task,
+					 void *msg,
+					 int nbytes,
+					 int priority);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_proxy_attach(struct rt_task_struct *task,
+				       void *msg,
+				       int nbytes,
+				       int priority);
+
+RTAI_SYSCALL_MODE int rt_proxy_detach(struct rt_task_struct *proxy);
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_trigger(struct rt_task_struct *proxy);
+
+#define exist(name)  rt_get_adr(nam2num(name))
+
+RTAI_SYSCALL_MODE int rt_Send(pid_t pid,
+	    void *smsg,
+	    void *rmsg,
+	    size_t ssize,
+	    size_t rsize);
+
+RTAI_SYSCALL_MODE pid_t rt_Receive(pid_t pid,
+		 void *msg,
+		 size_t maxsize,
+		 size_t *msglen);
+
+RTAI_SYSCALL_MODE pid_t rt_Creceive(pid_t pid,
+		  void *msg,
+		  size_t maxsize,
+		  size_t *msglen,
+		  RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_Reply(pid_t pid,
+	     void *msg,
+	     size_t size);
+
+RTAI_SYSCALL_MODE pid_t rt_Proxy_attach(pid_t pid,
+		      void *msg,
+		      int nbytes,
+		      int priority);
+
+RTAI_SYSCALL_MODE int rt_Proxy_detach(pid_t pid);
+
+RTAI_SYSCALL_MODE pid_t rt_Trigger(pid_t pid);
+
+RTAI_SYSCALL_MODE pid_t rt_Name_attach(const char *name);
+
+RTAI_SYSCALL_MODE pid_t rt_Name_locate(const char *host,
+		     const char *name);
+
+RTAI_SYSCALL_MODE int rt_Name_detach(pid_t pid);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else /* !__KERNEL__ */
+
+#include <rtai_lxrt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+RTAI_PROTO(struct rt_task_struct *,rt_send,(struct rt_task_struct *task, unsigned long msg))
+{
+	struct { struct rt_task_struct *task; unsigned long msg; } arg = { task, msg };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SENDMSG, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_send_if,(struct rt_task_struct *task, unsigned long msg))
+{
+	struct { struct rt_task_struct *task; unsigned long msg; } arg = { task, msg };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SEND_IF, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_send_until,(struct rt_task_struct *task, unsigned long msg, RTIME time))
+{
+	struct { struct rt_task_struct *task; unsigned long msg; RTIME time; } arg = { task, msg, time };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SEND_UNTIL, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_send_timed,(struct rt_task_struct *task, unsigned long msg, RTIME delay))
+{
+	struct { struct rt_task_struct *task; unsigned long msg; RTIME delay; } arg = { task, msg, delay };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SEND_TIMED, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_evdrp,(struct rt_task_struct *task, void *msg))
+{
+	struct { struct rt_task_struct *task; void *msg; } arg = { task, msg };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, EVDRP, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receive,(struct rt_task_struct *task, void *msg))
+{
+	struct { struct rt_task_struct *task; void *msg; } arg = { task, msg };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVEMSG, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receive_if,(struct rt_task_struct *task, void *msg))
+{
+	struct { struct rt_task_struct *task; void *msg; } arg = { task, msg };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVE_IF, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receive_until,(struct rt_task_struct *task, void *msg, RTIME time))
+{
+	struct { struct rt_task_struct *task; void *msg; RTIME time; } arg = { task, msg, time };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVE_UNTIL, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receive_timed,(struct rt_task_struct *task, void *msg, RTIME delay))
+{
+	struct { struct rt_task_struct *task; void *msg; RTIME delay; } arg = { task, msg, delay };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVE_TIMED, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpc,(struct rt_task_struct *task, unsigned long to_do, void *result))
+{
+	struct { struct rt_task_struct *task; unsigned long to_do; void *result; } arg = { task, to_do, result };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPCMSG, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpc_if,(struct rt_task_struct *task, unsigned long to_do, void *result))
+{
+	struct { struct rt_task_struct *task; unsigned long to_do; void *result; } arg = { task, to_do, result };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPC_IF, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpc_until,(struct rt_task_struct *task, unsigned long to_do, void *result, RTIME time))
+{
+	struct { struct rt_task_struct *task; unsigned long to_do; void *result; RTIME time; } arg = { task, to_do, result, time };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPC_UNTIL, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpc_timed,(struct rt_task_struct *task, unsigned long to_do, void *result, RTIME delay))
+{
+	struct { struct rt_task_struct *task; unsigned long to_do; void *result; RTIME delay; } arg = { task, to_do, result, delay };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPC_TIMED, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_isrpc,(struct rt_task_struct *task))
+{
+	struct { struct rt_task_struct *task; } arg = { task };
+	return (int)rtai_lxrt(BIDX, SIZARG, ISRPC, &arg).i[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_return,(struct rt_task_struct *task, unsigned long result))
+{
+	struct { struct rt_task_struct *task; unsigned long result; } arg = { task, result };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RETURNMSG, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpcx,(struct rt_task_struct *task, void *smsg, void *rmsg, int ssize, int rsize))
+{
+	struct { struct rt_task_struct *task; void *smsg; void *rmsg; long ssize; long rsize; } arg = { task, smsg, rmsg, ssize, rsize };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPCX, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpcx_if,(struct rt_task_struct *task, void *smsg, void *rmsg, int ssize, int rsize))
+{
+	struct { struct rt_task_struct *task; void *smsg; void *rmsg; long ssize; long rsize; } arg = { task, smsg, rmsg, ssize, rsize };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPCX_IF, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpcx_until,(struct rt_task_struct *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME time))
+{
+	struct { struct rt_task_struct *task; void *smsg; void *rmsg; long ssize; long rsize; RTIME time; } arg = { task, smsg, rmsg, ssize, rsize, time };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPCX_UNTIL, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_rpcx_timed,(struct rt_task_struct *task, void *smsg, void *rmsg, int ssize, int rsize, RTIME delay))
+{
+	struct { struct rt_task_struct *task; void *smsg; void *rmsg; long ssize; long rsize; RTIME delay; } arg = { task, smsg, rmsg, ssize, rsize, delay };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RPCX_TIMED, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_sendx,(struct rt_task_struct *task, void *msg, int size))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; } arg = { task, msg, size };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SENDX, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_sendx_if,(struct rt_task_struct *task, void *msg, int size))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; } arg = { task, msg, size };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SENDX_IF, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_sendx_until,(struct rt_task_struct *task, void *msg, int size, RTIME time))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; RTIME time; } arg = { task, msg, size, time };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SENDX_UNTIL, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_sendx_timed,(struct rt_task_struct *task, void *msg, long size, RTIME delay))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; RTIME delay; } arg = { task, msg, size, delay };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, SENDX_TIMED, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_returnx,(struct rt_task_struct *task, void *msg, int size))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; } arg = { task, msg, size };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RETURNX, &arg).v[LOW];
+}
+
+#define rt_isrpcx(task)  rt_isrpc(task)
+
+RTAI_PROTO(struct rt_task_struct *,rt_evdrpx,(struct rt_task_struct *task, void *msg, int size, long *len))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; long *len; } arg = { task, msg, size, len };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, EVDRPX, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receivex,(struct rt_task_struct *task, void *msg, int size, long *len))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; long *len; } arg = { task, msg, size, len };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVEX, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receivex_if,(struct rt_task_struct *task, void *msg, int size, long *len))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; long *len; } arg = { task, msg, size, len };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVEX_IF, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receivex_until,(struct rt_task_struct *task, void *msg, int size, long *len, RTIME time))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; long *len; RTIME time; } arg = { task, msg, size, len, time };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVEX_UNTIL, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_receivex_timed,(struct rt_task_struct *task, void *msg, int size, long *len, RTIME delay))
+{
+	struct { struct rt_task_struct *task; void *msg; long size; long *len; RTIME delay; } arg = { task, msg, size, len, delay };
+	return (struct rt_task_struct *)rtai_lxrt(BIDX, SIZARG, RECEIVEX_TIMED, &arg).v[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_proxy_attach,(struct rt_task_struct *proxy, void *msg, int nbytes, int priority))
+{
+	struct { struct rt_task_struct *proxy; void *msg; long nbytes, priority;} arg = { proxy, msg, nbytes, priority };
+	return (struct rt_task_struct *) rtai_lxrt(BIDX, SIZARG, PROXY_ATTACH, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_proxy_detach,(struct rt_task_struct *proxy))
+{
+	struct { struct rt_task_struct *proxy; } arg = { proxy };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, PROXY_DETACH, &arg).i[LOW];
+}
+
+RTAI_PROTO(struct rt_task_struct *,rt_trigger,(struct rt_task_struct *proxy))
+{
+	struct { struct rt_task_struct *proxy; } arg = { proxy };
+	return (struct rt_task_struct *) rtai_lxrt(BIDX, SIZARG, PROXY_TRIGGER, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_Send,(pid_t pid, void *smsg, void *rmsg, size_t ssize, size_t rsize ))
+{
+	struct { long pid; void *smsg; void *rmsg; unsigned long ssize, rsize;} arg = { pid, smsg, rmsg, ssize, rsize };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_SEND, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Receive,(pid_t pid, void *msg, size_t maxsize, size_t *msglen))
+{
+	struct { long pid; void *msg; unsigned long maxsize; size_t *msglen; } arg = { pid, msg, maxsize, msglen };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_RECEIVE, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Creceive,(pid_t pid, void *msg, size_t maxsize, size_t *msglen, RTIME delay))
+{
+	struct { long pid; void *msg; unsigned long maxsize; size_t *msglen; RTIME delay;} arg = { pid, msg, maxsize, msglen, delay };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_CRECEIVE, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Reply,(pid_t pid, void *msg, size_t size))
+{
+	struct { long pid; void *msg; unsigned long size;} arg = { pid, msg, size };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_REPLY, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Proxy_attach,(pid_t pid, void *msg, int nbytes, int priority))
+{
+	struct { long pid; void *msg; long nbytes, priority;} arg = { pid, msg, nbytes, priority };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_PROXY_ATTACH, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Proxy_detach,(pid_t pid))
+{
+	struct { long pid; } arg = { pid };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_PROXY_DETACH, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Trigger,(pid_t pid))
+{
+	struct { long pid; } arg = { pid };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_TRIGGER, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Alias_attach,(const char *name))
+{
+	struct { const char *name; } arg = { name};
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_NAME_ATTACH, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_Name_locate,(const char *host, const char *name))
+{
+	struct { const char *host, *name; } arg = { host, name };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_NAME_LOCATE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_Name_detach,(pid_t pid))
+{
+	struct { long pid; } arg = { pid };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_NAME_DETACH, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_InitTickQueue,(void))
+{
+	struct { unsigned long dummy; } arg;
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_INITTICKQUEUE, &arg).i[LOW];
+}
+
+RTAI_PROTO(void, rt_ReleaseTickQueue,(void))
+{
+	struct { unsigned long dummy; } arg;
+	rtai_lxrt(BIDX, SIZARG, RT_RELEASETICKQUEUE, &arg);
+}
+
+RTAI_PROTO(unsigned long, rt_qDynAlloc,(unsigned long n))
+{
+	struct { unsigned long n; } arg = { n };
+	return (unsigned long) rtai_lxrt(BIDX, SIZARG, RT_QDYNALLOC, &arg).i[LOW];
+} 
+
+RTAI_PROTO(unsigned long, rt_qDynFree,(int n))
+{
+	struct { long n; } arg = { n };
+	return (unsigned long) rtai_lxrt(BIDX, SIZARG, RT_QDYNFREE, &arg).i[LOW];
+}
+
+RTAI_PROTO(struct QueueBlock *,rt_qDynInit,(struct QueueBlock **q, void (*fun)(void *, int), void *data, int evn ))
+{
+	struct QueueBlock *r;
+
+	struct { struct QueueBlock **q; void (*fun)(void *, int), *data; long evn; } arg = { 0, fun, data, evn };
+	r  = (struct QueueBlock *) rtai_lxrt(BIDX, SIZARG, RT_QDYNINIT, &arg).v[LOW];
+	if (q) *q = r;
+	return r;
+}
+
+RTAI_PROTO(void, rt_qBlkWait,(struct QueueBlock *q, RTIME t))
+{
+	struct { struct QueueBlock *q; RTIME t; } arg = { q, t } ;
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKWAIT, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkRepeat,(struct QueueBlock *q, RTIME t))
+{
+	struct { struct QueueBlock *q; RTIME t; } arg = { q, t } ;
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKREPEAT, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkSoon,(struct QueueBlock *q))
+{
+	struct { struct QueueBlock *q; } arg = { q };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKSOON, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkDequeue,(struct QueueBlock *q))
+{
+	struct { struct QueueBlock *q; } arg = { q };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKDEQUEUE, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkCancel,(struct QueueBlock *q))
+{
+	struct { struct QueueBlock *q; } arg = { q };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKCANCEL, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkBefore,(struct QueueBlock *cur, struct QueueBlock *nxt))
+{
+	struct { struct QueueBlock *cur, *nxt; } arg = { cur, nxt };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKBEFORE, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkAfter,(struct QueueBlock *cur, struct QueueBlock *prv))
+{
+	struct { struct QueueBlock *cur, *prv; } arg = { cur, prv };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKAFTER, &arg);
+}
+
+RTAI_PROTO(struct QueueBlock *,rt_qBlkUnhook,(struct QueueBlock *q))
+{
+	struct { struct QueueBlock *q; } arg = { q };
+	return (struct QueueBlock *) rtai_lxrt(BIDX, SIZARG, RT_QBLKUNHOOK, &arg).v[LOW];
+}
+
+RTAI_PROTO(void, rt_qBlkRelease,(struct QueueBlock *q))
+{
+	struct { struct QueueBlock *q; } arg = { q };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKRELEASE, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkComplete,(struct QueueBlock *q))
+{
+	struct { struct QueueBlock *q; } arg = { q };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKCOMPLETE, &arg);
+}
+
+RTAI_PROTO(int, rt_qSync,(void))
+{
+	struct { unsigned long long dummy; } arg;
+	return rtai_lxrt(BIDX, SIZARG, RT_QSYNC, &arg).i[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_qReceive,(pid_t target, void *buf, size_t maxlen, size_t *msglen))
+{
+	struct { long target; void *buf; unsigned long maxlen; size_t *msglen; } arg = { target, buf, maxlen, msglen };
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_QRECEIVE, &arg).i[LOW];
+}
+
+RTAI_PROTO(void, rt_qLoop,(void))
+{
+	struct { unsigned long dummy; } arg;
+	rtai_lxrt(BIDX, SIZARG, RT_QLOOP, &arg);
+}
+
+RTAI_PROTO(RTIME, rt_qStep,(void))
+{
+	struct { unsigned long dummy; } arg;
+	return rtai_lxrt(BIDX, SIZARG, RT_QSTEP, &arg).rt;
+}
+
+RTAI_PROTO(void, rt_qHookFlush,(struct QueueHook *h))
+{
+	struct { struct QueueHook *h; } arg = { h };
+	rtai_lxrt(BIDX, SIZARG, RT_QHOOKFLUSH, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkAtHead,(struct QueueBlock *q, struct QueueHook *h))
+{
+	struct { struct QueueBlock *q; struct QueueHook *h; } arg = { q, h };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKATHEAD, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkAtTail,(struct QueueBlock *q, struct QueueHook *h))
+{
+	struct { struct QueueBlock *q; struct QueueHook *h; } arg = { q, h };
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKATTAIL, &arg);
+}
+
+RTAI_PROTO(struct QueueHook *,rt_qHookInit,(struct QueueHook **h, void (*c)(void *, struct QueueBlock *), void *a))
+{
+	struct QueueHook *r;
+	struct { struct QueueHook **h; void (*c)(void *, struct QueueBlock *), *a;} arg = { 0, c, a };
+	r = (struct QueueHook *) rtai_lxrt(BIDX, SIZARG, RT_QHOOKINIT, &arg).v[LOW];
+	if (h) *h = r;
+	return r;
+}
+
+RTAI_PROTO(void, rt_qHookRelease,(struct QueueHook *h))
+{
+	struct { struct QueueHook *h; } arg = { h };
+	rtai_lxrt(BIDX, SIZARG, RT_QHOOKRELEASE, &arg);
+}
+
+RTAI_PROTO(void, rt_qBlkSchedule,(struct QueueBlock *q, RTIME t))
+{
+	struct { struct QueueBlock *q; RTIME t; } arg = { q, t } ;
+	rtai_lxrt(BIDX, SIZARG, RT_QBLKSCHEDULE, &arg);
+}
+
+RTAI_PROTO(struct QueueHook *,rt_GetTickQueueHook,(void))
+{
+	struct { unsigned long dummy; } arg;
+	return (struct QueueHook *) rtai_lxrt(BIDX, SIZARG, RT_GETTICKQUEUEHOOK, &arg).v[LOW];
+}
+
+RTAI_PROTO(pid_t, rt_vc_reserve,( void ))
+{
+	struct { unsigned long dummy; } arg;
+	return (pid_t) rtai_lxrt(BIDX, SIZARG, RT_VC_RESERVE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_vc_attach,(pid_t pid))
+{
+	struct { long pid; } arg = { pid };
+	return rtai_lxrt(BIDX, SIZARG, RT_VC_ATTACH, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_vc_release,(pid_t pid))
+{
+	struct { long pid; } arg = { pid };
+	return rtai_lxrt(BIDX, SIZARG, RT_VC_RELEASE, &arg).i[LOW];
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#if !defined(__KERNEL__) || defined(__cplusplus)
+
+typedef struct t_msgcb {
+    int opaque;
+} MSGCB;
+
+#endif /* !__KERNEL__ || __cplusplus */
+
+#endif /* !_RTAI_MSG_H */

include/rtai_nam2num.h

@@ -0,0 +1,136 @@
+/**
+ * @ingroup shm
+ * @ingroup lxrt
+ * @ingroup tasklets
+ * @file
+ *
+ * Conversion between 6 characters strings and unsigned long identifiers.
+ * 
+ * Convert a 6 characters string to un unsigned long, and vice versa, to be used
+ * as an dentifier for RTAI services, symmetrically available in user and kernel
+ * space, e.g. @ref shm "shared memory" and @ref lxrt "LXRT and LXRT-INFORMED".
+ *
+ * @author Paolo Mantegazza
+ *
+ * @note Copyright &copy; 1999-2013 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_NAM2NUM_H
+#define _RTAI_NAM2NUM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <rtai_types.h>
+
+#ifdef __KERNEL__
+
+#include <linux/ctype.h>
+#include <linux/string.h>
+#define NAM2NUM_PROTO(type, name, arglist)  static inline type name arglist
+
+#else
+
+#include <ctype.h>
+#include <string.h>
+#define NAM2NUM_PROTO  RTAI_PROTO
+
+#endif
+
+#define MAX_NAM2NUM 4096000003UL  // nam2num("$$$$$$") + 2
+
+/**
+ * Convert a 6 characters string to an unsigned long.
+ *
+ * Converts a 6 characters string name containing an alpha numeric identifier 
+ * to its corresponding unsigned long identifier.
+ *
+ * @param name is the name to be converted.
+ *
+ * Allowed characters are:
+ * -  english letters (no difference between upper and lower case, the latter 
+ *    will always be translated to upper case);
+ * -  decimal digits;
+ * -  '_', '@', '.' and another character of your choice, the latter will 
+ *    always be treated as a $ and converted back as such by num2nam().
+ *
+ * @return the unsigned long associated with @a name.
+ */
+NAM2NUM_PROTO(unsigned long, nam2num, (const char *name))
+{
+        unsigned long retval = 0;
+	int c, i;
+
+	for (i = 0; i < 6; i++) {
+		if (!(c = name[i])) {
+			break;
+		}
+		if (islower(c)) {
+			c +=  (10 - 'a');
+		} else if (isupper(c)) {
+			c += (10 - 'A');
+		} else if (isdigit(c)) {
+			c -= '0';
+		} else {
+			c = c == '_' ? 36 : c == '@' ? 37 : c == '.' ? 38 : 39;
+		}
+		retval = retval*40 + c;
+	}
+	return i > 0 ? retval + 2 : 0xFFFFFFFF;
+}
+
+/**
+ * Convert an unsigned long identifier back to its corresponding 6 characters 
+ * string.
+ *
+ * @param num is the unsigned long identifier whose alphanumeric name string has
+ * to be evaluated;
+ * 
+ * @param name is a pointer to a 6 characters buffer where the identifier will
+ * be returned. Recall to dimension it at least to 7.
+ */
+NAM2NUM_PROTO(void, num2nam, (unsigned long num, char *name))
+{
+        int c, i, k, q; 
+	if (num >= MAX_NAM2NUM) {
+		strncpy(name, "|null|", 7);
+		return;
+	}
+        i = 5; 
+	num -= 2;
+	while (num && i >= 0) {
+		q = num/40;
+		c = num - q*40;
+		num = q;
+		if (c < 36) {
+			name[i--] = c > 9 ? c + 'A' - 10 : c + '0';
+		} else {
+			name[i--] = c == 36 ? '_' : c == 37 ? '@' : c == 38 ? '.' : '$';
+		}
+	}
+	for (k = 0; i < 5; k++) {
+		name[k] = name[++i];
+	}
+	name[k] = 0;
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !_RTAI_NAM2NUM_H */

include/rtai_names.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2000  POSEIDON CONTROLS INC <pcloutier@poseidoncontrols.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_NAMES_H
+#define _RTAI_NAMES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+pid_t rt_Name_attach(const char *name);
+
+pid_t rt_Name_locate(const char *host,
+		     const char *name);
+
+int rt_Name_detach(pid_t pid);
+
+void rt_boom(void);
+
+void rt_stomp(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !_RTAI_NAMES_H */

include/rtai_prinher.h

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2006-2008 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef _RTAI_PRINHER_H
+#define _RTAI_PRINHER_H
+
+#include <rtai_schedcore.h>
+
+#ifdef __KERNEL__
+
+#ifdef CONFIG_RTAI_FULL_PRINHER
+
+#define task_owns_sems(task)  ((task)->resq.next != &(task)->resq)
+
+static inline void enqueue_resqel(QUEUE *resqel, RT_TASK *resownr)
+{
+	QUEUE *resq;
+	resqel->next = resq = &resownr->resq;
+	(resqel->prev = resq->prev)->next = resqel;
+	resq->prev = resqel;
+}
+
+#define enqueue_resqtsk(resownr)
+
+#define RESQEL_TASK ((((QUEUE *)resqel->task)->next)->task)
+
+static inline int _set_task_prio_from_resq(RT_TASK *resownr)
+{
+	int hprio;
+	RT_TASK *task;
+	QUEUE *resq, *resqel;
+	hprio = resownr->base_priority;
+	resqel = resq = &resownr->resq;
+	while ((resqel = resqel->next) != resq && (task = RESQEL_TASK) && task->priority < hprio) {
+		hprio = task->priority;
+	}
+	return hprio;
+}
+
+static inline int dequeue_resqel_reset_task_priority(QUEUE *resqel, RT_TASK *resownr)
+{
+	int hprio, prio;
+	QUEUE *q;
+	(resqel->prev)->next = resqel->next;
+	(resqel->next)->prev = resqel->prev;
+	hprio = _set_task_prio_from_resq(resownr);
+	return renq_ready_task(resownr, ((q = resownr->msg_queue.next) != &resownr->msg_queue && (prio = (q->task)->priority) < hprio) ? prio : hprio);
+}
+
+static inline int set_task_prio_from_resq(RT_TASK *resownr)
+{
+	int hprio, prio;
+	QUEUE *q;
+	hprio = _set_task_prio_from_resq(resownr);
+	return renq_ready_task(resownr, ((q = resownr->msg_queue.next) != &resownr->msg_queue && (prio = (q->task)->priority) < hprio) ? prio : hprio);
+}
+
+#else /* !CONFIG_RTAI_FULL_PRINHER */
+
+#define task_owns_sems(task)  ((task)->owndres)
+
+#define enqueue_resqel(resqel, task) \
+	do { (task)->owndres++; } while (0)
+
+#define enqueue_resqtsk(task)
+//	do { (task)->owndres += RPCINC; } while (0)
+
+static inline int _set_task_prio_from_resq(RT_TASK *resownr)
+{
+	QUEUE *q;
+	int prio;
+	return renq_ready_task(resownr, ((q = resownr->msg_queue.next) != &resownr->msg_queue && (prio = (q->task)->priority) < resownr->base_priority) ? prio : resownr->base_priority);
+}
+
+static inline int dequeue_resqel_reset_task_priority(QUEUE *resqel, RT_TASK *resownr)
+{
+	if (--resownr->owndres <= 0) {
+		resownr->owndres = 0;
+		return _set_task_prio_from_resq(resownr);
+	}
+	return 0;
+}
+
+static inline int set_task_prio_from_resq(RT_TASK *resownr)
+{
+	return !resownr->owndres ? _set_task_prio_from_resq(resownr) : 0;
+}
+
+#endif /* CONFIG_RTAI_FULL_PRINHER */
+
+#define dequeue_resqel_reset_current_priority(resqel, rt_current) \
+	dequeue_resqel_reset_task_priority(resqel, rt_current)
+
+#define set_current_prio_from_resq(rt_current) \
+	set_task_prio_from_resq(rt_current)
+
+#define task_owns_msgs(task)  ((task)->msg_queue.next != &(task)->msg_queue)
+#define task_owns_res(task)   (task_owns_sems(task) || task_owns_msgs(task))
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_PRINHER_H */

include/rtai_proc_fs.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 1999-2017 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_PROC_FS_H
+#define _RTAI_PROC_FS_H
+
+extern struct proc_dir_entry *rtai_proc_root;
+
+#include <linux/seq_file.h>
+
+#define PROC_READ_FUN(read_fun_name) \
+	read_fun_name(struct seq_file *pf, void *v)
+
+#define PROC_READ_OPEN_OPS(rtai_proc_fops, read_fun_name) \
+\
+static int rtai_proc_open(struct inode *inode, struct file *file) { \
+	return single_open(file, read_fun_name, NULL); \
+} \
+\
+static const struct file_operations rtai_proc_fops = { \
+	.owner = THIS_MODULE, \
+	.open = rtai_proc_open, \
+	.read = seq_read, \
+	.llseek = seq_lseek, \
+	.release = single_release \
+};
+
+static inline void *CREATE_PROC_ENTRY(const char *name, umode_t mode, void *parent, const struct file_operations *proc_fops)
+{
+	return !parent ? proc_mkdir(name, NULL) : proc_create(name, mode, parent, proc_fops);
+}
+
+#define SET_PROC_READ_ENTRY(entry, read_fun)  do { } while(0)
+
+#define PROC_PRINT_VARS 
+
+#define PROC_PRINT(fmt, args...)  \
+	do { seq_printf(pf, fmt, ##args); } while(0)
+
+#define PROC_PRINT_RETURN do { goto done; } while(0)
+
+#define PROC_PRINT_DONE do { return 0; } while(0)
+
+// End of proc print macros
+
+#endif  /* !_RTAI_PROC_FS_H */

include/rtai_proxies.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2000  Pierre Cloutier  <pcloutier@poseidoncontrols.com>
+ * Copyright (C) 2000  Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_PROXIES_H
+#define _RTAI_PROXIES_H
+
+#include <rtai_sched.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+// Create a generic proxy task.
+RT_TASK *__rt_proxy_attach(void (*func)(long),
+			   RT_TASK *task,
+			   void *msg,
+			   int nbytes,
+			   int priority);
+
+// Create a raw proxy task.
+RTAI_SYSCALL_MODE RT_TASK *rt_proxy_attach(RT_TASK *task,
+			 void *msg,
+			 int nbytes,
+			 int priority);
+
+// Delete a proxy task (a simplified specific rt_task_delete).
+RTAI_SYSCALL_MODE int rt_proxy_detach(RT_TASK *proxy);
+
+//Trigger a proxy.
+RTAI_SYSCALL_MODE RT_TASK *rt_trigger(RT_TASK *proxy);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !_RTAI_PROXIES_H */

include/rtai_registry.h

@@ -0,0 +1,96 @@
+/**
+ * @ingroup lxrt
+ * @file
+ *
+ * @author Paolo Mantegazza
+ *
+ * @note Copyright &copy; 1999  Paolo Mantegazza <mantegazza@aero.polimi.it>,
+ * @note Copyright &copy; 2019  Alec Ari <neotheuser@ymail.com,
+ * extensions for user space modules are jointly copyrighted (2000) with:
+ *            Pierre Cloutier <pcloutier@poseidoncontrols.com>,
+ *     	      Steve Papacharalambous <stevep@zentropix.com>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_REGISTRY_H
+#define _RTAI_REGISTRY_H
+
+#include <rtai_nam2num.h>
+
+struct task_struct;
+
+struct rt_registry_entry {
+	unsigned long name;	 // Numerical representation of resource name
+	void *adr;		 // Physical rt memory address of resource
+	struct task_struct *tsk; // Linux task owner of the resource
+	int type;		 // Type of resource
+        unsigned short count;	 // Usage registry
+	unsigned short alink;
+	unsigned short nlink;
+};
+
+#define MAX_SLOTS  CONFIG_RTAI_SCHED_LXRT_NUMSLOTS // Max number of registered objects
+
+#define IS_TASK  0               // Used to identify registered resources
+#define IS_SEM   1
+#define IS_RWL   2
+#define IS_SPL   3
+#define IS_MBX   4
+#define IS_PRX   5
+#define IS_HPCK  6
+
+#ifdef __KERNEL__
+
+#include <rtai.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+unsigned long is_process_registered(struct task_struct *tsk);
+
+int rt_register(unsigned long nam,
+		void *adr,
+		int typ,
+		struct task_struct *tsk);
+
+int rt_drg_on_name(unsigned long name);
+
+int rt_drg_on_name_cnt(unsigned long name);
+
+int rt_drg_on_adr(void *adr);
+
+int rt_drg_on_adr_cnt(void *adr);
+
+RTAI_SYSCALL_MODE unsigned long rt_get_name(void *adr);
+
+RTAI_SYSCALL_MODE void *rt_get_adr(unsigned long name);
+
+void *rt_get_adr_cnt(unsigned long name);
+
+int rt_get_type(unsigned long name);
+
+int rt_get_registry_slot(int slot, struct rt_registry_entry *entry);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif
+
+#define exist(name)  rt_get_adr(nam2num(name))
+
+#endif /* !_RTAI_REGISTRY_H */

include/rtai_rwl.h

@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 1999-2003 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_RWL_H
+#define _RTAI_RWL_H
+
+#include <rtai_sem.h>
+
+struct rtai_rwlock;
+
+#ifdef __KERNEL__
+
+#ifndef __cplusplus
+
+typedef struct rtai_rwlock {
+    SEM wrmtx,
+	wrsem,
+	rdsem;
+} RWL;
+
+#else /* __cplusplus */
+extern "C" {
+#endif /* !__cplusplus */
+
+RTAI_SYSCALL_MODE int rt_typed_rwl_init(RWL *rwl, int type);
+
+#define rt_rwl_init(rwl)  rt_typed_rwl_init(rwl, RESEM_RECURS)
+
+RTAI_SYSCALL_MODE int rt_rwl_delete(struct rtai_rwlock *rwl);
+
+RTAI_SYSCALL_MODE RWL *_rt_named_rwl_init(unsigned long rwl_name);
+
+RTAI_SYSCALL_MODE int rt_named_rwl_delete(RWL *rwl);
+
+RTAI_SYSCALL_MODE int rt_rwl_rdlock(struct rtai_rwlock *rwl);
+
+RTAI_SYSCALL_MODE int rt_rwl_rdlock_if(struct rtai_rwlock *rwl);
+
+RTAI_SYSCALL_MODE int rt_rwl_rdlock_until(struct rtai_rwlock *rwl, RTIME time);
+
+RTAI_SYSCALL_MODE int rt_rwl_rdlock_timed(struct rtai_rwlock *rwl, RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_rwl_wrlock(struct rtai_rwlock *rwl);
+
+RTAI_SYSCALL_MODE int rt_rwl_wrlock_if(struct rtai_rwlock *rwl);
+
+RTAI_SYSCALL_MODE int rt_rwl_wrlock_until(struct rtai_rwlock *rwl, RTIME time);
+
+RTAI_SYSCALL_MODE int rt_rwl_wrlock_timed(struct rtai_rwlock *rwl, RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_rwl_unlock(struct rtai_rwlock *rwl);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else /* !__KERNEL__ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define rt_rwl_init(rwl)  rt_typed_rwl_init(rwl, RESEM_RECURS)
+
+RTAI_PROTO(struct rtai_rwlock *, rt_typed_rwl_init,(unsigned long name, int type))
+{
+        struct { unsigned long name; long type; } arg = { name, type };
+       	return (struct rtai_rwlock *)rtai_lxrt(BIDX, SIZARG, LXRT_RWL_INIT, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_delete,(struct rtai_rwlock *rwl))
+{
+	struct { struct rtai_rwlock *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, LXRT_RWL_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(struct rtai_rwlock *, rt_named_rwl_init,(const char *name))
+{
+	struct { unsigned long name; } arg = { nam2num(name) };
+       	return (struct rtai_rwlock *)rtai_lxrt(BIDX, SIZARG, NAMED_RWL_INIT, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_named_rwl_delete,(struct rtai_rwlock *rwl))
+{
+	struct { struct rtai_rwlock *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, NAMED_RWL_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_rdlock,(struct rtai_rwlock *rwl))
+{
+	struct { struct rtai_rwlock *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, RWL_RDLOCK, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_rdlock_if,(struct rtai_rwlock *rwl))
+{
+	struct { void *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, RWL_RDLOCK_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_rdlock_until,(struct rtai_rwlock *rwl, RTIME time))
+{
+	struct { struct rtai_rwlock *rwl; RTIME time; } arg = { rwl, time };
+	return rtai_lxrt(BIDX, SIZARG, RWL_RDLOCK_UNTIL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_rdlock_timed,(struct rtai_rwlock *rwl, RTIME delay))
+{
+	struct { struct rtai_rwlock *rwl; RTIME delay; } arg = { rwl, delay };
+	return rtai_lxrt(BIDX, SIZARG, RWL_RDLOCK_TIMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_wrlock,(struct rtai_rwlock *rwl))
+{
+	struct { struct rtai_rwlock *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, RWL_WRLOCK, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_wrlock_if,(struct rtai_rwlock *rwl))
+{
+	struct { struct rtai_rwlock *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, RWL_WRLOCK_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_wrlock_until,(struct rtai_rwlock *rwl, RTIME time))
+{
+	struct { struct rtai_rwlock *rwl; RTIME time; } arg = { rwl, time };
+	return rtai_lxrt(BIDX, SIZARG, RWL_WRLOCK_UNTIL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_wrlock_timed,(struct rtai_rwlock *rwl, RTIME delay))
+{
+	struct { struct rtai_rwlock *rwl; RTIME delay; } arg = { rwl, delay };
+	return rtai_lxrt(BIDX, SIZARG, RWL_WRLOCK_TIMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_rwl_unlock,(struct rtai_rwlock *rwl))
+{
+	struct { struct rtai_rwlock *rwl; } arg = { rwl };
+	return rtai_lxrt(BIDX, SIZARG, RWL_UNLOCK, &arg).i[LOW];
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#if !defined(__KERNEL__) || defined(__cplusplus)
+
+typedef struct rtai_rwlock {
+    int opaque;
+} RWL;
+
+#endif /* !__KERNEL__ || __cplusplus */
+
+#endif /* !_RTAI_RWL_H */

include/rtai_scb.h

@@ -0,0 +1,332 @@
+/**
+ * @ingroup shm
+ * @file
+ *
+ * SCB stand for Shared (memory) Circular Buffer. It is a non blocking
+ * implementation for just a single writer (producer) and reader
+ * (consumer) and, under such a constraint, it can be a specific
+ * substitute for RTAI mailboxes. There are other constraints that
+ * must be satisfied, so it cannot be a general substitute for the more
+ * flexible RTAI mailboxes. In fact it provides just functions
+ * corresponding to RTAI mailboxes non blocking atomic send/receive of
+ * messages, i.e. the equivalents of rt_mbx_send_if and
+ * rt_mbx_receive_if. Moreover the circular buffer size must be >= to
+ * the largest message to be sent/received. At least the double of the 
+ * largest message to be sent/received is strongly recommended.
+ * Thus sending/receiving a message either succeeds of fails. However 
+ * thanks to the use of shared memory it should be more efficient than
+ * mailboxes in atomic exchanges of messages from kernel to user space.
+ * So it is a good candidate for supporting drivers development.
+ *
+ * @author Paolo Mantegazza
+ *
+ * @note Copyright &copy; 2004-2008 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_SCB_H
+#define _RTAI_SCB_H
+
+#include <rtai_shm.h>
+#include <asm/rtai_atomic.h>
+
+#define SCB     ((void *)(scb))
+#define SIZE    ((volatile int *)scb)[-3]
+#define FBYTE   ((volatile int *)scb)[-2]
+#define LBYTE   ((volatile int *)scb)[-1]
+#define HDRSIZ  (3*sizeof(int))
+
+struct task_struct;
+
+#ifdef __KERNEL__
+
+#define RTAI_SCB_PROTO(type, name, arglist)  static inline type name arglist
+
+#else
+
+#define RTAI_SCB_PROTO  RTAI_PROTO
+
+#endif
+
+/**
+ * Allocate and initialize a shared memory circular buffer.
+ *
+ * @internal
+ *
+ * rt_scb_init is used to allocate and/or initialize a shared memory circular
+ * buffer.
+ *
+ * @param name is an unsigned long identifier;
+ *
+ * @param size is the size of the circular buffer.
+ *
+ * @param suprt is the kernel allocation method to be used, it can be:
+ * - USE_VMALLOC, use vmalloc;
+ * - USE_GFP_KERNEL, use kmalloc with GFP_KERNEL;
+ * - USE_GFP_ATOMIC, use kmalloc with GFP_ATOMIC;
+ * - USE_GFP_DMA, use kmalloc with GFP_DMA.
+ * - for use in kernel/(multi-threaded)user space only applications the 
+ *   user can use "suprt" to pass the address of any memory area (s)he has
+ *   allocated on her/his own. In such a case the actual buffer should be
+ *   greater than the requested size by the amount HDRSIZ at least.
+ *
+ * Since @a an unsigned long can be a clumsy identifier, services are provided
+ * to convert 6 characters identifiers to unsigned long, and vice versa.
+ *
+ * @see nam2num() and num2nam().
+ *
+ * It must be remarked that only the very first call does a real allocation,
+ * any following call to allocate with the same name, from anywhere, will just
+ * increase the usage count and map the circular buffer to the user space, or 
+ * return the related pointer to the already allocated buffer in kernel/user
+ * space.
+ * In any case the functions return a pointer to the circular buffer,
+ * appropriately mapped to the memory space in use. So if one is really sure
+ * that the named circular buffer has been initted already parameters "size"
+ * and "suprt" are not used and can be assigned any value.
+ *
+ * @returns a valid address on succes, you must use it, 0 on failure.
+ *
+ */
+
+RTAI_SCB_PROTO(void *, rt_scb_init, (unsigned long name, int size, unsigned long suprt))
+{	
+	void *scb;
+	if (suprt > 1000) {
+		size -=  HDRSIZ + 1;
+		scb = (void *)suprt;
+	} else {
+		scb = rt_shm_alloc(name, size + HDRSIZ + 1, suprt);
+	}
+	if (scb && !atomic_cmpxchg((atomic_t *)scb, 0, name)) {
+		((int *)scb)[1] = ((int *)scb)[2] = 0;
+		((int *)scb)[0] = size + 1;
+	} else {
+		while (!((int *)scb)[0]);
+	}			
+	return scb ? scb + HDRSIZ : 0;
+}
+
+/**
+ * Reset a shared memory circular buffer.
+ *
+ * @internal
+ *
+ * rt_scb_reset reinitializes a shared memory circular buffer.
+ *
+ * @param scb is the pointer returned when the buffer was initted.
+ *
+ */
+
+RTAI_SCB_PROTO(void, rt_scb_reset, (void *scb))
+{ 
+	LBYTE = FBYTE = 0;
+}
+
+/**
+ * Free a shared memory circular buffer.
+ *
+ * @internal
+ *
+ * rt_scb_delete is used to release a previously allocated shared memory 
+ * circular buffer.
+ *
+ * @param name is the unsigned long identifier used when the buffer was
+ * allocated;
+ *
+ * Analogously to what done by all the named allocation functions the freeing
+ * calls have just the effect of decrementing a usage count, unmapping any
+ * user space shared memory being freed, till the last is done, as that is the
+ * one the really frees any allocated memory.
+ *
+ * @returns the size of the succesfully freed buffer, 0 on failure.
+ *
+ * No need to call this function if you provided your own memory for the
+ * circular buffer. 
+ *
+ */
+
+RTAI_SCB_PROTO(int, rt_scb_delete, (unsigned long name))
+{ 
+	return rt_shm_free(name);
+}
+
+/**
+ * Get the number of bytes avaiable in a shared memory circular buffer.
+ *
+ * @internal
+ *
+ * rt_scb_avbs is used to get the number of bytes avaiable in a shared 
+ * memory circular buffer.
+ *
+ * @param scb is the pointer handle returned when the buffer was initted.
+ *
+ * @returns the available number of bytes.
+ *
+ */
+
+RTAI_SCB_PROTO (int, rt_scb_avbs, (void *scb))
+{ 
+	int size = SIZE, fbyte = FBYTE, lbyte = LBYTE;
+	return (lbyte >= fbyte ? lbyte - fbyte : size + lbyte - fbyte);
+}
+
+/**
+ * Get the number of bytes avaiable in a shared memory circular buffer.
+ *
+ * @internal
+ *
+ * rt_scb_bytes is used to get the number of bytes avaiable in a shared 
+ * memory circular buffer; legacy alias for rt_scb_avbs.
+ *
+ * @param scb is the pointer handle returned when the buffer was initted.
+ *
+ * @returns the available number of bytes.
+ *
+ */
+
+RTAI_SCB_PROTO (int, rt_scb_bytes, (void *scb))
+{ 
+	return rt_scb_avbs(scb);
+}
+
+/**
+ * Get the number of free bytes pace in a shared memory circular buffer.
+ *
+ * @internal
+ *
+ * rt_scb_frbs is used to get the number of free bytes space avaiable in a 
+ * shared memory circular buffer.
+ *
+ * @param scb is the pointer handle returned when the buffer was initted.
+ *
+ * @returns the number of free bytes.
+ *
+ */
+
+RTAI_SCB_PROTO (int, rt_scb_frbs, (void *scb))
+{ 
+	int size = SIZE, fbyte = FBYTE, lbyte = LBYTE;
+	return (fbyte <= lbyte ? size + fbyte - lbyte : size - lbyte);
+}
+
+/**
+ * @brief Gets (receives) a message, only if the whole message can be passed 
+ * all at once.
+ *
+ * rt_scb_get tries to atomically receive the message @e msg of @e
+ * msg_size bytes from the shared memory circular buffer @e scb.
+ * It returns immediately and the caller is never blocked.
+ *
+ * @return On success, i.e. message got, it returns 0, msg_size on failure.
+ *
+ */
+
+RTAI_SCB_PROTO(int, rt_scb_get, (void *scb, void *msg, int msg_size))
+{ 
+	int size = SIZE, fbyte = FBYTE, lbyte = LBYTE;
+	if (msg_size > 0 && ((lbyte -= fbyte) >= 0 ? lbyte : size + lbyte) >= msg_size) {
+		int tocpy;
+		if ((tocpy = size - fbyte) > msg_size) {
+			memcpy(msg, SCB + fbyte, msg_size);
+			FBYTE = fbyte + msg_size;
+		} else {
+			memcpy(msg, SCB + fbyte, tocpy);
+			memcpy(msg + tocpy, SCB, msg_size -= tocpy);
+			FBYTE = msg_size;
+		}
+		return 0;
+	}
+	return msg_size;
+}
+
+/**
+ * @brief eavedrops a message.
+ *
+ * rt_scb_evdrp atomically spies the message @e msg of @e
+ * msg_size bytes from the shared memory circular buffer @e scb.
+ * It returns immediately and the caller is never blocked. It is like 
+ * rt_scb_get but leaves the message in the shared memory circular buffer.
+ *
+ * @return On success, i.e. message got, it returns 0, msg_size on failure.
+ *
+ */
+
+RTAI_SCB_PROTO(int, rt_scb_evdrp, (void *scb, void *msg, int msg_size))
+{ 
+	int size = SIZE, fbyte = FBYTE, lbyte = LBYTE;
+	if (msg_size > 0 && ((lbyte -= fbyte) >= 0 ? lbyte : size + lbyte) >= msg_size) {
+		int tocpy;
+		if ((tocpy = size - fbyte) > msg_size) {
+			memcpy(msg, SCB + fbyte, msg_size);
+		} else {
+			memcpy(msg, SCB + fbyte, tocpy);
+			memcpy(msg + tocpy, SCB, msg_size - tocpy);
+		}
+		return 0;
+	}
+	return msg_size;
+}
+
+/**
+ * @brief Puts (sends) a message, only if the whole message can be passed all
+ * at once.
+ *
+ * rt_scb_put tries to atomically send the message @e msg of @e
+ * msg_size bytes to the shared memory circular buffer @e scb. 
+ * It returns immediately and the caller is never blocked.
+ *
+ * @return On success, i.e. message put, it returns 0, msg_size on failure.
+ *
+ */
+
+RTAI_SCB_PROTO(int, rt_scb_put, (void *scb, void *msg, int msg_size))
+{ 
+	int size = SIZE, fbyte = FBYTE, lbyte = LBYTE;
+	if (msg_size > 0 && ((fbyte -= lbyte) <= 0 ? size + fbyte : fbyte) > msg_size) {
+		int tocpy;
+		if ((tocpy = size - lbyte) > msg_size) {
+			memcpy(SCB + lbyte, msg, msg_size);
+			LBYTE = lbyte + msg_size;
+		} else {
+			memcpy(SCB + lbyte, msg, tocpy);
+			memcpy(SCB, msg + tocpy, msg_size -= tocpy);
+			LBYTE = msg_size;
+		}
+		return 0;
+	}
+	return msg_size;
+}
+
+RTAI_SCB_PROTO(int, rt_scb_ovrwr, (void *scb, void *msg, int msg_size))
+{ 
+	int size = SIZE, lbyte = LBYTE;
+	if (msg_size > 0 && msg_size < size) {
+		int tocpy;
+		if ((tocpy = size - lbyte) > msg_size) {
+			memcpy(SCB + lbyte, msg, msg_size);
+			LBYTE = lbyte + msg_size;
+		} else {
+			memcpy(SCB + lbyte, msg, tocpy);
+			memcpy(SCB, msg + tocpy, msg_size -= tocpy);
+			LBYTE = msg_size;
+		}
+		return 0;
+	}
+	return msg_size;
+}
+
+#endif /* _RTAI_SCB_H */

include/rtai_sched.h

@@ -0,0 +1,528 @@
+/*
+ * Copyright (C) 1999-2017 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_SCHED_H
+#define _RTAI_SCHED_H
+
+#include <rtai.h>
+#ifndef __KERNEL__
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+#include <rtai_types.h>
+#endif /* __KERNEL__ */
+
+#define RT_SCHED_UP   1
+#define RT_SCHED_SMP  2
+#define RT_SCHED_MUP  3
+
+#define RT_SCHED_HIGHEST_PRIORITY  0
+#define RT_SCHED_LOWEST_PRIORITY   0x3fffFfff
+#define RT_SCHED_LINUX_PRIORITY    0x7fffFfff
+
+#define RT_RESEM_SUSPDEL  (-0x7fffFfff)
+
+#define RT_SCHED_READY        1
+#define RT_SCHED_SUSPENDED    2
+#define RT_SCHED_DELAYED      4
+#define RT_SCHED_SEMAPHORE    8
+#define RT_SCHED_SEND        16
+#define RT_SCHED_RECEIVE     32
+#define RT_SCHED_RPC         64
+#define RT_SCHED_RETURN     128
+#define RT_SCHED_MBXSUSP    256
+#define RT_SCHED_SFTRDY     512
+#define RT_SCHED_POLL      1024
+#define RT_SCHED_SIGSUSP    (1 << 15)
+
+#define RT_RWLINV     (11)  // keep this the highest
+#define RT_CHGPORTERR (10)
+#define RT_CHGPORTOK  (9)
+#define RT_NETIMOUT   (8)
+#define RT_DEADLOK    (7)
+#define RT_PERM       (6)
+#define RT_OBJINV     (5)
+#define RT_OBJREM     (4)
+#define RT_TIMOUT     (3)
+#define RT_UNBLKD     (2)
+#define RT_TMROVRN    (1)  // keep this the lowest, must be 1
+#define RTP_RWLINV     ((void *)RT_RWLINV)
+#define RTP_CHGPORTERR ((void *)RT_CHGPORTERR)
+#define RTP_CHGPORTOK  ((void *)RT_CHGPORTOK)
+#define RTP_NETIMOUT   ((void *)RT_NETIMOUT)
+#define RTP_DEADLOK    ((void *)RT_DEADLOK)
+#define RTP_PERM       ((void *)RT_PERM)
+#define RTP_OBJINV     ((void *)RT_OBJINV)
+#define RTP_OBJREM     ((void *)RT_OBJREM)
+#define RTP_TIMOUT     ((void *)RT_TIMOUT)
+#define RTP_UNBLKD     ((void *)RT_UNBLKD)
+#define RTP_TMROVRN    ((void *)RT_TMROVRN)
+#define RTP_HIGERR     (RTP_RWLINV)
+#define RTP_LOWERR     (RTP_TMROVRN)
+#if CONFIG_RTAI_USE_NEWERR
+#define RTE_BASE       (0x3FFFFF00)
+#define RTE_RWLINV     (RTE_BASE + RT_RWLINV)
+#define RTE_CHGPORTERR (RTE_BASE + RT_CHGPORTERR)
+#define RTE_CHGPORTOK  (RTE_BASE + RT_CHGPORTOK)
+#define RTE_NETIMOUT   (RTE_BASE + RT_NETIMOUT)
+#define RTE_DEADLOK    (RTE_BASE + RT_DEADLOK)
+#define RTE_PERM       (RTE_BASE + RT_PERM)
+#define RTE_OBJINV     (RTE_BASE + RT_OBJINV)
+#define RTE_OBJREM     (RTE_BASE + RT_OBJREM)
+#define RTE_TIMOUT     (RTE_BASE + RT_TIMOUT)
+#define RTE_UNBLKD     (RTE_BASE + RT_UNBLKD)
+#define RTE_TMROVRN    (RTE_BASE + RT_TMROVRN)
+#define RTE_HIGERR     (RTE_RWLINV)
+#define RTE_LOWERR     (RTE_TMROVRN)
+#else
+#define RTE_BASE       (0xFFFB)
+#define RTE_RWLINV     (RTE_BASE + RT_RWLINV)
+#define RTE_CHGPORTERR (RTE_BASE + RT_CHGPORTERR)
+#define RTE_CHGPORTOK  (RTE_BASE + RT_CHGPORTOK)
+#define RTE_NETIMOUT   (RTE_BASE + RT_NETIMOUT)
+#define RTE_DEADLOK    (RTE_BASE + RT_DEADLOK)
+#define RTE_PERM       (RTE_BASE + RT_PERM)
+#define RTE_OBJINV     (RTE_BASE + RT_OBJREM)
+#define RTE_OBJREM     (RTE_BASE + RT_OBJREM)
+#define RTE_TIMOUT     (RTE_BASE + RT_TIMOUT)
+#define RTE_UNBLKD     (RTE_BASE + RT_UNBLKD)
+#define RTE_TMROVRN    (RTE_BASE + RT_TMROVRN)
+#define RTE_HIGERR     (RTE_RWLINV)
+#define RTE_LOWERR     (RTE_TMROVRN)
+#endif
+
+#define RT_EINTR      (RTE_UNBLKD)
+
+#define rt_is_reterr(i)  (i >= RTE_LOWERR)
+
+#define RT_IRQ_TASK         0
+#define RT_IRQ_TASKLET      1
+#define RT_IRQ_TASK_ERR     0x7FFFFFFF
+
+struct rt_task_struct;
+
+typedef struct rt_task_info { 
+	RTIME period; long base_priority, priority; 
+} RT_TASK_INFO;
+
+#ifdef __KERNEL__
+
+#include <linux/time.h>
+#include <linux/errno.h>
+
+#if defined(CONFIG_RTAI_LONG_TIMED_LIST)
+#include <linux/rbtree.h>
+typedef struct rb_node rb_node_t;
+typedef struct rb_root rb_root_t;
+#endif
+
+#define RT_TASK_MAGIC 0x9ad25f6f  // nam2num("rttask")
+
+#ifndef __cplusplus
+
+#include <linux/sched.h>
+
+typedef struct rt_queue {
+	struct rt_queue *prev;
+	struct rt_queue *next;
+	struct rt_task_struct *task;
+} QUEUE;
+
+struct mcb_t {
+	void *sbuf;
+	int sbytes;
+	void *rbuf;
+	int rbytes;
+};
+
+/*Exit handler functions are called like C++ destructors in rt_task_delete().*/
+typedef struct rt_ExitHandler {
+	struct rt_ExitHandler *nxt;
+	void (*fun) (void *arg1, int arg2);
+	void *arg1;
+	int   arg2;
+} XHDL;
+
+struct rt_heap_t { void *heap, *kadr, *uadr; };
+
+#define RTAI_MAX_NAME_LENGTH  32
+
+typedef struct rt_task_struct {
+	long *stack __attribute__ ((__aligned__ (L1_CACHE_BYTES)));
+	int uses_fpu;
+	int magic;
+	volatile int state, running;
+	unsigned long runnable_on_cpus;
+	long *stack_bottom;
+	volatile int priority;
+	int base_priority;
+	int policy;
+	int sched_lock_priority;
+	struct rt_task_struct *prio_passed_to;
+	RTIME period;
+	RTIME resume_time;
+	RTIME periodic_resume_time;
+	RTIME yield_time;
+	int rr_quantum, rr_remaining;
+	int suspdepth;
+	struct rt_queue queue;
+	int owndres;
+	struct rt_queue *blocked_on;
+	struct rt_queue msg_queue;
+	int tid;  /* trace ID */
+	unsigned long msg;
+	struct rt_queue ret_queue;
+	void (*signal)(void);
+	FPU_ENV fpu_reg __attribute__ ((__aligned__ (L1_CACHE_BYTES)));
+	struct rt_task_struct *prev, *next;
+	struct rt_task_struct *tprev, *tnext;
+	struct rt_task_struct *rprev, *rnext;
+
+	/* For calls from LINUX. */
+	long *fun_args;
+	long *bstack;
+	struct task_struct *lnxtsk;
+	long long retval;
+	char *msg_buf[2];
+	long max_msg_size[2];
+	char task_name[RTAI_MAX_NAME_LENGTH];
+	void *system_data_ptr;
+	struct rt_task_struct *nextp, *prevp;
+
+	RT_TRAP_HANDLER task_trap_handler[RTAI_NR_TRAPS];
+
+	long unblocked;
+	void *rt_signals;
+	volatile unsigned long pstate;
+	unsigned long usp_flags;
+	unsigned long usp_flags_mask;
+	unsigned long force_soft;
+	volatile int is_hard;
+	int kerrno;
+
+	long busy_time_align;
+	void *linux_syscall_server;
+
+	/* For use by watchdog. */
+	int resync_frame;
+
+	/* For use by exit handler functions. */
+	XHDL *ExitHook;
+
+	RTIME exectime[2];
+	struct mcb_t mcb;
+
+	/* Real time heaps. */
+	struct rt_heap_t heap[2];
+
+	long scheduler;
+
+#ifdef CONFIG_RTAI_LONG_TIMED_LIST
+	rb_root_t rbr;
+	rb_node_t rbn;
+#endif
+	struct rt_queue resq;
+	unsigned long resumsg;
+	int schedlat;
+} RT_TASK __attribute__ ((__aligned__ (L1_CACHE_BYTES)));
+
+#else /* __cplusplus */
+extern "C" {
+#endif /* !__cplusplus */
+
+int set_rtext(RT_TASK *task, int priority, int uses_fpu, void(*signal)(void), unsigned int cpuid);
+
+int rt_task_init(struct rt_task_struct *task,
+		 void (*rt_thread)(long),
+		 long data,
+		 int stack_size,
+		 int priority,
+		 int uses_fpu,
+		 void(*signal)(void));
+
+int rt_task_init_cpuid(struct rt_task_struct *task,
+		       void (*rt_thread)(long),
+		       long data,
+		       int stack_size,
+		       int priority,
+		       int uses_fpu,
+		       void(*signal)(void),
+		       unsigned run_on_cpu);
+
+void rt_thread_create(void *fun, void *args, struct task_struct **thread);
+
+RT_TASK *rt_thread_init(unsigned long name, int priority, int make_hard, int policy, int cpus_allowed);
+
+int rt_thread_delete(RT_TASK *rt_task);
+
+
+int rt_kthread_init(struct rt_task_struct *task,
+		    void (*rt_thread)(long),
+		    long data,
+		    int stack_size,
+		    int priority,
+		    int uses_fpu,
+		    void(*signal)(void));
+
+int rt_kthread_init_cpuid(struct rt_task_struct *task,
+		          void (*rt_thread)(long),
+		          long data,
+		          int stack_size,
+		          int priority,
+		          int uses_fpu,
+		          void(*signal)(void),
+		          unsigned run_on_cpu);
+
+RTAI_SYSCALL_MODE void rt_set_runnable_on_cpus(struct rt_task_struct *task,
+			     unsigned long cpu_mask);
+
+RTAI_SYSCALL_MODE void rt_set_runnable_on_cpuid(struct rt_task_struct *task,
+			      unsigned cpuid);
+
+RTAI_SYSCALL_MODE void rt_set_sched_policy(struct rt_task_struct *task,
+			 int policy,
+			 int rr_quantum_ns);
+
+int rt_task_delete(struct rt_task_struct *task);
+
+int rt_get_task_state(struct rt_task_struct *task);
+
+void rt_gettimeorig(RTIME time_orig[]);
+
+int rt_get_timer_cpu(void);
+
+int rt_is_hard_timer_running(void);
+
+void rt_set_periodic_mode(void);
+
+void rt_set_oneshot_mode(void);
+
+RTAI_SYSCALL_MODE RTIME start_rt_timer(int period);
+
+#define start_rt_timer_ns(period) start_rt_timer(nano2count((period)))
+
+RTAI_SYSCALL_MODE void start_rt_apic_timers(struct apic_timer_setup_data *setup_mode,
+			  unsigned rcvr_jiffies_cpuid);
+
+void stop_rt_timer(void);
+
+struct rt_task_struct *rt_whoami(void);
+
+int rt_sched_type(void);
+
+RTAI_SYSCALL_MODE int rt_task_signal_handler(struct rt_task_struct *task,
+			   void (*handler)(void));
+
+RTAI_SYSCALL_MODE int rt_task_use_fpu(struct rt_task_struct *task,
+		    int use_fpu_flag);
+  
+void rt_linux_use_fpu(int use_fpu_flag);
+
+RTAI_SYSCALL_MODE int rt_hard_timer_tick_count(void);
+
+RTAI_SYSCALL_MODE int rt_hard_timer_tick_count_cpuid(int cpuid);
+
+RTAI_SYSCALL_MODE RTIME count2nano(RTIME timercounts);
+
+RTAI_SYSCALL_MODE RTIME nano2count(RTIME nanosecs);
+  
+RTAI_SYSCALL_MODE RTIME count2nano_cpuid(RTIME timercounts, unsigned cpuid);
+
+RTAI_SYSCALL_MODE RTIME nano2count_cpuid(RTIME nanosecs, unsigned cpuid);
+  
+RTIME rt_get_time(void);
+
+RTAI_SYSCALL_MODE RTIME rt_get_time_cpuid(unsigned cpuid);
+
+RTIME rt_get_time_ns(void);
+
+RTAI_SYSCALL_MODE RTIME rt_get_time_ns_cpuid(unsigned cpuid);
+
+RTIME rt_get_cpu_time_ns(void);
+
+RTIME rt_get_real_time(void);
+
+RTIME rt_get_real_time_ns(void);
+
+int rt_get_prio(struct rt_task_struct *task);
+
+int rt_get_inher_prio(struct rt_task_struct *task);
+
+RTAI_SYSCALL_MODE int rt_task_get_info(RT_TASK *task, RT_TASK_INFO *task_info);
+
+RTAI_SYSCALL_MODE int rt_get_priorities(struct rt_task_struct *task, int *priority, int *base_priority);
+
+RTAI_SYSCALL_MODE void rt_spv_RMS(int cpuid);
+
+RTAI_SYSCALL_MODE int rt_change_prio(struct rt_task_struct *task,
+		   int priority);
+
+void rt_sched_lock(void);
+
+void rt_sched_unlock(void);
+
+void rt_task_yield(void);
+
+RTAI_SYSCALL_MODE int rt_task_suspend(struct rt_task_struct *task);
+
+RTAI_SYSCALL_MODE int rt_task_suspend_if(struct rt_task_struct *task);
+
+RTAI_SYSCALL_MODE int rt_task_suspend_until(struct rt_task_struct *task, RTIME until);
+
+RTAI_SYSCALL_MODE int rt_task_suspend_timed(struct rt_task_struct *task, RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_task_resume(struct rt_task_struct *task);
+
+RTAI_SYSCALL_MODE int rt_set_linux_syscall_mode(long sync_async, void (*callback_fun)(long, long));
+
+struct linux_syscalls_list;
+void rt_exec_linux_syscall(RT_TASK *rt_current, struct linux_syscalls_list *syscalls, struct pt_regs *regs);
+
+RTAI_SYSCALL_MODE void rt_return_linux_syscall(RT_TASK *task, unsigned long retval);
+
+RTAI_SYSCALL_MODE int rt_irq_wait(unsigned irq);
+
+RTAI_SYSCALL_MODE int rt_irq_wait_if(unsigned irq);
+
+RTAI_SYSCALL_MODE int rt_irq_wait_until(unsigned irq, RTIME until);
+
+RTAI_SYSCALL_MODE int rt_irq_wait_timed(unsigned irq, RTIME delay);
+
+RTAI_SYSCALL_MODE void rt_irq_signal(unsigned irq);
+
+RTAI_SYSCALL_MODE int rt_request_irq_task (unsigned irq, void *handler, int type, int affine2task);
+
+RTAI_SYSCALL_MODE int rt_release_irq_task (unsigned irq);
+
+RTAI_SYSCALL_MODE int rt_task_make_periodic_relative_ns(struct rt_task_struct *task,
+				      RTIME start_delay,
+				      RTIME period);
+
+RTAI_SYSCALL_MODE int rt_task_make_periodic(struct rt_task_struct *task,
+			  RTIME start_time,
+			  RTIME period);
+
+RTAI_SYSCALL_MODE void rt_task_set_resume_end_times(RTIME resume,
+				  RTIME end);
+
+RTAI_SYSCALL_MODE int rt_set_resume_time(struct rt_task_struct *task,
+		       RTIME new_resume_time);
+
+RTAI_SYSCALL_MODE int rt_set_period(struct rt_task_struct *task,
+		  RTIME new_period);
+
+int rt_task_wait_period(void);
+
+void rt_schedule(void);
+
+RTIME next_period(void);
+
+RTAI_SYSCALL_MODE void rt_busy_sleep(int nanosecs);
+
+RTAI_SYSCALL_MODE int rt_sleep(RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_sleep_until(RTIME time);
+
+RTAI_SYSCALL_MODE int rt_task_masked_unblock(struct rt_task_struct *task, unsigned long mask);
+
+#define rt_task_wakeup_sleeping(t)  rt_task_masked_unblock(t, RT_SCHED_DELAYED)
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_named_task_init(const char *task_name,
+					  void (*thread)(long),
+					  long data,
+					  int stack_size,
+					  int prio,
+					  int uses_fpu,
+					  void(*signal)(void));
+
+RTAI_SYSCALL_MODE struct rt_task_struct *rt_named_task_init_cpuid(const char *task_name,
+						void (*thread)(long),
+						long data,
+						int stack_size,
+						int prio,
+						int uses_fpu,
+						void(*signal)(void),
+						unsigned run_on_cpu);
+
+RTAI_SYSCALL_MODE int rt_named_task_delete(struct rt_task_struct *task);
+
+RT_TRAP_HANDLER rt_set_task_trap_handler(struct rt_task_struct *task,
+					 unsigned vec,
+					 RT_TRAP_HANDLER handler);
+
+static inline RTIME timeval2count(struct timeval *t)
+{
+        return nano2count(t->tv_sec*1000000000LL + t->tv_usec*1000);
+}
+
+static inline void count2timeval(RTIME rt, struct timeval *t)
+{
+        t->tv_sec = rtai_ulldiv(count2nano(rt), 1000000000, (unsigned long *)&t->tv_usec);
+        t->tv_usec /= 1000;
+}
+
+static inline RTIME timespec2count(const struct timespec *t)
+{
+        return nano2count(t->tv_sec*1000000000LL + t->tv_nsec);
+}
+
+static inline void count2timespec(RTIME rt, struct timespec *t)
+{
+        t->tv_sec = rtai_ulldiv(count2nano(rt), 1000000000, (unsigned long *)&t->tv_nsec);
+}
+
+static inline RTIME timespec2nanos(const struct timespec *t)
+{
+        return t->tv_sec*1000000000LL + t->tv_nsec;
+}
+
+static inline void nanos2timespec(RTIME rt, struct timespec *t)
+{
+        t->tv_sec = rtai_ulldiv(rt, 1000000000, (unsigned long *)&t->tv_nsec);
+}
+
+void rt_make_hard_real_time(RT_TASK *task);
+
+void rt_make_soft_real_time(RT_TASK *task);
+
+#ifdef __cplusplus
+}
+#else /* !__cplusplus */
+
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#if !defined(__KERNEL__) || defined(__cplusplus)
+
+typedef struct rt_task_struct {
+    int opaque;
+} RT_TASK;
+
+typedef struct QueueBlock {
+    int opaque;
+} QBLK;
+
+typedef struct QueueHook {
+    int opaque;
+} QHOOK;
+
+#endif /* !__KERNEL__ || __cplusplus */
+
+#endif /* !_RTAI_SCHED_H */

include/rtai_schedcore.h

@@ -0,0 +1,599 @@
+/*
+ * Copyright (C) 1999-2013 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef _RTAI_SCHEDCORE_H
+#define _RTAI_SCHEDCORE_H
+
+#ifdef __KERNEL__
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/timex.h>
+#include <linux/sched.h>
+#include <asm/param.h>
+#include <asm/io.h>
+#include <linux/oom.h>
+#include <rtai_lxrt.h>
+#include <rtai_sched.h>
+#include <rtai_malloc.h>
+#include <rtai_trace.h>
+#include <rtai_sem.h>
+#include <rtai_rwl.h>
+#include <rtai_spl.h>
+#include <rtai_scb.h>
+#include <rtai_mbx.h>
+#include <rtai_msg.h>
+#include <rtai_fifos.h>
+#include <rtai_shm.h>
+
+
+#ifdef OOM_DISABLE
+#define RTAI_OOM_DISABLE() \
+	do { current->signal->oom_score_adj = OOM_DISABLE; } while (0)
+#else
+#define RTAI_OOM_DISABLE()
+#endif
+
+#define NON_RTAI_TASK_SUSPEND(task) \
+	do { (task->lnxtsk)->state = TASK_SOFTREALTIME; } while (0)
+
+#define NON_RTAI_TASK_RESUME(ready_task) \
+	do { pend_wake_up_srq(ready_task->lnxtsk, rtai_cpuid()); } while (0)
+
+#define REQUEST_RESUME_SRQs_STUFF() \
+do { \
+	if (!(wake_up_srq[0].srq = hal_alloc_irq())) { \
+		printk("*** ABORT, NO VIRQ AVAILABLE FOR THE WAKING UP SRQ. ***\n"); \
+		return -1; \
+	} \
+	ipipe_request_irq(hal_root_domain, wake_up_srq[0].srq, (void *)wake_up_srq_handler, NULL, NULL); \
+} while (0)
+
+#define RELEASE_RESUME_SRQs_STUFF() \
+do { \
+	ipipe_free_irq(hal_root_domain, wake_up_srq[0].srq); \
+	hal_free_irq(wake_up_srq[0].srq); \
+} while (0)
+
+extern RT_TASK rt_smp_linux_task[];
+
+extern RT_TASK *rt_smp_current[];
+
+extern RTIME rt_smp_time_h[];
+
+extern volatile int rt_sched_timed;
+
+RT_TASK *rt_get_base_linux_task(RT_TASK **base_linux_task);
+
+RT_TASK *rt_alloc_dynamic_task(void);
+
+void rt_enq_ready_edf_task(RT_TASK *ready_task);
+
+void rt_enq_ready_task(RT_TASK *ready_task);
+
+int rt_renq_ready_task(RT_TASK *ready_task,
+		       int priority);
+
+void rt_rem_ready_task(RT_TASK *task);
+
+void rt_rem_ready_current(RT_TASK *rt_current);
+
+void rt_enq_timed_task(RT_TASK *timed_task);
+
+void rt_rem_timed_task(RT_TASK *task);
+
+void rt_dequeue_blocked(RT_TASK *task);
+
+#ifdef CONFIG_RTAI_MALLOC
+#ifdef CONFIG_RTAI_MALLOC_BUILTIN
+#define sched_mem_init() \
+	{ if(__rtai_heap_init() != 0) { \
+                return(-ENOMEM); \
+        } }
+#define sched_mem_end()	 __rtai_heap_exit()
+#else  /* CONFIG_RTAI_MALLOC_BUILTIN */
+#define sched_mem_init()
+#define sched_mem_end()
+#endif /* !CONFIG_RTAI_MALLOC_BUILTIN */
+#define call_exit_handlers(task)	        __call_exit_handlers(task)
+#define set_exit_handler(task, fun, arg1, arg2)	__set_exit_handler(task, fun, arg1, arg2)
+#else  /* !CONFIG_RTAI_MALLOC */
+#define sched_mem_init()
+#define sched_mem_end()
+#define call_exit_handlers(task)
+#define set_exit_handler(task, fun, arg1, arg2)
+#endif /* CONFIG_RTAI_MALLOC */
+
+#define SEMHLF 0x0000FFFF
+#define RPCHLF 0xFFFF0000
+#define RPCINC 0x00010000
+
+#define DECLARE_RT_CURRENT int cpuid; RT_TASK *rt_current
+#define ASSIGN_RT_CURRENT rt_current = rt_smp_current[cpuid = rtai_cpuid()]
+#define RT_CURRENT rt_smp_current[rtai_cpuid()]
+
+#define MAX_LINUX_RTPRIO  99
+#define MIN_LINUX_RTPRIO   1
+
+#ifdef CONFIG_RTAI_SCHED_ISR_LOCK
+void rtai_handle_isched_lock(int nesting);
+#endif /* CONFIG_RTAI_SCHED_ISR_LOCK */
+
+#ifdef CONFIG_SMP
+#define rt_time_h (rt_smp_time_h[cpuid])
+#define rt_linux_task (rt_smp_linux_task[cpuid])
+#else
+#define rt_time_h (rt_smp_time_h[0])
+#define rt_linux_task (rt_smp_linux_task[0])
+#endif
+
+/*
+ * WATCH OUT for the max expected number of arguments of rtai funs and 
+ * their scattered around different calling ways.
+ */
+
+#define RTAI_MAX_FUN_ARGS  9
+struct fun_args { unsigned long a[RTAI_MAX_FUN_ARGS]; RTAI_SYSCALL_MODE long long (*fun)(unsigned long, ...); };
+//used in sys.c
+#define RTAI_FUN_ARGS  arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],arg[7],arg[RTAI_MAX_FUN_ARGS - 1]
+//used in sched.c (generalised calls from soft threads)
+#define RTAI_FUNARGS   funarg->a[0],funarg->a[1],funarg->a[2],funarg->a[3],funarg->a[4],funarg->a[5],funarg->a[6],funarg->a[7],funarg->a[RTAI_MAX_FUN_ARGS - 1]
+
+#ifdef CONFIG_SMP
+
+static inline void send_sched_ipi(unsigned long dest)
+{
+	_send_sched_ipi(dest);
+}
+
+#define RT_SCHEDULE_MAP(schedmap) \
+	do { if (schedmap) send_sched_ipi(schedmap); } while (0)
+
+#define RT_SCHEDULE_MAP_BOTH(schedmap) \
+	do { if (schedmap) send_sched_ipi(schedmap); rt_schedule(); } while (0)
+
+#define RT_SCHEDULE(task, cpuid) \
+	do { \
+		if ((task)->runnable_on_cpus != (cpuid)) { \
+			send_sched_ipi(1 << (task)->runnable_on_cpus); \
+		} else { \
+			rt_schedule(); \
+		} \
+	} while (0)
+
+#define RT_SCHEDULE_BOTH(task, cpuid) \
+	{ \
+		if ((task)->runnable_on_cpus != (cpuid)) { \
+			send_sched_ipi(1 << (task)->runnable_on_cpus); \
+		} \
+		rt_schedule(); \
+	}
+
+#else /* !CONFIG_SMP */
+
+#define send_sched_ipi(dest)
+
+#define RT_SCHEDULE_MAP_BOTH(schedmap)  rt_schedule()
+
+#define RT_SCHEDULE_MAP(schedmap)       rt_schedule()
+
+#define RT_SCHEDULE(task, cpuid)        rt_schedule()
+
+#define RT_SCHEDULE_BOTH(task, cpuid)   rt_schedule()
+
+#endif /* CONFIG_SMP */
+
+#define BASE_SOFT_PRIORITY 1000000000
+
+#ifndef TASK_NOWAKEUP
+#define TASK_NOWAKEUP  TASK_UNINTERRUPTIBLE
+#endif
+
+#define TASK_HARDREALTIME  (TASK_INTERRUPTIBLE) // | TASK_NOWAKEUP)
+#define TASK_RTAISRVSLEEP  (TASK_INTERRUPTIBLE) // | TASK_NOWAKEUP)
+#define TASK_SOFTREALTIME  TASK_INTERRUPTIBLE
+
+static inline void enq_ready_edf_task(RT_TASK *ready_task)
+{
+	RT_TASK *task;
+#ifdef CONFIG_SMP
+	task = rt_smp_linux_task[ready_task->runnable_on_cpus].rnext;
+#else
+	task = rt_smp_linux_task[0].rnext;
+#endif
+	while (task->policy < 0 && ready_task->period >= task->period) {
+		task = task->rnext;
+	}
+	task->rprev = (ready_task->rprev = task->rprev)->rnext = ready_task;
+	ready_task->rnext = task;
+}
+
+struct epoch_struct { spinlock_t lock; volatile int touse; volatile RTIME time[2][2]; };
+
+#ifdef CONFIG_RTAI_CLOCK_REALTIME
+#define REALTIME2COUNT(rtime) \
+	if (rtime > boot_epoch.time[boot_epoch.touse][0]) { \
+		rtime -= boot_epoch.time[boot_epoch.touse][0]; \
+	}
+#else 
+#define REALTIME2COUNT(rtime)
+#endif
+
+#define MAX_WAKEUP_SRQ (1 << 6)
+
+struct klist_t { int srq; volatile unsigned long in, out; void *task[MAX_WAKEUP_SRQ]; };
+extern struct klist_t wake_up_srq[];
+
+#define pend_wake_up_srq(lnxtsk, cpuid) \
+do { \
+	wake_up_srq[cpuid].task[wake_up_srq[cpuid].in++ & (MAX_WAKEUP_SRQ - 1)] = lnxtsk; \
+	hal_pend_uncond(wake_up_srq[0].srq, cpuid); \
+} while (0)
+
+static inline void enq_ready_task(RT_TASK *ready_task)
+{
+	RT_TASK *task;
+	if (ready_task->is_hard) {
+#ifdef CONFIG_SMP
+		task = rt_smp_linux_task[ready_task->runnable_on_cpus].rnext;
+#else
+		task = rt_smp_linux_task[0].rnext;
+#endif
+		while (ready_task->priority >= task->priority) {
+			if ((task = task->rnext)->priority < 0) break;
+		}
+		task->rprev = (ready_task->rprev = task->rprev)->rnext = ready_task;
+		ready_task->rnext = task;
+	} else {
+		ready_task->state |= RT_SCHED_SFTRDY;
+		NON_RTAI_TASK_RESUME(ready_task);
+	}
+}
+
+static inline int renq_ready_task(RT_TASK *ready_task, int priority)
+{
+	int retval;
+	if ((retval = ready_task->priority != priority)) {
+		ready_task->priority = priority;
+		if (ready_task->state == RT_SCHED_READY) {
+			(ready_task->rprev)->rnext = ready_task->rnext;
+			(ready_task->rnext)->rprev = ready_task->rprev;
+			enq_ready_task(ready_task);
+		}
+	}
+	return retval;
+}
+
+static inline void rem_ready_task(RT_TASK *task)
+{
+	if (task->state == RT_SCHED_READY) {
+		if (!task->is_hard) {
+			NON_RTAI_TASK_SUSPEND(task);
+		}
+//		task->unblocked = 0;
+		(task->rprev)->rnext = task->rnext;
+		(task->rnext)->rprev = task->rprev;
+	}
+}
+
+static inline void rem_ready_current(RT_TASK *rt_current)
+{
+	if (!rt_current->is_hard) {
+		NON_RTAI_TASK_SUSPEND(rt_current);
+	}
+//	rt_current->unblocked = 0;
+	(rt_current->rprev)->rnext = rt_current->rnext;
+	(rt_current->rnext)->rprev = rt_current->rprev;
+}
+
+#ifdef CONFIG_RTAI_LONG_TIMED_LIST
+
+/* BINARY TREE */
+static inline void enq_timed_task(RT_TASK *timed_task)
+{
+	RT_TASK *taskh, *tsknxt, *task;
+	rb_node_t **rbtn, *rbtpn = NULL;
+#ifdef CONFIG_SMP
+	task = taskh = &rt_smp_linux_task[timed_task->runnable_on_cpus];
+#else
+	task = taskh = &rt_smp_linux_task[0];
+#endif
+	rbtn = &taskh->rbr.rb_node;
+
+	while (*rbtn) {
+		rbtpn = *rbtn;
+		tsknxt = rb_entry(rbtpn, RT_TASK, rbn);
+		if (timed_task->resume_time > tsknxt->resume_time) {
+			rbtn = &(rbtpn)->rb_right;
+		} else {
+			rbtn = &(rbtpn)->rb_left;
+			task = tsknxt;
+		}
+	}
+	rb_link_node(&timed_task->rbn, rbtpn, rbtn);
+	rb_insert_color(&timed_task->rbn, &taskh->rbr);
+	task->tprev = (timed_task->tprev = task->tprev)->tnext = timed_task;
+	timed_task->tnext = task;
+}
+
+#define	rb_erase_task(task, cpuid) \
+	rb_erase(&(task)->rbn, &rt_smp_linux_task[cpuid].rbr);
+
+#else /* !CONFIG_RTAI_LONG_TIMED_LIST */
+
+/* LINEAR */
+static inline void enq_timed_task(RT_TASK *timed_task)
+{
+	RT_TASK *task;
+#ifdef CONFIG_SMP
+	task = rt_smp_linux_task[timed_task->runnable_on_cpus].tnext;
+#else
+	task = rt_smp_linux_task[0].tnext;
+#endif
+	while (timed_task->resume_time > task->resume_time) {
+		task = task->tnext;
+	}
+	task->tprev = (timed_task->tprev = task->tprev)->tnext = timed_task;
+	timed_task->tnext = task;
+}
+
+#define	rb_erase_task(task, cpuid)
+
+#endif /* !CONFIG_RTAI_LONG_TIMED_LIST */
+
+static inline void rem_timed_task(RT_TASK *task)
+{
+	if ((task->state & RT_SCHED_DELAYED)) {
+                (task->tprev)->tnext = task->tnext;
+                (task->tnext)->tprev = task->tprev;
+#ifdef CONFIG_SMP
+		rb_erase_task(task, task->runnable_on_cpus);
+#else
+		rb_erase_task(task, 0);
+#endif
+	}
+}
+
+static inline void wake_up_timed_tasks(int cpuid)
+{
+	RT_TASK *taskh, *task;
+#ifdef CONFIG_SMP
+	task = (taskh = &rt_smp_linux_task[cpuid])->tnext;
+#else
+	task = (taskh = &rt_smp_linux_task[0])->tnext;
+#endif
+	if (task->resume_time - task->schedlat <= rt_time_h) {
+		do {
+			if ((task->state & RT_SCHED_SUSPENDED) && task->suspdepth > 0) {
+				task->suspdepth = 0;
+			}
+        	        if ((task->state &= ~(RT_SCHED_DELAYED | RT_SCHED_SUSPENDED | RT_SCHED_SEMAPHORE | RT_SCHED_RECEIVE | RT_SCHED_SEND | RT_SCHED_RPC | RT_SCHED_RETURN | RT_SCHED_MBXSUSP | RT_SCHED_POLL)) == RT_SCHED_READY) {
+                	        if (task->policy < 0) {
+                        	        enq_ready_edf_task(task);
+	                        } else {
+        	                        enq_ready_task(task);
+                	        }
+#if ((CONFIG_RTAI_USER_BUSY_ALIGN_RET_DELAY > 0 || CONFIG_RTAI_KERN_BUSY_ALIGN_RET_DELAY > 0))
+				task->busy_time_align = 1;
+#endif
+        	        }
+			rb_erase_task(task, cpuid);
+			task = task->tnext;
+		} while (task->resume_time <= rt_time_h);
+#ifdef CONFIG_SMP
+		rt_smp_linux_task[cpuid].tnext = task;
+		task->tprev = &rt_smp_linux_task[cpuid];
+#else
+		rt_smp_linux_task[0].tnext = task;
+		task->tprev = &rt_smp_linux_task[0];
+#endif
+	}
+}
+
+#define get_time() rt_get_time()
+
+static inline void enqueue_blocked(RT_TASK *task, QUEUE *queue, int qtype)
+{
+        QUEUE *q;
+        task->blocked_on = (q = queue);
+        if (!qtype) {
+                while ((q = q->next) != queue && (q->task)->priority <= task->priority);
+        }
+        q->prev = (task->queue.prev = q->prev)->next  = &(task->queue);
+        task->queue.next = q;
+}
+
+
+static inline void dequeue_blocked(RT_TASK *task)
+{
+        task->prio_passed_to     = NULL;
+        (task->queue.prev)->next = task->queue.next;
+        (task->queue.next)->prev = task->queue.prev;
+        task->blocked_on         = NULL;
+}
+
+static inline unsigned long pass_prio(RT_TASK *to, RT_TASK *from)
+{
+        QUEUE *q, *blocked_on;
+#ifdef CONFIG_SMP
+	RT_TASK *rhead;
+        unsigned long schedmap;
+        schedmap = 0;
+#endif
+//	from->prio_passed_to = to;
+        while (to && to->priority > from->priority) {
+                to->priority = from->priority;
+		if (to->state == RT_SCHED_READY) {
+			if ((to->rprev)->priority > to->priority || (to->rnext)->priority < to->priority) {
+#ifdef CONFIG_SMP
+				rhead = rt_smp_linux_task[to->runnable_on_cpus].rnext;
+#endif
+				(to->rprev)->rnext = to->rnext;
+				(to->rnext)->rprev = to->rprev;
+				enq_ready_task(to);
+#ifdef CONFIG_SMP
+				if (rhead != rt_smp_linux_task[to->runnable_on_cpus].rnext)  {
+					__set_bit(to->runnable_on_cpus & 0x1F, &schedmap);
+				}
+#endif
+			}
+			break;
+//		} else if ((void *)(q = to->blocked_on) > RTE_HIGERR && !((to->state & RT_SCHED_SEMAPHORE) && ((SEM *)q)->qtype)) {
+		} else if ((unsigned long)(blocked_on = to->blocked_on) > RTE_HIGERR && (((to->state & RT_SCHED_SEMAPHORE) && ((SEM *)blocked_on)->type > 0) || (to->state & (RT_SCHED_SEND | RT_SCHED_RPC | RT_SCHED_RETURN)))) {
+			if (to->queue.prev != blocked_on) {
+				q = blocked_on;
+				(to->queue.prev)->next = to->queue.next;
+				(to->queue.next)->prev = to->queue.prev;
+				while ((q = q->next) != blocked_on && (q->task)->priority <= to->priority);
+				q->prev = (to->queue.prev = q->prev)->next  = &(to->queue);
+				to->queue.next = q;
+				if (to->queue.prev != blocked_on) {
+					break;
+				}
+			}
+			to = (to->state & RT_SCHED_SEMAPHORE) ? ((SEM *)blocked_on)->owndby : blocked_on->task;
+                }
+//		to = to->prio_passed_to;
+	}
+#ifdef CONFIG_SMP
+	return schedmap;
+#else
+	return 0;
+#endif
+}
+
+static inline RT_TASK *_rt_whoami(void)
+{
+#ifdef CONFIG_SMP
+        RT_TASK *rt_current;
+        unsigned long flags;
+        flags = rt_global_save_flags_and_cli();
+        rt_current = RT_CURRENT;
+        rt_global_restore_flags(flags);
+        return rt_current;
+#else
+        return rt_smp_current[0];
+#endif
+}
+
+static inline void __call_exit_handlers(RT_TASK *task)
+{
+	XHDL *pt, *tmp;
+
+	pt = task->ExitHook; // Initialise ExitHook in rt_task_init()
+	while ( pt ) {
+		(*pt->fun) (pt->arg1, pt->arg2);
+		tmp = pt;
+		pt  = pt->nxt;
+		rt_free(tmp);
+	}
+	task->ExitHook = 0;
+}
+
+static inline XHDL *__set_exit_handler(RT_TASK *task, void (*fun) (void *, int), void *arg1, int arg2)
+{
+	XHDL *p;
+
+	// exit handler functions are automatically executed at terminattion time by rt_task_delete()
+	// in the reverse order they were created (like C++ destructors behave).
+	if (task->magic != RT_TASK_MAGIC) return 0;
+	if (!(p = (XHDL *) rt_malloc (sizeof(XHDL)))) return 0;
+	p->fun  = fun;
+	p->arg1 = arg1;
+	p->arg2 = arg2;
+	p->nxt  = task->ExitHook;
+	return (task->ExitHook = p);
+}
+
+static inline int rtai_init_features (void)
+
+{
+#ifdef CONFIG_RTAI_SEM_BUILTIN
+    __rtai_sem_init();
+#endif /* CONFIG_RTAI_SEM_BUILTIN */
+#ifdef CONFIG_RTAI_MSG_BUILTIN
+    __rtai_msg_init();
+#endif /* CONFIG_RTAI_MSG_BUILTIN */
+#ifdef CONFIG_RTAI_MBX_BUILTIN
+    __rtai_mbx_init();
+#endif /* CONFIG_RTAI_MBX_BUILTIN */
+#ifdef CONFIG_RTAI_FIFOS_BUILTIN
+    __rtai_fifos_init();
+#endif /* CONFIG_RTAI_FIFOS_BUILTIN */
+#ifdef CONFIG_RTAI_SHM_BUILTIN
+    __rtai_shm_init();
+#endif /* CONFIG_RTAI_SHM_BUILTIN */
+#ifdef CONFIG_RTAI_MATH_BUILTIN
+    __rtai_math_init();
+#endif /* CONFIG_RTAI_MATH_BUILTIN */
+
+	return 0;
+}
+
+static inline void rtai_cleanup_features (void) {
+
+#ifdef CONFIG_RTAI_MATH_BUILTIN
+    __rtai_math_exit();
+#endif /* CONFIG_RTAI_MATH_BUILTIN */
+#ifdef CONFIG_RTAI_SHM_BUILTIN
+    __rtai_shm_exit();
+#endif /* CONFIG_RTAI_SHM_BUILTIN */
+#ifdef CONFIG_RTAI_FIFOS_BUILTIN
+    __rtai_fifos_exit();
+#endif /* CONFIG_RTAI_FIFOS_BUILTIN */
+#ifdef CONFIG_RTAI_MBX_BUILTIN
+    __rtai_mbx_exit();
+#endif /* CONFIG_RTAI_MBX_BUILTIN */
+#ifdef CONFIG_RTAI_MSG_BUILTIN
+    __rtai_msg_exit();
+#endif /* CONFIG_RTAI_MSG_BUILTIN */
+#ifdef CONFIG_RTAI_SEM_BUILTIN
+    __rtai_sem_exit();
+#endif /* CONFIG_RTAI_SEM_BUILTIN */
+}
+
+int rt_check_current_stack(void);
+
+int rt_kthread_init_old(RT_TASK *task,
+		    void (*rt_thread)(long),
+		    long data,
+		    int stack_size,
+		    int priority,
+		    int uses_fpu,
+		    void(*signal)(void));
+
+int rt_kthread_init_cpuid(RT_TASK *task,
+			  void (*rt_thread)(long),
+			  long data,
+			  int stack_size,
+			  int priority,
+			  int uses_fpu,
+			  void(*signal)(void),
+			  unsigned int cpuid);
+
+#else /* !__KERNEL__ */
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_SCHEDCORE_H */

include/rtai_sem.h

@@ -0,0 +1,429 @@
+/**
+ * @ingroup lxrt
+ * @file
+ *
+ * @author Paolo Mantegazza
+ *
+ * @note Copyright &copy; 1999-2003 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * @note Copyright &copy; 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_SEM_H
+#define _RTAI_SEM_H
+
+#include <rtai_types.h>
+#include <rtai_nam2num.h>
+#include <rtai_sched.h>
+
+#define RT_SEM_MAGIC 0x3f83ebb  // nam2num("rtsem")
+
+#define SEM_ERR     (RTE_OBJINV)
+#define SEM_TIMOUT  (RTE_TIMOUT)
+
+struct rt_poll_s { void *what; unsigned long forwhat; };
+
+// do not use 0 for any "forwhat" below
+#define RT_POLL_NOT_TO_USE    0
+#define RT_POLL_MBX_RECV      1
+#define RT_POLL_MBX_SEND      2
+#define RT_POLL_SEM_WAIT_ALL  3
+#define RT_POLL_SEM_WAIT_ONE  4
+
+#if defined(__KERNEL__) && !defined(__cplusplus)
+
+struct rt_poll_ql { QUEUE pollq; spinlock_t pollock; };
+struct rt_poll_enc { unsigned long offset; int (*topoll)(void *); };
+extern struct rt_poll_enc rt_poll_ofstfun[];
+
+typedef struct rt_semaphore {
+	struct rt_queue queue; /* <= Must be first in struct. */
+	int magic;
+	int type, restype;
+	int count;
+	struct rt_task_struct *owndby;
+	int qtype;
+	struct rt_queue resq;
+#ifdef CONFIG_RTAI_RT_POLL
+	struct rt_poll_ql poll_wait_all;
+	struct rt_poll_ql poll_wait_one;
+#endif
+} SEM;
+
+#ifdef CONFIG_RTAI_RT_POLL
+
+RTAI_SYSCALL_MODE int _rt_poll(struct rt_poll_s *pdsa, unsigned long nr, RTIME timeout, int space);
+static inline int rt_poll(struct rt_poll_s *pdsa, unsigned long nr, RTIME timeout)
+{
+	return _rt_poll(pdsa, nr, timeout, 1);
+}
+
+void rt_wakeup_pollers(struct rt_poll_ql *ql, int reason);
+
+#else
+
+static inline int rt_poll(struct rt_poll_s *pdsa, unsigned long nr, RTIME timeout)
+{
+	return RTE_OBJINV;
+}
+
+#define rt_wakeup_pollers(ql, reason)
+
+#endif
+
+#else /* !__KERNEL__ || __cplusplus */
+
+typedef struct rt_semaphore {
+    int opaque;
+} SEM;
+
+#endif /* __KERNEL__ && !__cplusplus */
+
+typedef SEM CND;
+
+#ifdef __KERNEL__
+
+#include <linux/errno.h>
+
+typedef SEM psem_t;
+
+typedef SEM pmutex_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+int __rtai_sem_init(void);
+
+void __rtai_sem_exit(void);
+
+RTAI_SYSCALL_MODE void rt_typed_sem_init(SEM *sem,
+		       int value,
+		       int type);
+
+RTAI_SYSCALL_MODE int rt_sem_delete(SEM *sem);
+
+RTAI_SYSCALL_MODE SEM *_rt_typed_named_sem_init(unsigned long sem_name,
+			     int value,
+			     int type,
+			     unsigned long *handle);
+
+static inline SEM *rt_typed_named_sem_init(const char *sem_name,
+					   int value,
+					   int type) {
+    return _rt_typed_named_sem_init(nam2num(sem_name), value, type, NULL);
+}
+
+RTAI_SYSCALL_MODE int rt_named_sem_delete(SEM *sem);
+
+void rt_sem_init(SEM *sem,
+		 int value);
+
+RTAI_SYSCALL_MODE int rt_sem_signal(SEM *sem);
+
+RTAI_SYSCALL_MODE int rt_sem_broadcast(SEM *sem);
+
+RTAI_SYSCALL_MODE int rt_sem_wait(SEM *sem);
+
+RTAI_SYSCALL_MODE int rt_sem_wait_if(SEM *sem);
+
+int rt_cntsem_wait_if_and_lock(SEM *sem);
+
+RTAI_SYSCALL_MODE int rt_sem_wait_until(SEM *sem,
+		      RTIME time);
+
+RTAI_SYSCALL_MODE int rt_sem_wait_timed(SEM *sem,
+		      RTIME delay);
+
+RTAI_SYSCALL_MODE int rt_sem_wait_barrier(SEM *sem);
+
+RTAI_SYSCALL_MODE int rt_sem_count(SEM *sem);
+
+RTAI_SYSCALL_MODE int rt_cond_signal(CND *cnd);
+
+RTAI_SYSCALL_MODE int rt_cond_wait(CND *cnd,
+		 SEM *mtx);
+
+RTAI_SYSCALL_MODE int rt_cond_wait_until(CND *cnd,
+		       SEM *mtx,
+		       RTIME time);
+
+RTAI_SYSCALL_MODE int rt_cond_wait_timed(CND *cnd,
+		       SEM *mtx,
+		       RTIME delay);
+
+#define rt_named_sem_init(sem_name, value)  rt_typed_named_sem_init(sem_name, value, CNT_SEM)
+
+static inline int rt_psem_init(psem_t *sem, int pshared, unsigned int value)
+{
+	if (value < SEM_TIMOUT) {
+		rt_typed_sem_init(sem, value, pshared | PRIO_Q);
+		return 0;
+	}
+	return -EINVAL;
+}
+
+static inline int rt_psem_destroy(psem_t *sem)
+{
+	if (rt_sem_wait_if(sem) >= 0) {
+		rt_sem_signal(sem);
+		return rt_sem_delete(sem);
+	}
+	return -EBUSY;
+}
+
+static inline int rt_psem_wait(psem_t *sem) {
+    return rt_sem_wait(sem) < SEM_TIMOUT ? 0 : -1;
+}
+
+static inline int rt_psem_timedwait(psem_t *sem, struct timespec *abstime) {
+    return rt_sem_wait_until(sem, timespec2count(abstime)) < SEM_TIMOUT ? 0 : -1;
+}
+
+static inline int rt_psem_trywait(psem_t *sem) {
+    return rt_sem_wait_if(sem) > 0 ? 0 : -EAGAIN;
+}
+
+static inline int rt_psem_post(psem_t *sem) {
+    return rt_sem_signal(sem);
+}
+
+static inline int rt_psem_getvalue(psem_t *sem, int *sval)
+{
+	if ((*sval = rt_sem_wait_if(sem)) > 0) {
+		rt_sem_signal(sem);
+	}
+	return 0;
+}
+
+static inline int rt_pmutex_init(pmutex_t *mutex, void *mutexattr)
+{
+	rt_typed_sem_init(mutex, 1, RES_SEM);
+	return 0;
+}
+
+static inline int rt_pmutex_destroy(pmutex_t *mutex)
+{
+	if (rt_sem_wait_if(mutex) > 0) {
+		rt_sem_signal(mutex);
+		return rt_sem_delete(mutex);
+	}
+	return -EBUSY;
+}
+
+static inline int rt_pmutex_lock(pmutex_t *mutex) {
+    return rt_sem_wait(mutex) < SEM_TIMOUT ? 0 : -EINVAL;
+}
+
+static inline int rt_pmutex_trylock(pmutex_t *mutex) {
+    return rt_sem_wait_if(mutex) > 0 ? 0 : -EBUSY;
+}
+
+static inline int rt_pmutex_timedlock(pmutex_t *sem, struct timespec *abstime) {
+    return rt_sem_wait_until(sem, timespec2count(abstime)) < SEM_TIMOUT ? 0 : -1;
+}
+
+static inline int rt_pmutex_unlock(pmutex_t *mutex) {
+    return rt_sem_signal(mutex);
+}
+
+#undef rt_mutex_init
+#define rt_mutex_init(mtx)             rt_typed_sem_init(mtx, 1, RES_SEM)
+#define rt_mutex_delete(mtx)           rt_sem_delete(mtx)
+#define rt_mutex_destroy(mtx)          rt_sem_delete(mtx)
+#define rt_mutex_trylock(mtx)          rt_sem_wait_if(mtx)
+#define rt_mutex_lock(mtx)             rt_sem_wait(mtx)
+#define rt_mutex_timedlock(mtx, time)  rt_sem_wait_until(mtx, time)
+#define rt_mutex_unlock(mtx)           rt_sem_signal(mtx)
+
+#define rt_cond_init(cnd)                  rt_typed_sem_init(cnd, 0, BIN_SEM | PRIO_Q)
+#define rt_cond_delete(cnd)                rt_sem_delete(cnd)
+#define rt_cond_destroy(cnd)               rt_sem_delete(cnd)
+#define rt_cond_broadcast(cnd)             rt_sem_broadcast(cnd)
+
+static inline int rt_cond_timedwait(CND *cnd, SEM *mtx, RTIME time) {
+    return rt_cond_wait_until(cnd, mtx, time) < SEM_TIMOUT ? 0 : -1;
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else /* !__KERNEL__ */
+
+#include <rtai_lxrt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+RTAI_PROTO(SEM *, rt_typed_sem_init,(unsigned long name, int value, int type))
+{
+	struct { unsigned long name; long value, type; } arg = { name ? name : rt_get_name(NULL), value, type };
+	return (SEM *)rtai_lxrt(BIDX, SIZARG, LXRT_SEM_INIT, &arg).v[LOW];
+}
+
+/**
+ * @ingroup lxrt
+ * Initialize a counting semaphore.
+ *
+ * Allocates and initializes a semaphore to be referred by @a name.
+ *
+ * @param name name of the semaphore.
+ *
+ * @param value is the initial value of the semaphore
+ *
+ * It is important to remark that the returned task pointer cannot be used
+ * directly, they are for kernel space data, but just passed as arguments when
+ * needed.
+ *
+ * @return a pointer to the semaphore to be used in related calls or 0 if an
+ * error has occured.
+ */ 
+#define rt_sem_init(name, value) rt_typed_sem_init(name, value, CNT_SEM)
+
+#define rt_named_sem_init(sem_name, value) \
+	rt_typed_named_sem_init(sem_name, value, CNT_SEM)
+
+RTAI_PROTO(int, rt_sem_delete,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, LXRT_SEM_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(SEM *, rt_typed_named_sem_init,(const char *name, int value, int type))
+{
+	struct { unsigned long name; long value, type; unsigned long *handle; } arg = { nam2num(name), value, type, NULL };
+	return (SEM *)rtai_lxrt(BIDX, SIZARG, NAMED_SEM_INIT, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_named_sem_delete,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, NAMED_SEM_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_signal,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, SEM_SIGNAL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_broadcast,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, SEM_BROADCAST, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_wait,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, SEM_WAIT, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_wait_if,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, SEM_WAIT_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_wait_until,(SEM *sem, RTIME time))
+{
+	struct { SEM *sem; RTIME time; } arg = { sem, time };
+	return rtai_lxrt(BIDX, SIZARG, SEM_WAIT_UNTIL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_wait_timed,(SEM *sem, RTIME delay))
+{
+	struct { SEM *sem; RTIME delay; } arg = { sem, delay };
+	return rtai_lxrt(BIDX, SIZARG, SEM_WAIT_TIMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_wait_barrier,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, SEM_WAIT_BARRIER, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_sem_count,(SEM *sem))
+{
+	struct { SEM *sem; } arg = { sem };
+	return rtai_lxrt(BIDX, SIZARG, SEM_COUNT, &arg).i[LOW];
+}
+
+/**
+ * @ingroup lxrt
+ * Initialize a condition variable.
+ *
+ * Allocates and initializes a condition variable to be referred by @a name.
+ *
+ * @param name name of the condition variable.
+ *
+ * It is important to remark that the returned pointer cannot be used
+ * directly, it is for kernel space data, but just passed as arguments when
+ * needed.
+ *
+ * @return a pointer to the condition variable to be used in related calls or 0
+ * if an error has occured.
+ */ 
+#define rt_cond_init(name)                 rt_typed_sem_init(name, 0, BIN_SEM)
+#define rt_cond_delete(cnd)                rt_sem_delete(cnd)
+#define rt_cond_destroy(cnd)               rt_sem_delete(cnd)
+#define rt_cond_broadcast(cnd)             rt_sem_broadcast(cnd)
+#define rt_cond_timedwait(cnd, mtx, time)  rt_cond_wait_until(cnd, mtx, time)
+
+RTAI_PROTO(int, rt_cond_signal,(CND *cnd))
+{
+	struct { CND *cnd; } arg = { cnd };
+	return rtai_lxrt(BIDX, SIZARG, COND_SIGNAL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_cond_wait,(CND *cnd, SEM  *mutex))
+{
+	struct { CND *cnd; SEM *mutex; } arg = { cnd, mutex };
+	return rtai_lxrt(BIDX, SIZARG, COND_WAIT, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_cond_wait_until,(CND *cnd, SEM *mutex, RTIME time))
+{
+	struct { CND *cnd; SEM *mutex; RTIME time; } arg = { cnd, mutex, time };
+	return rtai_lxrt(BIDX, SIZARG, COND_WAIT_UNTIL, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_cond_wait_timed,(CND *cnd, SEM *mutex, RTIME delay))
+{
+	struct { CND *cnd; SEM *mutex; RTIME delay; } arg = { cnd, mutex, delay };
+	return rtai_lxrt(BIDX, SIZARG, COND_WAIT_TIMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_poll, (struct rt_poll_s *pdsa, unsigned long nr, RTIME timeout))
+{
+#ifdef CONFIG_RTAI_RT_POLL
+	struct { struct rt_poll_s *pdsa; unsigned long nr; RTIME timeout; long space; } arg = { pdsa, nr, timeout, 0 };
+	return rtai_lxrt(BIDX, SIZARG, SEM_RT_POLL, &arg).i[LOW];
+#else
+	(void)pdsa; (void)nr; (void)timeout;
+	return RTE_OBJINV;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_SEM_H */

include/rtai_shm.h

@@ -0,0 +1,512 @@
+/**
+ * @ingroup shm
+ * @file
+ *
+ * Interface of the @ref shm "RTAI SHM module".
+ *
+ * @author Paolo Mantegazza
+ *
+ * @note Copyright &copy; 1999-2017 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * @note Copyright &copy; 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ACKNOWLEDGMENTS:
+- The suggestion and the code for mmapping at a user specified address is due to  Trevor Woolven (trevw@zentropix.com).
+*/
+
+
+#ifndef _RTAI_SHM_H
+#define _RTAI_SHM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/** @addtogroup shm
+ *@{*/
+
+#define GLOBAL_HEAP_ID  0x9ac6d9e7  // nam2num("RTGLBH");
+
+#define USE_VMALLOC     0
+#define USE_GFP_KERNEL  1
+#define USE_GFP_ATOMIC  2
+#define USE_GFP_DMA     3
+
+/**
+ * Allocate a chunk of memory to be shared inter-intra kernel modules and 
+ * Linux processes.
+ *
+ * @internal
+ * 
+ * rtai_kalloc is used to allocate shared memory from kernel space.
+ * 
+ * @param name is an unsigned long identifier;
+ * 
+ * @param size is the amount of required shared memory;
+ * 
+ * rtai_kmalloc is a legacy helper macro, the real job is carried out by a
+ * call to rt_shm_alloc() with the same name, size and with vmalloc support.
+ * This function should not be used in newly developed applications. See 
+ * rt_shm_alloc for more details.
+ *
+ * @returns a valid address on succes, 0 on failure.
+ *
+ */
+
+#define rtai_kmalloc(name, size) \
+	rt_shm_alloc(name, size, USE_VMALLOC)  // legacy
+
+/**
+ * Free a chunk of shared memory being shared inter-intra kernel modules and 
+ * Linux processes.
+ *
+ * rtai_kfree is used to free a shared memory chunk from kernel space.
+ *
+ * @param name is the unsigned long identifier used when the memory was
+ * allocated;
+ *
+ * rtai_kfree is a legacy helper macro, the real job is carried out by a
+ * call to rt_shm_free with the same name. This function should not be used 
+ * in newly developed applications. See rt_shm_free for more details.
+ *
+ * @returns the size of the succesfully freed memory, 0 on failure.
+ *
+ */
+
+#define rtai_kfree(name) \
+	rt_shm_free(name)  // legacy
+
+#if defined(__KERNEL__)
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+
+#define UVIRT_TO_KVA(adr)  uvirt_to_kva(pgd_offset_k(adr), (adr))
+
+static inline int remap_page_range(struct vm_area_struct *vma, unsigned long uvaddr, unsigned long paddr, unsigned long size, pgprot_t prot)
+{
+	return remap_pfn_range(vma, uvaddr, paddr >> PAGE_SHIFT, size, prot);
+}
+
+#include <rtai.h>
+
+#include <rtai_malloc.h>
+
+static inline unsigned long uvirt_to_kva(pgd_t *pgd, unsigned long adr)
+{
+	if (!pgd_none(*pgd) && !pgd_bad(*pgd)) {
+		pmd_t *pmd;
+		pmd = pmd_offset(pud_offset((void *)pgd, adr), adr);
+		if (!pmd_none(*pmd)) {
+			pte_t *ptep, pte;
+			ptep = pte_offset_kernel(pmd, adr);
+			pte = *ptep;
+			if (pte_present(pte)) {
+				return (((unsigned long)page_address(pte_page(pte))) | (adr & (PAGE_SIZE - 1)));
+			}
+		}
+	}
+	return 0UL;
+}
+
+static inline unsigned long kvirt_to_pa(unsigned long adr)
+{
+	return virt_to_phys((void *)uvirt_to_kva(pgd_offset_k(adr), adr));
+}
+
+int __rtai_shm_init(void);
+
+void __rtai_shm_exit(void);
+
+void *rt_shm_alloc(unsigned long name,
+		   int size,
+		   int suprt);
+
+#define rt_shm_alloc_adr(adr, name, size) \
+	rt_shm_alloc(name, size, suprt)
+
+RTAI_SYSCALL_MODE int rt_shm_free(unsigned long name);
+
+void *rt_heap_open(unsigned long name,
+		   int size,
+		   int suprt);
+
+#define rt_heap_open_adr(adr, name, size, suprt) \
+	rt_heap_open(name, size, suprt)
+
+RTAI_SYSCALL_MODE void *rt_halloc(int size);
+
+RTAI_SYSCALL_MODE void rt_hfree(void *addr);
+
+RTAI_SYSCALL_MODE void *rt_named_halloc(unsigned long name, int size);
+
+RTAI_SYSCALL_MODE void rt_named_hfree(void *addr);
+
+void *rt_named_malloc(unsigned long name,
+		      int size);
+
+void rt_named_free(void *addr);
+
+void *rvmalloc(unsigned long size);
+
+void rvfree(void *mem,
+	    unsigned long size);
+
+int rvmmap(void *mem,
+	   unsigned long memsize,
+	   struct vm_area_struct *vma);
+
+void *rkmalloc(int *size,
+	       int suprt);
+
+void rkfree(void *mem,
+	    unsigned long size);
+
+int rkmmap(void *mem,
+	   unsigned long memsize,
+	   struct vm_area_struct *vma);
+
+#else /* !__KERNEL__ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <rtai_lxrt.h>
+
+//#define SHM_USE_LXRT
+
+#define RTAI_SHM_DEV  "/dev/rtai_shm"
+
+RTAI_PROTO (void *, _rt_shm_alloc, (void *start, unsigned long name, int size, int suprt, int isheap))
+{
+	int hook;
+	void *adr = NULL;
+
+	if ((hook = open(RTAI_SHM_DEV, O_RDWR)) <= 0) {
+		return NULL;
+	} else {
+		struct { unsigned long name; long arg, suprt; } arg = { name, size, suprt };
+#ifdef SHM_USE_LXRT
+		if ((size = rtai_lxrt(BIDX, SIZARG, SHM_ALLOC, &arg).i[LOW])) {
+#else
+		if ((size = ioctl(hook, SHM_ALLOC, (unsigned long)(&arg)))) {
+#endif
+			if ((adr = mmap(start, size, PROT_WRITE | PROT_READ, MAP_SHARED | MAP_LOCKED, hook, 0)) == MAP_FAILED) {;
+#ifdef SHM_USE_LXRT
+				rtai_lxrt(BIDX, sizeof(name), SHM_FREE, &name);
+#else
+				ioctl(hook, SHM_FREE, &name);
+#endif
+			} else if (isheap) {
+				arg.arg = (unsigned long)adr;
+#ifdef SHM_USE_LXRT
+				rtai_lxrt(BIDX, SIZARG, HEAP_SET, &arg);
+#else
+				ioctl(hook, HEAP_SET, &arg);
+#endif
+			}
+		}
+	}
+	close(hook);
+	return adr;
+}
+
+#define rt_shm_alloc(name, size, suprt)  \
+	_rt_shm_alloc(0, name, size, suprt, 0)
+
+#define rt_heap_open(name, size, suprt)  \
+	_rt_shm_alloc(0, name, size, suprt, 1)
+
+/**
+ * Allocate a chunk of memory to be shared inter-intra kernel modules and 
+ * Linux processes.
+ *
+ * @internal
+ * 
+ * rtai_malloc is used to allocate shared memory from user space.
+ * 
+ * @param name is an unsigned long identifier;
+ * 
+ * @param size is the amount of required shared memory;
+ * 
+ * rtai_malloc is a legacy helper macro, the real job is carried out by a
+ * call to rt_shm_alloc() with the same name, size and with vmalloc support.
+ * This function should not be used in newly developed applications. See
+ * rt_shm_alloc fro more details.
+ *
+ * @returns a valid address on succes, on failure: 0 if it was unable to 
+ * allocate any memory, MAP_FAILED if it was possible to allocate the
+ * required memory but failed to mmap it to user space, in which case the
+ * allocated memory is freed anyhow.
+ *
+ */
+
+#define rtai_malloc(name, size)  \
+	_rt_shm_alloc(0, name, size, USE_VMALLOC, 0)  // legacy
+
+/**
+ * Allocate a chunk of memory to be shared inter-intra kernel modules and Linux
+ * processes.
+ *
+ * rt_shm_alloc_adr is used to allocate in user space.
+ *
+ * @param start_address is a user desired address where the allocated memory
+ * should be mapped in user space;
+ *
+ * @param name is an unsigned long identifier;
+ * 
+ * @param size is the amount of required shared memory.
+ *
+ * @param suprt is the kernel allocation method to be used, it can be:
+ * - USE_VMALLOC, use vmalloc;
+ * - USE_GFP_KERNEL, use kmalloc with GFP_KERNEL;
+ * - USE_GFP_ATOMIC, use kmalloc with GFP_ATOMIC;
+ * - USE_GFP_DMA, use kmalloc with GFP_DMA.
+ *
+ * Since @c name can be a clumsy identifier, services are provided to
+ * convert 6 characters identifiers to unsigned long, and vice versa.
+ *
+ * @see the functions nam2num() and num2nam().
+ *
+ * It must be remarked that only the very first call does a real allocation, 
+ * any subsequent call to allocate with the same name from anywhere will just
+ * increase the usage count and map the area to user space, or return the
+ * related pointer to the already allocated space in kernel space. The function 
+ * returns a pointer to the allocated memory, appropriately mapped to the memory
+ * space in use. So if one is really sure that the named shared memory has been 
+ * allocated already parameters size and suprt are not used and can be 
+ * assigned any value.
+ *
+ * @note If the same process calls rtai_malloc_adr and rtai_malloc() twice in
+ * the same process it get a zero return value on the second call.
+ *
+ * @returns a valid address on succes, on failure: 0 if it was unable to
+ * allocate any memory, MAP_FAILED if it was possible to allocate the
+ * required memory but failed to mmap it to user space, in which case the
+ * allocated memory is freed anyhow.
+ *
+ */
+
+#define rt_shm_alloc_adr(start_address, name, size, suprt)  \
+	_rt_shm_alloc(start_address, name, size, suprt, 0)
+
+#define rt_heap_open_adr(start, name, size, suprt)  \
+	_rt_shm_alloc(start, name, size, suprt, 1)
+
+/**
+ * Allocate a chunk of memory to be shared inter-intra kernel modules and 
+ * Linux processes.
+ *
+ * @internal
+ * 
+ * rtai_malloc_adr is used to allocate shared memory from user space.
+ *
+ * @param start_address is the adr were the shared memory should be mapped.
+ * 
+ * @param name is an unsigned long identifier;
+ * 
+ * @param size is the amount of required shared memory;
+ * 
+ * rtai_malloc_adr is a legacy helper macro, the real job is carried out by a
+ * call to rt_shm_alloc_adr() with the same name, size and with vmalloc support.
+ * This function should not be used in newly developed applications. See
+ * rt_shm_alloc_adr for more details.
+ *
+ * @returns a valid address on succes, 0 on failure.
+ *
+ */
+
+#define rtai_malloc_adr(start_address, name, size)  \
+	_rt_shm_alloc(start_address, name, size, USE_VMALLOC, 0)  // legacy
+
+RTAI_PROTO(int, rt_shm_free, (unsigned long name))
+{
+	int hook, size;
+	struct { void *nameadr; } arg = { &name };
+	if ((hook = open(RTAI_SHM_DEV, O_RDWR)) <= 0) {
+		return 0;
+	}
+// no SHM_FREE needed, we release it all and munmap will do it through 
+// the vma close operation provided by shm.c
+#ifdef SHM_USE_LXRT
+	if ((size = rtai_lxrt(BIDX, SIZARG, SHM_SIZE, &arg).i[LOW])) {
+#else
+	if ((size = ioctl(hook, SHM_SIZE, (unsigned long)&arg))) {
+#endif
+		if (munmap((void *)name, size)) {
+			size = 0;
+		}
+	}
+	close(hook);
+	return size;
+}
+
+/**
+ * Free a chunk of shared memory being shared inter-intra 
+ * kernel modules and Linux processes.
+ *
+ * rtai_free is used to free a shared memory chunk from user space.
+ *
+ * @param name is the unsigned long identifier used when the memory was
+ * allocated;
+ *
+ * @param adr is not used.
+ *
+ * rtai_free is a legacy helper macro, the real job is carried out by a
+ * call to rt_shm_free with the same name. This function should not be used 
+ * in newly developed applications. See rt_shm_alloc_adr for more details.
+ *
+ * @returns the size of the succesfully freed memory, 0 on failure.
+ *
+ */
+
+#define rtai_free(name, adr)  \
+	rt_shm_free(name)  // legacy
+
+RTAI_PROTO(void *, rt_halloc, (int size))
+{
+	struct { long size; } arg = { size };
+	return rtai_lxrt(BIDX, SIZARG, HEAP_ALLOC, &arg).v[LOW];
+}
+
+RTAI_PROTO(void, rt_hfree, (void *addr))
+{
+	struct { void *addr; } arg = { addr };
+	rtai_lxrt(BIDX, SIZARG, HEAP_FREE, &arg);
+}
+
+RTAI_PROTO(void *, rt_named_halloc, (unsigned long name, int size))
+{
+	struct { unsigned long name; long size; } arg = { name, size };
+	return rtai_lxrt(BIDX, SIZARG, HEAP_NAMED_ALLOC, &arg).v[LOW];
+}
+
+RTAI_PROTO(void, rt_named_hfree, (void *addr))
+{
+	struct { void *addr; } arg = { addr };
+	rtai_lxrt(BIDX, SIZARG, HEAP_NAMED_FREE, &arg);
+}
+
+RTAI_PROTO(void *, rt_malloc, (int size))
+{
+	struct { long size; } arg = { size };
+	return rtai_lxrt(BIDX, SIZARG, MALLOC, &arg).v[LOW];
+}
+
+RTAI_PROTO(void, rt_free, (void *addr))
+{
+	struct { void *addr; } arg = { addr };
+	rtai_lxrt(BIDX, SIZARG, FREE, &arg);
+}
+
+RTAI_PROTO(void *, rt_named_malloc, (unsigned long name, int size))
+{
+	struct { unsigned long name; long size; } arg = { name, size };
+	return rtai_lxrt(BIDX, SIZARG, NAMED_MALLOC, &arg).v[LOW];
+}
+
+RTAI_PROTO(void, rt_named_free, (void *addr))
+{
+	struct { void *addr; } arg = { addr };
+	rtai_lxrt(BIDX, SIZARG, NAMED_FREE, &arg);
+}
+
+#endif /* __KERNEL__ */
+
+/**
+ * Close a real time group heap being shared inter-intra kernel modules and
+ * Linux processes.
+ *
+ * @internal
+ * 
+ * rt_heap_close is used to close a previously opened real time group heap.
+ *
+ * @param name is the unsigned long identifier used to identify the heap.
+ *
+ * @param adr is not used.
+ *
+ * Analogously to what done by any allocation function this group real time
+ * heap closing call have just the effect of decrementing a usage count, 
+ * unmapping any user space heap being closed, till the last is done, as that 
+ * is the one the really closes the group heap, freeing any allocated memory.
+ *
+ * @returns the size of the succesfully freed heap, 0 on failure.
+ *
+ */
+
+#define rt_heap_close(name, adr)  rt_shm_free(name)
+
+// aliases in use already, different heads different choices
+#define rt_heap_init         rt_heap_open
+#define rt_heap_create       rt_heap_open
+#define rt_heap_acquire      rt_heap_open
+#define rt_heap_init_adr     rt_heap_open_adr
+#define rt_heap_create_adr   rt_heap_open_adr
+#define rt_heap_acquire_adr  rt_heap_open_adr
+
+#define rt_heap_delete       rt_heap_close
+#define rt_heap_destroy      rt_heap_close
+#define rt_heap_release      rt_heap_close
+
+// these have no aliases, and never will
+
+/**
+ * Open the global real time heap to be shared inter-intra kernel modules and 
+ * Linux processes.
+ *
+ * @internal
+ * 
+ * rt_global_heap_open is used to open the global real time heap.
+ * 
+ * The global heap is created by the shared memory module and its opening is
+ * needed in user space to map it to the process address space. In kernel
+ * space opening the global heap in a task is not required but should be done
+ * anyhow, both for symmetry and to register its usage.
+ *
+ */
+
+#define rt_global_heap_open()  rt_heap_open(GLOBAL_HEAP_ID, 0, 0)
+
+/**
+ * Close the global real time heap being shared inter-intra kernel modules and 
+ * Linux processes.
+ *
+ * @internal
+ * 
+ * rt_global_heap_close is used to close the global real time heap.
+ * 
+ * Closing a global heap in user space has just the effect of deregistering
+ * its use and unmapping the related memory from a process address space.
+ * In kernel tasks just the deregistration is performed.
+ * The global real time heap is destroyed just a the rmmoding of the shared
+ * memory module.
+ *
+ */
+
+#define rt_global_heap_close()  rt_heap_close(GLOBAL_HEAP_ID, 0)
+
+/*@}*/
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !_RTAI_SHM_H */

include/rtai_signal.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2006 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ * 
+ *
+ */
+
+#ifndef _RTAI_SIGNAL_H_
+#define _RTAI_SIGNAL_H_
+
+#define RTAI_SIGNALS_IDX  BIDX
+
+#include <rtai_sched.h>
+
+#define MAXSIGNALS  16
+
+#define SIGNAL_TASK_INIPRIO     0
+
+struct rt_signal_t { unsigned long flags; RT_TASK *sigtask; };
+
+struct sigsuprt_t { RT_TASK *sigtask; RT_TASK *task; long signal; void (*sighdl)(long, RT_TASK *); unsigned long cpuid; };
+
+#ifdef __KERNEL__
+
+#define SIGNAL_ENBIT   0
+#define SIGNAL_PNDBIT  1
+
+#define SIGNAL_TASK_STACK_SIZE  8192
+
+RTAI_SYSCALL_MODE int rt_signal_helper(RT_TASK *task);
+
+int rt_request_signal(long signal, void (*sighdl)(long, RT_TASK *));
+
+RTAI_SYSCALL_MODE int rt_request_signal_(RT_TASK *sigtask, RT_TASK *task, long signal);
+
+RTAI_SYSCALL_MODE int rt_release_signal(long signal, RT_TASK *task);
+
+RTAI_SYSCALL_MODE void rt_enable_signal(long signal, RT_TASK *task);
+
+RTAI_SYSCALL_MODE void rt_disable_signal(long signal, RT_TASK *task);
+
+RTAI_SYSCALL_MODE void rt_trigger_signal(long signal, RT_TASK *task);
+
+RTAI_SYSCALL_MODE int rt_wait_signal(RT_TASK *sigtask, RT_TASK *task);
+
+#else /* !__KERNEL__ */
+
+#include <sys/mman.h>
+
+#include <rtai_lxrt.h>
+
+#define SIGNAL_TASK_STACK_SIZE  64*1024
+
+#ifndef __SIGNAL_SUPPORT_FUN__
+#define __SIGNAL_SUPPORT_FUN__
+
+static void signal_suprt_fun(struct sigsuprt_t *funarg)
+{		
+	struct sigtsk_t { RT_TASK *sigtask; RT_TASK *task; };
+	struct sigreq_t { RT_TASK *sigtask; RT_TASK *task; long signal; void (*sighdl)(int, RT_TASK *); };
+	struct sigsuprt_t arg = *funarg;
+
+	if ((arg.sigtask = rt_thread_init(rt_get_name(0), SIGNAL_TASK_INIPRIO, 0, SCHED_FIFO, 1 << arg.cpuid))) {
+		if (!rtai_lxrt(RTAI_SIGNALS_IDX, sizeof(struct sigreq_t), RT_SIGNAL_REQUEST, &arg).i[LOW]) {
+			rt_grow_and_lock_stack(SIGNAL_TASK_STACK_SIZE/2);
+			rt_make_hard_real_time();
+			while (rtai_lxrt(RTAI_SIGNALS_IDX, sizeof(struct sigtsk_t), RT_SIGNAL_WAITSIG, &arg).i[LOW]) {
+				arg.sighdl(arg.signal, arg.task);
+			}
+			rt_make_soft_real_time();
+		}
+		rt_task_delete(arg.sigtask);
+	}
+}
+
+#endif /* __SIGNAL_SUPPORT_FUN__ */
+
+RTAI_PROTO(int, rt_request_signal, (long signal, void (*sighdl)(long, RT_TASK *)))
+{
+	if (signal >= 0 && sighdl) {
+		struct sigsuprt_t arg = { NULL, rt_buddy(), signal, sighdl };
+		arg.cpuid = rtai_lxrt(RTAI_SIGNALS_IDX, sizeof(void *), RT_SIGNAL_HELPER, &arg.sigtask).i[LOW];
+		if (rt_thread_create((void *)signal_suprt_fun, &arg, SIGNAL_TASK_STACK_SIZE)) {
+			return rtai_lxrt(RTAI_SIGNALS_IDX, sizeof(RT_TASK *), RT_SIGNAL_HELPER, &arg.task).i[LOW];
+		}
+	}
+	return -EINVAL;
+}
+
+RTAI_PROTO(int, rt_release_signal, (long signal, RT_TASK *task))
+{
+	struct { long signal; RT_TASK *task; } arg = { signal, task };
+	return rtai_lxrt(RTAI_SIGNALS_IDX, SIZARG, RT_SIGNAL_RELEASE, &arg).i[LOW];
+}
+
+RTAI_PROTO(void, rt_enable_signal, (long signal, RT_TASK *task))
+{
+	struct { long signal; RT_TASK *task; } arg = { signal, task };
+	rtai_lxrt(RTAI_SIGNALS_IDX, SIZARG, RT_SIGNAL_ENABLE, &arg);
+}
+
+RTAI_PROTO(void, rt_disable_signal, (long signal, RT_TASK *task))
+{
+	struct { long signal; RT_TASK *task; } arg = { signal, task };
+	rtai_lxrt(RTAI_SIGNALS_IDX, SIZARG, RT_SIGNAL_DISABLE, &arg);
+}
+
+RTAI_PROTO(void, rt_trigger_signal, (long signal, RT_TASK *task))
+{
+	struct { long signal; RT_TASK *task; } arg = { signal, task };
+	rtai_lxrt(RTAI_SIGNALS_IDX, SIZARG, RT_SIGNAL_TRIGGER, &arg);
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_SIGNAL_H_ */

include/rtai_spl.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2002,2003 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_SPL_H
+#define _RTAI_SPL_H
+
+#include <rtai_sem.h>
+
+struct rtai_spl;
+
+#ifdef __KERNEL__
+
+#ifndef __cplusplus
+
+typedef struct rtai_spl {
+    void *owndby;
+    int count;
+    unsigned long flags;
+} SPL;
+
+#else /* __cplusplus */
+extern "C" {
+#endif /* !__cplusplus */
+
+RTAI_SYSCALL_MODE int rt_spl_init(struct rtai_spl *spl);
+
+RTAI_SYSCALL_MODE int rt_spl_delete(struct rtai_spl *spl);
+
+RTAI_SYSCALL_MODE SPL *_rt_named_spl_init(unsigned long spl_name);
+
+RTAI_SYSCALL_MODE int rt_named_spl_delete(SPL *spl);
+
+RTAI_SYSCALL_MODE int rt_spl_lock(struct rtai_spl *spl);
+
+RTAI_SYSCALL_MODE int rt_spl_lock_if(struct rtai_spl *spl);
+
+RTAI_SYSCALL_MODE int rt_spl_lock_timed(struct rtai_spl *spl,
+		      unsigned long ns);
+
+RTAI_SYSCALL_MODE int rt_spl_unlock(struct rtai_spl *spl);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#else /* !__KERNEL__ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+RTAI_PROTO(struct rtai_spl *, rt_spl_init,(unsigned long name))
+{
+	struct { unsigned long name; } arg = { name };
+	return (struct rtai_spl *)rtai_lxrt(BIDX, SIZARG, LXRT_SPL_INIT, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_spl_delete,(struct rtai_spl *spl))
+{
+	struct { struct rtai_spl *spl; } arg = { spl };
+	return rtai_lxrt(BIDX, SIZARG, LXRT_SPL_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(struct rtai_spl *, rt_named_spl_init,(const char *name))
+{
+        struct { unsigned long name; } arg = { nam2num(name) };
+       	return (struct rtai_spl *)rtai_lxrt(BIDX, SIZARG, NAMED_SPL_INIT, &arg).v[LOW];
+}
+
+RTAI_PROTO(int, rt_named_spl_delete,(struct rtai_spl *spl))
+{
+	struct { struct rtai_spl *spl; } arg = { spl };
+	return rtai_lxrt(BIDX, SIZARG, NAMED_SPL_DELETE, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_spl_lock,(struct rtai_spl *spl))
+{
+	struct { struct rtai_spl *spl; } arg = { spl };
+	return rtai_lxrt(BIDX, SIZARG, SPL_LOCK, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_spl_lock_if,(struct rtai_spl *spl))
+{
+	struct { struct rtai_spl *spl; } arg = { spl };
+	return rtai_lxrt(BIDX, SIZARG, SPL_LOCK_IF, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_spl_lock_timed,(struct rtai_spl *spl, RTIME delay))
+{
+	struct { struct rtai_spl *spl; RTIME delay; } arg = { spl, delay };
+	return rtai_lxrt(BIDX, SIZARG, SPL_LOCK_TIMED, &arg).i[LOW];
+}
+
+RTAI_PROTO(int, rt_spl_unlock,(struct rtai_spl *spl))
+{
+	struct { struct rtai_spl *spl; } arg = { spl };
+	return rtai_lxrt(BIDX, SIZARG, SPL_UNLOCK, &arg).i[LOW];
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __KERNEL__ */
+
+#if !defined(__KERNEL__) || defined(__cplusplus)
+
+typedef struct rtai_spl {
+    int opaque;
+} SPL;
+
+#endif /* !__KERNEL__ || __cplusplus */
+
+#endif /* !_RTAI_SPL_H */

include/rtai_taskq.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2008-2010 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef _RTAI_TASKQ_H
+#define _RTAI_TASKQ_H
+
+#include <rtai_schedcore.h>
+
+extern struct epoch_struct boot_epoch;
+
+typedef struct rt_task_queue {
+	struct rt_queue queue; /* <= Must be first in struct. */
+	int qtype;
+	unsigned long status;
+} TASKQ;
+
+#define XNTIMEO  0x00000001  // RTE_TIMOUT
+#define XNRMID   0x00000002  // RTE_OBJREM
+#define XNBREAK  0x00000004  // RTE_UNBLKD
+
+#define TASKQ_PRIO    0x0
+#define TASKQ_FIFO    0x1
+
+#define RT_SCHED_TASKQ  RT_SCHED_SEMAPHORE
+
+#ifdef CONFIG_SMP
+
+extern volatile unsigned long tosched_mask;
+
+#define TOSCHED_TASK(task) \
+	do { tosched_mask |= (1 << (task)->runnable_on_cpus); } while (0)
+
+#else /* !CONFIG_SMP */
+
+#define TOSCHED_TASK(task)
+
+#endif /* CONFIG_SMP */
+
+void rt_schedule_readied(void);
+
+void rt_taskq_init(TASKQ *taskq, unsigned int type);
+
+RT_TASK *rt_taskq_ready_one(TASKQ *taskq);
+
+int rt_taskq_ready_all(TASKQ *taskq, unsigned long why);
+
+void rt_taskq_wait(TASKQ *taskq);
+
+void rt_taskq_wait_until(TASKQ *taskq, RTIME time);
+
+#define rt_taskq_delete(taskq)  rt_taskq_ready_all(taskq, RTE_OBJREM)
+
+#define rt_taskq_wait_timed(taskq, delay) \
+	do { rt_taskq_wait_until(taskq, get_time() + delay); } while (0)
+
+static inline int rt_task_test_taskq_retval(RT_TASK *task, unsigned long mask)
+{
+	return ((task)->retval & mask); 
+}
+
+#endif /* !_RTAI_TASKQ_H */

include/rtai_trace.h

@@ -0,0 +1,513 @@
+/*
+ * This file contains the necessary definitions for the RTAI tracer.
+ *
+ * Copyright (C) 2000, Karim Yaghmour <karym@opersys.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_TRACE_H
+#define _RTAI_TRACE_H
+
+#include <rtai_types.h>
+
+#if defined(CONFIG_RTAI_TRACE) && defined(__KERNEL__)
+
+#include <linux/trace.h>
+
+/* Is RTAI tracing enabled */
+
+/* The functions to the tracer management code */
+int rt_register_tracer
+       (tracer_call   /* The tracer function */);
+int rt_unregister_tracer
+       (tracer_call   /* The tracer function */);
+int rt_trace_event
+       (uint8_t       /* Event ID (as defined in this header file) */,
+	void*         /* Structure describing the event */);
+
+/* Generic macros */
+#define RT_TRACE_EVENT(ID, DATA) rt_trace_event(ID, DATA)
+
+#define TRACE_RTAI_START TRACE_EV_MAX
+
+/* Traced events */
+#define TRACE_RTAI_EV_MOUNT              TRACE_RTAI_START +  1   /* The RTAI subsystem was mounted */
+#define TRACE_RTAI_EV_UMOUNT             TRACE_RTAI_START +  2   /* The RTAI subsystem was unmounted */
+#define TRACE_RTAI_EV_GLOBAL_IRQ_ENTRY   TRACE_RTAI_START +  3   /* Entry in a global IRQ */
+#define TRACE_RTAI_EV_GLOBAL_IRQ_EXIT    TRACE_RTAI_START +  4   /* Exit from a global IRQ */
+#define TRACE_RTAI_EV_OWN_IRQ_ENTRY      TRACE_RTAI_START +  5   /* Entry in a CPU own IRQ */
+#define TRACE_RTAI_EV_OWN_IRQ_EXIT       TRACE_RTAI_START +  6   /* Exit from a CPU own IRQ */
+#define TRACE_RTAI_EV_TRAP_ENTRY         TRACE_RTAI_START +  7   /* Entry in a trap */
+#define TRACE_RTAI_EV_TRAP_EXIT          TRACE_RTAI_START +  8   /* Exit from a trap */
+#define TRACE_RTAI_EV_SRQ_ENTRY          TRACE_RTAI_START +  9   /* Entry in a SRQ */
+#define TRACE_RTAI_EV_SRQ_EXIT           TRACE_RTAI_START + 10   /* Exit from a SRQ */
+#define TRACE_RTAI_EV_SWITCHTO_LINUX     TRACE_RTAI_START + 11   /* Switch a CPU to Linux */
+#define TRACE_RTAI_EV_SWITCHTO_RT        TRACE_RTAI_START + 12   /* Switch a CPU to real-time */
+#define TRACE_RTAI_EV_SCHED_CHANGE       TRACE_RTAI_START + 13   /* A scheduling change has occured */
+#define TRACE_RTAI_EV_TASK               TRACE_RTAI_START + 14   /* Hit key part of task services */
+#define TRACE_RTAI_EV_TIMER              TRACE_RTAI_START + 15   /* Hit key part of timer services */
+#define TRACE_RTAI_EV_SEM                TRACE_RTAI_START + 16   /* Hit key part of semaphore services */
+#define TRACE_RTAI_EV_MSG                TRACE_RTAI_START + 17   /* Hit key part of message services */
+#define TRACE_RTAI_EV_RPC                TRACE_RTAI_START + 18   /* Hit key part of RPC services */
+#define TRACE_RTAI_EV_MBX                TRACE_RTAI_START + 19   /* Hit key part of mail box services */
+#define TRACE_RTAI_EV_FIFO               TRACE_RTAI_START + 20   /* Hit key part of FIFO services */
+#define TRACE_RTAI_EV_SHM                TRACE_RTAI_START + 21   /* Hit key part of shared memory services */
+#define TRACE_RTAI_EV_LXRT               TRACE_RTAI_START + 22   /* Hit key part of LXRT services */
+#define TRACE_RTAI_EV_LXRTI              TRACE_RTAI_START + 23   /* Hit key part of LXRT-Informed services */
+
+/* Max number of traced events */
+#define TRACE_RTAI_EV_MAX               TRACE_RTAI_EV_LXRTI
+
+/* Structures and macros for traced events */
+/*  TRACE_RTAI_MOUNT */
+#define TRACE_RTAI_MOUNT()    rt_trace_event(TRACE_RTAI_EV_MOUNT, NULL)
+
+/*  TRACE_RTAI_UMOUNT */
+#define TRACE_RTAI_UMOUNT()   rt_trace_event(TRACE_RTAI_EV_UMOUNT, NULL)
+
+/*  TRACE_RTAI_GLOBAL_IRQ_ENTRY */
+typedef struct _trace_rtai_global_irq_entry
+{
+  uint8_t  irq_id;      /* IRQ number */
+  uint8_t  kernel;      /* Are we executing kernel code */
+} LTT_PACKED_STRUCT trace_rtai_global_irq_entry;
+#define TRACE_RTAI_GLOBAL_IRQ_ENTRY(ID, __dummy) \
+           do \
+           {\
+           uint32_t                    eflags, xcs; \
+           trace_rtai_global_irq_entry irq_entry;\
+           irq_entry.irq_id = ID;\
+           __asm__ __volatile__("pushfl; pop %0": "=g" (eflags)); \
+           __asm__ __volatile__("pushl %%cs; pop %0": "=g" (xcs)); \
+           irq_entry.kernel = !((VM_MASK & eflags) || (3 & xcs));\
+           rt_trace_event(TRACE_RTAI_EV_GLOBAL_IRQ_ENTRY, &irq_entry);\
+           } while(0)
+
+/*  TRACE_RTAI_GLOBAL_IRQ_EXIT */
+#define TRACE_RTAI_GLOBAL_IRQ_EXIT() rt_trace_event(TRACE_RTAI_EV_GLOBAL_IRQ_EXIT, NULL)
+
+/*  TRACE_RTAI_OWN_IRQ_ENTRY */
+typedef struct _trace_rtai_own_irq_entry
+{
+  uint8_t  irq_id;      /* IRQ number */
+  uint8_t  kernel;      /* Are we executing kernel code */
+} LTT_PACKED_STRUCT trace_rtai_own_irq_entry;
+#define TRACE_RTAI_OWN_IRQ_ENTRY(ID) \
+           do \
+           {\
+           uint32_t                 eflags, xcs; \
+           trace_rtai_own_irq_entry irq_entry;\
+           irq_entry.irq_id = ID;\
+           __asm__ __volatile__("pushfl; pop %0": "=g" (eflags)); \
+           __asm__ __volatile__("pushl %%cs; pop %0": "=g" (xcs)); \
+           irq_entry.kernel = !((VM_MASK & eflags) || (3 & xcs));\
+           rt_trace_event(TRACE_RTAI_EV_OWN_IRQ_ENTRY, &irq_entry);\
+           } while(0)
+
+/*  TRACE_RTAI_OWN_IRQ_EXIT */
+#define TRACE_RTAI_OWN_IRQ_EXIT() rt_trace_event(TRACE_RTAI_EV_OWN_IRQ_EXIT, NULL)
+
+/*  TRACE_RTAI_TRAP_ENTRY */
+typedef struct _trace_rtai_trap_entry
+{
+  uint8_t   trap_id;        /* Trap number */
+  uint32_t  address;        /* Address where trap occured */
+} LTT_PACKED_STRUCT trace_rtai_trap_entry;
+#define TRACE_RTAI_TRAP_ENTRY(ID,ADDR) \
+           do \
+           {\
+           trace_rtai_trap_entry trap_event;\
+           trap_event.trap_id = ID;\
+           trap_event.address = ADDR; \
+           rt_trace_event(TRACE_RTAI_EV_TRAP_ENTRY, &trap_event);\
+	   } while(0)
+/*
+           uint32_t              eip; \
+           __asm__ __volatile__("pushl %%ip; pop %0": "=g" (eip)); \
+           trap_event.address = eip;\
+*/
+
+/*  TRACE_RTAI_TRAP_EXIT */
+#define TRACE_RTAI_TRAP_EXIT() rt_trace_event(TRACE_RTAI_EV_TRAP_EXIT, NULL)
+
+/*  TRACE_RTAI_SRQ_ENTRY */
+typedef struct _trace_rtai_srq_entry
+{
+  uint8_t  srq_id;      /* SRQ number */
+  uint8_t  kernel;      /* Are we executing kernel code */
+} LTT_PACKED_STRUCT trace_rtai_srq_entry;
+#define TRACE_RTAI_SRQ_ENTRY(ID) \
+           do \
+           {\
+           uint32_t             eflags, xcs; \
+           trace_rtai_srq_entry srq_entry;\
+           srq_entry.srq_id = ID;\
+           __asm__ __volatile__("pushfl; pop %0": "=g" (eflags)); \
+           __asm__ __volatile__("pushl %%cs; pop %0": "=g" (xcs)); \
+           srq_entry.kernel = !((VM_MASK & eflags) || (3 & xcs));\
+           rt_trace_event(TRACE_RTAI_EV_SRQ_ENTRY, &srq_entry);\
+           } while(0)
+
+/*  TRACE_RTAI_SRQ_EXIT */
+#define TRACE_RTAI_SRQ_EXIT() rt_trace_event(TRACE_RTAI_EV_SRQ_EXIT, NULL)
+
+/*  TRACE_RTAI_SWITCHTO_LINUX */
+typedef struct _trace_rtai_switchto_linux
+{
+  uint8_t   cpu_id;         /* The CPUID being switched to Linux */
+} LTT_PACKED_STRUCT trace_rtai_switchto_linux;
+#define TRACE_RTAI_SWITCHTO_LINUX(ID) \
+           do \
+           {\
+           trace_rtai_switchto_linux switch_event; \
+           switch_event.cpu_id = (uint8_t) ID; \
+           rt_trace_event(TRACE_RTAI_EV_SWITCHTO_LINUX, &switch_event); \
+           } while(0)
+
+/*  TRACE_RTAI_SWITCHTO_RT */
+typedef struct _trace_rtai_switchto_rt
+{
+  uint8_t   cpu_id;         /* The CPUID being switched to RT */
+} LTT_PACKED_STRUCT trace_rtai_switchto_rt;
+#define TRACE_RTAI_SWITCHTO_RT(ID) \
+           do \
+           {\
+           trace_rtai_switchto_rt switch_event; \
+           switch_event.cpu_id = (uint8_t) ID; \
+           rt_trace_event(TRACE_RTAI_EV_SWITCHTO_RT, &switch_event); \
+           } while(0)
+
+/*  TRACE_RTAI_SCHED_CHANGE */ 
+typedef struct _trace_rtai_sched_change
+{
+  uint32_t  out;         /* Outgoing process */
+  uint32_t  in;          /* Incoming process */
+  uint32_t  out_state;   /* Outgoing process' state */
+} LTT_PACKED_STRUCT trace_rtai_sched_change;
+#define TRACE_RTAI_SCHED_CHANGE(OUT, IN, OUT_STATE) \
+           do \
+           {\
+           trace_rtai_sched_change sched_event;\
+           sched_event.out       = (uint32_t) OUT;\
+           sched_event.in        = (uint32_t) IN;\
+           sched_event.out_state = (uint32_t) OUT_STATE; \
+           rt_trace_event(TRACE_RTAI_EV_SCHED_CHANGE, &sched_event);\
+           } while(0)
+
+/*  TRACE_RTAI_TASK */
+#define TRACE_RTAI_EV_TASK_INIT                    1     /* Initialize task */
+#define TRACE_RTAI_EV_TASK_DELETE                  2     /* Delete task */
+#define TRACE_RTAI_EV_TASK_SIG_HANDLER             3     /* Set signal handler */
+#define TRACE_RTAI_EV_TASK_YIELD                   4     /* Yield CPU control */
+#define TRACE_RTAI_EV_TASK_SUSPEND                 5     /* Suspend task */
+#define TRACE_RTAI_EV_TASK_RESUME                  6     /* Resume task */
+#define TRACE_RTAI_EV_TASK_MAKE_PERIOD_RELATIVE    7     /* Make task periodic relative in nanoseconds */
+#define TRACE_RTAI_EV_TASK_MAKE_PERIOD             8     /* Make task periodic */
+#define TRACE_RTAI_EV_TASK_WAIT_PERIOD             9     /* Wait until the next period */
+#define TRACE_RTAI_EV_TASK_BUSY_SLEEP             10     /* Busy sleep */
+#define TRACE_RTAI_EV_TASK_SLEEP                  11     /* Sleep */
+#define TRACE_RTAI_EV_TASK_SLEEP_UNTIL            12     /* Sleep until */
+typedef struct _trace_rtai_task
+{
+  uint8_t   event_sub_id;  /* Task event ID */
+  uint32_t  event_data1;   /* Event data */
+  uint64_t  event_data2;   /* Event data 2 */
+  uint64_t  event_data3;   /* Event data 3 */
+} LTT_PACKED_STRUCT trace_rtai_task;
+#define TRACE_RTAI_TASK(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_task task_event;\
+           task_event.event_sub_id = (uint8_t)  ID;\
+           task_event.event_data1  = (uint32_t) DATA1; \
+           task_event.event_data2  = (uint64_t) DATA2; \
+           task_event.event_data3  = (uint64_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_TASK, &task_event);\
+           } while(0)
+
+/*  TRACE_RTAI_TIMER */
+#define TRACE_RTAI_EV_TIMER_REQUEST                1     /* Request timer */
+#define TRACE_RTAI_EV_TIMER_FREE                   2     /* Free timer */
+#define TRACE_RTAI_EV_TIMER_REQUEST_APIC           3     /* Request APIC timers */
+#define TRACE_RTAI_EV_TIMER_APIC_FREE              4     /* Free APIC timers */
+#define TRACE_RTAI_EV_TIMER_HANDLE_EXPIRY          5     /* Handle timer expiry */
+typedef struct _trace_rtai_timer
+{
+  uint8_t   event_sub_id;  /* Timer event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+} LTT_PACKED_STRUCT trace_rtai_timer;
+#define TRACE_RTAI_TIMER(ID, DATA1, DATA2) \
+           do \
+           {\
+           trace_rtai_timer timer_event; \
+           timer_event.event_sub_id = (uint8_t)  ID; \
+           timer_event.event_data1  = (uint32_t) DATA1; \
+           timer_event.event_data2  = (uint32_t) DATA2; \
+           rt_trace_event(TRACE_RTAI_EV_TIMER, &timer_event); \
+           } while(0)
+
+/*  TRACE_RTAI_SEM */
+#define TRACE_RTAI_EV_SEM_INIT                     1     /* Initialize semaphore */
+#define TRACE_RTAI_EV_SEM_DELETE                   2     /* Delete semaphore */
+#define TRACE_RTAI_EV_SEM_SIGNAL                   3     /* Signal semaphore */
+#define TRACE_RTAI_EV_SEM_WAIT                     4     /* Wait on semaphore */
+#define TRACE_RTAI_EV_SEM_WAIT_IF                  5     /* Take semaphore if possible */
+#define TRACE_RTAI_EV_SEM_WAIT_UNTIL               6     /* Wait on semaphore until a certain time */
+typedef struct _trace_rtai_sem
+{
+  uint8_t   event_sub_id;  /* Semaphore event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint64_t  event_data2;   /* Event data 2 */
+} LTT_PACKED_STRUCT trace_rtai_sem;
+#define TRACE_RTAI_SEM(ID, DATA1, DATA2) \
+           do \
+           {\
+           trace_rtai_sem sem_event; \
+           sem_event.event_sub_id = (uint8_t)  ID; \
+           sem_event.event_data1  = (uint32_t) DATA1; \
+           sem_event.event_data2  = (uint64_t) DATA2; \
+           rt_trace_event(TRACE_RTAI_EV_SEM, &sem_event); \
+           } while(0)
+
+/*  TRACE_RTAI_MSG */
+#define TRACE_RTAI_EV_MSG_SEND                      1    /* Send a message */
+#define TRACE_RTAI_EV_MSG_SEND_IF                   2    /* Send if possible */
+#define TRACE_RTAI_EV_MSG_SEND_UNTIL                3    /* Try sending until a certain time */
+#define TRACE_RTAI_EV_MSG_RECV                      4    /* Receive a message */
+#define TRACE_RTAI_EV_MSG_RECV_IF                   5    /* Receive if possible */
+#define TRACE_RTAI_EV_MSG_RECV_UNTIL                6    /* Try receiving until a certain time */
+typedef struct _trace_rtai_msg
+{
+  uint8_t   event_sub_id;  /* Message event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+  uint64_t  event_data3;   /* Event data 3 */
+} LTT_PACKED_STRUCT trace_rtai_msg;
+#define TRACE_RTAI_MSG(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_msg msg_event; \
+           msg_event.event_sub_id = (uint8_t)  ID; \
+           msg_event.event_data1  = (uint32_t) DATA1; \
+           msg_event.event_data2  = (uint32_t) DATA2; \
+           msg_event.event_data3  = (uint64_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_MSG, &msg_event); \
+           } while(0)
+
+/*  TRACE_RTAI_RPC */
+#define TRACE_RTAI_EV_RPC_MAKE                       1    /* Make a remote procedure call */
+#define TRACE_RTAI_EV_RPC_MAKE_IF                    2    /* Make RPC if receiver is ready */
+#define TRACE_RTAI_EV_RPC_MAKE_UNTIL                 3    /* Try making an RPC until a certain time */
+#define TRACE_RTAI_EV_RPC_RETURN                     4    /* Send result of RPC back to caller */
+typedef struct _trace_rtai_rpc
+{
+  uint8_t   event_sub_id;  /* RPC event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+  uint64_t  event_data3;   /* Event data 3 */
+} LTT_PACKED_STRUCT trace_rtai_rpc;
+#define TRACE_RTAI_RPC(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_rpc rpc_event; \
+           rpc_event.event_sub_id = (uint8_t)  ID; \
+           rpc_event.event_data1  = (uint32_t) DATA1; \
+           rpc_event.event_data2  = (uint32_t) DATA2; \
+           rpc_event.event_data3  = (uint64_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_RPC, &rpc_event); \
+           } while(0)
+
+/*  TRACE_RTAI_MBX */
+#define TRACE_RTAI_EV_MBX_INIT                       1    /* Initialize Message BoX */
+#define TRACE_RTAI_EV_MBX_DELETE                     2    /* Delete message box */
+#define TRACE_RTAI_EV_MBX_SEND                       3    /* Send a message to a message box */
+#define TRACE_RTAI_EV_MBX_SEND_WP                    4    /* Send as many bytes as possible */
+#define TRACE_RTAI_EV_MBX_SEND_IF                    5    /* Send a message if possible */
+#define TRACE_RTAI_EV_MBX_SEND_UNTIL                 6    /* Try sending until a certain time */
+#define TRACE_RTAI_EV_MBX_RECV                       7    /* Receive a message */
+#define TRACE_RTAI_EV_MBX_RECV_WP                    8    /* Receive as many bytes as possible */
+#define TRACE_RTAI_EV_MBX_RECV_IF                    9    /* Receive a message if available */
+#define TRACE_RTAI_EV_MBX_RECV_UNTIL                10    /* Try receiving until a certain time */
+typedef struct _trace_rtai_mbx
+{
+  uint8_t   event_sub_id;  /* Message Box event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+  uint64_t  event_data3;   /* Event data 3 */  
+} LTT_PACKED_STRUCT trace_rtai_mbx;
+#define TRACE_RTAI_MBX(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_mbx mbx_event; \
+           mbx_event.event_sub_id = (uint8_t)  ID; \
+           mbx_event.event_data1  = (uint32_t) DATA1; \
+           mbx_event.event_data2  = (uint32_t) DATA2; \
+           mbx_event.event_data3  = (uint64_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_MBX, &mbx_event); \
+           } while(0)
+
+/*  TRACE_RTAI_FIFO */
+#define TRACE_RTAI_EV_FIFO_CREATE                     1   /* Create FIFO */
+#define TRACE_RTAI_EV_FIFO_DESTROY                    2   /* Destroy FIFO */
+#define TRACE_RTAI_EV_FIFO_RESET                      3   /* Reset FIFO */
+#define TRACE_RTAI_EV_FIFO_RESIZE                     4   /* Resize FIFO */
+#define TRACE_RTAI_EV_FIFO_PUT                        5   /* Write data to FIFO */
+#define TRACE_RTAI_EV_FIFO_GET                        6   /* Get data from FIFO */
+#define TRACE_RTAI_EV_FIFO_CREATE_HANDLER             7   /* Install FIFO handler */
+#define TRACE_RTAI_EV_FIFO_OPEN                       8   /* Open FIFO */
+#define TRACE_RTAI_EV_FIFO_RELEASE                    9   /* Release FIFO */
+#define TRACE_RTAI_EV_FIFO_READ                      10   /* Read from FIFO */
+#define TRACE_RTAI_EV_FIFO_WRITE                     11   /* Write to FIFO */
+#define TRACE_RTAI_EV_FIFO_READ_TIMED                12   /* Read with time limit */
+#define TRACE_RTAI_EV_FIFO_WRITE_TIMED               13   /* Write with time limit */
+#define TRACE_RTAI_EV_FIFO_READ_ALLATONCE            14   /* Read all the data from FIFO */
+#define TRACE_RTAI_EV_FIFO_LLSEEK                    15   /* Seek position into FIFO */
+#define TRACE_RTAI_EV_FIFO_FASYNC                    16   /* Asynchronous notification */
+#define TRACE_RTAI_EV_FIFO_IOCTL                     17   /* IO control on FIFO */
+#define TRACE_RTAI_EV_FIFO_POLL                      18   /* Poll FIFO */
+#define TRACE_RTAI_EV_FIFO_SUSPEND_TIMED             19   /* Suspend task for given period */
+#define TRACE_RTAI_EV_FIFO_SET_ASYNC_SIG             20   /* Set asynchrounous signal */
+#define TRACE_RTAI_EV_FIFO_SEM_INIT                  21   /* Initialize semaphore */
+#define TRACE_RTAI_EV_FIFO_SEM_POST                  22   /* Post semaphore */
+#define TRACE_RTAI_EV_FIFO_SEM_WAIT                  23   /* Wait on semaphore */
+#define TRACE_RTAI_EV_FIFO_SEM_TRY_WAIT              24   /* Try waiting on semaphore */
+#define TRACE_RTAI_EV_FIFO_SEM_TIMED_WAIT            25   /* Wait on semaphore until a certain time */
+#define TRACE_RTAI_EV_FIFO_SEM_DESTROY               26   /* Destroy semaphore  */
+typedef struct _trace_rtai_fifo
+{
+  uint8_t   event_sub_id;  /* FIFO event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+} LTT_PACKED_STRUCT trace_rtai_fifo;
+#define TRACE_RTAI_FIFO(ID, DATA1, DATA2) \
+           do \
+           {\
+           trace_rtai_fifo fifo_event; \
+           fifo_event.event_sub_id = (uint8_t)  ID; \
+           fifo_event.event_data1  = (uint32_t) DATA1; \
+           fifo_event.event_data2  = (uint32_t) DATA2; \
+           rt_trace_event(TRACE_RTAI_EV_FIFO, &fifo_event); \
+           } while(0)
+
+/*  TRACE_RTAI_SHM */
+#define TRACE_RTAI_EV_SHM_MALLOC                       1  /* Allocate shared memory */
+#define TRACE_RTAI_EV_SHM_KMALLOC                      2  /* Allocate shared memory in kernel space */
+#define TRACE_RTAI_EV_SHM_GET_SIZE                     3  /* Get the size of the shared memory area */ 
+#define TRACE_RTAI_EV_SHM_FREE                         4  /* Free shared memory */
+#define TRACE_RTAI_EV_SHM_KFREE                        5  /* Free kernel space shared memory */
+typedef struct _trace_rtai_shm
+{
+  uint8_t   event_sub_id;  /* SHared Memory event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+  uint32_t  event_data3;   /* Event data 3 */
+} LTT_PACKED_STRUCT trace_rtai_shm;
+#define TRACE_RTAI_SHM(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_shm shm_event; \
+           shm_event.event_sub_id = (uint8_t)  ID; \
+           shm_event.event_data1  = (uint32_t) DATA1; \
+           shm_event.event_data2  = (uint32_t) DATA2; \
+           shm_event.event_data3  = (uint32_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_SHM, &shm_event); \
+           } while(0)
+
+/*  TRACE_RTAI_LXRT */
+#define TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_ENTRY             1  /* Entry in LXRT syscall */
+#define TRACE_RTAI_EV_LXRT_RTAI_SYSCALL_EXIT              2  /* Exit from LXRT syscall */
+#define TRACE_RTAI_EV_LXCHANGE                   3  /* Scheduling change */
+#define TRACE_RTAI_EV_LXRT_STEAL_TASK                     4  /* Take task control from Linux */
+#define TRACE_RTAI_EV_LXRT_GIVE_BACK_TASK                 5  /* Give task control back to Linux */
+#define TRACE_RTAI_EV_LXRT_SUSPEND                        6  /* Suspend a task */
+#define TRACE_RTAI_EV_LXRT_RESUME                         7  /* Resume task's execution */
+#define TRACE_RTAI_EV_LXRT_HANDLE                         8  /* Handle a request for an RTAI service */
+typedef struct _trace_rtai_lxrt
+{
+  uint8_t   event_sub_id;  /* LXRT event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+  uint32_t  event_data3;   /* Event data 3 */  
+} LTT_PACKED_STRUCT trace_rtai_lxrt;
+#define TRACE_RTAI_LXRT(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_lxrt lxrt_event; \
+           lxrt_event.event_sub_id = (uint8_t)  ID; \
+           lxrt_event.event_data1  = (uint32_t) DATA1; \
+           lxrt_event.event_data2  = (uint32_t) DATA2; \
+           lxrt_event.event_data3  = (uint32_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_LXRT, &lxrt_event); \
+           } while(0)
+
+/*  TRACE_RTAI_LXRTI */
+#define TRACE_RTAI_EV_LXRTI_NAME_ATTACH                    1  /* Register current process as name */
+#define TRACE_RTAI_EV_LXRTI_NAME_LOCATE                    2  /* Locate a given process usint it's name */
+#define TRACE_RTAI_EV_LXRTI_NAME_DETACH                    3  /* Detach process from name */
+#define TRACE_RTAI_EV_LXRTI_SEND                           4  /* Send message to PID */
+#define TRACE_RTAI_EV_LXRTI_RECV                           5  /* Receive message */
+#define TRACE_RTAI_EV_LXRTI_CRECV                          6  /* Non-blocking receive */
+#define TRACE_RTAI_EV_LXRTI_REPLY                          7  /* Reply to message received */
+#define TRACE_RTAI_EV_LXRTI_PROXY_ATTACH                   8  /* Attach proxy to process */
+#define TRACE_RTAI_EV_LXRTI_PROXY_DETACH                   9  /* Detach proxy from process */
+#define TRACE_RTAI_EV_LXRTI_TRIGGER                       10  /* Trigger proxy */
+typedef struct _trace_rtai_lxrti
+{
+  uint8_t   event_sub_id;  /* LXRT event ID */
+  uint32_t  event_data1;   /* Event data 1 */
+  uint32_t  event_data2;   /* Event data 2 */
+  uint64_t  event_data3;   /* Event data 3 */  
+} LTT_PACKED_STRUCT trace_rtai_lxrti;
+#define TRACE_RTAI_LXRTI(ID, DATA1, DATA2, DATA3) \
+           do \
+           {\
+           trace_rtai_lxrti lxrti_event; \
+           lxrti_event.event_sub_id = (uint8_t)  ID; \
+           lxrti_event.event_data1  = (uint32_t) DATA1; \
+           lxrti_event.event_data2  = (uint32_t) DATA2; \
+           lxrti_event.event_data3  = (uint64_t) DATA3; \
+           rt_trace_event(TRACE_RTAI_EV_LXRTI, &lxrti_event); \
+           } while(0)
+
+#else /* !(CONFIG_RTAI_TRACE && __KERNEL__) */
+#define RT_TRACE_EVENT(ID, DATA)
+#define TRACE_RTAI_MOUNT()
+#define TRACE_RTAI_UMOUNT()
+#define TRACE_RTAI_GLOBAL_IRQ_ENTRY(ID,X)
+#define TRACE_RTAI_GLOBAL_IRQ_EXIT()
+#define TRACE_RTAI_OWN_IRQ_ENTRY(ID)
+#define TRACE_RTAI_OWN_IRQ_EXIT()
+#define TRACE_RTAI_TRAP_ENTRY(ID,ADDR)
+#define TRACE_RTAI_TRAP_EXIT()
+#define TRACE_RTAI_SRQ_ENTRY(a)
+#define TRACE_RTAI_SRQ_EXIT()
+#define TRACE_RTAI_SWITCHTO_LINUX(ID)
+#define TRACE_RTAI_SWITCHTO_RT(ID)
+#define TRACE_RTAI_SCHED_CHANGE(OUT, IN, OUT_STATE)
+#define TRACE_RTAI_TASK(ID, DATA1, DATA2, DATA3)
+#define TRACE_RTAI_TIMER(ID, DATA1, DATA2)
+#define TRACE_RTAI_SEM(ID, DATA1, DATA2)
+#define TRACE_RTAI_MSG(ID, DATA1, DATA2, DATA3)
+#define TRACE_RTAI_RPC(ID, DATA1, DATA2, DATA3)
+#define TRACE_RTAI_MBX(ID, DATA1, DATA2, DATA3)
+#define TRACE_RTAI_FIFO(ID, DATA1, DATA2)
+#define TRACE_RTAI_SHM(ID, DATA1, DATA2, DATA3)
+#define TRACE_RTAI_LXRT(ID, DATA1, DATA2, DATA3)
+#define TRACE_RTAI_LXRTI(ID, DATA1, DATA2, DATA3)
+#endif /* CONFIG_RTAI_TRACE && __KERNEL__ */
+
+#endif /* !_RTAI_TRACE_H */

include/rtai_types.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 1999-2003 Paolo Mantegazza <mantegazza@aero.polimi.it>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_TYPES_H
+#define _RTAI_TYPES_H
+
+#include <rtai_config.h>
+#include <rtai_wrappers.h>
+
+#define PRIO_Q    0 
+#define FIFO_Q    4 
+#define RES_Q     3
+
+#define BIN_SEM   1 
+#define CNT_SEM   2 
+#define RES_SEM   3
+
+#define RESEM_RECURS   1
+#define RESEM_BINSEM   0
+#define RESEM_CHEKWT  -1
+
+#define RT_SCHED_FIFO  0 
+#define RT_SCHED_RR    1 
+
+#define RTAI_PROTO(type,name,arglist) static inline type name arglist
+#define RTAI_PROTO_ALWAYS_INLINE(type,name,arglist) static inline type name arglist
+
+struct pt_regs;
+
+struct rt_task_struct;
+
+typedef long long RTIME;
+
+typedef int (*RT_TRAP_HANDLER)(int, int, struct pt_regs *,void *);
+
+struct rt_times {
+	int linux_tick;
+	int periodic_tick;
+	RTIME tick_time;
+	RTIME linux_time;
+	RTIME intr_time;
+};
+
+#endif /* !_RTAI_TYPES_H */

include/rtai_wrappers.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2004-2017 Philippe Gerum <rpm@xenomai.org>
+ * Copyright (C) 2019 Alec Ari <neotheuser@ymail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _RTAI_WRAPPERS_H
+#define _RTAI_WRAPPERS_H
+
+#ifdef __KERNEL__
+
+#include <linux/version.h>
+#ifndef __cplusplus
+#include <linux/module.h>
+#endif /* !__cplusplus */
+
+#include <linux/moduleparam.h>
+
+#define RTAI_MODULE_PARM(name, type) \
+	module_param(name, type, 0444)
+
+#ifndef DEFINE_SPINLOCK
+#define DEFINE_SPINLOCK(x) spinlock_t x = SPIN_LOCK_UNLOCKED
+#endif
+
+#ifndef DECLARE_MUTEX_LOCKED
+#ifndef __DECLARE_SEMAPHORE_GENERIC
+#define DECLARE_MUTEX_LOCKED(name) \
+        struct semaphore name = __SEMAPHORE_INITIALIZER(name, 0)
+#else
+#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
+#endif
+#endif
+
+#ifndef cpu_online_map
+#define cpu_online_map (*(cpumask_t *)cpu_online_mask)
+#endif
+
+#ifndef init_MUTEX_LOCKED 
+#define init_MUTEX_LOCKED(sem)  sema_init(sem, 0)
+#endif
+
+#define RTAI_MODULE_PARM_ARRAY(name, type, addr, size) \
+	module_param_array(name, type, addr, 0400);
+
+/* Basic class macros */
+
+#include <linux/device.h>
+typedef struct class class_t;
+#define CLASS_DEVICE_CREATE(cls, devt, device, fmt, arg...)  device_create(cls, NULL, devt, NULL, fmt, ##arg)
+#define class_device_destroy(a, b)  device_destroy(a, b)
+
+#define mm_remap_page_range(vma,from,to,size,prot) remap_page_range(vma,from,to,size,prot)
+
+#define get_tsk_addr_limit(t) ((t)->thread_info->addr_limit.seg)
+
+#define self_daemonize(name) daemonize(name)
+
+#define get_thread_ptr(t)  ((t)->thread_info)
+
+#define RTAI_LINUX_IRQ_HANDLED IRQ_HANDLED
+
+#define CPUMASK_T(name)  ((cpumask_t){ { name } })
+#define CPUMASK(name)    (name.bits[0])
+
+#include <linux/pid.h>
+
+#define find_task_by_pid(nr) \
+	find_task_by_pid_ns(nr, &init_pid_ns)
+#define kill_proc(pid, sig, priv)       \
+  kill_proc_info(sig, (priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO, pid)
+
+#endif /* __KERNEL__ */
+
+#endif /* !_RTAI_WRAPPERS_H */